---
name: dream
description: "Weekly review of all thoughts captured in the past week. Reads new concept notes, saved articles, and daily-note Wiki Ingest sections; identifies patterns across multiple notes and surfaces tensions and open questions. Delivers as an interactive HTML file attached to Telegram — does NOT save a vault note (the user doesn't read them). Triggers on /dream, 'weekly dream', 'what did I think about this week', 'patterns from this week'."
argument-hint: "[--days N]"
allowed-tools: Read, Edit, Write, Glob, Grep, Skill, Bash(date *), Bash(~/.claude/skills/dream/scripts/collect.sh *), Bash(~/.claude/skills/dream/scripts/log-send.sh *), Bash(~/.claude/skills/dream/scripts/recent-dreams.sh *), Bash(~/.claude/skills/dream/scripts/pick-lens.sh *), Bash(~/.claude/skills/telegram/scripts/send-document.sh *), Bash(rg *), Bash(cat *), Bash(wc *), Bash(ls *), Bash(mkdir *)
---

# Dream

A weekly pattern-noticing pass over the thoughts the user captured this week. The point is **resurfacing what the user themselves wrote** — not generating new analysis. If the user reads the dream digest and learns something they hadn't already filed themselves, the dream failed (it should be pulling threads out of the wiki, not inventing them).

## Why this exists

The user captures dozens of atomic concept notes a week via `/capture`, `/process-link`, `/process-transcript`, `/process-sessions`. The vault accumulates value, but they rarely have time to re-read it. The dream is the **reading-shaped output of a week's thinking** — a top-10 of the user's own material, with the patterns the wiki itself is suggesting.

## When this skill runs

- **Richard-owned cron** (primary): nightly at 21:00 BST (20:00 UTC) via `~/vault/agents/richard/reflexes/dream.sh`. Richard owns the reading-shaped synthesis and routes concrete follow-up threads to other agents when needed.
- **Interactive**: the user invokes `/dream` directly with optional `--days N` to override the window.

## Process

### 1. Roll tonight's lens — *do this first*

The lens picker rolls one of 10 angles (random recent note / older surprise / mission audit / counter-current / lateral word / 1-day window / 30-day window / forgotten thread / one person / sit-with-tension). The lens is the *angle of attack* for tonight's dream — it forces variation across nightly runs.

```bash
LENS_LABEL=$(~/.claude/skills/dream/scripts/pick-lens.sh --label)
LENS_PROMPT=$(~/.claude/skills/dream/scripts/pick-lens.sh)
echo "Lens: $LENS_LABEL"
echo "$LENS_PROMPT"
```

Some lenses override the input window (`window:3days`, `window:90days`) — adjust the `--days` flag to `collect.sh` accordingly. **Default window is 30 days** (the past month of thoughts) — a month gives a wide enough random-pool for the lens to sample from so each night feels different.

### 2. Read what was already sent recently — avoid repeating

```bash
~/.claude/skills/dream/scripts/recent-dreams.sh 5
```

This prints the last 5 nights of Telegram messages. **Read them.** The whole point of the lens roll is so each night feels different — but the harder discipline is *not re-surfacing threads the user has just read*. If a tension was named last night, don't lead with it tonight; pick something else from this week's material, or sit with the lens.

### 3. Gather the month's material

```bash
~/.claude/skills/dream/scripts/collect.sh --days 30 > /tmp/dream-input.md
wc -l /tmp/dream-input.md
```

(If the lens overrode the window — `window:3days` or `window:90days` — use that value instead of 30.)

The collector produces a single markdown blob with:
- New atomic concept notes (vault root *.md created in window)
- New entries in `links/reference/` (saved articles, transcripts, PDFs)
- "### Wiki Ingest" sections from each daily note in the window
- Active projects (`status: doing` or `todo`)

If `--days N` was passed to `/dream`, pass it through to `collect.sh`.

### 4. Read the input through tonight's lens

Read `/tmp/dream-input.md` end to end, but with **tonight's lens** as the active filter. The lens overrides "find the dominant pattern" — if tonight's lens is `forgotten-thread`, the dream is about a forgotten thread, even if the dominant pattern is something else.

The input is the past 30 days — much wider than a weekly pool, deliberately, so each night's random sample can land on a genuinely different corner of recent thinking. Bias *away* from "the loudest material from the past week" and *towards* the corner the lens picked, even if it's quieter.

