@zalom/plastic 1.0.0-beta.1 → 1.0.0-beta.10

package/scripts/lib/links_section.rb

@@ -0,0 +1,207 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "intent_validator"
+
+# LinksSection — pure, minimal, style-preserving rewrite of ONLY the `## Links`
+# section of an intent file's content string (intent 72). Mirrors the discipline of
+# FrontmatterWriter: pure (no file IO, no eval, no global/ENV state), and returns
+# the original content UNCHANGED when nothing changed (idempotency).
+#
+# `## Links` is canonically the LAST sanctioned section
+# (IntentValidator::SANCTIONED_SECTIONS = Intent, Context, Outcome, Insights,
+# Links), and real intents put it last. So a file with an existing `## Links` has
+# its section replaced in place (from the heading to the next top-level `## `
+# heading or EOF), and a file WITHOUT a `## Links` gets one appended at end-of-body,
+# separated by exactly one blank line, preserving the body's trailing-newline shape.
+#
+# FENCE AWARENESS (intent 72 corruption fix): a `## Links` heading INSIDE a fenced
+# code block (``` or ~~~, possibly with an info string like ```markdown) is part of
+# an EXAMPLE, not a real section. All section scanning here IGNORES headings inside
+# fences and only ever targets the REAL `## Links` section (outside any fence). The
+# section end is the next `## ` heading that is ALSO outside a fence, so a replace
+# never consumes or unbalances a code fence. If more than one REAL `## Links`
+# heading exists, #rewrite raises AmbiguousLinks rather than guess.
+#
+# Frontmatter is NEVER touched: the leading `---`...`---` block is preserved
+# byte-for-byte and only the body is rebuilt.
+module LinksSection
+  module_function
+
+  HEADING = "## Links"
+
+  # A fence delimiter: ``` or ~~~ (any length >= 3), optional leading whitespace,
+  # optional info string (e.g. ```markdown). Mirrors CommonMark fenced-code rules
+  # closely enough for intent bodies.
+  FENCE_RE = /\A\s*(`{3,}|~{3,})/
+
+  # Raised when a body has more than one REAL `## Links` heading outside any fence;
+  # the tool must fail loud rather than guess which one to rewrite.
+  class AmbiguousLinks < StandardError
+    def initialize(count)
+      super("found #{count} real `## Links` headings outside code fences; refusing to guess")
+    end
+  end
+
+  # PURE. Replace (or insert) the REAL `## Links` section in `content` with
+  # `section_text` (the canonical block from LinksProjection.section, which begins
+  # with the `## Links` heading line and ends with a single trailing newline).
+  # Returns the new content, or the original when nothing changed. Raises
+  # AmbiguousLinks when more than one real `## Links` heading exists.
+  def rewrite(content, section_text)
+    return content unless content.is_a?(String)
+
+    fm, body = split_frontmatter(content)
+    new_body = rewrite_body(body, section_text)
+    updated = "#{fm}#{new_body}"
+    updated == content ? content : updated
+  end
+
+  # Split content into [frontmatter_with_delimiters, body]. When there is no
+  # frontmatter block, the frontmatter part is "" and the whole content is the
+  # body. The frontmatter part is preserved byte-for-byte by the caller.
+  def split_frontmatter(content)
+    return ["", content] unless content.start_with?("---")
+
+    parts = content.split("---", 3)
+    return ["", content] if parts.length < 3
+
+    ["---#{parts[1]}---", parts[2]]
+  end
+
+  # Rewrite ONLY the REAL `## Links` section within the body text.
+  def rewrite_body(body, section_text)
+    bounds = links_bounds(body)
+    if bounds
+      replace_section(body, section_text, bounds)
+    else
+      insert_section(body, section_text)
+    end
+  end
+
+  # PURE. Locate the REAL `## Links` section (fence-aware). Returns
+  # [start_index, end_index] line indices into body.lines, where start_index is the
+  # `## Links` heading line and end_index is the index of the next out-of-fence
+  # `## ` heading (or lines.length at EOF). Returns nil when there is no real
+  # `## Links` heading. Raises AmbiguousLinks when more than one exists.
+  def links_bounds(body)
+    lines = body.to_s.lines
+    starts = real_links_heading_indices(lines)
+    return nil if starts.empty?
+    raise AmbiguousLinks, starts.length if starts.length > 1
+
+    start = starts.first
+    stop = next_out_of_fence_heading(lines, start + 1)
+    [start, stop]
+  end
+
+  # PURE. Indices of every `## Links` heading line that is OUTSIDE any code fence.
+  # Accepts a body String or an Array of lines.
+  def real_links_heading_indices(body_or_lines)
+    lines = body_or_lines.is_a?(Array) ? body_or_lines : body_or_lines.to_s.lines
+    indices = []
+    in_fence = false
+    fence_marker = nil
+    lines.each_with_index do |line, i|
+      if (m = fence_open_close(line, in_fence, fence_marker))
+        in_fence = m[:in_fence]
+        fence_marker = m[:marker]
+        next
+      end
+      indices << i if !in_fence && line.rstrip == HEADING
+    end
+    indices
+  end
+
+  # PURE. Index of the first `## ` heading at or after `from` that is OUTSIDE any
+  # code fence. Returns lines.length when none (EOF). Fence state is recomputed
+  # from the top so nested example fences after the real heading are respected.
+  def next_out_of_fence_heading(lines, from)
+    in_fence = false
+    fence_marker = nil
+    lines.each_with_index do |line, i|
+      if (m = fence_open_close(line, in_fence, fence_marker))
+        in_fence = m[:in_fence]
+        fence_marker = m[:marker]
+        next
+      end
+      return i if i >= from && !in_fence && line.start_with?("## ")
+    end
+    lines.length
+  end
+
+  # PURE. Given the current fence state, decide whether `line` is a fence delimiter
+  # and return the new state, or nil when the line is not a fence delimiter.
+  # An opening fence records its marker family (` or ~); a closing fence must use a
+  # marker of the SAME family and carry no info string.
+  def fence_open_close(line, in_fence, fence_marker)
+    m = line.match(FENCE_RE)
+    return nil unless m
+
+    marker = m[1]
+    family = marker[0] # "`" or "~"
+    if in_fence
+      # A closing fence uses the same family, length >= the opener, no info string.
+      rest = line.sub(FENCE_RE, "").strip
+      if family == fence_marker && rest.empty?
+        { in_fence: false, marker: nil }
+      else
+        # A delimiter of the OTHER family (or an info-string line) inside a fence is
+        # literal content, not a fence event.
+        nil
+      end
+    else
+      { in_fence: true, marker: family }
+    end
+  end
+
+  # True iff the body has a REAL (out-of-fence) `## Links` heading. Used by callers
+  # to classify regenerate-vs-add without re-deriving fence state.
+  def links_heading?(body)
+    !real_links_heading_indices(body.to_s.lines).empty?
+  end
+
+  # Replace the REAL `## Links` section (the [start, stop] line bounds) with
+  # `section_text`, preserving everything before the heading and after the section
+  # byte-for-byte (including any fenced example that lives BEFORE the real section).
+  def replace_section(body, section_text, bounds)
+    lines = body.lines
+    start, stop = bounds
+    before = lines[0...start].join
+    tail = (lines[stop..] || [])
+
+    # `section_text` already ends with exactly one newline. When there is trailing
+    # content (another section follows), separate the block from it with one blank
+    # line; otherwise the section ends the body.
+    block = tail.empty? ? section_text : "#{section_text}\n"
+    "#{before}#{block}#{tail.join}"
+  end
+
+  # Append a `## Links` section at end-of-body, after the last existing section,
+  # separated by exactly one blank line, preserving the body's trailing newline.
+  def insert_section(body, section_text)
+    trimmed = body.to_s.sub(/\s+\z/, "")
+    if trimmed.empty?
+      # An empty body (no sections) just becomes the section.
+      section_text
+    else
+      "#{trimmed}\n\n#{section_text}"
+    end
+  end
+
+  # PURE. Extract the REAL `## Links` section text (fence-aware), normalized to the
+  # canonical block shape the projection emits: heading line + entry lines + a
+  # single trailing newline. Returns "" when there is no real section. Shared by
+  # the IO shell's audit and the doctor drift check so all three agree on the
+  # location. Raises AmbiguousLinks when more than one real heading exists.
+  def extract_section(body)
+    bounds = links_bounds(body)
+    return "" if bounds.nil?
+
+    start, stop = bounds
+    lines = body.to_s.lines
+    section = lines[(start + 1)...stop].join.sub(/\n+\z/, "\n")
+    section = "" if section.strip.empty?
+    "#{HEADING}\n#{section}"
+  end
+end

package/scripts/lib/power_tools.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "qmd_sync"
+
+# PowerTools — detect-then-degrade harness for Plastic's optional power-tools
+# (intent 66b). It owns deterministic detection of each tool and builds an
+# obligation ("mandate") string for whichever tools are present, so the agent is
+# obliged (not merely reminded) to use them: QMD for finding intents, Serena for
+# code navigation.
+#
+# Strictly detect-then-degrade: a tool that is absent contributes nothing, and
+# `mandate` returns nil when no tool is present. Nothing here installs anything.
+#
+# Pure and dependency-injected: every detection runs through an injected callable
+# or keyword probe (PATH scan / `.serena` marker walk), so the whole module is
+# unit-testable with no real binaries, no network, and no global/ENV state.
+module PowerTools
+  module_function
+
+  # True when QMD is present. Reuses QmdSync.detect (PATH probe), injectable.
+  def qmd?(detector: QmdSync.method(:detect))
+    !!detector.call
+  end
+
+  # True when Serena is present: a `.serena` directory exists in cwd or any
+  # ancestor, OR `serena` is resolvable on PATH. Both probes are injectable so
+  # tests do not depend on the host having Serena installed.
+  def serena?(cwd:, path_probe: method(:which_serena), marker_finder: method(:serena_marker?))
+    return true if marker_finder.call(cwd)
+    !!path_probe.call
+  end
+
+  # True when `serena` is an executable on PATH. Mirrors QmdSync.which_qmd.
+  def which_serena
+    ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+      candidate = File.join(dir, "serena")
+      File.file?(candidate) && File.executable?(candidate)
+    end
+  end
+
+  # Walk up from cwd to the filesystem root, returning true if any level holds a
+  # `.serena` directory.
+  def serena_marker?(cwd)
+    dir = File.expand_path(cwd)
+    loop do
+      return true if Dir.exist?(File.join(dir, ".serena"))
+      parent = File.dirname(dir)
+      break if parent == dir
+      dir = parent
+    end
+    false
+  end
+
+  # Obligation text for whichever tools are present, joined by newlines, or nil
+  # when none are. One MANDATORY line per present tool.
+  def mandate(cwd:, qmd_detector: QmdSync.method(:detect), serena_detector: nil)
+    lines = []
+
+    if qmd?(detector: qmd_detector)
+      lines << "MANDATORY: you MUST use QMD (`qmd search` / `qmd query` over the " \
+               "`plastic-*` collections) to check for an existing or related intent " \
+               "before treating this as new work; do not grep/Read the store first."
+    end
+
+    serena_present = serena_detector ? !!serena_detector.call : serena?(cwd: cwd)
+    if serena_present
+      lines << "MANDATORY: you MUST use Serena's symbolic tools (find_symbol / " \
+               "get_symbols_overview / find_referencing_symbols) for code navigation " \
+               "before grep/Read."
+    end
+
+    return nil if lines.empty?
+    lines.join("\n")
+  end
+end

package/scripts/lib/qmd_hook.rb

@@ -2,43 +2,56 @@
 # frozen_string_literal: true
 
 require_relative "qmd_sync"
+require_relative "power_tools"
 
-# QmdHook — decision logic for the qmd-first UserPromptSubmit hook (intent 66).
-# 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 a fake runner/detector (no real qmd, no network).
+# QmdHook — decision logic for the power-tools UserPromptSubmit hook (intents 66,
+# 66b). 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 a fake runner/detector (no real qmd, no network).
+#
+# When qmd is present it still injects scored qmd hits (intent 66), then appends
+# the PowerTools mandate (a MUST obligation per present tool: qmd for finding
+# intents, serena for code navigation) instead of the old soft reminder.
 module QmdHook
   module_function
 
   MIN_PROMPT_LENGTH = 10
-  REMINDER = "qmd is available: query it (`qmd search` / `qmd query` over the " \
-             "`plastic-*` collections) before grep/Read when gathering intent " \
-             "context (sources/chain) or checking whether this work already " \
-             "exists as an intent."
 
   def run(prompt:, cwd:, plastic_home:, runner: QmdSync.default_runner,
-          detector: QmdSync.method(:detect), limit: 3, min_score: 0.5)
-    return nil unless detector.call
-    p = prompt.to_s.strip
-    return nil if p.length < MIN_PROMPT_LENGTH
-    return nil if p.downcase == "continue"
+          detector: QmdSync.method(:detect), limit: 3, min_score: 0.5,
+          serena_detector: nil)
+    serena_detector ||= -> { PowerTools.serena?(cwd: cwd) }
+    qmd_present = !!detector.call
+    serena_present = !!serena_detector.call
+    return nil unless qmd_present || serena_present
 
