@zalom/plastic 1.0.0-alpha.24 → 1.0.0-alpha.26

package/PLASTIC.md

@@ -184,6 +184,6 @@ Detailed conventions live inside the skills that use them, not in this file.
 | Projects, hubs | `plastic-creating-project` | hubs, project stores |
 | Index maintenance | `plastic-managing-index` | — |
 | Releases, deprecations | `plastic-releasing` | deprecation process |
-| Health diagnostics | `plastic-doctor` | gate enforcement, stuck detection |
+| Health diagnostics | `plastic-doctor` | three scopes: `--core` (binary install-integrity check, runs on SessionStart), `--store [global\|<slug>]` (per-store check, runs on dashboard load), no flag = full check (runs after every update); gate enforcement, stuck detection |
 | Writing agent instructions | `plastic-writing-instructions` | agentskills.io spec |
 | Evaluating skills, evals | `plastic-evaluating-skills` | eval methodology, convention checks |

package/README.md

@@ -114,6 +114,11 @@ Or say "auto" to let the agent handle the full lifecycle autonomously.
 
 All conventions live in `AGENTS.md`, distributed to `~/.plastic/AGENTS.md`
 during installation. Run `plastic-doctor` to check installation health.
+`plastic-doctor --core` runs a binary install-integrity check (compares files
+against the install manifests; pass or error). `plastic-doctor --store` checks
+store state (intents, INDEX sections, conventions) and can be scoped to
+`global` or a project slug. The full `plastic-doctor` runs all checks and is
+run automatically after every update.
 
 ## License
 

package/package.json

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

package/scripts/dashboard.rb

@@ -22,6 +22,7 @@
 require "json"
 require "yaml"
 require "date"
+require_relative "doctor"
 
 PLASTIC_HOME = ENV.fetch("PLASTIC_HOME") { File.join(Dir.home, ".plastic") }
 
@@ -449,6 +450,34 @@ def render_all(records)
   out.join("\n") + "\n"
 end
 
+# ---------------------------------------------------------------------------
+# Store health — runs doctor's scoped store check on dashboard load.
+#
+# Each board load runs `doctor --store <scope>` (global board -> :global,
+# project board -> the slug) and surfaces a compact store-health line in the
+# payload. Invoked IN-PROCESS (Doctor.new + run_store_checks) rather than
+# shelling out: it is hermetic for tests (same PLASTIC_HOME), faster (no second
+# Ruby boot), and avoids parsing a subprocess's JSON. Non-fatal by contract: a
+# warn/fail result is data only and never crashes the board or changes its exit.
+# ---------------------------------------------------------------------------
+
+def store_health(scope)
+  result = Doctor.new(plastic_home: PLASTIC_HOME).run_store_checks(scope)
+  failing = (result[:checks] || []).reject { |c| c[:status] == "pass" }
+                                   .map { |c| c[:name] }
+  {
+    scope: scope.is_a?(Symbol) ? scope.to_s : scope,
+    status: result[:status],
+    summary: result[:summary],
+    failing_checks: failing,
+  }
+rescue StandardError => e
+  # Never let a store-health probe take down the dashboard.
+  { scope: scope.is_a?(Symbol) ? scope.to_s : scope,
+    status: "warn", summary: { pass: 0, warn: 1, fail: 0, total: 1 },
+    failing_checks: ["store_health_probe_error"], error: e.message }
+end
+
 # ---------------------------------------------------------------------------
 # Markdown-board data payload (intent 37) — heavy side; the skill fills a
 # Markdown template from this and presents it. Deterministic, golden-tested.