General skim for:
- **Recurring entities** — names, companies, concepts that appear across multiple notes
- **Counter-current ideas** — notes that contradict or extend other notes
- **Strategic flags** — anything that touches the user's mission, active client work, or open commercial commitments
- **Threads NOT in the recent-dreams log** — bias hard towards material the past 5 nights haven't named

### 5. Run vault searches to find depth (only if the lens needs them)

For the threads you're considering surfacing, run targeted ripgrep searches with several distinctive phrases:

```bash
rg -i "<theme>|<specific phrase>|<named person>" ~/vault ~/code/blog/_posts ~/code/blog/pages | head -80
```

This reveals what the user has *already* written about the theme over time so the dream can connect old wiki to new notes ("this is the 4th note on X; previous: ..."). Keep it to 1-2 searches for a nightly run; if results are noisy, refine the phrase rather than widening the scan.

### 6. Compose an interactive HTML dream

**Telegram is the only delivery surface, but the *content* is an HTML file attached to it — not the message body.** Do not write a vault note or append to the daily note. The user does not read dream notes — the file either lands in Telegram and gets opened, or it doesn't land at all. The Telegram caption is just a doorway.

**Why HTML, not text.** Text dreams stop landing once the format goes stale and the prose blurs together. Interactive HTML — short atoms, visible connections, SVG diagrams, mobile-friendly layouts — keeps the user engaging with their own thinking. The format should vary each night to stay fresh.

**Mobile-first, non-negotiable.** The user reads the dream on their phone. That means:
- Single-column at narrow widths; multi-column only on wide.
- No off-canvas side panels, no click-to-fetch-detail patterns — those fail on touch.
- No external assets (no CDN fonts, no remote SVG, no analytics). Self-contained file, opens with no network.
- Text scales sensibly; tap targets ≥ 40px.
- `<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">` always.

**No JavaScript — interactivity must be pure HTML/CSS.** Telegram's in-app browser sandboxes/strips inline `onclick` and `<script>`, so any JS-driven tap-to-reveal silently does nothing — the cards look tappable but don't open. This has shipped broken (2026-05-26: question-cards used `onclick="this.classList.toggle('open')"`, nothing expanded). Build every expand/collapse with native `<details><summary>…</summary>…</details>` (style the marker via `summary::-webkit-details-marker{display:none}` and a `[open]` selector for the +/− glyph). Carousels: `scroll-snap-type`. Scroll-to: plain `#anchor` links. If you cannot build the interaction without JS, make it static instead — never ship a control that needs JS to function.

**No dead links.** Don't emit `<a href="#">` or `<a>` pointing at vault note titles — the reader is on a phone with no vault access, so they go nowhere and read as broken. Reference concept notes as plain emphasised text (`<em>`), not anchors. Only use real, tappable `https://` URLs as links.

**Content shape (still):**
- Tonight's lens stated up top, one line, italic.
- **2–4 threads.** Lens drives which threads.
- **Each thread ends with a question, not a decision.** The dream surfaces unresolved threads — let the reader resolve them.
- **Connections, not categories.** Name the people, conversations, dates, projects. Cross-thread bridges shown *visually*, not buried in prose.
- **Almost no body prose.** Long paragraphs of inline citations die on mobile. Decompose each thread into 4–6 short attributed atoms (one sentence each, with attribution) and let the layout do the connecting work.

**Format rotation — pick a DIFFERENT one each night.** This is the format equivalent of the lens roll. Check `recent-dreams.sh 5` and explicitly pick a format that hasn't been used recently. The format axis is independent of the lens axis. Menu (extend it):

| Format | Best for | Sketch |
|---|---|---|
| **Constellation + carousels** | 2–4 threads with explicit bridges | SVG of nodes + bridges at top, horizontal swipeable strips of attributed atoms below |
| **Timeline** | `window:7days` / `window:30days` / `window:90days` — date-anchored thinking | Horizontal time axis with thought-dots; clicking a dot reveals the atom |
| **Quote wall** | `one-person` lens or a single dominant voice | Big quote cards as heroes, with attribution and a small "where this connects" footer |
| **Sankey-style flow** | Many sources feeding into fewer themes feeding into one or two questions | SVG flows source → theme → question; widths proportional to weight |
| **Tarot spread** | `sit-with-tension` lens — 3 cards laid down | 3 large flip cards (past / present / question), each face-up with one image and one sentence |
| **2D matrix** | Tension between two axes (e.g. internal/external × commercial/mission) | Cells contain atoms; empty cells are the actual interesting question |
| **Force-graph** | `forgotten-thread` lens — show how the thread connects | Static SVG of nodes + edges, no JS physics; tappable nodes that scroll to atoms |
| **Map / spatial** | Cross-client patterns | Geographic-style layout, clients as places, threads as roads between them |
| **One big diagram + annotations** | A single concept with multiple facets | Hero SVG centre, marginalia atoms pointing in |
| **Question-first** | `mission-audit` lens — the question is the lead | 3 big questions as cards; tap reveals the evidence atoms behind it |

