@zalom/plastic 1.14.1 → 2.0.0-alpha.1

package/scripts/exec-worktree

@@ -2,8 +2,9 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# exec-worktree (intent 213, group 2) - finish an intent's code worktree: an order
-# precondition, then Worktree.finish (delivered merges + removes, abandoned removes only).
+# exec-worktree (intent 213, group 2) - finish an intent's code worktree: the dirty-worktree
+# guard, then Worktree.finish (delivered merges + removes, abandoned removes only). The order
+# precondition it once ran first was removed in 2.0 with the gates (intent 302).
 #
 # Usage:
 #   exec-worktree --store <path> --id <intent_id> --home <plastic_home> \
@@ -18,26 +19,17 @@
 # Steps performed:
 #   0. Resolve inputs: the intent dir, normalize --home, resolve the calling session
 #      (--session, else CLAUDE_CODE_SESSION_ID, else the existing delivery.lock's own
-#      recorded owner_session when non-blank, else nil; unlike start-intent, the
-#      lock-owner fallback IS used here, matching end-intent's teardown resolution order).
-#      Load the bridge (Bridge.read); a nil bridge means there is nothing to finish (exit
-#      0, loud: the worktree this intent provisioned, if any, was NOT removed). No
-#      worktree.code on the bridge means nothing was provisioned (exit 0).
-#   1. The order precondition (delivered only): calls the EXISTING
-#      Bridge.code_gate_decision predicate exactly as it exists. On an auto bridge that
-#      has not reached How, this BLOCKS (exit 2). Bridge.code_gate_decision returns nil
-#      UNCONDITIONALLY on a guided bridge (build.auto != true), so on a guided bridge
-#      this precondition is ADVISORY ONLY: it always passes and the run proceeds. This
-#      script is NOT the enforcement point either way; the hook layer
-#      (scripts/lib/bridge.rb code_gate_decision, wired through scripts/lib/edit_gates.rb)
-#      remains the actual gate. See scripts/lib/exec_worktree.rb's module doc for why the
-#      auto-only condition is never relaxed and never duplicated here.
-#   2. The dirty-worktree guard (delivered only): git status --porcelain on the code
+#      recorded owner_session when non-blank, else nil; the lock-owner fallback IS
+#      used here, matching end-intent's teardown resolution order).
+#      Derive the worktree block from projects.yml and the intent id (Arm.worktree_block;
+#      the /tmp bridge this once read was removed in 2.0, intent 307). No code worktree on
+#      disk means nothing was provisioned (exit 0).
+#   1. The dirty-worktree guard (delivered only): git status --porcelain on the code
 #      worktree. Not clean, or the check itself fails, fails CLOSED (exit 3), mirroring
 #      end-intent's dirty-worktree handling. abandoned skips this guard entirely: the
 #      branch survives and can be reclaimed, so a dirty worktree is not a reason to
 #      refuse.
-#   3. Finish: Worktree.finish(bridge_data, home:, runner:, merge: disposition ==
+#   2. Finish: Worktree.finish(bridge_data, home:, runner:, merge: disposition ==
 #      "delivered"). Worktree.finish is fail-open and never raises, so failure is
 #      detected by checking, for a delivered disposition only, whether the worktree
 #      directory still exists on disk afterward (release removes it on success).
@@ -49,8 +41,7 @@
 #   0  finished (merged or removed per disposition), or nothing to finish (no bridge
 #      resolved, or no code worktree recorded on the bridge)
 #   1  usage or path-resolution failure
-#   2  the order precondition blocked a delivered disposition (auto bridge, How not
-#      reached)
+#   2  retired in 2.0 (intent 302): was the order precondition; never emitted, never reused
 #   3  the worktree is not clean, or the merge/removal did not complete (delivered only)
 #   4  lock or session resolution failure
 

