@zalom/plastic 2.0.0-alpha.17 → 2.0.0-alpha.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "2.0.0-alpha.17",
+  "version": "2.0.0-alpha.19",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/zalom/plastic"
+    "url": "git+https://github.com/zalom/plastic.git"
   },
   "homepage": "https://github.com/zalom/plastic",
   "files": [

package/scripts/dashboard.rb

@@ -33,6 +33,7 @@ require_relative "lib/report_screen"
 require_relative "lib/roadmap_queue"
 require_relative "lib/day_summary"
 require_relative "lib/screen_paint"
+require_relative "lib/ready_set"
 
 # Intent 331a (D6/R8): every caller-added screen kind file registers itself on
 # load, so this glob is the only wiring a new kind needs (scripts/report-screen:42
@@ -268,9 +269,27 @@ def parse_intent(store_info, dir_name, status_index)
     # durable lock beside the intent. intent_line deliberately does not expose
     # this filesystem path in --data or any rendered surface.
     intent_dir: File.expand_path(dir),
+    # Intent 336 (G3, D14): the ready node count for a graph-shaped intent,
+    # read through ReadySet, nil for every other intent. Explicitly advisory,
+    # entirely separate from the sources-derived "unblocked" flag below,
+    # which is the cross-intent knowledge graph and stays exactly as it was
+    # (327 D40 forbids that field from gating work). ReadySet.analyze is
+    # called only when real.("graph.md") is true, so the cost of this read
+    # is zero for every intent that has no graph.
+    ready_node_count: real.("graph.md") ? ready_node_count_for(dir) : nil,
   }
 end
 
+# The count of currently-ready nodes in a graph-shaped intent's own graph.md,
+# or nil when ReadySet cannot analyze it (a malformed or cyclic graph never
+# raises out of the dashboard).
+def ready_node_count_for(dir)
+  analysis = ReadySet.analyze(dir)
+  return nil unless analysis[:ok]
+
+  analysis[:nodes].count { |_, view| view[:ready] }
+end
+
 def checklist_partially_done?(path)
   txt = File.read(path)
   checked = txt.scan(/^\s*- \[x\]/i).size
@@ -828,6 +847,7 @@ def next_work(records, cap: NEXT_WORK_CAP)
     { id: r[:id], intent: r[:intent], scope: r[:scope], lifecycle: r[:lifecycle],
       value: r[:value].to_s, disposition: r[:disposition], flags: r[:flags],
       what: cell(text), flags_label: cell(Array(r[:flags]).join(", ")),
+      ready_node_count: r[:ready_node_count],
       line: "#{r[:id]} #{text}" }
   end
 end

package/scripts/doctor.rb

@@ -27,6 +27,8 @@ require_relative "lib/links_projection"
 require_relative "lib/links_section"
 require_relative "lib/lock"
 require_relative "lib/savepoint"
+require_relative "lib/node_ledger"
+require_relative "lib/ready_set"
 require_relative "lib/agent_models"
 require_relative "lib/outcome_guard"
 require_relative "lib/skill_lint"
@@ -620,6 +622,14 @@ class Doctor
     # flagged: validate_graph does not compute it.
     checks.concat(graph_invariant_checks(intent_dirs))
 
+    # node_graph - ReadySet's own view of every intent carrying a real graph.md
+    # (intent 336, n7): dead ends, stale done nodes, and expired running leases,
+    # none of which any other doctor rule surfaces. Lives here rather than
+    # doctor_core.rb because test/doctor_core_split_test.rb pins that file's
+    # boot path to exactly three project files and 781 bytes of headroom;
+    # ReadySet's own require chain is 65,648 bytes, far past that budget.
+    checks.concat(node_graph_checks(intent_dirs))
+
     # cross_store_resolution — RESOLVES (not just shape-checks) every cross-store
     # `store:id` ref against the FULL store family via the relocation map
     # (relocation consulted first), closing the shape-only gap i1/i3/i4 leave open.
