@zalom/plastic 1.0.0-beta.32 → 1.0.0-beta.34

package/PLASTIC.md

@@ -329,10 +329,12 @@ is a named, ordered, delivery-side collection of intents: the delivery-side coun
 release (completion-side, tracked in `CHANGELOG.md`). Use `plastic-roadmap` to create, order,
 close, and consume one.
 
-File location: `roadmaps/{slug}.md`, a store-root sibling of `INDEX.md`, identical in the global
-store (`~/.plastic/store/`) and any project store (`~/.plastic/projects/{slug}/store/`).
-`roadmaps/` lists only live (open or in-flight) roadmaps: once a roadmap's goal is reached, it
-moves to `roadmaps/archived/{slug}.md`, a sibling subdirectory scaffolded once with a `.gitkeep`.
+File location: `roadmaps/{slug}.md`, a sibling of `INDEX.md`, wherever `INDEX.md` lives, never
+inside `store/` (store holds intent directories, not project artifacts). For a project that is its
+root, `~/.plastic/projects/{slug}/roadmaps/`, beside `project.yml`; for the global tier it is
+`~/.plastic/roadmaps/`, beside `~/.plastic/INDEX.md`. `roadmaps/` lists only live (open or
+in-flight) roadmaps: once a roadmap's goal is reached, it moves to `roadmaps/archived/{slug}.md`,
+a sibling subdirectory scaffolded once with a `.gitkeep`.
 
 A roadmap file has four sections, in order: a title/meta header, `## Goal`, `## Waves`, and an
 append-only dated `## Log`. `## Goal` is a checkable prose condition read by a human or agent, not
@@ -345,8 +347,9 @@ on any conflict INDEX wins and the roadmap entry is corrected to match.
 
 **Human-comprehension surface.** A roadmap is also written to be read cold. Wave entries render as
 checkboxes (checked once delivered, unchecked otherwise) next to the status token, and each `## Log`
-line is one plain-language sentence, dated, written the way an engineering manager would brief a
-non-expert executive: what shipped and why it matters, no jargon or codenames, ending with a link
+line is one plain-language sentence, starting `YYYY-MM-DD HH:MM UTC`, written the way an
+engineering manager would brief a non-expert executive: what shipped and why it matters, no jargon
+or codenames, ending with a link
 to that intent's `outcome.md`. The log points at the detail instead of repeating it, so a person
 opening the file with no other context can tell what shipped, what is running now, and what is
 next in under a minute.

package/hooks/statusline

@@ -85,15 +85,57 @@ fi
 INDEX_DIR=$(dirname "$INDEX")
 
 # --- Current-session work-unit: the live bridge wins over savepoint recency ---
-# The statusline receives the real session_id on stdin; the session's bridge
-# (plastic-{session_id}.json) is the authoritative "what THIS session is driving".
-# This beats the shared, savepoint-recency heuristic so parallel sessions on one
-# store no longer overwrite each other's line. grep/sed only - no jq, no ruby.
+# The statusline receives the real session_id on stdin. A session can now own
+# SEVERAL per-intent bridges at once (intent 131, plastic-{session_id}--{id}.json),
+# one per concurrent delivery, so the statusline must pick which of them to show:
+# prefer a candidate whose worktree.code (or intent dir) prefixes REAL_CWD, else
+# the newest by mtime (ls -t is 3.2-safe); tolerate a legacy single-key
+# plastic-{session_id}.json when no per-intent file exists. This beats the shared,
+# savepoint-recency heuristic so parallel sessions on one store no longer
+# overwrite each other's line. grep/sed/ls only - no jq, no ruby.
 WORK=""
 SID=$(json_str "session_id")
 if [ -n "$SID" ]; then
