@zalom/plastic 2.0.0-alpha.4 → 2.0.0-alpha.6

package/scripts/lib/doctor_session_ledger.rb

@@ -18,6 +18,18 @@ require_relative "session_ledger"
 module DoctorSessionLedger
   ORPHAN_TTL_SECONDS = 24 * 60 * 60
 
+  # Row H (spec D9): a `.tmp/<sid>/` directory with no `current` pointer is a
+  # DIFFERENT orphan class than ORPHAN_TTL_SECONDS's -- a session where
+  # session start never ran at all (a `-p` print session, a resumed
+  # background job, an unregistered SessionStart hook), not a session that
+  # ran and then never closed. No choice of session id ever creates a
+  # pointer for that class, so it would otherwise stay invisible for the
+  # full 24 hours (or forever, once hook-capture/hook-record stop creating
+  # it at all). Short relative to ORPHAN_TTL_SECONDS on purpose: a session
+  # between its own start and its first pointer write is normal and must not
+  # be flagged, but that window is seconds, not hours.
+  NO_POINTER_TTL_SECONDS = 5 * 60
+
   # Seconds since the session's last heartbeat: the ISO-8601 content of `heartbeat`,
   # else that file's mtime, else the directory's mtime.
   def heartbeat_age(dir, now)
@@ -37,6 +49,7 @@ module DoctorSessionLedger
 
     store_dir = File.join(plastic_home, "store")
     orphans = orphaned_session_dirs(store_dir, now)
+    no_pointer = no_pointer_session_dirs(store_dir, now)
     shape = day_ledger_shape_problems(store_dir)
 
     checks = []
@@ -54,6 +67,20 @@ module DoctorSessionLedger
                                 "session is gone: a live session rewrites its heartbeat on every " \
                                 "prompt and edit, so only a listed directory may be removed, by hand.")
               end
+    checks << if no_pointer.empty?
+                check(category: "session_ledger", name: "no_pointer_session_tmp", status: "pass",
+                      message: "No .tmp/<session>/ directory has gone without a `current` pointer for " \
+                               "longer than #{NO_POINTER_TTL_SECONDS} seconds")
+              else
+                check(category: "session_ledger", name: "no_pointer_session_tmp", status: "warn",
+                      message: "#{no_pointer.size} .tmp/<session>/ director#{no_pointer.size == 1 ? "y" : "ies"} " \
+                               "with no `current` pointer for longer than #{NO_POINTER_TTL_SECONDS} seconds " \
+                               "(session start never ran for this session)",
+                      details: no_pointer, fixable: true,
+                      fix_hint: "Remove each listed .tmp/<session>/ directory after confirming that " \
+                                "session never started: no `current` pointer means session start never " \
+                                "ran for it, so this is not a live session missing a checklist entry.")
+              end
     checks << if shape.empty?
                 check(category: "session_ledger", name: "day_ledger_shape", status: "pass",
                       message: "Every .sessions/ entry is a YYYYMMDD day directory with its <day>.md file")
@@ -86,6 +113,31 @@ module DoctorSessionLedger
     [] # unreadable .tmp/: nothing to report, never a crash
   end
 
+  # Row H (spec D9): `.tmp/<sid>/` directories with no `current` pointer, past
+  # NO_POINTER_TTL_SECONDS. A different signal than #orphaned_session_dirs:
+  # that one is age-only and blind to whether a pointer exists at all, so a
+  # young no-pointer dir (a session between its start and its first pointer
+  # write) must not appear here even though it may well appear there once it
+  # ages past ORPHAN_TTL_SECONDS -- the two checks answer different questions
+  # and a dir can legitimately show up in neither, either, or both.
+  def no_pointer_session_dirs(store_dir, now)
+    tmp_root = SessionLedger.tmp_root(store_dir)
+    return [] unless File.directory?(tmp_root)
+
+    Dir.children(tmp_root).sort.filter_map do |name|
+      dir = File.join(tmp_root, name)
+      next unless File.directory?(dir)
+      next if File.exist?(File.join(dir, "current"))
+
+      age = heartbeat_age(dir, now)
+      next if age <= NO_POINTER_TTL_SECONDS
+
+      "global: #{dir} (session #{name}, no `current` pointer, last heartbeat #{age.round}s ago)"
+    end
+  rescue SystemCallError
+    [] # unreadable .tmp/: nothing to report, never a crash
+  end
+
   def day_ledger_shape_problems(store_dir)
     root = SessionLedger.sessions_root(store_dir)
     return [] unless File.directory?(root)

