feat: comprehensive pipeline skill upgrades from PAI learnings

- reflect: enforce-before-adding pattern gate, proactive synthesis step,
  improvements.md triage, debrief must list every file modified
- housekeeping: domain INDEX.md rebuild step, briefing bridge SSOT rule
  and richer section format with compression rules
- foresight: cruising velocity classification, non-obvious rule,
  anti-patterns section, scenario candidate format in nudge output,
  thread current-state in memory reads
- scenario: full rewrite with body template (Decision Point, Dependencies,
  Branches, Timeline Overlay, Contingency Map, Retrospective), anti-patterns,
  trigger threshold, related-threads frontmatter
- evolve: route content issues step, scorecard generation, architecture-only
  constraint on Next Run Priorities
- history: simple vs deep triage note
- CLAUDE.md: structured action items format, briefing-bridge and
  foresight-nudge in file edit table

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude/commands/evolve.md

@@ -63,10 +63,33 @@ For each proposal:
 - What problem does it solve?
 - What evidence supports it?
 - What's the risk?
+- Is this a rule change (apply directly) or architecture change (propose for user review)?
 
-**Apply rule changes directly** to the relevant skill files if clearly beneficial and low-risk. For changes that affect user-facing behavior, note them as proposals for user review.
+**Apply low-risk rule changes directly** to the relevant skill files. Propose architecture changes for user review.
 
-### 4. Write Observations & Update Log
+### 4. Route Content Issues
+
+When you spot content problems during your audit, **don't fix them and don't defer them for yourself**. Route them explicitly:
+
+Format in debrief:
+```
+→ housekeeping: entities.md at 290 lines, needs glacier pass
+→ reflect: hot-memory missing thread link for X
+→ reflect: patterns.md has stale snapshot data from Feb
+```
+
+If the same content issue keeps appearing across runs, that's a **rule problem** — propose a rule change so housekeeping/reflect catch it themselves.
+
+### 5. Generate Scorecard
+
+Overwrite `memory/cog-meta/scorecard.md` with current metrics:
+- Core patterns.md: line count / 70, byte size / 5.5KB (target: ≤1.0)
+- Satellite pattern files: list each with line count (soft cap: 30)
+- Entity compression ratio: `(total entity lines across all files) / (total ### entries)` — target ≤3.0
+- Hot-memory line counts vs caps
+- Briefing bridge SSOT compliance (% of lines with [[source]] links)
+
+### 6. Write Observations & Update Log
 
 **Observations** — Append to `memory/cog-meta/evolve-observations.md`:
 - Format: `- YYYY-MM-DD [tag]: observation`
@@ -74,15 +97,17 @@ For each proposal:
 
 **Evolve Log** — Append to `memory/cog-meta/evolve-log.md`:
 - Run number, process effectiveness findings, rule changes applied or proposed, deferred items
-- Update "Next Run Priorities" section at top
+- Content issues routed (→ housekeeping / → reflect)
+- Update "Next Run Priorities" section at top. **Only architecture/design items — never content work.**
 
-### 5. Debrief
+### 7. Debrief
 
 Concise summary:
 - *Process health* — did housekeeping/reflect follow their rules?
 - *Rule changes* — applied or proposed, with rationale
+- *Routed issues* — content problems sent to housekeeping/reflect
 - *Architecture notes* — structural observations
-- *Next evolve* — top 3 things to check next time
+- *Next evolve* — top 3 architecture priorities
 
 Keep it actionable. Numbers over narrative.
 

.claude/commands/foresight.md

@@ -10,7 +10,7 @@ Cross-domain strategic synthesis — personal, work, projects, health, family. T
 
 ## Memory Files
 
-Read broadly:
+Read broadly — this is a scan, not a focused lookup:
 
 1. Read `memory/domains.yml` to discover all active domains
 2. For each domain, read `hot-memory.md` and `action-items.md` (if they exist)
@@ -21,6 +21,7 @@ Read broadly:
    - `memory/personal/health.md` (health trajectory)
    - `memory/cog-meta/briefing-bridge.md` (housekeeping findings)
    - Recent observations across all domains (last 7 days)
