uv-suite 0.30.0 → 0.32.0

package/README.md

@@ -1,6 +1,8 @@
 # UV Suite
 
-A portable layer that turns Claude Code, Cursor, or Codex into a labeled, observable, anti-slop dev environment — with named sessions, a real-time observability dashboard, anti-slop guardrails, and per-session memory across launches.
+A portable layer that turns Claude Code, Cursor, or Codex into a labeled, observable, anti-slop dev environment — with named sessions, a real-time observability **and control** dashboard, anti-slop guardrails, and per-session memory across launches.
+
+By [Utsav](https://www.utsava.xyz/) · [github.com/utsavanand/uv-suite](https://github.com/utsavanand/uv-suite)
 
 ## Install
 
@@ -24,7 +26,7 @@ uvs claude pro                # Claude Code, Professional persona
 uvs codex auto                # Codex, Auto persona
 uvs pro                       # Shorthand for uvs claude pro
 uvs install                   # Explicit install (also runs automatically on launch)
-uvs watch                     # Open the Watchtower observability dashboard
+uvs watch                     # Open the Watchtower observability + control dashboard
 uvs info                      # Show what's installed
 ```
 
@@ -69,22 +71,19 @@ Picking a persona (Spike / Sport / Professional / Auto) is a separate axis from
 Each `uvs` launch generates a `UVS_SESSION_ID` and writes metadata to `.uv-suite-state/sessions/<id>.json`. This unlocks:
 
 - **Concurrent terminals don't collide.** Two `uvs` launches in the same repo run as distinct sessions with separate names, checkpoints, and dashboard rows.
-- **`uvs watch` shows them all.** The Watchtower dashboard at `localhost:4200` streams every tool call across every session in real time — labeled by your name, sorted by priority (high to top, low dimmed), color-coded by persona.
+- **`uvs watch` shows them all.** The Watchtower control plane at `localhost:4200` streams every session live and lets you act on them from the browser — see [Watchtower at a glance](#watchtower-at-a-glance).
 - **Per-session checkpoints.** `/session checkpoint` writes to `uv-out/checkpoints/<sid>/`, and `/session restore` auto-picks the current session's latest. Pass a session id prefix or name to restore from a different one.
 - **Status line shows it all.** The Claude Code status bar shows session name, persona, priority, and elapsed time continuously.
 
 ### Watchtower at a glance
 
-```
-Sessions               Events    Tool calls    Errors    Need human
-4                      1,247     914           2         0
+`uvs watch` starts the dashboard at `localhost:4200` — Python + **embedded SQLite**, no Docker and no database to set up (it provisions its own deps on first run). It's a control plane, not just a viewer, laid out in three panes:
 
-[payments retry [auto]   [P:high]  [outcome]      ] (147)
-[infra cleanup  [pro]    [P:med]   [long-running] ] (382)
-[exec deck      [spike]  [P:low]   [outcome]      ] (89)
-```
+- **Heartbeat** (left) — a live, scrolling stream of what every agent is doing, as it happens.
+- **Sessions** (center) — each session as a flat row (state · tokens · tool calls · last activity). Filter by time / priority / kind and search by name; expand a row to **checkpoint, view checkpoint history, compact, fork, close, or delete** it.
+- **Needs human** (right) — sessions waiting on you (a tool-permission prompt or an idle wait), with the tool + command as context. **Approve / Deny** from the browser; for `uvs`-launched (tmux-owned) sessions the keystroke is sent for you.
 
-Hooks fire on every Claude Code event (`PreToolUse`, `PostToolUse`, `UserPromptSubmit`, `SessionStart`, `Stop`, `PermissionRequest`, ...) and forward to the dashboard with the session metadata merged in. Zero dependencies — vanilla Node + SSE.
+Sessions launched via `uvs` run inside a transparent tmux so Watchtower can act on them. Hooks forward every Claude Code event (`PreToolUse`, `PostToolUse`, `UserPromptSubmit`, `Notification`, `SessionStart`, `Stop`, ...) with session metadata merged in. A Node-only fallback (no Python) is available via `uvs watch --legacy`.
 
 ## Personas
 
@@ -241,6 +240,10 @@ uv-out/                  Agent output artifacts (gitignored)
 | [research/tool-comparison.md](research/tool-comparison.md) | Claude Code vs Cursor vs Codex — how UV Suite works across all three |
 | [research/best-practices.md](research/best-practices.md) | Subagent patterns, remote sessions, sharing with engineers, cost optimization |
 
+## Author
+
+Built by [Utsav](https://www.utsava.xyz/) — [utsava.xyz](https://www.utsava.xyz/).
+
 ## License
 
 MIT

package/bin/cli.js

@@ -34,7 +34,7 @@ function usage() {
   Monitoring:
     uvs watch               Start Watchtower dashboard (open browser)
     uvs watch --bg          Start Watchtower in background
-    uvs watch --legacy      Start the legacy Node Watchtower (no Docker/Postgres)
+    uvs watch --legacy      Start the legacy Node Watchtower
 
   Personas:
     spike        Research & docs (Opus, max effort)
@@ -183,19 +183,19 @@ function prompt(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
 
-function normalizeKind(s) {
-  const v = (s || "").toLowerCase().trim();
-  if (["l", "long", "long-running"].includes(v)) return "long-running";
-  if (["o", "outcome"].includes(v)) return "outcome";
-  return "";
-}
-
-function normalizePriority(s) {
-  const v = (s || "").toLowerCase().trim();
-  if (["l", "low"].includes(v)) return "low";
-  if (["m", "med", "medium"].includes(v)) return "med";
-  if (["h", "high"].includes(v)) return "high";
-  return "";
+// Prompt for one of a fixed set of values (enum). Accepts the number, the full
+// value, or a unique prefix; Enter skips (returns ""). Re-prompts on invalid input.
+async function promptChoice(rl, label, options) {
+  const menu = options.map((o, i) => `${i + 1}=${o}`).join("  ");
+  for (;;) {
+    const raw = (await prompt(rl, `${label} (${menu}, Enter to skip): `)).trim().toLowerCase();
+    if (!raw) return "";
+    const n = parseInt(raw, 10);
+    if (n >= 1 && n <= options.length) return options[n - 1];
+    const matches = options.filter((o) => o === raw || o.startsWith(raw));
+    if (matches.length === 1) return matches[0];
+    console.log(`  ? pick one of: ${options.join(", ")} (or its number)`);
+  }
 }
 
 // Generate a UVS_SESSION_ID, prompt for metadata (name/kind/purpose/priority),
@@ -221,13 +221,11 @@ async function setupSession(persona) {
     });
     console.log("");
     console.log("Label this session (Enter to skip — you'll be reminded):");
-    name = (await prompt(rl, "  name:                     ")).trim();
-    const kindRaw = await prompt(rl, "  kind [long/outcome]:      ");
-    purpose = (await prompt(rl, "  purpose:                  ")).trim();
-    const priorityRaw = await prompt(rl, "  priority [low/med/high]:  ");
+    name = (await prompt(rl, "  name:     ")).trim();
+    kind = await promptChoice(rl, "  kind", ["long-running", "outcome"]);
+    purpose = (await prompt(rl, "  purpose:  ")).trim();
+    priority = await promptChoice(rl, "  priority", ["low", "med", "high"]);
     rl.close();
-    kind = normalizeKind(kindRaw);
-    priority = normalizePriority(priorityRaw);
   }
 
   const meta = {
@@ -254,6 +252,47 @@ function ensureInstalled(persona) {
   syncPackageFiles(persona);
 }
 
+// Launch `tool` so Watchtower can control it: wrap it in a transparent tmux session
+// (dedicated socket `uvs`) and register the handle, so the dashboard can checkpoint /
+// close / approve it. Falls back to a direct spawn when tmux is unavailable, UVS_NO_TMUX
+// is set, or we're already inside the wrapper.
+function launchWrapped(tool, toolArgs, sid) {
+  const { spawnSync } = require("child_process");
+  const env = { ...process.env, UVS_SESSION_ID: sid };
+  const canTmux =
+    !process.env.UVS_NO_TMUX &&
+    !process.env.UVS_IN_TMUX &&
+    spawnSync("tmux", ["-V"], { stdio: "ignore" }).status === 0;
+
+  if (canTmux) {
+    const tname = "uvs_" + sid;
+    const wtUrl = process.env.UVS_WATCHTOWER_URL || "http://localhost:4200";
+    const shq = (s) => "'" + String(s).replace(/'/g, "'\\''") + "'";
+    const inner =
+      "UVS_SESSION_ID=" + shq(sid) + " UVS_IN_TMUX=1 exec " + [tool, ...toolArgs].map(shq).join(" ");
+    const mk = spawnSync(
+      "tmux", ["-L", "uvs", "new-session", "-d", "-s", tname, "-c", process.cwd(), inner],
+      { stdio: "ignore" },
+    );
+    if (mk.status === 0) {
+      spawnSync("tmux", ["-L", "uvs", "set", "-t", tname, "status", "off"], { stdio: "ignore" });
+      spawnSync(
+        "curl", ["-s", "-m", "2", wtUrl + "/sessions/register",
+          "-H", "Content-Type: application/json",
+          "-d", JSON.stringify({ id: sid, tmux_target: tname, pid: process.pid, cwd: process.cwd() })],
+        { stdio: "ignore" },
+      );
+      const att = spawn("tmux", ["-L", "uvs", "attach", "-t", tname], { stdio: "inherit" });
+      att.on("exit", (code) => process.exit(code || 0));
+      return;
+    }
+    // tmux new-session failed — fall through to a direct spawn.
+  }
+
+  const child = spawn(tool, toolArgs, { stdio: "inherit", env });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
 async function launchClaude(persona, extra) {
   syncPackageFiles(persona);
   const settings = path.resolve(".claude/personas", `${persona}.json`);
@@ -268,11 +307,7 @@ async function launchClaude(persona, extra) {
   console.log(`UV Suite | Claude Code | ${personaLabel(persona)}`);
   console.log(`Session: ${sid.slice(0, 8)}${name ? " — " + name : ""}`);
   console.log("");
-  const child = spawn("claude", ["--settings", settings, ...extra], {
-    stdio: "inherit",
-    env: { ...process.env, UVS_SESSION_ID: sid },
-  });
-  child.on("exit", (code) => process.exit(code || 0));
+  launchWrapped("claude", ["--settings", settings, ...extra], sid);
 }
 
 async function launchCodex(persona, extra) {
@@ -288,11 +323,55 @@ async function launchCodex(persona, extra) {
   console.log(`UV Suite | Codex | ${personaLabel(persona)}`);
   console.log(`Session: ${sid.slice(0, 8)}${name ? " — " + name : ""}`);
   console.log("");
-  const child = spawn("codex", [...codexArgs, ...extra], {
-    stdio: "inherit",
-    env: { ...process.env, UVS_SESSION_ID: sid },
-  });
-  child.on("exit", (code) => process.exit(code || 0));
+  launchWrapped("codex", [...codexArgs, ...extra], sid);
+}
+
+// Resolve how to run the Python app, provisioning deps on first run.
+// Prefers `uv` (astral) if present; otherwise a venv at watchtower/.venv.
+// Returns the argv prefix to which we append `uvicorn` args.
+function ensurePyEnv(wtDir) {
+  const { spawnSync } = require("child_process");
+  const hasUv = spawnSync("uv", ["--version"], { stdio: "ignore" }).status === 0;
+  if (hasUv) {
+    // --native-tls: use the OS cert store so corporate SSL-inspection proxies don't break pypi.
+    return ["uv", "run", "--native-tls", "--python", "3.12", "--no-project", "--with-requirements", "requirements.txt", "--", "python", "-m"];
+  }
+  const venv = path.join(wtDir, ".venv");
+  const py =
+    process.platform === "win32"
+      ? path.join(venv, "Scripts", "python.exe")
+      : path.join(venv, "bin", "python");
+  if (!fs.existsSync(py)) {
+    const python3 = spawnSync("python3", ["--version"], { stdio: "ignore" }).status === 0 ? "python3" : "python";
+    console.log("First run: creating Python env in watchtower/.venv (one-time)...");
+    if (spawnSync(python3, ["-m", "venv", ".venv"], { cwd: wtDir, stdio: "inherit" }).status !== 0) {
+      console.error("Failed to create venv. Install Python 3 (python3) and retry.");
+      process.exit(1);
+    }
+    console.log("Installing dependencies (fastapi, uvicorn, aiosqlite)...");
+    if (spawnSync(py, ["-m", "pip", "install", "-q", "-r", "requirements.txt"], { cwd: wtDir, stdio: "inherit" }).status !== 0) {
+      console.error("pip install failed (see output above).");
+      process.exit(1);
+    }
+  }
+  return [py, "-m"];
+}
+
+// If a Watchtower is already running on this port, stop it so we start fresh —
+// uvicorn doesn't hot-reload, so a long-running process serves stale routes while
+// the (disk-served) dashboard updates. Only kills a process that answers /health
+// like a Watchtower, so we never kill an unrelated app on the port.
+function restartIfRunning(port) {
+  const { spawnSync } = require("child_process");
+  if (process.platform === "win32") return;
+  const health = spawnSync("curl", ["-s", "-m", "1", `http://localhost:${port}/health`], { encoding: "utf8" });
+  if (!(health.stdout || "").includes("status")) return;
+  const pids = (spawnSync("lsof", ["-ti", `tcp:${port}`], { encoding: "utf8" }).stdout || "")
+    .trim().split(/\s+/).filter(Boolean);
+  if (!pids.length) return;
+  spawnSync("kill", pids);
+  console.log(`Restarting Watchtower (stopped existing PID ${pids.join(", ")})`);
+  spawnSync("sleep", ["1"]);  // let the port free up before rebinding
 }
 
 function watch() {
@@ -322,35 +401,26 @@ function watch() {
     }
     return;
   }
