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

package/scripts/lib/runner_dispatch.rb

@@ -6,7 +6,7 @@ require "yaml"
 require_relative "ready_set"
 require_relative "node_ledger"
 require_relative "node_file"
-require_relative "node_packet"
+require_relative "node_input"
 require_relative "node_worktree"
 require_relative "work_graph_validator"
 require_relative "runner_core"
@@ -17,12 +17,12 @@ 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
+# ready set, applies RunnerPolicy, mints leases, builds node inputs, writes
 # `running`, and returns the dispatch plan `step` prints. Never spawns an
 # agent itself (327 D42): the session does that from the plan this returns.
 #
 # Pure and dependency-injected down to the clock: every side effect - the
-# full validator, the ready-set analyzer, the packet builder, the worktree
+# full validator, the ready-set analyzer, the input builder, the worktree
 # module, the ledger write, git itself - is an injectable keyword argument
 # with a real default, so a test never touches a real repository or a real
 # filesystem outside its own tmpdir.
@@ -32,7 +32,7 @@ module RunnerDispatch
   DEFAULT_LIMIT = 2
 
   # The return-schema instruction (327 D5): rides in the dispatch PLAN, never
-  # inside the packet, so `packet=<sha>` keeps naming a reproducible input
+  # inside the node input, so `input=<sha>` keeps naming a reproducible input
   # (matrix row 5.23). NodeReturn.parse (n4) is this text's implementation.
   RETURN_CONTRACT = <<~TEXT.freeze
     RETURN CONTRACT: reply with exactly one YAML document as your final
@@ -52,13 +52,13 @@ module RunnerDispatch
   SPAWN_AGENT = "plastic-executor"
 
   # matrix 6.1/6.2: one spawn block per dispatched node - agent, the model
-  # RunnerPolicy.model_for resolved, the packet path, the one test command
-  # (NodePacket.test_command_block, n4), and the call cap (n2) - fenced so a
+  # RunnerPolicy.model_for resolved, the node input path, the one test command
+  # (NodeInput.test_command_block, n4), and the call cap (n2) - fenced so a
   # session pastes it straight into the Agent tool (327 D42: the runner
   # itself never spawns).
-  def spawn_block(model:, packet:, test_command:, call_cap:, agent: SPAWN_AGENT)
-    lines = ["agent: #{agent}", "model: #{model}", "packet: #{packet}", test_command,
-             NodePacket.call_cap_sentence(call_cap)]
+  def spawn_block(model:, input:, test_command:, call_cap:, agent: SPAWN_AGENT)
+    lines = ["agent: #{agent}", "model: #{model}", "input: #{input}", test_command,
+             NodeInput.call_cap_sentence(call_cap)]
     (["```"] + lines + ["```"]).join("\n")
   end
 
@@ -69,7 +69,7 @@ module RunnerDispatch
   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),
+               input_builder: NodeInput.method(:build),
                worktree: NodeWorktree,
                ledger: NodeLedger,
                runner: Worktree::ShellRunner.new,
@@ -132,7 +132,7 @@ module RunnerDispatch
     dispatched = []
     parked = []
     stop = nil
-    packet_failures = []
+    input_failures = []
     ceiling_blocked = false
 
     analysis[:ranked_ready].each do |row|
@@ -172,10 +172,10 @@ module RunnerDispatch
       end
 
       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,
+                             caps: caps, edges: edges, nodes_decl: nodes_decl, input_builder: input_builder,
                              worktree: worktree, ledger: ledger, runner: runner)
-      if result[:packet_build_failed]
-        packet_failures << result
+      if result[:input_build_failed]
+        input_failures << result
         next
       end
       next unless result[:ok]
@@ -192,7 +192,7 @@ 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, input_failures: input_failures, running_count: running_count,
                  harness: harness_key)
   end
 
@@ -212,9 +212,9 @@ module RunnerDispatch
   end
   private_class_method :safe_analyze
 
-  # --- one node's whole dispatch (packet, lease, `running`) -------------------
+  # --- one node's whole dispatch (node input, lease, `running`) -------------------
 