package/scripts/file-session-intent

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# file-session-intent (intent 301): backfill and close one session day ledger,
+# carrying its open items into a target day.
+#
+# Usage:
+#   file-session-intent --day <YYYYMMDD> [--carry-to <YYYYMMDD>] [--store <dir>]
+#                       [--templates <dir>] [--author <name>]
+#
+# --store defaults to $PLASTIC_HOME/store ($PLASTIC_HOME defaults to ~/.plastic).
+# Prints one line: `filed <day>` or `skipped <day>: closed`. Exit 0 on success
+# and on any filing error (reported on stderr; the next boot tries again), 2 on
+# a usage error.
+
+require_relative "lib/session_ledger"
+require_relative "lib/session_backfill"
+
+def usage_abort(message)
+  warn "file-session-intent: #{message}"
+  exit 2
+end
+
+def next_value!(argv, i, flag)
+  value = argv[i + 1]
+  usage_abort("#{flag} needs a value") if value.nil? || value.start_with?("--")
+  value
+end
+
+opts = { day: nil, carry_to: nil, store: nil, templates: nil, author: "session" }
+i = 0
+while i < ARGV.length
+  case ARGV[i]
+  when "--day"       then opts[:day] = next_value!(ARGV, i, "--day"); i += 1
+  when "--carry-to"  then opts[:carry_to] = next_value!(ARGV, i, "--carry-to"); i += 1
+  when "--store"     then opts[:store] = next_value!(ARGV, i, "--store"); i += 1
+  when "--templates" then opts[:templates] = next_value!(ARGV, i, "--templates"); i += 1
+  when "--author"    then opts[:author] = next_value!(ARGV, i, "--author"); i += 1
+  else usage_abort("unknown argument #{ARGV[i].inspect}")
+  end
+  i += 1
+end
+
+usage_abort("--day is required") if opts[:day].nil?
+usage_abort("--day must be a real calendar date, YYYYMMDD") unless SessionLedger.valid_day_id?(opts[:day])
+if opts[:carry_to] && !SessionLedger.valid_day_id?(opts[:carry_to])
+  usage_abort("--carry-to must be a real calendar date, YYYYMMDD")
+end
+
+store = opts[:store] || File.join(File.expand_path(ENV.fetch("PLASTIC_HOME", "~/.plastic")), "store")
+templates = opts[:templates] || File.expand_path("../templates", __dir__)
+
+begin
+  result = SessionBackfill.file_day(store: store, day: opts[:day], templates: templates,
+                                    author: opts[:author], carry_to: opts[:carry_to])
+  puts(result == :closed ? "skipped #{opts[:day]}: closed" : "filed #{opts[:day]}")
+rescue StandardError => e
+  warn "file-session-intent: #{opts[:day]} not filed: #{e.class}: #{e.message}"
+end
+exit 0

