qwen-base 1.0.0

package/src/hooks/active-hook.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+BASE Hook v2: active-hook-v2.py
+Source: .base/data/projects.json (APEX unified project management)
+Output: <active-awareness> compact summary grouped by priority
+Filters: items with status NOT in [backlog, archived]
+
+Drop-in replacement for active-hook.py. Swap in settings.json when ready.
+Legacy active-hook.py reads from .base/data/active.json (unchanged).
+"""
+
+import sys
+import json
+from pathlib import Path
+from datetime import date, datetime
+
+SURFACE_NAME = "active"
+
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent
+DATA_FILE = WORKSPACE_ROOT / ".base" / "data" / "projects.json"
+
+BEHAVIOR_DIRECTIVE = f"""BEHAVIOR: This context is PASSIVE AWARENESS ONLY.
+Do NOT proactively mention these items unless:
+  - User explicitly asks (e.g., "what should I work on?", "what's next?")
+  - A deadline is within 24 hours AND user hasn't acknowledged it this session
+For details on any item, use base_get_project(id)."""
+
+PRIORITY_ORDER = ["urgent", "high", "medium", "low", "ongoing", "deferred"]
+
+# Staleness thresholds (days since last update)
+STALE_THRESHOLDS = {
+    "urgent": 3,
+    "high": 5,
+    "medium": 7,
+    "low": 14,
+    "ongoing": 14,
+    "deferred": 30,
+}
+
+# Statuses that are NOT active (excluded from active view)
+EXCLUDED_STATUSES = {"backlog", "archived", "completed"}
+
+# Types to exclude from active awareness (checked via MCP during grooms)
+EXCLUDED_TYPES = {"initiative"}
+
+
+def days_since_update(item):
+    """Calculate days since last update. Uses updated_at (ISO datetime)."""
+    ts = item.get("updated_at") or item.get("created_at")
+    if not ts:
+        return None
+    try:
+        d = date.fromisoformat(ts[:10])
+        return (date.today() - d).days
+    except (ValueError, TypeError):
+        return None
+
+
+def main():
+    try:
+        input_data = json.loads(sys.stdin.read())
+    except (json.JSONDecodeError, OSError):
+        pass
+
+    if not DATA_FILE.exists():
+        sys.exit(0)
+
+    try:
+        data = json.loads(DATA_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        sys.exit(0)
+
+    items = data.get("items", [])
+    if not items:
+        sys.exit(0)
+
+    # Filter: only active items (not backlog, archived, completed), exclude initiatives
+    active_items = [i for i in items if i.get("status") not in EXCLUDED_STATUSES and i.get("type") not in EXCLUDED_TYPES]
+    if not active_items:
+        sys.exit(0)
+
+    # Group by priority
+    groups = {}
+    for item in active_items:
+        p = item.get("priority", "medium")
+        groups.setdefault(p, []).append(item)
+
+    # Workload balance header
+    blocked_count = sum(1 for i in active_items if i.get("blocked_by"))
+    ongoing_count = sum(1 for i in active_items if i.get("priority") == "ongoing")
+    deferred_count = sum(1 for i in active_items if i.get("status") == "deferred")
+    working_count = len(active_items) - ongoing_count - deferred_count
+    lines = [f"Load: {working_count} active | {blocked_count} blocked | {ongoing_count} ongoing | {deferred_count} deferred"]
+
+    for priority in PRIORITY_ORDER:
+        group = groups.get(priority, [])
+        if not group:
+            continue
+        lines.append(f"[{priority.upper()}]")
+        for item in group:
+            item_id = item.get("id", "?")
+            title = item.get("title", "untitled")
+            status = item.get("status", "")
+            category = item.get("category", "")
+            cat_tag = f"({category}) " if category else ""
+            parts = [f"- [{item_id}] {cat_tag}{title}"]
+            if status:
+                parts[0] += f" ({status})"
+            # PAUL signal (phase, loop, plan age, handoff) — only if paul data has real values
+            paul_info = item.get("paul")
+            if paul_info and paul_info.get("is_paul_project") and paul_info.get("phase"):
+                paul_parts = []
+                p_phase = paul_info.get("phase", "?")
+                p_completed = paul_info.get("completed_phases", "?")
+                p_total = paul_info.get("total_phases", "?")
+                p_loop = paul_info.get("loop_position", "?")
+                paul_parts.append(f"Phase {p_completed}/{p_total} ({p_phase})")
+                paul_parts.append(str(p_loop))
+                # Plan age
+                last_plan = paul_info.get("last_plan_completed_at") or paul_info.get("last_update")
+                if last_plan:
+                    try:
+                        lp = last_plan.replace("Z", "+00:00")
+                        if "T" in lp:
+                            lp_date = datetime.fromisoformat(lp).date() if hasattr(datetime, 'fromisoformat') else date.fromisoformat(lp[:10])
+                        else:
+                            lp_date = date.fromisoformat(lp)
+                        age = (date.today() - lp_date).days
+                        paul_parts.append(f"plan {age}d ago")
+                    except (ValueError, TypeError):
+                        pass
+                # Handoff flag
+                p_handoff = paul_info.get("handoff")
+                if isinstance(p_handoff, dict) and p_handoff.get("present"):
+                    paul_parts.append("HANDOFF")
+                elif isinstance(p_handoff, bool) and p_handoff:
+                    paul_parts.append("HANDOFF")
+                parts.append(f"  PAUL: {' | '.join(paul_parts)}")
+
+            # Revenue signal
+            rev = item.get("revenue")
+            if rev and rev.get("amount"):
+                rev_type = rev.get("type", "")
+                parts.append(f"  REV: {rev['amount']} ({rev_type})")
+
+            blocked = item.get("blocked_by")
+            if blocked:
+                parts.append(f"  BLOCKED: {blocked}")
+            next_action = item.get("next")
+            if next_action and priority != "ongoing":
+                parts.append(f"  NEXT: {next_action}")
+            deadline = item.get("due_date")
+            if deadline:
+                parts.append(f"  DUE: {deadline}")
+            days = days_since_update(item)
+            threshold = STALE_THRESHOLDS.get(priority, 7)
+            if days is not None:
+                if days >= threshold:
+                    parts.append(f"  STALE: {days}d since update (threshold: {threshold}d)")
+                else:
+                    parts.append(f"  updated: {days}d ago")
+            lines.append("\n".join(parts))
+
+    if lines:
+        count = len(active_items)
+        summary = "\n".join(lines)
+        print(f"""<{SURFACE_NAME}-awareness items="{count}">
+{summary}
+
+{BEHAVIOR_DIRECTIVE}
+</{SURFACE_NAME}-awareness>""")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/src/hooks/apex-insights.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+APEX Insights — On-demand workspace analytics
+Computes velocity, stall detection, blocking analysis, workload, and dependency chains.
+Invoked by /apex: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 / ".base" / "data" / "projects.json"
+WORKSPACE_JSON = WORKSPACE / ".base" / "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 (PAUL Projects)")
+    paul_projects = []
+    for item in items:
+        paul = item.get("paul")
+        if paul and paul.get("is_paul_project") and paul.get("phase"):
+            lp_age = days_ago(paul.get("last_plan_completed_at") or paul.get("last_update"))
+            paul_projects.append({
+                "id": item["id"],
+                "title": item["title"][:35],
+                "phase": f"{paul.get('completed_phases', '?')}/{paul.get('total_phases', '?')}",
+                "loop": paul.get("loop_position", "?"),
+                "last_plan_age": lp_age,
+                "handoff": paul.get("handoff", False),
+                "status": item.get("status"),
+            })
+
+    if paul_projects:
+        for p in sorted(paul_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 PAUL projects found")
+    print()
+
+    # --- STALLS (active projects with plan age > 14d) ---
+    print("## STALLS (plan age > 14 days, not completed/deferred)")
+    stalls = [p for p in paul_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/src/hooks/backlog-hook.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+BASE Hook v2: backlog-hook-v2.py
+Source: .base/data/projects.json (APEX unified project management)
+Output: <backlog-awareness> compact summary grouped by priority
+Filters: only items with status "backlog"
+
+Drop-in replacement for backlog-hook.py. Swap in settings.json when ready.
+Legacy backlog-hook.py reads from .base/data/backlog.json (unchanged).
+"""
+
+import sys
+import json
+from pathlib import Path
+from datetime import date
+
+SURFACE_NAME = "backlog"
+
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent
+DATA_FILE = WORKSPACE_ROOT / ".base" / "data" / "projects.json"
+
+BEHAVIOR_DIRECTIVE = f"""BEHAVIOR: This context is PASSIVE AWARENESS ONLY.
+Do NOT proactively mention these items unless:
+  - User explicitly asks (e.g., "what's in the backlog?", "what's queued?")
+  - A review_by date has passed AND user hasn't acknowledged it this session
+For details on any item, use base_get_project(id)."""
+
+PRIORITY_ORDER = ["high", "medium", "low"]
+
+# Staleness thresholds (days since last update)
+STALE_THRESHOLDS = {
+    "high": 7,
+    "medium": 14,
+    "low": 30,
+}
+
+
+def days_since_update(item):
+    """Calculate days since last update. Uses updated_at (ISO datetime)."""
+    ts = item.get("updated_at") or item.get("created_at")
+    if not ts:
+        return None
+    try:
+        d = date.fromisoformat(ts[:10])
+        return (date.today() - d).days
+    except (ValueError, TypeError):
+        return None
+
+
+def main():
+    try:
+        input_data = json.loads(sys.stdin.read())
+    except (json.JSONDecodeError, OSError):
+        pass
+
+    if not DATA_FILE.exists():
+        sys.exit(0)
+
+    try:
+        data = json.loads(DATA_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        sys.exit(0)
+
+    items = data.get("items", [])
+    if not items:
+        sys.exit(0)
+
+    # Filter: only backlog items
+    backlog_items = [i for i in items if i.get("status") == "backlog"]
+    if not backlog_items:
+        sys.exit(0)
+
+    # Group by priority
+    groups = {}
+    for item in backlog_items:
+        p = item.get("priority", "medium")
+        groups.setdefault(p, []).append(item)
+
+    lines = []
+    for priority in PRIORITY_ORDER:
+        group = groups.get(priority, [])
+        if not group:
+            continue
+        lines.append(f"[{priority.upper()}]")
+        for item in group:
+            item_id = item.get("id", "?")
+            title = item.get("title", "untitled")
+            review_by = item.get("review_by")
+            entry = f"- [{item_id}] {title}"
+            if review_by:
+                entry += f" [review by: {review_by}]"
+            days = days_since_update(item)
+            threshold = STALE_THRESHOLDS.get(priority, 14)
+            if days is not None:
+                if days >= threshold:
+                    entry += f" STALE: {days}d"
+                else:
+                    entry += f" ({days}d ago)"
+            lines.append(entry)
+
+    if lines:
+        count = len(backlog_items)
+        summary = "\n".join(lines)
+        print(f"""<{SURFACE_NAME}-awareness items="{count}">
+{summary}
+
+{BEHAVIOR_DIRECTIVE}
+</{SURFACE_NAME}-awareness>""")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/src/hooks/base-pulse-check.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+BASE Hook v2: base-pulse-check-v2.py
+Purpose: Workspace health check on session start.
+         Reads .base/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: <base-pulse> workspace health status or groom reminder
+
+Drop-in replacement for base-pulse-check.py. Swap in settings.json when ready.
+Legacy base-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 / ".base"
+STATE_FILE = BASE_DIR / "data" / "state.json"
+PROJECTS_FILE = BASE_DIR / "data" / "projects.json"
+CARL_DIR = WORKSPACE_ROOT / ".carl"
+CARL_JSON = CARL_DIR / "carl.json"
+
+
+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 base_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 paul.json timestamps
+    satellites = state.get("satellites", {})
+    stale_sats = 0
+    for name, sat in satellites.items():
+        sat_path = WORKSPACE_ROOT / sat.get("path", "") / ".paul" / "paul.json"
+        if sat_path.exists():
+            try:
+                paul = json.loads(sat_path.read_text())
+                ts = paul.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 main():
+    if not STATE_FILE.exists():
+        sys.exit(0)
+
+    try:
+        state = json.loads(STATE_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        sys.exit(0)
+
+    # Self-heal: recalculate drift from live data every session start
+    state = recalculate_drift(state)
+
+    output_parts = []
+    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"BASE: Workspace groom overdue by {overdue_days} days "
+                    f"(last groom: {last_groom}). "
+                    f"Run /base: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"BASE drift score: {drift_score} | Stale areas: {', '.join(stale_areas)}"
+        )
+    elif drift_score == 0:
+        last_groom = groom.get("last_groom", "unknown")
+        output_parts.append(
+            f"BASE: Drift 0 | Last groom: {last_groom} | All areas current"
+        )
+
+    # CARL hygiene reminder
+    carl_hygiene = state.get("carl_hygiene", {})
+    if carl_hygiene.get("proactive", False):
+        hygiene_cadence = {"weekly": 7, "bi-weekly": 14, "monthly": 30}.get(
+            carl_hygiene.get("cadence", "monthly"), 30
+        )
+        last_run = carl_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"CARL hygiene overdue ({days_since}d since last run). Run /base:carl-hygiene"
+                    )
+            except ValueError:
+                output_parts.append("CARL hygiene: last_run date invalid. Run /base:carl-hygiene")
+        else:
+            output_parts.append("CARL hygiene never run. Run /base:carl-hygiene when ready")
+
+        # Check staging proposals in carl.json
+        if CARL_JSON.exists():
+            try:
+                carl_data = json.loads(CARL_JSON.read_text())
+                pending = [p for p in carl_data.get("staging", []) 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"""<base-pulse>
+{chr(10).join(output_parts)}
+</base-pulse>""")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()