@mycadet/assistant 0.12.9 → 0.12.10

package/src/__tests__/llm-usage-store.test.ts

@@ -10,7 +10,6 @@ import {
   getUsageTotals,
   listRunConversationIds,
   listUsageEvents,
-  queryUnreportedUsageEvents,
   recordUsageEvent,
 } from "../persistence/llm-usage-store.js";
 import type { PricingResult, UsageEventInput } from "../usage/types.js";
@@ -1668,497 +1667,3 @@ describe("getUsageGroupedSeries", () => {
     });
   });
 });
-
-// ---------------------------------------------------------------------------
-// queryUnreportedUsageEvents tests
-// ---------------------------------------------------------------------------
-
-describe("queryUnreportedUsageEvents", () => {
-  beforeEach(() => {
-    const db = getDb();
-    // Order matters: clear `llm_usage_events` (no FK), then `messages`
-    // (FK to conversations cascades, but be explicit), then
-    // `conversations`. The conversation-level metadata tests below
-    // depend on a clean conversations + messages slate so JOINs are
-    // deterministic.
-    db.run(`DELETE FROM llm_usage_events`);
-    db.run(`DELETE FROM messages`);
-    db.run(`DELETE FROM conversations`);
-  });
-
-  test("returns events with createdAt strictly greater than afterCreatedAt in ascending order", () => {
-    insertEventAt(1000, { model: "model-a" });
-    insertEventAt(2000, { model: "model-b" });
-    insertEventAt(3000, { model: "model-c" });
-
-    // afterCreatedAt = 1000 should exclude the event at exactly 1000
-    const events = queryUnreportedUsageEvents(1000, undefined, 100);
-    expect(events).toHaveLength(2);
-    expect(events[0].model).toBe("model-b");
-    expect(events[0].createdAt).toBe(2000);
-    expect(events[1].model).toBe("model-c");
-    expect(events[1].createdAt).toBe(3000);
-  });
-
-  test("respects the limit parameter", () => {
-    insertEventAt(1000, { model: "model-a" });
-    insertEventAt(2000, { model: "model-b" });
-    insertEventAt(3000, { model: "model-c" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 2);
-    expect(events).toHaveLength(2);
-    // Should return the earliest two due to ASC ordering
-    expect(events[0].model).toBe("model-a");
-    expect(events[1].model).toBe("model-b");
-  });
-
-  test("returns attribution fields for unreported usage events", () => {
-    insertEventAt(1000, {
-      callSite: "mainAgent",
-      inferenceProfile: "balanced",
-      inferenceProfileSource: "active",
-    });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].callSite).toBe("mainAgent");
-    expect(events[0].inferenceProfile).toBe("balanced");
-    expect(events[0].inferenceProfileSource).toBe("active");
-  });
-
-  test("returns empty array when no events match", () => {
-    insertEventAt(1000, { model: "model-a" });
-
-    const events = queryUnreportedUsageEvents(2000, undefined, 100);
-    expect(events).toHaveLength(0);
-  });
-
-  test("returns empty array when table is empty", () => {
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(0);
-  });
-
-  // -------------------------------------------------------------------------
-  // Conversation-level metadata (conversationType + turnIndex).
-  // `conversationType` is stamped on the row at record time (so it survives
-  // deletion of the parent conversation before flush) with a JOIN fallback
-  // for pre-migration rows; `turnIndex` is JOIN-computed at telemetry-query
-  // time.
-  // -------------------------------------------------------------------------
-
-  test("conversationType resolves from the conversations table", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-std', 'standard', ${now}, ${now})`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-bg', 'background', ${now}, ${now})`,
-    );
-
-    insertEventAt(1000, { conversationId: "conv-std" });
-    insertEventAt(2000, { conversationId: "conv-bg" });
-    insertEventAt(3000, { conversationId: null });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(3);
-    expect(events[0].conversationType).toBe("standard");
-    expect(events[1].conversationType).toBe("background");
-    // LLM calls without a parent conversation get null — LEFT JOIN, not INNER.
-    expect(events[2].conversationType).toBeNull();
-  });
-
-  test("conversationType is stamped on the row at record time", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-stamp', 'background', ${now}, ${now})`,
-    );
-
-    const event = recordUsageEvent(
-      makeInput({ conversationId: "conv-stamp" }),
-      pricedResult,
-    );
-
-    const row = getSqlite()
-      .query("SELECT conversation_type FROM llm_usage_events WHERE id = ?")
-      .get(event.id) as { conversation_type: string | null } | null;
-    expect(row?.conversation_type).toBe("background");
-  });
-
-  test("conversationType survives deletion of the parent conversation before flush", () => {
-    // Reproduces the memory-retrospective NULL-label bug: the retrospective
-    // runs in a `background` fork conversation whose row is GC'd once a
-    // newer run supersedes it (or immediately on wake failure). Usage rows
-    // flushed after that deletion carried a conversation_id but a null
-    // conversation_type, because the type was derived only via a flush-time
-    // JOIN. Same mechanism covers users deleting a standard conversation
-    // within the flush window (the mainAgent NULL case).
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-gone', 'background', ${now}, ${now})`,
-    );
-    insertEventAt(1000, {
-      conversationId: "conv-gone",
-      callSite: "memoryRetrospective",
-    });
-
-    db.run(`DELETE FROM conversations WHERE id = 'conv-gone'`);
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].conversationId).toBe("conv-gone");
-    expect(events[0].conversationType).toBe("background");
-  });
-
-  test("conversationType falls back to the JOIN for pre-migration rows", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-legacy', 'scheduled', ${now}, ${now})`,
-    );
-    insertEventAt(1000, { conversationId: "conv-legacy" });
-    // Simulate a row persisted before migration 353 stamped the column.
-    db.run(
-      `UPDATE llm_usage_events SET conversation_type = NULL WHERE conversation_id = 'conv-legacy'`,
-    );
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].conversationType).toBe("scheduled");
-  });
-
-  test("turnIndex counts real user turns up to the LLM call's createdAt", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-1', 'standard', ${now}, ${now})`,
-    );
-    // Two user messages in the conversation.
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('m1', 'conv-1', 'user', 'hello', 1000)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('m2', 'conv-1', 'user', 'follow up', 3000)`,
-    );
-
-    // Three LLM calls across the timeline:
-    //  - mid-turn-1 (between m1 and m2)
-    //  - exactly at m2's createdAt (still counts m2: `created_at <= e.created_at`)
-    //  - after m2
-    insertEventAt(2000, { conversationId: "conv-1" });
-    insertEventAt(3000, { conversationId: "conv-1" });
-    insertEventAt(4000, { conversationId: "conv-1" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(3);
-    expect(events[0].turnIndex).toBe(1);
-    expect(events[1].turnIndex).toBe(2);
-    expect(events[2].turnIndex).toBe(2);
-  });
-
-  test("turnIndex is null when the LLM call has no conversationId", () => {
-    insertEventAt(1000, { conversationId: null });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].conversationId).toBeNull();
-    expect(events[0].turnIndex).toBeNull();
-  });
-
-  test("turnIndex skips tool_result rows when counting", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-tr', 'standard', ${now}, ${now})`,
-    );
-    // One real user turn, then a tool_result row (which should be
-    // ignored), then the LLM call. Expected turn_index = 1.
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('real-1', 'conv-tr', 'user', 'real text', 1000)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('tool-1', 'conv-tr', 'user', '[{"type":"tool_result","tool_use_id":"x","content":""}]', 1500)`,
-    );
-    insertEventAt(2000, { conversationId: "conv-tr" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].turnIndex).toBe(1);
-  });
-
-  test("turnIndex is 0 when the LLM call fires before any user message", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-early', 'standard', ${now}, ${now})`,
-    );
-    // LLM call fires at t=1000; first user message is at t=2000.
-    insertEventAt(1000, { conversationId: "conv-early" });
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('later', 'conv-early', 'user', 'hi', 2000)`,
-    );
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    // Conversation exists but no user turn has fired yet. The CASE
-    // short-circuits only on null conversationId, so we get a real 0.
-    // Analytics can treat 0 as "pre-first-turn" if needed.
-    expect(events[0].turnIndex).toBe(0);
-  });
-
-  // -------------------------------------------------------------------------
-  // Parent linkage (parentConversationId + parentTurnIndex): subagent spawns
-  // stamp `parent_conversation_id` on their background conversation; the
-  // query resolves it (with a fork-parent fallback) so the reporter can
-  // attribute the child's usage to the parent turn in flight at spawn.
-  // -------------------------------------------------------------------------
-
-  test("parentConversationId links a subagent conversation and parentTurnIndex counts the parent turn in flight at spawn", () => {
-    const db = getDb();
-    // Parent user turns at t=1000 and t=3000; the child conversation is
-    // created at t=2000, i.e. while the parent's turn 1 is in flight.
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('parent-1', 'standard', 500, 500)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('p1', 'parent-1', 'user', 'first', 1000)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('p2', 'parent-1', 'user', 'second', 3000)`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, parent_conversation_id) VALUES ('child-1', 'background', 2000, 2000, 'parent-1')`,
-    );
-    // The usage event fires after the parent's turn 2, but attribution is
-    // anchored to the child's creation time, not the event time.
-    insertEventAt(5000, { conversationId: "child-1" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].parentConversationId).toBe("parent-1");
-    expect(events[0].parentTurnIndex).toBe(1);
-  });
-
-  test("parent linkage falls back to fork_parent_conversation_id (retrospective forks)", () => {
-    const db = getDb();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('source-1', 'standard', 500, 500)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('s1', 'source-1', 'user', 'hello', 1000)`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, fork_parent_conversation_id) VALUES ('retro-1', 'background', 2000, 2000, 'source-1')`,
-    );
-    insertEventAt(3000, { conversationId: "retro-1" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].parentConversationId).toBe("source-1");
-    expect(events[0].parentTurnIndex).toBe(1);
-  });
-
-  test("fork parentTurnIndex anchors on the fork boundary message, not fork creation time", () => {
-    const db = getDb();
-    // Source conversation with turns at t=1000 and t=3000. The fork
-    // branches from the FIRST turn (boundary message s1) but is created
-    // at t=5000, after turn 2 exists — attribution must report turn 1.
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('source-2', 'standard', 500, 500)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('s2a', 'source-2', 'user', 'first', 1000)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('s2b', 'source-2', 'user', 'second', 3000)`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, fork_parent_conversation_id, fork_parent_message_id) VALUES ('retro-2', 'background', 5000, 5000, 'source-2', 's2a')`,
-    );
-    insertEventAt(6000, { conversationId: "retro-2" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].parentConversationId).toBe("source-2");
-    expect(events[0].parentTurnIndex).toBe(1);
-  });
-
-  test("user-initiated forks (standard type) do not inherit fork parent attribution", () => {
-    const db = getDb();
-    // A user forks a conversation: the fork stamps
-    // fork_parent_conversation_id but is a first-class standard
-    // conversation — its usage must not fold into the source turn.
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('source-3', 'standard', 500, 500)`,
-    );
-    db.run(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('s3', 'source-3', 'user', 'hello', 1000)`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, fork_parent_conversation_id, fork_parent_message_id) VALUES ('user-fork-1', 'standard', 2000, 2000, 'source-3', 's3')`,
-    );
-    insertEventAt(3000, { conversationId: "user-fork-1" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].parentConversationId).toBeNull();
-    expect(events[0].parentTurnIndex).toBeNull();
-  });
-
-  test("parent fields are null for parentless conversations and no-conversation events", () => {
-    const db = getDb();
-    const now = Date.now();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-solo', 'background', ${now}, ${now})`,
-    );
-    insertEventAt(1000, { conversationId: "conv-solo" });
-    insertEventAt(2000, { conversationId: null });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(2);
-    expect(events[0].parentConversationId).toBeNull();
-    expect(events[0].parentTurnIndex).toBeNull();
-    expect(events[1].parentConversationId).toBeNull();
-    expect(events[1].parentTurnIndex).toBeNull();
-  });
-
-  // -------------------------------------------------------------------------
-  // Delegated-work decomposition (subagentRole + subagentSpawnMode). Every
-  // subagent variety emits under `llm_call_site = "subagentSpawn"`, so these
-  // two orthogonal columns, stamped on the conversation row at spawn, are
-  // what make advisor consults, forks and regular spawns separable.
-  // -------------------------------------------------------------------------
-
-  test("surfaces subagentRole and subagentSpawnMode from the child conversation", () => {
-    const db = getDb();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, parent_conversation_id, subagent_role, subagent_spawn_mode) VALUES ('advisor-child', 'background', 1000, 1000, 'parent-1', 'advisor', 'advisor_consult')`,
-    );
-    insertEventAt(2000, { conversationId: "advisor-child" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].subagentRole).toBe("advisor");
-    expect(events[0].subagentSpawnMode).toBe("advisor_consult");
-  });
-
-  test("role and spawn mode are independent: a general subagent can be regular or forked", () => {
-    const db = getDb();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode) VALUES ('plain-child', 'background', 1000, 1000, 'general', 'regular')`,
-    );
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode) VALUES ('forked-child', 'background', 1000, 1000, 'general', 'fork')`,
-    );
-    insertEventAt(2000, { conversationId: "plain-child" });
-    insertEventAt(3000, { conversationId: "forked-child" });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(2);
-    expect(events[0].subagentRole).toBe("general");
-    expect(events[0].subagentSpawnMode).toBe("regular");
-    expect(events[1].subagentRole).toBe("general");
-    expect(events[1].subagentSpawnMode).toBe("fork");
-  });
-
-  test("subagent fields are null for ordinary conversations and no-conversation events", () => {
-    const db = getDb();
-    db.run(
-      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-plain', 'standard', 500, 500)`,
-    );
-    insertEventAt(1000, { conversationId: "conv-plain" });
-    insertEventAt(2000, { conversationId: null });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(2);
-    expect(events[0].subagentRole).toBeNull();
-    expect(events[0].subagentSpawnMode).toBeNull();
-    expect(events[1].subagentRole).toBeNull();
-    expect(events[1].subagentSpawnMode).toBeNull();
-  });
-
-  test("surfaces llmCallCount on unreported events", () => {
-    insertEventAt(1000, { llmCallCount: 4 });
-    insertEventAt(2000, {});
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(2);
-    expect(events[0].llmCallCount).toBe(4);
-    // recordUsageEvent defaults llmCallCount to 1 when unset.
-    expect(events[1].llmCallCount).toBe(1);
-  });
-
-  test("surfaces raw_usage on unreported events", () => {
-    // The telemetry reporter consumes `queryUnreportedUsageEvents` output
-    // directly and forwards it to BigQuery. If the SELECT projection
-    // drops the `raw_usage` column, every provider-specific detail
-    // (Anthropic TTL breakdown, OpenAI prompt-token details, etc.)
-    // vanishes silently — covered here so a refactor of the projection
-    // can't regress the wire shape.
-    const rawUsage = {
-      input_tokens: 1500,
-      output_tokens: 600,
-      cache_creation_input_tokens: 800,
-      cache_creation: {
-        ephemeral_5m_input_tokens: 300,
-        ephemeral_1h_input_tokens: 500,
-      },
-    };
-    insertEventAt(1000, {
-      cacheCreationInputTokens: 800,
-      rawUsage,
-    });
-
-    const events = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(events).toHaveLength(1);
-    expect(events[0].cacheCreationInputTokens).toBe(800);
-    expect(events[0].rawUsage).toEqual(rawUsage);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Record-time assistantVersion stamping (May 2026 telemetry honesty fix)
-//
-// Events buffered while the assistant is offline must remember the binary
-// that was running when they were recorded, not the one that finally
-// uploads them. recordUsageEvent stamps APP_VERSION at insert time and the
-// query must return it so the reporter can put it on the wire.
-// ---------------------------------------------------------------------------
-
-describe("recordUsageEvent — assistantVersion stamping", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run(`DELETE FROM llm_usage_events`);
-  });
-
-  test("stamps APP_VERSION on the returned event", async () => {
-    const { APP_VERSION } = await import("../version.js");
-    const event = recordUsageEvent(makeInput(), pricedResult);
-    expect(event.assistantVersion).toBe(APP_VERSION);
-  });
-
-  test("persists assistantVersion and queryUnreportedUsageEvents returns it", async () => {
-    const { APP_VERSION } = await import("../version.js");
-    insertEventAt(1000);
-    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(event).toBeDefined();
-    expect(event.assistantVersion).toBe(APP_VERSION);
-  });
-
-  test("legacy rows (null assistant_version column) round-trip as null", () => {
-    // Simulate a row that was persisted before migration 267 ran by
-    // inserting one through recordUsageEvent and then nulling the
-    // column out. This mirrors what production rows look like before
-    // the migration backfills `null`s; the reporter must accept them
-    // and let the cloud fall back to the envelope's version.
-    insertEventAt(1000);
-    const db = getDb();
-    db.run(`UPDATE llm_usage_events SET assistant_version = NULL`);
-
-    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
-    expect(event).toBeDefined();
-    expect(event.assistantVersion).toBeNull();
-  });
-});