package/scripts/hook-capture

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-capture (reads the UserPromptSubmit stdin JSON payload)
+# Intent 298. One UserPromptSubmit process replacing hook-continue,
+# hook-future-intent-check, and hook-auto-arm: it appends a pending line to
+# the session day ledger, detects "continue" and "auto" prompts, and hints at
+# matching Future intents. Every job runs in its own rescue and the hook
+# always exits 0 (spec D2).
+
+require "json"
+require "yaml"
+require "open3"
+require "fileutils"
+require_relative "lib/session_ledger"
+require_relative "lib/dashboard_banner"
+
+raw = begin
+  $stdin.read
+rescue StandardError
+  nil
+end
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = begin
+  JSON.parse(raw)
+rescue StandardError
+  nil
+end
+exit 0 unless payload.is_a?(Hash)
+
+session_id = payload["session_id"].to_s
+prompt = payload["user_prompt"].to_s
+cwd = payload["cwd"].to_s
+cwd = Dir.pwd if cwd.empty?
+
+plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+store = File.join(plastic_home, "store")
+templates = File.expand_path("../templates", __dir__)
+sid = SessionLedger.short_session_id(nil, session_id)
+today = SessionLedger.day_id
+
+# --- Extracted matching logic, shared by both the global and project store
+# passes of job (f) below (mirrors hook-future-intent-check verbatim). ---
+def future_intent_matches(store_root, message)
+  index_path = File.join(store_root, "INDEX.md")
+  return [] unless File.exist?(index_path)
+
+  lines = File.readlines(index_path)
+  future_dirs = []
+  section = nil
+
+  lines.each do |line|
+    section = :future if line.start_with?("## Future")
+    section = nil if line.start_with?("## ") && !line.start_with?("## Future")
+    next unless section == :future && line.strip.start_with?("- [")
+
+    future_dirs << $1 if line =~ /store\/([\w-]+)\//
+  end
+  return [] if future_dirs.empty?
+
+  matches = []
+  message_words = message.split(/\W+/).reject { |w| w.length < 4 }
+
+  future_dirs.each do |dir|
+    intent_path = File.join(store_root, "store", dir, "#{dir}.md")
+    next unless File.exist?(intent_path)
+
+    content = File.read(intent_path)
+
+    tags = []
+    tags = $1.split(",").map(&:strip).map(&:downcase) if content =~ /^tags:\s*\[([^\]]+)\]/
+
+    intent_name = ""
+    intent_name = $1.downcase if content =~ /^intent:\s*["']?(.+?)["']?\s*$/
+
+    keywords = (tags + intent_name.split(/\W+/).reject { |w| w.length < 4 }).map(&:downcase).uniq
+
+    matched_keywords = keywords.select { |kw| message.include?(kw) }
+    name_matches = message_words.select { |w| intent_name.include?(w) }
+    matched_keywords = (matched_keywords + name_matches).uniq
+
+    next if matched_keywords.empty?
+
+    index_line = lines.find { |l| l.include?(dir) }&.strip || "#{dir} - #{intent_name}"
+    matches << { "index_line" => index_line, "keywords" => matched_keywords }
+  end
+  matches
+end
+
+# The store_root that carries the current project's own store, resolved from
+# cwd through projects.yml, mirroring SessionLedger.project_slug's matching
+# but returning nil (not "global") when nothing matches, since there is then
+# no distinct second store to hint against.
+def resolve_project_store_root(cwd, plastic_home)
+  projects_path = File.join(plastic_home, "projects.yml")
+  return nil unless File.exist?(projects_path)
+
+  data = begin
+    YAML.safe_load(File.read(projects_path))
+  rescue StandardError
+    nil
+  end
+  data = {} unless data.is_a?(Hash)
+  projects = data["projects"].is_a?(Hash) ? data["projects"] : {}
+  expanded_cwd = File.expand_path(cwd)
+
+  matches = projects.filter_map do |slug, info|
+    next unless info.is_a?(Hash) && slug.is_a?(String)
+
+    path = info["path"]
+    next unless path
+
+    root = File.expand_path(path)
+    next unless expanded_cwd == root || expanded_cwd.start_with?("#{root}#{File::SEPARATOR}")
+
+    [root.length, slug]
+  end
+
+  best = matches.max_by { |(length, _slug)| length }
+  best ? File.join(plastic_home, "projects", best[1]) : nil
+end
+
+def truncate(text, max)
+  return text if text.length <= max
+
+  "#{text[0, max - 3]}..."
+end
+
+# --- (a) tmp root + heartbeat, unconditional -------------------------------
+begin
+  SessionLedger.ensure_tmp_root(store)
+  FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+  File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
+rescue StandardError
+  nil
+end
+
+# --- (b) read the pointer -----------------------------------------------
+skip_day_ledger = false
+begin
+  pointer = SessionLedger.pointer_path(store, sid)
+  if File.exist?(pointer)
+    current = File.read(pointer).strip
+    skip_day_ledger = !current.empty? && current != today
+  end
+rescue StandardError
+  nil
+end
+
+# --- (c) pending checklist line -------------------------------------------
+unless skip_day_ledger
+  begin
+    project = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+    clean = truncate(SessionLedger.sanitize_summary(prompt), 120)
+    if clean.length >= 10
+      SessionLedger.open_day(store: store, day: today, templates: templates, author: sid)
+      line = SessionLedger.checklist_line(:pending, sid, project, clean)
+      SessionLedger.append_line(SessionLedger.checklist_path(store, today), line,
+                                 header: SessionLedger.checklist_header(today))
+    end
+  rescue StandardError
+    nil
+  end
+end
+
+context_parts = []
+system_message = nil
+
+# --- (d) "continue" cockpit -------------------------------------------------
+begin
+  if prompt.match?(/\bcontinue\b/i)
+    dashboard = File.expand_path("dashboard.rb", __dir__)
+    if File.exist?(dashboard)
+      cockpit, _err, status = Open3.capture3({ "RUBYOPT" => nil }, "ruby", dashboard, "continue")
+      if status.success? && !cockpit.strip.empty?
+        context_parts << (cockpit.rstrip +
+          "\n\nFollow the plastic-intent-continuing skill workflow to resume: " \
+          "if active intents exist, read their state and resume; otherwise surface the " \
+          "most-valuable next work and any stale or triage intents from the board above.")
+
+        begin
+          data_json, _data_err, data_status = Open3.capture3({ "RUBYOPT" => nil }, "ruby", dashboard,
+                                                               "continue", "--data")
+          if data_status.success?
+            banner = DashboardBanner.render(JSON.parse(data_json))
+            system_message = banner if banner
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+rescue StandardError
+  nil
+end
+
+# --- (e) auto-trigger steering (hook-auto-arm job 1 only) ------------------
+begin
+  message_lower = prompt.downcase
+  auto_triggers = ["take it from here", "deliver this", "/plastic-auto", "auto mode"].freeze
+  triggered = auto_triggers.any? { |p| message_lower.include?(p) } || message_lower.match?(/\bauto\b/)
+  if triggered
+    context_parts << "Auto-mode request detected. Invoke the plastic-auto skill to deliver the " \
+                      "active intent autonomously - it takes the intent under a lock and a worktree " \
+                      "and points this session at it."
+  end
+rescue StandardError
+  nil
+end
+
+# --- (f) Future-intent hint, global store then the project's own store -----
+begin
+  message = prompt.to_s.downcase
+  if message.strip.length >= 10 && message.strip != "continue"
+    matches = future_intent_matches(plastic_home, message)
+    project_root = resolve_project_store_root(cwd, plastic_home)
+    matches += future_intent_matches(project_root, message) if project_root
+
+    if matches.any?
+      parts = ["PLASTIC - Future intents related to this message:\n"]
+      matches.each { |m| parts << "#{m["index_line"]} (matched: #{m["keywords"].join(", ")})" }
+      parts << "\nConsider asking the user if they want to activate any of these, or note the connection."
+      context_parts << parts.join("\n")
+    end
+  end
+rescue StandardError
+  nil
+end
+
+exit 0 if context_parts.empty?
+
+payload_out = {
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context_parts.join("\n\n")
+  }
+}
+payload_out["systemMessage"] = system_message if system_message
+puts JSON.generate(payload_out)

