@zalom/plastic 1.14.0 → 2.0.0-alpha.1

package/scripts/lib/edit_gates.rb

@@ -1,398 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# EditGates (intent 244): the five Claude PreToolUse edit-path gates as plain
-# functions over one parsed payload. Three callers share these functions so the
-# harnesses cannot drift: scripts/hook-edit-gates (the merged Claude dispatcher),
-# scripts/lib/codex_edit_gates.rb (the merged Codex dispatcher, intent 251), and
-# the retained scripts/hook-code-gate / hook-lock-gate / hook-savepoint-pre /
-# hook-links-gate / hook-create-gate CLI wrappers, which no longer have a
-# production caller on either harness and remain as the per-gate isolation
-# surface for the hook test suite.
-#
-# A gate returns nil to allow, or a Deny. Two deny shapes coexist deliberately
-# (spec D-b): :stderr (stderr lines plus exit 2, code-gate / links-gate /
-# create-gate) and :json (stdout JSON plus exit 0, lock-gate, which reserves a
-# non-zero exit for hook-internal errors). Nothing here normalizes them.
-
-require "json"
-require "time"
-require_relative "hook_registry"
-require_relative "bridge"
-require_relative "lock"
-require_relative "links_gate"
-require_relative "intent_validator"
-
-module EditGates
-  module_function
-
-  ALLOW = nil
-
-  Deny = Struct.new(:shape, :lines, :stdout, keyword_init: true)
-
-  # Everything the five gates read out of one PreToolUse payload (spec D-g).
-  #   gate_path  - code-gate and lock-gate: file_path || notebook_path ||
-  #                relative_path, absolutized against tool_input.project_root ||
-  #                payload.cwd when relative. Exactly what the old Bash shims
-  #                computed with their `ruby -rjson -e` one-liners.
-  #   file_path  - savepoint-pre, links-gate, create-gate: tool_input.file_path
-  #                only, raw. Preserving this narrower extraction is what keeps
-  #                create-gate's dormant Serena gap byte-for-byte intact.
-  #   content    - the RAW tool_input.content (nil when the key is absent, ""
-  #                when it is explicitly empty). Kept unmixed with new_string so
-  #                links-gate and create-gate's `!content.nil?` branch keeps its
-  #                exact original meaning; code-gate computes its own combined
-  #                content-or-new_string-or-"" value locally, mirroring what its
-  #                old Bash shim computed independently for ARGV[2].
-  Context = Struct.new(:tool_name, :session, :gate_path, :file_path, :savepoint_path,
-                       :content, :old_string, :new_string, :replace_all, :harness,
-                       keyword_init: true) do
-    # links-gate and create-gate branch on content.nil? (key absent) vs content
-    # present (even ""). This is the raw field already, kept as a named reader
-    # so both gates read intent, not a struct field, at the call site.
-    def content_or_nil
-      content
-    end
-  end
-
-  # Per-key tool_input/tool_params fallback (post-review fix, intent 244): old
-  # links-gate and create-gate read
-  # `payload.dig("tool_input", key) || payload.dig("tool_params", key)`, each
-  # key falling back independently, NOT the whole-object pick `input =
-  # tool_input || tool_params` used for gate_path/content/etc below. This
-  # matters for a payload shaped tool_input: {} plus
-  # tool_params: { file_path: X }: the whole-object read stops at the (empty)
-  # tool_input and never sees X; the per-key read still finds it. `prefer`
-  # flips which object wins when BOTH carry the key, since savepoint-pre alone
-  # read tool_params FIRST (see savepoint_path below).
-  def per_key_field(payload, key, prefer: "tool_input")
-    other = prefer == "tool_input" ? "tool_params" : "tool_input"
-    a = payload[prefer]
-    b = payload[other]
-    (a.is_a?(Hash) ? a[key] : nil) || (b.is_a?(Hash) ? b[key] : nil)
-  end
-
-  def context_from(payload, env: ENV)
-    input = payload["tool_input"] || payload["tool_params"] || {}
-    input = {} unless input.is_a?(Hash)
-
-    raw = input["file_path"] || input["notebook_path"] || input["relative_path"] || ""
-    if !raw.empty? && !raw.start_with?("/")
-      root = input["project_root"] || payload["cwd"] || ""
-      raw = File.join(root, raw) unless root.empty?
-    end
-
-    session = payload["session_id"]
-    session = env["CLAUDE_CODE_SESSION_ID"] if session.to_s.empty?
-
-    Context.new(
-      tool_name: payload["tool_name"],
-      session: (session unless session.to_s.empty?),
-      gate_path: raw,
-      file_path: per_key_field(payload, "file_path", prefer: "tool_input"),
-      # savepoint-pre's own historical precedence, inverted from links-gate /
-      # create-gate above: old hooks/savepoint-pre read
-      # `dig("tool_params","file_path") || dig("tool_input","file_path")`.
-      savepoint_path: per_key_field(payload, "file_path", prefer: "tool_params"),
-      content: input["content"],
-      old_string: input["old_string"],
-      new_string: input["new_string"],
-      replace_all: input["replace_all"],
-      harness: "claude",
-    )
-  end
-
-  # --- savepoint-pre (intent 81): never denies; appends the `started` ledger line.
-  def savepoint_pre(ctx)
-    # ctx.savepoint_path carries context_from's tool_params-first read (fix 3);
-    # falls back to ctx.file_path for the thin CLI wrapper (hook-savepoint-pre),
-    # which only ever sets file_path directly and never populates savepoint_path.
-    path = ctx.savepoint_path || ctx.file_path
-    return ALLOW if path.nil? || path.empty?
-
-    abs = File.expand_path(path)
-    intent_dir = Bridge.intent_dir_for(abs)
-    return ALLOW unless intent_dir
-
-    begin
-      Bridge.append_started_savepoint(intent_dir, abs)
-    rescue StandardError
-      # best-effort; the ledger is rebuildable and the post line still lands
-    end
-    ALLOW
-  end
-
-  # --- lock-gate (intent 96, 111): fail-CLOSED delivery lock plus the artifact claim.
-  def lock_gate(ctx)
-    file_path = ctx.gate_path
-    return ALLOW if file_path.nil? || file_path.empty?
-
-    session = ctx.session
-    harness = ctx.harness
-
-    bridge_data = Bridge.discover_bridge(session: session, cwd: Dir.pwd)
-    reason = Bridge.lock_gate_decision(bridge_data, file_path, session: session, harness: harness)
-
-    unless reason
-      begin
-        dir = Bridge.intent_dir_for(file_path)
-        Lock.heartbeat(dir, session: session) if dir && !session.to_s.empty?
-      rescue StandardError
-        # ignore
-      end
-
-      begin
-        dir = Bridge.intent_dir_for(file_path)
-        artifact = File.basename(file_path) if dir
-        if dir && artifact
-          claim_reason = Claim.claim_gate_reason(dir, artifact, session: session, harness: harness)
-          return deny_json(claim_reason) if claim_reason
-
-          if Claim.fail_open?(dir, artifact)
-            $stderr.puts "plastic claim gate: unresolvable claim on #{artifact} in " \
-                         "intent #{Bridge.intent_id_from_dir(dir)} yielded; write " \
-                         "proceeds (see /plastic-lock status)"
-          end
-
-          Claim.heartbeat(dir, artifact, session: session) rescue nil
-        end
-      rescue StandardError
-        # ignore: a claim-gate bug must never block a write (fail open)
-      end
-
-      return ALLOW
-    end
-
-    deny_json(reason)
-  end
-
-  def deny_json(reason)
-    Deny.new(shape: :json, stdout: JSON.generate(
-      "hookSpecificOutput" => {
-        "hookEventName" => "PreToolUse",
-        "permissionDecision" => "deny",
-        "permissionDecisionReason" => reason,
-      }
-    ))
-  end
-
-  # --- code-gate (intents 27, 73c2, 150): stage rule OR worktree rule, first match wins.
-  def code_gate(ctx)
-    file_path = ctx.gate_path
-    return ALLOW if file_path.nil? || file_path.empty?
-
-    session = ctx.session
-    # Auditable escape (intent 150): mirrors the old Bash shim's independent
-    # ti["content"] || ti["new_string"] || "" computation for ARGV[2]. Kept
-    # local to code-gate; links-gate and create-gate never read it.
-    new_content = ctx.content || ctx.new_string || ""
-
-    if new_content && Bridge::PLASTIC_OK_RE.match?(new_content.chomp)
-      log_escape(session, file_path)
-      return ALLOW
-    end
-
-    bridge_data = Bridge.discover_bridge(session: session, cwd: file_path, edited_path: file_path)
-    return ALLOW unless bridge_data
-
-    reason = Bridge.code_gate_decision(bridge_data, file_path) ||
-             Bridge.worktree_gate_decision(bridge_data, file_path, current_session: session)
-    return ALLOW unless reason
-
-    Deny.new(shape: :stderr, lines: ["PLASTIC GATE — #{reason}"])
-  end
-
-  def log_escape(session, file_path)
-    require "fileutils"
-    log = File.join(Dir.home, ".plastic", ".cache", "gate-escapes.log")
-    FileUtils.mkdir_p(File.dirname(log))
-    File.open(log, "a") do |io|
-      io.puts("#{Time.now.utc.iso8601}\t#{session}\t#{file_path}")
-    end
-  rescue StandardError
-    # the escape still applies; logging is best-effort
-  end
-
-  # --- block log (intent 229): one TSV line per block, six tab-separated fields
-  # in a fixed order. Mirrors log_escape above exactly: best-effort, wrapped in
-  # rescue StandardError, so a logging failure can never change what a gate
-  # decided and can never raise. `path` is the injected seam a test uses to
-  # force the write to fail without eval, ENV, or a global.
-  def block_log_path
-    File.join(Dir.home, ".plastic", ".cache", "gate-blocks.log")
-  end
-
-  def log_block(gate:, session:, intent:, subject:, rule:, path: nil)
-    require "fileutils"
-    log = path || block_log_path
-    FileUtils.mkdir_p(File.dirname(log))
-    File.open(log, "a") do |io|
-      io.puts([Time.now.utc.iso8601, gate, session.to_s, intent.to_s,
-               collapse_ws(subject), collapse_ws(rule)].join("\t"))
-    end
-  rescue StandardError
-    # the block still applies; logging is best-effort
-  end
-
-  def collapse_ws(value)
-    value.to_s.gsub(/\s+/, " ").strip
-  end
-
-  # The reason text a Deny carries, per shape. Rescues to "" so a malformed
-  # outcome costs one field, never the line and never the decision.
-  def deny_reason(outcome)
-    if outcome.shape == :json
-      JSON.parse(outcome.stdout.to_s).dig("hookSpecificOutput", "permissionDecisionReason").to_s
-    else
-      Array(outcome.lines).join(" ")
-    end
-  rescue StandardError
-    ""
-  end
-
-  # "" when the path is not inside an intent dir, keeping the column count fixed.
-  def block_intent_id(path)
-    dir = Bridge.intent_dir_for(path.to_s)
-    dir ? Bridge.intent_id_from_dir(dir).to_s : ""
-  rescue StandardError
-    ""
-  end
-
-  # --- links-gate (intent 192): the write-time belt for the ## Links contract.
-  def links_gate(ctx)
-    path = ctx.file_path
-    return ALLOW if path.to_s.strip.empty?
-
-    abs = File.expand_path(path)
-    return ALLOW unless LinksGate.intent_file?(abs)
-
-    content = ctx.content_or_nil
-    old_string = ctx.old_string
-
-    before_content = File.exist?(abs) ? File.read(abs) : ""
-
-    after_content =
-      if !content.nil?
-        content
-      elsif !old_string.nil?
-        return ALLOW unless before_content.include?(old_string)
-        ctx.replace_all ? before_content.gsub(old_string, ctx.new_string.to_s)
-                        : before_content.sub(old_string, ctx.new_string.to_s)
-      else
-        return ALLOW # pathless mutation (no visible proposal); cannot judge, allow
-      end
-
-    plastic_home = ENV.fetch("PLASTIC_HOME") { File.join(Dir.home, ".plastic") }
-
-    reason = LinksGate.decision(file_path: abs, before_content: before_content,
-                                 after_content: after_content, plastic_home: plastic_home)
-    return ALLOW unless reason
-
-    Deny.new(shape: :stderr, lines: [reason])
-  end
-
-  # --- create-gate (intents 60b, 108 D7): validate the PROPOSED intent file content.
-  def create_gate(ctx)
-    path = ctx.file_path
-    return ALLOW if path.nil? || path.to_s.strip.empty?
-
-    abs = File.expand_path(path)
-    dir = File.dirname(abs)
-    is_intent_file = dir.match?(%r{/store/[^/]+--[^/]+\z}) &&
-                     File.basename(abs) == "#{File.basename(dir)}.md"
-    return ALLOW unless is_intent_file
-
-    content = ctx.content_or_nil
-    old_string = ctx.old_string
-
-    result =
-      if !content.nil?
-        IntentValidator.validate_content(content)
-      elsif !old_string.nil?
-        unless File.exist?(abs)
-          return Deny.new(shape: :stderr, lines: [
-            "PLASTIC CREATE GATE — #{File.basename(abs)} does not exist; " \
-            "create intents via new-intent / plastic-intent-creating.",
-          ])
-        end
-        current = File.read(abs)
-        return ALLOW unless current.include?(old_string)
-        simulated = ctx.replace_all ? current.gsub(old_string, ctx.new_string.to_s)
-                                    : current.sub(old_string, ctx.new_string.to_s)
-        IntentValidator.validate_content(simulated)
-      else
-        unless File.exist?(abs)
-          return Deny.new(shape: :stderr, lines: [
-            "PLASTIC CREATE GATE — #{File.basename(abs)}: cannot read proposed " \
-            "content and no file exists; refusing to allow an unvalidated intent write.",
-          ])
-        end
-        IntentValidator.validate_content(File.read(abs))
-      end
-
-    return ALLOW if result[:ok]
-
-    lines = ["PLASTIC CREATE GATE — #{File.basename(abs)} is not a valid intent:"]
-    result[:errors].each { |e| lines << "  #{e}" }
-    lines << "Create intents via new-intent / plastic-intent-creating; do not hand-author them."
-    Deny.new(shape: :stderr, lines: lines)
-  end
-
-  # Applicability (post-review fixes 1+2, intent 244): reproduces the Claude
-  # harness's OWN matcher semantics, not the dispatcher's earlier string
-  # equality. Two corrections:
-  #   - the harness matches an UNANCHORED REGEX (`"Write|Edit"` matches
-  #     "NotebookEdit" by substring), so applicability must too, or a gate
-  #     whose table entry never listed NotebookEdit explicitly stops firing on
-  #     it even though the old per-gate matcher group DID fire (a coverage
-  #     narrowing the byte-identical-behavior bar exists to catch);
-  #   - a missing/unrecognized tool_name means "the harness matched, but did
-  #     not name the tool", not "not our tool": the five old wrappers never
-  #     read tool_name at all, so they ALL ran on such a payload. Skipping
-  #     every gate here would be a coverage WEAKENING (the gate-weakening
-  #     direction is the dangerous one; see intent 203).
-  def tool_applies?(tool_name, tools)
-    return true if tool_name.to_s.empty?
-    Regexp.new(tools.join("|")).match?(tool_name.to_s)
-  end
-
-  # --- the ordered evaluation (spec D-a, D-i) -------------------------------
-  # `route` is injected so a test can supply a raising gate and prove isolation
-  # without eval, an ENV seam, or a global. `gate_tools` is injected for the same
-  # reason and defaults to the single source of truth.
-  # Returns the process exit code.
-  def dispatch(ctx:, route:, gate_tools: HookRegistry::GATE_TOOLS, out: $stdout, err: $stderr,
-               block_log: nil)
-    gate_tools.each do |gate, tools|
-      next unless tool_applies?(ctx.tool_name, tools)
-
-      begin
-        outcome = route.call(gate, ctx)
-        next unless outcome
-
-        # intent 229: one block-log line per deny, both shapes, one call site.
-        # Every helper here rescues internally, so nothing new can reach this
-        # method's rescue and turn a logging problem into a changed decision.
-        subject = ctx.gate_path.to_s.empty? ? ctx.file_path.to_s : ctx.gate_path.to_s
-        log_block(gate: gate, session: ctx.session, intent: block_intent_id(subject),
-                  subject: subject, rule: deny_reason(outcome), path: block_log)
-
-        if outcome.shape == :json
-          out.print outcome.stdout
-          return 0
-        else
-          outcome.lines.each { |line| err.puts line }
-          return 2
-        end
-      rescue StandardError => e
-        # Fix 7: outcome.shape / out.print / err.puts now live INSIDE the same
-        # rescue as route.call, so a malformed outcome or a stream write
-        # failure (e.g. EPIPE) is isolated exactly like a raising gate, and
-        # never aborts the gates still to come.
-        err.puts "plastic #{gate} error: #{e.message}"
-        next
-      end
-    end
-    0
-  end
-end