+   - Thread current-state sections — what narratives are actively unfolding?
 
 ## Process
 
@@ -30,10 +31,13 @@ Look for topics, people, or themes appearing in 2+ domains simultaneously. These
 
 ### 2. Velocity & Stall Detection
 
-Scan action-items across all domains:
+Scan action-items across all domains. Classify each active item:
-- **Accelerating** — multiple updates in the last week
+- **Accelerating** — multiple updates in the last week, clear momentum. Signal: ride the wave, don't interrupt.
-- **Stalling** — no movement in 2+ weeks despite not being deferred
+- **Cruising** — steady progress, on track. Signal: nothing to flag.
-- **Dormant** — domain-level silence (0 observations in 4+ weeks)
+- **Stalling** — no movement in 2+ weeks despite not being deferred. Signal: ask why. Blocked? Lost priority?
+- **Dormant** — domain-level silence (0 observations in 4+ weeks). Signal: conscious choice or drift?
+
+Stalls and dormant domains are high-value nudge material — they represent things the user cares about but isn't acting on.
 
 ### 3. Timing Awareness
 
@@ -43,7 +47,7 @@ Read calendar and entities for upcoming events in the next 2-4 weeks. Look for t
 
 Read patterns and recent observations. Project forward: "If this continues for 2 more weeks, what happens?"
 
-**Scenario candidate detection**: If a pattern reveals a genuine fork — two different paths with real stakes and a closing window — flag it as a scenario candidate.
+**Scenario candidate detection**: If a pattern projection reveals a genuine fork — two meaningfully different paths with real stakes and a closing decision window — flag it as a scenario candidate below the main nudge. A valid candidate needs: a fork (2+ paths), stakes (wrong choice has real cost), and time sensitivity (window closing). Don't flag routine decisions or hypotheticals with no deadline.
 
 ### 5. Write One Strategic Nudge
 
@@ -63,25 +67,42 @@ Write to `memory/cog-meta/foresight-nudge.md`:
 <!-- Last updated: YYYY-MM-DD -->
 
 ## Signal
-<What you noticed — from 2+ domains>
+<What you noticed — the raw observation from 2+ domains>
 
 ## Insight
-<Why it matters>
+<Why it matters — the connection, timing, or trajectory that makes this worth flagging>
 
 ## Suggested Action
-<One concrete thing to do>
+<One concrete thing to do — specific, actionable, grounded>
 
 ---
 Sources: [[file1]], [[file2]], [[file3]]
+
+## Scenario Candidate (optional)
+<!-- Only include if pattern projection reveals a genuine fork worth simulating -->
+Decision: <one-line framing>
+Why now: <why the window is closing>
+Domains: <affected domains>
 ```
 
+Overwrite the file each run. One nudge per run.
+
 ## Rules
 
-1. **Read-only** — Foresight NEVER edits memory files. Writes ONLY to `memory/cog-meta/foresight-nudge.md`.
+1. **Read-only** — Foresight NEVER edits memory files. Writes ONLY to `memory/cog-meta/foresight-nudge.md`. If you spot a memory error, note it in the nudge's signal section and let reflect handle it.
-2. **One nudge, not a list** — force prioritization.
+2. **One nudge, not a list** — force prioritization. If everything is equally important, nothing is.
-3. **Evidence-based** — every nudge cites at least 2 source files.
+3. **Evidence-based** — every nudge cites at least 2 source files. No vibes.
-4. **Forward-looking** — avoid rehashing yesterday.
+4. **Non-obvious** — the nudge should surprise. If the user already knows and is acting on it, pick something else.
-5. **Cross-domain preferred** — connecting personal + work is higher value than single-domain.
+5. **Forward-looking** — avoid rehashing yesterday. Project into next week, next month.
+6. **Cross-domain preferred** — nudges that connect personal + work are higher value than single-domain insights.
+
+## Anti-Patterns
+
+- Don't repeat what briefing-bridge already says (stale items, birthday prep) — that's housekeeping's job
+- Don't recommend "reflect on X" — be specific about what to DO
+- Don't flag things the user has explicitly deferred — respect the deferral
+- Don't flag things that are cruising — focus on convergences, stalls, and timing windows
+- Don't write a mini-briefing — one insight, one action
 
 ## Activation
 

.claude/commands/history.md

@@ -1,4 +1,4 @@
-Use this skill for deep memory search and recall. Trigger if the user says "what did I say about...", "when did we discuss...", "find that conversation about...", "history of...", or asks about past information that needs multi-file search.
+Use this skill for deep memory search and recall. Trigger if the user says "what did I say about...", "when did we discuss...", "find that conversation about...", "history of...", or asks about past information that needs multi-file search. For simple date/keyword lookups, a quick Grep suffices — this skill is for when you need to piece together a narrative from multiple entries.
 
 ## Domain
 

.claude/commands/housekeeping.md

@@ -102,7 +102,9 @@ Rules:
 
 ## 7. Write Briefing Bridge
 
-Write key findings to `memory/cog-meta/briefing-bridge.md` so foresight can pick them up:
+Write key findings to `memory/cog-meta/briefing-bridge.md` so foresight can pick them up. Overwrite the file each run.
+
+**SSOT rule**: Every line in the bridge must include a `[[source]]` link to its canonical file. The bridge summarizes and links — it NEVER introduces original facts.
 
 ```markdown
 # Briefing Bridge
