opsroom-console 0.3.0__py3-none-any.whl

opsroom/__init__.py

@@ -0,0 +1,2 @@
+"""opsroom — local-first operator console. See https://github.com/malekadjeb-ai/opsroom"""
+__version__ = "0.3.0"

opsroom/cli.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""opsroom — a local-first operator console. Read-only on all sources.
+Commands: serve · init · sync · sitrep · dash · today · week · loops · drift · venture ·
+search · daily · demo · purge · status"""
+import argparse
+import sys
+import time
+
+from . import config, db, enrich, views
+
+
+def cmd_sync(args):
+    con = db.connect()
+    sources = args.source.split(",") if args.source else ["cli", "codex", "git", "fs", "notes", "chat"]
+    t0 = time.time()
+    results, degraded = {}, []
+    git_result, notes_result = {}, {}
+    from .collectors import (cli as c_cli, codex as c_codex, git as c_git, fs as c_fs,
+                             notes as c_notes, chat as c_chat)
+    registry = {"cli": c_cli, "codex": c_codex, "git": c_git, "fs": c_fs,
+                "notes": c_notes, "chat": c_chat}
+    for name in sources:
+        mod = registry.get(name)
+        if not mod:
+            print(f"unknown source: {name}")
+            continue
+        try:
+            r = mod.collect(con, dry_run=args.dry_run)
+            results[name] = r
+            if name == "git":
+                git_result = r
+            if name == "notes":
+                notes_result = r
+                if r.get("degraded"):
+                    degraded.append(f"notes: {r['degraded']}")
+            if not args.dry_run:
+                db.set_watermark(con, name, "degraded" if (name == "notes" and r.get("degraded")) else "ok",
+                                 last_ts=r.get("watermark"))
+        except Exception as e:
+            degraded.append(f"{name}: {type(e).__name__}: {e}")
+            if not args.dry_run:
+                db.set_watermark(con, name, "failed")
+            print(f"  [{name}] DEGRADED: {e}", file=sys.stderr)
+    if not args.dry_run:
+        n_sessions = enrich.build_sessions(con)
+        loop_stats = enrich.detect_loops(con, git_result, notes_result)
+        con.commit()
+        db.enforce_perms()
+    else:
+        n_sessions, loop_stats = "-", {"open": "-"}
+    dt = time.time() - t0
+    print(f"\nopsroom sync {'(dry-run) ' if args.dry_run else ''}done in {dt:.1f}s")
+    for name, r in results.items():
+        print(f"  {name:<6} new={r.get('events_new', 0):<6} seen={r.get('events_seen', 0):<7} "
+              f"dropped={r.get('dropped', 0)}")
+    print(f"  sessions built: {n_sessions} · open loops: {loop_stats['open']}")
+    if degraded:
+        print(f"  DEGRADED SOURCES: {degraded}")
+    if not args.dry_run:
+        row = con.execute("SELECT COUNT(*) c FROM events").fetchone()
+        print(f"  events total: {row['c']}")
+    con.close()
+    return 0
+
+
+def cmd_purge(args):
+    con = db.connect()
+    if args.source:
+        for t in ("events", "sessions"):
+            con.execute(f"DELETE FROM {t} WHERE source=?", (args.source,))
+        con.execute("DELETE FROM loops WHERE signal LIKE ?", (f"%{args.source}%",))
+        con.execute("DELETE FROM watermarks WHERE source=? OR source LIKE ?",
+                    (args.source, f"{args.source}:%"))
+        if args.source == "cli":
+            con.execute("DELETE FROM file_state WHERE path LIKE '%/.claude/%'")
+        if args.source == "codex":
+            con.execute("DELETE FROM file_state WHERE path LIKE '%/.codex/%'")
+        print(f"purged source={args.source}")
+    if args.before:
+        con.execute("DELETE FROM events WHERE ts < ?", (args.before,))
+        con.execute("DELETE FROM sessions WHERE ended_at < ?", (args.before,))
+        print(f"purged events before {args.before}")
+    con.commit()
+    con.execute("VACUUM")
+    db.enforce_perms()
+    con.close()
+    return 0
+
+
+def cmd_status(args):
+    con = db.connect()
+    print(f"\nconfig: {config.config_dir() / 'config.toml'}"
+          f"{'' if (config.config_dir() / 'config.toml').is_file() else ' (not found — opsroom init)'}")
+    print(f"data:   {config.data_dir()}\n\nSOURCE STATUS")
+    for r in con.execute("SELECT * FROM watermarks WHERE source NOT LIKE 'git:%' ORDER BY source"):
+        print(f"  {r['source']:<8} {r['status']:<10} last run {r['last_run'] or '-'}")
+    for r in con.execute("SELECT source, COUNT(*) c FROM events GROUP BY source"):
+        print(f"  {r['source']:<8} {r['c']} events")
+    con.close()
+    return 0
+
+
+def main():
+    p = argparse.ArgumentParser(prog="opsroom", description=__doc__)
+    sub = p.add_subparsers(dest="cmd")  # no subcommand → `opsroom serve` (the app)
+    ip = sub.add_parser("init", help="interactive setup: ventures, goal, notes, trackers")
+    ip.add_argument("--yes", action="store_true", help="accept detected defaults, no prompts")
+    sp = sub.add_parser("sync", help="ingest all sources (read-only on sources)")
+    sp.add_argument("--source", help="comma-separated subset: cli,codex,git,fs,notes,chat")
+    sp.add_argument("--dry-run", action="store_true", help="parse + count, write nothing")
+    st = sub.add_parser("sitrep", help="operator SITREP: goal clock, cash, leads, pipeline, leak, one move")
+    st.add_argument("--write", action="store_true", help="append to the daily note (default: print only)")
+    sub.add_parser("dash", help="operator console (single local HTML file)").add_argument(
+        "--no-open", action="store_true")
+    vp2 = sub.add_parser("serve", help="the console as a live local app: buttons write back "
+                                       "(touches, follow-ups, cash, leads). Loopback only.")
+    vp2.add_argument("--port", type=int, default=7337)
+    vp2.add_argument("--no-open", action="store_true")
+    vp2.add_argument("--always-on", action="store_true",
+                     help="macOS: install a launchd agent so the console survives reboots")
+    sub.add_parser("today", help="what did I actually do today").add_argument(
+        "--offset", type=int, default=0, help="days back")
+    sub.add_parser("week", help="7-day activity + drift")
+    lp = sub.add_parser("loops", help="open loops with evidence")
+    lp.add_argument("--all", action="store_true")
+    lp.add_argument("--dismiss", metavar="ID_PREFIX")
+    dp = sub.add_parser("drift", help="effort vs revenue for the week")
+    dp.add_argument("--weeks-ago", type=int, default=0)
+    sub.add_parser("venture", help="one venture's ledger").add_argument("name")
+    sub.add_parser("search", help="full-text search the ledger").add_argument("query", nargs="+")
+    vp = sub.add_parser("daily", help="append-only activity ledger into the daily note")
+    vp.add_argument("--write", action="store_true")
+    sub.add_parser("demo", help="spin up a fictional portfolio and open the console")
+    pp = sub.add_parser("purge", help="shrink the blast radius")
+    pp.add_argument("--source")
+    pp.add_argument("--before", metavar="ISO_DATE")
+    sub.add_parser("status", help="config + watermarks + row counts per source")
+    args = p.parse_args()
+
+    if args.cmd is None:  # bare `opsroom` = the live console
+        from . import serve as _serve
+        return _serve.serve() or 0
+    if args.cmd == "init":
+        from . import setup
+        return setup.run(yes=args.yes)
+    if args.cmd == "demo":
+        from . import demo
+        return demo.run()
+    if args.cmd == "serve":
+        from . import serve as _serve
+        if args.always_on:
+            return 0 if _serve.install_always_on(port=args.port) else 1
+        return _serve.serve(port=args.port, open_browser=not args.no_open) or 0
+    if args.cmd == "sync":
+        return cmd_sync(args)
+    if args.cmd == "purge":
+        if not (args.source or args.before):
+            p.error("purge needs --source or --before")
+        return cmd_purge(args)
+    if args.cmd == "status":
+        return cmd_status(args)
+
+    con = db.connect()
+    try:
+        if args.cmd == "today":
+            views.today(con, args.offset)
+        elif args.cmd == "week":
+            views.week(con)
+        elif args.cmd == "loops":
+            if args.dismiss:
+                views.dismiss_loop(con, args.dismiss)
+                con.commit()
+            else:
+                views.loops(con, args.all)
+        elif args.cmd == "drift":
+            views.drift(con, args.weeks_ago)
+        elif args.cmd == "venture":
+            views.venture_view(con, args.name)
+        elif args.cmd == "search":
+            views.search(con, " ".join(args.query))
+        elif args.cmd == "dash":
+            path = views.dash(con)
+            if not args.no_open:
+                import subprocess
+                import sys as _s
+                opener = {"darwin": "open", "linux": "xdg-open"}.get(_s.platform)
+                if opener:
+                    subprocess.run([opener, path], check=False)
+        elif args.cmd == "sitrep":
+            views.sitrep(con, write=args.write)
+        elif args.cmd == "daily":
+            views.daily_writeback(con, dry_run=not args.write)
+    finally:
+        con.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

opsroom/collectors/__init__.py

@@ -0,0 +1,81 @@
+"""Shared collector plumbing: redact-gated event emission, per-file watermarks."""
+import hashlib
+import json
+import sys
+from datetime import datetime, timezone
+
+from .. import redact as _redact
+
+MAX_DETAIL = 4096
+
+
+def norm_ts(ts: str) -> str:
+    """Normalize any ISO8601 timestamp (Z, ±hh:mm, or naive) to canonical UTC 'YYYY-MM-DDTHH:MM:SS.mmmZ'
+    so lexicographic SQL comparisons are correct across sources."""
+    dt = datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+class Emitter:
+    """Buffers redacted events and writes them idempotently. Fail-closed on redaction errors."""
+
+    def __init__(self, con, dry_run: bool = False):
+        self.con = con
+        self.dry_run = dry_run
+        self.inserted = 0
+        self.seen = 0
+        self.dropped = 0
+
+    def emit(self, *, ts, source, kind, actor, summary, detail="", session_id=None,
+             venture=None, project=None, artifacts=None, raw_ref=None, is_sidechain=0):
+        self.seen += 1
+        try:
+            ts = norm_ts(ts)
+        except (ValueError, TypeError):
+            self.dropped += 1
+            return
+        try:
+            # redact BEFORE truncating: a secret straddling the cut would otherwise be
+            # sliced so the pattern no longer matches, storing its unredacted head.
+            rs, h1 = _redact.redact(summary or "")
+            rd, h2 = _redact.redact(detail or "")
+            summary, detail = rs[:512], rd[:MAX_DETAIL]
+            redacted = 1 if (h1 + h2) else 0
+        except Exception as e:  # fail closed: never write unredacted content
+            self.dropped += 1
+            print(f"  [redactor] dropped event ({source}/{kind}): {type(e).__name__}", file=sys.stderr)
+            return
+        eid = hashlib.sha256(
+            f"{source}|{session_id}|{ts}|{kind}|{raw_ref}|{summary[:200]}".encode()).hexdigest()
+        if self.dry_run:
+            self.inserted += 1
+            return
+        cur = self.con.execute(
+            """INSERT OR IGNORE INTO events
+               (id, ts, source, session_id, venture, project, kind, actor, summary, detail,
+                artifacts, raw_ref, is_sidechain, redacted)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+            (eid, ts, source, session_id, venture, project, kind, actor, summary, detail,
+             json.dumps(artifacts) if artifacts else None, raw_ref, is_sidechain, redacted))
+        self.inserted += cur.rowcount
+
+
+def file_changed(con, path: str, mtime: float, size: int):
+    """Return (changed, lines_already_ingested). Reparse fully if the file shrank."""
+    row = con.execute("SELECT mtime, size, lines FROM file_state WHERE path=?", (path,)).fetchone()
+    if row is None:
+        return True, 0
+    if row["mtime"] == mtime and row["size"] == size:
+        return False, row["lines"]
+    if size < row["size"]:
+        return True, 0  # truncated/rewritten: reparse
+    return True, row["lines"]
+
+
+def record_file(con, path: str, mtime: float, size: int, lines: int):
+    con.execute(
+        """INSERT INTO file_state(path, mtime, size, lines) VALUES (?,?,?,?)
+           ON CONFLICT(path) DO UPDATE SET mtime=excluded.mtime, size=excluded.size, lines=excluded.lines""",
+        (path, mtime, size, lines))