-  BRIDGE="${PLASTIC_TMP:-/tmp}/plastic-${SID}.json"
-  if [ -f "$BRIDGE" ]; then
+  BR_TMP="${PLASTIC_TMP:-/tmp}"
+  BRIDGE=""
+  CANDIDATES=$(ls -1t "${BR_TMP}"/plastic-"${SID}"--*.json 2>/dev/null)
+  if [ -n "$CANDIDATES" ]; then
+    while IFS= read -r cand; do
+      [ -z "$cand" ] && continue
+      WT_BLOCK=$(sed -n '/"worktree"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
+      WC=$(printf '%s\n' "$WT_BLOCK" | grep -o '"code"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"code"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      IN_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
+      ISTORE=$(printf '%s\n' "$IN_BLOCK" | grep -o '"store"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"store"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      IDIR=$(printf '%s\n' "$IN_BLOCK" | grep -o '"dir"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"dir"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      MATCH=""
+      if [ -n "$WC" ] && [ -n "$REAL_CWD" ]; then
+        case "$REAL_CWD" in "$WC"|"$WC"/*) MATCH=1 ;; esac
+      fi
+      if [ -z "$MATCH" ] && [ -n "$ISTORE" ] && [ -n "$IDIR" ] && [ -n "$REAL_CWD" ]; then
+        IPATH="$ISTORE/$IDIR"
+        case "$REAL_CWD" in "$IPATH"|"$IPATH"/*) MATCH=1 ;; esac
+      fi
+      if [ -n "$MATCH" ]; then
+        BRIDGE="$cand"
+        break
+      fi
+    done <<BRIDGE_CAND_EOF
+$CANDIDATES
+BRIDGE_CAND_EOF
+    # No cwd/worktree signal on any candidate: fail open to the newest (ls -t
+    # already sorted CANDIDATES newest-first).
+    [ -z "$BRIDGE" ] && BRIDGE=$(printf '%s\n' "$CANDIDATES" | head -1)
+  else
+    # Legacy tolerance: no per-intent bridge for this session, but an old
+    # single-key file may still exist.
+    LEGACY="${BR_TMP}/plastic-${SID}.json"
+    [ -f "$LEGACY" ] && BRIDGE="$LEGACY"
+  fi
+
+  if [ -n "$BRIDGE" ] && [ -f "$BRIDGE" ]; then
     # Bridge JSON is pretty-printed (one field per line). Scope extraction to the
     # "intent" object so a sibling top-level "id"/"name" can never win (the intent
     # object holds only string fields, so the first "}" closes it). grep/sed only.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-beta.32",
+  "version": "1.0.0-beta.34",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/dashboard.rb

@@ -32,7 +32,11 @@ def today
   s && !s.empty? ? Date.parse(s) : Date.today
 end
 
-STALE_DAYS = 14
+# A generic "about a month" threshold, not tuned to any one store's item count.
+# Deliberately independent from plastic-continuing's separate stale_threshold_days
+# config: that one is a proactive boot-time triage nudge, this is a board annotation.
+# Unifying the two is a follow-up, not this intent.
+STALE_DAYS = 30
 
 # ---------------------------------------------------------------------------
 # Parsing — reuses the conventions in scripts/doctor.rb
@@ -105,6 +109,26 @@ def last_accessed_at(dir, created)
   ""
 end
 
+# True iff the savepoint ledger's last non-blank line shows real post-birth
+# activity, not just the one-line birth stamp every intent gets at creation
+# (scripts/new-intent's Bridge.append_savepoint call, stage "What"). Reads the
+# last line, extracts the stage token (second whitespace-separated field, same
+# ledger shape last_accessed_at already parses), and treats any stage other
+# than "What" as progress. Returns false when the file is missing/empty.
+def savepoint_shows_progress?(path)
+  return false unless File.exist?(path)
+  last_line = nil
+  File.readlines(path).reverse_each do |line|
+    stripped = line.strip
+    next if stripped.empty?
+    last_line = stripped
+    break
+  end
+  return false unless last_line
+  stage = last_line.split(/\s+/)[1]
+  !stage.nil? && stage != "What"
+end
+
 # Parse one intent directory into a raw record.
 def parse_intent(store_info, dir_name, status_index)
   dir = File.join(store_info[:store], dir_name)
@@ -113,7 +137,6 @@ def parse_intent(store_info, dir_name, status_index)
   return nil unless fm && fm["id"]
 
   id = fm["id"].to_s
-  has = ->(f) { File.exist?(File.join(dir, f)) }
   # Sentinel-aware presence for lifecycle files (intent 60b): a scaffolded
   # placeholder spec/plan/checklist/outcome reads as absent, so a freshly
   # scaffolded intent reports What/Why and is never marked completed/advanced.
@@ -143,7 +166,7 @@ def parse_intent(store_info, dir_name, status_index)
     plan: real.("plan.md"),
     checklist: real.("checklist.md"),
     outcome: real.("outcome.md"),
-    savepoint: has.("savepoint.md"),
+    savepoint: savepoint_shows_progress?(File.join(dir, "savepoint.md")),
     checklist_partial: real.("checklist.md") && checklist_partially_done?(File.join(dir, "checklist.md")),
     body_has_context: body.include?("## Context"),
     last_accessed_at: last_accessed_at(dir, (fm["created"].to_s rescue "")),
@@ -163,6 +186,7 @@ end
 def load_all
   all = []
   done_ids = {}
+  completed_on_map = {}
   stores.each do |si|
     idx = {
       active: index_section_ids(si[:index], "## Active"),
@@ -176,11 +200,12 @@ def load_all
       rec[:completed_on] = comp[rec[:id]] || ""
       all << rec
       done_ids[[rec[:scope], rec[:id]]] = true if rec[:status] == "completed"
+      completed_on_map[[rec[:scope], rec[:id]]] = comp[rec[:id]] if comp[rec[:id]] && !comp[rec[:id]].empty?
     end
   end
   referenced = {}
   all.each { |r| r[:sources].each { |s| referenced[[r[:scope], s]] = true } }
-  [all, done_ids, referenced]
+  [all, done_ids, referenced, completed_on_map]
 end
 
 # ---------------------------------------------------------------------------
@@ -214,11 +239,14 @@ end
 
 # Effort -> :small | :big
 # Small when the work is bounded: a non-implementation type, an already-scoped intent
-# (plan/checklist exists), or a deep refinement branch. Otherwise big.
+# (plan/checklist exists), or a branch id. By Plastic's own Zettelkasten convention, a
+# branch id is a narrower refinement of its parent, so any branch (not only deep
+# sub-branches) defaults to smaller effort than an untouched root idea; root ids
+# (`root_intent?`) are unaffected since `folgezettel_depth` on a bare number is always 1.
 def effort_of(rec, type)
   return :small if %w[research exploration bugfix].include?(type)
   return :small if rec[:plan] || rec[:checklist]
-  return :small if folgezettel_depth(rec[:id]) >= 4
+  return :small if folgezettel_depth(rec[:id]) >= 2
   :big
 end
 
@@ -238,11 +266,12 @@ def value_of(rec, referenced = {})
   :low
 end
 
-def flags_of(rec, done_ids)
+def flags_of(rec, done_ids, completed_on_map = {})
   flags = []
   flags << "in-progress" if rec[:savepoint] || rec[:checklist_partial]
   if rec[:status] == "future" && !rec[:sources].empty? &&
-     rec[:sources].all? { |s| done_ids[[rec[:scope], s]] }
+     rec[:sources].all? { |s| done_ids[[rec[:scope], s]] } &&
+     genuine_wait?(rec, completed_on_map)
     flags << "unblocked"
   end
   age = stale_age(rec)
@@ -250,6 +279,22 @@ def flags_of(rec, done_ids)
   flags
 end
 
+# True iff at least one declared source's completion date is strictly later
+# than this intent's own `created` date — i.e. the intent actually waited on
+# something, rather than being born already-satisfied (the common case: a
+# branch's declared source is almost always finished before the branch exists,
+# since the child is created from the parent's own lifecycle).
+def genuine_wait?(rec, completed_on_map)
+  created_date = (Date.parse(rec[:created]) rescue nil)
+  return false unless created_date
+  rec[:sources].any? do |s|
+    source_date_str = completed_on_map[[rec[:scope], s]]
+    next false unless source_date_str
+    source_date = (Date.parse(source_date_str) rescue nil)
+    source_date && source_date > created_date
+  end
+end
+
 def stale_age(rec)
   return nil if rec[:created].nil? || rec[:created].empty?
   (today - Date.parse(rec[:created])).to_i
@@ -274,13 +319,13 @@ def disposition_of(type, quadrant)
   end
 end
 
-def classify(rec, done_ids, referenced = {})
+def classify(rec, done_ids, referenced = {}, completed_on_map = {})
   type = intent_type(rec)
   value = value_of(rec, referenced)
   effort = effort_of(rec, type)
   quadrant = QUADRANTS[[value, effort]]
   disposition = disposition_of(type, quadrant)
-  flags = flags_of(rec, done_ids)
+  flags = flags_of(rec, done_ids, completed_on_map)
   rec.merge(
     type: type, value: value, effort: effort, quadrant: quadrant,
     lifecycle: lifecycle_stage(rec), flags: flags, disposition: disposition,
@@ -329,6 +374,13 @@ end
 
 CELL_CAP = 6
 
+# Markdown-board caps (Task 5, D6/D7): the ASCII renderer already caps via CELL_CAP/
+# cap_cell, but the Markdown board's matrix_data quadrants and the project board's
+# active/future lists had no cap and no per-line truncation, so a large store printed
+# hundreds of full-length lines. These two constants fix that on the Markdown side only.
+MATRIX_DATA_CAP = 8
+INTENT_LINE_MAX_CHARS = 120
+
 def matrix(records, scope_tag: false)
   cells = { "quick_win" => [], "next_big" => [], "defer" => [], "triage" => [] }
   research = []
@@ -526,8 +578,23 @@ end
 
 def intent_line(rec, bullet)
   note = rec[:status] == "active" ? " (#{rec[:lifecycle].to_s.capitalize})" : ""
+  text = rec[:intent].to_s
+  text = "#{text[0, INTENT_LINE_MAX_CHARS]}…" if text.length > INTENT_LINE_MAX_CHARS
   { id: rec[:id], intent: rec[:intent], created: rec[:created], bullet: bullet,
-    scope: rec[:scope], line: "#{bullet} #{rec[:id]} #{rec[:intent]}#{note}".rstrip }
+    scope: rec[:scope], line: "#{bullet} #{rec[:id]} #{text}#{note}".rstrip }
+end
+
+# Cap a raw record list to MATRIX_DATA_CAP entries, then map to intent_line-shaped
+# hashes, appending a plain "+N more" line (no id, not a real record) when truncated.
+# Caps the record list first so the "+N more" entry never goes through intent_line.
+def cap_lines(list, bullet)
+  capped = list.first(MATRIX_DATA_CAP)
+  lines = capped.map { |r| intent_line(r, bullet) }
+  if list.size > MATRIX_DATA_CAP
+    lines << { id: "", intent: "", created: "", bullet: bullet, scope: "",
+               line: "#{bullet} +#{list.size - MATRIX_DATA_CAP} more" }
+  end
+  lines
 end
 
 def matrix_data(records)
@@ -539,8 +606,8 @@ def matrix_data(records)
   end
   by_created_desc = ->(list) { list.sort_by { |r| invert_ts(r[:created]) } }
   out = {}
-  cells.each { |q, list| out[q] = by_created_desc.call(list).map { |r| intent_line(r, QUADRANT_BULLET[q]) } }
-  out["research"] = by_created_desc.call(research).map { |r| intent_line(r, "🔬") }
+  cells.each { |q, list| out[q] = cap_lines(by_created_desc.call(list), QUADRANT_BULLET[q]) }
+  out["research"] = cap_lines(by_created_desc.call(research), "🔬")
   out
 end
 
@@ -606,12 +673,10 @@ def render_data_project(records, slug)
     recently_worked: recently_worked(records, project_scope: scope),
     matrix: matrix_data(matrix_pool),
     counts: counts_of(scoped),
-    active: scoped.select { |r| r[:status] == "active" }
-                  .sort_by { |r| invert_ts(r[:last_accessed_at]) }
-                  .map { |r| intent_line(r, STATUS_GLYPH["active"]) },
-    future: scoped.select { |r| r[:status] == "future" }
-                  .sort_by { |r| invert_ts(r[:created]) }
-                  .map { |r| intent_line(r, STATUS_GLYPH["future"]) } }
+    active: cap_lines(scoped.select { |r| r[:status] == "active" }
+                            .sort_by { |r| invert_ts(r[:last_accessed_at]) }, STATUS_GLYPH["active"]),
+    future: cap_lines(scoped.select { |r| r[:status] == "future" }
+                            .sort_by { |r| invert_ts(r[:created]) }, STATUS_GLYPH["future"]) }
 end
 
 # ---------------------------------------------------------------------------
@@ -645,8 +710,8 @@ def main(argv)
   mode = argv.shift || "continue"
   slug = argv.shift
 
-  raw, done_ids, referenced = load_all
-  records = raw.map { |r| classify(r, done_ids, referenced) }
+  raw, done_ids, referenced, completed_on_map = load_all
+  records = raw.map { |r| classify(r, done_ids, referenced, completed_on_map) }
 
   if data
     payload = mode == "project" ? render_data_project(records, slug) : render_data_global(records)

package/scripts/hook-continue

@@ -7,6 +7,7 @@
 
 require "json"
 require "open3"
+require_relative "lib/dashboard_banner"
 
 index_path, _store_root, _mode = ARGV
 exit 0 unless index_path && File.exist?(index_path)
@@ -28,4 +29,20 @@ payload = {
     "additionalContext" => context
   }
 }
+
+# Hook-owned systemMessage floor (intent 125, Task 6): a hard fallback summary
+# independent of the agent's reply, mirroring hook-session-start's BootBanner
+# pattern. Best-effort only — any failure here (subprocess, JSON, renderer)
+# degrades silently, omitting systemMessage; this hook must never crash
+# UserPromptSubmit over a summary line.
+begin
+  data_json, _data_err, data_status = Open3.capture3("ruby", dashboard, "continue", "--data")
+  if data_status.success?
+    banner = DashboardBanner.render(JSON.parse(data_json))
+    payload["systemMessage"] = banner if banner
+  end
+rescue StandardError
+  nil
+end
+
 puts JSON.generate(payload)

package/scripts/lib/bridge.rb

@@ -45,8 +45,18 @@ module Bridge
     (t.nil? || t.strip.empty?) ? "/tmp" : t
   end
 
-  def self.path(session, tmp: tmp_dir)
-    "#{tmp}/plastic-#{session}.json"
+  # Per-intent bridge key (intent 131): `plastic-<session>--<intent_id>.json`
+  # when intent_id is present, else the legacy single-key
+  # `plastic-<session>.json`. The per-intent key is what lets two concurrent
+  # deliveries under ONE session id keep separate bridge files instead of
+  # clobbering a shared one; the legacy form is still produced (and read) when
+  # no intent_id is given, so old single-key files stay valid.
+  def self.path(session, intent_id: nil, tmp: tmp_dir)
+    if blank?(intent_id)
+      "#{tmp}/plastic-#{session}.json"
+    else
+      "#{tmp}/plastic-#{session}--#{intent_id}.json"
+    end
   end
 
   # --- Session resolution (intent 52) ----------------------------------------
@@ -123,15 +133,46 @@ module Bridge
     data.is_a?(Hash) && !blank?(data["session"]) && data["intent"].is_a?(Hash)
   end
 
-  # Resolve the active bridge. Exact-session lookup first; otherwise scan tmp:
-  # for plastic-*.json, keep only valid bridges, prefer auto-armed, then prefer
-  # the one whose intent.store matches cwd, tie-break by newest mtime.
-  def self.discover_bridge(session:, cwd: Dir.pwd, tmp: tmp_dir)
-    if !blank?(session) && File.exist?(path(session, tmp: tmp))
-      exact = read(session, tmp: tmp)
-      return exact if bridge_valid?(exact)
+  # Tiered cwd discriminator for one bridge candidate (intent 131). A session
+  # now owns SEVERAL bridges (one per concurrent intent), so the discriminator
+  # that used to be "cwd overlaps intent.store" is too coarse: every sibling
+  # under the same store shares it. worktree.code is the only field that
+  # differs between siblings, so it is the strongest signal; the intent dir is
+  # next; the shared store is a last-resort coarse tie.
+  #   2 - cwd is the intent's provisioned code worktree (or under it)
+  #   1 - cwd is the intent's own dir (or under it)
+  #   0 - cwd merely overlaps the intent's store (shared by every sibling)
+  #  -1 - no signal at all
+  def self.bridge_cwd_tier(data, cwd_abs)
+    worktree_code = data.dig("worktree", "code")
+    if !blank?(worktree_code)
+      wc_abs = File.expand_path(worktree_code)
+      return 2 if cwd_abs == wc_abs || cwd_abs.start_with?("#{wc_abs}/")
+    end
+
+    dir_abs = bridge_intent_dir(data)
+    if dir_abs
+      return 1 if cwd_abs == dir_abs || cwd_abs.start_with?("#{dir_abs}/")
+    end
+
+    store = data.dig("intent", "store").to_s
+    unless store.empty?
+      store_abs = File.expand_path(store)
+      return 0 if cwd_abs == store_abs || cwd_abs.start_with?("#{store_abs}/") ||
+                  store_abs.start_with?("#{cwd_abs}/")
     end
 
+    -1
+  end
+
+  # Resolve the active bridge: scan tmp for plastic-*.json (both per-intent and
+  # legacy-keyed files), keep only valid bridges, filter to the caller's own
+  # session when it has one, prefer auto-armed, then disambiguate by cwd tier
+  # (see bridge_cwd_tier), tie-break by newest mtime. No exact-session fast
+  # path: a session now legitimately owns several bridges (one per concurrent
+  # intent), so filename lookup alone cannot pick the right one; cwd must
+  # decide (intent 131).
+  def self.discover_bridge(session:, cwd: Dir.pwd, tmp: tmp_dir)
     candidates = Dir.glob(File.join(tmp, "plastic-*.json")).reject { |f| f.end_with?(".tmp") }
     parsed = candidates.filter_map do |f|
       data = (JSON.parse(File.read(f)) rescue nil)
@@ -156,26 +197,34 @@ module Bridge
       return nil if parsed.empty?
     end
 
+    # Auto-preference pool: a build-armed bridge is preferred over a merely
+    # derived one, but ONLY as a fallback when cwd cannot decide (below). cwd
+    # must win over auto-preference, so this pool is not applied before the
+    # cwd tiering (intent 131: a guided sibling in the caller's own worktree
+    # must beat an auto sibling in another worktree).
     auto = parsed.select { |c| c[:data].dig("build", "auto") == true }
-    pool = auto.empty? ? parsed : auto
+    auto_pool = auto.empty? ? parsed : auto
 
     unless blank?(cwd)
       cwd_abs = File.expand_path(cwd)
-      matching = pool.select do |c|
-        store = c[:data].dig("intent", "store").to_s
-        next false if store.empty?
-        store_abs = File.expand_path(store)
-        cwd_abs == store_abs ||
-          cwd_abs.start_with?("#{store_abs}/") ||
-          store_abs.start_with?("#{cwd_abs}/")
+      # Tier the FULL session pool by cwd BEFORE the auto-preference filter.
+      # When cwd overlaps ANY candidate (tier >= 0) it decides outright, even
+      # against a newer or auto-armed sibling: worktree.code (tier 2) and the
+      # intent dir (tier 1) disambiguate same-store siblings (intent 131), and
+      # a store overlap (tier 0) still selects the overlapping bridge over an
+      # off-cwd one in another store (the intent 90/52 store filter, preserved).
+      # Only when NO candidate overlaps cwd (max tier -1) do we fall through to
+      # the auto-preference pool and newest mtime, so a lone armed bridge
+      # off-cwd still resolves (intent 52 headless).
+      tiered = parsed.map { |c| [bridge_cwd_tier(c[:data], cwd_abs), c] }
+      max_tier = tiered.map(&:first).max
+      if max_tier && max_tier >= 0
+        winners = tiered.select { |tier, _| tier == max_tier }.map { |_, c| c }
+        return winners.max_by { |c| c[:mtime] }&.fetch(:data)
       end
-      # Hard cwd filter when the caller has a session (intent 90): a non-matching store
-      # excludes the candidate outright. Without a session, keep the best-effort revert
-      # (intent 52) so a lone armed bridge is still found when cwd does not overlap its store.
-      pool = has_session ? matching : (matching.empty? ? pool : matching)
     end
 
-    pool.max_by { |c| c[:mtime] }&.fetch(:data)
+    auto_pool.max_by { |c| c[:mtime] }&.fetch(:data)
   end
 
   # --- Terminal-state bridge purge (intent 80) -------------------------------
@@ -221,10 +270,16 @@ module Bridge
   # arm_auto and disarm_auto so both manual and auto delivery keep the temp dir
   # clean at deterministic work boundaries.
   def self.purge_done_bridges(session:, tmp: tmp_dir)
-    current = path(session, tmp: tmp)
+    # Own-bridge predicate (intent 131): a session now legitimately owns
+    # SEVERAL bridges (one per concurrent intent), so "current" is no longer
+    # one filename. Skip the legacy single-key file for this session AND every
+    # per-intent-keyed file for this session; none of the session's own live
+    # bridges may be reaped mid-run.
+    own_legacy_name = File.basename(path(session, tmp: tmp))
+    own_prefix = "plastic-#{session}--"
     removed = []
     Dir.glob(File.join(tmp, "plastic-*.json")).each do |f|
-      next if f == current
+      next if File.basename(f) == own_legacy_name || File.basename(f).start_with?(own_prefix)
       begin
         data = JSON.parse(File.read(f)) rescue nil
         keep = false
@@ -256,17 +311,35 @@ module Bridge
     removed || []
   end
 
-  def self.read(session, tmp: tmp_dir)
-    p = path(session, tmp: tmp)
-    return nil unless File.exist?(p)
-    JSON.parse(File.read(p))
+  # Try the per-intent path first; when it is absent and an intent_id was
+  # given, fall back to the legacy single-key path (migration + legacy
+  # tolerance, intent 131): a live `plastic-<session>.json` from before this
+  # intent keeps resolving during the transition. The legacy fallback is
+  # honored for a specific intent_id ONLY when the legacy file actually carries
+  # that intent (or carries none), so a caller asking for intent A never acts
+  # on a legacy file that still holds sibling B.
+  def self.read(session, intent_id: nil, tmp: tmp_dir)
+    p = path(session, intent_id: intent_id, tmp: tmp)
+    return JSON.parse(File.read(p)) if File.exist?(p)
+    return nil if blank?(intent_id)
+    legacy = path(session, tmp: tmp)
+    return nil unless File.exist?(legacy)
+    data = JSON.parse(File.read(legacy))
+    id = data.is_a?(Hash) ? data.dig("intent", "id") : nil
+    (blank?(id) || id.to_s == intent_id.to_s) ? data : nil
   rescue JSON::ParserError
     nil
   end
 
+  # Self-keying (intent 131): the file `write` targets is derived from
+  # `data.dig("intent", "id")`, not a caller-supplied intent_id, so every
+  # existing `write(session, data)` call site keys itself correctly for free
+  # as long as `data["intent"]["id"]` is set (arm/derive/disarm_auto/
+  # repair_lock/hook-gate-check/plastic-lock all carry it).
   def self.write(session, data, tmp: tmp_dir)
     raise ArgumentError, "bridge session must be present" if blank?(session)
-    p = path(session, tmp: tmp)
+    intent_id = data.is_a?(Hash) ? data.dig("intent", "id") : nil
+    p = path(session, intent_id: intent_id, tmp: tmp)
     # Atomic write: tmp file + rename to prevent partial reads
     tmp_file = "#{p}.tmp.#{Process.pid}"
     File.write(tmp_file, JSON.pretty_generate(data.merge("updated_at" => Time.now.utc.iso8601)))
@@ -709,13 +782,31 @@ module Bridge
     arm(session, intent_id: intent_id, intent_dir: intent_dir, store: store, name: name, auto: false)
   end
 
+  # Degrade path for disarm_auto when no intent_id is given (intent 131): the
+  # session's sole per-intent bridge when there is exactly one, else the
+  # legacy single-key file. Keeps the common single-intent auto path working
+  # without every caller having to name the intent id explicitly.
+  def self.sole_bridge_data(session, tmp: tmp_dir)
+    matches = Dir.glob(File.join(tmp, "plastic-#{session}--*.json")).reject { |f| f.end_with?(".tmp") }
+    if matches.length == 1
+      data = (JSON.parse(File.read(matches.first)) rescue nil)
+      return data if data
+    end
+    read(session, tmp: tmp)
+  end
+
   # Disarm. No-op if no bridge exists for the session. End-tail order (D6):
   # worktrees are merged/removed FIRST (the verify step is the caller's,
   # before disarm), then the delivery lock is cleared, and only then does the
   # bridge become purge-eligible. purge_done_bridges enforces the same order
   # defensively by skipping any bridge whose intent still holds a lock.
-  def self.disarm_auto(session)
-    data = read(session)
+  #
+  # Now takes intent_id (intent 131): a session can own SEVERAL live bridges
+  # (one per concurrent intent), so disarm must target ONE of them. When
+  # intent_id is nil, degrades to the session's sole bridge (see
+  # sole_bridge_data) so the common single-intent path keeps working.
+  def self.disarm_auto(session, intent_id: nil)
+    data = blank?(intent_id) ? sole_bridge_data(session) : read(session, intent_id: intent_id)
     return nil unless data
     data["build"] ||= {}
     data["build"]["auto"] = false
@@ -783,7 +874,7 @@ module Bridge
       actions << "lock #{status}"
     end
 
-    previous = read(key, tmp: tmp)
+    previous = read(key, intent_id: intent_id, tmp: tmp)
     auto = !!(previous && previous.dig("build", "auto"))
     data = derive(key, intent_id: intent_id, intent_dir: dir, store: store,
                   name: name, tmp: tmp)

package/scripts/lib/dashboard_banner.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Renders a one-line dashboard summary for the hook-owned systemMessage floor
+# (intent 125, Task 6). Pure and dependency-injected, mirroring BootBanner: it
+# takes the already-parsed `dashboard.rb continue --data` JSON payload and
+# returns a single line, with no file I/O and no subprocess calls in here, so
+# it is unit-testable in isolation while the hook feeds it real data.
+module DashboardBanner
+  module_function
+
+  # payload: the Hash from JSON.parse(`dashboard.rb continue --data`), or nil
+  #          when the subprocess call failed or produced unusable JSON.
+  #
+  # Returns a single summary line, or nil when the payload has nothing usable
+  # (the caller degrades silently in that case, omitting systemMessage).
+  def render(payload)
+    return nil unless payload.is_a?(Hash)
+    counts = payload["counts"]
+    return nil unless counts.is_a?(Hash)
+    active = counts["active"].to_i
+    future = counts["future"].to_i
+    line = "Plastic: #{active} active · #{future} next · run /plastic-dashboard to see the board"
+    nbt = next_big_thing_id(payload)
+    line += " · next big thing: #{nbt}" if nbt
+    line
+  end
+
+  # The id of the top-ranked next_big candidate, when the payload's matrix carries
+  # exactly the shape dashboard.rb emits (a "next_big" list of {id, ...} hashes,
+  # already rank-sorted). Returns nil for any other shape rather than raising.
+  def next_big_thing_id(payload)
+    matrix = payload["matrix"]
+    return nil unless matrix.is_a?(Hash)
+    list = matrix["next_big"]
+    return nil unless list.is_a?(Array) && !list.empty?
+    top = list.first
+    return nil unless top.is_a?(Hash)
+    id = top["id"].to_s
+    id.empty? ? nil : id
+  end
+end

package/scripts/lib/installer_core.rb

@@ -224,6 +224,7 @@ class InstallerCore
       "scripts/lib/insights.rb" => "scripts/lib/insights.rb",
       "scripts/lib/worktree.rb" => "scripts/lib/worktree.rb",
       "scripts/lib/boot_banner.rb" => "scripts/lib/boot_banner.rb",
+      "scripts/lib/dashboard_banner.rb" => "scripts/lib/dashboard_banner.rb",
       "scripts/lib/qmd_sync.rb" => "scripts/lib/qmd_sync.rb",
       "scripts/qmd-sync" => "scripts/qmd-sync",
       "scripts/lib/intent_validator.rb" => "scripts/lib/intent_validator.rb",

package/scripts/plastic-lock

@@ -72,7 +72,7 @@ key = Bridge.resolve_session(session, intent_id: intent_id, store: store)
 case verb
 when "status"
   lock = Lock.read(dir)
-  bridge = Bridge.read(key)
+  bridge = Bridge.read(key, intent_id: intent_id)
   report = {
     "intent_dir" => dir,
     "session" => key,
@@ -100,7 +100,7 @@ when "release"
     warn "plastic-lock: not the owner; run plastic-lock status"
     exit 1
   end
-  data = Bridge.read(key)
+  data = Bridge.read(key, intent_id: intent_id)
   if data
     data["lock"] = { "owner_session" => nil, "acquired_at" => nil,
                      "host" => nil, "type" => nil, "delegates" => [] }

package/scripts/update.rb

@@ -53,18 +53,22 @@ class Update < InstallerCore
       end
       puts "\u{2b06}\u{fe0f}  Updating Plastic #{iv} \u{2192} #{res[:target]}"
       exit_code = perform_switch(res[:target], agent_args(argv))
-      run_post_update_doctor if exit_code == 0
+      run_post_update_doctor(full: argv.include?("--full-doctor")) if exit_code == 0
       exit_code
     end
   end
 
-  # Run the full doctor after a successful update and print a human-readable
-  # summary. Informational only: does not raise and does not affect the update's
-  # exit code. Accepts injected `doctor` and `out` for hermetic unit tests.
-  def run_post_update_doctor(doctor: nil, out: $stdout)
+  # Run doctor after a successful update and print a human-readable summary.
+  # Defaults to the fast core tier (agent registration + core files + manifest
+  # sync, binary pass|fail, no store walk) so a newcomer's first post-update
+  # run is not buried in convention warns they cannot act on. `full: true`
+  # (via `--full-doctor`) runs the complete store walk instead. Informational
+  # only: does not raise and does not affect the update's exit code. Accepts
+  # injected `doctor` and `out` for hermetic unit tests.
+  def run_post_update_doctor(doctor: nil, out: $stdout, full: false)
     doctor ||= Doctor.new
-    out.puts "\nRunning full doctor after update..."
-    result = doctor.run_checks("claude")
+    out.puts full ? "\nRunning full doctor after update..." : "\nRunning core doctor after update..."
+    result = full ? doctor.run_checks("claude") : doctor.run_core_checks("claude")
     s = result[:summary]
     out.puts "  Doctor status: #{result[:status]} " \
              "(pass: #{s[:pass]}, warn: #{s[:warn]}, fail: #{s[:fail]}, total: #{s[:total]})"
@@ -152,6 +156,11 @@ class Update < InstallerCore
       Agent options (default: --claude):
         --claude --codex --hermes --all
 
+      Post-update doctor:
+        By default, a successful update runs the fast core doctor sync (agent
+        registration, core files, manifest — binary pass|fail, no store walk).
+        --full-doctor   Run the full doctor (complete store walk) after updating.
+
       Behaviour:
         No flag advances to the next version on your current channel. Switching toward a
         more stable channel is frictionless; switching toward bleeding edge is confirmed.

package/skills/auto/SKILL.md

@@ -275,9 +275,11 @@ During initial project creation, all decisions are non-destructive by definition
    ```
    (Use `"abandoned"` instead when the intent is being moved to `## Abandoned`.) Idempotent.
 7. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: deliver intent <ID> — <name>"`
-8. Disarm the lifecycle gate (auto delivery is finished):
+8. Disarm the lifecycle gate (auto delivery is finished). Substitute the intent's own id for
+   `<ID>` (a session can be delivering more than one intent at once, intent 131, so disarm must
+   name which of the session's bridges to clear):
    ```bash
-   ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.disarm_auto(ENV["CLAUDE_CODE_SESSION_ID"])'
+   ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.disarm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>")'
    ```
    Disarm runs the ordered End tail: it releases the worktrees first, then clears the
    intent's `delivery.lock` (and the bridge's lock cache), and only then is the bridge

package/skills/continuing/SKILL.md

@@ -38,7 +38,11 @@ here — run the data payload and fill + present the matching template:
 - Otherwise → `ruby ~/.plastic/scripts/dashboard.rb continue --data`
 
 Fill the matching template from this skill's `templates/` and **present the filled Markdown
-in your reply** (every time). See `plastic-dashboard` for the fill rules and entry flow.
+in your reply** (every time, non-optional). If the reply does not contain the filled Markdown,
+the user sees nothing — tool-call stdout and hook `additionalContext` are both invisible to
+them. `hook-continue` also emits a one-line `systemMessage` summary as a hook-owned fallback;
+treat it as a floor only, never as a substitute for presenting the full board here. See
+`plastic-dashboard` for the fill rules and entry flow.
 
 The board load runs the scoped store check on every load (`doctor --store <scope>`): the
 global board runs `--store global` and a project board runs `--store <slug>`. The result

package/skills/dashboard/SKILL.md

@@ -61,9 +61,17 @@ Fill mechanically — no rewriting, no re-sorting:
 
 ### Step 3 — Present it (mandatory, every invocation)
 
-**Paste the filled Markdown into your reply.** This is non-optional: the board only reaches
-the user when it is in the chat reply, not in tool-call stdout. Never describe the board
-instead of showing it.
+**Paste the filled Markdown into your reply.** This is non-optional: if the reply does not
+contain the filled Markdown, the user sees nothing — tool-call stdout and hook
+`additionalContext` are both invisible to them. Never describe the board instead of showing
+it, and never assume a hook already showed it for you.
+
+`hook-continue` also emits a one-line `systemMessage` summary (counts, and the next big thing
+when there is one) as a hook-owned fallback, independent of the agent's reply. Treat that line
+as a floor only, not a substitute for this step: it carries no matrix, no recently-worked
+section, and no entry-flow prompt. Presenting the full board here remains mandatory regardless
+of whether the summary line fired. This stays a soft, agent-followed mechanism — there is no
+stronger enforcement for a full multi-section Markdown document in this harness today.
 
 ### Step 4 — Entry flow (the board is the menu)
 
@@ -103,13 +111,22 @@ a raw terminal. The Markdown board (`--data` + template) is the surface for the
 ## How classification works (deterministic)
 
 - **Effort** — small for `research`/`exploration`/`bugfix`, for already-scoped intents
-  (plan/checklist exists), or deep refinement branches; big otherwise.
-- **Value → high** when any of: explicit `value: high`; a human-authored **root** intent; an
-  intent with a non-empty `chain`; or an intent that is a `source` of ≥1 other intent. Else low.
-- **Flags** — `unblocked` only when a **future** intent has **all** its `sources` done;
-  `stale` only on future intents past the staleness threshold. Both kept low-noise by design.
+  (plan/checklist exists), or a **branch id** (folgezettel depth ≥ 2, e.g. `4a`, `12b3`); big
+  otherwise. A root id (a bare number) is always depth 1, so it is never demoted by this rule.
+- **Value → high** when any of: explicit `value: high`; a human-authored **root** intent; or
+  an intent that is a `source` of ≥1 other intent (it has spawned follow-on work). A purely
+  relational `chain` entry alone is **not** a value signal (intent 68) — else low.
+- **Flags** — `unblocked` only when a **future** intent has **all** its `sources` done AND at
+  least one source's completion date is strictly later than the intent's own `created` date (a
+  genuine wait, not a birth-time default); `in-progress` only when the savepoint ledger shows
+  real post-birth activity, not just the creation stamp; `stale` only on future intents past
+  the staleness threshold. All three kept low-noise by design.
 - **Override** — a `value: high|low` frontmatter field always wins (pre-stamped data, never
   model judgment at render time).
+- **Caps** — quadrant lists and the project board's `active`/`future` lists are capped at 8
+  entries plus a trailing "+N more" line; each entry's text is truncated to 120 characters
+  with a trailing ellipsis. Applies to the Markdown board only (the ASCII renderer has its own
+  separate `CELL_CAP`).
 
 ## Eval
 

package/skills/releasing/SKILL.md

@@ -243,9 +243,12 @@ from the bridge:
 
 ```bash
 ruby -r ~/.plastic/scripts/lib/worktree -r ~/.plastic/scripts/lib/bridge -e \
-  'b = Bridge.read(ENV["CLAUDE_CODE_SESSION_ID"]); Worktree.finish(b, merge: true) if b'
+  'b = Bridge.discover_bridge(session: ENV["CLAUDE_CODE_SESSION_ID"], cwd: Dir.pwd); Worktree.finish(b, merge: true) if b'
 ```
 
+(Uses `discover_bridge`, not a bare session-keyed `Bridge.read`, because a session can own more
+than one live bridge now — intent 131 — and `discover_bridge` resolves the right one for this cwd.)
+
 `finish` is fail-open and idempotent: a conflicting merge is aborted and logged (the worktree
 is still removed rather than stranded), and a second call with the block already cleared is a
 no-op. Honor the worktree-cleanup rule: never leave an orphaned worktree, and run `git worktree

package/skills/roadmap/SKILL.md

@@ -6,9 +6,11 @@ description: Use when the user wants to plan a delivery batch, order waves of in
 # Roadmap
 
 A roadmap is a named, ordered, delivery-side collection of intents: the delivery-side counterpart
-to a release (completion-side, `CHANGELOG.md`). It lives at `roadmaps/{slug}.md`, a store-root
-sibling of `INDEX.md`, in both the global store (`~/.plastic/store/`) and any project store
-(`~/.plastic/projects/{slug}/store/`).
+to a release (completion-side, `CHANGELOG.md`). It lives at `roadmaps/{slug}.md`, a sibling of
+`INDEX.md` wherever `INDEX.md` lives: the global tier's `~/.plastic/roadmaps/` (beside
+`~/.plastic/INDEX.md`), or a project's root, `~/.plastic/projects/{slug}/roadmaps/` (beside that
+project's `INDEX.md` and `project.yml`). It never sits inside `store/`, which holds intent
+directories, not project artifacts.
 
 A roadmap file has four parts: a title/meta header, `## Goal` (prose), `## Waves` (ordered; entries
 inside a wave are parallel-safe, waves run sequentially), and an append-only dated `## Log`. Each
@@ -37,8 +39,9 @@ verb above.
 
 ## Notes
 
-- File location and the four-section shape are identical across stores; do not invent a different
-  layout per project.
+- File location and the four-section shape are identical across tiers; do not invent a different
+  layout per project. The general rule: `roadmaps/` is a sibling of `INDEX.md`, wherever `INDEX.md`
+  lives.
 - `## Goal` is a checkable prose condition read by a human or agent, not an executable checker.
 - Wave entries render as checkboxes (`- [x] ... — delivered` / `- [ ] ... — <status>`); a human
   reading cold should see shipped/running/next within a minute. `## Log` lines are one-sentence,

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

@@ -2,10 +2,12 @@
 
 ## Location
 
-`roadmaps/{slug}.md`, a store-root sibling of `INDEX.md`. Same layout in the global store
-(`~/.plastic/store/roadmaps/{slug}.md`) and any project store
-(`~/.plastic/projects/{slug}/store/roadmaps/{slug}.md`). Create the `roadmaps/` directory the
-first time a store gets a roadmap.
+`roadmaps/{slug}.md`, a sibling of `INDEX.md`, wherever `INDEX.md` lives. For the global tier
+that is `~/.plastic/roadmaps/{slug}.md` (beside `~/.plastic/INDEX.md`); for any project it is
+that project's root, `~/.plastic/projects/{slug}/roadmaps/{slug}.md` (beside that project's
+`INDEX.md` and `project.yml`). `roadmaps/` never sits inside `store/`: `store/` holds intent
+directories, not project artifacts. Create the `roadmaps/` directory the first time a tier gets a
+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
@@ -14,7 +16,7 @@ its file moves to `roadmaps/archived/{slug}.md` (see Close/archive in `operation
 ## The four sections (in order)
 
 1. **Title/meta header** — `# Roadmap: <name>` plus a one-line meta sentence naming what the
-   roadmap delivers and which store it lives in.
+   roadmap delivers and which tier (project or global) it lives in.
 2. **`## Goal`** — a checkable prose condition: one or a few sentences a human or coordinator reads
    to decide the roadmap is done. Not an executable checker, not a list of tasks.
 3. **`## Waves`** — ordered waves (`### Wave 1`, `### Wave 2`, ...). Entries inside a wave are
@@ -49,12 +51,13 @@ it. The roadmap never sets a status that INDEX does not already reflect.
 
 ## Log line shape
 
-One line per event, dated, in plain-language EM-to-CTO voice: what shipped and why it matters to a
-non-expert reader, no jargon or internal codenames, ending with a link to that entry-intent's
-`outcome.md`:
+One line per event, starting `YYYY-MM-DD HH:MM UTC` (human-readable, sortable, zone-explicit so
+same-day parallel deliveries can still be ordered), in plain-language EM-to-CTO voice: what shipped
+and why it matters to a non-expert reader, no jargon or internal codenames, ending with a link to
+that entry-intent's `outcome.md`:
 
 ```
-- <YYYY-MM-DD> <one plain-language sentence: what shipped, its impact> — see store/<id>--<slug>/outcome.md
+- <YYYY-MM-DD HH:MM UTC> <one plain-language sentence: what shipped, its impact> — see store/<id>--<slug>/outcome.md
 ```
 
 The log line never restates `outcome.md` detail; it points at it (lossless-by-reference). This
@@ -83,6 +86,6 @@ abandoned | blocked); INDEX wins on any conflict.
 - [x] 124 Roadmap feature — delivered
 
 ## Log
-- 2026-07-06 Shipped the bash-gate redirect fix so quoted arrows and heredoc trailers stop
-  blocking legitimate commits — see store/121--fix-bash-gate-redirect-parsing/outcome.md.
+- 2026-07-06 14:32 UTC Shipped the bash-gate redirect fix so quoted arrows and heredoc trailers
+  stop blocking legitimate commits — see store/121--fix-bash-gate-redirect-parsing/outcome.md.
 ```

package/skills/roadmap/references/operations.md

@@ -10,14 +10,16 @@ next" in under a minute, just from this one file.
 ## Create
 
 1. Pick a `slug` (kebab-case, descriptive) and a `title`.
-2. Resolve the store root (global `~/.plastic/store/` or the current project's
-   `~/.plastic/projects/{slug}/store/`); create `roadmaps/` inside it if it does not exist yet.
+2. Resolve the tier root: the directory that holds `INDEX.md` (a project's root, beside
+   `project.yml`, or `~/.plastic/` for the global tier). `roadmaps/` is always a sibling of
+   `INDEX.md`, never inside `store/`. Create `roadmaps/` there if it does not exist yet.
 3. Copy `templates/roadmap.md` to `roadmaps/{slug}.md`.
 4. Fill the header (`# Roadmap: <title>` + the one-line meta) and write a real `## Goal` prose
    condition.
 5. Add at least one `## Waves` wave with real entries (see Add / reorder below), each entry's
    status mirroring that intent's current `INDEX.md` status.
-6. Append the first `## Log` line, a short dated plain-language note that the roadmap was created.
+6. Append the first `## Log` line, a short `YYYY-MM-DD HH:MM UTC`-prefixed plain-language note
+   that the roadmap was created.
 
 ## Add / reorder entries
 
@@ -29,7 +31,7 @@ next" in under a minute, just from this one file.
   entries) earlier or later. Reordering never changes an entry's status; it only changes when the
   entry is eligible to run.
 - After any add/reorder, append a `## Log` line describing the change (e.g.
-  `- <YYYY-MM-DD> added 132 to wave 2`).
+  `- <YYYY-MM-DD HH:MM UTC> added 132 to wave 2`).
 
 ## Sync status mirror
 
@@ -46,8 +48,8 @@ next" in under a minute, just from this one file.
 
 ## Append a log line
 
-- One line per event, dated `YYYY-MM-DD`, appended at the bottom of `## Log`. Never edit or delete
-  an existing line (append-only).
+- One line per event, starting `YYYY-MM-DD HH:MM UTC`, appended at the bottom of `## Log`. Never
+  edit or delete an existing line (append-only).
 - Every line is plain language a non-expert can read, never a codename or a raw `field -> value`.
   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
@@ -68,7 +70,9 @@ next" in under a minute, just from this one file.
 
 1. Confirm the roadmap's `## Goal` prose condition is met (every entry `delivered` or explicitly
    `abandoned` with a recorded reason, plus whatever else the goal states).
-2. Create `roadmaps/archived/` in the store root if it does not exist yet.
+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: `- <YYYY-MM-DD> roadmap closed`.
+4. Append the final `## Log` line before or as part of the move:
+   `- <YYYY-MM-DD HH:MM UTC> roadmap closed`.

package/templates/roadmap.md

@@ -1,8 +1,9 @@
 # Roadmap: <name>
 
-(one-line meta: what this roadmap delivers, and which store it lives in. When this roadmap's goal
-is reached, move this file from `roadmaps/{slug}.md` to `roadmaps/archived/{slug}.md`; `roadmaps/`
-itself lists only live roadmaps.)
+(one-line meta: what this roadmap delivers, and which tier it lives in. `roadmaps/` is a sibling
+of `INDEX.md` — a project's root or the global `~/.plastic/`, never inside `store/`. When this
+roadmap's goal is reached, move this file from `roadmaps/{slug}.md` to
+`roadmaps/archived/{slug}.md`; `roadmaps/` itself lists only live roadmaps.)
 
 ## Goal
 (a checkable prose condition — one or a few sentences a human or coordinator reads to decide the
@@ -26,4 +27,4 @@ any conflict between the checkbox/token here and INDEX's real status.
 what shipped and its impact for a non-expert reader, no jargon or internal codenames, ending with a
 link to that entry-intent's `outcome.md`. Never restate outcome detail here; link to it instead.
 Newest at the bottom.)
-- 2026-01-01 Shipped the first wave of this roadmap; see store/<intent-id>--<slug>/outcome.md.
+- 2026-01-01 00:00 UTC Shipped the first wave of this roadmap; see store/<intent-id>--<slug>/outcome.md.