@zalom/plastic 2.0.0-alpha.9 → 2.0.1

package/scripts/hook-session-start

@@ -3,17 +3,21 @@
 # Usage: hook-session-start <index_path> <plastic_home> <mode> [plugin_root]
 # Outputs hook JSON for the session-start hook. Exits silently if nothing to show.
 
+require_relative "lib/store_layout"
 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"
 require_relative "lib/day_summary"
+require_relative "lib/data_boundary"
+require_relative "lib/active_delivery"
+require_relative "lib/runner_core"
+require_relative "lib/runner_watch"
+require_relative "lib/version_number"
 
 index_path, plastic_home, mode, plugin_root = ARGV
 exit 0 unless index_path && plastic_home && mode
@@ -36,147 +40,32 @@ rescue StandardError
 end
 payload_session_id = stdin_payload.is_a?(Hash) ? stdin_payload["session_id"].to_s : ""
 
+# --- subagent marker (intent 355 spec D9, node n7; review fix n8, B6): the
+# stdin payload carries agent_id only when this SessionStart call runs
+# inside a spawned agent. agent_type alone is not enough: a live
+# `claude --agent` session carries agent_type on every turn but never
+# agent_id, so keying on agent_type would boot a live agent session with the
+# core banner only. Read from that payload only, never from an environment
+# variable, so a helper needs the core banner alone. An absent agent_id (the
+# common case) is a live session. Any exception here still boots the banner,
+# never nothing: the rescue falls back to a live session, whose own content
+# already comes from paths this file already guards independently.
+subagent_session = begin
+  stdin_payload.is_a?(Hash) && !!stdin_payload["agent_id"]
+rescue StandardError
+  false
+end
+
 # Plastic home and the store are two different paths (intent 231). The shim passes
 # home (~/.plastic) as argument 2; the store lives one level below it. Compose the
 # store exactly once here, so no later line re-derives it and no path can gain a
 # doubled store/ segment.
-store_dir = File.join(plastic_home, "store")
-
-# --- Parse INDEX.md ---
-
-lines = File.readlines(index_path)
-active = []
-future = []
-section = nil
-
-lines.each do |line|
-  if line.start_with?("## Active")
-    section = :active
-    next
-  elsif line.start_with?("## Future")
-    section = :future
-    next
-  elsif line.start_with?("## ")
-    section = nil
-    next
-  end
-
-  next unless section && line.strip.start_with?("- [")
-
-  if section == :active
-    active << line.strip
-  elsif section == :future
-    future << line.strip
-  end
-end
-
-# --- Stage of the single active intent (the /tmp bridge this once derived was removed in 2.0, intent 307) ---
-
-stage_line = nil
-if active.length == 1 && active.first =~ /store\/([\w-]+)\//
-  dir_name = $1
-  intent_dir = "#{store_dir}/#{dir_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 ---
-
-stale = []
-read_config = if plugin_root && !plugin_root.empty?
-  "#{plugin_root}/scripts/read-config"
-else
-  File.expand_path("~/.plastic/scripts/read-config")
-end
-stale_days = `"#{read_config}" stale_threshold_days`.strip.to_i
-stale_days = 3 if stale_days == 0
-
-future.each do |f|
-  if f =~ /store\/([\w-]+)\//
-    dir_name = $1
-    intent_file = "#{store_dir}/#{dir_name}/#{dir_name}.md"
-    next unless File.exist?(intent_file)
-
-    content = File.read(intent_file)
-    if content =~ /^created:\s*['"]?(\d{4}-\d{2}-\d{2})/
-      age = (Date.today - Date.parse($1)).to_i
-      if age >= stale_days
-        name = f[/\[([^\]]+)\]/, 1] || "unknown"
-        stale << { name: name, age: age, entry: f }
-      end
-    end
-  end
-end
-
-# --- Detect current project ---
-
-current_project = nil
-project_active = []
-project_future = []
-
-projects_path = "#{plastic_home}/projects.yml"
-if File.exist?(projects_path)
-  projects = YAML.safe_load(File.read(projects_path)) rescue {}
-  cwd = Dir.pwd
-  (projects["projects"] || {}).each do |slug, info|
-    project_path = File.expand_path(info["path"])
-    if cwd.start_with?(project_path)
-      current_project = { "slug" => slug, "parent" => info["parent"], "path" => project_path }
-      project_index = "#{plastic_home}/projects/#{slug}/INDEX.md"
-      if File.exist?(project_index)
-        p_section = nil
-        File.readlines(project_index).each do |pline|
-          if pline.start_with?("## Active")
-            p_section = :active
-            next
-          elsif pline.start_with?("## Future")
-            p_section = :future
-            next
-          elsif pline.start_with?("## ")
-            p_section = nil
-            next
-          end
-          next unless p_section && pline.strip.start_with?("- [")
-          project_active << pline.strip if p_section == :active
-          project_future << pline.strip if p_section == :future
-        end
-      end
-      break
-    end
-  end
-end
-
-# --- Load PLASTIC.md conventions ---
+store_dir = Plastic::StoreLayout.global_store(plastic_home)
 
