@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-NPPQ3TR4.js

@@ -0,0 +1,735 @@
+import {
+  sessionScopeFilter
+} from "./chunk-F5OSXH4A.js";
+import {
+  getClient,
+  getIdentity
+} from "./chunk-XABJRAUW.js";
+import {
+  getEmotionalBaseline
+} from "./chunk-PNQDP3OA.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 };
+  }
+  /**
+   * Score how far an agent's recent communication tone diverges from their
+   * role's emotional baseline.
+   *
+   * Scans recent memories and task results for presence/absence of target
+   * tones and anti-patterns defined in EMOTIONAL_BASELINES.
+   *
+   * Score 0.0 = perfectly on-tone, 1.0 = completely off-tone.
+   */
+  calculateEmotionalDrift(agentId, review) {
+    const identity = getIdentity(agentId);
+    const role = identity?.frontmatter.role ?? agentId;
+    const baseline = getEmotionalBaseline(role);
+    if (!baseline) {
+      return {
+        score: 0,
+        baseline: null,
+        tonesPresent: [],
+        tonesMissing: [],
+        antiPatternsDetected: [],
+        narrative: `No emotional baseline defined for role "${role}". Skipping emotional drift check.`
+      };
+    }
+    const workText = [
+      ...review.memories.map((m) => m.text),
+      ...review.tasks.map((t) => t.title + " " + (t.result ?? ""))
+    ].join(" ").toLowerCase();
+    if (workText.trim().length === 0) {
+      return {
+        score: 0,
+        baseline,
+        tonesPresent: [],
+        tonesMissing: baseline.tone,
+        antiPatternsDetected: [],
+        narrative: `No recent work found for ${agentId}. Cannot assess emotional drift.`
+      };
+    }
+    const TONE_SIGNALS = {
+      calm: ["calm", "measured", "steady", "composed", "clear-headed"],
+      direct: ["direct", "straightforward", "blunt", "upfront", "plainly"],
+      confident: ["confident", "certain", "assertive", "definitive"],
+      decisive: ["decisive", "decided", "committed", "chose", "picked"],
+      precise: ["precise", "exact", "specific", "pinpoint"],
+      technical: ["technical", "implementation", "architecture", "function", "module", "api", "endpoint"],
+      analytical: ["analytical", "analyzed", "compared", "measured", "benchmarked", "evaluated"],
+      creative: ["creative", "innovative", "original", "compelling", "storytelling"],
+      persuasive: ["persuasive", "compelling", "convincing", "engaging"],
+      "brand-conscious": ["brand", "design system", "consistency", "guidelines"],
+      strategic: ["strategic", "strategy", "goal", "objective", "roadmap"],
+      "ownership-oriented": ["ownership", "accountable", "responsible", "own"],
+      pragmatic: ["pragmatic", "practical", "realistic", "achievable"],
+      proactive: ["proactive", "anticipated", "surfaced", "flagged early"],
+      accountable: ["accountable", "ownership", "responsible", "followed through"],
+      terse: ["terse", "brief", "concise", "short"],
+      factual: ["factual", "fact", "evidence", "verified", "confirmed"],
+      focused: ["focused", "scoped", "targeted", "on-track"],
+      "production-focused": ["production", "rendered", "deliverable", "asset", "output"],
+      efficient: ["efficient", "optimized", "fast", "streamlined"],
+      "detail-oriented": ["detail", "checked", "verified", "dimensions", "specifications"],
+      "cost-aware": ["cost", "budget", "credits", "pricing"],
+      "evidence-based": ["evidence", "benchmark", "measured", "data", "metrics"],
+      skeptical: ["skeptical", "questioned", "challenged", "validated"],
+      thorough: ["thorough", "comprehensive", "exhaustive", "covered"],
+      strict: ["strict", "mandatory", "non-negotiable", "enforced"],
+      uncompromising: ["uncompromising", "no exceptions", "mandatory", "must"],
+      systematic: ["systematic", "pattern", "checklist", "audit"],
+      "evidence-driven": ["evidence", "finding", "file:line", "grep", "verified"]
+    };
+    const ANTI_PATTERN_SIGNALS = {
+      sugarcoating: ["sugarcoat", "softened", "downplay", "not that bad"],
+      hedging: ["maybe", "perhaps", "might", "could potentially", "not sure but"],
+      apologetic: ["sorry", "apologize", "my apologies", "forgive"],
+      passive: ["waiting", "monitoring", "will check later", "when available"],
+      vague: ["somehow", "something", "stuff", "things", "various"],
+      "hand-wavy": ["hand-wav", "roughly", "ballpark", "ish", "sort of"],
+      "deferring without opinion": ["up to you", "your call", "whatever you think", "no preference"],
+      "marketing-speak": ["synergy", "leverage", "paradigm", "disrupt", "revolutionary"],
+      "off-brand": ["off-brand", "inconsistent", "doesn't match"],
+      generic: ["generic", "boilerplate", "template-like"],
+      "verbose prose": ["in conclusion", "furthermore", "moreover", "it should be noted"],
+      speculation: ["speculate", "guess", "assume without", "probably means"],
+      "scope creep": ["also added", "while I was there", "bonus", "extra feature"],
+      "excuses for failing tests": ["flaky test", "not my fault", "works locally"],
+      hype: ["game-changer", "revolutionary", "incredible", "amazing"],
+      "rubber-stamping": ["looks good", "lgtm", "ship it", "approved without"],
+      "improvising on brand": ["took creative liberty", "my own spin", "deviated from brief"],
+      "ignoring budget": ["didn't check cost", "budget unknown"],
+      "deflecting responsibility": ["not my area", "someone else", "not my problem"],
+      "vague status updates": ["progressing", "making headway", "things are moving"],
+      "waiting passively": ["waiting on", "blocked by", "nothing I can do"],
+      "over-escalating": ["escalating everything", "need founder input on"]
+    };
+    const tonesPresent = [];
+    const tonesMissing = [];
+    for (const targetTone of baseline.tone) {
+      const signals = TONE_SIGNALS[targetTone] ?? [targetTone];
+      const found = signals.some((signal) => workText.includes(signal));
+      if (found) {
+        tonesPresent.push(targetTone);
+      } else {
+        tonesMissing.push(targetTone);
+      }
+    }
+    const antiPatternsDetected = [];
+    for (const avoidItem of baseline.avoid) {
+      const signals = ANTI_PATTERN_SIGNALS[avoidItem] ?? [avoidItem];
+      const found = signals.some((signal) => workText.includes(signal));
+      if (found) {
+        antiPatternsDetected.push(avoidItem);
+      }
+    }
+    const toneCoverage = baseline.tone.length > 0 ? tonesPresent.length / baseline.tone.length : 1;
+    const toneGap = 1 - toneCoverage;
+    const antiPatternRatio = baseline.avoid.length > 0 ? antiPatternsDetected.length / baseline.avoid.length : 0;
+    const rawScore = toneGap * 0.6 + antiPatternRatio * 0.4;
+    const score = Math.max(0, Math.min(1, rawScore));
+    let narrative;
+    if (score < 0.15) {
+      narrative = `${agentId} is well-aligned with their emotional baseline. Communication tone matches role expectations.`;
+    } else if (score < 0.4) {
+      narrative = `${agentId} shows moderate emotional drift (${(score * 100).toFixed(0)}%).`;
+      if (tonesMissing.length > 0) {
+        narrative += ` Missing tones: ${tonesMissing.join(", ")}.`;
+      }
+      if (antiPatternsDetected.length > 0) {
+        narrative += ` Anti-patterns detected: ${antiPatternsDetected.join(", ")}.`;
+      }
+    } else {
+      narrative = `${agentId} shows significant emotional drift (${(score * 100).toFixed(0)}%).`;
+      if (tonesMissing.length > 0) {
+        narrative += ` Missing tones: ${tonesMissing.join(", ")}.`;
+      }
+      if (antiPatternsDetected.length > 0) {
+        narrative += ` Anti-patterns detected: ${antiPatternsDetected.join(", ")}.`;
+      }
+      narrative += ` Review whether task assignments match this agent's role persona.`;
+    }
+    return {
+      score,
+      baseline,
+      tonesPresent,
+      tonesMissing,
+      antiPatternsDetected,
+      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 emotionalDrift = this.calculateEmotionalDrift(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 {
+    }
+    let overdueProspective = [];
+    try {
+      const { getOverdueProspective, completeProspective } = await import("./prospective-memory-OAFZUODU.js");
+      const overdue = await getOverdueProspective(agentId);
+      overdueProspective = overdue.map((o) => ({
+        id: o.id,
+        content: o.content,
+        dueDate: o.dueDate ?? "",
+        recurrence: o.recurrence,
+        priority: o.priority
+      }));
+      for (const item of overdue) {
+        if (item.recurrence !== "once") {
+          await completeProspective(item.id);
+        }
+      }
+    } catch {
+    }
+    const result = {
+      review,
+      patterns,
+      proposals,
+      drift,
+      emotionalDrift,
+      calibration,
+      overdueProspective,
+      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 emotionalLines = [];
+      if (emotionalDrift.baseline) {
+        emotionalLines.push(`Emotional drift: ${(emotionalDrift.score * 100).toFixed(0)}% \u2014 ${emotionalDrift.narrative}`);
+        if (emotionalDrift.tonesPresent.length > 0) emotionalLines.push(`  Tones present: ${emotionalDrift.tonesPresent.join(", ")}`);
+        if (emotionalDrift.tonesMissing.length > 0) emotionalLines.push(`  Tones missing: ${emotionalDrift.tonesMissing.join(", ")}`);
+        if (emotionalDrift.antiPatternsDetected.length > 0) emotionalLines.push(`  Anti-patterns: ${emotionalDrift.antiPatternsDetected.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}`,
+        `Overdue reminders: ${overdueProspective.length}`,
+        `Drift score: ${drift.score.toFixed(2)} \u2014 ${drift.narrative}`,
+        emotionalLines.length > 0 ? `
+Emotional Baseline:
+${emotionalLines.join("\n")}` : "",
+        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")}` : "",
+        overdueProspective.length > 0 ? `
+Overdue Reminders:
+${overdueProspective.map((o) => `- [P${o.priority}] ${o.content} (due ${o.dueDate}${o.recurrence !== "once" ? `, ${o.recurrence}` : ""})`).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
+};