@cleocode/core 2026.4.58 → 2026.4.60

package/dist/index.js

@@ -1,5 +1,11 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -9039,9 +9045,11 @@ __export(brain_schema_exports, {
   BRAIN_STICKY_COLORS: () => BRAIN_STICKY_COLORS,
   BRAIN_STICKY_PRIORITIES: () => BRAIN_STICKY_PRIORITIES,
   BRAIN_STICKY_STATUSES: () => BRAIN_STICKY_STATUSES,
+  brainConsolidationEvents: () => brainConsolidationEvents,
   brainDecisions: () => brainDecisions,
   brainLearnings: () => brainLearnings,
   brainMemoryLinks: () => brainMemoryLinks,
+  brainModulators: () => brainModulators,
   brainObservations: () => brainObservations,
   brainPageEdges: () => brainPageEdges,
   brainPageNodes: () => brainPageNodes,
@@ -9049,10 +9057,11 @@ __export(brain_schema_exports, {
   brainPlasticityEvents: () => brainPlasticityEvents,
   brainRetrievalLog: () => brainRetrievalLog,
   brainSchemaMeta: () => brainSchemaMeta,
-  brainStickyNotes: () => brainStickyNotes
+  brainStickyNotes: () => brainStickyNotes,
+  brainWeightHistory: () => brainWeightHistory
 });
 import { sql as sql2 } from "drizzle-orm";
-var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog, brainPlasticityEvents;
+var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog, brainPlasticityEvents, brainWeightHistory, brainModulators, brainConsolidationEvents;
 var init_brain_schema = __esm({
   "packages/core/src/store/brain-schema.ts"() {
     "use strict";
@@ -9558,13 +9567,75 @@ var init_brain_schema = __esm({
          *           'auto:contradiction-detected' | 'auto:consolidation' | 'manual'
          */
         provenance: text("provenance"),
-        createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`)
+        createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`),
+        // === T673-M3: Plasticity tracking columns ===
+        /**
+         * ISO 8601 timestamp of the last LTP event applied to this edge.
+         * Used by the decay pass: edges with (now - last_reinforced_at) > decay_threshold_days
+         * receive a per-day weight decay. Null = never reinforced (structural/semantic edges).
+         * Only populated when plasticity_class IN ('hebbian', 'stdp').
+         *
+         * @task T706
+         */
+        lastReinforcedAt: text("last_reinforced_at"),
+        /**
+         * Count of LTP (potentiation) events applied to this edge lifetime.
+         * Incremented on every LTP write. Used to compute stability_score.
+         *
+         * @task T706
+         */
+        reinforcementCount: integer("reinforcement_count").notNull().default(0),
+        /**
+         * Plasticity class governing which algorithm(s) write to this edge.
+         *
+         * - 'static':  Non-plastic edge (structural, semantic, etc.). Immune to decay.
+         * - 'hebbian': Written by strengthenCoRetrievedEdges. Subject to decay.
+         * - 'stdp':    Written or refined by applyStdpPlasticity. Subject to decay + LTD.
+         *
+         * Edges start 'static' for all non-co_retrieved types.
+         * co_retrieved edges start 'hebbian' (seeded by M3 migration), can upgrade to 'stdp'.
+         *
+         * @task T706
+         */
+        plasticityClass: text("plasticity_class", {
+          enum: ["static", "hebbian", "stdp"]
+        }).notNull().default("static"),
+        /**
+         * ISO 8601 timestamp of the last LTD (depression) event on this edge.
+         * Null = never depressed. Used for debugging and Studio viz animation.
+         *
+         * @task T706
+         */
+        lastDepressedAt: text("last_depressed_at"),
+        /**
+         * Count of LTD (depression) events applied to this edge lifetime.
+         * Enables analysis of edges that are persistently weakened.
+         *
+         * @task T706
+         */
+        depressionCount: integer("depression_count").notNull().default(0),
+        /**
+         * Biological-analog stability score: 0.0 (unstable) – 1.0 (consolidated).
+         *
+         * Computed by runConsolidation decay pass as:
+         *   stability = tanh(reinforcement_count / 10) × exp(-(days_since_reinforced / 30))
+         *
+         * Null = not yet computed (new edges). Enables fast filtering in decay pass:
+         * edges with stability > 0.9 skip the full decay recalculation.
+         * Updated at session-end consolidation, NOT per-event.
+         *
+         * @task T706
+         */
+        stabilityScore: real("stability_score")
       },
       (table) => [
         primaryKey({ columns: [table.fromId, table.toId, table.edgeType] }),
         index("idx_brain_edges_from").on(table.fromId),
         index("idx_brain_edges_to").on(table.toId),
-        index("idx_brain_edges_type").on(table.edgeType)
+        index("idx_brain_edges_type").on(table.edgeType),
+        index("idx_brain_edges_last_reinforced").on(table.lastReinforcedAt),
+        index("idx_brain_edges_plasticity_class").on(table.plasticityClass),
+        index("idx_brain_edges_stability").on(table.stabilityScore)
       ]
     );
     brainRetrievalLog = sqliteTable(
@@ -9573,7 +9644,12 @@ var init_brain_schema = __esm({
         id: integer("id").primaryKey({ autoIncrement: true }),
         /** The search query or fetch IDs that triggered this retrieval. */
         query: text("query").notNull(),
-        /** Comma-separated list of entry IDs returned in this retrieval. */
+        /**
+         * JSON array of entry IDs returned in this retrieval.
+         * Stored as JSON array string: '["obs:A","obs:B"]'.
+         * Always write with JSON.stringify() — NEVER join(',').
+         * Readers call JSON.parse(). Migration M1 converts any pre-existing CSV rows.
+         */
         entryIds: text("entry_ids").notNull(),
         /** Number of entries returned. */
         entryCount: integer("entry_count").notNull(),
@@ -9583,12 +9659,26 @@ var init_brain_schema = __esm({
         tokensUsed: integer("tokens_used"),
         /** Session ID (soft FK to tasks.db sessions). Enables grouping retrievals by session for STDP analysis. */
         sessionId: text("session_id"),
-        createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`)
+        createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`),
+        // === T673-M1: STDP plasticity columns ===
+        /** Sequence position of this retrieval within a batch query (0-based). */
+        retrievalOrder: integer("retrieval_order"),
+        /** Wall-clock ms since the previous retrieval row in the same batch. */
+        deltaMs: integer("delta_ms"),
+        /**
+         * R-STDP reward signal: scalar [-1.0, +1.0], null = unlabeled.
+         * Populated by backfillRewardSignals() at session end (Step 9a).
+         * +1.0 = task verified and passed | +0.5 = done (unverified) | -0.5 = cancelled.
+         * Per D-BRAIN-VIZ-13. backfillRewardSignals MUST skip rows where
+         * session_id LIKE 'ses_backfill_%' (synthetic historical sessions, no task correlation).
+         */
+        rewardSignal: real("reward_signal")
       },
       (table) => [
         index("idx_retrieval_log_created").on(table.createdAt),
         index("idx_retrieval_log_source").on(table.source),
-        index("idx_retrieval_log_session").on(table.sessionId)
+        index("idx_retrieval_log_session").on(table.sessionId),
+        index("idx_retrieval_log_reward").on(table.rewardSignal)
       ]
     );
     brainPlasticityEvents = sqliteTable(
@@ -9612,14 +9702,182 @@ var init_brain_schema = __esm({
         /** ISO 8601 timestamp when this event was applied. */
         timestamp: text("timestamp").notNull().default(sql2`(datetime('now'))`),
         /** Session ID that triggered the STDP pass, if available. */
-        sessionId: text("session_id")
+        sessionId: text("session_id"),
+        // === T673-M2: Observability columns ===
+        /**
+         * Edge weight immediately BEFORE this plasticity event was applied.
+         * Null on the first LTP event that inserts a new edge (edge didn't exist).
+         * Enables "show learning history" in Studio viz without querying brain_weight_history.
+         *
+         * @task T696
+         */
+        weightBefore: real("weight_before"),
+        /**
+         * Edge weight immediately AFTER this plasticity event was applied.
+         * Computed as CLAMP(weight_before + delta_w, 0.0, 1.0).
+         * Redundant with delta_w but enables fast before/after display without arithmetic.
+         *
+         * @task T696
+         */
+        weightAfter: real("weight_after"),
+        /**
+         * Soft FK to brain_retrieval_log.id — the retrieval row that triggered this pair.
+         * Null for externally-triggered or legacy events.
+         * Enables: "which memory retrieval caused this edge to strengthen?"
+         *
+         * @task T696
+         */
+        retrievalLogId: integer("retrieval_log_id"),
+        /**
+         * R-STDP reward signal active when this event fired.
+         * Copied from the retrieval_log row's reward_signal at time of plasticity pass.
+         * Null = unmodulated. Denormalized for fast filtering without a JOIN.
+         *
+         * @task T696
+         */
+        rewardSignal: real("reward_signal"),
+        /**
+         * Wall-clock milliseconds between the two spikes that generated this event.
+         * Pre-computed at INSERT time — avoids re-deriving from retrieval timestamps.
+         * Enables analysis of STDP window distribution.
+         *
+         * @task T696
+         */
+        deltaTMs: integer("delta_t_ms")
       },
       (table) => [
         index("idx_plasticity_source").on(table.sourceNode),
         index("idx_plasticity_target").on(table.targetNode),
         index("idx_plasticity_timestamp").on(table.timestamp),
         index("idx_plasticity_session").on(table.sessionId),
-        index("idx_plasticity_kind").on(table.kind)
+        index("idx_plasticity_kind").on(table.kind),
+        index("idx_plasticity_retrieval_log").on(table.retrievalLogId),
+        index("idx_plasticity_reward").on(table.rewardSignal)
+      ]
+    );
+    brainWeightHistory = sqliteTable(
+      "brain_weight_history",
+      {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        /** from_id of the affected brain_page_edges row. */
+        edgeFromId: text("edge_from_id").notNull(),
+        /** to_id of the affected brain_page_edges row. */
+        edgeToId: text("edge_to_id").notNull(),
+        /** Edge type of the affected brain_page_edges row (e.g. 'co_retrieved'). */
+        edgeType: text("edge_type").notNull(),
+        /** Edge weight immediately before this event. Null if the edge was just created. */
+        weightBefore: real("weight_before"),
+        /** Edge weight after this event. CLAMP(weightBefore + deltaWeight, 0, 1). NOT NULL. */
+        weightAfter: real("weight_after").notNull(),
+        /**
+         * Signed weight delta applied to the edge.
+         * Positive = potentiation (LTP/Hebbian), negative = depression (LTD).
+         * Prune events record the final weight that triggered deletion (negative).
+         */
+        deltaWeight: real("delta_weight").notNull(),
+        /**
+         * Plasticity event kind.
+         * 'ltp'      — Long-Term Potentiation (STDP pre-before-post)
+         * 'ltd'      — Long-Term Depression (STDP post-before-pre)
+         * 'hebbian'  — Co-retrieval Hebbian strengthening
+         * 'decay'    — Temporal decay (only prune-triggering decays written here)
+         * 'prune'    — Edge deleted (weight fell below min_weight threshold)
+         * 'external' — Manually-applied external weight change
+         */
+        eventKind: text("event_kind").notNull(),
+        /** Soft FK to brain_plasticity_events.id — the STDP event that caused this. */
+        sourcePlasticityEventId: integer("source_plasticity_event_id"),
+        /** Soft FK to brain_retrieval_log.id — the retrieval batch that triggered this. */
+        retrievalLogId: integer("retrieval_log_id"),
+        /** R-STDP reward signal at time of event (copied from retrieval_log.reward_signal). */
+        rewardSignal: real("reward_signal"),
+        /** ISO 8601 timestamp when this weight change was applied. */
+        changedAt: text("changed_at").notNull().default(sql2`(datetime('now'))`)
+      },
+      (table) => [
+        index("idx_weight_history_edge").on(table.edgeFromId, table.edgeToId, table.edgeType),
+        index("idx_weight_history_from").on(table.edgeFromId),
+        index("idx_weight_history_to").on(table.edgeToId),
+        index("idx_weight_history_changed_at").on(table.changedAt),
+        index("idx_weight_history_event_kind").on(table.eventKind),
+        index("idx_weight_history_plasticity_event").on(table.sourcePlasticityEventId)
+      ]
+    );
+    brainModulators = sqliteTable(
+      "brain_modulators",
+      {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        /**
+         * Modulator event type. String (not enum constraint) for extensibility.
+         * Expected values: 'task_verified'|'task_completed'|'task_cancelled'|
+         * 'owner_verify'|'session_success'|'session_blocker'|'external'
+         */
+        modulatorType: text("modulator_type").notNull(),
+        /**
+         * Reward valence in range [-1.0, +1.0].
+         * +1.0 = strong reward (verified correct task)
+         * +0.5 = moderate reward (done, unverified)
+         * -0.5 = mild correction (cancelled task)
+         * -1.0 = strong correction (explicit invalidation)
+         *  0.0 = neutral signal
+         */
+        valence: real("valence").notNull(),
+        /**
+         * Magnitude 0.0–1.0 confidence scaling.
+         * Effective reward = valence × magnitude.
+         * Defaults to 1.0 (full confidence).
+         */
+        magnitude: real("magnitude").notNull().default(1),
+        /** Polymorphic source event ID — task ID, memory entry ID, or other string ref. */
+        sourceEventId: text("source_event_id"),
+        /** Session ID (soft FK to tasks.db sessions). */
+        sessionId: text("session_id"),
+        /** Human-readable description of why this modulator was emitted. */
+        description: text("description"),
+        /** ISO 8601 timestamp when this modulator event was recorded. */
+        createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`)
+      },
+      (table) => [
+        index("idx_modulators_type").on(table.modulatorType),
+        index("idx_modulators_session").on(table.sessionId),
+        index("idx_modulators_created_at").on(table.createdAt),
+        index("idx_modulators_source_event").on(table.sourceEventId),
+        index("idx_modulators_valence").on(table.valence)
+      ]
+    );
+    brainConsolidationEvents = sqliteTable(
+      "brain_consolidation_events",
+      {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        /**
+         * What triggered this consolidation run. String (not enum constraint) for
+         * forward compatibility with T628 scheduler.
+         * Expected values: 'session_end' | 'maintenance' | 'scheduled' | 'manual'
+         */
+        trigger: text("trigger").notNull(),
+        /** Session ID that initiated this consolidation (soft FK to tasks.db sessions). */
+        sessionId: text("session_id"),
+        /**
+         * JSON-serialized ConsolidationResult — all per-step counts and metrics.
+         * Shape: { [stepName: string]: { count: number, durationMs?: number } }
+         * Required NOT NULL — every run must record its results for T628 scheduling.
+         */
+        stepResultsJson: text("step_results_json").notNull(),
+        /** Wall-clock milliseconds from start to completion. Null if run did not complete. */
+        durationMs: integer("duration_ms"),
+        /**
+         * Whether the run succeeded.
+         * Stored as integer(boolean) per Drizzle SQLite boolean convention.
+         * true = completed without unhandled error, false = partial or error.
+         */
+        succeeded: integer("succeeded", { mode: "boolean" }).notNull().default(true),
+        /** ISO 8601 timestamp when this consolidation run started. */
+        startedAt: text("started_at").notNull().default(sql2`(datetime('now'))`)
+      },
+      (table) => [
+        index("idx_consolidation_events_started_at").on(table.startedAt),
+        index("idx_consolidation_events_trigger").on(table.trigger),
+        index("idx_consolidation_events_session").on(table.sessionId)
       ]
     );
   }
@@ -14490,6 +14748,108 @@ function runBrainMigrations(nativeDb, db) {
            AND provenance LIKE 'consolidation:%'`
     ).run();
   }
+  if (tableExists(nativeDb, "brain_retrieval_log")) {
+    ensureColumns(
+      nativeDb,
+      "brain_retrieval_log",
+      [
+        { name: "session_id", ddl: "text" },
+        { name: "reward_signal", ddl: "real" },
+        { name: "retrieval_order", ddl: "integer" },
+        { name: "delta_ms", ddl: "integer" }
+      ],
+      "brain"
+    );
+  }
+  if (tableExists(nativeDb, "brain_plasticity_events")) {
+    ensureColumns(
+      nativeDb,
+      "brain_plasticity_events",
+      [
+        { name: "session_id", ddl: "text" },
+        { name: "weight_before", ddl: "real" },
+        { name: "weight_after", ddl: "real" },
+        { name: "retrieval_log_id", ddl: "integer" },
+        { name: "reward_signal", ddl: "real" },
+        { name: "delta_t_ms", ddl: "integer" }
+      ],
+      "brain"
+    );
+  }
+  ensureColumns(
+    nativeDb,
+    "brain_page_edges",
+    [
+      { name: "last_reinforced_at", ddl: "text" },
+      { name: "reinforcement_count", ddl: "integer NOT NULL DEFAULT 0" },
+      { name: "plasticity_class", ddl: "text NOT NULL DEFAULT 'static'" },
+      { name: "last_depressed_at", ddl: "text" },
+      { name: "depression_count", ddl: "integer NOT NULL DEFAULT 0" },
+      { name: "stability_score", ddl: "real" }
+    ],
+    "brain"
+  );
+  if (tableExists(nativeDb, "brain_page_edges")) {
+    nativeDb.prepare(
+      `UPDATE brain_page_edges SET plasticity_class = 'hebbian'
+         WHERE edge_type = 'co_retrieved' AND plasticity_class = 'static'`
+    ).run();
+  }
+  nativeDb.exec(
+    `CREATE TABLE IF NOT EXISTS brain_weight_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      edge_from_id TEXT NOT NULL,
+      edge_to_id TEXT NOT NULL,
+      edge_type TEXT NOT NULL,
+      weight_before REAL,
+      weight_after REAL NOT NULL,
+      delta_weight REAL NOT NULL,
+      event_kind TEXT NOT NULL,
+      source_plasticity_event_id INTEGER,
+      retrieval_log_id INTEGER,
+      reward_signal REAL,
+      changed_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`
+  );
+  nativeDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_weight_history_edge
+      ON brain_weight_history (edge_from_id, edge_to_id, edge_type)`
+  );
+  nativeDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_weight_history_changed_at
+      ON brain_weight_history (changed_at)`
+  );
+  nativeDb.exec(
+    `CREATE TABLE IF NOT EXISTS brain_modulators (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      modulator_type TEXT NOT NULL,
+      valence REAL NOT NULL,
+      magnitude REAL NOT NULL DEFAULT 1.0,
+      source_event_id TEXT,
+      session_id TEXT,
+      description TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`
+  );
+  nativeDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_modulators_session
+      ON brain_modulators (session_id)`
+  );
+  nativeDb.exec(
+    `CREATE TABLE IF NOT EXISTS brain_consolidation_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      trigger TEXT NOT NULL,
+      session_id TEXT,
+      step_results_json TEXT NOT NULL,
+      duration_ms INTEGER,
+      succeeded INTEGER NOT NULL DEFAULT 1,
+      started_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`
+  );
+  nativeDb.exec(
+    `CREATE INDEX IF NOT EXISTS idx_consolidation_events_started_at
+      ON brain_consolidation_events (started_at)`
+  );
 }
 function loadBrainVecExtension(nativeDb) {
   try {
@@ -16653,13 +17013,48 @@ var init_link_pipeline = __esm({
 var brain_accessor_exports = {};
 __export(brain_accessor_exports, {
   BrainDataAccessor: () => BrainDataAccessor,
-  getBrainAccessor: () => getBrainAccessor
+  getBrainAccessor: () => getBrainAccessor,
+  insertModulatorRow: () => insertModulatorRow,
+  insertWeightHistoryRow: () => insertWeightHistoryRow,
+  logConsolidationComplete: () => logConsolidationComplete,
+  logConsolidationStart: () => logConsolidationStart
 });
 import { and as and5, asc as asc2, desc as desc2, eq as eq7, gte as gte2, or as or4 } from "drizzle-orm";
 async function getBrainAccessor(cwd) {
   const db = await getBrainDb(cwd);
   return new BrainDataAccessor(db);
 }
+async function insertWeightHistoryRow(cwd, input) {
+  const db = await getBrainDb(cwd);
+  const result = await db.insert(brainWeightHistory).values(input).returning();
+  return result[0];
+}
+async function insertModulatorRow(cwd, input) {
+  const db = await getBrainDb(cwd);
+  const result = await db.insert(brainModulators).values(input).returning();
+  return result[0];
+}
+async function logConsolidationStart(cwd, trigger, sessionId) {
+  const db = await getBrainDb(cwd);
+  const result = await db.insert(brainConsolidationEvents).values({
+    trigger,
+    sessionId: sessionId ?? null,
+    // stepResultsJson is required NOT NULL — use empty object as placeholder
+    // until logConsolidationComplete updates it with final step results.
+    stepResultsJson: "{}",
+    succeeded: true
+  }).returning({ id: brainConsolidationEvents.id });
+  return result[0].id;
+}
+async function logConsolidationComplete(cwd, id, stats2, durationMs, succeeded = true) {
+  const db = await getBrainDb(cwd);
+  const result = await db.update(brainConsolidationEvents).set({
+    stepResultsJson: JSON.stringify(stats2),
+    durationMs,
+    succeeded
+  }).where(eq7(brainConsolidationEvents.id, id)).returning();
+  return result[0];
+}
 var BrainDataAccessor;
 var init_brain_accessor = __esm({
   "packages/core/src/store/brain-accessor.ts"() {
@@ -48852,7 +49247,7 @@ async function logRetrieval(projectRoot, query, entryIds, source, tokensUsed, se
       "INSERT INTO brain_retrieval_log (query, entry_ids, entry_count, source, tokens_used, session_id) VALUES (?, ?, ?, ?, ?, ?)"
     ).run(
       query,
-      entryIds.join(","),
+      JSON.stringify(entryIds),
       entryIds.length,
       source,
       tokensUsed ?? null,
@@ -77860,6 +78255,85 @@ function checkLegacyAgentOutputs(projectRoot) {
     fix: null
   };
 }
+function checkCanonicalRcasdPaths(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const cleoDir = join91(root, ".cleo");
+  const failures = [];
+  const deprecatedDirs = ["research", "consensus", "specs", "decomposition"];
+  for (const dir of deprecatedDirs) {
+    const dirPath = join91(cleoDir, dir);
+    if (existsSync89(dirPath)) {
+      try {
+        const entries = __require("node:fs").readdirSync(dirPath).filter(
+          (e) => !e.startsWith(".")
+        );
+        if (entries.length > 0) {
+          failures.push(
+            `deprecated .cleo/${dir}/ contains files (should migrate to .cleo/rcasd/{epicId}/${dir}/)`
+          );
+        }
+      } catch {
+      }
+    }
+  }
+  const rcasdPath = join91(cleoDir, "rcasd");
+  if (existsSync89(rcasdPath)) {
+    try {
+      const rootFiles = __require("node:fs").readdirSync(rcasdPath).filter(
+        (e) => e.endsWith(".md")
+      );
+      if (rootFiles.length > 0) {
+        failures.push(
+          `misplaced .md files in .cleo/rcasd/ root (audit-*.md, etc. should be in .cleo/agent-outputs/)`
+        );
+      }
+    } catch {
+    }
+  }
+  const claudedocsPath = join91(root, "claudedocs");
+  if (existsSync89(claudedocsPath)) {
+    try {
+      const agentOutputs = join91(claudedocsPath, "agent-outputs");
+      if (existsSync89(agentOutputs)) {
+        failures.push(
+          `legacy claudedocs/agent-outputs/ directory exists (should migrate to .cleo/agent-outputs/)`
+        );
+      }
+    } catch {
+    }
+  }
+  if (failures.length > 0) {
+    return {
+      id: "canonical_rcasd_paths",
+      category: "configuration",
+      status: "warning",
+      message: `Canonical path drift detected (ADR-045): ${failures.join("; ")}`,
+      details: {
+        issues: failures,
+        canonical: {
+          rcasdStages: ".cleo/rcasd/{epicId}/{stage}/{epicId}-{stage}.md",
+          agentOutputs: ".cleo/agent-outputs/{taskId}-{slug}.md",
+          publishedSpecs: "docs/specs/SPEC-NAME.md"
+        }
+      },
+      fix: "cleo upgrade (migrates old paths) or manually move files per ADR-045"
+    };
+  }
+  return {
+    id: "canonical_rcasd_paths",
+    category: "configuration",
+    status: "passed",
+    message: "All artifacts at canonical RCASD paths (ADR-045 compliant)",
+    details: {
+      canonical: {
+        rcasdStages: ".cleo/rcasd/{epicId}/{stage}/{epicId}-{stage}.md",
+        agentOutputs: ".cleo/agent-outputs/{taskId}-{slug}.md",
+        publishedSpecs: "docs/specs/SPEC-NAME.md"
+      }
+    },
+    fix: null
+  };
+}
 function checkCaampMarkerIntegrity(projectRoot) {
   const root = projectRoot ?? process.cwd();
   const files = ["CLAUDE.md", "AGENTS.md"];
@@ -78172,6 +78646,8 @@ function runAllGlobalChecks(cleoHome, projectRoot) {
     checkCoreFilesNotIgnored(projectRoot),
     checkSqliteNotTracked(projectRoot),
     checkLegacyAgentOutputs(projectRoot),
+    // ADR-045 canonical paths check (T708)
+    checkCanonicalRcasdPaths(projectRoot),
     // Injection chain checks (T5153)
     checkCaampMarkerIntegrity(projectRoot),
     checkAtReferenceTargetExists(projectRoot),
@@ -78732,6 +79208,7 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkVitalFilesTracked(projectRoot)));
   checks.push(mapCheckResult(checkCoreFilesNotIgnored(projectRoot)));
   checks.push(mapCheckResult(checkLegacyAgentOutputs(projectRoot)));
+  checks.push(mapCheckResult(checkCanonicalRcasdPaths(projectRoot)));
   const cleoGitHeadExists = existsSync90(join92(cleoDir, ".git", "HEAD"));
   checks.push({
     check: "cleo_git_repo",