package/scripts/lib/links_gate.rb

@@ -1,140 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require_relative "intent_validator"
-require_relative "links_section"
-require_relative "links_projection"
-require_relative "store_discovery"
-require_relative "graph_rebuild"
-
-# LinksGate, the write-time belt for the PLASTIC.md `## Links` contract
-# (intent 192). Pure decision logic plus a small store-scanning glue (mirrors
-# the glue ProjectLinks and Doctor each already carry independently for
-# themselves; the CALCULATION is shared via LinksSection/LinksProjection so
-# gate, projector, and doctor can never disagree by construction, even though
-# each IO shell still does its own discovery, exactly as project-links and
-# doctor already do today).
-#
-# #decision is the single entry point the PreToolUse hook
-# (scripts/hook-links-gate) calls: given a file path and its BEFORE/AFTER
-# content (BEFORE = on-disk, AFTER = the proposed Write/Edit result), it
-# returns nil (allow) or a deny message (String). It only ever judges the
-# REAL, fence-aware `## Links` section (LinksSection.extract_section); an
-# edit that leaves that section untouched is always allowed, cheaply, with no
-# store scan at all.
-module LinksGate
-  module_function
-
-  DENY_MESSAGE =
-    "PLASTIC LINKS GATE - a ## Links line must come from the frontmatter " \
-    "sources/chain graph, never be hand-typed. This edit changes the ## Links " \
-    "section to something other than its frontmatter projection. Add the edge " \
-    "to sources or chain in frontmatter instead, then run scripts/project-links " \
-    "to regenerate ## Links.".freeze
-
-  # True iff `path` is an intent file inside its own equally-named store
-  # directory (store/<id>--<slug>/<id>--<slug>.md). Mirrors the create-gate
-  # path matcher (intent 60b) so the two gates agree on what "an intent file" is.
-  def intent_file?(path)
-    return false if path.to_s.strip.empty?
-
-    abs = File.expand_path(path)
-    dir = File.dirname(abs)
-    dir.match?(%r{/store/[^/]+--[^/]+\z}) && File.basename(abs) == "#{File.basename(dir)}.md"
-  end
-
-  # Decide whether to deny a Write/Edit whose proposed result is
-  # `after_content` (the on-disk content before the edit is `before_content`,
-  # "" when the file does not yet exist). Returns nil (allow, including every
-  # "cannot judge" case) or DENY_MESSAGE.
-  def decision(file_path:, before_content:, after_content:, plastic_home:)
-    return nil unless intent_file?(file_path)
-
-    before_links = safe_extract(before_content)
-    after_links = safe_extract(after_content)
-    return nil if before_links.nil? || after_links.nil? # ambiguous ## Links; cannot judge
-    return nil if before_links == after_links # this edit does not touch ## Links at all
-
-    fm = IntentValidator.parse_frontmatter_text(after_content.to_s)
-    return nil unless fm.is_a?(Hash) # no parseable frontmatter; cannot judge
-
-    referer_store = store_key_for(file_path, plastic_home)
-    return nil unless referer_store # not under any discovered store; cannot judge
-
-    ctx = build_context(plastic_home)
-    resolve = ->(ref) do
-      LinksProjection.resolve_ref_projection(
-        ref, referer_store: referer_store, relocation_map: ctx[:relocation_map],
-             store_index: ctx[:store_index], node_index: ctx[:node_index]
-      )
-    end
-
-    expected =
-      begin
-        LinksProjection.section(sources: Array(fm["sources"]), chain: Array(fm["chain"]),
-                                 resolve: resolve)
-      rescue LinksProjection::UnresolvedRef
-        return nil # a pre-existing dead frontmatter ref is a doctor finding, not this gate's job
-      end
-
-    after_links == expected ? nil : DENY_MESSAGE
-  end
-
-  # Fence-aware real-section extract, tolerant of an ambiguous file (returns
-  # nil rather than raising, so #decision can fail open on it).
-  def safe_extract(content)
-    LinksSection.extract_section(IntentValidator.body_of(content.to_s))
-  rescue LinksSection::AmbiguousLinks
-    nil
-  end
-
-  # Which discovered store (by store_index/node_index key) `file_path` lives
-  # under, or nil when it is not inside any store this plastic_home discovers.
-  def store_key_for(file_path, plastic_home)
-    abs = File.expand_path(file_path)
-    store_dir = File.dirname(File.dirname(abs)) # .../<store>/<id>--<slug>/<file>.md
-    StoreDiscovery.discover(plastic_home)[:stores]
-      .find { |s| File.expand_path(s[:store]) == store_dir }
-      &.fetch(:key)
-  end
-
-  # Build the store_index/node_index/relocation_map resolver context spanning
-  # every discovered store, the same shape ProjectLinks#run and Doctor each
-  # build for themselves. Re-scanned per call (no caching): this only runs on
-  # the rare edit that actually changes ## Links, so the cost is paid where it
-  # matters, not on every Edit/Write.
-  def build_context(plastic_home)
-    discovery = StoreDiscovery.discover(plastic_home)
-    store_index = {}
-    node_index = {}
-    index_texts = {}
-
-    discovery[:stores].each do |s|
-      nodes = load_nodes(s[:store])
-      store_index[s[:key]] = nodes.keys
-      node_index[s[:key]] = nodes.transform_values { |v| { basename: v[:basename], label: v[:label] } }
-      index_texts[s[:key]] = File.exist?(s[:index]) ? File.read(s[:index]) : ""
-    end
-
-    { store_index: store_index, node_index: node_index,
-      relocation_map: GraphRebuild.build_relocation_map(index_texts) }
-  end
-
-  # { id => { basename:, label: } } for one store directory.
-  def load_nodes(store_dir)
-    nodes = {}
-    Dir.children(store_dir).reject { |e| e.start_with?(".") }.sort.each do |entry|
-      dir = File.join(store_dir, entry)
-      next unless File.directory?(dir)
-
-      md = File.join(dir, "#{entry}.md")
-      next unless File.exist?(md)
-
-      fm = IntentValidator.parse_frontmatter(md)
-      next unless fm.is_a?(Hash) && fm["id"]
-
-      nodes[fm["id"].to_s] = { basename: entry, label: fm["intent"].to_s.strip }
-    end
-    nodes
-  end
-end

