@zalom/plastic 1.12.0 → 1.14.0

package/scripts/lib/doctor_core.rb

@@ -107,6 +107,150 @@ class Doctor
     path.sub(Dir.home, "~")
   end
 
+  # Every hook command string registered under one settings.json event, flattened
+  # across that event's matcher groups. Shape-tolerant on purpose: settings.json is
+  # hand-editable and may carry anything at all under an event key.
+  def event_commands(groups)
+    return [] unless groups.is_a?(Array)
+
+    groups.flat_map do |group|
+      next [] unless group.is_a?(Hash) && group["hooks"].is_a?(Array)
+
+      group["hooks"].map { |h| h.is_a?(Hash) ? h["command"].to_s : "" }
+    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,
@@ -270,14 +414,30 @@ class Doctor
       )
     else
       hooks = settings["hooks"] || {}
+
+      # A live registration is a launcher Plastic ships TODAY (intent 277).
+      # claude_purge_command?, which this replaced, answers "was this ever ours":
+      # right for the installer's purge, wrong here, because a SessionStart
+      # carrying only the retired plastic-lock-gate satisfied the event while
+      # nothing shipped to run it.
       missing_events = CLAUDE_HOOK_EVENTS.reject do |event|
-        groups = hooks[event]
-        next false unless groups.is_a?(Array)
+        event_commands(hooks[event]).any? { |cmd| HookRegistry.claude_current_command?(cmd) }
+      end
 
-        groups.any? do |group|
-          group.is_a?(Hash) && group["hooks"].is_a?(Array) &&
-            group["hooks"].any? { |h| HookRegistry.claude_purge_command?(h["command"]) }
-        end
+      # Name the launcher when a missing event still carries a Plastic-owned
+      # command. Inside a missing event every such command is by construction not
+      # a current one, and a bare "SessionStart" reads as "nothing registered" to
+      # someone looking at a settings.json that plainly holds a plastic- entry.
+      # Events with no Plastic entry keep the bare name: two tests compare details
+      # by element equality and by count.
+      missing_details = missing_events.map do |event|
+        stale = event_commands(hooks[event])
+                .flat_map { |cmd| HookRegistry.command_basenames(cmd) }
+                .select { |name| HookRegistry.claude_purgeable_launcher_names.include?(name) }
+                .uniq
+        next event if stale.empty?
+
+        "#{event} (registered command is not a current Plastic hook: #{stale.join(', ')})"
       end
 
       if missing_events.empty?
@@ -289,7 +449,7 @@ class Doctor
         checks << check(
           category: "agent_registration", name: "hooks_registered", status: "fail",
           message: "#{missing_events.size} hook event(s) not registered in settings.json",
-          details: missing_events,
+          details: missing_details,
           fixable: true, fix_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest --claude"
         )
       end
@@ -300,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
@@ -332,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>/)
@@ -339,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")
@@ -348,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
@@ -431,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)
@@ -487,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
@@ -538,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 }
@@ -644,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/hook_registry.rb

@@ -244,6 +244,26 @@ module HookRegistry
     command_basenames(cmd).any? { |name| known.include?(name) }
   end
 
+  # Is this settings.json hook command one Plastic registers TODAY? (intent 277)
+  #
+  # The narrower twin of claude_purge_command?. The purge asks "was this ever
+  # ours", because it has to recognise an old entry in order to remove it. A
+  # liveness check asks "is there something here that still runs", and the two
+  # sets differ by exactly the entries that make the answers disagree: a
+  # SessionStart carrying only plastic-lock-gate satisfied doctor's
+  # hooks_registered while no such launcher ships anymore.
+  #
+  # Sourced from claude_launcher_names alone, so RETIRED_CLAUDE_LAUNCHERS is out
+  # (that is the bug) and CLAUDE_NON_HOOK_LAUNCHERS is out too: plastic-statusline
+  # is settings["statusLine"], not a hook of any event, so a group whose only
+  # Plastic entry is the statusline command has no hook registered in it.
+  # Tokenised through command_basenames like the purge predicate, so a quoted
+  # path or the legacy `ruby <path>/plastic-<name>.rb` form still resolves.
+  def claude_current_command?(cmd)
+    known = claude_launcher_names
+    command_basenames(cmd).any? { |name| known.include?(name) }
+  end
+
   # Is this ~/.codex/hooks.json command one of ours? Every Plastic Codex entry
   # invokes our dispatcher by path (`"<plastic_home>/scripts/codex-hook" <name>`),
   # so the dispatcher's filename identifies it. Basename EQUALITY, so a user's

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