-plastic_md_path = "#{plastic_home}/PLASTIC.md"
-plastic_md = File.exist?(plastic_md_path) ? File.read(plastic_md_path).strip : nil
-
-# --- Load deprecations ---
-
-dep_file = if plugin_root && !plugin_root.empty?
-  "#{plugin_root}/deprecations.yml"
-else
-  "#{plastic_home}/deprecations.yml"
-end
-
-deprecations = []
-if File.exist?(dep_file)
-  dep_data = YAML.safe_load(File.read(dep_file)) rescue {}
-  deprecations = dep_data["deprecations"] || []
-end
-
-dismissed_json = `"#{read_config}" deprecations_dismissed`.strip
-dismissed = begin
-  JSON.parse(dismissed_json)
-rescue
-  []
-end
+# --- Current version ---
+# Read early, before any of the richer INDEX/project parsing below, so the
+# core banner (the one thing every session must get) never depends on
+# anything that can raise.
 
 current_version = nil
 version_file = "#{plastic_home}/VERSION"
@@ -190,23 +79,6 @@ elsif plugin_root && !plugin_root.empty?
   end
 end
 
-active_deprecations = deprecations.select do |dep|
-  next true if dep["severity"] == "critical"
-  next true if current_version && dep["removal"] == current_version
-  !dismissed.include?(dep["id"])
-end
-
-# --- Check for available updates (from previous session's check) ---
-
-update_notice = nil
-cache_file = "#{plastic_home}/.cache/update-check.json"
-if File.exist?(cache_file)
-  cache = JSON.parse(File.read(cache_file)) rescue {}
-  if cache["updateAvailable"]
-    update_notice = "Plastic update available: #{cache["current"]} -> #{cache["latest"]} — run /plastic-update"
-  end
-end
-
 # --- Run core health in-process (intent 36a) ---
 # Reuse Doctor's own --core checks so there is one source of truth for "core
 # health" (no second process spawn, no duplicated check list). Never blocks the
@@ -219,206 +91,372 @@ rescue
 end
 core_banner = BootBanner.render(health: core_health, version: current_version)
 
-# --- Assemble session context ---
-
-all_active = active + project_active
-all_future = future + project_future
-
 # --- Build context ---