@@ -785,7 +795,14 @@ def done_signal_findings_for_dir(dir, label:, scope:, dirname:, terminal:, activ
     # reported as a fixable warn (backfilled_complete). Its exclusions go to their OWN
     # bucket so savepoint_operational's consumed/dead-row bookkeeping above never sees them.
     backfill_gaps = %w[spec.md plan.md].reject { |f| Savepoint.stage_file_present?(File.join(dir, f)) }
-    backfill_gaps << "actions/" unless Savepoint.has_real_action?(dir)
+    # Name whichever directory the intent actually used (post-execution
+    # review, non-blocking 8), consistent with Savepoint.missing_for_stage:
+    # a nodes/ directory on disk means the intent chose the node-graph
+    # convention, so a gap here is a missing nodes/, never the literal
+    # actions/ has_real_action? no longer implies.
+    unless Savepoint.has_real_action?(dir)
+      backfill_gaps << (File.directory?(File.join(dir, "nodes")) ? "nodes/" : "actions/")
+    end
     if backfill_gaps.any?
       suppressed_backfill = excluded_rules.include?("backfilled_complete")
       target = suppressed_backfill ? findings[:excluded_backfill] : findings[:unbackfilled]
@@ -1461,20 +1478,37 @@ end
     expected_pair = Savepoint.savepoint_milestone(intent_dir, File.basename(Savepoint.intent_file(intent_dir)))
 
     phantoms = Savepoint.savepoint_phantom_lines(intent_dir)
+    # Intent 335 (spec C2/C5): a torn or unattributed node/Intent transition
+    # line has no reader anywhere else in the tree, so this is where it
+    # surfaces. NodeLedger.anomalies never touches a stage line (its own
+    # transition-candidate gate excludes them), so this is purely additive
+    # beside the phantom check above.
+    transition_anomalies = NodeLedger.anomalies(savepoint)
     problems = []
     problems << "born line #{born_pair.inspect} does not match the expected #{expected_pair.inspect}" \
       if born_pair != expected_pair
     problems << "#{phantoms.size} phantom savepoint line(s): " \
                 "#{phantoms.map { |l, r| "#{l} (#{r})" }.join("; ")}" if phantoms.any?
+    problems << "#{transition_anomalies.size} torn/unattributed transition line(s): " \
+                "#{transition_anomalies.map { |a| "#{a[:line]} (#{a[:reason]})" }.join("; ")}" \
+      if transition_anomalies.any?
 
     if problems.empty?
       check(category: "intent_end", name: "intent_savepoint_truthful", status: "pass",
             message: "Savepoint born line and phantom-line state are truthful")
     else
+      # A torn or unattributed transition line's CONTENT cannot be repaired by
+      # a rebuild (rebuild_savepoint preserves it verbatim, spec D13), unlike a
+      # born-line mismatch or a stage phantom, which rebuild does fix. Say so
+      # explicitly rather than pointing at a fix that will not fix it.
+      fix_hint = "Rebuild the ledger via Savepoint.rebuild_savepoint"
+      fix_hint += "; note: rebuild preserves a torn or unattributed transition line " \
+                  "verbatim and does not repair one - hand-edit it or accept the finding" \
+        if transition_anomalies.any?
       check(category: "intent_end", name: "intent_savepoint_truthful", status: "warn",
             message: "#{problems.size} savepoint truthfulness issue(s) (advisory, never blocking)",
             details: problems,
-            fixable: true, fix_hint: "Rebuild the ledger via Savepoint.rebuild_savepoint")
+            fixable: true, fix_hint: fix_hint)
     end
   end
 
@@ -1620,6 +1654,90 @@ end
     end
   end
 
