scout-ai 1.2.3 → 2.0.0

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

@@ -2,7 +2,7 @@ require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
 require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
 
 class TestParse < Test::Unit::TestCase
-  def test_parse_simple_text
+  def _test_parse_simple_text
     text = "Hello\nWorld"
     msgs = Chat.parse(text)
     assert_equal 1, msgs.size
@@ -10,7 +10,7 @@ class TestParse < Test::Unit::TestCase
     assert_equal "Hello\nWorld", msgs[0][:content]
   end
 
-  def test_parse_block_and_inline_headers
+  def _test_parse_block_and_inline_headers
     text = <<~TXT
     assistant:
     This is a block
@@ -21,21 +21,38 @@ class TestParse < Test::Unit::TestCase
 
     msgs = Chat.parse(text)
 
-    # Expect a few messages: initial empty user, assistant block, inline user, and final user block
-    assert_equal 'user', msgs[0][:role]
-    assert_equal '', msgs[0][:content]
+    # Expect three messages: assistant block, inline user, and the final
+    # block, which takes the default user role. No leading empty user
+    # message is emitted any more.
+    assert_equal 3, msgs.size
 
-    assert_equal 'assistant', msgs[1][:role]
-    assert_equal "This is a block\nwith lines", msgs[1][:content]
+    assert_equal 'assistant', msgs[0][:role]
+    assert_equal "This is a block\nwith lines", msgs[0][:content]
+
+    assert_equal 'user', msgs[1][:role]
+    assert_equal 'inline reply', msgs[1][:content]
 
     assert_equal 'user', msgs[2][:role]
-    assert_equal 'inline reply', msgs[2][:content]
+    assert_equal 'another line', msgs[2][:content]
+  end
+
+  def test_no_leading_empty_user_message
+    # A chat whose whole content is an empty user block parses to no
+    # messages: Chat.parse must not fabricate an empty leading message.
+    assert_equal [], Chat.parse("user:\n")
+    assert_equal [], Chat.parse("user: \n")
 
-    assert_equal 'assistant', msgs[3][:role]
-    assert_equal 'another line', msgs[3][:content]
+    # A chat starting with a block header keeps its real messages and
+    # gains no empty user message in front of them.
+    msgs = Chat.parse("user:\nRun the worker\nassistant: done\n")
+    assert_equal 2, msgs.size
+    assert_equal 'user', msgs[0][:role]
+    assert_equal 'Run the worker', msgs[0][:content]
+    assert_equal 'assistant', msgs[1][:role]
+    assert_equal 'done', msgs[1][:content]
   end
 
-  def test_parse_code_fence_protection
+  def _test_parse_code_fence_protection
     text = <<~TXT
     assistant:
     Here is code:
@@ -56,7 +73,7 @@ class TestParse < Test::Unit::TestCase
     assert_equal expected, assistant_msg[:content]
   end
 
-  def test_parse_xml_protection
+  def _test_parse_xml_protection
     text = <<~TXT
     assistant:
     Before xml
@@ -72,7 +89,7 @@ class TestParse < Test::Unit::TestCase
     assert_equal "Before xml\n<note>\nThis is protected\n</note>\nAfter", assistant_msg[:content]
   end
 
-  def test_parse_square_brackets_protection
+  def _test_parse_square_brackets_protection
     text = <<~TXT
     assistant:
     Start
@@ -87,7 +104,7 @@ class TestParse < Test::Unit::TestCase
     assert_equal "Start\nThis: has colon\nand lines\nEnd", assistant_msg[:content]
   end
 
-  def test_parse_cmd_output_protection
+  def _test_parse_cmd_output_protection
     text = <<~TXT
     assistant:
     Before
@@ -105,7 +122,7 @@ class TestParse < Test::Unit::TestCase
     assert_equal expected, assistant_msg[:content]
   end
 
-  def test_previous_response_id_behavior
+  def _test_previous_response_id_behavior
     text = <<~TXT
     previous_response_id:abc123
     Some block
@@ -123,4 +140,42 @@ class TestParse < Test::Unit::TestCase
     assert_equal 'user', msgs[idx + 1][:role]
     assert_equal 'Some block', msgs[idx + 1][:content]
   end
