@accelerationguy/accel 1.0.0

package/modules/momentum/src/hooks/mission-control-insights.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+Mission Control Insights — On-demand workspace analytics
+Computes velocity, stall detection, blocking analysis, workload, and dependency chains.
+Invoked by /accel:insights slash command via !command injection.
+"""
+
+import json
+import sys
+from datetime import datetime, date
+from pathlib import Path
+from collections import defaultdict
+
+WORKSPACE = Path(__file__).resolve().parent.parent.parent
+PROJECTS_FILE = WORKSPACE / ".accel/momentum" / "data" / "projects.json"
+WORKSPACE_JSON = WORKSPACE / ".accel/momentum" / "workspace.json"
+
+
+def load_json(path):
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def days_ago(iso_str):
+    if not iso_str:
+        return None
+    try:
+        s = iso_str.replace("Z", "+00:00")
+        if "T" in s:
+            d = datetime.fromisoformat(s).date()
+        else:
+            d = date.fromisoformat(s[:10])
+        return (date.today() - d).days
+    except (ValueError, TypeError):
+        return None
+
+
+def main():
+    projects = load_json(PROJECTS_FILE)
+    workspace = load_json(WORKSPACE_JSON)
+
+    if not projects:
+        print("ERROR: Cannot read projects.json")
+        sys.exit(0)
+
+    items = projects.get("items", [])
+    satellites = (workspace or {}).get("satellites", {})
+
+    # --- VELOCITY ---
+    print("## VELOCITY (Drive Projects)")
+    drive_projects = []
+    for item in items:
+        drive = item.get("drive")
+        if drive and drive.get("is_drive_project") and drive.get("phase"):
+            lp_age = days_ago(drive.get("last_plan_completed_at") or drive.get("last_update"))
+            drive_projects.append({
+                "id": item["id"],
+                "title": item["title"][:35],
+                "phase": f"{drive.get('completed_phases', '?')}/{drive.get('total_phases', '?')}",
+                "loop": drive.get("loop_position", "?"),
+                "last_plan_age": lp_age,
+                "handoff": drive.get("handoff", False),
+                "status": item.get("status"),
+            })
+
+    if drive_projects:
+        for p in sorted(drive_projects, key=lambda x: (x["last_plan_age"] or 0), reverse=True):
+            age_str = f"{p['last_plan_age']}d ago" if p["last_plan_age"] is not None else "never"
+            hf = " [HANDOFF]" if (isinstance(p["handoff"], dict) and p["handoff"].get("present")) or p["handoff"] is True else ""
+            print(f"  {p['id']} {p['title']:35s} Phase {p['phase']:8s} {p['loop']:5s} plan: {age_str}{hf}")
+    else:
+        print("  No Drive projects found")
+    print()
+
+    # --- STALLS (active projects with plan age > 14d) ---
+    print("## STALLS (plan age > 14 days, not completed/deferred)")
+    stalls = [p for p in drive_projects
+              if p["last_plan_age"] is not None
+              and p["last_plan_age"] > 14
+              and p["status"] not in ("completed", "deferred", "archived")]
+    if stalls:
+        for s in sorted(stalls, key=lambda x: x["last_plan_age"], reverse=True):
+            print(f"  {s['id']} {s['title']:35s} STALLED {s['last_plan_age']}d")
+    else:
+        print("  No stalls detected")
+    print()
+
+    # --- BLOCKING ANALYSIS ---
+    print("## BLOCKING ANALYSIS")
+    blocked = [i for i in items if i.get("blocked_by") and i.get("status") not in ("completed", "archived")]
+    if blocked:
+        # Group by blocker
+        blockers = defaultdict(list)
+        for item in blocked:
+            blockers[item["blocked_by"]].append(item)
+
+        for blocker, items_blocked in blockers.items():
+            rev_items = [i for i in items_blocked if i.get("revenue")]
+            rev_str = ""
+            if rev_items:
+                rev_str = f" | Revenue at risk: {', '.join(i['revenue']['amount'] for i in rev_items)}"
+            print(f"  Blocker: {blocker}")
+            for i in items_blocked:
+                print(f"    {i['id']} {i['title'][:40]}")
+            if rev_str:
+                print(f"    {rev_str}")
+            print()
+    else:
+        print("  No blocked projects")
+    print()
+
+    # --- DEPENDENCIES ---
+    print("## CROSS-PROJECT DEPENDENCIES")
+    has_deps = [i for i in items if i.get("dependencies")]
+    if has_deps:
+        for item in has_deps:
+            for dep in item["dependencies"]:
+                dep_project = next((i for i in items if i["id"] == dep["project_id"]), None)
+                dep_title = dep_project["title"][:30] if dep_project else dep["project_id"]
+                print(f"  {item['id']} {item['title'][:30]} --{dep['type']}--> {dep_title}")
+                if dep.get("notes"):
+                    print(f"    Note: {dep['notes']}")
+    else:
+        print("  No cross-project dependencies defined")
+    print()
+
+    # --- WORKLOAD BY CATEGORY ---
+    print("## WORKLOAD BY CATEGORY")
+    active = [i for i in items if i.get("status") not in ("backlog", "archived", "completed") and i.get("type") != "initiative"]
+    cats = defaultdict(int)
+    for item in active:
+        cats[item.get("category", "uncategorized")] += 1
+    for cat, count in sorted(cats.items(), key=lambda x: -x[1]):
+        print(f"  {cat}: {count} projects")
+    print()
+
+    # --- REVENUE SUMMARY ---
+    print("## REVENUE EXPOSURE")
+    rev_projects = [i for i in items if i.get("revenue") and i.get("status") not in ("completed", "archived")]
+    if rev_projects:
+        for item in rev_projects:
+            rev = item["revenue"]
+            status = item.get("status", "?")
+            blocked_flag = " [BLOCKED]" if item.get("blocked_by") else ""
+            print(f"  {item['id']} {item['title'][:35]} | {rev['amount']} ({rev['type']}){blocked_flag}")
+    else:
+        print("  No revenue projects active")
+    print()
+
+    # --- HANDOFFS ---
+    print("## PENDING HANDOFFS")
+    handoff_sats = [(name, sat) for name, sat in satellites.items() if sat.get("handoff")]
+    if handoff_sats:
+        for name, sat in handoff_sats:
+            phase = sat.get("phase_name", "?")
+            print(f"  {name}: Phase {phase} — has HANDOFF waiting")
+    else:
+        print("  No pending handoffs")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"ERROR: {e}")
+        sys.exit(0)

package/modules/momentum/src/hooks/momentum-pulse-check.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+Momentum Hook v2: momentum-pulse-check.py
+Purpose: Workspace health check on session start.
+         Reads .accel/momentum/data/state.json (pre-calculated drift, areas, groom config).
+         Much simpler than v1 which parsed STATE.md text + computed drift from file mtimes.
+Triggers: UserPromptSubmit (session context)
+Output: <momentum-pulse> workspace health status or groom reminder
+
+Drop-in replacement for momentum-pulse-check.py. Swap in settings.json when ready.
+Legacy momentum-pulse-check.py reads STATE.md + workspace.json (unchanged).
+"""
+
+import sys
+import json
+from datetime import datetime, date
+from pathlib import Path
+
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent
+BASE_DIR = WORKSPACE_ROOT / ".accel/momentum"
+STATE_FILE = BASE_DIR / "data" / "state.json"
+PROJECTS_FILE = BASE_DIR / "data" / "projects.json"
+STAGING_FILE = BASE_DIR / "data" / "staging.json"
+EVENTS_DIR = Path.home() / ".accel" / "events"
+ARCHIVE_DIR = EVENTS_DIR / "archive"
+BACKLOG_DIR = BASE_DIR / "data" / "backlog"
+
+
+def recalculate_drift(state):
+    """Recalculate drift indicators from live data and update state.json.
+
+    This ensures drift score is always fresh on session start, not stale
+    from the last time momentum_update_drift was manually called.
+    """
+    now = date.today()
+
+    # Calculate indicators from projects.json
+    indicators = {
+        "active_age_days": 0,
+        "backlog_age_days": 0,
+        "backlog_past_review": 0,
+        "orphaned_sessions": 0,
+        "untracked_root_files": 0,
+        "stale_satellites": 0,
+    }
+
+    if PROJECTS_FILE.exists():
+        try:
+            projects = json.loads(PROJECTS_FILE.read_text())
+            items = projects.get("items", [])
+
+            # Active staleness: max days since update for active/in_progress/blocked/in_review projects
+            active_statuses = {"in_progress", "blocked", "in_review", "todo"}
+            active_ages = []
+            backlog_ages = []
+            past_review = 0
+
+            for item in items:
+                if item.get("type") != "project":
+                    continue
+
+                updated = item.get("updated_at")
+                if updated:
+                    try:
+                        updated_date = datetime.fromisoformat(updated).date()
+                        age = (now - updated_date).days
+                    except (ValueError, TypeError):
+                        age = 0
+                else:
+                    age = 0
+
+                status = item.get("status", "")
+                if status in active_statuses:
+                    active_ages.append(age)
+                elif status == "backlog":
+                    backlog_ages.append(age)
+
+                # Check review_by dates
+                review_by = item.get("review_by")
+                if review_by:
+                    try:
+                        review_date = date.fromisoformat(review_by)
+                        if now > review_date:
+                            past_review += 1
+                    except (ValueError, TypeError):
+                        pass
+
+            indicators["active_age_days"] = max(active_ages) if active_ages else 0
+            indicators["backlog_age_days"] = max(backlog_ages) if backlog_ages else 0
+            indicators["backlog_past_review"] = past_review
+
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Stale satellites: check drive.json timestamps
+    satellites = state.get("satellites", {})
+    stale_sats = 0
+    for name, sat in satellites.items():
+        sat_path = WORKSPACE_ROOT / sat.get("path", "") / ".drive" / "drive.json"
+        if sat_path.exists():
+            try:
+                drive = json.loads(sat_path.read_text())
+                ts = drive.get("timestamps", {}).get("updated_at")
+                if ts:
+                    updated_date = datetime.fromisoformat(ts).date()
+                    if (now - updated_date).days > 14:
+                        stale_sats += 1
+            except (json.JSONDecodeError, OSError, ValueError):
+                pass
+    indicators["stale_satellites"] = stale_sats
+
+    # Compute score as sum of indicators
+    score = sum(v for v in indicators.values() if isinstance(v, (int, float)))
+
+    # Write back to state
+    if "drift" not in state:
+        state["drift"] = {}
+    state["drift"]["score"] = score
+    state["drift"]["indicators"] = indicators
+
+    try:
+        state["last_modified"] = datetime.now().isoformat()
+        STATE_FILE.write_text(json.dumps(state, indent=2))
+    except OSError:
+        pass
+
+    return state
+
+
+def _consume_events(event_types=None):
+    """
+    Read and archive matching event files from ~/.accel/events/.
+
+    Same logic as shared/events/event_bus.py consume() — inlined here so
+    this hook has zero import dependencies outside the stdlib.
+    """
+    consumed = []
+    if not EVENTS_DIR.is_dir():
+        return consumed
+
+    ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
+
+    files = sorted(
+        f for f in EVENTS_DIR.iterdir()
+        if f.is_file() and f.suffix == ".json"
+    )
+
+    for filepath in files:
+        try:
+            event = json.loads(filepath.read_text())
+            if event_types and event.get("type") not in event_types:
+                continue
+            consumed.append({"file": filepath.name, "event": event})
+            # Move to archive
+            filepath.rename(ARCHIVE_DIR / filepath.name)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    return consumed
+
+
+def _process_pending_events():
+    """
+    Consume pending events from the event bus and translate them into
+    Momentum state changes and backlog items.
+
+    Processes:
+      - audit-complete  -> create backlog item under .accel/momentum/data/backlog/
+      - phase-progress  -> update state.json currentPhase / phases
+      - plan-created    -> informational notice in pulse output
+
+    Returns list of human-readable summary strings for pulse output.
+    """
+    summaries = []
+
+    # ── audit-complete events (Radar -> Momentum) ──
+    audit_events = _consume_events(["audit-complete"])
+    for item in audit_events:
+        ev = item["event"]
+        payload = ev.get("payload", {})
+        findings = payload.get("findings", 0)
+        critical = payload.get("critical", 0)
+        report = payload.get("report", "")
+
+        BACKLOG_DIR.mkdir(parents=True, exist_ok=True)
+        backlog_item = {
+            "id": f"radar-{int(datetime.now().timestamp() * 1000)}",
+            "type": "audit-finding",
+            "source": "radar",
+            "title": f"Radar found {findings} issue{'s' if findings != 1 else ''} ({critical} critical)",
+            "priority": "high" if critical > 0 else "medium",
+            "report": report,
+            "createdAt": datetime.now().isoformat(),
+            "status": "open",
+        }
+        item_path = BACKLOG_DIR / f"{backlog_item['id']}.json"
+        try:
+            item_path.write_text(json.dumps(backlog_item, indent=2))
+        except OSError:
+            pass
+
+        summaries.append(
+            f"Event: Radar audit — {findings} findings, {critical} critical → backlog item created"
+        )
+
+    # ── phase-progress events (Drive -> Momentum) ──
+    phase_events = _consume_events(["phase-progress"])
+    for item in phase_events:
+        ev = item["event"]
+        payload = ev.get("payload", {})
+        phase = payload.get("phase", "unknown")
+        status = payload.get("status", "unknown")
+
+        # Update state.json if it exists
+        if STATE_FILE.exists():
+            try:
+                state = json.loads(STATE_FILE.read_text())
+                state["currentPhase"] = phase
+                state["lastUpdated"] = datetime.now().isoformat()
+                if status == "completed":
+                    if "phases" not in state:
+                        state["phases"] = []
+                    state["phases"].append({
+                        "phase": phase,
+                        "completedAt": datetime.now().isoformat(),
+                    })
+                STATE_FILE.write_text(json.dumps(state, indent=2))
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        summaries.append(f"Event: Drive phase \"{phase}\" → {status}")
+
+    # ── plan-created events (Ignition -> Drive/Momentum) ──
+    plan_events = _consume_events(["plan-created"])
+    for item in plan_events:
+        ev = item["event"]
+        payload = ev.get("payload", {})
+        title = payload.get("title", "untitled")
+        project_type = payload.get("projectType", "unknown")
+        summaries.append(
+            f"Event: Ignition plan created — \"{title}\" ({project_type})"
+        )
+
+    return summaries
+
+
+def main():
+    # ── Process pending cross-module events ──
+    event_summaries = _process_pending_events()
+
+    if not STATE_FILE.exists():
+        # Even without state, report any events that were processed
+        if event_summaries:
+            print(f"""<momentum-pulse>
+{chr(10).join(event_summaries)}
+</momentum-pulse>""")
+        sys.exit(0)
+
+    try:
+        state = json.loads(STATE_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        if event_summaries:
+            print(f"""<momentum-pulse>
+{chr(10).join(event_summaries)}
+</momentum-pulse>""")
+        sys.exit(0)
+
+    # Self-heal: recalculate drift from live data every session start
+    state = recalculate_drift(state)
+
+    output_parts = []
+
+    # Include event summaries at the top of pulse output
+    output_parts.extend(event_summaries)
+
+    now = date.today()
+
+    # Check groom overdue
+    groom = state.get("groom", {})
+    next_due = groom.get("next_groom_due")
+    if next_due:
+        try:
+            due_date = date.fromisoformat(next_due)
+            if now > due_date:
+                last_groom = groom.get("last_groom", "unknown")
+                overdue_days = (now - due_date).days
+                output_parts.append(
+                    f"Momentum: Workspace groom overdue by {overdue_days} days "
+                    f"(last groom: {last_groom}). "
+                    f"Run /momentum:groom to maintain workspace health."
+                )
+        except ValueError:
+            pass
+
+    # Drift score and stale areas
+    drift = state.get("drift", {})
+    drift_score = drift.get("score", 0)
+    areas = state.get("areas", {})
+    stale_areas = [name for name, area in areas.items() if area.get("status") in ("stale", "critical")]
+
+    if stale_areas:
+        output_parts.append(
+            f"Momentum drift score: {drift_score} | Stale areas: {', '.join(stale_areas)}"
+        )
+    elif drift_score == 0:
+        last_groom = groom.get("last_groom", "unknown")
+        output_parts.append(
+            f"Momentum: Drift 0 | Last groom: {last_groom} | All areas current"
+        )
+
+    # Vector hygiene reminder
+    vector_hygiene = state.get("vector_hygiene", state.get("carl_hygiene", {}))
+    if vector_hygiene.get("proactive", False):
+        hygiene_cadence = {"weekly": 7, "bi-weekly": 14, "monthly": 30}.get(
+            vector_hygiene.get("cadence", "monthly"), 30
+        )
+        last_run = vector_hygiene.get("last_run")
+        if last_run:
+            try:
+                last_run_date = date.fromisoformat(last_run)
+                days_since = (now - last_run_date).days
+                if days_since > hygiene_cadence:
+                    output_parts.append(
+                        f"Vector hygiene overdue ({days_since}d since last run). Run /momentum:vector-hygiene"
+                    )
+            except ValueError:
+                output_parts.append("Vector hygiene: last_run date invalid. Run /momentum:vector-hygiene")
+        else:
+            output_parts.append("Vector hygiene never run. Run /momentum:vector-hygiene when ready")
+
+        # Check staging proposals
+        if STAGING_FILE.exists():
+            try:
+                staging = json.loads(STAGING_FILE.read_text())
+                pending = [p for p in staging.get("proposals", []) if p.get("status") == "pending"]
+                if pending:
+                    output_parts[-1] += f" | {len(pending)} staged proposals pending"
+            except (json.JSONDecodeError, OSError):
+                pass
+
+    if output_parts:
+        print(f"""<momentum-pulse>
+{chr(10).join(output_parts)}
+</momentum-pulse>""")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/modules/momentum/src/hooks/operator.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Momentum Hook: operator.py
+Source: .accel/momentum/operator.json
+Output: <operator> compact identity summary for alignment context
+Controlled by: hook_active field in operator.json (true/false)
+"""
+
+import json
+from pathlib import Path
+
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent
+DATA_FILE = WORKSPACE_ROOT / ".accel/momentum" / "operator.json"
+
+
+def main():
+    if not DATA_FILE.exists():
+        return
+
+    try:
+        data = json.loads(DATA_FILE.read_text())
+    except (json.JSONDecodeError, IOError):
+        return
+
+    # Check activation flag
+    if not data.get("hook_active", False):
+        return
+
+    # Extract high-signal fields
+    north_star = data.get("north_star", {}).get("metric", "Not set")
+    timeframe = data.get("north_star", {}).get("timeframe", "")
+    deep_why = data.get("deep_why", {}).get("statement", "Not set")
+    values = [v.get("value", "") for v in data.get("key_values", {}).get("values", [])]
+    vision = data.get("surface_vision", {}).get("summary", "Not set")
+    pitch = data.get("elevator_pitch", {}).get("pitch", "Not set")
+
+    values_str = ", ".join(values) if values else "Not set"
+    star_str = f"{north_star} ({timeframe})" if timeframe else north_star
+
+    output = f"""<operator>
+North Star: {star_str}
+Deep Why: {deep_why}
+Values: {values_str}
+Vision: {vision}
+Pitch: {pitch}
+</operator>"""
+
+    print(output)
+
+
+if __name__ == "__main__":
+    main()

package/modules/momentum/src/hooks/psmm-injector.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Hook: psmm-injector.py
+Purpose: Per-Session Meta Memory — inject ephemeral session observations
+         into every prompt so they stay hot in long sessions (1M window).
+
+         Uses a single psmm.json file with session-keyed entries.
+         Each session gets its own array keyed by Claude Code session UUID.
+         Stale sessions are NOT auto-cleaned — that's the operator's job
+         via Vector hygiene / Momentum drift detection.
+
+Triggers: UserPromptSubmit
+Output: Current session's PSMM entries as system context, or silent if empty.
+"""
+
+import sys
+import json
+from pathlib import Path
+
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent
+PSMM_FILE = WORKSPACE_ROOT / ".accel/momentum" / "data" / "psmm.json"
+
+
+def main():
+    # Get session_id from hook input
+    try:
+        input_data = json.loads(sys.stdin.read())
+        session_id = input_data.get("session_id", "")
+    except (json.JSONDecodeError, OSError):
+        session_id = ""
+
+    if not session_id or not PSMM_FILE.exists():
+        sys.exit(0)
+
+    try:
+        data = json.loads(PSMM_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        sys.exit(0)
+
+    sessions = data.get("sessions", {})
+    session = sessions.get(session_id)
+
+    if not session or not session.get("entries"):
+        sys.exit(0)
+
+    # Build output from this session's entries
+    entries = session["entries"]
+    lines = []
+    for entry in entries:
+        entry_type = entry.get("type", "NOTE")
+        text = entry.get("text", "")
+        timestamp = entry.get("timestamp", "")
+        lines.append(f"- [{timestamp}] {entry_type}: {text}")
+
+    if lines:
+        created = session.get("created", "unknown")
+        count = len(entries)
+        print(f"""<psmm session="{session_id[:8]}" entries="{count}" created="{created}">
+{chr(10).join(lines)}
+</psmm>""")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()