package/src/__tests__/log-export-routes.test.ts

@@ -19,7 +19,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import { llmUsageEvents } from "../persistence/schema/index.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
-import { getLogsDir } from "../util/platform.js";
+import { getLogsDir } from "../util/layout.js";
 
 await initializeDb();
 

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -101,20 +101,13 @@ const configGetRoute = findRoute("config_get");
 const configPatchRoute = findRoute("config_patch");
 const configSetRoute = findRoute("config_set");
 
-function withoutWireProfiles(
-  result: Record<string, unknown>,
-): Record<string, unknown> {
-  const { llm: _llm, ...rest } = result;
-  return rest;
-}
-
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
     seedRawConfig({});
     rmSync(mcpJsonPath(), { force: true });
   });
 
-  test("config_get omits MCP headers from the mcp.json overlay", () => {
+  test("config_get serves no mcp subtree — workspace mcp.json headers never reach the config wire", () => {
     seedWorkspaceMcp({
       mcpServers: {
         remote: {
@@ -132,16 +125,10 @@ describe("MCP config secret boundary", () => {
 
     expect(JSON.stringify(result)).not.toContain("mcp-secret");
     expect(JSON.stringify(result)).not.toContain("mcp-api-secret");
-    const mcp = result.mcp as {
-      servers: { remote: { transport: Record<string, unknown> } };
-    };
-    expect(mcp.servers.remote.transport).toEqual({
-      type: "streamable-http",
-      url: "https://mcp.example.com",
-    });
+    expect(result.mcp).toBeUndefined();
   });
 
-  test("config_get ignores leftover config.json mcp so its headers cannot leak", () => {
+  test("config_get drops leftover config.json mcp so its headers cannot leak", () => {
     seedRawConfig({
       mcp: {
         servers: {
@@ -159,12 +146,10 @@ describe("MCP config secret boundary", () => {
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
     expect(JSON.stringify(result)).not.toContain("leftover-secret");
-    expect(
-      (result.mcp as { servers: Record<string, unknown> }).servers,
-    ).toEqual({});
+    expect(result.mcp).toBeUndefined();
   });
 
-  test("config_get preserves an MCP server named headers", () => {
+  test("config_get ignores workspace mcp.json even when a server is named headers", () => {
     seedWorkspaceMcp({
       mcpServers: {
         headers: {
@@ -176,19 +161,10 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result).mcp).toEqual({
-      servers: {
-        headers: {
-          transport: {
-            type: "streamable-http",
-            url: "https://mcp.example.com",
-          },
-        },
-      },
-    });
+    expect(result.mcp).toBeUndefined();
   });
 
-  test("config_get preserves non-credential headers env vars", () => {
+  test("config_get ignores workspace mcp.json env vars (the MCP API serves them)", () => {
     seedWorkspaceMcp({
       mcpServers: {
         local: {
@@ -203,20 +179,7 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result).mcp).toEqual({
-      servers: {
-        local: {
-          transport: {
-            type: "stdio",
-            command: "npx",
-            args: [],
-            env: {
-              headers: "not-a-transport-header",
-            },
-          },
-        },
-      },
-    });
+    expect(result.mcp).toBeUndefined();
   });
 
   test("config_patch strips MCP transport headers so generic writes cannot persist plaintext credentials", async () => {
@@ -237,12 +200,10 @@ describe("MCP config secret boundary", () => {
     });
 
     // `mcp` is not an AssistantConfigSchema key: the write's schema parse
-    // strips it, so the secret never reaches disk — and the response's
-    // projected workspace view carries no such server either.
+    // strips it, so the secret never reaches disk — and the response
+    // echoes no such subtree either.
     expect(committedRaw()?.mcp).toBeUndefined();
-    expect(
-      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
-    ).toEqual({});
+    expect(result).not.toHaveProperty("mcp");
   });
 
   test("config_patch strips mcp so a full-config round trip cannot write it back", async () => {
@@ -262,9 +223,7 @@ describe("MCP config secret boundary", () => {
     });
 
     expect(committedRaw()?.mcp).toBeUndefined();
-    expect(
-      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
-    ).toEqual({});
+    expect(result).not.toHaveProperty("mcp");
   });
 
   test("config_set drops MCP server writes", async () => {

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -75,7 +75,7 @@ setWorkspaceMcp({
   },
 });
 
-const { getWorkspacePluginsDir } = await import("../util/platform.js");
+const { getWorkspacePluginsDir } = await import("../util/layout.js");
 const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
 
 const listHandler = ROUTES.find(

package/src/__tests__/memory-config-file-parity.test.ts

@@ -15,7 +15,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { getConfig } from "../config/loader.js";
 import { getMemoryConfig } from "../plugins/defaults/memory/config.js";
-import { getWorkspaceConfigPath } from "../util/platform.js";
+import { getWorkspaceConfigPath } from "../util/layout.js";
 
 const configPath = getWorkspaceConfigPath();
 const savedIsPlatform = process.env.IS_CLOUD;

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -29,7 +29,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { memoryInjectors } from "../plugins/defaults/memory/injectors.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
+import { getWorkspacePromptPath } from "../util/layout.js";
 
 function findInjector(name: string): Injector {
   const injector = memoryInjectors.find((i) => i.name === name);

package/src/__tests__/messages-read-boundary-guard.test.ts

@@ -65,8 +65,6 @@ const BASELINE: Readonly<Record<string, number>> = {
   "src/runtime/pre-first-message-gate.ts": 1,
   "src/runtime/routes/log-export-routes.ts": 1,
   "src/runtime/routes/surface-conversation-resolver.ts": 2,
-  "src/telemetry/turn-events-store.ts": 2,
-  "src/telemetry/turn-trace-store.ts": 2,
   "src/workspace/migrations/rebuild-conversation-disk-view.ts": 1,
 };