@cleocode/cleo 2026.4.59 → 2026.4.62

package/dist/cli/index.js

@@ -6,10 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b2) => (typeof require !== "undefined" ? require : a)[b2]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn2, res) => function __init() {
   return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -1925,7 +1931,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join135(chunks, separator) {
+      function join136(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -1933,7 +1939,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join135;
+      _sql.join = join136;
       function identifier(value) {
         return new Name(value);
       }
@@ -6707,7 +6713,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join135) => join135.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join136) => join136.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -7992,7 +7998,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_2, v2]) => v2);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k2, join135]) => {
+          return sql.join(withEntries.map(([k2, join136]) => {
             const relation = tableConfig.relations[k2];
             const isSingle2 = is(relation, One3);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -8003,7 +8009,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join135,
+              queryConfig: join136,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -8017,7 +8023,7 @@ var init_dialect = __esm({
               key: k2,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join135 !== true && !!join135.where
+              isOptional: (relation.optional ?? false) || join136 !== true && !!join136.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s3) => {
               return sql`${sql.raw(this.escapeString(s3.key))}, ${s3.selection ? sql`${jsonb2}(${sql.identifier(s3.key)})` : sql.identifier(s3.key)}`;
@@ -8416,7 +8422,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join135) => join135.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join136) => join136.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -9064,9 +9070,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,
@@ -9074,10 +9082,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";
@@ -9583,13 +9592,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(
@@ -9598,7 +9669,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(),
@@ -9608,12 +9684,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(
@@ -9637,14 +9727,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)
       ]
     );
   }
@@ -15013,56 +15271,116 @@ function runBrainMigrations(nativeDb, db) {
   }
   reconcileJournal(nativeDb, migrationsFolder, "brain_decisions", "brain");
   migrateWithRetry(db, migrationsFolder, nativeDb, "brain_decisions", "brain");
-  ensureColumns(
-    nativeDb,
-    "brain_page_nodes",
-    [
-      { name: "quality_score", ddl: "real DEFAULT 0.5" },
-      { name: "content_hash", ddl: "text" },
-      { name: "last_activity_at", ddl: "text" },
-      { name: "updated_at", ddl: "text" }
-    ],
-    "brain"
-  );
-  for (const table of [
-    "brain_decisions",
-    "brain_patterns",
-    "brain_learnings",
-    "brain_observations"
-  ]) {
-    ensureColumns(nativeDb, table, [{ name: "quality_score", ddl: "real" }], "brain");
+  if (tableExists(nativeDb, "brain_page_edges")) {
+    nativeDb.prepare(
+      `UPDATE brain_page_edges
+         SET edge_type = 'co_retrieved'
+         WHERE edge_type = 'relates_to'
+           AND provenance LIKE 'consolidation:%'`
+    ).run();
   }
-  for (const table of [
-    "brain_decisions",
-    "brain_patterns",
-    "brain_learnings",
-    "brain_observations"
-  ]) {
+  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,
-      table,
+      "brain_plasticity_events",
       [
-        { name: "memory_tier", ddl: "text DEFAULT 'short'" },
-        { name: "memory_type", ddl: "text DEFAULT 'episodic'" },
-        { name: "verified", ddl: "integer NOT NULL DEFAULT 0" },
-        // valid_at uses nullable text (no datetime('now') default) because
-        // ALTER TABLE ADD COLUMN with non-constant defaults fails on non-empty tables.
-        { name: "valid_at", ddl: "text" },
-        { name: "invalid_at", ddl: "text" },
-        { name: "source_confidence", ddl: "text DEFAULT 'agent'" },
-        { name: "citation_count", ddl: "integer NOT NULL DEFAULT 0" }
+        { 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 edge_type = 'co_retrieved'
-         WHERE edge_type = 'relates_to'
-           AND provenance LIKE 'consolidation:%'`
+      `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 {
@@ -16207,7 +16525,8 @@ async function createSqliteDataAccessor(cwd) {
         ["createdBy", "createdBy"],
         ["modifiedBy", "modifiedBy"],
         ["sessionId", "sessionId"],
-        ["assignee", "assignee"]
+        ["assignee", "assignee"],
+        ["pipelineStage", "pipelineStage"]
       ];
       for (const [key, col] of fieldMap) {
         if (fields[key] !== void 0) {
@@ -18638,13 +18957,48 @@ var init_adrs = __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"() {
@@ -46519,13 +46873,147 @@ var init_graph_memory_bridge = __esm({
   }
 });
 
+// packages/core/src/memory/brain-plasticity-class.ts
+function upgradePlasticityClass(currentClass, event) {
+  const current = currentClass ?? "static";
+  if (current === "stdp") return "stdp";
+  if (event === "stdp") return "stdp";
+  if (event === "hebbian") {
+    return current === "static" ? "hebbian" : current;
+  }
+  return current;
+}
+function computeStabilityScore(reinforcementCount, lastReinforcedAt, now2 = Date.now()) {
+  if (!reinforcementCount || reinforcementCount <= 0) return null;
+  if (!lastReinforcedAt) return null;
+  const rcTerm = Math.tanh(reinforcementCount / 10);
+  const lastReinforcedMs = new Date(lastReinforcedAt).getTime();
+  const ageMs = now2 - lastReinforcedMs;
+  const ageDays = ageMs / (24 * 60 * 60 * 1e3);
+  const decayTerm = Math.exp(-ageDays / 30);
+  const stability = rcTerm * decayTerm;
+  return Math.max(0, Math.min(1, stability));
+}
+var init_brain_plasticity_class = __esm({
+  "packages/core/src/memory/brain-plasticity-class.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/memory/brain-stdp.ts
 var brain_stdp_exports = {};
 __export(brain_stdp_exports, {
+  applyHomeostaticDecay: () => applyHomeostaticDecay,
   applyStdpPlasticity: () => applyStdpPlasticity,
-  getPlasticityStats: () => getPlasticityStats
-});
-async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3) {
+  backfillRewardSignals: () => backfillRewardSignals,
+  computeTau: () => computeTau,
+  getPlasticityStats: () => getPlasticityStats,
+  shouldRunPlasticity: () => shouldRunPlasticity
+});
+function computeTau(deltaT) {
+  if (deltaT <= TAU_NEAR_THRESHOLD_MS) return TAU_NEAR_MS;
+  if (deltaT <= TAU_SESSION_THRESHOLD_MS) return TAU_SESSION_MS;
+  return TAU_EPISODIC_MS;
+}
+function isPlasticityEventDuplicate(nativeDb, sourceNode, targetNode, kind, sessionId, withinHours = 1) {
+  try {
+    const cutoffIso = new Date(Date.now() - withinHours * 60 * 60 * 1e3).toISOString().replace("T", " ").slice(0, 19);
+    const db = nativeDb;
+    const stmt = db.prepare(
+      `SELECT 1 FROM brain_plasticity_events
+       WHERE source_node = ? AND target_node = ? AND kind = ?
+         AND session_id = ?
+         AND timestamp > ?
+       LIMIT 1`
+    );
+    const result = stmt.get(sourceNode, targetNode, kind, sessionId, cutoffIso);
+    return result !== void 0;
+  } catch {
+    return false;
+  }
+}
+function hasMinimumRetrievalsSinceLastPlasticity(nativeDb, minCount = 2, sessionId = null) {
+  try {
+    const db = nativeDb;
+    const lastPlasticityStmt = db.prepare(
+      `SELECT MAX(timestamp) as last_time FROM brain_plasticity_events
+       WHERE session_id = ?`
+    );
+    const lastPlasticityRow = lastPlasticityStmt.get(sessionId);
+    const lastTime = lastPlasticityRow?.last_time ?? null;
+    let newRetrievalCount;
+    if (lastTime === null) {
+      const countRow = db.prepare(
+        `SELECT COUNT(*) as cnt FROM brain_retrieval_log
+           WHERE session_id = ?`
+      ).get(sessionId);
+      newRetrievalCount = countRow?.cnt ?? 0;
+    } else {
+      const countRow = db.prepare(
+        `SELECT COUNT(*) as cnt FROM brain_retrieval_log
+           WHERE session_id = ? AND created_at > ?`
+      ).get(sessionId, lastTime);
+      newRetrievalCount = countRow?.cnt ?? 0;
+    }
+    return newRetrievalCount >= minCount;
+  } catch {
+    return true;
+  }
+}
+async function shouldRunPlasticity(projectRoot, sessionId = null, minRetrievalsForPlasticity = 2) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  if (!nativeDb) return true;
+  const hasMinimum = hasMinimumRetrievalsSinceLastPlasticity(
+    nativeDb,
+    minRetrievalsForPlasticity,
+    sessionId
+  );
+  if (!hasMinimum) {
+    const count5 = (() => {
+      try {
+        const db = nativeDb;
+        const lastPlasticityStmt = db.prepare(
+          `SELECT MAX(timestamp) as last_time FROM brain_plasticity_events WHERE session_id = ?`
+        );
+        const lastPlasticityRow = lastPlasticityStmt.get(sessionId);
+        const lastTime = lastPlasticityRow?.last_time ?? null;
+        if (lastTime === null) {
+          const countStmt = db.prepare(
+            `SELECT COUNT(*) as cnt FROM brain_retrieval_log WHERE session_id = ?`
+          );
+          const countRow = countStmt.get(sessionId);
+          return countRow?.cnt ?? 0;
+        } else {
+          const countStmt = db.prepare(
+            `SELECT COUNT(*) as cnt FROM brain_retrieval_log WHERE session_id = ? AND created_at > ?`
+          );
+          const countRow = countStmt.get(sessionId, lastTime);
+          return countRow?.cnt ?? 0;
+        }
+      } catch {
+        return 0;
+      }
+    })();
+    console.warn(
+      `[plasticity] Minimum-pair gate: skipped STDP Step 9b (${count5} retrievals, need >=${minRetrievalsForPlasticity})`
+    );
+  }
+  return hasMinimum;
+}
+async function applyStdpPlasticity(projectRoot, options) {
+  let lookbackDays = DEFAULT_LOOKBACK_DAYS;
+  let pairingWindowMs = DEFAULT_PAIRING_WINDOW_MS;
+  if (typeof options === "number") {
+    console.warn(
+      "[brain-stdp] Deprecated: passing sessionWindowMs as a number. Use StdpPlasticityOptions { lookbackDays, pairingWindowMs } instead. (T679)"
+    );
+    pairingWindowMs = options;
+  } else if (options !== void 0) {
+    lookbackDays = options.lookbackDays ?? DEFAULT_LOOKBACK_DAYS;
+    pairingWindowMs = options.pairingWindowMs ?? DEFAULT_PAIRING_WINDOW_MS;
+  }
   const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
   await getBrainDb2(projectRoot);
   const nativeDb = getBrainNativeDb2();
@@ -46533,7 +47021,8 @@ async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3)
     ltpEvents: 0,
     ltdEvents: 0,
     edgesCreated: 0,
-    pairsExamined: 0
+    pairsExamined: 0,
+    rewardModulatedEvents: 0
   };
   if (!nativeDb) return result;
   try {
@@ -46547,14 +47036,14 @@ async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3)
     return result;
   }
   const now2 = Date.now();
-  const cutoffMs = now2 - sessionWindowMs;
+  const cutoffMs = now2 - lookbackDays * 24 * 60 * 60 * 1e3;
   const cutoffIso = new Date(cutoffMs).toISOString().replace("T", " ").slice(0, 19);
   const nowIso = new Date(now2).toISOString().replace("T", " ").slice(0, 19);
   let logRows = [];
   try {
     logRows = typedAll(
       nativeDb.prepare(
-        `SELECT id, entry_ids, created_at, retrieval_order, delta_ms
+        `SELECT id, entry_ids, created_at, retrieval_order, delta_ms, session_id, reward_signal
          FROM brain_retrieval_log
          WHERE created_at >= ?
          ORDER BY created_at ASC, id ASC
@@ -46575,68 +47064,318 @@ async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3)
     } catch {
       continue;
     }
+    if (!Array.isArray(ids)) continue;
     const rowTime = (/* @__PURE__ */ new Date(row.created_at.replace(" ", "T") + "Z")).getTime();
     for (const rawId of ids) {
+      if (typeof rawId !== "string" || rawId.length === 0) continue;
       const entryId = rawId.includes(":") ? rawId : `observation:${rawId}`;
       spikes.push({
         entryId,
         rowId: row.id,
         retrievedAt: rowTime,
-        order: row.retrieval_order ?? globalOrder
+        order: row.retrieval_order ?? globalOrder,
+        sessionId: row.session_id ?? null,
+        rewardSignal: row.reward_signal ?? null
       });
       globalOrder++;
     }
   }
+  if (spikes.length < 2) return result;
   spikes.sort((a, b2) => a.retrievedAt - b2.retrievedAt || a.order - b2.order);
+  const MAX_PAIRS_PER_SESSION = 50;
+  const sessionBucketMap = /* @__PURE__ */ new Map();
+  for (const spike of spikes) {
+    const key = spike.sessionId ?? "null";
+    const bucket = sessionBucketMap.get(key);
+    if (bucket !== void 0) {
+      bucket.push(spike);
+    } else {
+      sessionBucketMap.set(key, [spike]);
+    }
+  }
+  const orderedBuckets = Array.from(sessionBucketMap.entries()).sort(
+    ([, a], [, b2]) => (a[0]?.retrievedAt ?? 0) - (b2[0]?.retrievedAt ?? 0)
+  );
+  const workingSpikes = [];
+  for (let bi2 = 0; bi2 < orderedBuckets.length; bi2++) {
+    const [, bucketSpikes] = orderedBuckets[bi2];
+    workingSpikes.push(...bucketSpikes);
+  }
+  const withinSessionIndex = /* @__PURE__ */ new Map();
+  const sessionSizeMap = /* @__PURE__ */ new Map();
+  for (const [, bucketSpikes] of orderedBuckets) {
+    for (let idx = 0; idx < bucketSpikes.length; idx++) {
+      const spike = bucketSpikes[idx];
+      withinSessionIndex.set(spike, idx);
+      sessionSizeMap.set(spike.sessionId ?? "null", bucketSpikes.length);
+    }
+  }
   const prepareGetEdge = nativeDb.prepare(
-    `SELECT weight FROM brain_page_edges
+    `SELECT weight, reinforcement_count, last_reinforced_at, plasticity_class, depression_count, last_depressed_at
+     FROM brain_page_edges
      WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
   );
-  const prepareUpdateEdge = nativeDb.prepare(
+  const prepareUpdateEdgeLtp = nativeDb.prepare(
     `UPDATE brain_page_edges
-     SET weight = MAX(?, MIN(?, weight + ?))
+     SET weight = MAX(?, MIN(?, weight + ?)),
+         reinforcement_count = reinforcement_count + 1,
+         last_reinforced_at = ?,
+         plasticity_class = ?,
+         stability_score = ?
+     WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
+  );
+  const prepareUpdateEdgeLtd = nativeDb.prepare(
+    `UPDATE brain_page_edges
+     SET weight = MAX(?, MIN(?, weight + ?)),
+         depression_count = depression_count + 1,
+         last_depressed_at = ?,
+         plasticity_class = ?,
+         stability_score = ?
      WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
   );
   const prepareInsertEdge = nativeDb.prepare(
     `INSERT OR IGNORE INTO brain_page_edges
-       (from_id, to_id, edge_type, weight, provenance, created_at)
-     VALUES (?, ?, 'co_retrieved', ?, 'plasticity:stdp-ltp', ?)`
+       (from_id, to_id, edge_type, weight, provenance, reinforcement_count, last_reinforced_at, plasticity_class, stability_score, created_at)
+     VALUES (?, ?, 'co_retrieved', ?, 'plasticity:stdp-ltp', 1, ?, 'stdp', ?, ?)`
   );
   const prepareLogEvent = nativeDb.prepare(
     `INSERT INTO brain_plasticity_events
-       (source_node, target_node, delta_w, kind, timestamp)
-     VALUES (?, ?, ?, ?, ?)`
+       (source_node, target_node, delta_w, kind, timestamp,
+        session_id, retrieval_log_id, weight_before, weight_after, delta_t_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
-  for (let i = 0; i < spikes.length; i++) {
-    const spikeA = spikes[i];
-    for (let j2 = i + 1; j2 < spikes.length; j2++) {
-      const spikeB = spikes[j2];
+  let prepareLogWeightHistory = null;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_weight_history LIMIT 1").get();
+    prepareLogWeightHistory = nativeDb.prepare(
+      `INSERT INTO brain_weight_history
+         (edge_from_id, edge_to_id, edge_type, weight_before, weight_after,
+          delta_weight, event_kind, source_plasticity_event_id, retrieval_log_id,
+          reward_signal, changed_at)
+       VALUES (?, ?, 'co_retrieved', ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+  } catch {
+  }
+  for (let i = 0; i < workingSpikes.length; i++) {
+    const spikeA = workingSpikes[i];
+    const sessionKeyA = spikeA.sessionId ?? "null";
+    const sessionSizeA = sessionSizeMap.get(sessionKeyA) ?? 1;
+    const posInSessionA = withinSessionIndex.get(spikeA) ?? 0;
+    const canCrossSession = posInSessionA >= sessionSizeA - MAX_PAIRS_PER_SESSION;
+    for (let j2 = i + 1; j2 < workingSpikes.length; j2++) {
+      const spikeB = workingSpikes[j2];
       const deltaT = spikeB.retrievedAt - spikeA.retrievedAt;
-      if (deltaT > sessionWindowMs) break;
+      if (deltaT > pairingWindowMs) break;
       if (spikeA.entryId === spikeB.entryId) continue;
+      const sessionKeyB = spikeB.sessionId ?? "null";
+      if (sessionKeyA !== sessionKeyB && !canCrossSession) {
+        continue;
+      }
       result.pairsExamined++;
-      const deltaW = A_PRE * Math.exp(-deltaT / TAU_PRE_MS);
+      const tau = computeTau(deltaT);
+      let deltaW = A_PRE * Math.exp(-deltaT / tau);
       if (deltaW < 1e-6) continue;
+      const eventSessionId = spikeA.sessionId ?? null;
+      const eventRewardSignal = spikeA.rewardSignal ?? null;
+      let wasRewardModulated = false;
+      if (eventRewardSignal !== null) {
+        const r = eventRewardSignal;
+        deltaW = Math.min(deltaW * (1 + r), 2 * A_PRE);
+        deltaW = Math.max(deltaW, 0);
+        wasRewardModulated = true;
+      }
+      if (deltaW < 1e-6) {
+        if (wasRewardModulated) result.rewardModulatedEvents++;
+        continue;
+      }
       const existingEdge = prepareGetEdge.get(spikeA.entryId, spikeB.entryId);
+      let ltpEventId = null;
       try {
         if (existingEdge !== void 0) {
-          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaW, spikeA.entryId, spikeB.entryId);
+          const currentWeight = existingEdge.weight;
+          const newWeight = Math.max(WEIGHT_MIN, Math.min(WEIGHT_MAX, currentWeight + deltaW));
+          const upgradedClass = upgradePlasticityClass(existingEdge.plasticity_class, "stdp");
+          const newRcCount = (existingEdge.reinforcement_count ?? 0) + 1;
+          const stability = computeStabilityScore(newRcCount, nowIso, now2);
+          prepareUpdateEdgeLtp.run(
+            WEIGHT_MIN,
+            WEIGHT_MAX,
+            deltaW,
+            nowIso,
+            // last_reinforced_at
+            upgradedClass,
+            stability,
+            spikeA.entryId,
+            spikeB.entryId
+          );
+          const isDuplicate = isPlasticityEventDuplicate(
+            nativeDb,
+            spikeA.entryId,
+            spikeB.entryId,
+            "ltp",
+            eventSessionId,
+            1
+            // within 1 hour
+          );
+          if (isDuplicate) {
+            result.ltpEvents++;
+            if (wasRewardModulated) result.rewardModulatedEvents++;
+            continue;
+          }
+          const evtStmt = prepareLogEvent.run(
+            spikeA.entryId,
+            spikeB.entryId,
+            deltaW,
+            "ltp",
+            nowIso,
+            eventSessionId,
+            spikeA.rowId,
+            currentWeight,
+            newWeight,
+            deltaT
+          );
+          ltpEventId = evtStmt.lastInsertRowid != null ? Number(evtStmt.lastInsertRowid) : null;
+          if (prepareLogWeightHistory) {
+            prepareLogWeightHistory.run(
+              spikeA.entryId,
+              spikeB.entryId,
+              currentWeight,
+              newWeight,
+              deltaW,
+              "ltp",
+              ltpEventId,
+              spikeA.rowId,
+              eventRewardSignal,
+              nowIso
+            );
+          }
         } else {
-          const initialWeight = Math.min(WEIGHT_MAX, deltaW);
-          prepareInsertEdge.run(spikeA.entryId, spikeB.entryId, initialWeight, nowIso);
+          const noveltyBoostedWeight = deltaW * K_NOVELTY;
+          const initialWeight = Math.min(
+            WEIGHT_MAX,
+            Math.min(A_PRE * K_NOVELTY, noveltyBoostedWeight)
+          );
+          const stability = computeStabilityScore(1, nowIso, now2);
+          prepareInsertEdge.run(
+            spikeA.entryId,
+            spikeB.entryId,
+            initialWeight,
+            nowIso,
+            // last_reinforced_at
+            stability,
+            nowIso
+          );
           result.edgesCreated++;
+          const evtStmt = prepareLogEvent.run(
+            spikeA.entryId,
+            spikeB.entryId,
+            initialWeight,
+            "ltp",
+            nowIso,
+            eventSessionId,
+            spikeA.rowId,
+            null,
+            initialWeight,
+            deltaT
+          );
+          ltpEventId = evtStmt.lastInsertRowid != null ? Number(evtStmt.lastInsertRowid) : null;
+          if (prepareLogWeightHistory) {
+            prepareLogWeightHistory.run(
+              spikeA.entryId,
+              spikeB.entryId,
+              null,
+              initialWeight,
+              initialWeight,
+              "ltp",
+              ltpEventId,
+              spikeA.rowId,
+              eventRewardSignal,
+              nowIso
+            );
+          }
         }
-        prepareLogEvent.run(spikeA.entryId, spikeB.entryId, deltaW, "ltp", nowIso);
         result.ltpEvents++;
+        if (wasRewardModulated) result.rewardModulatedEvents++;
       } catch {
       }
-      const deltaWNeg = -(A_POST * Math.exp(-deltaT / TAU_POST_MS));
+      let deltaWNeg = -(A_POST * Math.exp(-deltaT / tau));
+      let ltdWasRewardModulated = false;
+      if (eventRewardSignal !== null) {
+        const r = eventRewardSignal;
+        deltaWNeg = Math.max(deltaWNeg * (1 - r), -2 * A_POST);
+        ltdWasRewardModulated = true;
+      }
       const existingReverseEdge = prepareGetEdge.get(spikeB.entryId, spikeA.entryId);
       if (existingReverseEdge !== void 0 && Math.abs(deltaWNeg) >= 1e-6) {
         try {
-          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaWNeg, spikeB.entryId, spikeA.entryId);
-          prepareLogEvent.run(spikeB.entryId, spikeA.entryId, deltaWNeg, "ltd", nowIso);
+          const currentReverseWeight = existingReverseEdge.weight;
+          const newReverseWeight = Math.max(
+            WEIGHT_MIN,
+            Math.min(WEIGHT_MAX, currentReverseWeight + deltaWNeg)
+          );
+          const upgradedClass = upgradePlasticityClass(
+            existingReverseEdge.plasticity_class,
+            "stdp"
+          );
+          const stability = computeStabilityScore(
+            existingReverseEdge.reinforcement_count,
+            existingReverseEdge.last_reinforced_at,
+            now2
+          );
+          prepareUpdateEdgeLtd.run(
+            WEIGHT_MIN,
+            WEIGHT_MAX,
+            deltaWNeg,
+            nowIso,
+            // last_depressed_at
+            upgradedClass,
+            stability,
+            spikeB.entryId,
+            spikeA.entryId
+          );
+          const isLtdDuplicate = isPlasticityEventDuplicate(
+            nativeDb,
+            spikeB.entryId,
+            spikeA.entryId,
+            "ltd",
+            eventSessionId,
+            1
+            // within 1 hour
+          );
+          if (isLtdDuplicate) {
+            result.ltdEvents++;
+            if (ltdWasRewardModulated) result.rewardModulatedEvents++;
+            continue;
+          }
+          const ltdEvtStmt = prepareLogEvent.run(
+            spikeB.entryId,
+            spikeA.entryId,
+            deltaWNeg,
+            "ltd",
+            nowIso,
+            eventSessionId,
+            spikeB.rowId,
+            currentReverseWeight,
+            newReverseWeight,
+            deltaT
+          );
+          const ltdEventId = ltdEvtStmt.lastInsertRowid != null ? Number(ltdEvtStmt.lastInsertRowid) : null;
+          if (prepareLogWeightHistory) {
+            prepareLogWeightHistory.run(
+              spikeB.entryId,
+              spikeA.entryId,
+              currentReverseWeight,
+              newReverseWeight,
+              deltaWNeg,
+              "ltd",
+              ltdEventId,
+              spikeB.rowId,
+              eventRewardSignal,
+              nowIso
+            );
+          }
           result.ltdEvents++;
+          if (ltdWasRewardModulated) result.rewardModulatedEvents++;
         } catch {
         }
       }
@@ -46706,15 +47445,240 @@ async function getPlasticityStats(projectRoot, limit = 20) {
     }))
   };
 }
-var TAU_PRE_MS, TAU_POST_MS, A_PRE, A_POST, WEIGHT_MIN, WEIGHT_MAX;
+async function backfillRewardSignals(projectRoot, sessionId, lookbackDays = 30) {
+  const result = { rowsLabeled: 0, rowsSkipped: 0 };
+  if (!sessionId) {
+    return result;
+  }
+  if (sessionId.startsWith("ses_backfill_")) {
+    return result;
+  }
+  let taskRows = [];
+  try {
+    const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
+    const tasksDb = await getDb4(projectRoot);
+    const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
+    const { and: and15, eq: eq18, inArray: inArray8, gte: gte4, or: or7, isNotNull: isNotNull3 } = await import("drizzle-orm");
+    const cutoffTs = new Date(Date.now() - lookbackDays * 24 * 60 * 60 * 1e3).toISOString().replace("T", " ").slice(0, 19);
+    const rawRows = await tasksDb.select({
+      id: tasks2.id,
+      status: tasks2.status,
+      verificationJson: tasks2.verificationJson,
+      completedAt: tasks2.completedAt,
+      cancelledAt: tasks2.cancelledAt
+    }).from(tasks2).where(
+      and15(
+        eq18(tasks2.sessionId, sessionId),
+        inArray8(tasks2.status, ["done", "cancelled"]),
+        or7(
+          and15(isNotNull3(tasks2.completedAt), gte4(tasks2.completedAt, cutoffTs)),
+          and15(isNotNull3(tasks2.cancelledAt), gte4(tasks2.cancelledAt, cutoffTs))
+        )
+      )
+    ).all();
+    taskRows = rawRows.map((r) => ({
+      id: r.id,
+      status: r.status,
+      verificationJson: r.verificationJson ?? null,
+      completedAt: r.completedAt ?? null,
+      cancelledAt: r.cancelledAt ?? null
+    }));
+  } catch {
+    return result;
+  }
+  if (taskRows.length === 0) {
+    return result;
+  }
+  let sessionReward = null;
+  function deriveTaskReward(task) {
+    if (task.status === "cancelled") {
+      return -0.5;
+    }
+    let verificationPassed = false;
+    if (task.verificationJson) {
+      try {
+        const v2 = JSON.parse(task.verificationJson);
+        verificationPassed = v2.passed === true;
+      } catch {
+      }
+    }
+    return verificationPassed ? 1 : 0.5;
+  }
+  for (const task of taskRows) {
+    const taskReward = deriveTaskReward(task);
+    if (sessionReward === null || taskReward > sessionReward) {
+      sessionReward = taskReward;
+    }
+  }
+  if (sessionReward === null) {
+    return result;
+  }
+  try {
+    const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+    await getBrainDb2(projectRoot);
+    const nativeDb = getBrainNativeDb2();
+    if (!nativeDb) return result;
+    try {
+      nativeDb.prepare("SELECT 1 FROM brain_retrieval_log LIMIT 1").get();
+    } catch {
+      return result;
+    }
+    const updateResult = nativeDb.prepare(
+      `UPDATE brain_retrieval_log
+         SET reward_signal = ?
+         WHERE session_id = ?
+           AND reward_signal IS NULL`
+    ).run(sessionReward, sessionId);
+    const updatedCount = typeof updateResult.changes === "number" ? updateResult.changes : 0;
+    result.rowsLabeled = updatedCount;
+    const skipRow = nativeDb.prepare(
+      `SELECT COUNT(*) AS cnt FROM brain_retrieval_log
+         WHERE session_id = ? AND reward_signal IS NOT NULL`
+    ).get(sessionId);
+    result.rowsSkipped = skipRow?.cnt ?? 0;
+    let modulatorsExist = false;
+    try {
+      nativeDb.prepare("SELECT 1 FROM brain_modulators LIMIT 1").get();
+      modulatorsExist = true;
+    } catch {
+    }
+    if (modulatorsExist && updatedCount > 0) {
+      const insertModulator = nativeDb.prepare(
+        `INSERT INTO brain_modulators
+           (modulator_type, valence, magnitude, source_event_id, session_id, description)
+         VALUES (?, ?, 1.0, ?, ?, ?)`
+      );
+      for (const task of taskRows) {
+        const taskReward = deriveTaskReward(task);
+        let modulatorType;
+        let description;
+        if (task.status === "cancelled") {
+          modulatorType = "task_cancelled";
+          description = `Task ${task.id} cancelled`;
+        } else if (taskReward >= 1) {
+          modulatorType = "task_verified";
+          description = `Task ${task.id} completed and verified`;
+        } else {
+          modulatorType = "task_completed";
+          description = `Task ${task.id} completed (unverified)`;
+        }
+        try {
+          insertModulator.run(modulatorType, taskReward, task.id, sessionId, description);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+async function applyHomeostaticDecay(projectRoot, options) {
+  const decayRatePerDay = options?.decayRatePerDay ?? 0.02;
+  const gracePeriodDays = options?.gracePeriodDays ?? 7;
+  const pruneThreshold = options?.pruneThreshold ?? 0.05;
+  const result = { edgesDecayed: 0, edgesPruned: 0 };
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  if (!nativeDb) return result;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_page_edges LIMIT 1").get();
+  } catch {
+    return result;
+  }
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  let weightHistoryExists = false;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_weight_history LIMIT 1").get();
+    weightHistoryExists = true;
+  } catch {
+  }
+  let candidates = [];
+  try {
+    candidates = typedAll(
+      nativeDb.prepare(
+        `SELECT from_id, to_id, edge_type, weight, plasticity_class, last_reinforced_at
+         FROM brain_page_edges
+         WHERE plasticity_class IN ('hebbian', 'stdp')
+           AND last_reinforced_at IS NOT NULL
+           AND (julianday('now') - julianday(last_reinforced_at)) > ?`
+      ),
+      gracePeriodDays
+    );
+  } catch {
+    return result;
+  }
+  if (candidates.length === 0) return result;
+  const prepareUpdateWeight = nativeDb.prepare(
+    `UPDATE brain_page_edges
+     SET weight = ?
+     WHERE from_id = ? AND to_id = ? AND edge_type = ?`
+  );
+  const prepareDeleteEdge = nativeDb.prepare(
+    `DELETE FROM brain_page_edges
+     WHERE from_id = ? AND to_id = ? AND edge_type = ?`
+  );
+  let prepareInsertHistory = null;
+  if (weightHistoryExists) {
+    try {
+      prepareInsertHistory = nativeDb.prepare(
+        `INSERT INTO brain_weight_history
+           (edge_from_id, edge_to_id, edge_type, weight_before, weight_after,
+            delta_weight, event_kind, changed_at)
+         VALUES (?, ?, ?, ?, 0.0, ?, 'prune', ?)`
+      );
+    } catch {
+    }
+  }
+  const nowMs = Date.now();
+  for (const edge of candidates) {
+    try {
+      const lastReinforced = (/* @__PURE__ */ new Date(edge.last_reinforced_at.replace(" ", "T") + "Z")).getTime();
+      const daysIdle = (nowMs - lastReinforced) / (24 * 60 * 60 * 1e3);
+      const decayDays = Math.max(0, daysIdle - gracePeriodDays);
+      const newWeight = edge.weight * (1 - decayRatePerDay) ** decayDays;
+      if (newWeight < pruneThreshold) {
+        prepareDeleteEdge.run(edge.from_id, edge.to_id, edge.edge_type);
+        result.edgesPruned++;
+        if (prepareInsertHistory) {
+          const deltaW = -edge.weight;
+          try {
+            prepareInsertHistory.run(
+              edge.from_id,
+              edge.to_id,
+              edge.edge_type,
+              edge.weight,
+              deltaW,
+              nowIso
+            );
+          } catch {
+          }
+        }
+      } else {
+        prepareUpdateWeight.run(newWeight, edge.from_id, edge.to_id, edge.edge_type);
+        result.edgesDecayed++;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+var DEFAULT_LOOKBACK_DAYS, DEFAULT_PAIRING_WINDOW_MS, TAU_NEAR_MS, TAU_SESSION_MS, TAU_EPISODIC_MS, TAU_NEAR_THRESHOLD_MS, TAU_SESSION_THRESHOLD_MS, A_PRE, A_POST, K_NOVELTY, WEIGHT_MIN, WEIGHT_MAX;
 var init_brain_stdp = __esm({
   "packages/core/src/memory/brain-stdp.ts"() {
     "use strict";
     init_typed_query();
-    TAU_PRE_MS = 2e4;
-    TAU_POST_MS = 2e4;
+    init_brain_plasticity_class();
+    DEFAULT_LOOKBACK_DAYS = 30;
+    DEFAULT_PAIRING_WINDOW_MS = 24 * 60 * 60 * 1e3;
+    TAU_NEAR_MS = 2e4;
+    TAU_SESSION_MS = 30 * 60 * 1e3;
+    TAU_EPISODIC_MS = 12 * 60 * 60 * 1e3;
+    TAU_NEAR_THRESHOLD_MS = 3e4;
+    TAU_SESSION_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
     A_PRE = 0.05;
     A_POST = 0.06;
+    K_NOVELTY = 1.5;
     WEIGHT_MIN = 0;
     WEIGHT_MAX = 1;
   }
@@ -46963,7 +47927,8 @@ async function runTierPromotion(projectRoot) {
   }
   return { promoted, evicted };
 }
-async function runConsolidation(projectRoot) {
+async function runConsolidation(projectRoot, sessionId, trigger = "session_end") {
+  const consolidationStartMs = Date.now();
   const result = {
     deduplicated: 0,
     qualityRecomputed: 0,
@@ -47026,11 +47991,59 @@ async function runConsolidation(projectRoot) {
     console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
   }
   try {
-    const { applyStdpPlasticity: applyStdpPlasticity2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
-    const stdpResult = await applyStdpPlasticity2(projectRoot);
-    result.stdpPlasticity = stdpResult;
+    const { backfillRewardSignals: backfillRewardSignals2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
+    const rewardResult = await backfillRewardSignals2(projectRoot, sessionId ?? null);
+    result.rewardBackfilled = rewardResult;
+  } catch (err) {
+    console.warn("[consolidation] Step 9a reward backfill failed:", err);
+  }
+  try {
+    const { applyStdpPlasticity: applyStdpPlasticity2, shouldRunPlasticity: shouldRunPlasticity2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
+    const shouldRun = await shouldRunPlasticity2(projectRoot, sessionId ?? null, 2);
+    if (shouldRun) {
+      const stdpResult = await applyStdpPlasticity2(projectRoot);
+      result.stdpPlasticity = stdpResult;
+    } else {
+      result.stdpPlasticity = {
+        ltpEvents: 0,
+        ltdEvents: 0,
+        edgesCreated: 0,
+        pairsExamined: 0
+      };
+    }
   } catch (err) {
-    console.warn("[consolidation] Step 9 STDP plasticity failed:", err);
+    console.warn("[consolidation] Step 9b STDP plasticity failed:", err);
+  }
+  try {
+    const { applyHomeostaticDecay: applyHomeostaticDecay2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
+    const decayResult = await applyHomeostaticDecay2(projectRoot);
+    result.homeostaticDecay = decayResult;
+  } catch (err) {
+    console.warn("[consolidation] Step 9c homeostatic decay failed:", err);
+  }
+  try {
+    const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+    await getBrainDb2(projectRoot);
+    const nativeDb = getBrainNativeDb2();
+    if (nativeDb) {
+      let consolidationEventsExist = false;
+      try {
+        nativeDb.prepare("SELECT 1 FROM brain_consolidation_events LIMIT 1").get();
+        consolidationEventsExist = true;
+      } catch {
+      }
+      if (consolidationEventsExist) {
+        const durationMs = Date.now() - consolidationStartMs;
+        const stepResultsJson = JSON.stringify(result);
+        nativeDb.prepare(
+          `INSERT INTO brain_consolidation_events
+               (trigger, session_id, step_results_json, duration_ms, succeeded)
+             VALUES (?, ?, ?, ?, 1)`
+        ).run(trigger, sessionId ?? null, stepResultsJson, durationMs);
+      }
+    }
+  } catch (err) {
+    console.warn("[consolidation] Step 9e consolidation event log failed:", err);
   }
   return result;
 }
@@ -47192,7 +48205,8 @@ async function strengthenCoRetrievedEdges(projectRoot) {
     try {
       const updateStmt = nativeDb.prepare(`
         UPDATE brain_page_edges
-        SET weight = MIN(1.0, weight + 0.1)
+        SET weight = MIN(1.0, weight + 0.1),
+            plasticity_class = 'hebbian'
         WHERE from_id = ? AND to_id = ? AND edge_type = ?
       `);
       const updateResult = updateStmt.run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED);
@@ -47200,8 +48214,8 @@ async function strengthenCoRetrievedEdges(projectRoot) {
       if (changes === 0) {
         nativeDb.prepare(`
             INSERT OR IGNORE INTO brain_page_edges
-              (from_id, to_id, edge_type, weight, provenance, created_at)
-            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', ?)
+              (from_id, to_id, edge_type, weight, provenance, plasticity_class, created_at)
+            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', 'hebbian', ?)
           `).run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED, now2);
       }
       strengthened++;
@@ -52314,7 +53328,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,
@@ -56790,8 +57804,8 @@ async function ensureGlobalHome() {
       await writeFile6(globalConfigPath, resolved);
     }
   }
-  const homedir8 = (await import("node:os")).homedir();
-  const legacyCleoHome = join42(homedir8, ".cleo");
+  const homedir9 = (await import("node:os")).homedir();
+  const legacyCleoHome = join42(homedir9, ".cleo");
   const cleanupPaths = [cleoHome];
   if (legacyCleoHome !== cleoHome && existsSync40(legacyCleoHome)) {
     cleanupPaths.push(legacyCleoHome);
@@ -64894,10 +65908,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync107, existsSync: existsSync135 } = await import("node:fs");
+    const { readFileSync: readFileSync108, existsSync: existsSync136 } = await import("node:fs");
     const infoPath = join64(projectPath, ".cleo", "project-info.json");
-    if (!existsSync135(infoPath)) return "";
-    const data = JSON.parse(readFileSync107(infoPath, "utf-8"));
+    if (!existsSync136(infoPath)) return "";
+    const data = JSON.parse(readFileSync108(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -66601,6 +67615,10 @@ async function startTask(taskId, cwd, accessor) {
       }
     );
   }
+  const currentStage = task.pipelineStage;
+  if (currentStage && isValidPipelineStage(currentStage) && PLANNING_STAGES2.has(currentStage)) {
+    await acc.updateTaskFields(taskId, { pipelineStage: "implementation" });
+  }
   const focus = await acc.getMetaValue("focus_state") ?? {};
   const previousTask = focus.currentTask ?? null;
   focus.currentTask = taskId;
@@ -66688,16 +67706,24 @@ async function getWorkHistory(cwd, accessor) {
   }
   return history.reverse();
 }
-var getTaskHistory;
+var PLANNING_STAGES2, getTaskHistory;
 var init_task_work = __esm({
   "packages/core/src/task-work/index.ts"() {
     "use strict";
+    init_handlers();
     init_src();
     init_errors3();
     init_data_accessor();
     init_add();
     init_dependency_check();
-    init_handlers();
+    init_pipeline_stage();
+    PLANNING_STAGES2 = /* @__PURE__ */ new Set([
+      "research",
+      "consensus",
+      "architecture_decision",
+      "specification",
+      "decomposition"
+    ]);
     getTaskHistory = getWorkHistory;
   }
 });
@@ -66819,6 +67845,10 @@ async function completeTask(options, cwd, accessor) {
   }
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const before = { ...task };
+  const completionStage = task.pipelineStage;
+  if (completionStage && isValidPipelineStage(completionStage) && EXECUTION_STAGES_FOR_RELEASE.has(completionStage)) {
+    task.pipelineStage = "release";
+  }
   task.status = "done";
   task.completedAt = now2;
   task.updatedAt = now2;
@@ -66931,7 +67961,7 @@ async function completeTask(options, cwd, accessor) {
     ...unblockedTasks.length > 0 && { unblockedTasks }
   };
 }
-var DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
+var EXECUTION_STAGES_FOR_RELEASE, DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
 var init_complete = __esm({
   "packages/core/src/tasks/complete.ts"() {
     "use strict";
@@ -66941,6 +67971,8 @@ var init_complete = __esm({
     init_session_enforcement();
     init_data_accessor();
     init_enforcement();
+    init_pipeline_stage();
+    EXECUTION_STAGES_FOR_RELEASE = /* @__PURE__ */ new Set(["implementation", "validation", "testing"]);
     DEFAULT_VERIFICATION_REQUIRED_GATES = [
       "implemented",
       "testsPassed",
@@ -76515,8 +77547,8 @@ async function initializeSpawnAdapters(manifests) {
     if (!manifest.capabilities?.supportsSpawn) continue;
     if (spawnRegistry.hasAdapterForProvider(manifest.provider)) continue;
     try {
-      const { join: join135 } = await import("node:path");
-      const modulePath = join135(manifest.packagePath, manifest.entryPoint);
+      const { join: join136 } = await import("node:path");
+      const modulePath = join136(manifest.packagePath, manifest.entryPoint);
       const adapterModule = await import(modulePath);
       let SpawnProviderClass;
       for (const [exportName, exportValue] of Object.entries(adapterModule)) {
@@ -79319,6 +80351,85 @@ function checkLegacyAgentOutputs(projectRoot) {
     fix: null
   };
 }
+function checkCanonicalRcasdPaths(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const cleoDir = join93(root, ".cleo");
+  const failures = [];
+  const deprecatedDirs = ["research", "consensus", "specs", "decomposition"];
+  for (const dir of deprecatedDirs) {
+    const dirPath = join93(cleoDir, dir);
+    if (existsSync91(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 = join93(cleoDir, "rcasd");
+  if (existsSync91(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 = join93(root, "claudedocs");
+  if (existsSync91(claudedocsPath)) {
+    try {
+      const agentOutputs = join93(claudedocsPath, "agent-outputs");
+      if (existsSync91(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"];
@@ -79631,6 +80742,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),
@@ -80402,6 +81515,46 @@ async function getSystemHealth(projectRoot, opts) {
   if (existsSync92(dbPath)) {
     checks.push(checkAuditLogAvailability(dbPath));
   }
+  if (existsSync92(dbPath) && databaseSyncCtor) {
+    try {
+      const tasksDb = new databaseSyncCtor(dbPath, { readOnly: true });
+      let taskCount = 0;
+      try {
+        const tableExists3 = tasksDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tasks'").get();
+        if (tableExists3?.name) {
+          const countRow = tasksDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+          taskCount = countRow?.cnt ?? 0;
+        }
+      } finally {
+        tasksDb.close();
+      }
+      if (taskCount === 0) {
+        const { listSqliteBackups: listSqliteBackups2 } = await Promise.resolve().then(() => (init_sqlite_backup(), sqlite_backup_exports));
+        const backups = listSqliteBackups2(projectRoot);
+        if (backups.length > 0) {
+          const latestBackup = backups[0];
+          checks.push({
+            name: "tasks_wipe_guard",
+            status: "fail",
+            message: `WIPE ALERT: tasks.db has 0 tasks but ${backups.length} backup(s) exist. Latest: ${latestBackup?.name ?? "unknown"} (${new Date(latestBackup?.mtimeMs ?? 0).toISOString()}). Probable data loss \u2014 restore via: cleo restore backup --file tasks.db. See docs/RECOVERY.md for the full procedure. (T724)`
+          });
+        } else {
+          checks.push({
+            name: "tasks_wipe_guard",
+            status: "warn",
+            message: "tasks.db has 0 tasks and no backups exist (fresh install or data loss without backup recovery)."
+          });
+        }
+      } else {
+        checks.push({
+          name: "tasks_wipe_guard",
+          status: "pass",
+          message: `tasks.db integrity: ${taskCount} task(s) present`
+        });
+      }
+    } catch {
+    }
+  }
   const sdDbPath = join94(cleoDir, "signaldock.db");
   if (existsSync92(sdDbPath)) {
     try {
@@ -80855,6 +82008,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 = existsSync92(join94(cleoDir, ".git", "HEAD"));
   checks.push({
     check: "cleo_git_repo",
@@ -88229,6 +89383,7 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src3 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -91698,6 +92853,197 @@ var init_claude_mem_migration = __esm({
   }
 });
 
+// packages/core/src/memory/dream-cycle.ts
+function countNewObservations(afterTimestamp) {
+  const db = getBrainNativeDb();
+  if (!db) return 0;
+  try {
+    const row = db.prepare(
+      `SELECT COUNT(*) AS cnt FROM brain_observations
+         WHERE created_at > ? AND invalid_at IS NULL`
+    ).get(afterTimestamp);
+    return row?.cnt ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function getLastConsolidationTimestamp() {
+  const db = getBrainNativeDb();
+  if (!db) return null;
+  try {
+    const row = db.prepare(
+      `SELECT started_at FROM brain_consolidation_events
+         ORDER BY started_at DESC LIMIT 1`
+    ).get();
+    return row?.started_at ?? null;
+  } catch {
+    return null;
+  }
+}
+function getLastRetrievalTimestamp() {
+  const db = getBrainNativeDb();
+  if (!db) return null;
+  try {
+    const row = db.prepare(`SELECT created_at FROM brain_retrieval_log ORDER BY created_at DESC LIMIT 1`).get();
+    return row?.created_at ?? null;
+  } catch {
+    return null;
+  }
+}
+function minutesSince(isoTimestamp2) {
+  if (!isoTimestamp2) return Infinity;
+  const normalised = isoTimestamp2.includes("T") ? isoTimestamp2 : isoTimestamp2.replace(" ", "T") + "Z";
+  const ms2 = Date.now() - new Date(normalised).getTime();
+  return ms2 / 6e4;
+}
+function checkVolumeTrigger(threshold) {
+  const lastConsolidated = getLastConsolidationTimestamp();
+  const after = lastConsolidated ?? "1970-01-01 00:00:00";
+  const newObservationCount = countNewObservations(after);
+  return {
+    shouldTrigger: newObservationCount >= threshold,
+    newObservationCount
+  };
+}
+function checkIdleTrigger(idleThresholdMinutes) {
+  const lastRetrievalTs = getLastRetrievalTimestamp();
+  if (lastRetrievalTs === null) {
+    return { shouldTrigger: false, idleMinutes: 0 };
+  }
+  const idleMinutes = minutesSince(lastRetrievalTs);
+  return {
+    shouldTrigger: idleMinutes >= idleThresholdMinutes,
+    idleMinutes
+  };
+}
+async function dispatchDream(projectRoot, sessionId, inline = false) {
+  if (dreamInFlight) return;
+  dreamInFlight = true;
+  lastDreamAt = Date.now();
+  const run = async () => {
+    try {
+      const { runConsolidation: runConsolidation2 } = await Promise.resolve().then(() => (init_brain_lifecycle(), brain_lifecycle_exports));
+      await runConsolidation2(projectRoot, sessionId ?? null, "scheduled");
+    } catch (err) {
+      console.warn("[dream-cycle] Consolidation failed:", err);
+    } finally {
+      dreamInFlight = false;
+    }
+  };
+  if (inline) {
+    await run();
+  } else {
+    setImmediate(run);
+  }
+}
+async function checkAndDream(projectRoot, opts = {}) {
+  const volumeThreshold = opts.volumeThreshold ?? VOLUME_THRESHOLD_DEFAULT;
+  const idleThresholdMinutes = opts.idleThresholdMinutes ?? IDLE_MINUTES_DEFAULT;
+  try {
+    await getBrainDb(projectRoot);
+  } catch {
+    return {
+      triggered: false,
+      tier: null,
+      skippedReason: "brain.db unavailable"
+    };
+  }
+  const msSinceLastDream = Date.now() - lastDreamAt;
+  if (msSinceLastDream < DREAM_COOLDOWN_MS) {
+    return {
+      triggered: false,
+      tier: null,
+      skippedReason: `dream cooldown active (${Math.round(msSinceLastDream / 1e3)}s since last dream)`
+    };
+  }
+  if (dreamInFlight) {
+    return {
+      triggered: false,
+      tier: null,
+      skippedReason: "dream already in flight"
+    };
+  }
+  const volumeCheck = checkVolumeTrigger(volumeThreshold);
+  if (volumeCheck.shouldTrigger) {
+    await dispatchDream(projectRoot, opts.sessionId, opts.inline);
+    return {
+      triggered: true,
+      tier: "volume",
+      newObservationCount: volumeCheck.newObservationCount
+    };
+  }
+  const idleCheck = checkIdleTrigger(idleThresholdMinutes);
+  if (idleCheck.shouldTrigger) {
+    await dispatchDream(projectRoot, opts.sessionId, opts.inline);
+    return {
+      triggered: true,
+      tier: "idle",
+      idleMinutes: idleCheck.idleMinutes
+    };
+  }
+  return {
+    triggered: false,
+    tier: null,
+    skippedReason: `volume below threshold (${volumeCheck.newObservationCount}/${volumeThreshold}); idle below threshold (${Math.round(idleCheck.idleMinutes)}/${idleThresholdMinutes} min)`,
+    newObservationCount: volumeCheck.newObservationCount,
+    idleMinutes: idleCheck.idleMinutes
+  };
+}
+async function triggerManualDream(projectRoot, sessionId) {
+  const { runConsolidation: runConsolidation2 } = await Promise.resolve().then(() => (init_brain_lifecycle(), brain_lifecycle_exports));
+  const result = await runConsolidation2(projectRoot, sessionId ?? null, "manual");
+  lastDreamAt = Date.now();
+  return result;
+}
+function startDreamScheduler(projectRoot, hourUTC = NIGHTLY_HOUR_DEFAULT) {
+  if (nightlyTimer !== null) return false;
+  const msUntilNextFire = () => {
+    const now2 = /* @__PURE__ */ new Date();
+    const next = new Date(now2);
+    next.setUTCHours(hourUTC, 0, 0, 0);
+    if (next.getTime() <= now2.getTime()) {
+      next.setUTCDate(next.getUTCDate() + 1);
+    }
+    return next.getTime() - now2.getTime();
+  };
+  const scheduleNext = () => {
+    nightlyTimer = setTimeout(() => {
+      nightlyTimer = null;
+      checkAndDream(projectRoot, { inline: false }).catch((err) => {
+        console.warn("[dream-cycle] Nightly cron failed:", err);
+      });
+      scheduleNext();
+    }, msUntilNextFire());
+  };
+  scheduleNext();
+  return true;
+}
+function stopDreamScheduler() {
+  if (nightlyTimer === null) return false;
+  clearTimeout(nightlyTimer);
+  nightlyTimer = null;
+  return true;
+}
+function _resetDreamState() {
+  lastDreamAt = 0;
+  dreamInFlight = false;
+  stopDreamScheduler();
+}
+var VOLUME_THRESHOLD_DEFAULT, IDLE_MINUTES_DEFAULT, DREAM_COOLDOWN_MS, NIGHTLY_HOUR_DEFAULT, lastDreamAt, dreamInFlight, nightlyTimer;
+var init_dream_cycle = __esm({
+  "packages/core/src/memory/dream-cycle.ts"() {
+    "use strict";
+    init_brain_sqlite();
+    VOLUME_THRESHOLD_DEFAULT = 10;
+    IDLE_MINUTES_DEFAULT = 30;
+    DREAM_COOLDOWN_MS = 5 * 60 * 1e3;
+    NIGHTLY_HOUR_DEFAULT = 4;
+    lastDreamAt = 0;
+    dreamInFlight = false;
+    nightlyTimer = null;
+  }
+});
+
 // packages/core/src/memory/mental-model-queue.ts
 async function drainQueue() {
   if (_queue.length === 0) return 0;
@@ -91994,7 +93340,14 @@ function mapEdge(raw) {
     edgeType: raw.edge_type,
     weight: raw.weight,
     provenance: raw.provenance,
-    createdAt: raw.created_at
+    createdAt: raw.created_at,
+    // T673-M3 plasticity columns (default to neutral values if absent from SELECT)
+    lastReinforcedAt: raw.last_reinforced_at ?? null,
+    reinforcementCount: raw.reinforcement_count ?? 0,
+    plasticityClass: raw.plasticity_class ?? "static",
+    lastDepressedAt: raw.last_depressed_at ?? null,
+    depressionCount: raw.depression_count ?? 0,
+    stabilityScore: raw.stability_score ?? null
   };
 }
 async function traceBrainGraph(projectRoot, nodeId, maxDepth = 3) {
@@ -100849,9 +102202,9 @@ async function runUpgrade(options = {}) {
             mkdirSync29(backupDir, { recursive: true });
           }
           copyFileSync9(dbPath2, dbBackupPath);
-          const { createHash: createHash17 } = await import("node:crypto");
-          const origChecksum = createHash17("sha256").update(readFileSync87(dbPath2)).digest("hex");
-          const backupChecksum = createHash17("sha256").update(readFileSync87(dbBackupPath)).digest("hex");
+          const { createHash: createHash18 } = await import("node:crypto");
+          const origChecksum = createHash18("sha256").update(readFileSync87(dbPath2)).digest("hex");
+          const backupChecksum = createHash18("sha256").update(readFileSync87(dbBackupPath)).digest("hex");
           if (origChecksum !== backupChecksum) {
             throw new Error(
               `Backup verification failed: checksum mismatch. Aborting migration to prevent data loss.`
@@ -113509,6 +114862,7 @@ __export(internal_exports, {
   WORKFLOW_GATE_SEQUENCE: () => WORKFLOW_GATE_SEQUENCE,
   WorkflowGateName: () => WorkflowGateName,
   WorkflowGateTracker: () => WorkflowGateTracker,
+  _resetDreamState: () => _resetDreamState,
   _resetGlobalSignaldockDb_TESTING_ONLY: () => _resetGlobalSignaldockDb_TESTING_ONLY,
   adapters: () => adapters_exports,
   addChain: () => addChain,
@@ -113581,6 +114935,7 @@ __export(internal_exports, {
   channelToDistTag: () => channelToDistTag,
   checkAgentHealth: () => checkAgentHealth2,
   checkAllDependencies: () => checkAllDependencies,
+  checkAndDream: () => checkAndDream,
   checkArchitectureDecisionManifest: () => checkArchitectureDecisionManifest,
   checkArtifactPublishManifest: () => checkArtifactPublishManifest,
   checkConduitDbHealth: () => checkConduitDbHealth,
@@ -113592,6 +114947,7 @@ __export(internal_exports, {
   checkEpicCompleteness: () => checkEpicCompleteness,
   checkGate: () => checkGate,
   checkGlobalSignaldockDbHealth: () => checkGlobalSignaldockDbHealth,
+  checkIdleTrigger: () => checkIdleTrigger,
   checkImplementationManifest: () => checkImplementationManifest,
   checkProvenanceManifest: () => checkProvenanceManifest,
   checkReleaseManifest: () => checkReleaseManifest,
@@ -113605,6 +114961,7 @@ __export(internal_exports, {
   checkStorageMigration: () => checkStorageMigration,
   checkTestingManifest: () => checkTestingManifest,
   checkValidationManifest: () => checkValidationManifest,
+  checkVolumeTrigger: () => checkVolumeTrigger,
   classifyError: () => classifyError,
   classifyProject: () => classifyProject,
   cleanupSessions: () => cleanupSessions,
@@ -114201,6 +115558,7 @@ __export(internal_exports, {
   snapshot: () => snapshot_exports,
   spawn: () => spawn_exports,
   spawnRegistry: () => spawnRegistry,
+  startDreamScheduler: () => startDreamScheduler,
   startParallelExecution: () => startParallelExecution,
   startPhase: () => startPhase,
   startSession: () => startSession,
@@ -114208,6 +115566,7 @@ __export(internal_exports, {
   startupHealthCheck: () => startupHealthCheck,
   stats: () => stats_exports,
   sticky: () => sticky_exports,
+  stopDreamScheduler: () => stopDreamScheduler,
   stopTask: () => stopTask,
   storeDetectedPattern: () => storeDetectedPattern,
   storeHealingStrategy: () => storeHealingStrategy,
@@ -114242,6 +115601,7 @@ __export(internal_exports, {
   tokenUsageTransportSchema: () => tokenUsageTransportSchema,
   touchLink: () => touchLink,
   trackMemoryUsage: () => trackMemoryUsage,
+  triggerManualDream: () => triggerManualDream,
   ui: () => ui_exports,
   uncancelTask: () => uncancelTask,
   unpackBundle: () => unpackBundle,
@@ -114329,6 +115689,7 @@ var init_internal = __esm({
     init_brain_retrieval();
     init_brain_stdp();
     init_claude_mem_migration();
+    init_dream_cycle();
     init_engine_compat();
     init_pipeline_manifest_sqlite();
     init_quality_feedback();
@@ -121701,7 +123062,7 @@ async function systemStats(projectRoot, params) {
     }
     const byPhase = {};
     for (const t of activeTasks) {
-      const phase = t.phase || "unassigned";
+      const phase = t.pipelineStage || "unassigned";
       byPhase[phase] = (byPhase[phase] ?? 0) + 1;
     }
     const completedTasks = tasks2.filter((t) => t.status === "done" && t.completedAt && t.createdAt);
@@ -121787,10 +123148,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join135 } = await import("node:path");
-    const { existsSync: existsSync135 } = await import("node:fs");
-    const dbPath = join135(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync135(dbPath)) {
+    const { join: join136 } = await import("node:path");
+    const { existsSync: existsSync136 } = await import("node:fs");
+    const dbPath = join136(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync136(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -127396,16 +128757,16 @@ var init_nexus2 = __esm({
 async function orchestrateClassify(request, context, projectRoot) {
   try {
     const { getCleoCantWorkflowsDir: getCleoCantWorkflowsDir2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-    const { readFileSync: readFileSync107, readdirSync: readdirSync42, existsSync: existsSync135 } = await import("node:fs");
-    const { join: join135 } = await import("node:path");
+    const { readFileSync: readFileSync108, readdirSync: readdirSync43, existsSync: existsSync136 } = await import("node:fs");
+    const { join: join136 } = await import("node:path");
     const workflowsDir = getCleoCantWorkflowsDir2();
     const combined = `${request} ${context ?? ""}`.toLowerCase();
     const matches = [];
-    if (existsSync135(workflowsDir)) {
-      const files = readdirSync42(workflowsDir).filter((f2) => f2.endsWith(".cant"));
+    if (existsSync136(workflowsDir)) {
+      const files = readdirSync43(workflowsDir).filter((f2) => f2.endsWith(".cant"));
       for (const file2 of files) {
         try {
-          const src = readFileSync107(join135(workflowsDir, file2), "utf-8");
+          const src = readFileSync108(join136(workflowsDir, file2), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -127420,12 +128781,12 @@ async function orchestrateClassify(request, context, projectRoot) {
         }
       }
     }
-    const localCantDir = join135(projectRoot, ".cleo", "workflows");
-    if (existsSync135(localCantDir)) {
-      const files = readdirSync42(localCantDir).filter((f2) => f2.endsWith(".cant"));
+    const localCantDir = join136(projectRoot, ".cleo", "workflows");
+    if (existsSync136(localCantDir)) {
+      const files = readdirSync43(localCantDir).filter((f2) => f2.endsWith(".cant"));
       for (const file2 of files) {
         try {
-          const src = readFileSync107(join135(localCantDir, file2), "utf-8");
+          const src = readFileSync108(join136(localCantDir, file2), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -132070,8 +133431,8 @@ var init_cli = __esm({
 
 // packages/cleo/src/cli/index.ts
 init_internal();
-import { readFileSync as readFileSync106 } from "node:fs";
-import { dirname as dirname31, join as join134 } from "node:path";
+import { readFileSync as readFileSync107 } from "node:fs";
+import { dirname as dirname31, join as join135 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 
 // node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
@@ -133573,13 +134934,13 @@ function registerAgentCommand(program) {
         transportConfig: {},
         isActive: true
       });
-      const { existsSync: existsSync135, mkdirSync: mkdirSync35, writeFileSync: writeFileSync26 } = await import("node:fs");
-      const { join: join135 } = await import("node:path");
-      const cantDir = join135(".cleo", "agents");
-      const cantPath = join135(cantDir, `${agentId}.cant`);
+      const { existsSync: existsSync136, mkdirSync: mkdirSync36, writeFileSync: writeFileSync27 } = await import("node:fs");
+      const { join: join136 } = await import("node:path");
+      const cantDir = join136(".cleo", "agents");
+      const cantPath = join136(cantDir, `${agentId}.cant`);
       let cantScaffolded = false;
-      if (!existsSync135(cantPath)) {
-        mkdirSync35(cantDir, { recursive: true });
+      if (!existsSync136(cantPath)) {
+        mkdirSync36(cantDir, { recursive: true });
         const role = classification ?? "specialist";
         const cantContent = `---
 kind: agent
@@ -133629,7 +134990,7 @@ agent ${agentId}:
   enforcement:
     1: TODO \u2014 what does this agent push back on?
 `;
-        writeFileSync26(cantPath, cantContent, "utf-8");
+        writeFileSync27(cantPath, cantContent, "utf-8");
         cantScaffolded = true;
       }
       cliOutput(
@@ -133638,7 +134999,7 @@ agent ${agentId}:
           data: {
             agentId: credential.agentId,
             displayName: credential.displayName,
-            cantFile: cantScaffolded ? cantPath : existsSync135(cantPath) ? cantPath : null,
+            cantFile: cantScaffolded ? cantPath : existsSync136(cantPath) ? cantPath : null,
             cantScaffolded
           }
         },
@@ -133718,8 +135079,8 @@ agent ${agentId}:
     try {
       const { AgentRegistryAccessor: AgentRegistryAccessor2, getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
       const { createRuntime } = await import("@cleocode/runtime");
-      const { existsSync: existsSync135, readFileSync: readFileSync107 } = await import("node:fs");
-      const { join: join135 } = await import("node:path");
+      const { existsSync: existsSync136, readFileSync: readFileSync108 } = await import("node:fs");
+      const { join: join136 } = await import("node:path");
       await getDb4();
       const registry2 = new AgentRegistryAccessor2(process.cwd());
       const credential = await registry2.get(agentId);
@@ -133739,9 +135100,9 @@ agent ${agentId}:
       }
       let profile = null;
       let cantValidation = null;
-      const cantPath = opts["cant"] ?? join135(".cleo", "agents", `${agentId}.cant`);
-      if (existsSync135(cantPath)) {
-        profile = readFileSync107(cantPath, "utf-8");
+      const cantPath = opts["cant"] ?? join136(".cleo", "agents", `${agentId}.cant`);
+      if (existsSync136(cantPath)) {
+        profile = readFileSync108(cantPath, "utf-8");
         try {
           const cantModule = await import("@cleocode/cant");
           const validate = "validate" in cantModule ? cantModule.validate : null;
@@ -134136,8 +135497,8 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
     try {
       const { AgentRegistryAccessor: AgentRegistryAccessor2, getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
       const { createRuntime } = await import("@cleocode/runtime");
-      const { existsSync: existsSync135 } = await import("node:fs");
-      const { join: join135 } = await import("node:path");
+      const { existsSync: existsSync136 } = await import("node:fs");
+      const { join: join136 } = await import("node:path");
       const { execFile: execFile8 } = await import("node:child_process");
       const { promisify: promisify8 } = await import("node:util");
       const execFileAsync6 = promisify8(execFile8);
@@ -134157,8 +135518,8 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
       }
       await registry2.update(agentId, { isActive: true });
       await registry2.markUsed(agentId);
-      const cantPath = join135(".cleo", "agents", `${agentId}.cant`);
-      const hasProfile = existsSync135(cantPath);
+      const cantPath = join136(".cleo", "agents", `${agentId}.cant`);
+      const hasProfile = existsSync136(cantPath);
       const runtime = await createRuntime(registry2, {
         agentId,
         pollIntervalMs: 5e3,
@@ -134781,12 +136142,12 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
   });
   agent.command("install <path>").description("Install an agent from a .cantz archive or agent directory").option("--global", "Install to global tier (~/.local/share/cleo/cant/agents/)").action(async (sourcePath, opts) => {
     try {
-      const { existsSync: existsSync135, mkdirSync: mkdirSync35, cpSync, readFileSync: readFileSync107, rmSync: rmSync2, statSync: statSync22 } = await import("node:fs");
-      const { join: join135, basename: basename19, resolve: resolve17 } = await import("node:path");
-      const { homedir: homedir8 } = await import("node:os");
+      const { existsSync: existsSync136, mkdirSync: mkdirSync36, cpSync, readFileSync: readFileSync108, rmSync: rmSync2, statSync: statSync22 } = await import("node:fs");
+      const { join: join136, basename: basename19, resolve: resolve17 } = await import("node:path");
+      const { homedir: homedir9 } = await import("node:os");
       const { tmpdir: tmpdir2 } = await import("node:os");
       const resolvedPath = resolve17(sourcePath);
-      if (!existsSync135(resolvedPath)) {
+      if (!existsSync136(resolvedPath)) {
         cliOutput(
           {
             success: false,
@@ -134806,8 +136167,8 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
       const isCantzArchive = resolvedPath.endsWith(".cantz") && statSync22(resolvedPath).isFile();
       if (isCantzArchive) {
         const { execFileSync: execFileSync19 } = await import("node:child_process");
-        tempDir = join135(tmpdir2(), `cleo-agent-install-${Date.now()}`);
-        mkdirSync35(tempDir, { recursive: true });
+        tempDir = join136(tmpdir2(), `cleo-agent-install-${Date.now()}`);
+        mkdirSync36(tempDir, { recursive: true });
         try {
           execFileSync19("unzip", ["-o", "-q", resolvedPath, "-d", tempDir], {
             encoding: "utf-8",
@@ -134828,9 +136189,9 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
           process.exitCode = 6;
           return;
         }
-        const { readdirSync: readdirSync42 } = await import("node:fs");
-        const topLevel = readdirSync42(tempDir).filter((entry) => {
-          const entryPath = join135(tempDir, entry);
+        const { readdirSync: readdirSync43 } = await import("node:fs");
+        const topLevel = readdirSync43(tempDir).filter((entry) => {
+          const entryPath = join136(tempDir, entry);
           return statSync22(entryPath).isDirectory();
         });
         if (topLevel.length !== 1) {
@@ -134849,7 +136210,7 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
           return;
         }
         agentName = topLevel[0];
-        agentDir = join135(tempDir, agentName);
+        agentDir = join136(tempDir, agentName);
       } else if (statSync22(resolvedPath).isDirectory()) {
         agentDir = resolvedPath;
         agentName = basename19(resolvedPath);
@@ -134867,8 +136228,8 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
         process.exitCode = 6;
         return;
       }
-      const personaPath = join135(agentDir, "persona.cant");
-      if (!existsSync135(personaPath)) {
+      const personaPath = join136(agentDir, "persona.cant");
+      if (!existsSync136(personaPath)) {
         if (tempDir) rmSync2(tempDir, { recursive: true, force: true });
         cliOutput(
           {
@@ -134886,21 +136247,21 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
       const isGlobal = opts["global"] === true;
       let targetRoot;
       if (isGlobal) {
-        const home = homedir8();
-        const xdgData = process.env["XDG_DATA_HOME"] ?? join135(home, ".local", "share");
-        targetRoot = join135(xdgData, "cleo", "cant", "agents");
+        const home = homedir9();
+        const xdgData = process.env["XDG_DATA_HOME"] ?? join136(home, ".local", "share");
+        targetRoot = join136(xdgData, "cleo", "cant", "agents");
       } else {
-        targetRoot = join135(process.cwd(), ".cleo", "cant", "agents");
+        targetRoot = join136(process.cwd(), ".cleo", "cant", "agents");
       }
-      const targetDir = join135(targetRoot, agentName);
-      mkdirSync35(targetRoot, { recursive: true });
+      const targetDir = join136(targetRoot, agentName);
+      mkdirSync36(targetRoot, { recursive: true });
       cpSync(agentDir, targetDir, { recursive: true, force: true });
       if (tempDir) {
         rmSync2(tempDir, { recursive: true, force: true });
       }
       let registered = false;
       try {
-        const persona = readFileSync107(join135(targetDir, "persona.cant"), "utf-8");
+        const persona = readFileSync108(join136(targetDir, "persona.cant"), "utf-8");
         const descMatch = persona.match(/description:\s*"([^"]+)"/);
         const displayName = descMatch?.[1] ?? agentName;
         const { AgentRegistryAccessor: AgentRegistryAccessor2, getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
@@ -134947,11 +136308,11 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
   });
   agent.command("pack <dir>").description("Package an agent directory as a .cantz archive").action(async (dir) => {
     try {
-      const { existsSync: existsSync135, statSync: statSync22 } = await import("node:fs");
+      const { existsSync: existsSync136, statSync: statSync22 } = await import("node:fs");
       const { resolve: resolve17, basename: basename19, dirname: dirname32 } = await import("node:path");
       const { execFileSync: execFileSync19 } = await import("node:child_process");
       const resolvedDir = resolve17(dir);
-      if (!existsSync135(resolvedDir) || !statSync22(resolvedDir).isDirectory()) {
+      if (!existsSync136(resolvedDir) || !statSync22(resolvedDir).isDirectory()) {
         cliOutput(
           {
             success: false,
@@ -134965,9 +136326,9 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
         process.exitCode = 4;
         return;
       }
-      const { join: join135 } = await import("node:path");
-      const personaPath = join135(resolvedDir, "persona.cant");
-      if (!existsSync135(personaPath)) {
+      const { join: join136 } = await import("node:path");
+      const personaPath = join136(resolvedDir, "persona.cant");
+      if (!existsSync136(personaPath)) {
         cliOutput(
           {
             success: false,
@@ -135006,15 +136367,15 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
         return;
       }
       const archiveStats = statSync22(archivePath);
-      const { readdirSync: readdirSync42 } = await import("node:fs");
+      const { readdirSync: readdirSync43 } = await import("node:fs");
       let fileCount = 0;
       const countFiles2 = (dirPath) => {
-        const entries = readdirSync42(dirPath, { withFileTypes: true });
+        const entries = readdirSync43(dirPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile()) {
             fileCount++;
           } else if (entry.isDirectory()) {
-            countFiles2(join135(dirPath, entry.name));
+            countFiles2(join136(dirPath, entry.name));
           }
         }
       };
@@ -135041,9 +136402,9 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
   });
   agent.command("create").description("Scaffold a new agent package with persona.cant and manifest.json").requiredOption("--name <name>", "Agent name (kebab-case)").requiredOption("--role <role>", "Agent role: orchestrator, lead, worker, or docs-worker").option("--tier <tier>", "Agent tier: low, mid, or high (defaults based on role)").option("--team <teamName>", "Team this agent belongs to").option("--domain <description>", "Domain description for file permissions and context").option("--global", "Create in global tier (~/.local/share/cleo/cant/agents/)").option("--seed-brain", "Create expertise/mental-model-seed.md and seed a BRAIN observation").option("--parent <parentAgent>", "Parent agent name in the hierarchy").action(async (opts) => {
     try {
-      const { existsSync: existsSync135, mkdirSync: mkdirSync35, writeFileSync: writeFileSync26 } = await import("node:fs");
-      const { join: join135 } = await import("node:path");
-      const { homedir: homedir8 } = await import("node:os");
+      const { existsSync: existsSync136, mkdirSync: mkdirSync36, writeFileSync: writeFileSync27 } = await import("node:fs");
+      const { join: join136 } = await import("node:path");
+      const { homedir: homedir9 } = await import("node:os");
       const name2 = opts["name"];
       const role = opts["role"];
       const tier = opts["tier"] ?? inferTierFromRole(role);
@@ -135101,14 +136462,14 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
       }
       let targetRoot;
       if (isGlobal) {
-        const home = homedir8();
-        const xdgData = process.env["XDG_DATA_HOME"] ?? join135(home, ".local", "share");
-        targetRoot = join135(xdgData, "cleo", "cant", "agents");
+        const home = homedir9();
+        const xdgData = process.env["XDG_DATA_HOME"] ?? join136(home, ".local", "share");
+        targetRoot = join136(xdgData, "cleo", "cant", "agents");
       } else {
-        targetRoot = join135(process.cwd(), ".cleo", "cant", "agents");
+        targetRoot = join136(process.cwd(), ".cleo", "cant", "agents");
       }
-      const agentDir = join135(targetRoot, name2);
-      if (existsSync135(agentDir)) {
+      const agentDir = join136(targetRoot, name2);
+      if (existsSync136(agentDir)) {
         cliOutput(
           {
             success: false,
@@ -135123,7 +136484,7 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
         process.exitCode = 6;
         return;
       }
-      mkdirSync35(agentDir, { recursive: true });
+      mkdirSync36(agentDir, { recursive: true });
       const personaContent = generatePersonaCant({
         name: name2,
         role,
@@ -135132,29 +136493,29 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
         domain: domain2,
         parent
       });
-      writeFileSync26(join135(agentDir, "persona.cant"), personaContent, "utf-8");
+      writeFileSync27(join136(agentDir, "persona.cant"), personaContent, "utf-8");
       const manifest = generateManifest2({ name: name2, role, tier, domain: domain2 });
-      writeFileSync26(
-        join135(agentDir, "manifest.json"),
+      writeFileSync27(
+        join136(agentDir, "manifest.json"),
         `${JSON.stringify(manifest, null, 2)}
 `,
         "utf-8"
       );
       const createdFiles = [
-        join135(agentDir, "persona.cant"),
-        join135(agentDir, "manifest.json")
+        join136(agentDir, "persona.cant"),
+        join136(agentDir, "manifest.json")
       ];
       if (team) {
         const teamConfigContent = generateTeamConfig(name2, role, team);
-        writeFileSync26(join135(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
-        createdFiles.push(join135(agentDir, "team-config.cant"));
+        writeFileSync27(join136(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
+        createdFiles.push(join136(agentDir, "team-config.cant"));
       }
       if (seedBrain) {
-        const expertiseDir = join135(agentDir, "expertise");
-        mkdirSync35(expertiseDir, { recursive: true });
+        const expertiseDir = join136(agentDir, "expertise");
+        mkdirSync36(expertiseDir, { recursive: true });
         const seedContent = generateMentalModelSeed(name2, role, domain2);
-        writeFileSync26(join135(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
-        createdFiles.push(join135(expertiseDir, "mental-model-seed.md"));
+        writeFileSync27(join136(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
+        createdFiles.push(join136(expertiseDir, "mental-model-seed.md"));
         try {
           const { execFile: execFile8 } = await import("node:child_process");
           const { promisify: promisify8 } = await import("node:util");
@@ -137025,10 +138386,10 @@ function registerCheckCommand(program) {
     );
   });
   check2.command("chain-validate <file>").description("Validate a WarpChain definition from a JSON file").action(async (file2) => {
-    const { readFileSync: readFileSync107 } = await import("node:fs");
+    const { readFileSync: readFileSync108 } = await import("node:fs");
     let chain;
     try {
-      chain = JSON.parse(readFileSync107(file2, "utf8"));
+      chain = JSON.parse(readFileSync108(file2, "utf8"));
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.error(`Failed to read or parse chain file: ${message}`);
@@ -139472,6 +140833,55 @@ function registerMapCommand(program) {
 init_internal();
 init_cli();
 init_renderers();
+import { createHash as createHash17 } from "node:crypto";
+import { existsSync as existsSync135, mkdirSync as mkdirSync35, readdirSync as readdirSync42, readFileSync as readFileSync105, writeFileSync as writeFileSync26 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join132 } from "node:path";
+function parseMemoryFileFrontmatter(raw) {
+  const lines = raw.split("\n");
+  if (!lines[0]?.trim().startsWith("---")) {
+    return { body: raw.trim() };
+  }
+  const endIdx = lines.slice(1).findIndex((l) => /^---\s*$/.test(l));
+  if (endIdx === -1) {
+    return { body: raw.trim() };
+  }
+  const fmLines = lines.slice(1, endIdx + 1);
+  const body = lines.slice(endIdx + 2).join("\n").trim();
+  const fm = {};
+  for (const line2 of fmLines) {
+    const colonIdx = line2.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line2.slice(0, colonIdx).trim();
+    const value = line2.slice(colonIdx + 1).trim();
+    if (key && value) fm[key] = value;
+  }
+  return {
+    name: fm["name"],
+    description: fm["description"],
+    type: fm["type"],
+    body
+  };
+}
+function memoryContentHash(title, body) {
+  return createHash17("sha256").update(`${title}
+${body}`).digest("hex").slice(0, 16);
+}
+function loadImportHashes(stateFile) {
+  try {
+    if (!existsSync135(stateFile)) return /* @__PURE__ */ new Set();
+    const raw = readFileSync105(stateFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    return new Set(parsed.hashes);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function saveImportHashes(stateFile, hashes) {
+  const dir = stateFile.slice(0, stateFile.lastIndexOf("/"));
+  if (!existsSync135(dir)) mkdirSync35(dir, { recursive: true });
+  writeFileSync26(stateFile, JSON.stringify({ hashes: [...hashes] }, null, 2), "utf-8");
+}
 function registerMemoryBrainCommand(program) {
   const memory = program.command("memory").description("BRAIN memory operations (patterns, learnings)");
   memory.command("store").description("Store a pattern or learning to BRAIN memory").requiredOption("--type <type>", "Memory type: pattern or learning").requiredOption("--content <text>", "Content of the memory entry").option("--context <text>", "Context in which the pattern/learning was observed").option("--source <text>", "Source of the learning").option(
@@ -139887,6 +141297,206 @@ function registerMemoryBrainCommand(program) {
       process.exit(1);
     }
   });
+  memory.command("dream").description(
+    "Manually trigger the full auto-dream cycle: consolidation pipeline including R-STDP reward backfill (Step 9a), STDP plasticity (Step 9b), and homeostatic decay (Step 9c). Equivalent to autonomous autonomous nightly consolidation but triggered on demand. Idempotent \u2014 safe to run multiple times."
+  ).option("--json", "Output results as JSON").action(async (opts) => {
+    const root = getProjectRoot();
+    const isJson = !!opts.json;
+    if (!isJson) {
+      console.log("Triggering dream cycle (full consolidation including STDP plasticity)...");
+    }
+    try {
+      const result = await triggerManualDream(root);
+      if (isJson) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: result,
+              meta: {
+                operation: "memory.dream",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log("\nDream cycle complete.");
+      console.log(`  Deduplicated:    ${result.deduplicated}`);
+      console.log(`  Quality recomp:  ${result.qualityRecomputed}`);
+      console.log(`  Tier promoted:   ${result.tierPromotions.promoted.length} entries promoted`);
+      console.log(`  Tier evicted:    ${result.tierPromotions.evicted.length} entries evicted`);
+      console.log(`  Contradictions:  ${result.contradictions}`);
+      console.log(`  Soft evicted:    ${result.softEvicted}`);
+      console.log(`  Edges strength:  ${result.edgesStrengthened}`);
+      console.log(`  Summaries gen:   ${result.summariesGenerated}`);
+      if (result.graphLinksCreated !== void 0) {
+        console.log(`  Graph links:     ${result.graphLinksCreated}`);
+      }
+      if (result.rewardBackfilled !== void 0) {
+        console.log(
+          `  Reward backfill: ${result.rewardBackfilled.rowsLabeled} labeled, ${result.rewardBackfilled.rowsSkipped} skipped`
+        );
+      }
+      if (result.stdpPlasticity !== void 0) {
+        console.log(
+          `  STDP plasticity: ${result.stdpPlasticity.ltpEvents} LTP, ${result.stdpPlasticity.ltdEvents} LTD, ${result.stdpPlasticity.edgesCreated} edges created`
+        );
+      }
+      if (result.homeostaticDecay !== void 0) {
+        console.log(
+          `  Decay/pruning:   ${result.homeostaticDecay.edgesDecayed} decayed, ${result.homeostaticDecay.edgesPruned} pruned`
+        );
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        console.log(JSON.stringify({ success: false, error: message }));
+      } else {
+        console.error(`Dream cycle failed: ${message}`);
+      }
+      process.exit(1);
+    }
+  });
+  memory.command("import").description(
+    "Import memory files from a provider-specific directory (e.g. ~/.claude/projects/*/memory/) into brain.db. Enables provider-agnostic memory via CLEO CLI instead of Claude Code MEMORY.md."
+  ).option(
+    "--from <dir>",
+    "Source directory containing *.md memory files (default: ~/.claude/projects/-mnt-projects-cleocode/memory)"
+  ).option("--dry-run", "Print what would be imported without writing to brain.db").option("--json", "Output results as JSON").action(async (opts) => {
+    const sourceDir = opts.from ?? join132(homedir8(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
+    const isDryRun = !!opts.dryRun;
+    const isJson = !!opts.json;
+    const projectRoot = getProjectRoot();
+    const stateFile = join132(projectRoot, ".cleo", "migrate-memory-hashes.json");
+    if (!existsSync135(sourceDir)) {
+      const msg = `Source directory not found: ${sourceDir}`;
+      if (isJson) {
+        console.log(JSON.stringify({ success: false, error: msg }));
+      } else {
+        console.error(msg);
+      }
+      process.exit(1);
+    }
+    const files = readdirSync42(sourceDir).filter((f2) => f2.endsWith(".md") && f2 !== "MEMORY.md").map((f2) => join132(sourceDir, f2));
+    const importedHashes = isDryRun ? /* @__PURE__ */ new Set() : loadImportHashes(stateFile);
+    const stats2 = { total: files.length, imported: 0, skipped: 0, errors: 0 };
+    const importedEntries = [];
+    const skippedEntries = [];
+    const errorEntries = [];
+    if (!isJson) {
+      console.log(`Importing memory from: ${sourceDir}`);
+      console.log(`Files found: ${files.length}`);
+      if (isDryRun) console.log("Mode: DRY RUN");
+      console.log("");
+    }
+    for (const filePath of files) {
+      const fileName = filePath.split("/").pop() ?? filePath;
+      try {
+        const raw = readFileSync105(filePath, "utf-8");
+        if (!raw.trim()) {
+          stats2.skipped++;
+          skippedEntries.push({ file: fileName, reason: "empty file" });
+          continue;
+        }
+        const { name: name2, description, type, body } = parseMemoryFileFrontmatter(raw);
+        const title = name2 ?? fileName.replace(/\.md$/, "").replace(/-/g, " ");
+        const bodyParts = [description, body].filter(Boolean);
+        const fullText = bodyParts.join("\n\n").trim();
+        if (!fullText) {
+          stats2.skipped++;
+          skippedEntries.push({ file: fileName, reason: "empty body" });
+          continue;
+        }
+        const hash2 = memoryContentHash(title, fullText);
+        if (!isDryRun && importedHashes.has(hash2)) {
+          stats2.skipped++;
+          skippedEntries.push({ file: fileName, reason: `already imported (hash: ${hash2})` });
+          if (!isJson) console.log(`  [SKIP] ${fileName}`);
+          continue;
+        }
+        const entryType = type ?? "project";
+        if (!isJson) {
+          const prefix = isDryRun ? "[DRY-RUN]" : "[IMPORT]";
+          console.log(`  ${prefix} ${fileName} (type: ${entryType})`);
+        }
+        if (!isDryRun) {
+          if (entryType === "feedback") {
+            await dispatchFromCli(
+              "mutate",
+              "memory",
+              "learning.store",
+              {
+                insight: `[MIGRATED] ${title}: ${fullText}`,
+                source: "manual",
+                confidence: 0.8,
+                actionable: false
+              },
+              { command: "memory", operation: "memory.learning.store" }
+            );
+          } else {
+            const observeType = entryType === "project" ? "feature" : entryType === "reference" ? "discovery" : entryType === "user" ? "change" : "discovery";
+            await dispatchFromCli(
+              "mutate",
+              "memory",
+              "observe",
+              {
+                text: `[MIGRATED] ${title}: ${fullText}`,
+                title: `[MIGRATED] ${title}`,
+                type: observeType,
+                sourceType: "manual"
+              },
+              { command: "memory", operation: "memory.observe" }
+            );
+          }
+          importedHashes.add(hash2);
+        }
+        stats2.imported++;
+        importedEntries.push({ file: fileName, type: entryType, title });
+      } catch (err) {
+        stats2.errors++;
+        const message = err instanceof Error ? err.message : String(err);
+        errorEntries.push({ file: fileName, error: message });
+        if (!isJson) console.error(`  [ERROR] ${fileName}: ${message}`);
+      }
+    }
+    if (!isDryRun) {
+      saveImportHashes(stateFile, importedHashes);
+    }
+    if (isJson) {
+      console.log(
+        JSON.stringify(
+          {
+            success: stats2.errors === 0,
+            data: {
+              ...stats2,
+              dryRun: isDryRun,
+              imported: importedEntries,
+              skipped: skippedEntries,
+              errors: errorEntries
+            },
+            meta: {
+              operation: "memory.import",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log("");
+      console.log("=== Import Complete ===");
+      console.log(`Total:   ${stats2.total}`);
+      console.log(`Imported: ${stats2.imported}`);
+      console.log(`Skipped:  ${stats2.skipped}`);
+      console.log(`Errors:   ${stats2.errors}`);
+    }
+    if (stats2.errors > 0) process.exit(1);
+  });
 }
 
 // packages/cleo/src/cli/commands/migrate-claude-mem.ts
@@ -141344,17 +142954,17 @@ function registerNexusCommand(program) {
     const autoRegister = !!opts["autoRegister"];
     const includeExisting = !!opts["includeExisting"];
     const maxDepth = Math.max(1, Math.min(opts["maxDepth"] ?? 4, 20));
-    const { homedir: homedir8 } = await import("node:os");
-    const home = homedir8();
+    const { homedir: homedir9 } = await import("node:os");
+    const home = homedir9();
     const defaultRoots = [path10.join(home, "code"), path10.join(home, "projects"), "/mnt/projects"];
     const rawRoots = typeof opts["roots"] === "string" && opts["roots"].trim().length > 0 ? opts["roots"].split(",").map((r) => r.trim()).filter((r) => r.length > 0).map(
       (r) => r.startsWith("~") ? path10.join(home, r.slice(1)) : path10.resolve(r)
     ) : defaultRoots;
-    const { existsSync: existsSync135, readdirSync: readdirSync42, statSync: statSync22 } = await import("node:fs");
+    const { existsSync: existsSync136, readdirSync: readdirSync43, statSync: statSync22 } = await import("node:fs");
     const { Dirent } = await import("node:fs");
     const roots = rawRoots.filter((r) => {
       try {
-        return existsSync135(r) && statSync22(r).isDirectory();
+        return existsSync136(r) && statSync22(r).isDirectory();
       } catch {
         return false;
       }
@@ -141395,7 +143005,7 @@ function registerNexusCommand(program) {
       if (depth > maxDepth) return [];
       let entries;
       try {
-        entries = readdirSync42(dir, { withFileTypes: true });
+        entries = readdirSync43(dir, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -141938,8 +143548,8 @@ function registerNexusCommand(program) {
         return;
       }
       if (outputFile) {
-        const { writeFileSync: writeFileSync26 } = await import("node:fs");
-        writeFileSync26(outputFile, output, "utf-8");
+        const { writeFileSync: writeFileSync27 } = await import("node:fs");
+        writeFileSync27(outputFile, output, "utf-8");
         process.stdout.write(
           `[nexus] Exported to ${outputFile} (${nodes.length} nodes, ${relations.length} edges)
 `
@@ -143771,7 +145381,7 @@ init_src();
 init_internal();
 import { execFile as execFile7 } from "node:child_process";
 import { readFile as readFile23 } from "node:fs/promises";
-import { join as join132 } from "node:path";
+import { join as join133 } from "node:path";
 import * as readline2 from "node:readline";
 import { promisify as promisify7 } from "node:util";
 init_renderers();
@@ -143780,7 +145390,7 @@ var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome();
   try {
-    const content = await readFile23(join132(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile23(join133(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -143834,7 +145444,7 @@ async function writeRuntimeVersionMetadata(mode, source, version2) {
   ];
   await import("node:fs/promises").then(
     ({ writeFile: writeFile15, mkdir: mkdir20 }) => mkdir20(cleoHome, { recursive: true }).then(
-      () => writeFile15(join132(cleoHome, "VERSION"), `${lines.join("\n")}
+      () => writeFile15(join133(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8")
     )
   );
@@ -144887,10 +146497,10 @@ function registerSyncCommand(program) {
     "How to resolve conflicts: keep-cleo, keep-external, or newest (default: keep-cleo)",
     "keep-cleo"
   ).action(async (file2, opts) => {
-    const { readFileSync: readFileSync107 } = await import("node:fs");
+    const { readFileSync: readFileSync108 } = await import("node:fs");
     let externalTasks;
     try {
-      externalTasks = JSON.parse(readFileSync107(file2, "utf8"));
+      externalTasks = JSON.parse(readFileSync108(file2, "utf8"));
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.error(`Failed to read or parse external tasks file: ${message}`);
@@ -144986,11 +146596,11 @@ function registerTestingCommand(program) {
 init_internal();
 init_cli();
 init_renderers();
-import { readFileSync as readFileSync105 } from "node:fs";
+import { readFileSync as readFileSync106 } from "node:fs";
 function readPayload(opts, textKey, fileKey) {
   const text3 = opts[textKey];
   const file2 = opts[fileKey];
-  if (file2) return readFileSync105(file2, "utf-8");
+  if (file2) return readFileSync106(file2, "utf-8");
   return text3;
 }
 function registerTokenCommand(program) {
@@ -145240,16 +146850,16 @@ init_src3();
 init_renderers();
 import { execFileSync as execFileSync18, spawn as spawn2 } from "node:child_process";
 import { mkdir as mkdir19, open, readFile as readFile24, rm as rm3, stat as stat3, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join133 } from "node:path";
+import { join as join134 } from "node:path";
 var DEFAULT_PORT = 3456;
 var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome();
   return {
-    pidFile: join133(cleoHome, "web-server.pid"),
-    configFile: join133(cleoHome, "web-server.json"),
-    logDir: join133(cleoHome, "logs"),
-    logFile: join133(cleoHome, "logs", "web-server.log")
+    pidFile: join134(cleoHome, "web-server.pid"),
+    configFile: join134(cleoHome, "web-server.json"),
+    logDir: join134(cleoHome, "logs"),
+    logFile: join134(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -145281,99 +146891,99 @@ async function getStatus() {
     return { running: false, pid: null, port: null, host: null, url: null };
   }
 }
+async function startWebServer(port, host) {
+  const { pidFile, configFile, logFile, logDir } = getWebPaths();
+  const status = await getStatus();
+  if (status.running) {
+    throw new CleoError(1 /* GENERAL_ERROR */, `Server already running (PID: ${status.pid})`);
+  }
+  const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
+  const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join134(projectRoot, "packages", "studio", "build");
+  await mkdir19(logDir, { recursive: true });
+  await writeFile14(
+    configFile,
+    JSON.stringify({
+      port,
+      host,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  );
+  const webIndexPath = join134(studioDir, "index.js");
+  try {
+    await stat3(webIndexPath);
+  } catch {
+    try {
+      execFileSync18("pnpm", ["--filter", "@cleocode/studio", "run", "build"], {
+        cwd: projectRoot,
+        stdio: "ignore"
+      });
+    } catch {
+      throw new CleoError(
+        1 /* GENERAL_ERROR */,
+        `Studio build failed. Run: pnpm --filter @cleocode/studio run build
+Logs: ${logFile}`
+      );
+    }
+  }
+  const logFileHandle = await open(logFile, "a");
+  const serverProcess = spawn2("node", [webIndexPath], {
+    cwd: studioDir,
+    env: {
+      ...process.env,
+      HOST: host,
+      PORT: String(port),
+      // Pass CLEO paths through to the studio server
+      CLEO_ROOT: projectRoot
+    },
+    detached: true,
+    stdio: ["ignore", logFileHandle.fd, logFileHandle.fd]
+  });
+  serverProcess.unref();
+  const pidFileTmp = `${pidFile}.tmp`;
+  await writeFile14(pidFileTmp, String(serverProcess.pid));
+  await rm3(pidFile, { force: true });
+  await writeFile14(pidFile, String(serverProcess.pid));
+  await rm3(pidFileTmp, { force: true });
+  await logFileHandle.close();
+  const maxAttempts = 30;
+  let started = false;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(`http://${host}:${port}/api/health`);
+      if (response.ok) {
+        started = true;
+        break;
+      }
+    } catch {
+    }
+    await new Promise((resolve17) => setTimeout(resolve17, 500));
+  }
+  if (!started) {
+    try {
+      process.kill(serverProcess.pid);
+    } catch {
+    }
+    await rm3(pidFile, { force: true });
+    throw new CleoError(1 /* GENERAL_ERROR */, "Server failed to start within 15 seconds");
+  }
+  cliOutput(
+    {
+      pid: serverProcess.pid,
+      port,
+      host,
+      url: `http://${host}:${port}`,
+      logFile
+    },
+    { command: "web", message: `CLEO Web UI running on port ${port}` }
+  );
+}
 function registerWebCommand(program) {
   const webCmd = program.command("web").description("Manage CLEO Web UI server");
   webCmd.command("start").description("Start the web server").option("--port <port>", "Server port", String(DEFAULT_PORT)).option("--host <host>", "Server host", DEFAULT_HOST).action(async (opts) => {
     try {
       const port = parseInt(opts["port"], 10);
       const host = opts["host"];
-      const { pidFile, configFile, logFile, logDir } = getWebPaths();
-      const status = await getStatus();
-      if (status.running) {
-        throw new CleoError(
-          1 /* GENERAL_ERROR */,
-          `Server already running (PID: ${status.pid})`
-        );
-      }
-      const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-      const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join133(projectRoot, "packages", "studio", "build");
-      await mkdir19(logDir, { recursive: true });
-      await writeFile14(
-        configFile,
-        JSON.stringify({
-          port,
-          host,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-      const webIndexPath = join133(studioDir, "index.js");
-      try {
-        await stat3(webIndexPath);
-      } catch {
-        try {
-          execFileSync18("pnpm", ["--filter", "@cleocode/studio", "run", "build"], {
-            cwd: projectRoot,
-            stdio: "ignore"
-          });
-        } catch {
-          throw new CleoError(
-            1 /* GENERAL_ERROR */,
-            `Studio build failed. Run: pnpm --filter @cleocode/studio run build
-Logs: ${logFile}`
-          );
-        }
-      }
-      const logFileHandle = await open(logFile, "a");
-      const serverProcess = spawn2("node", [webIndexPath], {
-        cwd: studioDir,
-        env: {
-          ...process.env,
-          HOST: host,
-          PORT: String(port),
-          // Pass CLEO paths through to the studio server
-          CLEO_ROOT: projectRoot
-        },
-        detached: true,
-        stdio: ["ignore", logFileHandle.fd, logFileHandle.fd]
-      });
-      serverProcess.unref();
-      const pidFileTmp = `${pidFile}.tmp`;
-      await writeFile14(pidFileTmp, String(serverProcess.pid));
-      await rm3(pidFile, { force: true });
-      await writeFile14(pidFile, String(serverProcess.pid));
-      await rm3(pidFileTmp, { force: true });
-      await logFileHandle.close();
-      const maxAttempts = 30;
-      let started = false;
-      for (let i = 0; i < maxAttempts; i++) {
-        try {
-          const response = await fetch(`http://${host}:${port}/api/health`);
-          if (response.ok) {
-            started = true;
-            break;
-          }
-        } catch {
-        }
-        await new Promise((resolve17) => setTimeout(resolve17, 500));
-      }
-      if (!started) {
-        try {
-          process.kill(serverProcess.pid);
-        } catch {
-        }
-        await rm3(pidFile, { force: true });
-        throw new CleoError(1 /* GENERAL_ERROR */, "Server failed to start within 15 seconds");
-      }
-      cliOutput(
-        {
-          pid: serverProcess.pid,
-          port,
-          host,
-          url: `http://${host}:${port}`,
-          logFile
-        },
-        { command: "web", message: `CLEO Web UI running on port ${port}` }
-      );
+      await startWebServer(port, host);
     } catch (err) {
       if (err instanceof CleoError) {
         console.error(formatError3(err));
@@ -145452,16 +147062,9 @@ Logs: ${logFile}`
         }
         await rm3(pidFile, { force: true });
       }
-      const port = opts["port"] ?? String(DEFAULT_PORT);
+      const port = parseInt(opts["port"] ?? String(DEFAULT_PORT), 10);
       const host = opts["host"] ?? DEFAULT_HOST;
-      const startOpts = { port, host };
-      const startCmd = webCmd.commands.find((c) => c.name() === "start");
-      const startAction = startCmd?.action;
-      if (startAction) {
-        await startAction(startOpts);
-      } else {
-        throw new CleoError(1 /* GENERAL_ERROR */, "Could not restart server");
-      }
+      await startWebServer(port, host);
     } catch (err) {
       if (err instanceof CleoError) {
         console.error(formatError3(err));
@@ -145535,9 +147138,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartOutline: smartOutline2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-        const { join: join135 } = await import("node:path");
+        const { join: join136 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join135(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join136(root, args.file);
         const result = smartOutline2(absPath, root);
         if (result.errors.length > 0 && result.symbols.length === 0) {
           console.error(`Error: ${result.errors.join(", ")}`);
@@ -145603,9 +147206,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartUnfold: smartUnfold2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-        const { join: join135 } = await import("node:path");
+        const { join: join136 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join135(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join136(root, args.file);
         const result = smartUnfold2(absPath, args.symbol, root);
         if (!result.found) {
           console.error(`Symbol "${args.symbol}" not found in ${args.file}`);
@@ -145624,8 +147227,8 @@ var codeCommand = defineCommand({
 
 // packages/cleo/src/cli/index.ts
 function getPackageVersion() {
-  const pkgPath = join134(dirname31(fileURLToPath8(import.meta.url)), "../../package.json");
-  const pkg = JSON.parse(readFileSync106(pkgPath, "utf-8"));
+  const pkgPath = join135(dirname31(fileURLToPath8(import.meta.url)), "../../package.json");
+  const pkg = JSON.parse(readFileSync107(pkgPath, "utf-8"));
   return pkg.version;
 }
 var CLI_VERSION = getPackageVersion();