**SVG diagrams — make concepts visual.** Use SVG aggressively. Inline it (no external files). Patterns that work:
- **Node-and-edge constellations** — small filled circles for threads, dashed lines for bridges, labels on the lines, all in one `<svg viewBox>`. Keep the viewBox aspect ratio modest (e.g. 600×160) so it stays legible on mobile.
- **Spectrums and gradients** — a horizontal axis with thought-dots placed along it (e.g. "fully automated ↔ fully human")
- **Concentric shells** — surface/middle/deep layers showing what's visible vs hidden (great for the visibility-crisis theme)
- **Sankey-lite** — `<path>` curves between source and destination columns
- **Spot-illustrations** — a single small SVG inside a card to make a concept land (a broken ladder for the apprenticeship-rung idea, a magnifying glass with a hole for visibility, etc.). They don't have to be pretty — they have to *point*.

Inline SVG with `viewBox` + `preserveAspectRatio="xMidYMid meet"` scales correctly on phones without extra CSS. Use CSS variables for colour so the diagram inherits the page palette.

**Visual language guidelines:**
- Dark background by default (most users read at night). One `--bg`, one `--ink`, 2–4 accent colours mapped to threads.
- A monospace face for metadata (lens, dates, tags); a system sans for everything else. Don't load fonts — use `-apple-system` / system stack.
- Generous whitespace. Atom cards 14–22px padding minimum.
- Each thread gets ONE colour and that colour is consistent everywhere it appears (heading, pager dot, question border, SVG node).
- Use `scroll-snap-type: x mandatory` for horizontal carousels — native, no JS, perfect on mobile touch.
- Tap target minimum 40×40px.

**Length target:** 8–25 KB file size. Big enough for SVG + interactivity; small enough that it loads instantly in Telegram's in-app browser.

**Output paths:**
- `/tmp/dream-YYYY-MM-DD.html` — the file you send
- `/tmp/dream-YYYY-MM-DD.summary.txt` — a short plain-text recap (thread titles, key entities, the 3 questions, the format used). This is what `recent-dreams.sh` will show future runs. Keep it under 600 chars. **Do not** dump the HTML into the log — it bloats the history and makes future format rotation blind.

### 7. Send as Telegram document + log

Delivery is via the `/telegram` skill's `send-document.sh` wrapper — see `~/.claude/skills/telegram/SKILL.md` for the full Telegram integration including caption escaping rules and document-attachment behaviour on mobile vs desktop clients.

```bash
DATE=$(date +%Y-%m-%d)
HTML=/tmp/dream-$DATE.html
SUMMARY=/tmp/dream-$DATE.summary.txt
FORMAT="constellation+carousels"   # whatever was actually picked

# Compose a brief caption — this is the doorway, not the dream itself.
# Telegram's Markdown parse mode (not MarkdownV2): bold is *single asterisks*, NOT **double**.
# Avoid `_underscores_` and `[brackets]` in the caption — both break the parser.
CAPTION=$(cat <<CAP
🌙 *Dream — $DATE · $LENS_LABEL*

<one-line tease of the threads — e.g. "A reviewer paradox · B HTML deliverable · C visibility crisis">

<one-line on the format — e.g. "swipe each strip; constellation up top shows where threads touch">
CAP
)

# Richard owns Dream, so the document goes out through his bot whether this is
# his nightly reflex or a manual /dream run. Agents send as themselves; there is
# no default bot.
~/.claude/skills/telegram/scripts/send-document.sh "$HTML" --bot-var RICHARD_BOT_TOKEN --caption "$CAPTION"

# Log with the summary (NOT the HTML body)
~/.claude/skills/dream/scripts/log-send.sh "$LENS_LABEL" "$HTML" --format "$FORMAT" --summary "$SUMMARY"
```

The `log-send.sh` step is **mandatory**. Without it, format rotation breaks for the next night. Pass `--format` so future runs can read what's already been used and pick something different.

## Quality bar

