@vellumai/assistant 0.7.3 → 0.8.1

package/src/daemon/conversation-lifecycle.ts

@@ -4,6 +4,7 @@
  * can delegate without exposing its full surface.
  */
 
+import { getConfig } from "../config/loader.js";
 import { createContextSummaryMessage } from "../context/window-manager.js";
 import type { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
@@ -16,6 +17,7 @@ import {
   type MessageRow,
 } from "../memory/conversation-crud.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -182,6 +184,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
   }
 
+  const personalMemoryAllowed = !isUntrustedTrustClass(trustClass);
   const parsedMessages: Message[] = dbMessages
     .slice(ctx.contextCompactedMessageCount)
     .map((m, index, arr) => {
@@ -214,7 +217,8 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
           // shape right-to-left, since each prepend shifts previously-
           // prepended blocks one slot right:
           //   [<workspace>, <turn_context>, <NOW.md>, <memory __injected>,
-          //    <system_reminder>, <knowledge_base>, ...original]
+          //    <memory>\n…</memory>, <system_reminder>, <knowledge_base>,
+          //    ...original]
           //
           // Persisted non-tail rows rehydrate the full set so Anthropic's
           // prefix cache keeps matching msg[0] across daemon restarts and
@@ -237,15 +241,37 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
             ];
           }
 
+          // The v2 static memory block (essentials/threads/recent/buffer
+          // wrapped in `<memory>…</memory>`) carries personal user memory.
+          // Trust-gated to mirror `shouldExposePersonalMemory` at injection
+          // time — untrusted-actor views must not read persisted personal
+          // memory back through metadata. Skipped on the tail row because
+          // the next turn re-injects fresh content on full-mode turns.
+          if (
+            !isTail &&
+            personalMemoryAllowed &&
+            typeof meta.memoryV2StaticBlock === "string"
+          ) {
+            content = [
+              { type: "text" as const, text: meta.memoryV2StaticBlock },
+              ...content,
+            ];
+          }
+
           // Memory remains rehydrated on all rows (existing behavior).
           // Strip any pre-existing wrapper before re-wrapping so historical
           // rows persisted with the wrapper (v2 path before the
           // injectedBlockText contract was unified with v1's unwrapped form)