-    collections = QmdSync.collections_for_cwd(cwd, plastic_home: plastic_home)
-    hits = QmdSync.search(p, collections: collections, limit: limit,
-                          min_score: min_score, runner: runner, detector: detector)
+    p = prompt.to_s.strip
+    # The hit SEARCH is the only expensive step and the only one gated by prompt
+    # triviality: skip it for short or bare-"continue" prompts (and when qmd is
+    # absent). The mandate itself is always-on for whichever tools are present.
+    search_ok = qmd_present && p.length >= MIN_PROMPT_LENGTH && p.downcase != "continue"
 
     parts = []
-    if hits.any?
-      parts << "Related / prior Plastic intents (qmd BM25, includes completed) — " \
-               "check before treating this as new work:"
-      hits.each do |h|
-        loc = h[:file].to_s.sub(%r{\Aqmd://}, "")
-        pct = (h[:score] * 100).round
-        parts << "- [#{pct}%] #{loc} — #{h[:title]}"
+    if search_ok
+      collections = QmdSync.collections_for_cwd(cwd, plastic_home: plastic_home)
+      hits = QmdSync.search(p, collections: collections, limit: limit,
+                            min_score: min_score, runner: runner, detector: detector)
+      if hits.any?
+        parts << "Related / prior Plastic intents (qmd BM25, includes completed) — " \
+                 "check before treating this as new work:"
+        hits.each do |h|
+          loc = h[:file].to_s.sub(%r{\Aqmd://}, "")
+          pct = (h[:score] * 100).round
+          parts << "- [#{pct}%] #{loc} — #{h[:title]}"
+        end
+        parts << ""
       end
-      parts << ""
     end
-    parts << REMINDER
+
+    mandate = PowerTools.mandate(cwd: cwd, qmd_detector: -> { qmd_present },
+                                 serena_detector: -> { serena_present })
+    parts << mandate if mandate
+    return nil if parts.empty?
     parts.join("\n")
   end
 end

package/scripts/lib/qmd_sync.rb

@@ -99,6 +99,27 @@ module QmdSync
     { ran: true, ok: (ok1 && ok2) }
   end
 
+  # Non-blocking reindex for the completion path. QMD has no incremental reindex
+  # (`qmd update` is a full rescan, `qmd embed -c` re-embeds the whole collection,
+  # ~2 min), so running it inline would block the agent's turn; spawning detached
+  # returns immediately. No-op when qmd absent. Spawner/detector are injected so
+  # tests assert behavior with no real qmd and no real spawned process.
+  def reindex_async(collection:, detector: method(:detect), spawner: method(:default_async_spawner))
+    return skip_result unless detector.call
+    pid = spawner.call(collection)
+    { ran: true, async: true, pid: pid }
+  end
+
+  # Default spawner: launch `qmd update && qmd embed -c <collection>` detached and
+  # non-blocking, discarding output, then detach so it never blocks the turn.
+  def default_async_spawner(collection)
+    require "shellwords"
+    cmd = "qmd update && qmd embed -c #{Shellwords.escape(collection)}"
+    pid = Process.spawn(cmd, out: File::NULL, err: File::NULL, pgroup: true)
+    Process.detach(pid)
+    pid
+  end
+
   # Read-only status used by doctor and the session-start report line.
   # Returns a structured hash; never mutates the index.
   def status(plastic_home:, runner: default_runner, detector: method(:detect))

package/scripts/new-intent

@@ -26,6 +26,9 @@ require "fileutils"
 require "date"
 require_relative "lib/bridge"
 require_relative "lib/intent_validator"
+require_relative "lib/graph_rebuild"
+require_relative "lib/links_projection"
+require_relative "lib/links_section"
 
 # --- Explicit flag parsing (no eval, no global injection) ------------------
 
@@ -73,25 +76,152 @@ def render_tokens(text, tokens)
   tokens.reduce(text) { |acc, (k, v)| acc.gsub("{{#{k}}}", v.to_s) }
 end
 
-# Append a wikilink line under the file's `## Links` section, idempotently.
-def append_link(file_path, link_line)
+# Add an id to a source intent's frontmatter `chain` array, idempotently (I1
+# reciprocity: `child in parent.sources` => `parent.chain` gains `child`). A
+# targeted edit of the `chain:` line only; the body (including `## Links`) is
+# preserved byte-for-byte and no other frontmatter key is touched, so the file
+# stays born-complete. Renders the array in flow style (`["a", "b"]`) to match
+# templates/intent.md. No-op when the id is already present.
+def add_to_chain(file_path, new_id)
   return unless File.exist?(file_path)
   content = File.read(file_path)
-  return if content.include?(link_line)
+  return unless content.start_with?("---")
 
-  lines = content.lines
-  idx = lines.index { |l| l.strip == "## Links" }
-  return unless idx
+  parts = content.split("---", 3)
+  return unless parts.length >= 3
 
-  insert_at = lines.length
-  ((idx + 1)...lines.length).each do |j|
-    if lines[j].strip.start_with?("## ")
-      insert_at = j
-      break
+  fm = parts[1]
+  chain_line = fm.lines.find { |l| l.match?(/\A\s*chain\s*:/) }
+  return unless chain_line
+
+  existing = fm.match(/\bchain\s*:\s*\[(.*?)\]/m)
+  ids =
+    if existing
+      existing[1].scan(/"([^"]*)"|'([^']*)'/).flatten.compact
+    else
+      []
     end
+  return if ids.include?(new_id)
+
+  ids << new_id
+  rendered = "chain: [#{ids.map { |i| "\"#{i}\"" }.join(", ")}]"
+  new_fm = fm.sub(/^\s*chain\s*:.*$/, rendered)
+  File.write(file_path, ["", new_fm, parts[2]].join("---"))
+end
+
+# Derive [plastic_home, referer_store_key] from a store directory path so the
+# cross-store resolver (shared with project-links and the doctor check) can be
+# built. A global store is `<home>/store` (key "global"); a project store is
+# `<home>/projects/<slug>/store` (key "project:<slug>"). Returns
+# [nil, "global"] only if the layout is unrecognized, in which case Links
+# projection falls back to single-store resolution rooted at this store.
+def store_context(store)
+  store = File.expand_path(store)
+  parent = File.dirname(store)               # `<home>` or `<home>/projects/<slug>`
+  if File.basename(store) == "store" && File.basename(File.dirname(parent)) == "projects"
+    slug = File.basename(parent)
+    home = File.dirname(File.dirname(parent)) # strip projects/<slug>
+    [home, "project:#{slug}"]
+  elsif File.basename(store) == "store"
+    [parent, "global"]                        # `<home>/store`
+  else
+    [parent, "global"]
   end
