meridian-dev 1.1.0

package/BOOTSTRAP_PROMPT.md

@@ -0,0 +1,110 @@
+# Bootstrap Prompt
+
+Copy and paste the block below into a new Claude Code session. That's it.
+
+---
+
+```
+Please set up Meridian for my Claude Code environment.
+
+Run this command:
+npx meridian-dev init
+
+Once it completes:
+1. Tell me what was installed and what still needs to be configured
+2. Run /init-memory to initialize memory for the current repo
+3. Ask me what my preferences are (communication style, tool preferences, commit
+   conventions, anything I want Claude to always know) so we can fill in
+   global-state.md together
+4. Ask me if I want to set up backup (see below) — I will need to provide a
+   private GitHub repo URL before you can proceed with that step
+5. Ask me if I want to set up team context (/init-team) for shared journals,
+   digests, and product state
+```
+
+---
+
+## What happens
+
+The install command will:
+- Create `~/.claude/memory/` and `~/.claude/memory/journal/`
+- Install `~/.claude/global-state.md` (your persistent index)
+- Install `~/.claude/hooks/check-global-state.sh` (warns when state is stale)
+- Install slash commands: `/init-memory`, `/init-team`, `/journal`, `/doctor`
+- Register the hook in `~/.claude/settings.json`
+
+After the paste, Claude will walk you through filling in your preferences. From
+then on, every session in every repo will start with full context of where you
+left off. You don't need to do anything special — just open Claude Code and
+start working. Claude reads the state files automatically.
+
+---
+
+## Setting up backup (recommended)
+
+Your memory files live locally at `~/.claude/`. If you want them backed up and
+synced across machines, you need to provide a **private GitHub repo**.
+
+**You must create this repo yourself** — Claude cannot do it for you.
+
+Steps:
+1. Go to github.com/new
+2. Create a **private** repo (name it anything — e.g. `claude-memory`)
+3. Copy the repo URL (SSH preferred: `git@github.com:you/claude-memory.git`)
+4. Tell Claude: *"Set up backup using <your-repo-url>"*
+
+Claude will then run:
+```
+bash ~/.claude/skip-tissue/backup/setup.sh <your-repo-url>
+```
+
+This will:
+- Clone your backup repo to `~/.claude-backup/`
+- Do an initial sync of your memory files
+- Install hooks that automatically restore at session start and push at session end
+
+After that, your memory is backed up silently on every session — no manual steps.
+
+---
+
+## Setting up team context (optional)
+
+Once you have the basics working, run `/init-team` in a Claude Code session to set up:
+- A shared team context repo for journals and digests
+- Slack integration for weekly digest posts
+- Notion integration for browseable product state and digest archives
+- Product state for your pilot repo (PM intent, success criteria, constraints)
+
+This is the team-level layer — it turns individual session context into shared
+visibility across product, engineering, and strategy.
+
+---
+
+## Per-repo initialization
+
+In any repo you work in, run:
+```
+/init-memory
+```
+
+Claude will create `.claude/team-state.md` (shared) and `.claude/personal-state.md`
+(gitignored), fix your `.gitignore`, and register the repo in your global index.
+
+---
+
+## For Cursor users
+
+```
+npx meridian-dev init-cursor
+```
+
+---
+
+## Source
+
+https://github.com/leizerowicz/skip-tissue
+
+To install a specific version:
+```
+npx meridian-dev@1.1.0 init
+```

package/README.md

