templates: add Obsidian /note skill + restic backup script

Two pieces previously living only in the production workspace:

skills/note/SKILL.md
  Obsidian-formatted note creation skill. Two modes (verbatim fix,
  summarize/concept), YAML frontmatter requirement (3-5 tags +
  YYYY-MMM-DD created), full Obsidian callout vocabulary
  ([!bug], [!success], [!tip], [!warning], [!info], [!note],
  [!example], [!question]) with usage rules. Sync target is left
  configurable (rclone-to-gdrive, local vault, bisync timer).

scripts/backup-restic.sh
  Twice-daily restic backup to two destinations: Google Drive via
  rclone and a local NAS mount. Encrypted, deduplicated, retention
  7d/4w/3m. Conservative rclone throttling to survive Drive quota
  pressure. Skips NAS cleanly if not mounted. Sanitized paths and
  repo names.

Plus two memory cards that explain when/why to use each:

memory/cards/obsidian-notes.md
  Verbatim-vs-concept mode selection, callout vocabulary table, sync
  target shapes, when NOT to /note (durable agent knowledge belongs
  in cards, not the vault), relationship to the memory system.

memory/cards/backup-restic.md
  Two-destination rationale (workstation-fail vs NAS-fail vs
  account-lock vs ransomware matrix), cadence (twice-daily 03/15),
  default paths and excludes, retention math, rclone throttle
  reasoning, NAS lockfile handling, recovery drill, monitoring hook,
  anti-patterns.

Wired into the workspace profile manifest with the script marked
executable. Tests cover both new files and the executable bit.

Author: solomonneas

memory/cards/backup-restic.md

@@ -0,0 +1,126 @@
+---
+topic: backup-restic
+category: infrastructure
+tags: [backup, restic, rclone, gdrive, nas, retention, recovery]
+---
+
+# Workspace Backup (Restic + rclone + NAS)
+
+Twice-daily restic backups to two destinations: Google Drive (via rclone) and a local NAS mount. Encrypted, deduplicated, snapshot-pruned. The reference script ships at `scripts/backup-restic.sh`; this card explains *why* the shape is what it is.
+
+## Why both destinations
+
+| Failure mode | Local NAS only | gdrive only | Both |
+|--------------|----------------|-------------|------|
+| Workstation disk dies | Recover from NAS, fast | Recover from gdrive, slow | Either |
+| NAS hardware failure | Lose everything | Recover from gdrive | gdrive saves you |
+| Google account locked / quota | Lose everything that ran since last NAS run | Lose everything | NAS saves you |
+| Ransomware hits workstation | Possibly hits NAS too | Off-site immutable copy | gdrive saves you |
+
+Two destinations covers the "one of them is broken" case without raising the recovery time for the common case (NAS is faster).
+
+## Cadence
+
+```cron
+0 3,15 * * * /path/to/backup-restic.sh
+```
+
+03:00 + 15:00. Twice a day means worst-case data loss window is ~12 hours. Adjust if your write velocity is higher.
+
+## What gets backed up
+
+Default paths:
+
+- The agent workspace (`~/.solo-mise` or your equivalent)
+- All repos under `~/repos`
+- Local scripts and bin (`~/bin`)
+- Dotfiles: `.bashrc`, `.profile`, `.gitconfig`, `.ssh`, `.claude`, `.codex`, `.npmrc`
+- Notes (`~/notes`)
+- Obsidian vault (`~/Obsidian`)
+
+Excluded by default: `node_modules`, `.git/objects`, `__pycache__`, `*.pyc`, `.venv`, `dist`, `build`, `.next`, `.astro`, `coverage`, `.turbo`, `*.jsonl`, `.pm2/logs`, `.pm2/pids`, `.ollama`, `.obsidian/workspace*.json`, `.obsidian/cache`, `.trash`.
+
+Edit the `BACKUP_PATHS` and `EXCLUDES` arrays in the script for your stack.
+
+## Retention
+
+```text
+--keep-daily 7
+--keep-weekly 4
+--keep-monthly 3
+```
+
+About 14 snapshots overlapping over three months. Plenty for human-paced workflows.
+
+## Why rclone is throttled hard
+
+Google Drive can reject bursty restic-over-rclone writes when other rclone jobs (Obsidian bisync, cookbook sync, etc.) are running. The script sets:
+
+```bash
+RCLONE_TRANSFERS=1
+RCLONE_CHECKERS=2
+RCLONE_TPSLIMIT=4
+RCLONE_TPSLIMIT_BURST=4
+RCLONE_DRIVE_PACER_MIN_SLEEP=500ms
+RCLONE_DRIVE_PACER_BURST=10
+RCLONE_RETRIES=8
+RCLONE_LOW_LEVEL_RETRIES=20
+```
+
+Conservative on purpose. A backup that takes 40 minutes and finishes beats one that races, hits Drive quota, and dies in a retry loop.
+
+## NAS shape
+
+The NAS mount is typically an SMB/NFS share at `/mnt/nas/backups`. The script:
+
+1. Skips cleanly if the mount is not present.
+2. Uses a separate restic repo path on the NAS (independent encryption + deduplication state).
+3. Tags NAS snapshots distinctly (`scheduled-nas`) so summaries are easy to read.
+
+NAS-side considerations:
+
+- **Permissions:** the NAS share must allow write from the workstation user.
+- **Lock files:** restic uses lockfiles inside the repo. A killed process can leave stale locks; the script runs `restic unlock --remove-all` after each successful backup.
+- **Read-only by default:** if the NAS holds irreplaceable family photos or other "do not touch" data, keep that data on a separate path and treat the rest of the NAS as read-only for the agent. See `SAFETY_RULES.md`.
+
+## Password
+
+```bash
+echo "<strong-password>" > ~/.solo-mise/.restic-password
+chmod 600 ~/.solo-mise/.restic-password
+```
+
+Never commit this file. Never paste the password in a chat. If the password is lost, the encrypted snapshots are unrecoverable.
+
+## Recovery
+
+```bash
+# list snapshots
+restic snapshots
+
+# restore a specific snapshot to /tmp/restore/
+restic restore <id> --target /tmp/restore
+
+# restore just one path
+restic restore <id> --target /tmp/restore --include "$HOME/repos/<project>"
+```
+
+Practice this. A backup you have never restored is a hope, not a backup.
+
+## Monitoring
+
+Log file path:
+
+```text
+~/.solo-mise/logs/backup-YYYYMMDD.log
+```
+
+Worth wiring into the morning report (`memory/cards/pipeline-standups.md`): grep recent logs for `ERROR` and surface in the briefing. A silent backup that has been failing for three weeks is the second-worst kind of bug.
+
+## Anti-patterns
+
+- **One destination only.** Single point of failure.
+- **No retention policy.** Old snapshots accumulate, gdrive quota fills, new backups fail.
+- **Backing up `node_modules`.** Wastes deduplication windows. Use the excludes.
+- **Backing up secrets unencrypted.** `.env` files get backed up too; that is intentional because restic encrypts everything at rest. The password file is the keystone; protect it.
+- **Skipping verification.** Run `restic check` periodically. Snapshots that exist but are corrupted are not snapshots.

