opsroom-console 0.3.0__tar.gz

opsroom_console-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Malek Adjeb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

opsroom_console-0.3.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: opsroom-console
+Version: 0.3.0
+Summary: Local-first operator console: fuses your AI agent sessions (Claude Code, Codex CLI, ChatGPT), git repos, and markdown notes into one dashboard that tells you what to do next.
+Author: Malek Adjeb
+License: MIT
+Project-URL: Homepage, https://github.com/malekadjeb-ai/opsroom
+Project-URL: Issues, https://github.com/malekadjeb-ai/opsroom/issues
+Keywords: dashboard,productivity,founder,claude-code,codex,chatgpt,ai-agents,local-first,obsidian,time-tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ⚡ opsroom
+
+![ci](https://github.com/malekadjeb-ai/opsroom/actions/workflows/ci.yml/badge.svg)
+![python](https://img.shields.io/badge/python-3.11%2B-blue)
+![deps](https://img.shields.io/badge/dependencies-zero-brightgreen)
+![license](https://img.shields.io/badge/license-MIT-green)
+
+**Your AI agents write code all day. opsroom shows you whether any of it pays.**
+
+![opsroom demo — sitrep, by-agent, trap-zone alert](docs/launch/demo.gif)
+
+One console for **every AI coding agent you run** — Claude Code, OpenAI Codex CLI, ChatGPT, Claude web — plus your **git repos** and your **markdown notes** (Obsidian or plain folders), fused into one local dashboard that answers the only question that matters:
+
+> *What should I do right now to make money?*
+
+No cloud. No accounts. No dependencies. One Python package, one SQLite file on your disk, one HTML file as your console.
+
+```
+pipx install git+https://github.com/malekadjeb-ai/opsroom   # or: uv tool install git+https://github.com/malekadjeb-ai/opsroom
+opsroom demo             # see a fully loaded console in 10 seconds (fictional data)
+opsroom init             # wire up YOUR repos, goal, and notes
+opsroom sync && opsroom dash
+```
+
+## What you get
+
+**🎯 NOW — an action queue, not a report.** Drafts staged in your outreach tracker become a send list with an open-your-drafts button. Phone-first targets become tap-to-dial links. Stale leads become a rescue block. The single highest cash action sits on top, pulled from your own dashboard note.
+
+![opsroom console — the NOW action queue](docs/launch/console-now.png)
+
+**🏢 VENTURES — every project, with a brief.** Click any venture: an ordered **DO NEXT** list generated from live pipeline state ("UNBLOCK FIRST: …" when your notes say something's blocking), a **DONE** timeline auto-pulled from your decisions log, live numbers, and every researched target as a searchable click-to-open card — pain hypothesis, decision-makers, phones linked.
+
+**💰 MONEY — the goal math.** Collected vs goal, days left, needed per day. Cash counts only when collected, not quoted.
+
+**📊 ACTIVITY — where your time actually went, by agent.** A **BY AGENT** table (Claude vs Codex vs ChatGPT: sessions, active hours, top venture), sessions per venture, commits, and the two features that hurt (in a good way):
+
+![opsroom ACTIVITY — by agent, drift, open loops](docs/launch/console-activity.png)
+
+- **Trap-zone drift**: time spent in $0-revenue builds vs revenue ventures, with a red alert when building beats selling this week. The engineer's trap, made visible.
+- **Open loops**: things you started and silently dropped — plan language in AI transcripts with no follow-up commit, stale branches, uncommitted work, in-progress notes going stale.
+
+## The sitrep
+
+```
+$ opsroom sitrep
+
+SITREP · 2026-07-16
+
+- DATE / DAYS TO GOAL: 2026-07-16 / 19d
+- CASH COLLECTED vs Q3 $50K sprint: $8,250 collected
+- OPEN LEADS: ~14 aged ~8d
+- LIVE PIPELINE: Meridian: 2 proposals out ($12K + $18K) · 2 drafted, 1 sent, 2 call sheet
+- TOP LEAK RIGHT NOW: ~14 open leads aged ~8d — paid-for money rotting uncalled
+- SINGLE HIGHEST CASH ACTION TODAY: Finish the case-study PDF and send both proposals
+```
+
+Six lines, every morning, from live data. `--write` appends it to a daily note.
+
+## How it works
+
+Read-only collectors, one local SQLite ledger, deterministic rendering:
+
+| Source | What it reads |
+|---|---|
+| `cli` | Claude Code session logs (`~/.claude/projects`) — prompts, duration, outcomes |
+| `codex` | OpenAI Codex CLI session logs (`~/.codex/sessions`) — same treatment, same attribution |
+| `git` | every repo under your scan roots — commits, branches, uncommitted work |
+| `fs` | mtime scan for non-git work |
+| `notes` | your markdown roots — frontmatter, staleness, your dashboard note's `## Live state` table |
+| `chat` | manual drop of a chat export — **both** Claude (Anthropic) and ChatGPT (OpenAI) exports, sniffed by shape |
+
+Attribution is by path: work done in `~/code/acme` counts toward venture `acme`. Sessions are gap-capped active minutes, not wall clock.
+
+### Your notes are the API
+
+opsroom doesn't make you adopt a system — it reads simple markdown conventions you can start using in five minutes:
+
+- A dashboard note with a `## Live state` table (`| Metric | Value | As of |`) — rows are matched by key words (`days to goal`, `cash`, anything with `lead`), never by position, so reformatting won't break it. Ages keep ticking: "aged ~6 days" as-of last week reads correctly today.
+- A `## Today's one move` section → the console's hero action.
+- Pipeline trackers with `## Totals` lines and `## TOUCH LOG` tables (`Target | Channel | Status | Next`) → your send/call queues. Any wide table in the same file → your searchable target list.
+- A `Decisions Log.md` with `- **YYYY-MM-DD** — …` bullets → per-venture DONE timelines.
+
+## Security posture
+
+This tool reads your terminal history and notes, so it's built paranoid:
+
+- **Fail-closed secret redaction** — every event passes a redactor *before* touching the DB (API keys, AWS/GitHub/Slack/Stripe/Google tokens, JWTs, DB URIs, private keys, high-entropy `KEY=value`). If redaction errors, the event is dropped, never written.
+- **No network egress. Ever.** Nothing phones home; the console HTML loads zero external resources. The only URLs are ones *you* configured as buttons.
+- **Local only** — SQLite at `~/.local/share/opsroom` with `600` perms, refuses to live under a cloud-sync root (iCloud/Dropbox/OneDrive).
+- **Read-only on all sources** — your notes are never written; the only writes are the ledger and an optional append-only daily note.
+- `opsroom purge --source=X` / `--before=DATE` to shrink the blast radius any time.
+
+## Philosophy
+
+Built during a 23-day cash sprint by an operator running eight ventures, out of one frustration: every productivity tool tracks *activity*; none of them track *whether the activity pays*. The rules encoded here are blunt:
+
+1. Cash counts when **collected** — not quoted, not booked, not "basically closed".
+2. Building instead of selling is a **trap** — visible on the board, hours counted.
+3. Everything you start and drop is a **loop** — it stays on the board until closed or dismissed.
+4. The console must answer *"what do I do next"* with names, numbers, and buttons — or it's just letters on a screen.
+
+## FAQ
+
+**Do I need Claude Code / Codex / Obsidian?** No. Every source is optional and degrades gracefully. Git repos alone give you drift + loops + sessions; add notes when you want the money features.
+
+**Which AI agents are supported?** Claude Code and OpenAI Codex CLI are read live from their local logs. ChatGPT and Claude web/desktop ingest via each vendor's data-export file dropped in a folder. Gemini CLI and Cursor are next — collectors are ~100-line files with one `collect(con)` entry point, PRs welcome.
+
+**macOS says the notes are unreadable.** Grant your terminal Full Disk Access. If access drops mid-session, opsroom serves the last cached snapshot and says so.
+
+**Windows?** WSL works. Native Windows is untested.
+
+## Development
+
+```
+git clone https://github.com/malekadjeb-ai/opsroom && cd opsroom
+for t in tests/test_*.py; do python "$t" || break; done   # five gates, all must print green
+python -m opsroom.cli demo
+```
+
+Stdlib only — there is nothing to `pip install` for development. MIT license.

opsroom_console-0.3.0/README.md

@@ -0,0 +1,120 @@
+# ⚡ opsroom
+
+![ci](https://github.com/malekadjeb-ai/opsroom/actions/workflows/ci.yml/badge.svg)
+![python](https://img.shields.io/badge/python-3.11%2B-blue)
+![deps](https://img.shields.io/badge/dependencies-zero-brightgreen)
+![license](https://img.shields.io/badge/license-MIT-green)
+
+**Your AI agents write code all day. opsroom shows you whether any of it pays.**
+
+![opsroom demo — sitrep, by-agent, trap-zone alert](docs/launch/demo.gif)
+
+One console for **every AI coding agent you run** — Claude Code, OpenAI Codex CLI, ChatGPT, Claude web — plus your **git repos** and your **markdown notes** (Obsidian or plain folders), fused into one local dashboard that answers the only question that matters:
+
+> *What should I do right now to make money?*
+
+No cloud. No accounts. No dependencies. One Python package, one SQLite file on your disk, one HTML file as your console.
+
+```
+pipx install git+https://github.com/malekadjeb-ai/opsroom   # or: uv tool install git+https://github.com/malekadjeb-ai/opsroom
+opsroom demo             # see a fully loaded console in 10 seconds (fictional data)
+opsroom init             # wire up YOUR repos, goal, and notes
+opsroom sync && opsroom dash
+```
+
+## What you get
+
+**🎯 NOW — an action queue, not a report.** Drafts staged in your outreach tracker become a send list with an open-your-drafts button. Phone-first targets become tap-to-dial links. Stale leads become a rescue block. The single highest cash action sits on top, pulled from your own dashboard note.
+
+![opsroom console — the NOW action queue](docs/launch/console-now.png)
+
+**🏢 VENTURES — every project, with a brief.** Click any venture: an ordered **DO NEXT** list generated from live pipeline state ("UNBLOCK FIRST: …" when your notes say something's blocking), a **DONE** timeline auto-pulled from your decisions log, live numbers, and every researched target as a searchable click-to-open card — pain hypothesis, decision-makers, phones linked.
+
+**💰 MONEY — the goal math.** Collected vs goal, days left, needed per day. Cash counts only when collected, not quoted.
+
+**📊 ACTIVITY — where your time actually went, by agent.** A **BY AGENT** table (Claude vs Codex vs ChatGPT: sessions, active hours, top venture), sessions per venture, commits, and the two features that hurt (in a good way):
+
+![opsroom ACTIVITY — by agent, drift, open loops](docs/launch/console-activity.png)
+
+- **Trap-zone drift**: time spent in $0-revenue builds vs revenue ventures, with a red alert when building beats selling this week. The engineer's trap, made visible.
+- **Open loops**: things you started and silently dropped — plan language in AI transcripts with no follow-up commit, stale branches, uncommitted work, in-progress notes going stale.
+
+## The sitrep
+
+```
+$ opsroom sitrep
+
+SITREP · 2026-07-16
+
+- DATE / DAYS TO GOAL: 2026-07-16 / 19d
+- CASH COLLECTED vs Q3 $50K sprint: $8,250 collected
+- OPEN LEADS: ~14 aged ~8d
+- LIVE PIPELINE: Meridian: 2 proposals out ($12K + $18K) · 2 drafted, 1 sent, 2 call sheet
+- TOP LEAK RIGHT NOW: ~14 open leads aged ~8d — paid-for money rotting uncalled
+- SINGLE HIGHEST CASH ACTION TODAY: Finish the case-study PDF and send both proposals
+```
+
+Six lines, every morning, from live data. `--write` appends it to a daily note.
+
+## How it works
+
+Read-only collectors, one local SQLite ledger, deterministic rendering:
+
+| Source | What it reads |
+|---|---|
+| `cli` | Claude Code session logs (`~/.claude/projects`) — prompts, duration, outcomes |
+| `codex` | OpenAI Codex CLI session logs (`~/.codex/sessions`) — same treatment, same attribution |
+| `git` | every repo under your scan roots — commits, branches, uncommitted work |
+| `fs` | mtime scan for non-git work |
+| `notes` | your markdown roots — frontmatter, staleness, your dashboard note's `## Live state` table |
+| `chat` | manual drop of a chat export — **both** Claude (Anthropic) and ChatGPT (OpenAI) exports, sniffed by shape |
+
+Attribution is by path: work done in `~/code/acme` counts toward venture `acme`. Sessions are gap-capped active minutes, not wall clock.
+
+### Your notes are the API
+
+opsroom doesn't make you adopt a system — it reads simple markdown conventions you can start using in five minutes:
+
+- A dashboard note with a `## Live state` table (`| Metric | Value | As of |`) — rows are matched by key words (`days to goal`, `cash`, anything with `lead`), never by position, so reformatting won't break it. Ages keep ticking: "aged ~6 days" as-of last week reads correctly today.
+- A `## Today's one move` section → the console's hero action.
+- Pipeline trackers with `## Totals` lines and `## TOUCH LOG` tables (`Target | Channel | Status | Next`) → your send/call queues. Any wide table in the same file → your searchable target list.
+- A `Decisions Log.md` with `- **YYYY-MM-DD** — …` bullets → per-venture DONE timelines.
+
+## Security posture
+
+This tool reads your terminal history and notes, so it's built paranoid:
+
+- **Fail-closed secret redaction** — every event passes a redactor *before* touching the DB (API keys, AWS/GitHub/Slack/Stripe/Google tokens, JWTs, DB URIs, private keys, high-entropy `KEY=value`). If redaction errors, the event is dropped, never written.
+- **No network egress. Ever.** Nothing phones home; the console HTML loads zero external resources. The only URLs are ones *you* configured as buttons.
+- **Local only** — SQLite at `~/.local/share/opsroom` with `600` perms, refuses to live under a cloud-sync root (iCloud/Dropbox/OneDrive).
+- **Read-only on all sources** — your notes are never written; the only writes are the ledger and an optional append-only daily note.
+- `opsroom purge --source=X` / `--before=DATE` to shrink the blast radius any time.
+
+## Philosophy
+
+Built during a 23-day cash sprint by an operator running eight ventures, out of one frustration: every productivity tool tracks *activity*; none of them track *whether the activity pays*. The rules encoded here are blunt:
+
+1. Cash counts when **collected** — not quoted, not booked, not "basically closed".
+2. Building instead of selling is a **trap** — visible on the board, hours counted.
+3. Everything you start and drop is a **loop** — it stays on the board until closed or dismissed.
+4. The console must answer *"what do I do next"* with names, numbers, and buttons — or it's just letters on a screen.
+
+## FAQ
+
+**Do I need Claude Code / Codex / Obsidian?** No. Every source is optional and degrades gracefully. Git repos alone give you drift + loops + sessions; add notes when you want the money features.
+
+**Which AI agents are supported?** Claude Code and OpenAI Codex CLI are read live from their local logs. ChatGPT and Claude web/desktop ingest via each vendor's data-export file dropped in a folder. Gemini CLI and Cursor are next — collectors are ~100-line files with one `collect(con)` entry point, PRs welcome.
+
+**macOS says the notes are unreadable.** Grant your terminal Full Disk Access. If access drops mid-session, opsroom serves the last cached snapshot and says so.
+
+**Windows?** WSL works. Native Windows is untested.
+
+## Development
+
+```
+git clone https://github.com/malekadjeb-ai/opsroom && cd opsroom
+for t in tests/test_*.py; do python "$t" || break; done   # five gates, all must print green
+python -m opsroom.cli demo
+```
+
+Stdlib only — there is nothing to `pip install` for development. MIT license.

opsroom_console-0.3.0/opsroom/__init__.py

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

opsroom_console-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_console-0.3.0/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))