-  if (!fs.existsSync(path.join(wtDir, "docker-compose.yml"))) {
-    console.error("Error: watchtower compose not found at", wtDir);
-    process.exit(1);
-  }
   const bg = args.includes("--bg") || args.includes("--background");
-  const url = "http://localhost:" + (process.env.UVS_WATCHTOWER_PORT || 4200);
+  const port = process.env.UVS_WATCHTOWER_PORT || 4200;
+  const url = "http://localhost:" + port;
   const opener =
     process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  console.log("UV Suite Watchtower (Python + Postgres) starting via docker compose...");
+
+  // Python + SQLite, run locally (no Docker, no database to install).
+  restartIfRunning(port);
+  console.log("UV Suite Watchtower starting...");
   console.log("Dashboard: " + url);
   console.log("");
-
-  // Bring the stack up (Postgres + FastAPI). Build is cached after first run.
-  const up = spawn("docker", ["compose", "up", "--build", "-d"], { cwd: wtDir, stdio: "inherit" });
-  up.on("exit", (code) => {
-    if (code) {
-      console.error("docker compose failed. Is Docker running? (the Python Watchtower needs it)");
-      process.exit(code);
-    }
-    setTimeout(() => spawn(opener, [url], { stdio: "ignore" }), 1500);
-    if (bg) {
-      console.log("Watchtower running in background.");
-      console.log("Stop with: (cd watchtower && docker compose down)");
-      process.exit(0);
-    }
-    // Foreground: follow logs until Ctrl-C.
-    const logs = spawn("docker", ["compose", "logs", "-f"], { cwd: wtDir, stdio: "inherit" });
-    logs.on("exit", (c) => process.exit(c || 0));
-  });
+  const argv = [...ensurePyEnv(wtDir), "uvicorn", "app.main:app", "--host", "127.0.0.1", "--port", String(port)];
+  setTimeout(() => spawn(opener, [url], { stdio: "ignore" }), 1500);
+  const child = spawn(argv[0], argv.slice(1), { cwd: wtDir, stdio: bg ? "ignore" : "inherit", detached: bg });
+  if (bg) {
+    child.unref();
+    console.log(`Running in background (PID: ${child.pid}). Stop with: kill ${child.pid}`);
+  } else {
+    child.on("exit", (code) => process.exit(code || 0));
+  }
 }
 
 // --- Parse and route ---