-  lines.insert(insert_at, "#{link_line}\n")
-  File.write(file_path, lines.join)
+end
+
+# The in-scope stores under `plastic_home`, each { key:, store: }. Mirrors
+# project-links/RebuildGraph#stores so cross-store resolution spans the family.
+def family_stores(plastic_home)
+  list = []
+  global_store = File.join(plastic_home, "store")
+  list << { key: "global", store: global_store } if File.directory?(global_store)
+  %w[plastic knowdb].each do |slug|
+    store = File.join(plastic_home, "projects", slug, "store")
+    list << { key: "project:#{slug}", store: store } if File.directory?(store)
+  end
+  list
+end
+
+# Build the cross-store maps the LinksProjection resolver needs:
+#   store_index    => { store_key => [bare ids] }
+#   node_index     => { store_key => { id => { basename:, label: } } }
+#   relocation_map => from GraphRebuild.build_relocation_map over every INDEX.md
+# `fallback_store` is the store the new intent lives in; it is always included so
+# resolution works even for a brand-new store with no INDEX.md yet.
+def build_cross_store_maps(plastic_home, fallback_store_key, fallback_store_dir)
+  stores = family_stores(plastic_home)
+  # Ensure the fallback store is represented even if family discovery missed it.
+  unless stores.any? { |s| s[:key] == fallback_store_key }
+    stores << { key: fallback_store_key, store: fallback_store_dir }
+  end
+
+  store_index = Hash.new { |h, k| h[k] = [] }
+  node_index = Hash.new { |h, k| h[k] = {} }
+  index_texts = {}
+
+  stores.each do |s|
+    next unless File.directory?(s[:store])
+
+    Dir.children(s[:store]).reject { |e| e.start_with?(".") }.sort.each do |entry|
+      dir = File.join(s[:store], 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"]
+
+      id = fm["id"].to_s
+      store_index[s[:key]] << id
+      node_index[s[:key]][id] = { basename: entry, label: fm["intent"].to_s.strip }
+    end
+
+    idx = File.join(File.dirname(s[:store]), "INDEX.md")
+    index_texts[s[:key]] = File.read(idx) if File.exist?(idx)
+  end
+
+  relocation_map = GraphRebuild.build_relocation_map(index_texts)
+  { store_index: store_index, node_index: node_index, relocation_map: relocation_map }
+end
+
+# Re-project ONE intent file's `## Links` as the canonical I5 projection of its
+# OWN frontmatter sources+chain, using the shared cross-store resolver. Writes the
+# file only if the section changed (idempotent). Born-canonical: a fresh root with
+# no edges gets the empty-state comment; the fence-aware rewriter touches only the
+# real `## Links` section. Returns true on success, false when the intent could
+# not be read or a ref was unresolvable (left unwritten, never a guessed link).
+def project_links_for(file_path, referer_store_key, maps)
+  return false unless File.exist?(file_path)
+
+  content = File.read(file_path)
+  fm = IntentValidator.parse_frontmatter_text(content)
+  return false unless fm.is_a?(Hash)
+
+  resolve = lambda do |ref|
+    LinksProjection.resolve_ref_projection(
+      ref,
+      referer_store: referer_store_key,
+      relocation_map: maps[:relocation_map],
+      store_index: maps[:store_index],
+      node_index: maps[:node_index]
+    )
+  end
+
+  begin
+    section_text = LinksProjection.section(
+      sources: Array(fm["sources"]).map(&:to_s),
+      chain: Array(fm["chain"]).map(&:to_s),
+      resolve: resolve
+    )
+    updated = LinksSection.rewrite(content, section_text)
+  rescue LinksProjection::UnresolvedRef, LinksSection::AmbiguousLinks => e
+    warn "new-intent: could not project ## Links for #{File.basename(file_path)}: #{e.message}"
+    return false
+  end
+
+  File.write(file_path, updated) if updated != content
+  true
 end
 
 def main(argv)
@@ -140,17 +270,37 @@ def main(argv)
   intent_file = File.join(intent_dir, "#{id}--#{slug}.md")
   File.write(intent_file, intent_body)
 
-  # 4. Reciprocal links: forward link to parent + back-reference in the parent.
-  if opts[:parent] && !opts[:parent].empty?
-    parent_id = opts[:parent]
-    append_link(intent_file, "- [[#{parent_id}]]")
-    parent_dir = Dir.glob(File.join(store, "#{parent_id}--*")).find { |d| File.directory?(d) }
-    if parent_dir
-      parent_file = File.join(parent_dir, "#{File.basename(parent_dir)}.md")
-      append_link(parent_file, "- [[#{id}]]")
-    end
+  # 4a. I1 reciprocity: write the child's id into EACH source intent's frontmatter
+  # `chain` (the formative-reciprocity backlink), for BOTH the `--parent` and the
+  # `--sources` path. `sources` is the redundant-explicit set from step 3 (it already
+  # folds in `--parent`). Collect the touched source files so their `## Links` can be
+  # re-projected once the chain edges are on disk.
+  source_files = []
+  sources.each do |src_id|
+    next if src_id.nil? || src_id.empty?
+
+    src_dir = Dir.glob(File.join(store, "#{src_id}--*")).find { |d| File.directory?(d) }
+    next unless src_dir
+
+    src_file = File.join(src_dir, "#{File.basename(src_dir)}.md")
+    add_to_chain(src_file, id)
+    source_files << src_file
   end
 
+  # 4b. Canonical `## Links` projection (intent 72): born-canonical, drift PREVENTED
+  # at the source. Build the cross-store resolver maps AFTER the chain backlinks are
+  # written, then project the NEW intent's Links from its own frontmatter (sources at
+  # birth, chain empty) and RE-project each source/parent's Links (it just gained the
+  # new id in its chain). The fence-aware rewriter and the resolved-target dedup are
+  # the same ones project-links and the doctor check use, so a freshly created intent
+  # and its sources both PASS graph_links_projection. A no-source root gets the
+  # canonical empty-state comment.
+  plastic_home, referer_store_key = store_context(store)
+  maps = build_cross_store_maps(plastic_home, referer_store_key, store)
+
+  project_links_for(intent_file, referer_store_key, maps)
+  source_files.uniq.each { |sf| project_links_for(sf, referer_store_key, maps) }
+
   # 5. Sentinel placeholders for each lifecycle file. The sentinel is the FIRST
   # line; the rendered template body follows so the file is a usable starting
   # point once an agent deletes the sentinel.