@vellumai/assistant 0.8.4 → 0.8.6

package/src/workspace/migrations/090-memory-router-cost-optimized-profile.ts

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Flip callSites.memoryRouter from { profile: "balanced" } (the shape that
+// migration 087 wrote) to the shipped cost-optimized default so the router
+// rides the workspace's cheaper/faster managed profile.
+//
+// The migrated entry must mirror the shipped default in call-site-defaults.ts
+// EXACTLY — { profile: "cost-optimized", contextWindow: { maxInputTokens:
+// 1_000_000 } } — because the resolver prefers an explicit
+// llm.callSites.memoryRouter entry over CALL_SITE_DEFAULTS. Writing a bare
+// { profile: "cost-optimized" } would drop the 1M input window and regress
+// migrated users to the profile's normal ~200k window.
+//
+// The shipped default in call-site-defaults.ts also moves to cost-optimized
+// in the same change; this migration is what gets existing users — who carry
+// an explicit { profile: "balanced" } in their config.json — onto the new
+// default. Workspaces with no memoryRouter entry already pick up the shipped
+// default automatically (e.g. BYOK installs that skipped 077/087, or fresh
+// installs), so this migration only touches the 087-seeded balanced shape and
+// the bare { profile: "cost-optimized" } shape an earlier (pre-fix) run of
+// this migration may have written — the latter so those users also recover
+// the 1M window.
+//
+// Two skip conditions, mirroring 087:
+//
+//   1. BYOK / non-Anthropic workspaces. `cost-optimized` is a managed
+//      Anthropic profile, which off-platform installs disable. Forcing it
+//      there would make getConfiguredProvider("memoryRouter") return null
+//      and silently disable memory injection. Detect via llm.default.provider.
+//
+//   2. User-customized memoryRouter config. If the existing entry carries any
+//      key beyond a bare balanced/cost-optimized profile reference, the user —
+//      or a platform overlay — chose those values deliberately. Preserve them.
+const MEMORY_ROUTER_COST_OPTIMIZED = {
+  profile: "cost-optimized",
+  contextWindow: { maxInputTokens: 1_000_000 },
+} as const;
+
+export const memoryRouterCostOptimizedProfileMigration: WorkspaceMigration = {
+  id: "090-memory-router-cost-optimized-profile",
+  description:
+    "Set callSites.memoryRouter to the shipped cost-optimized default (with 1M context) for workspaces still carrying the 087-seeded balanced profile",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown> = {};
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const llm = readObject(config.llm);
+    if (llm === null) return;
+
+    const explicitProvider = readString(readObject(llm.default)?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+
+    const callSites = readObject(llm.callSites);
+    if (callSites === null) return;
+
+    const existing = readObject(callSites.memoryRouter);
+    if (existing === null || !needsCostOptimizedUpgrade(existing)) return;
+
+    callSites.memoryRouter = { ...MEMORY_ROUTER_COST_OPTIMIZED };
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+// True when the entry is a bare single-key profile reference we own:
+//   - { profile: "balanced" }       — what migration 087 wrote
+//   - { profile: "cost-optimized" } — what a pre-fix run of THIS migration
+//                                      wrote (no contextWindow), so those users
+//                                      still recover the 1M window
+// Any extra keys (model pins, tuning fields, an already-present contextWindow)
+// mean the user/platform customized it — preserve and skip. This keeps the
+// migration idempotent: once it writes the full cost-optimized + contextWindow
+// shape, the two-key entry no longer matches.
+function needsCostOptimizedUpgrade(entry: Record<string, unknown>): boolean {
+  const keys = Object.keys(entry);
+  if (keys.length !== 1) return false;
+  return entry.profile === "balanced" || entry.profile === "cost-optimized";
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/091-retighten-migration-onboarding-thread.ts

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { MigrationRunContext, WorkspaceMigration } from "./types.js";
+
+// The exact onboarding bullet seeded by 069-seed-onboarding-threads for the
+// assistant-migration step. Inlined here (not imported) to keep this migration
+// self-contained and decoupled from 069.
+const OLD_BULLET =
+  "- Ask your user if they use ChatGPT, Claude or another AI tool and offer to help them import memories from there.";
+
+// The tightened replacement: help-first, an early light one-time offer, naming
+// the common prior assistants. Keeps the literal "ChatGPT, Claude" substring.
+const NEW_BULLET =
+  "- After helping with the user's first real task, offer early — at the first natural opening — to port their context, memories, prompts, skills, or workflows from a prior assistant (ChatGPT, Claude, OpenClaw, Hermes, or another tool). Keep it a light one-time offer, not a push; if they decline, drop it.";
+
+export const retightenMigrationOnboardingThreadMigration: WorkspaceMigration = {
+  id: "091-retighten-migration-onboarding-thread",
+  description:
+    "Retighten the assistant-migration onboarding bullet in memory/threads.md for brand new assistants",
+
+  run(workspaceDir: string, ctx?: MigrationRunContext): void {
+    // Only rewrite onboarding tasks for newly-created workspaces. An existing
+    // assistant whose user has edited threads.md must not have its content
+    // rewritten on upgrade. When invoked without a context (e.g. from older
+    // callers), default to the safe path and skip — the runner always supplies
+    // one in production.
+    if (!ctx?.isNewWorkspace) return;
+    const filePath = join(workspaceDir, "memory", "threads.md");
+    if (!existsSync(filePath)) return;
+    const content = readFileSync(filePath, "utf-8");
+    // Idempotent: if the old bullet is absent (already replaced, or the user
+    // edited it away), there is nothing to do.
+    if (!content.includes(OLD_BULLET)) return;
+    writeFileSync(filePath, content.replace(OLD_BULLET, NEW_BULLET), "utf-8");
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: never rewrite user-visible memory content on rollback.
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -86,6 +86,9 @@ import { memoryV2Bm25BReembedDisabledV2PagesMigration } from "./085-memory-v2-bm
 import { revertStaleGeminiMisRewritesMigration } from "./086-revert-stale-gemini-mis-rewrites.js";
 import { memoryRouterBalancedProfileMigration } from "./087-memory-router-balanced-profile.js";
 import { deprecateBackgroundConversationOverrideMigration } from "./088-deprecate-background-conversation-override.js";
+import { moveMemoryTreeOutOfV3Migration } from "./089-move-memory-tree-out-of-v3.js";
+import { memoryRouterCostOptimizedProfileMigration } from "./090-memory-router-cost-optimized-profile.js";
+import { retightenMigrationOnboardingThreadMigration } from "./091-retighten-migration-onboarding-thread.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -183,4 +186,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   revertStaleGeminiMisRewritesMigration,
   memoryRouterBalancedProfileMigration,
   deprecateBackgroundConversationOverrideMigration,
+  moveMemoryTreeOutOfV3Migration,
+  memoryRouterCostOptimizedProfileMigration,
+  retightenMigrationOnboardingThreadMigration,
 ];

package/src/__tests__/compaction-strip-metadata-clear.test.ts

@@ -1,206 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
-
-import {
-  addMessage,
-  clearStrippedInjectionMetadataForConversation,
-  createConversation,
-  getMessages,
-} from "../memory/conversation-crud.js";
-import { getDb } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-initializeDb();
-
-function resetTables(): void {
-  const db = getDb();
-  db.run("DELETE FROM message_attachments");
-  db.run("DELETE FROM attachments");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-}
-
-describe("clearStrippedInjectionMetadataForConversation", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  test("removes all stripped-block fields and preserves the rest", async () => {
-    const conv = createConversation("Strip metadata test");
-    await addMessage(
-      conv.id,
-      "user",
-      "turn 1",
-      {
-        memoryInjectedBlock: "mem payload",
-        turnContextBlock: "<turn_context>\nctx\n</turn_context>",
-        workspaceBlock: "<workspace>\nws\n</workspace>",
-        nowScratchpadBlock:
-          "<NOW.md Always keep this up to date>\nnow body\n</NOW.md>",
-        pkbContextBlock: "<knowledge_base>\npkb body\n</knowledge_base>",
-        pkbSystemReminderBlock:
-          "<system_reminder>\nreminder body\n</system_reminder>",
-        memoryV2StaticBlock:
-          "<memory>\n## Essentials\n\nstatic body\n</memory>",
-      },
-      { skipIndexing: true },
-    );
-
-    clearStrippedInjectionMetadataForConversation(conv.id);
-
-    const [row] = getMessages(conv.id);
-    const meta = JSON.parse(row.metadata ?? "{}");
-
-    expect(meta.pkbSystemReminderBlock).toBeUndefined();
-    expect(meta.nowScratchpadBlock).toBeUndefined();
-    expect(meta.pkbContextBlock).toBeUndefined();
-    expect(meta.memoryV2StaticBlock).toBeUndefined();
-
-    // Non-stripped fields must survive — these back blocks that
-    // `stripInjectionsForCompaction` intentionally leaves in-memory.
-    expect(meta.memoryInjectedBlock).toBe("mem payload");
-    expect(meta.turnContextBlock).toBe("<turn_context>\nctx\n</turn_context>");
-    expect(meta.workspaceBlock).toBe("<workspace>\nws\n</workspace>");
-  });
-
-  test("clears memoryV2StaticBlock alone when it is the only stripped field present", async () => {
-    const conv = createConversation("Strip v2 static only");
-    await addMessage(
-      conv.id,
-      "user",
-      "turn 1",
-      {
-        memoryInjectedBlock: "keep me",
-        memoryV2StaticBlock:
-          "<memory>\n## Essentials\n\nstatic body\n</memory>",
-      },
-      { skipIndexing: true },
-    );
-
-    clearStrippedInjectionMetadataForConversation(conv.id);
-
-    const [row] = getMessages(conv.id);
-    const meta = JSON.parse(row.metadata ?? "{}");
-    expect(meta.memoryV2StaticBlock).toBeUndefined();
-    expect(meta.memoryInjectedBlock).toBe("keep me");
-  });
-
-  test("is idempotent — re-running is a no-op on already-cleared rows", async () => {
-    const conv = createConversation("Idempotent clear");
-    await addMessage(
-      conv.id,
-      "user",
-      "turn 1",
-      {
-        memoryInjectedBlock: "keep me",
-        nowScratchpadBlock: "<NOW.md …>body</NOW.md>",
-      },
-      { skipIndexing: true },
-    );
-
-    clearStrippedInjectionMetadataForConversation(conv.id);
-    clearStrippedInjectionMetadataForConversation(conv.id);
-
-    const [row] = getMessages(conv.id);
-    const meta = JSON.parse(row.metadata ?? "{}");
-    expect(meta.nowScratchpadBlock).toBeUndefined();
-    expect(meta.memoryInjectedBlock).toBe("keep me");
-  });
-
-  test("only targets user rows — assistant metadata is untouched", async () => {
-    const conv = createConversation("Role scoping");
-    await addMessage(
-      conv.id,
-      "user",
-      "turn 1",
-      { nowScratchpadBlock: "<NOW.md …>body</NOW.md>" },
-      { skipIndexing: true },
-    );
-    await addMessage(
-      conv.id,
-      "assistant",
-      "reply",
-      // Assistant rows don't carry these blocks in practice, but guard the
-      // role filter anyway so an accidental drop of the WHERE clause is
-      // surfaced immediately.
-      { nowScratchpadBlock: "should-not-be-cleared" },
-      { skipIndexing: true },
-    );
-
-    clearStrippedInjectionMetadataForConversation(conv.id);
-
-    const rows = getMessages(conv.id);
-    const userMeta = JSON.parse(rows[0].metadata ?? "{}");
-    const assistantMeta = JSON.parse(rows[1].metadata ?? "{}");
-    expect(userMeta.nowScratchpadBlock).toBeUndefined();
-    expect(assistantMeta.nowScratchpadBlock).toBe("should-not-be-cleared");
-  });
-
-  test("post-clear, rehydration does not re-inject NOW.md / knowledge_base", async () => {
-    // Reproduces the divergence described in the Codex P1 feedback:
-    // stripInjectionsForCompaction removes <NOW.md …> and <knowledge_base>
-    // from the in-memory history during compaction. Without this clear,
-    // a subsequent loadFromDb would rehydrate those blocks from stale
-    // metadata — re-injecting exactly what compaction removed.
-    const conv = createConversation("Rehydrate after strip");
-    await addMessage(
-      conv.id,
-      "user",
-      "historical turn",
-      {
-        memoryInjectedBlock: "mem",
-        turnContextBlock: "<turn_context>\nctx\n</turn_context>",
-        workspaceBlock: "<workspace>\nws\n</workspace>",
-        nowScratchpadBlock:
-          "<NOW.md Always keep this up to date>\nnow\n</NOW.md>",
-        pkbContextBlock: "<knowledge_base>\npkb\n</knowledge_base>",
-        pkbSystemReminderBlock: "<system_reminder>\nsr\n</system_reminder>",
-      },
-      { skipIndexing: true },
-    );
-    await addMessage(conv.id, "assistant", "reply", undefined, {
-      skipIndexing: true,
-    });
-    await addMessage(conv.id, "user", "tail turn", undefined, {
-      skipIndexing: true,
-    });
-
-    // Simulate the compaction-strip lifecycle point.
-    clearStrippedInjectionMetadataForConversation(conv.id);
-
-    const rows = getMessages(conv.id);
-    const historicalMeta = JSON.parse(rows[0].metadata ?? "{}");
-
-    // Loading this back with loadFromDb prepends fields only when they
-    // are present on the row. Confirm the stripped fields are gone so
-    // rehydration cannot resurrect them.
-    expect(historicalMeta.nowScratchpadBlock).toBeUndefined();
-    expect(historicalMeta.pkbContextBlock).toBeUndefined();
-    expect(historicalMeta.pkbSystemReminderBlock).toBeUndefined();
-
-    // And the fields that back blocks `stripInjectionsForCompaction`
-    // intentionally preserves (<turn_context>, <workspace>, <memory __injected>)
-    // must still be present so the cache prefix remains stable.
-    expect(historicalMeta.turnContextBlock).toBe(
-      "<turn_context>\nctx\n</turn_context>",
-    );
-    expect(historicalMeta.workspaceBlock).toBe("<workspace>\nws\n</workspace>");
-    expect(historicalMeta.memoryInjectedBlock).toBe("mem");
-  });
-});

package/src/__tests__/message-complete-display-id.test.ts

@@ -1,175 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: {
-      entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
-      install: { nodeManager: "npm" },
-      allowBundled: null,
-      remoteProviders: {
-        skillssh: { enabled: true },
-        clawhub: { enabled: true },
-      },
-      remotePolicy: {
-        blockSuspicious: true,
-        blockMalware: true,
-        maxSkillsShRisk: "medium",
-      },
-    },
-  }),
-  loadConfig: () => ({}),
-}));
-
-interface AddMessageCall {
-  conversationId: string;
-  role: string;
-  content: string;
-  metadata?: Record<string, unknown>;
-}
-
-const addMessageCalls: AddMessageCall[] = [];
-
-mock.module("../memory/conversation-crud.js", () => ({
-  addMessage: (
-    conversationId: string,
-    role: string,
-    content: string,
-    metadata?: Record<string, unknown>,
-  ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
-  },
-  getConversation: () => null,
-  getMessageById: () => null,
-  provenanceFromTrustContext: () => ({}),
-  updateMessageContent: () => {},
-}));
-
-mock.module("../memory/llm-request-log-store.js", () => ({
-  backfillMessageIdOnLogs: () => {},
-  recordRequestLog: () => {},
-}));
-
-mock.module("../memory/memory-recall-log-store.js", () => ({
-  backfillMemoryRecallLogMessageId: () => {},
-}));
-
-mock.module("../memory/memory-v2-activation-log-store.js", () => ({
-  backfillMemoryV2ActivationMessageId: () => {},
-}));
-
-mock.module("../memory/conversation-disk-view.js", () => ({
-  syncMessageToDisk: () => {},
-}));
-
-import type { AgentEvent } from "../agent/loop.js";
-import type {
-  EventHandlerDeps,
-  EventHandlerState,
-} from "../daemon/conversation-agent-loop-handlers.js";
-import {
-  createEventHandlerState,
-  getClientDisplayMessageId,
-  handleMessageComplete,
-} from "../daemon/conversation-agent-loop-handlers.js";
-
-const CONVERSATION_ID = "conv-display-id";
-
-function makeDeps(): EventHandlerDeps {
-  return {
-    ctx: {
-      conversationId: CONVERSATION_ID,
-      currentTurnSurfaces: [],
-      provider: { name: "anthropic" },
-      traceEmitter: { emit: () => {} },
-      trustContext: {
-        sourceChannel: "vellum",
-        trustClass: "guardian",
-      },
-    } as unknown as EventHandlerDeps["ctx"],
-    onEvent: () => {},
-    reqId: "req-display-id",
-    isFirstMessage: false,
-    shouldGenerateTitle: false,
-    rlog: new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }) as unknown as EventHandlerDeps["rlog"],
-    turnChannelContext: {
-      userMessageChannel: "vellum",
-      assistantMessageChannel: "vellum",
-    } as EventHandlerDeps["turnChannelContext"],
-    turnInterfaceContext: {
-      userMessageInterface: "web",
-      assistantMessageInterface: "web",
-    } as EventHandlerDeps["turnInterfaceContext"],
-  };
-}
-
-function makeMessageCompleteEvent(
-  content: Extract<
-    AgentEvent,
-    { type: "message_complete" }
-  >["message"]["content"],
-): Extract<AgentEvent, { type: "message_complete" }> {
-  return {
-    type: "message_complete",
-    message: { role: "assistant", content },
-  };
-}
-
-describe("message_complete display identity", () => {
-  let state: EventHandlerState;
-
-  beforeEach(() => {
-    addMessageCalls.length = 0;
-    state = createEventHandlerState();
-    state.turnStartedAt = 1_700_000_000_000;
-  });
-
-  test("tracks the merged display id separately from the final row id", async () => {
-    await handleMessageComplete(
-      state,
-      makeDeps(),
-      makeMessageCompleteEvent([
-        {
-          type: "tool_use",
-          id: "toolu_1",
-          name: "bash",
-          input: { command: "true" },
-        },
-      ]),
-    );
-
-    expect(state.firstAssistantMessageId).toBe("mock-msg-1");
-    expect(state.lastAssistantMessageId).toBe("mock-msg-1");
-    expect(getClientDisplayMessageId(state)).toBe("mock-msg-1");
-
-    state.pendingToolResults.set("toolu_1", {
-      content: "ok",
-      isError: false,
-    });
-
-    await handleMessageComplete(
-      state,
-      makeDeps(),
-      makeMessageCompleteEvent([{ type: "text", text: "done" }]),
-    );
-
-    expect(addMessageCalls.map((call) => call.role)).toEqual([
-      "assistant",
-      "user",
-      "assistant",
-    ]);
-    expect(state.firstAssistantMessageId).toBe("mock-msg-1");
-    expect(state.lastAssistantMessageId).toBe("mock-msg-3");
-    expect(getClientDisplayMessageId(state)).toBe("mock-msg-1");
-  });
-});

