meridian-dev 1.1.0

package/setup.sh

@@ -0,0 +1,407 @@
+#!/usr/bin/env bash
+# Skip Tissue — Setup Script
+# Installs the memory system for your AI coding assistant.
+# Safe to re-run (idempotent). Backs up existing files before modifying.
+#
+# Usage:
+#   bash setup.sh                    # Interactive — prompts for tool choice
+#   bash setup.sh --tool claude-code # Non-interactive
+#   bash setup.sh --tool cursor
+#   bash setup.sh --tool generic
+#   bash setup.sh --dry-run          # Preview changes without modifying files
+#   bash setup.sh --help             # Show this help
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TOOL=""
+DRY_RUN=false
+REPO_DIR=""
+UPDATE=false
+
+# ── Argument parsing ──────────────────────────────────────────────────────────
+
+usage() {
+    cat <<USAGE
+Usage: bash setup.sh [OPTIONS]
+
+Options:
+  --tool=TOOL     Specify tool without prompt (claude-code, cursor, generic)
+  --tool TOOL     Same as above (space-separated form)
+  --repo=PATH     Install per-repo rule into PATH (Cursor only)
+  --repo PATH     Same as above (space-separated form)
+  --update        Update mode: overwrite hook scripts and commands (memory files untouched)
+  --dry-run       Preview what would be installed without modifying files
+  --help          Show this help message
+
+Examples:
+  bash setup.sh
+  bash setup.sh --tool claude-code
+  bash setup.sh --tool=cursor --repo .
+  bash setup.sh --tool claude-code --update --dry-run
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --tool=*) TOOL="${1#--tool=}"; shift ;;
+        --tool)
+            if [ -z "${2:-}" ]; then
+                echo "Error: --tool requires a value (claude-code, cursor, or generic)"
+                exit 1
+            fi
+            TOOL="$2"; shift 2 ;;
+        --repo=*) REPO_DIR="$(cd "${1#--repo=}" 2>/dev/null && pwd || echo "")"; shift ;;
+        --repo)
+            if [ -z "${2:-}" ]; then
+                echo "Error: --repo requires a path"
+                exit 1
+            fi
+            REPO_DIR="$(cd "$2" 2>/dev/null && pwd || echo "")"; shift 2 ;;
+        --update) UPDATE=true; shift ;;
+        --dry-run) DRY_RUN=true; shift ;;
+        --help) usage; exit 0 ;;
+        *) shift ;;
+    esac
+done
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+RESET='\033[0m'
+
+log()    { echo -e "${GREEN}✓${RESET} $1"; }
+warn()   { echo -e "${YELLOW}⚠${RESET}  $1"; }
+info()   { echo "  $1"; }
+header() { echo ""; echo -e "${GREEN}── $1 ──${RESET}"; }
+
+backup_if_exists() {
+    local file="$1"
+    if [ -f "$file" ]; then
+        local backup="${file}.bak.$(date +%Y%m%d%H%M%S)"
+        cp "$file" "$backup"
+        warn "Backed up existing $file → $backup"
+    fi
+}
+
+run() {
+    if [ "$DRY_RUN" = true ]; then
+        info "[dry-run] $*"
+    else
+        "$@"
+    fi
+}
+
+append_if_missing() {
+    local needle="$1"
+    local content="$2"
+    local file="$3"
+    if ! grep -qF "$needle" "$file" 2>/dev/null; then
+        echo "$content" >> "$file"
+        log "Appended to $file"
+    else
+        info "Already present in $file — skipped"
+    fi
+}
+
+# ── Tool selection ─────────────────────────────────────────────────────────────
+
+if [ -z "$TOOL" ]; then
+    echo ""
+    echo "Skip Tissue — Setup"
+    echo "─────────────────────"
+    echo "Which AI tool are you setting up for?"
+    echo "  1) Claude Code"
+    echo "  2) Cursor"
+    echo "  3) Generic (system prompt / manual)"
+    echo ""
+    read -rp "Enter choice [1-3]: " choice
+    case "$choice" in
+        1) TOOL="claude-code" ;;
+        2) TOOL="cursor" ;;
+        3) TOOL="generic" ;;
+        *) echo "Invalid choice. Exiting."; exit 1 ;;
+    esac
+fi
+
+SPEC_DIR="$SCRIPT_DIR/specializations/$TOOL"
+if [ ! -d "$SPEC_DIR" ]; then
+    echo -e "${RED}Error:${RESET} No specialization found for '$TOOL' at $SPEC_DIR"
+    echo "Available: $(ls "$SCRIPT_DIR/specializations/")"
+    exit 1
+fi
+
+echo ""
+echo "Installing Skip Tissue for: $TOOL"
+[ "$DRY_RUN" = true ] && warn "Dry-run mode — no files will be modified"
+[ "$UPDATE" = true ] && warn "Update mode: overwriting hook scripts and commands (memory files untouched)"
+
+# ── Tool-specific config ───────────────────────────────────────────────────────
+
+case "$TOOL" in
+    claude-code)
+        MEMORY_DIR="$HOME/.claude"
+        MEMORY_SUBDIR="$HOME/.claude/memory"
+        GLOBAL_STATE="$HOME/.claude/global-state.md"
+        ADMIN_STATE="$HOME/.claude/state.md"
+        GLOBAL_CLAUDE_MD="$HOME/.claude/CLAUDE.md"
+        ;;
+    cursor)
+        MEMORY_DIR="$HOME/.ai-memory"
+        MEMORY_SUBDIR="$HOME/.ai-memory/memory"
+        GLOBAL_STATE="$HOME/.ai-memory/global.md"
+        ADMIN_STATE="$HOME/.ai-memory/state.md"
+        GLOBAL_CLAUDE_MD=""  # No global instructions file for Cursor
+        ;;
+    generic)
+        MEMORY_DIR="$HOME/.ai-memory"
+        MEMORY_SUBDIR="$HOME/.ai-memory/memory"
+        GLOBAL_STATE="$HOME/.ai-memory/global.md"
+        ADMIN_STATE="$HOME/.ai-memory/state.md"
+        GLOBAL_CLAUDE_MD=""
+        ;;
+esac
+
+# ── Step 1: Directories ────────────────────────────────────────────────────────
+
+header "Creating directories"
+
+run mkdir -p "$MEMORY_SUBDIR/journal"
+log "Memory directories: $MEMORY_SUBDIR/journal"
+
+if [ "$TOOL" = "claude-code" ]; then
+    run mkdir -p "$HOME/.claude/hooks"
+    run mkdir -p "$HOME/.claude/commands"
+    log "Claude Code hooks and commands directories"
+fi
+
+# ── Step 2: Global state file ─────────────────────────────────────────────────
+
+header "Global state file"
+
+if [ ! -f "$GLOBAL_STATE" ]; then
+    if [ "$TOOL" = "claude-code" ]; then
+        if [ "$DRY_RUN" = false ]; then
+            sed \
+                -e 's|~/.ai-memory/|~/.claude/|g' \
+                -e 's|\.ai-memory/state\.md|.claude/state.md|g' \
+                "$SCRIPT_DIR/templates/global.md" > "$GLOBAL_STATE"
+        else
+            info "[dry-run] Would sed (path substitution) templates/global.md > $GLOBAL_STATE"
+        fi
+    else
+        run cp "$SCRIPT_DIR/templates/global.md" "$GLOBAL_STATE"
+    fi
+    log "Created $GLOBAL_STATE"
+    warn "Edit $GLOBAL_STATE to add your name, preferences, and projects"
+else
+    info "Already exists: $GLOBAL_STATE — skipped"
+fi
+
+# ── Step 3: Admin state file (team/personal split) ───────────────────────────
+# For team repos, use templates/team-state.md (committed, shared context).
+# For personal notes, use templates/personal-state.md (gitignored, private).
+# The admin state file at ADMIN_STATE is the non-repo catch-all (email, admin, misc).
+
+header "Admin state file"
+
+if [ ! -f "$ADMIN_STATE" ]; then
+    run cp "$SCRIPT_DIR/templates/repo-state.md" "$ADMIN_STATE"
+    log "Created $ADMIN_STATE"
+else
+    info "Already exists: $ADMIN_STATE — skipped"
+fi
+
+# ── Step 4: Tool-specific files ───────────────────────────────────────────────
+
+header "Tool-specific files ($TOOL)"
+
+case "$TOOL" in
+    claude-code)
+        # Global CLAUDE.md fragment
+        if [ -n "$GLOBAL_CLAUDE_MD" ]; then
+            touch "$GLOBAL_CLAUDE_MD"
+            append_if_missing "Session State Protocol" \
+                "$(cat "$SPEC_DIR/CLAUDE.md-global-fragment.md")" \
+                "$GLOBAL_CLAUDE_MD"
+        fi
+
+        # Hook script
+        HOOK_DEST="$HOME/.claude/hooks/check-global-state.sh"
+        if [ ! -f "$HOOK_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SPEC_DIR/hooks/check-global-state.sh" "$HOOK_DEST"
+            run chmod +x "$HOOK_DEST"
+            log "Installed hook: $HOOK_DEST"
+        else
+            info "Hook already exists: $HOOK_DEST — skipped"
+        fi
+
+        # init-memory command
+        CMD_DEST="$HOME/.claude/commands/init-memory.md"
+        if [ ! -f "$CMD_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SPEC_DIR/commands/init-memory.md" "$CMD_DEST"
+            log "Installed command: /init-memory"
+        else
+            info "/init-memory command already exists — skipped"
+        fi
+
+        # doctor command
+        DOCTOR_CMD_DEST="$HOME/.claude/commands/doctor.md"
+        if [ ! -f "$DOCTOR_CMD_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SPEC_DIR/commands/doctor.md" "$DOCTOR_CMD_DEST"
+            log "Installed command: /doctor"
+        else
+            info "/doctor command already exists — skipped"
+        fi
+
+        # doctor.sh script
+        run mkdir -p "$HOME/.claude/skip-tissue"
+        DOCTOR_DEST="$HOME/.claude/skip-tissue/doctor.sh"
+        if [ ! -f "$DOCTOR_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SCRIPT_DIR/doctor.sh" "$DOCTOR_DEST"
+            run chmod +x "$DOCTOR_DEST"
+            log "Installed doctor script: $DOCTOR_DEST"
+        else
+            info "doctor.sh already exists: $DOCTOR_DEST — skipped"
+        fi
+
+        # journal-summary.sh script
+        JOURNAL_DEST="$HOME/.claude/skip-tissue/journal-summary.sh"
+        if [ ! -f "$JOURNAL_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SCRIPT_DIR/journal-summary.sh" "$JOURNAL_DEST"
+            run chmod +x "$JOURNAL_DEST"
+            log "Installed journal summary script: $JOURNAL_DEST"
+        else
+            info "journal-summary.sh already exists: $JOURNAL_DEST — skipped"
+        fi
+
+        # /journal command
+        JOURNAL_CMD_DEST="$HOME/.claude/commands/journal.md"
+        if [ ! -f "$JOURNAL_CMD_DEST" ] || [ "$UPDATE" = true ]; then
+            run cp "$SPEC_DIR/commands/journal.md" "$JOURNAL_CMD_DEST"
+            log "Installed command: /journal"
+        else
+            info "/journal command already exists — skipped"
+        fi
+
+        # /init-team command
+        TEAM_CMD_DEST="$HOME/.claude/commands/init-team.md"
+        if [ ! -f "$TEAM_CMD_DEST" ] || [ "$UPDATE" = true ]; then
+            if [ -f "$SPEC_DIR/commands/init-team.md" ]; then
+                run cp "$SPEC_DIR/commands/init-team.md" "$TEAM_CMD_DEST"
+                log "Installed command: /init-team"
+            fi
+        else
+            info "/init-team command already exists — skipped"
+        fi
+
+        # settings.json — merge hook, don't overwrite
+        SETTINGS="$HOME/.claude/settings.json"
+        HOOK_CMD="bash ~/.claude/hooks/check-global-state.sh"
+
+        if [ ! -f "$SETTINGS" ]; then
+            run cp "$SPEC_DIR/settings.json" "$SETTINGS"
+            log "Created $SETTINGS with hook registration"
+        else
+            if ! grep -q "check-global-state" "$SETTINGS" 2>/dev/null; then
+                # Merge hook into existing settings.json using Python
+                if [ "$DRY_RUN" = false ]; then
+                    # Write to temp file first (atomic write)
+                    TMP_SETTINGS="$(mktemp)"
+                    if python3 - "$SETTINGS" "$HOOK_CMD" "$TMP_SETTINGS" <<'PYEOF' 2>/dev/null; then
+import json, sys
+settings_path, hook_cmd, out_path = sys.argv[1], sys.argv[2], sys.argv[3]
+try:
+    with open(settings_path) as f:
+        settings = json.load(f)
+except (json.JSONDecodeError, IOError):
+    sys.exit(1)
+hooks = settings.setdefault("hooks", {})
+session_start = hooks.setdefault("SessionStart", [])
+if not isinstance(session_start, list):
+    sys.exit(1)
+hook_entry = {"type": "command", "command": hook_cmd}
+if not any(h.get("command") == hook_cmd for h in session_start if isinstance(h, dict)):
+    session_start.append(hook_entry)
+with open(out_path, "w") as f:
+    json.dump(settings, f, indent=2)
+    f.write("\n")
+PYEOF
+                        mv "$TMP_SETTINGS" "$SETTINGS"
+                        log "Merged SessionStart hook into existing $SETTINGS"
+                    else
+                        rm -f "$TMP_SETTINGS"
+                        warn "Could not auto-merge hook into $SETTINGS (malformed JSON or python3 unavailable)."
+                        warn "Manually add the SessionStart hook from: $SPEC_DIR/settings.json"
+                    fi
+                else
+                    info "[dry-run] Would merge hook into $SETTINGS"
+                fi
+            else
+                info "Hook already registered in settings.json — skipped"
+            fi
+        fi
+        ;;
+
+    cursor)
+        # Global rules
+        run mkdir -p "$HOME/.cursor/rules"
+        GLOBAL_RULE="$HOME/.cursor/rules/ai-memory.mdc"
+        if [ ! -f "$GLOBAL_RULE" ] || [ "${UPDATE:-false}" = true ]; then
+            run cp "$SPEC_DIR/global-rule.mdc" "$GLOBAL_RULE"
+            log "Installed global Cursor rule: $GLOBAL_RULE"
+        else
+            info "Global Cursor rule already exists — skipped"
+        fi
+
+        # Per-repo rule (if --repo was passed)
+        if [ -n "${REPO_DIR:-}" ]; then
+            if [ -d "$REPO_DIR" ]; then
+                RULE_DIR="$REPO_DIR/.cursor/rules"
+                run mkdir -p "$RULE_DIR"
+                if [ ! -f "$RULE_DIR/memory.mdc" ] || [ "${UPDATE:-false}" = true ]; then
+                    run cp "$SPEC_DIR/repo-rule.mdc" "$RULE_DIR/memory.mdc"
+                    log "Installed repo rule: $RULE_DIR/memory.mdc"
+                    warn "Edit $RULE_DIR/memory.mdc to add repo name and initial status"
+                else
+                    info "Repo rule already exists — skipped"
+                fi
+            else
+                warn "--repo path not found or not a directory: $REPO_DIR"
+            fi
+        fi
+        ;;
+
+    generic)
+        info "Generic setup complete. See $SPEC_DIR/README.md for system prompt instructions."
+        ;;
+esac
+
+# ── Step 5: Summary ───────────────────────────────────────────────────────────
+
+header "Done"
+
+echo ""
+echo "Memory kit installed for $TOOL."
+echo ""
+echo "Next steps:"
+echo "  1. Edit $GLOBAL_STATE with your preferences and projects"
+
+if [ "$TOOL" = "claude-code" ]; then
+    echo "  2. Open a repo and run /init-memory to set it up"
+    echo "  3. Start a Claude Code session — it will load your state automatically"
+    echo "  4. Run /journal for a weekly digest of your AI session logs"
+elif [ "$TOOL" = "cursor" ]; then
+    echo "  2. Open a repo and run: bash setup.sh --tool cursor --repo <path>"
+    echo "  3. Start a Cursor session — the global rule loads your state automatically"
+    echo "  4. See specializations/cursor/README.md for full documentation"
+else
+    echo "  2. Add the session protocol to your tool's system prompt"
+    echo "     See: specializations/generic/README.md"
+fi
+
+echo ""
+echo "  Full documentation: README.md"
+echo ""

package/specializations/claude-code/CLAUDE.md-global-fragment.md

@@ -0,0 +1,52 @@
+
+## Session State Protocol (Skip Tissue)
+
+**Memory system:** Hierarchical plain-markdown files. No CLI tools, no databases.
+
+### File Hierarchy
+
+```
+~/.claude/
+  global-state.md          # Thin index — ALWAYS load at session start
+  state.md                 # Admin/non-repo work
+  memory/                  # Topic files — load on demand
+    <topic>.md
+    journal/YYYY-MM-DD.md  # Daily log
+
+<repo>/.claude/
+  state.md                 # Per-repo state — load when working in that repo
+```
+
+### Session Start (REQUIRED)
+
+1. Read `~/.claude/global-state.md`
+2. Read `.claude/team-state.md` (shared team context) and `.claude/personal-state.md` (your personal context) in the current repo, if they exist. Fall back to `.claude/state.md` for older repos not yet migrated. (Or `~/.claude/state.md` if in home dir.)
+3. Check the Memory Files table in global-state.md — load any `~/.claude/memory/` files whose keywords match this session's topic
+4. Summarize current state, then ask: **"What's the goal for this session? What does success look like?"**
+
+### Mid-Session
+
+If work drifts from the stated goal, flag it: *"Quick check — we set out to [goal]. This feels like [tangent]. Stay the course or pivot?"*
+
+### Session End (on "stop" / "done" / "pause" / "tomorrow")
+
+1. Update `.claude/team-state.md` with shared changes and `.claude/personal-state.md` with personal changes. (For older repos not yet migrated, update `.claude/state.md` as before.)
+2. Update the Active Projects row in `~/.claude/global-state.md`
+3. Create/update topic files in `~/.claude/memory/` for significant new cross-repo context
+4. Append to `~/.claude/memory/journal/YYYY-MM-DD.md`:
+   ```
+   ## [Repo] — [Title]
+   **Why:** [Stated goal]
+   **What:** [What was done]
+   **Outcome:** [Did we hit it?]
+   **On track?:** [Focused or drift?]
+   **Lessons:** [Cross-session learnings]
+   ```
+5. Confirm: **"State saved. Say 'let's continue' next time."**
+
+### Rules
+
+- Keep `global-state.md` under 80 lines. Detail goes in `~/.claude/memory/` files.
+- Per-repo `state.md` stays focused on that repo only.
+- New cross-repo topics get new files in `~/.claude/memory/`, not appended to global-state.md.
+- Do NOT use ruvector/claude-flow memory CLI. It writes empty databases. Plain files only.

package/specializations/claude-code/CLAUDE.md-repo-fragment.md

@@ -0,0 +1,16 @@
+
+## Session State Protocol
+
+**At session start (REQUIRED):**
+1. Read `~/.claude/global-state.md` — preferences, active projects, memory file manifest
+2. Read `.claude/team-state.md` in this repo — shared team context (architecture decisions, conventions, sprint focus, gotchas)
+3. Read `.claude/personal-state.md` in this repo — your personal context (current focus, working notes, opinions)
+4. Check the Memory Files table in global-state.md — load any `~/.claude/memory/` files relevant to this session's topic
+
+**At session end (when user says stop/done/pause/tomorrow):**
+1. Update `.claude/team-state.md` with shared context: architecture decisions, conventions, gotchas the whole team should know
+2. Update `.claude/personal-state.md` with personal context: your next steps, working notes, opinions
+3. Update the project's row in `~/.claude/global-state.md` Active Projects table
+4. If significant new cross-repo context was created (patterns, strategies, decisions), create or update a file in `~/.claude/memory/` and add it to the Memory Files manifest in global-state.md
+
+**Do NOT use ruvector/claude-flow memory CLI for state storage.** Use plain markdown files only.

package/specializations/claude-code/README.md

@@ -0,0 +1,96 @@
+# Claude Code Specialization
+
+This directory contains everything needed to wire the Skip Tissue into Claude Code specifically.
+
+## What's Different About Claude Code
+
+Claude Code reads a `CLAUDE.md` file at the root of every repo (and `~/.claude/CLAUDE.md` globally) as persistent instructions. It also supports:
+- **Hooks** — shell scripts that run on session start/end, file edits, commands
+- **Custom slash commands** — markdown files in `.claude/commands/` become `/command-name` shortcuts
+- **Settings** — `~/.claude/settings.json` controls hooks and behavior
+
+The memory directory for Claude Code is `~/.claude/` (not `~/.ai-memory/`).
+
+## File Map
+
+| File | Install to | Purpose |
+|------|-----------|---------|
+| `CLAUDE.md-global-fragment.md` | Append to `~/.claude/CLAUDE.md` | Tells Claude to load memory files at session start |
+| `CLAUDE.md-repo-fragment.md` | Append to `<repo>/CLAUDE.md` | Repo-level session protocol |
+| `settings.json` | Merge into `~/.claude/settings.json` | Registers the anti-drift hook |
+| `hooks/check-global-state.sh` | Copy to `~/.claude/hooks/` | Warns when global index is stale |
+| `commands/init-memory.md` | Copy to `~/.claude/commands/` | Adds `/init-memory` slash command |
+
+The `setup.sh` at the kit root handles all of this automatically.
+
+## Manual Install
+
+```bash
+# 1. Create directories
+mkdir -p ~/.claude/hooks ~/.claude/commands ~/.claude/memory/journal
+
+# 2. Copy the global CLAUDE.md fragment
+cat specializations/claude-code/CLAUDE.md-global-fragment.md >> ~/.claude/CLAUDE.md
+
+# 3. Install hook script
+cp specializations/claude-code/hooks/check-global-state.sh ~/.claude/hooks/
+chmod +x ~/.claude/hooks/check-global-state.sh
+
+# 4. Install init-memory command
+cp specializations/claude-code/commands/init-memory.md ~/.claude/commands/
+
+# 5. Merge settings.json
+# If ~/.claude/settings.json doesn't exist:
+cp specializations/claude-code/settings.json ~/.claude/settings.json
+# If it already exists, manually add the "hooks" block from settings.json
+
+# 6. Copy global state template
+cp ../../templates/global.md ~/.claude/global-state.md
+# Edit it to add your preferences and projects
+```
+
+## Per-Repo Setup
+
+For each repo you work in:
+
+```bash
+cd ~/repos/your-org/your-repo
+mkdir -p .claude
+
+# Copy repo state template
+cp ~/.claude/skip-tissue/templates/repo-state.md .claude/state.md
+# Fill it in with current branch, status, next steps
+
+# Add session protocol to repo CLAUDE.md
+cat ~/.claude/skip-tissue/specializations/claude-code/CLAUDE.md-repo-fragment.md >> CLAUDE.md
+
+# Add gitignore entries (IMPORTANT — see note below)
+echo ".claude/state.md" >> .gitignore
+echo ".claude/settings.local.json" >> .gitignore
+echo ".claude/memory.db" >> .gitignore
+```
+
+Or just run `/init-memory` inside Claude Code after setup.
+
+## Gitignore Warning
+
+**Never add `.claude/` to `.gitignore` as a whole directory.**
+
+Claude Code stores skills, commands, and settings in `.claude/` that should be tracked in git. If you ignore the whole directory, git won't track those files — and negation rules like `!.claude/commands/` won't rescue them (git doesn't descend into ignored directories).
+
+**Correct pattern:**
+```gitignore
+# Claude Code — local only, don't track
+.claude/state.md
+.claude/settings.local.json
+.claude/memory.db
+```
+
+**Wrong:**
+```gitignore
+.claude/          ← this breaks skills and commands
+```
+
+## Memory Directory Note
+
+Claude Code uses `~/.claude/` as its home. This kit uses that same directory rather than `~/.ai-memory/` so that Claude's native file loading works correctly. The file paths in your `global-state.md` will reference `~/.claude/memory/` accordingly.

package/specializations/claude-code/commands/doctor.md

@@ -0,0 +1,31 @@
+---
+description: Run Skip Tissue health check — validates hooks, state files, backup status, and memory file sizes.
+---
+
+# Skip Tissue — Doctor
+
+Run a health check on the memory system.
+
+## Step 1: Check if doctor.sh is available
+
+Look for `~/.claude/skip-tissue/doctor.sh`. If found, run it:
+```bash
+bash ~/.claude/skip-tissue/doctor.sh
+```
+
+If not found, perform the checks manually:
+
+## Step 2: Manual checks
+
+1. **Hook registered?** — Does `~/.claude/settings.json` contain "check-global-state"?
+2. **Global state current?** — Read `~/.claude/global-state.md`. When was it last updated?
+3. **Backup status** — Check `~/.claude/.backup-last-push` and `~/.claude/.backup-last-error`
+4. **Repos** — Scan `~/repos`, `~/code`, `~/dev` for `.claude/state.md` files
+5. **Memory files** — List files in `~/.claude/memory/`, flag any over 8KB
+
+## Step 3: Report findings
+
+Report in this format:
+- ✓ items that are working correctly
+- ⚠ items that need attention (not broken, but worth knowing)
+- ✗ items that are broken (with how to fix)