@zalom/plastic 2.0.0-alpha.8 → 2.0.1

package/scripts/dashboard.rb

@@ -21,12 +21,26 @@
 #
 # Read-only. Never modifies files.
 
+require_relative "lib/store_layout"
 require "json"
 require "yaml"
 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") }
 
@@ -87,7 +101,7 @@ end
 # instead, with no end-of-line requirement, so trailing note prose is irrelevant. The
 # separator there may be a real em dash (U+2014, INDEX.md's normal on-write convention,
 # built from the codepoint so this source line stays em-dash free) or a plain hyphen
-# (end-intent's own Bridge.index_entry_match accepts either on read). Because regex
+# (end-intent's own IndexEntry.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. The id class
@@ -130,13 +144,13 @@ def completion_dates(index_path)
 end
 
 # All stores: global + every registered project. -> [{scope, store, index}]
-def stores
+def stores(home = PLASTIC_HOME)
   list = []
-  global = File.join(PLASTIC_HOME, "store")
-  list << { scope: "global", store: global, index: File.join(PLASTIC_HOME, "INDEX.md") } if File.directory?(global)
-  projects_root = File.join(PLASTIC_HOME, "projects")
+  global = Plastic::StoreLayout.global_store(home)
+  list << { scope: "global", store: global, index: File.join(Plastic::StoreLayout.global_root(home), "INDEX.md") } if File.directory?(global)
+  projects_root = Plastic::StoreLayout.projects_root(home)
   if File.directory?(projects_root)
-    Dir.children(projects_root).sort.each do |proj|
+    Plastic::StoreLayout.project_slugs(home).each do |proj|
       store = File.join(projects_root, proj, "store")
       next unless File.directory?(store)
       list << { scope: "project:#{proj}", store: store, index: File.join(projects_root, proj, "INDEX.md") }
@@ -256,9 +270,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
@@ -561,7 +593,7 @@ def render_continue(records)
   out.concat(matrix(open, scope_tag: true))
   out << ""
   out << LEGEND
-  out << "ask    for the <slug> project board  ·  plastic-auto  (works the dispatchable queue)"
+  out << "ask    for the <slug> project board  ·  plastic auto take ID  (works the dispatchable queue)"
   out.join("\n") + "\n"
 end
 
@@ -670,15 +702,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
@@ -821,6 +848,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
@@ -828,7 +856,7 @@ end
 def short_description(scope)
   return "" unless scope.start_with?("project:")
   slug = scope.sub("project:", "")
-  agents = File.join(PLASTIC_HOME, "projects", slug, "AGENTS.md")
+  agents = File.join(Plastic::StoreLayout.project_root(PLASTIC_HOME, slug), "AGENTS.md")
   if File.exist?(agents)
     File.readlines(agents).each do |l|
       t = l.strip
@@ -969,6 +997,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"
+  Plastic::StoreLayout.project_root(plastic_home, 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 = Plastic::StoreLayout.global_store(plastic_home)
+  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
 # ---------------------------------------------------------------------------
@@ -997,6 +1230,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")
@@ -1047,6 +1282,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"

package/scripts/day-summary

@@ -14,6 +14,7 @@
 #
 # Exit codes: 0 done; 2 usage error.
 
+require_relative "lib/store_layout"
 require_relative "lib/session_ledger"
 require_relative "lib/day_summary"
 
@@ -43,7 +44,7 @@ end
 
 opts = parse_args(ARGV)
 home = opts[:home] ? expand(opts[:home]) : expand(ENV.fetch("PLASTIC_HOME", "~/.plastic"))
-store = opts[:store] ? expand(opts[:store]) : File.join(home, "store")
+store = opts[:store] ? expand(opts[:store]) : Plastic::StoreLayout.global_store(home)
 day = opts[:day] || SessionLedger.day_id
 usage_abort("--day must be eight digits parsing as a real date, got #{day.inspect}") unless SessionLedger.valid_day_id?(day)
 session = SessionLedger.short_session_id(opts[:session], ENV["CLAUDE_CODE_SESSION_ID"])