@vellumai/assistant 0.8.4 → 0.8.5

package/src/memory/graph/extraction.ts

@@ -12,7 +12,6 @@ import { join } from "node:path";
 import { and, asc, desc, eq, gt } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../config/types.js";
-import { resolveGuardianPersona } from "../../prompts/persona-resolver.js";
 import { buildCoreIdentityContext } from "../../prompts/system-prompt.js";
 import {
   extractToolUse,
@@ -1026,10 +1025,7 @@ export async function runGraphExtraction(
   const candidateNodeIds = new Set(candidateNodes.map((n) => n.id));
 
   // 4. Build prompt
-  const userPersona = resolveGuardianPersona();
-  const identityContext = buildCoreIdentityContext({
-    userPersona: userPersona ?? undefined,
-  });
+  const identityContext = buildCoreIdentityContext();
 
   const activeSet = opts?.activeContextNodeIds
     ? new Set(opts.activeContextNodeIds)

package/src/memory/graph/graph-search.ts

@@ -9,7 +9,11 @@ import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
 import { asString } from "../job-utils.js";
-import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  type MemoryJob,
+} from "../jobs-store.js";
 import { isQdrantBreakerOpen } from "../qdrant-circuit-breaker.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import {
@@ -238,6 +242,7 @@ export async function embedGraphNodeJob(
  * Enqueue an embedding job for a graph node (async, for live conversations).
  */
 export function enqueueGraphNodeEmbed(nodeId: string): void {
+  if (!isMemoryEnabled()) return;
   enqueueMemoryJob("embed_graph_node", { nodeId });
 }
 
@@ -282,5 +287,6 @@ export async function embedGraphTriggerJob(
  * Enqueue a trigger embedding job.
  */
 export function enqueueGraphTriggerEmbed(triggerId: string): void {
+  if (!isMemoryEnabled()) return;
   enqueueMemoryJob("graph_trigger_embed", { triggerId });
 }

package/src/memory/indexer.ts

@@ -11,7 +11,11 @@ import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
-import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  upsertDebouncedJob,
+} from "./jobs-store.js";
 import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueue.js";
 import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import {
@@ -139,20 +143,22 @@ export async function indexMessageNow(
 
       if (existing?.contentHash === hash) {
         skippedEmbedJobs++;
-      } else {
+      } else if (isMemoryEnabled()) {
         enqueueMemoryJob("embed_segment", { segmentId }, Date.now(), tx);
       }
     }
 
     // Enqueue embed_attachment jobs for image content blocks when the
     // embedding provider supports multimodal (Gemini only).
-    for (const block of mediaBlocks) {
-      enqueueMemoryJob(
-        "embed_attachment",
-        { messageId: input.messageId, blockIndex: block.index },
-        Date.now(),
-        tx,
-      );
+    if (isMemoryEnabled()) {
+      for (const block of mediaBlocks) {
+        enqueueMemoryJob(
+          "embed_attachment",
+          { messageId: input.messageId, blockIndex: block.index },
+          Date.now(),
+          tx,
+        );
+      }
     }
   });
 
@@ -221,14 +227,16 @@ export async function indexMessageNow(
         extractRunAfter = graphBatchFired
           ? Date.now()
           : Date.now() + idleTimeoutMs;
-        upsertDebouncedJob(
-          "graph_extract",
-          {
-            conversationId: input.conversationId,
-            scopeId: input.scopeId ?? "default",
-          },
-          extractRunAfter,
-        );
+        if (isMemoryEnabled()) {
+          upsertDebouncedJob(
+            "graph_extract",
+            {
+              conversationId: input.conversationId,
+              scopeId: input.scopeId ?? "default",
+            },
+            extractRunAfter,
+          );
+        }
       } else {
         extractRunAfter = Date.now() + idleTimeoutMs;
       }
@@ -309,7 +317,7 @@ export async function indexMessageNow(
     // jobs-worker.ts. Debounced on the same idle timeout — no threshold
     // trigger needed since summaries compress the whole conversation, not
     // incremental batches.
-    if (v2Config == null) {
+    if (v2Config == null && isMemoryEnabled()) {
       upsertDebouncedJob(
         "build_conversation_summary",
         { conversationId: input.conversationId },
@@ -372,10 +380,12 @@ export async function indexMessageNow(
 }
 
 export function enqueueBackfillJob(force = false): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("backfill", { force });
 }
 
 export function enqueueRebuildIndexJob(): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("rebuild_index", {});
 }
 

package/src/memory/job-handlers/cleanup.ts

@@ -1,8 +1,9 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { runAsyncSqlite } from "../db-async-query.js";
 import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
-import { rawAll, rawChanges, rawRun } from "../raw-query.js";
+import { rawAll, rawRun } from "../raw-query.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -13,11 +14,18 @@ const PRUNE_LOG_BATCH_LIMIT = 1000;
  * Delete LLM request/response logs older than the configured retention period.
  * Processes in batches to avoid long DB locks and excessive WAL growth.
  * Re-enqueues itself if more rows remain.
+ *
+ * The DELETE is dispatched through `runAsyncSqlite` so it runs in a
+ * sqlite3 subprocess (when available) and does not block the daemon's
+ * main event loop. The two bind parameters (`cutoffMs`, batch limit)
+ * are integers — they're inlined directly into the SQL after a
+ * `Math.floor` + `Number.isFinite` guard so there is no string
+ * interpolation surface.
  */
-export function pruneOldLlmRequestLogsJob(
+export async function pruneOldLlmRequestLogsJob(
   job: MemoryJob,
   config: AssistantConfig,
-): void {
+): Promise<void> {
   const rawRetention = job.payload.retentionMs;
   const retentionMs =
     rawRetention === null
@@ -31,14 +39,29 @@ export function pruneOldLlmRequestLogsJob(
   // null means "keep forever" — skip pruning entirely
   if (retentionMs === null || retentionMs === undefined) return;
 
-  const cutoffMs = Date.now() - retentionMs;
-
-  rawRun(
-    `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ? LIMIT ?)`,
-    cutoffMs,
-    PRUNE_LOG_BATCH_LIMIT,
+  const cutoffMs = Math.floor(Date.now() - retentionMs);
+  if (!Number.isFinite(cutoffMs)) return;
+
+  // Inline the cutoff and batch limit (both integers, both validated)
+  // and chain `SELECT changes()` so we can read the row count from the
+  // subprocess's stdout. The sqlite3 CLI prints `changes()` as a bare
+  // integer on its own line in default output mode; the in-process
+  // fallback backend in `db-async-query.ts` synthesizes the same shape
+  // by capturing `changes()` atomically after `exec()`. Both backends
+  // end up on the parser path below.
+  const result = await runAsyncSqlite(
+    `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
+SELECT changes();`,
   );
-  const deleted = rawChanges();
+  if (!result.ok) {
+    log.warn(
+      { error: result.error, backend: result.backend },
+      "pruneOldLlmRequestLogsJob: DELETE failed",
+    );
+    return;
+  }
+
+  const deleted = parseDeletedCount(result.stdout);
 
   if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
     enqueueMemoryJob("prune_old_llm_request_logs", { retentionMs });
@@ -58,11 +81,14 @@ export function pruneOldLlmRequestLogsJob(
  * Delete trace events older than the configured retention period.
  * Processes in batches to avoid long DB locks and excessive WAL growth.
  * Re-enqueues itself if more rows remain.
+ *
+ * Same async dispatch + integer inlining shape as
+ * {@link pruneOldLlmRequestLogsJob}.
  */
-export function pruneOldTraceEventsJob(
+export async function pruneOldTraceEventsJob(
   job: MemoryJob,
   config: AssistantConfig,
-): void {
+): Promise<void> {
   const rawRetention = job.payload.retentionDays;
   const retentionDays =
     typeof rawRetention === "number" &&
@@ -74,14 +100,22 @@ export function pruneOldTraceEventsJob(
   // 0 means disabled
   if (retentionDays === 0) return;
 
-  const cutoffMs = Date.now() - retentionDays * 86_400_000;
+  const cutoffMs = Math.floor(Date.now() - retentionDays * 86_400_000);
+  if (!Number.isFinite(cutoffMs)) return;
 
-  rawRun(
-    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ? LIMIT ?)`,
-    cutoffMs,
-    PRUNE_LOG_BATCH_LIMIT,
+  const result = await runAsyncSqlite(
+    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
+SELECT changes();`,
   );
-  const deleted = rawChanges();
+  if (!result.ok) {
+    log.warn(
+      { error: result.error, backend: result.backend },
+      "pruneOldTraceEventsJob: DELETE failed",
+    );
+    return;
+  }
+
+  const deleted = parseDeletedCount(result.stdout);
 
   if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
     enqueueMemoryJob("prune_old_trace_events", { retentionDays });
@@ -97,6 +131,30 @@ export function pruneOldTraceEventsJob(
   );
 }
 
+/**
+ * Parse the `SELECT changes()` result emitted by the sqlite3 CLI after
+ * the prune DELETE. Returns 0 if stdout is missing or unparseable —
+ * callers treat that the same as "no rows deleted, do not re-enqueue".
+ *
+ * In the CLI's default output mode the value is a bare integer on its
+ * own line. We tolerate trailing whitespace/blank lines and pick the
+ * last numeric line so any incidental output (warnings, etc.) above it
+ * doesn't throw the parse off.
+ */
+export function _parseDeletedCount(stdout: string | undefined): number {
+  return parseDeletedCount(stdout);
+}
+
+function parseDeletedCount(stdout: string | undefined): number {
+  if (!stdout) return 0;
+  const lines = stdout.split(/\r?\n/).filter((s) => s.trim().length > 0);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const n = parseInt(lines[i].trim(), 10);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return 0;
+}
+
 /**
  * Delete conversations that have had no activity (updatedAt) for longer than
  * the configured retention period. Processes in batches so a single job doesn't

package/src/memory/job-handlers/conversation-starters.ts

@@ -9,7 +9,6 @@ import { and, desc, eq, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { loadSkillCatalog } from "../../config/skills.js";
-import { resolveGuardianPersona } from "../../prompts/persona-resolver.js";
 import { buildCoreIdentityContext } from "../../prompts/system-prompt.js";
 import {
   createTimeout,
@@ -200,9 +199,7 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
 
   // Truncate identity context to prevent oversized prompts when SOUL.md /
   // IDENTITY.md / users/<slug>.md are large.
-  const rawIdentityContext = buildCoreIdentityContext({
-    userPersona: resolveGuardianPersona(),
-  });
+  const rawIdentityContext = buildCoreIdentityContext();
   const identityContext = rawIdentityContext
     ? truncate(rawIdentityContext, 2000, "\n…[truncated]")
     : null;

package/src/memory/jobs/embed-pkb-file.ts

@@ -1,6 +1,10 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { asString } from "../job-utils.js";
-import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  type MemoryJob,
+} from "../jobs-store.js";
 import { indexPkbFile } from "../pkb/pkb-index.js";
 
 /**
@@ -46,6 +50,7 @@ export async function embedPkbFileJob(
  * Enqueue an `embed_pkb_file` job (async, fire-and-forget).
  */
 export function enqueuePkbIndexJob(input: EmbedPkbFileJobInput): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("embed_pkb_file", {
     pkbRoot: input.pkbRoot,
     absPath: input.absPath,

package/src/memory/jobs-store.ts

@@ -1,6 +1,7 @@
 import { and, asc, eq, inArray, lte, notInArray, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { getConfig } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
 import { truncate } from "../util/truncate.js";
 import { getDb } from "./db-connection.js";
@@ -43,6 +44,9 @@ export type MemoryJobType =
   | "memory_v2_migrate"
   | "memory_v2_reembed"
   | "memory_v2_activation_recompute"
+  | "memory_v3_consolidate"
+  | "memory_v3_index_maintenance"
+  | "memory_v3_edge_learning"
   | "memory_retrospective";
 
 export const EMBED_JOB_TYPES: MemoryJobType[] = [
@@ -66,12 +70,22 @@ export const SLOW_LLM_JOB_TYPES: MemoryJobType[] = [
   "generate_conversation_starters",
   "memory_v2_sweep",
   "memory_v2_consolidate",
+  "memory_v3_consolidate",
   "memory_v2_migrate",
   "memory_retrospective",
   "backfill",
   "graph_bootstrap",
 ];
 
+/** Returns `false` only when `config.memory.enabled` is explicitly `false`; defaults to `true` on missing config or load errors. */
+export function isMemoryEnabled(): boolean {
+  try {
+    return getConfig().memory?.enabled !== false;
+  } catch {
+    return true;
+  }
+}
+
 export interface MemoryJob<T = Record<string, unknown>> {
   id: string;
   type: MemoryJobType;

package/src/memory/jobs-worker.ts

@@ -83,6 +83,9 @@ import {
   memoryV2ConsolidateJob,
 } from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
+import { memoryV3ConsolidateJob } from "./v3/consolidation-job.js";
+import { memoryV3EdgeLearningJob } from "./v3/edge-learning-job.js";
+import { memoryV3IndexMaintenanceJob } from "./v3/maintenance.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -259,7 +262,7 @@ export async function runMemoryJobsOnce(
       maybeEnqueueScheduledCleanupJobs(config);
     }
     maybeEnqueueGraphMaintenanceJobs(config);
-    maybeRunDbMaintenance();
+    await maybeRunDbMaintenance();
     return 0;
   }
 
@@ -313,7 +316,7 @@ export async function runMemoryJobsOnce(
     maybeEnqueueScheduledCleanupJobs(config);
   }
   maybeEnqueueGraphMaintenanceJobs(config);
-  maybeRunDbMaintenance();
+  await maybeRunDbMaintenance();
   return slowProcessed + fastProcessed + embedProcessed;
 }
 
@@ -524,10 +527,10 @@ async function processJob(
       pruneOldConversationsJob(job, config);
       return;
     case "prune_old_llm_request_logs":
-      pruneOldLlmRequestLogsJob(job, config);
+      await pruneOldLlmRequestLogsJob(job, config);
       return;
     case "prune_old_trace_events":
-      pruneOldTraceEventsJob(job, config);
+      await pruneOldTraceEventsJob(job, config);
       return;
     case "build_conversation_summary":
       // Stale rows enqueued before v2 was enabled must not consume the
@@ -603,6 +606,16 @@ async function processJob(
     case "memory_v2_consolidate":
       await memoryV2ConsolidateJob(job, config);
       return;
+    case "memory_v3_consolidate":
+      await memoryV3ConsolidateJob(job, config);
+      return;
+    case "memory_v3_index_maintenance":
+      await memoryV3IndexMaintenanceJob(job);
+      return;
+    case "memory_v3_edge_learning":
+      // Fast lane: bounded DB work (decay + reinforce + read), no LLM.
+      memoryV3EdgeLearningJob(job);
+      return;
     case "memory_v2_migrate":
       await memoryV2MigrateJob(job, config);
       return;
@@ -681,17 +694,28 @@ export const GRAPH_MAINTENANCE_CHECKPOINTS = {
   patternScan: "graph_maintenance:pattern_scan:last_run",
   narrative: "graph_maintenance:narrative:last_run",
   memoryV2Consolidate: "memory_v2_consolidate_last_run",
+  memoryV3Consolidate: "memory_v3_consolidate_last_run",
 } as const;
 
 /**
  * Enqueue periodic graph maintenance jobs.
  *
  * Mutually exclusive between v1 and v2:
- *   - v2 active (`memory.v2.enabled` on) → only `memory_v2_consolidate` is
- *     scheduled.
+ *   - v2 active (`memory.v2.enabled` on) → only one buffer-drainer is
+ *     scheduled (see below).
  *   - v2 inactive → the four v1 entries (decay, consolidate, pattern_scan,
  *     narrative) are scheduled instead.
  *
+ * **Buffer-drainer retarget (v2 vs v3).** The `memory/buffer.md` is shared, so
+ * exactly one consolidator may own the drain at a time. When
+ * `memory.v3.write.enabled` is on, the v3 consolidator (`memory_v3_consolidate`)
+ * is scheduled INSTEAD of `memory_v2_consolidate` — same shared buffer +
+ * standing-context files, additionally authored into the v3 tree. When the v3
+ * write flag is off (default) the v2 consolidator stays the sole drainer,
+ * unchanged. The retarget is a clean conditional, fully reversible via the flag.
+ * Concept pages stay the shared canonical store, so the v2 router keeps working
+ * off pages v3 writes regardless of which consolidator ran.
+ *
  * Read/write paths route to v2 when the flag is on, so v1 graph data goes
  * unread; running v1 maintenance alongside v2 is wasted compute and LLM
  * spend. The v1 code path remains live so flipping the flag back to off
@@ -708,20 +732,29 @@ export function maybeEnqueueGraphMaintenanceJobs(
   nowMs = Date.now(),
 ): void {
   const v2Active = config.memory.v2.enabled;
+  const v3WriteActive = config.memory.v3.write.enabled;
+
+  // The single buffer-drainer entry for the v2-active branch: v3 when the v3
+  // write flag owns the drain, v2 otherwise. Same shared buffer either way.
+  const consolidateEntry = v3WriteActive
+    ? {
+        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV3Consolidate,
+        intervalMs: config.memory.v3.write.consolidateIntervalMs,
+        jobType: "memory_v3_consolidate" as MemoryJobType,
+      }
+    : {
+        key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
+        intervalMs:
+          config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
+        jobType: "memory_v2_consolidate" as MemoryJobType,
+      };
 
   const schedule: Array<{
     key: string;
     intervalMs: number;
     jobType: MemoryJobType;
   }> = v2Active
-    ? [
-        {
-          key: GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
-          intervalMs:
-            config.memory.v2.consolidation_interval_hours * 60 * 60 * 1000,
-          jobType: "memory_v2_consolidate",
-        },
-      ]
+    ? [consolidateEntry]
     : [
         {
           key: GRAPH_MAINTENANCE_CHECKPOINTS.decay,
@@ -745,25 +778,25 @@ export function maybeEnqueueGraphMaintenanceJobs(
         },
       ];
 
-  let enqueuedV2 = false;
+  let enqueuedConsolidate = false;
   for (const { key, intervalMs, jobType } of schedule) {
     const lastRun = parseInt(getMemoryCheckpoint(key) ?? "0", 10);
     if (nowMs - lastRun >= intervalMs) {
       enqueueMemoryJob(jobType, {});
       setMemoryCheckpoint(key, String(nowMs));
-      if (jobType === "memory_v2_consolidate") enqueuedV2 = true;
+      if (jobType === consolidateEntry.jobType) enqueuedConsolidate = true;
     }
   }
 
+  // Size-based trigger: when the shared buffer crosses the configured line
+  // count, drain it now rather than waiting out the interval. Retargets to the
+  // same consolidator the interval branch above selected.
   const maxLines = config.memory.v2.consolidation_max_buffer_lines;
-  if (v2Active && !enqueuedV2 && maxLines !== null) {
+  if (v2Active && !enqueuedConsolidate && maxLines !== null) {
     const bufferPath = join(getWorkspaceDir(), "memory", "buffer.md");
     if (countBufferLines(bufferPath) >= maxLines) {
-      enqueueMemoryJob("memory_v2_consolidate", {});
-      setMemoryCheckpoint(
-        GRAPH_MAINTENANCE_CHECKPOINTS.memoryV2Consolidate,
-        String(nowMs),
-      );
+      enqueueMemoryJob(consolidateEntry.jobType, {});
+      setMemoryCheckpoint(consolidateEntry.key, String(nowMs));
     }
   }
 }

package/src/memory/llm-request-log-source-clickhouse.ts

@@ -58,6 +58,16 @@ interface ClickHouseRow {
   response_payload: string;
   created_at: string;
   agent_loop_exit_reason: string;
+  /**
+   * Mirrors `llm_request_logs.call_site` from the SQLite source. Added
+   * to the CH `default.llm_request_logs` table via ALTER TABLE (matching
+   * the `agent_loop_exit_reason` precedent — see
+   * `memory/concepts/objects/clickhouse-mirror.md`).
+   *
+   * CH columns are `DEFAULT ''` rather than Nullable, so empty-string
+   * means "not set" — `toLogRow` maps that back to NULL on the JS side.
+   */
+  call_site: string;
 }
 
 /** Injectable fetch override for tests. Defaults to globalThis.fetch. */
@@ -125,7 +135,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         request_payload,
         response_payload,
         toUnixTimestamp64Milli(created_at) AS created_at,
-        agent_loop_exit_reason
+        agent_loop_exit_reason,
+        call_site
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND id = {log_id:String}
@@ -171,6 +182,33 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     );
   }
 
+  async getRequestLogsByConversationId(
+    conversationId: string,
+  ): Promise<LogRow[]> {
+    const aid = await this.assistantId();
+    const sql = `SELECT
+        id,
+        conversation_id,
+        message_id,
+        provider,
+        request_payload,
+        response_payload,
+        toUnixTimestamp64Milli(created_at) AS created_at,
+        agent_loop_exit_reason,
+        call_site
+      FROM ${this.tableRef()}
+      WHERE assistant_id = {assistant_id:String}
+        AND conversation_id = {conversation_id:String}
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1 BY id
+      FORMAT JSONEachRow`;
+    const rows = await this.exec(sql, {
+      assistant_id: aid,
+      conversation_id: conversationId,
+    });
+    return rows.map((r) => this.toLogRow(r));
+  }
+
   private async selectByMessageIds(ids: string[]): Promise<LogRow[]> {
     if (ids.length === 0) return [];
     const aid = await this.assistantId();
@@ -197,7 +235,8 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
         request_payload,
         response_payload,
         toUnixTimestamp64Milli(created_at) AS created_at,
-        agent_loop_exit_reason
+        agent_loop_exit_reason,
+        call_site
       FROM ${this.tableRef()}
       WHERE assistant_id = {assistant_id:String}
         AND message_id IN (${placeholders.join(",")})
@@ -288,6 +327,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       createdAt: Number(row.created_at),
       agentLoopExitReason:
         row.agent_loop_exit_reason === "" ? null : row.agent_loop_exit_reason,
+      callSite: row.call_site === "" ? null : row.call_site,
     };
   }
 

package/src/memory/llm-request-log-source-local.ts

@@ -11,6 +11,7 @@
 import type { LlmRequestLogSource } from "./llm-request-log-source.js";
 import {
   getRequestLogById,
+  getRequestLogsByConversationId,
   getRequestLogsByMessageId,
   type LogRow,
 } from "./llm-request-log-store.js";
@@ -23,4 +24,10 @@ export class LocalLlmRequestLogSource implements LlmRequestLogSource {
   async getRequestLogsByMessageId(messageId: string): Promise<LogRow[]> {
     return getRequestLogsByMessageId(messageId);
   }
+
+  async getRequestLogsByConversationId(
+    conversationId: string,
+  ): Promise<LogRow[]> {
+    return getRequestLogsByConversationId(conversationId);
+  }
 }

package/src/memory/llm-request-log-source.ts

@@ -1,8 +1,8 @@
 /**
  * Pluggable read source for LLM request logs.
  *
- * The Inspector view at `GET /v1/messages/:id/llm-context` (and the
- * single-log payload route) historically read directly from the local
+ * The Inspector views at `GET /v1/messages/:id/llm-context` and
+ * `GET /v1/conversations/llm-context` (plus the single-log payload route) historically read directly from the local
  * SQLite `llm_request_logs` table via `llm-request-log-store.ts`. The
  * source-of-truth remains local, but the *read path* is now configurable
  * via `llmRequestLogs.readSource` in workspace config.
@@ -31,6 +31,13 @@ export interface LlmRequestLogSource {
    * INSERT-only against the source-of-truth).
    */
   getRequestLogsByMessageId(messageId: string): Promise<LogRow[]>;
+
+  /**
+   * Fetch every LLM request log associated with the given conversation.
+   * This is the conversation-wide inspector read path: linked, unlinked,
+   * and orphaned logs are all included because they share conversation_id.
+   */
+  getRequestLogsByConversationId(conversationId: string): Promise<LogRow[]>;
 }
 
 /**