+  # ReadySet over every intent carrying a real graph.md (intent 336, n7):
+  # dead ends, stale done nodes, and expired running leases. An intent with
+  # no real graph.md is skipped entirely (never touches ReadySet); a
+  # malformed or cyclic one is reported by name, never raised out of doctor.
+  def node_graph_checks(intent_dirs)
+    dead_ends = []
+    stale = []
+    expired = []
+    malformed = []
+
+    intent_dirs.each do |d|
+      graph_path = File.join(d[:path], "graph.md")
+      next unless Savepoint.stage_file_present?(graph_path)
+
+      analysis = ReadySet.analyze(d[:path])
+      unless analysis[:ok]
+        malformed << "#{d[:name]}: #{analysis[:errors].join('; ')}"
+        next
+      end
+
+      savepoint_path = File.join(d[:path], "savepoint.md")
+      analysis[:nodes].each do |id, view|
+        dead_ends << "#{d[:name]}/#{id}" if view[:dead_end]
+        stale << "#{d[:name]}/#{id}" if view[:stale]
+        expired << "#{d[:name]}/#{id}" if view[:state] == "running" && expired_running_lease?(savepoint_path, id)
+      end
+    end
+
+    [
+      node_graph_finding_check(
+        "node_graph_dead_ends", dead_ends,
+        "No node waits on a need that resolves to superseded or abandoned",
+        "Re-plan or supersede the dead-end node's need chain, or abandon the node itself"
+      ),
+      node_graph_finding_check(
+        "node_graph_stale_done", stale,
+        "No done node rests on a need superseded after it finished",
+        "Re-verify the stale node against the superseding work, or record the staleness in revisions.md"
+      ),
+      node_graph_finding_check(
+        "node_graph_expired_running_lease", expired,
+        "No running node's lease has expired unreclaimed",
+        "Run `node-transition <intent_dir> --node <id> --state reclaimed --field holder=<h> " \
+        "--field expired=<iso>` to sweep it"
+      ),
+      node_graph_finding_check(
+        "node_graph_malformed", malformed,
+        "Every intent's graph.md parses cleanly",
+        "Fix the malformed graph.md or nodes/ file named in the details"
+      ),
+    ]
+  end
+
+  # True iff `id`'s last running line in the ledger at `savepoint_path` carries
+  # an `expires=` strictly in the past. An unparseable or absent expires=
+  # never counts as expired (fail milder than the bug).
+  def expired_running_lease?(savepoint_path, id, now: Time.now)
+    entry = NodeLedger.last_running(savepoint_path, id)
+    return false unless entry
+
+    expires_raw = (entry[:fields] || {})["expires"]
+    expiry = begin
+      expires_raw && Time.iso8601(expires_raw)
+    rescue ArgumentError
+      nil
+    end
+    !!(expiry && now > expiry)
+  end
+
+  # One node-graph check: pass when `findings` is empty, otherwise warn
+  # (never fail, matching graph_finding_check's own precedent - an existing
+  # store never turns red on an advisory graph finding).
+  def node_graph_finding_check(name, findings, pass_message, fix_hint)
+    if findings.empty?
+      check(category: "conventions", name: name, status: "pass", message: pass_message)
+    else
+      check(
+        category: "conventions", name: name, status: "warn",
+        message: "#{findings.size} #{name} violation(s)",
+        details: findings, fixable: false, fix_hint: fix_hint
+      )
+    end
+  end
+
   # --- Check category 3: Agent registration ---
 
 

package/scripts/end-intent

@@ -81,6 +81,7 @@ require_relative "lib/intent_validator"
 require_relative "lib/outcome_guard"
 require_relative "lib/report_screen"
 require_relative "lib/backfill_intent"
+require_relative "lib/outcome_report"
 
 DISPOSITIONS = %w[delivered abandoned].freeze
 
@@ -176,6 +177,64 @@ def resolve_plastic_home_and_scope(store)
   end
 end
 
+# --- outcome generation, before the backfill (intent 339, G6, spec D10) -----
+#
+# Generates outcome.md from graph.md, nodes/, and the ledger, BEFORE the
+# backfill step runs, and only into a file that is missing or still the
+# scaffold placeholder (`Savepoint.stage_file_present?` false) - a real,
+# hand-written outcome.md is never touched (row 7.2). Only when a graph.md
+# exists at all (row 7.3): every intent without one closes exactly as it did
+# before this intent. The model is parsed AFTER the `stage_file_present?`
+# guard, not before: a real hand-written outcome.md returns at that guard
+# regardless of graph.md's own health, so a close that was never going to
+# generate anything must never print a parse warning about it. Refuses a
+# report model that reports itself broken (row v1f.2, B2): a malformed
+# `## Graph` fails `model[:ok]` and the close falls straight through to the
+# backfill, rather than adopting parse damage as delivery fact - agreeing
+# with the shipped `outcome-report` CLI, which exits 3 on the same
+# directory. The generated text is then checked against
+# BOTH close gates - `OutcomeGuard` and the hollow-report gate below - before
+# being adopted (row 7.4); when either would refuse it, the write is
+# reverted and the close falls through to intent 308's unchanged backfill
+# (row 7.5), so no close gains an exit 7 it did not have before this intent.
+# Fails open on any exception (row 7.6), the same report-and-proceed shape
+# every other close step in this file uses. `generator:` is the injectable
+# seam (mirrors run_structure_check's `gate:`).
+def run_generate_outcome(intent_dir, disposition:, generator: OutcomeReport.method(:write))
+  graph_path = File.join(intent_dir, "graph.md")
+  return unless File.exist?(graph_path)
+
+  outcome_path = File.join(intent_dir, "outcome.md")
+  return if Savepoint.stage_file_present?(outcome_path)
+
+  report_model = OutcomeReport.model(intent_dir)
+  unless report_model[:ok]
+    warn "end-intent: graph.md failed to parse (#{report_model[:errors].join('; ')}); falling back to the backfill"
+    return
+  end
+
+  original_exists = File.exist?(outcome_path)
+  original_content = original_exists ? File.read(outcome_path) : nil
+
+  generator.call(intent_dir, disposition: disposition)
+
+  guard_reason = OutcomeGuard.reason(intent_dir, disposition)
+  hollow = hollow_report_reason(intent_dir, disposition)
+  if guard_reason || hollow
+    if original_exists
+      File.write(outcome_path, original_content)
+    elsif File.exist?(outcome_path)
+      File.delete(outcome_path)
+    end
+    warn "end-intent: generated outcome.md would be refused (#{[guard_reason, hollow].compact.join('; ')}); " \
+         "falling back to the backfill"
+  else
+    warn "end-intent: outcome.md generated from graph.md and the ledger"
+  end
+rescue StandardError => e
+  warn "end-intent: outcome generation crashed (#{e.message}); proceeding without it"
+end
+
 # Backfill (intent 308): write the judgment documents that are missing or still the
 # placeholder from the record (BackfillIntent). Fail-open: a crash here warns and the
 # close proceeds, the same contract as the structure check below.