-# PLASTIC.md conventions and intent context render only when conventions are
-# installed. Deprecation warnings and update notices render regardless, so a
-# partial install (or a missing PLASTIC.md) still surfaces critical warnings.
-
-parts = []
-
-# Boot banner first: every session start surfaces that Plastic loaded, with the
-# version (clean) or the first failing core check (degraded). Owned by the hook
-# so it runs by construction — the plastic-intent-continuing skill no longer does this.
-parts << core_banner
-parts << ""
-
-# --- QMD search status (intent 45a, READ-ONLY) ---
-# Report-only line for the model (additionalContext), never systemMessage and
-# never the exit code. QmdSync.status shells out to `qmd collection list`, so the
-# whole block is guarded: a 2s timeout caps any hang, and rescue-all guarantees a
-# slow/broken/missing qmd appends nothing and the hook continues cleanly.
+# The core banner is the one thing a session always gets. Everything below it
+# (the project/global banner with its active intent, the QMD line,
+# deprecations, the update notice, the first-boot sweep, the day ledger) is
+# best-effort: intent 341, G8 wraps all of it in one rescue so any exception
+# anywhere in that assembly degrades to a banner-only boot, never nothing.
+# That is the same "as today" contract every individual sub-block already
+# kept on its own, made a whole-block guarantee now that the doctrine dump
+# this used to gate everything on is cut (PLASTIC.md's conventions prose, the
+# active-intents listing, the stage line, the stale-future list), since a
+# skill or the conventions chapter already carries that text.
+
+parts = [core_banner, ""]
+
 begin
-  require "timeout"
-  qmd_status = Timeout.timeout(2) { QmdSync.status(plastic_home: plastic_home) }
-  if qmd_status[:present]
-    if qmd_status[:all_registered]
-      parts << "QMD: #{qmd_status[:registered].size} Plastic collections indexed (search with the qmd skill)."
-    else
-      parts << "QMD detected — run `qmd-sync register --all` to index your Plastic stores for search."
+  # --- Parse INDEX.md ---
+
+  lines = File.readlines(index_path)
+  active = []
+  future = []
+  section = nil
+
+  lines.each do |line|
+    if line.start_with?("## Active")
+      section = :active
+      next
+    elsif line.start_with?("## Future")
+      section = :future
+      next
+    elsif line.start_with?("## ")
+      section = nil
+      next
     end
-  end
-rescue Exception
-  # Any failure (timeout, missing binary, parse error) — stay silent, never crash.
-end
 
-if plastic_md
-  # Conventions always loaded first
-  parts << plastic_md
-  parts << "\n---\n"
-
-  if current_project
-    slug = current_project["slug"]
-    banner = "Project: #{slug} | Store: ~/.plastic/projects/#{slug}/store/"
-    if project_active.any? && project_active.first =~ /\[([^\]]+)\].*store\/([\w-]+)\//
-      intent_name, dir_name = $1, $2
-      intent_id = dir_name.split("--").first
-      banner += "\nActive: [#{intent_id} — #{intent_name}] | Artifacts → store/#{dir_name}/"
+    next unless section && line.strip.start_with?("- [")
+
+    if section == :active
+      active << line.strip
+    elsif section == :future
+      future << line.strip
     end
-    parts << banner + "\n"
+  end
+
+  # --- read-config path (used below for author and dismissed deprecations) ---
+
+  read_config = if plugin_root && !plugin_root.empty?
+    "#{plugin_root}/scripts/read-config"
   else
-    parts << "PLASTIC — Global store loaded from ~/.plastic/\n"
+    File.expand_path("~/.plastic/scripts/read-config")
   end
 
