scout-ai 2.0.0 → 2.1.0

data/test/scout/llm/chat/test_agent_meta_provenance.rb

@@ -45,6 +45,77 @@ class TestChatAgentMetaProvenance < Test::Unit::TestCase
     end
   end
 
+  ## Envelope variants (current `meta` key) and repeated references ##
+
+  # The current envelope writes receipts under the `meta` key of the
+  # function_call_output payload instead of the legacy `agent_meta` array.
+  # Both must yield :agent_job edges from the enclosing chat.
+  def test_current_meta_envelope_receipt_yields_agent_job_edge
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Cortex/continue/Default_cur.chat')
+      parent = write_chat(dir, 'parent.chat',
+                          receipt_chat_text({'a1' => [{'job' => child}]},
+                                            envelope: :meta))
+
+      errors = []
+      visits = Chat.traverse_provenance(parent, on_error: ->(*args) { errors << args }).to_a
+
+      assert_empty errors
+      signature = visit_signature(visits)
+      edge = signature.find { |_kind, path, relation, _first| relation == :agent_job && path == child }
+      assert edge, "no :agent_job edge to #{child} in #{signature.inspect}"
+      assert_equal :job, edge[0]
+    end
+  end
+
+  # Job references recorded by chat_task point at the .chat result file
+  # (e.g. Cortex/continue/Default_x.chat); resolution must work for them too.
+  def test_chat_typed_job_reference_resolves
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Cortex/continue/Default_x.chat')
+      parent = write_chat(dir, 'parent.chat',
+                          receipt_chat_text({'a1' => [{'job' => child}]},
+                                            envelope: :meta))
+
+      errors = []
+      visits = Chat.traverse_provenance(parent, on_error: ->(*args) { errors << args }).to_a
+
+      assert_empty errors
+      signature = visit_signature(visits)
+      assert signature.any? { |_kind, path, relation, _first| relation == :agent_job && path == child },
+             signature.inspect
+    end
+  end
+
+  # Several continuations of one conversation report the SAME child job ref
+  # from one parent (the user-visible case: three Cortex/continue calls).
+  # Each receipt keeps its own edge and detail, the child node expands once.
+  def test_repeated_job_references_keep_distinct_edges_and_expand_once
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Cortex/continue/Default_dup.chat')
+      receipt = [{'job' => child}]
+      parent = write_chat(dir, 'parent.chat',
+                          receipt_chat_text({'a1' => receipt, 'a2' => receipt, 'a3' => receipt},
+                                            envelope: :meta))
+
+      errors = []
+      visits = Chat.traverse_provenance(parent, on_error: ->(*args) { errors << args }).to_a
+
+      assert_empty errors
+      delegated = visits.select { |v| v[4] == :agent_job }
+      assert_equal 3, delegated.length, 'each receipt keeps its own edge'
+      delegated.each_with_index do |visit, i|
+        assert_equal child, visit[1].path.to_s
+        assert_equal "a#{i + 1}", visit[6][:call_id], 'edge detail keeps the originating call id'
+      end
+      assert_equal [true, false, false], delegated.collect { |v| v[5] },
+                   'only the first visit expands the child node'
+      # Three edges to the SAME job node are structural: only the first one
+      # expands it (visit count 3, single expansion flag set).
+      assert_equal 3, visits.count { |kind, object, *_| kind == :job && object.path.to_s == child }
+    end
+  end
+
   def test_follow_job_excludes_the_agent_job_edge
     TmpFile.with_dir do |dir|
       parent, _worker, _critic, _dep = fixture_c(dir)
@@ -448,6 +519,68 @@ TXT
 
   ## Regression
 
