feat(llm,timeline): cross-turn reasoning state replay for gpt-5/o3/o4

[ngoclam9415]

Summary

Persist raw reasoning items from the OpenAI Responses API in TimelineEntry.metadata. On the next turn, splice them back into input[] when provider:model:endpoint matches, so gpt-5+ retains structured reasoning state across turns instead of re-deriving it from flattened assistant text.

Stacks on #9 — diff includes its 5 commits (Responses API plumbing, env-driven effort, agent reasoning persistence). When #9 merges, rebase this PR.

What changes

Layer	Change
LLMResponse	+ reasoning_items: list[dict] | None and response_id
LLMMessage	+ carriers reasoning_items / reasoning_fingerprint / response_id
OpenAICompatibleProvider	Captures raw items via input-side-only field whitelist; opts in to include=["reasoning.encrypted_content"] with sticky 400 fallback; endpoint_hash + fingerprint properties
_chat_via_responses	Stale-id / item-shape rejection fallback (one-shot strip-and-retry); never silently kills turns
_convert_to_responses_input	Splices raw items before assistant message when fingerprint matches; LLM_REASONING_REPLAY=0 kill switch (default ON)
Timeline.to_llm_messages	Propagates entry metadata onto assistant messages; merge-skip when items present (preserves provenance)
STARAgent._record_think_results	Writes {reasoning_items, fingerprint, response_id} into AGENT_THOUGHTS.metadata
NativeMessage.to_llm_message	Propagates metadata fields — closes the CompressedTimeline gap
compression_engine	Summary metadata composed explicitly so reasoning state never leaks past the boundary

Architecture

Capture (Phase 1):
  Responses API output[] → reasoning_items list[dict] (whitelisted fields)
                        → encrypted_content opportunistic when ZDR-enabled

Persist (Phase 2):
  AGENT_THOUGHTS.metadata = {reasoning_items, fingerprint, response_id}
  fingerprint = "{provider}:{model_family}:{sha256(endpoint_url)[:8]}"

Replay (Phase 3):
  Timeline → LLMMessage carriers → openai_messages dict carrier keys
          → splice on fingerprint match → Responses API input[]
  Order: [reasoning items] → [assistant w/ tool_calls] → [function_call_output]

Compression (Phase 4):
  Compressed-away entries discarded entirely; summary metadata composed
  fresh — reasoning items never survive the boundary.

Counter-intuitive finding (live verify)

Replay does NOT save tokens in steady-state. When prior reasoning state is present, gpt-5 reasons every turn (~200-300 tokens per accumulated item). Without replay, the model nondeterministically skips reasoning, sometimes saving tokens but losing continuity.

Real benefit:

• Reasoning continuity — model carries structured state, not lossy summary text
• Reasoning consistency — every turn reasons when state is provided
• Cost benefit materializes only with ZDR/encrypted_content (encrypted blob is smaller than equivalent summary text)

Records: plans/260507-1829-reasoning-state-replay/reports/

Critical bug found and fixed during verify

model_dump() was leaking output-only fields (status, content) into replayed input[]. Azure rejected with unknown_parameter: input[N].status, silently killing all subsequent turns. Now whitelisted to {type, id, summary, encrypted_content} + stale-id rejection fallback for graceful degradation.

Operator runbook

# Disable replay globally (fall back to flat-text history)
LLM_REASONING_REPLAY=0

# Verify a session has captured items
cat .dana/dana_agent/<id>/sessions/<sid>/timeline.json \
  | jq '.entries[] | select(.type=="agent_thoughts") | .metadata.fingerprint'

# Expected log line on replay
# reasoning replay items=N fingerprint=azure:gpt-5:abcd1234

Resume from disk (one ergonomics gotcha): DanaCodingAgent doesn't auto-resume sessions. To continue a persisted conversation in a fresh process:

import json
agent = DanaCodingAgent(agent_id="my-agent", llm_provider="azure", model="gpt-5.2")
data = json.loads(open(".dana/dana_agent/my-agent/sessions/<sid>/timeline.json").read())
agent._timeline.load_from_entries(entries=data["entries"])
# Replay fires automatically on subsequent calls

Tests

333/333 unit tests green:

• tests/unit/llm/test_reasoning_items_capture.py (14) — capture path, encrypted_content presence/absence, include-flag fallback, endpoint hash, fingerprint format
• tests/unit/core/agent/test_thinking_metadata_persistence.py (11) — _build_thinking_metadata, _provider_fingerprint defensive lookup, both _record_think_results branches, JSON round-trip, isolation
• tests/unit/llm/test_reasoning_replay.py (17) — splice match/mismatch, kill switch (incl. falsy values), tool-call ordering, multi-turn, carrier stripping, Timeline.to_llm_messages propagation, merge-skip
• tests/unit/test_reasoning_compression_policy.py (7) — NativeMessage propagation, CompressedTimeline end-to-end, compressed-away entries vanish, kept entries retain items, no-keep edge case
• tests/unit/test_reasoning_replay_disk_resume.py (4) — legacy + native format disk-resume, cross-provider mismatch, kill switch on resumed timeline

Live verify (Azure gpt-5.2):

• scripts/verify-reasoning-replay.py — 4-turn × 2-run (ON/OFF), splice fires confirmed, kill switch confirmed
• scripts/verify-disk-resume-replay.py — fresh process loads 3-item timeline, replays all 3 to input[]

Test plan

• Local: uv run pytest tests/unit -q → all green
• Live in-process: uv run python scripts/verify-reasoning-replay.py → 4 hard PASS
• Live disk-resume: uv run python scripts/verify-disk-resume-replay.py → 3 hard PASS
• Smoke gpt-5.2 long session in dev env, then flip LLM_REASONING_REPLAY=0 and confirm flat-text path still works

Worth flagging

1. Token cost grows ~200-300 per accumulated item with replay. Net benefit is reasoning continuity, not cost. Flip to ZDR for cost win.
2. DanaCodingAgent doesn't auto-resume from disk. Pre-existing behavior, not introduced here, but consumers of replay will hit it. Future ergonomics PR could add resume_from_session_id.
3. Long sessions grow timeline.json since reasoning items persist alongside summary text. Compression drops them from the summary boundary, but steady-state size still increases. Monitor .dana/**/timeline.json size in prod.