-  if all_active.any?
-    parts << "Active intents:\n"
-    all_active.each { |a| parts << a }
-    parts << stage_line if stage_line
-    parts << ""
+  # --- Detect current project ---
+
+  current_project = nil
+  project_active = []
+  project_future = []
+
+  projects_path = "#{plastic_home}/projects.yml"
+  if File.exist?(projects_path)
+    projects = YAML.safe_load(File.read(projects_path)) rescue {}
+    cwd = Dir.pwd
+    (projects["projects"] || {}).each do |slug, info|
+      project_path = File.expand_path(info["path"])
+      if cwd.start_with?(project_path)
+        current_project = { "slug" => slug, "parent" => info["parent"], "path" => project_path }
+        project_index = File.join(Plastic::StoreLayout.project_root(plastic_home, slug), "INDEX.md")
+        if File.exist?(project_index)
+          p_section = nil
+          File.readlines(project_index).each do |pline|
+            if pline.start_with?("## Active")
+              p_section = :active
+              next
+            elsif pline.start_with?("## Future")
+              p_section = :future
+              next
+            elsif pline.start_with?("## ")
+              p_section = nil
+              next
+            end
+            next unless p_section && pline.strip.start_with?("- [")
+            project_active << pline.strip if p_section == :active
+            project_future << pline.strip if p_section == :future
+          end
+        end
+        break
+      end
+    end
+  end
+
+  # --- Load PLASTIC.md conventions ---
+  # Its content no longer renders at boot (intent 341, G8): the gate stays,
+  # so a partial install without PLASTIC.md still renders no project banner,
+  # but the text itself is never read into `parts`.
+
+  plastic_md_path = "#{plastic_home}/PLASTIC.md"
+  plastic_md = File.exist?(plastic_md_path) ? File.read(plastic_md_path).strip : nil
+
+  # --- Load deprecations ---
+
+  dep_file = if plugin_root && !plugin_root.empty?
+    "#{plugin_root}/deprecations.yml"
   else
-    parts << "No active intents. #{future.length} future intents available.\n"
+    "#{plastic_home}/deprecations.yml"
+  end
+
+  deprecations = []
+  if File.exist?(dep_file)
+    dep_data = YAML.safe_load(File.read(dep_file)) rescue {}
+    deprecations = dep_data["deprecations"] || []
+  end
+
+  dismissed_json = `"#{read_config}" deprecations_dismissed`.strip
+  dismissed = begin
+    JSON.parse(dismissed_json)
+  rescue
+    []
+  end
+
+  # A notice whose removal version is already behind the installed one has
+  # nothing left to warn about, and kept firing at every boot until someone
+  # dismissed it by hand. Only a critical notice outlives its own removal.
+  installed = VersionNumber.parse(current_version)
+
+  active_deprecations = deprecations.select do |dep|
+    next true if dep["severity"] == "critical"
+
+    removal = VersionNumber.parse(dep["removal"])
+    next false if installed && removal && removal < installed
+    next true if current_version && dep["removal"] == current_version
+
+    !dismissed.include?(dep["id"])
   end
 
-  if stale.any?
-    parts << "\nStale future intents (untouched for days):\n"
-    stale.each do |s|
-      parts << "- #{s[:name]} (#{s[:age]} days) — consider: activate, abandon, or defer to agent"
+  # --- Check for available updates (from previous session's check) ---
+
+  update_notice = nil
+  cache_file = "#{plastic_home}/.cache/update-check.json"
+  if File.exist?(cache_file)
+    cache = JSON.parse(File.read(cache_file)) rescue {}
+    if cache["updateAvailable"]
+      update_notice = "Plastic update available: #{cache["current"]} -> #{cache["latest"]} — run `plastic update`"
     end
-    parts << "\nWhen appropriate, ask the user what to do with stale intents."
   end
-end
 