@@ -549,6 +578,7 @@ def render_data_global(records)
   matrix_pool = global.select { |r| actionable?(r) && r[:status] != "active" }
   projs = project_summaries(records)
   { mode: "global", date: today.to_s,
+    store_health: store_health(:global),
     recently_worked: recently_worked(records),
     matrix: matrix_data(matrix_pool),
     counts: counts_of(global),
@@ -564,6 +594,7 @@ def render_data_project(records, slug)
   scoped = records.select { |r| r[:scope] == scope }
   matrix_pool = scoped.select { |r| r[:status] == "future" }
   { mode: "project", date: today.to_s, slug: slug,
+    store_health: store_health(slug),
     description: short_description(scope),
     recently_worked: recently_worked(records, project_scope: scope),
     matrix: matrix_data(matrix_pool),
@@ -619,7 +650,14 @@ def main(argv)
   if json
     subset = mode == "project" ? records.select { |r| r[:scope] == "project:#{slug}" } : records
     label = mode == "project" ? "project:#{slug}" : "all"
-    puts JSON.pretty_generate(render_json(subset, label))
+    payload = render_json(subset, label)
+    # Run the scoped store check on load, mirroring the --data board path:
+    # project board -> the slug; global/continue board -> :global. The `all`
+    # manifest spans every store, so its store-health probe is left to the
+    # per-scope boards (keeping the all-scopes auto-mode contract stable).
+    payload[:store_health] = store_health(slug) if mode == "project"
+    payload[:store_health] = store_health(:global) if mode == "continue"
+    puts JSON.pretty_generate(payload)
     return 0
   end
 

package/scripts/doctor.rb

@@ -13,6 +13,7 @@ require "json"
 require "yaml"
 require "time"
 require "date"
+require "digest"
 
 # Diagnostic engine, instantiable with an injected store/agent map so tests can
 # run it hermetically (no eval, no global-constant rewriting).
@@ -63,6 +64,12 @@ class Doctor
     agent = "claude"
     help = false
     core = false
+    # store flag representation:
+    #   nil        — --store not given
+    #   :all       — --store with no value (check every store)
+    #   :global    — --store global
+    #   "<slug>"   — --store <slug> (a single project)
+    store = nil
 
     i = 0
     while i < argv.length
@@ -78,6 +85,15 @@ class Doctor
       when "--core"
         core = true
         i += 1
+      when "--store"
+        nxt = argv[i + 1]
+        if nxt && !nxt.start_with?("-")
+          store = (nxt == "global") ? :global : nxt
+          i += 2
+        else
+          store = :all
+          i += 1
+        end
       when "--help", "-h"
         help = true
         i += 1
@@ -86,7 +102,7 @@ class Doctor
       end
     end
 
-    { agent: agent, help: help, core: core }
+    { agent: agent, help: help, core: core, store: store }
   end
 
   def show_help
@@ -99,8 +115,12 @@ class Doctor
 
       Options:
         --agent NAME    Agent to check: claude (default), codex, hermes
-        --core          Fast runtime-liveness check only (hooks, scripts, core files);
-                        skips the slow store/conventions/project inventory walks.
+        --core          Binary core sync check: verifies agent registration, core
+                        files, and that every manifest-tracked file matches its
+                        recorded SHA256. Exits 0 (pass) or 2 (fail); never warn.
+        --store [WHICH] Run only the store/conventions checks. WHICH may be:
+                        global (global store only), a project slug (that project
+                        only), or omitted (all stores). 3-state pass/warn/fail.
         -h, --help      Show this help
 
       Output:
@@ -301,10 +321,14 @@ class Doctor
 
   # --- Check category 2: Conventions ---
 
-  def check_conventions
+  # When `scopes` is a non-nil Array of scope strings (e.g. ["global"] or
+  # ["project:plastic"]), only intents whose :scope is in that list are checked.
+  # When nil (the default, used by the full run), every intent is checked.
+  def check_conventions(scopes: nil)
     checks = []
 
     intent_dirs = all_intent_dirs
+    intent_dirs = intent_dirs.select { |d| scopes.include?(d[:scope]) } unless scopes.nil?
     dirname_pattern = /^\w+--[\w-]+$/
 
     # intent_dirname
@@ -639,6 +663,84 @@ class Doctor
     checks
   end
 
+  # --- Check category: manifest sync (binary core integrity) ---
+
+  # Verify, for BOTH the global manifest and the agent-side manifest, that every
+  # file listed exists and its current SHA256 matches the recorded hash.
+  #   - GLOBAL manifest:    <plastic_home>/manifest.json
+  #   - AGENT-side manifest: claude -> <dir>/plastic/manifest.json
+  #                          other  -> <dir>/plastic-manifest.json
+  # Manifest format: { "version", "created", "files": { abs_path => sha256 } }.
+  # A missing manifest is a fail; any missing/mismatched listed file is a fail;
+  # otherwise a single pass per manifest.
+  def check_manifest_sync(agent_key)
+    checks = []
+
+    global_manifest = File.join(plastic_home, "manifest.json")
+    checks << verify_manifest(global_manifest, "global")
+
+    agent_dir = agents[agent_key][:dir]
+    agent_manifest = if agent_key == "claude"
+                       File.join(agent_dir, "plastic", "manifest.json")
+                     else
+                       File.join(agent_dir, "plastic-manifest.json")
+                     end
+    checks << verify_manifest(agent_manifest, "agent")
+
+    checks
+  end
+
+  # Check one manifest file. Returns a single check (pass or fail).
+  def verify_manifest(manifest_path, label)
+    unless File.exist?(manifest_path)
+      return check(
+        category: "manifest_sync", name: "#{label}_manifest", status: "fail",
+        message: "#{label} core manifest missing — re-run the Plastic installer",
+        details: [tilde(manifest_path)],
+        fixable: true, fix_hint: "Re-run the Plastic installer"
+      )
+    end
+
+    data = read_json_safe(manifest_path)
+    files = data.is_a?(Hash) ? data["files"] : nil
+    unless files.is_a?(Hash)
+      return check(
+        category: "manifest_sync", name: "#{label}_manifest", status: "fail",
+        message: "#{label} core manifest unreadable or malformed — re-run the Plastic installer",
+        details: [tilde(manifest_path)],
+        fixable: true, fix_hint: "Re-run the Plastic installer"
+      )
+    end
+
+    missing = []
+    mismatched = []
+    files.each do |path, recorded|
+      unless File.exist?(path)
+        missing << tilde(path)
+        next
+      end
+      actual = Digest::SHA256.file(path).hexdigest
+      mismatched << tilde(path) if actual != recorded
+    end
+
+    if missing.empty? && mismatched.empty?
+      check(
+        category: "manifest_sync", name: "#{label}_manifest", status: "pass",
+        message: "#{label} manifest: all #{files.size} tracked file(s) present and matching"
+      )
+    else
+      details = []
+      details += missing.map { |p| "missing: #{p}" }
+      details += mismatched.map { |p| "modified: #{p}" }
+      check(
+        category: "manifest_sync", name: "#{label}_manifest", status: "fail",
+        message: "#{label} manifest out of sync: #{missing.size} missing, #{mismatched.size} modified",
+        details: details,
+        fixable: true, fix_hint: "Re-run the Plastic installer to restore tracked files"
+      )
+    end
+  end
+
   # --- Check category 5: Project stores ---
 
   def check_project_stores
@@ -666,135 +768,140 @@ class Doctor
       return checks
     end
 
-    # Load INDEX.md content for cross-reference checks
-    index_path = File.join(plastic_home, "INDEX.md")
-    index_content = File.exist?(index_path) ? File.read(index_path) : ""
-
     projects.each do |slug, project_info|
-      project_dir = File.join(plastic_home, "projects", slug)
+      checks += check_project_store(slug, project_info)
+    end
 
-      # project_dir_exists
-      if File.directory?(project_dir)
-        checks << check(
-          category: "project_stores", name: "project_dir_exists", status: "pass",
-          message: "Project directory exists for '#{slug}'"
-        )
-      else
-        checks << check(
-          category: "project_stores", name: "project_dir_exists", status: "warn",
-          message: "Project directory missing for '#{slug}'",
-          details: [tilde(project_dir)],
-          fixable: true, fix_hint: "Create the project store directory: mkdir -p #{tilde(project_dir)}"
-        )
-      end
+    checks
+  end
 
-      # project_index
-      project_index = File.join(project_dir, "INDEX.md")
-      if File.exist?(project_index)
-        checks << check(
-          category: "project_stores", name: "project_index", status: "pass",
-          message: "INDEX.md exists for project '#{slug}'"
-        )
-      else
-        checks << check(
-          category: "project_stores", name: "project_index", status: "warn",
-          message: "INDEX.md missing for project '#{slug}'",
-          details: [tilde(project_index)],
-          fixable: true, fix_hint: "Create INDEX.md in the project store directory"
-        )
-      end
+  # Per-project validation extracted from check_project_stores so a single
+  # project can be checked in isolation (used by `--store <slug>`).
+  def check_project_store(slug, project_info)
+    checks = []
+    project_dir = File.join(plastic_home, "projects", slug)
+
+    # project_dir_exists
+    if File.directory?(project_dir)
+      checks << check(
+        category: "project_stores", name: "project_dir_exists", status: "pass",
+        message: "Project directory exists for '#{slug}'"
+      )
+    else
+      checks << check(
+        category: "project_stores", name: "project_dir_exists", status: "warn",
+        message: "Project directory missing for '#{slug}'",
+        details: [tilde(project_dir)],
+        fixable: true, fix_hint: "Create the project store directory: mkdir -p #{tilde(project_dir)}"
+      )
+    end
 
-      # project_yml_exists
-      project_yml_path = File.join(plastic_home, "projects", slug, "project.yml")
-      project_yml_data = nil
+    # project_index
+    project_index = File.join(project_dir, "INDEX.md")
+    if File.exist?(project_index)
+      checks << check(
+        category: "project_stores", name: "project_index", status: "pass",
+        message: "INDEX.md exists for project '#{slug}'"
+      )
+    else
+      checks << check(
+        category: "project_stores", name: "project_index", status: "warn",
+        message: "INDEX.md missing for project '#{slug}'",
+        details: [tilde(project_index)],
+        fixable: true, fix_hint: "Create INDEX.md in the project store directory"
+      )
+    end
 
-      if File.exist?(project_yml_path)
-        checks << check(
-          category: "project_stores", name: "project_yml_exists", status: "pass",
-          message: "project.yml exists for project '#{slug}'"
-        )
-        project_yml_data = load_yaml_safe(project_yml_path)
-      else
-        checks << check(
-          category: "project_stores", name: "project_yml_exists", status: "warn",
-          message: "project.yml missing for project '#{slug}'",
-          fixable: true, fix_hint: "Create project.yml from template — see plastic-creating-project"
-        )
-      end
+    # project_yml_exists
+    project_yml_path = File.join(plastic_home, "projects", slug, "project.yml")
+    project_yml_data = nil
 
-      # governing_docs_exist
-      if project_yml_data.is_a?(Hash) && project_yml_data["governing_docs"].is_a?(Array) && !project_yml_data["governing_docs"].empty?
-        project_path = project_info.is_a?(Hash) ? project_info["path"] : nil
-
-        if project_path
-          missing_docs = project_yml_data["governing_docs"].reject do |doc_path|
-            File.exist?(File.join(project_path, doc_path))
-          end
-
-          if missing_docs.empty?
-            checks << check(
-              category: "project_stores", name: "governing_docs_exist", status: "pass",
-              message: "All governing docs exist for project '#{slug}'"
-            )
-          else
-            checks << check(
-              category: "project_stores", name: "governing_docs_exist", status: "warn",
-              message: "#{missing_docs.size} governing doc(s) missing for project '#{slug}'",
-              details: missing_docs,
-              fixable: false
-            )
-          end
+    if File.exist?(project_yml_path)
+      checks << check(
+        category: "project_stores", name: "project_yml_exists", status: "pass",
+        message: "project.yml exists for project '#{slug}'"
+      )
+      project_yml_data = load_yaml_safe(project_yml_path)
+    else
+      checks << check(
+        category: "project_stores", name: "project_yml_exists", status: "warn",
+        message: "project.yml missing for project '#{slug}'",
+        fixable: true, fix_hint: "Create project.yml from template — see plastic-creating-project"
+      )
+    end
+
+    # governing_docs_exist
+    if project_yml_data.is_a?(Hash) && project_yml_data["governing_docs"].is_a?(Array) && !project_yml_data["governing_docs"].empty?
+      project_path = project_info.is_a?(Hash) ? project_info["path"] : nil
+
+      if project_path
+        missing_docs = project_yml_data["governing_docs"].reject do |doc_path|
+          File.exist?(File.join(project_path, doc_path))
+        end
+
+        if missing_docs.empty?
+          checks << check(
+            category: "project_stores", name: "governing_docs_exist", status: "pass",
+            message: "All governing docs exist for project '#{slug}'"
+          )
+        else
+          checks << check(
+            category: "project_stores", name: "governing_docs_exist", status: "warn",
+            message: "#{missing_docs.size} governing doc(s) missing for project '#{slug}'",
+            details: missing_docs,
+            fixable: false
+          )
         end
       end
+    end
 
-      # cross_references — if project has `parent` field, check global store intent tags
-      parent_id = project_info.is_a?(Hash) ? project_info["parent"] : nil
-      next unless parent_id
+    # cross_references — if project has `parent` field, check global store intent tags
+    parent_id = project_info.is_a?(Hash) ? project_info["parent"] : nil
+    return checks unless parent_id
 
-      # Find the intent directory for the parent ID
-      store_dir = File.join(plastic_home, "store")
-      parent_dir = nil
-      if File.directory?(store_dir)
-        parent_dir = Dir.children(store_dir).find { |d| d.start_with?("#{parent_id}--") }
-      end
+    # Find the intent directory for the parent ID
+    store_dir = File.join(plastic_home, "store")
+    parent_dir = nil
+    if File.directory?(store_dir)
+      parent_dir = Dir.children(store_dir).find { |d| d.start_with?("#{parent_id}--") }
+    end
 
-      if parent_dir.nil?
-        checks << check(
-          category: "project_stores", name: "cross_references", status: "warn",
-          message: "Parent intent '#{parent_id}' for project '#{slug}' not found in global store",
-          fixable: false
-        )
-        next
-      end
+    if parent_dir.nil?
+      checks << check(
+        category: "project_stores", name: "cross_references", status: "warn",
+        message: "Parent intent '#{parent_id}' for project '#{slug}' not found in global store",
+        fixable: false
+      )
+      return checks
+    end
 
-      intent_md = File.join(store_dir, parent_dir, "#{parent_dir}.md")
-      fm = parse_frontmatter(intent_md)
+    intent_md = File.join(store_dir, parent_dir, "#{parent_dir}.md")
+    fm = parse_frontmatter(intent_md)
 
-      if fm.nil?
-        checks << check(
-          category: "project_stores", name: "cross_references", status: "warn",
-          message: "Cannot read frontmatter of parent intent '#{parent_id}' for project '#{slug}'",
-          fixable: false
-        )
-        next
-      end
+    if fm.nil?
+      checks << check(
+        category: "project_stores", name: "cross_references", status: "warn",
+        message: "Cannot read frontmatter of parent intent '#{parent_id}' for project '#{slug}'",
+        fixable: false
+      )
+      return checks
+    end
 
-      tags = fm["tags"]
-      expected_tag = "project-#{slug}"
+    tags = fm["tags"]
+    expected_tag = "project-#{slug}"
 
-      if tags.is_a?(Array) && tags.include?(expected_tag)
-        checks << check(
-          category: "project_stores", name: "cross_references", status: "pass",
-          message: "Parent intent '#{parent_id}' has '#{expected_tag}' tag for project '#{slug}'"
-        )
-      else
-        checks << check(
-          category: "project_stores", name: "cross_references", status: "warn",
-          message: "Parent intent '#{parent_id}' missing '#{expected_tag}' tag",
-          details: ["Intent: store/#{parent_dir}", "Expected tag: #{expected_tag}", "Current tags: #{(tags || []).inspect}"],
-          fixable: false
-        )
-      end
+    if tags.is_a?(Array) && tags.include?(expected_tag)
+      checks << check(
+        category: "project_stores", name: "cross_references", status: "pass",
+        message: "Parent intent '#{parent_id}' has '#{expected_tag}' tag for project '#{slug}'"
+      )
+    else
+      checks << check(
+        category: "project_stores", name: "cross_references", status: "warn",
+        message: "Parent intent '#{parent_id}' missing '#{expected_tag}' tag",
+        details: ["Intent: store/#{parent_dir}", "Expected tag: #{expected_tag}", "Current tags: #{(tags || []).inspect}"],
+        fixable: false
+      )
     end
 
     checks
@@ -912,24 +1019,67 @@ class Doctor
     summarize(all_checks, agent_key)
   end
 
-  # Fast runtime-liveness check: only the plumbing that proves Plastic can
-  # operate (hooks, skills, scripts, core files). Skips the slow inventory
-  # walks (global store refs, per-intent conventions, project stores,
-  # deprecations) so it returns near-instantly. Used by `doctor.rb --core`.
+  # Binary core sync check: agent registration + core files + manifest sync,
+  # rolled up with binary: true so ANY warn or fail makes the overall status
+  # "fail" (and "warn" is never emitted). Used by `doctor.rb --core`.
   def run_core_checks(agent_key)
     all_checks = []
     all_checks += check_agent_registration(agent_key)
     all_checks += check_core_files(agent_key)
+    all_checks += check_manifest_sync(agent_key)
 
-    summarize(all_checks, agent_key)
+    summarize(all_checks, agent_key, binary: true)
+  end
+
+  # Store-scoped checks for `doctor.rb --store [global|<slug>]`.
+  #   :all     -> global store + all project stores + all conventions
+  #   :global  -> global store + conventions scoped to ["global"]
+  #   "<slug>" -> that project only + conventions scoped to ["project:<slug>"]
+  #               (fail if the slug is not registered in projects.yml)
+  # 3-state roll-up (pass/warn/fail), like the full run.
+  def run_store_checks(store)
+    all_checks =
+      case store
+      when :all
+        check_global_store + check_project_stores + check_conventions
+      when :global
+        check_global_store + check_conventions(scopes: ["global"])
+      else
+        all_checks_for_project_slug(store)
+      end
+
+    summarize(all_checks, "claude", binary: false)
+  end
+
+  # Build the checks for a single project slug, or a lone fail check when the
+  # slug is unknown.
+  def all_checks_for_project_slug(slug)
+    projects_data = load_yaml_safe(File.join(plastic_home, "projects.yml"))
+    projects = projects_data.is_a?(Hash) ? projects_data["projects"] : nil
+
+    unless projects.is_a?(Hash) && projects.key?(slug)
+      return [check(
+        category: "project_stores", name: "unknown_project", status: "fail",
+        message: "unknown project '#{slug}'",
+        fixable: false
+      )]
+    end
+
+    check_project_store(slug, projects[slug]) +
+      check_conventions(scopes: ["project:#{slug}"])
   end
 
   # Roll a list of checks up into the standard result envelope.
-  def summarize(all_checks, agent_key)
+  # When binary: true, the overall status is "pass" only if there are zero warn
+  # AND zero fail; any warn or fail yields "fail" (never "warn"). When false
+  # (the default) the classic 3-state pass/warn/fail roll-up is used.
+  def summarize(all_checks, agent_key, binary: false)
     summary = { pass: 0, warn: 0, fail: 0, total: all_checks.size }
     all_checks.each { |c| summary[c[:status].to_sym] += 1 }
 
-    overall = if summary[:fail] > 0
+    overall = if binary
+                (summary[:fail] > 0 || summary[:warn] > 0) ? "fail" : "pass"
+              elsif summary[:fail] > 0
                 "fail"
               elsif summary[:warn] > 0
                 "warn"
@@ -957,10 +1107,19 @@ class Doctor
       exit 0
     end
 
-    result = flags[:core] ? run_core_checks(flags[:agent]) : run_checks(flags[:agent])
+    result =
+      if !flags[:store].nil?
+        run_store_checks(flags[:store])
+      elsif flags[:core]
+        run_core_checks(flags[:agent])
+      else
+        run_checks(flags[:agent])
+      end
 
     puts JSON.pretty_generate(result)
 
+    # --core is binary: status is only ever pass|fail, so this maps to 0|2.
+    # --store and the full run keep the 3-state 0/1/2 mapping.
     case result[:status]
     when "fail" then exit 2
     when "warn" then exit 1

package/scripts/hook-session-start

@@ -284,6 +284,11 @@ payload = {
   "hookSpecificOutput" => {
     "hookEventName" => "SessionStart",
     "additionalContext" => parts.join("\n")
-  }
+  },
+  # Intent 54: additionalContext is model-only, so the banner stays invisible to
+  # the human. The top-level systemMessage channel is rendered in the user's
+  # terminal (and re-fires on /clear). Reuse the same BootBanner line so the
+  # visible banner and the model-facing banner cannot drift.
+  "systemMessage" => core_banner
 }
 puts JSON.generate(payload)

package/scripts/lib/boot_banner.rb

@@ -13,24 +13,16 @@ module BootBanner
   # health: the Hash returned by Doctor#run_core_checks, or nil if the check
   #         itself raised (degraded to an error banner).
   # version: the installed Plastic version string, or nil.
+  #
+  # Returns one of two binary lines:
+  #   "Plastic Core loaded — v{VER} | doctor --core run: success"
+  #   "Plastic Core loaded — v{VER} | doctor --core run: error — run /plastic-doctor"
   def render(health:, version:)
-    return "Plastic Core: health check error — run /plastic-doctor" if health.nil?
-
-    if health[:status] == "pass"
-      "Plastic Core loaded — v#{version || "unknown"}"
+    ver = version || "unknown"
+    if !health.nil? && health[:status] == "pass"
+      "Plastic Core loaded — v#{ver} | doctor --core run: success"
     else
-      bad = first_problem(health[:checks])
-      if bad
-        "Plastic Core loaded with issues — #{bad[:name]}: #{bad[:message]} — run /plastic-doctor"
-      else
-        "Plastic Core loaded with issues — run /plastic-doctor"
-      end
+      "Plastic Core loaded — v#{ver} | doctor --core run: error — run /plastic-doctor"
     end
   end
-
-  # First failing check, else first warning, else nil.
-  def first_problem(checks)
-    checks = checks || []
-    checks.find { |c| c[:status] == "fail" } || checks.find { |c| c[:status] == "warn" }
-  end
 end

package/scripts/lib/installer_core.rb

@@ -177,6 +177,11 @@ class InstallerCore
 
     Dir.glob(File.join(plastic_home, "scripts", "*")).each { |f| FileUtils.chmod(0o755, f) if File.file?(f) }
 
+    global_files = core_files.values.map { |d| File.join(plastic_home, d) }
+    global_files << File.join(plastic_home, "VERSION")
+    global_files = global_files.select { |p| File.exist?(p) }
+    write_manifest(global_files, File.join(plastic_home, "manifest.json"))
+
     puts "  \u{2705} Core files synced (v#{version})"
   end
 

package/scripts/update.rb

@@ -13,6 +13,7 @@
 # `install --reinstall --ledger-action update` for the chosen version via npx.
 
 require_relative "lib/installer_core"
+require_relative "doctor"
 
 class Update < InstallerCore
   PKG = "@zalom/plastic"
@@ -51,10 +52,31 @@ class Update < InstallerCore
         return 1
       end
       puts "\u{2b06}\u{fe0f}  Updating Plastic #{iv} \u{2192} #{res[:target]}"
-      perform_switch(res[:target], agent_args(argv))
+      exit_code = perform_switch(res[:target], agent_args(argv))
+      run_post_update_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)
+    doctor ||= Doctor.new
+    out.puts "\nRunning full doctor after update..."
+    result = doctor.run_checks("claude")
+    s = result[:summary]
+    out.puts "  Doctor status: #{result[:status]} " \
+             "(pass: #{s[:pass]}, warn: #{s[:warn]}, fail: #{s[:fail]}, total: #{s[:total]})"
+    out.puts "  Run /plastic-doctor for details." unless result[:status] == "pass"
+    result
+  rescue StandardError => e
+    # Non-blocking: a crash here (e.g. malformed file in the real store) must not
+    # undo or fail an update that already succeeded. Report and move on.
+    out.puts "  doctor could not run: #{e.message} — run /plastic-doctor"
+    nil
+  end
+
   # Pure decision logic (hermetically testable). Returns a status hash.
   def compute_target(installed_version:, dist_tags:, requested_channel: nil)
     installed_ch = channel_for(installed_version)