package/scripts/lib/hook_registry.rb

@@ -54,6 +54,18 @@ module HookRegistry
           { "name" => "capture", "status" => "Capturing prompt into the session ledger..." },
         ] },
       ],
+      # Intent 316a (D6): Claude Code only, no Codex projection — MessageDisplay
+      # is not one of CODEX_LIVE_STATE_EVENTS, so codex_hooks_json (below) never
+      # picks it up; codex_hook_names stays exactly what it was (pinned by
+      # test/hook_registry_test.rb:82 and :110-111). Fires on every streamed
+      # chunk of every assistant message (D11); the launcher (hooks/message-
+      # display) decides with shell builtins and forks nothing on the common
+      # case, execing Ruby only for a candidate message.
+      "MessageDisplay" => [
+        { "matcher" => "", "hooks" => [
+          { "name" => "message-display", "status" => "" },
+        ] },
+      ],
     }
   end
 

package/scripts/lib/installer_core.rb

@@ -76,8 +76,25 @@ class InstallerCore
     @agents = agents
   end
 
+  # Reads the package version from `package.json` when present (the source
+  # tree, and any dev checkout), falling back to the bare `VERSION` file the
+  # installer copies to `~/.plastic` (row B, spec 315b): an installed system
+  # carries VERSION but never package.json, so `rollback.rb` and `update.rb`
+  # constructing an InstallerCore with `package_root: ~/.plastic` crashed with
+  # a raw Errno::ENOENT before this fallback existed. Raises a named error,
+  # not a bare ENOENT, when neither file exists, so the caller is not
+  # misdirected toward the wrong missing file.
   def read_package_version(root)
-    File.read(File.join(root, "package.json")).then { |s| JSON.parse(s)["version"] }
+    package_json = File.join(root, "package.json")
+    version_file = File.join(root, "VERSION")
+
+    if File.exist?(package_json)
+      JSON.parse(File.read(package_json))["version"]
+    elsif File.exist?(version_file)
+      File.read(version_file).strip
+    else
+      raise "cannot determine the package version: neither #{package_json} nor #{version_file} exists"
+    end
   end
 
   # --- Channel derivation (the channel is encoded in the version string) ---
@@ -426,6 +443,14 @@ class InstallerCore
       "scripts/lib/intent_screen.rb" => "scripts/lib/intent_screen.rb",
       "scripts/intent-screen" => "scripts/intent-screen",
       "scripts/hook-savepoint" => "scripts/hook-savepoint",
+      # Intent 316a: hooks/* only glob-copies scripts/*, never scripts/lib/*
+      # (see hook_files above), so the two lib files a require_relative
+      # between themselves are unguarded there — these three literal
+      # entries are their only protection (test/install_sync_test.rb:23-29
+      # greps installer_core.rb's own source text for "scripts/<name>").
+      "scripts/lib/intent_screen_ansi.rb" => "scripts/lib/intent_screen_ansi.rb",
+      "scripts/lib/message_display.rb" => "scripts/lib/message_display.rb",
+      "scripts/hook-message-display" => "scripts/hook-message-display",
     }
   end
 

package/scripts/lib/intent_screen.rb

@@ -1,9 +1,17 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 # IntentScreen (intent 316) - fills templates/intent-screen.md from one intent's
-# record: the intent file, the tier's INDEX.md, savepoint.md, and checklist.md.
+# record: the intent file, the tier's INDEX.md, savepoint.md and checklist.md.
 # Every number on the screen comes from here so the session never writes one by
 # eye. Pure: explicit paths in, a Markdown string out; no ENV, no Dir.pwd.
