feat(dashboard): agentic conversation tracking — v4, decoupled + storage-architecture concern resolved (#10263)

* feat(responses): virtualize previous_response_id continuation regardless of upstream support

OmniRoute now exposes OpenAI-compatible previous_response_id/store
continuation to clients unconditionally, even when the selected upstream
provider has no native Responses-API state support. Reconstruction happens
server-side in handleChatImplementation, before any downstream validation
or provider translation: OmniRoute resolves the response id back to the
full input/output it previously produced, prepends it to the client's
delta, and forwards the full reconstructed history upstream exactly as it
does today. Client<->OmniRoute traffic shrinks to the new delta only;
OmniRoute<->provider traffic is unchanged.

Storage reuses the existing call-log pipeline artifact (already gated by
call_log_pipeline_enabled, already retained/cleaned up by the existing
call-log lifecycle) instead of duplicating conversation content into a
second store -- only a lightweight call_logs.response_id index is new.
Every lookup is scoped by api_key_id so one client can never resolve
another client's stored conversation, and any unresolvable/missing/
size-limit-omitted state fails closed with OpenAI's own
previous_response_not_found contract.

Stacked on feat/openai-responses-store-toggle (#10121).

* feat(dashboard): agentic conversation tracking with live transcript view

Every agentic chat request now gets a conversation id (X-ConversationId
response header). OmniRoute detects when a follow-up request continues the
same conversation via fingerprint + bounded prefix-hash matching, with a
strict-growth invariant to prevent false merges between independent
single-shot requests that happen to share identical opening content.
Continuation detection excludes the system message from the identity
anchor, since real coding-agent CLIs commonly regenerate it every request
with live context (timestamp, cwd, git status) — without this, that
volatility alone broke every continuation check against real traffic.

- `/dashboard/logs`: new toggleable Conversation column.
- `/dashboard/logs/timeline`: requests sharing a conversation id share a
  timeline lane, connected by an arrow, with a configurable lane-reuse
  window.
- Request detail panel: new Full Conversation transcript above the raw SSE
  event stream — Markdown rendering, per-turn timestamps, turn-relative
  view, click-any-turn navigation, live auto-refresh building the
  transcript in real time from the in-flight SSE chunk buffer while a
  request is still streaming, auto-scroll-to-bottom as the live turn grows.
- New `/dashboard/conversations` page listing conversations with 2+ turns,
  no-forking model (an edited/duplicated mid-history turn mints its own
  independent conversation instead of merging), pagination, duplicate-
  anchor fix.
- Configurable auto-refresh intervals on both the timeline and
  conversations list pages.
- Responses API tool-call gap fix: turnsFromOpenAiMessages only handled
  role-based Chat Completions messages, so bare {type:"function_call"} /
  {type:"function_call_output"} / {type:"reasoning"} items (real Responses
  API traffic) silently vanished from the Conversation Context panel.
- truncateForLog now counts input[] (Responses API), not just messages[]
  (Chat Completions), so a truncated /v1/responses request still shows a
  placeholder instead of nothing.
- RequestTimeline.tsx now reads the same debugEnabled/emailsVisible
  settings RequestLoggerV2.tsx already used, instead of hardcoding both
  false — the timeline view never showed SSE/stream-chunk events or
  respected email-masking, regardless of the actual setting.

Migrations 147/148 (agentic_conversations, conversation_turn_nodes) — 135
and 136 are now taken upstream; 143-145 are documented KNOWN_GAPS, so this
uses the next free slot past upstream's current highest.

Test plan:
- npm run typecheck:core — clean
- npm run lint — clean
- node --import tsx/esm scripts/check/check-migration-numbering.mjs — OK, 0 collisions
- 109 unit tests across the conversation-tracking, migration-renumber, and
  dashboard-wiring surface — 0 failures

* refactor(dashboard): reuse call-log artifacts for conversation transcript content

conversation_turn_nodes no longer stores turn text/tool-call content
(text_preview/block_kind/tool_name) -- it's identity-only now (id/parent/
content_hash), matching agentic_conversations' existing lightweight-index
shape. Every node's originating request is already fully captured by the
call-log pipeline artifact its last_correlation_id points at, so the
/dashboard/conversations tree view resolves each node's actual display
content on demand from there (open-sse/services/conversationTurnContent.ts),
re-running the same extractCanonicalTurns/hashTurnContent the write path
used and matching by content_hash, instead of duplicating conversation
content into a second store under a separate retention/gating policy. This
also drops the old 8000-char text_preview truncation entirely -- resolved
content is always full and untruncated.

The frontend contract is unchanged (tree API still returns
{textPreview, blockKind, toolName} per node), so the dashboard UI itself
(page.tsx, RequestLoggerDetail/RequestTimeline, sidebar, i18n) needed no
changes.

Renumbered the cherry-picked 147/148 migrations to 153/154 -- 147 now
collides with 147_api_keys_model_access_mode.sql, which landed on
release/v3.8.50 after this work was originally built.

Also includes a standalone, unrelated fix carried along from this rebase:
close isProviderModelHidden's missing function-body brace in
modelSelectModalHelpers.ts (separately landed as #10206).

Stacked on feat/responses-previous-response-id-virtualization (#3), which
is itself stacked on feat/openai-responses-store-toggle (#10121).

* fix(dashboard): resync conversation list on open so the live-text poll starts immediately

openConversation() seeded activeConversation (and therefore activeCallLogId,
which gates the live-partial-text poll effect) from whatever row snapshot the
list's own fixed-interval poll last produced. A conversation opened right
after a reply started streaming -- after that tick, before the next -- had
activeCallLogId still null, so the live-text poll never started; only a
subsequent background list-poll resync (already existed) picked it up,
which is why closing and reopening the same conversation "just worked".

loadConversations() is now a shared callback so openConversation can force
one immediately on open instead of waiting on pollSeconds.

Live-verified against omniroute-dev: opening a conversation mid-stream now
shows live reasoning on the first open.

* style: prettier formatting for conversationTurnContent.test.ts

* fix(db): close migration numbering gap left by decoupling from #3/#10262

153/154 (originally 154/155) were chosen back when this branch stacked on
top of the previous_response_id migration (153_call_logs_response_id.sql).
Decoupling removed that migration from this branch's history, leaving an
unused 153 slot that check-migration-numbering.test.ts correctly flags as
a gap.

* refactor(dashboard): split RequestTimeline/RequestLoggerDetail under the 1000-line file-size cap

Both files exceeded check-file-size's new-file cap after this PR's own
additions (RequestTimeline 1048, RequestLoggerDetail 1163). Extracted pure
non-component logic (types, constants, allocateLanes and its helpers) out
of RequestTimeline.tsx into RequestTimeline.utils.ts, and the two
self-contained presentational sub-components (PayloadSection,
ConversationContextSection + its private helper) out of
RequestLoggerDetail.tsx into RequestLoggerDetail.sections.tsx. No behavior
change; existing external imports (default exports, allocateLanes,
TimelineLog, CONVERSATION_LANE_REUSE_STORAGE_KEY) still resolve from the
original file paths.

* fix(db): renumber agentic-conversation migrations to clear 153 collision + sync migration-count docs

The refresh-merge of release/v3.8.50 exposed that the feature's three
migrations collided at slot 153 with the base's radar_local_model_state
(153) and its own call_logs_response_id. Migration runner enforces unique
numeric prefixes -> every DB init threw, red-ing Vitest, all Unit shards and
the DB-backed quality gates. Renumber the feature's pair to
155_agentic_conversations / 156_conversation_turn_nodes and move
call_logs_response_id to 154 (keeps 153_radar base-owned, preserves
agentic-before-turn_nodes ordering). Update SQL headers and the
154/156 references in feature code + tests.

Migration count is now 151 (was 148 stale in README/AGENTS/llm.txt) — sync
the doc counts to clear the docs-accuracy gate.

Co-authored-by: diegosouzapw <diegosouza.pw@gmail.com>

* fix(ui): drop unused CONVERSATION_LANE_REUSE_STORAGE_KEY re-export from RequestTimeline

Knip 6.32 (baseline 415) flags the public re-export of
CONVERSATION_LANE_REUSE_STORAGE_KEY from RequestTimeline.tsx as dead: no
external consumer imports it through that re-export (it is imported and
used directly from RequestTimeline.utils.ts inside the component). Removed
the unused re-export; the internal import stays. DEAD_TOTAL 416 -> 415,
back to the frozen baseline.

Co-authored-by: diegosouzapw <diegosouza.pw@gmail.com>

* fix(agentic-conversations): guard resolveConversationId, drop dead whole-chain export

- Wrap resolveConversationId() in try/catch in chat.ts, matching the
  defensive pattern used by every other best-effort side call nearby, so a
  DB hiccup in conversation tracking can't turn a working chat request into
  a hard failure.
- Remove getConversationTurnTree: knip's project scope excludes tests/**,
  so an export used only by tests can never register as used there. Swap
  its 8 test call sites to the paginated getConversationTurnPage (already
  the dashboard's canonical query) with a generous limit, collapsing to one
  query path instead of keeping a second whole-chain export alive solely
  for test convenience.
- Regenerate i18n llm.txt mirrors from root (pre-existing drift on this
  branch, unrelated to the above, caught by the docs-sync pre-commit gate).

Addresses PR review feedback.

* fix(i18n): close requestLogger conversation-column gap, fix domain-modules count drift

- fr.json, vi.json were missing requestLogger.columns.conversation (added
  in the conversation-tracking feature), failing i18n-vi-completeness.test.ts.
- docs/i18n/*/llm.txt mirrors still said 117 domain-specific files after an
  earlier rebase fixed the migration count but missed this companion number,
  failing check-docs-sync.mjs across all 42 locales.

Co-authored-by: diegosouzapw <8016841+diegosouzapw@users.noreply.github.com>

* fix(docs): restore PROXY_LOG_INCLUDE_IPS env/doc entries (env-doc-sync red)

.env.example and docs/reference/ENVIRONMENT.md were both missing the
PROXY_LOG_INCLUDE_IPS entry that src/lib/proxyLogger.ts already reads
(confirmed present at this branch's merge-base too, so this predates
the conversation-tracking work and is unrelated to it) -- the entry
was added on release/v3.8.50 after this branch's last sync and this
branch never picked it up. That gap red-lines
tests/unit/check-env-doc-sync.test.ts and
tests/unit/issue-7793-env-doc-sync-repro.test.ts (Unit Tests
fast-path 2/4 in CI). Restore both entries verbatim from the current
release/v3.8.50 tip -- no feature-code change.

Co-authored-by: diegosouzapw <8016841+diegosouzapw@users.noreply.github.com>

---------

Co-authored-by: hartmark <hartmark@users.noreply.github.com>
Co-authored-by: diegosouzapw <diegosouza.pw@gmail.com>
Co-authored-by: diegosouzapw <8016841+diegosouzapw@users.noreply.github.com>

src/app/api/conversations/[id]/tree/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
+import { getConversationTurnPage } from "@/lib/db/agenticConversations";
+import { resolveTurnDisplayContent } from "@omniroute/open-sse/services/conversationTurnContent.ts";
+
+export const dynamic = "force-dynamic";
+
+// Number(null) is 0, not NaN — so naively doing Number(searchParams.get(x))
+// turns an ABSENT query param into a real 0 instead of "not provided",
+// which made beforeSeq/afterSeq always look present (0 != null) and forced
+// the query into the afterSeq branch (uncapped, all rows) on every request,
+// even ones with no beforeSeq/afterSeq at all.
+export function parseSeqParam(raw: string | null): number | undefined {
+  if (raw === null || raw === "") return undefined;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+// Every OmniRoute conversation is a single straight line (see
+// conversationTracker.ts's 2026-08-06 redesign — an edited/duplicated turn
+// mints its own independent conversation instead of forking this one), so
+// this always returns a flat, chronological page — never a tree — capped
+// at `limit` (default 20) since a real OpenClaw conversation can run to
+// hundreds of turns. `beforeSeq`/`afterSeq` page backward/forward from a
+// previously-returned node's `seq`.
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> | { id: string } }
+) {
+  const authError = await requireManagementAuth(req);
+  if (authError) return authError;
+
+  try {
+    const { id } = await params;
+    if (!id) return NextResponse.json({ error: "Missing id" }, { status: 400 });
+
+    const { searchParams } = new URL(req.url);
+    const limitParam = parseSeqParam(searchParams.get("limit"));
+
+    const { nodes, hasMore } = getConversationTurnPage(id, {
+      limit: limitParam != null && limitParam > 0 ? limitParam : undefined,
+      beforeSeq: parseSeqParam(searchParams.get("beforeSeq")),
+      afterSeq: parseSeqParam(searchParams.get("afterSeq")),
+    });
+
+    // Nodes store identity only (see migration 154) — resolve each node's
+    // actual text/tool-call shape from the call-log artifact its
+    // correlation id points at. A node whose artifact is gone (purged,
+    // never captured because detailed logging was off at the time, or
+    // size-limit-omitted) falls back to an empty text placeholder rather
+    // than failing the whole page — the chain/identity data is still valid
+    // even when the display content underneath it aged out.
+    const displayContent = resolveTurnDisplayContent(nodes);
+
+    return NextResponse.json({
+      nodes: nodes.map((n) => {
+        const content = displayContent.get(n.contentHash);
+        return {
+          seq: n.seq,
+          id: n.id,
+          parentId: n.parentId,
+          role: n.role,
+          textPreview: content?.textPreview ?? "",
+          blockKind: content?.blockKind ?? "text",
+          toolName: content?.toolName ?? null,
+          firstSeenAt: n.firstSeenAt,
+        };
+      }),
+      hasMore,
+    });
+  } catch (err) {
+    console.error("[API ERROR] /api/conversations/[id]/tree failed:", err);
+    return NextResponse.json({ error: "Failed to fetch conversation" }, { status: 500 });
+  }
+}

src/app/api/conversations/route.ts

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
+import { listMultiTurnConversations } from "@/lib/db/agenticConversations";
+import { getPendingById } from "@/lib/usage/usageHistory";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: Request) {
+  const authError = await requireManagementAuth(req);
+  if (authError) return authError;
+
+  try {
+    const { searchParams } = new URL(req.url);
+    const limit = Number(searchParams.get("limit") ?? "50");
+    const offset = Number(searchParams.get("offset") ?? "0");
+
+    const { rows, total } = listMultiTurnConversations({
+      limit: Number.isFinite(limit) ? limit : undefined,
+      offset: Number.isFinite(offset) ? offset : undefined,
+    });
+
+    // A pending (still-streaming) request's sessionTag is the conversation's
+    // own id (agentic_conversations.id === call_logs.session_tag) — cross
+    // reference so the list can show "in progress" without a separate poll.
+    // `call_logs` only gets its row on completion (src/lib/usage/callLogs.ts's
+    // INSERT needs duration/status/tokens, none of which exist yet), so
+    // `lastCallLogId` from listMultiTurnConversations always lags one request
+    // behind while a reply is still streaming — it can't be used to fetch the
+    // in-flight response. Surface the pending request's own id separately so
+    // the conversation panel can poll /api/logs/[id] for it directly (same
+    // live-partial-text path RequestLoggerDetail already uses).
+    const activeCallLogIdByConversation = new Map<string, string>();
+    for (const pending of getPendingById().values()) {
+      if (pending.sessionTag) activeCallLogIdByConversation.set(pending.sessionTag, pending.id);
+    }
+    const conversations = rows.map((row) => ({
+      ...row,
+      isActive: activeCallLogIdByConversation.has(row.id),
+      activeCallLogId: activeCallLogIdByConversation.get(row.id) ?? null,
+    }));
+
+    return NextResponse.json({ conversations, total });
+  } catch (err) {
+    console.error("[API ERROR] /api/conversations failed:", err);
+    return NextResponse.json({ error: "Failed to fetch conversations" }, { status: 500 });
+  }
+}

src/app/api/logs/[id]/route.ts

@@ -3,6 +3,58 @@ import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
 import { getCallLogById } from "@/lib/usageDb";
 import { getCompletedDetails, getPendingById } from "@/lib/usage/usageHistory";
 
+// Each logged chunk-array element is one raw network read, timestamp-prefixed
+// for the debug display — NOT one complete SSE `data:` line. A single JSON
+// value (e.g. a `reasoning_content` delta) routinely splits across two or
+// more elements, so parsing each element in isolation intermittently fails
+// JSON.parse and silently drops that piece, leaving gaps that read as
+// garbled/scrambled text once the survivors are concatenated. Strip each
+// element's `[HH:MM:SS.mmm] ` prefix and concatenate the WHOLE array into one
+// continuous string first, so a value split across elements rejoins correctly
+// before it's parsed.
+const CHUNK_LOG_TIMESTAMP_PREFIX = /^\[\d{2}:\d{2}:\d{2}\.\d{3}\]\s*/;
+
+// Best-effort parse of the accumulated SSE `data:` lines captured live for an
+// in-flight request (open-sse/utils/requestLogger.ts's appendConvertedChunk
+// mutates these arrays in place as chunks arrive, so this reflects "the reply
+// so far", not just the final text) into the concatenated assistant text.
+export function extractPartialAssistantText(
+  streamChunks: { provider?: string[]; openai?: string[]; client?: string[] } | null | undefined
+): string {
+  if (!streamChunks) return "";
+  for (const chunkArr of [streamChunks.client, streamChunks.provider, streamChunks.openai]) {
+    if (!Array.isArray(chunkArr) || chunkArr.length === 0) continue;
+    let text = "";
+    let reasoning = "";
+    const joined = chunkArr
+      .map((raw) => String(raw).replace(CHUNK_LOG_TIMESTAMP_PREFIX, ""))
+      .join("");
+    for (const line of joined.split("\n")) {
+      const idx = line.indexOf("data:");
+      if (idx === -1) continue;
+      const jsonStr = line.slice(idx + 5).trim();
+      if (!jsonStr || jsonStr === "[DONE]") continue;
+      try {
+        const parsed = JSON.parse(jsonStr);
+        const delta = parsed?.choices?.[0]?.delta ?? parsed?.choices?.[0]?.message;
+        if (typeof delta?.content === "string") text += delta.content;
+        if (typeof delta?.reasoning_content === "string") reasoning += delta.reasoning_content;
+      } catch {
+        // partial/malformed chunk line (e.g. cut mid-write) — skip it
+      }
+    }
+    if (text) return text;
+    // Reasoning-model providers (e.g. DeepSeek-R1-style) stream
+    // `reasoning_content` before any visible `content` — with only the
+    // content check above, the live panel had nothing new to show for the
+    // whole reasoning phase and looked frozen even while the SSE event
+    // stream kept visibly ticking. Surface the reasoning text meanwhile so
+    // the panel keeps progressing.
+    if (reasoning) return `_Thinking…_\n\n${reasoning}`;
+  }
+  return "";
+}
+
 export const dynamic = "force-dynamic";
 
 export async function GET(
@@ -43,6 +95,10 @@ export async function GET(
           active: true,
           pipelinePayloads,
           hasPipelineDetails: true,
+          // The still-generating reply so far — the request's own context
+          // panel renders this alongside its (already-complete) requestBody
+          // instead of waiting for the stream to finish.
+          partialAssistantText: extractPartialAssistantText(pendingRequestDetail.streamChunks),
         };
 
         return NextResponse.json(activeEntry);
@@ -102,6 +158,7 @@ export async function GET(
     }
 
     if (!persistedRequest) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
     return NextResponse.json(persistedRequest);
   } catch (err) {
     console.error("[API ERROR] /api/logs/[id] failed:", err);