memory/cards/obsidian-notes.md

@@ -0,0 +1,82 @@
+---
+topic: obsidian-notes
+category: foundation
+tags: [obsidian, notes, callouts, vault, sync, knowledge-capture]
+---
+
+# Obsidian Notes (Verbatim + Concept)
+
+The `/note` skill captures a session's durable knowledge as an Obsidian-formatted markdown file in `~/notes/`, then syncs it to the user's configured Obsidian vault inbox. It is the user-facing complement to the [memory-scanner](memory-scanner.md): cards are for the agent, Obsidian notes are for the human.
+
+Full skill spec lives in `skills/note/SKILL.md`. This card explains *when* to use it and the two modes you must distinguish before writing.
+
+## Two modes
+
+| Mode | Use when | Output style |
+|------|----------|--------------|
+| **Verbatim fix** | Troubleshooting, root-causing, post-incident. Future-you needs the exact commands to reproduce the fix. | `[!bug]` -> `[!success]` -> "How it works" -> `[!warning]` gotchas. Heavy on exact strings and runnable code. |
+| **Summarize / concept** | Learning, capturing a workflow, documenting a system. The reader needs to understand *why* before they trust the *how*. | Overview -> How it works -> Example -> Tips and gotchas. More prose than callouts. |
+
+Ask the user which mode applies if it is not obvious. Default to verbatim for bugs and to concept for everything else.
+
+## Callout vocabulary
+
+Obsidian callouts make the critical parts stick out without breaking prose flow. Use them sparingly. A note should be mostly regular markdown with callouts highlighting the parts that matter.
+
+| Callout | Use for |
+|---------|---------|
+| `[!bug]` | Problems, errors, symptoms |
+| `[!success]` | Solutions, fixes, what worked |
+| `[!tip]` | Helpful hints, shortcuts |
+| `[!warning]` | Dangers, things that can break |
+| `[!info]` | Background context |
+| `[!note]` | General annotations |
+| `[!example]` | Practical examples, runnable commands |
+| `[!question]` | Open questions, things to investigate |
+
+Syntax:
+
+```markdown
+> [!success] Optional title
+> Content.
+> Multi-line is fine.
+```
+
+## YAML frontmatter (required)
+
+```yaml
+---
+tags:
+  - tag1
+  - tag2
+created: YYYY-MMM-DD
+---
+```
+
+- 3-5 lowercase, hyphenated tags.
+- Date format `YYYY-MMM-DD` (e.g. `2026-Jan-24`). Not ISO. The vault sorts on this.
+
+## Sync target
+
+Three common shapes; the user picks one and documents it in `TOOLS.md`:
+
+1. **Google Drive + rclone bisync.** `~/notes/` writes propagate to the vault inbox on the next bisync timer fire. Most common for cross-machine vaults.
+2. **Local Obsidian vault on disk.** `cp ~/notes/<slug>.md ~/Obsidian/<Vault>/<Inbox>/`. Same machine only.
+3. **Direct rclone copy.** `rclone copy ~/notes/<slug>.md "gdrive:My Drive/<VaultPath>/<Inbox>/"`. One-shot, no bisync.
+
+If no sync target is configured, leave the file in `~/notes/` and surface the path. Do not invent a sync path.
+
+## When NOT to use /note
+
+- **Durable agent-facing knowledge** -> memory card via the handoff flow, not a vault note. Cards are searched semantically by the agent every session; vault notes are read by humans.
+- **Operational runbook detail** -> `TOOLS.md` or a `rules/*.md` file. The publish gate and memory ingester treat those as canonical.
+- **Sensitive personal context** -> not in `~/notes/` if the vault syncs to a cloud provider. Use the local-only sync path or skip the note entirely.
+
+## Relationship to the memory system
+
+Vault notes are human-readable references; memory cards are agent-readable durable knowledge. The two have different shapes and different audiences:
+
+- A `/note` is written for future-you reading on a phone at a coffee shop.
+- A memory card is written for the agent to retrieve via `memory_search` mid-session.
+
+When both apply, write the card first (through the handoff flow) and then optionally write a `/note` if the user will want to reference it outside the workspace. Do not duplicate content.

