dreaming

name	dreaming
description	Unified memory corpus maintenance — covers both reactive (change-triggered) and proactive (periodic/idle-time improvement) paths. One skill, two entries.

Dreaming

Memory decays. Files move, commands change, invariants shift, duplicates accumulate. This skill is the maintenance loop that keeps the corpus trustworthy — one procedure, entered from either direction.

Reactive entry. Something changed: a file was renamed, a command flag was removed, an ADR shifted a subsystem boundary, a code review found stale memories referencing old paths. Run the procedure scoped to the affected area.

Proactive entry. Idle time, end-of-slice wrap-up, or a scheduled maintenance window. Run the procedure corpus-wide.

Procedure

1. Validate. Run doctrine memory validate corpus-wide (reactive: scope with --path-scope/--glob to the changed area). Triage each finding:

   • Fix immediately if trivial (update a path, refresh a scope)
   • Capture as a backlog item if non-trivial (risk, chore, or improvement)
   • Note and defer if low-impact and not time-sensitive

2. Prune. Identify stale memories:

   • Past review_by date → flag for review or archive
   • Unverified threads past expiry → archive (memory status <REF> archived)
   • working-lifespan memories older than a few days → retract or promote to a durable type
   • Run doctrine memory status <REF> archived for stale items; use retracted for memories that were simply wrong.

3. Link. Strengthen the graph:

   • Review suggested relations on recently-recorded or recently-edited memories (check memory show <REF> for relation rows)
   • Check for orphans — memories with no inbound and no outbound relations memory list --orphans
   • If there are orphans, focus on these - linking 20-30 records this run
   • If there aren't, explore the corpus and strengthen / prune connections between existing memories
     • use memory find <keyword> to find candidate memories for linking
   • Run doctrine link for high-confidence matches

4. Backlog grooming. Findings that can't be fixed in this pass become backlog items:

   • Risks for not-yet-surfaced issues (e.g., a memory pointing at a deprecated API)
   • Chores for cleanup work (e.g., merging duplicate memories)
   • Improvements for enhancements (e.g., promoting a pattern memory to a spec)

5. Fact-check. Spot-check the top-N memories by severity × staleness (days since updated). For each:

   • Check the cited source (code path, doc, ADR) against the current tree
   • If correct, no action
   • If drifted, correct with doctrine memory edit <REF>
   • If obsolete, supersede (memory status <REF> superseded --by <SUCCESSOR>) or quarantine (memory status <REF> quarantined)
   • If unverifiable, lower trust (memory edit <REF> --trust low)

6. Report. Produce a brief handoff summary:

   • Actions taken (validated N, pruned M, linked L, fact-checked F)
   • Findings deferred to backlog (with ids if filed)
   • Items flagged for human attention (high-severity, ambiguous, needs decision)
   • Write this to notes.md or the active handover so the next agent doesn't re-do the same checks.