@zalom/plastic 2.0.0-alpha.21 → 2.0.0-alpha.23

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

@@ -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/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/runner_absorb.rb

@@ -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
@@ -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:

package/scripts/lib/runner_dispatch.rb

@@ -14,6 +14,7 @@ require_relative "runner_policy"
 require_relative "worktree"
 require_relative "savepoint"
 require_relative "guarded_append"
+require_relative "harness_adapter"
 
 # RunnerDispatch (intent 340, G7, n5): validates the graph, computes the
 # ready set, applies RunnerPolicy, mints leases, builds packets, writes
@@ -65,16 +66,25 @@ module RunnerDispatch
   # :errors, :rearm_command, :dispatched, :stop, :parked, :status, :blockers,
   # :plan - fields that do not apply to a given outcome stay nil/empty rather
   # than being omitted, so a caller never has to guard with `dig`.
-  def dispatch(context, limit: DEFAULT_LIMIT, now: Time.now, config: {}, caps: ReadySet::DEFAULT_CAPS,
+  def dispatch(context, limit: DEFAULT_LIMIT, now: Time.now, config: {}, harness: nil, caps: ReadySet::DEFAULT_CAPS,
                validator: WorkGraphValidator.method(:validate),
                ready_analyzer: ReadySet.method(:analyze),
                packet_builder: NodePacket.method(:build),
                worktree: NodeWorktree,
                ledger: NodeLedger,
-               runner: Worktree::ShellRunner.new)
+               runner: Worktree::ShellRunner.new,
+               harness_adapter: HarnessAdapter)
     intent_dir = context.intent_dir
     savepoint_path = File.join(intent_dir.to_s, "savepoint.md")
 
+    # Intent 340b, G7c, n1, rows 1.19/1.20/D21: resolved ONCE for the whole
+    # step through HarnessAdapter, never a literal - `harness:` (this call's
+    # `--harness` override, or nil) wins over `config`'s own `agent.type`.
+    # Every node this call dispatches carries the SAME value, and the
+    # caller (scripts/runner) reads it back off the report to pick which
+    # harness's block to render.
+    harness_key = harness_adapter.resolve_key(config: config, override: harness)
+
     # Row 5.31/5.32: this is RunnerDispatch's OWN lock check, never a shelled
     # `node-transition` call - append_transition below is used in-process
     # (RunnerAbsorb's own pattern), so nothing here inherits node-transition's
@@ -161,8 +171,8 @@ module RunnerDispatch
         next
       end
 
-      result = dispatch_one(context, node: node, kind: kind, now: now, config: config, caps: caps,
-                             edges: edges, nodes_decl: nodes_decl, packet_builder: packet_builder,
+      result = dispatch_one(context, node: node, kind: kind, now: now, config: config, harness: harness_key,
+                             caps: caps, edges: edges, nodes_decl: nodes_decl, packet_builder: packet_builder,
                              worktree: worktree, ledger: ledger, runner: runner)
       if result[:packet_build_failed]
         packet_failures << result
@@ -182,7 +192,8 @@ module RunnerDispatch
     RunnerCore.render_status(context) if dispatched.any? || stop || parked.any?
 
     build_report(context: context, dispatched: dispatched, stop: stop, parked: parked,
-                 ceiling_blocked: ceiling_blocked, packet_failures: packet_failures, running_count: running_count)
+                 ceiling_blocked: ceiling_blocked, packet_failures: packet_failures, running_count: running_count,
+                 harness: harness_key)
   end
 
   # --- guarded re-entries into graph.md (M9) ----------------------------------
@@ -203,8 +214,8 @@ module RunnerDispatch
 
   # --- one node's whole dispatch (packet, lease, `running`) -------------------
 
-  def dispatch_one(context, node:, kind:, now:, config:, caps:, edges:, nodes_decl:, packet_builder:, worktree:,
-                    ledger:, runner:)
+  def dispatch_one(context, node:, kind:, now:, config:, harness:, caps:, edges:, nodes_decl:, packet_builder:,
+                    worktree:, ledger:, runner:)
     intent_dir = context.intent_dir
     savepoint_path = File.join(intent_dir.to_s, "savepoint.md")
 
@@ -253,7 +264,11 @@ module RunnerDispatch
     precondition = lambda do |c|
       ReadySet.ready?(content: c, subject: node, graph: { edges: edges }, nodes: nodes_decl, caps: caps)[:ready]
     end
-    fields = { holder: holder, expires: expires, packet: build_result[:sha], model: model, calls: calls_cap }
+    # Row 1.19/1.20/D21: harness= rides alongside model= on every `running`
+    # line, resolved once by the caller through HarnessAdapter and threaded
+    # straight through here - never re-resolved, never a literal.
+    fields = { holder: holder, expires: expires, packet: build_result[:sha], model: model, harness: harness,
+               calls: calls_cap }
 
     result = begin
       ledger.append_transition(savepoint_path, subject: node, state: "running", fields: fields, now: now,
@@ -400,7 +415,7 @@ module RunnerDispatch
 
   def empty_result
     { ok: true, reason: nil, errors: [], rearm_command: nil, dispatched: [], stop: nil, parked: [],
-      status: nil, blockers: [], plan: nil }
+      status: nil, blockers: [], plan: nil, harness: nil }
   end
   private_class_method :empty_result
 
@@ -415,9 +430,9 @@ module RunnerDispatch
   private_class_method :invalid_graph_result
 
   def build_report(context:, dispatched:, stop:, parked:, ceiling_blocked: false, packet_failures: [],
-                    running_count: 0)
+                    running_count: 0, harness: nil)
     base = empty_result.merge(dispatched: dispatched, stop: stop, parked: parked,
-                               plan: render_plan(dispatched))
+                               plan: render_plan(dispatched), harness: harness)
 
     if dispatched.any?
       base.merge(status: "dispatched")