@zalom/plastic 1.0.0-beta.33 → 1.0.0-beta.35

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)
@@ -1082,7 +1173,11 @@ module Bridge
       c = line[i]
       case state
       when :single
-        out << " "
+        if c == "'" || c == "<" || c == ">"
+          out << " "
+        else
+          out << c
+        end
         state = :normal if c == "'"
         i += 1
       when :double
@@ -1090,7 +1185,11 @@ module Bridge
           out << "  "
           i += 2
         else
-          out << " "
+          if c == '"' || c == "<" || c == ">"
+            out << " "
+          else
+            out << c
+          end
           state = :normal if c == '"'
           i += 1
         end
@@ -1100,7 +1199,7 @@ module Bridge
         elsif c == '"'
           out << " "; state = :double; i += 1
         elsif c == "<" && line[i + 1] == "<"
-          m = line[i..].match(/\A<<(-?)\s*("|')?([A-Za-z_][A-Za-z0-9_]*)\2?/)
+          m = line[i..].match(/\A<<(-?)\s*("|')?([A-Za-z0-9_][A-Za-z0-9_]*)\2?/)
           if m
             openers << { word: m[3], dash: m[1] == "-" }
             out << (" " * m[0].length)

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

@@ -161,6 +161,37 @@ class InstallerCore
     nums.select { |n| n >= 1 && n <= agents.size }.map { |n| agents[n - 1][:key] }
   end
 
+  # Resolve whether install should keep the user's existing statusline or switch it
+  # to Plastic's. Pure function of (settings file, argv, input, reinstall): no writes,
+  # so it stays fully unit-testable apart from merge_claude_hooks.
+  def statusline_choice(settings_path, argv: [], input: $stdin, reinstall: false)
+    existing_command = read_json_safe(settings_path)&.dig("statusLine", "command").to_s
+    return :plastic if existing_command.empty?
+    return :plastic if existing_command.include?("plastic-")
+
+    idx = argv.index("--statusline")
+    flag = idx && argv[idx + 1]
+    return flag.to_sym if %w[keep plastic].include?(flag)
+
+    return :keep if reinstall
+    return prompt_statusline(input: input) if input.tty?
+
+    :keep
+  end
+
+  def prompt_statusline(input: $stdin)
+    return :keep unless input.tty?
+
+    puts "An existing statusline was found in your settings.\n\n"
+    puts "  1. Keep my statusline (Plastic will not change it)"
+    puts "  2. Switch to Plastic's statusline"
+    puts
+    print "Select (1 or 2, Enter to keep): "
+    answer = input.gets&.strip
+
+    answer == "2" ? :plastic : :keep
+  end
+
   # --- Distribution phase ---
 
   def distribute(mode)
@@ -224,6 +255,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",
@@ -248,6 +280,7 @@ class InstallerCore
       "scripts/lib/store_provisioning.rb" => "scripts/lib/store_provisioning.rb",
       "scripts/provision-project-store" => "scripts/provision-project-store",
       "scripts/lib/installer_core.rb" => "scripts/lib/installer_core.rb",
+      "scripts/lib/preflight.rb" => "scripts/lib/preflight.rb",
       "scripts/install.rb" => "scripts/install.rb",
       "scripts/update.rb" => "scripts/update.rb",
       "scripts/uninstall.rb" => "scripts/uninstall.rb",
@@ -320,7 +353,7 @@ class InstallerCore
     (data["files"] || {}).keys
   end
 
-  def install_for_agent(key, force)
+  def install_for_agent(key, force, argv: [], input: $stdin, reinstall: false)
     config = agent_config(key)
     return { agent: config[:name], success: false, reason: "Unknown agent" } unless config
 
@@ -333,7 +366,7 @@ class InstallerCore
     old_files = manifest_files(manifest_path_for(key, config))
 
     result = case key
-             when "claude" then install_claude(config, force)
+             when "claude" then install_claude(config, force, argv: argv, input: input, reinstall: reinstall)
              when "codex" then install_codex(config, force)
              when "hermes" then install_hermes(config, force)
              end
@@ -362,7 +395,7 @@ class InstallerCore
     removed
   end
 
-  def install_claude(config, force)
+  def install_claude(config, force, argv: [], input: $stdin, reinstall: false)
     hooks_dir = File.join(config[:dir], "hooks")
     skills_root = File.join(config[:dir], "skills")
     plastic_dir = File.join(config[:dir], "plastic")
@@ -405,7 +438,8 @@ class InstallerCore
 
     # Merge hooks + statusline into settings.json (no plugin registration)
     settings_path = File.join(config[:dir], "settings.json")
-    merge_claude_hooks(settings_path)
+    choice = statusline_choice(settings_path, argv: argv, input: input, reinstall: reinstall)
+    merge_claude_hooks(settings_path, choice: choice)
 
     # Write manifest
     manifest_path = File.join(plastic_dir, "manifest.json")
@@ -571,7 +605,7 @@ class InstallerCore
 
   # --- settings.json merge (read-modify-write, never clobber) ---
 
-  def merge_claude_hooks(settings_path)
+  def merge_claude_hooks(settings_path, choice: :plastic)
     settings = read_json_safe(settings_path) || {}
     return if settings.nil?
 
@@ -613,7 +647,7 @@ class InstallerCore
       File.write(File.join(cache_dir, "original-statusline.json"), JSON.pretty_generate(existing_status))
     end
 
-    settings["statusLine"] = { "type" => "command", "command" => "#{hook_dir}/plastic-statusline" }
+    settings["statusLine"] = { "type" => "command", "command" => "#{hook_dir}/plastic-statusline" } if choice == :plastic
 
     # No plugin/marketplace registration: skills are flat personal skills
     # (plastic-<name>/) discovered directly from ~/.claude/skills.

package/scripts/lib/preflight.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "rubygems"
+
+# Pure, dependency-injected pre-flight checks for Plastic's runtime dependencies
+# (intent 38). Takes injected probes (ruby version, node version, git presence,
+# mise presence) and returns a plain decision: ok / fatal plus branded messages.
+#
+# No I/O, no shelling out, no ENV reads here. Callers (scripts/install.rb,
+# bin/plastic.js) own the impure probing and the printing, so this module stays
+# hermetically testable. Voice matches boot_banner.rb (understated, "Plastic ..."
+# prefix); no em-dash, no en-dash in any message.
+module Preflight
+  module_function
+
+  RUBY_FLOOR = "3.0.0"
+  NODE_FLOOR = 18
+  RUBY_PIN = "3.3"
+
+  def check(ruby_version:, node_version:, git_present:, mise_present:)
+    messages = []
+
+    ruby_message = ruby_issue(ruby_version, mise_present)
+    fatal = !ruby_message.nil?
+    messages << ruby_message if ruby_message
+
+    node_message = node_issue(node_version)
+    messages << node_message if node_message
+
+    git_message = git_issue(git_present)
+    messages << git_message if git_message
+
+    { ok: messages.empty?, fatal: fatal, messages: messages }
+  end
+
+  def ruby_issue(ruby_version, mise_present)
+    parsed = safe_version(ruby_version)
+    return nil if parsed && parsed >= safe_version(RUBY_FLOOR)
+
+    lines = []
+    lines << "Plastic needs Ruby #{RUBY_FLOOR} or newer to run its scripts (found #{found(ruby_version)})."
+    lines << "Install a pinned Ruby with mise:"
+    lines << "  curl https://mise.run | sh        # only if mise is not installed yet" unless mise_present
+    lines << "  mise use --global ruby@#{RUBY_PIN}"
+    lines << "Then re-run the Plastic installer."
+    lines.join("\n")
+  end
+
+  def node_issue(node_version)
+    parsed = safe_version(strip_leading_v(node_version))
+    return nil if parsed && parsed >= safe_version(NODE_FLOOR.to_s)
+
+    "Plastic works best on Node #{NODE_FLOOR} or newer (found #{found(node_version)}). " \
+      "Pin it with mise: mise use --global node@25"
+  end
+
+  def git_issue(git_present)
+    return nil if git_present
+
+    "Plastic uses git for its store and worktrees (git was not found). " \
+      "Install git, e.g. macOS: xcode-select --install"
+  end
+
+  def safe_version(str)
+    Gem::Version.new(str.to_s)
+  rescue ArgumentError
+    nil
+  end
+
+  def strip_leading_v(str)
+    str.to_s.strip.sub(/\Av/, "")
+  end
+
+  def found(value)
+    text = value.to_s.strip
+    text.empty? ? "not found" : text
+  end
+end

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/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/doctor/SKILL.md

@@ -3,7 +3,7 @@ name: plastic-doctor
 description: Use when diagnosing Plastic installation health, after updates, or when something seems broken. Runs checks and reports findings with fix options.
 ---
 
-# Doctor — Plastic Health Check
+# Doctor: Plastic Health Check
 
 ## Scopes
 
@@ -67,9 +67,9 @@ Parse the JSON output from stdout. The script is read-only and never modifies
 files. Errors go to stderr.
 
 Exit codes indicate check results, not script failure:
-- `0` — all checks passed
-- `1` — warnings found
-- `2` — failures found
+- `0`: all checks passed
+- `1`: warnings found
+- `2`: failures found
 
 All three exit codes mean the script ran successfully. Do not treat non-zero
 as an error.
@@ -118,7 +118,7 @@ Use the `fix_hint` value to determine the correct action:
 | "Remove stale references from INDEX.md" | Edit INDEX.md to remove ghost references |
 | "Inject the missing required frontmatter field(s)" | Edit the intent's `{ID}--{slug}.md` frontmatter to add the missing key (e.g. `chain: []`) without touching other keys |
 | "Run: provision-project-store {slug}" | Run `provision-project-store <slug>` (or invoke the `plastic-add-project-store` skill) to create the missing store |
-| "Re-run installer" | Run `npx @zalom/plastic@latest --agent` |
+| "Re-run installer" | Run `npx -y @zalom/plastic@<channel> install --agent <agent>` (channel: -alpha->@alpha, -beta->@beta, else @latest) |
 | "Dispatch plastic-intent-curator ... revisions.md ..." | Invoke the `plastic-intent-curator` (or the agent) to relocate the flagged section or ref into the intent's `revisions.md` via move-and-record (one dated, `[rule: <tag>]`-tagged entry per item), per PLASTIC.md > Structural maintenance and revisions.md. For a missing required section, restore or reproject it instead. |
 
 For fixes the agent cannot handle automatically, explain what the user needs
@@ -144,7 +144,7 @@ Show the updated results.
 When invoked from `plastic-update` (not directly by the user):
 
 1. Run the diagnostic script as in Step 1.
-2. If all checks pass: show a single line — **"Health check: all clear."**
+2. If all checks pass, show a single line: **"Health check: all clear."**
 3. If issues are found: show the full report (Steps 3-6).
 
 This keeps the update flow clean when nothing is wrong.