package/scripts/lib/qmd_hook.rb

@@ -1,41 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require_relative "qmd_sync"
-require_relative "power_tools"
-
-# QmdHook - decision logic for the power-tools UserPromptSubmit hook (intents 66,
-# 66b, 187, 246). Pure and dependency-injected: returns the additionalContext
-# string to emit, or nil to emit nothing. The executable hook wires real deps and
-# prints; this is unit-tested with fake detectors (no real qmd, no network, no
-# subprocess at all).
-#
-# It emits exactly one thing: the PowerTools mandate, one recommendation line per
-# present tool (qmd for finding intents, Enola-first for code navigation, falling
-# back to Serena; intent 187 added the enola_detector alongside the pre-existing
-# serena_detector).
-#
-# Intent 246 removed the scored qmd hit injection this hook used to prepend.
-# Intent 225 measured that injection at 0.24 intent-level recall@3 against a plain
-# ripgrep control at 0.18, while agent-driven `qmd query` scored 0.71. The failure
-# was recall, not latency, so caching and async were both rejected. QmdSync.search
-# is untouched and still backs the `scripts/qmd-sync search` CLI verb. All three
-# detectors are PATH and marker-file walks with no subprocess, which is why what is
-# left costs about a tenth of a second.
-module QmdHook
-  module_function
-
-  def run(cwd:, detector: QmdSync.method(:detect), serena_detector: nil,
-          enola_detector: nil)
-    serena_detector ||= -> { PowerTools.serena?(cwd: cwd) }
-    enola_detector ||= -> { PowerTools.enola?(cwd: cwd) }
-    qmd_present = !!detector.call
-    serena_present = !!serena_detector.call
-    enola_present = !!enola_detector.call
-    return nil unless qmd_present || serena_present || enola_present
-
-    PowerTools.mandate(cwd: cwd, qmd_detector: -> { qmd_present },
-                       serena_detector: -> { serena_present },
-                       enola_detector: -> { enola_present })
-  end
-end