- **Connections, not summaries.** "Three notes mentioned distributed systems" is bookkeeping. "These three notes are circling the same insight: external validation converts Byzantine failures into crash failures — this is the theoretical core the user keeps approaching from different angles" is dream output.
- **The user's voice, their own thinking.** The dream surfaces what the user has already written — it doesn't invent new framings the user didn't put in their notes. If a pattern requires inventing a frame the user never used, demote it.
- **Specific over general.** Naming the actual conversation, date, project, or person beats abstractions like "various conversations this week."
- **Mission filter.** Weight threads that touch the user's stated mission or guiding theme above generic interesting-but-orphan ideas.
- **Don't pad.** If only two real tensions surfaced this week, send two. The dream is not a quota.

## Failure modes to reject

- Restating concept-note bodies (the dream is a connector, not a summary)
- Inventing patterns from a single note
- Adding analysis the user didn't write themselves (the dream surfaces *the user's* thinking, not the agent's)
- Writing a punch list of actions ("audit proposals, productise X, write blog Y") — action lists were explicitly rejected during development. Surface the questions; let the reader decide.
- Saving a vault note. The vault note doesn't get read; the file attached to Telegram does.
- **Falling back to a plain Telegram text message.** Dream is HTML attached to Telegram. The caption is just the doorway.
- **Re-using the same HTML format two nights running.** The format axis is the second variation mechanism (alongside the lens roll). Check `recent-dreams.sh 5` for the `format:` line and pick something else.
- **Click-to-fetch-detail, off-canvas drawers, hover-only tooltips** — these patterns fail on mobile and have been tried and reverted. Everything visible inline or via native touch gestures (scroll-snap, swipe).
- **External assets** — no CDN fonts, no remote images, no analytics. The file must work offline in Telegram's in-app browser.
- **Long paragraphs of inline prose with bracketed citations.** Decompose each thread into 4–6 short attributed atoms.
- Re-running the same patterns from the past 5 nights — the lens roll + recent-dreams check exist to prevent this.
- Defaulting back to "top 3 patterns of the week" when the lens picked something different. The lens is the angle of attack — honour it.
- Dumping the raw HTML into `dreams.jsonl` (this is what `log-send.sh --summary` fixes). Without a separate `--summary` text, future runs see a wall of HTML in `recent-dreams.sh` and the rotation breaks.

#!/bin/bash
# Gather a week's worth of raw material for /dream to chew on.
# Outputs a single markdown blob to stdout for the agent to read.
#
# Inputs collected:
#   - New atomic concept notes (vault root *.md created in window, excluding
#     daily notes YYYY-MM-DD.md and system files)
#   - New entries in links/reference/ (saved articles, transcripts, PDFs)
#   - "### Wiki Ingest" sections from daily notes in the window
#   - Active projects (status doing or todo)
#
# Usage: collect.sh [--days N]    (default 7)

set -uo pipefail

DAYS=7
while [ $# -gt 0 ]; do
  case "$1" in
    --days) DAYS="$2"; shift 2 ;;
    *) echo "ERROR: unknown flag: $1" >&2; exit 1 ;;
  esac
done

VAULT="${VAULT_DIR:-$HOME/vault}"
cd "$VAULT" || exit 1

# Window: today and back DAYS days
SINCE_DATE=$(date -d "$DAYS days ago" +%Y-%m-%d)
TODAY=$(date +%Y-%m-%d)

echo "# Dream input: thoughts from $SINCE_DATE to $TODAY"
echo
echo "Window: last $DAYS days"
echo "Generated: $(date '+%Y-%m-%d %H:%M')"
echo

# --- New atomic concept notes in vault root ---
echo "## New concept notes ($DAYS days)"
echo
COUNT=0
while IFS= read -r f; do
  base=$(basename "$f")
  # Skip daily notes (YYYY-MM-DD.md) and known system files
  if [[ "$base" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}\.md$ ]]; then continue; fi
  case "$base" in
    Inbox.md|REMINDERS.md|CLAUDE.md|MEMORY.md|TODO.md) continue ;;
    *-W[0-9][0-9].md) continue ;;          # weekly notes YYYY-Wnn.md
    *-Q[1-4].md) continue ;;               # quarterly notes
    *-[0-9][0-9].md) continue ;;           # monthly notes YYYY-MM.md
  esac
  COUNT=$((COUNT + 1))
  title="${base%.md}"
  # Print a brief: title + first 30 lines of body (after frontmatter if any)
  echo "### [[$title]]"
  echo
  echo "Path: \`$f\` · Modified: $(date -r "$f" '+%Y-%m-%d')"
  echo
  python3 - "$f" <<'PY'
