ai-browser-profile 1.0.5

package/clean.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""Programmatic cleanup of memories.db — rule-based, no LLM required.
+
+Rules:
+1. Delete autofill:* and address_type_* keys (noise/duplicate keys)
+2. Delete superseded entries
+3. Fix single-value key chains (pick winner by appeared_count)
+4. Deduplicate phones (normalize, keep highest appeared_count)
+5. Deduplicate emails (lowercase, keep highest appeared_count)
+6. Delete known noise patterns (feliciti flood, etc.)
+7. Mark everything touched as reviewed
+"""
+
+import os
+import re
+import sys
+import logging
+from datetime import datetime, timezone
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s", datefmt="%H:%M:%S")
+log = logging.getLogger("clean")
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from ai_browser_profile import MemoryDB
+
+DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "memories.db")
+
+SINGLE_VALUE_KEYS = ["first_name", "last_name", "full_name", "card_holder_name"]
+
+NOISE_VALUE_PATTERNS = [
+    r"^application\.from\.feliciti\.co",  # feliciti housing app flood
+]
+
+NOISE_WORDS = {
+    "test", "asdf", "qwerty", "foo", "bar", "baz", "placeholder",
+    "technical placeholder just to pay",
+    "wegs sdg", "sdgsdg",  # keyboard mash garbage
+    "mediar inc", "mediar, inc.", "mediar",  # company name in card holder field
+    "omi",  # product name in name field
+}
+
+# Known garbage address field combinations (city + state that don't match real location)
+# Keep only entries where city/state are consistent with San Francisco, CA
+KNOWN_CITIES = {"san francisco", "sf"}
+KNOWN_STATES = {"california", "ca"}
+KNOWN_ZIPS = {"94102", "94103", "94105", "94107", "94109", "94110", "94111",
+              "94114", "94115", "94117", "94118", "94121", "94122", "94123",
+              "94124", "94127", "94129", "94130", "94131", "94132", "94133",
+              "94134"}
+
+
+def now_iso():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def normalize_phone(phone: str) -> str | None:
+    """Normalize phone to digits only, return None if not a valid US/intl number."""
+    digits = re.sub(r"\D", "", phone)
+    if digits.startswith("1") and len(digits) == 11:
+        digits = digits[1:]
+    if len(digits) == 10:
+        return digits
+    return None
+
+
+def normalize_email(email: str) -> str:
+    return email.strip().lower()
+
+
+def run_cleanup(db_path: str = DB_PATH, dry_run: bool = False):
+    mem = MemoryDB(db_path)
+    conn = mem.conn
+    now = now_iso()
+
+    stats = {
+        "autofill_deleted": 0,
+        "address_type_deleted": 0,
+        "superseded_deleted": 0,
+        "single_value_fixed": 0,
+        "phone_deduped": 0,
+        "email_deduped": 0,
+        "noise_pattern_deleted": 0,
+        "marked_reviewed": 0,
+    }
+
+    def delete_id(mid):
+        if not dry_run:
+            mem.delete(mid)
+
+    def mark_reviewed(ids):
+        if not dry_run and ids:
+            mem.mark_reviewed(ids)
+        stats["marked_reviewed"] += len(ids)
+
+    # ── 1. Delete autofill:* keys ──────────────────────────────────
+    autofill_ids = [r[0] for r in conn.execute(
+        "SELECT id FROM memories WHERE key LIKE 'autofill:%'"
+    ).fetchall()]
+    for mid in autofill_ids:
+        delete_id(mid)
+    stats["autofill_deleted"] = len(autofill_ids)
+    log.info(f"Deleted {len(autofill_ids)} autofill:* entries")
+
+    # ── 2. Delete address_type_* keys ─────────────────────────────
+    addr_type_ids = [r[0] for r in conn.execute(
+        "SELECT id FROM memories WHERE key LIKE 'address_type_%'"
+    ).fetchall()]
+    for mid in addr_type_ids:
+        delete_id(mid)
+    stats["address_type_deleted"] = len(addr_type_ids)
+    log.info(f"Deleted {len(addr_type_ids)} address_type_* entries")
+
+    # ── 3. Fix single-value key chains ────────────────────────────
+    # Must run BEFORE deleting superseded entries, so we can see the full chain
+    # (including superseded entries like "Matthew Diakonov") to pick the best winner.
+    for key in SINGLE_VALUE_KEYS:
+        rows = conn.execute(
+            "SELECT id, value, appeared_count FROM memories WHERE key=? ORDER BY appeared_count DESC",
+            (key,)
+        ).fetchall()
+
+        if not rows:
+            continue
+
+        # Filter out obvious garbage to find the real winner
+        good = [(r[0], r[1], r[2]) for r in rows
+                if r[1].lower() not in NOISE_WORDS
+                and "_" not in r[1]
+                and len(r[1]) > 2
+                and not r[1].isdigit()]
+
+        if good:
+            winner_id = good[0][0]
+            winner_val = good[0][1]
+        else:
+            winner_id = rows[0][0]
+            winner_val = rows[0][1]
+
+        # Unsupersede the winner, delete everything else
+        if not dry_run:
+            conn.execute(
+                "UPDATE memories SET superseded_by=NULL, superseded_at=NULL WHERE id=?",
+                (winner_id,)
+            )
+        losers = [r[0] for r in rows if r[0] != winner_id]
+        for mid in losers:
+            delete_id(mid)
+            stats["single_value_fixed"] += 1
+
+        if losers:
+            log.info(f"  {key}: winner='{winner_val}' (deleted {len(losers)} others)")
+
+    if not dry_run:
+        conn.commit()
+
+    # ── 4. Delete remaining superseded entries ────────────────────
+    superseded_ids = [r[0] for r in conn.execute(
+        "SELECT id FROM memories WHERE superseded_by IS NOT NULL"
+    ).fetchall()]
+    for mid in superseded_ids:
+        delete_id(mid)
+    stats["superseded_deleted"] = len(superseded_ids)
+    log.info(f"Deleted {len(superseded_ids)} superseded entries")
+
+    # ── 5. Deduplicate phones ─────────────────────────────────────
+    phone_rows = conn.execute(
+        "SELECT id, value, appeared_count FROM memories WHERE key='phone' AND superseded_by IS NULL"
+    ).fetchall()
+
+    groups: dict[str, list] = {}
+    for mid, val, count in phone_rows:
+        norm = normalize_phone(val)
+        if norm:
+            groups.setdefault(norm, []).append((mid, val, count))
+        # phones that can't be normalized: leave alone
+
+    for norm, entries in groups.items():
+        if len(entries) <= 1:
+            continue
+        entries.sort(key=lambda x: -x[2])  # sort by appeared_count desc
+        winner_id = entries[0][0]
+        for mid, val, _ in entries[1:]:
+            delete_id(mid)
+            stats["phone_deduped"] += 1
+        log.info(f"  phone {norm}: kept id={winner_id}, deleted {len(entries)-1} duplicates")
+
+    # ── 6. Deduplicate emails ─────────────────────────────────────
+    email_rows = conn.execute(
+        "SELECT id, value, appeared_count FROM memories WHERE key='email' AND superseded_by IS NULL"
+    ).fetchall()
+
+    email_groups: dict[str, list] = {}
+    for mid, val, count in email_rows:
+        norm = normalize_email(val)
+        email_groups.setdefault(norm, []).append((mid, val, count))
+
+    for norm, entries in email_groups.items():
+        if len(entries) <= 1:
+            continue
+        entries.sort(key=lambda x: -x[2])
+        winner_id = entries[0][0]
+        for mid, val, _ in entries[1:]:
+            delete_id(mid)
+            stats["email_deduped"] += 1
+        log.info(f"  email {norm}: kept id={winner_id}, deleted {len(entries)-1} duplicates")
+
+    # ── 7. Delete known noise patterns ────────────────────────────
+    all_rows = conn.execute(
+        "SELECT id, value FROM memories WHERE superseded_by IS NULL"
+    ).fetchall()
+
+    for mid, val in all_rows:
+        for pattern in NOISE_VALUE_PATTERNS:
+            if re.search(pattern, val, re.IGNORECASE):
+                delete_id(mid)
+                stats["noise_pattern_deleted"] += 1
+                break
+
+    if not dry_run:
+        conn.commit()
+
+    # ── 8. Clean up bad address entries ──────────────────────────
+    # Delete city/state/zip entries that don't match known SF location
+    city_rows = conn.execute(
+        "SELECT id, value FROM memories WHERE key='city' AND superseded_by IS NULL"
+    ).fetchall()
+    for mid, val in city_rows:
+        if val.lower().strip() not in KNOWN_CITIES:
+            delete_id(mid)
+            stats.setdefault("address_noise_deleted", 0)
+            stats["address_noise_deleted"] += 1
+
+    state_rows = conn.execute(
+        "SELECT id, value FROM memories WHERE key='state' AND superseded_by IS NULL"
+    ).fetchall()
+    for mid, val in state_rows:
+        if val.lower().strip() not in KNOWN_STATES:
+            delete_id(mid)
+            stats.setdefault("address_noise_deleted", 0)
+            stats["address_noise_deleted"] += 1
+
+    zip_rows = conn.execute(
+        "SELECT id, value FROM memories WHERE key='zip' AND superseded_by IS NULL"
+    ).fetchall()
+    for mid, val in zip_rows:
+        if val.strip() not in KNOWN_ZIPS:
+            delete_id(mid)
+            stats.setdefault("address_noise_deleted", 0)
+            stats["address_noise_deleted"] += 1
+
+    if not dry_run:
+        conn.commit()
+    log.info(f"Deleted {stats.get('address_noise_deleted', 0)} bad address entries")
+
+    # ── 9. Mark all remaining non-superseded as reviewed ─────────
+    unreviewed_ids = [r[0] for r in conn.execute(
+        "SELECT id FROM memories WHERE reviewed_at IS NULL AND superseded_by IS NULL"
+    ).fetchall()]
+    mark_reviewed(unreviewed_ids)
+
+    if not dry_run:
+        conn.commit()
+
+    # ── Report ────────────────────────────────────────────────────
+    final_stats = mem.stats()
+    log.info("\n── Cleanup complete ──────────────────────────────────")
+    log.info(f"  autofill:* deleted:      {stats['autofill_deleted']}")
+    log.info(f"  address_type_* deleted:  {stats['address_type_deleted']}")
+    log.info(f"  superseded deleted:      {stats['superseded_deleted']}")
+    log.info(f"  single-value fixed:      {stats['single_value_fixed']}")
+    log.info(f"  phone dupes removed:     {stats['phone_deduped']}")
+    log.info(f"  email dupes removed:     {stats['email_deduped']}")
+    log.info(f"  noise patterns deleted:  {stats['noise_pattern_deleted']}")
+    log.info(f"  address noise deleted:   {stats.get('address_noise_deleted', 0)}")
+    log.info(f"  marked reviewed:         {stats['marked_reviewed']}")
+    log.info(f"\n  Final DB: {final_stats['total_memories']} memories")
+    log.info(f"  Unreviewed remaining: {conn.execute('SELECT COUNT(*) FROM memories WHERE reviewed_at IS NULL').fetchone()[0]}")
+    log.info("\n── Profile after cleanup ─────────────────────────────")
+    print(mem.profile_text())
+
+    mem.close()
+    return stats
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Rule-based cleanup of memories.db")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would be deleted without changing anything")
+    parser.add_argument("--db", default=DB_PATH, help="Path to memories.db")
+    args = parser.parse_args()
+
+    if args.dry_run:
+        log.info("DRY RUN — no changes will be made")
+
+    run_cleanup(db_path=args.db, dry_run=args.dry_run)

package/extract.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""CLI entry point for ai-browser-profile extraction."""
+
+import argparse
+import logging
+
+from ai_browser_profile import extract_memories
+from clean import run_cleanup
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("extract")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract user memories from browser data")
+    parser.add_argument("--output", "-o", default="memories.db",
+                        help="Output memories database path (default: memories.db)")
+    parser.add_argument("--browsers", nargs="*",
+                        help="Only scan specific browsers (arc, chrome, safari, firefox, brave, edge)")
+    parser.add_argument("--no-indexeddb", action="store_true",
+                        help="Skip IndexedDB extraction (WhatsApp contacts)")
+    parser.add_argument("--no-localstorage", action="store_true",
+                        help="Skip Local Storage extraction (LinkedIn connections)")
+    parser.add_argument("--no-notion", action="store_true",
+                        help="Skip Notion extraction (workspace, users, pages)")
+    parser.add_argument("--no-clean", action="store_true",
+                        help="Skip auto-cleanup after extraction")
+    args = parser.parse_args()
+
+    browsers = set(b.lower() for b in args.browsers) if args.browsers else None
+
+    mem = extract_memories(
+        memories_db_path=args.output,
+        browsers=browsers,
+        skip_indexeddb=args.no_indexeddb,
+        skip_localstorage=args.no_localstorage,
+        skip_notion=args.no_notion,
+    )
+    stats = mem.stats()
+    log.info(f"Extraction done — {stats['total_memories']} memories in {args.output}")
+    mem.close()
+
+    if not args.no_clean:
+        log.info("Running auto-cleanup...")
+        run_cleanup(db_path=args.output)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "ai-browser-profile",
+  "version": "1.0.5",
+  "description": "Extract user identity (name, emails, accounts, addresses, payments) from browser data into a self-ranking SQLite database. Install as a Claude Code agent skill.",
+  "bin": {
+    "ai-browser-profile": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "ai_browser_profile/**/*.py",
+    "skill/",
+    "review/",
+    "setup/",
+    "autofill/",
+    "whatsapp/",
+    "extract.py",
+    "clean.py"
+  ],
+  "keywords": [
+    "browser-data",
+    "browser-profile",
+    "identity",
+    "claude",
+    "claude-code",
+    "ai-agent",
+    "knowledge-base",
+    "embeddings",
+    "autofill"
+  ],
+  "author": "Matthew Diakonov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/m13v/ai-browser-profile.git"
+  },
+  "homepage": "https://github.com/m13v/ai-browser-profile",
+  "engines": {
+    "node": ">=16"
+  }
+}