+  ## Reviewer pins: no tool-name gating on the :agent_job edge
+
+  # The edge exists for ANY tool whose function_call_output envelope carries a
+  # meta[].job receipt; the function name is irrelevant to accounting.  Proven
+  # by fabricating a tool name that is not a scout-ai task (`not_ask`) and by
+  # reusing the names of the receipt-producing workflows (`cortex_continue`,
+  # `cortex_brief`) on a non-delegating envelope as a negative control.
+  def test_agent_job_edge_under_arbitrary_tool_names
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Cortex/continue/Default_tn.chat')
+
+      %w[not_ask cortex_continue cortex_brief].each do |tool|
+        parent = write_chat(dir, "parent_#{tool}.chat",
+                            receipt_chat_text({'a1' => [{'job' => child}]},
+                                              envelope: :meta, tool: tool))
+        signature = visit_signature(Chat.traverse_provenance(parent).to_a)
+        assert signature.any? { |_kind, path, relation, _first|
+          relation == :agent_job && path == child
+        }, "no :agent_job edge for tool #{tool}: #{signature.inspect}"
+      end
+
+      # Negative control: same tool names, envelope without a job receipt ->
+      # no edge, so the edge follows the receipt, not the name.
+      %w[not_ask cortex_continue cortex_brief].each do |tool|
+        parent = write_chat(dir, "plain_#{tool}.chat",
+                            receipt_chat_text({'a1' => [{'role' => 'meta',
+                                                         'content' => 'ok'}]},
+                                              envelope: :meta, tool: tool))
+        signature = visit_signature(Chat.traverse_provenance(parent).to_a)
+        assert_empty signature.select { |_kind, _path, relation, _first| relation == :agent_job },
+                     "unexpected :agent_job edge for tool #{tool}"
+      end
+    end
+  end
+
+  # Structural double check: the provenance source contains no conditional on
+  # a function/tool name anywhere in the receipt lifting path.  The check
+  # looks for gating CONSTRUCTS around the tool name (==/match/case), not for
+  # the bare word, because `tool_name` is legitimately recorded as evidence
+  # detail.
+  def test_no_tool_name_conditional_in_provenance_sources
+    source = File.read(File.expand_path('../../../../lib/scout/llm/chat/provenance.rb', __dir__))
+    # 1. no equality/matching test between the name and a literal tool name
+    %w[ask cortex_continue cortex_brief not_ask].each do |name|
+      ["tool_name == :#{name}",
+       "tool_name.to_s == '#{name}'",
+       "tool_name == '#{name}'",
+       "name == '#{name}'",
+       "tool_name =~ /#{name}/",
+       "'name' => '#{name}'"].each do |pattern|
+        assert_not_include source, pattern,
+                           "tool-name conditional #{pattern.inspect} leaked into provenance traversal"
+      end
+    end
+    # 2. no case/when branch on the name at all
+    assert_not_match(/^\s*case\s+(\S*tool_name|name)\s*$/, source)
+    # 3. the word only appears as evidence detail, never as a value compared
+    #    (the literal name recorded by callers lives in test fixtures, not here)
+    assert_not_include source, "tool_name =='", source
+    assert_not_include source, 'tool_name==', source
+  end
+
   def test_provenance_relations_include_agent_job_and_not_import
     assert_equal %i[job dependency log result agent_job], Chat::PROVENANCE_RELATIONS
     assert_not_include Chat::PROVENANCE_RELATIONS, :import

data/test/scout/llm/chat/test_agent_meta_tokens.rb

@@ -511,6 +511,60 @@ class TestChatAgentMetaTokens < Test::Unit::TestCase
     end
   end
 
