@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/server.ts

@@ -27,6 +27,7 @@ import type { CesProcessManager } from "../credential-execution/process-manager.
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { CliIpcServer } from "../ipc/cli-server.js";
+import { registerBrowserIpcContextResolver } from "../ipc/routes/browser-context.js";
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
@@ -49,6 +50,7 @@ import {
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
+import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import { getProvider, initializeProviders } from "../providers/registry.js";
 import {
@@ -60,6 +62,7 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
+import { registerInteractiveUiResolver } from "../runtime/interactive-ui.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { redactSecrets } from "../security/secret-scanner.js";
@@ -90,10 +93,14 @@ import {
 } from "./conversation.js";
 import { ConversationEvictor } from "./conversation-evictor.js";
 import { registerLaunchConversationDeps } from "./conversation-launch.js";
+import { buildSlackMetaForPersistence } from "./conversation-messaging.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
+import {
+  refreshSurfacesForApp,
+  showStandaloneSurface,
+} from "./conversation-surfaces.js";
 import { undoLastMessage } from "./handlers/conversations.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type {
@@ -813,6 +820,11 @@ export class DaemonServer {
     // DB, exposing only the narrow surface the wake helper needs.
     registerDefaultWakeResolver(async (conversationId) => {
       try {
+        // Only resolve existing conversations — don't create ghost
+        // conversations for stale targets (e.g. meetings that ended
+        // but a delayed opportunity callback still fires).
+        const existing = getConversation(conversationId);
+        if (!existing) return null;
         const conversation = await this.getOrCreateConversation(conversationId);
         return conversationToWakeTarget(conversation);
       } catch (err) {
@@ -824,6 +836,60 @@ export class DaemonServer {
       }
     });
 
+    // Install the interactive UI resolver so skills and IPC handlers can
+    // present ad-hoc UI surfaces (confirmations, forms) to the user via
+    // `requestInteractiveUi()`. Interactive UI requires a client to be
+    // actively connected to the conversation (via SSE), which means the
+    // conversation must be in the in-memory map. If the conversation was
+    // evicted from memory the client is definitely disconnected, so
+    // hydration from persistent storage is pointless — the hydrated
+    // conversation would have hasNoClient=true, causing
+    // canShowInteractiveUi() to return false and the surface to be
+    // cancelled with no_interactive_surface. We skip that wasted work
+    // and return conversation_not_found directly.
+    registerInteractiveUiResolver(async (request) => {
+      const conversation = this.conversations.get(request.conversationId);
+
+      if (!conversation) {
+        log.warn(
+          {
+            conversationId: request.conversationId,
+            surfaceType: request.surfaceType,
+          },
+          "interactive-ui resolver: conversation not in memory (client not connected); failing closed",
+        );
+        return {
+          status: "cancelled" as const,
+          surfaceId: `ui-resolver-${Date.now()}`,
+          cancellationReason: "conversation_not_found" as const,
+        };
+      }
+
+      // Generate a unique surface ID and delegate to the conversation's
+      // standalone surface lifecycle. The returned Promise blocks until
+      // the user submits, cancels, or the timeout elapses.
+      const surfaceId = `ui-standalone-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      return showStandaloneSurface(conversation, request, surfaceId);
+    });
+
+    // Allow `browser_execute` IPC calls to reuse live conversation browser
+    // proxy wiring (when a caller passes a conversationId from
+    // __CONVERSATION_ID / __SKILL_CONTEXT_JSON). This keeps nested
+    // `assistant browser status` checks consistent with the parent turn's
+    // extension connectivity instead of always falling back to a synthetic
+    // browser-cli session that has no hostBrowserProxy.
+    registerBrowserIpcContextResolver((conversationId) => {
+      const conversation = this.conversations.get(conversationId);
+      if (!conversation) return null;
+      return {
+        conversationId,
+        trustClass: conversation.trustContext?.trustClass ?? "guardian",
+        hostBrowserProxy: conversation.hostBrowserProxy,
+        transportInterface: conversation.transportInterface,
+        hostBrowserRegistryRouted: !!conversation.hostBrowserSenderOverride,
+      };
+    });
+
     // Start the CLI IPC server. Built-in methods (wake_conversation) are
     // registered by the constructor; CLI commands connect to this socket to
     // invoke daemon-side operations that require in-process state.
@@ -1033,7 +1099,19 @@ export class DaemonServer {
 
       const createPromise = (async () => {
         const config = getConfig();
-        let provider = getProvider(config.services.inference.provider);
+        let provider = getProvider(config.llm.default.provider);
+        // Per-call `options.config.callSite` can resolve to a provider name
+        // that differs from `llm.default.provider`. Wrap the default
+        // provider so the actual transport routes correctly per call,
+        // rather than only forwarding metadata to the default's HTTP
+        // client. See `providers/call-site-routing.ts`.
+        provider = new CallSiteRoutingProvider(provider, (name) => {
+          try {
+            return getProvider(name);
+          } catch {
+            return undefined;
+          }
+        });
         const { rateLimit } = config;
         if (rateLimit.maxRequestsPerMinute > 0) {
           provider = new RateLimitProvider(
@@ -1046,7 +1124,8 @@ export class DaemonServer {
 
         const systemPrompt =
           storedOptions?.systemPromptOverride ?? buildSystemPrompt();
-        const maxTokens = storedOptions?.maxResponseTokens ?? config.maxTokens;
+        const maxTokens =
+          storedOptions?.maxResponseTokens ?? config.llm.default.maxTokens;
 
         const memoryPolicy = this.deriveMemoryPolicy(conversationId);
         // Resolve the shared CES client (may still be initializing).
@@ -1065,7 +1144,6 @@ export class DaemonServer {
           sharedCesClient,
           storedOptions?.speed,
           undefined,
-          storedOptions?.modelIntent,
           storedOptions?.modelOverride,
         );
         newConversation.updateClient(sendToClient, true);
@@ -1225,9 +1303,10 @@ export class DaemonServer {
     // Chrome-extension host_browser wiring is intentionally not supported
     // through this entry point. `prepareConversationForMessage` constructs
     // host_browser proxies that capture `conversation.getCurrentSender()`
-    // directly, which would route browser frames through the daemon SSE
-    // channel instead of the `ChromeExtensionRegistry`. Chrome-extension
-    // flows reach host_browser exclusively through the
+    // directly, which routes browser frames through the daemon SSE channel.
+    // This is correct for macOS (SSE-based host proxy), but chrome-extension
+    // requires the `ChromeExtensionRegistry` WebSocket transport instead.
+    // Chrome-extension flows reach host_browser exclusively through the
     // `/v1/messages` flow in `conversation-routes.ts`, which wires a
     // registry-aware sender and sets `hostBrowserSenderOverride`.
     //
@@ -1397,6 +1476,7 @@ export class DaemonServer {
       .runAgentLoop(content, messageId, onEvent, {
         isInteractive: options?.isInteractive ?? false,
         isUserMessage: true,
+        ...(options?.callSite ? { callSite: options.callSite } : {}),
       })
       .finally(() => {
         if (
@@ -1437,14 +1517,26 @@ export class DaemonServer {
       messageCount: conversation.getMessages().length,
       inputTokens: conversation.usageStats.inputTokens,
       outputTokens: conversation.usageStats.outputTokens,
-      maxInputTokens: config.contextWindow.maxInputTokens,
-      model: config.services.inference.model,
-      provider: config.services.inference.provider,
+      maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
+      model: config.llm.default.model,
+      provider: config.llm.default.provider,
       estimatedCost: conversation.usageStats.estimatedCost,
       userMessageInterface: serverInterfaceCtx?.userMessageInterface,
     };
     const slashResult = await resolveSlash(content, slashContext);
 
+    // Slack inbound metadata is materialized once here for the slash-command
+    // bypass paths (unknown-slash and /compact), which persist the user row
+    // directly via `addMessage` and would otherwise drop the envelope. The
+    // agent-loop path does not consume this variable — it forwards
+    // `options.slackInbound` through `persistMetadata` and the envelope is
+    // built internally by `buildSlackMetaForPersistence` inside
+    // `persistQueuedMessageBody`.
+    const slackMeta = buildSlackMetaForPersistence({
+      slackInbound: options?.slackInbound,
+      turnChannel: conversation.getTurnChannelContext()?.userMessageChannel,
+    });
+
     if (slashResult.kind === "unknown") {
       const serverTurnCtx = conversation.getTurnChannelContext();
       const serverProvenance = provenanceFromTrustContext(
@@ -1476,13 +1568,20 @@ export class DaemonServer {
           ? { imageSourcePaths }
           : {}),
       };
+      // slackMeta encodes the inbound user message's ts/thread — it attaches
+      // to the user row only. The assistant's slash-command response does not
+      // originate from Slack and must not inherit the user's channelTs, which
+      // would break ordering in the chronological renderer.
+      const userMetaWithSlack = slackMeta
+        ? { ...serverChannelMeta, slackMeta }
+        : serverChannelMeta;
       const cleanMsg = createUserMessage(content, attachments);
       const llmMsg = enrichMessageWithSourcePaths(cleanMsg, attachments);
       const persisted = await addMessage(
         conversationId,
         "user",
         JSON.stringify(cleanMsg.content),
-        serverChannelMeta,
+        userMetaWithSlack,
       );
       conversation.getMessages().push(llmMsg);
 
@@ -1560,12 +1659,15 @@ export class DaemonServer {
             }
           : {}),
       };
+      const compactUserMeta = slackMeta
+        ? { ...compactChannelMeta, slackMeta }
+        : compactChannelMeta;
       const cleanMsg = createUserMessage(content, attachments);
       const persisted = await addMessage(
         conversationId,
         "user",
         JSON.stringify(cleanMsg.content),
-        compactChannelMeta,
+        compactUserMeta,
       );
       conversation.getMessages().push(cleanMsg);
 
@@ -1590,10 +1692,17 @@ export class DaemonServer {
     const resolvedContent = slashResult.content;
 
     const requestId = crypto.randomUUID();
+    // Slack inbound metadata captured at the channel ingress boundary is
+    // forwarded into the persistence call so `persistQueuedMessageBody` can
+    // emit a `slackMeta` envelope on the row's metadata column.
+    const persistMetadata = options?.slackInbound
+      ? { slackInbound: options.slackInbound }
+      : undefined;
     const messageId = await conversation.persistUserMessage(
       resolvedContent,
       attachments,
       requestId,
+      persistMetadata,
     );
 
     // Register pending interactions so channel approval interception can
@@ -1623,6 +1732,7 @@ export class DaemonServer {
       await conversation.runAgentLoop(resolvedContent, messageId, onEvent, {
         isInteractive: options?.isInteractive ?? false,
         isUserMessage: true,
+        ...(options?.callSite ? { callSite: options.callSite } : {}),
       });
     } finally {
       if (

package/src/daemon/shutdown-handlers.ts

@@ -3,7 +3,6 @@ import * as Sentry from "@sentry/node";
 import type { BackupWorkerHandle } from "../backup/backup-worker.js";
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
-import type { HookManager } from "../hooks/manager.js";
 import type { McpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
@@ -23,7 +22,6 @@ export interface ShutdownDeps {
   workspaceHeartbeat: WorkspaceHeartbeatService;
   heartbeat: HeartbeatService;
   filing: FilingService;
-  hookManager: HookManager;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
   feedScheduler: { stop(): void } | null;
@@ -44,11 +42,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     shuttingDown = true;
     log.info("Shutting down daemon...");
 
-    deps.hookManager.stopWatching();
-
     // Force exit if graceful shutdown takes too long.
-    // Set this BEFORE awaiting heartbeat stop and triggering daemon-stop hooks
-    // so it covers all potentially-blocking async shutdown work.
+    // Set this BEFORE awaiting heartbeat stop so it covers all
+    // potentially-blocking async shutdown work.
     //
     // 20s budget: 15s reserved for Meet session teardown
     // (`MeetSessionManager.shutdownAll`), plus ~5s for the remaining
@@ -67,12 +63,6 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await deps.heartbeat.stop();
     await deps.filing.stop();
 
-    try {
-      await deps.hookManager.trigger("daemon-stop", { pid: process.pid });
-    } catch {
-      // Don't let hook failures block shutdown
-    }
-
     // Run registered skill shutdown hooks (e.g. meet-join session teardown)
     // before stopping the server so any HTTP round-trips and SSE emissions
     // still have live transports.

package/src/daemon/tool-side-effects.ts

@@ -7,9 +7,7 @@
  * registry entry instead of another if/else branch.
  */
 
-import { compileApp } from "../bundler/app-compiler.js";
 import { generateAppIcon } from "../media/app-icon-generator.js";
-import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
 import { deliverVerificationSlack } from "../runtime/verification-outbound-actions.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
@@ -39,41 +37,22 @@ export type PostExecutionHook = (
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
-/** Shared logic for refreshing app surfaces, broadcasting changes, and triggering auto-deploy. */
-function handleAppChange(
+/**
+ * Propagate an app change to connected clients and the publish pipeline.
+ *
+ * Compilation is the responsibility of the tool executor (see
+ * `executeAppCreate`, `executeAppRefresh`): executors own the source→dist
+ * transform and surface `compile_errors` in their result when it fails.
+ * Post-execution hooks only observe the outcome and notify — they must
+ * not re-run a compile because `compileApp()` begins with `rm -rf dist/`
+ * and would race with the executor's own output (LUM-1153).
+ */
+function notifyAppChanged(
   ctx: ToolSetupContext,
   appId: string,
   broadcastToAllClients: ((msg: ServerMessage) => void) | undefined,
   opts?: { fileChange?: boolean; status?: string },
 ): void {
-  const app = getApp(appId);
-
-  // Multifile apps need a recompile before refreshing surfaces so the
-  // WebView picks up the latest compiled output.
-  if (app && isMultifileApp(app)) {
-    const appDir = getAppDirPath(appId);
-    void compileApp(appDir)
-      .then((result) => {
-        if (!result.ok) {
-          log.warn(
-            { appId, errors: result.errors },
-            "Recompile failed on app change, serving stale dist/",
-          );
-        }
-        refreshSurfacesForApp(ctx, appId, opts);
-        broadcastToAllClients?.({ type: "app_files_changed", appId });
-        void updatePublishedAppDeployment(appId);
-      })
-      .catch((err) => {
-        log.warn({ appId, err }, "Recompile threw on app change");
-        // Still refresh surfaces with stale output
-        refreshSurfacesForApp(ctx, appId, opts);
-        broadcastToAllClients?.({ type: "app_files_changed", appId });
-        void updatePublishedAppDeployment(appId);
-      });
-    return;
-  }
-
   refreshSurfacesForApp(ctx, appId, opts);
   broadcastToAllClients?.({ type: "app_files_changed", appId });
   void updatePublishedAppDeployment(appId);
@@ -115,7 +94,7 @@ registerHook(
         // trigger live reload.
         ensureAppSourceWatcher();
 
-        handleAppChange(ctx, parsed.id, broadcastToAllClients);
+        notifyAppChanged(ctx, parsed.id, broadcastToAllClients);
 
         // Fire-and-forget: generate an app icon in the background.
         // When complete, broadcast again so clients pick up the new icon.
@@ -165,42 +144,12 @@ registerHook(
 );
 
 // Trigger surface refresh + broadcast when an app is refreshed.
-// If the executor already compiled (multifile path), skip the redundant
-// recompile and just refresh surfaces / broadcast / deploy directly.
 registerHook(
   "app_refresh",
-  (_name, input, result, { ctx, broadcastToAllClients }) => {
+  (_name, input, _result, { ctx, broadcastToAllClients }) => {
     const appId = input.app_id as string | undefined;
     if (!appId) return;
-
-    // executeAppRefresh already compiled multifile apps and included a
-    // "compiled" field in the result. Skip the expensive recompile and
-    // go straight to surface refresh + broadcast + deploy.
-    let alreadyCompiled = false;
-    try {
-      const parsed = JSON.parse(result.content) as { compiled?: boolean };
-      alreadyCompiled = parsed.compiled !== undefined;
-    } catch {
-      // Result wasn't valid JSON — fall through to handleAppChange.
-    }
-
-    if (alreadyCompiled) {
-      const opts = { fileChange: true };
-      refreshSurfacesForApp(ctx, appId, opts);
-      broadcastToAllClients?.({ type: "app_files_changed", appId });
-      void updatePublishedAppDeployment(appId);
-    } else {
-      handleAppChange(ctx, appId, broadcastToAllClients, { fileChange: true });
-    }
-  },
-);
-
-// Broadcast tasks_changed so connected clients (e.g. macOS Tasks window)
-// auto-refresh when the LLM mutates the task queue via tools
-registerHook(
-  ["task_list_add", "task_list_update", "task_list_remove", "task_queue_run"],
-  (_name, _input, _result, { broadcastToAllClients }) => {
-    broadcastToAllClients?.({ type: "tasks_changed" });
+    notifyAppChanged(ctx, appId, broadcastToAllClients, { fileChange: true });
   },
 );
 

package/src/daemon/web-search-history.ts

@@ -0,0 +1,126 @@
+import type {
+  ContentBlock,
+  Message,
+  ServerToolUseContent,
+  TextContent,
+  WebSearchToolResultContent,
+} from "../providers/types.js";
+
+export interface StripStats {
+  blocksStripped: number;
+  serverToolUsesDropped: number;
+  messagesModified: number;
+}
+
+export interface StripResult {
+  messages: Message[];
+  stats: StripStats;
+}
+
+/**
+ * Replaces every `web_search_tool_result` block in the message list with a
+ * plain `text` summary of its results, and drops the paired `server_tool_use`
+ * that produced it.
+ *
+ * Anthropic's `encrypted_content` tokens attached to each `web_search_result`
+ * are opaque server tokens with bounded validity (they expire and/or are
+ * route-scoped). Replaying a stale token produces
+ * `messages.N.content.M: Invalid encrypted_content in search_result block`.
+ * For historical turns the model does not need the opaque token to re-read
+ * the body — a title+url summary is sufficient to preserve context.
+ *
+ * Intended to run on `runMessages` immediately before the agent loop starts a
+ * new turn, at which point every `web_search_tool_result` in the list is by
+ * definition from a prior turn.
+ */
+export function stripHistoricalWebSearchResults(
+  messages: Message[],
+): StripResult {
+  const stats: StripStats = {
+    blocksStripped: 0,
+    serverToolUsesDropped: 0,
+    messagesModified: 0,
+  };
+
+  const next: Message[] = messages.map((msg) => {
+    const droppedServerToolUseIds = new Set<string>();
+    const transformed: ContentBlock[] = [];
+
+    for (const block of msg.content) {
+      if (block.type !== "web_search_tool_result") continue;
+      const wsr = block as WebSearchToolResultContent;
+      const query = findQueryForToolUseId(msg.content, wsr.tool_use_id);
+      transformed.push(formatAsText(wsr, query));
+      droppedServerToolUseIds.add(wsr.tool_use_id);
+      stats.blocksStripped++;
+    }
+
+    if (droppedServerToolUseIds.size === 0) return msg;
+
+    const rewritten: ContentBlock[] = [];
+    let wsrIndex = 0;
+    for (const block of msg.content) {
+      if (block.type === "server_tool_use") {
+        const stu = block as ServerToolUseContent;
+        if (droppedServerToolUseIds.has(stu.id)) {
+          stats.serverToolUsesDropped++;
+          continue;
+        }
+        rewritten.push(block);
+      } else if (block.type === "web_search_tool_result") {
+        rewritten.push(transformed[wsrIndex++]);
+      } else {
+        rewritten.push(block);
+      }
+    }
+
+    stats.messagesModified++;
+    return { ...msg, content: rewritten };
+  });
+
+  return { messages: next, stats };
+}
+
+function findQueryForToolUseId(
+  blocks: ContentBlock[],
+  toolUseId: string,
+): string | null {
+  for (const b of blocks) {
+    if (b.type !== "server_tool_use") continue;
+    const stu = b as ServerToolUseContent;
+    if (stu.id !== toolUseId) continue;
+    const q = stu.input?.query;
+    return typeof q === "string" ? q : null;
+  }
+  return null;
+}
+
+function formatAsText(
+  block: WebSearchToolResultContent,
+  query: string | null,
+): TextContent {
+  const header = query
+    ? `[Prior web_search results for "${query}":`
+    : "[Prior web_search results:";
+
+  const content = block.content;
+  if (!Array.isArray(content)) {
+    return { type: "text", text: `${header} (results unavailable)]` };
+  }
+
+  const entries = content
+    .filter(
+      (r): r is { type: string; title?: unknown; url?: unknown } =>
+        typeof r === "object" &&
+        r != null &&
+        (r as { type?: string }).type === "web_search_result",
+    )
+    .map((r, i) => {
+      const title = typeof r.title === "string" ? r.title : "(untitled)";
+      const url = typeof r.url === "string" ? r.url : "";
+      return url ? `${i + 1}. ${title}\n   ${url}` : `${i + 1}. ${title}`;
+    });
+
+  const body = entries.length > 0 ? entries.join("\n") : "(no results)";
+  return { type: "text", text: `${header}\n${body}]` };
+}

package/src/events/domain-events.ts

@@ -22,7 +22,6 @@ export interface ToolDomainEvents {
       | "allow_10m"
       | "allow_conversation"
       | "always_allow"
-      | "always_allow_high_risk"
       | "deny"
       | "always_deny"
       | "temporary_override";

package/src/filing/filing-service.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getConfig } from "../config/loader.js";
-import type { Speed } from "../config/schemas/inference.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
@@ -17,23 +17,24 @@ const FILING_PROMPT_TEMPLATE = `You are running a periodic knowledge base filing
 ## Part 1: File the buffer
 
 Read \`pkb/buffer.md\`. For each item in the buffer:
-1. Determine which topic file it belongs in. Check \`pkb/INDEX.md\` to see what topic files exist.
-2. Read the target topic file, then append or integrate the new fact.
+1. Determine which topic file(s) it belongs in. Check \`pkb/INDEX.md\` to see what topic files exist.
+2. Read the target topic file(s), then integrate the new fact.
 3. If the fact is important enough to always be in context, add it to \`pkb/essentials.md\` instead.
 4. If the fact is a commitment, follow-up, or active project, add it to \`pkb/threads.md\`.
 5. If no existing topic file fits, create a new one and update \`pkb/INDEX.md\`.
+6. If the topic file is getting too long (>1500 tokens), compress it or split it into multiple topic files.
 
 After all items are filed, clear the processed items from \`pkb/buffer.md\` (leave the file empty, don't delete it).
 
-## Part 2: Nest
+## Part 2: Review
 
-Pick 1-2 topic files from your knowledge base and review them:
+Pick 3 random topic files from your knowledge base and review them:
 - Is the information still accurate and up to date?
 - Are there duplicates that should be consolidated?
 - Is anything important enough to promote to \`pkb/essentials.md\`?
 - Is anything in \`pkb/essentials.md\` that's no longer essential? Demote it to a topic file.
 - Are any threads in \`pkb/threads.md\` completed or stale? Remove them.
-- Is any file getting too long? Consider splitting it.
+- Is any file getting too long (>1500 tokens)? Strongly consider compressing it or splitting it into multiple topic files.
 - Should any topic file be restructured for clarity?
 
 Make improvements as you see fit. This is your knowledge base — keep it sharp.`;
@@ -42,7 +43,7 @@ export interface FilingDeps {
   processMessage: (
     conversationId: string,
     content: string,
-    options?: { speed?: Speed },
+    options?: { callSite?: LLMCallSite },
   ) => Promise<{ messageId: string }>;
   onConversationCreated?: (info: {
     conversationId: string;
@@ -190,8 +191,6 @@ export class FilingService {
     log.info("Running filing job");
 
     try {
-      const config = getConfig().filing;
-
       const conversation = bootstrapConversation({
         conversationType: "background",
         source: "filing",
@@ -206,7 +205,7 @@ export class FilingService {
       });
 
       await this.deps.processMessage(conversation.id, FILING_PROMPT_TEMPLATE, {
-        speed: config.speed,
+        callSite: "filingAgent",
       });
 
       log.info({ conversationId: conversation.id }, "Filing job completed");