package/scripts/hook-close

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# hook-close (intent 301): the SessionEnd hook. Reads the harness payload from
+# stdin (session_id, cwd, reason), takes the Plastic home from argv, and runs
+# SessionClose with the detached filer spawner. Always exits 0, prints nothing.
+#
+# Usage: hook-close <plastic_home>   (stdin: the hook JSON)
+
+require "json"
+require_relative "lib/session_ledger"
+require_relative "lib/session_close"
+
+plastic_home = ARGV[0]
+exit 0 if plastic_home.nil? || plastic_home.empty?
+
+payload =
+  begin
+    raw = $stdin.tty? ? "" : $stdin.read
+    raw.to_s.strip.empty? ? {} : JSON.parse(raw)
+  rescue JSON::ParserError
+    {}
+  end
+
+store = File.join(File.expand_path(plastic_home), "store")
+filer = File.expand_path("file-session-intent", __dir__)
+begin
+  SessionClose.run(payload: payload, store: store, today: SessionLedger.day_id,
+                   spawner: SessionClose.default_spawner(filer))
+rescue StandardError
+  nil
+end
+exit 0

package/scripts/hook-record

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-record (reads the PostToolUse stdin JSON payload)
+# Intent 298. Replaces hook-gate-check: never blocks, keeps the decoupled
+# intent-dir savepoint append byte for byte, refreshes the delivery-lock lease
+# for the owning session (intent 302, the lock gate's old allow-path job),
+# promotes the session's newest pending day-ledger line when a project file
+# lands, and calls the session-commit seam when that script exists. Always
+# exits 0 (spec D3).
+
+require "json"
+require "timeout"
+require "fileutils"
+require_relative "lib/savepoint"
+require_relative "lib/lock"
+require_relative "lib/session_ledger"
+
+raw = begin
+  $stdin.read
+rescue StandardError
+  nil
+end
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = begin
+  JSON.parse(raw)
+rescue StandardError
+  nil
+end
+exit 0 unless payload.is_a?(Hash)
+
+file_path = payload.dig("tool_input", "file_path") || payload.dig("tool_params", "file_path")
+exit 0 if file_path.to_s.empty?
+
+session_id = payload["session_id"].to_s
+cwd = payload["cwd"].to_s
+cwd = Dir.pwd if cwd.empty?
+
+file_path_abs = File.expand_path(file_path)
+
+# --- (a) decoupled savepoint ledger, byte for byte -------------------------
+intent_dir_abs = nil
+begin
+  intent_dir_abs = Savepoint.intent_dir_for(file_path_abs)
+  if intent_dir_abs
+    begin
+      Savepoint.append_savepoint(intent_dir_abs, file_path_abs)
+      if File.basename(file_path_abs) == "checklist.md" && Savepoint.stage_file_present?(file_path_abs)
+        Savepoint.append_exec_started(intent_dir_abs)
+      end
+    rescue StandardError
+      nil
+    end
+    # The lease heartbeat (intent 302, spec D10): the lock gate's allow path used
+    # to refresh delivery.lock on every edit; record does it now. Lock.heartbeat
+    # refuses a session that does not hold the lock, so a stranger's write never
+    # refreshes the owner's lease.
+    begin
+      Lock.heartbeat(intent_dir_abs, session: session_id) unless session_id.empty?
+    rescue StandardError
+      nil
+    end
+  end
+rescue StandardError
+  nil
+end
+
+plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+
+# --- (b) stop the day-ledger path when inside ~/.plastic or an intent dir --
+inside_plastic = file_path_abs == plastic_home || file_path_abs.start_with?("#{plastic_home}/")
+skip_day_ledger = inside_plastic || !intent_dir_abs.nil?
+
+# --- (c) promote the newest pending line, Item savepoint, seam -------------
+unless skip_day_ledger
+  begin
+    store = File.join(plastic_home, "store")
+    sid = SessionLedger.short_session_id(nil, session_id)
+    today = SessionLedger.day_id
+
+    proceed = true
+    pointer = SessionLedger.pointer_path(store, sid)
+    if File.exist?(pointer)
+      current = File.read(pointer).strip
+      proceed = current.empty? || current == today
+    end
+
+    if proceed
+      checklist = SessionLedger.checklist_path(store, today)
+      target_summary = begin
+        SessionLedger.set_state(checklist, from: :pending, to: :open, session: sid)
+      rescue SessionLedger::LockUnavailableError
+        nil
+      end
+
+      if target_summary
+        project = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+        line = SessionLedger.savepoint_line("Item", sid, project, target_summary, now: Time.now)
+        SessionLedger.append_line(SessionLedger.savepoint_path(store, today), line, header: nil)
+
+        seam = File.expand_path("session-commit", __dir__)
+        if File.executable?(seam)
+          begin
+            # A bare Timeout.timeout around Open3.capture3 does not reliably bound a
+            # genuinely hanging child: capture3's internal wait still blocks on
+            # Process.waitpid for the child regardless of the raised Timeout::Error.
+            # Spawn directly and kill on timeout instead, so the 10s bound is real.
+            pid = Process.spawn({ "RUBYOPT" => nil }, seam, "--cwd", cwd, "--summary", target_summary,
+                                 "--session", sid, "--day", today,
+                                 [:out, :err] => File::NULL)
+            begin
+              Timeout.timeout(10) { Process.wait(pid) }
+            rescue Timeout::Error
+              begin
+                Process.kill("KILL", pid)
+              rescue StandardError
+                nil
+              end
+              begin
+                Process.wait(pid)
+              rescue StandardError
+                nil
+              end
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  rescue StandardError
+    nil
+  end
+end
+
+# --- (d) heartbeat, always -------------------------------------------------
+begin
+  store ||= File.join(plastic_home, "store")
+  sid ||= SessionLedger.short_session_id(nil, session_id)
+  SessionLedger.ensure_tmp_root(store)
+  FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+  File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
+rescue StandardError
+  nil
+end
+
+exit 0

