@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-GYIX2HLD.js

@@ -0,0 +1,81 @@
+// src/bin/fast-db-init.ts
+async function fastDbInit() {
+  const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
+  if (isInitialized()) {
+    return getClient();
+  }
+  const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
+  if (!forceDirect) {
+    try {
+      const { connectEmbedDaemon, sendDaemonRequest, isClientConnected, disconnectClient } = await import("./lib/exe-daemon-client.js");
+      const { deserializeResultSet } = await import("./daemon-protocol-XW2OLNBS.js");
+      await Promise.race([
+        connectEmbedDaemon(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Daemon socket timeout (2s)")), 2e3))
+      ]);
+      if (isClientConnected()) {
+        const daemonClient = {
+          async execute(stmt) {
+            const sql = typeof stmt === "string" ? stmt : stmt.sql;
+            const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+            const resp = await sendDaemonRequest({ type: "db-execute", sql, args });
+            if (resp.error) throw new Error(String(resp.error));
+            if (resp.db) return deserializeResultSet(resp.db);
+            throw new Error("Unexpected daemon response");
+          },
+          async batch(stmts, mode) {
+            const statements = stmts.map((s) => {
+              const sql = typeof s === "string" ? s : s.sql;
+              const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+              return { sql, args };
+            });
+            const resp = await sendDaemonRequest({ type: "db-batch", statements, mode: mode ?? "deferred" });
+            if (resp.error) throw new Error(String(resp.error));
+            const batchResults = resp["db-batch"];
+            if (batchResults) return batchResults.map(deserializeResultSet);
+            throw new Error("Unexpected daemon batch response");
+          },
+          async transaction(_mode) {
+            throw new Error("Transactions not supported via daemon socket");
+          },
+          async executeMultiple(_sql) {
+            throw new Error("executeMultiple not supported via daemon socket");
+          },
+          async migrate(_stmts) {
+            throw new Error("migrate not supported via daemon socket");
+          },
+          sync() {
+            return Promise.resolve(void 0);
+          },
+          close() {
+          },
+          get closed() {
+            return false;
+          },
+          get protocol() {
+            return "file";
+          }
+        };
+        try {
+          await daemonClient.execute("SELECT 1");
+        } catch {
+          try {
+            disconnectClient();
+          } catch {
+          }
+          throw new Error("Daemon socket validation failed");
+        }
+        setExternalClient(daemonClient);
+        return daemonClient;
+      }
+    } catch {
+    }
+  }
+  const { initStore } = await import("./lib/store.js");
+  await initStore({ lightweight: true });
+  return getClient();
+}
+
+export {
+  fastDbInit
+};

package/dist/chunk-H4LLEQ3F.js

@@ -0,0 +1,551 @@
+import {
+  sessionScopeFilter
+} from "./chunk-5M5RYJ22.js";
+import {
+  getClient,
+  getIdentity
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/dreaming.ts
+var DreamingEngine = class {
+  /**
+   * Gather recent work artifacts for analysis.
+   */
+  async reviewRecentWork(agentId, hours = 24) {
+    const client = getClient();
+    const now = /* @__PURE__ */ new Date();
+    const start = new Date(now.getTime() - hours * 60 * 60 * 1e3);
+    const startISO = start.toISOString();
+    const endISO = now.toISOString();
+    const memResult = await client.execute({
+      sql: `SELECT id, agent_id, raw_text, memory_type, importance, timestamp, project_name
+            FROM memories
+            WHERE agent_id = ? AND timestamp >= ? AND (status IS NULL OR status != 'deleted')
+            ORDER BY timestamp DESC
+            LIMIT 200`,
+      args: [agentId, startISO]
+    });
+    const memories = memResult.rows.map((r) => ({
+      id: String(r.id),
+      agent_id: String(r.agent_id),
+      text: String(r.raw_text ?? ""),
+      memory_type: String(r.memory_type ?? "raw"),
+      importance: Number(r.importance ?? 0),
+      created_at: String(r.timestamp ?? ""),
+      project_name: r.project_name ? String(r.project_name) : null
+    }));
+    const scope = sessionScopeFilter();
+    const taskResult = await client.execute({
+      sql: `SELECT id, title, status, assigned_to, result, created_at, updated_at, project_name
+            FROM tasks
+            WHERE assigned_to = ? AND updated_at >= ?${scope.sql}
+            ORDER BY updated_at DESC
+            LIMIT 100`,
+      args: [agentId, startISO, ...scope.args]
+    });
+    const tasks = taskResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title ?? ""),
+      status: String(r.status ?? ""),
+      assigned_to: String(r.assigned_to ?? ""),
+      result: r.result ? String(r.result) : null,
+      created_at: String(r.created_at),
+      updated_at: String(r.updated_at),
+      project_name: r.project_name ? String(r.project_name) : null
+    }));
+    const behaviorResult = await client.execute({
+      sql: `SELECT id, agent_id, domain, content, priority, created_at
+            FROM behaviors
+            WHERE agent_id = ? AND created_at >= ? AND active = 1
+            ORDER BY created_at DESC
+            LIMIT 50`,
+      args: [agentId, startISO]
+    });
+    const behaviors = behaviorResult.rows.map((r) => ({
+      id: String(r.id),
+      agent_id: String(r.agent_id),
+      domain: r.domain ? String(r.domain) : null,
+      content: String(r.content ?? ""),
+      priority: String(r.priority ?? "p1"),
+      created_at: String(r.created_at)
+    }));
+    let investigations = [];
+    try {
+      const invResult = await client.execute({
+        sql: `SELECT investigation_key,
+                     COUNT(*) as total,
+                     SUM(CASE WHEN result != 'pass' THEN 1 ELSE 0 END) as failed,
+                     SUM(CASE WHEN result != 'pass' THEN duration_ms ELSE 0 END) as wasted_ms,
+                     failure_category
+              FROM investigation_attempts
+              WHERE agent_id = ? AND timestamp >= ?
+              GROUP BY investigation_key
+              ORDER BY failed DESC
+              LIMIT 20`,
+        args: [agentId, startISO]
+      });
+      const invMap = /* @__PURE__ */ new Map();
+      const catCounts = /* @__PURE__ */ new Map();
+      for (const r of invResult.rows) {
+        const key = String(r.investigation_key ?? "");
+        if (!invMap.has(key)) {
+          invMap.set(key, {
+            investigationKey: key,
+            totalAttempts: Number(r.total ?? 0),
+            failedAttempts: Number(r.failed ?? 0),
+            topFailureCategory: String(r.failure_category ?? "unknown"),
+            wastedMs: Number(r.wasted_ms ?? 0)
+          });
+        }
+        const cat = String(r.failure_category ?? "unknown");
+        if (!catCounts.has(key)) catCounts.set(key, /* @__PURE__ */ new Map());
+        catCounts.get(key).set(cat, (catCounts.get(key).get(cat) ?? 0) + Number(r.failed ?? 0));
+      }
+      for (const [key, rec] of invMap) {
+        const cats = catCounts.get(key);
+        if (cats) {
+          let topCat = "unknown";
+          let topCount = 0;
+          for (const [cat, count] of cats) {
+            if (count > topCount) {
+              topCat = cat;
+              topCount = count;
+            }
+          }
+          rec.topFailureCategory = topCat;
+        }
+      }
+      investigations = Array.from(invMap.values());
+    } catch {
+    }
+    return {
+      memories,
+      tasks,
+      behaviors,
+      investigations,
+      period: { start: startISO, end: endISO }
+    };
+  }
+  /**
+   * Analyze work review for recurring patterns.
+   */
+  identifyPatterns(review) {
+    const patterns = [];
+    const investigations = review.investigations ?? [];
+    const errorTasks = review.tasks.filter(
+      (t) => /\b(fix|bug|error|fail|broken|crash|revert)\b/i.test(t.title) || t.result && /\b(error|failed|broken|crash)\b/i.test(t.result)
+    );
+    if (errorTasks.length >= 2) {
+      patterns.push({
+        type: "mistake",
+        description: `Repeated error/fix tasks detected (${errorTasks.length} in period)`,
+        evidence: errorTasks.map((t) => `Task "${t.title}" (${t.status})`),
+        frequency: errorTasks.length,
+        confidence: Math.min(0.5 + errorTasks.length * 0.1, 1)
+      });
+    }
+    const completedTasks = review.tasks.filter(
+      (t) => t.status === "done" || t.status === "closed" || t.status === "needs_review"
+    );
+    if (completedTasks.length >= 3) {
+      patterns.push({
+        type: "success",
+        description: `High task completion rate: ${completedTasks.length} tasks completed in review period`,
+        evidence: completedTasks.map((t) => `"${t.title}" (${t.status})`),
+        frequency: completedTasks.length,
+        confidence: 0.8
+      });
+    }
+    const questionMemories = review.memories.filter(
+      (m) => /\b(how do|what is|where is|can't find|unclear|confused|don't know)\b/i.test(m.text)
+    );
+    if (questionMemories.length >= 3) {
+      patterns.push({
+        type: "gap",
+        description: `Knowledge gaps detected: ${questionMemories.length} uncertainty signals in memories`,
+        evidence: questionMemories.slice(0, 5).map((m) => m.text.slice(0, 120)),
+        frequency: questionMemories.length,
+        confidence: Math.min(0.4 + questionMemories.length * 0.1, 0.9)
+      });
+    }
+    if (review.behaviors.length >= 5) {
+      patterns.push({
+        type: "inefficiency",
+        description: `High behavior churn: ${review.behaviors.length} new behaviors in period (suggests unstable workflow)`,
+        evidence: review.behaviors.map((b) => `[${b.domain ?? "general"}] ${b.content.slice(0, 80)}`),
+        frequency: review.behaviors.length,
+        confidence: Math.min(0.5 + review.behaviors.length * 0.05, 0.9)
+      });
+    }
+    const blockedTasks = review.tasks.filter(
+      (t) => t.status === "blocked" || t.status === "cancelled"
+    );
+    if (blockedTasks.length >= 2) {
+      patterns.push({
+        type: "inefficiency",
+        description: `${blockedTasks.length} tasks blocked or cancelled in period`,
+        evidence: blockedTasks.map((t) => `"${t.title}" (${t.status})`),
+        frequency: blockedTasks.length,
+        confidence: 0.7
+      });
+    }
+    if (investigations.length > 0) {
+      const catTotals = /* @__PURE__ */ new Map();
+      let totalFailed = 0;
+      let totalAttempts = 0;
+      let totalWastedMs = 0;
+      for (const inv of investigations) {
+        totalAttempts += inv.totalAttempts;
+        totalFailed += inv.failedAttempts;
+        totalWastedMs += inv.wastedMs;
+        catTotals.set(inv.topFailureCategory, (catTotals.get(inv.topFailureCategory) ?? 0) + inv.failedAttempts);
+      }
+      if (totalAttempts > 0 && totalFailed / totalAttempts > 0.5) {
+        patterns.push({
+          type: "mistake",
+          description: `Investigation failure rate: ${Math.round(totalFailed / totalAttempts * 100)}% of ${totalAttempts} attempts failed (${Math.round(totalWastedMs / 6e4)}min wasted)`,
+          evidence: investigations.map((i) => `${i.investigationKey}: ${i.failedAttempts}/${i.totalAttempts} failed (${i.topFailureCategory})`),
+          frequency: totalFailed,
+          confidence: Math.min(0.6 + totalFailed * 0.05, 0.95)
+        });
+      }
+      const sortedCats = Array.from(catTotals.entries()).sort(([, a], [, b]) => b - a);
+      if (sortedCats.length > 0 && sortedCats[0][1] >= 2) {
+        const [topCat, topCount] = sortedCats[0];
+        patterns.push({
+          type: "inefficiency",
+          description: `Top debugging failure: "${topCat}" (${topCount} times). ${topCat === "lack_of_context" ? "Agent didn't have enough code context before editing" : topCat === "lack_of_tools" ? "Agent couldn't verify the fix (missing tools)" : topCat === "lack_of_reasoning" ? "Agent had the info but drew wrong conclusion" : topCat === "lack_of_measurement" ? "Agent tested the wrong thing (API vs browser)" : topCat === "wrong_diagnosis" ? "Agent misidentified the root cause" : "Recurring failure pattern"}`,
+          evidence: investigations.filter((i) => i.topFailureCategory === topCat).map((i) => `${i.investigationKey}: ${i.failedAttempts} failed attempts`),
+          frequency: topCount,
+          confidence: Math.min(0.7 + topCount * 0.05, 0.95)
+        });
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Generate behavior proposals for high-confidence patterns.
+   */
+  proposeBehaviors(patterns) {
+    const proposals = [];
+    for (const pattern of patterns) {
+      if (pattern.confidence < 0.7) continue;
+      switch (pattern.type) {
+        case "mistake":
+          proposals.push({
+            text: `Before implementing fixes, verify the root cause with tests \u2014 ${pattern.evidence.length} fix cycles detected recently.`,
+            priority: "p1",
+            domain: "workflow",
+            rationale: `Pattern: ${pattern.description}`,
+            source_pattern: pattern
+          });
+          break;
+        case "gap":
+          proposals.push({
+            text: `Document solutions immediately after resolving uncertainties \u2014 ${pattern.frequency} knowledge gaps detected.`,
+            priority: "p1",
+            domain: "workflow",
+            rationale: `Pattern: ${pattern.description}`,
+            source_pattern: pattern
+          });
+          break;
+        case "inefficiency":
+          if (pattern.description.includes("lack_of_context")) {
+            proposals.push({
+              text: "Before editing any file for a bug fix, run code_context(action='search') and code_context(action='trace') to understand the full call chain. You've been editing without enough context.",
+              priority: "p0",
+              domain: "investigation",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else if (pattern.description.includes("lack_of_measurement")) {
+            proposals.push({
+              text: "After every fix, test the ACTUAL user flow (playwright for frontend, curl for API) \u2014 not just the build. You've been testing at the wrong level.",
+              priority: "p0",
+              domain: "investigation",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else if (pattern.description.includes("lack_of_tools")) {
+            proposals.push({
+              text: "You lack verification tools for this type of work. Before starting, check: do you have playwright for browser testing? curl for API testing? Access to logs? Request what you need before guessing.",
+              priority: "p0",
+              domain: "investigation",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else if (pattern.description.includes("lack_of_reasoning")) {
+            proposals.push({
+              text: "Trace the actual execution path step-by-step instead of guessing from code reading. Read the logs, add console.log, check the actual HTTP request \u2014 don't reason about what SHOULD happen.",
+              priority: "p0",
+              domain: "investigation",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else if (pattern.description.includes("wrong_diagnosis")) {
+            proposals.push({
+              text: "Run blast_radius before editing. Your diagnoses are hitting the wrong target. Understand what the change affects across the full dependency chain before committing to a fix.",
+              priority: "p0",
+              domain: "investigation",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else if (pattern.description.includes("behavior churn")) {
+            proposals.push({
+              text: `Review existing behaviors before creating new ones \u2014 high churn detected (${pattern.frequency} in period).`,
+              priority: "p1",
+              domain: "workflow",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          } else {
+            proposals.push({
+              text: `Identify and surface blockers earlier \u2014 ${pattern.frequency} blocked/cancelled tasks detected.`,
+              priority: "p1",
+              domain: "workflow",
+              rationale: `Pattern: ${pattern.description}`,
+              source_pattern: pattern
+            });
+          }
+          break;
+        case "success":
+          proposals.push({
+            text: `Continue current approach \u2014 high completion rate (${pattern.frequency} tasks) indicates effective workflow.`,
+            priority: "p2",
+            domain: "workflow",
+            rationale: `Pattern: ${pattern.description}`,
+            source_pattern: pattern
+          });
+          break;
+      }
+    }
+    return proposals;
+  }
+  /**
+   * Score how far an agent's recent work diverges from their identity definition.
+   *
+   * Heuristic-based: compares identity keywords vs recent memory/task topics.
+   * Score 0.0 = perfectly aligned, 1.0 = completely off-identity.
+   */
+  calculateDrift(agentId, review) {
+    const identity = getIdentity(agentId);
+    if (!identity) {
+      return {
+        score: 0,
+        factors: [{ factor: "no_identity", weight: 0, evidence: "No identity file found \u2014 cannot calculate drift." }],
+        narrative: `No identity file found for ${agentId}. Drift cannot be calculated.`
+      };
+    }
+    const factors = [];
+    const identityText = (identity.body + " " + identity.frontmatter.role + " " + identity.frontmatter.title).toLowerCase();
+    const identityKeywords = new Set(
+      identityText.replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length >= 4)
+    );
+    const workText = [
+      ...review.memories.map((m) => m.text),
+      ...review.tasks.map((t) => t.title + " " + (t.result ?? ""))
+    ].join(" ").toLowerCase();
+    const workWords = new Set(
+      workText.replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length >= 4)
+    );
+    let identityHits = 0;
+    for (const kw of identityKeywords) {
+      if (workWords.has(kw)) identityHits++;
+    }
+    const coverageRatio = identityKeywords.size > 0 ? identityHits / identityKeywords.size : 1;
+    const coverageDrift = 1 - coverageRatio;
+    factors.push({
+      factor: "keyword_coverage",
+      weight: 0.4,
+      evidence: `${identityHits}/${identityKeywords.size} identity keywords found in recent work (${(coverageRatio * 100).toFixed(0)}% coverage)`
+    });
+    const role = identity.frontmatter.role.toLowerCase();
+    const roleWords = role.split(/\s+/).filter((w) => w.length >= 3);
+    let roleMatchCount = 0;
+    for (const task of review.tasks) {
+      const taskLower = (task.title + " " + (task.result ?? "")).toLowerCase();
+      if (roleWords.some((rw) => taskLower.includes(rw))) {
+        roleMatchCount++;
+      }
+    }
+    const roleAlignment = review.tasks.length > 0 ? roleMatchCount / review.tasks.length : 1;
+    const roleDrift = 1 - roleAlignment;
+    factors.push({
+      factor: "role_alignment",
+      weight: 0.4,
+      evidence: `${roleMatchCount}/${review.tasks.length} tasks align with role "${identity.frontmatter.role}" (${(roleAlignment * 100).toFixed(0)}%)`
+    });
+    const offTopicMemories = review.memories.filter((m) => {
+      const mWords = m.text.toLowerCase().split(/\s+/);
+      return !mWords.some((w) => identityKeywords.has(w));
+    });
+    const offTopicRatio = review.memories.length > 0 ? offTopicMemories.length / review.memories.length : 0;
+    factors.push({
+      factor: "off_topic_work",
+      weight: 0.2,
+      evidence: `${offTopicMemories.length}/${review.memories.length} memories have no identity keyword overlap (${(offTopicRatio * 100).toFixed(0)}% off-topic)`
+    });
+    const rawScore = coverageDrift * 0.4 + roleDrift * 0.4 + offTopicRatio * 0.2;
+    const score = Math.max(0, Math.min(1, rawScore));
+    let narrative;
+    if (score < 0.2) {
+      narrative = `${agentId} is well-aligned with their identity. Recent work closely matches role definition.`;
+    } else if (score < 0.5) {
+      narrative = `${agentId} shows moderate drift (${(score * 100).toFixed(0)}%). Some work falls outside identity scope. Review factors for specifics.`;
+    } else {
+      narrative = `${agentId} shows significant drift (${(score * 100).toFixed(0)}%). Much of recent work does not align with identity. Consider reviewing task assignments.`;
+    }
+    return { score, factors, narrative };
+  }
+  /**
+   * Auto-compute calibration scores from completed tasks with assertions + time estimates.
+   * Returns structured calibration data for the dream cycle summary and telemetry.
+   */
+  async computeCalibration(agentId, hours = 24) {
+    const client = getClient();
+    const since = new Date(Date.now() - hours * 60 * 60 * 1e3).toISOString();
+    const report = {
+      assertions: { total: 0, correct: 0, incorrect: 0, partial: 0, byType: {} },
+      estimation: { total: 0, avgRatio: 0, underestimates: 0, overestimates: 0, accurate: 0 },
+      whyWrong: {}
+    };
+    try {
+      const isAllAgents = agentId === "*";
+      const scope = sessionScopeFilter();
+      const tasks = await client.execute({
+        sql: isAllAgents ? `SELECT assertions, estimated_minutes, actual_minutes, estimate_confidence
+             FROM tasks WHERE updated_at >= ?
+             AND status IN ('needs_review', 'closed')
+             AND (assertions IS NOT NULL OR estimated_minutes IS NOT NULL)${scope.sql}` : `SELECT assertions, estimated_minutes, actual_minutes, estimate_confidence
+             FROM tasks WHERE assigned_to = ? AND updated_at >= ?
+             AND status IN ('needs_review', 'closed')
+             AND (assertions IS NOT NULL OR estimated_minutes IS NOT NULL)${scope.sql}`,
+        args: isAllAgents ? [since, ...scope.args] : [agentId, since, ...scope.args]
+      });
+      for (const row of tasks.rows) {
+        try {
+          const data = JSON.parse(String(row.assertions ?? "{}"));
+          const resolved = data.resolved ?? [];
+          for (const r of resolved) {
+            report.assertions.total++;
+            if (r.outcome === "correct") report.assertions.correct++;
+            else if (r.outcome === "incorrect") report.assertions.incorrect++;
+            else if (r.outcome === "partial") report.assertions.partial++;
+            const aType = r.type ?? "unknown";
+            if (!report.assertions.byType[aType]) {
+              report.assertions.byType[aType] = { total: 0, correct: 0 };
+            }
+            report.assertions.byType[aType].total++;
+            if (r.outcome === "correct") report.assertions.byType[aType].correct++;
+            if (r.outcome === "incorrect" && r.why_wrong) {
+              report.whyWrong[r.why_wrong] = (report.whyWrong[r.why_wrong] ?? 0) + 1;
+            }
+          }
+        } catch {
+        }
+        const est = Number(row.estimated_minutes);
+        const actual = Number(row.actual_minutes);
+        if (est > 0 && actual > 0) {
+          report.estimation.total++;
+          const ratio = actual / est;
+          report.estimation.avgRatio += ratio;
+          if (ratio > 1.3) report.estimation.underestimates++;
+          else if (ratio < 0.7) report.estimation.overestimates++;
+          else report.estimation.accurate++;
+        }
+      }
+      if (report.estimation.total > 0) {
+        report.estimation.avgRatio = report.estimation.avgRatio / report.estimation.total;
+      }
+    } catch {
+    }
+    return report;
+  }
+  /**
+   * Run a full dream cycle: review → identify patterns → propose behaviors → drift check → calibration.
+   */
+  async runDreamCycle(agentId, hours = 24) {
+    const review = await this.reviewRecentWork(agentId, hours);
+    const patterns = this.identifyPatterns(review);
+    const proposals = this.proposeBehaviors(patterns);
+    const drift = this.calculateDrift(agentId, review);
+    const calibration = await this.computeCalibration(agentId, hours);
+    const client = getClient();
+    try {
+      const { scoreBehaviors, detectConflicts, measureBehaviorLoad } = await import("./behavior-effectiveness-UP76GMOC.js");
+      const scores = await scoreBehaviors(agentId);
+      const conflicts = await detectConflicts(agentId);
+      await measureBehaviorLoad(agentId);
+      for (const score of scores) {
+        if (score.recommendation === "deactivate") {
+          await client.execute({
+            sql: "UPDATE behaviors SET active = 0, updated_at = ? WHERE id = ?",
+            args: [(/* @__PURE__ */ new Date()).toISOString(), score.behaviorId]
+          });
+        }
+      }
+      const deactivateCount = scores.filter((s) => s.recommendation === "deactivate").length;
+      if (conflicts.length > 0 || deactivateCount > 0) {
+        process.stderr.write(`[dreaming] Behavior health: ${conflicts.length} conflicts, ${deactivateCount} ineffective
+`);
+      }
+    } catch {
+    }
+    const result = {
+      review,
+      patterns,
+      proposals,
+      drift,
+      calibration,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const { randomUUID } = await import("crypto");
+      const id = randomUUID();
+      const calLines = [];
+      if (calibration.assertions.total > 0) {
+        const pct = Math.round(calibration.assertions.correct / calibration.assertions.total * 100);
+        calLines.push(`Assertion accuracy: ${pct}% (${calibration.assertions.correct}/${calibration.assertions.total})`);
+        for (const [type, data] of Object.entries(calibration.assertions.byType)) {
+          const tPct = data.total > 0 ? Math.round(data.correct / data.total * 100) : 0;
+          calLines.push(`  ${type}: ${tPct}% (${data.correct}/${data.total})`);
+        }
+      }
+      if (calibration.estimation.total > 0) {
+        calLines.push(`Time estimation: avg ${calibration.estimation.avgRatio.toFixed(1)}x ratio (${calibration.estimation.accurate} accurate, ${calibration.estimation.underestimates} under, ${calibration.estimation.overestimates} over)`);
+      }
+      if (Object.keys(calibration.whyWrong).length > 0) {
+        calLines.push(`Why wrong: ${Object.entries(calibration.whyWrong).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+      }
+      const summaryText = [
+        `DREAM CYCLE for ${agentId}`,
+        `Period: ${review.period.start} \u2192 ${review.period.end}`,
+        `Memories analyzed: ${review.memories.length}`,
+        `Tasks analyzed: ${review.tasks.length}`,
+        `Patterns found: ${patterns.length}`,
+        `Behavior proposals: ${proposals.length}`,
+        `Drift score: ${drift.score.toFixed(2)} \u2014 ${drift.narrative}`,
+        calLines.length > 0 ? `
+Calibration:
+${calLines.join("\n")}` : "",
+        patterns.length > 0 ? `
+Patterns:
+${patterns.map((p) => `- [${p.type}] ${p.description}`).join("\n")}` : "",
+        proposals.length > 0 ? `
+Proposals:
+${proposals.map((p) => `- [${p.priority}/${p.domain}] ${p.text}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n");
+      await client.execute({
+        sql: `INSERT INTO memories (id, agent_id, raw_text, memory_type, importance, timestamp, status, agent_role, session_id, tool_name, project_name, has_error, version)
+              VALUES (?, ?, ?, 'observation', 7, ?, 'active', 'system', 'dream-cycle', 'dreaming', '', 0, 0)`,
+        args: [id, agentId, summaryText, result.timestamp]
+      });
+    } catch {
+    }
+    return result;
+  }
+};
+
+export {
+  DreamingEngine
+};