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

package/scripts/lib/runner_watch.rb

@@ -0,0 +1,389 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "time"
+require "rbconfig"
+require_relative "worktree"
+require_relative "runner_core"
+require_relative "runner_sweep"
+require_relative "ready_set"
+require_relative "node_ledger"
+require_relative "savepoint"
+require_relative "atomic_write"
+require_relative "runner_until_empty"
+require_relative "harness_adapter"
+require_relative "meter_watch"
+
+# RunnerWatch (intent 340a, G7b, n1): one tick over disk truth. The whole
+# watch minus the CLI and the dispatch branch (340a n2). Composes the
+# existing modules the way RunnerSweep and MeterWatch already do - the
+# git runner, the clock and the sweep module are all injected, nothing
+# reads ENV, nothing evals.
+#
+# Order, fixed by graph.md D2: take a non-blocking lock on
+# `<intent_dir>/watch.lock` for the whole tick (a losing tick is `busy`,
+# writes nothing); `RunnerSweep.abort_if_merging`; refuse the tick outright
+# on a half-finished merge (row 1.3), writing nothing; `RunnerSweep.reclaim`
+# (never `RunnerSweep.run`, D3: that method heartbeats the delivery lease,
+# which would keep a dead lead's lock fresh forever); classify (D4);
+# persist the snapshot and the record line only when `record:` holds.
+module RunnerWatch
+  module_function
+
+  LOCK_FILENAME = "watch.lock"
+  STATE_FILENAME = "watch.state"
+  RECORD_FILENAME = "watch.record"
+
+  # Classes that never dispatch (D8): a finished delivery re-running its own
+  # graph on every tick is exactly the bug a timer must not have.
+  FINISHED_CLASSES = %w[closed done_unreported].freeze
+
+  # tick(context, record:, dispatch:, harness:, now:, runner:, sweep:,
+  # until_empty:) -> {class:, blockers:, ready:, reclaimed:, dispatched:,
+  # tick:, busy:}. `dispatch:` (327 Q6, D7, D8) only ever runs under an
+  # explicit ask - never inferred from the class - and only when the lock is
+  # held, the class is not finished, and the meter does not read `stop`.
+  # `until_empty:` is `RunnerUntilEmpty` by default; a test can inject a
+  # double so the whole dispatch path never spawns a real `node-run`
+  # subprocess. `harness=` and `meter=` on the record line read `-` only
+  # when `dispatch:` itself was never asked for (D5) - every other refusal
+  # (an unheld lock, a finished class, a stopped meter) still consults and
+  # records the meter, since the tick DID look, it just chose not to act.
+  def tick(context, record: true, dispatch: false, harness: nil, now: Time.now,
+           runner: Worktree::ShellRunner.new, sweep: RunnerSweep, until_empty: RunnerUntilEmpty)
+    intent_dir = context.intent_dir.to_s
+    lock_handle = acquire_lock(File.join(intent_dir, LOCK_FILENAME))
+    return busy_result unless lock_handle
+
+    begin
+      abort_result = sweep.abort_if_merging(context, runner: runner)
+      unless abort_result[:ok]
+        return {
+          class: "merge_in_progress", blockers: [abort_result[:error]], ready: [],
+          reclaimed: [], dispatched: [], tick: nil, busy: false,
+        }
+      end
+
+      reclaim_result = sweep.reclaim(context, runner: runner, skip: [], now: now)
+      reclaimed_ids = Array(reclaim_result[:reclaimed]).map { |r| r[:node] }
+      extended = !Array(reclaim_result[:extended]).empty?
+
+      view = classify(context, runner: runner, now: now, intent_dir: intent_dir, extended: extended)
+
+      lock_state = context.session ? "held" : "not_held"
+      harness_field = "-"
+      meter_state = "-"
+      dispatched_ids = []
+
+      # B1: the dispatch loop and the persist step share one inner
+      # begin/ensure so a raise mid `until_empty.run` (a launchd SIGTERM, a
+      # Process.spawn Errno) still lands the snapshot and the record line
+      # with whatever `dispatched_ids` was collected before the raise, and
+      # then the exception keeps propagating past this method (the outer
+      # `ensure` below still releases the tick lock).
+      begin
+        if dispatch
+          harness_field = blank?(harness) ? "-" : harness.to_s
+          meter_state = read_meter_state(context)
+
+          if context.session && !FINISHED_CLASSES.include?(view[:class]) && meter_state != "stop"
+            run_until_empty_dispatch(context, harness: harness, until_empty: until_empty,
+                                      dispatched_ids: dispatched_ids)
+          end
+        end
+      ensure
+        if record
+          Worktree.ensure_gitignored(context.plastic_home, STATE_FILENAME, runner: runner)
+          write_snapshot(intent_dir, view[:snapshot])
+          append_record(
+            intent_dir, now: now, tick: view[:tick], klass: view[:class],
+            reclaimed: reclaimed_ids, ready: view[:ready], dispatched: dispatched_ids,
+            harness: harness_field, meter: meter_state, lock: lock_state
+          )
+        end
+      end
+
+      {
+        class: view[:class], blockers: view[:blockers], ready: view[:ready],
+        reclaimed: reclaimed_ids, dispatched: dispatched_ids, tick: view[:tick], busy: false,
+      }
+    ensure
+      release_lock(lock_handle)
+    end
+  end
+
+  # install_timer(context, home:, harness_key:, installer:) -> the written
+  # plist path. Graph.md D9: the Codex carrier is `runner watch
+  # --install-timer`, and it reuses MeterWatch's own writer through
+  # `label:`/`arguments:` rather than rendering plist XML here (row 3.5) - a
+  # second writer is exactly the drift D9 rules out. The label carries the
+  # intent id (row 3.4), so a second intent's timer never overwrites the
+  # first's job; `--dispatch --harness codex` rides the arguments only when
+  # `HarnessAdapter.unattended_start?` holds for the resolved harness (row
+  # 3.3), the same predicate `run_watch` itself already gates `--dispatch`
+  # on. `installer:` is `MeterWatch` by default so a test can inject a
+  # double that never touches a real home.
+  def install_timer(context, home:, harness_key:, installer: MeterWatch)
+    runner_path = File.expand_path(File.join(__dir__, "..", "runner"))
+    arguments = [RbConfig.ruby, runner_path, "watch", context.intent_dir.to_s]
+    arguments += ["--dispatch", "--harness", harness_key.to_s] if HarnessAdapter.unattended_start?(harness_key)
+
+    installer.install_timer(home: home, script_path: runner_path,
+                             label: "com.plastic.delivery-watch.#{context.intent_id}", arguments: arguments)
+  end
+
+  # run_until_empty_dispatch(context, harness:, until_empty:) -> every node
+  # id the loop dispatched (C30). `until_empty.run` gets `step:` wrapped
+  # around `until_empty.step_once` so this method sees every turn's own
+  # `:dispatched` ids, the same shape RunnerDispatch.dispatch returns
+  # (graph.md D8); `until_empty.run` itself still owns spawning and waiting
+  # on the real `node-run` subprocesses (never duplicated here).
+  def run_until_empty_dispatch(context, harness:, until_empty:, dispatched_ids:)
+    wrapped_step = lambda do |ctx, harness:, returns:|
+      result = until_empty.step_once(ctx, harness: harness, returns: returns)
+      dispatched_ids.concat(Array(result[:dispatched]))
+      result
+    end
+
+    until_empty.run(context, harness: harness, step: wrapped_step)
+  end
+  private_class_method :run_until_empty_dispatch
+
+  # read_meter_state(context) -> "ok", "reduce", "stop", "resume", "stale"
+  # (whatever MeterWatch's own tick last wrote), or "unavailable" for a
+  # missing or unparseable file (D8) - read-only, at MeterWatch's own state
+  # path under `context.plastic_home`, never through a MeterWatch instance
+  # (that class computes a FRESH state from the rate-limit cache; this tick
+  # only ever reads what it already wrote).
+  def read_meter_state(context)
+    path = File.join(context.plastic_home.to_s, ".cache", "meter-state.json")
+    return "unavailable" unless File.file?(path)
+
+    state = JSON.parse(File.read(path))["state"]
+    blank?(state) ? "unavailable" : state.to_s
+  rescue StandardError
+    "unavailable"
+  end
+  private_class_method :read_meter_state
+
+  def blank?(value)
+    value.nil? || value.to_s.strip.empty?
+  end
+  private_class_method :blank?
+
+  # fingerprint(context, runner:) -> the SHA256 D4 defines: savepoint.md's
+  # current content plus the intent branch head, so a commit that lands no
+  # ledger line still counts as movement (row 1.13). Public so a caller (and
+  # this file's own tests) can compute the exact value a tick would compute
+  # without duplicating the hashing here.
+  def fingerprint(context, runner: Worktree::ShellRunner.new)
+    content = savepoint_content(context.intent_dir)
+    Digest::SHA256.hexdigest("#{content}\x1f#{branch_head_sha(context, runner)}")
+  end
+
+  # --- the lock ----------------------------------------------------------------
+
+  def acquire_lock(path)
+    handle = File.open(path, File::CREAT | File::RDWR, 0o644)
+    return handle if handle.flock(File::LOCK_EX | File::LOCK_NB)
+
+    handle.close
+    nil
+  rescue SystemCallError
+    nil
+  end
+  private_class_method :acquire_lock
+
+  def release_lock(handle)
+    return unless handle
+
+    handle.flock(File::LOCK_UN)
+  rescue SystemCallError
+    nil
+  ensure
+    handle&.close
+  end
+  private_class_method :release_lock
+
+  def busy_result
+    { class: nil, blockers: [], ready: [], reclaimed: [], dispatched: [], tick: nil, busy: true }
+  end
+  private_class_method :busy_result
+
+  # --- classification (D4), first match wins ------------------------------------
+
+  def classify(context, runner:, now:, intent_dir:, extended: false)
+    content = savepoint_content(intent_dir)
+    recorded_pairs = Savepoint.savepoint_recorded_pairs(intent_dir)
+    previous = read_snapshot(intent_dir)
+    tick_number = (previous ? previous[:tick] : 0) + 1
+
+    if closed?(recorded_pairs)
+      return settle("closed", blockers: [], ready_ids: [], previous: previous, tick_number: tick_number,
+                     quiet_ticks: 0, content: content, context: context, runner: runner, now: now)
+    end
+
+    unless context.graph[:ok]
+      errors = Array(context.graph[:errors])
+      errors = ["graph.md could not be parsed"] if errors.empty?
+      return settle("stalled", blockers: errors, ready_ids: [], previous: previous, tick_number: tick_number,
+                     quiet_ticks: 0, content: content, context: context, runner: runner, now: now)
+    end
+
+    if RunnerCore.complete?(context)
+      return settle("done_unreported", blockers: [], ready_ids: [], previous: previous, tick_number: tick_number,
+                     quiet_ticks: 0, content: content, context: context, runner: runner, now: now)
+    end
+
+    ready_ids = ReadySet.analyze(intent_dir, now: now)[:ranked_ready].map { |r| r[:id] }
+    running = any_running?(content)
+
+    if !running && ready_ids.empty?
+      return settle("stalled", blockers: blocked_reasons(context), ready_ids: ready_ids, previous: previous,
+                     tick_number: tick_number, quiet_ticks: 0, content: content, context: context, runner: runner,
+                     now: now)
+    end
+
+    current_fingerprint = fingerprint(context, runner: runner)
+
+    # B2: a reclaim that extended a lease is evidence of live work (the
+    # sweep extends only when the node branch has commits newer than the
+    # expiry), so it counts as movement here, at the fingerprint
+    # comparison, after closed/malformed-graph/done_unreported/the
+    # nothing-running-nothing-ready stall have already returned above.
+    if extended || previous.nil? || previous[:fingerprint] != current_fingerprint
+      return settle("moving", blockers: [], ready_ids: ready_ids, previous: previous, tick_number: tick_number,
+                     quiet_ticks: 0, content: content, context: context, runner: runner, now: now,
+                     fingerprint: current_fingerprint)
+    end
+
+    next_quiet_ticks = previous[:quiet_ticks] + 1
+    if previous[:quiet_ticks] >= 1 && !unexpired_running_lease?(content, now)
+      klass = "stalled"
+      blockers = ["no observed movement for #{next_quiet_ticks} consecutive ticks and no unexpired running lease"]
+    else
+      klass = "quiet"
+      blockers = []
+    end
+
+    settle(klass, blockers: blockers, ready_ids: ready_ids, previous: previous, tick_number: tick_number,
+           quiet_ticks: next_quiet_ticks, content: content, context: context, runner: runner, now: now,
+           fingerprint: current_fingerprint)
+  end
+  private_class_method :classify
+
+  # Assembles the return view plus the snapshot that will be persisted, when
+  # `record:` is honored by the caller. `fingerprint:` defaults to a fresh
+  # computation so every class - not only moving/quiet/stalled-by-quiet -
+  # persists a value later ticks can compare against.
+  def settle(klass, blockers:, ready_ids:, previous:, tick_number:, quiet_ticks:, content:, context:, runner:,
+             now:, fingerprint: nil)
+    fp = fingerprint || RunnerWatch.fingerprint(context, runner: runner)
+    {
+      class: klass, blockers: blockers, ready: ready_ids, tick: tick_number,
+      snapshot: { fingerprint: fp, quiet_ticks: quiet_ticks, tick: tick_number, at: now.utc.iso8601 },
+    }
+  end
+  private_class_method :settle
+
+  def closed?(recorded_pairs)
+    recorded_pairs.include?(["Done", "delivered"]) || recorded_pairs.include?(["Done", "abandoned"])
+  end
+  private_class_method :closed?
+
+  def blocked_reasons(context)
+    rows = RunnerCore.status(context)
+    rows.values.reject { |v| ReadySet::TERMINAL_STATES.include?(v[:state]) || v[:ready] }
+        .flat_map { |v| v[:blockers] }
+        .uniq
+  end
+  private_class_method :blocked_reasons
+
+  def any_running?(content)
+    NodeLedger.status_from_content(content).value?("running")
+  end
+  private_class_method :any_running?
+
+  def unexpired_running_lease?(content, now)
+    status_map = NodeLedger.status_from_content(content)
+    entries = NodeLedger.entries_from_content(content)
+    status_map.any? do |subject, state|
+      next false unless state == "running"
+
+      last = entries.select { |e| !e[:torn] && e[:subject] == subject && e[:state] == "running" }.last
+      next false unless last
+
+      at = parse_time((last[:fields] || {})["expires"])
+      at && now < at
+    end
+  end
+  private_class_method :unexpired_running_lease?
+
+  def branch_head_sha(context, runner)
+    worktree = context.worktree
+    return "" if worktree.nil? || worktree.to_s.strip.empty?
+
+    res = runner.run("-C", worktree, "rev-parse", "HEAD")
+    res.success? ? res.stdout.to_s.strip : ""
+  rescue StandardError
+    ""
+  end
+  private_class_method :branch_head_sha
+
+  def parse_time(raw)
+    return nil if raw.nil? || raw.to_s.strip.empty?
+
+    Time.iso8601(raw.to_s)
+  rescue ArgumentError
+    nil
+  end
+  private_class_method :parse_time
+
+  def savepoint_content(intent_dir)
+    path = File.join(intent_dir.to_s, "savepoint.md")
+    File.exist?(path) ? File.read(path) : ""
+  end
+  private_class_method :savepoint_content
+
+  # --- the snapshot (D5) ---------------------------------------------------------
+
+  def read_snapshot(intent_dir)
+    path = File.join(intent_dir, STATE_FILENAME)
+    return nil unless File.file?(path)
+
+    data = JSON.parse(File.read(path))
+    { fingerprint: data["fingerprint"], quiet_ticks: data["quiet_ticks"].to_i, tick: data["tick"].to_i,
+      at: data["at"] }
+  rescue StandardError
+    nil
+  end
+  private_class_method :read_snapshot
+
+  def write_snapshot(intent_dir, snapshot)
+    path = File.join(intent_dir, STATE_FILENAME)
+    data = {
+      "fingerprint" => snapshot[:fingerprint], "quiet_ticks" => snapshot[:quiet_ticks],
+      "tick" => snapshot[:tick], "at" => snapshot[:at],
+    }
+    AtomicWrite.write(path, JSON.generate(data))
+  end
+  private_class_method :write_snapshot
+
+  # --- the record (D5) -----------------------------------------------------------
+
+  def append_record(intent_dir, now:, tick:, klass:, reclaimed:, ready:, dispatched:, harness: "-", meter: "-",
+                     lock:)
+    line = "#{now.utc.iso8601}  tick=#{tick} class=#{klass} reclaimed=#{list_or_dash(reclaimed)} " \
+           "ready=#{list_or_dash(ready)} dispatched=#{list_or_dash(dispatched)} harness=#{harness} " \
+           "meter=#{meter} lock=#{lock}\n"
+    File.open(File.join(intent_dir, RECORD_FILENAME), "a") { |f| f.write(line) }
+  end
+  private_class_method :append_record
+
+  def list_or_dash(list)
+    list.nil? || list.empty? ? "-" : list.join(",")
+  end
+  private_class_method :list_or_dash
+end

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)
@@ -145,7 +144,7 @@ module Savepoint
     ["spec.md", "graph.md", "plan.md", "checklist.md", "outcome.md"].each do |f|
       files << f if stage_file_present?("#{intent_dir}/#{f}")
     end