opsroom/collectors/chat.py

@@ -0,0 +1,126 @@
+"""Collector: Desktop/web chat via the vendor data-export flow (manual drop).
+Drop conversations.json (or the export .zip) into the configured chat_drop_dir —
+Anthropic (Claude) and OpenAI (ChatGPT) exports are both recognized by shape.
+The zip is deleted after successful ingest (spec P0 #7); extracted JSON is kept out of
+sync roots and removed too."""
+import json
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .. import ventures
+from . import Emitter
+
+DROP_DIR = Path(ventures.CHAT_DROP_DIR)
+
+
+def _ingest_conversations(em: Emitter, data: list, ref: str) -> int:
+    n = 0
+    for conv in data:
+        cid = conv.get("uuid") or conv.get("id") or "?"
+        name = conv.get("name") or "(untitled chat)"
+        venture = ventures.attribute_text(name)
+        for i, m in enumerate(conv.get("chat_messages", [])):
+            text = m.get("text")
+            if not text and isinstance(m.get("content"), list):
+                text = "\n".join(c.get("text", "") for c in m["content"]
+                                 if isinstance(c, dict) and c.get("type") == "text")
+            text = (text or "").strip()
+            if not text:
+                continue
+            sender = m.get("sender", "?")
+            ts = m.get("created_at") or conv.get("created_at") or datetime.now(timezone.utc).isoformat()
+            v = venture if venture != "unknown" else ventures.attribute_text(text[:500])
+            em.emit(ts=ts, source="chat", kind="prompt" if sender == "human" else "response",
+                    actor="you" if sender == "human" else "assistant",
+                    session_id=f"chat:{cid}", venture=v, project=name[:60],
+                    summary=text.strip().split("\n")[0][:180], detail=text,
+                    raw_ref=f"{ref}#conv={cid}&msg={i}")
+            n += 1
+    return n
+
+
+def _openai_text(msg: dict) -> str:
+    content = msg.get("content") or {}
+    if content.get("content_type") not in (None, "text", "multimodal_text"):
+        return ""
+    parts = content.get("parts") or []
+    return "\n".join(p for p in parts if isinstance(p, str)).strip()
+
+
+def _ingest_openai(em: Emitter, data: list, ref: str) -> int:
+    """OpenAI ChatGPT export: each conversation is a mapping-tree of nodes."""
+    n = 0
+    for conv in data:
+        cid = conv.get("conversation_id") or conv.get("id") or "?"
+        name = conv.get("title") or "(untitled chat)"
+        venture = ventures.attribute_text(name)
+        nodes = conv.get("mapping") or {}
+        msgs = []
+        for node in nodes.values():
+            m = (node or {}).get("message")
+            if not isinstance(m, dict):
+                continue
+            role = ((m.get("author") or {}).get("role"))
+            if role not in ("user", "assistant"):
+                continue
+            text = _openai_text(m)
+            if not text:
+                continue
+            msgs.append((m.get("create_time") or conv.get("create_time") or 0, role, text, m.get("id", "?")))
+        for ct, role, text, mid in sorted(msgs):
+            ts = datetime.fromtimestamp(ct, timezone.utc).isoformat() if ct else \
+                datetime.now(timezone.utc).isoformat()
+            v = venture if venture != "unknown" else ventures.attribute_text(text[:500])
+            em.emit(ts=ts, source="chat", kind="prompt" if role == "user" else "response",
+                    actor="you" if role == "user" else "chatgpt",
+                    session_id=f"chatgpt:{cid}", venture=v, project=name[:60],
+                    summary=text.split("\n")[0][:180], detail=text,
+                    raw_ref=f"{ref}#conv={cid}&msg={mid}")
+            n += 1
+    return n
+
+
+def _ingest_any(em: Emitter, data, ref: str) -> int:
+    """Sniff export format: Anthropic conversations carry chat_messages, OpenAI carry mapping."""
+    if not isinstance(data, list):
+        return 0
+    if any(isinstance(c, dict) and "mapping" in c for c in data):
+        return _ingest_openai(em, data, ref)
+    return _ingest_conversations(em, data, ref)
+
+
+def collect(con, dry_run: bool = False) -> dict:
+    em = Emitter(con, dry_run)
+    if not DROP_DIR.is_dir():
+        return {"status": "no drop dir", "events_new": 0, "events_seen": 0, "dropped": 0}
+    ingested, cleanup = [], []
+    for f in sorted(DROP_DIR.iterdir()):
+        try:
+            if f.suffix == ".json" and "conversation" in f.name.lower():
+                data = json.loads(f.read_text(errors="replace"))
+                _ingest_any(em, data, str(f))
+                ingested.append(f.name)
+                cleanup.append(f)
+            elif f.suffix == ".zip":
+                with zipfile.ZipFile(f) as z:
+                    for info in z.infolist():
+                        if info.filename.endswith("conversations.json"):
+                            if info.file_size > 500_000_000:  # decompression-bomb cap
+                                print(f"  [chat] skipped {info.filename}: "
+                                      f"{info.file_size // 1_000_000}MB exceeds 500MB cap")
+                                continue
+                            data = json.loads(z.read(info).decode(errors="replace"))
+                            _ingest_any(em, data, f"{f}!{info.filename}")
+                            ingested.append(f"{f.name}!{info.filename}")
+                cleanup.append(f)
+        except Exception as e:
+            print(f"  [chat] failed on {f.name}: {e}")
+    if not dry_run:
+        for f in cleanup:
+            try:
+                f.unlink()  # spec: delete export after ingest to shrink blast radius
+            except OSError:
+                pass
+    return {"ingested": ingested, "events_new": em.inserted, "events_seen": em.seen,
+            "dropped": em.dropped}

