From 28aa16226a34bca90a7d54ebb46b800bf5893181 Mon Sep 17 00:00:00 2001 From: Marcio Puga Date: Mon, 23 Mar 2026 07:59:41 +1100 Subject: [PATCH] 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 --- .claude/commands/evolve.md | 35 ++++++- .claude/commands/foresight.md | 49 ++++++--- .claude/commands/history.md | 2 +- .claude/commands/housekeeping.md | 40 ++++++-- .claude/commands/reflect.md | 44 ++++++-- .claude/commands/scenario.md | 171 +++++++++++++++++++++++++------ CLAUDE.md | 4 +- 7 files changed, 276 insertions(+), 69 deletions(-) diff --git a/.claude/commands/evolve.md b/.claude/commands/evolve.md index bc3cb45..7595b62 100644 --- a/.claude/commands/evolve.md +++ b/.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. diff --git a/.claude/commands/foresight.md b/.claude/commands/foresight.md index 1072c5f..0c71780 100644 --- a/.claude/commands/foresight.md +++ b/.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: -- **Accelerating** — multiple updates in the last week -- **Stalling** — no movement in 2+ weeks despite not being deferred -- **Dormant** — domain-level silence (0 observations in 4+ weeks) +Scan action-items across all domains. Classify each active item: +- **Accelerating** — multiple updates in the last week, clear momentum. Signal: ride the wave, don't interrupt. +- **Cruising** — steady progress, on track. Signal: nothing to flag. +- **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`: ## Signal - + ## Insight - + ## Suggested Action - + --- Sources: [[file1]], [[file2]], [[file3]] + +## Scenario Candidate (optional) + +Decision: +Why now: +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`. -2. **One nudge, not a list** — force prioritization. -3. **Evidence-based** — every nudge cites at least 2 source files. -4. **Forward-looking** — avoid rehashing yesterday. -5. **Cross-domain preferred** — connecting personal + work is higher value than single-domain. +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. If everything is equally important, nothing is. +3. **Evidence-based** — every nudge cites at least 2 source files. No vibes. +4. **Non-obvious** — the nudge should surprise. If the user already knows and is acting on it, pick something else. +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 diff --git a/.claude/commands/history.md b/.claude/commands/history.md index 70cafe9..905b1b7 100644 --- a/.claude/commands/history.md +++ b/.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 diff --git a/.claude/commands/housekeeping.md b/.claude/commands/housekeeping.md index f7001fd..515c1e2 100644 --- a/.claude/commands/housekeeping.md +++ b/.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) - — — suggested action: +- **Compression rule**: Items stale >4 weeks — group by domain as a single line ## Birthday Prep -- birthday in days — interests: +- birthday in days — interests: — gift ideas: ## Dormant Domains -- — last activity: +- — last activity: — recommendation: ## Health Escalation -- — open months +- — open months — urgency: ``` -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 `` 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 + + + + +- **{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 diff --git a/.claude/commands/reflect.md b/.claude/commands/reflect.md index 727ac44..3dd2f9e 100644 --- a/.claude/commands/reflect.md +++ b/.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: -1. Compress multi-line entries to single lines -2. Merge entries with overlapping lessons -3. Remove point-in-time data: counts with date ranges, incident tallies with specific dates -4. 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 +**Pattern file caps — enforce before adding to any file:** +- Core `patterns.md`: HARD LIMIT **70 lines / 5.5KB** — universal rules only +- Domain/satellite files: soft cap **30 lines** each +- If near cap, compress before adding (merge overlapping rules, drop examples, remove temporal data) +- Entries must be **timeless rules** — "what to do" not "what happened" +- 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]: ` diff --git a/.claude/commands/scenario.md b/.claude/commands/scenario.md index 507fd5f..57c80a2 100644 --- a/.claude/commands/scenario.md +++ b/.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: -- `memory/hot-memory.md` -- `memory/personal/calendar.md` -- `memory/personal/action-items.md` +Read based on scenario topic — this is focused, not a broad scan: +- `memory/hot-memory.md` (cross-domain strategic context) +- `memory/personal/calendar.md` (upcoming timeline for overlay) +- `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 -- `memory/cog-meta/scenarios/` (check for duplicates) -- `memory/cog-meta/scenario-calibration.md` (past accuracy) +- Relevant domain hot-memory and entity files based on the scenario topic +- `memory/cog-meta/scenarios/` (existing scenarios — check for duplicates or related active scenarios) +- `memory/cog-meta/scenario-calibration.md` (past accuracy — calibrate confidence accordingly) ## Process ### 1. Decision Point Identification -A valid scenario requires: -- A **fork** — at least 2 meaningfully different paths -- **Stakes** — wrong choice has real cost -- **Uncertainty** — right choice isn't obvious -- **Time sensitivity** — decision window is closing +From user input or foresight seed, identify the specific decision point. A valid scenario requires: +- A **fork** — at least 2 meaningfully different paths forward +- **Stakes** — the outcome matters enough that choosing wrong has real cost (time, money, relationships, health) +- **Uncertainty** — the right choice isn't obvious from current information +- **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: +Context: +Window: +Domains affected: +``` ### 2. Dependency Mapping -**Upstream dependencies** (constraints): calendar, commitments, people's states, health/financial constraints. -**Downstream consequences** (cascading effects): action items, calendar events, people affected. +Read across memory files to identify what this decision depends on and what depends on it. -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: **Path**: -**Timeline**: -**Assumptions**: -**Dependencies**: -**Risk**: -**Confidence**: +**Timeline**: +**Assumptions**: +**Dependencies**: +**Risk**: +**Confidence**: ``` -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: +- Week of Mar 24: (note: conflict with X) +- Week of Apr 1: +... +``` + +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: +related-threads: [thread1, thread2] source: user|foresight --- ``` +Body format: +```markdown +# Scenario: + + +## Decision Point + + +## Dependencies +### Upstream + + +### Downstream + + +## Branches + +### Branch 1: + + +### Branch 2: + + +### Branch 3: (optional) + + +## Timeline Overlay + + +## Contingency Map + + +## Retrospective + +``` + ## Rules -1. **Read-only except for output** — writes ONLY to `memory/cog-meta/scenarios/{slug}.md` -2. **2-3 branches, not more** -3. **Evidence-based** — every dependency cites a source file -4. **Calendar-grounded** — every branch overlays against real calendar -5. **Confidence-calibrated** — read calibration before assigning confidence +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** — force prioritization. If you can't distinguish 2 branches, it's not a scenario. +3. **Evidence-based** — every dependency and assumption cites a source file. No hunches. +4. **Calendar-grounded** — every branch must overlay against the real calendar. No timelines in a vacuum. +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. diff --git a/CLAUDE.md b/CLAUDE.md index 2a5eb77..7e5a6f8 100644 --- a/CLAUDE.md +++ b/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]: ` — 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