-if active_deprecations.any?
-  parts << ""
-  active_deprecations.each do |dep|
-    severity = dep["severity"] || "info"
-    summary = dep["summary"] || dep["id"]
-    removal = dep["removal"]
-    link = dep["link"]
-    steps = dep["migration_steps"] || []
-
-    if severity == "info"
-      line = "i Deprecation: #{summary}. Removed in: #{removal}."
-      line += " See: #{link}" if link
-      parts << line
+  # --- QMD search status (intent 45a, READ-ONLY) ---
+  # Report-only line for the model (additionalContext), never systemMessage and
+  # never the exit code. QmdSync.status shells out to `qmd collection list`, so the
+  # whole block is guarded: a 2s timeout caps any hang, and rescue-all guarantees a
+  # slow/broken/missing qmd appends nothing and the hook continues cleanly.
+  begin
+    require "timeout"
+    qmd_status = Timeout.timeout(2) { QmdSync.status(plastic_home: plastic_home) }
+    if qmd_status[:present]
+      # C23 (intent 341, G8): a QMD hit is untrusted text, so it never sits
+      # loose in additionalContext alongside the owner's own banners; it
+      # rides inside DataBoundary's data boundary.
+      qmd_line = if qmd_status[:all_registered]
+        "QMD: #{qmd_status[:registered].size} Plastic collections indexed (search with the qmd skill)."
+      else
+        "QMD detected — run `qmd-sync register --all` to index your Plastic stores for search."
+      end
+      token = DataBoundary.boundary_token([qmd_line])
+      parts << DataBoundary.wrap(qmd_line, label: "qmd-hit", source: "qmd-sync", token: token).rstrip
+    end
+  rescue Exception
+    # Any failure (timeout, missing binary, parse error) — stay silent, never crash.
+  end unless subagent_session
+
+  # --- Delivery watch (intent 340a, G7b, n3, graph.md D10) ---
+  # One unrecorded tick (record: false: reclaim and classify, no snapshot,
+  # no record line, so boot never advances a quiet count) per intent
+  # ActiveDelivery.candidate_intent_dirs finds, naming every stalled or
+  # done_unreported one in a single line, nothing when there are none. The
+  # whole block is one guarded unit, like the QMD block above it: a raise or
+  # a hang on any one candidate must add nothing rather than name only the
+  # candidates seen before the failure, so the line a boot does print is
+  # never a partial one.
+  begin
+    Timeout.timeout(2) do
+      roots_raw = IO.popen({ "PLASTIC_HOME" => plastic_home }, [read_config, "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) }
+
+      attention = []
+      ActiveDelivery.candidate_intent_dirs(global_store: store_dir, project_roots: project_roots).uniq.each do |dir|
+        watch_context = RunnerCore.context(intent_dir: dir)
+        result = RunnerWatch.tick(watch_context, record: false)
+        next unless %w[stalled done_unreported].include?(result[:class])
+
+        watch_intent_id = File.basename(dir).split("--").first
+        if result[:class] == "stalled"
+          blocker = Array(result[:blockers]).first
+          attention << (blocker ? "#{watch_intent_id} stalled (#{blocker})" : "#{watch_intent_id} stalled")
+        else
+          attention << "#{watch_intent_id} done_unreported"
+        end
+      end
+      parts << "PLASTIC watch: #{attention.join(', ')}" if attention.any?
+    end
+  rescue Exception
+    # Any failure or timeout (a malformed intent directory, a hung tick) -
+    # stay silent, never crash boot.
+  end unless subagent_session
+
+  # --- Project (or global) banner with its active intent ---
+  # The one piece of intent context a live boot still carries: which store
+  # is live, and which intent (if any) is active in it (intent 341, G8, D4).
+  if plastic_md && !subagent_session
+    if current_project
+      slug = current_project["slug"]
+      banner = "Project: #{slug} | Store: #{File.join(Plastic::StoreLayout.project_root(plastic_home, slug), "store").sub(Dir.home, "~")}/"
+      if project_active.any? && project_active.first =~ /\[([^\]]+)\].*store\/([\w-]+)\//
+        intent_name, dir_name = $1, $2
+        intent_id = dir_name.split("--").first
+        banner += "\nActive: [#{intent_id} — #{intent_name}] | Artifacts → store/#{dir_name}/"
+      end
+      parts << banner
     else
-      marker = severity == "critical" ? "!! DEPRECATION (critical)" : "! DEPRECATION (warning)"
-      parts << "#{marker}: #{summary}"
-      if steps.any?
-        parts << "  Migration steps:"
-        steps.each_with_index { |s, i| parts << "  #{i + 1}. #{s}" }
+      banner = "PLASTIC — Global store loaded from ~/.plastic/"
+      if active.any? && active.first =~ /\[([^\]]+)\].*store\/([\w-]+)\//
+        intent_name, dir_name = $1, $2
+        intent_id = dir_name.split("--").first
+        banner += "\nActive: [#{intent_id} — #{intent_name}] | Artifacts → store/#{dir_name}/"
       end