package/review/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: memory-review
+description: "Review and clean unreviewed memories in the database. Removes junk, merges duplicates, fixes miskeyed data, and marks good entries as reviewed. Run periodically after extraction."
+---
+
+# Memory Review
+
+LLM-powered post-ingestion review of the user memories database. Processes unreviewed memories in phases — bulk cleanup first, then per-entry review.
+
+## Setup
+
+```python
+import sys, os
+sys.path.insert(0, os.path.expanduser("~/ai-browser-profile"))
+from ai_browser_profile import MemoryDB
+
+mem = MemoryDB(os.path.expanduser("~/ai-browser-profile/memories.db"))
+```
+
+## Workflow
+
+### Phase 0: Fast Pass (bulk cleanup)
+
+Before reviewing individual entries, bulk-delete entire categories of known noise. This typically removes ~50% of entries instantly.
+
+```python
+# 1. Delete ALL autofill:* entries — these are raw form field duplicates of real data
+autofill_ids = [r[0] for r in mem.conn.execute(
+    "SELECT id FROM memories WHERE key LIKE 'autofill:%' AND reviewed_at IS NULL"
+).fetchall()]
+for mid in autofill_ids:
+    mem.delete(mid)
+
+# 2. Delete ALL address_type_* entries — always noise (last names, numbers in address fields)
+addr_type_ids = [r[0] for r in mem.conn.execute(
+    "SELECT id FROM memories WHERE key LIKE 'address_type_%' AND reviewed_at IS NULL"
+).fetchall()]
+for mid in addr_type_ids:
+    mem.delete(mid)
+
+# 3. Delete ALL superseded entries
+superseded_ids = [r[0] for r in mem.conn.execute(
+    "SELECT id FROM memories WHERE superseded_by IS NOT NULL AND reviewed_at IS NULL"
+).fetchall()]
+for mid in superseded_ids:
+    mem.delete(mid)
+```
+
+**Check for leaked secrets before bulk-deleting autofill.** Grep for `client_secret`, `api_key`, `token`, `password` in autofill values and flag them to the user before deleting.
+
+### Phase 1: Supersession Chain Repair
+
+After the fast pass, single-value key chains (`first_name`, `last_name`, `full_name`, `card_holder_name`, `email`) are often corrupted. The extraction supersedes the real value with garbage because each new autofill entry blindly replaces the old one.
+
+Common pattern: `first_name` chain goes Matthew → Marina → mediar → ... leaving "mediar" as the active value.
+
+```python
+# For each single-value key, check the active (non-superseded) value
+SINGLE_VALUE_KEYS = ["first_name", "last_name", "full_name", "card_holder_name", "email", "phone"]
+for key in SINGLE_VALUE_KEYS:
+    rows = mem.conn.execute(
+        "SELECT id, value, confidence, superseded_by FROM memories WHERE key=? ORDER BY id",
+        (key,)
+    ).fetchall()
+    print(f"\n{key}:")
+    for r in rows:
+        status = "ACTIVE" if r[3] is None else f"superseded by {r[3]}"
+        print(f"  id={r[0]} val='{r[1]}' conf={r[2]} [{status}]")
+```
+
+Fix by:
+1. Deleting garbage entries (code identifiers, other people's names, company names in name fields)
+2. Unsuperseding the real value: `UPDATE memories SET superseded_by=NULL, superseded_at=NULL WHERE id=?`
+3. Boosting confidence on the real value if needed
+
+### Phase 2: Per-Entry Review
+
+Now process remaining unreviewed entries in batches:
+
+1. Call `mem.get_unreviewed(limit=50)` to get a batch
+2. Print the batch as a numbered table
+3. Classify each as KEEP, DELETE, MERGE, or FIX
+4. Execute actions via `mem.delete()`, `mem.update_memory()`, etc.
+5. Call `mem.mark_reviewed([...ids...])` on all processed IDs (including kept ones)
+6. Print summary per batch
+7. Repeat until no unreviewed remain
+
+### Phase 3: Profile Verification
+
+After all entries are reviewed, verify the profile output catches any residual issues:
+
+```python
+print(mem.profile_text())
+```
+
+Check for:
+- Wrong name showing (garbage superseded the real one)
+- Mixed cities/states (e.g. "San Francisco, New York" in the same address)
+- Garbage card holder names
+- Missing fields that should be populated
+
+Fix any issues, then `mem.close()`.
+
+## Classification Criteria
+
+### DELETE — remove entirely
+
+- **Gibberish/test data**: `"wegs sdg"`, `"asdf"`, `"test123"`, `"technical placeholder just to pay"`, single characters
+- **Code identifiers in name fields**: values containing underscores (`investor_role`, `handle_new_workflow_analysis`, `on_low_level_event_insert`), or known non-names (`os`, `type`, `use-case`)
+- **Leaked secrets**: values containing `client_secret`, `GOCSPX-`, full API keys, OAuth tokens, private keys — **flag to user before deleting**
+- **Other people's data**: names/emails/phones that belong to someone else — UNLESS stored as `contact:*` or `linkedin:*` keys
+- **Company names in name fields**: `first_name="mediar"`, `last_name="inc"`, `full_name="Mediar, inc."` — these are autofill bugs
+- **Truncated names**: `last_name="Di"`, `full_name="Matthew Di"`, `full_name="Matt"` (incomplete)
+- **Noise locations**: cities/states from insurance quoting, comparison shopping, or form testing
+- **Expired card data**: card expiry dates in the past
+- **Meaningless amounts**: `"100.00"`, `"199.00"`, `"1.00"`, `"$ 245.80"` — these are form values, not useful data
+- **Duplicate phone formats**: keep only one format per phone number (prefer international format with `+1`)
+
+### MERGE — combine duplicates
+
+- **Same phone, different formats**: `"+1 650-796-1489"`, `"(650) 796-1489"`, `"6507961489"` — keep the international format with highest confidence, delete all others
+- **Same email, different casing**: keep lowercase
+- **Duplicate DOB entries**: identify the real one (consistent across sources) vs noise
+- **Same contact, multiple entries**: merge into highest-confidence one
+
+When merging: keep highest confidence. If tied, keep highest `accessed_count`. Delete the rest.
+
+### FIX — correct bad data
+
+- **Wrong key assignment**: `company="Dmitrii Diakonov"` → delete (person name in company field)
+- **Wrong confidence**: real DOB at 0.4 while fake one at 0.6 → boost real one
+- **Missing tags**: `phone` key without `phone` tag, `email` without `email` tag
+- **Broken supersession**: use `UPDATE memories SET superseded_by=NULL, superseded_at=NULL WHERE id=?`
+- Use `mem.update_memory(id, key=..., value=..., confidence=..., tags=[...])` for fixes
+
+### KEEP — mark as reviewed
+
+- Genuine user data
+- Correctly keyed and tagged entries
+- Legitimate contacts, accounts, tools
+- Just call `mem.mark_reviewed([id])` — no changes needed
+
+## Output Format
+
+For each batch, print a table like:
+
+```
+Batch 1/N (50 memories)
+───────────────────────────────────────
+ID  | Key              | Value              | Conf | Action
+----|------------------|--------------------|------|--------
+1   | first_name       | Matthew            | 0.8  | KEEP
+2   | full_name        | investor_role      | 0.5  | DELETE (code identifier)
+3   | phone            | +14155551234       | 0.7  | KEEP
+4   | phone            | (415) 555-1234     | 0.5  | MERGE → #3
+...
+
+Summary: 30 kept, 12 deleted, 5 fixed, 3 merged
+```
+
+At the end, print the profile and final stats:
+
+```
+## Final Profile
+[output of mem.profile_text()]
+
+## Stats
+Total: X memories (was Y before review)
+Deleted: Z, Kept: W, Fixed: V, Merged: U
+Secrets found and removed: N
+```

package/review/run.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# Memory Review — weekly extract + LLM review
+# 1. Run extract.py to ingest new browser data
+# 2. Run Claude to review/clean new entries
+# Called by launchd weekly (604800s)
+
+set -euo pipefail
+
+REPO="$HOME/user-memories"
+SKILL_FILE="$REPO/review/SKILL.md"
+LOG_DIR="$REPO/review/logs"
+VENV="$REPO/.venv/bin/activate"
+DB="$REPO/memories.db"
+
+mkdir -p "$LOG_DIR"
+LOG_FILE="$LOG_DIR/$(date +%Y-%m-%d_%H%M%S).log"
+
+echo "=== Memory Review Run: $(date) ===" | tee "$LOG_FILE"
+
+# Phase 0: Extract new browser data
+echo "--- Extracting browser data ---" | tee -a "$LOG_FILE"
+(
+  cd "$REPO"
+  source "$VENV"
+  python extract.py 2>&1
+) | tee -a "$LOG_FILE"
+
+# Check if there are unreviewed entries
+UNREVIEWED=$(cd "$REPO" && source "$VENV" && python -c "
+import sys; sys.path.insert(0, '.')
+from user_memories import MemoryDB
+m = MemoryDB('memories.db')
+print(len(m.get_unreviewed(limit=10000)))
+m.close()
+" 2>/dev/null)
+
+echo "Unreviewed entries: $UNREVIEWED" | tee -a "$LOG_FILE"
+
+if [ "$UNREVIEWED" = "0" ]; then
+  echo "No new entries to review. Done." | tee -a "$LOG_FILE"
+  exit 0
+fi
+
+# Phase 1: Rule-based cleanup
+echo "--- Running rule-based cleanup ---" | tee -a "$LOG_FILE"
+(
+  cd "$REPO"
+  source "$VENV"
+  python clean.py 2>&1
+) | tee -a "$LOG_FILE"
+
+# Re-check unreviewed after cleanup
+UNREVIEWED=$(cd "$REPO" && source "$VENV" && python -c "
+import sys; sys.path.insert(0, '.')
+from user_memories import MemoryDB
+m = MemoryDB('memories.db')
+print(len(m.get_unreviewed(limit=10000)))
+m.close()
+" 2>/dev/null)
+
+if [ "$UNREVIEWED" = "0" ]; then
+  echo "All entries handled by cleanup. Done." | tee -a "$LOG_FILE"
+  exit 0
+fi
+
+# Phase 2: Claude reviews remaining entries
+echo "--- Starting Claude review ($UNREVIEWED entries) ---" | tee -a "$LOG_FILE"
+claude -p "You are the Memory Review agent. You clean up the user memories database after extraction.
+
+Read $SKILL_FILE for full classification criteria and workflow.
+
+DB path: $DB
+Module path: $REPO
+
+Run Phases 1-3 from the skill file (Phase 0 fast pass already done by clean.py).
+Process remaining unreviewed entries in batches of 50.
+Print a summary at the end." --max-turns 80 2>&1 | tee -a "$LOG_FILE"
+
+echo "=== Run complete: $(date) ===" | tee -a "$LOG_FILE"
+
+# Clean up old logs (keep last 30 days)
+find "$LOG_DIR" -name "*.log" -mtime +30 -delete 2>/dev/null || true