opsroom/collectors/cli.py

@@ -0,0 +1,165 @@
+"""Collector: Claude Code CLI session logs (~/.claude/projects/**/*.jsonl) + task state
+(~/.claude/tasks/<sessionId>/*.json). Strictly read-only on sources."""
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .. import ventures
+from . import Emitter, file_changed, record_file
+
+CLAUDE_DIR = Path.home() / ".claude"
+FILE_TOOLS = {"Edit", "Write", "NotebookEdit", "Read"}
+EDIT_TOOLS = {"Edit", "Write", "NotebookEdit"}
+
+
+def _project_of(cwd: str) -> str:
+    if not cwd:
+        return "?"
+    home = str(Path.home())
+    rel = cwd[len(home):].strip("/") if cwd.startswith(home) else cwd
+    return rel or "~"
+
+
+def _first_line(s: str, n: int = 180) -> str:
+    return (s or "").strip().split("\n")[0][:n]
+
+
+def _blocks(msg) -> list:
+    c = (msg or {}).get("content")
+    if isinstance(c, str):
+        return [{"type": "text", "text": c}]
+    return c if isinstance(c, list) else []
+
+
+def _tool_paths(name: str, inp: dict) -> list:
+    paths = []
+    if isinstance(inp, dict):
+        for k in ("file_path", "path", "notebook_path"):
+            if isinstance(inp.get(k), str):
+                paths.append(inp[k])
+    return paths
+
+
+def _parse_line(em: Emitter, d: dict, raw_ref: str) -> None:
+    t = d.get("type")
+    if t not in ("user", "assistant") or d.get("isMeta"):
+        return
+    ts = d.get("timestamp")
+    if not ts:
+        return
+    base = dict(ts=ts, source="cli", session_id=d.get("sessionId"),
+                venture=ventures.attribute(d.get("cwd", "")),
+                project=_project_of(d.get("cwd", "")), raw_ref=raw_ref,
+                is_sidechain=1 if d.get("isSidechain") else 0)
+    msg = d.get("message") or {}
+    if t == "user":
+        texts, results = [], []
+        for b in _blocks(msg):
+            if not isinstance(b, dict):
+                continue
+            if b.get("type") == "text":
+                texts.append(b.get("text") or "")
+            elif b.get("type") == "tool_result":
+                results.append(b)
+        text = "\n".join(x for x in texts if x).strip()
+        if text and not text.startswith(("<system-reminder", "<command-name", "<local-command")):
+            em.emit(kind="prompt", actor="you", summary=_first_line(text), detail=text, **base)
+        for r in results:
+            content = r.get("content")
+            if isinstance(content, list):
+                content = "\n".join(str(x.get("text", "")) for x in content if isinstance(x, dict))
+            content = str(content or "")
+            failed = bool(r.get("is_error"))
+            em.emit(kind="error" if failed else "tool_result", actor="claude",
+                    summary=("FAILED: " if failed else "") + _first_line(content),
+                    detail=content, **base)
+    else:  # assistant
+        if d.get("isApiErrorMessage"):
+            em.emit(kind="error", actor="claude",
+                    summary=f"API error {d.get('apiErrorStatus', '?')}", **base)
+            return
+        for b in _blocks(msg):
+            if not isinstance(b, dict):
+                continue
+            if b.get("type") == "text" and (b.get("text") or "").strip():
+                em.emit(kind="response", actor="claude", summary=_first_line(b["text"]),
+                        detail=b["text"], **base)
+            elif b.get("type") == "tool_use":
+                name = b.get("name", "?")
+                inp = b.get("input") or {}
+                paths = _tool_paths(name, inp)
+                kind = "file_edit" if name in EDIT_TOOLS else "tool_call"
+                hint = paths[0] if paths else _first_line(json.dumps(inp)[:150], 120)
+                em.emit(kind=kind, actor="claude", summary=f"{name}: {hint}",
+                        artifacts=paths or None, **base)
+
+
+def _collect_tasks(em: Emitter, con, session_meta: dict) -> None:
+    tasks_dir = CLAUDE_DIR / "tasks"
+    if not tasks_dir.is_dir():
+        return
+    for f in tasks_dir.glob("*/*.json"):
+        st = f.stat()
+        changed, _ = file_changed(con, str(f), st.st_mtime, st.st_size)
+        if not changed and not em.dry_run:
+            continue
+        try:
+            d = json.loads(f.read_text(errors="replace"))
+        except Exception:
+            continue
+        sid = f.parent.name
+        meta = session_meta.get(sid) or _session_meta_from_db(con, sid)
+        ts = datetime.fromtimestamp(st.st_mtime, timezone.utc).isoformat()
+        em.emit(ts=ts, source="cli", kind="task", actor="claude", session_id=sid,
+                venture=meta.get("venture", "unknown"), project=meta.get("project", "?"),
+                summary=f"[{d.get('status', '?')}] {d.get('subject', '?')}",
+                detail=d.get("description", ""), raw_ref=str(f))
+        if not em.dry_run:
+            record_file(con, str(f), st.st_mtime, st.st_size, 1)
+
+
+def _session_meta_from_db(con, sid: str) -> dict:
+    row = con.execute(
+        "SELECT venture, project FROM events WHERE session_id=? AND venture!='unknown' LIMIT 1",
+        (sid,)).fetchone()
+    return dict(row) if row else {}
+
+
+def collect(con, dry_run: bool = False) -> dict:
+    em = Emitter(con, dry_run)
+    files = sorted((CLAUDE_DIR / "projects").glob("*/*.jsonl"))
+    parsed_files = 0
+    session_meta = {}
+    for f in files:
+        st = f.stat()
+        changed, start_line = file_changed(con, str(f), st.st_mtime, st.st_size)
+        if not changed:
+            continue
+        parsed_files += 1
+        lineno = 0
+        try:
+            with open(f, errors="replace") as fh:
+                for lineno, line in enumerate(fh, 1):
+                    if lineno <= start_line:
+                        continue
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        d = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if d.get("sessionId") and d.get("cwd"):
+                        session_meta[d["sessionId"]] = {
+                            "venture": ventures.attribute(d["cwd"]),
+                            "project": _project_of(d["cwd"])}
+                    _parse_line(em, d, f"{f}:{lineno}")
+        except OSError as e:
+            print(f"  [cli] unreadable {f}: {e}")
+            continue
+        if not dry_run:
+            record_file(con, str(f), st.st_mtime, st.st_size, lineno)
+    _collect_tasks(em, con, session_meta)
+    return {"files_scanned": len(files), "files_parsed": parsed_files,
+            "sessions_seen": len(session_meta),
+            "events_new": em.inserted, "events_seen": em.seen, "dropped": em.dropped}