package/scripts/lib/spec_header.rb

@@ -1,83 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# SpecHeader - the single implementation that parses the `Tier:` and `Settled:` lines out
-# of a spec.md's header block (intent 213). No script, skill, or hook re-implements this
-# grammar anywhere else; Bridge.savepoint_tier delegates here instead of carrying its own
-# copy of the Tier regex.
-#
-# Grammar (both lines live above the `# ` level-1 heading):
-#
-#   Tier: L
-#   Settled: yes (design fixed by the 2026-07-18 Fable advisor verdict)
-#
-# `Tier:` is exactly one of S, M, L; anything else is unparseable and yields nil. An ABSENT
-# `Settled:` line means not settled, there is no `Settled: no` variant. The parenthesised
-# reason is REQUIRED for a line to count as settled: a bare `Settled: yes` with no reason
-# does NOT parse as settled. D2 calls Settled a ONE-WAY DOOR (leniency accepted now can
-# never be tightened later), so this stays strict from the start rather than being loosened
-# once and then needing a breaking change to fix.
-module SpecHeader
-  module_function
-
-  # Mirrors Bridge::PLACEHOLDER_SENTINEL (scripts/lib/bridge.rb:22). Not required in from
-  # bridge.rb to avoid a require cycle: bridge.rb requires spec_header.rb, so spec_header.rb
-  # must have zero require_relative dependencies of its own.
-  PLACEHOLDER_SENTINEL = "<!-- plastic:placeholder -->"
-
-  HEADER_BLOCK_MAX_LINES = 10
-
-  TIER_RE = /\ATier:\s*(S|M|L)\z/
-  SETTLED_RE = /\ASettled:\s*yes\s*\((.*)\)\z/
-
-  # PURE. Parse a spec.md's raw text. Returns a Hash with symbol keys, always the same
-  # three keys: tier ("S"|"M"|"L"|nil), settled (true|false), settled_reason (String|nil).
-  def parse(text)
-    result = { tier: nil, settled: false, settled_reason: nil }
-    return result if text.nil?
-
-    lines = text.each_line.first(HEADER_BLOCK_MAX_LINES)
-    lines.each do |raw|
-      line = raw.chomp.strip
-      next if line.empty?
-      next if line == PLACEHOLDER_SENTINEL
-      break if line.start_with?("# ")
-
-      if (m = line.match(TIER_RE))
-        result[:tier] = m[1]
-      elsif (m = line.match(SETTLED_RE))
-        result[:settled] = true
-        result[:settled_reason] = m[1]
-      end
-    end
-
-    result
-  end
-
-  # Read at most the header block off disk and parse it. Returns the same Hash shape as
-  # `parse`, with every value nil/false when the path does not exist or cannot be read.
-  def parse_file(path)
-    lines = []
-    File.open(path) do |f|
-      HEADER_BLOCK_MAX_LINES.times do
-        line = f.gets
-        break if line.nil?
-        lines << line
-      end
-    end
-    parse(lines.join)
-  rescue StandardError
-    { tier: nil, settled: false, settled_reason: nil }
-  end
-
-  # Render the two header lines for a spec.md. `tier` is "S"|"M"|"L" or nil, `settled_reason`
-  # is a String or nil. Returns a String ending in one newline. A nil tier renders the
-  # placeholder `Tier: S|M|L`; a nil reason renders no Settled line at all (absent means not
-  # settled).
-  def render(tier: nil, settled_reason: nil)
-    lines = []
-    lines << "Tier: #{tier || 'S|M|L'}"
-    lines << "Settled: yes (#{settled_reason})" if settled_reason
-    "#{lines.join("\n")}\n"
-  end
-end