@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/runtime/routes/__tests__/theme-routes.test.ts

@@ -0,0 +1,66 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { WorkspaceThemeReadResult } from "../../../theme/workspace-theme.js";
+import { ROUTES } from "../theme-routes.js";
+
+function getThemeHandler() {
+  const route = ROUTES.find((r) => r.operationId === "workspace_theme_get");
+  if (!route) {
+    throw new Error("workspace_theme_get route not registered");
+  }
+  expect(route.endpoint).toBe("workspace/theme");
+  expect(route.method).toBe("GET");
+  return route.handler as () => WorkspaceThemeReadResult;
+}
+
+describe("GET /workspace/theme", () => {
+  let workspaceDir: string;
+  let prevWorkspaceDir: string | undefined;
+
+  beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "theme-route-test-"));
+    prevWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  });
+
+  afterEach(() => {
+    if (prevWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = prevWorkspaceDir;
+    }
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  test("returns source none when no theme file exists", () => {
+    const result = getThemeHandler()();
+    expect(result).toEqual({ theme: null, source: "none", issues: [] });
+  });
+
+  test("returns the validated theme when the file is valid", () => {
+    mkdirSync(join(workspaceDir, "ui"), { recursive: true });
+    writeFileSync(
+      join(workspaceDir, "ui", "theme.json"),
+      JSON.stringify({ version: 1, base: "velvet" }),
+    );
+    const result = getThemeHandler()();
+    expect(result.source).toBe("workspace");
+    expect(result.theme).toEqual({ version: 1, base: "velvet" });
+    expect(result.issues).toEqual([]);
+  });
+
+  test("returns null theme plus issues when the file is rejected", () => {
+    mkdirSync(join(workspaceDir, "ui"), { recursive: true });
+    writeFileSync(
+      join(workspaceDir, "ui", "theme.json"),
+      JSON.stringify({ version: 1, tokens: { accent: "not-a-color" } }),
+    );
+    const result = getThemeHandler()();
+    expect(result.source).toBe("invalid");
+    expect(result.theme).toBeNull();
+    expect(result.issues.length).toBeGreaterThan(0);
+  });
+});

package/src/runtime/routes/__tests__/tts-routes.test.ts

@@ -4,13 +4,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Module mocks — must appear before any imports of the modules under test
 // ---------------------------------------------------------------------------
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // -- Config mock -----------------------------------------------------------
 
 const mockConfig = {

package/src/runtime/routes/__tests__/user-route-dispatcher.test.ts

@@ -1,18 +1,10 @@
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks
 // ---------------------------------------------------------------------------
-
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 import { getWorkspaceRoutesDir } from "../../../util/platform.js";
 import { AssistantEventHub } from "../../assistant-event-hub.js";
 import type { UserRouteContext } from "../user-route-dispatcher.js";

package/src/runtime/routes/__tests__/wake-conversation-routes.test.ts

@@ -8,13 +8,6 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 interface CapturedWake {
   conversationId: string;
   hint: string;

package/src/runtime/routes/acp-routes.ts

@@ -19,6 +19,8 @@ import {
 } from "../../acp/session-manager.js";
 import type { AcpSessionState } from "../../acp/types.js";
 import { getConfig } from "../../config/loader.js";
+import type { ServerMessage } from "../../daemon/message-protocol.js";
+import { createCanonicalRequestForConfirmation } from "../../permissions/confirmation-canonical-request.js";
 import type { UserDecision } from "../../permissions/types.js";
 import { getDb } from "../../persistence/db-connection.js";
 import { rawChanges } from "../../persistence/raw-query.js";
@@ -155,21 +157,25 @@ function awaitRouteApproval(args: {
         settle(decision, decision === "allow" ? "approved" : "rejected"),
     });
 
-    broadcastMessage(
-      {
-        type: "confirmation_request",
-        requestId,
-        toolName,
-        input,
-        riskLevel: "high",
-        executionTarget: "host",
-        allowlistOptions: [],
-        scopeOptions: [],
-        conversationId,
-        persistentDecisionsAllowed: false,
-      },
+    const confirmationMsg: ServerMessage & {
+      type: "confirmation_request";
+    } = {
+      type: "confirmation_request",
+      requestId,
+      toolName,
+      input,
+      riskLevel: "high",
+      executionTarget: "host",
+      allowlistOptions: [],
+      scopeOptions: [],
       conversationId,
-    );
+      persistentDecisionsAllowed: false,
+    };
+    broadcastMessage(confirmationMsg, conversationId);
+
+    // Promote the confirmation to a canonical guardian request so channel
+    // guardian decisions (reactions, buttons, text) can resolve it.
+    void createCanonicalRequestForConfirmation(confirmationMsg, conversationId);
   });
 }
 