package/hooks/uv-out-notify.sh

@@ -1,27 +1,34 @@
 #!/bin/bash
-# UV Suite Hook: Surface the uv-out/ artifact path after a skill run.
+# UV Suite Hook: surface real skill artifacts written to uv-out/ after a run.
 # Event: Stop
-# When a UV Suite skill writes artifacts to uv-out/, the writing happens inside a
-# forked sub-agent whose transcript the user never sees. This hook runs when control
-# returns to the main loop and prints the path so the user knows where output landed.
+# A skill (/spec, /review, /understand, …) writes artifacts inside a forked sub-agent
+# whose transcript the user never sees; this prints the path when control returns.
+#
+# Scoped to the CURRENT session and excludes checkpoints — checkpoints are background
+# state (surfaced by the dashboard and /session restore), and listing every session's
+# checkpoints here produced cross-session noise.
 
 [ -d uv-out ] || exit 0
 
-# Files written in the ~2 min covering the run that just finished.
-RECENT=$(find uv-out -type f -mmin -2 2>/dev/null | sort)
+SID="${UVS_SESSION_ID:-}"
+[ -z "$SID" ] && [ -f .uv-suite-state/current-session.txt ] && SID=$(cat .uv-suite-state/current-session.txt 2>/dev/null)
+
+# Recent files, minus checkpoints, minus other sessions (when we know our own).
+RECENT=$(find uv-out -type f -mmin -2 2>/dev/null \
+  | grep -v '/checkpoints/' \
+  | awk -v sid="$SID" '
+      /^uv-out\/sessions\// { if (sid == "" || index($0, "uv-out/sessions/" sid "/") == 1) print; next }
+      { print }
+    ' \
+  | sort)
 [ -z "$RECENT" ] && exit 0
 
 LIST=$(echo "$RECENT" | sed 's/^/  /' | sed 's/$/\\n/' | tr -d '\n')
 
-# Name the session if these artifacts are session-scoped (uv-out/sessions/<sid>/...).
-SID=$(echo "$RECENT" | sed -n 's#^uv-out/sessions/\([^/]*\)/.*#\1#p' | head -1)
-HEADER="UV Suite output written to:"
-[ -n "$SID" ] && HEADER="UV Suite output (session ${SID}) written to:"
-
 cat <<EOF
 {
   "continue": true,
-  "systemMessage": "${HEADER}\n${LIST}"
+  "systemMessage": "UV Suite output written to:\n${LIST}"
 }
 EOF
 

package/hooks/watchtower-end.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# UV Suite Hook: tell Watchtower the session has ended (Event: SessionEnd).
+# POSTs state=terminated so the dashboard stops showing it as active when the
+# user exits the session directly (rather than via the dashboard Close button).
+# Non-blocking; fails silently if Watchtower isn't running.
+
+cat >/dev/null  # drain stdin
+
+WATCHTOWER_URL="${UVS_WATCHTOWER_URL:-http://localhost:4200}"
+STATE_DIR="${CLAUDE_PROJECT_DIR:-.}/.uv-suite-state"
+
+SID="${UVS_SESSION_ID:-}"
+if [ -z "$SID" ] && [ -f "$STATE_DIR/current-session.txt" ]; then
+  SID=$(cat "$STATE_DIR/current-session.txt" 2>/dev/null)
+fi
+[ -z "$SID" ] && exit 0
+
+curl -s -X POST "$WATCHTOWER_URL/sessions/$SID/state" \
+  -H "Content-Type: application/json" \
+  -d '{"state":"terminated"}' \
+  &>/dev/null &
+
+exit 0

package/hooks/watchtower-notify.sh

@@ -10,6 +10,17 @@
 INPUT=$(cat)
 WATCHTOWER_URL="${UVS_WATCHTOWER_URL:-http://localhost:4200}"
 
+# Notification events carry a type; only surface ones that mean "human needed".
+# (permission_prompt = tool approval, idle_prompt = waiting for input.) PermissionRequest
+# events have no type, so they pass through.
+if command -v jq >/dev/null 2>&1; then
+  NTYPE=$(echo "$INPUT" | jq -r '.type // ""' 2>/dev/null)
+  case "$NTYPE" in
+    ""|permission_prompt|idle_prompt) ;;
+    *) exit 0 ;;
+  esac
+fi
+
 STATE_DIR="${CLAUDE_PROJECT_DIR:-.}/.uv-suite-state"
 
 # Resolve UVS session id: env first, then current-session pointer

