@vellumai/assistant 0.8.0 → 0.8.2

package/src/daemon/conversation-process.ts

@@ -12,6 +12,7 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
+  type InterfaceId,
   parseChannelId,
   parseInterfaceId,
   type TurnChannelContext,
@@ -30,8 +31,12 @@ import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
 import type { Message } from "../providers/types.js";
 import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
-import { persistQueuedMessageBody } from "./conversation-messaging.js";
+import {
+  persistQueuedMessageBody,
+  serializePersistedUserMessageContent,
+} from "./conversation-messaging.js";
 import type {
   MessageQueue,
   QueuedMessage,
@@ -179,7 +184,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 +202,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 +446,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
@@ -503,11 +517,11 @@ async function drainSingleMessage(
       // When displayContent is provided (e.g. original text before recording
       // intent stripping), persist that to DB so users see the full message.
       // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-      const contentToPersist = next.displayContent
-        ? JSON.stringify(
-            createUserMessage(next.displayContent, next.attachments).content,
-          )
-        : JSON.stringify(cleanUserMsg.content);
+      const contentToPersist = serializePersistedUserMessageContent(
+        next.content,
+        next.attachments,
+        next.displayContent,
+      );
       await addMessage(
         conversation.conversationId,
         "user",
@@ -560,6 +574,7 @@ async function drainSingleMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -592,6 +607,7 @@ async function drainSingleMessage(
 
   // /compact — force context compaction, persist exchange, continue draining.
   if (slashResult.kind === "compact") {
+    let persistedCompactMessage = false;
     try {
       const drainProvenance = provenanceFromTrustContext(
         conversation.trustContext,
@@ -617,9 +633,14 @@ async function drainSingleMessage(
       await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          next.content,
+          next.attachments,
+          next.displayContent,
+        ),
         drainChannelMeta,
       );
+      persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
       conversation.emitActivityState(
@@ -628,7 +649,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);
@@ -654,7 +677,11 @@ async function drainSingleMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
     } catch (err) {
+      if (persistedCompactMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
       const message = err instanceof Error ? err.message : String(err);
       log.error(
         {
@@ -750,6 +777,7 @@ async function drainSingleMessage(
     requestId: next.requestId,
     clientMessageId: next.clientMessageId,
   });
+  publishConversationMessagesChanged(conversation.conversationId);
 
   // Set the active surface for the dequeued message so runAgentLoop can inject context
   conversation.currentActiveSurfaceId = next.activeSurfaceId;
@@ -875,15 +903,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
@@ -1076,6 +1103,7 @@ async function drainBatch(
       requestId: qm.requestId,
       clientMessageId: qm.clientMessageId,
     });
+    publishConversationMessagesChanged(conversation.conversationId);
 
     // Persist succeeded. Update last-successful markers so a later tail
     // failure won't overwrite them.
@@ -1295,7 +1323,11 @@ export async function processMessage(
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          content,
+          attachments,
+          displayContent,
+        ),
         routerChannelMeta,
       );
       conversation.messages.push(llmUserMsg);
@@ -1314,7 +1346,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,
@@ -1376,9 +1412,11 @@ export async function processMessage(
     // When displayContent is provided (e.g. original text before recording
     // intent stripping), persist that to DB so users see the full message.
     // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-    const contentToPersist = displayContent
-      ? JSON.stringify(createUserMessage(displayContent, attachments).content)
-      : JSON.stringify(cleanUserMsg.content);
+    const contentToPersist = serializePersistedUserMessageContent(
+      content,
+      attachments,
+      displayContent,
+    );
     const persisted = await addMessage(
       conversation.conversationId,
       "user",
@@ -1431,12 +1469,14 @@ export async function processMessage(
       type: "message_complete",
       conversationId: conversation.conversationId,
     });
+    publishConversationMessagesChanged(conversation.conversationId);
     return persisted.id;
   }
 
   // /compact — force context compaction, persist exchange, return message ID.
   if (slashResult.kind === "compact") {
     conversation.processing = true;
+    let persistedCompactMessage = false;
     try {
       const pmTurnCtx = conversation.getTurnChannelContext();
       const pmInterfaceCtx = conversation.getTurnInterfaceContext();
@@ -1463,9 +1503,14 @@ export async function processMessage(
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          content,
+          attachments,
+          displayContent,
+        ),
         pmChannelMeta,
       );
+      persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
       conversation.emitActivityState(
@@ -1474,7 +1519,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);
@@ -1500,7 +1547,13 @@ export async function processMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
       return persisted.id;
+    } catch (err) {
+      if (persistedCompactMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
+      throw err;
     } finally {
       conversation.processing = false;
       await drainQueue(conversation);
@@ -1540,6 +1593,7 @@ export async function processMessage(
       undefined,
       displayContent,
     );
+    publishConversationMessagesChanged(conversation.conversationId);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     onEvent({

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

@@ -1182,12 +1182,23 @@ function placeholderForBlockType(type: ContentBlock["type"]): string | null {
  */
 function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
   let slackMeta: ReturnType<typeof readSlackMetadata> = null;
+  let provenanceTrustClass: TrustClass | undefined;
   if (row.metadata) {
     try {
-      const outer = JSON.parse(row.metadata) as { slackMeta?: unknown };
+      const outer = JSON.parse(row.metadata) as {
+        slackMeta?: unknown;
+        provenanceTrustClass?: unknown;
+      };
       if (typeof outer.slackMeta === "string") {
         slackMeta = readSlackMetadata(outer.slackMeta);
       }
+      if (
+        outer.provenanceTrustClass === "guardian" ||
+        outer.provenanceTrustClass === "trusted_contact" ||
+        outer.provenanceTrustClass === "unknown"
+      ) {
+        provenanceTrustClass = outer.provenanceTrustClass;
+      }
     } catch {
       // Malformed metadata — fall through to legacy/null treatment.
     }
@@ -1252,6 +1263,8 @@ function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
     senderLabel,
     createdAt: row.createdAt,
     contentBlocks,
+    wrapContentForModel:
+      row.role === "user" && !isReaction && provenanceTrustClass !== "guardian",
   };
 }
 
@@ -1641,12 +1654,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 +1752,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
@@ -1985,6 +2002,7 @@ export interface RuntimeInjectionOptions {
    * `undefined` when the inbound is a top-level (non-thread) post.
    */
   slackActiveThreadFocusBlock?: string | null;
+  activeDocuments?: TurnInjectionInputs["activeDocuments"];
   mode?: InjectionMode;
   /**
    * Per-turn {@link TurnContext} forwarded to plugin-registered
@@ -2038,6 +2056,7 @@ function buildTurnInjectionInputs(
     voiceCallControlPrompt: options.voiceCallControlPrompt,
     transportHints: options.transportHints,
     isNonInteractive: options.isNonInteractive,
+    activeDocuments: options.activeDocuments,
   };
 }
 
@@ -2153,6 +2172,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 +2193,9 @@ export async function applyRuntimeInjections(
         case "pkb-reminder":
           pkbSystemReminderCaptured = block.text;
           break;
+        case "memory-v2-static":
+          memoryV2StaticCaptured = block.text;
+          break;
       }
     }
   }
@@ -2354,6 +2377,7 @@ export async function applyRuntimeInjections(
       workspaceBlock: workspaceCaptured,
       nowScratchpadBlock: nowScratchpadCaptured,
       pkbContextBlock: pkbContextCaptured,
+      memoryV2StaticBlock: memoryV2StaticCaptured,
       injectorChainBlock,
     },
   };

package/src/daemon/conversation-slash.ts

@@ -1,14 +1,56 @@
 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";
+import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibility.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,132 @@ 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"];
@@ -83,14 +247,14 @@ async function resolveModelList(): Promise<SlashResolution> {
     id: provider,
     displayName: providerName,
     models,
-  } of PROVIDER_CATALOG) {
+  } of getVisibleProviderCatalog(config)) {
     const hasKey = configuredProviders.has(provider);
     const status = hasKey ? "✓" : "✗";
     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 +310,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 +323,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 +336,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 +348,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 +368,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 +379,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 +396,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 +420,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") {