@xmarts/genius-setup 1.9.0 → 1.10.0

package/bin/genius-setup.js

@@ -150,6 +150,7 @@ function runSetup(token) {
   const hookDst = copyHook('genius_capture.py');
   const injectDst = copyHook('genius_inject.py');
   const guardDst = copyHook('plan_committee_guard.py');
+  const presenceDst = copyHook('genius_presence.py');
 
   // 2) ~/.claude.json mcpServers (merge, no clobber)
   const claudeJsonPath = path.join(HOME, '.claude.json');
@@ -187,6 +188,18 @@ function runSetup(token) {
   // (XMA_PLAN_GUARD_MODE=block|warn|off). Unlike the fire-and-forget hooks above, this
   // one can return {"decision":"block"} — by design — but never traps a session.
   addHook('Stop', guardDst);
+  // Presence heartbeat (time-tracking "amarre"): binds worked time to THIS machine's
+  // clock — counts VSCode edits + executing loops/workflows, excludes idle-open VSCode.
+  // Unlike every hook above, this is a LONG-LIVED daemon (loops up to ~18h), so it MUST be
+  // launched DETACHED (nohup ... & disown) — never as a blocking `python3 X || true`, which
+  // would freeze every SessionStart. A single-instance lock + self-terminate make repeated
+  // SessionStart launches safe. POSIX form; mirrors the proven admin-bootstrap installer.
+  settings.hooks.SessionStart = settings.hooks.SessionStart || [];
+  if (!JSON.stringify(settings.hooks.SessionStart).includes('genius_presence.py')) {
+    const presenceCmd = 'nohup python3 ' + JSON.stringify(presenceDst) +
+      ' --cwd "${CLAUDE_PROJECT_DIR:-$PWD}" >/dev/null 2>&1 & disown 2>/dev/null; true';
+    settings.hooks.SessionStart.push({ hooks: [{ type: 'command', command: presenceCmd }] });
+  }
   writeJson(settingsPath, settings);
 
   // 4) ~/.claude/CLAUDE.md — install/refresh the Genius Protocol between auto-managed
@@ -309,6 +322,7 @@ function runSetup(token) {
   log('  - Capture hook   : ' + hookDst + '  (SessionEnd / PreCompact / Stop)');
   log('  - Inject hook    : ' + injectDst + '  (UserPromptSubmit / SessionStart)');
   log('  - Plan/committee : ' + guardDst + '  (Stop — enforces plan/comité → Brain; XMA_PLAN_GUARD_MODE=block|warn|off)');
+  log('  - Presence       : ' + presenceDst + '  (SessionStart, detached — honest time-tracking amarre)');
   log('  - Config         : ' + path.join(GENIUS_DIR, 'config.json'));
   log('  - Protocol       : ' + path.join(CLAUDE_DIR, 'CLAUDE.md') + '  (auto-managed)');
   if (CLIENT) log('  - Default client : ' + CLIENT);

package/hooks/genius_presence.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Genius presence heartbeat (amarre v2, Phase 2) — CONSERVATIVE.
+
+Emits one presence ping (~every PING_INTERVAL) to the Genius capture/presence endpoint
+ONLY when there is REAL recent activity, so it binds worked-time to the consultant's
+machine clock without counting an idle-open VSCode:
+
+  ACTIVE  := a workspace SOURCE file was edited in the last IDLE_WINDOW   (human work)
+          OR the Claude transcript / agent files grew in the last IDLE_WINDOW
+             (a /loop or Workflow is executing — counts even with no human interaction)
+  IDLE    := neither -> NO ping (VSCode open but nothing running is NOT counted)
+
+Metadata only: workspace path + git branch (for project classification + retroactive
+attribution) + machine-clock timestamp + tz. No transcript content. Never blocks, always
+exit 0. Single-instance per machine (lockfile). Self-terminates when the Claude session
+is gone (transcript dir idle > STOP_IDLE) or after MAX_LIFETIME.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+import urllib.request
+
+HOME = os.path.expanduser("~")
+CFG = os.path.join(HOME, ".genius", "config.json")
+LOCK = os.path.join(HOME, ".genius", "presence.lock")
+STOP_FLAG = os.path.join(HOME, ".genius", "presence.stop")
+PROJECTS = os.path.join(HOME, ".claude", "projects")
+
+PING_INTERVAL = 300        # 5 min between ticks
+IDLE_WINDOW = 600          # a file touched in the last 10 min => active this tick
+STOP_IDLE = 2700           # Claude dir quiet 45 min => session over, exit
+MAX_LIFETIME = 18 * 3600   # hard stop
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".next", "dist", "build",
+             ".venv", "venv", ".mypy_cache", ".pytest_cache", "outbox"}
+
+
+def _cfg():
+    try:
+        with open(CFG) as fh:
+            return json.load(fh)
+    except Exception:
+        return {}
+
+
+def _recent(path, window_s, budget_s=2.0):
+    """True if any non-skipped file under path has mtime within window_s. Bounded by a
+    small wall-clock budget so a huge tree never stalls a tick. Early-returns."""
+    cutoff = time.time() - window_s
+    deadline = time.time() + budget_s
+    try:
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+            for f in files:
+                try:
+                    if os.path.getmtime(os.path.join(root, f)) >= cutoff:
+                        return True
+                except OSError:
+                    pass
+            if time.time() > deadline:
+                break
+    except OSError:
+        pass
+    return False
+
+
+def _project_dir(cwd):
+    """Best-effort: the ~/.claude/projects/<slug> dir for this cwd, else the most
+    recently-modified project dir (the active session)."""
+    slug = re.sub(r"[^A-Za-z0-9]+", "-", cwd)
+    cand = os.path.join(PROJECTS, slug)
+    if os.path.isdir(cand):
+        return cand
+    # fallback: most-recently-touched project dir
+    try:
+        best, best_m = None, 0
+        for d in os.listdir(PROJECTS):
+            p = os.path.join(PROJECTS, d)
+            if os.path.isdir(p):
+                m = os.path.getmtime(p)
+                if m > best_m:
+                    best, best_m = p, m
+        return best
+    except OSError:
+        return None
+
+
+def _git_branch(cwd):
+    try:
+        out = subprocess.run(["git", "-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
+                             capture_output=True, text=True, timeout=3)
+        b = (out.stdout or "").strip()
+        return b if b and b != "HEAD" else ""
+    except Exception:
+        return ""
+
+
+def _post(cfg, payload):
+    base = (cfg.get("base_url") or "").rstrip("/")
+    token = cfg.get("token") or ""
+    if not base or not token:
+        return False
+    url = base + "/xma/genius/v1/capture/presence"
+    body = json.dumps({"jsonrpc": "2.0", "method": "call",
+                       "params": payload, "id": 1}).encode()
+    req = urllib.request.Request(url, data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Authorization", "Bearer " + token)
+    req.add_header("User-Agent", "GeniusPresence/1.0")  # WAF blocks default Python-urllib UA
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            json.loads(resp.read().decode("utf-8", "replace") or "{}")
+        return True
+    except Exception:
+        return False
+
+
+def _work_mode(cwd, claude_dir):
+    """Label HOW the work is happening (owner: loop/workflow vs short interactions).
+    A workspace edit = the human is present -> interactive. Otherwise, if a Workflow/
+    subagent run is active -> autonomous (Claude working alone, e.g. overnight). Default
+    interactive (a normal Claude turn)."""
+    if _recent(cwd, IDLE_WINDOW):
+        return "interactive"
+    if claude_dir:
+        for sub in ("subagents", os.path.join("subagents", "workflows")):
+            if _recent(os.path.join(claude_dir, sub), IDLE_WINDOW, budget_s=1.5):
+                return "autonomous"
+    return "interactive"
+
+
+def _ping(cfg, cwd, session_ref, claude_dir):
+    payload = {
+        "session_ref": session_ref,
+        "occurred_at_epoch": time.time(),
+        "utc_offset_minutes": -int(time.timezone // 60) if not time.daylight
+                              else -int(time.altzone // 60),
+        "workspace": cwd[:256],
+        "git_branch": _git_branch(cwd)[:128],
+        "surface": "vscode",
+        "work_mode": _work_mode(cwd, claude_dir),
+    }
+    return _post(cfg, payload)
+
+
+def _is_active(cwd, claude_dir):
+    """Conservative: real work signal in the last IDLE_WINDOW — human edit OR Claude
+    execution (loop/workflow). Idle-open VSCode touches no file -> not active."""
+    if _recent(cwd, IDLE_WINDOW):
+        return True
+    if claude_dir and _recent(claude_dir, IDLE_WINDOW):
+        return True
+    return False
+
+
+def _claude_idle_too_long(claude_dir):
+    return not (claude_dir and _recent(claude_dir, STOP_IDLE, budget_s=2.0))
+
+
+def main():
+    args = sys.argv[1:]
+    once = "--once" in args
+    cwd = os.getcwd()
+    session_ref = "vscode:%s" % time.strftime("%Y-%m-%d")
+    for i, a in enumerate(args):
+        if a == "--cwd" and i + 1 < len(args):
+            cwd = args[i + 1]
+        if a == "--session" and i + 1 < len(args):
+            session_ref = args[i + 1]
+    cfg = _cfg()
+    claude_dir = _project_dir(cwd)
+
+    if once:
+        active = _is_active(cwd, claude_dir)
+        ok = _ping(cfg, cwd, session_ref, claude_dir) if active else False
+        print(json.dumps({"active": active, "posted": ok, "cwd": cwd,
+                          "claude_dir": claude_dir, "session_ref": session_ref}))
+        return
+
+    # single-instance lock
+    try:
+        if os.path.exists(LOCK):
+            with open(LOCK) as fh:
+                pid = int((fh.read() or "0").strip() or 0)
+            if pid:
+                try:
+                    os.kill(pid, 0)   # alive?
+                    return            # another daemon owns it
+                except OSError:
+                    pass
+        with open(LOCK, "w") as fh:
+            fh.write(str(os.getpid()))
+    except Exception:
+        pass
+
+    start = time.time()
+    try:
+        while True:
+            if os.path.exists(STOP_FLAG):
+                break
+            if time.time() - start > MAX_LIFETIME:
+                break
+            claude_dir = _project_dir(cwd)  # refresh (slug may resolve later)
+            if _is_active(cwd, claude_dir):
+                _ping(cfg, cwd, session_ref, claude_dir)
+            elif _claude_idle_too_long(claude_dir):
+                break  # session truly over
+            time.sleep(PING_INTERVAL)
+    finally:
+        try:
+            if os.path.exists(LOCK):
+                os.remove(LOCK)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass
+    sys.exit(0)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xmarts/genius-setup",
-  "version": "1.9.0",
-  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + plan/committee→Brain enforcement + CLAUDE.md protocol + MCP fan-out: provisions the consultant's granted MCP servers into Claude Code & Claude Desktop). Secret-free onboarding via single-use setup-token exchange. Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
+  "version": "1.10.0",
+  "description": "One-command, self-updating onboarding for Xmarts Genius (Brain MCP + per-turn injection + automatic session/time capture + presence heartbeat for honest time-tracking 'amarre' + plan/committee→Brain enforcement + CLAUDE.md protocol + MCP fan-out: provisions the consultant's granted MCP servers into Claude Code & Claude Desktop). Secret-free onboarding via single-use setup-token exchange. Installs once; self-updates daily so new tools/skills/features arrive with zero action.",
   "bin": {
     "genius-setup": "bin/genius-setup.js"
   },
@@ -10,6 +10,7 @@
     "hooks/genius_inject.py",
     "hooks/genius_capture.py",
     "hooks/plan_committee_guard.py",
+    "hooks/genius_presence.py",
     "CLAUDE_PROTOCOL.md",
     "README.md"
   ],