package/skills/continuing/SKILL.md

@@ -40,6 +40,11 @@ here — run the data payload and fill + present the matching template:
 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.
 
+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
+arrives in the payload as `store_health`; surface it as a one-line store-health note. It is
+non-fatal (a warn or fail is shown as data, it does not block continuing).
+
 ### Then stop
 Present "here is the state, what next?" and wait. Offer active intents first, then future
 intents. Do not start executing work. The branches below are the only follow-ups:

package/skills/dashboard/SKILL.md

@@ -32,10 +32,17 @@ ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>] --data
 - `continue` (default) → the **global** board payload (`mode: "global"`).
 - `project <slug>` → that **project** board payload (`mode: "project"`).
 
-The payload is read-only JSON. Global-board fields: `date`, `recently_worked`, `matrix`
-(`quick_win`/`next_big`/`defer`/`triage`/`research`, each a list of `{line, bullet, ...}`),
-`counts`, `projects`, `project_totals`. Project-board fields: `slug`, `description`,
-`recently_worked`, `matrix`, `counts`, `active`, `future`.
+The payload is read-only JSON. Global-board fields: `date`, `store_health`, `recently_worked`,
+`matrix` (`quick_win`/`next_big`/`defer`/`triage`/`research`, each a list of `{line, bullet, ...}`),
+`counts`, `projects`, `project_totals`. Project-board fields: `slug`, `store_health`,
+`description`, `recently_worked`, `matrix`, `counts`, `active`, `future`.
+
+Each board load runs the scoped store check (`doctor --store <scope>`): the global board runs
+`--store global` and a project board runs `--store <slug>`. The result rides in the payload as
+`store_health` (`{scope, status, summary, failing_checks}`). Surface it as a one-line
+store-health note on the board (for example `store health: pass (3/3)` or
+`store health: warn (orphaned_intents)`). It is non-fatal: a warn or fail is shown as data and
+never blocks the board.
 
 ### Step 2 — Fill the matching template
 