-          // don't render double-wrapped after rehydrate.
+          // don't render double-wrapped after rehydrate. Only unwrap when
+          // the full <memory>...</memory> pair is present so we don't mutate
+          // legitimate unwrapped payloads that happen to start with
+          // "<memory>\n" or end with "\n</memory>".
           if (typeof meta.memoryInjectedBlock === "string") {
-            const inner = meta.memoryInjectedBlock
-              .replace(/^<memory>\n/, "")
-              .replace(/\n<\/memory>$/, "");
+            const block = meta.memoryInjectedBlock;
+            const inner =
+              block.startsWith("<memory>\n") && block.endsWith("\n</memory>")
+                ? block.slice("<memory>\n".length, -"\n</memory>".length)
+                : block;
             content = [
               {
                 type: "text" as const,
@@ -373,16 +399,29 @@ export function disposeConversation(ctx: DisposeContext): void {
       // Best-effort — don't block conversation disposal
     }
     if (!isAutoAnalysis) {
+      // Suppress v1 graph extraction when memory v2 is active — v2 reads
+      // from buffer.md and concept pages, so the v1 graph would be stale
+      // data nobody consumes. Mirrors the gate applied in `indexer.ts`
+      // for the per-message indexing path. Fail open to v1 if config
+      // can't load, since the worker handler also short-circuits.
+      let v2Enabled = false;
       try {
-        enqueueMemoryJob("graph_extract", {
-          conversationId: ctx.conversationId,
-          scopeId: "default",
-          ...(ctx.activeContextNodeIds?.length
-            ? { activeContextNodeIds: ctx.activeContextNodeIds }
-            : {}),
-        });
+        v2Enabled = getConfig().memory.v2.enabled;
       } catch {
-        // Best-effort — don't block conversation disposal
+        // Best-effort — fall through to legacy v1 enqueue
+      }
+      if (!v2Enabled) {
+        try {
+          enqueueMemoryJob("graph_extract", {
+            conversationId: ctx.conversationId,
+            scopeId: "default",
+            ...(ctx.activeContextNodeIds?.length
+              ? { activeContextNodeIds: ctx.activeContextNodeIds }
+              : {}),
+          });
+        } catch {
+          // Best-effort — don't block conversation disposal
+        }
       }
     }
 
@@ -397,6 +436,22 @@ export function disposeConversation(ctx: DisposeContext): void {
     } catch {
       // Best-effort — don't block conversation disposal
     }
+
+    try {
+      // Memory-retrospective lifecycle safety-net. The periodic triggers
+      // (interval / message_count / pre-compaction) handle the common
+      // path; lifecycle catches the gap between the last interval fire
+      // and conversation eviction. The job's `no_new_messages` early
+      // return makes this a cheap no-op when the periodic path already
+      // covered things. `enqueueMemoryRetrospectiveIfEnabled` has its
+      // own internal recursion guard.
+      enqueueMemoryRetrospectiveIfEnabled({
+        conversationId: ctx.conversationId,
+        trigger: "lifecycle",
+      });
+    } catch {
+      // Best-effort — don't block conversation disposal
+    }
   }
 
   abortConversation(

package/src/daemon/conversation-process.ts

@@ -12,6 +12,7 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
+  type InterfaceId,
   parseChannelId,
   parseInterfaceId,
   type TurnChannelContext,
@@ -179,7 +180,9 @@ export interface ProcessConversationContext {
     statusText?: string,
   ): void;
   /** Force context compaction regardless of threshold/cooldown. */
-  forceCompact(): Promise<ContextWindowResult>;
+  forceCompact(options?: {
+    targetInputTokensOverride?: number;
+  }): Promise<ContextWindowResult>;
   /** Set transport-derived hints for the conversation. */
   setTransportHints(hints: string[] | undefined): void;
   /** IANA timezone reported by the active client for the current turn. */
@@ -195,6 +198,13 @@ export interface ProcessConversationContext {
   applyClientTimezoneFromTransport(
     transport: ConversationTransportMetadata,
   ): void;
+  /**
+   * Instantiate host proxies for capabilities that have become reachable
+   * mid-queue (e.g. a macOS client connected after a web turn was enqueued
+   * without a proxy). Called from drain paths before preactivation so skills
+   * are only activated when the proxy that services them is present.
+   */
+  ensureHostProxiesForTurn(sourceInterface: InterfaceId | undefined): void;
 }
 
 function resolveQueuedTurnContext(
@@ -432,19 +442,19 @@ async function drainSingleMessage(
     conversation.applyClientTimezoneFromTransport(next.transport);
   }
 
-  // Re-preactivate host-proxy skills for interactive desktop turns. The
-  // dequeue path reset `preactivatedSkillIds` above, so without these
-  // re-adds the relevant skill tools wouldn't be projected to the LLM
-  // for queued messages 2+ even though the underlying proxies (HostCuProxy,
-  // HostAppControlProxy) are still attached. Mirrors the per-message
-  // instantiation block in `conversation-routes.ts` / `process-message.ts`.
+  // Re-attach and re-preactivate host-proxy skills for interactive turns.
+  // The dequeue path reset `preactivatedSkillIds` above; without these
+  // re-adds the relevant skill tools won't be projected to the LLM for
+  // queued messages 2+. Also instantiates proxies that may not have been
+  // present when the message was first enqueued (e.g. a macOS client
+  // connects between enqueue and drain). Mirrors the per-message block in
+  // `conversation-routes.ts` / `process-message.ts`.
   if (next.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    preactivateHostProxySkills(
-      conversation,
-      interfaceCtx?.userMessageInterface,
-    );
+    const sourceInterface = interfaceCtx?.userMessageInterface;
+    conversation.ensureHostProxiesForTurn(sourceInterface);
+    preactivateHostProxySkills(conversation, sourceInterface);
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -628,7 +638,9 @@ async function drainSingleMessage(
         "assistant_turn",
         next.requestId,
       );
-      const result = await conversation.forceCompact();
+      const result = await conversation.forceCompact({
+        targetInputTokensOverride: slashResult.targetInputTokensOverride,
+      });
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);
@@ -875,15 +887,14 @@ async function drainBatch(
     conversation.applyClientTimezoneFromTransport(head.transport);
   }
 
-  // Re-preactivate host-proxy skills for interactive desktop turns.
+  // Re-attach and re-preactivate host-proxy skills for interactive turns.
   // Mirrors the single-message path exactly — sourced from `head`.
   if (head.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    preactivateHostProxySkills(
-      conversation,
-      interfaceCtx?.userMessageInterface,
-    );
+    const sourceInterface = interfaceCtx?.userMessageInterface;
+    conversation.ensureHostProxiesForTurn(sourceInterface);
+    preactivateHostProxySkills(conversation, sourceInterface);
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -1314,7 +1325,11 @@ export async function processMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      onEvent({ type: "assistant_text_delta", text: replyText });
+      onEvent({
+        type: "assistant_text_delta",
+        text: replyText,
+        conversationId: conversation.conversationId,
+      });
       onEvent({
         type: "message_complete",
         conversationId: conversation.conversationId,
@@ -1474,7 +1489,9 @@ export async function processMessage(
         "assistant_turn",
         requestId,
       );
-      const result = await conversation.forceCompact();
+      const result = await conversation.forceCompact({
+        targetInputTokensOverride: slashResult.targetInputTokensOverride,
+      });
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);

package/src/daemon/conversation-runtime-assembly.ts

@@ -1641,12 +1641,15 @@ const RUNTIME_INJECTION_PREFIXES = [
   // blocks persist in history so the assistant retains temporal/actor grounding.
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
-  // NOTE: `<memory>` blocks (both the dynamic activation block from
-  // `injectTextBlock` and the static `memory-v2-static` injector) are
-  // intentionally NOT stripped — memory injections persist in history so
-  // the assistant retains intra-turn memory state. The activation pipeline
-  // dedupes via `everInjected`, and compaction handles aggregate growth, so
+  // The static `memory-v2-static` block (opens `<memory>\n…`) IS stripped
+  // so each compaction re-injects the freshest essentials/threads/recent/
+  // buffer view, matching the `<knowledge_base>` cadence. The dynamic
+  // activation block (opens `<memory __injected>…`) is intentionally NOT
+  // stripped — `startsWith("<memory>\n")` does not match it — so per-turn
+  // memory activations persist in history. The activation pipeline dedupes
+  // via `everInjected`, and compaction handles aggregate growth, so
   // accumulation does not cause unbounded context growth.
+  "<memory>\n",
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // NOTE: <workspace> is intentionally NOT stripped — workspace context
@@ -1736,6 +1739,7 @@ export interface RuntimeInjectionBlocks {
   workspaceBlock?: string;
   nowScratchpadBlock?: string;
   pkbContextBlock?: string;
+  memoryV2StaticBlock?: string;
   /**
    * Composed output of every plugin-registered {@link Injector}, concatenated
    * in ascending `order`. Empty string when every injector opted out (returned
@@ -2153,6 +2157,7 @@ export async function applyRuntimeInjections(
   let nowScratchpadCaptured: string | undefined;
   let pkbContextCaptured: string | undefined;
   let pkbSystemReminderCaptured: string | undefined;
+  let memoryV2StaticCaptured: string | undefined;
   const initialTail = runMessages[runMessages.length - 1];
   const initialTailIsUser = !!initialTail && initialTail.role === "user";
   if (initialTailIsUser) {
@@ -2173,6 +2178,9 @@ export async function applyRuntimeInjections(
         case "pkb-reminder":
           pkbSystemReminderCaptured = block.text;
           break;
+        case "memory-v2-static":
+          memoryV2StaticCaptured = block.text;
+          break;
       }
     }
   }
@@ -2354,6 +2362,7 @@ export async function applyRuntimeInjections(
       workspaceBlock: workspaceCaptured,
       nowScratchpadBlock: nowScratchpadCaptured,
       pkbContextBlock: pkbContextCaptured,
+      memoryV2StaticBlock: memoryV2StaticCaptured,
       injectorChainBlock,
     },
   };

package/src/daemon/conversation-slash.ts

@@ -1,6 +1,12 @@
 import type { InterfaceId } from "../channels/types.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
-import { getConfig } from "../config/loader.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+} from "../config/loader.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
 import { getConfiguredProviders } from "../providers/provider-availability.js";
@@ -8,7 +14,43 @@ import { getConfiguredProviders } from "../providers/provider-availability.js";
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
   | { kind: "unknown"; message: string }
-  | { kind: "compact" };
+  | { kind: "compact"; targetInputTokensOverride?: number };
+
+const COMPACT_USAGE_HINT =
+  "Usage: `/compact [<tokens>]` (e.g. `/compact 30000`, `/compact 30k`, `/compact 1m`).";
+
+type CompactParse =
+  | { kind: "compact"; targetInputTokensOverride?: number }
+  | { kind: "unknown"; message: string };
+
+const TOKEN_COUNT_PATTERN = /^(\d+(?:\.\d+)?)([km])?$/i;
+const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s+(.+?))?\s*$/i;
+
+function parseTokenCount(input: string): number | null {
+  const match = input.match(TOKEN_COUNT_PATTERN);
+  if (!match) return null;
+  const value = Number.parseFloat(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return null;
+  const suffix = match[2]?.toLowerCase();
+  const multiplier = suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
+  const tokens = Math.floor(value * multiplier);
+  return tokens > 0 ? tokens : null;
+}
+
+function parseCompactCommand(trimmed: string): CompactParse | null {
+  const match = trimmed.match(COMPACT_COMMAND_PATTERN);
+  if (!match) return null;
+  const rest = match[1]?.trim();
+  if (!rest) return { kind: "compact" };
+  const tokens = parseTokenCount(rest);
+  if (tokens == null) {
+    return {
+      kind: "unknown",
+      message: `Unrecognized argument to \`/compact\`: \`${rest}\`. ${COMPACT_USAGE_HINT}`,
+    };
+  }
+  return { kind: "compact", targetInputTokensOverride: tokens };
+}
 
 // ── /context and /status commands ────────────────────────────────────
 
@@ -71,10 +113,125 @@ const DEPRECATED_MODEL_SHORTCUTS = new Set([
   "grok-multi",
 ]);
 
+// ── /model command (inference profile switcher) ──────────────────────
+
+type ModelCommandParse =
+  | { kind: "list" }
+  | { kind: "switch"; profileName: string };
+
+/**
+ * Parse `/model` and `/model <name>` forms. Returns `null` for any input
+ * that isn't a `/model` invocation (so the caller can fall through).
+ */
+function parseModelCommand(trimmed: string): ModelCommandParse | null {
+  if (trimmed === "/model") return { kind: "list" };
+  if (!trimmed.startsWith("/model ")) return null;
+  const rest = trimmed.slice("/model ".length).trim();
+  if (rest.length === 0) return { kind: "list" };
+  return { kind: "switch", profileName: rest };
+}
+
+function orderedProfileNames(
+  profiles: Record<string, { label?: string; description?: string; status?: "active" | "disabled" }>,
+  profileOrder: readonly string[] | undefined,
+): string[] {
+  const order = profileOrder ?? [];
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const name of order) {
+    if (profiles[name] != null && !seen.has(name)) {
+      ordered.push(name);
+      seen.add(name);
+    }
+  }
+  const tail = Object.keys(profiles)
+    .filter((n) => !seen.has(n))
+    .sort();
+  return [...ordered, ...tail];
+}
+
+async function resolveModelCommand(
+  parse: ModelCommandParse,
+): Promise<SlashResolution> {
+  const config = getConfig();
+  const profiles = (config.llm.profiles ?? {}) as Record<
+    string,
+    { label?: string; description?: string; status?: "active" | "disabled" }
+  >;
+  const profileNames = orderedProfileNames(profiles, config.llm.profileOrder);
+  const activeProfile = config.llm.activeProfile;
+
+  if (parse.kind === "list") {
+    if (profileNames.length === 0) {
+      return {
+        kind: "unknown",
+        message:
+          "No inference profiles are defined. Use **Settings → Models & Services** to create one.",
+      };
+    }
+    const lines = ["Inference profiles:\n"];
+    for (const name of profileNames) {
+      const profile = profiles[name];
+      const label = profile.label ?? name;
+      const isCurrent = name === activeProfile;
+      const isDisabled = profile.status === "disabled";
+      const marker = isCurrent ? " **[current]**" : "";
+      const disabled = isDisabled ? " *(disabled)*" : "";
+      const description = profile.description ? ` — ${profile.description}` : "";
+      lines.push(`  - \`${name}\` (${label})${marker}${disabled}${description}`);
+    }
+    lines.push("\nSwitch with `/model <name>`.");
+    return { kind: "unknown", message: lines.join("\n") };
+  }
+
+  const target = parse.profileName;
+  if (!(target in profiles)) {
+    const available = profileNames.map((n) => `\`${n}\``).join(", ");
+    const hint = available.length > 0 ? ` Available: ${available}.` : "";
+    return {
+      kind: "unknown",
+      message: `Profile \`${target}\` not found.${hint}`,
+    };
+  }
+  if (profiles[target].status === "disabled") {
+    return {
+      kind: "unknown",
+      message: `Profile \`${target}\` is disabled. Enable it in **Settings → Models & Services** first.`,
+    };
+  }
+  if (target === activeProfile) {
+    const label = profiles[target].label ?? target;
+    return {
+      kind: "unknown",
+      message: `Already using profile \`${target}\` (${label}).`,
+    };
+  }
+
+  // Write `llm.activeProfile` directly to the raw config file. We invalidate
+  // the in-process cache so the very next `getConfig()` reflects the switch;
+  // the file watcher will also pick this up but its debounce can lag a tick.
+  const raw = loadRawConfig();
+  const llm: Record<string, unknown> =
+    raw.llm != null && typeof raw.llm === "object" && !Array.isArray(raw.llm)
+      ? (raw.llm as Record<string, unknown>)
+      : {};
+  llm.activeProfile = target;
+  raw.llm = llm;
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  const label = profiles[target].label ?? target;
+  return {
+    kind: "unknown",
+    message: `Switched to profile \`${target}\` (${label}).`,
+  };
+}
+
 // ── /models command ──────────────────────────────────────────────────
 
 async function resolveModelList(): Promise<SlashResolution> {
   const config = getConfig();
+  const resolvedMainAgent = resolveCallSiteConfig("mainAgent", config.llm);
   const configuredProviders = new Set<string>(await getConfiguredProviders());
 
   const lines = ["Available models:\n"];
@@ -89,8 +246,8 @@ async function resolveModelList(): Promise<SlashResolution> {
     lines.push(`**${providerName}** ${status}`);
     for (const { id, displayName } of models) {
       const isCurrent =
-        config.llm.default.provider === provider &&
-        config.llm.default.model === id;
+        resolvedMainAgent.provider === provider &&
+        resolvedMainAgent.model === id;
       const current = isCurrent ? " **[current]**" : "";
       lines.push(`  - ${displayName} (\`${id}\`)${current}`);
     }
@@ -146,6 +303,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
   if (context) {
     fallbackLines.push("/context — Show conversation context usage");
   }
+  fallbackLines.push("/model — List or switch inference profile");
   fallbackLines.push("/models — List all available models");
   if (context) {
     fallbackLines.push("/status — Show conversation status and context usage");
@@ -158,6 +316,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -170,6 +329,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -181,6 +341,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
     "/commands — List all available commands",
     "/compact — Force context compaction immediately",
     "/context — Show conversation context usage",
+    "/model — List or switch inference profile",
     "/models — List all available models",
     "/status — Show conversation status and context usage",
     "/btw — Ask a side question while the assistant is working",
@@ -200,10 +361,7 @@ export function classifySlash(
   content: string,
 ): "passthrough" | "compact" | "unknown" {
   const trimmed = content.trim();
-  if (
-    trimmed === "/model" ||
-    (trimmed.startsWith("/model ") && trimmed !== "/models")
-  ) {
+  if (parseModelCommand(trimmed) != null) {
     return "unknown";
   }
   const shortcutMatch = trimmed.match(/^\/([a-z0-9-]+)(\s|$)/i);
@@ -214,7 +372,8 @@ export function classifySlash(
     return "unknown";
   }
   if (trimmed === "/models") return "unknown";
-  if (trimmed === "/compact") return "compact";
+  const compactParse = parseCompactCommand(trimmed);
+  if (compactParse) return compactParse.kind;
   if (trimmed === "/context") return "unknown";
   if (trimmed === "/status") return "unknown";
   if (trimmed === "/commands") return "unknown";
@@ -230,17 +389,11 @@ export async function resolveSlash(
   content: string,
   context?: SlashContext,
 ): Promise<SlashResolution> {
-  // Handle deprecated model-switching commands — direct users to Settings
+  // Handle `/model` — list profiles (no arg) or switch active profile.
   const trimmed = content.trim();
-  if (
-    trimmed === "/model" ||
-    (trimmed.startsWith("/model ") && trimmed !== "/models")
-  ) {
-    return {
-      kind: "unknown",
-      message:
-        "The `/model` command has been removed. Use **Settings → Models & Services** to change your model and provider.",
-    };
+  const modelParse = parseModelCommand(trimmed);
+  if (modelParse != null) {
+    return await resolveModelCommand(modelParse);
   }
 
   // Reject deprecated provider shortcut commands (/opus, /sonnet, /haiku, etc.)
@@ -260,10 +413,9 @@ export async function resolveSlash(
     return await resolveModelList();
   }
 
-  // Handle /compact command
-  if (trimmed === "/compact") {
-    return { kind: "compact" };
-  }
+  // Handle /compact command (with optional `<tokens>` override).
+  const compactParse = parseCompactCommand(trimmed);
+  if (compactParse) return compactParse;
 
   // Handle /context and legacy /status commands
   if (trimmed === "/context" || trimmed === "/status") {

package/src/daemon/conversation-store.ts

@@ -14,12 +14,13 @@
  * shared rate-limit timestamps, broadcast).
  */
 
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
+import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
-import { getProvider } from "../providers/registry.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
@@ -222,14 +223,20 @@ export async function getOrCreateConversation(
 
     const createPromise = (async () => {
       const config = getConfig();
-      let provider = getProvider(config.llm.default.provider);
-      provider = new CallSiteRoutingProvider(provider, (name) => {
-        try {
-          return getProvider(name);
-        } catch {
-          return undefined;
-        }
-      });
+      // Connection-aware default-provider resolution. Throws
+      // `ConnectionResolutionError` when the default profile's
+      // `provider_connection` is unset / unknown / mismatched (config
+      // bugs). Returns null on soft credential failures (handled below
+      // as "default provider not registered").
+      const baseProvider = await resolveDefaultProvider(config);
+      if (!baseProvider) {
+        throw new Error(
+          `Conversation: default provider '${resolveCallSiteConfig("mainAgent", config.llm).provider}' is not registered`,
+        );
+      }
+      // Per-call `callSite` routing layered on top, with connection-awareness
+      // for alternate profiles (matches the canonical dispatch path).
+      let provider = wrapWithCallSiteRouting(baseProvider, config);
       const { rateLimit } = config;
       if (rateLimit.maxRequestsPerMinute > 0) {
         provider = new RateLimitProvider(