@zalom/plastic 1.1.0 → 1.1.1

package/skills/roadmap/SKILL.md

@@ -21,7 +21,10 @@ wave entry mirrors that intent's status in `INDEX.md` (`queued`/`delivering`/`de
 **`INDEX.md` is the single writer of intent status; on any conflict INDEX wins and the roadmap
 entry is corrected to match.**
 
-The skill operates on the file directly via Read/Edit; no helper script.
+The skill operates on the roadmap file directly via Read/Edit. The one deterministic helper it
+uses is the savepoint ledger writer (`scripts/roadmap-savepoint`, `append`/`rebuild`); every verb's
+closing step calls `append` after its Read/Edit, and the roadmap `.md` file itself stays
+Read/Edit-only.
 
 ## Verbs
 
@@ -50,3 +53,6 @@ verb above.
 - Additive: this skill introduces no gate, lock, or hook, and does not change `INDEX.md`'s section
   list or the intent frontmatter schema.
 - Closing a roadmap moves it to `roadmaps/archived/{slug}.md` so `roadmaps/` lists only live ones.
+- Every verb also appends a machine ledger line to the roadmap's name-paired
+  `roadmaps/{slug}.savepoint.md`, the derived counterpart to the human `## Log`; see
+  `references/file-format.md` for its shape and location.

package/skills/roadmap/references/file-format.md

@@ -11,7 +11,9 @@ roadmap.
 
 `roadmaps/` lists only live (open or in-flight) roadmaps. Once a roadmap's `## Goal` is reached,
 its file moves to `roadmaps/archived/{slug}.md` (see Close/archive in `operations.md`); the
-`archived/` subdirectory is scaffolded once, alongside `roadmaps/`, with a `.gitkeep`.
+`archived/` subdirectory is scaffolded once, alongside `roadmaps/`, with a `.gitkeep`. Its
+name-paired ledger, `roadmaps/{slug}.savepoint.md` (see Savepoint ledger below), moves alongside
+it in the same Close/archive step.
 
 ## The four sections (in order)
 
@@ -63,6 +65,33 @@ that entry-intent's `outcome.md`:
 The log line never restates `outcome.md` detail; it points at it (lossless-by-reference). This
 complements, and does not replace, `INDEX.md`'s `## Completed` section or `CHANGELOG.md`.
 
+## Savepoint ledger
+
+`roadmaps/{slug}.savepoint.md` is the name-paired sibling of `roadmaps/{slug}.md`: the machine
+counterpart to the human `## Log`, moving to `roadmaps/archived/{slug}.savepoint.md` alongside its
+roadmap on close (see Close/archive). It is created lazily by the first `append` call; there is no
+template to scaffold.
+
+Line shape, one event per line, append-only, newest at the bottom:
+
+```
+<UTC-iso8601>  <event>  <detail>
+```
+
+Two-space fields, mirroring the intent-dir cycle-step ledger (`savepoint.md`). The controlled event
+vocabulary: `created`, `dispatched`, `parked`, `merged`, `release`, `handoff`, `closed`, and
+optionally `added`, `reordered`, `wave`. The `(event, detail)` pair is the idempotency key, so
+re-appending the same pair is a no-op.
+
+`## Log` and the ledger record the same events in two voices: the Log is the dated, one-sentence,
+EM-to-CTO-plain-language record a human reads cold; the ledger is the terse, machine-timestamped,
+controlled-vocabulary record a coordinator reads at a glance. Both are append-only; neither edits
+the other.
+
+The ledger is derived and rebuildable (`ruby ~/.plastic/scripts/roadmap-savepoint rebuild --roadmap
+roadmaps/{slug}.md`, reconstructing it from `## Log`), never a status source: `INDEX.md` stays the
+single writer of intent status, exactly as for the roadmap file itself.
+
 ## Worked example
 
 ```

package/skills/roadmap/references/operations.md

@@ -20,7 +20,10 @@ next" in under a minute, just from this one file.
    status mirroring that intent's current `INDEX.md` status.
 6. Append the first `## Log` line, a short `YYYY-MM-DD HH:MM UTC`-prefixed plain-language note
    that the roadmap was created.
