@vellumai/assistant 0.7.3 → 0.8.1

package/src/context/window-manager.ts

@@ -32,6 +32,19 @@ const COMPACTION_TOOL_RESULT_MAX_CHARS = 6_000;
 const MIN_COMPACTABLE_PERSISTED_MESSAGES = 2;
 const INTERNAL_CONTEXT_SUMMARY_MESSAGES = new WeakSet<Message>();
 
+/**
+ * Hard cap on the verbatim tail-anchor block we splice into the
+ * post-compaction summary message (see `extractTailAssistantText`). 1500
+ * chars (~375 tokens) covers a few paragraphs of recent assistant
+ * narration without bloating the summary. When the tail exceeds this
+ * size we keep the END (most recent text), since "next step" / "now I'll
+ * …" statements typically live at the end of the assistant's last text
+ * block and that's the part the post-compaction model needs most.
+ */
+const TAIL_ANCHOR_MAX_CHARS = 1500;
+const TAIL_ANCHOR_OPEN_TAG = "<verbatim_tail>";
+const TAIL_ANCHOR_CLOSE_TAG = "</verbatim_tail>";
+
 /**
  * When the existing summary is this fraction or more of the per-summary
  * token budget, inject a "compress older content aggressively" instruction
@@ -488,13 +501,45 @@ export class ContextWindowManager {
       };
     }
 
-    const keepPlan = this.pickKeepBoundary(messages, userTurnStarts, {
+    const keepPlanInitial = this.pickKeepBoundary(messages, userTurnStarts, {
       minKeepRecentUserTurns: options?.minKeepRecentUserTurns,
       targetInputTokensOverride: options?.targetInputTokensOverride,
       conversationOriginChannel: options?.conversationOriginChannel,
       force: options?.force,
       previousEstimatedInputTokens,
     });
+    // Under force (user-explicit `/compact`), never route through the
+    // "already fits" / "truncated tool results without summarization"
+    // early-return — those are no-op responses to a direct user command.
+    // The boundary can collapse to the summary in two cases the
+    // projection-optimism clamp in pickKeepBoundary does not cover:
+    //   1. `adjustForToolPairs` walked the boundary back through a
+    //      tool_use/tool_result chain at the start of the conversation.
+    //   2. The binary search settled below `userTurnStarts.length` (so
+    //      the clamp at the top of pickKeepBoundary did not fire) but
+    //      `adjustForToolPairs` still walked the resulting boundary
+    //      backwards past `summaryOffset`.
+    // Rescue: restore the binary search's intended keep depth (capped at
+    // `length - 1` so we always summarize at least one turn) and bypass
+    // `adjustForToolPairs`. The kept region's first message may then
+    // contain a `tool_result` whose matching `tool_use` lives in the
+    // compacted region; we strip such orphans below before assembling
+    // the final messages array so the next agent turn does not fail
+    // when sending to the LLM.
+    const forceRescueApplied =
+      options?.force === true &&
+      keepPlanInitial.keepFromIndex <= summaryOffset &&
+      userTurnStarts.length >= 2;
+    const safeKeepTurns = Math.max(
+      1,
+      Math.min(keepPlanInitial.keepTurns, userTurnStarts.length - 1),
+    );
+    const keepPlan = forceRescueApplied
+      ? {
+          keepFromIndex: userTurnStarts[userTurnStarts.length - safeKeepTurns],
+          keepTurns: safeKeepTurns,
+        }
+      : keepPlanInitial;
     if (keepPlan.keepFromIndex <= summaryOffset) {
       // All turns fit after truncation projection, but the real in-memory
       // messages may still contain un-truncated tool results. Apply truncation
@@ -511,6 +556,14 @@ export class ContextWindowManager {
             toolTokenBudget: this.toolTokenBudget,
           })
         : previousEstimatedInputTokens;
+      // Under force with only one user turn, the rescue above could not
+      // fire — there is nothing earlier to summarize. Surface that
+      // explicitly instead of "conversation already fits..." so the user
+      // knows why `/compact` did not produce a summary.
+      const noSummarizationReason =
+        options?.force && userTurnStarts.length < 2
+          ? "only one user turn — nothing earlier to compact"
+          : "conversation already fits within the compaction target";
       return {
         messages: truncatedMessages,
         compacted: didTruncate,
@@ -527,7 +580,7 @@ export class ContextWindowManager {
         summaryText: existingSummary ?? "",
         reason: didTruncate
           ? "truncated tool results without summarization"
-          : "conversation already fits within the compaction target",
+          : noSummarizationReason,
       };
     }
 
@@ -645,9 +698,15 @@ export class ContextWindowManager {
       };
     }
 
+    // `severePressure` already bypasses this guard to keep context from
+    // overflowing. Forced compaction also bypasses: when the user
+    // explicitly types `/compact` we must summarize whatever is
+    // available rather than return "insufficient compactable persisted
+    // messages" — that is a no-op response to a direct user command.
     if (
       compactedPersistedMessages < MIN_COMPACTABLE_PERSISTED_MESSAGES &&
-      !severePressure
+      !severePressure &&
+      !options?.force
     ) {
       return {
         messages,
@@ -688,7 +747,6 @@ export class ContextWindowManager {
       signal,
       options?.overrideProfile ?? null,
     );
-    const summary = summaryUpdate.summary;
     const summaryInputTokens = summaryUpdate.inputTokens;
     const summaryOutputTokens = summaryUpdate.outputTokens;
     const summaryModel = summaryUpdate.model;
@@ -704,6 +762,19 @@ export class ContextWindowManager {
     }
     const summaryCalls = 1;
 
+    // Force-keep the most recent assistant text from the compactable region
+    // by splicing it verbatim into the summary message. This is independent
+    // of what the LLM summarizer chose to surface — when compaction
+    // interrupts a long assistant work span, this anchor preserves the
+    // model's last self-narration ("Next step: …", "About to …") so the
+    // post-compaction model has unambiguous continuity instead of falling
+    // back to a "where am I?" recovery shape.
+    const tailAnchorText = extractTailAssistantText(compactableMessages);
+    const summary =
+      tailAnchorText != null
+        ? appendTailAnchorToSummary(summaryUpdate.summary, tailAnchorText)
+        : summaryUpdate.summary;
+
     // Media (images, files) in kept turns is preserved naturally — those
     // turns are carried forward as-is and their token cost is already
     // accounted for by pickKeepBoundary's estimatePromptTokens call.
@@ -716,7 +787,14 @@ export class ContextWindowManager {
         messages.slice(keepPlan.keepFromIndex),
         COMPACTION_TOOL_RESULT_MAX_CHARS,
       );
-    const compactedMessages = [summaryMessage, ...truncatedKeptMessages];
+    // The force-rescue boundary bypasses `adjustForToolPairs`, so the
+    // kept region may contain `tool_result` blocks whose matching
+    // `tool_use` is in the (now-compacted) prefix. Strip those orphans
+    // so the next agent turn does not fail with an LLM API error.
+    const keptMessages = forceRescueApplied
+      ? stripOrphanToolResults(truncatedKeptMessages)
+      : truncatedKeptMessages;
+    const compactedMessages = [summaryMessage, ...keptMessages];
     const estimatedInputTokens = estimatePromptTokens(
       compactedMessages,
       this.systemPrompt,
@@ -1251,6 +1329,53 @@ function adjustForToolPairs(
   return idx;
 }
 
+/**
+ * Strip `tool_result` blocks whose matching `tool_use` is not present in
+ * the message array. Used by the force-rescue path in `_maybeCompact`
+ * which bypasses `adjustForToolPairs` to honor user-explicit `/compact`
+ * commands — the kept region's first user message can otherwise contain
+ * an orphan `tool_result`, which the LLM API rejects.
+ *
+ * A user message that contains only orphan `tool_result` blocks is
+ * dropped entirely; partial messages keep the surviving content blocks.
+ */
+function stripOrphanToolResults(messages: Message[]): Message[] {
+  const knownToolUseIds = new Set<string>();
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const block of msg.content) {
+      if (
+        (block.type === "tool_use" || block.type === "server_tool_use") &&
+        "id" in block
+      ) {
+        knownToolUseIds.add((block as { id: string }).id);
+      }
+    }
+  }
+
+  return messages.flatMap((msg) => {
+    if (msg.role !== "user") return [msg];
+    let stripped = false;
+    const filtered = msg.content.filter((block) => {
+      if (
+        (block.type === "tool_result" ||
+          block.type === "web_search_tool_result") &&
+        "tool_use_id" in block
+      ) {
+        const id = (block as { tool_use_id: string }).tool_use_id;
+        if (!knownToolUseIds.has(id)) {
+          stripped = true;
+          return false;
+        }
+      }
+      return true;
+    });
+    if (!stripped) return [msg];
+    if (filtered.length === 0) return [];
+    return [{ ...msg, content: filtered }];
+  });
+}
+
 export function getSummaryFromContextMessage(
   message: Message | undefined,
 ): string | null {
@@ -1286,6 +1411,67 @@ export function createContextSummaryMessage(summary: string): Message {
   return message;
 }
 
+/**
+ * Walk `messages` backward and return the concatenated text content of the
+ * most recent assistant message that contains at least one non-empty text
+ * block. tool_use / tool_result / image / unknown blocks are skipped. The
+ * result is trimmed and (if longer than `maxChars`) clamped from the START
+ * so the END — where "next step" / "now I'll …" narration tends to land —
+ * is preserved.
+ *
+ * Returns `null` when no eligible assistant text is found (e.g. compactable
+ * region was all user/tool messages, or all assistant messages were
+ * tool_use-only). The caller treats `null` as "no anchor to splice".
+ *
+ * Used by `_maybeCompact` to force-keep the last assistant text from the
+ * compactable region into the post-compaction summary message, so the
+ * model's most recent self-narration survives summarization regardless of
+ * whether the LLM summarizer chose to surface it.
+ */
+export function extractTailAssistantText(
+  messages: Message[],
+  maxChars: number = TAIL_ANCHOR_MAX_CHARS,
+): string | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "assistant") continue;
+    const text = extractText(message.content).trim();
+    if (text.length === 0) continue;
+    if (text.length <= maxChars) return text;
+    // Keep the END — most recent narration wins.
+    const truncated = safeStringSlice(
+      text,
+      text.length - maxChars,
+      text.length,
+    );
+    return `[...truncated] ${truncated}`;
+  }
+  return null;
+}
+
+/**
+ * Splice a verbatim tail-anchor block onto the end of the LLM-produced
+ * summary text. The tag-wrapped block is structurally distinct from any
+ * `## ` section the LLM might generate, so it survives section-boundary
+ * clamping in `clampSummaryAtSectionBoundary` (which only runs on the LLM
+ * summary itself, before this splice).
+ *
+ * Idempotent: if the summary already ends with a `<verbatim_tail>…` block
+ * (e.g. from a prior compaction whose summary was carried forward as
+ * `existingSummary`), it is replaced rather than stacked, so successive
+ * compactions don't accumulate stale tails.
+ */
+export function appendTailAnchorToSummary(
+  summary: string,
+  tailText: string,
+): string {
+  const trimmed = summary.trimEnd();
+  const existingOpen = trimmed.lastIndexOf(TAIL_ANCHOR_OPEN_TAG);
+  const base =
+    existingOpen >= 0 ? trimmed.slice(0, existingOpen).trimEnd() : trimmed;
+  return `${base}\n\n${TAIL_ANCHOR_OPEN_TAG}\n${tailText.trim()}\n${TAIL_ANCHOR_CLOSE_TAG}`;
+}
+
 /**
  * Build content blocks for the summary prompt. Returns a mix of text blocks
  * (for the scaffolding, existing summary, and serialized non-image content)

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -56,6 +56,16 @@ let autoAnalyzeEnabled = true;
 // `disposeConversation` must skip the `graph_extract` enqueue.
 const autoAnalysisConversations = new Set<string>();
 
+// Toggles the `memory.v2.enabled` flag the disposal code reads via
+// `getConfig()`. Defaults to false so the bulk of the suite — which asserts
+// v1 graph_extract still fires — keeps its semantics. The dedicated v2 cases
+// flip this to true.
+let v2Enabled = false;
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: v2Enabled } } }),
+}));
+
 mock.module("../../memory/auto-analysis-guard.js", () => ({
   AUTO_ANALYSIS_SOURCE: "auto-analysis",
   isAutoAnalysisConversation: (conversationId: string) =>
@@ -81,6 +91,27 @@ mock.module("../../memory/auto-analysis-enqueue.js", () => ({
   },
 }));
 
+let memoryRetroEnabled = false;
+const memoryRetroCalls: Array<{
+  conversationId: string;
+  trigger: string;
+}> = [];
+
+mock.module("../../memory/memory-retrospective-enqueue.js", () => ({
+  enqueueMemoryRetrospectiveIfEnabled: (args: {
+    conversationId: string;
+    trigger: string;
+  }) => {
+    if (!memoryRetroEnabled) return;
+    memoryRetroCalls.push(args);
+  },
+  // Also export sibling functions other modules import from this file, so
+  // mocking it here doesn't break transitive imports loaded during the
+  // `disposeConversation` dynamic-import chain.
+  enqueueMemoryRetrospectiveOnCompaction: () => {},
+  isMemoryRetrospectiveConversation: (_id: string) => false,
+}));
+
 // Stub all side-effecting cleanup helpers that disposeConversation chains
 // into after the enqueue block. We assert on enqueue behavior only.
 mock.module("../../tools/browser/browser-screencast.js", () => ({
@@ -158,8 +189,11 @@ describe("disposeConversation — auto-analysis enqueue", () => {
   beforeEach(() => {
     memoryJobCalls.length = 0;
     autoAnalyzeCalls.length = 0;
+    memoryRetroCalls.length = 0;
     autoAnalyzeEnabled = true;
+    memoryRetroEnabled = false;
     autoAnalysisConversations.clear();
+    v2Enabled = false;
   });
 
   test("guardian conversation with auto-analyze ON — enqueues both graph_extract and conversation_analyze (via helper)", () => {
@@ -313,4 +347,81 @@ describe("disposeConversation — auto-analysis enqueue", () => {
     }));
     autoAnalyzeEnabled = originalEnabled;
   });
+
+  test("memory v2 enabled — graph_extract enqueue is suppressed (auto-analysis still runs)", () => {
+    // Under memory v2, the v1 graph has no readers (retrieval is bypassed at
+    // conversation-graph-memory.ts), so producing extraction jobs just fills
+    // the queue with stale work. Auto-analysis is orthogonal and must keep
+    // running.
+    v2Enabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-v2-on",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryJobCalls).toHaveLength(0);
+    expect(autoAnalyzeCalls).toHaveLength(1);
+    expect(autoAnalyzeCalls[0]).toEqual({
+      conversationId: "conv-v2-on",
+      trigger: "lifecycle",
+    });
+  });
+});
+
+describe("disposeConversation — memory-retrospective lifecycle safety net", () => {
+  beforeEach(() => {
+    memoryJobCalls.length = 0;
+    autoAnalyzeCalls.length = 0;
+    memoryRetroCalls.length = 0;
+    autoAnalyzeEnabled = false;
+    memoryRetroEnabled = false;
+    autoAnalysisConversations.clear();
+    v2Enabled = false;
+  });
+
+  test("guardian conversation + flag on — enqueues memory-retrospective with trigger 'lifecycle'", () => {
+    memoryRetroEnabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryRetroCalls).toHaveLength(1);
+    expect(memoryRetroCalls[0]).toEqual({
+      conversationId: "conv-retro",
+      trigger: "lifecycle",
+    });
+  });
+
+  test("flag off — no memory-retrospective enqueue", () => {
+    memoryRetroEnabled = false;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro-off",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryRetroCalls).toHaveLength(0);
+  });
+
+  test("untrusted actor — no memory-retrospective enqueue even when flag is on", () => {
+    memoryRetroEnabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro-untrusted",
+      trustClass: "unknown",
+    });
+
+    disposeConversation(ctx);
+
+    // The outer trust-class guard in disposeConversation gates ALL three
+    // enqueues (graph_extract, auto-analyze, memory-retrospective). When
+    // the actor is untrusted, none of them fire.
+    expect(memoryRetroCalls).toHaveLength(0);
+    expect(autoAnalyzeCalls).toHaveLength(0);
+  });
 });

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -20,10 +20,11 @@
  * hasNoClient flag.
  *
  * Cross-client exception: tools whose capabilities are in
- * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file) are allowed for
- * non-host-proxy interfaces (e.g. "web") when at least one capable client
- * is connected via the event hub. host_browser is excluded (chrome-extension
- * is its own executor; web turns have no CDP target model).
+ * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file, host_browser)
+ * are allowed for non-host-proxy interactive interfaces ("web", "ios")
+ * when at least one capable client is connected via the event hub.
+ * chrome-extension is excluded as a security boundary, regardless of
+ * whether the capability is technically supported elsewhere.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -358,6 +359,110 @@ describe("isToolActiveForContext — cross-client exposure for host_file_*", ()
   });
 });
 
+describe("isToolActiveForContext — cross-client exposure for host_browser", () => {
+  // host_browser cross-client routing was shipped in PR #27489 (host-
+  // browser-via-macos-host-proxy); LLM-exposure for non-host-proxy
+  // transports is added by including "host_browser" in
+  // CROSS_CLIENT_EXPOSED_CAPABILITIES. Web and iOS turns can now drive a
+  // connected macOS or chrome-extension client via the event hub.
+  test("host_browser is exposed for web transport when a host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser is exposed for ios transport when a host_browser client is connected", () => {
+    // INTERACTIVE_INTERFACES = {macos, ios, web}; ios goes through the same
+    // cross-client branch as web because supportsHostProxy("ios", *) is
+    // false. This pins the parity guarantee.
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "ios" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser is NOT exposed for web when no host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser is NOT exposed for ios when no host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "ios" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser is NOT exposed when hasNoClient is true (no approval UI)", () => {
+    // hasNoClient gate: cross-client exception must not bypass this.
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: true, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser for macos transport is unaffected by the cross-client exception", () => {
+    // macos natively supports host_browser via host proxy — the
+    // supportsHostProxy check passes, so the cross-client branch is never
+    // reached.
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "macos" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser for chrome-extension transport is unaffected by the cross-client exception", () => {
+    // chrome-extension natively supports host_browser via its own
+    // executor (supportsHostProxy("chrome-extension", "host_browser")
+    // returns true), so the cross-client branch is never reached. The
+    // hasNoClient gate is also bypassed for chrome-extension transports
+    // because the extension provides its own approval UI.
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: true, transportInterface: "chrome-extension" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("listClientsByCapability is queried with host_browser, not host_bash or host_file (per-capability invariant)", () => {
+    // Defense against any future regression that hardcodes a different
+    // capability in the cross-client check. Only host_browser-capable
+    // clients should satisfy host_browser exposure.
+    mockClientCountByCapability.set("host_bash", 1);
+    mockClientCountByCapability.set("host_file", 1);
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+});
+
 describe("HOST_TOOL_NAMES derivation", () => {
   test("HOST_TOOL_NAMES is derived from HOST_TOOL_TO_CAPABILITY", () => {
     // Sanity check: every tool in the names set has a capability mapping.

package/src/daemon/__tests__/daemon-skill-host.test.ts

@@ -23,8 +23,9 @@ const loggerSpy = {
   warn: mock(() => {}),
   error: mock(() => {}),
 };
+const getLoggerSpy = mock((_name: string) => loggerSpy);
 mock.module("../../util/logger.js", () => ({
-  getLogger: () => loggerSpy,
+  getLogger: getLoggerSpy,
 }));
 
 mock.module("../../config/loader.js", () => ({
@@ -163,12 +164,13 @@ describe("createDaemonSkillHost", () => {
     expect(host.speakers).toBeDefined();
   });
 
-  test("logger.get returns an object with the four severity methods", () => {
+  test("logger.get prefixes the scope with the skillId", () => {
     const log = host.logger.get("test-scope");
     log.debug("d", { k: "v" });
     log.info("i");
     log.warn("w");
     log.error("e");
+    expect(getLoggerSpy).toHaveBeenCalledWith("meet-join:test-scope");
     expect(loggerSpy.debug).toHaveBeenCalled();
     expect(loggerSpy.info).toHaveBeenCalled();
     expect(loggerSpy.warn).toHaveBeenCalled();
@@ -255,8 +257,12 @@ describe("createDaemonSkillHost", () => {
     });
     expect(handle).toBeDefined();
     expect(registerSkillRouteSpy).toHaveBeenCalled();
-    host.registries.registerShutdownHook("test-hook", async () => {});
-    expect(registerShutdownHookSpy).toHaveBeenCalled();
+    const hook = async () => {};
+    host.registries.registerShutdownHook("test-hook", hook);
+    expect(registerShutdownHookSpy).toHaveBeenCalledWith(
+      "meet-join:test-hook",
+      hook,
+    );
   });
 
   test("speakers.createTracker yields a concrete tracker instance", () => {

package/src/daemon/approval-generators.ts

@@ -1,6 +1,6 @@
 import { loadConfig } from "../config/loader.js";
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
-import { getProvider, listProviders } from "../providers/registry.js";
+import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
+import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import type { Provider } from "../providers/types.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
@@ -79,15 +79,18 @@ const VALID_DISPOSITIONS: ReadonlySet<string> = new Set([
 export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
   return async (context, options = {}) => {
     const config = loadConfig();
-    let baseProvider: Provider;
-    try {
-      baseProvider = getProvider(config.llm.default.provider);
-    } catch {
-      return null;
-    }
+    // Connection-aware default-provider resolution. Throws
+    // `ConnectionResolutionError` on hard config errors (missing /
+    // unknown / mismatched connection). Returns null on soft credential
+    // failures (vault miss, transient auth) — we treat null as "no
+    // provider available" and skip generating copy.
+    const baseProvider: Provider | null = await resolveDefaultProvider(config);
+    if (!baseProvider) return null;
     // Wrap so per-call `callSite` can route to an alternative provider
     // transport when `llm.callSites.<id>.provider` overrides the default.
-    const provider = wrapWithCallSiteRouting(baseProvider);
+    // The `wrapWithCallSiteRouting` helper threads `config` through so the
+    // wrapper's per-call resolution is also connection-aware.
+    const provider = wrapWithCallSiteRouting(baseProvider, config);
 
     const fallbackText =
       options.fallbackText?.trim() || getFallbackMessage(context);
@@ -136,12 +139,19 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
 export function createApprovalConversationGenerator(): ApprovalConversationGenerator {
   return async (context) => {
     const config = loadConfig();
-    if (!listProviders().includes(config.llm.default.provider)) {
+    // Connection-aware default + per-call routing. `resolveDefaultProvider`
+    // throws `ConnectionResolutionError` on hard config errors (missing /
+    // unknown / mismatched connection) and returns null on soft credential
+    // failures (vault miss, transient auth) — we treat null as "no
+    // provider available" and throw a domain-specific error below. We do
+    // not pre-gate on `listProviders()` because the default provider lives
+    // behind a `provider_connection` and never appears in the registry's
+    // initialization-time provider list.
+    const baseProvider = await resolveDefaultProvider(config);
+    if (!baseProvider) {
       throw new Error("No provider available for approval conversation");
     }
-    const provider = wrapWithCallSiteRouting(
-      getProvider(config.llm.default.provider),
-    );
+    const provider = wrapWithCallSiteRouting(baseProvider, config);
 
     const pendingDescription = context.pendingApprovals
       .map((p) => `- Request ${p.requestId}: tool "${p.toolName}"`)
@@ -212,19 +222,3 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     return result;
   };
 }
-
-/**
- * Wrap a base Provider so per-call `callSite` metadata can route the actual
- * transport to a different provider when `llm.callSites.<id>.provider`
- * differs from the default. Without this wrapper, only request metadata
- * reflects the callSite — the HTTP transport stays bound to the default.
- */
-function wrapWithCallSiteRouting(base: Provider): Provider {
-  return new CallSiteRoutingProvider(base, (name) => {
-    try {
-      return getProvider(name);
-    } catch {
-      return undefined;
-    }
-  });
-}

package/src/daemon/config-watcher.ts

@@ -18,6 +18,7 @@ import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
 import { resetCleanupScheduleThrottle } from "../memory/cleanup-schedule-state.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
+import { invalidateLlmRequestLogSourceCache } from "../memory/llm-request-log-source.js";
 import { initializeProviders } from "../providers/registry.js";
 import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
@@ -140,6 +141,7 @@ export class ConfigWatcher {
       return false;
     }
     clearEmbeddingBackendCache();
+    invalidateLlmRequestLogSourceCache();
     // If cleanup retention settings changed, reset the cleanup scheduler
     // throttle so the next worker tick re-enqueues jobs with the new values
     // instead of waiting out the remaining enqueueIntervalMs (default 6h).