-    # Name the directory that actually exists (fold B3): a nodes-only intent
+    # Name the directory that actually exists (review B3): a nodes-only intent
     # must never claim the literal "actions/" artifact it does not have.
     # Checks actions/ first, matching D15r's read order.
     if has_real_files_in?("actions", intent_dir)
@@ -160,7 +159,7 @@ module Savepoint
     ifile = intent_dir ? File.basename(intent_file(intent_dir)) : "intent.md"
     # A How-stage intent that already started a nodes/ directory is named
     # accordingly, so the next-step hint never tells a node-graph intent to
-    # go make an actions/ directory it will never use (fold B3). Mirrors
+    # go make an actions/ directory it will never use (review B3). Mirrors
     # has_real_files_in?'s actions-first order and its real-file requirement
     # (post-execution review, non-blocking 4): an intent carrying real files
     # in both directories, or a real actions/ file beside an empty or
@@ -177,7 +176,7 @@ module Savepoint
     when "why" then ["spec.md"]
     when "how"
       # A node-shaped How intent (a real graph.md already) is named after its
-      # own two artifacts, never the three D41 removed from its path (fold
+      # own two artifacts, never the three D41 removed from its path (review
       # B3, extended by 336 D13): checked via stage_file_present? alone, the
       # same primitive derive_stage itself uses.
       if intent_dir && stage_file_present?("#{intent_dir}/graph.md")
@@ -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 ------------------------------------------------------------
@@ -245,7 +251,7 @@ module SessionGit
   # The branch HEAD points to, even on an unborn branch (review R3: a fresh
   # `git init`, zero commits). `git rev-parse --abbrev-ref HEAD` FAILS on an
   # unborn branch (there is no commit for it to resolve yet), which the old
-  # implementation misread as "cannot determine a branch" and folded into
+  # implementation misread as "cannot determine a branch" and merged into
   # the detached-HEAD case. `git symbolic-ref --quiet --short HEAD` succeeds
   # on both a normal AND an unborn branch (HEAD is a symbolic ref to
   # `refs/heads/<name>` in both cases) and only fails when HEAD is
@@ -354,7 +360,7 @@ module SessionGit
 
     # An unknown mode/workspace value, or workspace: worktree's degradation
     # to checkout, is itself a degradation (spec D2, BLOCKER 3 ruling), so
-    # it always turns the outcome into a Note, folding both facts into the
+    # it always turns the outcome into a Note, merging both facts into the
     # single savepoint line spec D7 allows.
     Result.new(message: "#{flow_notes.join('; ')}; #{result.message}", event: "Note")
   end