+#
+# Intent 316a fixed three defects the field code inherited into both the plain
+# renderer and the ANSI renderer (scripts/lib/intent_screen_ansi.rb): the
+# Insight row dumping a multi-clause remainder into the note column, an empty
+# "What this means" heading rendering bold with nothing under it, and step
+# text cut mid-sentence. `step_text`, `insight_fields` and `next_fields` are
+# public so the ANSI renderer reuses the exact same trims (D3) rather than
+# re-deriving them and drifting.
 module IntentScreen
   BAR_WIDTH = 20
   ON = "█"
@@ -11,10 +19,22 @@ module IntentScreen
   PLACEHOLDER_SENTINEL = "<!-- plastic:placeholder -->"
   SECTIONS = %w[Active Future Completed Abandoned].freeze
   ITEM_RE = /^\s*- \[([ xX])\]\s+(.*)$/
-  STEP_PREFIX_RE = /\A(?:Step|S)\s*\d+\s*[-:·]\s*/i
+  # Em dash and en dash added (intent 316a O1e): a checklist item written
+  # "S1 — text" (the em dash every checklist this intent writes, and the one a
+  # reviewer reads, uses) kept its prefix under the old character class and
+  # rendered "S1  [ open ]  S1 — text" on screen.
+  STEP_PREFIX_RE = /\A(?:Step|S)\s*\d+\s*[-:·—–]\s*/i
   INSIGHT_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s+·\s+\S+\s+·\s+.+?\s+—\s+(.+)\z/
   SAVEPOINT_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s{2,}(\S+)\s{2,}(.+?)\s*\z/
 
+  # Word-boundary truncation caps (intent 316a D3/O1a/O1c). Never a clause
+  # trim: a clause trim on step text destroys a pinned `OPEN:` row
+  # (test/intent_screen_test.rb:171-178) that a mid-sentence cut would eat.
+  INSIGHT_VALUE_MAX = 72
+  INSIGHT_NOTE_MAX = 96
+  NEXT_VALUE_MAX = 72
+  STEP_TEXT_MAX = 110
+
   # Where a resume lands, from the ledger's last line (the boarding matrix).
   def self.landing_stage(stage, milestone)
     case stage
@@ -54,8 +74,6 @@ module IntentScreen
     fields.merge!(next_fields(items, status, checklist_present: items_present?(intent_dir)))
     fields.merge!(insight_fields(intent_text))
     fields["steps.rows"] = steps_rows(items)
-    fields["meaning"] = ""
-    fields["close"] = ""
 
     out = template.dup
     fields.each { |k, v| out = out.gsub("{{#{k}}}", v.to_s) }
@@ -171,7 +189,11 @@ module IntentScreen
       "progress.note" => note }
   end
 
-  def self.next_fields(items, status, checklist_present:)
+  # `escape_pipes:` (intent 316a O1d, default true) keeps the plain Markdown
+  # table's pipe-escaping; the ANSI renderer, which never emits a table,
+  # passes `escape_pipes: false` to get the raw value instead of a literal
+  # `\|`. Named to not shadow the module's own `escape` method.
+  def self.next_fields(items, status, checklist_present:, escape_pipes: true)
     return { "next" => "", "next.note" => "" } if %w[Completed Abandoned].include?(status)
     return { "next" => "write checklist.md", "next.note" => "How" } unless checklist_present
 
@@ -179,43 +201,83 @@ module IntentScreen
     return { "next" => "", "next.note" => "all steps done" } unless idx
 
     head, = split_first_clause(items[idx][:text])
-    { "next" => "S#{idx + 1} · #{escape(head)}", "next.note" => "first open step" }
+    head = truncate_words(head, NEXT_VALUE_MAX)
+    head = escape(head) if escape_pipes
+    { "next" => "S#{idx + 1} · #{head}", "next.note" => "first open step" }
   end
 
   def self.steps_rows(items)
     return "| | | no steps yet |" if items.empty?
 
     items.each_with_index.map do |item, i|
-      "| S#{i + 1} | #{item[:done] ? 'done' : 'open'} | #{escape(item[:text])} |"
+      "| S#{i + 1} | #{item[:done] ? 'done' : 'open'} | #{escape(step_text(item[:text]))} |"
     end.join("\n")
   end
 