package/src/runtime/routes/approval-routes.ts

@@ -13,9 +13,13 @@ import { findConversation } from "../../daemon/conversation-registry.js";
 import type {
   SecretDelivery,
   SecretPromptResult,
-} from "../../permissions/secret-prompter.js";
+} from "../../permissions/secret-prompt-types.js";
 import type { UserDecision } from "../../permissions/types.js";
 import { getConversationByKey } from "../../persistence/conversation-key-store.js";
+import {
+  hasInteriorWhitespace,
+  normalizeSecretValue,
+} from "../../security/secret-normalize.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import * as pendingInteractions from "../pending-interactions.js";
@@ -127,7 +131,22 @@ function handleSecret({ body }: RouteHandlerArgs) {
   // undefined) so the request settles cleanly rather than 400-ing and stranding
   // the pending interaction.
   const isCancel = delivery === "none";
-  const value = isCancel ? undefined : (body?.value as string | undefined);
+  const rawValue = isCancel ? undefined : (body?.value as string | undefined);
+
+  const value =
+    rawValue === undefined ? undefined : normalizeSecretValue(rawValue);
+  if (value !== undefined && value !== rawValue) {
+    log.info(
+      { hadEdgeWhitespace: true },
+      "Trimmed edge whitespace from submitted secret value",
+    );
+  }
+  if (value !== undefined && hasInteriorWhitespace(value)) {
+    log.warn(
+      { interiorWhitespace: true },
+      "Submitted secret contains interior whitespace — expected for multi-line secrets (e.g. PEM keys), unexpected for API tokens",
+    );
+  }
 
   if (
     delivery !== undefined &&

package/src/runtime/routes/canned-message-complete.ts

@@ -0,0 +1,82 @@
+import { createAssistantMessage } from "../../agent/message-types.js";
+import type { ServerMessage } from "../../daemon/message-protocol.js";
+import {
+  addMessage,
+  recordConversationPersistedSeq,
+} from "../../persistence/conversation-crud.js";
+import type { Message } from "../../providers/types.js";
+import { broadcastMessage } from "../assistant-event-hub.js";
+import { getCurrentSeq } from "../assistant-stream-state.js";
+import { publishConversationMessagesChanged } from "../sync/resource-sync-events.js";
+
+// ---------------------------------------------------------------------------
+// Temporary fix — remove when #31994 lands
+// ---------------------------------------------------------------------------
+//
+// The canned-response paths (canned greeting, inline approval reply, slash
+// command, /compact, /clean, summarize-up-to) bypass the agent loop and so
+// don't pick up the per-turn anchor id allocated in
+// conversation-agent-loop.ts. Their `message_complete` events therefore went
+// out without `messageId`, and the macOS client filter at
+// ChatActionHandler.swift:507 dropped those events when they raced past the
+// 50 ms streaming-buffer flush — leaving `isSending` stuck for the full 60 s
+// watchdog window.
+//
+// Centralized so the patch surface is one helper + N one-line callers rather
+// than N duplicated literals. When #31994 lands and stamps these sites with
+// `state.assistantTurnId` directly, grep for `emitCannedMessageComplete` to
+// find every call site and inline-then-delete.
+export function emitCannedMessageComplete(
+  send: (msg: ServerMessage) => void,
+  conversationId: string,
+  persistedAssistantId: string,
+): void {
+  send({
+    type: "message_complete",
+    conversationId,
+    messageId: persistedAssistantId,
+  });
+}
+
+/**
+ * Persist a canned assistant "card" — a pre-composed reply that bypasses the
+ * agent loop (the /compact, /clean, and summarize-up-to result cards) — and
+ * emit the turn-style events clients expect for it: the full text as a single
+ * `assistant_text_delta`, `message_complete` with the persisted assistant id,
+ * the persisted-seq anchor advance (so a stale /messages reseed cannot erase
+ * the card), and the messages-changed sync invalidation.
+ *
+ * Callers that interleave other broadcasts between the persist and the
+ * delta (the canned greeting and unknown-slash-command paths defer their
+ * broadcasts behind the HTTP response with a `user_message_echo` in
+ * between) cannot use this helper without reordering their events.
+ */
+export async function persistCannedAssistantCard(opts: {
+  conversation: { getMessages(): Message[] };
+  conversationId: string;
+  text: string;
+  metadata: Record<string, unknown>;
+  originClientId?: string;
+}): Promise<void> {
+  const { conversation, conversationId, text, metadata, originClientId } = opts;
+  const assistantMsg = createAssistantMessage(text);
+  const persistedAssistant = await addMessage(
+    conversationId,
+    "assistant",
+    JSON.stringify(assistantMsg.content),
+    { metadata },
+  );
+  conversation.getMessages().push(assistantMsg);
+  broadcastMessage({
+    type: "assistant_text_delta",
+    text,
+    conversationId,
+  });
+  emitCannedMessageComplete(
+    broadcastMessage,
+    conversationId,
+    persistedAssistant.id,
+  );
+  recordConversationPersistedSeq(conversationId, getCurrentSeq());
+  publishConversationMessagesChanged(conversationId, originClientId);
+}

package/src/runtime/routes/channel-metadata.ts

@@ -0,0 +1,49 @@
+import {
+  extractImageSourcePaths,
+  provenanceFromTrustContext,
+} from "../../persistence/conversation-crud.js";
+
+/**
+ * Assemble the standard channel metadata object for message persistence.
+ *
+ * Combines provenance (trust context), channel/interface routing, and
+ * optional per-message fields (automated flag, image source paths) into the
+ * Record that `addMessage` stores in the `metadata` column.
+ *
+ * `sourceInterface` may be undefined for routes that don't receive an
+ * interface id from the client (e.g. the summarize-up-to management route);
+ * the interface keys are omitted in that case.
+ */
+export function buildChannelMetadata(
+  sourceChannel: string,
+  sourceInterface: string | undefined,
+  opts?: {
+    trustContext?: Parameters<typeof provenanceFromTrustContext>[0];
+    provenanceOverride?: Record<string, unknown>;
+    automated?: boolean;
+    attachments?: ReadonlyArray<{
+      filename: string;
+      mimeType: string;
+      filePath?: string;
+    }>;
+  },
+): Record<string, unknown> {
+  const provenance =
+    opts?.provenanceOverride ?? provenanceFromTrustContext(opts?.trustContext);
+  const imageSourcePaths = opts?.attachments
+    ? extractImageSourcePaths(opts.attachments)
+    : undefined;
+  return {
+    ...provenance,
+    userMessageChannel: sourceChannel,
+    assistantMessageChannel: sourceChannel,
+    ...(sourceInterface !== undefined
+      ? {
+          userMessageInterface: sourceInterface,
+          assistantMessageInterface: sourceInterface,
+        }
+      : {}),
+    ...(opts?.automated ? { automated: true } : {}),
+    ...(imageSourcePaths ? { imageSourcePaths } : {}),
+  };
+}

package/src/runtime/routes/contact-routes.ts

@@ -9,6 +9,7 @@
  */
 
 import {
+  INVITES_IPC_METHODS,
   RedeemInviteByTokenRequestSchema,
   RedeemVoiceInviteRequestSchema,
 } from "@vellumai/gateway-client";
@@ -21,6 +22,14 @@ import {
 import { IpcCallError } from "@vellumai/gateway-client/ipc-client";
 import { z } from "zod";
 
+import {
+  createInvite,
+  type InviteWire,
+  listInvites,
+  redeemInviteByToken,
+  redeemInviteByVoiceCode,
+  revokeInvite,
+} from "../../channels/gateway-invites.js";
 import {
   listContacts,
   mergeContacts,
@@ -78,7 +87,7 @@ function withGuardianNameOverride<
 
 /**
  * Stamp `role` from the gateway guardian id set on DAEMON-NATIVE reads, whose
- * `role` is the neutral `"contact"` default (search / contactType-filtered).
+ * local contact shape carries no role (search / contactType-filtered).
  * Fail-soft: empty set → everyone is `"contact"`.
  *
  * NOT applied to gateway-relayed reads (`contacts_list_rich`/`_get_rich`),
@@ -86,10 +95,10 @@ function withGuardianNameOverride<
  * stale/empty 30s id-set cache DOWNGRADE a freshly-rebound guardian to
  * `"contact"` during a rebind.
  */
-function withGatewayRole<T extends { id: string; role: string }>(
+function withGatewayRole<T extends { id: string }>(
   contact: T,
   guardianIds: ReadonlySet<string>,
-): T {
+): T & { role: ContactRole } {
   return {
     ...contact,
     role: guardianIds.has(contact.id) ? "guardian" : "contact",
@@ -109,6 +118,13 @@ function withChannelCompat<T extends { channels: { address: string }[] }>(
   };
 }
 
+interface PreparableContact {
+  id: string;
+  displayName: string;
+  contactType?: string | null;
+  channels: { address: string }[];
+}
+
 /** Compose the response transforms, then apply the guardian display-name
  * override (keyed off the role that's correct for this path) and the channel
  * compat field. Also coerces nullable gateway-sourced fields to their DB
@@ -119,25 +135,27 @@ function withChannelCompat<T extends { channels: { address: string }[] }>(
  *   - omitted (gateway-relayed reads): TRUST the gateway-sourced `role` already
  *     on the `ContactRead`. Never re-derive — a stale/empty id-set cache must
  *     not downgrade a relayed guardian to `"contact"`.
- *   - provided (daemon-native reads): role is the neutral `"contact"` default,
+ *   - provided (daemon-native reads): the local contact shape carries no role,
  *     so derive it from the gateway guardian id set.
  */
-function prepareContactResponse<
-  T extends {
-    id: string;
-    role: string;
-    displayName: string;
-    contactType?: string | null;
-    channels: { address: string }[];
-  },
->(contact: T, guardianIds?: ReadonlySet<string>): T {
+function prepareContactResponse<T extends PreparableContact & { role: string }>(
+  contact: T,
+): T;
+function prepareContactResponse<T extends PreparableContact>(
+  contact: T,
+  guardianIds: ReadonlySet<string>,
+): T & { role: ContactRole };
+function prepareContactResponse(
+  contact: PreparableContact & { role?: string },
+  guardianIds?: ReadonlySet<string>,
+) {
   const coerced =
     contact.contactType == null
-      ? { ...contact, contactType: "human" as T["contactType"] }
+      ? { ...contact, contactType: "human" }
       : contact;
   const withRole = guardianIds
     ? withGatewayRole(coerced, guardianIds)
-    : coerced;
+    : (coerced as PreparableContact & { role: string });
   return withChannelCompat(withGuardianNameOverride(withRole));
 }
 
@@ -411,21 +429,20 @@ export async function handleGetContact(contactId: string) {
 // ---------------------------------------------------------------------------
 
 // The gateway owns the canonical invite lifecycle: mint, list, revoke, and
-// redemption. These CLI handlers relay via `ipcCallPersistent`; the daemon
-// then layers the presentation fields (share link, LLM guardian instruction,
-// channel handle) onto the gateway's one-time create payload.
+// redemption. These handlers relay via the typed `channels/gateway-invites`
+// client (schema-validated responses); the daemon then layers the
+// presentation fields (share link, LLM guardian instruction, channel handle)
+// onto the gateway's one-time create payload.
 
 export async function handleListInvites({
   queryParams = {},
 }: RouteHandlerArgs) {
   try {
-    const result = (await ipcCallPersistent("invites_list", {
-      ...(queryParams.sourceChannel
-        ? { sourceChannel: queryParams.sourceChannel }
-        : {}),
-      ...(queryParams.status ? { status: queryParams.status } : {}),
-    })) as { invites: Array<Record<string, unknown>> };
-    return { ok: true, invites: result.invites };
+    const invites = await listInvites({
+      sourceChannel: queryParams.sourceChannel,
+      status: queryParams.status,
+    });
+    return { ok: true, invites };
   } catch (err) {
     rethrowGatewayError(err);
   }
@@ -438,9 +455,9 @@ export async function handleCreateInvite({ body = {} }: RouteHandlerArgs) {
   // through to the gateway, which stores it and never interprets it.
   const guardianName =
     sourceChannel === "phone" ? resolveInviteGuardianName() : undefined;
-  let result: { invite: Record<string, unknown>; rawToken?: string };
+  let result: { invite: InviteWire; rawToken?: string };
   try {
-    result = (await ipcCallPersistent("invites_create", {
+    result = await createInvite({
       contactId,
       sourceChannel,
       note: body.note as string | undefined,
@@ -453,7 +470,7 @@ export async function handleCreateInvite({ body = {} }: RouteHandlerArgs) {
       ...(typeof body.sourceConversationId === "string"
         ? { sourceConversationId: body.sourceConversationId }
         : {}),
-    })) as { invite: Record<string, unknown>; rawToken?: string };
+    });
   } catch (err) {
     rethrowGatewayError(err);
   }
@@ -473,10 +490,8 @@ export async function handleRevokeInvite({
   pathParams = {},
 }: RouteHandlerArgs) {
   try {
-    const result = (await ipcCallPersistent("invites_revoke", {
-      id: pathParams.id,
-    })) as { invite: Record<string, unknown> };
-    return { ok: true, invite: result.invite };
+    const invite = await revokeInvite(pathParams.id);
+    return { ok: true, invite };
   } catch (err) {
     rethrowGatewayError(err);
   }
@@ -499,12 +514,12 @@ async function handleRedeemVoiceInvite({ body = {} }: RouteHandlerArgs) {
   }
 
   try {
-    return (await ipcCallPersistent("invites_redeem", {
+    return await redeemInviteByVoiceCode({
       ...parsed.data,
       ...(typeof body.assistantId === "string"
         ? { assistantId: body.assistantId }
         : {}),
-    })) as { ok: true; type: string; memberId: string; inviteId?: string };
+    });
   } catch (err) {
     rethrowGatewayError(err);
   }
@@ -540,11 +555,7 @@ async function handleRedeemTokenInvite({ body = {} }: RouteHandlerArgs) {
   try {
     // The `type` is surfaced so callers can tell a real redeem apart from an
     // `already_member` no-op (which consumes no invite use).
-    return (await ipcCallPersistent("invites_redeem", parsed.data)) as {
-      ok: true;
-      invite: Record<string, unknown>;
-      type: string;
-    };
+    return await redeemInviteByToken(parsed.data);
   } catch (err) {
     rethrowGatewayError(err);
   }
@@ -639,8 +650,10 @@ export const ROUTES: RouteDefinition[] = [
   },
 
   // ── contacts/invites (must precede contacts/:id) ────────────────────
+  // The relayed invite routes' operationIds deliberately reuse the gateway
+  // wire method names (single shared map; CLI dispatch uses the same names).
   {
-    operationId: "invites_list",
+    operationId: INVITES_IPC_METHODS.list,
     endpoint: "contacts/invites",
     method: "GET",
     policy: {
@@ -668,7 +681,7 @@ export const ROUTES: RouteDefinition[] = [
     }),
   },
   {
-    operationId: "invites_create",
+    operationId: INVITES_IPC_METHODS.create,
     endpoint: "contacts/invites",
     method: "POST",
     policy: {
@@ -717,7 +730,7 @@ export const ROUTES: RouteDefinition[] = [
     // Relays to the gateway `invites_redeem` IPC: the gateway redemption
     // engine is the single lifecycle authority (validation, atomic claim,
     // ACL upsert). Fail-closed when the gateway is unreachable.
-    operationId: "invites_redeem",
+    operationId: INVITES_IPC_METHODS.redeem,
     endpoint: "contacts/invites/redeem",
     method: "POST",
     policy: {
@@ -773,7 +786,7 @@ export const ROUTES: RouteDefinition[] = [
     },
   },
   {
-    operationId: "invites_revoke",
+    operationId: INVITES_IPC_METHODS.revoke,
     endpoint: "contacts/invites/:id",
     method: "DELETE",
     policy: {
@@ -971,6 +984,25 @@ export const ROUTES: RouteDefinition[] = [
 // Transport-agnostic handlers (moved from HTTP-only)
 // ---------------------------------------------------------------------------
 
+/**
+ * DIVERGENCE RISK — daemon-local merge, NOT the canonical path.
+ *
+ * This executes the LOCAL `mergeContacts` (assistant DB only). The canonical
+ * merge is the gateway control plane (POST /v1/contacts/merge →
+ * contacts-control-plane-proxy.handleMergeContacts), which merges the gateway
+ * DB — the ACL source of truth — and mirrors here via
+ * `contacts_mirror_merge_contact`. A merge through THIS route leaves the
+ * gateway DB untouched: the donor contact and its ACL channel rows survive
+ * gateway-side while the assistant mirror deletes them. Gateway-fronted
+ * clients never reach this route (the control-plane route-match intercepts
+ * the path), but direct daemon callers — notably the bundled `contact_merge`
+ * tool — do.
+ *
+ * Not converted to a relay yet because no gateway IPC/SDK merge surface
+ * exists (unlike `update_contact_channel` below); relaying requires new
+ * gateway-client contracts + a gateway IPC route + a core extraction of the
+ * HTTP handler. Until then, prefer the gateway route wherever reachable.
+ */
 async function handleMergeContactsRoute(args: RouteHandlerArgs) {
   const { body } = args;
   const keepId = body?.keepId as string | undefined;

package/src/runtime/routes/conversation-attention-routes.ts

@@ -75,7 +75,7 @@ function handleListConversationAttention({
       if (msg?.content) {
         snippetMap.set(
           attn.latestAssistantMessageId,
-          truncate(msg.content, 200, ""),
+          truncate(JSON.stringify(msg.content), 200, ""),
         );
       }
     }

package/src/runtime/routes/conversation-cli-routes.ts

@@ -13,7 +13,6 @@ import { clearAllConversations as clearAllActive } from "../../daemon/handlers/c
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
 import { ipcCall as ipcCallGateway } from "../../ipc/gateway-client.js";
 import { sendSlackReply } from "../../messaging/providers/slack/send.js";
-import type { ConversationCreateType } from "../../persistence/conversation-crud.js";
 import { isConversationProcessing } from "../../persistence/conversation-crud.js";
 import {
   addMessage,
@@ -23,6 +22,7 @@ import {
 } from "../../persistence/conversation-crud.js";
 import { setConversationKey } from "../../persistence/conversation-key-store.js";
 import { listConversations } from "../../persistence/conversation-queries.js";
+import type { ConversationCreateType } from "../../persistence/conversation-types.js";
 import { getBindingByConversation } from "../../persistence/external-conversation-store.js";
 import { getLogger } from "../../util/logger.js";
 import { withSqliteRetry } from "../../util/sqlite-retry.js";
@@ -170,7 +170,7 @@ function handleExportCli({ body = {} }: RouteHandlerArgs) {
     ...conversation,
     messages: msgs.map((m) => ({
       role: m.role,
-      content: JSON.parse(m.content),
+      content: m.content,
       createdAt: m.createdAt,
     })),
   };

package/src/runtime/routes/conversation-compaction-routes.ts

@@ -62,6 +62,7 @@ import {
   type LlmContextSummary,
   normalizeLlmContextPayloads,
 } from "./llm-context-normalization.js";
+import { assertLlmRequestLoggingEnabled } from "./llm-request-logs-access.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-compaction-routes");
@@ -256,6 +257,10 @@ async function handleGetCompactionTrail({
   pathParams = {},
   queryParams = {},
 }: RouteHandlerArgs): Promise<CompactionTrailResponse> {
+  // The compaction trail reads LLM-derived log data (metadata + the
+  // compactionAgent projection over `llm_request_logs`), so it honours the
+  // same opt-out as the other inspector reads.
+  assertLlmRequestLoggingEnabled();
   const conversationId = pathParams.id;
   const callId = queryParams.callId;