+  # Continuation chain: a job's accounting delta is its RESULT CHAT ONLY, even
+  # though its persisted agent log also carries the whole projected parent
+  # history.  The synthetic A/B/C chain from the review (theme 2) is rebuilt
+  # here in miniature; the history stays inspectable through the ordinary
+  # :log relation, so nothing is truncated, it just is not counted twice.
+  def test_continuation_chain_delta_is_result_chat_only
+    TmpFile.with_dir do |dir|
+      a_meta = (1..3).collect { |i| "meta: pt=10 tt=10 inference_id=a#{i}" }
+      b_meta = (1..2).collect { |i| "meta: pt=100 tt=100 inference_id=b#{i}" }
+
+      # Job A: fresh conversation; result chat = 3 metas; log = same 3.
+      make_job(dir, 'Chain/continue/Default_A', result: "user: a\n#{a_meta * "\n"}\n",
+              logs: {'agent.chat' => "user: a\n#{a_meta * "\n"}\n"})
+
+      # Job B: continuation of A; result chat = B's own 2 metas; log = the
+      # cumulative agent history (A's 3 projected + B's 2).
+      b_log = ["user: a\n", a_meta, "user: b\n", b_meta].flatten.join("\n")
+      b_result = "user: b\n#{b_meta * "\n"}\n"
+      b = make_job(dir, 'Chain/continue/Default_B', result: b_result,
+                   logs: {'agent.chat' => b_log})
+
+      # Type the job result as chat so Chat.job_result_chat_file resolves it.
+      info = JSON.parse(File.read(b + '.info'))
+      File.write(b + '.info', {dependencies: info['dependencies'], type: :chat}.to_json)
+
+      result_chat = Chat.job_result_chat_file(Step.load(b))
+      assert result_chat, 'B has a chat-typed persisted result'
+      assert_equal({pt: 200, ct: 0, tt: 200, cct: 0, cwt: 0, rt: 0},
+                   Chat.token_totals([Chat.load(result_chat)]),
+                   'B delta = its own new metas only, not the projected history')
+
+      # The cumulative log remains fully inspectable: its direct totals still
+      # count 3 + 2 events (30 + 200 = 230), and the traversal still reaches
+      # it through the ordinary :log relation.
+      log_path = File.join(b + '.files', 'log', 'agent.chat')
+      assert_equal({pt: 230, ct: 0, tt: 230, cct: 0, cwt: 0, rt: 0},
+                   Chat.token_totals([Chat.load(log_path)]),
+                   'the history itself is untouched and readable')
+      # Traversed from the JOB root (the accounting root of a chat_task run);
+      # a bare path string would be interpreted as a chat root, so load the
+      # Step.  The cumulative log is visited through the ordinary :log relation.
+      visits = Chat.traverse_provenance(Step.load(b)).to_a
+      assert visits.any? { |k, o, _pk, _p, r, _f| k == :chat && o.to_s == log_path && r == :log },
+             'cumulative log is traversed, not dropped'
+
+      # Whole-chain accounting from the B root keeps one copy of each event:
+      # 3 A metas (30) + 2 B metas (200) = 230, not the sum of the two files
+      # (130 + 130) and not B's delta alone (200).
+      assert_equal({pt: 230, ct: 0, tt: 230, cct: 0, cwt: 0, rt: 0},
+                   Chat.provenance_token_totals(Step.load(b)),
+                   'deduplicated chain total = A metas + B metas, once each')
+    end
+  end
+
   # Two separate ask receipts pointing at the same job= keep both edge details
   # (distinct call ids and receipt addresses) while the Step is visited once.
   def test_two_receipts_to_the_same_job_keep_both_edge_details

data/test/scout/llm/chat/test_prov_cli.rb

@@ -68,10 +68,14 @@ class TestProvCLI < Test::Unit::TestCase
       out, _err, status = prov(parent)
       assert status.success?
 
-      # Cross-consumer equality: the root chat line carries the collector total.
+      # Cross-consumer equality: the root chat line carries the collector total
+      # under the evidence= label (subtree-deduplicated closure).
       root_line = out.lines.find { |line| line.include?('parent.chat') }
       assert root_line, out