import sys, re
path = sys.argv[1]
try:
    with open(path) as fh:
        text = fh.read()
except Exception:
    sys.exit(0)
# Strip leading YAML frontmatter
if text.startswith('---\n'):
    end = text.find('\n---\n', 4)
    if end > 0:
        text = text[end + 5:]
# First 40 non-empty lines of body, max 1500 chars
lines = [ln for ln in text.splitlines()]
out = []
chars = 0
for ln in lines[:80]:
    out.append(ln)
    chars += len(ln) + 1
    if chars > 1500:
        out.append("... (truncated)")
        break
print("\n".join(out).strip())
PY
  echo
  echo "---"
  echo
done < <(find "$VAULT" -maxdepth 1 -name "*.md" -newermt "$SINCE_DATE" -type f 2>/dev/null | sort)
echo "_Total new concept notes: ${COUNT}_"
echo

# --- New entries in links/reference/ ---
echo "## New saved sources in links/reference/ ($DAYS days)"
echo
LCOUNT=0
while IFS= read -r f; do
  LCOUNT=$((LCOUNT + 1))
  base=$(basename "$f" .md)
  echo "### [[$base]]"
  echo
  echo "Path: \`$f\` · Modified: $(date -r "$f" '+%Y-%m-%d')"
  # Print just the frontmatter + first 6 lines of body — these are large files
  python3 - "$f" <<'PY'
import sys
path = sys.argv[1]
try:
    with open(path) as fh:
        text = fh.read()
except Exception:
    sys.exit(0)
out_lines = []
in_fm = False
fm_done = False
body_lines = 0
for i, ln in enumerate(text.splitlines()):
    if i == 0 and ln.strip() == '---':
        in_fm = True
        out_lines.append(ln)
        continue
    if in_fm and not fm_done:
        out_lines.append(ln)
        if ln.strip() == '---':
            fm_done = True
        continue
    if fm_done:
        out_lines.append(ln)
        body_lines += 1
        if body_lines >= 8:
            out_lines.append("... (body truncated — full source on disk)")
            break
print("\n".join(out_lines))
PY
  echo
  echo "---"
  echo
done < <(find "$VAULT/links/reference" -maxdepth 1 -name "*.md" -newermt "$SINCE_DATE" -type f 2>/dev/null | sort)
echo "_Total new saved sources: ${LCOUNT}_"
echo

# --- Wiki Ingest sections from daily notes ---
echo "## Wiki Ingest sections from daily notes ($DAYS days)"
echo
WCOUNT=0
for offset in $(seq 0 "$DAYS"); do
  d=$(date -d "$offset days ago" +%Y-%m-%d)
  daily="$VAULT/$d.md"
  [ ! -f "$daily" ] && continue
  # Extract any "### Wiki Ingest" sections (until next ### or ## header)
  EXTRACT=$(python3 - "$daily" <<'PY'
import sys, re
path = sys.argv[1]
try:
    with open(path) as fh:
        text = fh.read()
except Exception:
    sys.exit(0)
# Find all "### Wiki Ingest" sections — they may have a timestamp suffix
blocks = re.findall(r'(### Wiki Ingest[^\n]*\n.*?)(?=\n###|\n##|\Z)', text, re.DOTALL)
for b in blocks:
    print(b.strip())
    print()
PY
)
  if [ -n "$EXTRACT" ]; then
    WCOUNT=$((WCOUNT + 1))
    echo "### From [[$d]]"
    echo
    echo "$EXTRACT"
    echo "---"
    echo
  fi
done
echo "_Daily notes with Wiki Ingest: ${WCOUNT}_"
echo

# --- Active projects (status doing/todo only, skip done/someday) ---
echo "## Active projects (status: doing or todo)"
echo
ACOUNT=0
while IFS= read -r pf; do
  slug=$(basename "$(dirname "$pf")")
  status=$(python3 - "$pf" <<'PY'
import sys, re
try:
    with open(sys.argv[1]) as fh:
        text = fh.read()
except Exception:
    sys.exit(0)
if not text.startswith('---'):
    sys.exit(0)
end = text.find('\n---\n', 4)
if end < 0:
    sys.exit(0)
fm = text[4:end]
m = re.search(r'^status:\s*(\S+)', fm, re.MULTILINE)
if m:
    print(m.group(1).strip())
PY
)
  if [ "$status" = "doing" ] || [ "$status" = "todo" ]; then
    ACOUNT=$((ACOUNT + 1))
    echo "- [[$slug]] (status: $status)"