@@ -111,18 +113,19 @@ Write key findings to `memory/cog-meta/briefing-bridge.md` so foresight can pick
 
 ## Stale Items (>2 weeks)
 - <item> — <age> — suggested action: <action>
+- **Compression rule**: Items stale >4 weeks — group by domain as a single line
 
 ## Birthday Prep
-- <name> birthday in <N> days — interests: <from entities>
+- <name> birthday in <N> days — interests: <from entities> — gift ideas: <suggestions>
 
 ## Dormant Domains
-- <domain> — last activity: <date>
+- <domain> — last activity: <date> — recommendation: <shelf/reactivate/shut down>
 
 ## Health Escalation
-- <item> — open <N> months
+- <item> — open <N> months — urgency: <high/medium>
 ```
 
-Only include sections that have content.
+Only include sections that have content. Empty sections should be omitted.
 
 ## 8. L0 Header Maintenance
 
@@ -132,7 +135,32 @@ Check all active memory files for missing `<!-- L0: ... -->` headers. If a file
 
 L0 headers are the first tier of the retrieval protocol — they let any skill scan what a file contains before deciding to read it.
 
-## 9. Compose Debrief
+## 9. Rebuild Domain Indexes
+
+Regenerate `INDEX.md` for each domain directory. These files power the memory router — the system prompt only shows a light domain table; the model reads INDEX.md on demand to find specific files.
+
+**For each domain** (scan `memory/` for directories, skip `glacier/`):
+1. List all `.md` files in the domain (exclude `INDEX.md`, `hot-memory.md`, and empty files)
+2. Extract the L0 summary from each file (same logic as step 8)
+3. Count total files
+4. Write `memory/{domain}/INDEX.md`:
+
+```markdown
+# {Domain} Index
+<!-- L0: {domain summary} — {N} files -->
+<!-- Auto-generated by housekeeping. Do not edit. -->
+<!-- Last updated: YYYY-MM-DD -->
+
+- **{filename}** — {L0 summary}
+- **{filename}** — {L0 summary}
+...
+```
+
+- Sort entries alphabetically by filename
+- Domain summary: use the `label` from `memory/domains.yml` for the matching domain
+- If a file has no L0, list it as just `**{filename}**` (no summary)
+
+## 10. Compose Debrief
 
 Summarize everything done:
 - What was archived/pruned

.claude/commands/reflect.md

@@ -74,12 +74,12 @@ Check if findings are already captured:
 - Distill into a pattern and add/update in `memory/cog-meta/patterns.md` (or domain `patterns.md` if domain-specific)
 - Don't delete the observations — they stay as the raw record
 
-**Core patterns.md size cap — HARD LIMIT: 70 lines / 5.5KB.** After any updates, check the file size. If it exceeds the cap:
+**Pattern file caps — enforce before adding to any file:**
-1. Compress multi-line entries to single lines
+- Core `patterns.md`: HARD LIMIT **70 lines / 5.5KB** — universal rules only
-2. Merge entries with overlapping lessons
+- Domain/satellite files: soft cap **30 lines** each
-3. Remove point-in-time data: counts with date ranges, incident tallies with specific dates
+- If near cap, compress before adding (merge overlapping rules, drop examples, remove temporal data)
-4. Entries must be **timeless rules** — "what to do" not "what happened"
+- Entries must be **timeless rules** — "what to do" not "what happened"
-5. Move domain-specific patterns to satellite files (e.g. `work/acme/patterns.md`) — only universal rules stay in core
+- Move domain-specific patterns to satellite files (e.g. `work/acme/patterns.md`) — only universal rules stay in core
 
 **Pattern routing** — when adding a new pattern, decide where it belongs:
 - **Core** (`cog-meta/patterns.md`) — universal rules that apply every conversation
@@ -107,7 +107,28 @@ For each candidate:
 - If not, note it as a suggestion: "Thread candidate: [topic] — [N] fragments across [date range]"
 - Don't auto-create threads — suggest them
 
-### 3d. Scenario Feedback Loop
+### 3d. Proactive Synthesis Suggestions
+
+Execute this clustering analysis every run:
+
+1. **Gather observations** — Read all `memory/*/observations.md` and `memory/*/*/observations.md` files
+2. **Filter to last 7 days** — Only count entries with dates within the past 7 calendar days
+3. **Cluster by domain** — Group filtered entries by their parent domain folder
+4. **Cluster by topic** — Group filtered entries by recurring keywords, tags, or subjects
+5. **Check trigger conditions** (either one qualifies):
+   - A single domain has **5+ observations** in the last 7 days
+   - A single topic/keyword appears in **5+ observations** across any domains in the last 7 days
+6. **Cross-reference threads** — If a thread already covers the topic, suggest updating it rather than creating new
+7. **Dedup with 3c** — If 3c already flagged the same topic, merge into one suggestion
+8. **Output** — If any clusters qualify, add a **"Synthesis Opportunities"** section to the debrief:
+   ```
+   **Synthesis Opportunities**
+   - [domain or topic]: [N] observations this week — [top 3 entry summaries]. Suggest: raise thread / update existing thread / update hot-memory
+   ```
+9. **Suppress if empty** — If no clusters meet the threshold, omit the heading
+10. **Never auto-synthesize** — Suggest and let the user decide
+
+### 3e. Scenario Feedback Loop
 
 Scan `memory/cog-meta/scenarios/` for active scenario files.
 
@@ -131,11 +152,16 @@ Honestly evaluate:
 Don't just log observations — *fix things*.
 
 **Write:**
-- New self-observations → append to `memory/cog-meta/self-observations.md`. **Cap: max 5 per reflect pass.**
+- New self-observations → append to `memory/cog-meta/self-observations.md`. **Cap: max 5 per reflect pass.** Prioritize highest-signal observations. If you have more than 5, merge lower-signal ones.
 - Pattern updates → edit `memory/cog-meta/patterns.md` in place
 - Improvement ideas → add to `memory/cog-meta/improvements.md`
 - Memory gaps → write to the appropriate domain files
 
+**Triage improvements.md:**
+- Stale ideas (>30 days, no progress) → archive to glacier or mark abandoned
+- Implemented but not moved → move to Implemented section
+- Duplicates → merge similar ideas
+
 **Reorganize:**
 - Entity data that's changed → update in place
 - When creating or restructuring any memory file, ensure it has an L0 header
@@ -160,6 +186,8 @@ Compose a concise summary:
 
 Keep it honest. If there's nothing notable, say so.
 
+**IMPORTANT**: Your debrief MUST list every file you modified and summarize the changes. Never respond with just "Done" — always enumerate your concrete actions. If you made no changes in a step, state that explicitly.
+
 ## Artifact Formats
 
 **Self-observation**: `- YYYY-MM-DD [tag]: <observation>`

.claude/commands/scenario.md

@@ -1,67 +1,112 @@
-Use this skill for scenario simulation — modeling decision branches with timelines, dependencies, and contingencies grounded in real memory data. Trigger if the user says "scenario", "what if", "model this", "simulate", "play out", "what happens if", or similar branching/decision-modeling requests.
+Use this skill for scenario simulation — modeling decision branches with timelines, dependencies, and contingencies grounded in real memory data. Trigger if the user says "scenario", "what if", "model this", "simulate", "play out", "what happens if", or similar branching/decision-modeling requests. Also triggered when foresight flags a scenario candidate.
 
-**This is NOT /foresight.** Foresight finds the question. Scenario models the answers.
+**This is NOT /foresight.** Foresight = scan broadly, write one nudge. Scenario = take a specific decision point, branch it into 2-3 paths, map dependencies and timelines for each. **Foresight finds the question. Scenario models the answers.**
+
+**This is NOT /reflect.** Reflect = past-facing, mines interactions, improves memory. Scenario = future-facing, models possible futures from a decision point. Reflect checks old scenarios against reality (the feedback loop), but scenario creates them.
 
 ## Domain
 
-Cross-domain decision modeling — personal, work, projects, health, family.
+Cross-domain decision modeling — personal, work, projects, health, family. Scenarios are most valuable when a decision in one domain has cascading effects across others.
 
 ## Memory Files
 
-Read based on scenario topic:
+Read based on scenario topic — this is focused, not a broad scan:
-- `memory/hot-memory.md`
+- `memory/hot-memory.md` (cross-domain strategic context)
-- `memory/personal/calendar.md`
+- `memory/personal/calendar.md` (upcoming timeline for overlay)
-- `memory/personal/action-items.md`
+- `memory/personal/action-items.md` (existing commitments, constraints)
 - Work domain action-items (read `memory/domains.yml` for active work domains)
-- Relevant domain hot-memory and entity files
+- Relevant domain hot-memory and entity files based on the scenario topic
-- `memory/cog-meta/scenarios/` (check for duplicates)
+- `memory/cog-meta/scenarios/` (existing scenarios — check for duplicates or related active scenarios)
-- `memory/cog-meta/scenario-calibration.md` (past accuracy)
+- `memory/cog-meta/scenario-calibration.md` (past accuracy — calibrate confidence accordingly)
 
 ## Process
 
 ### 1. Decision Point Identification
 
-A valid scenario requires:
+From user input or foresight seed, identify the specific decision point. A valid scenario requires:
-- A **fork** — at least 2 meaningfully different paths
+- A **fork** — at least 2 meaningfully different paths forward
-- **Stakes** — wrong choice has real cost
+- **Stakes** — the outcome matters enough that choosing wrong has real cost (time, money, relationships, health)
-- **Uncertainty** — right choice isn't obvious
+- **Uncertainty** — the right choice isn't obvious from current information
-- **Time sensitivity** — decision window is closing
+- **Time sensitivity** — the decision window is closing or the consequences unfold on a timeline
+
+If the input doesn't meet these criteria, say so and suggest what would make it scenario-worthy. Don't force-fit.
+
+Format the decision point:
+```
+Decision: <one-line framing>
+Context: <why this matters now — cite memory files>
+Window: <when must this be decided by>
+Domains affected: <which life/work domains>
+```
 
 ### 2. Dependency Mapping
 
-**Upstream dependencies** (constraints): calendar, commitments, people's states, health/financial constraints.
+Read across memory files to identify what this decision depends on and what depends on it.
-**Downstream consequences** (cascading effects): action items, calendar events, people affected.
 
-Every dependency must cite its source file.
+**Upstream dependencies** (things that constrain the decision):
+- Calendar events, deadlines, commitments from action-items
+- Other people's states/decisions from entities
+- Health, financial, or logistical constraints
+- Active scenarios that overlap
+
+**Downstream consequences** (things that change based on which path is chosen):
+- Action items that would need to change
+- Calendar events that would need to move
+- People who would be affected
+- Other decisions that cascade from this one
+
+Every dependency must cite its source file: `[[personal/calendar]]`, `[[work/acme/action-items]]`, etc.
 
 ### 3. Branch Generation
 
-Generate 2-3 branches. For each:
+Generate 2-3 branches. Not more — forced prioritization.
+
+For each branch:
 
 ```
 ### Branch N: <name>
 
 **Path**: <what happens, step by step>