@@ -0,0 +1,344 @@
+# Skip Tissue
+## Persistent Cross-Session Context for AI Coding Assistants
+
+> **Tool-agnostic.** Works with Claude Code, Cursor, Copilot, or any AI assistant that reads files. See `specializations/` for tool-specific setup.
+
+---
+
+## Give Your AI a Working Model of Your World
+
+The most valuable things your AI can know aren't in your codebase. They're the context that takes minutes to re-explain every session:
+
+**Team dynamics:**
+> "Jordan (co-founder) is a peer, not a report. Keep Jordan informed; Jordan manages their own workload. Don't suggest assigning tasks to Jordan."
+
+**Project status:**
+> "The checkout flow rewrite landed in staging but conversion dropped 3%. We're debugging before GA — don't touch the payment module until this is resolved."
+
+**Decision frameworks:**
+> "Build vs. buy: default to buy for non-core infrastructure unless there's significant vendor lock-in risk. We're a 4-person team — operational simplicity beats optimal."
+
+These aren't README comments. They're the working model your AI needs to handle your real work — saved once, loaded every session.
+
+---
+
+## Why Not Just Write a Good README?
+
+A README is for contributors. Memory files are for your AI — and they contain things you would never put in a README:
+
+- Team dynamics and working style notes
+- Personal decision frameworks and context that shifts over time
+- Current status of every active project, updated after each session
+- Solutions to recurring problems and cross-repo architectural decisions
+
+A README is static documentation. Memory files are a live operating context.
+
+---
+
+## The Problem
+
+AI coding assistants have no memory between sessions. Every conversation starts from zero. You re-explain the project, re-establish conventions, re-describe where you left off. The AI re-discovers things it already learned last time.
+
+This kit solves that with **plain markdown files** that your AI reads at the start of every session. No databases, no proprietary formats, no vendor lock-in — just text files you own and can read yourself.
+
+---
+
+## How It Works
+
+Your AI reads a small set of markdown files at session start to reconstruct context. At session end, it updates those files with what changed. The next session picks up exactly where you left off.
+
+> **Note on paths:** The memory directory depends on your tool. Claude Code uses `~/.claude/`. Cursor and generic setups use `~/.ai-memory/`. The setup script handles this automatically — all examples below show the generic path.
+
+### The Three-File Pattern
+
+```
+~/.ai-memory/
+  global.md              # Thin index — always loaded. Preferences, project table, file manifest.
+  state.md               # Admin/non-repo notes (decisions, emails, misc tasks)
+  memory/                # Topic files — loaded on demand when the session topic matches
+    <topic>.md
+    journal/
+      YYYY-MM-DD.md      # Daily log, append-only
+
+<repo>/.ai-memory/
+  state.md               # Per-repo: branch, status, next steps, gotchas
+```
+
+**The index stays small** (under 80 lines). Detail lives in `memory/` files and is loaded only when relevant. This keeps every session fast and focused.
+
+---
+
+## Quick Start
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/leizerowicz/skip-tissue/main/install.sh | bash
+```
+
+Or if you've cloned the repo:
+
+```bash
+bash setup.sh
+```
+
+The setup script will:
+- Create the memory directory structure
+- Install template files
+- Install your chosen tool's specialization
+- Register any hooks or system prompt fragments
+
+Then pick up your tool-specific README in `specializations/`.
+
+---
+
+## Manual Setup
+
+If you prefer to set up by hand:
+
+### 1. Create the directory structure
+
+```bash
+mkdir -p ~/.ai-memory/memory/journal
+```
+
+### 2. Copy and fill in the global index
+
+```bash
+cp templates/global.md ~/.ai-memory/global.md
+# Edit it with your name, preferences, and initial projects
+```
+
+### 3. Add the session protocol to your AI tool
+
+Each tool has a different mechanism. See `specializations/` for your tool:
+
+| Tool | Specialization |
+|------|---------------|
+| Claude Code | `specializations/claude-code/` |
+| Cursor | `specializations/cursor/` |
+| Any (manual system prompt) | `specializations/generic/` |
+
+### 4. Initialize each repo
+
+Copy `templates/repo-state.md` to `<repo>/.ai-memory/state.md` and fill it in. Or use the `/init-memory` command if your tool supports custom commands (see specialization).
+
+---
+
+## What Your Memory Files Look Like
+
+Here are examples of the kinds of content that belong in memory files. These are the entries that make the difference between an AI that re-asks the same questions every session and one that picks up exactly where you left off.
+
+**Working style and technical preferences** (`~/.ai-memory/memory/technical-patterns.md`):
+
+```markdown
+## Working Style
+- Commit messages: imperative mood, explain why not what
+- Never touch production before local repro
+- Default to TypeScript strict mode
+- Build vs. buy: default buy for non-core infrastructure unless vendor lock-in risk
+- When in doubt, prefer the boring solution over the clever one
+```
+
+**Team context** (`~/.ai-memory/memory/team-context.md`):
+
+```markdown
+## Team Context
+- Design Lead: prefers async feedback via Figma, not Slack. Needs 24h heads-up for scope changes.
+- Co-founder: peer, not a report. Keep informed; they manage their own workload.
+- Support team: PST-based. Async decisions logged in Notion, not Slack.
+```
+
+**Active projects** (in `~/.ai-memory/global.md`):
+
+```markdown
+## Active Projects
+| Project | Status | Next |
+|---------|--------|------|
+| Checkout flow rewrite | Staging — conversion regression under investigation | Fix promo code edge case, re-run A/B |
+| Notification service | In prod, but email deliverability dropped to 89% | Investigate SPF/DKIM alignment with new domain |
+| Mobile app v2 | Design approved, API contracts drafted | Scaffold React Native nav + auth screens |
+| Billing migration | **ON HOLD** — waiting on Stripe Connect approval | Unblock after Stripe responds (ETA ~1 week) |
+```
+
+**Per-repo state** (`<repo>/.ai-memory/state.md`):
+
+```markdown
+## Branch
+feat/webhooks-retry
+
+## Status
+Retry logic works for 5xx errors. Stuck on idempotency — duplicate events when
+the upstream acks late and we retry. Need a dedup key in the event payload.
+
+## Next
+Add `idempotency_key` to WebhookEvent model, enforce uniqueness in Postgres,
+then re-run the chaos test suite.
+
+## Gotchas
+- ngrok tunnel expires every 2 hours — restart before long test runs.
+- The `webhook_events` table in staging has 800K rows of junk. Truncate before
+  benchmarking or the index scan will mislead you.
+```
+
+These files are plain markdown. You own them, you can read them, and they travel with you across tools.
+
+---
+
+## What to Store — and What Not To
+
+Not everything belongs in AI-readable memory files. These files are transmitted to cloud AI provider APIs on every session. Here's a practical guide:
+
+### Tier 1 — Safe to include in any AI session
+- Project status and next steps
+- Technical patterns, gotchas, and architectural decisions
+- Workflow preferences and tool conventions
+- Team communication preferences (using roles, not names where possible)
+
+### Tier 2 — Handle with care
+- Named individuals with working style notes — keep factual, avoid psychological characterizations. Use roles ("Design Lead") rather than names when possible.
+- Vendor or client context — include enough to be useful, but not dispute positions or settlement targets
+- Anything you'd be comfortable sharing in a work setting
+
+### Tier 3 — Do not store in AI-readable files
+- Active legal dispute positions and settlement targets
+- Salary, compensation, or financial negotiation strategy
+- Named individual characterizations you'd be uncomfortable seeing quoted externally
+- Medical or personal information about anyone
+
+> **Guiding principle:** If you would be uncomfortable having this content quoted back in an employment discussion, a legal proceeding, or a vendor negotiation, it should not be in a file transmitted to a cloud AI API.
+
+**A practical middle ground:** Pseudonymize sensitive context. "Design Lead prefers async feedback" is useful and carries no personal data risk. "Sarah thinks the PM is incompetent and threatened to quit" should stay in your head.
+
+### A note on GDPR
+
+European users storing personal data about named third parties (employees, contractors, clients) in files transmitted to a cloud API likely constitute data processing under GDPR Article 4. If this applies to you, treat AI memory files as you would any other data processor relationship — store only what's necessary, and consider pseudonymization.
+
+---
+
+## What to Store — Examples
+
+**Good memory file candidates:**
+- Decisions that span multiple repos or sessions
+- Architectural patterns your team has settled on
+- Solutions to recurring problems
+- Cross-repo conventions
+- Team communication preferences and working style notes
+
+**Don't store:**
+- Things already in the codebase (code is the source of truth)
+- Single-session temporary state
+- Anything that duplicates what's in a project README or CLAUDE.md
+- Sensitive negotiation positions or personal information (see tiers above)
+
+---
+
+## Tool-Specific Setup
+
+### Claude Code
+
+See `specializations/claude-code/README.md` for:
+- Adding the session protocol to `CLAUDE.md`
+- Registering the `/init-memory` command
+- Session start/end hooks
+
+### Cursor
+
+See `specializations/cursor/README.md` for:
+- Adding the protocol to `.cursorrules`
+- Cursor-compatible memory file paths
+- Session management without hooks
+
+---
+
+## Backup
+
+Memory files are plain text — back them up like any other important file:
+
+```bash
+# Add to an existing private repo, or create one
+cd ~/.ai-memory
+git init
+git remote add origin git@github.com:<you>/ai-memory-private.git
+git add -A && git commit -m "backup"
+git push -u origin main
+```
+
+Run this periodically or hook it into your session-end workflow.
+
+---
+
+## The Protocol
+
+### Session Start
+
+Your AI will:
+1. Read `~/.ai-memory/global.md` (always)
+2. Read the current repo's `.ai-memory/state.md` (always)
+3. Check the Memory Files table in `global.md` — load any topic files that match the session
+4. Say: **"Resuming [project]: [summary of current state]"**
+5. Ask: **"What's the goal for this session? What does success look like?"**
+
+### Mid-Session
+
+If the session drifts from the stated goal, the AI flags it:
+
+> *"Quick check — we set out to [goal]. This feels like [tangent]. Stay the course or pivot?"*
+
+### Session End
+
+When you say "stop", "done", "pause", "wrap up", or "tomorrow":
+1. AI updates `.ai-memory/state.md` in the current repo
+2. AI updates the Active Projects row in `~/.ai-memory/global.md`
+3. AI creates/updates any relevant topic memory files
+4. AI appends to `~/.ai-memory/memory/journal/YYYY-MM-DD.md`
+5. AI confirms: **"State saved. Say 'let's continue' next time."**
+
+---
+
+## Journal Format
+
+The journal is a daily append-only log. Each entry follows this structure:
+
+```markdown
+## [Project or context] — [Brief title]
+**Why:** [The stated goal for this session]
+**What:** [Bullet list of what was actually done]
+**Outcome:** [Did we hit the goal? Key deliverables]
+**On track?:** [Focused or did we drift? What caused drift?]
+**Lessons:** [Worth remembering cross-session]
+```
+
+Multiple sessions per day just append more blocks to the same file.
+
+---
+
+## File Templates
+
+All templates are in `templates/`. See them for copy-paste-ready starting points:
+
+| Template | Purpose |
+|----------|---------|
+| `templates/global.md` | Starting `~/.ai-memory/global.md` |
+| `templates/repo-state.md` | Starting `.ai-memory/state.md` for a repo |
+| `templates/memory-file.md` | Starting point for a topic memory file |
+| `templates/session-protocol-fragment.md` | The protocol block to inject into your AI tool |
+
+---
+
+## Contributing
+
+### Adding a Specialization
+
+To add support for a new tool:
+1. Create `specializations/<tool-name>/README.md` following the pattern in `specializations/claude-code/README.md`
+2. Include any config files, hook scripts, or command files needed
+3. Document the install steps clearly — assume no prior context
+
+---
+
+## Critical Rules
+
+1. **Always read state files at session start.** They're plain files — they cannot fail.
+2. **Always update state files at session end.** Edit in place; don't append new sections.
+3. **Keep the global index small** (under 80 lines). Detail goes in `memory/` files.
+4. **Per-repo state stays focused** on that repo. Cross-repo context goes in topic files.
+5. **Don't gitignore your AI tool's config directory as a whole.** Only ignore local-only files (state.md, secrets). Commands, skills, and settings should be tracked.

package/backup/hooks/session-end.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Skip Tissue — Backup Push Hook
+# Runs at session end. Syncs ~/.claude/ memory files to backup repo and pushes.
+# Silently no-ops if backup isn't configured or nothing changed.
+
+set -euo pipefail
+
+MEMORY_DIR="$HOME/.claude"
+BACKUP_DIR_FILE="$MEMORY_DIR/.backup-dir"
+
+[ -f "$BACKUP_DIR_FILE" ] || exit 0
+BACKUP_DIR="$(cat "$BACKUP_DIR_FILE")"
+[ -d "$BACKUP_DIR/.git" ] || exit 0
+command -v git &>/dev/null || exit 0
+
+# Sync: ~/.claude/ -> backup repo
+rsync -a \
+    "$MEMORY_DIR/global-state.md" \
+    "$MEMORY_DIR/state.md" \
+    "$BACKUP_DIR/" 2>/dev/null || true
+
+if [ -d "$MEMORY_DIR/memory" ]; then
+    rsync -a "$MEMORY_DIR/memory/" "$BACKUP_DIR/memory/" 2>/dev/null || true
+fi
+
+# Commit and push if anything changed
+cd "$BACKUP_DIR" || { echo "ERROR: cannot cd to backup dir $BACKUP_DIR"; exit 1; }
+git add -A
+if git diff --cached --quiet; then
+    exit 0  # Nothing changed — skip silently
+fi
+
+git commit -m "auto: $(date '+%Y-%m-%d %H:%M')" --quiet
+
+# Push
+GIT_ERROR=$(git push origin "${BRANCH:-main}" --quiet 2>&1) && {
+    echo "$(date '+%Y-%m-%d %H:%M')" > "$HOME/.claude/.backup-last-push"
+    rm -f "$HOME/.claude/.backup-last-error"
+} || {
+    ERROR_MSG="$(date '+%Y-%m-%d %H:%M') — git push failed: $GIT_ERROR"
+    echo "$ERROR_MSG" > "$HOME/.claude/.backup-last-error"
+    echo "Warning: Backup push failed. Details: $HOME/.claude/.backup-last-error"
+    exit 1
+}

package/backup/hooks/session-start.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Skip Tissue — Backup Restore Hook
+# Runs at session start. Pulls latest from backup repo, then syncs to ~/.claude/
+# Silently no-ops if backup isn't configured or git isn't available.
+
+set -euo pipefail
+
+MEMORY_DIR="$HOME/.claude"
+BACKUP_DIR_FILE="$MEMORY_DIR/.backup-dir"
+
+[ -f "$BACKUP_DIR_FILE" ] || exit 0
+BACKUP_DIR="$(cat "$BACKUP_DIR_FILE")"
+[ -d "$BACKUP_DIR/.git" ] || exit 0
+command -v git &>/dev/null || exit 0
+
+# Warn if last push failed
+LAST_ERROR="$HOME/.claude/.backup-last-error"
+if [ -f "$LAST_ERROR" ]; then
+    echo "Warning: Backup: last push FAILED at $(cat "$LAST_ERROR")"
+    echo "  Fix and re-run: cd ~/.claude-backup && git push"
+fi
+
+# Pull latest (silently — don't block session start)
+git -C "$BACKUP_DIR" pull --quiet --ff-only 2>/dev/null || true
+
+# Restore: sync backup -> ~/.claude/
+rsync -a --update \
+    "$BACKUP_DIR/global-state.md" \
+    "$MEMORY_DIR/" 2>/dev/null || true
+
+rsync -a --update \
+    "$BACKUP_DIR/state.md" \
+    "$MEMORY_DIR/" 2>/dev/null || true
+
+if [ -d "$BACKUP_DIR/memory" ]; then
+    rsync -a --update "$BACKUP_DIR/memory/" "$MEMORY_DIR/memory/" 2>/dev/null || true
+fi

package/backup/setup.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# Skip Tissue — Backup Setup
+# Wires a private GitHub repo as your memory backup.
+#
+# Usage: bash backup/setup.sh <repo-url>
+# Example: bash backup/setup.sh git@github.com:you/claude-memory.git
+#          bash backup/setup.sh https://github.com/you/claude-memory.git
+#
+# What this does:
+#   1. Clones your backup repo to ~/.claude-backup/
+#   2. Does an initial sync of your memory files into it
+#   3. Installs session-start (restore) and session-end (push) hooks
+#   4. Registers both hooks in ~/.claude/settings.json
+
+set -euo pipefail
+
+REPO_URL="${1:-}"
+BACKUP_DIR="$HOME/.claude-backup"
+MEMORY_DIR="$HOME/.claude"
+HOOKS_DIR="$HOME/.claude/hooks"
+SETTINGS="$HOME/.claude/settings.json"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+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"; }
+err()  { echo -e "${RED}✗${RESET} $1"; exit 1; }
+
+# ── Validate ──────────────────────────────────────────────────────────────────
+
+if [ -z "$REPO_URL" ]; then
+    err "No repo URL provided.\nUsage: bash backup/setup.sh <repo-url>"
+fi
+
+if ! command -v git &>/dev/null; then
+    err "git is required but not installed."
+fi
+
+if ! command -v rsync &>/dev/null; then
+    err "rsync is required but not installed. On macOS: brew install rsync"
+fi
+
+# ── Clone or init backup repo ─────────────────────────────────────────────────
+
+echo ""
+echo "Skip Tissue — Backup Setup"
+echo ""
+
+if [ -d "$BACKUP_DIR/.git" ]; then
+    warn "Backup repo already exists at $BACKUP_DIR — pulling latest"
+    git -C "$BACKUP_DIR" pull --quiet
+else
+    echo "Cloning backup repo..."
+    if git clone "$REPO_URL" "$BACKUP_DIR" 2>/dev/null; then
+        log "Cloned $REPO_URL → $BACKUP_DIR"
+    else
+        # Repo exists on GitHub but is empty — clone fails. Init locally instead.
+        mkdir -p "$BACKUP_DIR"
+        git -C "$BACKUP_DIR" init
+        git -C "$BACKUP_DIR" remote add origin "$REPO_URL"
+        log "Initialized empty backup repo at $BACKUP_DIR"
+    fi
+fi
+
+# ── Initial sync ──────────────────────────────────────────────────────────────
+
+echo "Syncing memory files to backup repo..."
+
+# Files to back up: global index, admin state, and the entire memory/ directory
+mkdir -p "$BACKUP_DIR"
+rsync -a \
+    "$MEMORY_DIR/global-state.md" \
+    "$MEMORY_DIR/state.md" \
+    "$BACKUP_DIR/" 2>/dev/null || true
+
+if [ -d "$MEMORY_DIR/memory" ]; then
+    mkdir -p "$BACKUP_DIR/memory"
+    rsync -a "$MEMORY_DIR/memory/" "$BACKUP_DIR/memory/" 2>/dev/null || true
+fi
+
+# Initial commit
+cd "$BACKUP_DIR"
+git add -A
+if ! git diff --cached --quiet; then
+    git commit -m "initial backup — $(date '+%Y-%m-%d')"
+    git push -u origin main 2>/dev/null || git push -u origin master 2>/dev/null || \
+        warn "Push failed — check your repo URL and SSH/token auth, then run: git -C $BACKUP_DIR push"
+    log "Initial backup pushed"
+else
+    log "Nothing to commit in initial sync"
+fi
+
+# ── Install hook scripts ──────────────────────────────────────────────────────
+
+mkdir -p "$HOOKS_DIR"
+
+cp "$SCRIPT_DIR/hooks/session-start.sh" "$HOOKS_DIR/backup-restore.sh"
+chmod +x "$HOOKS_DIR/backup-restore.sh"
+log "Installed: $HOOKS_DIR/backup-restore.sh"
+
+cp "$SCRIPT_DIR/hooks/session-end.sh" "$HOOKS_DIR/backup-push.sh"
+chmod +x "$HOOKS_DIR/backup-push.sh"
+log "Installed: $HOOKS_DIR/backup-push.sh"
+
+# Store the backup dir path so hooks know where to find it
+echo "$BACKUP_DIR" > "$MEMORY_DIR/.backup-dir"
+log "Stored backup dir config: $MEMORY_DIR/.backup-dir"
+
+# ── Register hooks in settings.json ──────────────────────────────────────────
+
+if [ ! -f "$SETTINGS" ]; then
+    cp "$SCRIPT_DIR/../specializations/claude-code/settings.json" "$SETTINGS"
+fi
+
+python3 - <<PYEOF
+import json, os
+
+settings_path = os.path.expanduser("$SETTINGS")
+with open(settings_path) as f:
+    s = json.load(f)
+
+hooks = s.setdefault("hooks", {})
+
+# SessionStart: restore (pull) — prepend so it runs before check-global-state
+start_hooks = hooks.setdefault("SessionStart", [])
+restore_cmd = {"type": "command", "command": "bash ~/.claude/hooks/backup-restore.sh"}
+if not any(h.get("command", "").endswith("backup-restore.sh") for h in start_hooks):
+    start_hooks.insert(0, restore_cmd)
+    print("  + Registered backup-restore.sh in SessionStart")
+else:
+    print("  - backup-restore.sh already in SessionStart")
+
+# Stop: push — runs when Claude session ends
+stop_hooks = hooks.setdefault("Stop", [])
+push_cmd = {"type": "command", "command": "bash ~/.claude/hooks/backup-push.sh"}
+if not any(h.get("command", "").endswith("backup-push.sh") for h in stop_hooks):
+    stop_hooks.append(push_cmd)
+    print("  + Registered backup-push.sh in Stop")
+else:
+    print("  - backup-push.sh already in Stop")
+
+with open(settings_path, "w") as f:
+    json.dump(s, f, indent=2)
+    f.write("\n")
+PYEOF
+
+log "Updated $SETTINGS"
+
+# ── Done ──────────────────────────────────────────────────────────────────────
+
+echo ""
+echo "Backup setup complete."
+echo "  Backup repo:    $BACKUP_DIR  →  $REPO_URL"
+echo "  Restore hook:   runs at session start (pulls latest)"
+echo "  Push hook:      runs at session end (commits + pushes changes)"
+echo ""