@zalom/plastic 2.0.0-alpha.2 → 2.0.0-alpha.20

package/scripts/dashboard.rb

@@ -27,6 +27,19 @@ require "date"
 require_relative "doctor"
 require_relative "lib/savepoint"
 require_relative "lib/lock"
+require_relative "lib/dashboard_screen"
+require_relative "lib/intent_screen"
+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
+# does the identical glob for the same reason). Sorted for a deterministic load
+# order; tolerates the directory being absent or empty.
+Dir.glob(File.join(__dir__, "lib", "screens", "*.rb")).sort.each { |f| require_relative f }
 
 PLASTIC_HOME = ENV.fetch("PLASTIC_HOME") { File.join(Dir.home, ".plastic") }
 
@@ -56,13 +69,26 @@ rescue StandardError
   nil
 end
 
-# Returns the set of intent ids listed under a given INDEX.md section.
+# The link form's id: "- [id](path)...". The class excludes "[" (as well as
+# "]" and whitespace) so this can never match a wikilink line's OWN opening
+# bracket and key it as "[71" (row F, spec 315b): "- [[71]] ..." fails this
+# pattern outright (the character right after "- [" is itself "[", which the
+# class disallows), leaving it to WIKILINK_ID_RE below.
+LINK_ID_RE = /^- \[([^\[\]\s]+)/
+
+# The wikilink form's id: "- [[id]] name (em dash) description (date; ...)",
+# the shape mihradesign's INDEX.md and others use. Bare id, no brackets.
+WIKILINK_ID_RE = /^- \[\[([^\[\]]+)\]\]/
+
+# Returns the set of intent ids listed under a given INDEX.md section, link
+# form and wikilink form alike (row F5: Active, Abandoned, Completed, and a
+# store's Future section can all mix both forms).
 def index_section_ids(index_path, header)
   return [] unless File.exist?(index_path)
   body = File.read(index_path)
   seg = body[/^#{Regexp.escape(header)}\s*\n(.*?)(?=^## |\z)/m, 1]
   return [] unless seg
-  seg.scan(/^- \[([^\]\s]+)/).flatten
+  seg.scan(LINK_ID_RE).flatten + seg.scan(WIKILINK_ID_RE).flatten
 end
 
 # Bug found at intent 202's gate review: the date used to be anchored to the END of the
@@ -77,21 +103,37 @@ end
 # (end-intent's own Bridge.index_entry_match accepts either on read). Because regex
 # alternation is leftmost-first, this only ever matches the date immediately after the
 # link. It never continues scanning into the note prose, so a second date mentioned
-# later in a note's free text cannot be mistaken for the completion date.
-COMPLETION_DATE_RE = /^- \[([^\]\s]+).*?\)\s*[\u2014-]\s*(\d{4}-\d{2}-\d{2})\b/
+# later in a note's free text cannot be mistaken for the completion date. The id class
+# excludes "[" (row F) so this can never fire on a wikilink line's own opening bracket.
+COMPLETION_DATE_RE = /^- \[([^\[\]\s]+).*?\)\s*[\u2014-]\s*(\d{4}-\d{2}-\d{2})\b/
+
+# The wikilink form's completion date: "- [[id]] name (em dash) description
+# (date; other notes)". Real shape (mihradesign's INDEX.md): the date is the
+# first thing inside the entry's trailing parenthetical. A SEPARATE regex
+# from COMPLETION_DATE_RE (row F review finding), not one four-group
+# alternation: a four-group `scan` breaks `String#scan(...).to_h`, and a bare
+# `\(` alternative on the link form would harvest a date out of note prose on
+# an entry with no canonical date of its own.
+WIKILINK_COMPLETION_DATE_RE = /^- \[\[([^\[\]]+)\]\].*?\((\d{4}-\d{2}-\d{2})\b/
 
 # Map of intent id -> completion date string, parsed from the "## Completed" section
-# (lines like "- [12 (em dash) title](link) (em dash) 2026-06-10 optional note text").
-# Deterministic, content-derived. Observability: a populated "## Completed" section that
-# yields not one single dated entry is a parser regression, not a legitimately empty
-# result, so it is surfaced with a stderr warning rather than rotting invisibly (the same
-# silent-failure class intent 202's gate review caught this file already committing).
+# (lines like "- [12 (em dash) title](link) (em dash) 2026-06-10 optional note text",
+# or the wikilink form "- [[12]] title (em dash) description (2026-06-10; notes)").
+# Deterministic, content-derived. Two regexes scanned separately and merged into one
+# hash (row F), so each form's own matching rules stay independent: the wikilink
+# alternative can never steal a date out of a link-form entry's note prose, because it
+# never even looks at a link-form line (its "- [[" anchor cannot match a line whose
+# second character is not itself "["). Observability: a populated "## Completed"
+# section that yields not one single dated entry is a parser regression, not a
+# legitimately empty result, so it is surfaced with a stderr warning rather than
+# rotting invisibly (the same silent-failure class intent 202's gate review caught this
+# file already committing).
 def completion_dates(index_path)
   return {} unless File.exist?(index_path)
   body = File.read(index_path)
   seg = body[/^## Completed\s*\n(.*?)(?=^## |\z)/m, 1] || ""
   entry_count = seg.scan(/^- \[/).size
-  dates = seg.scan(COMPLETION_DATE_RE).to_h
+  dates = seg.scan(COMPLETION_DATE_RE).to_h.merge(seg.scan(WIKILINK_COMPLETION_DATE_RE).to_h)
   if entry_count.positive? && dates.empty?
     warn "dashboard: completion_dates parsed 0/#{entry_count} dates from the " \
          "\"## Completed\" section of #{index_path}; treat this as a parser regression, " \
@@ -227,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
@@ -641,15 +701,10 @@ end
 # recent_delivery_summary (D1 fix) uses this twice: once per intent label, so a
 # paragraph-long `intent` field collapses to a short name, and once on the fully assembled
 # summary string, the hard budget cap that holds no matter how the per-label math adds up.
+# Intent 331f: the one implementation now lives on ReportScreen; this delegates so dashboard.rb
+# and every ReportScreen render entry point share it.
 def truncate_on_word_boundary(text, max_chars)
-  t = text.to_s
-  return t if t.length <= max_chars
-  ellipsis = "…"
-  limit = [max_chars - ellipsis.length, 0].max
-  slice = t[0, limit]
-  cut = slice.rindex(/\s/)
-  slice = slice[0, cut] if cut && cut.positive?
-  "#{slice.rstrip}#{ellipsis}"
+  ReportScreen.truncate_on_word_boundary(text, max_chars)
 end
 
 # D3 fix (intent 202 gate review): completion dates only carry day granularity, and many
@@ -792,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
@@ -940,6 +996,211 @@ def render_json(records, scope_label)
   }
 end
 
+# ---------------------------------------------------------------------------
+# Screen renderer (intent 331d) - dashboard.rb continue|project <slug> --screen.
+#
+# Sources every fact through the same helpers report-screen and DaySummary
+# already use (Resolved contract, ACTION_1): a missing source prints "not
+# recorded" or "none", never a guess or a crash (R1). The classification
+# pipeline above (classify, rank_key, actionable?, QUADRANTS, disposition_of)
+# is read here, never edited: the screen is a new renderer over the same
+# records (D3), so every count and rank matches what --json already reports
+# for the identical scope.
+# ---------------------------------------------------------------------------
+
+SCREEN_ACTIVE_CAP = 8
+SCREEN_NEXT_CAP = 6
+SCREEN_NOT_RECORDED = "not recorded"
+
+def screen_scope_slug(scope)
+  scope.sub(/\Aproject:/, "")
+end
+
+# Tier root: PLASTIC_HOME for "global", PLASTIC_HOME/projects/<slug> for
+# "project:<slug>" (Resolved contract) - the same tier scripts/lib/qmd_sync.rb
+# already derives from a store path. Global's own roadmaps/INDEX.md sit
+# directly under PLASTIC_HOME, with no intervening "store" segment.
+def screen_tier_root(plastic_home, scope)
+  return plastic_home if scope == "global"
+  File.join(plastic_home, "projects", screen_scope_slug(scope))
+end
+
+# "global" spans every store (the same aggregate render_continue and --json's
+# continue-mode subset already read); a project scope narrows to its own
+# records. Never a project-only helper on the unscoped path (D10).
+def screen_scoped_records(records, scope)
+  return records if scope == "global"
+  records.select { |r| r[:scope] == scope }
+end
+
+def screen_active_count(scoped)
+  scoped.count { |r| r[:status] == "active" }
+end
+
+# D2: a stale or absent lock never counts as delivering.
+def screen_in_delivery_count(scoped, now:)
+  scoped.count do |r|
+    r[:status] == "active" && Lock.who(r[:intent_dir], now: now)["state"] == "fresh"
+  end
+end
+
+# D3: completed_on (the INDEX.md completion date) is the source of truth,
+# rec[:done_at] (the savepoint's own Done timestamp) the fallback when a
+# completed intent has no dated INDEX entry yet. `created` is never read.
+def screen_completion_date(rec)
+  raw = rec[:completed_on].to_s
+  raw = rec[:done_at].to_s if raw.empty?
+  return nil if raw.empty?
+  begin
+    Date.parse(raw)
+  rescue ArgumentError, TypeError
+    nil
+  end
+end
+
+def screen_delivered_count(scoped, now:)
+  today_date = now.to_date
+  scoped.count do |r|
+    next false unless r[:status] == "completed"
+    date = screen_completion_date(r)
+    next false unless date
+    diff = (today_date - date).to_i
+    diff >= 0 && diff <= 7
+  end
+end
+
+# "none" on state none/tie/exhausted or a missing roadmaps dir (R1, D4); the
+# live frontier otherwise (D17). RoadmapQueue itself tolerates an absent
+# directory (Dir.exist? guard), so this never crashes on a bare tier.
+def screen_roadmap_field(plastic_home, scope, now:)
+  tier = screen_tier_root(plastic_home, scope)
+  reader = RoadmapQueue.new(roadmaps_dir: File.join(tier, "roadmaps"),
+                             index_path: File.join(tier, "INDEX.md"), now: now)
+  payload = reader.which
+  return "none" if %w[none tie exhausted].include?(payload["state"])
+  "#{payload['roadmap']} · #{payload['frontier_wave']}"
+end
+
+# Sessions are global, never per-project (Resolved contract): always the
+# PLASTIC_HOME/store tmp root, and `session: nil` (A6) so the calling
+# session's own live heartbeat counts rather than being excluded as "self".
+def screen_sessions_count(plastic_home, now:)
+  store = File.join(plastic_home, "store")
+  DaySummary.active_sessions(store, nil, now: now, ttl: DaySummary::HEARTBEAT_TTL).size
+end
+
+def screen_changed_field(scoped)
+  latest = scoped.map { |r| r[:last_accessed_at].to_s }.reject(&:empty?).max
+  return SCREEN_NOT_RECORDED unless latest
+  t = begin
+    Time.parse(latest)
+  rescue ArgumentError, TypeError
+    nil
+  end
+  return SCREEN_NOT_RECORDED unless t
+  t.utc.strftime("%Y-%m-%d %H:%M UTC")
+end
+
+# D6, intent 331f: the one Lead freshness rule every screen shares - fresh prints
+# "agent · key", a stale lock prints "stale · N min" (never "not recorded" or a bare "idle",
+# which would either hide the staleness or contradict a live In-delivery count with a dead
+# lead), and no lock (or one that will not read) prints "idle".
+def screen_lead_field(rec, now:)
+  ReportScreen.lead_cell(rec[:intent_dir], now: now)
+end
+
+# D3 (331d1): the owner ruled no rendered row exceeds 115 visible columns.
+# The bound is on the WHOLE pipe-delimited row, not on one cell, so the
+# Intent cell gets whatever the other cells leave it. A cell short enough on
+# its own still drifts the row past the bound once the bar, the lead and the
+# scaffolding are added, which is the failure this measures away.
+SCREEN_ROW_MAX_COLUMNS = 115
+
+# D2 (331d1): the Intent cell carries the intent line up to but not including
+# its first colon. A Plastic intent line opens with a short name and then
+# explains itself after a colon, so the lead IS the name; a line with no
+# colon is already a name and passes through whole. Escaping happens here, so
+# the budget below measures what actually reaches the row.
+def screen_intent_title(rec)
+  # D8: one colon rule for every screen, on ReportScreen. `max:` is the whole line here
+  # because screen_fit_intent does this cell's own width budgeting a moment later.
+  cell(ReportScreen.title_before_colon(rec[:intent], max: rec[:intent].to_s.length + 1))
+end
+
+# The Intent cell fitted to what the row has left. `others` are the already
+# rendered sibling cells; the scaffolding is the leading "| ", a " | " between
+# every pair of cells, and the trailing " |". Intent 331f1: the one implementation now lives
+# on ReportScreen (fit_row_cell), measured in DISPLAY columns rather than String#length - an
+# `others` cell carrying a progress bar costs two columns per glyph, not one (RC1) - so
+# roadmap_state_entries_table's own Intent cell spends the same budget by the same rule.
+def screen_fit_intent(title, others)
+  ReportScreen.fit_row_cell(title, others, max: SCREEN_ROW_MAX_COLUMNS)
+end
+
+# D6: last_accessed_at descending, then id, capped at SCREEN_ACTIVE_CAP.
+def screen_where_we_are(scoped, now:)
+  active = scoped.select { |r| r[:status] == "active" }
+  ordered = active.sort_by { |r| [invert_ts(r[:last_accessed_at]), r[:id]] }
+  ordered.first(SCREEN_ACTIVE_CAP).map do |r|
+    items = IntentScreen.checklist_items(r[:intent_dir])
+    progress = IntentScreen.progress_fields(items)
+    graph_id = r[:id].to_s
+    stage = r[:lifecycle].to_s.capitalize
+    bar = "#{progress['progress.bar']} #{progress['progress.done']} / #{progress['progress.total']}"
+    lead = screen_lead_field(r, now: now)
+    {
+      graph_id: graph_id,
+      intent: screen_fit_intent(screen_intent_title(r), [graph_id, stage, bar, lead]),
+      stage: stage,
+      progress: bar,
+      lead: lead,
+    }
+  end
+end
+
+# A2: the exact pool render_json's dispatchable_queue ranks - actionable?
+# records, rank_key order, filtered to disposition defer/research (D12
+# excludes drive/triage). Rank is that queue's own 1-based position, so a
+# capped display row's rank always agrees with the uncapped --json contract.
+def screen_dispatchable_pool(scope_records)
+  ranked = scope_records.select { |r| actionable?(r) }.sort_by { |r| rank_key(r) }
+  ranked.select { |r| %w[defer research].include?(r[:disposition]) }
+end
+
+def screen_where_we_go_next(scope_records)
+  pool = screen_dispatchable_pool(scope_records)
+  pool.each_with_index.map do |r, i|
+    rank = i + 1
+    graph_id = r[:id].to_s
+    reason = r[:quadrant].to_s
+    {
+      rank: rank,
+      graph_id: graph_id,
+      intent: screen_fit_intent(screen_intent_title(r), [rank.to_s, graph_id, reason]),
+      reason: reason,
+    }
+  end.first(SCREEN_NEXT_CAP)
+end
+
+def screen_fields(records, scope, plastic_home:, now: Time.now)
+  scoped = screen_scoped_records(records, scope)
+  {
+    scope: scope,
+    active: screen_active_count(scoped),
+    in_delivery: screen_in_delivery_count(scoped, now: now),
+    delivered: screen_delivered_count(scoped, now: now),
+    roadmap: screen_roadmap_field(plastic_home, scope, now: now),
+    sessions: screen_sessions_count(plastic_home, now: now),
+    changed: screen_changed_field(scoped),
+    where_we_are: screen_where_we_are(scoped, now: now),
+    where_we_go_next: screen_where_we_go_next(scoped),
+  }
+end
+
+def render_screen(records, scope, plastic_home: PLASTIC_HOME, now: Time.now)
+  DashboardScreen.render(screen_fields(records, scope, plastic_home: plastic_home, now: now))
+end
+
 # ---------------------------------------------------------------------------
 # CLI
 # ---------------------------------------------------------------------------
@@ -968,6 +1229,8 @@ def main(argv)
   json = argv.delete("--json")
   data = argv.delete("--data")
   plain = argv.delete("--plain")
+  screen = argv.delete("--screen")
+  ansi = argv.delete("--ansi")
   all = argv.delete("--all")
   limit_active = extract_flag_value(argv, "--limit-active")
   limit_next = extract_flag_value(argv, "--limit-next")
@@ -1018,6 +1281,22 @@ def main(argv)
     return 0
   end
 
+  if screen
+    if mode == "project" && (slug.nil? || slug.empty?)
+      warn "usage: dashboard.rb project <slug> --screen"
+      return 2
+    end
+    scope = mode == "project" ? "project:#{slug}" : "global"
+    text = render_screen(records, scope, plastic_home: PLASTIC_HOME, now: Time.now)
+    # A4: the identical capability guard scripts/report-screen:161 applies -
+    # NO_COLOR always wins to plain; a non-tty stdout stays plain unless the
+    # PLASTIC_FORCE_COLOR test seam is set.
+    ansi_enabled = ansi && ENV["NO_COLOR"].to_s.empty? &&
+                   ($stdout.tty? || ENV["PLASTIC_FORCE_COLOR"] == "1")
+    print(ansi_enabled ? (ScreenPaint.paint(text, color: true) || text) : text)
+    return 0
+  end
+
   case mode
   when "continue" then print render_continue(records)
   when "project"