package/hooks/watchtower-send.sh

@@ -29,11 +29,11 @@ META_FILE=""
 PAYLOAD=""
 if command -v jq >/dev/null 2>&1; then
   if [ -n "$META_FILE" ] && [ -f "$META_FILE" ]; then
-    PAYLOAD=$(echo "$INPUT" | jq -c --arg etype "$EVENT_TYPE" --slurpfile m "$META_FILE" '
+    PAYLOAD=$(echo "$INPUT" | jq -c --arg etype "$EVENT_TYPE" --arg sid "$SID" --slurpfile m "$META_FILE" '
       . + {
         event_type: $etype,
         source_app: (.cwd // "" | split("/") | last),
-        uvs_session_id:   ($m[0].uvs_session_id // ""),
+        uvs_session_id:   ($m[0].uvs_session_id // $sid),
         session_name:     ($m[0].name // ""),
         session_kind:     ($m[0].kind // ""),
         session_purpose:  ($m[0].purpose // ""),
@@ -46,10 +46,13 @@ if command -v jq >/dev/null 2>&1; then
         _hook_ts: now
       }' 2>/dev/null)
   else
-    PAYLOAD=$(echo "$INPUT" | jq -c --arg etype "$EVENT_TYPE" '
+    # No metadata file (e.g. a forked session): still tag with the resolved UVS
+    # session id so events attribute to the right session, not Claude's internal id.
+    PAYLOAD=$(echo "$INPUT" | jq -c --arg etype "$EVENT_TYPE" --arg sid "$SID" '
       . + {
         event_type: $etype,
         source_app: (.cwd // "" | split("/") | last),
+        uvs_session_id: $sid,
         _hook_ts: now
       }' 2>/dev/null)
   fi

package/hooks/watchtower-tokens.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# UV Suite Hook: report Claude Code token usage to Watchtower (Event: Stop).
+# Parses the session transcript (transcript_path from the hook input), sums per-message
+# token usage (input + cache + output), and POSTs the totals so the dashboard can show
+# tokens used. Non-blocking; fails silently if Watchtower is down or there's no transcript.
+
+INPUT=$(cat 2>/dev/null || true)
+WATCHTOWER_URL="${UVS_WATCHTOWER_URL:-http://localhost:4200}"
+STATE_DIR="${CLAUDE_PROJECT_DIR:-.}/.uv-suite-state"
+
+SID="${UVS_SESSION_ID:-}"
+if [ -z "$SID" ] && [ -f "$STATE_DIR/current-session.txt" ]; then
+  SID=$(cat "$STATE_DIR/current-session.txt" 2>/dev/null)
+fi
+[ -z "$SID" ] && exit 0
+
+# Locate the transcript path inside the hook input.
+TP=""
+if command -v jq >/dev/null 2>&1; then
+  TP=$(printf '%s' "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null)
+fi
+[ -z "$TP" ] && TP=$(printf '%s' "$INPUT" | grep -o '"transcript_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+{ [ -z "$TP" ] || [ ! -f "$TP" ]; } && exit 0
+
+# Sum usage across assistant messages in the transcript (JSONL).
+TOTALS=$(TP_VAL="$TP" python3 -c '
+import json, os
+inp = out = 0
+try:
+    with open(os.environ["TP_VAL"]) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                o = json.loads(line)
+            except Exception:
+                continue
+            u = (o.get("message") or {}).get("usage") or o.get("usage") or {}
+            if not isinstance(u, dict):
+                continue
+            inp += (u.get("input_tokens") or 0) \
+                 + (u.get("cache_read_input_tokens") or 0) \
+                 + (u.get("cache_creation_input_tokens") or 0)
+            out += (u.get("output_tokens") or 0)
+except Exception:
+    pass
+print(inp); print(out)
+' 2>/dev/null)
+
+IN=$(echo "$TOTALS" | sed -n 1p)
+OUT=$(echo "$TOTALS" | sed -n 2p)
+[ -z "$IN" ] && exit 0
+[ "$IN" = "0" ] && [ "$OUT" = "0" ] && exit 0
+
+curl -s -X POST "$WATCHTOWER_URL/sessions/$SID/tokens" \
+  -H "Content-Type: application/json" \
+  -d "{\"input_tokens\":$IN,\"output_tokens\":$OUT}" \
+  &>/dev/null &
+
+exit 0

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "uv-suite",
-  "version": "0.30.0",
-  "description": "Anti-slop guardrails, specialized agents, and a live observability + control plane for AI-assisted coding. 8 agents, 12 skills, 27 hooks, 6 guardrails, 4 personas; Watchtower (Python/Postgres) for monitoring + checkpoint/close/approve from the browser. Works with Claude Code, Cursor, and Codex.",
-  "author": "Utsav Anand",
+  "version": "0.32.0",
+  "description": "Anti-slop guardrails, specialized agents, and a live observability + control plane for AI-assisted coding. Watchtower (Python + SQLite, no setup) shows a live heartbeat, your sessions, and a needs-human approval queue \u2014 checkpoint, compact, fork, close, or approve sessions from the browser. 8 agents, 12 skills, ~28 hooks, 6 guardrails, 4 personas. Works with Claude Code, Cursor, and Codex.",
+  "author": {
+    "name": "Utsav",
+    "url": "https://www.utsava.xyz/"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",

package/personas/auto.json

@@ -146,6 +146,11 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-send.sh Notification",
             "timeout": 2,
             "async": true
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-notify.sh",
+            "timeout": 5
           }
         ]
       }
@@ -231,6 +236,25 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/uv-out-notify.sh",
             "timeout": 5,
             "statusMessage": "Locating UV Suite output..."
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-tokens.sh",
+            "timeout": 10,
+            "statusMessage": "Reporting token usage..."
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-end.sh",
+            "timeout": 5,
+            "statusMessage": "Notifying Watchtower..."
           }
         ]
       }

package/personas/professional.json

@@ -158,6 +158,11 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-send.sh Notification",
             "timeout": 2,
             "async": true
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-notify.sh",
+            "timeout": 5
           }
         ]
       }
@@ -255,6 +260,25 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/uv-out-notify.sh",
             "timeout": 5,
             "statusMessage": "Locating UV Suite output..."
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-tokens.sh",
+            "timeout": 10,
+            "statusMessage": "Reporting token usage..."
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-end.sh",
+            "timeout": 5,
+            "statusMessage": "Notifying Watchtower..."
           }
         ]
       }

package/personas/spike.json

@@ -136,6 +136,11 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-send.sh Notification",
             "timeout": 2,
             "async": true
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-notify.sh",
+            "timeout": 5
           }
         ]
       }
@@ -197,6 +202,25 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/uv-out-notify.sh",
             "timeout": 5,
             "statusMessage": "Locating UV Suite output..."
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-tokens.sh",
+            "timeout": 10,
+            "statusMessage": "Reporting token usage..."
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-end.sh",
+            "timeout": 5,
+            "statusMessage": "Notifying Watchtower..."
           }
         ]
       }

package/personas/sport.json

@@ -132,6 +132,11 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-send.sh Notification",
             "timeout": 2,
             "async": true
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-notify.sh",
+            "timeout": 5
           }
         ]
       }
@@ -199,6 +204,25 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/uv-out-notify.sh",
             "timeout": 5,
             "statusMessage": "Locating UV Suite output..."
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-tokens.sh",
+            "timeout": 10,
+            "statusMessage": "Reporting token usage..."
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-end.sh",
+            "timeout": 5,
+            "statusMessage": "Notifying Watchtower..."
           }
         ]
       }