@@ -227,6 +286,48 @@ end
 # closed exactly this way and the owner read a screen full of "not recorded".
 # Abandoned closes and machine-backfilled outcomes (the backfill marker) are
 # exempt: the reader cannot expect labels the writer never had.
+#
+# Intent 334 (G1, fold A3; post-execution review, blocking 2): the legacy
+# "S3" label grammar applies only to actions/*.md headings, and the node id
+# grammar (kind prefix n/v/d/r plus digits, D1r) applies only to nodes/*.md
+# headings - never both over both directories. This repo's own house words
+# for plan review and post-execution review are "v1" and "v2"; widening the
+# node-id alternative onto actions/ headings turned that prose into a
+# manufactured label and refused legitimate legacy closes at exit 7.
+ACTION_ID_LABEL_RE = /\AS\d+\z/.freeze
+NODE_ID_LABEL_RE = /\A[nvdr][1-9]\d*\z/.freeze
+
+# The id-shaped tokens found in `paths`' headings, matched against
+# `id_label_re` only - the caller picks the grammar for the directory.
+def heading_id_labels(paths, id_label_re)
+  paths.flat_map do |path|
+    ReportScreen.split_by_headings(File.read(path)).flat_map do |heading, _body|
+      heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/).select { |tok| tok.match?(id_label_re) }
+    end
+  end
+end
+
+# 339 S9 (D18): a node id counts as a label in an actions/*.md heading too,
+# but only when it stands alone as one of the heading's " - "-delimited
+# segments - this repo's own convention, "### S1 - n1 - Title" (this action
+# file's own headings, post-fold) or the bare "### n1 - Title". Never as a
+# free word inside ordinary prose: the comment above ACTION_ID_LABEL_RE
+# records exactly why intent 334 restricted the node-id grammar to
+# nodes/*.md headings in the first place, and that reasoning does not change
+# here - a word-scan widened onto actions/ headings would let this repo's own
+# house words ("v1", "v2" for plan review and post-execution review)
+# manufacture a label out of ordinary prose and refuse a legitimate legacy
+# close. Segment position is what a word-scan cannot see: "v2" embedded
+# mid-sentence is never its own " - "-delimited segment, but a heading built
+# to this convention always puts the node id in one.
+def heading_node_id_segments(paths, id_label_re)
+  paths.flat_map do |path|
+    ReportScreen.split_by_headings(File.read(path)).flat_map do |heading, _body|
+      heading.to_s.sub(/\A#+\s*/, "").split(/\s+-\s+/).map(&:strip).select { |seg| seg.match?(id_label_re) }
+    end
+  end
+end
+
 def hollow_report_reason(intent_dir, disposition)
   return nil unless disposition == "delivered"
 
@@ -235,14 +336,34 @@ def hollow_report_reason(intent_dir, disposition)
   text = File.read(outcome)
   return nil if text.include?("<!-- backfilled from the record by end-intent on ")
 
-  # The gate's evidence bar (A7/B7): it judges only records that CLAIM the
-  # modern convention - at least one actions/*.md heading carrying an S-label.
-  # A terse legacy close with no labeled matrix stays report-and-proceed.
-  heading_labels = Dir.glob(File.join(intent_dir, "actions", "*.md")).sort.flat_map do |path|
-    ReportScreen.split_by_headings(File.read(path)).filter_map do |heading, _body|
-      heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/).find { |tok| tok.match?(/\AS\d+\z/) }
-    end
-  end.uniq
+  # The gate's evidence bar (A7/B7): it judges only records that CLAIM a
+  # labeled convention - at least one actions/*.md heading carrying an
+  # S-label or a node-id segment, or at least one nodes/*.md heading carrying
+  # a node id ("n1", "v2", "d3", "r4"). A terse legacy close with no labeled
+  # matrix stays report-and-proceed (intent 334, G1, D10r).
+  #
+  # Every matching token per heading is kept, not just the first (fold A3):
+  # a legacy actions/ heading can carry BOTH an S-label and prose that reads
+  # like a node id ("### The v2 rewrite (S3)"). Restricting the word-scan
+  # node-id grammar to nodes/*.md headings (post-execution review, blocking
+  # 2) means "v2" in that heading is never even tested against it, so the
+  # heading's real "S3" label is never at risk.
+  #
+  # 339 S9 (D18): a graph-era action file headed by node id alone ("### n1 -
+  # Title", no S-label) used to yield an empty label set here and the gate
+  # returned before judging anything - every such record closed unjudged by
+  # silent exemption. `heading_node_id_segments` widens the actions/*.md side
+  # to see that shape without reopening the word-scan hole above: it matches
+  # a node id only when the heading's own " - "-delimited segments carry one,
+  # never a free word in prose. The node_paths call stays exactly as it was;
+  # nodes/*.md headings already resolve node ids correctly (test_node_id_
+  # labels_are_recognized) and their heading grammar is controlled, so a
+  # word-scan there carries none of the prose risk.
+  action_paths = Dir.glob(File.join(intent_dir, "actions", "*.md")).sort
+  node_paths = Dir.glob(File.join(intent_dir, "nodes", "*.md")).sort
+  heading_labels = (heading_id_labels(action_paths, ACTION_ID_LABEL_RE) +
+                     heading_node_id_segments(action_paths, NODE_ID_LABEL_RE) +
+                     heading_id_labels(node_paths, NODE_ID_LABEL_RE)).uniq
   return nil if heading_labels.empty?
 
   rows = ReportScreen.delivered_rows(intent_dir)