package/skills/doctor/SKILL.md

@@ -5,10 +5,51 @@ description: Use when diagnosing Plastic installation health, after updates, or
 
 # Doctor — Plastic Health Check
 
+## Scopes
+
+Doctor has three scopes. Pick the right one for the situation:
+
+| Scope | Flag | When it runs | States |
+|-------|------|--------------|--------|
+| Core check | `--core` | SessionStart hook (automatic), also available on demand | Binary: pass or error |
+| Store check | `--store [global\|<slug>]` | Dashboard load, `plastic-continuing` | Three-state: pass / warn / fail |
+| Full check | (no flag) | After every update (automatic), or `/plastic-doctor` | Three-state: pass / warn / fail |
+
+### `--core` (binary, manifest-backed)
+
+Verifies that every core file is present and content-matches what the installed
+version shipped. It checks two install manifests:
+
+- `~/.plastic/manifest.json` (global manifest, covers PLASTIC.md and global scripts)
+- `~/.claude/plastic/manifest.json` (agent-side manifest, covers agent scripts and hooks)
+
+Each manifest maps a file path to its SHA256. The core check also confirms hooks
+are registered, scripts are present and executable, and the installed version
+matches. Result is binary: exit 0 on pass, non-zero on error. It never produces
+warnings.
+
+### `--store [global|<slug>]`
+
+Checks store state: intents are well-formed, INDEX sections are present, conventions
+are followed, and links are valid. Scope options:
+
+- No argument: checks all stores (global and all projects)
+- `global`: checks only the global store
+- A project slug (e.g. `--store plastic`): checks only that project's store
+
+Produces three-state results (pass / warn / fail) and is run per-scope at dashboard
+load time: the global board uses `--store global`, a project board uses `--store <slug>`.
+
+### Full doctor (no flag)
+
+Runs core plus all store checks plus deprecation checks. This is what `/plastic-doctor`
+invokes. It also runs automatically after every `plastic-update` (informational,
+does not block or revert the update).
+
 ## When to Use
 
-- User invokes `/plastic-doctor`
-- After `plastic-update` completes (automatically)
+- User invokes `/plastic-doctor` (full check)
+- After `plastic-update` completes (automatically, full check)
 - When hooks aren't firing, skills aren't loading, or something seems broken
 - When the user says "check plastic", "diagnose", "what's wrong with plastic"
 

package/skills/doctor/report.md

@@ -7,6 +7,10 @@
   2. Replace every {{placeholder}} below with the corresponding JSON value.
   3. For the category sections: the template shows ONE example section.
      Repeat that pattern for each unique category in the checks array.
+     The scope determines which categories appear:
+       --core scope:      agent_registration, core_files (binary pass/error only)
+       --store scope:     global_store, conventions, project_stores
+       full (no flag):    all six categories below
      The six known categories and their display names are:
        global_store       -> "Global Store"
        conventions        -> "Conventions"