scout-ai 1.2.3 → 2.0.0

data/test/scout/llm/backends/test_relay.rb

@@ -2,9 +2,11 @@ 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 TestRelay < Test::Unit::TestCase
-  def test_ask
+  # Real scp/ssh relay version moved to
+  # test/integration/scout/llm/backends/test_relay.rb: LLM::Relay shells out
+  # to `scp` and has no client seam, so the unit copy stays disabled.
+  def _test_ask
     Scout::Config.set(:server, 'localhost', :relay)
     ppp LLM::Relay.ask 'Say hi', model: 'gemma2'
   end
 end
-

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

@@ -0,0 +1,131 @@
+# Reusable offline fixtures for agent_meta provenance tests (plan fixtures C,
+# D, E; also intended for the later token-collector rounds).  Everything runs
+# on TmpFile.with_dir directories plus persisted-style chat text; no providers.
+#
+# Helpers provided:
+#   write_chat(dir, name, text)                         -> chat file path
+#   meta_receipt(content)                               -> agent_meta entry Hash
+#   receipt_output(call_id, agent_meta, ...)            -> JSON envelope String
+#   receipt_chat_text(receipts, extra: nil)             -> persisted chat text
+#   plain_delegation_chat(job_path)                     -> persisted chat text
+#   make_job(dir, ref, dependencies:, logs:)            -> job path
+#   visit_signature(visits)                             -> comparable Array
+#   fixture_c(dir)                                      -> C/D layout paths
+#   truncated_receipt_chat(call_id, agent_meta)          -> fixture H text
+require 'fileutils'
+require 'json'
+
+module AgentMetaFixtures
+  # Write persisted-style chat text and return its absolute path.
+  def write_chat(dir, name, text)
+    path = File.expand_path(File.join(dir, name))
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, text)
+    path
+  end
+
+  # One agent_meta receipt entry with direct meta content, e.g.
+  # meta_receipt('pt=10 ct=4 tt=14 inference_id=w1') or
+  # meta_receipt('job=Worker/ask/Default_w').
+  def meta_receipt(content)
+    {role: 'meta', content: content}
+  end
+
+  # JSON payload of a function_call_output envelope carrying agent_meta.
+  def receipt_output(call_id, agent_meta, name: 'ask', content: 'child answer')
+    {name: name, content: content, id: call_id, agent_meta: agent_meta}.to_json
+  end
+
+  # Persisted chat text with one paired ask call per receipt entry.  Hash keys
+  # are call ids, values are the agent_meta payloads (Arrays, Strings, ...).
+  # `extra` lines are appended after the receipts (e.g. local meta lines).
+  #
+  # Message indexes produced by Chat.parse (single user turn, no leading
+  # empty user message since 49c0d20):
+  #   0 user, then per receipt: function_call, function_call_output.
+  def receipt_chat_text(receipts, extra: nil)
+    lines = ['user: Run the worker']
+    receipts.each do |call_id, agent_meta|
+      lines << 'function_call: ' + %({"name":"ask","arguments":{},"id":"#{call_id}"})
+      lines << 'function_call_output: ' + receipt_output(call_id, agent_meta)
+    end
+    lines.concat(Array(extra)) if extra
+    lines << 'assistant: done'
+    lines * "\n" + "\n"
+  end
+
+  # Persisted chat text delegating to `job_path` through an ordinary local
+  # `meta: job=` message (no receipts at all).
+  def plain_delegation_chat(job_path)
+    "user: Run the worker\nmeta: job=#{job_path}\nassistant: done\n"
+  end
+
+  # Create a job layout under `dir` for the relative reference `ref`
+  # (e.g. 'Worker/ask/Default_w'): the result file, a .info sidecar with
+  # `dependencies` (always written, matching scout-gear Step), and log chats
+  # written under `<job>.files/log/<name>` (Hash name -> chat text).  Returns
+  # the job path.
+  def make_job(dir, ref, result: 'answer', dependencies: [], logs: {})
+    path = File.expand_path(File.join(dir, ref))
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, result)
+    File.write(path + '.info', {dependencies: dependencies}.to_json)
+    logs.each do |name, text|
+      log_path = File.join(path + '.files', 'log', name)
+      FileUtils.mkdir_p(File.dirname(log_path))
+      File.write(log_path, text)
+    end
+    path
+  end
+
+  # Comparable signature of traverse_provenance visits:
+  # [kind, path, relation, first_visit].
+  def visit_signature(visits)
+    visits.collect do |kind, object, _parent_kind, _parent, relation, first|
+      [kind, object.respond_to?(:path) ? object.path.to_s : object.to_s, relation, first]
+    end
+  end
+
+  # Fixture C layout (plan fixtures C/D): a parent receipt points at a Worker
+  # job whose log chat has two direct metas (w1, w2), a nested receipt for a
+  # Critic job (with one direct meta c1), and a dependency job.  The parent
+  # chat also carries an ordinary local `meta: job=` reference to the Critic so
+  # both discovery paths coexist, plus one receipt-only direct meta (shadow).
+  # Returns [parent_chat_path, worker_job_path, critic_job_path, dep_job_path].
+  def fixture_c(dir)
+    critic = make_job(dir, 'Critic/ask/Default_c')
+    dep = make_job(dir, 'Dep/load/Default_1')
+
+    worker_log = receipt_chat_text(
+      {'wc1' => [meta_receipt('pt=30 ct=10 tt=40 inference_id=c1'),
+                 meta_receipt("job=#{critic}")]},
+      extra: ['meta: pt=100 ct=50 tt=150 inference_id=w1',
+              'meta: pt=20 ct=10 tt=30 inference_id=w2']
+    )
+    worker = make_job(dir, 'Worker/ask/Default_w',
+                      dependencies: [dep], logs: {'agent.chat' => worker_log})
+
+    parent = write_chat(dir, 'parent.chat',
+                        receipt_chat_text(
+                          {'p1' => [meta_receipt('pt=10 tt=12 inference_id=shadow'),
+                                    meta_receipt("job=#{worker}")]},
+                          extra: ["meta: job=#{critic}"]
+                        ))
+
+    [parent, worker, critic, dep]
+  end
+
+  # Fixture H: the output content is the standard truncation exception JSON
+  # (error: :truncated) exactly as LLM.process_calls serializes it, while the
+  # agent_meta receipts survive in the same envelope.
+  def truncated_receipt_chat(call_id, agent_meta, name: 'ask', characters: 90_000)
+    exception_msg = "Function #{name} #{call_id} was executed successfully, but it returned #{characters} characters, which is more than the maximum of 30000. To protect the model context window this result was not returned."
+    content = {exception: exception_msg, stack: ['a', 'b']}.to_json
+    payload = {name: name, content: content, id: call_id, error: :truncated,
+               agent_meta: agent_meta}.to_json
+    "user: Run\n" +
+      %({"name":"#{name}","arguments":{},"id":"#{call_id}"}).sub(/^/, 'function_call: ') + "\n" +
+      "function_call_output: #{payload}\n" +
+      "assistant: done\n"
+  end
+end