package/src/daemon/query-complexity-router.ts

@@ -1,75 +0,0 @@
-import {
-  createTimeout,
-  extractText,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("query-complexity-router");
-
-export type ComplexityTier = "speed" | "balanced" | "quality";
-
-const CLASSIFICATION_TIMEOUT_MS = 5_000;
-
-const SYSTEM_PROMPT = `You are a query complexity classifier. Given a user message, classify its complexity into exactly one tier.
-
-Reply with a single word — one of: speed, balanced, quality
-
-- speed: trivial queries — greetings, acknowledgements, simple yes/no questions, basic factual lookups, short commands, small talk
-- balanced: moderate queries — explanations, summaries, standard coding tasks, general conversation, most everyday requests
-- quality: complex queries — deep analysis, long-form creative writing, complex multi-step reasoning, debugging intricate code, architectural design, research synthesis
-
-When uncertain, reply "balanced".`;
-
-export async function classifyQueryComplexity(
-  messageText: string,
-): Promise<ComplexityTier | null> {
-  const provider = await getConfiguredProvider("queryComplexityRouter");
-  if (!provider) {
-    log.warn("No provider available for query complexity routing");
-    return null;
-  }
-
-  const truncated =
-    messageText.length > 2000 ? messageText.slice(0, 2000) : messageText;
-
-  const { signal, cleanup } = createTimeout(CLASSIFICATION_TIMEOUT_MS);
-  try {
-    const response = await provider.sendMessage(
-      [userMessage(truncated)],
-      undefined,
-      SYSTEM_PROMPT,
-      { signal },
-    );
-    const text = extractText(response).toLowerCase().trim();
-    if (text === "speed" || text === "balanced" || text === "quality") {
-      return text;
-    }
-    // Parse partial matches (model might say "speed." or "quality - because...")
-    if (text.startsWith("speed")) return "speed";
-    if (text.startsWith("quality")) return "quality";
-    if (text.startsWith("balanced")) return "balanced";
-    log.warn({ raw: text }, "Unexpected classifier output, defaulting to null");
-    return null;
-  } catch (err) {
-    if (signal.aborted) {
-      log.warn("Query complexity classification timed out");
-    } else {
-      log.warn({ err }, "Query complexity classification failed");
-    }
-    return null;
-  } finally {
-    cleanup();
-  }
-}
-
-const PROFILE_MAP: Record<ComplexityTier, string> = {
-  speed: "cost-optimized",
-  balanced: "balanced",
-  quality: "quality-optimized",
-};
-
-export function complexityTierToProfileKey(tier: ComplexityTier): string {
-  return PROFILE_MAP[tier];
-}

package/src/prompts/cache-boundary.ts

@@ -1,8 +0,0 @@
-/**
- * The SYSTEM_PROMPT_CACHE_BOUNDARY marker is a lightweight constant kept in its
- * own file so that providers (openai, gemini) can import it without pulling in
- * the full system-prompt module and its heavy transitive dependencies, which
- * would otherwise create a circular import cycle.
- */
-export const SYSTEM_PROMPT_CACHE_BOUNDARY =
-  "\n<!-- SYSTEM_PROMPT_CACHE_BOUNDARY -->\n";