package/scripts/hook-session-start

@@ -6,10 +6,13 @@
 require "json"
 require "date"
 require "yaml"
+require "fileutils"
 require_relative "lib/bridge"
+require_relative "lib/savepoint"
 require_relative "lib/boot_banner"
 require_relative "lib/qmd_sync"
 require_relative "lib/doctor_core"
+require_relative "lib/session_ledger"
 
 index_path, plastic_home, mode, plugin_root = ARGV
 exit 0 unless index_path && plastic_home && mode
@@ -48,16 +51,20 @@ lines.each do |line|
   end
 end
 
-# --- Derive bridge for active intent ---
+# --- Stage of the single active intent (the /tmp bridge this once derived was removed in 2.0, intent 307) ---
 
-bridge_data = nil
+stage_line = nil
 if active.length == 1 && active.first =~ /store\/([\w-]+)\//
   dir_name = $1
   intent_dir = "#{store_dir}/#{dir_name}"
-  session = ENV["CLAUDE_CODE_SESSION_ID"] || Process.pid.to_s
-  intent_id = dir_name.split("--").first
-  intent_name = active.first[/\[([^\]]+)\]/, 1] || "unknown"
-  bridge_data = Bridge.derive(session, intent_id: intent_id, intent_dir: intent_dir, store: store_dir, name: intent_name)
+  begin
+    stage = Savepoint.derive_stage(intent_dir)
+    missing = Savepoint.missing_for_stage(stage, intent_dir)
+    missing_str = missing.empty? ? "none" : missing.join(", ")
+    stage_line = "Stage: #{stage} | Next: #{missing_str}"
+  rescue StandardError
+    stage_line = nil
+  end
 end
 
 # --- Detect stale future intents ---