-      assert root_line.include?("total=#{expected[:tt]}"), root_line
+      assert root_line.include?("evidence=#{expected[:tt]}"), root_line
+
+      # The authoritative root footer always follows the tree.
+      assert_match(/root deduplicated_total=#{expected[:tt]} /, out)
 
       # One delegated annotation line for the two receipt events (w1 + w2).
       assert_match(/delegated receipt: 2 events, total=180/, out)
@@ -105,14 +109,15 @@ class TestProvCLI < Test::Unit::TestCase
       assert root_line, out
       assert_match(/\A\s*chat\b/, root_line, out)
       assert_not_match(/\A\s*job\b/, root_line, out)
-      assert_include root_line, 'total=9', out
+      assert_include root_line, 'evidence=9', out
       assert_include root_line, 'prompt=6', out
+      assert_match(/root deduplicated_total=9 /, out)
 
       # The society conversation is traversed and rendered as its own node.
       society_line = out.lines.find { |line| line.include?('log/society/Worker/default/agent.chat') }
       assert society_line, out
       assert_match(/\A\s*chat\b/, society_line, out)
-      assert_include society_line, 'total=7', out
+      assert_include society_line, 'evidence=7', out
       assert_include society_line, 'prompt=5', out
     end
   end
@@ -195,13 +200,15 @@ class TestProvCLI < Test::Unit::TestCase
 
       out, _err, status = prov('--component', parent)
       assert status.success?
-      assert_include out, 'evidence deduplicated_total:'
       assert_include out, 'evidence chat_evidence:'
       assert_include out, 'evidence receipt_evidence:'
       assert_include out, 'evidence receipt_only:'
 
       expected = Chat.provenance_token_totals(parent)
-      assert_match(/evidence deduplicated_total: total=#{expected[:tt]}/, out)
+      # The scope block no longer repeats the authoritative total; the root
+      # footer (printed in both modes) is its single home.
+      assert_not_include out, 'evidence deduplicated_total:', 'scope block must stay 3 lines'
+      assert_match(/root deduplicated_total=#{expected[:tt]} /, out)
 
       # Coverage figures are explicitly labelled as overlapping; nothing in
       # the output invites summing them.
@@ -210,6 +217,8 @@ class TestProvCLI < Test::Unit::TestCase
 
       # No conflicts in this fixture: no non-authoritative label.
       assert_not_include out, 'not exact', out
+      # The -c conflict caveat comes from the footer only (still none here).
+      assert_not_include out, 'unresolved identity conflicts', out
     end
 
     TmpFile.with_dir do |dir|
@@ -218,6 +227,9 @@ class TestProvCLI < Test::Unit::TestCase
 
       out, _err, status = prov('--component', plain)
       assert status.success?
+      # Footer is present in -c even without any receipt evidence.
+      assert_match(/root deduplicated_total=2 /, out)
+      assert_include out, 'fresh=', out
       assert_not_include out, 'evidence deduplicated_total:', 'legacy chat must not gain scope lines'
       assert_not_include out, 'evidence chat_evidence:'
       assert_not_include out, 'evidence receipt_evidence:'
@@ -271,4 +283,392 @@ class TestProvCLI < Test::Unit::TestCase
       assert_not_include out, 'receipt=["', out
     end
   end
+
+  # Option B display contract: job nodes carry delta= (direct tokens of the
+  # persisted chat-typed result) alongside evidence=, jobs without a
+  # chat-typed result omit the field, and the root footer always follows.
+  def test_job_node_delta_labelled_and_footer_present
+    TmpFile.with_dir do |dir|
+      parent_metas = (1..3).collect { |i| "meta: pt=10 tt=10 inference_id=p#{i}" }
+      own_metas = (1..2).collect { |i| "meta: pt=100 tt=100 inference_id=o#{i}" }
+      result = "user: b\n#{own_metas * "\n"}\n"
+      # The job log is the cumulative history: parent's 3 projected + own 2.
+      log = ["user: a", parent_metas, "user: b", own_metas].flatten.join("\n") + "\n"
+      job = make_job(dir, 'Chain/continue/Default_d', result: result, logs: {'agent.chat' => log})
+      info = JSON.parse(File.read(job + '.info'))
+      File.write(job + '.info', {dependencies: info['dependencies'], type: :chat}.to_json)
+
+      out, _err, status = prov(job)
+      assert status.success?
+
+      # Job line: evidence closure (5 events once = 230) plus delta (200).
+      root_line = out.lines.find { |line| line =~ /\A job\b/ }
+      assert root_line, out
+      assert_include root_line, 'evidence=230', root_line
+      assert_include root_line, 'delta=200', root_line
+
+      # Footer: the authoritative figure, always printed, carrying the event
+      # count that no longer lives on the node line.
+      assert_match(/root deduplicated_total=230 \(5 events\)/, out)
+
+      # A job whose result is NOT chat-typed omits delta= entirely.
+      plain = make_job(dir, 'Chain/ask/Default_n', result: "answer\n",
+                       logs: {'agent.chat' => "user: x\nmeta: pt=1 tt=1 inference_id=n1\n"})
+      out2, _err2, status2 = prov(plain)
+      assert status2.success?
+      job_line = out2.lines.find { |line| line =~ /\A job\b/ }
+      assert job_line, out2
+      assert_include job_line, 'evidence=1', job_line
+      assert_not_include job_line, 'delta=', job_line
+      assert_match(/root deduplicated_total=1 /, out2)
+    end
+  end
+
+  # A JOB root whose top-level agent.chat log carries meta job pointers: the
+  # delegated children must appear in the tree nested under the owning job,
+  # even though the carrier chat itself stays hidden.
+  def test_job_root_delegated_children_nest_in_tree
+    TmpFile.with_dir do |dir|
+      child1 = make_job(dir, 'Cortex/continue/Default_c1')
+      child2 = make_job(dir, 'Cortex/continue/Default_c2')
+      worker_log = receipt_chat_text(
+        {'w1' => [meta_receipt("job=#{child1}"),
+                  meta_receipt("job=#{child2}")]}
+      )
+      worker = make_job(dir, 'Planned/work/Default_w',
+                        logs: {'agent.chat' => worker_log})
+
+      out, err, status = prov(worker)
+      assert status.success?, err
+
+      root_line = out.lines.find { |line| line.include?('Default_w') && !line.include?('Default_c') }
+      assert root_line, out
+      assert_match(/\A job\b/, root_line, out)
+
+      child_lines = out.lines.select { |line| line =~ /delegated-job .*Default_c[12]/ }
+      assert_equal 2, child_lines.length, out
+      child_lines.each do |line|
+        assert_match(/\A   job delegated-job\b/, line, "#{line} must nest two spaces under the job root")
+      end
+      assert_not_include out, 'agent.chat', 'carrier chat must stay hidden in tree mode'
+    end
+  end
+
+  # Legacy `agent_meta` receipts must keep producing delegated children too
+  # (the same lifter path, different envelope key).
+  def test_job_root_legacy_agent_meta_receipt_children
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Worker/ask/Default_legacy')
+      worker_log = receipt_chat_text(
+        {'l1' => [{role: 'meta', content: "job=#{child}"}]}
+      )
+      # force the legacy key by hand: receipt_chat_text always writes agent_meta
+      text = worker_log.gsub('"agent_meta"', '"agent_meta"')
+      worker = make_job(dir, 'Planned/work/Default_wl',
+                        logs: {'agent.chat' => text})
+
+      out, _err, status = prov(worker)
+      assert status.success?
+      assert_match(/delegated-job .*Default_legacy/, out)
+    end
+  end
+
+
+  # Job refs recorded by chat_task are chat-typed (Cortex/continue/Default_x.chat).
+  # Tree mode must resolve them and nest the delegated child once per distinct
+  # job, even when the parent repeated the same conversation three times.
+  def test_job_root_repeated_meta_refs_nest_once
+    TmpFile.with_dir do |dir|
+      child = make_job(dir, 'Cortex/continue/Default_dup.chat')
+      worker_log = receipt_chat_text(
+        {'a1' => [{'job' => child}], 'a2' => [{'job' => child}], 'a3' => [{'job' => child}]},
+        envelope: :meta
+      )
+      worker = make_job(dir, 'Planned/work/Default_w3',
+                        logs: {'agent.chat' => worker_log})
+
+      out, err, status = prov(worker)
+      assert status.success?, err
+
+      child_lines = out.lines.select { |line| line =~ /delegated-job .*Default_dup/ }
+      assert_equal 1, child_lines.length, out
+      assert_match(/\A   job delegated-job\b/, child_lines.first, out)
+    end
+  end
+
+  # A meta job pointer that does not resolve on disk must degrade to a
+  # warning, not an exception, and must not break the tree.
+  def test_dangling_meta_job_pointer_warns
+    TmpFile.with_dir do |dir|
+      missing = File.join(dir, 'Nope', 'ask', 'Default_x.chat')
+      worker_log = receipt_chat_text(
+        {'d1' => [meta_receipt("job=#{missing}")]}
+      )
+      worker = make_job(dir, 'Planned/work/Default_wd',
+                        logs: {'agent.chat' => worker_log})
+
+      out, err, status = prov(worker)
+      assert status.success?, 'a dangling pointer must never abort rendering'
+      assert_include err, 'agent_meta receipt:', err
+      assert_include err, 'unresolved_job_reference', err
+      assert_include err, 'Default_x', err
+      assert_match(/\A job Default_wd/, out)
+      assert_not_include out, 'Default_x'
+    end
+  end
+
+
+  # ---- Phase 10: reworked accounting/presentation contract ---------------
+
+  # 1 + 2 + 3: cache rate from RAW integers (rounding boundary pt=1_999_999
+  # cct=1_000_000 -> 50.0%), fresh only in the footer, canonical field order.
+  def test_footer_cache_rate_and_fresh_from_raw_integers
+    TmpFile.with_dir do |dir|
+      chat = write_chat(dir, 'round.chat',
+                        "user: hi\n" +
+                        "meta: pt=1999999 ct=1 tt=2000000 cct=1000000 inference_id=r1 timestamp=2026-09-04T00:00:00Z\n" +
+                        "meta: pt=0 ct=1 tt=500 inference_id=r2 timestamp=2026-09-04T00:00:00Z\n" +
+                        "assistant: ok\n")
+
+      out, _err, status = prov(chat)
+      assert status.success?
+
+      node_line = out.lines.find { |line| line.include?('round.chat') }
+      footer = out.lines.find { |line| line.start_with?('root') }
+      assert footer, out
+
+      # Raw-integer rate on both node and footer: 100.0 * 1000000/1999999
+      # is 50.00002... -> '50.0'.  The humanized absolute stays compact.
+      assert_include node_line, 'prompt=2M cache=1M@50.0%', node_line
+      assert_include footer, 'cache=1M@50.0%', footer
+
+      # fresh is footer-only, raw pt - cct, humanized.
+      assert_include footer, 'fresh=1M', footer
+      assert_not_include node_line, 'fresh=', 'fresh must not appear on node lines'
+
+      # Canonical field order on both lines.
+      assert_match(/chat evidence=2M prompt=2M cache=1M@50\.0% cont=2 round\.chat/,
+                   node_line, out)
+      assert_match(/\Aroot deduplicated_total=2M \(2 events\) prompt=2M cache=1M@50\.0% fresh=1M cont=2 /,
+                   footer, out)
+
+      # The pt=0 event contributes tt and ct but no prompt-axis field.
+      assert_include footer, 'cont=2', footer
+
+      # cache_write= only when cwt>0: absent here.
+      assert_not_include out, 'cache_write=', out
+
+      # The case2 shape (tmp/prov-rework/case2): pt=20M cct=19M -> 95.0%.
+      case2 = write_chat(dir, 'case2.chat',
+                         "user: hi\n" +
+                         "meta: pt=20000000 ct=800 tt=20000800 cct=19000000 rt=600 " \
+                         "inference_id=c2 timestamp=2026-09-04T00:00:00Z\n" +
+                         "assistant: ok\n")
+      out3, _err3, status3 = prov(case2)
+      assert status3.success?
+      assert_include out3, 'prompt=20M cache=19M@95.0% cont=800 reason=600', out3
+      footer2 = out3.lines.find { |line| line.start_with?('root') }
+      assert_include footer2, 'cache=19M@95.0% fresh=1M', footer2
+    end
+  end
+
+  # 2: fresh includes the cache-write portion (cwt is not subtracted from pt).
+  # 3: cache_write= prints only when cwt>0.
+  def test_footer_fresh_includes_cache_write_and_cache_write_gated
+    TmpFile.with_dir do |dir|
+      _a, _b, _c, _tsv, _parent = continuation_chain(dir)
+      out, _err, status = prov(_a)
+      assert status.success?
+
+      footer = out.lines.find { |line| line.start_with?('root') }
+      assert footer, out
+      # A's own metas: pt=120, cct=90, cwt=15 -> fresh=120-90=30, cache_write=15.
+      assert_include footer, 'prompt=120 cache=90@75.0% fresh=30 cache_write=15', footer
+
+      # Node lines never carry fresh= or cache_write=.
+      node = out.lines.find { |line| line =~ /\A job\b/ }
+      assert node, out
+      assert_not_include node, 'fresh=', node
+      assert_not_include node, 'cache_write=', node
+    end
+  end
+
+  # 4: -c direct= values come from the node's own log sums (cumulative ask
+  # shape: the continuation job's direct log carries the projected parent
+  # metas inlined, so direct= still equals its full recorded log).
+  def test_component_direct_values_from_local_log_sums
+    TmpFile.with_dir do |dir|
+      a, b, c, _tsv, _parent = continuation_chain(dir)
+
+      out, _err, status = prov('--component', a)
+      assert status.success?
+      line_a = out.lines.find { |line| line =~ /\A job\b/ }
+      assert_include line_a, 'direct=150', line_a
+      assert_not_include line_a, 'evidence=', line_a
+
+      out, _err, status = prov('--component', b)
+      assert status.success?
+      line_b = out.lines.find { |line| line =~ /\A job\b/ }
+      assert_include line_b, 'direct=390', 'B log = 3 parent metas + 2 own, each tt=50 or 120'
+
+      out, _err, status = prov('--component', c)
+      assert status.success?
+      line_c = out.lines.find { |line| line =~ /\A job\b/ }
+      assert_include line_c, 'direct=990', 'C log = cumulative history, 6 events'
+    end
+  end
+
+  # 5 + 11: delta= on job nodes in BOTH modes; absent on chat nodes and for
+  # non-chat results.
+  def test_delta_visibility_in_both_modes_and_omissions
+    TmpFile.with_dir do |dir|
+      a, b, c, tsv, parent = continuation_chain(dir)
+
+      ['', '-c'].each do |mode|
+        out, _err, status = prov(*(mode.empty? ? [c] : ['--component', c]))
+        assert status.success?, mode
+        job_c = out.lines.find { |line| line =~ /Default_c3/ && line =~ /\A job\b/ }
+        job_b = out.lines.find { |line| line =~ /Default_b2/ && line =~ /\A\s*job\b/ }
+        assert_include job_c, 'delta=600', job_c
+        assert_include job_b, 'delta=240', job_b
+
+        # The TSV-typed job (receipt child of parent.chat) omits delta=, and
+        # the plain chat node never carries it.
+        out2, _err2, status2 = prov(*(mode.empty? ? [parent] : ['--component', parent]))
+        assert status2.success?, mode
+        chat_line = out2.lines.find { |line| line.include?('parent.chat') }
+        assert_not_include chat_line, 'delta=', chat_line
+        tsv_line = out2.lines.find { |line| line =~ /Default_d4/ }
+        assert tsv_line, out2
+        assert_not_include tsv_line, 'delta=', 'non-chat result must omit delta=, not print delta=0'
+      end
+    end
+  end
+
+  # 6: footer equals the collector deduplicated scope; footer present in -c
+  # without receipts (covered by plain.chat in test_component_mode...).
+  def test_footer_equals_collector_deduplicated_total_on_chain
+    TmpFile.with_dir do |dir|
+      _a, _b, c, _tsv, parent = continuation_chain(dir)
+      [c, parent].each do |root|
+        expected = Chat.provenance_token_totals(root)
+        out, _err, status = prov(root)
+        assert status.success?
+        assert_match(/root deduplicated_total=#{expected[:tt]} /, out)
+        # Cross-consumer: the per-node root line also carries the closure.
+        root_line = out.lines.find { |line| line =~ /\A (job|chat)\b/ }
+        assert_include root_line, "evidence=#{expected[:tt]}", root_line
+        assert_equal expected, Chat.tokens(root)
+      end
+    end
+  end
+
+  # 9: continuation chain additivity: sum of per-job deltas equals the root
+  # footer deduplicated_total; ancestor evidence= closures are cumulative.
+  def test_chain_deltas_sum_to_footer_and_closures_cumulative
+    TmpFile.with_dir do |dir|
+      _a, _b, c, _tsv, _parent = continuation_chain(dir)
+
+      out, _err, status = prov(c)
+      assert status.success?
+
+      # Cumulative closures down the chain: A 150 < B 390 < C 990.
+      assert_match(/job evidence=150 .*Default_a1/, out)
+      assert_match(/job evidence=390 .*Default_b2/, out)
+      assert_match(/job evidence=990 .*Default_c3/, out)
+
+      # Deltas are disjoint and sum to the footer: 150 + 240 + 600 = 990.
+      deltas = out.lines.select { |line| line =~ /job\b/ && line =~ /evidence=/ }
+                   .collect { |line| line[/delta=(\d+)/, 1].to_i }
+      # Tree order is root-first: C, B, A.
+      assert_equal [600, 240, 150], deltas, out
+      assert_equal deltas.sum, 990
+      assert_match(/root deduplicated_total=990 \(6 events\)/, out)
+
+      # Same additivity holds in -c mode.
+      out_c, _err_c, status_c = prov('--component', c)
+      assert status_c.success?
+      deltas_c = out_c.lines.select { |line| line =~ /job\b/ && line =~ /direct=/ }
+                       .collect { |line| line[/delta=(\d+)/, 1].to_i }
+      assert_equal deltas, deltas_c
+      assert_match(/root deduplicated_total=990 /, out_c)
+    end
+  end
+
+  # 10: zero/missing cache and pt=0 omission (no exception, no prompt axis).
+  def test_zero_cache_and_missing_prompt_axis
+    TmpFile.with_dir do |dir|
+      _a, _b, _c, _tsv, parent = continuation_chain(dir)
+
+      # cct=0 with pt>0: cache=0@0.0% and footer fresh=<pt>.
+      out, _err, status = prov(parent)
+      assert status.success?
+      footer = out.lines.find { |line| line.start_with?('root') }
+      assert footer, out
+      assert_include footer, 'prompt=17 cache=0@0.0% fresh=17', footer
+
+      # pt=0 everywhere: the whole prompt axis disappears, tt still prints.
+      zero = write_chat(dir, 'zero.chat',
+                        "user: hi\nmeta: pt=0 ct=1 tt=500 inference_id=z1 timestamp=2026-09-04T00:00:00Z\nassistant: ok\n")
+      out2, _err2, status2 = prov(zero)
+      assert status2.success?, 'pt=0 must not raise'
+      assert_include out2, 'chat evidence=500 cont=1 zero.chat', out2
+      assert_match(/root deduplicated_total=500 \(1 events\) cont=1 /, out2)
+      %w[prompt= cache= fresh= cache_write= @].each do |token|
+        assert_not_include out2, token, "pt=0 must omit the whole prompt axis: #{token}"
+      end
+    end
+  end
+
+  # 12: identity conflicts produce the footer caveat in both modes; no
+  # conflicts means no caveat line.
+  def test_conflict_caveat_lives_in_footer_in_both_modes
+    TmpFile.with_dir do |dir|
+      # Same inference_id recorded with two different tt: a conflict.
+      conflicting = write_chat(dir, 'conflict.chat',
+                               "user: hi\n" +
+                               "meta: pt=10 ct=1 tt=11 inference_id=k1 timestamp=2026-09-04T00:00:00Z provider_response_id=p1\n" +
+                               "meta: pt=10 ct=1 tt=99 inference_id=k1 timestamp=2026-09-04T00:00:00Z provider_response_id=p1\n" +
+                               "assistant: ok\n")
+
+      ['', '-c'].each do |mode|
+        out, _err, status = prov(*(mode.empty? ? [conflicting] : ['--component', conflicting]))
+        assert status.success?, mode
+        caveat = out.lines.count { |line| line.include?('not exact') }
+        assert_equal 1, caveat, "caveat must come from the footer once: #{mode}\n#{out}"
+        assert_include out, 'unresolved identity conflicts', out
+      end
+
+      # No conflicts: no caveat line at all.
+      clean = write_chat(dir, 'clean.chat',
+                         "user: hi\nmeta: pt=10 ct=1 tt=11 inference_id=q1 timestamp=2026-09-04T00:00:00Z\nassistant: ok\n")
+      out, _err, status = prov(clean)
+      assert status.success?
+      assert_not_include out, 'not exact', out
+    end
+  end
+
+  # 8: saved+receipt dedup: the merged event is counted once in the scope
+  # block and the footer equals the collector total.
+  def test_saved_and_receipt_dedup_scope_and_footer
+    TmpFile.with_dir do |dir|
+      parent, _worker = fixture_b(dir)
+      expected = Chat.provenance_token_totals(parent)
+
+      out, _err, status = prov('--component', parent)
+      assert status.success?
+
+      # w1/w2 are stored in the worker log AND in the parent receipt: chat
+      # and receipt scopes both cover them, deduplicated_total counts once.
+      assert_match(/evidence chat_evidence: total=#{expected[:tt]}/, out)
+      assert_match(/evidence receipt_evidence: total=180/, out)
+      assert_match(/evidence receipt_only: total=0/, out)
+      assert_match(/root deduplicated_total=#{expected[:tt]} /, out)
+
+      # Scope block is exactly 3 lines now.
+      scope_lines = out.lines.count { |line| line =~ /^\s*evidence \w+:/ }
+      assert_equal 3, scope_lines, out
+    end
+  end
+
 end