data/test/scout/llm/chat/process/test_meta.rb

@@ -0,0 +1,518 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/llm/chat'
+require 'scout/llm/backends/responses'
+
+class TestLLMUsageMeta < Test::Unit::TestCase
+  def setup
+    super
+    Chat::TOKEN_KEYS.each { |name| Thread.current["#{name}_s"] = 0 }
+  end
+
+  def response(prompt: nil, completion: nil, total: nil,
+               cached: nil, cache_write: nil, reasoning: nil)
+    usage = {}
+    usage['prompt_tokens'] = prompt unless prompt.nil?
+    usage['completion_tokens'] = completion unless completion.nil?
+    usage['total_tokens'] = total unless total.nil?
+    usage['prompt_tokens_details'] = {}
+    usage['prompt_tokens_details']['cached_tokens'] = cached unless cached.nil?
+    usage['input_tokens_details'] = {} if cache_write || cached
+    usage['input_tokens_details'] ||= {}
+    usage['input_tokens_details']['cache_write_tokens'] = cache_write unless cache_write.nil?
+    usage['completion_tokens_details'] = {}
+    usage['completion_tokens_details']['reasoning_tokens'] = reasoning unless reasoning.nil?
+    { 'usage' => usage }
+  end
+
+  def chat(text)
+    Chat.setup(LLM.messages(text))
+  end
+
+  def test_backend_records_direct_and_running_token_counts
+    first = LLM::Responses.update_meta(response(prompt: 2, completion: 3, total: 5))
+    second = LLM::Responses.update_meta(response(prompt: 7, total: 7), first)
+
+    assert_equal 7, second['pt']
+    assert_nil second['ct']
+    assert_equal 9, second['pt_s']
+    assert_equal 12, second['tt_s']
+    assert_equal 9, second['pt_c']
+    assert_equal 3, second['ct_c']
+    assert_equal 12, second['tt_c']
+    assert_nil second['usage_id']
+  end
+
+  def test_jobs_returns_all_projecting_jobs
+    conversation = chat <<-EOF
+user: First
+meta: job=WF/ask/first.chat
+assistant: First answer
+user: Second
+meta: job=WF/ask/second.chat
+assistant: Second answer
+    EOF
+
+    assert_equal %w[WF/ask/first.chat WF/ask/second.chat], conversation.jobs
+    assert_equal 'WF/ask/second.chat', conversation.meta[:job]
+  end
+
+  def test_message_identity_includes_non_meta_history
+    first = chat <<-EOF
+user: Question
+meta: tt=5
+assistant: Answer
+    EOF
+    same = chat <<-EOF
+user: Question
+assistant: Answer
+    EOF
+    different = chat <<-EOF
+user: Different question
+assistant: Answer
+    EOF
+
+    assert_equal first.message_index.last[:id], same.message_index.last[:id]
+    assert_not_equal first.message_index.last[:id], different.message_index.last[:id]
+  end
+
+  def test_consecutive_meta_leaves_the_first_segment_orphaned
+    conversation = chat <<-EOF
+user: Work
+meta: tt=2
+meta: job=WF/ask/work.chat
+assistant: Done
+    EOF
+
+    trace = Chat.trace_chats([conversation])
+    assert_equal 2, trace.length
+    assert trace.first[:orphan]
+    assert_equal 2, trace.first[:meta][:tt]
+    assert_equal 'WF/ask/work.chat', trace.last[:meta][:job]
+    assert_equal 1, trace.last[:messages].length
+  end
+
+  def test_final_meta_is_an_orphan_segment
+    conversation = chat <<-EOF
+user: Work
+meta: tt=2
+assistant: Tool call removed
+meta: tt=7
+    EOF
+
+    trace = Chat.trace_chats([conversation])
+    assert_equal 2, trace.length
+    assert_equal 7, trace.last[:meta][:tt]
+    assert trace.last[:orphan]
+    assert_empty trace.last[:messages]
+  end
+
+  def test_meta_covers_a_multi_tool_response_segment
+    conversation = chat <<-EOF
+user: Write two files
+meta: tt=1000
+function_call: {"name":"write","id":"one"}
+function_call_output: {"id":"one","content":"done one"}
+function_call: {"name":"write","id":"two"}
+function_call_output: {"id":"two","content":"done two"}
+assistant: Done
+user: Next request
+    EOF
+
+    trace = Chat.trace_chats([conversation])
+    assert_equal 1, trace.length
+    assert_equal 1000, trace.first[:meta][:tt]
+    assert_equal 5, trace.first[:messages].length
+    assert !trace.first[:orphan]
+  end
+
+  def test_project_keeps_inference_meta_inline_with_one_job_marker
+    response = [
+      { role: :meta, content: 'tt=2' },
+      { role: :function_call, content: '{"name":"write"}' },
+      { role: :function_call_output, content: '{"content":"done"}' },
+      { role: :meta, content: 'tt=7' },
+      { role: :assistant, content: 'Done' }
+    ]
+
+    projected = Chat.project('WF/ask/work.chat', response)
+    assert_equal %i[meta meta function_call function_call_output meta assistant], projected.collect { |m| m[:role] }
+
+    marker = Chat.parse_meta(projected.first[:content])
+    assert_equal 'WF/ask/work.chat', marker[:job]
+    assert Chat::TOKEN_KEYS.none? { |key| marker.include?(key) }
+
+    assert_equal 2, Chat.parse_meta(projected[1][:content])[:tt]
+    assert_equal :function_call, projected[2][:role], 'first inference meta stays adjacent to the call it produced'
+    assert_equal 7, Chat.parse_meta(projected[4][:content])[:tt]
+
+    trace = Chat.trace_chats([Chat.setup(projected)])
+    assert_equal 3, trace.length
+    assert trace.first[:orphan]
+    assert_equal [2, 7], trace[1..-1].collect { |entry| entry[:meta][:tt] }
+    assert_equal [2, 1], trace[1..-1].collect { |entry| entry[:messages].length }
+    assert trace[1..-1].none? { |entry| entry[:orphan] }
+
+    assert_equal 2, Chat.direct_entries([Chat.setup(projected)]).length
+    totals = Chat.token_totals([Chat.setup(projected)])
+    assert_equal 9, totals[:tt]
+  end
+
+  # Legacy chats carry no inference_id, so Chat.trace_indices falls back to the
+  # digest-based lineage id.  The lineage id is computed from the preceding
+  # messages, and a projected copy sits behind a leading `job=` marker, so the
+  # projected and original copies of the same legacy inference get DIFFERENT
+  # lineage ids and are both counted.  This is the documented legacy behaviour:
+  # precise deduplication requires inference_id, which every new inference has.
+  def test_project_legacy_meta_without_inference_id_is_not_deduplicated_across_chats
+    original = chat <<-EOF
+user: Work
+meta: pt=2 ct=1 tt=3
+assistant: Done
+    EOF
+
+    projected = Chat.project('WF/ask/work.chat', [
+      { role: :meta, content: 'pt=2 ct=1 tt=3' },
+      { role: :assistant, content: 'Done' }
+    ])
+
+    trace = Chat.trace_chats([Chat.setup(projected), original])
+    assert_equal 3, trace.length, 'job marker + two non-merged legacy lineages'
+    assert trace.all? { |entry| entry[:deduplication] == :legacy_lineage }
+    assert_not_equal trace.first[:lineage_id], trace.last[:lineage_id]
+
+    projected_totals = Chat.token_totals([Chat.setup(projected)])
+    assert_equal 3, projected_totals[:tt]
+    assert_equal 3, Chat.token_totals([original])[:tt]
+    assert_equal 6, Chat.token_totals([Chat.setup(projected), original])[:tt]
+  end
+
+  def test_project_consumption_path_does_not_double_count_a_saved_projection
+    TmpFile.with_file(nil, false, :persistent => true) do |file|
+      original = chat <<-EOF
+user: Work
+meta: inference_id=request-one pt=10 ct=5 tt=15
+assistant: Done
+      EOF
+
+      # chat_task: the job result chat is the projection; the log keeps the
+      # original metas.
+      projected = Chat.project('WF/ask/work.chat', [
+        { role: :meta, content: 'inference_id=request-one pt=10 ct=5 tt=15' },
+        { role: :assistant, content: 'Done' }
+      ])
+      Open.write(file, Chat.print(Chat.setup(projected)))
+
+      # LLM::Agent#ask consumption path: load the persisted job chat and
+      # re-project it before counting.
+      loaded = Chat.load(file)
+      reprojected = Chat.project('WF/ask/work.chat', loaded)
+
+      assert_equal Chat.token_totals([original]), Chat.token_totals([Chat.setup(reprojected), original])
+    end
+  end
+  def test_trace_keeps_distinct_segments_for_direct_and_projected_metadata
+    direct = chat <<-EOF
+user: Work
+meta: tt=7
+assistant: Done
+    EOF
+    projected = chat <<-EOF
+user: Work
+meta: job=WF/ask/work.chat
+assistant: Done
+    EOF
+
+    trace = Chat.trace_chats([projected, direct])
+    assert_equal 2, trace.length
+    assert_equal ['WF/ask/work.chat', nil], trace.collect { |entry| entry[:meta][:job] }
+    assert_equal [nil, 7], trace.collect { |entry| entry[:meta][:tt] }
+  end
+
+  def test_job_meta_does_not_reset_the_last_direct_chat_total
+    messages = LLM.messages <<-EOF
+user: Plan
+meta: pt=10 ct=2 tt=12 pt_c=10 ct_c=2 tt_c=12
+assistant: Plan complete
+meta: job=WF/ask/work.chat
+assistant: Work complete
+    EOF
+
+    current = Chat.meta(messages)
+    assert_equal 'WF/ask/work.chat', current[:job]
+    assert_equal 10, current[:pt_c]
+    assert_equal 2, current[:ct_c]
+    assert_equal 12, current[:tt_c]
+  end
+
+  # === Cache token accounting tests ===
+
+  def test_openai_responses_api_cache_tokens
+    resp = { 'usage' => {
+      'input_tokens' => 9,
+      'input_tokens_details' => { 'cache_write_tokens' => 5, 'cached_tokens' => 3 },
+      'output_tokens' => 174,
+      'output_tokens_details' => { 'reasoning_tokens' => 128 },
+      'total_tokens' => 183
+    } }
+    meta = LLM::Responses.update_meta(resp)
+
+    assert_equal 9, meta['pt']
+    assert_equal 174, meta['ct']
+    assert_equal 183, meta['tt']
+    assert_equal 3, meta['cct']
+    assert_equal 5, meta['cwt']
+    assert_equal 128, meta['rt']
+    # cumulative variants
+    assert_equal 9, meta['pt_c']
+    assert_equal 3, meta['cct_c']
+    assert_equal 5, meta['cwt_c']
+    assert_equal 128, meta['rt_c']
+    # session variants
+    assert_equal 9, meta['pt_s']
+    assert_equal 3, meta['cct_s']
+    assert_equal 5, meta['cwt_s']
+    assert_equal 128, meta['rt_s']
+  end
+
+  def test_glm_cache_tokens
+    resp = { 'usage' => {
+      'completion_tokens' => 97,
+      'completion_tokens_details' => { 'reasoning_tokens' => 92 },
+      'prompt_tokens' => 8,
+      'prompt_tokens_details' => { 'cached_tokens' => 4 },
+      'total_tokens' => 105
+    } }
+    meta = LLM::Responses.update_meta(resp)
+
+    assert_equal 8, meta['pt']
+    assert_equal 97, meta['ct']
+    assert_equal 105, meta['tt']
+    assert_equal 4, meta['cct']
+    assert_nil meta['cwt']
+    assert_equal 92, meta['rt']
+    # cumulative variants
+    assert_equal 4, meta['cct_c']
+    assert_equal 92, meta['rt_c']
+  end
+
+  def test_anthropic_flat_cache_fields
+    resp = { 'usage' => {
+      'prompt_tokens' => 100,
+      'completion_tokens' => 50,
+      'cache_read_input_tokens' => 80,
+      'cache_creation_input_tokens' => 20
+    } }
+    meta = LLM::Responses.update_meta(resp)
+
+    assert_equal 100, meta['pt']
+    assert_equal 50, meta['ct']
+    assert_equal 150, meta['tt']  # computed
+    assert_equal 80, meta['cct']
+    assert_equal 20, meta['cwt']
+    assert_nil meta['rt']
+  end
+
+  def test_cumulative_cache_tokens_across_requests
+    first = LLM::Responses.update_meta(
+      response(prompt: 10, completion: 5, total: 15, cached: 3, reasoning: 2)
+    )
+    second = LLM::Responses.update_meta(
+      response(prompt: 8, completion: 4, total: 12, cached: 6, reasoning: 1),
+      first
+    )
+
+    assert_equal 3, first['cct_c']
+    assert_equal 2, first['rt_c']
+    assert_equal 9, second['cct_c']   # 3 + 6
+    assert_equal 3, second['rt_c']    # 2 + 1
+    assert_equal 18, second['pt_c']   # 10 + 8
+  end
+
+  def test_normalize_usage_constants
+    assert_equal %w[pt ct tt cct cwt rt], Chat::TOKEN_KEYS
+    assert_equal %w[pt_c ct_c tt_c cct_c cwt_c rt_c], Chat::CUMULATIVE_KEYS
+  end
+
+  def test_normalize_usage_openai_chat_api
+    usage = { 'prompt_tokens' => 9, 'completion_tokens' => 174, 'total_tokens' => 183 }
+    result = Chat.normalize_usage(usage)
+    assert_equal 9, result['pt']
+    assert_equal 174, result['ct']
+    assert_equal 183, result['tt']
+    assert_nil result['cct']
+    assert_nil result['cwt']
+    assert_nil result['rt']
+  end
+
+  def test_normalize_usage_computes_total_when_missing
+    usage = { 'prompt_tokens' => 10, 'completion_tokens' => 20 }
+    result = Chat.normalize_usage(usage)
+    assert_equal 30, result['tt']
+  end
+
+  def test_normalize_usage_handles_nil
+    assert_equal({}, Chat.normalize_usage(nil))
+    assert_equal({}, Chat.normalize_usage({}))
+  end
+
+  def test_direct_entries_includes_cache_tokens
+    conversation = chat <<-EOF
+user: Work
+meta: pt=10 ct=5 tt=15 cct=3 rt=2
+assistant: Done
+    EOF
+
+    entries = Chat.direct_entries([conversation])
+    assert_equal 1, entries.length
+    assert_equal 3, entries.first[:meta][:cct]
+    assert_equal 2, entries.first[:meta][:rt]
+  end
+
+  def test_token_totals_aggregates_cache_fields
+    c1 = chat <<-EOF
+user: Work
+meta: pt=10 ct=5 tt=15 cct=3 rt=2
+assistant: Done
+    EOF
+    c2 = chat <<-EOF
+user: More work
+meta: pt=20 ct=10 tt=30 cct=7 rt=8
+assistant: Done again
+    EOF
+
+    totals = Chat.token_totals([c1, c2])
+    assert_equal 30, totals[:pt]
+    assert_equal 15, totals[:ct]
+    assert_equal 45, totals[:tt]
+    assert_equal 10, totals[:cct]  # 3 + 7
+    assert_equal 10, totals[:rt]   # 2 + 8
+  end
+
+  def test_print_tokens_shows_cache_fields
+    totals = { pt: 100, ct: 50, tt: 150, cct: 30, cwt: 10, rt: 20 }
+    output = Chat.print_tokens(totals)
+    assert output.include?('cached=30')
+    assert output.include?('cache_write=10')
+    assert output.include?('reasoning=20')
+  end
+
+  # === Quoted-value serialization/parsing tests ===
+
+  def test_serialize_meta_quotes_value_containing_equals
+    serialized = Chat.serialize_meta('reas' => 'thinking about a=b')
+    assert_equal 'reas="thinking about a=b"', serialized
+  end
+
+  def test_serialize_meta_does_not_quote_simple_values
+    serialized = Chat.serialize_meta('pt' => 10, 'job' => 'WF/ask/test.chat')
+    assert_equal 'pt=10 job=WF/ask/test.chat', serialized
+  end
+
+  def test_parse_meta_handles_quoted_value_with_equals
+    parsed = Chat.parse_meta('pt=10 reas="thinking about a=b"')
+    assert_equal 10, parsed[:pt]
+    assert_equal 'thinking about a=b', parsed[:reas]
+  end
+
+  def test_roundtrip_value_with_equals
+    meta = { 'pt' => 10, 'reas' => 'thinking about a=b and c=d', 'job' => 'WF/ask/test.chat' }
+    parsed = Chat.parse_meta(Chat.serialize_meta(meta))
+    assert_equal meta, parsed
+  end
+
+  def test_roundtrip_value_with_quotes_and_backslashes
+    meta = { 'reas' => 'He said "hello" and a=b\c', 'pt' => 5 }
+    parsed = Chat.parse_meta(Chat.serialize_meta(meta))
+    assert_equal meta, parsed
+  end
+
+  def test_backward_compat_unquoted_value_with_spaces
+    parsed = Chat.parse_meta('pt=10 ct=5 tt=15 reas=some text here')
+    assert_equal 10, parsed[:pt]
+    assert_equal 5, parsed[:ct]
+    assert_equal 15, parsed[:tt]
+    assert_equal 'some text here', parsed[:reas]
+  end
+
+  def test_backward_compat_job_and_reas_without_equals
+    parsed = Chat.parse_meta('job=WF/ask/test.chat reas=thinking about stuff')
+    assert_equal 'WF/ask/test.chat', parsed[:job]
+    assert_equal 'thinking about stuff', parsed[:reas]
+  end
+
+  def test_multiple_quoted_values_roundtrip
+    meta = { 'reas' => 'a=b', 'note' => 'c=d', 'pt' => 5 }
+    parsed = Chat.parse_meta(Chat.serialize_meta(meta))
+    assert_equal meta, parsed
+  end
+
+  def test_realistic_roundtrip
+    meta = { 'pt' => 100, 'ct' => 50, 'tt' => 150,
+             'reas' => 'The user asked for x=y, so I computed z=2',
+             'job' => 'WF/ask/test.chat' }
+    parsed = Chat.parse_meta(Chat.serialize_meta(meta))
+    assert_equal meta, parsed
+  end
+
+  # === Unescaped inner quotes in quoted values ===
+
+  def test_parse_meta_unescaped_quotes_inside_quoted_value
+    parsed = Chat.parse_meta(%q{pt=100 reas="Some text with ["/path/to/file"] inside."})
+    assert_equal 100, parsed[:pt]
+    assert_equal 'Some text with ["/path/to/file"] inside.', parsed[:reas]
+  end
+
+  def test_parse_meta_unescaped_quotes_and_keyval_patterns_inside_quoted
+    parsed = Chat.parse_meta(%q{pt=100 rt_c=10 reas="text total=48M prompt=47M end. accurate."})
+    assert_equal 100, parsed[:pt]
+    assert_equal 10, parsed[:rt_c]
+    assert_nil parsed[:total]
+    assert_nil parsed[:prompt]
+    assert_equal 'text total=48M prompt=47M end. accurate.', parsed[:reas]
+  end
+
+  def test_parse_meta_quoted_value_then_following_keys
+    parsed = Chat.parse_meta(%q{pt=100 reas="a=b" ct=200})
+    assert_equal 100, parsed[:pt]
+    assert_equal 'a=b', parsed[:reas]
+    assert_equal 200, parsed[:ct]
+  end
+  def test_backend_assigns_distinct_inference_ids
+    first = LLM::Responses.update_meta(response(prompt: 2, completion: 3, total: 5))
+    second = LLM::Responses.update_meta(response(prompt: 2, completion: 3, total: 5))
+    assert_not_nil first['inference_id']
+    assert_not_equal first['inference_id'], second['inference_id']
+  end
+
+  def test_inference_id_controls_trace_deduplication
+    copied = chat <<-EOF
+user: Work
+meta: inference_id=request-one pt=2 ct=3 tt=5
+assistant: Done
+    EOF
+    repeated = chat <<-EOF
+user: Work
+meta: inference_id=request-two pt=2 ct=3 tt=5
+assistant: Done
+    EOF
+
+    assert_equal 1, Chat.trace_chats([copied, copied]).length
+    trace = Chat.trace_chats([copied, repeated])
+    assert_equal 2, trace.length
+    assert_equal [:inference_id, :inference_id], trace.collect { |entry| entry[:deduplication] }
+  end
+
+  def test_source_aware_trace_preserves_addresses
+    conversation = chat <<-EOF
+user: Work
+meta: inference_id=request-one tt=5
+assistant: Done
+    EOF
+    entry = Chat.trace_chat_sources('/tmp/work.chat' => conversation).first
+    assert_equal ['/tmp/work.chat', 1], entry[:meta_address]
+    assert_equal [['/tmp/work.chat', 2]], entry[:message_addresses]
+  end
+
+end