@zalom/plastic 2.0.0-alpha.9 → 2.0.1

package/scripts/hook-call-budget

@@ -0,0 +1,222 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-call-budget (reads the PreToolUse stdin JSON payload)
+#
+# Intent 355, n2 (review fix n8). A node gets a call budget by kind
+# (RunnerPolicy.call_cap): a cap on tool calls per attempt. RunnerDispatch
+# writes the cap onto the running line as `calls=` and states it as one
+# sentence in the node's own input, so the executor learns the number before
+# it ever gets denied.
+#
+# Inside a subagent the hook input's session_id and transcript_path are the
+# MAIN session's, never the subagent's own (v1 finding). So this hook caps
+# ONLY a subagent call: agent_id present in the payload. A call with no
+# agent_id (the main thread, a plain conversation, a live --agent session's
+# own turns) is never capped and the decision returns before any file is
+# touched.
+#
+# Which node a subagent is working is read from the subagent's OWN
+# transcript, at <dirname(transcript_path)>/<session_id>/subagents/
+# agent-<agent_id>.jsonl (the main transcript_path plus the main session_id
+# plus the subagent's own agent_id): its first user record carries the
+# dispatch prompt, and the lead/spawn block always pastes the node's input
+# path into that prompt (INPUT_PATH_RE). The node input path names the intent
+# directory directly (its grandparent), so this hook never scans the store to
+# find it. No node input path in that first prompt means allow.
+#
+# The cap applies only when that node's LATEST transition line in
+# <intent>/savepoint.md is `running` and carries `calls=`; a later `done` or
+# `failed_verification` line (or a sibling node's own running line) means no
+# cap. Past the cap, a Bash call that runs only a safe git verb (add, commit,
+# status, rev-parse, log) is still allowed, so the denial the hook itself
+# orders (commit what is green) is never the thing the hook blocks.
+#
+# Pure and dependency-injected down to the paths it reads; the trailing block
+# guarded by `$PROGRAM_NAME == __FILE__` is this file's only I/O (stdin,
+# stdout), so a test can `load` this file and call HookCallBudget's module
+# functions directly without spawning a process or touching stdin.
+
+require "json"
+require_relative "lib/node_ledger"
+require_relative "lib/savepoint"
+
+module HookCallBudget
+  module_function
+
+  RETURN_INSTRUCTION = "commit what is green and return failed_verification reason=call_budget"
+
+  # A node id, then "--a", then an attempt number, inside a /attempts/
+  # directory: the exact shape RunnerDispatch's spawn block pastes into a
+  # subagent's own first prompt. Captures [full_path, node].
+  INPUT_PATH_RE = %r{(\S+/attempts/([a-z]{1,2}\d+)--a\d+\.input)}.freeze
+
+  FIRST_RECORD_SCAN_LIMIT = 20
+
+  GIT_ALLOWED_VERBS = %w[add commit status rev-parse log].freeze
+  GIT_UNSAFE_RE = /[;&|\n]|\$\(|`/.freeze
+
+  # The one decision: nil (allow, no output) or a deny payload Hash. Never
+  # raises across its own boundary.
+  def decide(payload)
+    return nil unless payload.is_a?(Hash)
+
+    agent_id = payload["agent_id"]
+    return nil if agent_id.to_s.strip.empty?
+
+    session_id = payload["session_id"].to_s
+    transcript_path = payload["transcript_path"].to_s
+    return nil if session_id.empty? || transcript_path.empty?
+
+    sub_path = subagent_transcript_path(transcript_path, session_id, agent_id)
+
+    prompt = begin
+      first_user_prompt_text(sub_path)
+    rescue StandardError
+      nil
+    end
+    return nil unless prompt
+
+    match = INPUT_PATH_RE.match(prompt)
+    return nil unless match
+
+    node = match[2]
+    intent_dir = File.dirname(File.dirname(match[1]))
+
+    cap = node_cap(intent_dir, node)
+    return nil unless cap
+
+    count = begin
+      count_tool_use_blocks(sub_path)
+    rescue StandardError => e
+      note_unreadable(intent_dir, session_id, e.message)
+      return nil
+    end
+
+    return nil if count <= cap
+    return nil if git_only_bash_call?(payload)
+
+    deny_payload("#{node} is past its call budget (#{count}/#{cap} tool calls); #{RETURN_INSTRUCTION}")
+  end
+
+  def subagent_transcript_path(main_transcript_path, session_id, agent_id)
+    File.join(File.dirname(main_transcript_path), session_id, "subagents", "agent-#{agent_id}.jsonl")
+  end
+
+  # The first `"type":"user"` record in `path`'s own transcript, rendered to
+  # plain text (message.content as a string, or the joined text blocks of a
+  # content array). Scans at most FIRST_RECORD_SCAN_LIMIT lines: the dispatch
+  # prompt is always the transcript's opening record, so this never touches
+  # the bulk of a long-running subagent's history. Raises on a genuinely
+  # unreadable path (a directory, a permission error); the caller decides
+  # what that means.
+  def first_user_prompt_text(path)
+    File.open(path) do |f|
+      f.each_line.first(FIRST_RECORD_SCAN_LIMIT).each do |raw|
+        record = begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          next
+        end
+        next unless record.is_a?(Hash) && record["type"] == "user"
+
+        return message_text(record)
+      end
+    end
+    nil
+  end
+
+  def message_text(record)
+    content = record.dig("message", "content")
+    case content
+    when String
+      content
+    when Array
+      content.select { |b| b.is_a?(Hash) && b["type"] == "text" }.map { |b| b["text"].to_s }.join("\n")
+    else
+      ""
+    end
+  end
+
+  # The cap named on `node`'s LATEST (file-order) non-torn transition line in
+  # `intent_dir`/savepoint.md, or nil when that line is not `running`, carries
+  # no `calls=`, or does not exist at all (matrix 2.6/2.6b: a later done/
+  # failed_verification line, or a sibling node's own running line, never
+  # caps this node).
+  def node_cap(intent_dir, node)
+    path = File.join(intent_dir, "savepoint.md")
+    return nil unless File.exist?(path)
+
+    latest = NodeLedger.entries(path).select { |e| !e[:torn] && e[:subject] == node }.last
+    return nil unless latest && latest[:state] == "running"
+
+    cap = (latest[:fields] || {})["calls"]
+    cap ? cap.to_i : nil
+  end
+
+  # Streams `path` a line at a time, counting `"type":"tool_use"` content
+  # blocks with a plain regex rather than a full JSON parse per line (matrix
+  # 2.5/2.8): a 3 MB transcript counts in well under 50 ms this way.
+  def count_tool_use_blocks(path)
+    count = 0
+    File.foreach(path) { |ln| count += ln.scan(/"type"\s*:\s*"tool_use"/).length }
+    count
+  end
+
+  # Past the cap, a Bash call is still allowed when its command runs only one
+  # safe git verb (matrix 2.7/D3): the git add/commit the denial itself
+  # orders must never be the call the hook blocks. Any chaining token
+  # (`;`, `&`, `|`, a newline, a subshell or a backtick) refuses the whole
+  # command, so a compound command can never smuggle an unrelated call past
+  # the cap riding on a leading `git`.
+  def git_only_bash_call?(payload)
+    return false unless payload["tool_name"].to_s == "Bash"
+
+    command = payload.dig("tool_input", "command").to_s.strip
+    return false if command.empty? || GIT_UNSAFE_RE.match?(command)
+
+    tokens = command.split(/\s+/)
+    return false unless tokens.shift == "git"
+
+    tokens.shift(2) if tokens.first == "-C"
+    GIT_ALLOWED_VERBS.include?(tokens.first)
+  end
+
+  def deny_payload(reason)
+    { "hookSpecificOutput" => { "hookEventName" => "PreToolUse", "permissionDecision" => "deny",
+                                 "permissionDecisionReason" => reason } }
+  end
+
+  # Best-effort note that the transcript could not be counted (matrix 2.9): a
+  # plain milestone line, the same shared primitive Commit/Review/Report
+  # lines already use, dedup'd on (stage, milestone) so a repeat failure in
+  # the same session with the same message is not written twice.
+  def note_unreadable(intent_dir, session_id, message, now: Time.now)
+    Savepoint.append_savepoint_line(intent_dir, "CallBudget", "transcript unreadable for #{session_id}: #{message}",
+                                     now)
+  rescue StandardError
+    nil
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  raw = begin
+    $stdin.read
+  rescue StandardError
+    nil
+  end
+
+  if raw && !raw.strip.empty?
+    payload = begin
+      JSON.parse(raw)
+    rescue StandardError
+      nil
+    end
+
+    result = HookCallBudget.decide(payload)
+    puts JSON.generate(result) if result
+  end
+
+  exit 0
+end

package/scripts/hook-capture

@@ -5,16 +5,18 @@
 # 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).
+# the session day ledger and detects "continue" and "auto" prompts. Every job
+# runs in its own rescue and the hook always exits 0 (spec D2). Intent 345
+# (D7, 323) removed the per-prompt Future-intent hint step entirely.
 
+require_relative "lib/store_layout"
 require "json"
-require "yaml"
 require "open3"
+require "time"
 require "fileutils"
 require_relative "lib/session_ledger"
 require_relative "lib/dashboard_banner"
+require_relative "lib/active_delivery"
 
 raw = begin
   $stdin.read
@@ -37,124 +39,42 @@ 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")
+store = Plastic::StoreLayout.global_store(plastic_home)
 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, guarded on the pointer (spec D9) ------------
-# Session start writes the `current` pointer; a capture with no pointer yet
+# --- (a) heartbeat, guarded on the session tmp dir already existing --------
+# Session start creates `.tmp/<sid>/`; a capture with no such directory yet
 # means session start never ran for this session at all (a `-p` print
 # session, a resumed background job, an unregistered SessionStart hook), so
-# neither the per-session dir nor its heartbeat is created. UserPromptSubmit
-# fires before PostToolUse, so capture is the FIRST creator of every orphan
-# `.tmp/<sid>/` this guard prevents; hook-record carries the same guard for
-# its own (later) heartbeat write.
+# neither the directory nor its heartbeat is created HERE either.
+# UserPromptSubmit fires before PostToolUse, so capture is the FIRST place
+# this guard matters; hook-record carries the same guard for its own
+# (later) heartbeat write. (344 n2, D4-D5)
 begin
-  if File.exist?(SessionLedger.pointer_path(store, sid))
-    SessionLedger.ensure_tmp_root(store)
-    FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+  if Dir.exist?(SessionLedger.session_tmp_dir(store, sid))
     File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
   end
 rescue StandardError
   nil
 end
 
-# --- (b) read the pointer -----------------------------------------------
+# --- (b) a live delivery lock names this session (344 n2, D5, D12) ----------
 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
+  full_session = session_id.empty? ? ENV["CLAUDE_CODE_SESSION_ID"].to_s : session_id
+  skip_day_ledger = !ActiveDelivery.resolve(
+    global_store: store,
+    project_roots: ActiveDelivery.project_roots(plastic_home),
+    session: full_session
+  ).nil?
 rescue StandardError
   nil
 end
@@ -183,13 +103,13 @@ system_message = nil
 
 # --- (d) "continue" cockpit -------------------------------------------------
 begin
-  if prompt.match?(/\bcontinue\b/i)
+  if prompt.to_s.strip.downcase == "continue"
     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: " \
+          "\n\nRun `plastic continue` 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.")
 
@@ -216,7 +136,7 @@ begin
   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 " \
+    context_parts << "Auto-mode request detected. Run `plastic auto take ID` to deliver the " \
                       "active intent autonomously - it takes the intent under a lock and a worktree " \
                       "and points this session at it."
   end
@@ -224,25 +144,6 @@ 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 = {

package/scripts/hook-close

@@ -8,6 +8,7 @@
 #
 # Usage: hook-close <plastic_home>   (stdin: the hook JSON)
 
+require_relative "lib/store_layout"
 require "json"
 require_relative "lib/session_ledger"
 require_relative "lib/session_close"
@@ -23,7 +24,7 @@ payload =
     {}
   end
 
-store = File.join(File.expand_path(plastic_home), "store")
+store = Plastic::StoreLayout.global_store(File.expand_path(plastic_home))
 filer = File.expand_path("file-session-intent", __dir__)
 templates = File.expand_path("../templates", __dir__)
 begin

package/scripts/hook-message-display

@@ -51,11 +51,18 @@ begin
     tmp_root = ENV["PLASTIC_TMP"].to_s.empty? ? Dir.tmpdir : ENV["PLASTIC_TMP"]
     plastic_home = File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
 
+    # PLASTIC_HOOK_TRACE=<file> (331a1): opt-in, off by default, one JSON
+    # object appended per chunk. This script is the only place allowed to
+    # read the environment; MessageDisplay takes the sink as an argument.
+    trace_path = ENV["PLASTIC_HOOK_TRACE"].to_s
+    trace = trace_path.empty? ? nil : MessageDisplay.file_trace(trace_path)
+
     handler = MessageDisplay.new(
       tmp_root: tmp_root,
       plastic_home: plastic_home,
       color: color_enabled?(plastic_home),
       now: Time.now,
+      trace: trace,
     )
     result = handler.handle(payload)
 

package/scripts/hook-record

@@ -10,12 +10,14 @@
 # lands, and calls the session-commit seam when that script exists. Always
 # exits 0 (spec D3).
 
+require_relative "lib/store_layout"
 require "json"
 require "timeout"
 require "fileutils"
 require_relative "lib/savepoint"
 require_relative "lib/lock"
 require_relative "lib/session_ledger"
+require_relative "lib/active_delivery"
 
 raw = begin
   $stdin.read
@@ -76,15 +78,24 @@ 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")
+    store = Plastic::StoreLayout.global_store(plastic_home)
     sid = SessionLedger.short_session_id(nil, session_id)
     today = SessionLedger.day_id
 
+    # A live delivery lock naming this session's full id skips promotion
+    # (344 n2, D5, D12): the lock, not the retired pointer, decides.
     proceed = true
-    pointer = SessionLedger.pointer_path(store, sid)
-    if File.exist?(pointer)
-      current = File.read(pointer).strip
-      proceed = current.empty? || current == today
+    unless session_id.empty?
+      begin
+        held = ActiveDelivery.resolve(
+          global_store: store,
+          project_roots: ActiveDelivery.project_roots(plastic_home),
+          session: session_id
+        )
+        proceed = held.nil?
+      rescue StandardError
+        proceed = true
+      end
     end
 
     if proceed
@@ -135,19 +146,16 @@ unless skip_day_ledger
   end
 end
 
-# --- (d) heartbeat, guarded on the pointer (spec D9) -----------------------
-# Session start writes the `current` pointer; with no pointer at all, session
-# start never ran for this session (a `-p` print session, a resumed
-# background job, an unregistered SessionStart hook), so neither the
-# per-session dir nor its heartbeat is created here -- guarding only the
-# write would still leave an empty directory that heartbeat_age's mtime
-# fallback reports as an orphan just the same.
+# --- (d) heartbeat, guarded on the session tmp dir (344 n2, D4) ------------
+# Session start creates the per-session tmp directory; with no such
+# directory at all, session start never ran for this session (a `-p` print
+# session, a resumed background job, an unregistered SessionStart hook), so
+# the heartbeat is not written and no directory is created here either --
+# the session tmp directory, created by session start, is the guard.
 begin
-  store ||= File.join(plastic_home, "store")
+  store ||= Plastic::StoreLayout.global_store(plastic_home)
   sid ||= SessionLedger.short_session_id(nil, session_id)
-  if File.exist?(SessionLedger.pointer_path(store, sid))
-    SessionLedger.ensure_tmp_root(store)
-    FileUtils.mkdir_p(SessionLedger.session_tmp_dir(store, sid))
+  if Dir.exist?(SessionLedger.session_tmp_dir(store, sid))
     File.write(SessionLedger.heartbeat_path(store, sid), "#{Time.now.utc.iso8601}\n")
   end
 rescue StandardError

package/scripts/hook-savepoint

@@ -4,7 +4,8 @@
 
 # hook-savepoint (intent 311): the PreCompact hook body. Reads the harness
 # payload from stdin (session_id, cwd), takes the Plastic home from argv,
-# writes this session's hand-off for the pointer's day, and prints one
+# writes this session's hand-off for the session's day from the day ledger,
+# and prints one
 # message: the fixed text, plus the written file's path when a session
 # resolved (both harnesses relay the same launcher and the Codex pin feeds
 # both sides the same payload, so the two stay equal). Always exits 0,
@@ -12,15 +13,35 @@
 #
 # Usage: hook-savepoint <plastic_home>   (stdin: the hook JSON)
 
+require_relative "lib/store_layout"
 require "json"
 require_relative "lib/session_ledger"
 require_relative "lib/handoff"
+require_relative "lib/active_delivery"
 
 MESSAGE = "PLASTIC SAVEPOINT - context is being compacted. The hand-off for this " \
           "session is written in today's day ledger " \
           "(store/.sessions/<day>/handoff--<session>.md). " \
           "After compaction say continue to resume from it."
 
+# The intent this session is delivering, resolved through the same walk the
+# Stop gate uses (row 4.38): read-config's project_roots, plus the global
+# store, glob for a live delivery.lock this session holds. Never raises
+# (ActiveDelivery.resolve rescues its own reads); a lookup failure just
+# means the Runner section is omitted, never that the hand-off is lost.
+def resolve_intent(plastic_home, session_id, read_config_path)
+  return nil if session_id.strip.empty?
+
+  global_store = Plastic::StoreLayout.global_store(plastic_home)
+  roots_raw = IO.popen({ "PLASTIC_HOME" => plastic_home }, [read_config_path, "project_roots"],
+                       err: File::NULL, &:read).to_s.strip
+  project_roots = roots_raw.empty? ? [] : Array(JSON.parse(roots_raw))
+  project_roots = project_roots.map { |root| File.expand_path(root.to_s) }
+  ActiveDelivery.resolve(global_store: global_store, project_roots: project_roots, session: session_id)
+rescue StandardError
+  nil
+end
+
 written = nil
 begin
   plastic_home = ARGV[0].to_s
@@ -30,11 +51,14 @@ begin
   session_id = payload["session_id"].to_s
 
   unless plastic_home.empty? || session_id.strip.empty?
-    store = File.join(File.expand_path(plastic_home), "store")
+    home = File.expand_path(plastic_home)
+    store = Plastic::StoreLayout.global_store(home)
     session = SessionLedger.short_session_id(session_id, nil)
     day = Handoff.day_for(store, session, today: SessionLedger.day_id)
+    read_config_path = File.expand_path("read-config", __dir__)
+    intent = resolve_intent(home, session_id, read_config_path)
     written = Handoff.write(store: store, day: day, session: session, trigger: "precompact",
-                            templates: File.expand_path("../templates", __dir__))
+                            templates: File.expand_path("../templates", __dir__), intent: intent)
   end
 rescue StandardError, JSON::ParserError
   nil