feat(init): auto-update .gitignore so static.md is trackable

A common onboarding stumble: user follows the README, runs
`revive init`, then `git add .revive/static.md` — git silently
skips the file because their .gitignore has `.revive/*` (or
similar) and no exception. The "checked in" workflow the README
documents quietly fails.

`cmd_init` now calls `maybe_update_gitignore` after writing
static.md. Logic:

- Skip silently if not in a git repo, no .gitignore exists, or
  `git check-ignore` says the file is already trackable.
- Otherwise append a small canonical block:
    .revive/*
    !.revive/static.md
  with a header comment explaining what gets tracked vs not.
- Re-run `git check-ignore`. If a directory-level `.revive/`
  rule still suppresses the un-ignore (git semantics: `!`
  cannot rescue a file inside a fully-ignored directory), print
  a warning telling the user how to fix it.

4 new tests cover: no .gitignore (no-op), `.revive/*` (append +
verify trackable), already-correct (idempotent — line count
unchanged), `.revive/` directory rule (warning emitted, exit 0
preserved).

Author: justi

bin/revive

@@ -697,6 +697,39 @@ cmd_init() {
   else
     echo "created: $STATIC_FILE"
   fi
+
+  maybe_update_gitignore
+}
+
+# If $STATIC_FILE would currently be gitignored, append the canonical
+# exception block to .gitignore so the file can actually be tracked. Stays
+# silent when not in a git repo, when there's no .gitignore yet, or when
+# static.md is already trackable. If a directory-level `.revive/` rule
+# blocks the un-ignore from taking effect, surface a clear warning instead
+# of silently leaving the file untracked.
+maybe_update_gitignore() {
+  git rev-parse --git-dir >/dev/null 2>&1 || return 0
+  [[ -f .gitignore ]] || return 0
+  git check-ignore -q "$STATIC_FILE" 2>/dev/null || return 0
+
+  cat >> .gitignore <<'GITIGNORE'
+
+# revive: .revive/static.md is the curated STATIC layer (checked in);
+# other .revive/ contents are local runtime state.
+.revive/*
+!.revive/static.md
+GITIGNORE
+
+  if git check-ignore -q "$STATIC_FILE" 2>/dev/null; then
+    cat >&2 <<MSG
+warning: $STATIC_FILE is still gitignored after appending the canonical
+exception. A directory-level rule (\`.revive/\` or \`.revive\`) earlier in
+.gitignore is likely blocking the un-ignore — replace it with
+\`.revive/*\` + \`!.revive/static.md\`, or run \`git add -f $STATIC_FILE\`.
+MSG
+  else
+    echo "updated: .gitignore (un-ignored $STATIC_FILE)"
+  fi
 }
 
 # Build a prompt that a coding agent (Claude Code / Cursor / Aider / any

tests/revive.bats

@@ -1430,3 +1430,42 @@ JSON
   run "$REVIVE" help
   [[ "$output" == *"mark-compact"* ]] || return 1
 }
+
+# --- init: gitignore auto-update ---
+
+@test "init does nothing to .gitignore when there is none" {
+  run "$REVIVE" init
+  [ "$status" -eq 0 ] || return 1
+  [ ! -f .gitignore ] || return 1
+}
+
+@test "init appends exception when .revive/* is gitignored without exception" {
+  printf '.revive/*\n' > .gitignore
+  run "$REVIVE" init
+  [ "$status" -eq 0 ] || return 1
+  [[ "$output" == *"un-ignored"* ]] || return 1
+  run cat .gitignore
+  [[ "$output" == *"!.revive/static.md"* ]] || return 1
+  # static.md is now actually trackable
+  run git check-ignore -q .revive/static.md
+  [ "$status" -ne 0 ] || return 1
+}
+
+@test "init leaves .gitignore alone when static.md is already trackable" {
+  printf '.revive/*\n!.revive/static.md\n' > .gitignore
+  local before
+  before=$(wc -l < .gitignore)
+  run "$REVIVE" init
+  [ "$status" -eq 0 ] || return 1
+  local after
+  after=$(wc -l < .gitignore)
+  [ "$before" -eq "$after" ] || return 1
+}
+
+@test "init warns when a directory-level .revive/ rule blocks the un-ignore" {
+  printf '.revive/\n' > .gitignore
+  run "$REVIVE" init
+  # init still exits 0 — warning is informational, not fatal
+  [ "$status" -eq 0 ] || return 1
+  [[ "$output" == *"still gitignored"* ]] || return 1
+}