@zalom/plastic 1.13.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/doctor.rb

@@ -546,10 +546,16 @@ class Doctor
 # :operational_gap when "savepoint_operational" is in that set; the :gap bucket (signals_complete,
 # the outcome.md check) never consults it, which is what keeps the exclusion key (intent_id,
 # rule) rather than just intent_id (see test/doctor_done_signals_test.rb case 12).
+#
+# `:excluded_rules_fired` (intent 280) names the rules that actually suppressed a finding for
+# this dir - not merely the rules registered for it. The caller uses this to build the `consumed`
+# set `DoctorExclusions.dead_rows` needs: a registered rule that never fires here (nothing to
+# suppress) is exactly what makes the row dead.
 def done_signal_findings_for_dir(dir, label:, scope:, dirname:, terminal:, active:, excluded_rules: [])
   outcome = File.join(dir, "outcome.md")
   outcome_real = Bridge.stage_file_present?(outcome)
-  findings = { conflict: nil, phantom: nil, gap: [], operational_gap: [], excluded: [], stalled: nil }
+  findings = { conflict: nil, phantom: nil, gap: [], operational_gap: [], excluded: [],
+               excluded_rules_fired: [], stalled: nil }
 
   # HARD conflict: the deliverable exists but INDEX still says Active. This
   # is the one true INDEX-wins disagreement, so it stays a fail.
