uv-suite 0.26.4 → 0.27.0

package/README.md

@@ -1,34 +1,70 @@
 # UV Suite
 
-Portable framework for AI-assisted software development. Works with Claude Code, Cursor, and OpenAI Codex.
+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.
 
 ## Install
 
 ```bash
 npm install -g uv-suite
-uv install
+uvs claude pro                # auto-installs into the current project on first launch
 ```
 
 Or with npx:
 
 ```bash
-npx uv-suite install
+npx uv-suite install          # explicit install only
 ```
 
-This installs 10 agents, 10 skills, 8 hooks, 6 guardrails, and 4 personas into your project.
+> **Note:** The CLI is `uvs`, not `uv`. The name `uv` belongs to Astral's Python package manager and likely already exists on your system.
 
 ## Quick Start
 
 ```bash
-uv install                    # Install UV Suite into current project
-uv claude pro                 # Start Claude Code, Professional persona
-uv codex auto                 # Start Codex, Auto persona
-uv pro                        # Shorthand for uv claude pro
+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 info                      # Show what's installed
 ```
 
-## Modes
+On every `uvs` launch, you'll be prompted to label the session:
 
-Four personas for different contexts. Pick one when you start a session.
+```
+Label this session (Enter to skip — you'll be reminded):
+  name:                     payments retry refactor
+  kind [long/outcome]:      outcome
+  purpose:                  ship retry-on-5xx for the Stripe webhook handler
+  priority [low/med/high]:  high
+```
+
+Skip any field with Enter. If you skip the name, `/session-init` will be suggested every few prompts until you label it. Set `UVS_NO_PROMPT=1` to suppress prompts entirely.
+
+## Sessions and Watchtower
+
+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.
+- **Per-session checkpoints.** `/checkpoint` writes to `uv-out/checkpoints/<sid>/`, and `/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
+
+[payments retry [auto]   [P:high]  [outcome]      ] (147)
+[infra cleanup  [pro]    [P:med]   [long-running] ] (382)
+[exec deck      [spike]  [P:low]   [outcome]      ] (89)
+```
+
+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.
+
+## Personas
+
+Four modes for different contexts. Pick one when you start a session.
 
 ```
              Spike          Sport        Professional       Auto
@@ -43,12 +79,7 @@ Writes       New files      Anything     Anything           Anything
              only                        (reviewed)         (autonomous)
 Edits        Blocked        Allowed      Allowed            Allowed
 
-Hooks        1              1            8                  3
-             doc-slop       lint         all                lint, block,
-                                                            timer
-
 Guardrails   Doc slop       None         All 6              All 6
-
 Human gates  After each     End only     Every Act          Final output
              map                         boundary           only
 ```
@@ -56,7 +87,7 @@ Human gates  After each     End only     Every Act          Final output
 ### When to use what
 
 | Situation | Mode | Why |
-|-----------|------|-----|
+|---|---|---|
 | Joining a new codebase | **Spike** | Understand before changing. Writes docs, not code. |
 | Architecture review | **Spike** | Map the system, write ADRs, document findings. |
 | Prototyping a demo | **Sport** | Move fast, iterate freely, quality comes later. |
@@ -71,121 +102,114 @@ Human gates  After each     End only     Every Act          Final output
 - Spike → Auto (research thoroughly, then let the agent execute)
 - Sport → Professional (prototype fast, switch to rigor when it matters)
 
