@vellumai/assistant 0.4.44 → 0.4.45

package/src/prompts/system-prompt.ts

@@ -195,22 +195,21 @@ export function buildSystemPrompt(): string {
 
 function buildTaskScheduleReminderRoutingSection(): string {
   return [
-    "## Tool Routing: Tasks vs Schedules vs Reminders vs Notifications",
+    "## Tool Routing: Tasks vs Schedules vs Notifications",
     "",
-    'Four tools, each for a different purpose. Load the "Time-Based Actions" skill for the full decision framework.',
+    'Three tools, each for a different purpose. Load the "Time-Based Actions" skill for the full decision framework.',
     "",
     "| Tool | Purpose |",
     "|------|---------|",
     '| `task_list_add` | Track work — no time trigger ("add to my tasks", "remind me to X" without a time) |',
-    '| `schedule_create` | Recurring automation on cron/RRULE ("every day at 9am", "weekly on Mondays") |',
-    '| `reminder_create` | One-shot future alert ("remind me at 3pm", "remind me in 5 minutes") |',
+    '| `schedule_create` | Any time-based automation — recurring cron/RRULE ("every day at 9am") OR one-shot future alert with `fire_at` ("remind me at 3pm") |',
     "| `send_notification` | **Immediate-only** — fires instantly, NO delay capability |",
     "",
     "### Critical: `send_notification` is immediate-only",
-    "NEVER use `send_notification` for future-time requests — it fires NOW. Use `reminder_create` for any delayed alert.",
+    "NEVER use `send_notification` for future-time requests — it fires NOW. Use `schedule_create` with `fire_at` for any delayed alert.",
     "",
     "### Quick routing rules",
-    "- Future time, one-shot → `reminder_create`",
+    "- Future time, one-shot → `schedule_create` with `fire_at`",
     "- Recurring pattern → `schedule_create`",
     "- No time, track as work → `task_list_add`",
     "- Instant alert → `send_notification`",
@@ -342,7 +341,7 @@ function buildInChatConfigurationSection(): string {
     "**How to collect credentials and secrets:**",
     '- Use `credential_store` with `action: "prompt"` to present a secure input field. The value never appears in the conversation.',
     '- For OAuth flows, use `credential_store` with `action: "oauth2_connect"` to handle the authorization in-browser. Some services (e.g. Twitter/X) define their own auth flow via dedicated skill instructions — check the service\'s skill documentation for provider-specific setup steps.',
-    "- For non-secret config values (e.g. a public URL, a webhook URL), ask the user directly in the conversation and use the appropriate IPC or config tool to persist the value.",
+    "- For non-secret config values (e.g. a public URL, a webhook URL), ask the user directly in the conversation and use the appropriate config tool to persist the value.",
     "",
     '**After saving a value**, confirm success with a message like: "Great, saved! You can always update this from the Settings page."',
     "",
@@ -569,7 +568,7 @@ export function buildSwarmGuidanceSection(): string {
   return [
     "## Parallel Task Orchestration",
     "",
-    'Use `swarm_delegate` only when a task has **multiple independent parts** that benefit from parallel execution (e.g. "research X, implement Y, and review Z"). For single-focus tasks, work directly — do not decompose them into a swarm.',
+    'When a task has **multiple independent parts** that benefit from parallel execution (e.g. "research X, implement Y, and review Z"), load the `orchestration` skill using `skill_load` first, then use `swarm_delegate` to decompose and run them in parallel. For single-focus tasks, work directly — do not decompose them into a swarm.',
   ].join("\n");
 }
 
@@ -653,7 +652,7 @@ function buildMemoryPersistenceSection(): string {
     "",
     "Your memory does not survive session restarts. If you want to remember something, **save it**.",
     "",
-    "- Use `memory_save` for facts, preferences, learnings, and anything worth recalling later.",
+    '- Use `memory_manage` with `op: "save"` for facts, preferences, learnings, and anything worth recalling later.',
     "- Update workspace files (USER.md, SOUL.md) for profile and personality changes.",
     '- When someone says "remember this," save it immediately — don\'t rely on keeping it in context.',
     "- When you make a mistake, save the lesson so future-you doesn't repeat it.",
@@ -698,7 +697,7 @@ function buildLearningMemorySection(): string {
     "",
     "When you make a mistake, hit a dead end, or discover something non-obvious, save it to memory so you don't repeat it.",
     "",
-    'Use `memory_save` with `kind: "learning"` for:',
+    'Use `memory_manage` with `op: "save", kind: "learning"` for:',
     "- **Mistakes and corrections** — wrong assumptions, failed approaches, gotchas you ran into",
     "- **Discoveries** — undocumented behaviors, surprising API quirks, things that weren't obvious",
     "- **Working solutions** — the approach that actually worked after trial and error",
@@ -707,8 +706,8 @@ function buildLearningMemorySection(): string {
     "The statement should capture both what happened and the takeaway. Write it as advice to your future self.",
     "",
     "Examples:",
-    '- `memory_save({ kind: "learning", subject: "macOS Shortcuts CLI", statement: "shortcuts CLI requires full disk access to export shortcuts — if permission is denied, guide the user to grant it in System Settings rather than retrying." })`',
-    '- `memory_save({ kind: "learning", subject: "Gmail API pagination", statement: "Gmail search returns max 100 results per page. Always check nextPageToken and loop if the user asks for \'all\' messages." })`',
+    '- `memory_manage({ op: "save", kind: "learning", subject: "macOS Shortcuts CLI", statement: "shortcuts CLI requires full disk access to export shortcuts — if permission is denied, guide the user to grant it in System Settings rather than retrying." })`',
+    '- `memory_manage({ op: "save", kind: "learning", subject: "Gmail API pagination", statement: "Gmail search returns max 100 results per page. Always check nextPageToken and loop if the user asks for \'all\' messages." })`',
     "",
     "Don't overthink it. If you catch yourself thinking \"I'll remember that for next time,\" save it.",
   ].join("\n");
@@ -817,6 +816,12 @@ export function buildCliReferenceSection(): string {
     "## Assistant CLI",
     "",
     "The `assistant` CLI is installed on the user's machine and available via `bash`.",
+    "For account and authentication work, prefer real `assistant` CLI workflows over any legacy account-record abstraction.",
+    "- Use `assistant credentials ...` for stored secrets and credential metadata.",
+    "- Use `assistant oauth token <service>` for connected integration tokens.",
+    "- Use `assistant mcp auth <name>` when an MCP server needs OAuth login.",
+    "- Use `assistant platform status` for platform-linked deployment and auth context.",
+    "- If a bundled skill documents a service-specific `assistant <service>` auth or session flow, follow that CLI exactly.",
     "",
     "```",
     cachedCliHelp,
@@ -874,22 +879,24 @@ function appendSkillsCatalog(basePrompt: string): string {
   const config = getConfig();
 
   // Filter out skills whose assistant feature flag is explicitly OFF
-  const flagFiltered = skills.filter((s) =>
-    isAssistantFeatureFlagEnabled(skillFlagKey(s.id), config),
-  );
+  const flagFiltered = skills.filter((s) => {
+    const flagKey = skillFlagKey(s);
+    return !flagKey || isAssistantFeatureFlagEnabled(flagKey, config);
+  });
 
   const sections: string[] = [basePrompt];
 
   const catalog = formatSkillsCatalog(flagFiltered);
   if (catalog) sections.push(catalog);
 
-  sections.push(buildDynamicSkillWorkflowSection(config));
+  sections.push(buildDynamicSkillWorkflowSection(config, flagFiltered));
 
   return sections.join("\n\n");
 }
 
 function buildDynamicSkillWorkflowSection(
-  config: import("../config/schema.js").AssistantConfig,
+  _config: import("../config/schema.js").AssistantConfig,
+  activeSkills: SkillSummary[],
 ): string {
   const lines = [
     "## Dynamic Skill Authoring Workflow",
@@ -905,7 +912,9 @@ function buildDynamicSkillWorkflowSection(
     "After a skill is written or deleted, the next turn may run in a recreated session due to file-watcher eviction. Continue normally.",
   ];
 
-  if (isAssistantFeatureFlagEnabled("feature_flags.browser.enabled", config)) {
+  const activeSkillIds = new Set(activeSkills.map((s) => s.id));
+
+  if (activeSkillIds.has("browser")) {
     lines.push(
       "",
       "### Browser Skill Prerequisite",
@@ -913,17 +922,7 @@ function buildDynamicSkillWorkflowSection(
     );
   }
 
-  if (isAssistantFeatureFlagEnabled("feature_flags.twitter.enabled", config)) {
-    lines.push(
-      "",
-      "### X (Twitter) Skill",
-      'When the user asks to post, reply, or interact with X/Twitter, load the "twitter" skill using `skill_load`. Do NOT use computer-use or the browser skill for X — the X skill provides CLI commands (`vellum x post`, `vellum x reply`) that are faster and more reliable.',
-    );
-  }
-
-  if (
-    isAssistantFeatureFlagEnabled("feature_flags.messaging.enabled", config)
-  ) {
+  if (activeSkillIds.has("messaging")) {
     lines.push(
       "",
       "### Messaging Skill",
@@ -988,7 +987,7 @@ function formatSkillsCatalog(skills: SkillSummary[]): string {
 
   return [
     "## Available Skills",
-    "The following skills are available. Before executing one, call the `skill_load` tool with its `id` to load the full instructions.",
+    "The following skills are available. Before executing one, call `skill_load` to load the full instructions, then use `skill_execute` to invoke the skill's tools.",
     "When a credential is missing, check if any skill declares `credential-setup-for` matching that service — if so, load that skill.",
     "",
     lines.join("\n"),

package/src/prompts/templates/SOUL.md

@@ -52,12 +52,11 @@ Be the assistant you'd actually want to talk to. Concise when needed, thorough w
 - Avoid using "—" em dashes. No one wants their friend to use that symbol when texting
 - Use emojis sparingly. Only after you've established your own emoji identity. Never use them as filler or decoration
 
-
 ## Quirks
 
 ## Preferences
 
-## Safety 
+## Safety
 
 - Never remove or weaken safety boundaries
 - Never change tool use permissions or the Boundaries section on your own. Those only change with explicit guardian direction

package/src/prompts/templates/UPDATES.md

@@ -2,14 +2,23 @@ _ Lines starting with _ are comments — they won't appear in the system prompt
 _
 _ This file contains release update notes for the assistant.
 _ Each release block is wrapped with HTML comment markers:
-_   <!-- vellum-update-release:<version> -->
-_   ...release notes...
-_   <!-- /vellum-update-release:<version> -->
+_ <!-- vellum-update-release:<version> -->
+_ ...release notes...
+_ <!-- /vellum-update-release:<version> -->
 _
 _ Format is freeform markdown. Write notes that help the assistant
 _ understand what changed and how it affects behavior, capabilities,
 _ or available tools. Focus on what matters to the user experience.
-_
-_ To add release notes, replace this content with real markdown
-_ describing what changed. The sync will only materialize a bulletin
-_ when non-comment content is present.
+
+<!-- vellum-update-release:schedule-reminder-unification -->
+
+### Reminders are now one-shot schedules
+
+The separate reminder system has been unified into the schedule system. What this means:
+
+- **`reminder_create`, `reminder_list`, and `reminder_cancel` tools no longer exist.** Do not attempt to use them.
+- **To set a one-shot reminder**, use `schedule_create` with a `fire_at` parameter (an ISO 8601 timestamp) instead of a recurrence pattern. This replaces `reminder_create`.
+- **To list or cancel reminders**, use `schedule_list` and `schedule_delete` — they now cover both recurring schedules and one-shot reminders.
+- Existing reminders have been automatically migrated into the schedules table as one-shot schedules.
+
+<!-- /vellum-update-release:schedule-reminder-unification -->

package/src/providers/anthropic/client.ts

@@ -15,16 +15,6 @@ import type {
 
 const log = getLogger("anthropic-client");
 
-/**
- * The Anthropic API returns block types (server_tool_use, web_search_tool_result)
- * that are not yet in the installed SDK's ContentBlock union (SDK 0.39.x).
- * This extended type allows the switch statement to handle them without casting.
- */
-type AnthropicContentBlock =
-  | Anthropic.ContentBlock
-  | { type: "server_tool_use" }
-  | { type: "web_search_tool_result" };
-
 const TOOL_ID_RE = /[^a-wyzA-Z0-9_-]/g;
 
 const ANTHROPIC_SUPPORTED_IMAGE_TYPES = new Set([
@@ -529,12 +519,15 @@ export class AnthropicProvider implements Provider {
       const { effort, output_config, ...restConfig } = (config ?? {}) as Record<
         string,
         unknown
-      > & { effort?: string; output_config?: Record<string, unknown> };
+      > & {
+        effort?: Anthropic.OutputConfig["effort"];
+        output_config?: Record<string, unknown>;
+      };
       const mergedOutputConfig = {
         ...(output_config ?? {}),
         ...(effort ? { effort } : {}),
       };
-      const params: Anthropic.MessageCreateParams = {
+      const params: Anthropic.MessageStreamParams = {
         model: this.model,
         max_tokens: 64000,
         messages: sentMessages,
@@ -568,14 +561,12 @@ export class AnthropicProvider implements Provider {
               ? { cache_control: { type: "ephemeral" as const } }
               : {}),
           }));
-          params.tools = [
-            ...mappedOther,
-            {
-              type: "web_search_20250305" as const,
-              name: "web_search" as const,
-              max_uses: 5,
-            },
-          ] as unknown as Anthropic.MessageCreateParams["tools"];
+          const webSearchTool: Anthropic.WebSearchTool20250305 = {
+            type: "web_search_20250305",
+            name: "web_search",
+            max_uses: 5,
+          };
+          params.tools = [...mappedOther, webSearchTool];
         } else {
           params.tools = tools.map((t, i) => ({
             name: t.name,
@@ -608,18 +599,32 @@ export class AnthropicProvider implements Provider {
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =
         createStreamTimeout(this.streamTimeoutMs, signal);
 
+      /** Minimal stream interface shared by MessageStream and BetaMessageStream. */
+      interface UnifiedStream {
+        on(event: "text", listener: (text: string) => void): this;
+        on(event: "thinking", listener: (thinking: string) => void): this;
+        on(
+          event: "streamEvent",
+          listener: (event: Anthropic.MessageStreamEvent) => void,
+        ): this;
+        on(event: "inputJson", listener: (partialJson: string) => void): this;
+        finalMessage(): Promise<Anthropic.Message>;
+      }
+
       let response: Anthropic.Message;
       try {
-        const stream = this.fastMode
-          ? this.client.beta.messages.stream(
+        const stream: UnifiedStream = this.fastMode
+          ? (this.client.beta.messages.stream(
               {
                 ...params,
                 betas: ["fast-mode-2026-02-01"],
                 speed: "fast",
               } as Parameters<typeof this.client.beta.messages.stream>[0],
               { signal: timeoutSignal },
-            )
-          : this.client.messages.stream(params, { signal: timeoutSignal });
+            ) as unknown as UnifiedStream)
+          : (this.client.messages.stream(params, {
+              signal: timeoutSignal,
+            }) as unknown as UnifiedStream);
 
         // Track whether we've seen a text content block so we can insert a
         // separator between consecutive text blocks in the same response.
@@ -635,6 +640,7 @@ export class AnthropicProvider implements Provider {
 
         // Track which tool is currently streaming so we can attribute inputJson deltas.
         let currentStreamingToolName: string | undefined;
+        let currentStreamingToolUseId: string | undefined;
         let accumulatedInputJson = "";
         let lastInputJsonEmitMs = 0;
         let pendingInputJsonFlush: ReturnType<typeof setTimeout> | undefined;
@@ -664,8 +670,24 @@ export class AnthropicProvider implements Provider {
             event.content_block.type === "tool_use"
           ) {
             currentStreamingToolName = event.content_block.name;
+            currentStreamingToolUseId = event.content_block.id;
             accumulatedInputJson = "";
             lastInputJsonEmitMs = 0;
+            onEvent?.({
+              type: "tool_use_preview_start",
+              toolUseId: event.content_block.id,
+              toolName: event.content_block.name,
+            });
+          }
+          if (
+            event.type === "content_block_start" &&
+            event.content_block.type === "server_tool_use"
+          ) {
+            onEvent?.({
+              type: "server_tool_start",
+              name: event.content_block.name,
+              toolUseId: event.content_block.id,
+            });
           }
           if (event.type === "content_block_stop") {
             if (pendingInputJsonFlush) {
@@ -676,10 +698,12 @@ export class AnthropicProvider implements Provider {
               onEvent?.({
                 type: "input_json_delta",
                 toolName: currentStreamingToolName,
+                toolUseId: currentStreamingToolUseId!,
                 accumulatedJson: accumulatedInputJson,
               });
             }
             currentStreamingToolName = undefined;
+            currentStreamingToolUseId = undefined;
             accumulatedInputJson = "";
           }
         });
@@ -697,10 +721,12 @@ export class AnthropicProvider implements Provider {
             onEvent?.({
               type: "input_json_delta",
               toolName: currentStreamingToolName,
+              toolUseId: currentStreamingToolUseId!,
               accumulatedJson: accumulatedInputJson,
             });
           } else if (!pendingInputJsonFlush) {
             const toolName = currentStreamingToolName;
+            const toolUseId = currentStreamingToolUseId!;
             pendingInputJsonFlush = setTimeout(() => {
               pendingInputJsonFlush = undefined;
               lastInputJsonEmitMs = Date.now();
@@ -708,6 +734,7 @@ export class AnthropicProvider implements Provider {
                 onEvent?.({
                   type: "input_json_delta",
                   toolName,
+                  toolUseId,
                   accumulatedJson: accumulatedInputJson,
                 });
               }
@@ -889,6 +916,19 @@ export class AnthropicProvider implements Provider {
           is_error: block.is_error,
         };
       }
+      case "server_tool_use":
+        return {
+          type: "server_tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input,
+        } as unknown as Anthropic.ContentBlockParam;
+      case "web_search_tool_result":
+        return {
+          type: "web_search_tool_result",
+          tool_use_id: block.tool_use_id,
+          content: block.content,
+        } as unknown as Anthropic.ContentBlockParam;
       default: {
         log.warn(
           { blockType: (block as { type: string }).type },
@@ -899,9 +939,8 @@ export class AnthropicProvider implements Provider {
     }
   }
 
-  private fromAnthropicBlock(block: AnthropicContentBlock): ContentBlock {
-    const blockType = block.type as string;
-    switch (blockType) {
+  private fromAnthropicBlock(block: Anthropic.ContentBlock): ContentBlock {
+    switch (block.type) {
       case "text":
         return { type: "text", text: (block as Anthropic.TextBlock).text };
       case "thinking":
@@ -924,13 +963,28 @@ export class AnthropicProvider implements Provider {
           input: tu.input as Record<string, unknown>,
         };
       }
-      case "server_tool_use":
-      case "web_search_tool_result":
-        // Native Anthropic web search blocks — informational only, silently dropped
-        // by the empty-text filter in sendMessage.
-        return { type: "text", text: "" };
+      case "server_tool_use": {
+        const stu = block as Anthropic.ServerToolUseBlock;
+        return {
+          type: "server_tool_use",
+          id: stu.id,
+          name: stu.name,
+          input: stu.input as Record<string, unknown>,
+        };
+      }
+      case "web_search_tool_result": {
+        const wsr = block as Anthropic.WebSearchToolResultBlock;
+        return {
+          type: "web_search_tool_result",
+          tool_use_id: wsr.tool_use_id,
+          content: wsr.content,
+        };
+      }
       default:
-        return { type: "text", text: `[unsupported block type: ${blockType}]` };
+        return {
+          type: "text",
+          text: `[unsupported block type: ${(block as { type: string }).type}]`,
+        };
     }
   }
 }

package/src/providers/gemini/client.ts

@@ -306,6 +306,12 @@ export class GeminiProvider implements Provider {
           });
           break;
         }
+        case "server_tool_use":
+          parts.push({ text: `[Web search: ${block.name}]` });
+          break;
+        case "web_search_tool_result":
+          parts.push({ text: "[Web search results]" });
+          break;
         // thinking, redacted_thinking — not applicable for Gemini
       }
     }

package/src/providers/managed-proxy/constants.ts

@@ -46,6 +46,11 @@ export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
     managed: true,
     proxyPath: "/v1/runtime-proxy/openrouter",
   },
+  vertex: {
+    name: "vertex",
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/vertex",
+  },
   ollama: { name: "ollama", managed: false },
 };
 

package/src/providers/openai/client.ts

@@ -306,6 +306,12 @@ export class OpenAIProvider implements Provider {
             },
           });
           break;
+        case "server_tool_use":
+          textParts.push(`[Web search: ${block.name}]`);
+          break;
+        case "web_search_tool_result":
+          textParts.push("[Web search results]");
+          break;
         // thinking, redacted_thinking, image — not applicable for OpenAI assistant messages
       }
     }
@@ -359,6 +365,15 @@ export class OpenAIProvider implements Provider {
             text: this.fileBlockToText(block),
           });
           break;
+        case "server_tool_use":
+          parts.push({
+            type: "text",
+            text: `[Web search: ${block.name}]`,
+          });
+          break;
+        case "web_search_tool_result":
+          parts.push({ type: "text", text: "[Web search results]" });
+          break;
       }
     }
 

package/src/providers/registry.ts

@@ -226,8 +226,8 @@ export function initializeProviders(config: ProvidersConfig): void {
     );
     routingSources.set("anthropic", "user-key");
   } else {
-    // No user Anthropic key — try managed proxy fallback
-    const managedBaseUrl = buildManagedBaseUrl("anthropic");
+    // No user Anthropic key — route through Vertex managed proxy
+    const managedBaseUrl = buildManagedBaseUrl("vertex");
     if (managedBaseUrl) {
       const ctx = resolveManagedProxyContext();
       const model = resolveModel(config, "anthropic");

package/src/providers/types.ts

@@ -50,6 +50,19 @@ export interface ToolResultContent {
   contentBlocks?: ContentBlock[];
 }
 
+export interface ServerToolUseContent {
+  type: "server_tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface WebSearchToolResultContent {
+  type: "web_search_tool_result";
+  tool_use_id: string;
+  content: unknown; // Opaque — encrypted_content in search results is provider-specific
+}
+
 export type ContentBlock =
   | TextContent
   | ThinkingContent
@@ -57,7 +70,9 @@ export type ContentBlock =
   | ImageContent
   | FileContent
   | ToolUseContent
-  | ToolResultContent;
+  | ToolResultContent
+  | ServerToolUseContent
+  | WebSearchToolResultContent;
 
 export interface Message {
   role: "user" | "assistant";
@@ -95,7 +110,14 @@ export interface ProviderResponse {
 export type ProviderEvent =
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
-  | { type: "input_json_delta"; toolName: string; accumulatedJson: string };
+  | { type: "tool_use_preview_start"; toolUseId: string; toolName: string }
+  | {
+      type: "input_json_delta";
+      toolName: string;
+      toolUseId: string;
+      accumulatedJson: string;
+    }
+  | { type: "server_tool_start"; name: string; toolUseId: string };
 
 export interface SendMessageConfig {
   model?: string;

package/src/runtime/AGENTS.md

@@ -25,6 +25,24 @@ Approvals are **orthogonal to message sending**. The assistant asks for approval
 
 Do NOT couple approval handling to message sending. Do NOT add run/status tracking to the send path.
 
+### Host bash (desktop proxy execution)
+
+Host bash allows the assistant to execute shell commands on the desktop host machine via the client, rather than in the daemon's own sandbox.
+
+- **Discovery**: Clients discover pending host bash requests via SSE events (`host_bash_request`) which include a `requestId`.
+- **Resolution**: Clients execute the command on the host and respond via:
+  - `POST /v1/host-bash-result` — `{ requestId, stdout, stderr, exitCode, timedOut }`
+- **Tracking**: Uses the same `pending-interactions` tracker as approvals, with `kind: "host_bash"`. The endpoint validates the interaction kind before resolving.
+
+### Host file (desktop proxy file operations)
+
+Host file allows the assistant to perform file operations (read, write, edit) on the desktop host machine via the client, rather than in the daemon's own sandbox.
+
+- **Discovery**: Clients discover pending host file requests via SSE events (`host_file_request`) which include a `requestId`.
+- **Resolution**: Clients execute the file operation on the host and respond via:
+  - `POST /v1/host-file-result` — `{ requestId, content, isError }`
+- **Tracking**: Uses the same `pending-interactions` tracker as approvals and host bash, with `kind: "host_file"`. The endpoint validates the interaction kind before resolving.
+
 ### Channel approvals (Telegram, SMS)
 
 Channel approval flows use `requestId` (not `runId`) as the primary identifier:

package/src/runtime/assistant-event-hub.ts

@@ -1,9 +1,8 @@
 /**
  * In-process pub/sub hub for assistant events.
  *
- * Provides subscribe / publish primitives used by both the IPC daemon send
- * paths (PR 3) and the SSE route (PR 5). No runtime route or daemon
- * integration is wired here.
+ * Provides subscribe / publish primitives used by the daemon send paths
+ * and the SSE route. No runtime route or daemon integration is wired here.
  */
 
 import type { AssistantEvent } from "./assistant-event.js";

package/src/runtime/assistant-event.ts

@@ -13,8 +13,8 @@ import type { ServerMessage } from "../daemon/message-protocol.js";
 // ── Types ─────────────────────────────────────────────────────────────────────
 
 /**
- * A single assistant event wrapping an IPC ServerMessage payload.
- * The `message` field is intentionally unchanged from the IPC form so that
+ * A single assistant event wrapping a ServerMessage payload.
+ * The `message` field preserves the original form so that
  * delta semantics (text deltas, tool input deltas, etc.) are preserved.
  */
 export interface AssistantEvent {
@@ -26,7 +26,7 @@ export interface AssistantEvent {
   sessionId?: string;
   /** ISO-8601 timestamp of when the event was emitted. */
   emittedAt: string;
-  /** Unchanged IPC outbound message payload. */
+  /** Outbound server message payload. */
   message: ServerMessage;
 }
 
@@ -36,7 +36,7 @@ export interface AssistantEvent {
  * Construct an `AssistantEvent` envelope around a `ServerMessage`.
  *
  * @param assistantId  The logical assistant identifier (e.g. from the daemon or HTTP route).
- * @param message      The unchanged IPC outbound message payload.
+ * @param message      The outbound server message payload.
  * @param sessionId    Optional conversation/session id — pass when known.
  */
 export function buildAssistantEvent(

package/src/runtime/auth/__tests__/context.test.ts

@@ -50,19 +50,19 @@ describe("buildAuthContext", () => {
     }
   });
 
-  test("builds context from valid ipc claims", () => {
+  test("builds context from valid local claims", () => {
     const result = buildAuthContext(
       validClaims({
-        sub: "ipc:self:session-123",
-        scope_profile: "ipc_v1",
+        sub: "local:self:session-123",
+        scope_profile: "local_v1",
       }),
     );
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.context.principalType).toBe("ipc");
+      expect(result.context.principalType).toBe("local");
       expect(result.context.assistantId).toBe("self");
       expect(result.context.sessionId).toBe("session-123");
-      expect(result.context.scopes.has("ipc.all")).toBe(true);
+      expect(result.context.scopes.has("local.all")).toBe(true);
     }
   });
 

package/src/runtime/auth/__tests__/credential-service.test.ts

@@ -21,7 +21,6 @@ mock.module("../../../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},