v0.6

echo-memory.plugin.src/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "echo-memory",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Persistent memory via the ECHO Obsidian vault over the Local REST API. Self-bootstrapping: the plugin carries the full vault scaffold and all control logic (no in-vault routing docs), so it stands up an empty vault and ports cleanly to any other. Reads and writes notes across Claude/CoWork sessions using direct REST calls \u2014 no MCP server required. Jason's personal memory vault.",
   "author": {
     "name": "Jason"

echo-memory.plugin.src/README.md

@@ -28,22 +28,20 @@ The endpoint presents a **valid TLS certificate**, so `-k` is not required. The
 /vault/
 ├── README.md     ← thin human signpost (not read for routing)
 ├── inbox/        (captures, imports, processing-log)
-├── journal/      (daily, weekly, monthly, templates)
+├── journal/      (daily, weekly, monthly, quarterly, annual, templates) — one time-series stream; rollups live here, not in a separate reviews/ tree
 ├── projects/     (active, incubating, on-hold, archived)
 ├── areas/        (business, personal, learning, systems)
-├── resources/    (concepts, references, people, meetings, source-material)
+├── resources/    (concepts, references, people, meetings)
 ├── decisions/    (by-date)
-├── reviews/      (weekly, monthly, quarterly, annual)
-├── archive/      (notes, projects, imports)
 └── _agent/
     ├── echo-vault.md   ← bootstrap marker (schema_version + date)
     ├── context/        ← task-scoped context bundles
     ├── memory/         ← working / episodic / semantic
     ├── sessions/       ← YYYY-MM-DD-HHMM-<slug>.md
+    ├── health/         ← YYYY-MM-vault-health.md (monthly self-maintenance audit)
     ├── templates/      ← canonical note templates (seeded from the plugin's scaffold/)
-    ├── outputs/        ← briefs / drafts / summaries / synthesis
     ├── skills/         ← active / archived
-    └── heartbeat/
+    └── heartbeat/      ← last-session.md orientation pointer (read at load, written at session end)
 ```
 
 Control logic and the master scaffold live in the plugin, not the vault:
@@ -55,8 +53,11 @@ skills/echo-memory/
 │   ├── operating-contract.md      ← durable principles + safety
 │   ├── bootstrap.md               ← bootstrap / repair / migrate an empty vault
 │   ├── vault-layout.md            ← canonical layout + frontmatter
+│   ├── routing-map.md             ← complete endpoint→logic map (every path, trigger, why distinct)
 │   ├── api-reference.md           ← REST endpoint patterns + routing map
 │   └── session-log-template.md
+├── scripts/
+│   └── vault-lint.sh              ← read-only invariant checker (run by the monthly Vault Health pass)
 └── scaffold/                      ← verbatim files the bootstrap writes into the vault
     ├── README.vault.md  echo-vault.md
     ├── templates/  (8 note templates)

echo-memory.plugin.src/skills/echo-memory/SKILL.md

@@ -27,6 +27,7 @@ The endpoint has a **valid TLS certificate**, so `-k` is not needed (add it only
 - Durable principles, memory model, and safety rules: `references/operating-contract.md`
 - Bootstrapping an empty vault, repair, and schema migrations: `references/bootstrap.md`
 - Vault layout and frontmatter conventions: `references/vault-layout.md`
+- Complete endpoint→logic routing map (every write destination, its trigger, and why it's distinct): `references/routing-map.md`
 - Full API reference with every endpoint pattern and the memory routing map: `references/api-reference.md`
 
 ## Operating Contract & Safety
@@ -46,18 +47,26 @@ Load at the start of any substantive conversation — anything beyond a single q
 
 ### Loading procedure
 
-The cold-start reads are independent — **issue them in parallel** (one batch of 4–5 GETs), not sequentially. Parallel loading is ~3× faster wall-clock for the same call count.
+The cold-start reads are independent — **issue them in parallel** (one batch of 5–6 GETs), not sequentially. Parallel loading is ~3× faster wall-clock for the same call count.
 
 | # | GET | Notes |
 |---|-----|-------|
 | 1 | `/vault/_agent/echo-vault.md` | The bootstrap marker. 404 → vault not set up; follow `references/bootstrap.md`. 200 → check its `schema_version` and migrate if older. |
 | 2 | `/vault/_agent/memory/semantic/operator-preferences.md` | Jason's profile |
 | 3 | `/vault/_agent/context/current-context.md` | Active scope + Scope History |
-| 4 | `/vault/_agent/sessions/` (listing) | Pick the ~5 most recent by reverse lex sort (filenames `YYYY-MM-DD-HHMM-<slug>.md`, so lex == chrono); only read the ones whose slugs look relevant |
+| 4 | `/vault/_agent/heartbeat/last-session.md` → then `/vault/_agent/sessions/` | **Read the heartbeat first** — a one-line pointer (`<session-log-path> @ <ISO-timestamp>`) written at the end of the previous session. It's an O(1) jump to the latest log, so you can skip or shortcut the full listing. Fall back to the `sessions/` listing only if the pointer is missing or looks stale; then pick the ~5 most recent by reverse lex sort (filenames `YYYY-MM-DD-HHMM-<slug>.md`, so lex == chrono) and read only the relevant ones. |
 | 5 | `/vault/journal/daily/YYYY-MM-DD.md` | Today's note; 404 is fine — it's created on first agent activity |
+| 6 | `/vault/inbox/captures/inbox.md` | Inbox depth probe — feeds the load-time reconcile below. 404 is fine (empty inbox). |
 
 Do not read every session log — older sessions are reachable via `POST /search/simple/?query=...` when needed.
 
+**Reconcile at load (do this every cold start, after the batch returns).** The batch already fetched everything needed for a cheap self-check — run it before diving into the work so memory maintains itself instead of drifting:
+
+1. **Inbox depth (Inbox Triage).** If `inbox/captures/inbox.md` (GET #6) holds dated capture lines older than ~7 days that were never routed, surface the count once and offer to triage — see **Inbox Triage** below. This is the load-time trigger that makes triage self-firing rather than something you only run when asked.
+2. **Scope drift.** Compare `## Scope` in `current-context.md` (GET #3) against what Jason just asked for. If they diverge, follow **Scope Switching** to record the prior scope and set the new one.
+
+Keep the reconcile to a single short line to Jason (e.g. "3 inbox captures from last week are still un-routed — triage now?"); don't let it crowd out the actual request.
+
 **If a specific project is in play**, follow up with a **search across all lifecycle subfolders** (`active/`, `incubating/`, `on-hold/`, `archived/`) — searching one folder at a time misses notes filed elsewhere. Search by **both the slug AND any human title** Jason used in this conversation:
 
 ```bash
@@ -265,24 +274,42 @@ When scope changes:
 
 This keeps a rolling trail of recent scopes in one file instead of spawning separate stash notes. Trim Scope History to the last ~10 entries when it grows past that.
 
-## Weekly Review (opt-in)
+## Journal Rollups (the journal is one continuum)
 
-On the **first substantive session of a new ISO week**, offer a short weekly rollup; write it only if Jason accepts. Path: `reviews/weekly/YYYY-Www-review.md` (ISO week, e.g. `2026-W24-review.md` — lex-sorts chronologically), `type: review`. Scope: open threads across `projects/active/`, inbox items aging past ~7 days, and the week's `## Scope History` changes from `current-context.md`. Keep it a light digest, not a vault-health audit. Detect the trigger by computing the current ISO week (`date +%G-W%V`) and checking whether that week's review note already exists.
+The journal is a single append-only chronological stream. Rollups are just coarser-grained journal entries over the same timeline, so they **all live under `journal/`** — there is no separate `reviews/` tree. One place to read the whole time-series story, daily through annual.
 
-The other cadences: **monthly** is automatic (the Vault Health pass below); **quarterly** and **annual** are **manual / on request only**.
+| Cadence | Path | Trigger | Type |
+|---------|------|---------|------|
+| Daily | `journal/daily/YYYY-MM-DD.md` | first agent activity that day | `daily-note` |
+| Weekly | `journal/weekly/YYYY-Www.md` (e.g. `2026-W24.md`) | first substantive session of a new ISO week — **opt-in**, offer first | `weekly-note` |
+| Monthly | `journal/monthly/YYYY-MM.md` | first substantive session of a new calendar month — offer alongside the Vault Health pass | `monthly-note` |
+| Quarterly | `journal/quarterly/YYYY-Qn.md` | **manual / on request only** | `review` |
+| Annual | `journal/annual/YYYY.md` | **manual / on request only** | `review` |
+
+All filenames lex-sort chronologically. Detect the weekly trigger with `date +%G-W%V` and check whether that week's note already exists; monthly with `date +%Y-%m`.
+
+A weekly/monthly rollup is a **light digest** — open threads across `projects/active/`, inbox items aging past ~7 days, and the period's `## Scope History` changes from `current-context.md`. It is *not* a vault-health audit (that's an agent-maintenance artifact — see below).
 
 ## Vault Health (monthly)
 
-On the first substantive session of a calendar month, run a quick health pass and write findings to `reviews/monthly/YYYY-MM-vault-health.md`. Don't auto-fix without asking.
+On the first substantive session of a calendar month, run a quick health pass and write findings to `_agent/health/YYYY-MM-vault-health.md`. This is **agent self-maintenance, not a journal entry** — it lives under `_agent/` because it's about the vault's mechanical integrity, not Jason's work narrative. Don't auto-fix without asking.
 
-Checks:
+Run the bundled linter first — it mechanically checks the invariants below so you don't eyeball them:
+
+```bash
+bash "${CLAUDE_PLUGIN_ROOT}/skills/echo-memory/scripts/vault-lint.sh"
+```
+
+Checks (the linter asserts each and prints violations):
 
 1. **Stale active projects** — for each note in `projects/active/`, check `updated:` >30 days. Likely belongs in `on-hold/`.
 2. **Unprocessed inbox** — GET `inbox/captures/inbox.md`. List items older than 14 days that never moved through the triage protocol.
 3. **Duplicate slugs across lifecycle folders** — any slug appearing in more than one of `active/`, `incubating/`, `on-hold/`, `archived/` is broken state.
-4. **Broken-heading risk** — sample 2–3 frequently-PATCHed files; confirm `## Agent Log`, `## Scope`, `## Fact / Pattern`, `## Observations` headings still exist.
+4. **Folder ↔ `status:` mismatch** — any `projects/<lifecycle>/` note whose `status:` frontmatter disagrees with its folder.
+5. **Wikilinks in frontmatter** — any `[[...]]` inside a YAML frontmatter block (breaks Obsidian reading view).
+6. **Duplicate `## Agent Log` headings** — any daily note with more than one.
 
-The pass is cheap (a few searches + a directory listing) and pays for itself by catching drift before it requires a reorg.
+The pass is cheap and pays for itself by catching drift before it requires a reorg. Write the findings as a digest; act on them only with Jason's go-ahead.
 
 ## Daily Note — Agent Log
 
@@ -349,6 +376,12 @@ curl -s -X PATCH -H "$AUTH" \
 | Meeting notes / call recap | `resources/meetings/YYYY-MM-DD-<slug>.md` | PUT |
 | Skill / plugin capability entry (catalog, not the build work) | `_agent/skills/active/<slug>.md` (→ `_agent/skills/archived/` when retired) | PUT |
 | Daily activity / Agent Log | `journal/daily/YYYY-MM-DD.md` — see **Daily Note — Agent Log** above | PATCH (with auto-create) |
+| Weekly / monthly rollup | `journal/weekly/YYYY-Www.md` · `journal/monthly/YYYY-MM.md` — see **Journal Rollups** | PUT |
+| Quarterly / annual review | `journal/quarterly/YYYY-Qn.md` · `journal/annual/YYYY.md` (manual / on request) | PUT |
+| Vault-health audit (agent self-maintenance) | `_agent/health/YYYY-MM-vault-health.md` — see **Vault Health** | PUT |
+| Session-end orientation pointer | `_agent/heartbeat/last-session.md` (one line: `<session-log-path> @ <ISO-timestamp>`) | PUT |
+
+> **The complete, audited routing map lives in `references/routing-map.md`** — every write destination with its trigger, what lands there, and why it's distinct from its neighbors. This table is the quick-reference; the map is the authority. If a path isn't in the map, it shouldn't be written to.
 
 **Decision mirrors:** if the decision belongs to an existing note in `projects/active/`, add a `[[wikilink]]` to the ADR under that project's `## Key Decisions` heading (PATCH). If no matching project note exists, skip the mirror — the by-date ADR is sufficient; do not invent topical mirror files in `decisions/by-project/`.
 
@@ -382,6 +415,18 @@ curl -s -X PUT \
 
 Then add a one-line entry to today's daily note via the **Daily Note — Agent Log** procedure above.
 
+Finally, update the heartbeat pointer so the next session can orient in one GET (this is what closes the loop with loading-procedure Step 4 — a pointer nobody writes is a pointer nobody can read):
+
+```bash
+NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+printf '%s @ %s\n' "_agent/sessions/${SESSION_FILENAME}" "$NOW" \
+  | curl -s -X PUT -H "Authorization: Bearer 241265fbe6830934a9a4ad3e69335f64a42153b663aa5b0017cb1ea1217b2bab" \
+    -H "Content-Type: text/markdown" --data-binary @- \
+    "https://echoapi.alwisp.com/vault/_agent/heartbeat/last-session.md"
+```
+
+`last-session.md` is a single-line pointer overwritten (PUT) each session end — never appended, so it can't grow or duplicate.
+
 ## Vault Unreachable
 
 If the API returns a connection error, timeout, or `502`, tell Jason once that the memory vault is unreachable (a `502` usually means Obsidian/the REST plugin is not running on the backend), then proceed without memory. Do not retry repeatedly.

echo-memory.plugin.src/skills/echo-memory/references/api-reference.md

@@ -169,7 +169,7 @@ Returns an array of `{ filename, score, matches: [{ context, match }] }`.
 ```bash
 curl -s -X DELETE \
   -H "Authorization: Bearer 241265fbe6830934a9a4ad3e69335f64a42153b663aa5b0017cb1ea1217b2bab" \
-  "https://echoapi.alwisp.com/vault/archive/notes/old-note.md"
+  "https://echoapi.alwisp.com/vault/inbox/imports/old-note.md"
 ```
 
 Only on explicit operator request. Deletion is destructive.
@@ -205,7 +205,9 @@ Only on explicit operator request. Deletion is destructive.
 | Meeting notes / call recap | `resources/meetings/YYYY-MM-DD-<slug>.md` | PUT |
 | Skill / plugin capability entry (catalog, not build work) | `_agent/skills/active/<slug>.md` (→ `archived/` when retired) | PUT |
 | Daily activity / Agent Log | `journal/daily/YYYY-MM-DD.md` | POST / PATCH |
-| Periodic review | `reviews/{weekly,monthly,quarterly,annual}/` (weekly = opt-in offer on first session of a new ISO week; monthly = auto via Vault Health; quarterly/annual = manual) | PUT |
+| Journal rollup | `journal/{weekly/YYYY-Www,monthly/YYYY-MM,quarterly/YYYY-Qn,annual/YYYY}.md` (weekly = opt-in on first session of a new ISO week; monthly = offered with Vault Health; quarterly/annual = manual) | PUT |
+| Vault-health audit (agent self-maintenance) | `_agent/health/YYYY-MM-vault-health.md` (monthly; NOT a journal entry) | PUT |
+| Session-end orientation pointer | `_agent/heartbeat/last-session.md` (one line, overwritten each session end) | PUT |
 | Bootstrap marker (plugin-owned) | `_agent/echo-vault.md` (`schema_version`, bootstrap date) — the "is this vault set up?" probe | GET / PUT |
 
 **Slug rules:** kebab-case, ASCII, ~40 chars max. Every file carries canonical frontmatter (see `vault-layout.md`).

echo-memory.plugin.src/skills/echo-memory/references/bootstrap.md

@@ -19,7 +19,7 @@ At session start, GET the marker:
 curl -s -o /dev/null -w "%{http_code}" -H "$AUTH" "$BASE/vault/_agent/echo-vault.md"
 ```
 
-- **200** → bootstrapped. Read the marker's `schema_version`; if it is **less than** the plugin's current schema (1), run a migration pass (see *Migrations* below), otherwise proceed straight to the loading procedure in `SKILL.md`.
+- **200** → bootstrapped. Read the marker's `schema_version`; if it is **less than** the plugin's current schema (2), run a migration pass (see *Migrations* below), otherwise proceed straight to the loading procedure in `SKILL.md`.
 - **404** → empty/unconfigured vault. Run **Fresh bootstrap** below. (If you expected an existing vault, confirm with the operator once that the REST API is pointed at the right vault before seeding.)
 
 ---
@@ -36,18 +36,19 @@ The REST API auto-creates parent directories on PUT, so creating the tree = seed
 
 ```
 inbox/captures  inbox/imports  inbox/processing-log
-journal/daily  journal/templates
+journal/daily  journal/weekly  journal/monthly  journal/quarterly  journal/annual  journal/templates
 projects/active  projects/incubating  projects/on-hold  projects/archived
 areas/business  areas/personal  areas/learning  areas/systems
 resources/concepts  resources/references  resources/people  resources/meetings
 decisions/by-date
-reviews/weekly  reviews/monthly  reviews/quarterly  reviews/annual
 _agent/context  _agent/memory/working  _agent/memory/episodic  _agent/memory/semantic
-_agent/sessions  _agent/templates  _agent/heartbeat
+_agent/sessions  _agent/health  _agent/templates  _agent/heartbeat
 _agent/skills/active  _agent/skills/archived
 ```
 
 > `decisions/by-project/` is intentionally **not** created — it is retired. A project-relevant decision is mirrored as a `[[wikilink]]` under that project's `## Key Decisions` heading instead.
+>
+> `reviews/` is **not** created — it is retired. Journal rollups (weekly/monthly/quarterly/annual) live under `journal/`; the monthly vault-health audit lives under `_agent/health/`.
 
 A leaf README is just a one-liner, e.g.:
 
@@ -117,3 +118,4 @@ Run the same steps 1–5, but GET-probe each path first and **only create what i
 When the marker's `schema_version` is older than the plugin's, apply the migration steps for each intervening version, then PATCH the marker's `schema_version` frontmatter to the new value.
 
 - **0 → 1** (control-docs-in-plugin): the vault previously carried root control docs (`CLAUDE.md`, `BOOTSTRAP.md`, `STRUCTURE.md`, `index.md`). Back them up outside the vault, DELETE them, PUT the thin `scaffold/README.vault.md` over the old verbose `README.md`, write the `_agent/echo-vault.md` marker, and scrub now-dangling `[[CLAUDE]]`/`[[BOOTSTRAP]]`/`[[STRUCTURE]]`/`[[index]]` links from the `## Related` sections of `operator-preferences.md` and `current-context.md` (leave historical session logs alone). Confirm with the operator before deleting.
+- **1 → 2** (reviews-folded-into-journal): the `reviews/` tree is retired. (a) For each note under `reviews/weekly/` and `reviews/monthly/`, MOVE it into `journal/weekly/` (rename `YYYY-Www-review.md` → `YYYY-Www.md`) and `journal/monthly/` respectively, preserving the earliest `created:`. (b) Move any `reviews/monthly/YYYY-MM-vault-health.md` to `_agent/health/`. (c) Move `reviews/quarterly|annual/` artifacts to `journal/quarterly|annual/`. (d) Update inbound `[[reviews/...]]` wikilinks in `## Related` sections to the new paths. (e) DELETE the now-empty `reviews/` tree. Confirm with the operator before deleting; leave historical session logs alone. *(Jason's live vault was hand-migrated for the one existing `2026-W24` artifact on 2026-06-10; this step covers any vault bootstrapped under schema 1.)*

echo-memory.plugin.src/skills/echo-memory/references/routing-map.md

@@ -0,0 +1,112 @@
+# ECHO Routing Map
+
+**This document is canonical and complete.** Every write destination in the vault appears here exactly once, with the condition that routes content to it, what lands there, and why it is distinct from its neighbours. The rule for the whole system: **if a path is not in this map, nothing is written to it.** A path that cannot justify its separateness from a neighbour is a merge candidate, not a valid destination.
+
+Three views of the same truth: the `SKILL.md` *Where to Write* table is the quick-reference, this map is the authority, and `vault-layout.md` is the physical tree. When they disagree, this map wins and the others are fixed to match.
+
+## How to read a row
+
+- **Trigger** — the observable condition that sends content here. If two rows could both fire, the more specific trigger wins.
+- **What lands** — the unit of content written.
+- **Distinct because** — the one reason this path is not merged into its nearest neighbour. This is the load-bearing column; a row without it is a bug.
+- **Method** — the dominant REST verb (see `api-reference.md` for mechanics).
+
+---
+
+## inbox/ — unsorted intake
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `inbox/captures/inbox.md` | "Save this, sort later" — destination genuinely unknown at capture time | One date-prefixed line | The only path whose contract is *deferred routing*; everything else here has a known home | POST |
+| `inbox/imports/<slug>.md` | Raw external material dropped in wholesale (export, paste, dump) | The raw artifact, unedited | Holds un-triaged *bulk*, vs `captures` which holds single lines | PUT |
+| `inbox/processing-log/YYYY-MM-DD.md` | An inbox item is routed to its real home | One line: `<original> → <destination path>` | Audit trail of moves — never holds memory itself, only the record of routing | POST |
+
+Captures and imports are temporary by contract. Triage drains them into the homes below and logs the move; the original is left until Jason okays deletion.
+
+## journal/ — the one append-only time-series stream
+
+Rollups are coarser-grained journal entries over the same timeline, so they live in the same tree. There is no separate `reviews/` tree.
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `journal/daily/YYYY-MM-DD.md` | First agent activity on a given day | `## Agent Log` line(s) + day notes | Finest grain; the only journal note PATCHed repeatedly within its period | PATCH (auto-create) |
+| `journal/weekly/YYYY-Www.md` | First substantive session of a new ISO week — **opt-in**, offer first | Light digest: open `active/` threads, aging inbox, week's scope changes | Coarser than daily, finer than monthly; ISO-week grain | PUT |
+| `journal/monthly/YYYY-MM.md` | First substantive session of a new month — offered alongside Vault Health | Month digest, same shape as weekly | Month grain; separate cadence and trigger from weekly | PUT |
+| `journal/quarterly/YYYY-Qn.md` | **Manual / on request only** | Quarter-scale narrative review | Strategic grain; never auto-fires | PUT |
+| `journal/annual/YYYY.md` | **Manual / on request only** | Year-scale narrative review | Coarsest grain; never auto-fires | PUT |
+| `journal/templates/` | Bootstrap only (seeded from plugin masters) | Note templates | Holds templates, not journal content; never a runtime routing target | PUT (seed) |
+
+## projects/ — work with an end state
+
+Lifecycle folders; `status:` frontmatter MUST equal the folder name (the linter checks this).
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `projects/active/<slug>.md` | Work in motion now | Project note (Status PATCHed fresh) | Default state for anything being worked | PUT + PATCH |
+| `projects/incubating/<slug>.md` | Idea captured, work not started | Project note | Pre-work; promote to `active/` when work begins | PUT |
+| `projects/on-hold/<slug>.md` | Paused but still tracked | Project note | Resumable; distinct from `archived` (which is terminal) | PUT |
+| `projects/archived/<slug>.md` | Done, abandoned, or rolled up | Project note | Terminal; kept for history, never deleted | PUT |
+
+**Project vs area:** has an end state → `projects/`. Never "done" → `areas/`.
+
+## areas/ — standing responsibilities, no finish line
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `areas/<domain>/<slug>.md` | Ongoing domain Jason maintains indefinitely (`<domain>`: business/personal/learning/systems) | Area note | No end state — the one thing that disqualifies it from `projects/` | PUT |
+
+## resources/ — reference material about the world
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `resources/people/<name>.md` | A fact about a specific person | Person note (kebab-case slug) | Keyed to a person, not a topic or event | PUT / PATCH |
+| `resources/concepts/<slug>.md` | A reusable concept/idea Jason wants on file | Concept note | An idea, vs a `reference` which is an external source | PUT |
+| `resources/references/<slug>.md` | An external source/link worth keeping | Reference note | Points outward (a source), vs `concepts` (an idea) | PUT |
+| `resources/meetings/YYYY-MM-DD-<slug>.md` | Notes/recap tied to a specific meeting or call | Meeting note; mirror decisions to `decisions/by-date/`, commitments to the project | Event-anchored to a meeting, vs a project's ongoing thread | PUT |
+
+## decisions/ — non-obvious decisions (ADR)
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `decisions/by-date/YYYY-MM-DD-<slug>.md` | A non-obvious decision worth recording | ADR: Context → Decision → Consequences | The chronological system of record for decisions | PUT |
+
+**Mirror, don't duplicate:** if the decision belongs to an existing `projects/active/` note, PATCH a `[[wikilink]]` to the ADR under that project's `## Key Decisions`. No matching project → skip the mirror; the by-date ADR stands alone.
+
+## _agent/ — the agent's own working substrate
+
+| Path | Trigger | What lands | Distinct because | Method |
+|------|---------|------------|------------------|--------|
+| `_agent/echo-vault.md` | Bootstrap / schema migration only | Marker: `schema_version`, bootstrap date | Plugin-owned probe; never hand-edited | GET / PUT |
+| `_agent/context/current-context.md` | Active scope changes; task focus shifts | `## Scope`, `## Scope History`, priorities | Single *live* scope pointer, vs episodic which is a *past* record | PATCH / PUT |
+| `_agent/memory/semantic/operator-preferences.md` | A preference/pattern about Jason | Append under `## Observations`; promote to `## Fact / Pattern` when stable | The one curated profile; distinct from ad-hoc semantic notes | PATCH |
+| `_agent/memory/semantic/<slug>.md` | A durable fact/pattern that isn't a Jason-preference | Semantic note | Timeless fact, vs episodic (time-stamped event) and working (transient) | PUT |
+| `_agent/memory/episodic/<slug>.md` | A record of *what happened, when* | Episodic note | Anchored to an event in time; not a standing fact | PUT |
+| `_agent/memory/working/<slug>.md` | Short-lived state needed only for the current effort | Working note | Explicitly transient/time-boxed; safe to go stale | PUT |
+| `_agent/sessions/YYYY-MM-DD-HHMM-<slug>.md` | A substantive session ends (decisions/artifacts/commitments) | Session log (see template) | Per-session record; the unit loading Step 4 scans | PUT |
+| `_agent/health/YYYY-MM-vault-health.md` | First substantive session of a month (Vault Health pass) | Health-audit findings | Agent self-maintenance about vault integrity — NOT Jason's work narrative, so not in `journal/` | PUT |
+| `_agent/heartbeat/last-session.md` | End of every session, after the session log is written | One line: `<session-log-path> @ <ISO-timestamp>` | O(1) orientation pointer read first at load (Step 4); overwritten, never grows | PUT |
+| `_agent/templates/` | Bootstrap only (seeded from plugin masters) | Canonical note templates | Holds templates, not memory; never a runtime routing target | PUT (seed) |
+| `_agent/skills/active/<slug>.md` | Jason authors/installs a skill and wants it catalogued | Skill capability entry | Catalogs a *capability*, vs `projects/` which tracks the *build effort* | PUT |
+| `_agent/skills/archived/<slug>.md` | A catalogued skill is retired | Skill entry (moved from `active/`) | Terminal state of the skill catalog | PUT |
+
+---
+
+## Retired paths — explicitly never written
+
+Listed so they are recognised as dead and never recreated. Any one of these appearing in a live vault is a migration miss (see `bootstrap.md` Migrations).
+
+| Path | Status | Where it went instead |
+|------|--------|-----------------------|
+| `reviews/` (weekly/monthly/quarterly/annual) | Retired in schema 2 | Journal rollups → `journal/{weekly,monthly,quarterly,annual}/`; vault-health → `_agent/health/` |
+| `decisions/by-project/` | Retired in schema 1 | ADR mirrored as a `[[wikilink]]` under the project's `## Key Decisions` |
+| `archive/` (top-level) | Never existed | Project archival → `projects/archived/`; skill archival → `_agent/skills/archived/` |
+| `CLAUDE.md` / `BOOTSTRAP.md` / `STRUCTURE.md` / `index.md` (in-vault) | Retired in schema 1 | All control logic lives in the plugin (`references/`), not the vault |
+
+## Routing decision tree (the calls that get mis-made)
+
+1. **Destination unknown right now?** → `inbox/captures/`. Known? → route directly; never park a known fact in the inbox.
+2. **Is it about Jason's work over time?** → `journal/` (pick the grain by cadence). **About the vault's mechanical health?** → `_agent/health/`. These two look similar monthly but answer different questions.
+3. **Does the effort have an end state?** → `projects/` (folder = `status:`). **No finish line?** → `areas/`.
+4. **A fact about the world:** timeless → `semantic/`; a thing that happened → `episodic/`; needed only for now → `working/`. A fact about a *person* → `resources/people/`.
+5. **A decision:** always `decisions/by-date/`; mirror into a project only if one already exists.
+6. **A capability (skill/plugin):** `_agent/skills/` catalogs the capability; `projects/` tracks building it. Both can exist for the same skill.

echo-memory.plugin.src/skills/echo-memory/references/vault-layout.md

@@ -11,8 +11,12 @@
 │   ├── captures/      ← quick captures (inbox.md), date-prefixed lines
 │   ├── imports/       ← raw imported material
 │   └── processing-log/
-├── journal/
+├── journal/          ← one append-only time-series stream; rollups are coarser journal entries, NOT a separate reviews/ tree
 │   ├── daily/         ← YYYY-MM-DD.md (has an "Agent Log" section)
+│   ├── weekly/        ← YYYY-Www.md (ISO week, opt-in rollup)
+│   ├── monthly/       ← YYYY-MM.md (monthly rollup)
+│   ├── quarterly/     ← YYYY-Qn.md (manual / on request)
+│   ├── annual/        ← YYYY.md (manual / on request)
 │   └── templates/
 ├── projects/         ← lifecycle: incubating → active → on-hold/archived
 │   ├── active/        ← current work (status: active)
@@ -29,7 +33,7 @@
 │   └── decision-template.md
 │   (decisions/by-project/ is retired and not created —
 │    mirror an ADR into a project's `## Key Decisions` heading instead)
-├── reviews/           ← weekly / monthly / quarterly / annual
+│  (reviews/ is retired — journal rollups live under journal/; vault-health audits under _agent/health/)
 └── _agent/
     ├── echo-vault.md  ← bootstrap marker: schema_version + bootstrap date (plugin-owned; the "is this vault set up?" probe)
     ├── context/       ← current-context.md and task bundles
@@ -38,12 +42,13 @@
     │   ├── episodic/  ← what happened, when
     │   └── semantic/  ← durable facts/patterns (operator-preferences.md)
     ├── sessions/      ← YYYY-MM-DD-HHMM-<slug>.md
+    ├── health/        ← YYYY-MM-vault-health.md (monthly self-maintenance audit; NOT a journal entry)
     ├── templates/     ← canonical note templates
     ├── skills/        ← active / archived
     └── heartbeat/     ← single-line pointers (e.g. last-session.md → most-recent session log path)
 ```
 
-**Heartbeat:** `_agent/heartbeat/last-session.md` is a one-line pointer file an agent MAY write at session end (`<session-log-path> @ <ISO-timestamp>`). Reading it at session start is cheaper than listing the sessions directory; use it as a hint, not a source of truth — fall back to the directory listing if it's missing or stale.
+**Heartbeat:** `_agent/heartbeat/last-session.md` is a one-line pointer (`<session-log-path> @ <ISO-timestamp>`) the **session-logging procedure writes (PUT, overwrite) at session end** and the **loading procedure reads first (Step 4)** as an O(1) shortcut to the latest session log. It is a hint, not a source of truth — fall back to the `sessions/` directory listing if it's missing or stale. Because it's PUT-overwritten, it never grows or duplicates.
 
 **Slug rules:** kebab-case, ASCII only, truncate to ~40 chars.
 

echo-memory.plugin.src/skills/echo-memory/scaffold/README.vault.md

@@ -9,4 +9,4 @@ This Obsidian vault is the persistent memory substrate ("second brain") for its
 - **Bootstrap / repair:** see the plugin's `references/bootstrap.md`.
 - **Version marker:** `_agent/echo-vault.md` records the schema version and bootstrap date.
 
-Folders: `inbox/`, `journal/`, `projects/`, `areas/`, `resources/`, `decisions/`, `reviews/`, `archive/`, and the agent subtree `_agent/`.
+Folders: `inbox/`, `journal/` (daily + weekly/monthly/quarterly/annual rollups), `projects/`, `areas/`, `resources/`, `decisions/`, and the agent subtree `_agent/`.

echo-memory.plugin.src/skills/echo-memory/scaffold/echo-vault.md

@@ -6,7 +6,7 @@ updated: {{DATE}}
 tags: [agent, system, marker]
 agent_written: true
 source_notes: []
-schema_version: 1
+schema_version: 2
 bootstrapped: {{DATE}}
 managed_by: echo-memory-plugin
 ---

echo-memory.plugin.src/skills/echo-memory/scripts/vault-lint.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+# vault-lint.sh — mechanically assert ECHO vault invariants.
+#
+# Catches the recurring "invariant violation" bugs that prose rules can't enforce
+# on their own: folder<->status drift, duplicate slugs, wikilinks leaking into
+# frontmatter, duplicate "## Agent Log" headings, stale active projects, and
+# aging inbox captures. Invoked by the monthly Vault Health pass (see SKILL.md),
+# but safe to run any time — it is READ-ONLY and never modifies the vault.
+#
+# Exit status: 0 = clean, 1 = violations found, 2 = vault unreachable.
+#
+# Config is hardcoded to match the rest of the plugin; override via env if needed:
+#   ECHO_BASE   (default https://echoapi.alwisp.com)
+#   ECHO_KEY    (default the plugin's bearer token)
+#   STALE_DAYS  (default 30)  INBOX_DAYS (default 14)
+
+set -euo pipefail
+
+ECHO_BASE="${ECHO_BASE:-https://echoapi.alwisp.com}"
+ECHO_KEY="${ECHO_KEY:-241265fbe6830934a9a4ad3e69335f64a42153b663aa5b0017cb1ea1217b2bab}"
+STALE_DAYS="${STALE_DAYS:-30}"
+INBOX_DAYS="${INBOX_DAYS:-14}"
+
+ECHO_BASE="$ECHO_BASE" ECHO_KEY="$ECHO_KEY" STALE_DAYS="$STALE_DAYS" INBOX_DAYS="$INBOX_DAYS" \
+python3 - <<'PY'
+import os, sys, json, re, datetime, urllib.request, urllib.error
+
+BASE = os.environ["ECHO_BASE"].rstrip("/")
+KEY  = os.environ["ECHO_KEY"]
+STALE_DAYS = int(os.environ["STALE_DAYS"])
+INBOX_DAYS = int(os.environ["INBOX_DAYS"])
+TODAY = datetime.date.today()
+LIFECYCLES = ["active", "incubating", "on-hold", "archived"]
+SKIP = {"README.md", "project-template.md", "decision-template.md"}
+
+violations = []
+def flag(check, msg): violations.append((check, msg))
+
+def get(path):
+    """GET /vault/<path>. Returns text, or None on 404. Raises on hard failure."""
+    req = urllib.request.Request(f"{BASE}/vault/{path}",
+                                 headers={"Authorization": f"Bearer {KEY}"})
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return r.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        raise
+
+def listdir(path):
+    body = get(path if path.endswith("/") else path + "/")
+    if body is None:
+        return []
+    try:
+        return json.loads(body).get("files", [])
+    except json.JSONDecodeError:
+        return []
+
+def frontmatter(text):
+    """Return (raw_frontmatter_str, dict_of_scalar_fields). Empty if no block."""
+    if not text or not text.startswith("---"):
+        return "", {}
+    end = text.find("\n---", 3)
+    if end == -1:
+        return "", {}
+    raw = text[3:end]
+    fields = {}
+    for line in raw.splitlines():
+        m = re.match(r"^([A-Za-z_]+):\s*(.*)$", line)
+        if m:
+            fields[m.group(1)] = m.group(2).strip()
+    return raw, fields
+
+def parse_date(s):
+    m = re.match(r"(\d{4}-\d{2}-\d{2})", s or "")
+    if not m:
+        return None
+    try:
+        return datetime.date.fromisoformat(m.group(1))
+    except ValueError:
+        return None
+
+# Reachability probe
+try:
+    if get("_agent/echo-vault.md") is None:
+        print("vault-lint: marker missing — vault may not be bootstrapped.", file=sys.stderr)
+except Exception as e:
+    print(f"vault-lint: vault unreachable ({e}).", file=sys.stderr)
+    sys.exit(2)
+
+# ---- Projects: folder<->status, stale active, wikilinks-in-frontmatter, dup slugs
+slug_homes = {}
+for lc in LIFECYCLES:
+    for fn in listdir(f"projects/{lc}"):
+        if fn.endswith("/") or fn in SKIP:
+            continue
+        slug = fn[:-3] if fn.endswith(".md") else fn
+        slug_homes.setdefault(slug, []).append(lc)
+        text = get(f"projects/{lc}/{fn}")
+        if text is None:
+            continue
+        raw, fm = frontmatter(text)
+        status = fm.get("status", "").strip().strip('"').strip("'")
+        if status and status != lc:
+            flag("folder/status", f"projects/{lc}/{fn}: status='{status}' but folder='{lc}'")
+        if "[[" in raw:
+            flag("frontmatter-wikilink", f"projects/{lc}/{fn}: '[[...]]' inside frontmatter")
+        if lc == "active":
+            d = parse_date(fm.get("updated", ""))
+            if d and (TODAY - d).days > STALE_DAYS:
+                flag("stale-active", f"projects/active/{fn}: updated {d} ({(TODAY-d).days}d ago) — consider on-hold/")
+for slug, homes in slug_homes.items():
+    if len(homes) > 1:
+        flag("duplicate-slug", f"'{slug}' exists in {', '.join(homes)}")
+
+# ---- Wikilinks-in-frontmatter for other high-churn notes
+extra = ["_agent/context/current-context.md",
+         "_agent/memory/semantic/operator-preferences.md"]
+for fn in listdir("resources/people"):
+    if fn.endswith(".md") and fn not in SKIP:
+        extra.append(f"resources/people/{fn}")
+for fn in listdir("_agent/memory/semantic"):
+    if fn.endswith(".md") and fn not in SKIP:
+        extra.append(f"_agent/memory/semantic/{fn}")
+for path in extra:
+    text = get(path)
+    if text is None:
+        continue
+    raw, _ = frontmatter(text)
+    if "[[" in raw:
+        flag("frontmatter-wikilink", f"{path}: '[[...]]' inside frontmatter")
+
+# ---- Daily notes: duplicate "## Agent Log" headings
+for fn in listdir("journal/daily"):
+    if not fn.endswith(".md") or fn in SKIP:
+        continue
+    text = get(f"journal/daily/{fn}") or ""
+    n = len(re.findall(r"(?m)^## Agent Log\s*$", text))
+    if n > 1:
+        flag("duplicate-agent-log", f"journal/daily/{fn}: {n} '## Agent Log' headings")
+
+# ---- Inbox: captures aging past INBOX_DAYS
+inbox = get("inbox/captures/inbox.md") or ""
+for line in inbox.splitlines():
+    m = re.match(r"^\s*-\s*(\d{4}-\d{2}-\d{2})\b", line)
+    if m:
+        d = parse_date(m.group(1))
+        if d and (TODAY - d).days > INBOX_DAYS:
+            flag("aging-inbox", f"inbox capture {d} ({(TODAY-d).days}d): {line.strip()[:80]}")
+
+# ---- Report
+if not violations:
+    print("vault-lint: clean — all invariants hold.")
+    sys.exit(0)
+
+print(f"vault-lint: {len(violations)} violation(s) found\n")
+by = {}
+for check, msg in violations:
+    by.setdefault(check, []).append(msg)
+labels = {
+    "folder/status": "Folder <-> status mismatch",
+    "duplicate-slug": "Duplicate slug across lifecycle folders",
+    "frontmatter-wikilink": "Wikilink in frontmatter (breaks reading view)",
+    "duplicate-agent-log": "Duplicate '## Agent Log' heading",
+    "stale-active": f"Stale active project (updated > {STALE_DAYS}d)",
+    "aging-inbox": f"Inbox capture aging (> {INBOX_DAYS}d)",
+}
+for check, msgs in by.items():
+    print(f"## {labels.get(check, check)}")
+    for m in msgs:
+        print(f"  - {m}")
+    print()
+sys.exit(1)
+PY