-  def dispatch_one(context, node:, kind:, now:, config:, harness:, caps:, edges:, nodes_decl:, packet_builder:,
+  def dispatch_one(context, node:, kind:, now:, config:, harness:, caps:, edges:, nodes_decl:, input_builder:,
                     worktree:, ledger:, runner:)
     intent_dir = context.intent_dir
     savepoint_path = File.join(intent_dir.to_s, "savepoint.md")
@@ -231,7 +231,7 @@ module RunnerDispatch
     pre_existing_worktree = worktree_pre_existing?(worktree, context, node, kind)
 
     # Row 5.16/5.29: only a `work` node gets a worktree, and this is the
-    # node-scoped `worktree_reader:` D23 injects into NodePacket.build - it
+    # node-scoped `worktree_reader:` D23 injects into NodeInput.build - it
     # names THIS node's own worktree and branch, never the intent's.
     provisioned = RunnerPolicy.worktree?(kind) ? worktree.provision(context, node: node, kind: kind, runner: runner)
                                                 : unprovisioned
@@ -239,26 +239,26 @@ module RunnerDispatch
       { "code" => provisioned[:path], "code_branch" => provisioned[:branch], "provisioned" => !!provisioned[:provisioned] }
     end
 
-    # Row 5.18: build the packet BEFORE writing `running` - a `running` line
-    # naming bytes that do not exist yet is worse than a packet nobody reads.
+    # Row 5.18: build the node input BEFORE writing `running` - a `running` line
+    # naming bytes that do not exist yet is worse than a node input nobody reads.
     # Row 5.30: `force: true` always - a fresh attempt number this dispatch
     # computes is, by construction, never one `running` has already claimed,
     # so an existing file at that path is always an orphan from a step that
-    # crashed between building the packet and writing `running`, safe to
+    # crashed between building the node input and writing `running`, safe to
     # overwrite outright.
     # Row 5.20/10.8: the node's own declared budget: (M7) - nil when the node
-    # names none, in which case NodePacket.build falls back to its own
+    # names none, in which case NodeInput.build falls back to its own
     # default (row 10.9).
-    build_result = packet_builder.call(intent_dir: intent_dir, node: node, holder: holder, expires: expires,
+    build_result = input_builder.call(intent_dir: intent_dir, node: node, holder: holder, expires: expires,
                                         model: model, force: true, worktree_reader: node_reader,
                                         budget_tokens: node_declared_budget(intent_dir, node), call_cap: calls_cap)
     unless build_result[:ok]
-      # M6: a failed packet build never leaves an orphan worktree behind, and
+      # M6: a failed input build never leaves an orphan worktree behind, and
       # its errors travel back up so the step's report can name the node and
       # the reason instead of a bare "stalled" (row 10.6/10.7).
-      rollback_dispatch(context, node: node, kind: kind, packet_path: build_result[:path], runner: runner,
+      rollback_dispatch(context, node: node, kind: kind, input_path: build_result[:path], runner: runner,
                          worktree: worktree, created_this_dispatch: !pre_existing_worktree)
-      return { ok: false, packet_build_failed: true, node: node, errors: build_result[:errors] }
+      return { ok: false, input_build_failed: true, node: node, errors: build_result[:errors] }
     end
 
     precondition = lambda do |c|
@@ -267,7 +267,7 @@ module RunnerDispatch
     # 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,
+    fields = { holder: holder, expires: expires, input: build_result[:sha], model: model, harness: harness,
                calls: calls_cap }
 
     result = begin
@@ -281,18 +281,18 @@ module RunnerDispatch
     # side effects this method already produced - the node never ran, so
     # nothing may act like it did.
     unless result == :written
-      rollback_dispatch(context, node: node, kind: kind, packet_path: build_result[:path], runner: runner,
+      rollback_dispatch(context, node: node, kind: kind, input_path: build_result[:path], runner: runner,
                          worktree: worktree, created_this_dispatch: !pre_existing_worktree)
       return { ok: false }
     end
 
-    test_command = NodePacket.test_command_block(intent_dir: intent_dir, files: (nodes_decl[node] || {})[:files])
-    spawn = spawn_block(model: model, packet: build_result[:path], test_command: test_command, call_cap: calls_cap)
+    test_command = NodeInput.test_command_block(intent_dir: intent_dir, files: (nodes_decl[node] || {})[:files])
+    spawn = spawn_block(model: model, input: build_result[:path], test_command: test_command, call_cap: calls_cap)
 
     {
       ok: true,
       entry: { node: node, kind: kind.to_s, role: role_for(kind), model: model, worktree: provisioned[:path],
-                packet: build_result[:path], spawn: spawn },
+                input: build_result[:path], spawn: spawn },
     }
   end
 
@@ -331,10 +331,10 @@ module RunnerDispatch
 
   # Row 10.16/M13: `created_this_dispatch:` gates the worktree half of the
   # rollback - a worktree this call did not create (kept on disk by a prior
-  # attempt's failed_verification, D7) is never touched, only a packet this
-  # call's own `packet_builder` may have written is ever deleted.
-  def rollback_dispatch(context, node:, kind:, packet_path:, runner:, worktree:, created_this_dispatch:)
-    File.delete(packet_path) if packet_path && File.exist?(packet_path)
+  # attempt's failed_verification, D7) is never touched, only a node input this
+  # call's own `input_builder` may have written is ever deleted.
+  def rollback_dispatch(context, node:, kind:, input_path:, runner:, worktree:, created_this_dispatch:)
+    File.delete(input_path) if input_path && File.exist?(input_path)
     return unless RunnerPolicy.worktree?(kind)
     return unless created_this_dispatch
 
@@ -429,7 +429,7 @@ module RunnerDispatch
   end
   private_class_method :invalid_graph_result
 
-  def build_report(context:, dispatched:, stop:, parked:, ceiling_blocked: false, packet_failures: [],
+  def build_report(context:, dispatched:, stop:, parked:, ceiling_blocked: false, input_failures: [],
                     running_count: 0, harness: nil)
     base = empty_result.merge(dispatched: dispatched, stop: stop, parked: parked,
                                plan: render_plan(dispatched), harness: harness)
@@ -453,21 +453,21 @@ module RunnerDispatch
       if complete
         base.merge(status: "complete")
       else
-        # M6/row 10.7: a failed packet build writes no ledger line at all,
+        # M6/row 10.7: a failed input build writes no ledger line at all,
         # so `named_blockers` (ledger-derived) never sees it on its own -
         # its own node and reason are named here so `stalled` never prints
         # bare.
-        blockers = named_blockers(context) + packet_failures.map { |f| packet_failure_blocker(f) }
+        blockers = named_blockers(context) + input_failures.map { |f| input_failure_blocker(f) }
         base.merge(status: "stalled", blockers: blockers)
       end
     end
   end
   private_class_method :build_report
 
-  def packet_failure_blocker(failure)
-    "#{failure[:node]}: packet build failed (#{Array(failure[:errors]).join('; ')})"
+  def input_failure_blocker(failure)
+    "#{failure[:node]}: node input build failed (#{Array(failure[:errors]).join('; ')})"
   end
-  private_class_method :packet_failure_blocker
+  private_class_method :input_failure_blocker
 
   # Row 5.25a/5.26: every unfinished node's own blockers, with ReadySet's
   # hard-attempt-cap wording renamed so it reads as the named backstop it is
@@ -494,9 +494,9 @@ module RunnerDispatch
   private_class_method :name_blocker
 
   # Row 5.22/5.23/5.24: one machine-readable (YAML) document naming, per
-  # dispatched node, the packet path, the model, the worktree, the kind and
+  # dispatched node, the node input path, the model, the worktree, the kind and
   # the role, plus the return contract ONCE at the top level - never inside
-  # any one node's packet. Row 6.4: "spawn" carries the same, already fully
+  # any one node's input. Row 6.4: "spawn" carries the same, already fully
   # rendered spawn block for each dispatched node in order, so any reader of
   # this data (YAML today, JSON if it is ever re-serialized) finds it under
   # `spawn` rather than re-deriving it from the other fields.
@@ -507,7 +507,7 @@ module RunnerDispatch
       "return_contract" => RETURN_CONTRACT,
       "dispatch" => dispatched.map do |d|
         { "node" => d[:node], "kind" => d[:kind], "role" => d[:role], "model" => d[:model],
-          "worktree" => d[:worktree], "packet" => d[:packet] }
+          "worktree" => d[:worktree], "input" => d[:input] }
       end,
       "spawn" => dispatched.map { |d| d[:spawn] }
     )

package/scripts/lib/runner_sweep.rb

@@ -32,7 +32,7 @@ require_relative "savepoint"
 # newer commits is extended instead, up to twice per attempt (row 2.7); the
 # extension is never a ledger transition (`running` cannot re-enter `running`
 # under the transition layer), so it is one line appended to
-# packets/<node>--a<N>.extensions, `N` derived from the ledger's own attempt
+# attempts/<node>--a<N>.extensions, `N` derived from the ledger's own attempt
 # count (row 2.18), never trusted from the caller. A third expiry reclaims
 # regardless of new commits.
 #
@@ -199,15 +199,15 @@ module RunnerSweep
 
   # Row 2.18: the attempt number comes from the ledger's own count of
   # `running` lines since the subject's last terminal line - the exact same
-  # arithmetic NodePacket uses to name that attempt's packet file, so the
-  # extensions file for a `running` line always matches the packet it extends.
+  # arithmetic NodeInput uses to name that attempt's input file, so the
+  # extensions file for a `running` line always matches the node input it extends.
   def current_attempt(entries, subject)
     ReadySet.attempts_count(entries, subject)
   end
   private_class_method :current_attempt
 
   def extensions_path(intent_dir, node, attempt)
-    File.join(intent_dir.to_s, "packets", "#{node}--a#{attempt}.extensions")
+    File.join(intent_dir.to_s, "attempts", "#{node}--a#{attempt}.extensions")
   end
   private_class_method :extensions_path
 

package/scripts/lib/runner_until_empty.rb

@@ -184,7 +184,7 @@ module RunnerUntilEmpty
   # stdout_io:, stderr_io:}. `harness:` is accepted for symmetry with
   # `step_once` even though node-run itself never takes a --harness flag -
   # the harness was already recorded on the node's own `running` line by the
-  # dispatch this call followed, and node-run reads its packet off that
+  # dispatch this call followed, and node-run reads its node input off that
   # line, never off this argv. RUBYOPT is cleared explicitly, the same
   # contract every other ruby-spawning site in this tree carries.
   def spawn_node_run(context, node:, harness: nil)

package/scripts/lib/savepoint.rb

@@ -3,14 +3,13 @@
 # frozen_string_literal: true
 
 # Savepoint: the intent-directory savepoint ledger and the stage derivation it
-# rests on (intent 303, split out of bridge.rb). Everything here is derived from
+# rests on (intent 303). Everything here is derived from
 # the files on disk inside one intent directory: which lifecycle files are real
 # (not the placeholder sentinel), which stage that makes, and the append-only
-# savepoint.md ledger that records each milestone. No session, no bridge, no
+# savepoint.md ledger that records each milestone. No session, no lock, no
 # lock: a caller that only wants to append a ledger line or ask "which stage is
-# this intent at" loads this file and nothing else. bridge.rb (the session
-# pointer, arm and disarm, lock repair) requires this file; this file never
-# requires the bridge.
+# this intent at" loads this file and nothing else. `scripts/lib/arm.rb` (arm,
+# disarm, lock repair) requires this file; this file never requires arm.rb.
 require "fileutils"
 require "time" # Time#iso8601 for the ledger timestamps
 
@@ -60,7 +59,7 @@ module Savepoint
 
   # Walk up from file_path; return the first ancestor that looks like an intent
   # directory (`.../store/<id>--<slug>`), else nil. Used to derive the savepoint
-  # target without needing a bridge. The input is always a file inside the intent
+  # target without needing the lock or arm machinery. The input is always a file inside the intent
   # dir (never the dir itself), so the walk-up starts at its parent.
   def self.intent_dir_for(file_path)
     dir = File.expand_path(file_path)
@@ -384,7 +383,7 @@ module Savepoint
 
   # --- Phantom-line detection (intent 134) ------------------------------------
   #
-  # A companion to the ledger, not a new writer: pure, disk-only, hermetic (no bridge or
+  # A companion to the ledger, not a new writer: pure, disk-only, hermetic (no lock or
   # session resolution, no writes), matching intent 52's savepoint-decoupling precedent. Under
   # a gate-routing misfire (bug 131) or an out-of-band merge (124a's precedent), a ledger line
   # can go stale or duplicate without the file evidence agreeing. This detects, never repairs;

package/scripts/lib/scaffold_intent.rb

@@ -3,7 +3,6 @@
 
 require "fileutils"
 require_relative "worktree"
-require_relative "bridge"
 require_relative "savepoint"
 require_relative "intent_validator"
 
@@ -21,7 +20,7 @@ require_relative "intent_validator"
 # copy or a mechanical rendering of a committed artifact.
 #
 # Pure and dependency-injected: never calls `exit` or `abort`, never reads `ARGV` or
-# `ENV` directly (only via the ambient `Dir.home` default, matching Bridge/Worktree
+# `ENV` directly (only via the ambient `Dir.home` default, matching this module's own
 # convention). A git seam is injected as `runner:`, defaulting to
 # `Worktree::ShellRunner.new`, so tests drive this in process with a fake runner and
 # never touch real git. Every method returns a value; `scripts/scaffold-intent` maps the
@@ -29,6 +28,10 @@ require_relative "intent_validator"
 module ScaffoldIntent
   module_function
 
+  def blank?(value)
+    value.nil? || value.to_s.strip.empty?
+  end
+
   # --- path resolution (pure) --------------------------------------------------
 
   def expand(path)
@@ -211,7 +214,7 @@ module ScaffoldIntent
       end
     end
 
-    unless Bridge.blank?(test_summary)
+    unless blank?(test_summary)
       out << "\n"
       out << "Test summary from #{test_summary}:\n"
       out << "```\n"

package/scripts/lib/session_close.rb

@@ -17,8 +17,9 @@ module SessionClose
   NOOP_REASONS = %w[clear resume].freeze
 
   # The default hand-off writer (intent 311, spec D6): renders this session's
-  # share of the pointer day into handoff--<session>.md before the tmp dir
-  # goes. The hook script builds it with the shipped templates dir.
+  # share of its session day (SessionLedger.session_day, graph.md D7) into
+  # handoff--<session>.md before the tmp dir goes. The hook script builds it
+  # with the shipped templates dir.
   def default_handoff(templates)
     lambda do |store, day, session|
       Handoff.write(store: store, day: day, session: session, trigger: "close", templates: templates)
@@ -45,26 +46,33 @@ module SessionClose
     session = SessionLedger.short_session_id(payload.is_a?(Hash) ? payload["session_id"] : nil, nil)
     return report if session.empty?
 
-    pointer_day = safely { read_pointer_day(store, session) } || today
+    days = safely { SessionLedger.session_days(store, session, today: today) } || []
+    days = [today] if days.empty?
+    session_day = days.last
     project = "global"
 
+    # Intent 344 (G11, D13): a session that crossed midnight carries pending
+    # lines on more than one day ledger; every one of them drops, not only
+    # the newest, so a close never leaves an earlier day's lines pending.
     report[:dropped] = safely do
-      checklist = SessionLedger.checklist_path(store, pointer_day)
-      count = SessionLedger.flip_all(checklist, from: :pending, to: :dropped, session: session)
-      if count.positive?
-        SessionLedger.append_line(SessionLedger.savepoint_path(store, pointer_day),
-                                  SessionLedger.savepoint_line("Note", session, project,
-                                                               "dropped #{count} pending lines at close", now: now))
+      days.sum do |day|
+        checklist = SessionLedger.checklist_path(store, day)
+        count = SessionLedger.flip_all(checklist, from: :pending, to: :dropped, session: session)
+        if count.positive?
+          SessionLedger.append_line(SessionLedger.savepoint_path(store, day),
+                                    SessionLedger.savepoint_line("Note", session, project,
+                                                                 "dropped #{count} pending lines at close", now: now))
+        end
+        count
       end
-      count
     end || 0
 
     # The hand-off (intent 311, spec D6) is written after the drop, so it
-    # reflects it, and before the tmp dir goes, since the pointer lives there.
-    # An intent pointer falls back to today, the same as the drop above.
+    # reflects it, and before the tmp dir goes. A session with no line in the
+    # day ledger's window falls back to today, the same as the drop above.
     if handoff
       report[:handoff] = safely do
-        handoff.call(store, pointer_day, session)
+        handoff.call(store, session_day, session)
         true
       end || false
     end
@@ -75,27 +83,21 @@ module SessionClose
       true
     end || false
 
-    if pointer_day < today
+    # One carry spawns per day earlier than today, oldest first; a single
+    # earlier day keeps reporting its own arg array (not a one-element
+    # list) so an existing caller reading report[:spawned] as one array is
+    # unaffected.
+    earlier_days = days.select { |day| day < today }
+    unless earlier_days.empty?
       report[:spawned] = safely do
-        args = ["--day", pointer_day, "--carry-to", today, "--store", store]
-        spawner.call(args)
-        args
+        arg_lists = earlier_days.map { |day| ["--day", day, "--carry-to", today, "--store", store] }
+        arg_lists.each { |args| spawner.call(args) }
+        arg_lists.length == 1 ? arg_lists.first : arg_lists
       end
     end
     report
   end
 
-  # The pointer names the intent this session records into; a day id means
-  # the day ledger. Anything else (an intent id) means an auto team owns the
-  # record and the close touches no day ledger.
-  def read_pointer_day(store, session)
-    path = SessionLedger.pointer_path(store, session)
-    return nil unless File.exist?(path)
-
-    value = File.read(path).strip
-    SessionLedger.valid_day_id?(value) ? value : nil
-  end
-
   def safely
     yield
   rescue StandardError

package/scripts/lib/session_git.rb

@@ -5,6 +5,7 @@ require "yaml"
 require_relative "worktree"
 require_relative "scaffold_intent"
 require_relative "session_ledger"
+require_relative "active_delivery"
 
 # SessionGit - the branch model and per-repo flow settings behind
 # `scripts/session-commit` (intent 300), which is how a checklist item
@@ -185,24 +186,29 @@ module SessionGit
     text.to_s.downcase.scan(/[a-z0-9]+/).first(max_words).join("-")
   end
 
-  # The intent id named by the session's pointer file when `ticket_source`
-  # is `intent_id`, else the day id (spec D4). Per intent 298 spec D6, the
-  # pointer at `.tmp/<session>/current` holds exactly one line: either
-  # today's day id (the session records into the day ledger) or an intent
-  # id (an auto team owns the record). A day id in the pointer is therefore
-  # not an intent name, and falls back to the day id here too, which is the
-  # same value either way.
-  def resolve_ticket(day:, store:, session:, ticket_source:)
+  # The delivering intent's id when `ticket_source` is `intent_id`, else the
+  # day id (344 n2, D4-D7, D12). `resolver` is injected so tests need no
+  # real ~/.plastic; it defaults to ActiveDelivery.resolve_by_short_session
+  # against the store's own project roots.
+  def resolve_ticket(day:, store:, session:, ticket_source:, resolver: nil)
     return day.to_s unless ticket_source.to_s == "intent_id"
 
-    pointer = SessionLedger.pointer_path(store, session)
-    return day.to_s unless File.exist?(pointer)
+    resolver ||= lambda { |short_session|
+      ActiveDelivery.resolve_by_short_session(
+        global_store: store,
+        project_roots: ActiveDelivery.project_roots(File.dirname(store)),
+        short_session: short_session
+      )
+    }
 
-    content = File.read(pointer).to_s.strip
-    return day.to_s if content.empty?
-    return day.to_s if SessionLedger.valid_day_id?(content)
+    dir = begin
+      resolver.call(session)
+    rescue StandardError
+      nil
+    end
+    return day.to_s if dir.to_s.empty?
 
-    content
+    File.basename(dir).split("--", 2).first
   end
 
   # --- commit message ------------------------------------------------------------

package/scripts/lib/session_ledger.rb

@@ -154,14 +154,54 @@ module SessionLedger
     File.join(tmp_root(store), session_id)
   end
 
-  def pointer_path(store, session_id)
-    File.join(session_tmp_dir(store, session_id), "current")
-  end
-
   def heartbeat_path(store, session_id)
     File.join(session_tmp_dir(store, session_id), "heartbeat")
   end
 
+  # --- Session day (spec D7 replacement for the retired pointer) ------------
+
+  # Every day, ascending, no later than `today` and no earlier than `today`
+  # minus `window_days`, whose checklist carries at least one line tagged to
+  # `session` (any state). Each day's checklist is read inside its own
+  # rescue, so one unreadable or missing checklist skips that day only and
+  # never gives up on a later one. Returns an empty array when no day in the
+  # window carries the session's line, and on any error reading the store
+  # (never raises).
+  def session_days(store, session, today:, window_days: 7)
+    root = sessions_root(store)
+    return [] unless File.directory?(root)
+
+    today_date = Date.strptime(today, "%Y%m%d")
+    floor_date = today_date - window_days
+
+    days = Dir.children(root).select { |name| valid_day_id?(name) }.select do |name|
+      date = Date.strptime(name, "%Y%m%d")
+      date >= floor_date && date <= today_date
+    end.sort
+
+    days.select do |day|
+      begin
+        read_locked(checklist_path(store, day)).each_line.any? do |line|
+          parsed = parse_checklist_line(line)
+          parsed && parsed[:session] == session
+        end
+      rescue StandardError
+        false
+      end
+    end
+  rescue StandardError
+    []
+  end
+
+  # The newest day in `session_days`, the day this session's close and
+  # hand-off write belong to (intent 344, G11, D13: a session that crosses
+  # midnight carries lines on more than one day, and the newest is the one
+  # still open). Falls back to `today` when no day in the window carries the
+  # session's line.
+  def session_day(store, session, today:, window_days: 7)
+    session_days(store, session, today: today, window_days: window_days).last || today
+  end
+
   # Create `.tmp/` plus a `.gitignore` holding exactly `*`, if that file does
   # not already exist. The store is a local git repo that auto-commits
   # `add -A`, so without this ignore file every heartbeat write would enter