@zalom/plastic 2.0.0-alpha.22 → 2.0.0-alpha.24

package/scripts/lib/node_progress.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "graph_file"
+require_relative "graph_edges"
+require_relative "node_ledger"
+require_relative "intent_screen"
+
+# NodeProgress (intent 337a, n1): the graph-era progress reader every report
+# screen's node count calls instead of counting checklist.md items. A
+# graph-era intent (graph.md AND nodes/ both present, D4) counts declared
+# nodes - GraphFile.parse's ## Graph section, via GraphEdges - against
+# NodeLedger.status's last-non-torn-line-per-subject state; a checklist-era
+# intent gets nil, so its screen keeps counting checklist.md exactly as
+# before. No second parser: every number here comes from GraphFile,
+# GraphEdges or NodeLedger, never a hand-rolled scan.
+#
+# Pure: an explicit intent_dir and store_root: in, a fields hash or nil out;
+# no ENV, no Dir.pwd, no raise across the boundary (a malformed record
+# answers nil or zeroed fields, matrix row 1.16).
+module NodeProgress
+  module_function
+
+  # Same keys IntentScreen.progress_fields returns, plus "progress.unit".
+  # nil for a pre-graph intent (D4), so the caller keeps counting
+  # checklist.md.
+  def fields(intent_dir, store_root: nil)
+    return nil unless graph_era?(intent_dir)
+
+    nodes = declared_nodes(File.join(intent_dir, "graph.md"))
+    return nil if nodes.nil? || nodes.empty?
+
+    status = NodeLedger.status(File.join(intent_dir, "savepoint.md"))
+    superseded = nodes.count { |n| status[n] == "superseded" }
+    abandoned = nodes.count { |n| status[n] == "abandoned" }
+    remaining = nodes.reject { |n| status[n] == "superseded" || status[n] == "abandoned" }
+    done = remaining.count { |n| status[n] == "done" }
+    running = remaining.count { |n| status[n] == "running" }
+    total = remaining.length
+
+    inferred = done.zero? && total.positive? && delivered?(intent_dir, store_root)
+    done = total if inferred
+
+    {
+      "progress.bar" => bar_for(done, total),
+      "progress.done" => done.to_s,
+      "progress.total" => total.to_s,
+      "progress.note" => note_for(done, total, running, inferred, superseded, abandoned),
+      "progress.unit" => "nodes",
+    }
+  rescue StandardError
+    nil
+  end
+
+  # D4: graph-era means graph.md AND nodes/ both exist.
+  def graph_era?(intent_dir)
+    File.exist?(File.join(intent_dir, "graph.md")) && Dir.exist?(File.join(intent_dir, "nodes"))
+  end
+
+  # Declared node ids from the ## Graph section (GraphFile/GraphEdges), never
+  # from Dir over nodes/. nil for a missing ## Graph section or one that
+  # declares no nodes (matrix row 1.16).
+  def declared_nodes(graph_md_path)
+    parsed = GraphFile.parse(graph_md_path)
+    graph = parsed && parsed[:graph]
+    return nil unless graph
+
+    ids = graph[:nodes]
+    ids.nil? || ids.empty? ? nil : ids
+  end
+  private_class_method :declared_nodes
+
+  def bar_for(done, total)
+    width = IntentScreen::BAR_WIDTH
+    on = total.zero? ? 0 : (done * width) / total
+    (IntentScreen::ON * on) + (IntentScreen::OFF * (width - on))
+  end
+  private_class_method :bar_for
+
+  # D8's four exact note strings, plus a superseded/abandoned suffix (n6, B1):
+  # a node whose resolved state is superseded or abandoned leaves the total
+  # and the numerator, and the note names it, superseded first, appended as
+  # ", K superseded" and/or ", J abandoned". Unchanged when there are none of
+  # either. The inferred case never carries a suffix: it counts the already-
+  # reduced total, so the note stays exactly "inferred: delivered before the
+  # node ledger".
+  def note_for(done, total, running, inferred, superseded, abandoned)
+    return "inferred: delivered before the node ledger" if inferred
+
+    base =
+      if total.zero?
+        "no nodes counted"
+      else
+        open = total - done
+        if open.zero?
+          "all nodes done"
+        elsif running.positive?
+          "#{open} nodes open, #{running} running"
+        else
+          "#{open} nodes open"
+        end
+      end
+
+    suffix = []
+    suffix << "#{superseded} superseded" if superseded.positive?
+    suffix << "#{abandoned} abandoned" if abandoned.positive?
+    suffix.empty? ? base : "#{base}, #{suffix.join(', ')}"
+  end
+  private_class_method :note_for
+
+  # Delivered, proven twice (the inferred fallback's precondition):
+  # outcome.md on disk plus either an INDEX ## Completed line (store_root:
+  # given) or a Done savepoint line (store_root: nil, the roadmap-entries
+  # path that pays for no INDEX read per entry).
+  def delivered?(intent_dir, store_root)
+    return false unless File.exist?(File.join(intent_dir, "outcome.md"))
+
+    store_root ? index_completed?(store_root, intent_id(intent_dir)) : done_savepoint_line?(intent_dir)
+  end
+  private_class_method :delivered?
+
+  def intent_id(intent_dir)
+    File.basename(intent_dir).split("--", 2).first
+  end
+  private_class_method :intent_id
+
+  def index_completed?(store_root, id)
+    path = File.join(store_root, "INDEX.md")
+    return false unless File.exist?(path)
+
+    content = File.read(path).scrub
+    section = content[/^## Completed\n(.*?)(?=^## |\z)/m, 1]
+    return false unless section
+
+    section.each_line.any? { |line| line.strip.match?(/\A-\s*\[#{Regexp.escape(id)}(?=[\s\]])/) }
+  end
+  private_class_method :index_completed?
+
+  # Only a Done line whose text begins with "delivered" proves delivered (n6,
+  # B3): end-intent writes "Done  delivered" or "Done  abandoned"
+  # (scripts/end-intent, Savepoint.append_terminal_savepoint), and only the
+  # first disposition is delivery.
+  def done_savepoint_line?(intent_dir)
+    path = File.join(intent_dir, "savepoint.md")
+    return false unless File.exist?(path)
+
+    File.read(path).scrub.each_line.any? do |line|
+      m = line.strip.match(IntentScreen::SAVEPOINT_RE)
+      m && m[2] == "Done" && m[3].to_s.start_with?("delivered")
+    end
+  end
+  private_class_method :done_savepoint_line?
+end

package/scripts/lib/outcome_report.rb

@@ -120,7 +120,7 @@ module OutcomeReport
   # --- n2: the generator -------------------------------------------------------
 
   PLACEHOLDER_SUMMARY = "(what was delivered)"
-  NON_EVIDENCE_FIELD_KEYS = %w[holder expires packet model gates commit verdict reason question by expired suite].freeze
+  NON_EVIDENCE_FIELD_KEYS = %w[holder expires input model gates commit verdict reason question by expired suite].freeze
 
   # D14: a pipe in any generated table cell (or bullet line) is replaced with a
   # forward slash, never escaped - ReportScreen.table_rows splits on the bare
@@ -377,7 +377,7 @@ module OutcomeReport
   # --- n4: findings, read and capped ------------------------------------------
 
   # Two lines at the screens' own 115-column limit (spec D15). A named
-  # constant so the number is never folded into a regex.
+  # constant so the number is never embedded into a regex.
   FINDING_CAP = 200
 
   # `### Findings` under the intent record's own `## Insights` section (spec

package/scripts/lib/project_config.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "yaml"
+
+# ProjectConfig - reads a project's project.yml merged over the shipped defaults
+# (moved off the retired shared-helpers module by intent 344, D2). A missing or
+# malformed project.yml never raises: read returns the defaults with a warning
+# on stderr instead.
+module ProjectConfig
+  module_function
+
+  DEFAULTS = {
+    "governing_docs" => ["AGENTS.md"],
+    "release" => {
+      "on_complete" => "commit",
+    },
+  }.freeze
+
+  def read(slug)
+    path = File.join(Dir.home, ".plastic", "projects", slug, "project.yml")
+    config = if File.exist?(path)
+               YAML.safe_load(File.read(path)) || {}
+             else
+               {}
+             end
+
+    deep_merge(DEFAULTS, config)
+  rescue => e
+    $stderr.puts "Warning: failed to read project config for #{slug}: #{e.message}"
+    DEFAULTS.dup
+  end
+
+  def deep_merge(base, overlay)
+    result = base.dup
+    overlay.each do |key, value|
+      if value.is_a?(Hash) && result[key].is_a?(Hash)
+        result[key] = deep_merge(result[key], value)
+      else
+        result[key] = value
+      end
+    end
+    result
+  end
+end

package/scripts/lib/ready_set.rb

@@ -45,7 +45,7 @@ module ReadySet
 
   # The fixed key list a ranker row ever carries (D11/C16): every key is
   # state- or edge-derived, never a telemetry field (tokens, wall, model,
-  # suite, packet). Pinned by test/ready_set_ranker_test.rb.
+  # suite, input). Pinned by test/ready_set_ranker_test.rb.
   ROW_KEYS = %i[id kind batch retry downstream_hops on_critical_path].freeze
 
   # --- the readiness decision (D1) ---------------------------------------------

package/scripts/lib/report_screen.rb

@@ -21,6 +21,7 @@ require_relative "graph_tree"
 require_relative "screen_paint"
 require_relative "outcome_report"
 require_relative "node_file"
+require_relative "node_progress"
 
 module ReportScreen
   NOT_RECORDED = "not recorded"
@@ -920,7 +921,7 @@ def self.matching_action_heading(intent_dir, label)
     f["status.note"] = status == "unlisted" ? "no INDEX.md line names this id" : "listed under ## #{status} in INDEX.md"
     f.merge!(IntentScreen.savepoint_fields(intent_dir, text.to_s))
     items = IntentScreen.checklist_items(intent_dir)
-    f.merge!(IntentScreen.progress_fields(items))
+    f.merge!(NodeProgress.fields(intent_dir, store_root: store_root) || IntentScreen.progress_fields(items))
     f.merge!(IntentScreen.next_fields(items, status, checklist_present: IntentScreen.items_present?(intent_dir)))
     f.merge!(IntentScreen.insight_fields(text.to_s))
 
@@ -931,7 +932,7 @@ def self.matching_action_heading(intent_dir, label)
       ["Status", f["status"], f["status.note"]],
       ["Stage", f["stage"], f["stage.note"]],
       ["Savepoint", f["savepoint"], f["savepoint.note"]],
-      ["Progress", "#{f['progress.bar']} #{f['progress.done']} / #{f['progress.total']}", f["progress.note"]],
+      ["Progress", "#{f['progress.bar']} #{f['progress.done']} / #{f['progress.total']}#{f['progress.unit'] ? " #{f['progress.unit']}" : ''}", f["progress.note"]],
       ["Next", f["next"], f["next.note"]],
       ["Insight", f["insight"], f["insight.note"]],
       ["Changed", changed_value, CHANGED_NOTE],
@@ -1101,9 +1102,10 @@ def self.matching_action_heading(intent_dir, label)
       text = intent_text(e[:dir]).to_s
       savepoint = IntentScreen.savepoint_fields(e[:dir], text)
       items = IntentScreen.checklist_items(e[:dir])
-      progress = IntentScreen.progress_fields(items)
+      progress = NodeProgress.fields(e[:dir], store_root: store_root) || IntentScreen.progress_fields(items)
+      unit = progress["progress.unit"] ? " #{progress['progress.unit']}" : ""
       ch = state_fields(intent_dir: e[:dir], store_root: store_root, changed: changed)[:rows].find { |l, _, _| l == "Changed" }[1]
-      table << "| #{e[:id]} | #{savepoint['stage']} | #{progress['progress.bar']} #{progress['progress.done']} / #{progress['progress.total']} | #{escape(ch)} | #{lead(e[:dir], now: now)} |"
+      table << "| #{e[:id]} | #{savepoint['stage']} | #{progress['progress.bar']} #{progress['progress.done']} / #{progress['progress.total']}#{unit} | #{escape(ch)} | #{lead(e[:dir], now: now)} |"
     end
     blocks = entries.map { |e| render_collapsed_block(e[:dir], store_root, changed: changed) }
     head_and_table = ([header, ""] + table).join("\n")
@@ -1721,8 +1723,10 @@ def self.matching_action_heading(intent_dir, label)
   def self.roadmap_entry_progress(dir)
     return NOT_RECORDED unless dir
     items = IntentScreen.checklist_items(dir)
-    fields = IntentScreen.progress_fields(items)
-    "#{fields['progress.bar']} #{fields['progress.done']} / #{fields['progress.total']}"
+    fields = NodeProgress.fields(dir) || IntentScreen.progress_fields(items)
+    unit = fields["progress.unit"] ? " #{fields['progress.unit']}" : ""
+    inferred = fields["progress.note"].to_s.start_with?("inferred") ? " inferred" : ""
+    "#{fields['progress.bar']} #{fields['progress.done']} / #{fields['progress.total']}#{unit}#{inferred}"
   end
 
   def self.roadmap_progress_bar(done, total)

package/scripts/lib/roadmap_graph.rb

@@ -51,7 +51,7 @@ module RoadmapGraph
     entry_ids = order.dup
 
     # 1.6: an entry the graph never named (not declared, not targeted) is
-    # folded in as a root, so a partly migrated roadmap never silently
+    # included as a root, so a partly migrated roadmap never silently
     # drops real work from the batches.
     edges = parsed_edges[:edges].dup
     entry_ids.each do |id|

package/scripts/lib/roadmap_queue.rb

@@ -306,7 +306,7 @@ class RoadmapQueue
   # and never an invented dispatchable entry with no title. An id a batch
   # lists that the graph does not name is never dropped either: it keeps
   # the pre-change wave behavior (the G4 partial-migration path) by being
-  # folded in as needing nothing (never called on a cyclic graph: #analyze
+  # included as needing nothing (never called on a cyclic graph: #analyze
   # checks that first and reports "error" instead).
   def graph_frontier_for(candidate)
     edges = candidate[:graph_edges][:edges].dup

package/scripts/lib/roadmap_render.rb

@@ -14,7 +14,7 @@ require_relative "atomic_write"
 # byte of the file alone.
 #
 # The regroup is surgical, never a rebuild from parsed fields (327's own
-# lesson, folded at the 2026-09-10 plan review, rows 3.2/3.13/3.14): only
+# lesson, merged at the 2026-09-10 plan review, rows 3.2/3.13/3.14): only
 # entry lines RoadmapGraph itself recognized (the canonical checkbox +
 # status grammar) ever move. A line the grammar cannot parse, and any prose
 # a human wrote between batch headings, is untouched OUTPUT text - it is

package/scripts/lib/roadmap_savepoint.rb

@@ -8,7 +8,7 @@ require_relative "guarded_append"
 # RoadmapSavepoint - the roadmap's machine counterpart to its human `## Log` (intent 134).
 #
 # Mirrors scripts/lib/qmd_sync.rb's class shape and the cycle-step savepoint ledger in
-# scripts/lib/bridge.rb (append semantics: idempotent `(event, detail)` pair dedup, one
+# scripts/lib/savepoint.rb (append semantics: idempotent `(event, detail)` pair dedup, one
 # deterministic append primitive). Constructor-DI, hermetic: no eval, no ENV or global config
 # seam, clock injected through `now:`. Two operations:
 #

package/scripts/lib/runner_absorb.rb

@@ -10,7 +10,7 @@ require_relative "node_return"
 require_relative "node_ledger"
 require_relative "node_worktree"
 require_relative "node_file"
-require_relative "node_packet"
+require_relative "node_input"
 require_relative "ready_set"
 require_relative "core_integrity"
 require_relative "runner_core"
@@ -86,6 +86,17 @@ module RunnerAbsorb
     return refused("node_not_running") unless current_state == "running"
 
     holder = holder_for(entries, node)
+    # 340b n8: the harness that ran this attempt, read off the node's own
+    # `running` line - never the harness of the session doing the absorbing
+    # (row 8.12). `extra_fields` carries it into every terminal fields hash
+    # below through the same `.merge(extra_fields)` every path already uses,
+    # so it reaches `done`, every `failed_verification`/`needs_decision`, and
+    # `blocked` alike; a running line with no `harness=` leaves it out of
+    # `extra_fields` entirely, so nothing invents a value (row 8.13).
+    harness = harness_for(entries, node)
+    extra_fields = {}
+    extra_fields[:harness] = harness if harness
+
     node_decl = ((context.graph || {})[:nodes] || {})[node] || {}
     kind = node_decl[:kind]
     declared_files = normalize_files(node_decl[:files])
@@ -97,12 +108,11 @@ module RunnerAbsorb
     # empty), and land `done` carrying the executor's own self-reported
     # commit on work nothing had verified ever reached the intent branch.
     unless (context.graph || {})[:ok] && !kind.nil?
-      fields = { reason: "invalid_graph", holder: holder }
+      fields = { reason: "invalid_graph", holder: holder }.merge(extra_fields)
       return write_transition(savepoint_path, context, node, "blocked", fields, now: now, ledger: ledger)
     end
 
     checks_ran = []
-    extra_fields = {}
 
     # 1. integrity ------------------------------------------------------------
     checks_ran << "integrity"
@@ -112,7 +122,7 @@ module RunnerAbsorb
         extra_fields["allow_core_drift"] = "true"
       else
         fields = { reason: "core_integrity", core_drift: drift_summary(integrity), holder: holder,
-                   gates: checks_ran.join("+") }
+                   gates: checks_ran.join("+") }.merge(extra_fields)
         return write_transition(savepoint_path, context, node, "blocked", fields, now: now, ledger: ledger)
       end
     end
@@ -122,7 +132,7 @@ module RunnerAbsorb
     text = read_return_text(return_path)
     parsed = NodeReturn.parse(text)
 
-    attempt = NodePacket.compute_attempt_number(intent_dir: intent_dir, node: node, lease_flag_given: false,
+    attempt = NodeInput.compute_attempt_number(intent_dir: intent_dir, node: node, lease_flag_given: false,
                                                  entries: entries)
     preserve_return_file(intent_dir, node, attempt, return_path, text)
 
@@ -301,7 +311,13 @@ module RunnerAbsorb
     { state: "append_failed", written: false, fields: fields, gates: fields[:gates],
       commit: fields[:commit], error: e.message }
   rescue ArgumentError => e
-    fallback_fields = { reason: "return_unwritable", holder: fields[:holder], gates: fields[:gates] }.compact
+    # 340b n8, row 8.11: this fallback still merges no caller `extra_fields`
+    # (unchanged from before this node), but `fields[:harness]` is read
+    # straight off the fields hash the failed write attempted, which already
+    # carries `harness` whenever the caller's own `extra_fields` had it -
+    # `.compact` drops the key rather than writing it empty when it did not.
+    fallback_fields = { reason: "return_unwritable", holder: fields[:holder], gates: fields[:gates],
+                         harness: fields[:harness] }.compact
     fallback = begin
       ledger.append_transition(savepoint_path, subject: node, state: "blocked", fields: fallback_fields, now: now)
     rescue GuardedAppend::Unavailable
@@ -352,6 +368,16 @@ module RunnerAbsorb
   end
   private_class_method :holder_for
 
+  # 340b n8/row 8.12: mirrors holder_for exactly - the value on the node's
+  # OWN last `running` line, never a fresh resolve of the current session's
+  # own harness. nil when that line carried none (row 8.13), which is what
+  # keeps `extra_fields` from ever inventing the key.
+  def harness_for(entries, node)
+    last = entries.select { |e| !e[:torn] && e[:subject] == node && e[:state] == "running" }.last
+    last && (last[:fields] || {})["harness"]
+  end
+  private_class_method :harness_for
+
   def drift_summary(integrity)
     parts = []
     parts << "drifted:#{integrity[:drifted].join(',')}" if Array(integrity[:drifted]).any?
@@ -519,7 +545,7 @@ module RunnerAbsorb
     # `content` itself ends in a newline (the file's own trailing newline
     # made visible as an array slot). When Insights is the LAST section (no
     # further "## " heading), `insights_end` walks all the way to
-    # `lines.length`, folding that sentinel INTO the section - the very next
+    # `lines.length`, merging that sentinel INTO the section - the very next
     # insert then landed AFTER it, turning the file's trailing newline into
     # a spurious blank line and leaving the new bullet as the final element
     # with no newline of its own. Excluding the sentinel here restores both:
@@ -544,11 +570,11 @@ module RunnerAbsorb
   end
   private_class_method :read_return_text
 
-  # Row 4.42: the return is kept beside the packet at
-  # packets/<node>--a<N>.return - copied there when `return_path` names
+  # Row 4.42: the return is kept beside the node input at
+  # attempts/<node>--a<N>.return - copied there when `return_path` names
   # somewhere else, left alone when it already is that file.
   def preserve_return_file(intent_dir, node, attempt, return_path, text)
-    target = NodePacket.packet_path(intent_dir: intent_dir, node: node, attempt: attempt).sub(/\.packet\z/, ".return")
+    target = NodeInput.input_path(intent_dir: intent_dir, node: node, attempt: attempt).sub(/\.input\z/, ".return")
     return target if File.expand_path(return_path.to_s) == File.expand_path(target)
 
     FileUtils.mkdir_p(File.dirname(target))