#!/bin/bash
# log-send.sh — append a dream send to the JSONL state log so future runs
# can read what threads were already surfaced.
#
# State lives in the user's vault (NOT in the skill folder) so it's never
# committed with the shared skill. Override with DREAM_STATE_DIR if your
# state directory is elsewhere.
#
# Two modes:
#   Text dream (legacy):
#     log-send.sh <lens_label> <message_file>
#     Stores: {date, lens, chars, message}
#
#   HTML dream (current):
#     log-send.sh <lens_label> <html_file> --format <label> --summary <summary_file>
#     Stores: {date, lens, format, chars, html_path, summary}
#     The summary file is short plain text — thread titles, key people, questions.
#     It's what recent-dreams.sh prints, NOT the raw HTML.

set -uo pipefail

LENS="${1:-unknown}"
MAIN_FILE="${2:-}"
shift 2 2>/dev/null || true

FORMAT=""
SUMMARY_FILE=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    --format) FORMAT="$2"; shift 2 ;;
    --summary) SUMMARY_FILE="$2"; shift 2 ;;
    *) shift ;;
  esac
done

STATE_DIR="${DREAM_STATE_DIR:-${VAULT_DIR:-$HOME/vault}/.dream-state}"
mkdir -p "$STATE_DIR"
LOG="$STATE_DIR/dreams.jsonl"

if [ -z "$MAIN_FILE" ] || [ ! -f "$MAIN_FILE" ]; then
  echo "log-send.sh: main file required" >&2
  exit 1
fi

DATE=$(date '+%Y-%m-%d %H:%M')
CHARS=$(wc -c < "$MAIN_FILE" | tr -d ' ')

python3 - "$DATE" "$LENS" "$CHARS" "$MAIN_FILE" "$FORMAT" "$SUMMARY_FILE" "$LOG" <<'PY'
import json, sys, os
date, lens, chars, main_file, fmt, summary_file, log = sys.argv[1:]

entry = {"date": date, "lens": lens, "chars": int(chars)}

if summary_file and os.path.isfile(summary_file):
    with open(summary_file) as f:
        entry["summary"] = f.read()
    entry["html_path"] = main_file
    if fmt:
        entry["format"] = fmt
else:
    with open(main_file) as f:
        entry["message"] = f.read()

with open(log, "a") as f:
    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
PY

#!/bin/bash
# pick-lens.sh — picks a random lens for tonight's dream so successive nightly
# runs don't keep surfacing the same threads. Output is a short instruction
# paragraph the dream skill incorporates at step 2 to force a fresh angle.
#
# Usage: pick-lens.sh           (prints lens to stdout)
#        pick-lens.sh --label   (prints just the lens label, for logging)

set -uo pipefail

VAULT="${VAULT_DIR:-$HOME/vault}"
MODE="${1:-full}"

# ----- lens roller -----
# 10 lenses, equal probability. RANDOM is seeded from time + pid so cron runs differ.
LENS_NUM=$((RANDOM % 10))

emit() {
  if [ "$MODE" = "--label" ]; then
    echo "$1"
  else
    echo "$2"
  fi
}

pick_random_file() {
  # $1 = find expression, prints one random matching file
  find $1 2>/dev/null | shuf -n 1
}

# ---- lens 0: random concept note from the past month ----
if [ "$LENS_NUM" = "0" ]; then
  NOTE=$(find "$VAULT" -maxdepth 1 -name "*.md" -newermt "30 days ago" -type f \
    ! -name "20[0-9][0-9]-[0-9][0-9]-[0-9][0-9].md" \
    ! -name "Inbox.md" ! -name "REMINDERS.md" ! -name "CLAUDE.md" \
    ! -name "20[0-9][0-9]-W[0-9][0-9].md" ! -name "20[0-9][0-9]-Q[1-4].md" \
    2>/dev/null | shuf -n 1)
  TITLE=$(basename "$NOTE" .md)
  emit "recent-note:$TITLE" "Tonight's lens — random thread from the past month: open with the note [[$TITLE]] (created in the past 30 days). Look at the month's material *through that note* — what does it extend, what does it contradict, what does it leave unfinished?"
  exit 0
fi