-      trail = "  Removed in: #{removal}"
-      trail += " | Details: #{link}" if link
-      parts << trail
+      parts << banner
     end
   end
-end
 
-if update_notice
-  parts.unshift("! #{update_notice}\n")
-end
+  if active_deprecations.any? && !subagent_session
+    parts << ""
+    active_deprecations.each do |dep|
+      severity = dep["severity"] || "info"
+      summary = dep["summary"] || dep["id"]
+      removal = dep["removal"]
+      link = dep["link"]
+      steps = dep["migration_steps"] || []
+
+      if severity == "info"
+        line = "i Deprecation: #{summary}. Removed in: #{removal}."
+        line += " See: #{link}" if link
+        parts << line
+      else
+        marker = severity == "critical" ? "!! DEPRECATION (critical)" : "! DEPRECATION (warning)"
+        parts << "#{marker}: #{summary}"
+        if steps.any?
+          parts << "  Migration steps:"
+          steps.each_with_index { |s, i| parts << "  #{i + 1}. #{s}" }
+        end
+        trail = "  Removed in: #{removal}"
+        trail += " | Details: #{link}" if link
+        parts << trail
+      end
+    end
+  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
+  if update_notice && !subagent_session
+    parts.unshift("! #{update_notice}\n")
   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
 
+  # --- 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.
+  unless subagent_session
     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)
+      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
   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 = if !payload_session_id.empty?
-              payload_session_id
-            else
-              ENV["CLAUDE_CODE_SESSION_ID"] || Process.pid.to_s
-            end
-  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
+  # --- Session day ledger: open or join today, create the tmp dir and write
+  # the heartbeat (344 n2, spec D4). The per-session state retired: hooks
+  # now ask ActiveDelivery.resolve for a live delivery lock instead.
+  # Best-effort: any failure here degrades to no ledger context line, never
+  # blocks the session.
+  unless subagent_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 = if !payload_session_id.empty?
+                  payload_session_id
+                else
+                  ENV["CLAUDE_CODE_SESSION_ID"] || Process.pid.to_s
+                end
+      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")
+
+      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)"
+
+      # The day summary (intent 311, spec D8): open items, the last five done,
+      # live auto intents, other active sessions. Never the raw ledger. A
+      # failure here leaves the joined line alone.
+      begin
+        summary = DaySummary.build(store: store_dir, day: day, session: sid, home: plastic_home, now: Time.now)
+        parts << summary unless summary.empty?
+      rescue StandardError
+        nil
+      end
+    rescue StandardError
+      nil
     end
   end
-  parts << "PLASTIC: day ledger #{day} joined (#{open_count} open items, #{pending_count} pending)"
-
-  # The day summary (intent 311, spec D8): open items, the last five done,
-  # live auto intents, other active sessions. Never the raw ledger. A
-  # failure here leaves the joined line alone.
-  begin
-    summary = DaySummary.build(store: store_dir, day: day, session: sid, home: plastic_home, now: Time.now)
-    parts << summary unless summary.empty?
-  rescue StandardError
-    nil
-  end
 rescue StandardError
-  nil
+  # Anything unhandled above (a malformed INDEX.md, a broken projects.yml, or
+  # any other surprise) degrades the whole boot to the core banner alone,
+  # never a naked crash with no JSON at all (intent 341, G8, row 2.4).
+  parts = [core_banner, ""]
 end
 
-# Emit nothing when there is genuinely nothing to surface (no conventions,
+# Emit nothing when there is genuinely nothing to surface (no active intent,
 # no deprecations, no update notice).
 exit 0 if parts.join.strip.empty?