+  # Public (intent 316a O1c) so the ANSI renderer trims step text identically:
+  # word-boundary truncation only, never a clause trim, at STEP_TEXT_MAX.
+  def self.step_text(text)
+    truncate_words(text, STEP_TEXT_MAX)
+  end
+
   def self.escape(text)
     text.gsub("|", "\\|")
   end
 
   # --- ## Insights ----------------------------------------------------------------
 
-  def self.insight_fields(intent_text)
+  def self.insight_fields(intent_text, escape_pipes: true)
     section = intent_text.split(/^## Insights\s*$/, 2)[1].to_s.split(/^## /, 2)[0].to_s
     entry = section.lines.map(&:strip).reverse.map { |l| l.match(INSIGHT_RE) }.compact.first
     return { "insight" => "none yet", "insight.note" => "" } unless entry
 
     ts, text = entry[1], entry[2].strip
     head, tail = split_first_clause(text)
+    value = truncate_words(head, INSIGHT_VALUE_MAX)
+    tail = tail.empty? ? "" : truncate_words(tail, INSIGHT_NOTE_MAX)
     note = tail.empty? ? human_time(ts) : "#{human_time(ts)} · #{tail}"
-    { "insight" => escape(head), "insight.note" => escape(note) }
+    if escape_pipes
+      { "insight" => escape(value), "insight.note" => escape(note) }
+    else
+      { "insight" => value, "insight.note" => note }
+    end
   end
 
+  # First clause of `text`, and at most one following clause as the tail.
+  # Anything past the second clause is discarded (intent 316a O1a): the old
+  # behavior dumped the ENTIRE remainder into the note (an 800-character
+  # real-world tail starting mid-list). Boundary is a `.` or `;` immediately
+  # followed by whitespace-then-more or end of string, so "alpha.2" and "2.0"
+  # are never mistaken for clause ends.
   def self.split_first_clause(text)
-    m = text.match(/\A(.+?)[.;](\s+.*|\z)/m)
-    head = m ? m[1] : text
-    tail = m ? m[2].to_s.strip : ""
-    if head.length > 60
-      cut = head[0, 60].rindex(" ") || 60
-      tail = "#{head[cut..].strip} #{tail}".strip
-      head = head[0, cut].strip
-    end
+    head, rest = clause_and_rest(text)
+    return [head, ""] unless rest
+
+    second, more = clause_and_rest(rest)
+    tail = more ? second : rest
     [head, tail]
   end
+
+  # Returns [clause_without_terminal_punctuation, remainder_or_nil]. `nil` for
+  # the remainder means either no boundary exists at all, or the boundary
+  # sits at the absolute end of `text` (a single trailing clause with nothing
+  # after it) — both cases where there is no SECOND clause to fold in.
+  def self.clause_and_rest(text)
+    m = text.match(/\A(.+?)[.;](\s+(.*)|\z)/m)
+    return [text, nil] unless m
+
+    remainder = m[2].to_s.strip
+    remainder.empty? ? [m[1], nil] : [m[1], remainder]
+  end
+
+  # Word-boundary truncation with a trailing "…" when cut, never mid-word and
+  # never a clause trim (intent 316a D3).
+  def self.truncate_words(text, max)
+    return text if text.length <= max
+    return "…" if max <= 1
+
+    cut = text[0, max - 1].rindex(" ")
+    cut = max - 1 if cut.nil? || cut.zero?
+    "#{text[0, cut].rstrip}…"
+  end
 end

package/scripts/lib/intent_screen_ansi.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "intent_screen"
+
+# IntentScreenAnsi (intent 316a, O2) - renders one intent screen with raw
+# truecolor ANSI escapes, productionizing 318's mockup--render.rb. Standard
+# library only. Calls the SAME public IntentScreen.* field methods
+# scripts/intent-screen calls (store_fields, index_fields, savepoint_fields,
+# checklist_items, progress_fields, next_fields, insight_fields,
+# items_present?, fallback_name, step_text) and re-derives nothing, so every
+# field the ANSI block prints is the identical value the plain screen prints
+# (D3), just carried through a different layout.
+#
+# `color:` is a constructor/call argument, never an environment read (D18):
+# the plain path (`color: false`) is one call away and testable without
+# touching NO_COLOR or a TTY. No ENV, no Dir.pwd, no Dir.home.
+module IntentScreenAnsi
+  ESC = "\e"
+  RESET = "#{ESC}[0m".freeze
+  BOLD = "#{ESC}[1m".freeze
+  TEAL = "#{ESC}[38;2;45;212;191m".freeze
+  AMBER = "#{ESC}[38;2;245;158;11m".freeze
+  GRAPHITE_BG = "#{ESC}[48;2;31;41;55m".freeze
+  MIDGREY = "#{ESC}[38;2;148;163;184m".freeze
+  NEARWHITE = "#{ESC}[38;2;243;244;246m".freeze
+
+  BAR_CELLS = 24
+  EIGHTHS = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"].freeze
+
+  DEFAULT_WIDTH = 100
+
+  ELLIPSIS = "…"
+
+  def self.render(intent_dir:, store_root:, color: true, width: DEFAULT_WIDTH)
+    base = File.basename(intent_dir)
+    id = base.split("--", 2).first
+    intent_text = File.read(File.join(intent_dir, "#{base}.md"))
+
+    fields = {}
+    fields.merge!(IntentScreen.store_fields(store_root))
+    status, title = IntentScreen.index_fields(store_root, id)
+    fields["status"] = status
+    fields["status.note"] = status == "unlisted" ? "no INDEX.md line names this id" : "listed under ## #{status} in INDEX.md"
+    fields["id"] = id
+    fields["name"] = title || IntentScreen.fallback_name(intent_text)
+    fields.merge!(IntentScreen.savepoint_fields(intent_dir, intent_text))
+    items = IntentScreen.checklist_items(intent_dir)
+    fields.merge!(IntentScreen.progress_fields(items))
+    fields.merge!(IntentScreen.next_fields(items, status, checklist_present: IntentScreen.items_present?(intent_dir), escape_pipes: false))
+    fields.merge!(IntentScreen.insight_fields(intent_text, escape_pipes: false))
+    fields.transform_values! { |v| clean(v) }
+
+    done_n = fields["progress.done"].to_i
+    total_n = fields["progress.total"].to_i
+
+    out = +""
+    out << fit("▶ #{fields['id']} · #{fields['name']}", width) { |t| styled(t, color, BOLD, NEARWHITE) }
+    out << "\n\n"
+
+    # The 4th column marks a row whose value is already a finished, pre-fit
+    # string (the Progress bar, built above from styled glyphs plus a count)
+    # rather than raw field text still needing `fit_plain`. Naming that
+    # explicitly here reads better than testing the value for a leading ESC
+    # byte further down, which is really just asking "is this the Progress
+    # row?" through a type check.
+    field_rows = [
+      ["Store", fields["store"], fields["store.note"], false],
+      ["Status", fields["status"], fields["status.note"], false],
+      ["Stage", fields["stage"], fields["stage.note"], false],
+      ["Savepoint", fields["savepoint"], fields["savepoint.note"], false],
+      ["Progress", "#{render_bar(done_n, total_n, color)}  #{done_n} / #{total_n}", fields["progress.note"], true],
+      ["Next", fields["next"], fields["next.note"], false],
+      ["Insight", fields["insight"], fields["insight.note"], false],
+    ]
+    key_width = field_rows.map { |k, _, _, _| k.length }.max
+    prefix_width = key_width + 4 # "  " + key.ljust + "  "
+
+    field_rows.each do |key, value, note, prebuilt|
+      value_budget = [width - prefix_width, 0].max
+      value_text = prebuilt ? value : fit_plain(value, value_budget)
+      out << "  #{styled(key.ljust(key_width), color, BOLD)}  #{value_text}\n"
+      next if note.to_s.empty?
+
+      note_budget = [width - prefix_width, 0].max
+      indent = " " * prefix_width
+      out << "#{indent}#{fit(note, note_budget) { |t| styled(t, color, MIDGREY) }}\n"
+    end
+
+    out << "\n"
+    out << fit("Steps", width) { |t| styled(t, color, BOLD, NEARWHITE) }
+    out << "\n\n"
+
+    if items.empty?
+      out << "  no steps yet\n"
+    else
+      # Padded to the widest label (matrix B2): at 10+ steps "S10" is one
+      # column wider than "S1..S9", and without padding every badge past S9
+      # drifts out of column with the rows above it.
+      label_width = "S#{items.size}".length
+      items.each_with_index do |item, i|
+        num = "S#{i + 1}".ljust(label_width)
+        badge = status_cell(item[:done], color)
+        prefix_plain = "  #{num}  [ #{item[:done] ? 'done' : 'open'} ]  "
+        text_budget = [width - prefix_plain.length, 0].max
+        text = fit_plain(clean(IntentScreen.step_text(item[:text])), text_budget)
+        out << "  #{num}  [#{badge}]  #{text}\n"
+      end
+    end
+
+    out
+  end
+
+  # --- markdown-noise stripping (intent 316a, S1 answer 5 / matrix 19b) ------
+  #
+  # `displayContent` is still Markdown-processed by Claude Code even inside a
+  # raw ANSI block (a live capture showed backticks silently stripped from
+  # step text). Strip backticks and neutralise `*`/`_` runs from every value
+  # before it reaches the block, so nothing is left for that pass to act on.
+  # Single underscores are left alone: they are common inside ordinary words
+  # (`intent_screen.rb`) and GFM does not treat an intraword underscore as
+  # emphasis; only a run of 2+ (the bold marker `__`) is markdown-active.
+  def self.clean(text)
+    text.to_s.delete("`*").gsub(/_{2,}/, "")
+  end
+
+  # --- width cap (D15, matrix 18) --------------------------------------------
+
+  # Truncates `text` (already markdown-clean) to `max` visible columns with a
+  # trailing ellipsis when cut, then yields the truncated plain text to the
+  # block for coloring. Coloring never adds visible width.
+  def self.fit(text, max)
+    plain = fit_plain(text, max)
+    block_given? ? yield(plain) : plain
+  end
+
+  def self.fit_plain(text, max)
+    return "" if max <= 0
+    return text if text.length <= max
+    return ELLIPSIS[0, max] if max <= 1
+
+    "#{text[0, max - 1]}#{ELLIPSIS}"
+  end
+
+  # --- palette ----------------------------------------------------------------
+
+  def self.styled(text, color, *codes)
+    return text unless color
+
+    "#{codes.join}#{text}#{RESET}"
+  end
+
+  def self.status_cell(done, color)
+    label = done ? " done " : " open "
+    return label unless color
+
+    hue = done ? TEAL : AMBER
+    "#{hue}#{BOLD}#{label}#{RESET}"
+  end
+
+  # `.dup` matters, not just style (318's own note, carried forward): these
+  # constants are built via string interpolation, which frozen_string_literal
+  # does NOT freeze automatically — only static literals get that. `.freeze`
+  # above makes them immutable, but `bar << ...` below still needs its OWN
+  # mutable copy or it would raise (or, without the freeze, silently corrupt
+  # the shared constant for every later call in the same process — matrix 16).
+  def self.render_bar(done, total, color)
+    ratio = total.zero? ? 0.0 : done.to_f / total
+
+    unless color
+      on = total.zero? ? 0 : (done * BAR_CELLS) / total
+      return ("#" * on) + ("." * (BAR_CELLS - on))
+    end
+
+    units = (ratio * BAR_CELLS * 8).round.clamp(0, BAR_CELLS * 8)
+    full, rem = units.divmod(8)
+    full = [full, BAR_CELLS].min
+
+    bar = TEAL.dup
+    bar << ("█" * full)
+    if full < BAR_CELLS && rem.positive?
+      bar << EIGHTHS[rem]
+      full += 1
+    end
+    track = BAR_CELLS - full
+    bar << GRAPHITE_BG << (" " * track) if track.positive?
+    bar << RESET
+    bar
+  end
+end