@zalom/plastic 1.0.0-beta.2 → 1.0.0-beta.21

package/scripts/lib/frontmatter_writer.rb

@@ -0,0 +1,130 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# FrontmatterWriter — pure, minimal, style-preserving rewrite of the `sources:`
+# and `chain:` arrays in an intent file's content string (intent 49).
+#
+# It rewrites ONLY those two arrays and leaves every other frontmatter line and
+# the entire body byte-identical. It preserves each array's existing serialization
+# style independently:
+#   - flow style: `sources: ["40", "1a"]`  (or `[]`)
+#   - block style: a `sources:` line followed by `  - '1a'` item lines
+# When the desired array equals the file's current value (same ids, same order),
+# the content is returned UNCHANGED so a re-run produces no diff (idempotency).
+#
+# Pure: no file IO, no eval, no global/ENV state. The IO shell reads/writes files.
+module FrontmatterWriter
+  module_function
+
+  # Rewrite `sources:`/`chain:` in `content`. `sources`/`chain` are the desired
+  # final arrays of id strings. Returns the new content (or the original when
+  # nothing changed). Only operates within the leading `---`...`---` frontmatter
+  # block; never touches the body.
+  def rewrite_arrays(content, sources:, chain:)
+    return content unless content.is_a?(String) && content.start_with?("---")
+
+    parts = content.split("---", 3)
+    return content if parts.length < 3
+
+    fm = parts[1]
+    body = parts[2]
+
+    fm = rewrite_one(fm, "sources", sources)
+    fm = rewrite_one(fm, "chain", chain)
+
+    "---#{fm}---#{body}"
+  end
+
+  # Rewrite a single `key:` array within the frontmatter text `fm`, preserving the
+  # key's existing flow-vs-block style. No-op when the key is absent or unchanged.
+  def rewrite_one(fm, key, desired)
+    lines = fm.lines
+    idx = lines.index { |l| l.match?(/\A#{Regexp.escape(key)}:\s/) || l.match?(/\A#{Regexp.escape(key)}:\s*\z/) }
+    return fm if idx.nil?
+
+    header = lines[idx]
+    if block_style?(lines, idx)
+      rewrite_block(lines, idx, key, desired)
+    else
+      rewrite_flow(lines, idx, header, key, desired)
+    end
+  end
+
+  # The key is block style when its own line carries no inline value and the next
+  # non-blank line is a `-` list item.
+  def block_style?(lines, idx)
+    header = lines[idx]
+    inline = header.sub(/\A[^:]+:/, "").strip
+    return false unless inline.empty?
+
+    nxt = lines[idx + 1]
+    !nxt.nil? && nxt.match?(/\A\s*-\s/)
+  end
+
+  # Flow style: replace the inline array on the header line, preserving indentation
+  # and any trailing newline. No-op when the current ids already match `desired`.
+  def rewrite_flow(lines, idx, header, key, desired)
+    current = parse_flow(header)
+    return lines.join if current == desired
+
+    newline = header.end_with?("\n") ? "\n" : ""
+    lines[idx] = "#{key}: #{render_flow(desired)}#{newline}"
+    lines.join
+  end
+
+  # Parse the inline flow array from a `key: [ ... ]` header line.
+  def parse_flow(header)
+    inline = header.sub(/\A[^:]+:/, "").strip
+    return [] if inline.empty? || inline == "[]"
+
+    inline = inline.sub(/\A\[/, "").sub(/\]\z/, "")
+    inline.split(",").map { |t| t.strip.gsub(/\A['"]|['"]\z/, "") }.reject(&:empty?)
+  end
+
+  def render_flow(ids)
+    return "[]" if ids.empty?
+
+    "[#{ids.map { |i| "\"#{i}\"" }.join(", ")}]"
+  end
+
+  # Block style: replace the contiguous `-` item lines following the header. No-op
+  # when the current ids already match `desired`. Preserves the item indentation
+  # and quoting style sampled from the existing first item.
+  def rewrite_block(lines, idx, key, desired)
+    last = idx
+    item_lines = []
+    (idx + 1).upto(lines.length - 1) do |i|
+      break unless lines[i].match?(/\A\s*-\s/)
+
+      item_lines << lines[i]
+      last = i
+    end
+
+    current = item_lines.map { |l| l.sub(/\A\s*-\s*/, "").strip.gsub(/\A['"]|['"]\z/, "") }
+    return lines.join if current == desired
+
+    indent, quote = block_item_shape(item_lines.first)
+    rendered = desired.map { |id| "#{indent}- #{quote}#{id}#{quote}\n" }
+
+    # When desired is empty, collapse the block to an inline `key: []` to keep YAML
+    # valid (a bare `key:` with no items parses as nil, not an empty array).
+    rendered = ["#{key}: []\n"] if desired.empty? && rendered.empty?
+
+    if desired.empty?
+      new_lines = lines[0...idx] + rendered + lines[(last + 1)..]
+    else
+      new_lines = lines[0...idx] + [lines[idx]] + rendered + lines[(last + 1)..]
+    end
+    new_lines.join
+  end
+
+  # Sample indentation and quote char from an existing block item line.
+  def block_item_shape(sample)
+    return ["", "'"] if sample.nil?
+
+    indent = sample[/\A\s*/].to_s
+    value = sample.sub(/\A\s*-\s*/, "").strip
+    quote = value.start_with?('"') ? '"' : "'"
+    [indent, quote]
+  end
+end

package/scripts/lib/graph_rebuild.rb

@@ -0,0 +1,328 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# GraphRebuild — pure logic for repairing the store-wide sources/chain graph
+# (intent 49). Mirrors the pure-module style of IntentValidator: module-function
+# helpers with no file IO. The IO shell (scripts/rebuild-graph) and doctor build
+# the in-memory maps and feed them here.
+#
+# Two concerns live here:
+#   1. Cross-store relocation. Each store's INDEX.md `## Relocated` log records
+#      moves like `global:24 → project:22c` (or backtick bare-id form `1b1a1 → 41`).
+#      build_relocation_map parses every log into a multi-hop-collapsed map; the
+#      resolver consults it BEFORE direct id resolution so a relocation always wins
+#      over a coincidentally-reused id (the `global:24` impostor hazard).
+#   2. The per-intent rebuild transform (intent 68 I-invariants, one-directional):
+#      dedupe -> I3 (formative edge wins) -> cross-store resolve -> I1 backlinks ->
+#      I2 preserved (relational chains survive).
+module GraphRebuild
+  module_function
+
+  RELOCATION_ARROW = "→" # the unicode → used in every Relocated log
+
+  # PURE. Parse every store's INDEX.md `## Relocated` block into a multi-hop
+  # relocation map.
+  #
+  # `index_texts` is { store_key => index_md_string } where store_key is "global"
+  # or "project:<slug>". Returns { [from_store, from_id] => [to_store, to_id] }
+  # with chains transitively collapsed to their final hop. The `to_store` token is
+  # NORMALIZED: the generic `project:` token in the global log is left as the
+  # literal it appears with; resolve_ref maps a same-family target to a bare id.
+  #
+  # Two real arrow forms are handled:
+  #   - `global:24 → project:22c`   (store-prefixed, global log)
+  #   - `1b1a1 → 41` inside backticks (bare ids, plastic log) — these are
+  #     same-store moves; from/to store both default to the store the log lives in.
+  def build_relocation_map(index_texts)
+    raw = {}
+    (index_texts || {}).each do |store_key, text|
+      next unless text.is_a?(String)
+
+      relocated_block(text).each_line do |line|
+        parse_relocation_line(line, store_key).each do |(from, to)|
+          raw[from] = to
+        end
+      end
+    end
+    collapse_multi_hop(raw)
+  end
+
+  # Extract the text of the `## Relocated` section (everything from the heading to
+  # the next top-level `## ` heading or EOF). Returns "" when absent.
+  def relocated_block(text)
+    lines = text.lines
+    start = lines.index { |l| l.strip == "## Relocated" }
+    return "" if start.nil?
+
+    rest = lines[(start + 1)..] || []
+    stop = rest.index { |l| l.start_with?("## ") }
+    (stop ? rest[0...stop] : rest).join
+  end
+
+  # Parse one log line into an array of [[from_store, from_id], [to_store, to_id]]
+  # pairs. A line may pack several comma-separated pairs and carry trailing prose
+  # in parens. Lines without an arrow yield []. `home_store` is the store whose
+  # log this line came from (used as the default store for bare ids).
+  def parse_relocation_line(line, home_store)
+    body = line.sub(/\A\s*-\s*/, "") # drop list bullet
+    return [] unless body.include?(RELOCATION_ARROW)
+
+    body.split(",").filter_map do |segment|
+      seg = segment.strip
+      next nil unless seg.include?(RELOCATION_ARROW)
+
+      left, right = seg.split(RELOCATION_ARROW, 2)
+      from = parse_token(left, home_store)
+      to = parse_token(right, home_store)
+      next nil if from.nil? || to.nil?
+
+      [from, to]
+    end
+  end
+
+  # Parse a single `store:id` / bare-id token (possibly wrapped in backticks or
+  # trailed by parenthetical prose) into [store_key, bare_id], or nil. A bare id
+  # defaults to `home_store`. The generic `project:` prefix is resolved later by
+  # resolve_ref against the referer's store family; here it is recorded literally.
+  def parse_token(token, home_store)
+    cleaned = token.to_s.tr("`", " ").strip
+    cleaned = cleaned.sub(/\s*\(.*\z/, "").strip # drop trailing "(prose"
+    cleaned = cleaned.split(/\s/).first.to_s     # first whitespace-delimited atom
+    return nil if cleaned.empty?
+
+    if cleaned.include?(":")
+      store_tok, id = cleaned.split(":", 2)
+      return nil if id.to_s.empty?
+
+      [normalize_store_token(store_tok), id]
+    else
+      [home_store, cleaned]
+    end
+  end
+
+  # Normalize a store token from a log to a store_key. "global" stays "global".
+  # The generic "project" token (used in the global log) is kept as the sentinel
+  # "project" — resolve_ref binds it to the referer's project family.
+  def normalize_store_token(tok)
+    t = tok.to_s.strip
+    t == "global" ? "global" : t
+  end
+
+  # Transitively collapse a → b → c chains so every key maps to its FINAL hop.
+  # Cycle-guarded. Keys/values are [store_key, id] pairs.
+  def collapse_multi_hop(raw)
+    raw.each_with_object({}) do |(from, _to), acc|
+      seen = [from]
+      cur = raw[from]
+      while cur && raw.key?(cur) && !seen.include?(cur)
+        seen << cur
+        cur = raw[cur]
+      end
+      acc[from] = cur
+    end
+  end
+
+  # PURE. Resolve a single ref (a `store:id` cross-store ref, or a bare same-store
+  # id) to a final location and classification. ORDER IS LOAD-BEARING: the
+  # relocation map is consulted FIRST, so a relocation wins over a coincidentally
+  # reused id.
+  #
+  #   ref             — "global:24" or "22c"
+  #   referer_store   — store_key of the intent carrying the ref ("global"/"project:plastic")
+  #   relocation_map  — from build_relocation_map
+  #   store_index     — { store_key => Array/Set of bare ids present in that store }
+  #
+  # Returns a Hash:
+  #   { status: :same_store, id: "<bare id>" }              -> collapse to bare id
+  #   { status: :cross_store, ref: "<store>:<id>" }         -> keep/repoint store:id
+  #   { status: :dead, ref: <original> }                    -> drop (resolves nowhere)
+  def resolve_ref(ref, referer_store:, relocation_map:, store_index:)
+    store_tok, bare = split_ref(ref, referer_store)
+
+    # 1) Relocation FIRST. Look up [store, id]; the generic "project" target token
+    #    is bound to the referer's family when emitting the location.
+    reloc_key = [store_tok, bare]
+    if (relocation_map || {}).key?(reloc_key)
+      to_store, to_id = relocation_map[reloc_key]
+      to_store = bind_project_token(to_store, referer_store, store_index, to_id)
+      return classify(to_store, to_id, referer_store, store_index, ref)
+    end
+
+    # 2) Direct resolution against the live store index.
+    classify(store_tok, bare, referer_store, store_index, ref)
+  end
+
+  # Split a ref into [store_key, bare_id]; bare refs take the referer's store.
+  def split_ref(ref, referer_store)
+    s = ref.to_s
+    if s.include?(":")
+      store_tok, id = s.split(":", 2)
+      [normalize_store_token(store_tok), id]
+    else
+      [referer_store, s]
+    end
+  end
+
+  # The global log writes relocation targets as the generic `project:` token. Bind
+  # it to the concrete store family that actually owns the bare id. Prefer the
+  # referer's store when it holds the id; otherwise pick any store that has it.
+  def bind_project_token(to_store, referer_store, store_index, to_id)
+    return to_store unless to_store == "project"
+
+    return referer_store if ids_in(store_index, referer_store).include?(to_id)
+
+    owner = (store_index || {}).keys.find { |k| ids_in(store_index, k).include?(to_id) }
+    owner || referer_store
+  end
+
+  # Map a ref store token to the canonical store_index key. Refs in frontmatter
+  # use the slug form (`global`, `knowdb`, `plastic`); store_index keys use
+  # `global` and `project:<slug>`. "global" is canonical; anything else maps to
+  # `project:<token>` when that key exists, else the token itself (it may already
+  # be a `project:<slug>` key, e.g. a relocation target).
+  def canonical_store_key(store_tok, store_index)
+    return store_tok if store_tok == "global"
+    return store_tok if (store_index || {}).key?(store_tok)
+
+    projected = "project:#{store_tok}"
+    (store_index || {}).key?(projected) ? projected : store_tok
+  end
+
+  # The slug form of a canonical store key, for emitting a cross-store `slug:id`
+  # ref (the form used in frontmatter). "global" stays "global"; "project:<slug>"
+  # becomes "<slug>".
+  def slug_of(canonical_key)
+    canonical_key.to_s.sub(/\Aproject:/, "")
+  end
+
+  # Classify a resolved (store, id) relative to the referer, using the live store
+  # index to detect dead targets:
+  #   - target id present in the referer's OWN store -> :same_store (collapse to bare)
+  #   - target id present in a DIFFERENT store       -> :cross_store (keep slug:id)
+  #   - target id present NOWHERE                     -> :dead (drop)
+  def classify(store_tok, bare, referer_store, store_index, original_ref)
+    canonical = canonical_store_key(store_tok, store_index)
+    if ids_in(store_index, canonical).include?(bare)
+      if canonical == referer_store
+        { status: :same_store, id: bare }
+      else
+        { status: :cross_store, ref: "#{slug_of(canonical)}:#{bare}" }
+      end
+    else
+      { status: :dead, ref: original_ref.to_s }
+    end
+  end
+
+  def ids_in(store_index, store_key)
+    Array((store_index || {})[store_key])
+  end
+
+  # PURE. Per-store rebuild transform (intent 68 I-invariants, one-directional).
+  # Deterministic and idempotent: a second call over the result yields zero changes.
+  #
+  #   nodes          — ONE store's { id => { sources: [...], chain: [...] } } map
+  #   referer_store  — that store's key ("global" / "project:<slug>")
+  #   relocation_map — from build_relocation_map (spans all stores)
+  #   store_index    — { store_key => bare ids present } (spans all stores)
+  #
+  # Returns { nodes: <new map>, changes: [ {intent:, kind:, before:, after:} ] }.
+  # kinds: :dedupe, :i3, :repoint, :collapse, :drop, :i1_backlink.
+  #
+  # Order is load-bearing (spec Phase 2):
+  #   1. dedupe each array order-preserving
+  #   2. I3: an id in BOTH sources and chain is kept in sources, dropped from chain
+  #   3. cross-store resolve each ref (relocation FIRST): repoint, collapse to bare
+  #      same-store, or drop dead
+  #   4. I1: for every in-store source s, ensure s.chain backlinks this intent
+  #   5. I2 preserved: never synthesize a reciprocal source, never strip a
+  #      relational chain entry
+  def rebuild_store(nodes, referer_store:, relocation_map:, store_index:)
+    out = {}
+    (nodes || {}).each do |id, edges|
+      edges = {} unless edges.is_a?(Hash)
+      out[id.to_s] = {
+        sources: Array(edges[:sources] || edges["sources"]).map(&:to_s),
+        chain: Array(edges[:chain] || edges["chain"]).map(&:to_s),
+      }
+    end
+
+    changes = []
+
+    out.each do |id, edges|
+      # 1. dedupe order-preserving
+      deduped_sources = edges[:sources].uniq
+      deduped_chain = edges[:chain].uniq
+      if deduped_sources != edges[:sources] || deduped_chain != edges[:chain]
+        changes << { intent: id, kind: :dedupe,
+                     before: { sources: edges[:sources].dup, chain: edges[:chain].dup },
+                     after: { sources: deduped_sources, chain: deduped_chain } }
+      end
+      edges[:sources] = deduped_sources
+      edges[:chain] = deduped_chain
+
+      # 2. I3: overlap kept in sources, dropped from chain
+      overlap = edges[:sources] & edges[:chain]
+      overlap.each do |o|
+        changes << { intent: id, kind: :i3, before: o, after: nil }
+      end
+      edges[:chain] -= overlap unless overlap.empty?
+
+      # 3. cross-store resolve sources and chain
+      %i[sources chain].each do |field|
+        rebuilt = []
+        edges[field].each do |ref|
+          unless ref.include?(":")
+            rebuilt << ref # bare same-store id, left as-is here (I4 is doctor's job)
+            next
+          end
+
+          res = resolve_ref(ref, referer_store: referer_store,
+                                 relocation_map: relocation_map, store_index: store_index)
+          case res[:status]
+          when :same_store
+            if res[:id] != ref
+              changes << { intent: id, kind: :collapse, field: field, before: ref, after: res[:id] }
+            end
+            rebuilt << res[:id]
+          when :cross_store
+            if res[:ref] != ref
+              changes << { intent: id, kind: :repoint, field: field, before: ref, after: res[:ref] }
+            end
+            rebuilt << res[:ref]
+          when :dead
+            changes << { intent: id, kind: :drop, field: field, before: ref, after: nil }
+            # dropped: not appended
+          end
+        end
+        # de-dupe again after collapse/repoint may have created duplicates
+        edges[field] = rebuilt.uniq
+      end
+
+      # 3b. Re-apply I3 AFTER resolution: a cross-store ref that collapses to a
+      #     bare same-store id can newly overlap an existing chain entry (e.g.
+      #     sources:[global:14a]→[19a] meeting chain:[19a]). Formative edge wins.
+      post_overlap = edges[:sources] & edges[:chain]
+      post_overlap.each do |o|
+        changes << { intent: id, kind: :i3, before: o, after: nil }
+      end
+      edges[:chain] -= post_overlap unless post_overlap.empty?
+    end
+
+    # 4. I1: in-store source backlinks (mutates OTHER nodes). Runs after resolution
+    #    so collapsed bare ids participate. Order-preserving append.
+    out.each do |id, edges|
+      edges[:sources].each do |s|
+        next if s.include?(":")        # cross-store: backlink lives in another store
+        next unless out.key?(s)        # unresolved bare id is an I4 dangler, not I1
+        next if out[s][:chain].include?(id)
+
+        before_chain = out[s][:chain].dup
+        out[s][:chain] = out[s][:chain] + [id]
+        changes << { intent: s, kind: :i1_backlink, field: :chain,
+                     before: before_chain, after: out[s][:chain].dup, backlink: id }
+      end
+    end
+
+    { nodes: out, changes: changes }
+  end
+end

package/scripts/lib/insights.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# insights.rb - the blessed write path for an intent's `## Insights` section
+# (intent 82). A sibling library to bridge.rb so the insight write path stays
+# independent of the savepoint ledger (the spec forbids touching the ledger).
+#
+# Every entry leads with a fixed, machine-parseable prefix
+# `{utc-iso8601} · {stage} · {author}` where the timestamp is `now.utc.iso8601`,
+# the SAME convention `Bridge.append_savepoint_line` uses, so the store has one
+# timestamp convention across both ledgers. Entries are append-only, newest at
+# the BOTTOM (the [[34]] ordering law): the per-entry prefix is not prepending
+# the entry, and existing entries are never reordered.
+
+require "time"
+require_relative "bridge"
+
+module Insights
+  HEADING = "## Insights"
+  # The middle dot (U+00B7) with a single space on each side separates the
+  # timestamp, stage, and author fields.
+  SEPARATOR = " · "
+  # A well-formed prefix: UTC ISO8601 timestamp to the second with a trailing
+  # `Z`, then a non-empty stage, then a non-empty author, each ` · `-separated.
+  PREFIX_RE = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z · [^·]+ · [^·]+/.freeze
+
+  # Append one insight entry at the BOTTOM of the `## Insights` section of the
+  # intent file, creating the section (or the file) if absent. `now:` is the DI
+  # seam: defaults to Time.now, tests inject Time.utc(...). Raises ArgumentError
+  # if the assembled prefix is not well-formed (guard on write).
+  def self.append_insight(intent_dir, text, stage:, author:, now: Time.now)
+    prefix = "#{now.utc.iso8601}#{SEPARATOR}#{stage}#{SEPARATOR}#{author}"
+    unless valid_insight_prefix?(prefix)
+      raise ArgumentError, "malformed insight prefix: #{prefix.inspect}"
+    end
+
+    entry = "#{prefix} — #{text}"
+    path = Bridge.intent_file(intent_dir)
+    File.write(path, with_entry(File.exist?(path) ? File.read(path) : "", entry))
+    entry
+  end
+
+  # Pure validator: true when `line` begins with a well-formed prefix. No IO,
+  # no clock. Rejects a date-only prefix, a missing separator, a missing `Z`,
+  # and sub-second precision.
+  def self.valid_insight_prefix?(line)
+    line.is_a?(String) && line.match?(PREFIX_RE)
+  end
+
+  # Insert `entry` at the bottom of the `## Insights` section of `content`,
+  # preserving every existing line and their order. Pure string transform.
+  def self.with_entry(content, entry)
+    lines = content.empty? ? [] : content.split("\n", -1)
+    heading_idx = lines.index { |l| l.strip == HEADING }
+    return append_new_section(lines, entry) if heading_idx.nil?
+
+    insert_at = section_end(lines, heading_idx)
+    lines.insert(insert_at, entry)
+    lines.join("\n")
+  end
+
+  # The insertion index for a new entry: just after the last non-empty content
+  # line that belongs to the `## Insights` section (before the next `## `
+  # heading or EOF).
+  def self.section_end(lines, heading_idx)
+    last_content = heading_idx
+    idx = heading_idx + 1
+    while idx < lines.length
+      break if lines[idx].start_with?("## ")
+
+      last_content = idx unless lines[idx].strip.empty?
+      idx += 1
+    end
+    last_content + 1
+  end
+
+  # Append a fresh `## Insights` section (blank line, heading, entry) to the end
+  # of the existing content.
+  def self.append_new_section(lines, entry)
+    body = lines.join("\n")
+    body = body.sub(/\n+\z/, "") unless body.empty?
+    pieces = body.empty? ? [] : [body, ""]
+    pieces << HEADING << entry
+    "#{pieces.join("\n")}\n"
+  end
+end

package/scripts/lib/installer_core.rb

@@ -203,16 +203,30 @@ class InstallerCore
       "scripts/hook-continue" => "scripts/hook-continue",
       "scripts/hook-future-intent-check" => "scripts/hook-future-intent-check",
       "scripts/hook-gate-check" => "scripts/hook-gate-check",
+      "scripts/hook-savepoint-pre" => "scripts/hook-savepoint-pre",
       "scripts/hook-qmd-search" => "scripts/hook-qmd-search",
       "scripts/lib/qmd_hook.rb" => "scripts/lib/qmd_hook.rb",
+      "scripts/lib/power_tools.rb" => "scripts/lib/power_tools.rb",
       "scripts/hook-code-gate" => "scripts/hook-code-gate",
       "scripts/hook-bash-gate" => "scripts/hook-bash-gate",
+      "scripts/hook-retrieval-gate" => "scripts/hook-retrieval-gate",
+      "scripts/lib/retrieval_gate.rb" => "scripts/lib/retrieval_gate.rb",
       "scripts/hook-auto-arm" => "scripts/hook-auto-arm",
       "scripts/lib/bridge.rb" => "scripts/lib/bridge.rb",
+      "scripts/lib/insights.rb" => "scripts/lib/insights.rb",
+      "scripts/lib/worktree.rb" => "scripts/lib/worktree.rb",
       "scripts/lib/boot_banner.rb" => "scripts/lib/boot_banner.rb",
       "scripts/lib/qmd_sync.rb" => "scripts/lib/qmd_sync.rb",
       "scripts/qmd-sync" => "scripts/qmd-sync",
       "scripts/lib/intent_validator.rb" => "scripts/lib/intent_validator.rb",
+      "scripts/lib/graph_rebuild.rb" => "scripts/lib/graph_rebuild.rb",
+      "scripts/lib/frontmatter_writer.rb" => "scripts/lib/frontmatter_writer.rb",
+      "scripts/lib/links_projection.rb" => "scripts/lib/links_projection.rb",
+      "scripts/lib/links_section.rb" => "scripts/lib/links_section.rb",
+      "scripts/lib/link_suggestions.rb" => "scripts/lib/link_suggestions.rb",
+      "scripts/project-links" => "scripts/project-links",
+      "scripts/link-suggest" => "scripts/link-suggest",
+      "scripts/rebuild-graph" => "scripts/rebuild-graph",
       "scripts/validate-intent" => "scripts/validate-intent",
       "scripts/new-intent" => "scripts/new-intent",
       "scripts/hook-create-gate" => "scripts/hook-create-gate",
@@ -556,6 +570,15 @@ class InstallerCore
             { "type" => "command", "command" => "#{hook_dir}/plastic-create-gate", "statusMessage" => "Checking create gate..." },
           ],
         },
+        # Retrieval gate (intent 84, Lever 2): redirects store-markdown reads to
+        # QMD and code reads to Serena when those tools are present. Binds the
+        # main agent AND subagents (PreToolUse applies to subagent tool calls).
+        {
+          "matcher" => "Bash|Read|Grep|Glob",
+          "hooks" => [
+            { "type" => "command", "command" => "#{hook_dir}/plastic-retrieval-gate", "statusMessage" => "Checking retrieval gate..." },
+          ],
+        },
       ],
       "PostToolUse" => {
         "matcher" => "Write|Edit",