-**Timeline**: <mapped to real calendar>
+**Timeline**: <when each step occurs, mapped to real calendar>
-**Assumptions**: <what must be true>
+**Assumptions**: <what must be true for this path to work>
-**Dependencies**: <what else changes>
+**Dependencies**: <what else changes if this path is taken>
-**Risk**: <canary signal — earliest indicator it's going wrong>
+**Risk**: <what could go wrong, and what would you see first — the canary signal>
-**Confidence**: <calibrated against past accuracy>
+**Confidence**: <how likely is this path to play out as described — calibrated against past scenario accuracy>
 ```
 
-Include at least one branch the user probably isn't considering.
+Branch quality rules:
+- Each branch must be **genuinely different** — not "do it" vs "do it but slightly differently"
+- Include at least one branch the user probably isn't considering (the non-obvious path)
+- Every claim in a branch must trace to a memory file or be explicitly marked as an assumption
 
 ### 4. Timeline Overlay
 
-Map each branch against the actual calendar. Show where branches collide with reality.
+Map each branch's key events against the actual calendar. Cross-reference `calendar.md` for recurring routines.
+
+Output a simple timeline per branch:
+```
+Branch 1 Timeline:
+- Week of Mar 17: <action>
+- Week of Mar 24: <action> (note: conflict with X)
+- Week of Apr 1: <action>
+...
+```
+
+The overlay is what makes scenarios useful — it shows where branches collide with reality.
 
 ### 5. Contingency Mapping
 
-For each branch: `If [assumption] breaks → watch for [signal] → pivot to [contingency]`
+For each branch, identify the **canary signal** — the earliest observable indicator that this branch is going off-track.
+
+```
+If [assumption] breaks → watch for [signal] → pivot to [contingency]
+```
+
+This turns the scenario from a static prediction into a monitoring framework.
 
 ### 6. Write Scenario File
 
-Write to `memory/cog-meta/scenarios/{slug}.md` with YAML frontmatter:
+Write to `memory/cog-meta/scenarios/{slug}.md`:
 
 ```yaml
 ---