@@ -251,12 +258,7 @@ if plastic_md
   if all_active.any?
     parts << "Active intents:\n"
     all_active.each { |a| parts << a }
-    if bridge_data
-      stage = bridge_data["build"]["stage"]
-      missing = bridge_data["build"]["missing"]
-      missing_str = missing.empty? ? "none" : missing.join(", ")
-      parts << "Stage: #{stage} | Next: #{missing_str}"
-    end
+    parts << stage_line if stage_line
     parts << ""
   else
     parts << "No active intents. #{future.length} future intents available.\n"
@@ -302,6 +304,87 @@ if update_notice
   parts.unshift("! #{update_notice}\n")
 end
 
+# --- First-boot sweep (intent 301, spec D9): file every unclosed prior day
+# ledger into today, oldest first, at most 3 per boot within a 5-second
+# budget. Each day runs the sibling file-session-intent in its own rescue;
+# the boot never blocks on it.
+begin
+  require "open3"
+  require "timeout"
+  require_relative "lib/session_backfill"
+
+  sweep_today = SessionLedger.day_id
+  sweep_root = SessionLedger.sessions_root(store_dir)
+  sweep_filer = File.expand_path("file-session-intent", __dir__)
+  sweep_templates = File.expand_path("../templates", __dir__)
+  candidates = []
+  if Dir.exist?(sweep_root) && File.exist?(sweep_filer)
+    candidates = Dir.children(sweep_root).select do |name|
+      File.directory?(File.join(sweep_root, name)) && SessionLedger.valid_day_id?(name) &&
+        name < sweep_today && !SessionBackfill.closed?(store_dir, name)
+    end.sort
+  end
+  filed = 0
+  budget_end = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+  candidates.first(3).each do |day|
+    break if Process.clock_gettime(Process::CLOCK_MONOTONIC) > budget_end
+
+    begin
+      Timeout.timeout(5) do
+        _out, _err, sweep_status = Open3.capture3({ "RUBYOPT" => nil }, RbConfig.ruby, sweep_filer,
+                                                  "--day", day, "--carry-to", sweep_today,
+                                                  "--store", store_dir, "--templates", sweep_templates)
+        filed += 1 if sweep_status.success? && SessionBackfill.closed?(store_dir, day)
+      end
+    rescue StandardError
+      nil
+    end
+  end
+  if filed.positive?
+    line = "PLASTIC: filed #{filed} prior day ledger(s) into #{sweep_today}"
+    remaining = candidates.size - filed
+    line += ", #{remaining} more wait for the next boot" if remaining.positive?
+    parts << line
+  end
+rescue StandardError
+  nil
+end
+
+# --- Session day ledger: open or join today, write the per-session pointer
+# and heartbeat (intent 298, spec D4). Best-effort: any failure here degrades
+# to no ledger context line, never blocks the session.
+begin
+  templates = File.expand_path("../templates", __dir__)
+  day = SessionLedger.day_id
+  author = `"#{read_config}" author`.strip
+  author = "session" if author.empty?
+  SessionLedger.open_day(store: store_dir, day: day, templates: templates, author: author)
+
+  session = ENV["CLAUDE_CODE_SESSION_ID"] || Process.pid.to_s
+  sid = SessionLedger.short_session_id(nil, session)
+  SessionLedger.ensure_tmp_root(store_dir)
+  FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store_dir, sid))
+  File.write(SessionLedger.heartbeat_path(store_dir, sid), "#{Time.now.utc.iso8601}\n")
+  pointer = SessionLedger.pointer_path(store_dir, sid)
+  File.write(pointer, "#{day}\n") unless File.exist?(pointer)
+
+  checklist = SessionLedger.checklist_path(store_dir, day)
+  open_count = 0
+  pending_count = 0
+  if File.exist?(checklist)
+    File.readlines(checklist).each do |line|
+      parsed = SessionLedger.parse_checklist_line(line)
+      next unless parsed
+
+      open_count += 1 if parsed[:state] == :open
+      pending_count += 1 if parsed[:state] == :pending
+    end
+  end
+  parts << "PLASTIC: day ledger #{day} joined (#{open_count} open items, #{pending_count} pending)"
+rescue StandardError
+  nil
+end
+
 # Emit nothing when there is genuinely nothing to surface (no conventions,
 # no deprecations, no update notice).
 exit 0 if parts.join.strip.empty?