@cleocode/cleo 2026.4.60 → 2026.4.62

package/dist/cli/index.js

@@ -1931,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);
@@ -1939,7 +1939,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join135;
+      _sql.join = join136;
       function identifier(value) {
         return new Name(value);
       }
@@ -6713,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)) {
@@ -7998,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}`);
@@ -8009,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,
@@ -8023,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)}`;
@@ -8422,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({
@@ -15271,48 +15271,6 @@ 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");
-  }
-  for (const table of [
-    "brain_decisions",
-    "brain_patterns",
-    "brain_learnings",
-    "brain_observations"
-  ]) {
-    ensureColumns(
-      nativeDb,
-      table,
-      [
-        { 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" }
-      ],
-      "brain"
-    );
-  }
   if (tableExists(nativeDb, "brain_page_edges")) {
     nativeDb.prepare(
       `UPDATE brain_page_edges
@@ -16567,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) {
@@ -46914,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();
@@ -46928,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 {
@@ -46942,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
@@ -46970,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 prepareUpdateEdgeLtp = nativeDb.prepare(
+    `UPDATE brain_page_edges
+     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 prepareUpdateEdge = nativeDb.prepare(
+  const prepareUpdateEdgeLtd = nativeDb.prepare(
     `UPDATE brain_page_edges
-     SET weight = MAX(?, MIN(?, weight + ?))
+     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 {
         }
       }
@@ -47101,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;
   }
@@ -47358,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,
@@ -47421,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 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 9 STDP plasticity failed:", err);
+    console.warn("[consolidation] Step 9e consolidation event log failed:", err);
   }
   return result;
 }
@@ -47587,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);
@@ -47595,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++;
@@ -57185,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);
@@ -65289,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 "";
@@ -66996,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;
@@ -67083,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;
   }
 });
@@ -67214,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;
@@ -67326,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";
@@ -67336,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",
@@ -76910,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)) {
@@ -80878,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 {
@@ -88706,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();
@@ -92175,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;
@@ -101333,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.`
@@ -113993,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,
@@ -114065,6 +114935,7 @@ __export(internal_exports, {
   channelToDistTag: () => channelToDistTag,
   checkAgentHealth: () => checkAgentHealth2,
   checkAllDependencies: () => checkAllDependencies,
+  checkAndDream: () => checkAndDream,
   checkArchitectureDecisionManifest: () => checkArchitectureDecisionManifest,
   checkArtifactPublishManifest: () => checkArtifactPublishManifest,
   checkConduitDbHealth: () => checkConduitDbHealth,
@@ -114076,6 +114947,7 @@ __export(internal_exports, {
   checkEpicCompleteness: () => checkEpicCompleteness,
   checkGate: () => checkGate,
   checkGlobalSignaldockDbHealth: () => checkGlobalSignaldockDbHealth,
+  checkIdleTrigger: () => checkIdleTrigger,
   checkImplementationManifest: () => checkImplementationManifest,
   checkProvenanceManifest: () => checkProvenanceManifest,
   checkReleaseManifest: () => checkReleaseManifest,
@@ -114089,6 +114961,7 @@ __export(internal_exports, {
   checkStorageMigration: () => checkStorageMigration,
   checkTestingManifest: () => checkTestingManifest,
   checkValidationManifest: () => checkValidationManifest,
+  checkVolumeTrigger: () => checkVolumeTrigger,
   classifyError: () => classifyError,
   classifyProject: () => classifyProject,
   cleanupSessions: () => cleanupSessions,
@@ -114685,6 +115558,7 @@ __export(internal_exports, {
   snapshot: () => snapshot_exports,
   spawn: () => spawn_exports,
   spawnRegistry: () => spawnRegistry,
+  startDreamScheduler: () => startDreamScheduler,
   startParallelExecution: () => startParallelExecution,
   startPhase: () => startPhase,
   startSession: () => startSession,
@@ -114692,6 +115566,7 @@ __export(internal_exports, {
   startupHealthCheck: () => startupHealthCheck,
   stats: () => stats_exports,
   sticky: () => sticky_exports,
+  stopDreamScheduler: () => stopDreamScheduler,
   stopTask: () => stopTask,
   storeDetectedPattern: () => storeDetectedPattern,
   storeHealingStrategy: () => storeHealingStrategy,
@@ -114726,6 +115601,7 @@ __export(internal_exports, {
   tokenUsageTransportSchema: () => tokenUsageTransportSchema,
   touchLink: () => touchLink,
   trackMemoryUsage: () => trackMemoryUsage,
+  triggerManualDream: () => triggerManualDream,
   ui: () => ui_exports,
   uncancelTask: () => uncancelTask,
   unpackBundle: () => unpackBundle,
@@ -114813,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();
@@ -122185,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);
@@ -122271,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 {
@@ -127880,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];
@@ -127904,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];
@@ -132554,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
@@ -134057,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
@@ -134113,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(
@@ -134122,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
           }
         },
@@ -134202,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);
@@ -134223,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;
@@ -134620,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);
@@ -134641,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,
@@ -135265,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,
@@ -135290,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",
@@ -135312,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) {
@@ -135333,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);
@@ -135351,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(
           {
@@ -135370,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));
@@ -135431,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,
@@ -135449,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,
@@ -135490,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));
           }
         }
       };
@@ -135525,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);
@@ -135585,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,
@@ -135607,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,
@@ -135616,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");
@@ -137509,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}`);
@@ -139956,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(
@@ -140371,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
@@ -141828,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;
       }
@@ -141879,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 [];
       }
@@ -142422,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)
 `
@@ -144255,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();
@@ -144264,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";
@@ -144318,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")
     )
   );
@@ -145371,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}`);
@@ -145470,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) {
@@ -145724,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) {
@@ -145765,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));
@@ -145936,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));
@@ -146019,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(", ")}`);
@@ -146087,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}`);
@@ -146108,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();