@@ -718,6 +839,11 @@ def main(argv)
     end
   end
 
+  # 0a. Generate outcome.md from graph.md and the ledger, when there is one
+  # (intent 339, G6, spec D10) - before the backfill, so a real graph never
+  # falls through to the terse backfill it exists to replace.
+  run_generate_outcome(intent_dir, disposition: disposition)
+
   # 1. Backfill from the record (intent 308), then the structure self-check and the
   # outcome guard, both report-only since 308.
   run_backfill(intent_dir, store: store, id: id, disposition: disposition,

package/scripts/hook-capture

@@ -5,12 +5,11 @@
 # Usage: hook-capture (reads the UserPromptSubmit stdin JSON payload)
 # Intent 298. One UserPromptSubmit process replacing hook-continue,
 # hook-future-intent-check, and hook-auto-arm: it appends a pending line to
-# the session day ledger, detects "continue" and "auto" prompts, and hints at
-# matching Future intents. Every job runs in its own rescue and the hook
-# always exits 0 (spec D2).
+# the session day ledger and detects "continue" and "auto" prompts. Every job
+# runs in its own rescue and the hook always exits 0 (spec D2). Intent 345
+# (D7, 323) removed the per-prompt Future-intent hint step entirely.
 
 require "json"
-require "yaml"
 require "open3"
 require "fileutils"
 require_relative "lib/session_ledger"
@@ -42,87 +41,6 @@ templates = File.expand_path("../templates", __dir__)
 sid = SessionLedger.short_session_id(nil, session_id)
 today = SessionLedger.day_id
 
-# --- Extracted matching logic, shared by both the global and project store
-# passes of job (f) below (mirrors hook-future-intent-check verbatim). ---
-def future_intent_matches(store_root, message)
-  index_path = File.join(store_root, "INDEX.md")
-  return [] unless File.exist?(index_path)
-
-  lines = File.readlines(index_path)
-  future_dirs = []
-  section = nil
-
-  lines.each do |line|
-    section = :future if line.start_with?("## Future")
-    section = nil if line.start_with?("## ") && !line.start_with?("## Future")
-    next unless section == :future && line.strip.start_with?("- [")
-
-    future_dirs << $1 if line =~ /store\/([\w-]+)\//
-  end
-  return [] if future_dirs.empty?
-
-  matches = []
-  message_words = message.split(/\W+/).reject { |w| w.length < 4 }
-
-  future_dirs.each do |dir|
-    intent_path = File.join(store_root, "store", dir, "#{dir}.md")
-    next unless File.exist?(intent_path)
-
-    content = File.read(intent_path)
-
-    tags = []
-    tags = $1.split(",").map(&:strip).map(&:downcase) if content =~ /^tags:\s*\[([^\]]+)\]/
-
-    intent_name = ""
-    intent_name = $1.downcase if content =~ /^intent:\s*["']?(.+?)["']?\s*$/
-
-    keywords = (tags + intent_name.split(/\W+/).reject { |w| w.length < 4 }).map(&:downcase).uniq
-
-    matched_keywords = keywords.select { |kw| message.include?(kw) }
-    name_matches = message_words.select { |w| intent_name.include?(w) }
-    matched_keywords = (matched_keywords + name_matches).uniq
-
-    next if matched_keywords.empty?
-
-    index_line = lines.find { |l| l.include?(dir) }&.strip || "#{dir} - #{intent_name}"
-    matches << { "index_line" => index_line, "keywords" => matched_keywords }
-  end
-  matches
-end
-
-# The store_root that carries the current project's own store, resolved from
-# cwd through projects.yml, mirroring SessionLedger.project_slug's matching
-# but returning nil (not "global") when nothing matches, since there is then
-# no distinct second store to hint against.
-def resolve_project_store_root(cwd, plastic_home)
-  projects_path = File.join(plastic_home, "projects.yml")
-  return nil unless File.exist?(projects_path)
-
-  data = begin
-    YAML.safe_load(File.read(projects_path))
-  rescue StandardError
-    nil
-  end
-  data = {} unless data.is_a?(Hash)
-  projects = data["projects"].is_a?(Hash) ? data["projects"] : {}
-  expanded_cwd = File.expand_path(cwd)
-
-  matches = projects.filter_map do |slug, info|
-    next unless info.is_a?(Hash) && slug.is_a?(String)
-
-    path = info["path"]
-    next unless path
-
-    root = File.expand_path(path)
-    next unless expanded_cwd == root || expanded_cwd.start_with?("#{root}#{File::SEPARATOR}")
-
-    [root.length, slug]
-  end
-
-  best = matches.max_by { |(length, _slug)| length }
-  best ? File.join(plastic_home, "projects", best[1]) : nil
-end
-
 def truncate(text, max)
   return text if text.length <= max
 
@@ -183,7 +101,7 @@ system_message = nil
 
 # --- (d) "continue" cockpit -------------------------------------------------
 begin
-  if prompt.match?(/\bcontinue\b/i)
+  if prompt.to_s.strip.downcase == "continue"
     dashboard = File.expand_path("dashboard.rb", __dir__)
     if File.exist?(dashboard)
       cockpit, _err, status = Open3.capture3({ "RUBYOPT" => nil }, "ruby", dashboard, "continue")
@@ -224,25 +142,6 @@ rescue StandardError
   nil
 end
 
-# --- (f) Future-intent hint, global store then the project's own store -----
-begin
-  message = prompt.to_s.downcase
-  if message.strip.length >= 10 && message.strip != "continue"
-    matches = future_intent_matches(plastic_home, message)
-    project_root = resolve_project_store_root(cwd, plastic_home)
-    matches += future_intent_matches(project_root, message) if project_root
-
-    if matches.any?
-      parts = ["PLASTIC - Future intents related to this message:\n"]
-      matches.each { |m| parts << "#{m["index_line"]} (matched: #{m["keywords"].join(", ")})" }
-      parts << "\nConsider asking the user if they want to activate any of these, or note the connection."
-      context_parts << parts.join("\n")
-    end
-  end
-rescue StandardError
-  nil
-end
-
 exit 0 if context_parts.empty?
 
 payload_out = {