-7. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
+7. Append the ledger event (derived, idempotent, safe to re-run; never writes INDEX or roadmap
+   status; creates `roadmaps/<slug>.savepoint.md` lazily): `ruby ~/.plastic/scripts/roadmap-savepoint
+   append --roadmap roadmaps/<slug>.md --event created --detail "<slug>: <title>"`.
+8. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
    never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <roadmaps-dir> --async`.
 
 ## Add / reorder entries
@@ -34,6 +37,10 @@ next" in under a minute, just from this one file.
   entry is eligible to run.
 - After any add/reorder, append a `## Log` line describing the change (e.g.
   `- <YYYY-MM-DD HH:MM UTC> added 132 to wave 2`).
+- Append the ledger event (derived, idempotent, safe to re-run; never writes INDEX or roadmap
+  status): `ruby ~/.plastic/scripts/roadmap-savepoint append --roadmap roadmaps/<slug>.md --event
+  added --detail "<id> to wave N"` for an add, or `--event reordered` for a reorder (describe the
+  move in `<detail>`).
 - Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
   never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <roadmaps-dir> --async`.
 
@@ -49,7 +56,12 @@ next" in under a minute, just from this one file.
    one-line EM-to-CTO entry described in `file-format.md` (date, what shipped and its impact in
    plain language, then a link to that intent's `outcome.md`). For other transitions, write a
    short dated plain-language line (no codenames, no jargon).
-5. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
+5. Append the ledger event, only when the status token actually changed (derived, idempotent,
+   never writes INDEX or roadmap status): map the new status to its mechanized event (`delivered`
+   -> `merged`, `delivering` -> `dispatched`, `blocked`/`abandoned` -> `parked`), then `ruby
+   ~/.plastic/scripts/roadmap-savepoint append --roadmap roadmaps/<slug>.md --event <event>
+   --detail "<intent-id>"` (add a sha in `<detail>` when one is known).
+6. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
    never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <roadmaps-dir> --async`.
 
 ## Append a log line
@@ -60,6 +72,10 @@ next" in under a minute, just from this one file.
   A delivery event follows the EM-to-CTO one-line shape with an `outcome.md` link (see
   `file-format.md`); bookkeeping events (created, an intent added to a wave, a wave completed, a
   roadmap closed) are short dated plain-language lines.
+- Append the matching ledger event (derived, idempotent, never writes INDEX or roadmap status):
+  when the line records a release cut, `ruby ~/.plastic/scripts/roadmap-savepoint append --roadmap
+  roadmaps/<slug>.md --event release --detail "<version>"`; otherwise append the mechanized event
+  matching the bookkeeping line just written (see the per-verb event mapping on this page).
 - Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
   never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <roadmaps-dir> --async`.
 
@@ -80,9 +96,13 @@ next" in under a minute, just from this one file.
    `abandoned` with a recorded reason, plus whatever else the goal states).
 2. Create `roadmaps/archived/` beside `roadmaps/` (both siblings of `INDEX.md`) if it does not
    exist yet.
-3. Move the file: `roadmaps/{slug}.md` -> `roadmaps/archived/{slug}.md`. `roadmaps/` itself then
-   lists only live (open or in-flight) roadmaps.
-4. Append the final `## Log` line before or as part of the move:
+3. Append the ledger closed event, while the roadmap is still at its live path (derived,
+   idempotent, never writes INDEX or roadmap status): `ruby ~/.plastic/scripts/roadmap-savepoint
+   append --roadmap roadmaps/<slug>.md --event closed --detail "<slug>"`.
+4. Move BOTH files: `roadmaps/{slug}.md` -> `roadmaps/archived/{slug}.md` AND
+   `roadmaps/{slug}.savepoint.md` -> `roadmaps/archived/{slug}.savepoint.md`. `roadmaps/` itself
+   then lists only live (open or in-flight) roadmaps.
+5. Append the final `## Log` line before or as part of the move:
    `- <YYYY-MM-DD HH:MM UTC> roadmap closed`.