-## What You Get
-
-| Category | Count | What |
-|----------|-------|------|
-| Agents | 10 | Subagent definitions for Claude Code, Cursor, and Codex |
-| Skills | 10 | Slash commands with dynamic context injection |
-| Hooks | 8 | Auto-lint, slop check, danger zones, session tracking, destructive blocks |
-| Guardrails | 6 | Anti-slop rules (comments, overengineering, tests, docs, architecture, errors) |
-| Personas | 4 | Spike, Sport, Professional, Auto |
-
-## Three Subsystems
-
-```
-UV Index          UV Acts           UV Guard
-Understand        Build             Review
-Learn             Deliver           Harden
-Remember          Present           Protect
-```
-
-**UV Index** maps codebases using [Graphify](https://github.com/safishamsi/graphify) knowledge graphs, captures context, builds persistent memory.
-
-**UV Acts** delivers software in sequential phases (Acts) with parallel tasks, human-in-the-loop cycle budgets, and spec-driven development.
-
-**UV Guard** catches AI slop in real time, reviews code for security (OWASP, [Semgrep](https://github.com/semgrep/semgrep)), and enforces danger zones.
-
-## Skills
+## Skills (slash commands)
 
 | Command | What it does |
-|---------|-------------|
+|---|---|
 | `/map-codebase [dir]` | Build a knowledge graph of the codebase |
 | `/map-stack [dir]` | Map multiple services and their connections |
 | `/spec [requirements]` | Write a technical specification |
 | `/architect [spec]` | Design architecture, decompose into Acts |
-| `/review` | Code review: correctness, security, performance, slop |
+| `/prototype [concept]` | Build a static React prototype |
 | `/write-tests [file]` | Generate tests matching project conventions |
 | `/write-evals [prompt]` | Write AI/LLM evaluation cases ([DeepEval](https://github.com/confident-ai/deepeval) compatible) |
+| `/review` | Code review: correctness, security, performance, slop |
 | `/slop-check` | Detect 6 categories of AI-generated slop |
-| `/prototype [concept]` | Build a static React prototype |
 | `/security-review` | OWASP audit, dependency scan, secret detection |
+| `/investigate` | Systematic root-cause debugging |
+| `/commit` | Review → test → slop-check → commit (and optionally PR) |
+| `/checkpoint [label]` | Save session state to `uv-out/checkpoints/<sid>/` |
+| `/restore [sid-prefix\|name]` | Load the latest checkpoint for the current (or named) session |
+| `/session-init [name\|--kind\|--purpose\|--priority]` | Label or relabel the current session |
+| `/confirm [on\|off\|<n>]` | Toggle reframe-and-confirm for prompts over `<n>` words |
+| `/uv-help` | List every skill, agent, hook, guardrail, and persona |
 
-## Hooks
+## Hooks (lifecycle automation)
 
-Fire automatically. You never invoke these.
+Fire automatically on Claude Code events. You never invoke these.
 
 | Hook | Fires on | What it does |
-|------|----------|-------------|
+|---|---|---|
 | auto-lint | File write | Runs prettier, ruff, or gofmt |
-| Slop check | File write | Haiku scans for obvious slop patterns |
-| Danger zone | File edit | Warns if file is in DANGER-ZONES.md |
-| Destructive block | Bash command | Blocks rm -rf, force push, DROP TABLE |
-| Session start | Session start | Records start time for duration tracking |
-| Session timer | Every 20th tool call | Checkpoint reminders at 45/90/180 min |
-| Session end | Session stop | Shows duration, today's total, reflection prompt |
-| Status line | Continuous | Shows session time in Claude Code's status bar |
+| slop-grep | File write | Greps for obvious slop patterns (over-commented code, vague docs) |
+| doc-slop-grep | File write | Catches vague adjectives in markdown |
+| danger-zone-check | File edit | Warns if file is in DANGER-ZONES.md |
+| block-destructive | Bash command | Blocks `rm -rf /`, force push to main, `DROP TABLE` |
+| confirm-prompt | UserPromptSubmit | For prompts over the threshold, requires Claude to restate before any work starts |
+| session-label-nag | UserPromptSubmit | Reminds you to run `/session-init` every Nth prompt while the session has no name |
+| context-warning | PostToolUse | Warns when context usage crosses thresholds |
+| watchtower-send | All events | Forwards every event (with session metadata) to `localhost:4200` |
+| session-start | SessionStart | Records start time, fires bootstrap event with session metadata |
+| session-timer | PostToolUse | Reminders at 45 / 90 / 180 minutes |
+| session-end | Stop | Shows duration, today's total, reflection prompt |
+| session-review-reminder | Stop | Nudges you to review uncommitted changes |
+| status-line | Continuous | Renders session label, persona, priority, and timer in the Claude Code status bar |
 
 ## Agents
 
-10 agents, each in 4 formats (Claude Code, Cursor, Codex, Portable):
+10 agents, each in 4 formats (Claude Code, Cursor, Codex, portable):
 
 | Agent | Subsystem | Model | Cycle Budget |
-|-------|-----------|-------|-------------|
-| Cartographer | UV Index | Opus | 1 |
-| Spec Writer | UV Acts | Opus | 1 |
-| Architect | UV Acts | Opus | 2 |
-| Reviewer | UV Guard | Opus | 1 |
-| Test Writer | UV Acts | Sonnet | 3 |
-| Eval Writer | UV Acts | Opus | 2 |
-| Anti-Slop Guard | UV Guard | Opus | 1 |
-| Prototype Builder | UV Acts | Sonnet | 3 |
-| DevOps | UV Acts | Opus | 2 |
-| Security | UV Guard | Opus | 1 |
+|---|---|---|---|
+| Cartographer | Index | Opus | 1 |
+| Spec Writer | Acts | Opus | 1 |
+| Architect | Acts | Opus | 2 |
+| Reviewer | Guard | Opus | 1 |
+| Test Writer | Acts | Sonnet | 3 |
+| Eval Writer | Acts | Opus | 2 |
+| Anti-Slop Guard | Guard | Opus | 1 |
+| Prototype Builder | Acts | Sonnet | 3 |
+| DevOps | Acts | Opus | 2 |
+| Security | Guard | Opus | 1 |
 
 ## Artifacts
 
 Agents write persistent output to `uv-out/`. Each agent reads prior artifacts automatically.
 
-| Agent output | Read by |
-|-------------|---------|
+| Output | Read by |
+|---|---|
 | `uv-out/map-codebase.md` | /architect, /review, /security-review |
 | `uv-out/specs/*.md` | /architect, /write-tests, /write-evals |
 | `uv-out/architecture/*.md` | /review, /write-tests, /slop-check |
 | `uv-out/review-*.md` | /slop-check, /security-review |
+| `uv-out/checkpoints/<sid>/*.md` | /restore |
 
 ## Integrations
 
 | Tool | Used by | Purpose |
-|------|---------|---------|
+|---|---|---|
 | [Graphify](https://github.com/safishamsi/graphify) | Cartographer | Knowledge graph from codebase via Tree-sitter |
-| [Semgrep](https://github.com/semgrep/semgrep) | Security Agent | SAST with 4000+ OWASP-mapped rules |
-| [Gitleaks](https://github.com/gitleaks/gitleaks) | Security Agent | Secret detection in git repos |
-| [Trivy](https://github.com/aquasecurity/trivy) | Security Agent | Dependency vulnerability scanning |
+| [Semgrep](https://github.com/semgrep/semgrep) | Security | SAST with 4000+ OWASP-mapped rules |
+| [Gitleaks](https://github.com/gitleaks/gitleaks) | Security | Secret detection in git repos |
+| [Trivy](https://github.com/aquasecurity/trivy) | Security | Dependency vulnerability scanning |
 | [DeepEval](https://github.com/confident-ai/deepeval) | Eval Writer | Pytest-compatible LLM evaluation |
-| [Playwright](https://playwright.dev/docs/getting-started-mcp) | Prototype Builder, Test Writer | Browser automation and e2e testing |
+| [Playwright](https://playwright.dev/docs/getting-started-mcp) | Prototype, Test Writer | Browser automation and e2e testing |
 
 ## Project Structure After Install
 
 ```
 .claude/
-  settings.json        Permissions, hooks (from persona)
-  agents/              10 agent definitions
-  skills/              10 slash commands
-  hooks/               7 hook scripts
-  rules/               6 anti-slop guardrails
-  personas/            4 persona configs
-.codex/agents/         10 Codex agent definitions
-.cursor/rules/         10 Cursor rule definitions
-AGENTS.md              Codex instruction file
-DANGER-ZONES.md        Risky areas (commit this)
-uv-out/                Agent output artifacts (gitignored)
+  settings.json          Permissions and hooks (seeded from your persona on first install)
+  agents/                10 agent definitions
+  skills/                17 slash commands
+  hooks/                 14 hook scripts + 2 helpers
+  rules/                 6 anti-slop guardrails (Pro / Auto only)
+  personas/              4 persona configs
+.codex/agents/           10 Codex agent definitions
+.cursor/rules/           10 Cursor rule definitions
+AGENTS.md                Codex instruction file
+DANGER-ZONES.md          Risky areas (commit this)
+.uv-suite-state/         Session metadata + counters (gitignored)
+  current-session.txt
+  sessions/<sid>.json
+uv-out/                  Agent output artifacts (gitignored)
+  checkpoints/<sid>/     Per-session checkpoints
 ```
 
 ## Documentation
 
 | Document | What it covers |
-|----------|---------------|
+|---|---|
 | [usage-guide.md](usage-guide.md) | Full SDLC mapped to exact commands |
 | [personas.md](personas.md) | 4 personas, 7 knobs, when to use each |
 | [practices.md](practices.md) | Working principles (honesty, parallelism, scope, completion) |

package/hooks/auto-checkpoint-helper.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# UV Suite helper: read or change auto-checkpoint settings.
+# Used by the /auto-checkpoint slash command.
+#
+# Usage:
+#   auto-checkpoint-helper.sh status
+#   auto-checkpoint-helper.sh on
+#   auto-checkpoint-helper.sh off
+#   auto-checkpoint-helper.sh <minutes>     # set interval
+
+STATE_DIR="${CLAUDE_PROJECT_DIR:-.}/.uv-suite-state"
+mkdir -p "$STATE_DIR"
+STATE_FILE="$STATE_DIR/auto-checkpoint.json"
+
+ensure_state() {
+  [ -f "$STATE_FILE" ] && return
+  cat > "$STATE_FILE" <<'EOF'
+{
+  "mode": "on",
+  "interval_minutes": 10
+}
+EOF
+}
+
+get_field() {
+  ensure_state
+  STATE_PATH="$STATE_FILE" KEY="$1" python3 -c '
+import json, os
+d = json.load(open(os.environ["STATE_PATH"]))
+print(d.get(os.environ["KEY"], ""))
+'
+}
+
+set_field() {
+  ensure_state
+  STATE_PATH="$STATE_FILE" KEY="$1" VAL="$2" python3 -c '
+import json, os
+p = os.environ["STATE_PATH"]
+d = json.load(open(p))
+key = os.environ["KEY"]
+val = os.environ["VAL"]
+if key == "interval_minutes":
+    val = int(val)
+d[key] = val
+json.dump(d, open(p, "w"), indent=2)
+'
+}
+
+ARG=$(printf '%s' "$1" | tr -d '[:space:]')
+
+case "$ARG" in
+  on)
+    set_field mode on
+    echo "Auto-checkpoint: ON (every $(get_field interval_minutes) min, mechanical + semantic)"
+    ;;
+  off)
+    set_field mode off
+    echo "Auto-checkpoint: OFF"
+    ;;
+  ""|status)
+    ensure_state
+    echo "Auto-checkpoint: $(get_field mode) (every $(get_field interval_minutes) min)"
+    ;;
+  *)
+    if printf '%s' "$ARG" | grep -qE '^[0-9]+$' && [ "$ARG" -ge 1 ] && [ "$ARG" -le 1440 ]; then
+      set_field interval_minutes "$ARG"
+      echo "Auto-checkpoint interval: $ARG min (mode: $(get_field mode))"
+    else
+      echo "Usage: /auto-checkpoint [on | off | <minutes 1-1440> | status]"
+      exit 1
+    fi
+    ;;
+esac

package/hooks/auto-checkpoint.sh

@@ -0,0 +1,184 @@
+#!/bin/bash
+# UV Suite Hook: Tier A auto-checkpoint — mechanical state snapshot.
+# Event: PostToolUse
+#
+# Logs every tool call into a per-session activity log. When `interval_minutes`
+# have passed since the last mechanical checkpoint AND there has been activity
+# in the interval, writes a deterministic snapshot to
+# uv-out/checkpoints/<sid>/auto-<ts>-mechanical.md and forwards an
+# AutoCheckpoint event to the watchtower.
+#
+# Tier B (semantic, claude -p) runs separately from the watchtower's timer.
+
+INPUT=$(cat 2>/dev/null || true)
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+STATE_DIR="$PROJECT_DIR/.uv-suite-state"
+SESSIONS_DIR="$STATE_DIR/sessions"
+mkdir -p "$SESSIONS_DIR" 2>/dev/null
+
+STATE_FILE="$STATE_DIR/auto-checkpoint.json"
+
+# Default state if missing
+if [ ! -f "$STATE_FILE" ]; then
+  cat > "$STATE_FILE" <<'EOF'
+{
+  "mode": "on",
+  "interval_minutes": 10
+}
+EOF
+fi
+
+# Read mode + interval (skip if mode != on)
+read_state() {
+  STATE_PATH="$STATE_FILE" python3 -c '
+import json, os, sys
+try:
+    d = json.load(open(os.environ["STATE_PATH"]))
+    print(d.get("mode", "on"))
+    print(d.get("interval_minutes", 10))
+except Exception:
+    print("on"); print("10")
+' 2>/dev/null
+}
+
+STATE_OUT=$(read_state)
+MODE=$(echo "$STATE_OUT" | sed -n 1p)
+INTERVAL_MIN=$(echo "$STATE_OUT" | sed -n 2p)
+[ "$MODE" != "on" ] && exit 0
+[ -z "$INTERVAL_MIN" ] && INTERVAL_MIN=10
+
+# Resolve session id
+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
+
+ACTIVITY_LOG="$SESSIONS_DIR/$SID.activity.log"
+LAST_CP_FILE="$SESSIONS_DIR/$SID.last-mechanical-checkpoint.txt"
+NOW=$(date +%s)
+
+# Append activity entry. Cap log at last 500 lines.
+TOOL=""
+TARGET=""
+if command -v jq >/dev/null 2>&1; then
+  TOOL=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null)
+  TARGET=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.command // .tool_input.pattern // .tool_input.url // ""' 2>/dev/null)
+fi
+TARGET=$(printf '%s' "$TARGET" | tr -d '\n' | cut -c1-120)
+[ -n "$TOOL" ] && echo "$NOW $TOOL $TARGET" >> "$ACTIVITY_LOG"
+if [ -f "$ACTIVITY_LOG" ]; then
+  LINES=$(wc -l < "$ACTIVITY_LOG" 2>/dev/null | tr -d ' ')
+  if [ -n "$LINES" ] && [ "$LINES" -gt 500 ]; then
+    tail -n 500 "$ACTIVITY_LOG" > "$ACTIVITY_LOG.tmp" && mv "$ACTIVITY_LOG.tmp" "$ACTIVITY_LOG"
+  fi
+fi
+
+# Has the interval passed since last mechanical checkpoint?
+# On the very first run, seed the timestamp with NOW so we don't fire a
+# checkpoint immediately — the first one fires after the interval has elapsed.
+if [ ! -f "$LAST_CP_FILE" ]; then
+  echo "$NOW" > "$LAST_CP_FILE"
+  exit 0
+fi
+LAST_CP=$(cat "$LAST_CP_FILE" 2>/dev/null)
+LAST_CP=${LAST_CP:-0}
+ELAPSED=$((NOW - LAST_CP))
+INTERVAL_SEC=$((INTERVAL_MIN * 60))
+[ "$ELAPSED" -lt "$INTERVAL_SEC" ] && exit 0
+
+# Activity since last checkpoint? If none, skip.
+SINCE_LINES=0
+if [ -f "$ACTIVITY_LOG" ]; then
+  SINCE_LINES=$(awk -v cutoff="$LAST_CP" '$1 > cutoff' "$ACTIVITY_LOG" 2>/dev/null | wc -l | tr -d ' ')
+fi
+[ "${SINCE_LINES:-0}" -lt 1 ] && exit 0
+
+# Resolve checkpoint dir + metadata via the existing helper
+CP_DIR=$(CLAUDE_PROJECT_DIR="$PROJECT_DIR" "$PROJECT_DIR/.claude/hooks/checkpoint-helper.sh" dir 2>/dev/null)
+[ -z "$CP_DIR" ] && CP_DIR="$PROJECT_DIR/uv-out/checkpoints/$SID" && mkdir -p "$CP_DIR"
+
+# Build the mechanical checkpoint body
+TS_FILE=$(date +%Y-%m-%d-%H%M)
+TS_ISO=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+CP_FILE="$CP_DIR/auto-$TS_FILE-mechanical.md"
+
+# Frontmatter from helper, augmented with checkpoint_kind
+FRONT=$(CLAUDE_PROJECT_DIR="$PROJECT_DIR" "$PROJECT_DIR/.claude/hooks/checkpoint-helper.sh" frontmatter 2>/dev/null)
+# Insert checkpoint_kind: auto-mechanical before closing ---
+FRONT=$(printf '%s' "$FRONT" | awk '
+  /^---$/ { count++ }
+  count == 2 && !done { print "checkpoint_kind: auto-mechanical"; done=1 }
+  { print }
+')
+
+# Activity summary from the log
+ACTIVITY_SUMMARY=$(awk -v cutoff="$LAST_CP" '$1 > cutoff' "$ACTIVITY_LOG" 2>/dev/null | python3 -c '
+import sys, collections, os
+lines = [l.strip() for l in sys.stdin if l.strip()]
+tools = collections.Counter()
+files = collections.Counter()
+for ln in lines:
+    parts = ln.split(" ", 2)
+    if len(parts) < 2: continue
+    tool = parts[1]
+    target = parts[2] if len(parts) > 2 else ""
+    tools[tool] += 1
+    if target and tool in ("Edit", "Write", "Read"):
+        files[target] += 1
+print("### Tool calls")
+for t, n in tools.most_common(8):
+    print(f"- {n}× {t}")
+if files:
+    print("\n### Files touched")
+    for f, n in files.most_common(8):
+        print(f"- {f} ({n})")
+print(f"\n_total tool calls in window: {sum(tools.values())}_")
+' 2>/dev/null)
+
+# Git state (best-effort, may be absent in non-git dirs)
+GIT_BRANCH=$(cd "$PROJECT_DIR" && git branch --show-current 2>/dev/null)
+GIT_STATUS=$(cd "$PROJECT_DIR" && git status --short 2>/dev/null | head -20)
+GIT_LOG=$(cd "$PROJECT_DIR" && git log --oneline -5 2>/dev/null)
+
+{
+  printf '%s\n\n' "$FRONT"
+  printf '# Auto-checkpoint (mechanical): %s\n\n' "$TS_ISO"
+  printf '_window: last %s min, %s tool calls_\n\n' "$INTERVAL_MIN" "$SINCE_LINES"
+  printf '## Activity\n\n%s\n\n' "$ACTIVITY_SUMMARY"
+  if [ -n "$GIT_BRANCH" ]; then
+    printf '## Git\n\n'
+    printf '**Branch:** %s\n\n' "$GIT_BRANCH"
+    if [ -n "$GIT_STATUS" ]; then
+      printf '**Status:**\n```\n%s\n```\n\n' "$GIT_STATUS"
+    else
+      printf '**Status:** clean\n\n'
+    fi
+    if [ -n "$GIT_LOG" ]; then
+      printf '**Recent commits:**\n```\n%s\n```\n' "$GIT_LOG"
+    fi
+  fi
+} > "$CP_FILE"
+
+# Update latest.md so /restore picks it up
+cp "$CP_FILE" "$CP_DIR/latest.md" 2>/dev/null
+echo "$NOW" > "$LAST_CP_FILE"
+
+# Send AutoCheckpoint event to watchtower with inline content
+if [ -x "$PROJECT_DIR/.claude/hooks/watchtower-send.sh" ]; then
+  PREVIEW=$(head -c 2000 "$CP_FILE")
+  PAYLOAD=$(PREVIEW_PATH="$CP_FILE" PREVIEW="$PREVIEW" INTERVAL_MIN="$INTERVAL_MIN" SINCE_LINES="$SINCE_LINES" CWD_VAR="$PROJECT_DIR" python3 -c '
+import json, os
+print(json.dumps({
+    "checkpoint_kind": "auto-mechanical",
+    "checkpoint_path": os.environ["PREVIEW_PATH"],
+    "checkpoint_preview": os.environ["PREVIEW"],
+    "interval_minutes": int(os.environ["INTERVAL_MIN"]),
+    "tool_calls_in_window": int(os.environ["SINCE_LINES"]),
+    "cwd": os.environ["CWD_VAR"],
+}))
+' 2>/dev/null)
+  printf '%s' "$PAYLOAD" | CLAUDE_PROJECT_DIR="$PROJECT_DIR" "$PROJECT_DIR/.claude/hooks/watchtower-send.sh" AutoCheckpoint 2>/dev/null
+fi
+
+exit 0

package/hooks/confirm-helper.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# UV Suite helper: toggle confirm-mode or change the threshold.
+# Used by the /confirm slash command. Extracted into a script so the
+# slash command can avoid inline ${...} expansions, which Claude Code's
+# permission heuristic flags as obfuscation.
+#
+# Usage:
+#   confirm-helper.sh           # show status
+#   confirm-helper.sh status
+#   confirm-helper.sh on
+#   confirm-helper.sh off
+#   confirm-helper.sh <number>  # set threshold
+
+STATE_DIR="${CLAUDE_PROJECT_DIR:-.}/.uv-suite-state"
+mkdir -p "$STATE_DIR"
+MODE_FILE="$STATE_DIR/confirm-mode.txt"
+THRESH_FILE="$STATE_DIR/confirm-threshold.txt"
+
+current_mode() { cat "$MODE_FILE" 2>/dev/null || echo "on"; }
+current_thresh() { cat "$THRESH_FILE" 2>/dev/null || echo "50"; }
+
+ARG=$(printf '%s' "$1" | tr -d '[:space:]')
+
+case "$ARG" in
+  on)
+    echo "on" > "$MODE_FILE"
+    echo "Confirm mode: ON (threshold: $(current_thresh) words)"
+    ;;
+  off)
+    echo "off" > "$MODE_FILE"
+    echo "Confirm mode: OFF"
+    ;;
+  ""|status)
+    echo "Confirm mode: $(current_mode) (threshold: $(current_thresh) words)"
+    ;;
+  *)
+    if printf '%s' "$ARG" | grep -qE '^[0-9]+$'; then
+      echo "$ARG" > "$THRESH_FILE"
+      echo "Threshold set to $ARG words (mode: $(current_mode))"
+    else
+      echo "Usage: /confirm [on | off | <number> | status]"
+      exit 1
+    fi
+    ;;
+esac

package/hooks/confirm-prompt.sh

@@ -40,8 +40,19 @@ WORDS=$(echo "$PROMPT" | wc -w | tr -d ' ')
 [ "$WORDS" -le "$THRESHOLD" ] && exit 0
 
 # Emit Claude Code hook output. additionalContext is appended to the system
-# context for this turn. Keep it terse — long instructions get tuned out.
-ADDITIONAL=$(printf '[uv-suite confirm-mode] The user prompt is %s words (threshold %s). Before doing any work or making tool calls, restate what you understood in 1-2 plain sentences and ask the user to confirm. Only proceed once they confirm. The user can disable this with /confirm off or change the threshold with /confirm <number>.' "$WORDS" "$THRESHOLD")
+# context for this turn. The instructions below shape the *style* of the
+# confirmation, not just whether one happens — the response should set
+# context, break the ask into bullets, and end with an explicit invitation
+# for the user to redirect before any work starts.
+ADDITIONAL=$(printf '[uv-suite confirm-mode] The user prompt is %s words (threshold %s). Before any work or tool calls, write a confirmation in this exact shape:
+
+1. Open with one short sentence that restates the goal in your own words — set the frame for what you think the user is asking for.
+2. Then a bulleted breakdown (3-7 bullets, one line each) covering: concrete deliverables, the key decisions or assumptions you intend to make, and any open questions or scope choices the user might want to redirect.
+3. End with a single explicit prompt: "Want me to change anything before I start, or should I go ahead?"
+
+Do not propose implementation steps, write code, or call tools yet. The point is to confirm understanding so the user can correct course cheaply. Only proceed once the user confirms.
+
+The user can disable this with /confirm off or change the threshold with /confirm <number>.' "$WORDS" "$THRESHOLD")
 
 if command -v jq >/dev/null 2>&1; then
   jq -nc --arg ctx "$ADDITIONAL" '{hookSpecificOutput:{hookEventName:"UserPromptSubmit",additionalContext:$ctx}}'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uv-suite",
-  "version": "0.26.4",
+  "version": "0.27.0",
   "description": "Portable framework for AI-assisted software development. 10 agents, 9 skills, 5 hooks, 4 personas. Works with Claude Code, Cursor, and Codex.",
   "author": "Utsav Anand",
   "license": "MIT",

package/personas/auto.json

@@ -37,14 +37,22 @@
       "Bash(wc *)",
       "Bash(head *)",
       "Bash(tail *)",
-      "Bash(curl *)"
+      "Bash(curl *)",
+      "Bash(chmod *)",
+      "Bash(rm /tmp/*)",
+      "Bash(echo *)",
+      "Bash(printf *)",
+      "Bash(node --check *)",
+      "Bash(bash -n *)"
     ],
     "deny": [
       "Bash(rm -rf /)",
       "Bash(rm -rf ~)",
       "Bash(sudo rm -rf *)",
       "Bash(git push --force * main)",
-      "Bash(git push --force * master)"
+      "Bash(git push --force * master)",
+      "Bash(rm -rf .)",
+      "Bash(sudo rm *)"
     ]
   },
   "hooks": {
@@ -155,6 +163,12 @@
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/watchtower-send.sh PostToolUse",
             "timeout": 2,
             "async": true
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/auto-checkpoint.sh",
+            "timeout": 5,
+            "async": true
           }
         ]
       },