@@ -586,7 +592,8 @@ def done_signal_findings_for_dir(dir, label:, scope:, dirname:, terminal:, activ
     # reconstructible via maintenance-run --tool rebuild-savepoint, so this is repairable and
     # reported as a fixable warn (savepoint_operational).
     savepoint = File.join(dir, "savepoint.md")
-    bucket = excluded_rules.include?("savepoint_operational") ? findings[:excluded] : findings[:operational_gap]
+    suppressed = excluded_rules.include?("savepoint_operational")
+    bucket = suppressed ? findings[:excluded] : findings[:operational_gap]
     if !File.exist?(savepoint)
       bucket << "#{label}: terminal in INDEX but savepoint.md is missing " \
                 "entirely (operational - reconstructible)"
@@ -594,6 +601,7 @@ def done_signal_findings_for_dir(dir, label:, scope:, dirname:, terminal:, activ
       bucket << "#{label}: terminal in INDEX but savepoint.md has no " \
                 "`Done delivered|abandoned` line (operational - reconstructible)"
     end
+    findings[:excluded_rules_fired] << "savepoint_operational" if suppressed && findings[:excluded].any?
 
     # Stalled completion: unchanged, never consulted amnesty.
     if File.exist?(Lock.path(dir))
@@ -614,6 +622,8 @@ def check_done_signals(scopes: nil)
   exclusion_errors = []   # malformed doctor-exclusions lines, scope-tagged
   exclusion_error_paths = []
   exclusion_paths = []    # files that actually contributed a live exclusion
+  dead_rows = []          # exclusion rows that suppressed nothing this run (intent 280)
+  dead_row_paths = []
   stalled = []
   phantoms = []
 
@@ -624,6 +634,25 @@ def check_done_signals(scopes: nil)
       exclusion_error_paths << exclusions[:path]
     end
 
+    consumed = { "savepoint_operational" => [] }
+    # `known_ids` (post-review fix): every intent id with a REAL DIRECTORY in this store, scanned
+    # directly from disk - independent of INDEX.md. An id can have a directory on disk without
+    # being listed in INDEX (a de-indexed "ghost"), and the walk below alone would never visit it;
+    # deriving known_ids from walk membership misclassified that ghost as :no_intent (deleted)
+    # even though the directory plainly still exists.
+    # Shares `store_intent_dirs` (159, intent 189's store-discovery helper) rather than
+    # reimplementing the same directory scan (review fix): one predicate for "what is an intent
+    # directory in this store", never two that could drift apart.
+    known_ids = if File.directory?(store[:store_dir])
+                  store_intent_dirs(store[:store_dir]).map { |e| e.split("--", 2).first }
+                else
+                  []
+                end
+    # `evaluated_ids`: the narrower set the walk below actually judges (INDEX-listed and on
+    # disk). An id with a real directory that this run never evaluated (on disk, unindexed)
+    # carries no evidence either way and must never be called dead - dead_rows leaves it out.
+    evaluated_ids = []
+
     index_sections_by_dir(store[:index]).each do |dirname, in_sections|
       dir = File.join(store[:store_dir], dirname)
       next unless File.directory?(dir)
@@ -632,6 +661,7 @@ def check_done_signals(scopes: nil)
       active = in_sections.include?("Active") && !terminal
       label = "#{store[:scope]} store/#{dirname}"
       intent_id = dirname.split("--", 2).first
+      evaluated_ids << intent_id
       excluded_rules = DoctorExclusions.rules_for(exclusions, intent_id)
 
       findings = done_signal_findings_for_dir(
@@ -646,11 +676,29 @@ def check_done_signals(scopes: nil)
         excluded.concat(findings[:excluded])
         exclusion_paths << exclusions[:path]
       end
+      findings[:excluded_rules_fired].each { |fired| (consumed[fired] ||= []) << intent_id }
       stalled << findings[:stalled] if findings[:stalled]
     end
+
+    # Drift in the governance record itself (intent 280): rows naming a pair that produced no
+    # finding this run. Computed by set subtraction against the walk above, never re-derived from
+    # the exclusion file (208; the intent 200 self-diff). `:no_intent` below only ever fires when
+    # `known_ids` (a real directory scan) truly has no entry for the id - never merely because the
+    # walk did not visit it.
+    DoctorExclusions.dead_rows(exclusions, consumed: consumed, known_ids: known_ids,
+                                evaluated_ids: evaluated_ids).each do |row|
+      reason = if row[:reason] == :no_intent
+                 "names no live intent directory (a typo, or the intent was deleted)"
+               else
+                 "names an intent with no current #{row[:rule]} finding"
+               end
+      dead_rows << "#{store[:scope]}: #{exclusions[:path]}: #{row[:rule]} #{row[:id]} - #{reason}"
+      dead_row_paths << exclusions[:path]
+    end
   end
   exclusion_paths.uniq!
   exclusion_error_paths.uniq!
+  dead_row_paths.uniq!
 
   checks = []
 
@@ -697,7 +745,15 @@ def check_done_signals(scopes: nil)
   # a malformed exclusion file can never report pass (loud), a clean remaining gap set reports
   # pass with the exclusion count folded in, and a real remaining gap set stays warn, same as
   # before intent 274, with the same count folded in when exclusions applied.
+  #
+  # `dead_suffix` (intent 280) folds in a second, independent drift notice: exclusion rows that
+  # suppressed nothing this run. It is purely informational, exactly like `exclusion_suffix` - it
+  # never changes status on any of the three branches below, because a stale governance-record row
+  # is bookkeeping drift, not a store regression (219 D6 is untouched: no disposition is invented).
   exclusion_suffix = excluded.empty? ? "" : " (#{excluded.size} excluded via #{exclusion_paths.join(", ")})"
+  dead_suffix = dead_rows.empty? ? "" : " (#{dead_rows.size} dead row#{dead_rows.size == 1 ? "" : "s"} " \
+                                        "in #{dead_row_paths.join(", ")}, suppressing nothing - prune with " \
+                                        "`maintenance-run --tool register-exclusions --prune`)"
 
   if exclusion_errors.any?
     checks << check(
@@ -705,8 +761,8 @@ def check_done_signals(scopes: nil)
       message: "#{operational_gaps.size} terminal intent#{operational_gaps.size == 1 ? "" : "s"} " \
                "missing an operational savepoint.md or its Done echo, and " \
                "#{exclusion_errors.size} doctor-exclusions error#{exclusion_errors.size == 1 ? "" : "s"} " \
-               "(a malformed exclusion file never suppresses a finding)#{exclusion_suffix}",
-      details: operational_gaps + exclusion_errors, fixable: true,
+               "(a malformed exclusion file never suppresses a finding)#{exclusion_suffix}#{dead_suffix}",
+      details: operational_gaps + exclusion_errors + dead_rows, fixable: true,
       fix_hint: "Fix the malformed doctor-exclusions file(s) (#{exclusion_error_paths.join(", ")}) - " \
                 "format `rule_name id id id`, blank lines and # comments ignored - then reconstruct " \
                 "any remaining real gap via `maintenance-run --tool rebuild-savepoint --intent <id> " \
@@ -716,14 +772,17 @@ def check_done_signals(scopes: nil)
   elsif operational_gaps.empty?
     checks << check(
       category: "done_signals", name: "savepoint_operational", status: "pass",
-      message: "No terminal intent is missing an operational savepoint.md or its Done echo#{exclusion_suffix}"
+      message: "No terminal intent is missing an operational savepoint.md or its Done echo" \
+               "#{exclusion_suffix}#{dead_suffix}",
+      details: dead_rows
     )
   else
     checks << check(
       category: "done_signals", name: "savepoint_operational", status: "warn",
       message: "#{operational_gaps.size} terminal intent#{operational_gaps.size == 1 ? "" : "s"} " \
-               "missing an operational savepoint.md or its Done echo (reconstructible)#{exclusion_suffix}",
-      details: operational_gaps, fixable: true,
+               "missing an operational savepoint.md or its Done echo (reconstructible)" \
+               "#{exclusion_suffix}#{dead_suffix}",
+      details: operational_gaps + dead_rows, fixable: true,
       fix_hint: "Reconstruct the minimal two-line started/Done echo via " \
                 "`maintenance-run --tool rebuild-savepoint --intent <id> --apply` (197-conformant: " \
                 "receipt-before-write via RevisionsWriter, one intent per invocation, owner-approval-gated)."
@@ -881,12 +940,19 @@ end
       )]
     end
 
+    # The owning store's INDEX.md, resolved from `scope` through the memoized store_discovery
+    # (same {key:, index:} shape done_signal_stores enumerates). intent_savepoint_truthful_check
+    # needs it to reach that store's doctor-exclusions table and to ask INDEX whether this
+    # intent is terminal (intent 281 D3/D6). nil when the scope resolves to no known store,
+    # which restores the pre-281 behavior exactly.
+    index_path = store_discovery[:stores].find { |s| s[:key] == scope }&.fetch(:index, nil)
+
     [
       intent_structure_check(intent_dir),
       intent_lifecycle_artifacts_check(intent_dir, disposition),
       intent_checklist_complete_check(intent_dir),
       intent_links_projection_check_for(id, scope),
-      intent_savepoint_truthful_check(intent_dir),
+      intent_savepoint_truthful_check(intent_dir, index_path: index_path),
     ]
   end
 
@@ -997,11 +1063,67 @@ end
     end
   end
 
+  # Whether this one intent's missing-savepoint finding is knowingly excluded, for the
+  # per-intent surface (intent 281). Returns {excluded:, errors:, path:}.
+  #
+  # Same rule id as the store-wide sweep, `savepoint_operational` (281 D1): the fact is
+  # identical (a terminal intent with no savepoint.md), so one registration in one
+  # doctor-exclusions file covers both surfaces and the owner never learns a second name for
+  # one gap. RuleCatalog is deliberately NOT extended.
+  #
+  # Terminal-gated (281 D3): done_signal_findings_for_dir only ever produces this finding
+  # inside `if terminal`, so honoring the exclusion for a still-Active intent would suppress a
+  # strictly larger set of facts than the rule id names - and would let a mistyped id silence
+  # the live, repairable warning scripts/end-intent's pre-write gate exists to raise.
+  #
+  # Never raises: DoctorExclusions is fail-open by contract (274 D5) and index_sections_by_dir
+  # returns an empty map for a missing INDEX.
+  def savepoint_exclusion_for(intent_dir, index_path)
+    none = { excluded: false, errors: [], path: nil }
+    return none unless index_path
+
+    dirname = File.basename(intent_dir)
+    return none unless (index_sections_by_dir(index_path)[dirname] & ["Completed", "Abandoned"]).any?
+
+    loaded = DoctorExclusions.load(index_path)
+    rules = DoctorExclusions.rules_for(loaded, dirname.split("--", 2).first)
+    { excluded: rules.include?("savepoint_operational"), errors: loaded[:errors], path: loaded[:path] }
+  end
+
   # WARN-only, per intent 134 (savepoint truthfulness is advisory, never a hard gate). Do not
   # change this to FAIL: it would silently contradict a standing, binding ruling.
-  def intent_savepoint_truthful_check(intent_dir)
+  #
+  # `index_path:` (intent 281) is the owning store's INDEX.md, threaded from check_intent_end.
+  # It makes this surface honor the same doctor-exclusions registration check_done_signals
+  # already honors for the same fact, under the same rule id (281 D1). Only the missing-file
+  # branch below is excludable: the phantom-line branch is permanently non-suppressible by id
+  # or scope (intent 211, 281 D2). Omitting index_path restores the pre-281 behavior exactly.
+  def intent_savepoint_truthful_check(intent_dir, index_path: nil)
     savepoint = File.join(intent_dir, "savepoint.md")
     unless File.exist?(savepoint)
+      exclusion = savepoint_exclusion_for(intent_dir, index_path)
+
+      # A loader error never suppresses anything (274 D5: fail milder than the bug), and the
+      # check that consulted the file is where the error is reported.
+      if exclusion[:errors].any?
+        return check(
+          category: "intent_end", name: "intent_savepoint_truthful", status: "warn",
+          message: "savepoint.md is missing, and #{exclusion[:errors].size} doctor-exclusions " \
+                   "error#{exclusion[:errors].size == 1 ? "" : "s"} " \
+                   "(a malformed exclusion file never suppresses a finding)",
+          details: exclusion[:errors], fixable: true,
+          fix_hint: "Fix the malformed doctor-exclusions file (#{exclusion[:path]}) - format " \
+                    "`rule_name id id id`, blank lines and # comments ignored - then re-run."
+        )
+      end
+
+      # Excluded: the fact stays in the message with the honest count and the file that caused
+      # the suppression, and nothing lands in details (274 D4's wording, N is always 1 here).
+      if exclusion[:excluded]
+        return check(category: "intent_end", name: "intent_savepoint_truthful", status: "pass",
+                     message: "savepoint.md is missing (1 excluded via #{exclusion[:path]})")
+      end
+
       return check(category: "intent_end", name: "intent_savepoint_truthful", status: "warn",
                     message: "savepoint.md is missing")
     end

package/scripts/lib/doctor_core.rb

@@ -120,6 +120,137 @@ class Doctor
     end
   end
 
+  # Every (event, command) pair, unfiltered (intent 276).
+  def each_hook_command(hooks_hash)
+    return unless hooks_hash.is_a?(Hash)
+
+    hooks_hash.each do |event, groups|
+      group_list = groups.is_a?(Hash) ? [groups] : Array(groups)
+      group_list.each do |g|
+        next unless g.is_a?(Hash)
+
+        # A bare Hash is one entry, not a skipped group (review finding).
+        hooks_list = case g["hooks"]
+                     when Array then g["hooks"]
+                     when Hash then [g["hooks"]]
+                     end
+        next unless hooks_list
+
+        hooks_list.each do |h|
+          cmd = h.is_a?(Hash) ? h["command"].to_s : ""
+          yield event, cmd unless cmd.empty?
+        end
+      end
+    end
+  end
+
+  # Candidate start positions before end_pos: string start, or right after
+  # whitespace or an opening quote (round 3).
+  def command_boundaries(raw, end_pos)
+    boundaries = [0]
+    (0...end_pos).each do |i|
+      ch = raw[i]
+      boundaries << i + 1 if ch =~ /\s/ || ch == '"' || ch == "'"
+    end
+    boundaries.uniq.sort
+  end
+
+  # Strip a quote pair only when it wraps the WHOLE string; never delete a
+  # quote character inside it (that broke a real apostrophe, round 3).
+  def strip_balanced_quotes(str)
+    if str.length >= 2 && (str[0] == '"' || str[0] == "'") && str[0] == str[-1]
+      str[1..-2]
+    else
+      str
+    end
+  end
+
+  # End position of the leftmost known launcher name in raw, matched whole
+  # (optionally + ".rb"); nil if none appears.
+  def launcher_name_end_position(raw, known_names)
+    positions = known_names.filter_map do |name|
+      m = raw.match(/(?<![\w.-])#{Regexp.escape(name)}(\.rb)?(?=["'\s]|\z)/)
+      m && [m.begin(0), m.end(0)]
+    end
+    return nil if positions.empty?
+
+    positions.min_by(&:first).last
+  end
+
+  # Mode (b): true unless a launcher this command names is missing (round 3
+  # candidate design: see command_boundaries/strip_balanced_quotes above).
+  def launcher_on_disk?(cmd, known_names)
+    raw = cmd.to_s
+    end_pos = launcher_name_end_position(raw, known_names)
+    return true unless end_pos
+
+    any_absolute = false
+    command_boundaries(raw, end_pos).each do |start|
+      candidate = strip_balanced_quotes(raw[start...end_pos])
+      next if candidate.empty?
+
+      candidate = File.expand_path(candidate) if candidate.start_with?("~")
+      next unless candidate.start_with?("/")
+
+      any_absolute = true
+      return true if File.file?(candidate)
+    end
+
+    !any_absolute
+  end
+
+  # Mode (a): does the EXECUTABLE's basename carry plastic-, never an
+  # argument's? Executable = longest leading candidate (whole command, or
+  # with a leading word stripped) that resolves to a real file, else the
+  # first token, quote-aware (round 3).
+  def unowned_prefixed_command?(cmd)
+    raw = cmd.to_s
+    return false if raw.strip.empty?
+
+    executable = executable_candidate(raw)
+    return false unless executable
+
+    File.basename(executable).sub(/\.rb\z/, "").start_with?("plastic-")
+  end
+
+  def executable_candidate(raw)
+    return resolved_candidate(raw) || after_leading_word(raw) || quote_aware_first_token(raw)
+  end
+
+  def after_leading_word(raw)
+    first_space = raw.index(/\s/)
+    return nil unless first_space
+
+    resolved_candidate(raw[(first_space + 1)..-1].to_s.strip)
+  end
+
+  # Quote-stripped, tilde-expanded str, returned only if it resolves to a
+  # real file; nil otherwise so the caller tries its next candidate.
+  def resolved_candidate(str)
+    candidate = strip_balanced_quotes(str)
+    return nil if candidate.empty?
+
+    candidate = File.expand_path(candidate) if candidate.start_with?("~")
+    candidate if File.file?(candidate)
+  end
+
+  def quote_aware_first_token(raw)
+    if raw.start_with?('"') || raw.start_with?("'")
+      q = raw[0]
+      close = raw.index(q, 1)
+      return close ? raw[1...close] : raw[1..-1].to_s
+    end
+
+    raw.split(/\s+/).reject(&:empty?).first.to_s
+  end
+
+  # Shared mode-(a) fix_hint text (intent 276), parametrized by the config
+  # file the rename gets re-registered in.
+  def unowned_hook_rename_hint(config_file)
+    "The plastic- prefix is reserved for Plastic's hooks and skills. Rename your hook and " \
+      "re-register it in #{config_file}."
+  end
+
   def check(category:, name:, status:, message:, details: [], fixable: false, fix_hint: nil)
     result = {
       category: category,
@@ -329,21 +460,27 @@ class Doctor
       # dead once already.
       expected = HookRegistry.claude_settings_hooks(hook_dir: hooks_dir)
       diffs = []
+      # settings.json is hand-editable: "hooks" or a per-event value can be
+      # any JSON shape, not only what HookRegistry emits. Guard both here
+      # rather than trust .dig / .select on an assumed Hash/Array.
+      hooks_value = settings["hooks"].is_a?(Hash) ? settings["hooks"] : {}
       expected.each do |event, group|
         groups = group.is_a?(Array) ? group : [group]
-        live = settings.dig("hooks", event) || []
+        live = hooks_value[event]
+        live = [] unless live.is_a?(Array)
         groups.each do |g|
           matches = live.select { |h| h.is_a?(Hash) && h["matcher"] == g["matcher"] }
           wanted = g["hooks"].map { |h| h["command"] }
-          got = matches.flat_map { |m| Array(m["hooks"]).map { |h| h["command"] } }
+          got = matches.flat_map { |m| Array(m["hooks"]).select { |h| h.is_a?(Hash) }.map { |h| h["command"] } }
           missing = wanted - got
           diffs << "#{event}[#{g['matcher']}] missing: #{missing.join(', ')}" unless missing.empty?
         end
       end
-      live_plastic = (settings["hooks"] || {}).flat_map do |event, groups|
+      live_plastic = hooks_value.flat_map do |event, groups|
         Array(groups).flat_map do |g|
           next [] unless g.is_a?(Hash) && g["hooks"].is_a?(Array)
-          g["hooks"].map { |h| h["command"].to_s }.select { |c| HookRegistry.claude_purge_command?(c) }
+          g["hooks"].select { |h| h.is_a?(Hash) }.map { |h| h["command"].to_s }
+                    .select { |c| HookRegistry.claude_purge_command?(c) }
                     .map { |c| "#{event}: #{c}" }
         end
       end
@@ -361,6 +498,9 @@ class Doctor
               details: diffs, fixable: true,
               fix_hint: "Re-run the installer merge: npx @zalom/plastic update (or ruby ~/.plastic/scripts/install.rb)")
       end
+
+      # hooks_entries_owned: unfiltered unowned/missing-launcher scan (intent 276).
+      checks << hooks_entries_owned_check(settings)
     end
 
     # skills_exist — flat, hyphen-namespaced personal skills (plastic-<name>/)
@@ -368,8 +508,7 @@ class Doctor
 
     # stray_skills — installed plastic-* skill dir with no manifest entry (a leftover,
     # e.g. an old-name copy after a rename; intent 158a AC15)
-    stray_check = stray_skills_check(agent_dir, "--claude", File.join(agent_dir, "plastic", "manifest.json"))
-    checks << stray_check if stray_check
+    checks << stray_skills_check(agent_dir, "--claude", File.join(agent_dir, "plastic", "manifest.json"))
 
     # agents_exist — auto-mode role files (plastic-*.md) synced into <dir>/agents
     checks << flat_agents_check(agent_dir, "--claude")
@@ -377,6 +516,59 @@ class Doctor
     checks
   end
 
+  # Unfiltered classification (intent 276, spec Approach table): mode (a)
+  # unowned warns, mode (b) current-but-missing fails, a retired/non-hook
+  # launcher is skipped, a third-party hook stays silent.
+  def hooks_entries_owned_check(settings)
+    known_launchers = HookRegistry.claude_launcher_names
+    unowned = []
+    missing_launcher = []
+
+    each_hook_command(settings["hooks"]) do |event, cmd|
+      if HookRegistry.claude_current_command?(cmd)
+        missing_launcher << "missing launcher: #{event}: #{cmd} names a file that is not on disk" unless launcher_on_disk?(cmd, known_launchers)
+      elsif HookRegistry.claude_purge_command?(cmd)
+        next # retired or non-hook launcher; hooks_match_registry owns this case
+      elsif unowned_prefixed_command?(cmd)
+        unowned << "reserved prefix: #{event}: #{cmd} is not a hook Plastic registers"
+      end
+    end
+
+    hooks_entries_owned_result("hooks_entries_owned", unowned, missing_launcher,
+      pass_message: "Every settings.json hook entry is Plastic's and installed, or not ours",
+      rename_hint: unowned_hook_rename_hint("settings.json"),
+      missing_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest --claude."
+    )
+  end
+
+  # Fail on mode (b), else warn on mode (a), else pass (spec Decision 3).
+  def hooks_entries_owned_result(name, unowned, missing_launcher, pass_message:, rename_hint:, missing_hint:)
+    status = if !missing_launcher.empty?
+               "fail"
+             elsif !unowned.empty?
+               "warn"
+             else
+               "pass"
+             end
+
+    return check(category: "agent_registration", name: name, status: "pass", message: pass_message) if status == "pass"
+
+    clauses = []
+    clauses << "#{unowned.size} #{unowned.size == 1 ? "carries" : "carry"} the reserved plastic- prefix without being Plastic's" unless unowned.empty?
+    clauses << "#{missing_launcher.size} #{missing_launcher.size == 1 ? "names" : "name"} a launcher missing from disk" unless missing_launcher.empty?
+
+    hints = []
+    hints << rename_hint unless unowned.empty?
+    hints << missing_hint unless missing_launcher.empty?
+
+    check(
+      category: "agent_registration", name: name, status: status,
+      message: clauses.join("; "),
+      details: unowned + missing_launcher,
+      fixable: true, fix_hint: hints.join(" ")
+    )
+  end
+
   def claude_dispatcher_gate_names(source)
     case_start = source.index(/^\s*case gate\b/)
     return nil unless case_start
@@ -460,34 +652,42 @@ class Doctor
     end
   end
 
+  # Manifest-diff stray-skill check (intent 158a), extended (intent 276) to
+  # never vanish on a missing manifest and to name the reserved-prefix rule.
   def stray_skills_check(agent_dir, installer_flag, manifest_path)
     skills_root = File.join(agent_dir, "skills")
-    manifest = read_json_safe(manifest_path)
-    files = manifest.is_a?(Hash) ? manifest["files"] : nil
-    return nil unless files.is_a?(Hash)
-
     installed = Dir.glob(File.join(skills_root, "plastic-*", "SKILL.md"))
                     .map { |f| File.basename(File.dirname(f)) }
-    tracked = files.keys
-                   .select { |p| p.start_with?("#{skills_root}/") }
-                   .map { |p| p.sub("#{skills_root}/", "").split("/").first }
-                   .uniq
-
-    strays = (installed - tracked).sort
+    manifest = read_json_safe(manifest_path)
+    files = manifest.is_a?(Hash) ? manifest["files"] : nil
 
-    if strays.empty?
-      check(
-        category: "agent_registration", name: "stray_skills", status: "pass",
-        message: "No stray plastic-* skill directories in #{tilde(skills_root)}"
-      )
-    else
-      check(
+    if !files.is_a?(Hash) && installed.empty?
+      return check(category: "agent_registration", name: "stray_skills", status: "pass",
+        message: "No plastic-* skills installed in #{tilde(skills_root)}; nothing to verify")
+    elsif !files.is_a?(Hash)
+      return check(
         category: "agent_registration", name: "stray_skills", status: "warn",
-        message: "#{strays.size} installed skill dir(s) not in the current manifest (stray, e.g. a leftover old-name copy)",
-        details: strays,
-        fixable: true, fix_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest #{installer_flag}"
+        message: "#{installed.size} plastic-* skill dir(s) installed but the manifest at " \
+                 "#{tilde(manifest_path)} is missing or unusable, so ownership cannot be verified",
+        details: installed.sort, fixable: true,
+        fix_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest #{installer_flag}"
       )
     end
+
+    tracked = files.keys.select { |p| p.start_with?("#{skills_root}/") }
+                   .map { |p| p.sub("#{skills_root}/", "").split("/").first }.uniq
+    strays = (installed - tracked).sort
+    return check(category: "agent_registration", name: "stray_skills", status: "pass",
+      message: "No stray plastic-* skill directories in #{tilde(skills_root)}") if strays.empty?
+
+    check(
+      category: "agent_registration", name: "stray_skills", status: "warn",
+      message: "#{strays.size} installed skill dir(s) are not skills Plastic shipped",
+      details: strays, fixable: true,
+      fix_hint: "The plastic- prefix is reserved for hooks and skills Plastic ships: rename a skill " \
+                "of your own that carries it, or re-run the installer (npx @zalom/plastic@latest " \
+                "#{installer_flag}) to clear a genuine leftover."
+    )
   end
 
   def flat_agents_check(agent_dir, installer_flag)
@@ -516,8 +716,7 @@ class Doctor
 
     # stray_skills — installed plastic-* skill dir with no manifest entry (a leftover,
     # e.g. an old-name copy after a rename; intent 158a AC15)
-    stray_check = stray_skills_check(agent_dir, "--#{agent_key}", File.join(agent_dir, "plastic", "manifest.json"))
-    checks << stray_check if stray_check
+    checks << stray_skills_check(agent_dir, "--#{agent_key}", File.join(agent_dir, "plastic", "manifest.json"))
 
     checks
   end
@@ -567,6 +766,7 @@ class Doctor
 
     hooks_check = codex_hooks_registered_check(config)
     checks << hooks_check
+    codex_hooks_entries_owned_check(config).tap { |c| checks << c if c }
     checks << codex_hooks_implemented_check(config)
     checks << codex_hook_trust_advisory_check if hooks_check[:status] == "pass"
     codex_config_toml_advisory_check(config).tap { |c| checks << c if c }
@@ -673,6 +873,31 @@ class Doctor
     end
   end
 
+  # Codex sibling of hooks_entries_owned_check: mode (b) is "the dispatcher
+  # is registered but scripts/codex-hook is missing" (intent 276). nil when
+  # hooks.json is missing: codex_hooks_registered_check owns that state.
+  def codex_hooks_entries_owned_check(config)
+    data = read_json_safe(File.join(config[:home_dir], "hooks.json"))
+    return nil if data.nil?
+
+    unowned = []
+    missing_dispatcher = []
+
+    each_hook_command(data["hooks"]) do |event, cmd|
+      if HookRegistry.codex_purge_command?(cmd)
+        missing_dispatcher << "missing launcher: #{event}: #{cmd} names a file that is not on disk" unless launcher_on_disk?(cmd, HookRegistry::CODEX_DISPATCHER_BASENAMES)
+      elsif unowned_prefixed_command?(cmd)
+        unowned << "reserved prefix: #{event}: #{cmd} is not a hook Plastic registers"
+      end
+    end
+
+    hooks_entries_owned_result("codex_hooks_entries_owned", unowned, missing_dispatcher,
+      pass_message: "Every hooks.json entry is Plastic's and installed, or not ours",
+      rename_hint: unowned_hook_rename_hint("hooks.json"),
+      missing_hint: "Re-run the Plastic installer with --codex."
+    )
+  end
+
   # codex_hooks_implemented (intent 200): codex_hooks_registered_check above proves
   # hooks.json content matches what HookRegistry would emit; both sides of THAT
   # comparison come from the registry, so a pass only proves the registry agrees

package/scripts/lib/doctor_exclusions.rb

@@ -21,6 +21,10 @@ require_relative "rule_catalog"
 # excludes anything (fail milder than the bug: a typo must not silently suppress a real
 # regression) and contributes one error string naming its 1-based line number. An unreadable
 # file contributes one error and zero exclusions. This module NEVER raises.
+#
+# The file is also the input to a drift check (intent 280): `dead_rows` below reports rows that
+# suppress nothing this run, so a governance record that only ever grows does not silently decay
+# into an unreviewable list.
 module DoctorExclusions
   module_function
 
@@ -90,4 +94,54 @@ module DoctorExclusions
   def rules_for(loaded, intent_id)
     loaded[:rules].select { |_rule, ids| ids.include?(intent_id) }.keys
   end
+
+  # PURE (intent 280, hardened by post-review fixes). Dead rows: registered (rule, id) pairs that
+  # suppressed nothing this run.
+  #
+  # `consumed` is { rule_name => [intent_id] }, built by the CALLER from findings that actually
+  # fired during its own directory walk. `known_ids` is every intent id with a REAL DIRECTORY in
+  # the store - resolved by the caller against the store's own directory listing, never against
+  # which ids a particular walk happened to visit (review fix: an id can have a real directory on
+  # disk without being listed in INDEX.md at all, a de-indexed "ghost"; deriving known_ids from
+  # walk membership alone misclassified that ghost as :no_intent - deleted - even though its
+  # directory plainly still exists). `evaluated_ids` (defaults to `known_ids` when omitted) is the
+  # narrower set of ids this run's walk actually judged one way or the other. An id with a real
+  # directory that was never evaluated this run (on disk, but absent from INDEX so the walk never
+  # visited it) carries no evidence either way and is left out of the result entirely - never
+  # called dead, never called live. None of `loaded`, `consumed`, `known_ids`, or `evaluated_ids`
+  # is derived from the exclusion file itself: this function is handed all of them and has no way
+  # to reach the file, which is what keeps it from becoming the intent 200 self-diff (a check that
+  # only ever proves the file agrees with itself - see 208).
+  #
+  # Only rules present as a KEY in `consumed` are considered at all: a rule this run's walk never
+  # tracked consumption for (e.g. a newly-excludable check no caller has been updated to evaluate
+  # yet) is "not evaluated" for the whole rule, and none of its rows are ever reported dead -
+  # reporting them would assume evidence the caller never actually gathered.
+  #
+  # Genuinely pure and non-raising: reads with `fetch`/`Array()` throughout, never indexes a
+  # default-proc Hash with `[]` (doing so would silently ADD that key to the CALLER's own hash as
+  # a side effect - not pure), and tolerates a nil/empty/malformed `loaded`, a nil `consumed`, and
+  # nil `known_ids`/`evaluated_ids`.
+  #
+  # Returns [{ rule:, id:, reason: }], reason being :no_finding (a real directory, evaluated this
+  # run, but the rule fired nothing to suppress) or :no_intent (no real directory at all - a typo,
+  # or the intent was deleted). Order is stable: rule name, then id.
+  def dead_rows(loaded, consumed: {}, known_ids: [], evaluated_ids: nil)
+    rules = (loaded || {})[:rules] || {}
+    consumed = consumed || {}
+    known = Array(known_ids)
+    evaluated = evaluated_ids.nil? ? known : Array(evaluated_ids)
+
+    rules.keys.sort.select { |rule| consumed.key?(rule) }.flat_map do |rule|
+      live = Array(consumed.fetch(rule, []))
+      dead_ids = (Array(rules[rule]) - live).sort
+
+      dead_ids.each_with_object([]) do |id, acc|
+        is_known = known.include?(id)
+        next if is_known && !evaluated.include?(id) # on disk, never evaluated - no evidence
+
+        acc << { rule: rule, id: id, reason: is_known ? :no_finding : :no_intent }
+      end
+    end
+  end
 end

package/scripts/lib/installer_core.rb

@@ -1217,13 +1217,23 @@ class InstallerCore
     path.sub(Dir.home, "~")
   end
 
-  def report_removed_hook_entries(removed, file_label)
+  def report_removed_hook_entries(removed, file_label, qualifier: "stale Plastic")
     return if removed.nil? || removed.empty?
 
-    puts "  \u{1f9f9} Removed #{removed.size} stale Plastic hook entr#{removed.size == 1 ? "y" : "ies"} from #{file_label}:"
+    puts "  \u{1f9f9} Removed #{removed.size} #{qualifier} hook entr#{removed.size == 1 ? "y" : "ies"} from #{file_label}:"
     removed.each { |event, command| puts "     - #{event}: #{tilde(command.to_s)}" }
   end
 
+  # The statusline swap-back on uninstall is not an [event, command] pair: it is a
+  # value restored, not an entry deleted. It gets its own line rather than being
+  # forced into the entry list (intent 278).
+  def report_removed_statusline(restored_command, file_label = "settings.json")
+    puts "  \u{1f9f9} Removed Plastic's statusLine from #{file_label}."
+    return if restored_command.nil? || restored_command.to_s.empty?
+
+    puts "     - restored your original statusLine: #{tilde(restored_command.to_s)}"
+  end
+
   # The other half of intent 275: a hook the purge KEPT because the registry does not
   # know it, but whose name carries Plastic's prefix. Silence here is what let the
   # 1.11.0 update delete the owner's plastic-writing-style hook unnoticed; now the
@@ -1493,15 +1503,24 @@ class InstallerCore
     settings = read_json_safe(settings_path)
     return unless settings && settings["hooks"]
 
+    removed = []
+
     settings["hooks"].each do |event, groups|
       next unless groups.is_a?(Array)
 
       settings["hooks"][event] = groups.map do |group|
         if group.is_a?(Hash) && group["hooks"].is_a?(Array)
-          group["hooks"].reject! { |h| HookRegistry.claude_purge_command?(h["command"]) }
+          group["hooks"].reject! do |h|
+            HookRegistry.claude_purge_command?(h["command"]) && (removed << [event, h["command"]])
+          end
           group unless group["hooks"].empty?
         elsif group.is_a?(Hash) && group["command"]
-          HookRegistry.claude_purge_command?(group["command"]) ? nil : group
+          if HookRegistry.claude_purge_command?(group["command"])
+            removed << [event, group["command"]]
+            nil
+          else
+            group
+          end
         else
           group
         end
@@ -1510,12 +1529,19 @@ class InstallerCore
 
     settings["hooks"].delete_if { |_, v| v.is_a?(Array) && v.empty? }
     settings.delete("hooks") if settings["hooks"]&.empty?
+
+    statusline_removed = false
+    restored_statusline = nil
     if HookRegistry.claude_purge_command?(settings.dig("statusLine", "command"))
       settings.delete("statusLine")
+      statusline_removed = true
       original_path = File.join(plastic_home, ".cache", "original-statusline.json")
       if File.exist?(original_path)
         original = JSON.parse(File.read(original_path)) rescue nil
-        settings["statusLine"] = original if original
+        if original.is_a?(Hash)
+          settings["statusLine"] = original
+          restored_statusline = original["command"]
+        end
       end
     end
 
@@ -1525,7 +1551,10 @@ class InstallerCore
       settings.delete("enabledPlugins") if settings["enabledPlugins"].empty?
     end
 
-    write_json_atomic(settings_path, settings)
+    result = write_json_atomic(settings_path, settings)
+    report_removed_hook_entries(removed, "settings.json", qualifier: "Plastic")
+    report_removed_statusline(restored_statusline) if statusline_removed
+    result
   end
 
   # Remove exactly Plastic's entries from ~/.codex/hooks.json (intent 102), mirrors
@@ -1537,6 +1566,7 @@ class InstallerCore
     return nil unless data && data["hooks"]
 
     before = JSON.generate(data)
+    removed = []
 
     data["hooks"].each do |event, groups|
       next unless groups.is_a?(Array)
@@ -1544,7 +1574,9 @@ class InstallerCore
       data["hooks"][event] = groups.map do |g|
         next g unless g.is_a?(Hash) && Array(g["hooks"]).is_a?(Array)
 
-        g["hooks"] = Array(g["hooks"]).reject { |h| HookRegistry.codex_purge_command?(h["command"]) }
+        g["hooks"] = Array(g["hooks"]).reject do |h|
+          HookRegistry.codex_purge_command?(h["command"]) && (removed << [event, h["command"]])
+        end
         g["hooks"].empty? ? nil : g
       end.compact
     end
@@ -1557,6 +1589,7 @@ class InstallerCore
     else
       write_json_atomic(hooks_json_path, data)
     end
+    report_removed_hook_entries(removed, "hooks.json", qualifier: "Plastic")
     hooks_json_path
   end
 

package/scripts/maintenance-run

@@ -15,7 +15,7 @@
 #   maintenance-run --tool rebuild-graph [--plastic-home PATH] [--apply]
 #   maintenance-run --tool restore-intent-v1 <id> --at <ref> [--plastic-home PATH] [--apply] [--skip-links]
 #   maintenance-run --tool rebuild-savepoint --intent <id> [--store <key>] [--plastic-home PATH] [--apply]
-#   maintenance-run --tool register-exclusions [--rule <name>] [--store <key>] [--plastic-home PATH] [--apply]
+#   maintenance-run --tool register-exclusions [--prune] [--rule <name>] [--store <key>] [--plastic-home PATH] [--apply]
 #
 # project-links here is ALWAYS single-intent: --intent is required. A store-wide
 # project-links sweep is the rare, owner-approved batch exception (D2) and is run directly
@@ -77,7 +77,7 @@ end
 
 def parse_argv(argv)
   opts = { tool: nil, intent: nil, store: nil, plastic_home: DEFAULT_HOME, apply: false,
-           at: nil, skip_links: false, id: nil, rule: nil }
+           at: nil, skip_links: false, id: nil, rule: nil, prune: false }
   i = 0
   while i < argv.length
     case argv[i]
@@ -89,6 +89,7 @@ def parse_argv(argv)
     when "--at" then opts[:at] = argv[i += 1]
     when "--skip-links" then opts[:skip_links] = true
     when "--rule" then opts[:rule] = argv[i += 1]
+    when "--prune" then opts[:prune] = true
     else
       opts[:id] ||= argv[i] # positional id, restore-intent-v1 only
     end
@@ -311,12 +312,53 @@ end
 # structurally edit an intent's OWN files) does not apply, and writing one would mean editing
 # every touched Completed intent directory - forbidden, completed intents are immutable. The
 # scoped commit plus the diffable exclusion file itself are the receipt.
-def run_register_exclusions(home, rule, store, apply)
+#
+# `prune:` (intent 280) reverses the direction: instead of adding newly-violating ids, it
+# removes rows that `DoctorExclusions.dead_rows` reports as suppressing nothing, through the
+# SAME walk, the SAME comment-preserving writer, and the SAME dry-run/--apply gate. `known_ids`
+# (post-review fix) is resolved against a direct scan of the store's own directory listing, never
+# against which ids the INDEX walk happened to visit - an id can have a real directory without
+# being listed in INDEX at all (a de-indexed "ghost"), and walk membership alone misclassified
+# that as :no_intent (deleted) even though the directory plainly still exists. `evaluated_ids` is
+# the narrower set the walk DOES visit; an id with a real directory the walk never evaluated
+# carries no evidence either way, so `dead_rows` leaves it out of its result entirely - never
+# called dead by the reporter, so `prune` never sees it as a pruning candidate in the first
+# place.
+#
+# The walk here only ever evaluates `savepoint_operational`'s own finding bucket
+# (`findings[:operational_gap]`), regardless of `--rule`: `run_register_exclusions` refuses
+# `--prune --rule <other>` outright (a second review fix) rather than silently computing
+# `found_ids` from an unrelated check and misreporting every row under `<other>` dead.
+#
+# Three classes of row are additionally held harmless before anything is written
+# (`protected_ids`), belt-and-suspenders on top of the `evaluated_ids` gate: an id whose dir was
+# skipped for a fresh delivery lock (D6 - the lock skip runs AFTER the id already lands in
+# `evaluated_ids`, but BEFORE it can ever reach `found_ids`, since findings are never computed
+# for it), an id whose intent has not reached a terminal state yet (D6a - savepoint_operational
+# only fires on a terminal intent, so the row has nothing to suppress YET), and an id with a real
+# directory that is not in `evaluated_ids` at all (on disk, unindexed - this last class never
+# actually reaches `held` in practice, since `dead_rows`'s own gate already excludes it; the
+# protection stays explicit anyway rather than relying solely on that gate). A rule left with
+# zero ids after pruning is dropped from the hash entirely (D7): `render_exclusions_file` would
+# otherwise write a bare `rule_name` line that `DoctorExclusions.parse` rejects as "lists no
+# intent ids".
+def run_register_exclusions(home, rule, store, apply, prune = false)
   rule ||= "savepoint_operational"
   unless RuleCatalog.excludable_check?(rule)
     abort_loud("--rule #{rule.inspect} is not excludable (expected one of: " \
                "#{RuleCatalog::EXCLUDABLE_CHECKS.keys.join(", ")})")
   end
+  # Review fix: the walk below only ever evaluates savepoint_operational's own finding bucket
+  # (`findings[:operational_gap]`), regardless of --rule. Passing --prune --rule <other> would
+  # compute `found_ids` from an entirely unrelated check and subtract it against <other>'s
+  # registered ids, misreporting every one of them dead. Unreachable in v1 (EXCLUDABLE_CHECKS
+  # carries exactly one key) but one catalog entry away, so refuse it explicitly rather than
+  # silently mis-pruning the day a second excludable check exists.
+  if prune && rule != "savepoint_operational"
+    abort_loud("--prune evaluates only savepoint_operational; #{rule.inspect} rows are left " \
+               "untouched (the walk this tool runs only ever checks that one rule's finding " \
+               "bucket, regardless of --rule)")
+  end
 
   doctor = Doctor.new(plastic_home: home)
   stores = doctor.done_signal_stores(store ? [store] : nil)
@@ -340,15 +382,45 @@ def run_register_exclusions(home, rule, store, apply)
     existing_text = File.exist?(existing[:path]) ? File.read(existing[:path]).scrub : nil
 
     found_ids = []
+    protected_ids = []
+
+    # `known_ids` (post-review fix): every id with a REAL DIRECTORY in this store, scanned
+    # directly from disk - not from the INDEX walk below. Mirrors doctor.rb's own fix: an id can
+    # have a directory on disk without being listed in INDEX (a de-indexed "ghost"), and the walk
+    # alone would never visit it, misclassifying that ghost as :no_intent (deleted) even though
+    # it plainly still exists.
+    # Shares doctor.store_intent_dirs (doctor.rb:159, intent 189's store-discovery helper)
+    # rather than reimplementing the same directory scan (review fix): one predicate for "what
+    # is an intent directory in this store", never two that could drift apart.
+    known_ids = if File.directory?(s[:store_dir])
+                  doctor.store_intent_dirs(s[:store_dir]).map { |e| e.split("--", 2).first }
+                else
+                  []
+                end
+    # `evaluated_ids`: the narrower set the walk below actually judges (INDEX-listed and on disk).
+    evaluated_ids = []
+
     doctor.index_sections_by_dir(s[:index]).each do |dirname, in_sections|
       dir = File.join(s[:store_dir], dirname)
       next unless File.directory?(dir)
 
+      walked_id = dirname.split("--", 2).first
+      evaluated_ids << walked_id
+      # D6a: savepoint_operational only fires on a terminal intent, so a row naming a live
+      # non-terminal intent has nothing to suppress YET. Doctor reports it; prune leaves it.
+      protected_ids << walked_id unless (in_sections & ["Completed", "Abandoned"]).any?
+
       terminal = (in_sections & ["Completed", "Abandoned"]).any?
       next unless terminal
 
       if Lock.fresh?(dir)
         skip_lines << "#{s[:scope]}: #{dirname} skipped (fresh delivery lock)"
+        # Prune direction (intent 280 D6, post-review fix): the lock skip runs AFTER
+        # evaluated_ids already recorded this id (just above) but BEFORE findings are computed,
+        # so it never reaches `consumed` - dead_rows would read it as :no_finding (evaluated,
+        # nothing consumed) purely because we never checked. Hold it harmless via protected_ids
+        # regardless of what dead_rows would report.
+        protected_ids << walked_id
         next
       end
 
@@ -357,36 +429,74 @@ def run_register_exclusions(home, rule, store, apply)
         dir, label: "#{s[:scope]} store/#{dirname}", scope: s[:scope], dirname: dirname,
         terminal: terminal, active: active, excluded_rules: []
       )
-      found_ids << dirname.split("--", 2).first if findings[:operational_gap].any?
+      found_ids << walked_id if findings[:operational_gap].any?
     end
 
+    # Post-review fix: an id with a real directory that INDEX never lists at all is walked by
+    # neither branch above, so its terminal state is unknowable here. PURE DEFENSE-IN-DEPTH:
+    # `dead_rows`'s own `evaluated_ids` gate already excludes such an id from `dead` entirely (it
+    # is neither :no_finding nor :no_intent - no evidence either way), so `held` below never
+    # actually contains one and this concat's protection never needs to fire. Unlike D6 (fresh
+    # lock) and D6a (not yet terminal), which DO reach `held` and print "kept (protected, still
+    # live)", an unindexed id is never named in that skip output - it was never a live pruning
+    # candidate to begin with.
+    protected_ids.concat(known_ids - evaluated_ids)
+
     already = existing[:rules][rule] || []
-    added = found_ids - already
-    next if added.empty?
 
-    merged_rules = existing[:rules].merge(rule => (already | found_ids).sort)
-    plan[s] = { content: render_exclusions_file(merged_rules, existing_text: existing_text), added: added.sort }
+    if prune
+      # This tool calls done_signal_findings_for_dir with excluded_rules: [], so a registered id
+      # that still has a gap shows up in found_ids rather than in the :excluded bucket. found_ids
+      # IS the consumed set for this rule.
+      dead = DoctorExclusions.dead_rows(existing, consumed: { rule => found_ids }, known_ids: known_ids,
+                                          evaluated_ids: evaluated_ids)
+                             .select { |row| row[:rule] == rule }
+                             .map { |row| row[:id] }
+      held = dead & protected_ids # D6 (fresh lock) + D6a (not terminal) + on-disk-but-unindexed
+      held.each { |id| skip_lines << "#{s[:scope]}: #{id} kept (protected, still live)" }
+      dead -= held
+      next if dead.empty?
+
+      remaining = already - dead
+      merged_rules = existing[:rules].merge(rule => remaining.sort)
+      merged_rules.delete(rule) if remaining.empty? # D7: a bare rule line fails to reload
+      plan[s] = { content: render_exclusions_file(merged_rules, existing_text: existing_text),
+                  removed: dead.sort }
+    else
+      added = found_ids - already
+      next if added.empty?
+
+      merged_rules = existing[:rules].merge(rule => (already | found_ids).sort)
+      plan[s] = { content: render_exclusions_file(merged_rules, existing_text: existing_text),
+                  added: added.sort }
+    end
   end
 
   puts skip_lines.join("\n") unless skip_lines.empty?
 
   if plan.empty?
-    puts "maintenance-run: no new #{rule} violations to register."
+    puts(prune ? "maintenance-run: no dead #{rule} exclusion rows to prune."
+               : "maintenance-run: no new #{rule} violations to register.")
     exit 0
   end
 
   unless apply
     plan.each do |s, info|
-      puts "maintenance-run: DRY RUN, #{s[:scope]} would register #{info[:added].size} " \
-           "id(s) under #{rule}: #{info[:added].join(", ")}"
+      puts(if prune
+             "maintenance-run: DRY RUN, #{s[:scope]} would prune #{info[:removed].size} " \
+             "dead row(s) under #{rule}: #{info[:removed].join(", ")}"
+           else
+             "maintenance-run: DRY RUN, #{s[:scope]} would register #{info[:added].size} " \
+             "id(s) under #{rule}: #{info[:added].join(", ")}"
+           end)
     end
     exit 0
   end
 
   begin
     result = MaintenanceGit.run_scoped(
-      repo_dir: home, branch_name: "maintenance/register-exclusions-#{stamp}",
-      commit_message: "chore: maintenance - register doctor exclusions (#{rule})"
+      repo_dir: home, branch_name: "maintenance/#{prune ? "prune" : "register"}-exclusions-#{stamp}",
+      commit_message: "chore: maintenance - #{prune ? "prune dead" : "register"} doctor exclusions (#{rule})"
     ) do
       plan.each { |s, info| File.write(DoctorExclusions.path_for(s[:index]), info[:content]) }
     end
@@ -414,7 +524,7 @@ def main(argv)
   when "rebuild-savepoint"
     run_rebuild_savepoint(opts[:plastic_home], opts[:intent], opts[:store], opts[:apply])
   when "register-exclusions"
-    run_register_exclusions(opts[:plastic_home], opts[:rule], opts[:store], opts[:apply])
+    run_register_exclusions(opts[:plastic_home], opts[:rule], opts[:store], opts[:apply], opts[:prune])
   else
     abort_loud("unknown --tool #{opts[:tool].inspect} (expected project-links|rebuild-graph|" \
                "restore-intent-v1|rebuild-savepoint|register-exclusions)")

package/skills/conventions/SKILL.md

@@ -19,7 +19,7 @@ when the trigger in the second column applies to the work in front of you.
 | `references/knowledge-graph.md` | when creating, linking, curating, or indexing intents and you need the sources-vs-chain doctrine, the tiers of influence, the `## Links` projection, or branch-vs-root directory semantics |
 | `references/lifecycle-and-savepoints.md` | when running a lifecycle stage or a savepoint and you need the subagent report-home contract for how an insight reaches the intent |
 | `references/tiers-and-dispatch.md` | when sizing an intent, choosing agent models, routing to the advisor, or writing an auto-mode human report |
-| `references/gates-and-enforcement.md` | when a transition gate blocks you, or before using an audited escape, for the gate mechanics and the logging contract, or when naming, registering, or retiring a hook |
+| `references/gates-and-enforcement.md` | when a transition gate blocks you, or before using an audited escape, for the gate mechanics and the logging contract, or when naming, registering, or retiring a hook or skill |
 | `references/locks-and-worktrees.md` | before taking or releasing a delivery lock, and when working with claims, worktrees, solo mode, or the station ledger |
 | `references/completion-and-done.md` | when ending an intent, for what "intent done" means and the End-stage tail |
 | `references/maintenance-and-revisions.md` | before any structural maintenance edit, for WORK vs MAINTENANCE, the `revisions.md` move-and-record contract, the violation-tag catalog, and the context-economy measurement buckets |

package/skills/conventions/references/gates-and-enforcement.md

@@ -2,14 +2,19 @@
 
 This chapter holds the escape-and-logging depth for each transition gate.
 
-#### Hook naming and ownership
-
-The `plastic-` prefix on an installed hook launcher is reserved for hooks `HookRegistry`
-registers. A user-owned hook must never take it: the installer purges Plastic's registrations
-from the agent's hook config on every update, matching by registry launcher name (current plus
-`RETIRED_HOOK_NAMES`), and doctor's `hooks_no_orphans` reports any unregistered `plastic-*`
-launcher on disk. Renaming or removing a hook from `events` means adding its old name to
-`RETIRED_HOOK_NAMES` in the same change, or every existing install keeps a dead registration.
+#### Hook and skill naming and ownership
+
+The `plastic-` prefix is reserved for both surfaces: hooks `HookRegistry` registers and skills
+Plastic ships. A user-owned hook or skill must never take it: the installer purges Plastic's
+registrations from the agent's hook config on every update, matching by registry launcher name
+(current plus `RETIRED_HOOK_NAMES`), and doctor reports every violation it can find. On disk,
+`hooks_no_orphans` reports an unregistered `plastic-*` launcher file the registry does not know.
+In the live config, `hooks_entries_owned` (Claude) and `codex_hooks_entries_owned` (Codex)
+report a config entry that is neither a current registration nor recognizably ours, and,
+separately, a current registration whose launcher file is missing from disk. For skills,
+`stray_skills` reports a `plastic-*` skill directory the manifest does not track. Renaming or
+removing a hook from `events` means adding its old name to `RETIRED_HOOK_NAMES` in the same
+change, or every existing install keeps a dead registration.
 
 #### The gates by name
 

package/skills/conventions/references/maintenance-and-revisions.md

@@ -190,6 +190,20 @@ immutable forbids outright. The receipt is instead the scoped git commit
 durable, diffable record - not a missing safeguard, a deliberate substitution for a receipt
 shape that would otherwise require an illegal write.
 
+`--prune` (intent 280) reverses the same tool's direction under the identical carve-out: instead
+of adding newly-violating ids, it removes rows that suppress nothing this run (the intent's gap
+got repaired, the id was mistyped, or the intent directory is gone), computed via the same
+`DoctorExclusions.dead_rows` predicate doctor itself reports from, so the reporter and the
+remover can never disagree about what a dead row is. Same dry-run-by-default, same `--apply`
+gate, same comment-preserving writer, same one scoped commit, same no-`revisions.md`-entry rule -
+this direction still modifies no intent directory, only the store-level table. It holds back two
+kinds of row before writing even when they read as dead: an id whose intent dir carries a fresh
+delivery lock (the lock skip would otherwise leave it out of the walk entirely and misclassify
+it), and an id whose intent has not reached a terminal state yet (`savepoint_operational` only
+fires on a terminal intent, so the row has nothing to suppress *yet*). Both are named in the
+output as kept, never silently dropped, and a rule left with zero ids after pruning is removed
+from the file rather than written as a bare `rule_name` line the loader would reject.
+
 Like every other tool behind `maintenance-run`, it dry-runs by default (the owner-approval
 gate), unions with any existing hand-edited file content so a manually added id is never
 dropped, and skips (never aborts on) any intent dir holding a fresh delivery lock.

package/skills/doctor/SKILL.md

@@ -218,6 +218,12 @@ folds in the count and the file's path, e.g. `"... (3 excluded via ~/.plastic/do
 A malformed line in the file forces the check to `warn` with the parse error in `details`, even
 when zero real gaps remain, so a broken file is never silently permissive.
 
+**Both surfaces, one line.** A registration is honored by the store-wide `savepoint_operational`
+check and by the per-intent `doctor.rb --intent <id>` run, which reports the same missing
+`savepoint.md` under the check name `intent_savepoint_truthful`. Register the id once. The
+per-intent run honors it only for an intent that is terminal in `INDEX.md`, and never suppresses
+a phantom-savepoint-line finding.
+
 **Hand-editing.** The file is plain text; add a line (or append ids to an existing rule line) and
 save. No installer step, no reindex, and no `revisions.md` entry is required or written.
 
@@ -233,6 +239,14 @@ without writing anything. Review the output, then re-run with `--apply` to write
 land one scoped git commit. It unions with any existing hand-added ids (never drops one) and
 skips, rather than aborts on, any intent dir holding a fresh delivery lock.
 
+**Dead-row notice.** A registered row can go dead (gap repaired, id mistyped, or the intent
+directory gone). When any row is dead, the message adds a second suffix next to the exclusion
+count naming the count, the file, and the prune command - purely informational, status and exit
+code unchanged. Prune it the same way, dry-run first: register-exclusions --prune [--apply]. It
+removes exactly the dead rows through the same writer and commit, but holds back an id whose
+intent dir carries a fresh lock or has not gone terminal yet (nothing to suppress there yet),
+naming both as kept.
+
 ## References
 
 - Read `references/gates-stuck-detection.md` for the full gate enforcement table, bridge file pattern, and the recorded stuck-detection signals when diagnosing gate failures or stuck agents

package/skills/skill-creating/SKILL.md

@@ -40,6 +40,9 @@ routes each authoring task to the reference that holds the depth.
   them (use commas, periods, parentheses, colons). Existing internal files and the
   sanctioned template emissions (templates/index.md's INDEX line shape) are not
   violations.
+- The `plastic-` prefix is reserved for skills and hooks Plastic itself ships. A skill
+  authored outside Plastic's own tree takes a different name; doctor's ownership checks
+  and the installer's purge both key off the prefix.
 
 ## Route the authoring task to its reference
 

package/skills/skill-creating/references/skills.md

@@ -58,6 +58,9 @@ Rules [A5]:
 5. Must not contain `anthropic` or `claude`.
 6. Prefer the gerund form, which reads as a capability (`processing-pdfs`, `creating-skills`,
    not `pdf-tool`).
+7. Never start with `plastic-`. That prefix is reserved for skills and hooks Plastic itself
+   ships; doctor's ownership checks (`stray_skills`) and the installer's purge both key off it,
+   so a user-authored skill carrying it reads as squatting on Plastic's own namespace.
 
 ## The `description` field (triggering)