scripts/backup-restic.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# ============================================================================
+# Workspace backup via restic -> Google Drive (rclone) + local NAS mount
+# Run twice daily via cron. Tunable. Sanitize before commit.
+# ============================================================================
+#
+# Setup once:
+#   1. apt install restic rclone
+#   2. rclone config   # set up `gdrive` remote
+#   3. echo "<strong-password>" > ~/.solo-mise/.restic-password
+#      chmod 600 ~/.solo-mise/.restic-password
+#   4. (optional) mount your NAS at $NAS_MOUNT
+#   5. crontab -e:
+#        0 3,15 * * * /path/to/backup-restic.sh
+#
+set -euo pipefail
+
+# ---- Paths ----
+WORKSPACE_ROOT="${WORKSPACE_ROOT:-${HOME}}"
+LOG_FILE="${WORKSPACE_ROOT}/.solo-mise/logs/backup-$(date +%Y%m%d).log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"; }
+
+# ---- Config (edit for your stack) ----
+RESTIC_REPO_GDRIVE="rclone:gdrive:Backup/<your-repo-name>"
+RESTIC_PASSWORD_FILE="${HOME}/.solo-mise/.restic-password"
+NAS_MOUNT="${NAS_MOUNT:-/mnt/nas/backups}"
+RESTIC_REPO_NAS="${NAS_MOUNT}/<your-repo-name>"
+
+# Retention policy. Tune to taste; the defaults below cover ~3 months of
+# overlapping daily/weekly/monthly snapshots.
+KEEP_DAILY="${KEEP_DAILY:-7}"
+KEEP_WEEKLY="${KEEP_WEEKLY:-4}"
+KEEP_MONTHLY="${KEEP_MONTHLY:-3}"
+
+# Paths to back up. Replace with your actual roots.
+BACKUP_PATHS=(
+  "${HOME}/.solo-mise"
+  "${HOME}/repos"
+  "${HOME}/bin"
+  "${HOME}/.bashrc"
+  "${HOME}/.profile"
+  "${HOME}/.gitconfig"
+  "${HOME}/.ssh"
+  "${HOME}/.claude"
+  "${HOME}/.codex"
+  "${HOME}/notes"
+  "${HOME}/Obsidian"
+)
+
+# Exclude rules shared between gdrive + NAS runs.
+EXCLUDES=(
+  --exclude='node_modules'
+  --exclude='.git/objects'
+  --exclude='__pycache__'
+  --exclude='*.pyc'
+  --exclude='.venv'
+  --exclude='venv'
+  --exclude='dist'
+  --exclude='build'
+  --exclude='.next'
+  --exclude='.astro'
+  --exclude='coverage'
+  --exclude='.turbo'
+  --exclude='*.jsonl'
+  --exclude='.pm2/logs'
+  --exclude='.pm2/pids'
+  --exclude='.ollama'
+  --exclude='.obsidian/workspace*.json'
+  --exclude='.obsidian/cache'
+  --exclude='.trash'
+)
+
+export RESTIC_PASSWORD_FILE
+
+# ---- rclone tuning ----
+# Google Drive can reject bursty restic-over-rclone writes when other rclone
+# jobs are running. Keep the backend intentionally conservative so scheduled
+# backups finish reliably instead of spinning in quota retry loops.
+export RCLONE_TRANSFERS="${RCLONE_TRANSFERS:-1}"
+export RCLONE_CHECKERS="${RCLONE_CHECKERS:-2}"
+export RCLONE_TPSLIMIT="${RCLONE_TPSLIMIT:-4}"
+export RCLONE_TPSLIMIT_BURST="${RCLONE_TPSLIMIT_BURST:-4}"
+export RCLONE_DRIVE_PACER_MIN_SLEEP="${RCLONE_DRIVE_PACER_MIN_SLEEP:-500ms}"
+export RCLONE_DRIVE_PACER_BURST="${RCLONE_DRIVE_PACER_BURST:-10}"
+export RCLONE_RETRIES="${RCLONE_RETRIES:-8}"
+export RCLONE_LOW_LEVEL_RETRIES="${RCLONE_LOW_LEVEL_RETRIES:-20}"
+
+# ---- Pre-flight ----
+command -v restic >/dev/null || { log "ERROR: restic not installed."; exit 1; }
+command -v rclone >/dev/null || { log "ERROR: rclone not installed."; exit 1; }
+[ -f "$RESTIC_PASSWORD_FILE" ] || { log "ERROR: password file not found: $RESTIC_PASSWORD_FILE"; exit 1; }
+
+# ---- Helper: ensure a restic repo is usable ----
+ensure_repo() {
+  local repo="$1"
+  export RESTIC_REPOSITORY="$repo"
+  if restic snapshots --json >/dev/null 2>&1; then
+    log "Repo exists at $repo, proceeding."
+    return 0
+  fi
+  log "Initializing repo: $repo"
+  if restic init 2>&1 | tee -a "$LOG_FILE"; then
+    return 0
+  fi
+  # init may fail because the repo already exists; retry the check.
+  if restic snapshots --json >/dev/null 2>&1; then
+    log "Repo already exists (init not needed)."
+    return 0
+  fi
+  log "ERROR: cannot access or initialize repo: $repo"
+  return 1
+}
+
+# ---- Helper: backup + forget for a configured repo ----
+run_backup() {
+  local repo="$1"
+  local tag="$2"
+  export RESTIC_REPOSITORY="$repo"
+  log "Backing up to $repo (tag=$tag)..."
+  restic backup --verbose --tag "$tag" "${EXCLUDES[@]}" "${BACKUP_PATHS[@]}" 2>&1 | tee -a "$LOG_FILE"
+  log "Pruning old snapshots..."
+  restic forget \
+    --keep-daily "$KEEP_DAILY" \
+    --keep-weekly "$KEEP_WEEKLY" \
+    --keep-monthly "$KEEP_MONTHLY" \
+    --prune 2>&1 | tee -a "$LOG_FILE"
+}
+
+# ---- Google Drive backup ----
+if ensure_repo "$RESTIC_REPO_GDRIVE"; then
+  run_backup "$RESTIC_REPO_GDRIVE" "scheduled"
+  log "Clearing any stale gdrive locks..."
+  restic unlock --remove-all 2>&1 | tee -a "$LOG_FILE" || true
+else
+  log "Skipping gdrive backup; repo unavailable."
+fi
+
+# ---- NAS backup (skip cleanly if not mounted) ----
+if mountpoint -q "${NAS_MOUNT}" 2>/dev/null || [ -d "${NAS_MOUNT}" ]; then
+  if ensure_repo "$RESTIC_REPO_NAS"; then
+    run_backup "$RESTIC_REPO_NAS" "scheduled-nas"
+    restic unlock --remove-all 2>&1 | tee -a "$LOG_FILE" || true
+  else
+    log "Skipping NAS backup; repo unavailable."
+  fi
+else
+  log "NAS not mounted at ${NAS_MOUNT}, skipping NAS backup."
+fi
+
+# ---- Summary ----
+export RESTIC_REPOSITORY="$RESTIC_REPO_GDRIVE"
+SNAPSHOT_COUNT=$(restic snapshots --json 2>/dev/null | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null || echo "?")
+log "Done. Total snapshots (gdrive): $SNAPSHOT_COUNT"
+log "Log: $LOG_FILE"