# ---- lens 1: random article from links/reference in the past month ----
if [ "$LENS_NUM" = "1" ]; then
  REF=$(find "$VAULT/links/reference" -maxdepth 1 -name "*.md" -type f \
    -newermt "30 days ago" 2>/dev/null | shuf -n 1)
  if [ -n "$REF" ]; then
    TITLE=$(basename "$REF" .md)
    emit "article:$TITLE" "Tonight's lens — random article from the past month: re-surface the saved source [[$TITLE]] from links/reference. Read its frontmatter and key points, then ask: does it resonate with — or sit alongside — anything else from the past 30 days? Build the dream around the bridge, or surface it as a re-read if no bridge."
    exit 0
  fi
  # fall through if no eligible file
  LENS_NUM=4
fi

# ---- lens 2: mission filter ----
# Reads the user's mission from a vault note if present — falls back to a generic prompt.
if [ "$LENS_NUM" = "2" ]; then
  # The canonical mission note is "My Mission - ...". A bare -iname "*mission*"
  # substring-matches Permissions / Commission / Emissions and grabbed the wrong
  # note (2026-05-26: it picked the "Enterprise AI Bottleneck ... Permissions" note).
  # Prefer the "My Mission" note, then a title-leading "Mission", then word-boundary "mission".
  MISSION_FILE=$(find "$VAULT" -maxdepth 1 -iname "My Mission*.md" -type f 2>/dev/null | head -1)
  [ -z "$MISSION_FILE" ] && MISSION_FILE=$(find "$VAULT" -maxdepth 1 -iname "Mission *.md" -o -iname "Mission-*.md" -type f 2>/dev/null | head -1)
  [ -z "$MISSION_FILE" ] && MISSION_FILE=$(find "$VAULT" -maxdepth 1 -type f -iname "*.md" 2>/dev/null | grep -iE '(^|/| )mission( |-|\.)' | head -1)
  if [ -n "$MISSION_FILE" ]; then
    MISSION_TITLE=$(basename "$MISSION_FILE" .md)
    emit "mission-filter" "Tonight's lens — mission audit: read this week's input *only* through your mission as captured in [[$MISSION_TITLE]]. Where did the week's material strengthen the mission? Where did it conflict or cut against it? Where did it offer a position that is genuinely counter-mission?"
  else
    emit "mission-filter" "Tonight's lens — mission audit: stress-test this week's material against your stated mission or guiding theme. Where did the week strengthen it? Where did the week conflict with it? Surface the strongest pro and the strongest contra, and sit with the gap."
  fi
  exit 0
fi

# ---- lens 3: counter-current ----
if [ "$LENS_NUM" = "3" ]; then
  emit "counter-current" "Tonight's lens — find the contradiction: ignore the patterns that 'go with the grain'. Instead surface the single strongest *contradiction* this week — two notes that disagree, or a note that contradicts what you were saying a month ago. Live in the tension; do not resolve it."
  exit 0
fi

# ---- lens 4: random dictionary word (lateral) ----
if [ "$LENS_NUM" = "4" ]; then
  WORDS_FILE="$(dirname "$0")/words.txt"
  WORD=""
  if [ -f "$WORDS_FILE" ]; then
    WORD=$(shuf -n 1 "$WORDS_FILE")
  elif [ -f /usr/share/dict/words ]; then
    WORD=$(grep -E "^[a-z]{5,12}$" /usr/share/dict/words 2>/dev/null | shuf -n 1)
  fi
  WORD="${WORD:-threshold}"
  emit "lateral:$WORD" "Tonight's lens — lateral lens (random word): '$WORD'. View this week's material through this word as a metaphor or frame. What from the week looks different when seen through '$WORD'? Don't force it — if the word is genuinely irrelevant, name that and pick the most striking note instead. But try the lens first."
  exit 0
fi

# ---- lens 5: window jolt — narrow to past 3 days ----
if [ "$LENS_NUM" = "5" ]; then
  emit "window:3days" "Tonight's lens — short window jolt: re-run with **3 days** of input instead of 30. What's fresh from the past 72 hours that the wider month-view would have buried? Go narrow and recent."
  exit 0
fi

# ---- lens 6: window jolt — quarter-wide to 90 days ----
if [ "$LENS_NUM" = "6" ]; then
  emit "window:90days" "Tonight's lens — quarter-wide window: re-run with **90 days** of input. Look for slow-burn threads building across the quarter — things showing up in March/early April that the past month is still picking up. Bias hard towards notes from days 30-90 ago that the month view doesn't reach."
  exit 0
fi