+
+  def _test_parse_json
+    text = <<~TXT
+Hi
+
+
+```json
+{
+  "status": "PASS",
+  "summary": "The worker successfully created the file `tmp/number` and wrote a random number (42) into it, satisfying the request.",
+  "issues": [],
+  "next_step": "",
+  "search_needed": false
+}
+```
+    TXT
+
+    assert_nothing_raised do
+      Chat.parse_json(text)
+    end
+    assert_nothing_raised do
+      Chat.parse_json(text.chomp)
+    end
+
+  end
+
+  def test_protect_print
+    content =<<-EOF
+Hi this line is not a role
+sections:
+That was inside a content block
+    EOF
+    messages = [{role: 'assistant', content: content.strip}]
+
+    txt = Chat.print messages
+    m = Chat.parse txt
+    assert_equal messages, m.reject{|msg| msg[:content].empty?}
+  end
 end

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

@@ -0,0 +1,274 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require 'scout/llm/chat'
+require 'json'
+require 'open3'
+require 'rbconfig'
+require 'timeout'
+require_relative 'agent_meta_fixtures'
+
+# Smoke tests for `scout-ai llm prov` (plan delivery step 5).  The command is a
+# SOPT script, so the tests run the real binary in a subprocess against the
+# AgentMetaFixtures layouts and compare its output with the Chat APIs; no
+# providers and no network are involved.
+#
+# The prov binary works offline in this environment (verified manually), which
+# is why a subprocess runner is used instead of loading the command in-process.
+class TestProvCLI < Test::Unit::TestCase
+  include AgentMetaFixtures
+
+  REPO_ROOT = File.expand_path('../../../..', __dir__)
+
+  def self.startup
+    # Keep test progress output clean; the subprocess warnings are captured
+    # separately by Open3 anyway.
+    Log.severity = 5
+  end
+
+  def setup
+    @prov_count = 0
+  end
+
+  # Run `scout-ai llm prov` and return [stdout, stderr, status], colors stripped.
+  def prov(*args)
+    cmd = [RbConfig.ruby, File.join(REPO_ROOT, 'bin', 'scout-ai'), 'llm', 'prov'] + args.collect(&:to_s)
+    env = ENV.to_h.merge('SCOUT_DEV' => nil)
+    Timeout.timeout(120) do
+      out, err, status = Open3.capture3(env, *cmd, chdir: REPO_ROOT)
+      [strip_ansi(out), strip_ansi(err), status]
+    end
+  end
+
+  def strip_ansi(text)
+    text.gsub(/\e\[[0-9;]*m/, '')
+  end
+
+  # Fixture B layout: parent receipt carrying w1/w2, worker log with w1/w2/w3.
+  def fixture_b(dir)
+    worker_log = "user: work\n" +
+                 "meta: pt=100 ct=50 tt=150 inference_id=w1\n" +
+                 "meta: pt=20 ct=10 tt=30 inference_id=w2\n" +
+                 "meta: pt=5 ct=5 tt=10 inference_id=w3\n" +
+                 "assistant: done\n"
+    worker = make_job(dir, 'Worker/ask/Default_w', logs: {'agent.chat' => worker_log})
+    parent = write_chat(dir, 'parent.chat',
+                        receipt_chat_text(
+                          {'a1' => [meta_receipt('pt=100 ct=50 tt=150 inference_id=w1'),
+                                    meta_receipt('pt=20 ct=10 tt=30 inference_id=w2')]},
+                          extra: ['meta: pt=60 ct=40 tt=100 inference_id=p1',
+                                  "meta: job=#{worker}"]
+                        ))
+    [parent, worker]
+  end
+
+  def test_tree_aggregate_matches_token_collector
+    TmpFile.with_dir do |dir|
+      parent, _worker = fixture_b(dir)
+      expected = Chat.provenance_token_totals(parent)
+
+      out, _err, status = prov(parent)
+      assert status.success?
+
+      # Cross-consumer equality: the root chat line carries the collector total.
+      root_line = out.lines.find { |line| line.include?('parent.chat') }
+      assert root_line, out
+      assert root_line.include?("total=#{expected[:tt]}"), root_line
+
+      # One delegated annotation line for the two receipt events (w1 + w2).
+      assert_match(/delegated receipt: 2 events, total=180/, out)
+      assert_equal 1, out.lines.count { |line| line.include?('delegated receipt:') }
+
+      # Chat.tokens and the CLI now come from the same collector.
+      assert_equal expected, Chat.tokens(parent)
+    end
+  end
+
+  def test_saved_chat_with_files_sidecar_is_not_a_job
+    TmpFile.with_dir do |dir|
+      # A saved agent chat carries a .files sidecar but no .info sidecar: it
+      # must be rendered as a chat root, never loaded as a Step.
+      saved = write_chat(dir, 'saved.chat',
+                         "user: hi\nmeta: pt=1 ct=1 tt=2 inference_id=s1\nassistant: done\n")
+      society_chat = File.join(saved + '.files', 'log', 'society', 'Worker', 'default', 'agent.chat')
+      FileUtils.mkdir_p(File.dirname(society_chat))
+      File.write(society_chat,
+                 "user: work\nmeta: pt=5 ct=2 tt=7 inference_id=s2\nassistant: ok\n")
+      assert !File.exist?(saved + '.info')
+
+      out, err, status = prov(saved)
+      assert status.success?, "prov must not blow up on a .files-only chat\n#{err}"
+
+      # Root classification: the rendered root is the chat itself, not a job
+      # node. Its aggregate now includes the society conversation in the
+      # sidecar (2 + 7 = 9), because chats with a .files sidecar are scanned
+      # for socialized agent conversations just like jobs.
+      root_line = out.lines.find { |line| line.include?('saved.chat') && !line.include?('.files') }
+      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, 'prompt=6', 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, 'prompt=5', out
+    end
+  end
+
+  def test_evidence_lists_events_addresses_and_call_ids
+    TmpFile.with_dir do |dir|
+      parent, _worker = fixture_b(dir)
+
+      out, _err, status = prov('--evidence', parent)
+      assert status.success?
+      assert_include out, 'Direct inference events'
+
+      # Every direct event appears exactly once, with its id.
+      %w[w1 w2 w3 p1].each do |id|
+        rows = out.lines.count { |line| line =~ /^\s*#{id}\s/ }
+        assert_equal 1, rows, "#{id} should appear once, got #{rows}\n#{out}"
+      end
+
+      # Receipt evidence keeps its parent output address and call id.
+      assert_match(/agent_meta parent\.chat:2\[agent_meta,0\] call=a1/, out)
+      assert_match(/agent_meta parent\.chat:2\[agent_meta,1\] call=a1/, out)
+
+      # Chat-side evidence for the merged events.
+      assert_match(/chat_meta agent\.chat:3/, out)
+
+      # Status column; nothing is receipt-only, conflicting or duplicated here.
+      assert_include out, 'counted once'
+      assert_not_include out, 'Receipt-only events'
+      assert_not_include out, 'conflict'
+      assert_not_include out, 'Job projection references'
+    end
+  end
+
+  def test_tree_marks_delegated_jobs_only
+    TmpFile.with_dir do |dir|
+      parent, _worker, _critic, _dep = fixture_c(dir)
+
+      out, _err, status = prov(parent)
+      assert status.success?
+
+      # Worker is reached through a receipt (relation :agent_job) ...
+      assert_match(/delegated-job (Default_)?w\b/, out)
+      # ... while the Critic, referenced by an ordinary local meta job= line
+      # (relation :job), keeps the plain job rendering.
+      assert_match(/^\s*job\s+(Default_)?c\b/, out)
+      assert_not_match(/delegated-job (Default_)?c\b/, out)
+
+      # Delegated usage of the parent chat is annotated once.
+      assert_equal 1, out.lines.count { |line| line.include?('delegated receipt:') }
+    end
+  end
+
+  def test_flow_and_dot_render_delegated_result_without_extra_nodes
+    TmpFile.with_dir do |dir|
+      parent, _worker, _critic, _dep = fixture_c(dir)
+
+      out, _err, status = prov('--flow', parent)
+      assert status.success?
+      assert_include out, 'delegated_result'
+      kinds = out.lines.grep(/^\[\s*\d+\] (Job|Chat)/).collect { |line| line.strip[/\] (\w+)/, 1] }
+      assert kinds.all? { |kind| %w[Job Chat].include?(kind) }, out
+
+      dot_file = File.join(dir, 'prov.dot')
+      out2, _err2, status2 = prov('--dot', dot_file, parent)
+      assert status2.success?
+      dot = File.read(dot_file)
+
+      assert_include dot, 'delegated_result'
+      shapes = dot.scan(/^\s+n\d+ \[shape=(\w+)/).flatten
+      # Only chat/job node kinds exist: 3 jobs (box) + the parent chat (note).
+      assert shapes.all? { |shape| %w[box note].include?(shape) }, dot
+      assert_equal 4, shapes.length, dot
+      assert_not_include dot, 'agent_meta'
+    end
+  end
+
+  def test_component_mode_prints_scopes_only_with_receipts
+    TmpFile.with_dir do |dir|
+      parent, _worker = fixture_b(dir)
+
+      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)
+
+      # Coverage figures are explicitly labelled as overlapping; nothing in
+      # the output invites summing them.
+      assert_include out, 'overlaps chat_evidence', out
+      assert_include out, 'no saved chat/log', out
+
+      # No conflicts in this fixture: no non-authoritative label.
+      assert_not_include out, 'not exact', out
+    end
+
+    TmpFile.with_dir do |dir|
+      plain = write_chat(dir, 'plain.chat',
+                         "user: hi\nmeta: pt=1 ct=1 tt=2 inference_id=x1\nassistant: done\n")
+
+      out, _err, status = prov('--component', plain)
+      assert status.success?
+      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:'
+      assert_not_include out, 'evidence receipt_only:'
+      assert_not_include out, 'delegated receipt:'
+    end
+  end
+
+  def test_malformed_receipt_renders_with_warning
+    TmpFile.with_dir do |dir|
+      payload = {'id' => 'bad1', 'result' => 'x', 'agent_meta' => 'oops'}
+      text = "user: hi\n" +
+             'function_call: ' + %({"name":"ask","arguments":{},"id":"bad1"}) + "\n" +
+             'function_call_output: ' + JSON.generate(payload) + "\n" +
+             "meta: pt=10 ct=5 tt=15 inference_id=p9\n" +
+             "assistant: done\n"
+      bad = write_chat(dir, 'bad.chat', text)
+
+      out, err, status = prov(bad)
+      assert status.success?, 'a malformed receipt must never abort rendering'
+
+      assert_include out, 'total=15', out
+      assert_include err, 'agent_meta receipt:', err
+      assert_include err, 'not_an_array', err
+      assert_include err, 'bad1', err
+      # The specific receipt line replaces the generic traversal warning, so a
+      # malformed receipt must not print both lines.
+      assert_not_include err, 'Incomplete provenance at', err
+    end
+  end
+
+  def test_evidence_compact_legacy_ids_and_zero_scope
+    TmpFile.with_dir do |dir|
+      # Receipt-only chat with a legacy (no inference_id) meta: local scope has
+      # no events at all.
+      legacy = write_chat(dir, 'legacy.chat',
+                          receipt_chat_text({'r1' => [meta_receipt('pt=3 tt=5')]}))
+
+      out, _err, status = prov('--component', legacy)
+      assert status.success?
+      assert_include out, 'evidence chat_evidence: total=0', out
+      assert_include out, 'evidence receipt_evidence: total=5'
+      assert_include out, 'evidence receipt_only: total=5'
+
+      out, _err, status = prov('--evidence', legacy)
+      assert status.success?
+      # Legacy receipt events show their receipt location instead of the raw
+      # address array, and they are flagged as possibly overcounted.
+      assert_match(/receipt=legacy\.chat:2\[agent_meta,0\]/, out)
+      assert_include out, 'legacy unresolved'
+      assert_not_include out, 'receipt=["', out
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require 'scout/llm/chat'
+
+class TestChatProvenance < Test::Unit::TestCase
+  def test_does_not_follow_imports
+    TmpFile.with_dir do |dir|
+      imported = File.join(dir, 'imported.chat')
+      root = File.join(dir, 'root.chat')
+      File.write(imported, "user: Imported\n")
+      File.write(root, "import: imported.chat\nuser: Root\n")
+
+      visits = Chat.traverse_provenance(root).to_a
+      # Only the root chat is visited; imports are not part of provenance.
+      assert_equal 1, visits.length
+      assert_equal :chat, visits.first[0]
+      assert_nil visits.first[4]
+      assert_equal File.expand_path(root), Chat.provenance_path(visits.first[0], visits.first[1])
+    end
+  end
+
+  def test_does_not_follow_continue_or_last
+    TmpFile.with_dir do |dir|
+      continued = File.join(dir, 'continued.chat')
+      last_chat = File.join(dir, 'last_chat.chat')
+      root = File.join(dir, 'root.chat')
+      File.write(continued, "user: Continued\n")
+      File.write(last_chat, "user: Last\n")
+      File.write(root, "continue: continued.chat\nlast: last_chat.chat\nuser: Root\n")
+
+      visits = Chat.traverse_provenance(root).to_a
+      # Only the root chat is visited; continue and last are not part of provenance.
+      assert_equal 1, visits.length
+      assert_equal :chat, visits.first[0]
+      assert_equal File.expand_path(root), Chat.provenance_path(visits.first[0], visits.first[1])
+    end
+  end
+
+  def test_provenance_relations_does_not_include_import
+    assert_not_include Chat::PROVENANCE_RELATIONS, :import
+    assert_not_include Chat::PROVENANCE_RELATIONS, :continue
+    assert_not_include Chat::PROVENANCE_RELATIONS, :last
+    assert_equal %i[job dependency log result agent_job], Chat::PROVENANCE_RELATIONS
+  end
+
+  def test_traverses_job_and_log_relations
+    TmpFile.with_dir do |dir|
+      root = File.join(dir, 'root.chat')
+      # A chat with a job reference. The job will not be loadable, so use on_error.
+      File.write(root, "user: Root\njob: Agent/Worker/ask/Default_abcd1234\n")
+
+      errors = []
+      visits = Chat.traverse_provenance(root, on_error: ->(*args) { errors << args }).to_a
+      # Root chat is always visited. The job reference is attempted but may fail.
+      chat_visits = visits.select { |kind, *_rest| kind == :chat }
+      assert chat_visits.any? { |kind, object, *_rest| Chat.provenance_path(kind, object) == File.expand_path(root) }
+    end
+  end
+
+  def test_imports_in_chat_do_not_produce_warnings
+    TmpFile.with_dir do |dir|
+      root = File.join(dir, 'root.chat')
+      File.write(root, "import: nonexistent.chat\nuser: Root\n")
+
+      errors = []
+      visits = Chat.traverse_provenance(root, on_error: ->(*args) { errors << args }).to_a
+      # Import references are never resolved during provenance, so no errors.
+      assert_equal 1, visits.length
+      assert_empty errors
+    end
+  end
+
+end
+
+require_relative 'agent_meta_fixtures'
+
+# NEW save-layout (step 3) provenance expectations.  The producer step changed
+# the on-disk location of delegated agent chats:
+#
+#   direct delegated chat   <chat>.files/agent.chat (or <name>.chat)
+#   society chats           <chat>.files/agent.society/<Agent>/<conv>/agent.chat
+#   legacy (read-only)      <chat>.files/log/... and <chat>.files/log/society/...
+#
+# These tests only exercise the traversal/read side; writing the new layout is
+# covered by test/scout/llm/agent/test_save.rb.
+class TestNewLayoutProvenance < Test::Unit::TestCase
+  include AgentMetaFixtures
+
+  ROOT_CHAT = "user: hi\nmeta: pt=2 ct=1 tt=3 inference_id=s0\nassistant: done\n"
+
+  def visits_paths(root, root_type: nil)
+    opts = {}
+    opts[:root_type] = root_type if root_type
+    Chat.traverse_provenance(root, **opts).to_a.collect { |_k, object, _pk, _p, _r, _f| object.to_s }
+  end
+
+  # (a) new-layout society sidecar traversed with :log from a saved chat root
+  def test_new_layout_society_sidecar_is_traversed_with_log_relation
+    TmpFile.with_dir do |dir|
+      chat = write_chat(dir, 'saved.chat', ROOT_CHAT)
+
+      society = File.expand_path(File.join(chat + '.files', 'agent.society', 'Direct', 'harness_test'))
+      FileUtils.mkdir_p(society)
+      File.write(File.join(society, 'agent.chat'),
+                 "user: work\nmeta: pt=10 ct=5 tt=15 inference_id=w1\nassistant: ok\n")
+
+      errors = []
+      visits = Chat.traverse_provenance(chat, on_error: ->(*args) { errors << args }).to_a
+      assert_empty errors
+
+      found = visits.find do |_kind, object, _pk, _parent, _relation, _first|
+        object.to_s == File.join(society, 'agent.chat')
+      end
+      assert found, 'new-layout society chat not visited'
+      kind, object, parent_kind, parent, relation, first = found
+      assert_equal :chat, kind
+      assert_equal :chat, parent_kind
+      assert_equal File.expand_path(chat), parent.to_s
+      assert_equal :log, relation
+      assert first
+
+      # Aggregation is preserved across layouts.
+      assert_equal({pt: 12, ct: 6, tt: 18, cct: 0, cwt: 0, rt: 0},
+                   Chat.provenance_token_totals(chat))
+    end
+  end
+
+  # (b) new-layout root copy not traversed; legacy root copy still excluded
+  def test_new_layout_root_copy_is_not_traversed
+    TmpFile.with_dir do |dir|
+      chat = write_chat(dir, 'saved.chat', ROOT_CHAT)
+
+      files = File.expand_path(chat + '.files')
+      FileUtils.mkdir_p(File.join(files, 'agent.society', 'Direct', 'harness_test'))
+      FileUtils.mkdir_p(File.join(files, 'log', 'society', 'Worker', 'default'))
+      # Root copies in BOTH layouts: full copy of the root conversation.
+      File.write(File.join(files, 'agent.chat'), ROOT_CHAT)
+      File.write(File.join(files, 'log', 'agent.chat'), ROOT_CHAT)
+      # Independent society conversations in both layouts.
+      File.write(File.join(files, 'agent.society', 'Direct', 'harness_test', 'agent.chat'),
+                 "user: work\nmeta: pt=10 ct=5 tt=15 inference_id=w1\nassistant: ok\n")
+      File.write(File.join(files, 'log', 'society', 'Worker', 'default', 'agent.chat'),
+                 "user: work2\nmeta: pt=20 ct=10 tt=30 inference_id=w2\nassistant: ok\n")
+
+      paths = visits_paths(chat)
+
+      new_root_copy = File.join(files, 'agent.chat')
+      legacy_root_copy = File.join(files, 'log', 'agent.chat')
+      assert_not_include paths, new_root_copy,
+                          'new-layout root copy must not become its own node'
+      assert_not_include paths, legacy_root_copy,
+                          'legacy root copy must stay excluded'
+      assert_include paths, File.join(files, 'agent.society', 'Direct', 'harness_test', 'agent.chat')
+      assert_include paths, File.join(files, 'log', 'society', 'Worker', 'default', 'agent.chat')
+
+      edges = Chat.provenance_edges(chat).collect { |e| [e[:from].to_s, e[:to].to_s, e[:relation]] }
+      assert_empty edges.select { |_from, to, _r| to == new_root_copy }
+      assert_empty edges.select { |_from, to, _r| to == legacy_root_copy }
+    end
+  end
+
+  # (c) legacy log/ sidecar still traversed (compat) and (d) no duplicate
+  #     visits when both layouts coexist.
+  def test_both_layouts_coexist_without_duplicates
+    TmpFile.with_dir do |dir|
+      chat = write_chat(dir, 'saved.chat', ROOT_CHAT)
+
+      files = File.expand_path(chat + '.files')
+      FileUtils.mkdir_p(File.join(files, 'agent.society', 'Direct', 'harness_test'))
+      FileUtils.mkdir_p(File.join(files, 'log', 'society', 'Worker', 'default'))
+
+      File.write(File.join(files, 'agent.society', 'Direct', 'harness_test', 'agent.chat'),
+                 "user: work\nmeta: pt=10 ct=5 tt=15 inference_id=w1\nassistant: ok\n")
+      File.write(File.join(files, 'log', 'society', 'Worker', 'default', 'agent.chat'),
+                 "user: work2\nmeta: pt=20 ct=10 tt=30 inference_id=w2\nassistant: ok\n")
+
+      visits = Chat.traverse_provenance(chat).to_a
+      paths = visits.collect { |_k, object, _pk, _p, _r, _f| object.to_s }
+      assert_equal paths.uniq.length, paths.length, 'duplicate visits when layouts coexist'
+
+      # Legacy relation is unchanged.
+      legacy = visits.find do |_kind, object, _pk, _parent, relation, _first|
+        relation == :log && object.to_s.end_with?('log/society/Worker/default/agent.chat')
+      end
+      assert legacy, 'legacy log/ sidecar must keep being traversed'
+      assert_equal :chat, legacy[0]
+
+      # Tokens are counted exactly once.
+      assert_equal({pt: 32, ct: 16, tt: 48, cct: 0, cwt: 0, rt: 0},
+                   Chat.provenance_token_totals(chat))
+    end
+  end
+
+  # Jobs are the other root type that owns a .files sidecar.
+  def test_new_layout_job_files_are_traversed
+    TmpFile.with_dir do |dir|
+      job = make_job(dir, 'Worker/ask/Default_w')
+      files = job + '.files'
+      FileUtils.mkdir_p(File.join(files, 'agent.society', 'Critic', 'default'))
+
+      # A job's own top-level chat IS traversed (renderers hide it).
+      File.write(File.join(files, 'agent.chat'),
+                 "user: work\nmeta: pt=10 ct=5 tt=15 inference_id=w1\nassistant: ok\n")
+      File.write(File.join(files, 'agent.society', 'Critic', 'default', 'agent.chat'),
+                 "user: critic\nmeta: pt=4 ct=2 tt=6 inference_id=c1\nassistant: ok\n")
+
+      # A bare job path is only treated as a job with root_type: :job (the
+      # CLI decides job vs chat through the .info sidecar).
+      paths = visits_paths(job, root_type: :job)
+      assert_include paths, File.expand_path(File.join(files, 'agent.chat'))
+      assert_include paths, File.expand_path(File.join(files, 'agent.society', 'Critic', 'default', 'agent.chat'))
+
+      # The collector also keeps both (a bare job path needs root_type: :job
+      # here too; without it the traversal would treat it as a chat file).
+      assert_equal({pt: 14, ct: 7, tt: 21, cct: 0, cwt: 0, rt: 0},
+                   Chat.provenance_token_totals(job, root_type: :job))
+    end
+  end
+
+  # Nothing outside the three glob families may be swept.
+  def test_files_outside_the_glob_families_are_not_swept
+    TmpFile.with_dir do |dir|
+      chat = write_chat(dir, 'saved.chat', ROOT_CHAT)
+
+      files = File.expand_path(chat + '.files')
+      resets = File.join(files, 'agent.chat.files', 'resets')
+      FileUtils.mkdir_p(resets)
+      File.write(File.join(resets, 'reset-1.chat'),
+                 "user: reset\nmeta: pt=9 ct=9 tt=18 inference_id=r1\nassistant: ok\n")
+      # Second-order .files tree that must stay invisible.
+      other = File.join(files, 'other.files', 'agent.chat')
+      FileUtils.mkdir_p(File.dirname(other))
+      File.write(other, "user: other\nmeta: pt=9 ct=9 tt=18 inference_id=o1\nassistant: ok\n")
+
+      assert_not_include visits_paths(chat), File.join(resets, 'reset-1.chat')
+      assert_not_include visits_paths(chat), other
+      assert_equal({pt: 2, ct: 1, tt: 3, cct: 0, cwt: 0, rt: 0},
+                   Chat.provenance_token_totals(chat))
+    end
+  end
+end