@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/first-greeting.ts

@@ -2,14 +2,19 @@ import { existsSync } from "node:fs";
 
 import { getWorkspacePromptPath } from "../util/platform.js";
 
-/**
- * The canned assistant response for the wake-up greeting on a fresh workspace.
- * Warm, non-presumptuous greeting that communicates "I'm new," "I improve over
- * time," and invites the user to lead with whatever they want — a task, a
- * question, or getting to know each other.
- */
-export const CANNED_FIRST_GREETING =
-  "Hey — I'm brand new. No name, no memories, no idea who you are yet. I'll get sharper the more we work together. What can I do for you?";
+export interface OnboardingGreetingContext {
+  tools: string[];
+  tasks: string[];
+  tone: string;
+  userName?: string;
+  assistantName?: string;
+}
+
+export const CANNED_FIRST_GREETING = [
+  "Hey — brand new, no name, no memories, no idea who you are yet. I'll get sharper the more we work together.",
+  "",
+  "What can I do for you? Or I can ask you some questions to get started.",
+].join("\n");
 
 /**
  * Returns `true` when all of the following are true:
@@ -31,11 +36,183 @@ export function isWakeUpGreeting(
   );
 }
 
-/**
- * Returns the canned first-greeting string. Simple getter that exists to keep
- * the call site consistent and allow future flexibility (e.g., locale-aware
- * greetings) without changing the API.
- */
-export function getCannedFirstGreeting(): string {
+export function getCannedFirstGreeting(
+  onboarding?: OnboardingGreetingContext,
+): string {
+  if (onboarding) {
+    return buildPersonalizedGreeting(onboarding);
+  }
   return CANNED_FIRST_GREETING;
 }
+
+const TOOL_LABELS: Record<string, string> = {
+  gmail: "Gmail",
+  outlook: "Outlook",
+  "google-calendar": "Google Calendar",
+  slack: "Slack",
+  notion: "Notion",
+  linear: "Linear",
+  jira: "Jira",
+  github: "GitHub",
+  figma: "Figma",
+  "google-drive": "Google Drive",
+  excel: "Excel",
+  "apple-notes": "Apple Notes",
+};
+
+const TASK_PRIORITY: string[] = [
+  "code-building",
+  "project-management",
+  "writing",
+  "research",
+  "scheduling",
+  "personal",
+];
+
+interface Guess {
+  text: string;
+  preferredTools: string[];
+}
+
+const SINGLE_GUESSES: Record<string, Guess> = {
+  "code-building": {
+    text: "shipping something or debugging",
+    preferredTools: ["github", "linear", "jira"],
+  },
+  writing: {
+    text: "drafting something or cleaning up docs",
+    preferredTools: ["notion", "google-drive", "apple-notes"],
+  },
+  research: {
+    text: "digging into a topic or making sense of something",
+    preferredTools: ["notion", "google-drive"],
+  },
+  "project-management": {
+    text: "planning the week, writing a spec, or pushing something forward",
+    preferredTools: ["notion", "linear", "google-drive"],
+  },
+  scheduling: {
+    text: "planning the week or prepping for meetings",
+    preferredTools: ["google-calendar", "outlook", "linear"],
+  },
+  personal: {
+    text: "juggling travel, bills, or household stuff",
+    preferredTools: ["gmail", "google-calendar", "apple-notes"],
+  },
+};
+
+const COMBO_GUESSES: Record<string, Guess> = {
+  "code-building+project-management": {
+    text: "shipping code or figuring out what to ship next",
+    preferredTools: ["github", "linear", "jira"],
+  },
+  "code-building+writing": {
+    text: "shipping code or writing something up",
+    preferredTools: ["github", "linear", "jira"],
+  },
+  "project-management+writing": {
+    text: "writing a spec or pushing something forward",
+    preferredTools: ["notion", "linear", "google-drive"],
+  },
+  "research+writing": {
+    text: "drafting something or digging into a topic",
+    preferredTools: ["notion", "google-drive"],
+  },
+  "project-management+scheduling": {
+    text: "planning the week or prepping for something",
+    preferredTools: ["google-calendar", "outlook", "linear"],
+  },
+};
+
+function comboKey(a: string, b: string): string {
+  return [a, b].sort().join("+");
+}
+
+function highestPriorityTask(tasks: string[]): string | undefined {
+  for (const t of TASK_PRIORITY) {
+    if (tasks.includes(t)) return t;
+  }
+  return tasks[0];
+}
+
+function buildIntroLine(userName?: string, assistantName?: string): string {
+  const namepart = userName ? `Hey ${userName},` : "Hey,";
+  const who = assistantName
+    ? `I'm ${assistantName}. Brand new, and I'll get sharper the more we work together.`
+    : "brand new, and I'll get sharper the more we work together.";
+  return `${namepart} ${who}`;
+}
+
+function pickRelevantTools(
+  preferredTools: string[],
+  userTools: string[],
+): string[] {
+  const userSet = new Set(userTools);
+  const matched: string[] = [];
+  for (const t of preferredTools) {
+    if (userSet.has(t)) {
+      matched.push(TOOL_LABELS[t] ?? t);
+      if (matched.length === 2) break;
+    }
+  }
+  return matched;
+}
+
+function buildSpecificGuess(tasks: string[], tools: string[]): string {
+  let guess: Guess | undefined;
+
+  if (tasks.length === 2) {
+    guess = COMBO_GUESSES[comboKey(tasks[0], tasks[1])];
+  }
+
+  if (!guess) {
+    const top = highestPriorityTask(tasks);
+    guess = top ? SINGLE_GUESSES[top] : undefined;
+  }
+
+  if (!guess) return "";
+
+  const relevant = pickRelevantTools(guess.preferredTools, tools);
+
+  if (relevant.length === 2) {
+    return `You mentioned using ${relevant[0]} and ${relevant[1]} — probably ${guess.text}? Am I on the right track, or something else on your mind?`;
+  }
+  if (relevant.length === 1) {
+    return `You mentioned using ${relevant[0]} — probably ${guess.text}? Am I on the right track, or something else on your mind?`;
+  }
+
+  return `Probably ${guess.text}? Am I on the right track, or something else on your mind?`;
+}
+
+function buildPersonalizedGreeting(ctx: OnboardingGreetingContext): string {
+  const userName = ctx.userName?.trim();
+  const assistantName = ctx.assistantName?.trim();
+
+  const hasName = userName && userName.length > 0;
+  const hasTasks = ctx.tasks.length > 0;
+  const hasTools = ctx.tools.length > 0;
+
+  const hasAssistantName = assistantName && assistantName.length > 0;
+
+  if (!hasName && !hasTasks && !hasTools && !hasAssistantName) {
+    return CANNED_FIRST_GREETING;
+  }
+
+  const intro = buildIntroLine(hasName ? userName : undefined, assistantName);
+
+  let secondParagraph: string;
+
+  if (ctx.tasks.length >= 4) {
+    secondParagraph =
+      "Looks like you wear a lot of hats. Where should we start?";
+  } else if (ctx.tasks.length === 0) {
+    secondParagraph =
+      "What's on your plate? Or if it's easier, I can ask you a few questions to get oriented.";
+  } else {
+    secondParagraph =
+      buildSpecificGuess(ctx.tasks, ctx.tools) ||
+      "What's on your plate? Or if it's easier, I can ask you a few questions to get oriented.";
+  }
+
+  return [intro, "", secondParagraph].join("\n");
+}

package/src/daemon/guardian-action-generators.ts

@@ -1,5 +1,7 @@
-import { loadConfig } from "../config/loader.js";
+import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { getProvider } from "../providers/registry.js";
+import type { Provider } from "../providers/types.js";
 import {
   buildGuardianActionGenerationPrompt,
   getGuardianActionFallbackMessage,
@@ -18,21 +20,20 @@ import type {
 /**
  * Create the daemon-owned guardian action copy generator that resolves
  * providers and calls `provider.sendMessage` to generate guardian action
- * copy text. Uses `latency-optimized` model intent since these are
- * time-sensitive voice responses.
+ * copy text. Uses the `guardianQuestionCopy` call site so model selection
+ * tracks the unified `llm.callSites` configuration.
  *
  * This keeps all provider awareness in the daemon lifecycle, away from
  * the runtime composer.
  */
 export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator {
   return async (context, options = {}) => {
-    const config = loadConfig();
-    let provider;
-    try {
-      provider = getProvider(config.services.inference.provider);
-    } catch {
-      return null;
-    }
+    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
+    if (!baseProvider) return null;
+    // Wrap so the per-call `callSite` can route to a different provider
+    // transport when `llm.callSites.guardianQuestionCopy.provider` overrides
+    // the default. Without this, callSite only affects request metadata.
+    const provider = wrapWithCallSiteRouting(baseProvider);
 
     const fallbackText =
       options.fallbackText?.trim() || getGuardianActionFallbackMessage(context);
@@ -52,7 +53,7 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
       {
         config: {
           max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
-          modelIntent: "latency-optimized",
+          callSite: "guardianQuestionCopy",
         },
         signal: AbortSignal.timeout(
           options.timeoutMs ?? GUARDIAN_ACTION_COPY_TIMEOUT_MS,
@@ -130,8 +131,11 @@ const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
  */
 export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
   return async (context) => {
-    const config = loadConfig();
-    const provider = getProvider(config.services.inference.provider);
+    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
+    if (!baseProvider) {
+      throw new Error("No configured provider available for follow-up conversation");
+    }
+    const provider = wrapWithCallSiteRouting(baseProvider);
 
     const userPrompt = [
       `Original question from the voice call: "${context.questionText}"`,
@@ -146,7 +150,7 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
       {
         config: {
           max_tokens: FOLLOWUP_CONVERSATION_MAX_TOKENS,
-          modelIntent: "latency-optimized",
+          callSite: "guardianQuestionCopy",
         },
         signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
       },
@@ -188,3 +192,19 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
     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/handlers/config-model.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
+import { projectProviderForWire } from "./config-model.js";
+
+/**
+ * Regression guard for the wire contract declared in
+ * `daemon/message-types/conversations.ts#ModelInfo.allProviders`. The
+ * daemon's `PROVIDER_CATALOG` carries richer metadata (capability flags,
+ * pricing, subtitle, setupMode, setupHint, envVar, credentialsGuide), but
+ * clients source that metadata from the bundled `LLMProviderRegistry`
+ * JSON, so only the legacy fields belong on the wire. The Swift generated
+ * DTO declares the same legacy-only shape and silently discards any
+ * extras — this test keeps the daemon honest about what it sends.
+ */
+describe("projectProviderForWire", () => {
+  const LEGACY_WIRE_KEYS = new Set([
+    "id",
+    "displayName",
+    "models",
+    "defaultModel",
+    "apiKeyUrl",
+    "apiKeyPlaceholder",
+  ]);
+
+  test("drops rich catalog fields (subtitle, setupMode, envVar, credentialsGuide, setupHint)", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      const keys = Object.keys(wire);
+      for (const key of keys) {
+        expect(LEGACY_WIRE_KEYS.has(key)).toBe(true);
+      }
+      expect(keys).not.toContain("subtitle");
+      expect(keys).not.toContain("setupMode");
+      expect(keys).not.toContain("setupHint");
+      expect(keys).not.toContain("envVar");
+      expect(keys).not.toContain("credentialsGuide");
+    }
+  });
+
+  test("drops rich CatalogModel fields (capability flags, pricing, context windows)", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      for (const model of wire.models) {
+        expect(Object.keys(model).sort()).toEqual(["displayName", "id"]);
+      }
+    }
+  });
+
+  test("preserves legacy wire fields exactly", () => {
+    const anthropic = PROVIDER_CATALOG.find((p) => p.id === "anthropic");
+    expect(anthropic).toBeDefined();
+    const wire = projectProviderForWire(anthropic!);
+    expect(wire.id).toBe(anthropic!.id);
+    expect(wire.displayName).toBe(anthropic!.displayName);
+    expect(wire.defaultModel).toBe(anthropic!.defaultModel);
+    expect(wire.apiKeyUrl).toBe(anthropic!.apiKeyUrl);
+    expect(wire.apiKeyPlaceholder).toBe(anthropic!.apiKeyPlaceholder);
+    expect(wire.models.length).toBe(anthropic!.models.length);
+  });
+
+  test("omits apiKeyUrl/apiKeyPlaceholder when source entry has none (keyless providers)", () => {
+    const ollama = PROVIDER_CATALOG.find((p) => p.id === "ollama");
+    expect(ollama).toBeDefined();
+    // Sanity-check the fixture: ollama is the keyless provider.
+    expect(ollama!.apiKeyUrl).toBeUndefined();
+    expect(ollama!.apiKeyPlaceholder).toBeUndefined();
+
+    const wire = projectProviderForWire(ollama!);
+    expect("apiKeyUrl" in wire).toBe(false);
+    expect("apiKeyPlaceholder" in wire).toBe(false);
+  });
+
+  test("JSON round-trip exposes only the legacy wire keys", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      const wire = projectProviderForWire(entry);
+      const serialized = JSON.parse(JSON.stringify(wire)) as Record<
+        string,
+        unknown
+      >;
+      for (const key of Object.keys(serialized)) {
+        expect(LEGACY_WIRE_KEYS.has(key)).toBe(true);
+      }
+    }
+  });
+});

package/src/daemon/handlers/config-model.ts

@@ -3,8 +3,12 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import { setServiceField } from "../../config/raw-config-utils.js";
+import {
+  setLlmDefaultField,
+  setServiceField,
+} from "../../config/raw-config-utils.js";
 import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import { providerForImageModelPrefix } from "../../media/types.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
 import {
   isModelInCatalog,
@@ -37,25 +41,64 @@ export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
 
+/**
+ * Wire-contract shape for a provider entry in `ModelInfo.allProviders`.
+ * Mirrors the legacy fields declared in `message-types/conversations.ts` —
+ * rich provider metadata (capability flags, pricing, subtitle, setupMode,
+ * setupHint, envVar, credentialsGuide) is sourced by clients from the
+ * bundled `LLMProviderRegistry` JSON, so there is no reason to double-send
+ * it over the wire.
+ */
+export interface WireProviderEntry {
+  id: string;
+  displayName: string;
+  models: Array<{ id: string; displayName: string }>;
+  defaultModel: string;
+  apiKeyUrl?: string;
+  apiKeyPlaceholder?: string;
+}
+
 export interface ModelInfo {
   model: string;
   provider: string;
   configuredProviders?: string[];
   availableModels?: Array<{ id: string; displayName: string }>;
-  allProviders?: ProviderCatalogEntry[];
+  allProviders?: WireProviderEntry[];
+}
+
+/**
+ * Project a rich `ProviderCatalogEntry` to the legacy wire-contract fields.
+ * Keeping the wire payload honest avoids contract drift with
+ * `message-types/conversations.ts` and the generated Swift DTO.
+ */
+export function projectProviderForWire(
+  entry: ProviderCatalogEntry,
+): WireProviderEntry {
+  return {
+    id: entry.id,
+    displayName: entry.displayName,
+    models: entry.models.map((m) => ({ id: m.id, displayName: m.displayName })),
+    defaultModel: entry.defaultModel,
+    ...(entry.apiKeyUrl !== undefined && { apiKeyUrl: entry.apiKeyUrl }),
+    ...(entry.apiKeyPlaceholder !== undefined && {
+      apiKeyPlaceholder: entry.apiKeyPlaceholder,
+    }),
+  };
 }
 
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
-  const provider = config.services.inference.provider;
+  const provider = config.llm.default.provider;
 
   return {
-    model: config.services.inference.model,
+    model: config.llm.default.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
-    availableModels: PROVIDER_CATALOG.find((p) => p.id === provider)?.models,
-    allProviders: PROVIDER_CATALOG,
+    availableModels: PROVIDER_CATALOG.find(
+      (p) => p.id === provider,
+    )?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
+    allProviders: PROVIDER_CATALOG.map(projectProviderForWire),
   };
 }
 
@@ -102,12 +145,12 @@ export async function setModel(
   const resolvedProvider =
     explicitProvider ??
     MODEL_TO_PROVIDER[modelId] ??
-    current.services.inference.provider;
+    current.llm.default.provider;
 
   // Auto-reset model when provider changes and current modelId doesn't
   // belong to the new provider's catalog.
   if (
-    resolvedProvider !== current.services.inference.provider &&
+    resolvedProvider !== current.llm.default.provider &&
     !isModelInCatalog(resolvedProvider, modelId)
   ) {
     modelId = getProviderDefaultModel(resolvedProvider);
@@ -115,8 +158,8 @@ export async function setModel(
 
   // No-op guard: skip expensive reinitialization when nothing changed
   if (
-    modelId === current.services.inference.model &&
-    resolvedProvider === current.services.inference.provider
+    modelId === current.llm.default.model &&
+    resolvedProvider === current.llm.default.provider
   ) {
     return await getModelInfo();
   }
@@ -129,8 +172,8 @@ export async function setModel(
 
   // Use raw config to avoid persisting env-var API keys to disk
   const raw = loadRawConfig();
-  setServiceField(raw, "inference", "model", modelId);
-  setServiceField(raw, "inference", "provider", resolvedProvider);
+  setLlmDefaultField(raw, "model", modelId);
+  setLlmDefaultField(raw, "provider", resolvedProvider);
 
   // Suppress the file watcher callback — setModel already does
   // the full reload sequence; a redundant watcher-triggered reload
@@ -177,6 +220,16 @@ export async function setModel(
 export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
   const raw = loadRawConfig();
   setServiceField(raw, "image-generation", "model", modelId);
+  // Keep the derived provider in sync with the selected model so downstream
+  // routing never sends a Gemini request to an OpenAI model (or vice versa).
+  // The prefix logic is shared with workspace migration 006-services-config
+  // via providerForImageModelPrefix().
+  setServiceField(
+    raw,
+    "image-generation",
+    "provider",
+    providerForImageModelPrefix(modelId),
+  );
 
   const wasSuppressed = ctx.suppressConfigReload;
   ctx.setSuppressConfigReload(true);

package/src/daemon/handlers/conversations.ts

@@ -148,12 +148,19 @@ export function handleConfirmationResponse(
   // Route by requestId to the conversation that originated the prompt, not by
   // the current conversation binding which may have changed since the
   // request was issued (e.g. after a conversation switch).
+  // Normalize legacy decision: older clients may still send
+  // "always_allow_high_risk" via WebSocket for high-risk prompts.
+  const decision =
+    msg.decision === ("always_allow_high_risk" as typeof msg.decision)
+      ? "always_allow"
+      : msg.decision;
+
   for (const [conversationId, conversation] of ctx.conversations) {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
       ctx.touchConversation(conversationId);
       conversation.handleConfirmationResponse(
         msg.requestId,
-        msg.decision,
+        decision,
         msg.selectedPattern,
         msg.selectedScope,
         undefined,
@@ -435,7 +442,7 @@ export function handleUsageRequest(
     totalInputTokens: conversation.totalInputTokens,
     totalOutputTokens: conversation.totalOutputTokens,
     estimatedCost: conversation.totalEstimatedCost,
-    model: config.services.inference.model,
+    model: config.llm.default.model,
   });
 }
 

package/src/daemon/handlers/shared.ts

@@ -1,10 +1,10 @@
 import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../../config/loader.js";
-import type { Speed } from "../../config/schemas/inference.js";
+import type { LLMCallSite, Speed } from "../../config/schemas/llm.js";
 import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import type { SecretPromptResult } from "../../permissions/secret-prompter.js";
-import type { ModelIntent } from "../../providers/types.js";
+import { isPlaceholderSentinelText } from "../../providers/anthropic/client.js";
 import type { AuthContext } from "../../runtime/auth/types.js";
 import type { DebouncerMap } from "../../util/debounce.js";
 import { getLogger } from "../../util/logger.js";
@@ -102,6 +102,22 @@ export interface RenderedHistoryContent {
   thinkingSegments: string[];
 }
 
+/**
+ * Slack-specific metadata extracted at the inbound HTTP boundary and threaded
+ * through to user-message persistence so the row can be tagged with a
+ * `slackMeta` envelope for the chronological renderer.
+ */
+export interface SlackInboundMessageMetadata {
+  /** Slack channel id (conversation external id) — recorded as `channelId`. */
+  channelId: string;
+  /** Slack `ts` for this message — required so persistence can record `channelTs`. */
+  channelTs: string;
+  /** Parent `thread_ts` when the message lives inside a thread; absent for top-level. */
+  threadTs?: string;
+  /** Resolved sender label (display name preferred, username fallback). */
+  displayName?: string;
+}
+
 /**
  * Optional overrides for conversation creation (e.g. interview mode).
  */
@@ -128,19 +144,26 @@ export interface ConversationCreateOptions {
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   /** Optional callback to receive real-time agent loop events (text deltas, tool starts, etc.). */
   onEvent?: (msg: ServerMessage) => void;
-  /**
-   * Optional model selection strategy for this conversation's agent loop.
-   * When set, overrides the provider's default model per-turn. Used by the
-   * auto-analyze loop to route the analysis agent to a dedicated model.
-   */
-  modelIntent?: ModelIntent;
   /**
    * Optional explicit model override (provider/model string) for this
-   * conversation's agent loop. Takes precedence over `modelIntent` when
-   * both are set. Used by the auto-analyze loop to pin the analysis agent
-   * to a specific model.
+   * conversation's agent loop. Used by the auto-analyze loop to pin the
+   * analysis agent to a specific model.
    */
   modelOverride?: string;
+  /**
+   * Optional LLM call-site identifier threaded through to the per-call
+   * provider config. Adapter callers (heartbeat, filing, schedule, etc.)
+   * pass their call-site here so the agent loop routes through
+   * `resolveCallSiteConfig` instead of the global default.
+   */
+  callSite?: LLMCallSite;
+  /**
+   * Slack inbound metadata captured at the channel ingress boundary. When
+   * present (and the turn channel resolves to Slack), persistence writes a
+   * `slackMeta` sub-object into the message's `metadata` JSON for the
+   * chronological renderer to consume.
+   */
+  slackInbound?: SlackInboundMessageMetadata;
 }
 
 /**
@@ -329,6 +352,11 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       // path — e.g. empty segments between consecutive tool_use blocks that
       // break tool-call grouping in the UI.
       if (block.text.trim().length === 0) continue;
+      // Drop Anthropic provider placeholder sentinels. These are injected
+      // into outbound API requests to preserve role alternation and must
+      // never be rendered to users. Belt-and-suspenders with the persist-
+      // time filter in cleanAssistantContent and migration 222.
+      if (isPlaceholderSentinelText(block.text)) continue;
       textParts.push(block.text);
       ensureSegment();
       currentSegmentParts.push(block.text);

package/src/daemon/handlers/skills.ts

@@ -326,10 +326,14 @@ export function postInstallSkill(
 
 /** Map the old `source` field to the new `kind` axis. */
 function deriveKind(
-  source: "bundled" | "managed" | "workspace" | "extra" | "catalog",
+  source: "bundled" | "managed" | "workspace" | "extra" | "catalog" | "plugin",
 ): SlimSkillResponse["kind"] {
   if (source === "bundled") return "bundled";
   if (source === "catalog") return "catalog";
+  // Plugin-contributed skills are framework-provided like bundled skills —
+  // expose them under the same "bundled" kind so the UI doesn't invent a
+  // new category that existing clients don't know how to render.
+  if (source === "plugin") return "bundled";
   return "installed"; // managed, workspace, extra
 }
 
@@ -1517,7 +1521,7 @@ export async function draftSkill(
     if (missing.length > 0) {
       let llmGenerated = false;
       try {
-        const provider = await getConfiguredProvider();
+        const provider = await getConfiguredProvider("skillCategoryInference");
         if (provider) {
           const { signal, cleanup } = createTimeout(LLM_DRAFT_TIMEOUT_MS);
           try {
@@ -1539,7 +1543,7 @@ export async function draftSkill(
               [],
               undefined,
               {
-                config: { modelIntent: "latency-optimized", max_tokens: 256 },
+                config: { callSite: "skillCategoryInference", max_tokens: 256 },
                 signal,
               },
             );