coding-os 0.3.2__py3-none-any.whl

thinking_os/decay.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""
+Thinking OS — Confidence decay script (TASK-139).
+
+Monthly batch process that applies Ebbinghaus exponential decay
+to learned_patterns confidence. Run via `make thinking_os-decay`.
+
+Features:
+  - Exponential decay: conf * exp(-effective_rate * months)
+  - Anti-forgetting: high-validation, high-impact, recently-accessed
+  - Archive: patterns at floor (0.1) get promoted_to='archived'
+  - Working memory cleanup: expired observations deleted
+"""
+
+from __future__ import annotations
+
+import fcntl
+import logging
+import math
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Ensure db module is importable
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from database import DEFAULT_DB_PATH, get_connection, get_schema_version
+
+from core.logging_os import setup as _logging_os_setup
+
+_logging_os_setup(level="info")
+logger = logging.getLogger("thinking_os.decay")
+
+CONFIDENCE_FLOOR = 0.1
+
+
+# ---------------------------------------------------------------------------
+# Decay formulas
+# ---------------------------------------------------------------------------
+
+
+def effective_decay_rate(
+    *,
+    base_rate: float,
+    times_seen: int,
+    impact_score: float,
+    last_accessed_days: float | None,
+) -> float:
+    """Calculate effective decay rate with anti-forgetting protections.
+
+    Args:
+        base_rate: Pattern's decay_rate column (default 0.1).
+        times_seen: Occurrence count — how established the pattern is. Anti-
+            forgetting keys on established-ness, not validation, so a much-seen
+            pattern survives the honest times_validated reset.
+        impact_score: Digital amygdala score (0.0-1.0).
+        last_accessed_days: Days since last access (None if never accessed).
+
+    Returns:
+        Effective decay rate (may be 0.0 for recently-accessed patterns).
+    """
+    rate = base_rate
+
+    # Deep encoding: frequently-seen (established) patterns decay 70% slower
+    if times_seen >= 5:
+        rate *= 0.3
+
+    # Emotional tag: high-impact patterns decay 50% slower
+    if impact_score >= 0.8:
+        rate *= 0.5
+
+    # Working memory refresh: recently accessed = skip decay
+    if last_accessed_days is not None and last_accessed_days <= 7:
+        rate = 0.0
+
+    return rate
+
+
+def decay_confidence(
+    *,
+    confidence: float,
+    months_since_validated: float,
+    eff_rate: float,
+) -> float:
+    """Apply Ebbinghaus exponential decay.
+
+    Args:
+        confidence: Current confidence value.
+        months_since_validated: Months since last validation.
+        eff_rate: Effective decay rate from effective_decay_rate().
+
+    Returns:
+        Decayed confidence, floored at 0.1.
+    """
+    if eff_rate <= 0.0 or months_since_validated <= 0.0:
+        return confidence
+    return max(CONFIDENCE_FLOOR, confidence * math.exp(-eff_rate * months_since_validated))
+
+
+# ---------------------------------------------------------------------------
+# Batch decay runner
+# ---------------------------------------------------------------------------
+
+
+def _days_since(dt_str: str | None) -> float | None:
+    """Return days since a datetime string, or None if null."""
+    if not dt_str:
+        return None
+    try:
+        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        delta = datetime.now(timezone.utc) - dt
+        return max(0.0, delta.total_seconds() / 86400.0)
+    except (ValueError, TypeError):
+        return None
+
+
+def _marker_age_days(marker: Path) -> float | None:
+    try:
+        st = marker.stat()
+    except OSError:
+        return None
+    return max(0.0, (datetime.now(timezone.utc).timestamp() - st.st_mtime) / 86400.0)
+
+
+def run_decay_locked(
+    db_path: str | Path,
+    *,
+    throttle_days: int = 7,
+    archive_prune_days: int = 90,
+    dry_run: bool = False,
+    marker_path: Path | None = None,
+) -> dict:
+    """Throttled + flock-protected decay — the entry point shared by the nightly
+    job and the session_enrich Stop hook so they never double-decay (one
+    mtime-throttled marker) or race (one exclusive lock). auto-brain-decay
+    debounces on the same ``.last-decay`` marker. The throttle is mtime-based, so
+    the marker file's content format is irrelevant. Marker defaults to
+    ``<db-dir>/.last-decay`` (project-shared, next to the DB)."""
+    path = Path(db_path).resolve()
+    marker = marker_path or (path.parent / ".last-decay")
+    lock_path = marker.with_suffix(".lock")
+    try:
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        logger.warning("decay lock dir error: %s", exc)
+        return {"status": "error", "error": str(exc)}
+    with open(lock_path, "w") as lock_f:
+        try:
+            fcntl.flock(lock_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return {"status": "skipped", "reason": "lock_contention"}
+        try:
+            age = _marker_age_days(marker)
+            if age is not None and age < throttle_days:
+                return {
+                    "status": "skipped",
+                    "reason": f"ran {age:.1f}d ago (threshold {throttle_days}d)",
+                }
+            if dry_run:
+                return {"status": "dry_run", "would_run": True, "marker_age_days": age}
+            result = run_decay(path, archive_prune_days=archive_prune_days)
+            try:
+                marker.write_text(datetime.now(timezone.utc).isoformat())
+            except OSError:
+                pass
+            return {"status": "ok", **result}
+        finally:
+            fcntl.flock(lock_f, fcntl.LOCK_UN)
+
+
+def run_decay(
+    db_path: str | Path | None = None,
+    *,
+    dry_run: bool = False,
+    archive_prune_days: int = 90,
+) -> dict:
+    """Run confidence decay + consolidation on all learned_patterns.
+
+    Args:
+        db_path: Path to SQLite DB. Defaults to DEFAULT_DB_PATH.
+        dry_run: If True, compute but don't write changes.
+        archive_prune_days: Hard-delete archived, at-floor, seldom-seen
+            patterns not accessed within this window — caps unbounded growth
+            without touching established (times_seen>=5) memory.
+
+    Returns:
+        Dict with stats: total_patterns, decayed, archived, unchanged,
+        working_memory_cleaned, merged, pruned.
+    """
+    path = Path(db_path or DEFAULT_DB_PATH)
+
+    if not path.exists():
+        logger.info("No DB found at %s, skipping decay", path)
+        return {"status": "no_db", "message": f"No DB found at {path}"}
+
+    conn = get_connection(path)
+    try:
+        stats = {
+            "total_patterns": 0,
+            "decayed": 0,
+            "archived": 0,
+            "unchanged": 0,
+            "working_memory_cleaned": 0,
+            "merged": 0,
+            "pruned": 0,
+        }
+
+        # --- Prune long-dead archived patterns (caps unbounded growth) ---
+        # Runs BEFORE this run's archiving so a freshly-archived pattern gets a
+        # full grace window. Targets only patterns archived in a PRIOR run that
+        # are at-floor, seldom-seen, and dormant (no access / validation /
+        # creation within archive_prune_days). Established patterns
+        # (times_seen>=5) survive even when archived — they may resurface.
+        if not dry_run:
+            # Grace window is time-since-archived (archived_at). Legacy rows archived
+            # before v33 have NULL archived_at → fall back to the old COALESCE date so
+            # they stay prunable; new rows get a real archive_prune_days grace.
+            pruned = conn.execute(
+                "DELETE FROM learned_patterns "
+                "WHERE promoted_to = 'archived' "
+                "AND COALESCE(trust_tier, 'volatile') NOT IN ('locked', 'core') "
+                "AND confidence <= ? "
+                "AND COALESCE(times_seen, 0) < 5 "
+                "AND COALESCE(archived_at, last_accessed_at, last_validated, created_at) "
+                "    < datetime('now', ?)",
+                (CONFIDENCE_FLOOR + 0.001, f"-{int(archive_prune_days)} days"),
+            )
+            stats["pruned"] = pruned.rowcount
+
+        # --- Decay learned_patterns ---
+        # Exclude locked/core tiers: they are immutable via the protect triggers
+        # (RAISE ABORT on UPDATE/DELETE). One decay UPDATE of such a row would
+        # raise, unwind before conn.commit(), and silently roll back the whole run.
+        rows = conn.execute(
+            "SELECT id, confidence, decay_rate, impact_score, times_seen, "
+            "last_validated, last_accessed_at "
+            "FROM learned_patterns "
+            "WHERE (promoted_to IS NULL OR promoted_to != 'archived') "
+            "AND COALESCE(trust_tier, 'volatile') NOT IN ('locked', 'core')"
+        ).fetchall()
+
+        stats["total_patterns"] = len(rows)
+
+        for row in rows:
+            d = dict(row)
+            days_validated = _days_since(d["last_validated"])
+            days_accessed = _days_since(d["last_accessed_at"])
+
+            months = (days_validated or 999.0) / 30.0
+
+            eff_rate = effective_decay_rate(
+                base_rate=d["decay_rate"] or 0.1,
+                times_seen=d["times_seen"] or 0,
+                impact_score=d["impact_score"] or 0.5,
+                last_accessed_days=days_accessed,
+            )
+
+            new_conf = decay_confidence(
+                confidence=d["confidence"],
+                months_since_validated=months,
+                eff_rate=eff_rate,
+            )
+
+            if abs(new_conf - d["confidence"]) < 0.001:
+                stats["unchanged"] += 1
+                continue
+
+            if not dry_run:
+                conn.execute(
+                    "UPDATE learned_patterns SET confidence = ? WHERE id = ?",
+                    (round(new_conf, 4), d["id"]),
+                )
+
+            # Archive if at floor
+            if new_conf <= CONFIDENCE_FLOOR + 0.001:
+                if not dry_run:
+                    # Stamp archived_at only on first archival (COALESCE keeps the
+                    # original) so the prune grace window measures time-since-archived.
+                    conn.execute(
+                        "UPDATE learned_patterns SET promoted_to = 'archived', "
+                        "archived_at = COALESCE(archived_at, CURRENT_TIMESTAMP) "
+                        "WHERE id = ?",
+                        (d["id"],),
+                    )
+                stats["archived"] += 1
+            else:
+                stats["decayed"] += 1
+
+        # --- Clean expired observations (any TTL'd class) ---
+        # Only rows that carry an expires_at are eligible; legacy rows have NULL
+        # expiry and are never touched here (their one-time sweep is owner-gated).
+        if not dry_run:
+            cursor = conn.execute(
+                "DELETE FROM observations "
+                "WHERE expires_at IS NOT NULL AND expires_at < CURRENT_TIMESTAMP"
+            )
+            stats["working_memory_cleaned"] = cursor.rowcount
+
+        # --- Consolidate: merge exact (pattern, domain) duplicates ---
+        # learn_extract upserts by (pattern, domain), so dups are rare — this
+        # is defensive: fold losers' access_count/times_validated into the
+        # highest-confidence keeper so no signal is lost, then delete them.
+        dup_groups = conn.execute(
+            "SELECT pattern, COALESCE(domain, '') AS dom FROM learned_patterns "
+            "GROUP BY pattern, COALESCE(domain, '') HAVING COUNT(*) > 1"
+        ).fetchall()
+        for g in dup_groups:
+            members = conn.execute(
+                "SELECT id, access_count, times_validated FROM learned_patterns "
+                "WHERE pattern = ? AND COALESCE(domain, '') = ? "
+                "AND COALESCE(trust_tier, 'volatile') NOT IN ('locked', 'core') "
+                "ORDER BY confidence DESC, id DESC",
+                (g["pattern"], g["dom"]),
+            ).fetchall()
+            losers = members[1:]
+            if not losers:
+                continue
+            if not dry_run:
+                conn.execute(
+                    "UPDATE learned_patterns SET "
+                    "access_count = COALESCE(access_count, 0) + ?, "
+                    "times_validated = COALESCE(times_validated, 0) + ? WHERE id = ?",
+                    (
+                        sum((m["access_count"] or 0) for m in losers),
+                        sum((m["times_validated"] or 0) for m in losers),
+                        members[0]["id"],
+                    ),
+                )
+                conn.executemany(
+                    "DELETE FROM learned_patterns WHERE id = ?",
+                    [(m["id"],) for m in losers],
+                )
+            stats["merged"] += len(losers)
+
+        # --- Consolidate: merge SEMANTIC near-duplicates (B5) ---
+        # Exact-dedup above only catches identical text; this folds patterns that
+        # MEAN the same thing (embeddings cosine >= threshold) so the corpus stays
+        # sharp. No-op without embeddings. Lazy import avoids a load cycle.
+        try:
+            from tools.learning import _consolidate_semantic_duplicates
+
+            threshold = float(os.environ.get("COS_CONSOLIDATION_THRESHOLD", "0.85"))
+            stats["semantic_merged"] = _consolidate_semantic_duplicates(
+                conn, threshold=threshold, dry_run=dry_run
+            )
+            stats["merged"] += stats["semantic_merged"]
+        except Exception as exc:  # consolidation is best-effort — never break decay
+            logger.debug("semantic consolidation skipped: %s", exc)
+
+        if not dry_run:
+            conn.commit()
+
+        return stats
+
+    finally:
+        conn.close()
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    dry_run = "--dry-run" in sys.argv
+
+    if dry_run:
+        logger.info("DRY RUN — no changes will be written")
+
+    stats = run_decay(dry_run=dry_run)
+    logger.info("Decay results: %s", stats)
+
+    if stats.get("status") == "no_db":
+        sys.exit(0)
+
+    logger.info(
+        "Summary: %d patterns processed, %d decayed, %d archived, %d unchanged, "
+        "%d working memory cleaned, %d merged, %d pruned",
+        stats["total_patterns"],
+        stats["decayed"],
+        stats["archived"],
+        stats["unchanged"],
+        stats["working_memory_cleaned"],
+        stats.get("merged", 0),
+        stats.get("pruned", 0),
+    )
+
+
+if __name__ == "__main__":
+    main()

thinking_os/digest.py

@@ -0,0 +1,295 @@
+"""
+Coding OS — Agent digest.
+
+Rolling snapshot of what the agent currently "knows" and "prefers",
+stored at `<project>/.coding-os/digest.md` and refreshed on demand
+(or by the background indexer on a daily cadence).
+
+Why:
+    Memory is huge (observations, learned_patterns, outcome_history)
+    but most of it is low-signal for a new session. The digest is a
+    compact, always-in-context summary that gives the agent an
+    identity anchor before any retrieval happens.
+
+Structure (≤ ~2.4KB, hard cap in _RENDER_BUDGET_CHARS):
+    # Agent Digest — YYYY-MM-DD
+    ## Identity        — task counts, top domains, success rate
+    ## Active Beliefs  — top N learned patterns by confidence × impact
+    ## Fading          — patterns near decay threshold, due for review
+    ## Recent Breakthroughs — key_insight lines from last 7d
+    ## Preferences     — workflow/decision patterns
+
+Public API:
+    regenerate(conn, *, project_root, now=None) -> dict
+    render(conn, *, now=None) -> str
+    read_digest_path(project_root) -> Path
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+try:
+    from tools.trajectory import trajectory_digest_line as _trajectory_digest_line
+except ImportError:
+
+    def _trajectory_digest_line(conn) -> str:  # type: ignore[misc]
+        return ""
+
+
+logger = logging.getLogger("coding_os.digest")
+
+# Hard cap on the rendered markdown. Chosen so the digest fits comfortably
+# inside the agent's always-active context alongside AGENTS.md + rules.
+_RENDER_BUDGET_CHARS = 2400
+
+# How many items from each section to consider before trimming for budget.
+_TOP_BELIEFS = 5
+_TOP_FADING = 3
+_TOP_BREAKTHROUGHS = 3
+_TOP_PREFERENCES = 4
+_TOP_STATS = 3
+
+# Confidence windows
+_FADING_MIN = 0.2
+_FADING_MAX = 0.4
+_ACTIVE_MIN = 0.5
+
+
+def read_digest_path(project_root: Path) -> Path:
+    """Return the canonical digest file path under `<root>/.coding-os/`."""
+    return project_root.resolve() / ".coding-os" / "digest.md"
+
+
+def regenerate(
+    conn: sqlite3.Connection,
+    *,
+    project_root: Path,
+    now: datetime | None = None,
+) -> dict:
+    """Render the digest and write it to `.coding-os/digest.md`."""
+    body = render(conn, now=now)
+    target = read_digest_path(project_root)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(body, encoding="utf-8")
+
+    return {
+        "path": str(target),
+        "size_chars": len(body),
+        "truncated": "[truncated]" in body,
+        "status": "ok",
+    }
+
+
+def render(
+    conn: sqlite3.Connection,
+    *,
+    now: datetime | None = None,
+) -> str:
+    """Build the digest markdown string and enforce the token budget."""
+    now = now or datetime.now(timezone.utc)
+    date_str = now.strftime("%Y-%m-%d")
+
+    identity = _collect_identity(conn)
+    trajectory = _trajectory_digest_line(conn)
+    beliefs = _collect_beliefs(conn, limit=_TOP_BELIEFS)
+    fading = _collect_fading(conn, limit=_TOP_FADING)
+    breakthroughs = _collect_breakthroughs(conn, limit=_TOP_BREAKTHROUGHS)
+    preferences = _collect_preferences(conn, limit=_TOP_PREFERENCES)
+    stats = _collect_stats(conn, limit=_TOP_STATS)
+
+    lines: list[str] = [f"# Agent Digest — {date_str}", ""]
+
+    lines.append("## Identity")
+    lines.append(identity if identity else "_No completed tasks yet._")
+    lines.append("")
+
+    if trajectory:
+        lines.append("## Trajectory")
+        lines.append(trajectory)
+        lines.append("")
+
+    if beliefs:
+        lines.append("## Active Beliefs (top patterns)")
+        for p in beliefs:
+            lines.append(f"- [{p['confidence']:.2f} · impact {p['impact']:.2f}] {p['text']}")
+        lines.append("")
+
+    if fading:
+        lines.append("## Fading (review if encountered)")
+        for p in fading:
+            lines.append(f"- [{p['confidence']:.2f}] {p['text']}")
+        lines.append("")
+
+    if breakthroughs:
+        lines.append("## Recent Breakthroughs (last 7 days)")
+        for b in breakthroughs:
+            lines.append(f"- **{b['task_id']}** — {b['insight']}")
+        lines.append("")
+
+    if preferences:
+        lines.append("## Preferences")
+        for p in preferences:
+            lines.append(f"- {p['text']}")
+        lines.append("")
+
+    # Stats last + lowest priority — honest success rates, NOT learnings. Placed
+    # at the end so they are first to drop under the budget cap (bury the noise).
+    if stats:
+        lines.append("## Project Stats (success rates — not lessons)")
+        for s in stats:
+            lines.append(f"- {s['text']}")
+        lines.append("")
+
+    body = "\n".join(lines).rstrip() + "\n"
+    if len(body) > _RENDER_BUDGET_CHARS:
+        body = body[:_RENDER_BUDGET_CHARS].rstrip() + "\n\n…[truncated]\n"
+    return body
+
+
+# ---------------------------------------------------------------------------
+# Collectors — each returns structured dicts the renderer formats
+# ---------------------------------------------------------------------------
+
+
+def _collect_identity(conn: sqlite3.Connection) -> str:
+    """Summarise task_outcomes over the last 30 days into a single line."""
+    try:
+        row = conn.execute(
+            "SELECT COUNT(*) AS n, "
+            "SUM(CASE WHEN outcome='success' THEN 1 ELSE 0 END) AS succ "
+            "FROM task_outcomes "
+            "WHERE created_at >= datetime('now', '-30 days')"
+        ).fetchone()
+    except sqlite3.OperationalError:
+        return ""
+    if not row or not row["n"]:
+        return ""
+    n = row["n"]
+    succ = row["succ"] or 0
+    rate = succ / n if n else 0.0
+
+    top_domains = _top_domains(conn)
+    domains_str = ", ".join(f"{d} ({c})" for d, c in top_domains) or "—"
+    return f"{n} tasks completed (last 30d). Success rate: {rate:.0%}. Top domains: {domains_str}."
+
+
+def _top_domains(conn: sqlite3.Connection, k: int = 3) -> list[tuple[str, int]]:
+    try:
+        rows = conn.execute(
+            "SELECT domain, COUNT(*) AS n FROM task_outcomes "
+            "WHERE created_at >= datetime('now', '-30 days') "
+            "GROUP BY domain ORDER BY n DESC LIMIT ?",
+            (k,),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [(r["domain"] or "—", r["n"]) for r in rows]
+
+
+def _collect_beliefs(conn: sqlite3.Connection, *, limit: int) -> list[dict]:
+    """Top belief patterns by (confidence × impact), confidence ≥ _ACTIVE_MIN.
+
+    Excludes memory_type='stat' (success-rate baselines) — a statistic is not
+    a learned lesson. See docs/engineering/learning-extraction.md.
+    """
+    try:
+        rows = conn.execute(
+            "SELECT pattern, confidence, impact_score "
+            "FROM learned_patterns "
+            "WHERE confidence >= ? "
+            "  AND COALESCE(memory_type, '') != 'stat' "
+            "  AND promoted_to IS NULL "
+            "ORDER BY (confidence * COALESCE(impact_score, 0.5)) DESC, "
+            "         last_validated DESC, confidence DESC "
+            "LIMIT ?",
+            (_ACTIVE_MIN, limit),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [
+        {
+            "text": (r["pattern"] or "")[:120],
+            "confidence": r["confidence"] or 0.0,
+            "impact": r["impact_score"] or 0.5,
+        }
+        for r in rows
+        if r["pattern"]
+    ]
+
+
+def _collect_stats(conn: sqlite3.Connection, *, limit: int) -> list[dict]:
+    """Success-rate baselines (memory_type='stat') — shown as honest project
+    stats, clearly separated from learned lessons (never ranked as beliefs)."""
+    try:
+        rows = conn.execute(
+            "SELECT pattern FROM learned_patterns "
+            "WHERE memory_type = 'stat' "
+            "ORDER BY confidence DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [{"text": (r["pattern"] or "")[:120]} for r in rows if r["pattern"]]
+
+
+def _collect_fading(conn: sqlite3.Connection, *, limit: int) -> list[dict]:
+    """Patterns whose confidence sits in the fading window and are established."""
+    try:
+        rows = conn.execute(
+            "SELECT pattern, confidence "
+            "FROM learned_patterns "
+            "WHERE confidence BETWEEN ? AND ? "
+            "  AND times_seen >= 1 "
+            "  AND COALESCE(memory_type, '') != 'stat' "
+            "  AND promoted_to IS NULL "
+            "ORDER BY confidence ASC LIMIT ?",
+            (_FADING_MIN, _FADING_MAX, limit),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [
+        {"text": (r["pattern"] or "")[:120], "confidence": r["confidence"] or 0.0}
+        for r in rows
+        if r["pattern"]
+    ]
+
+
+def _collect_breakthroughs(conn: sqlite3.Connection, *, limit: int) -> list[dict]:
+    try:
+        rows = conn.execute(
+            "SELECT task_id, narrative_key_insight "
+            "FROM outcome_history "
+            "WHERE is_breakthrough = 1 "
+            "  AND narrative_key_insight IS NOT NULL "
+            "  AND created_at >= datetime('now', '-7 days') "
+            "ORDER BY created_at DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [
+        {"task_id": r["task_id"], "insight": (r["narrative_key_insight"] or "")[:160]}
+        for r in rows
+        if r["narrative_key_insight"]
+    ]
+
+
+def _collect_preferences(conn: sqlite3.Connection, *, limit: int) -> list[dict]:
+    """Pull workflow/decision patterns — these encode the agent's preferences."""
+    try:
+        rows = conn.execute(
+            "SELECT pattern "
+            "FROM learned_patterns "
+            "WHERE memory_type IN ('workflow', 'decision') "
+            "  AND confidence >= 0.4 "
+            "ORDER BY confidence DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    return [{"text": (r["pattern"] or "")[:140]} for r in rows if r["pattern"]]