@@ -72,18 +117,76 @@ status: active
 check-by: YYYY-MM-DD
 resolution-by: YYYY-MM-DD
 decision: <one-line>
+related-threads: [thread1, thread2]
 source: user|foresight
 ---
 ```
 
+Body format:
+```markdown
+# Scenario: <decision>
+<!-- Auto-generated by /scenario. Checked by /reflect. -->
+
+## Decision Point
+<from step 1>
+
+## Dependencies
+### Upstream
+<constraints — each with [[source]] link>
+
+### Downstream
+<consequences — each with [[source]] link>
+
+## Branches
+
+### Branch 1: <name>
+<from step 3>
+
+### Branch 2: <name>
+<from step 3>
+
+### Branch 3: <name> (optional)
+<from step 3>
+
+## Timeline Overlay
+<from step 4>
+
+## Contingency Map
+<from step 5>
+
+## Retrospective
+<!-- Added by /reflect when status changes to resolved -->
+```
+
 ## Rules
 
-1. **Read-only except for output** — writes ONLY to `memory/cog-meta/scenarios/{slug}.md`
+1. **Read-only except for output** — Scenario NEVER edits existing memory files. Writes ONLY to `memory/cog-meta/scenarios/{slug}.md`. If you spot a memory error, note it in the dependencies section and route to reflect.
-2. **2-3 branches, not more**
+2. **2-3 branches, not more** — force prioritization. If you can't distinguish 2 branches, it's not a scenario.
-3. **Evidence-based** — every dependency cites a source file
+3. **Evidence-based** — every dependency and assumption cites a source file. No hunches.
-4. **Calendar-grounded** — every branch overlays against real calendar
+4. **Calendar-grounded** — every branch must overlay against the real calendar. No timelines in a vacuum.
-5. **Confidence-calibrated** — read calibration before assigning confidence
+5. **Confidence-calibrated** — read `scenario-calibration.md` before assigning confidence. If past scenarios have been overconfident, adjust.
+6. **One scenario per decision** — don't combine multiple decisions. If they're linked, note the dependency and create separate scenarios.
+
+## Anti-Patterns
+
+- Don't scenario obvious decisions — if one path is clearly better, just say so
+- Don't scenario things already decided — check action-items for existing commitments
+- Don't produce "analysis paralysis" — the goal is clarity, not exhaustive enumeration
+- Don't scenario recurring/routine decisions — this is for inflection points, not daily choices
+- Don't ignore the non-obvious path — if all branches are variations of what the user already thinks, you're not adding value
+- Don't invent facts — if you don't have data for a dependency, mark it as an assumption
+
+## Trigger Threshold
+
+A scenario is worth running when:
+1. **Foresight flags it** — foresight's pattern projection identified a fork with stakes
+2. **User explicitly asks** — `/scenario what if...`
+3. **Action item conflict** — two critical/high-priority action items have incompatible timelines
+4. **Calendar crunch** — upcoming 2-week window has more commitments than capacity
+5. **Cross-domain cascade** — a decision in one domain visibly affects 2+ others
+
+NOT worth running for: hypotheticals with no deadline, decisions where all paths lead to the same outcome, things already decided.
 
 ## Activation
 
-Read scenario-calibration.md first. Then read relevant memory files. Model the futures. Be honest about uncertainty.
+Read scenario-calibration.md first (if it exists) for past accuracy. Then read the relevant memory files for the scenario topic. Model the futures. Be honest about uncertainty.

CLAUDE.md

@@ -124,7 +124,7 @@ The `/reflect` skill reads recent session transcripts to review interactions, ca
 2. **Write immediately**: Don't wait to save something worth remembering
 3. **Observations are append-only**: `- YYYY-MM-DD [tags]: <observation>` — never edit past entries
    - Tags: `health`, `habits`, `family`, `milestone`, `work`, `insight`, `regression`, `philosophy`, `mental-health`
-4. **Action items**: `- [ ] task (added YYYY-MM-DD)` / `- [x] task (done YYYY-MM-DD)`
+4. **Action items**: `- [ ] task | due:YYYY-MM-DD | pri:critical/high/med/low | domain:tag | added:YYYY-MM-DD` / `- [x] task (done YYYY-MM-DD)`. Fields after task are optional — use what's relevant. `pri:` defaults to medium if omitted.
 5. **Entities**: 3-line compact registry format. Each entry: `### Name (relationship)` / pipe-separated key facts / `status: active|inactive | last: YYYY-MM-DD | → [[link]]`. Max 3 content lines per entry. Heavy entries promoted to detail thread files — entity stub links to thread via `→ [[link]]`. Cross-domain entities: canonical entry in primary domain, pointer in secondary (e.g. `see [[work/acme/entities#Jane]]` in personal). **Temporal validity**: When a fact changes, mark old value as superseded with date. `last:` dates updated by reflect from journal/session scans. Entities inactive 6+ months → housekeeping moves to glacier.
 6. **Hot memory <50 lines**: Prune aggressively, move detail to observations
 7. **Self-improvement**: After notable interactions, append to `cog-meta/self-observations.md`. Periodically distill patterns into `cog-meta/patterns.md`
@@ -186,6 +186,8 @@ When responding to any query:
 | `link-index.md`                 | Auto-generated by housekeeping — do not edit manually |
 | `cog-meta/scenario-calibration.md` | Updated by /reflect — scenario accuracy tracking   |
 | `cog-meta/scenarios/*.md`       | Created by /scenario, reviewed by /reflect             |
+| `cog-meta/briefing-bridge.md`   | Auto-generated by housekeeping — consumed by foresight |
+| `cog-meta/foresight-nudge.md`   | Auto-generated by foresight — one nudge per run        |
 | `glacier/index.md`              | Auto-generated by housekeeping — do not edit manually |
 
 ### Glacier Archival