-5. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
+6. Refresh the QMD index for this roadmap (no-op when QMD is absent), in the background so it
    never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <roadmaps-dir> --async`.

package/skills/roadmap-continuing/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: plastic-roadmap-continuing
+description: >-
+  Use when the user wants to continue or resume a roadmap, pick up a mid-flight delivery batch,
+  asks "where is the roadmap", or wants to resume the wave that was shipping, including an
+  indirect ask that never names a roadmap directly (for example "where did that batch of
+  tickets land"). This is the roadmap route of plastic-continuing: it finds the tier's
+  mid-flight roadmap, presents its state, then asks how to proceed exactly once.
+user-invocable: true
+---
+
+# Roadmap Continuing - resume the mid-flight roadmap
+
+`plastic-roadmap-continuing` is the roadmap route of `plastic-continuing`. It finds the tier's
+mid-flight roadmap, presents its state, then asks the user how to proceed, exactly once.
+
+Before intent 158a1 there was no automated way to do this: the `171` (consistency-dividend)
+roadmap handoff had to be resumed by hand, carried as a free-prose note in `171`'s own
+`## Insights`. This skill closes that gap.
+
+## Find the mid-flight roadmap
+
+1. Determine the tier (project vs. global) and enumerate that tier's live `roadmaps/*.md`
+   (exclude `roadmaps/archived/`). Read via Read/glob, or `plastic-roadmap`'s Read/consume
+   verb. See `plastic-roadmap`'s `references/file-format.md` for the file grammar; do not
+   duplicate it here.
+2. For each candidate, also read its paired ledger `roadmaps/<slug>.savepoint.md` when present
+   (see `plastic-roadmap`'s `references/file-format.md#savepoint-ledger`): its last line(s) are a
+   cheaper, precise last-event signal (for example `dispatched 134` or `merged 172`), read
+   alongside the existing `## Waves`/`## Log` judgment. The ledger is read-only here, a derived
+   signal, never a new status field; INDEX.md stays the sole status writer.
+3. Rank liveness by calling the shared reader in which mode (one implementation across the
+   auto loop and this skill):
+
+   ```bash
+   ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps --which
+   ```
+
+   Read `state` and the winning `roadmap`. When `state` is `tie`, `tie_candidates` lists the
+   equally-live roadmaps to present side by side; the single "auto or guided?" ask below
+   doubles as the resolution. `roadmap-next` liveness-ranks the same way this skill used to do
+   by eye (a `delivering` or `blocked` entry wins, else the newest ledger or `## Log`
+   timestamp), now deterministically. See `references/liveness-ranking.md` for the algorithm it
+   implements.
+4. A genuine tie (two candidates equally live) is presented to the user and resolved by the
+   single ask below, not silently picked.
+
+## Present state
+
+Present the chosen roadmap's `## Goal`, the current wave with each entry's mirrored status, the
+ledger's newest line(s) (the last mechanized event) alongside the newest `## Log` line, before any
+ask, so the coordinator sees the machine last-event at a glance.
+
+## Ask once
+
+Ask "auto or guided?" exactly once, after presenting state, mirroring
+`plastic-intent-starting`'s single-ask contract:
+- **guided** -> continue step by step with the user.
+- **auto** -> hand off to `plastic-auto` to drive the next wave or entry.
+
+Never re-ask. No new roadmap or INDEX status field is invented anywhere in this flow.
+
+## The shared reader
+
+Liveness ranking and frontier selection live in one place, `scripts/lib/roadmap_queue.rb`
+(intent 148), behind the `scripts/roadmap-next` CLI. This skill calls it in which mode rather
+than ranking roadmaps in prose, so the auto loop (`plastic-auto`) and this skill share exactly
+one implementation (no forked ranking logic). 158a1 originally added no script because the
+benefit was marginal for a read-time judgment; the auto-loop consumer flipped that calculus by
+making the ranking load-bearing and deterministic. The reader is read-only: it consumes the
+roadmap `.md`, the 134 `<slug>.savepoint.md` ledger, and INDEX.md, and writes nothing. INDEX.md
+stays the single status writer.
+
+## Caller contract: who writes the ledger
+
+This skill is a reader, not a writer, of `roadmaps/<slug>.savepoint.md`. The coordinator flows
+(`plastic-auto`, the enforcer, and this skill's own resume-and-hand-off path) call `ruby
+~/.plastic/scripts/roadmap-savepoint append` at their own dispatch, merge, park, handoff, and
+release points, the same events `plastic-roadmap`'s verbs append at their closing steps. A
+resuming coordinator therefore both reads the ledger here and writes to it as it drives the next
+wave or entry.
+
+## References
+
+- `references/liveness-ranking.md` - the read-time ranking algorithm and the tie rule.

package/skills/roadmap-continuing/evals/evals.json

@@ -0,0 +1,82 @@
+{
+  "skill_name": "plastic-roadmap-continuing",
+  "notes": "Intent 158a1. New roadmap route, closing the gap that forced the 171 (consistency-dividend) roadmap handoff to be resumed by hand. Scopes: description triggering (1-3) and behavior/convention compliance (4-8), the latter checked against SKILL.md.",
+  "results": {
+    "triggering": { "cases": 3, "passed": 3, "run": "2026-07-10, one subagent per case" },
+    "behavior": { "cases": 5, "passed": 5, "evidence": "convention checks against skills/roadmap-continuing/SKILL.md and references/liveness-ranking.md" }
+  },
+  "evals": [
+    {
+      "id": 1, "scope": "triggering", "set": "train",
+      "prompt": "continue the roadmap",
+      "expected_output": "Activates plastic-roadmap-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-roadmap-continuing", "observed": "plastic-roadmap-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 2, "scope": "triggering", "set": "train",
+      "prompt": "resume the delivery batch we were shipping",
+      "expected_output": "Activates plastic-roadmap-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-roadmap-continuing", "observed": "plastic-roadmap-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 3, "scope": "triggering", "set": "validation",
+      "prompt": "where did that batch of tickets land",
+      "expected_output": "Activates plastic-roadmap-continuing (indirect trigger: a roadmap-resume request that never names 'roadmap' or 'continue').",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-roadmap-continuing", "observed": "plastic-roadmap-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 4, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill rank liveness correctly when a wave entry is delivering or blocked?",
+      "expected_output": "A roadmap with any delivering/blocked wave entry wins the ranking outright over every other candidate.",
+      "files": ["skills/roadmap-continuing/references/liveness-ranking.md"],
+      "assertions": [
+        { "type": "convention", "check": "delivering/blocked-wins rule documented as step 2 of the algorithm", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 5, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill fall back to newest Log date when no candidate is delivering/blocked?",
+      "expected_output": "Among remaining candidates, the most recent ## Log entry timestamp wins.",
+      "files": ["skills/roadmap-continuing/references/liveness-ranking.md"],
+      "assertions": [
+        { "type": "convention", "check": "newest-Log-date fallback documented as step 3", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 6, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill present the roadmap state before asking?",
+      "expected_output": "The '## Present state' section (Goal, current wave, newest Log line) runs before the '## Ask once' section.",
+      "files": ["skills/roadmap-continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "Present state precedes Ask once in document order", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 7, "scope": "behavior", "set": "validation",
+      "prompt": "Does the skill ask 'auto or guided?' exactly once?",
+      "expected_output": "Exactly one ask, after presenting state; never re-asked.",
+      "files": ["skills/roadmap-continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "the literal phrase 'auto or guided' appears on exactly one line of SKILL.md", "observed": "one occurrence", "result": "pass" }
+      ]
+    },
+    {
+      "id": 8, "scope": "behavior", "set": "validation",
+      "prompt": "Does the skill invent a new roadmap or INDEX status field, or add a new script?",
+      "expected_output": "No. Liveness is computed at read time from existing files; INDEX.md stays the sole status writer; the enumeration/ranking is prose, not a helper script.",
+      "files": ["skills/roadmap-continuing/SKILL.md", "skills/roadmap-continuing/references/liveness-ranking.md"],
+      "assertions": [
+        { "type": "convention", "check": "no new field or script introduced; 'No new script' section present", "observed": "present", "result": "pass" }
+      ]
+    }
+  ]
+}

package/skills/roadmap-continuing/references/liveness-ranking.md

@@ -0,0 +1,56 @@
+# Liveness Ranking (read time, no new field)
+
+Depth reference for "Find the mid-flight roadmap" in `SKILL.md`. This is the full algorithm the
+body summarizes. Since intent 148, this algorithm is IMPLEMENTED in
+`scripts/lib/roadmap_queue.rb` behind the `scripts/roadmap-next` CLI; it is no longer a by-eye
+procedure. This page documents what that reader does, and is the specification the reader
+satisfies.
+
+## Why read-time, not a stored field
+
+INDEX.md stays the sole writer of intent status; the roadmap file mirrors it (see
+`plastic-roadmap`'s `references/file-format.md`). Adding a "mid-flight" flag to the roadmap
+file or to INDEX.md would create a second thing to keep in sync for a question that is cheap to
+answer by reading what is already there. So liveness is computed fresh, every call, from the
+tier's live `roadmaps/*.md` files (excluding `roadmaps/archived/`), by `RoadmapQueue` (intent
+148) rather than by eye.
+
+## The algorithm
+
+1. **Enumerate.** List every `roadmaps/*.md` at the tier (project or global), skipping
+   `roadmaps/archived/`.
+2. **Delivering/blocked wins outright.** If any candidate roadmap has at least one `## Waves`
+   entry whose mirrored status token is `delivering` or `blocked`, it is in flight right now.
+   That candidate wins the ranking immediately; skip the rest of the ranking for it.
+3. **Otherwise, newest `## Log` entry wins.** Among the remaining candidates (none have a
+   `delivering`/`blocked` entry), read each file's last `## Log` line (append-only, newest at
+   the bottom) and rank by that line's `YYYY-MM-DD HH:MM UTC` timestamp. The most recent wins.
+   When a candidate's paired `roadmaps/<slug>.savepoint.md` (intent 134) is present, its last
+   line is a cheaper, machine-timestamped read of the same fact (the ledger is derived from `##
+   Log`, so the two should already agree); reading it first is an optimization, not a second
+   source of truth, so a missing or stale ledger never blocks falling back to `## Log` itself.
+4. **Genuine tie -> present, do not silently pick.** If two or more candidates are equally live
+   (for example two roadmaps both idle with `## Log` entries on the same timestamp, or two both
+   showing `delivering` entries with no other signal to separate them), do not choose for the
+   user. Present both/all tied candidates' state side by side, then let the single "auto or
+   guided?" ask (asked once regardless of how many candidates were presented) double as the
+   resolution: the user's answer implicitly picks by naming which roadmap to continue, or the
+   agent asks a short one-line disambiguation immediately before that same single ask, never a
+   second separate prompt.
+
+## What this closes
+
+Before this skill existed, nothing resumed a mid-flight roadmap automatically. The `171`
+(consistency-dividend) roadmap handoff had to be resumed by hand: a free-prose "SESSION
+HANDOFF" note written into `171`'s own `## Insights`, because nothing read `## Waves` +
+`## Log` and reconstructed where the batch stood. This ranking, now a deterministic reader
+rather than a by-eye judgment, is the mechanism that replaces that hand-carried note.
+
+## Grammar pointer (do not duplicate)
+
+The roadmap file's four sections, entry line shape, and status vocabulary
+(`queued|delivering|delivered|abandoned|blocked`) are owned by `plastic-roadmap`:
+`skills/roadmap/references/file-format.md` for the shape, and
+`skills/roadmap/references/operations.md#read--consume` for how a reader (human or
+coordinator) is meant to walk `## Waves` and `## Log`. This page assumes that grammar and adds
+only the liveness-ranking judgment on top of it.

package/skills/skill-evaluating/evals/evals.json

@@ -1,5 +1,5 @@
 {
-  "skill_name": "skill-evaluating",
+  "skill_name": "plastic-skill-evaluating",
   "evals": [
     {
       "id": 1,

package/skills/tutorial/references/track-2-auto.md

@@ -72,7 +72,7 @@ line.
 
 ### 5. Continue and where-was-I after time away
 
-Type `/plastic-intent-continuing`.
+Type `/plastic-continuing`.
 
 Artifact: the current state, presented and then the session stops. If a specific intent is
 named, the agent reads its stage and savepoint and resumes exactly there, rather than

package/skills/uninstall/SKILL.md

@@ -14,7 +14,7 @@ underlying uninstaller and adds reporting + verification.
 
 If Plastic is installed, derive `<channel>` from `~/.plastic/VERSION`: a version containing
 `-alpha` means `@alpha`, `-beta` means `@beta`, otherwise `@latest`. If not installed,
-default to `@beta`. The user can always override with `--alpha` / `--beta` / `--latest`.
+default to `@latest`. The user can always override with `--alpha` / `--beta` / `--latest`.
 
 ## Procedure
 
@@ -74,5 +74,5 @@ Delete it too?
 ```
 
 - **Keep:** "Your data is at ~/.plastic/. Re-install anytime with
-  `npx -y @zalom/plastic@beta install --claude` (or your channel)."
+  `npx -y @zalom/plastic@latest install --claude` (or your channel)."
 - **Delete:** run `rm -rf ~/.plastic/` and confirm.

package/skills/update/SKILL.md

@@ -22,7 +22,7 @@ clean no-op. You do not compute the target yourself, the script does.
 
 If Plastic is installed, derive `<channel>` from `~/.plastic/VERSION`: a version containing
 `-alpha` means `@alpha`, `-beta` means `@beta`, otherwise `@latest`. If not installed
-(first install), default to `@beta`. The user can always override with
+(first install), default to `@latest`. The user can always override with
 `--alpha` / `--beta` / `--latest`.
 
 ## Flags
@@ -40,7 +40,7 @@ confirmed. To roll **back** to a previously-installed version, use `plastic-roll
 ## Prerequisites
 
 Plastic must be installed (`~/.plastic/VERSION` present). If not, run `plastic-install`
-first (or `npx -y @zalom/plastic@beta install --claude` directly).
+first (or `npx -y @zalom/plastic@latest install --claude` directly).
 
 ## Procedure
 

package/templates/config.yml

@@ -14,7 +14,8 @@ architect:
 
 # Per-agent model override (intent 116). Uncomment and set to a Claude Code
 # alias (opus, sonnet, haiku) to override the shipped tier for one agent. With
-# no entry, the shipped default applies. Never resolves to Fable.
+# no entry, the shipped default applies and never resolves to Fable; naming
+# Fable here is an explicit, sanctioned override, honored as written.
 # agents:
 #   models:
 #     plastic-executor: sonnet

package/templates/index.md

@@ -1,13 +1,16 @@
 # Index
 
 ## Active
+<!-- Line shape: `- [ID — Title](path)`. The em-dash (U+2014, not a plain hyphen)
+     between id and title is load-bearing: Bridge.intent_active? matches only that
+     shape, and a plain hyphen there fails the lock gate open (see docs/internals.md). -->
 (no active intents)
 
 ## Future
 (no future intents)
 
 ## Clusters
-(clusters emerge as intents accumulate — add headings when 3+ intents share a topic)
+(clusters emerge as intents accumulate; add headings when 3+ intents share a topic)
 
 ## Completed
 (links preserved, never deleted)