# ---- lens 7: forgotten thread ----
if [ "$LENS_NUM" = "7" ]; then
  emit "forgotten-thread" "Tonight's lens — forgotten thread: find a topic you were writing about 2-4 weeks ago that has gone quiet, but that recent material touches. Surface the silence — what stopped? Was it resolved, abandoned, or just buried under more urgent threads?"
  exit 0
fi

# ---- lens 8: person-focused ----
if [ "$LENS_NUM" = "8" ]; then
  emit "person-focused" "Tonight's lens — one person: pick one person who appeared most in the past month's transcripts/notes (or pick at random from the month's person notes). Trace what their thinking *did to the vault* over the past 30 days. What did they push you to articulate that you hadn't already?"
  exit 0
fi

# ---- lens 9: open tension ----
if [ "$LENS_NUM" = "9" ]; then
  emit "open-tension" "Tonight's lens — sit with the tension: find the strongest unresolved tension in the past month's material and *do not resolve it*. The whole dream is one long sitting-with. Ask questions, hold the contradiction open, do not propose actions or syntheses."
  exit 0
fi

# fallback
emit "default" "Tonight's lens — default: surface 2-4 connection threads from the past month, prose form, with titled sections, ending each with a question rather than a decision."

#!/bin/bash
# recent-dreams.sh — print the past N nights of dream sends so the current
# run can read what threads were already surfaced and explicitly pick different ones.
#
# For HTML dreams (the current default), prints the stored `summary` field,
# NOT the raw HTML. For legacy text dreams, prints the full message.
#
# State lives in the vault (not the skill folder). Override with DREAM_STATE_DIR.
#
# Usage: recent-dreams.sh [count]   (default 5)

set -uo pipefail

COUNT="${1:-5}"
STATE_DIR="${DREAM_STATE_DIR:-${VAULT_DIR:-$HOME/vault}/.dream-state}"
LOG="$STATE_DIR/dreams.jsonl"

if [ ! -f "$LOG" ]; then
  echo "(no previous dreams recorded yet — this is the first run)"
  exit 0
fi

tail -n "$COUNT" "$LOG" | python3 -c "
import json, sys
for line in sys.stdin:
    try:
        e = json.loads(line)
        head = f\"### {e['date']} · lens: {e['lens']}\"
        if e.get('format'):
            head += f\" · format: {e['format']}\"
        head += f\" · {e['chars']} chars\"
        print(head)
        print()
        if 'summary' in e:
            print(e['summary'])
        elif 'message' in e:
            print(e['message'])
        print()
        print('---')
        print()
    except Exception:
        pass
"

scaffolding
threshold
foundation
membrane
gradient
substrate
inheritance
sediment
keystone
fracture
mycelium
ratchet
estuary
calcify
ferment
patina
weathervane
ballast
quarry
loom
weft
warp
buttress
pivot
hinge
tributary
backwash
undertow
trellis
graft
prune
distill
sieve
crucible
furnace
plumage
mimicry
camouflage
shoal
flock
swarm
hive
warren
burrow
periphery
margin
verge
fringe
seam
suture
fault
fissure
canyon
ridge
plateau
delta
beacon
lantern
prism
refraction
diffraction
echo
resonance
overtone
undertone
cadence
syncopation
meter
breath
exhale
inhale
respiration
percolate
seep
permeate
saturate
desiccate
parch
slake
quench
ember
kindling
tinder
spark
smoulder
ignition
glow
flicker
guttering
wick
fuse
detonate
ricochet
gravity
levity
inertia
momentum
drift
eddy
current
tide
ebb
flux
quanta
particle
wave
spectrum
frequency
amplitude
harmonic
dissonance
counterpoint
fugue
chorus
refrain
verse
stanza
manuscript
palimpsest
marginalia
glyph
sigil
emblem
totem
fetish
talisman
fossil
relic
artefact
sherd
midden
catacomb
ossuary
reliquary
shrine
sanctuary
hermitage
cloister
quarantine
liminal
threshold
betwixt
unbidden
overripe
brittle
supple
tensile
ductile
malleable
rigid
porous
opaque
translucent
luminous
phosphorescent
bioluminescent
mottled
dappled
striated
laminated
veined
marbled
crazed
faceted
prismatic
iridescent
nacreous
opalescent
sere
verdant
fecund
fallow
barren
rampant
overgrown
pruned
coppiced
pollarded
espaliered
grafted
chimaera
hybrid
mongrel
purebred
wild
feral
domesticated
naturalised
invasive
endemic
nomadic
sedentary
migratory
transient
seasonal
perennial
ephemeral
diurnal
nocturnal
crepuscular