@vellumai/assistant 0.6.6 → 0.7.0

package/src/daemon/meet-manifest-loader.ts

@@ -0,0 +1,410 @@
+/**
+ * `meet-manifest-loader` — registers proxy tools, routes, and shutdown
+ * hooks for the meet-join skill from its shipped `manifest.json` without
+ * loading the skill's source in-process. Paired with
+ * {@link MeetHostSupervisor}, this is how meet-join wires into the daemon
+ * across the skill-boundary.
+ *
+ * ## Lifecycle
+ *
+ * 1. `meet-host-startup.ts` constructs a {@link MeetHostSupervisor} and
+ *    calls {@link setMeetHostSupervisorForSessionReports} so
+ *    session-reporting IPC frames flow into the supervisor's counter.
+ * 2. It awaits `loadMeetManifestProxies(supervisor)` (this
+ *    function). It reads the shipped `manifest.json`, builds a proxy
+ *    `Tool` for every tool entry, a proxy `SkillRoute` for every route
+ *    entry, and a shutdown hook for every declared hook name.
+ * 3. Each proxy tool's `execute` and each proxy route handler call
+ *    `supervisor.ensureRunning()` before attempting to dispatch over the
+ *    skill IPC socket. Dispatch itself is implemented via the
+ *    bidirectional skill IPC RPC: the proxy invokes
+ *    `supervisor.dispatchTool` / `dispatchRoute` / `dispatchShutdown`,
+ *    which sends a `skill.dispatch_*` frame to the meet-host child and
+ *    awaits its response. Remote errors propagate to the LLM (for tools)
+ *    or to the HTTP caller (for routes) as normal.
+ *
+ * ## Manifest path
+ *
+ * The manifest is expected at `<skillRuntimePath>/manifest.json` where
+ * `skillRuntimePath` is resolved via
+ * `getSkillRuntimePath("meet-join", getRepoSkillsDir())`. The loader
+ * surfaces a clear error when the file is missing so packaging bugs
+ * (manifest not shipped in the Docker image or `.app` Resources) fail
+ * loudly at daemon startup rather than silently omitting the tools.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { SkillRoute } from "../runtime/skill-route-registry.js";
+import { registerSkillRoute } from "../runtime/skill-route-registry.js";
+import { getRepoSkillsDir } from "../skills/catalog-install.js";
+import { registerExternalTools } from "../tools/registry.js";
+import type {
+  ExecutionTarget,
+  Tool,
+  ToolContext,
+  ToolDefinition,
+} from "../tools/types.js";
+import { RiskLevel } from "../tools/types.js";
+import { getLogger } from "../util/logger.js";
+import { getSkillRuntimePath } from "../util/platform.js";
+import type { MeetHostSupervisor } from "./meet-host-supervisor.js";
+import { registerShutdownHook } from "./shutdown-registry.js";
+
+const log = getLogger("meet-manifest-loader");
+
+const MEET_SKILL_ID = "meet-join";
+
+// ---------------------------------------------------------------------------
+// Manifest shape — mirrors skills/meet-join/scripts/emit-manifest.ts
+// ---------------------------------------------------------------------------
+
+interface ManifestToolEntry {
+  name: string;
+  description: string;
+  category: string;
+  risk: string;
+  input_schema: unknown;
+}
+
+interface ManifestRouteEntry {
+  pattern: string;
+  methods: string[];
+}
+
+interface Manifest {
+  skill: string;
+  tools: ManifestToolEntry[];
+  routes: ManifestRouteEntry[];
+  shutdownHooks: string[];
+  sourceHash: string;
+}
+
+function coerceRiskLevel(value: string, toolName: string): RiskLevel {
+  // Manifest `risk` is a serialized RiskLevel ("low" | "medium" | "high").
+  const allowed: readonly string[] = ["low", "medium", "high"];
+  if (!allowed.includes(value)) {
+    throw new Error(
+      `meet-manifest-loader: unknown risk level "${value}" on tool "${toolName}"`,
+    );
+  }
+  return value as RiskLevel;
+}
+
+/**
+ * Allowlist of {@link ToolContext} fields that survive JSON serialization
+ * cleanly and that a remote skill might reasonably consult. Function /
+ * AbortSignal / CesClient / proxy fields are intentionally excluded —
+ * they cannot cross the IPC boundary.
+ */
+const SERIALIZABLE_TOOL_CONTEXT_KEYS = [
+  "workingDir",
+  "conversationId",
+  "trustClass",
+  "assistantId",
+  "taskRunId",
+  "requestId",
+  "executionChannel",
+  "callSessionId",
+  "principal",
+  "toolUseId",
+  "memoryScopeId",
+  "requesterExternalUserId",
+  "requesterChatId",
+  "requesterIdentifier",
+  "requesterDisplayName",
+  "transportInterface",
+  "isInteractive",
+  "isPlatformHosted",
+] as const satisfies ReadonlyArray<keyof ToolContext>;
+
+function serializeToolContext(context: ToolContext): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const key of SERIALIZABLE_TOOL_CONTEXT_KEYS) {
+    const value = context[key];
+    if (value !== undefined) out[key] = value;
+  }
+  return out;
+}
+
+function buildProxyTool(
+  entry: ManifestToolEntry,
+  supervisor: MeetHostSupervisor,
+  manifestHash: string,
+): Tool {
+  const definition: ToolDefinition = {
+    name: entry.name,
+    description: entry.description,
+    input_schema: (entry.input_schema as object) ?? {},
+  };
+  const risk = coerceRiskLevel(entry.risk, entry.name);
+  return {
+    name: entry.name,
+    description: entry.description,
+    category: entry.category,
+    defaultRiskLevel: risk,
+    executionMode: "proxy",
+    executionTarget: "host" as ExecutionTarget,
+    origin: "skill",
+    ownerSkillId: MEET_SKILL_ID,
+    ownerSkillBundled: true,
+    ownerSkillVersionHash: manifestHash,
+    getDefinition: () => definition,
+    execute: async (input, context) => {
+      // `dispatchTool` ensures the meet-host child is up + connected
+      // before sending the frame, so callers don't need a separate
+      // `ensureRunning()` call. Remote errors propagate as normal.
+      const result = await supervisor.dispatchTool(
+        entry.name,
+        input,
+        serializeToolContext(context),
+      );
+      // The skill returns whatever its `Tool.execute` produced — the
+      // daemon-side ToolExecutor expects `ToolExecutionResult` shape but
+      // proxies forward verbatim; the LLM-facing executor reconciles the
+      // shape downstream.
+      return result as Awaited<ReturnType<Tool["execute"]>>;
+    },
+  };
+}
+
+function buildProxyRoute(
+  entry: ManifestRouteEntry,
+  supervisor: MeetHostSupervisor,
+): SkillRoute {
+  let pattern: RegExp;
+  try {
+    pattern = new RegExp(entry.pattern);
+  } catch (err) {
+    throw new Error(
+      `meet-manifest-loader: invalid route pattern "${entry.pattern}": ${String(err)}`,
+    );
+  }
+  return {
+    pattern,
+    methods: [...entry.methods],
+    handler: async (request) => {
+      let response: {
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+      };
+      try {
+        // Materialize the inbound Request into a JSON-serializable
+        // envelope: skill-side `dispatchRoute` reconstructs a fresh
+        // `Request(url, init)` from this shape and runs the skill's
+        // handler against it.
+        const headers: Record<string, string> = {};
+        request.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        const method = request.method;
+        const body =
+          method === "GET" || method === "HEAD"
+            ? undefined
+            : await request.text();
+        // Skill-side `dispatchRoute` re-runs the registered regex against
+        // the forwarded URL; meet-join's patterns are path-anchored
+        // (e.g. `^/v1/internal/meet/...$`), so the absolute `request.url`
+        // would never match. Send pathname + search instead.
+        const { pathname, search } = new URL(request.url);
+        response = await supervisor.dispatchRoute(entry.pattern, {
+          method,
+          url: `${pathname}${search}`,
+          headers,
+          ...(body !== undefined ? { body } : {}),
+        });
+      } catch (err) {
+        log.warn(
+          { err, pattern: entry.pattern },
+          "meet-host route dispatch failed",
+        );
+        return new Response("meet-host route dispatch failed", { status: 503 });
+      }
+      return new Response(response.body, {
+        status: response.status,
+        headers: response.headers,
+      });
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Manifest loading
+// ---------------------------------------------------------------------------
+
+/**
+ * Locate the shipped manifest path. Visible for testing so callers can
+ * redirect to a fixture without stubbing `getRepoSkillsDir()` (which
+ * reads `import.meta.dir` and `process.env.VELLUM_DEV`).
+ */
+export function resolveMeetManifestPath(): string | undefined {
+  const skillsRoot = getRepoSkillsDir();
+  const skillRuntime = getSkillRuntimePath(MEET_SKILL_ID, skillsRoot);
+  if (!skillRuntime) return undefined;
+  return join(skillRuntime, "manifest.json");
+}
+
+/**
+ * Read and validate the shipped manifest from disk. Exposed so
+ * `meet-host-startup.ts` can extract `sourceHash` for
+ * {@link MeetHostSupervisor} construction without duplicating the JSON
+ * validation shape.
+ */
+export function loadMeetManifestFromDisk(manifestPath: string): {
+  skill: string;
+  sourceHash: string;
+  tools: ManifestToolEntry[];
+  routes: ManifestRouteEntry[];
+  shutdownHooks: string[];
+} {
+  return loadManifestInternal(manifestPath);
+}
+
+function loadManifestInternal(manifestPath: string): Manifest {
+  if (!existsSync(manifestPath)) {
+    throw new Error(
+      `meet-join manifest not found at ${manifestPath} — ` +
+        "rebuild/repackage to include the meet-join manifest " +
+        "(skills/meet-join/scripts/emit-manifest.ts).",
+    );
+  }
+  let raw: string;
+  try {
+    raw = readFileSync(manifestPath, "utf8");
+  } catch (err) {
+    throw new Error(
+      `meet-join manifest at ${manifestPath} could not be read: ${String(err)}`,
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `meet-join manifest at ${manifestPath} is not valid JSON: ${String(err)}`,
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `meet-join manifest at ${manifestPath} must be a JSON object`,
+    );
+  }
+  const obj = parsed as Record<string, unknown>;
+  if (obj.skill !== MEET_SKILL_ID) {
+    throw new Error(
+      `meet-join manifest skill field was "${String(obj.skill)}" but expected "${MEET_SKILL_ID}"`,
+    );
+  }
+  if (
+    !Array.isArray(obj.tools) ||
+    !Array.isArray(obj.routes) ||
+    !Array.isArray(obj.shutdownHooks) ||
+    typeof obj.sourceHash !== "string"
+  ) {
+    throw new Error(
+      `meet-join manifest at ${manifestPath} is missing required fields`,
+    );
+  }
+  return obj as unknown as Manifest;
+}
+
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Dependencies the loader reads to register manifest-derived proxies.
+ * All fields are optional — production callers rely on the module-level
+ * defaults and tests override one or two. Keeping them injectable lets
+ * the unit test inject a fixture manifest path without mocking
+ * `getRepoSkillsDir()` + `existsSync` + `readFileSync`.
+ */
+export interface MeetManifestLoaderDeps {
+  /** Override for the manifest path resolver. */
+  manifestPath?: string;
+  /** Override for {@link registerExternalTools}. */
+  registerTools?: (provider: () => Tool[]) => void;
+  /** Override for {@link registerSkillRoute}. */
+  registerRoute?: (route: SkillRoute) => unknown;
+  /** Override for {@link registerShutdownHook}. */
+  registerShutdown?: (
+    name: string,
+    hook: (reason: string) => Promise<void>,
+  ) => void;
+}
+
+/**
+ * Read the shipped manifest and install proxy tool/route/shutdown-hook
+ * registrations that front-run through {@link MeetHostSupervisor}.
+ * Throws when the manifest is missing or malformed so packaging errors
+ * surface at daemon startup.
+ */
+export async function loadMeetManifestProxies(
+  supervisor: MeetHostSupervisor,
+  deps: MeetManifestLoaderDeps = {},
+): Promise<void> {
+  const manifestPath = deps.manifestPath ?? resolveMeetManifestPath();
+  if (!manifestPath) {
+    throw new Error(
+      "meet-join manifest path is unresolved — " +
+        "the shipped skills directory was not found. " +
+        "Rebuild/repackage so first-party skills ship with the daemon.",
+    );
+  }
+  const manifest = loadManifestInternal(manifestPath);
+
+  const registerTools = deps.registerTools ?? registerExternalTools;
+  const registerRoute = deps.registerRoute ?? registerSkillRoute;
+  const registerShutdown = deps.registerShutdown ?? registerShutdownHook;
+
+  // Eagerly validate every tool entry so a malformed manifest (e.g. an
+  // unknown `risk` value) surfaces here, where startup catches it, rather
+  // than later inside the lazy tool provider during `initializeTools()`.
+  for (const entry of manifest.tools) {
+    coerceRiskLevel(entry.risk, entry.name);
+  }
+
+  // Tool provider resolves the full proxy list lazily so the tool manifest
+  // reflects the manifest file at `initializeTools()` time — same timing
+  // contract as the in-process skill's provider closure.
+  registerTools(() =>
+    manifest.tools.map((entry) =>
+      buildProxyTool(entry, supervisor, manifest.sourceHash),
+    ),
+  );
+
+  for (const entry of manifest.routes) {
+    registerRoute(buildProxyRoute(entry, supervisor));
+  }
+
+  for (const hookName of manifest.shutdownHooks) {
+    registerShutdown(hookName, async (reason) => {
+      // Fire the named shutdown hook on the skill side so it runs any
+      // teardown the in-process registration would have run. Best-effort:
+      // if the connection is gone or the dispatch throws, the supervisor
+      // still tears down the child below.
+      try {
+        await supervisor.dispatchShutdown(hookName, reason);
+      } catch (err) {
+        log.warn(
+          { err, hookName, reason },
+          "meet-host shutdown hook dispatch failed; continuing with supervisor teardown",
+        );
+      }
+      await supervisor.shutdown();
+    });
+  }
+
+  log.info(
+    {
+      manifestPath,
+      tools: manifest.tools.length,
+      routes: manifest.routes.length,
+      shutdownHooks: manifest.shutdownHooks.length,
+      sourceHash: manifest.sourceHash,
+    },
+    "Loaded meet-join manifest and installed lazy proxies",
+  );
+}

package/src/daemon/memory-v2-startup.ts

@@ -0,0 +1,35 @@
+// ---------------------------------------------------------------------------
+// Memory v2 — daemon-startup helpers
+// ---------------------------------------------------------------------------
+//
+// Small focused module that holds the gating + dispatch logic for v2-specific
+// startup work invoked from `lifecycle.ts`. Lives in its own file so the unit
+// test for the gate does not have to mount the entire lifecycle import graph.
+
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import type { AssistantConfig } from "../config/schema.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("memory-v2-startup");
+
+/**
+ * Fire-and-forget seed of the v2 parallel skill embedding collection. Gated
+ * on both the `memory-v2-enabled` feature flag and the workspace-level
+ * `config.memory.v2.enabled` switch so v2 modules stay out of the v1 startup
+ * path when v2 is off.
+ *
+ * Uses a dynamic import so v2 code does not load unless the gate passes.
+ * Never awaits — startup must not block on this (see `assistant/CLAUDE.md`
+ * daemon startup philosophy).
+ */
+export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
+  if (
+    !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
+    !config.memory.v2.enabled
+  ) {
+    return;
+  }
+  void import("../memory/v2/skill-store.js")
+    .then(({ seedV2SkillEntries }) => seedV2SkillEntries())
+    .catch((err) => log.warn({ err }, "Failed to seed v2 skill entries"));
+}

package/src/daemon/message-protocol.ts

@@ -27,6 +27,7 @@ export * from "./message-types/host-bash.js";
 export * from "./message-types/host-browser.js";
 export * from "./message-types/host-cu.js";
 export * from "./message-types/host-file.js";
+export * from "./message-types/host-transfer.js";
 export * from "./message-types/inbox.js";
 export * from "./message-types/integrations.js";
 export * from "./message-types/meet.js";
@@ -40,7 +41,6 @@ export * from "./message-types/shared.js";
 export * from "./message-types/skills.js";
 export * from "./message-types/subagents.js";
 export * from "./message-types/surfaces.js";
-export * from "./message-types/trust.js";
 export * from "./message-types/upgrades.js";
 export * from "./message-types/work-items.js";
 export * from "./message-types/workspace.js";
@@ -87,6 +87,7 @@ import type {
 } from "./message-types/host-browser.js";
 import type { _HostCuServerMessages } from "./message-types/host-cu.js";
 import type { _HostFileServerMessages } from "./message-types/host-file.js";
+import type { _HostTransferServerMessages } from "./message-types/host-transfer.js";
 import type {
   _InboxClientMessages,
   _InboxServerMessages,
@@ -129,10 +130,6 @@ import type {
   _SurfacesClientMessages,
   _SurfacesServerMessages,
 } from "./message-types/surfaces.js";
-import type {
-  _TrustClientMessages,
-  _TrustServerMessages,
-} from "./message-types/trust.js";
 import type { _UpgradesServerMessages } from "./message-types/upgrades.js";
 import type {
   _WorkItemsClientMessages,
@@ -159,7 +156,6 @@ export type ClientMessage =
   | _MessagesClientMessages
   | _SurfacesClientMessages
   | _SkillsClientMessages
-  | _TrustClientMessages
   | _AppsClientMessages
   | _IntegrationsClientMessages
   | _ComputerUseClientMessages
@@ -185,7 +181,6 @@ export type ServerMessage =
   | _MessagesServerMessages
   | _SurfacesServerMessages
   | _SkillsServerMessages
-  | _TrustServerMessages
   | _AppsServerMessages
   | _IntegrationsServerMessages
   | _ComputerUseServerMessages
@@ -200,6 +195,7 @@ export type ServerMessage =
   | _HostBrowserServerMessages
   | _HostCuServerMessages
   | _HostFileServerMessages
+  | _HostTransferServerMessages
   | _MeetServerMessages
   | _MemoryServerMessages
   | _WorkspaceServerMessages
@@ -219,3 +215,4 @@ export interface ContractSchema {
   client: ClientMessage;
   server: ServerMessage;
 }
+

package/src/daemon/message-types/acp.ts

@@ -14,6 +14,7 @@ export interface AcpSessionUpdate {
   acpSessionId: string;
   updateType:
     | "agent_message_chunk"
+    | "agent_thought_chunk"
     | "user_message_chunk"
     | "tool_call"
     | "tool_call_update"

package/src/daemon/message-types/conversations.ts

@@ -211,7 +211,11 @@ export interface ConversationInfo {
   title: string;
   correlationId?: string;
   conversationType?: ConversationType;
-  hostAccess: boolean;
+  /**
+   * Per-conversation override for the LLM inference profile. `undefined`
+   * means the conversation inherits the workspace `llm.activeProfile`.
+   */
+  inferenceProfile?: string;
 }
 
 export interface ConversationTitleUpdated {
@@ -253,7 +257,6 @@ export interface ConversationListResponse {
     updatedAt: number;
     conversationType?: ConversationType;
     source?: string;
-    hostAccess: boolean;
     scheduleJobId?: string;
     channelBinding?: ChannelBinding;
     conversationOriginChannel?: ChannelId;
@@ -262,6 +265,11 @@ export interface ConversationListResponse {
     displayOrder?: number;
     isPinned?: boolean;
     forkParent?: ConversationForkParent;
+    /**
+     * Per-conversation override for the LLM inference profile. Omitted when
+     * the conversation inherits the workspace `llm.activeProfile`.
+     */
+    inferenceProfile?: string;
   }>;
   /** Whether more conversations exist beyond the returned page. */
   hasMore?: boolean;
@@ -337,6 +345,12 @@ export interface HistoryResponseToolCall {
   confirmationDecision?: string;
   /** Friendly label for the confirmation (e.g. "Edit File", "Run Command"). */
   confirmationLabel?: string;
+  /** Risk level at the time of invocation ("low" | "medium" | "high" | "unknown"). */
+  riskLevel?: string;
+  /** Human-readable reason for the risk classification. */
+  riskReason?: string;
+  /** Whether the tool was auto-approved (true) or required explicit user input (false). */
+  autoApproved?: boolean;
 }
 
 export interface HistoryResponseSurface {

package/src/daemon/message-types/host-transfer.ts

@@ -0,0 +1,41 @@
+// Host transfer proxy types.
+// Enables bidirectional file transfer between sandbox and host machine
+// when running as a managed assistant.
+
+// === Server → Client ===
+
+export interface HostTransferToHostRequest {
+  type: "host_transfer_request";
+  requestId: string;
+  conversationId: string;
+  direction: "to_host";
+  transferId: string;
+  destPath: string;
+  sizeBytes: number;
+  sha256: string;
+  overwrite: boolean;
+}
+
+export interface HostTransferToSandboxRequest {
+  type: "host_transfer_request";
+  requestId: string;
+  conversationId: string;
+  direction: "to_sandbox";
+  transferId: string;
+  sourcePath: string;
+}
+
+export type HostTransferRequest =
+  | HostTransferToHostRequest
+  | HostTransferToSandboxRequest;
+
+export interface HostTransferCancelRequest {
+  type: "host_transfer_cancel";
+  requestId: string;
+}
+
+// --- Domain-level union aliases (consumed by the barrel file) ---
+
+export type _HostTransferServerMessages =
+  | HostTransferRequest
+  | HostTransferCancelRequest;

package/src/daemon/message-types/integrations.ts

@@ -98,6 +98,12 @@ export interface IngressConfigResponse {
   publicBaseUrl: string;
   /** Read-only gateway target computed from GATEWAY_PORT env var (default 7830) + loopback host. */
   localGatewayTarget: string;
+  /**
+   * When true, this assistant uses platform-managed callback routing.
+   * Webhook delivery is handled by the platform — no local tunnel or
+   * ngrok setup is needed. `publicBaseUrl` reflects the platform callback URL.
+   */
+  managedCallbacks?: boolean;
   success: boolean;
   error?: string;
 }

package/src/daemon/message-types/messages.ts

@@ -32,13 +32,7 @@ export interface UserMessage {
 export interface ConfirmationResponse {
   type: "confirmation_response";
   requestId: string;
-  decision:
-    | "allow"
-    | "allow_10m"
-    | "allow_conversation"
-    | "always_allow"
-    | "deny"
-    | "always_deny";
+  decision: "allow" | "deny";
   selectedPattern?: string;
   selectedScope?: string;
 }
@@ -153,6 +147,8 @@ export interface ToolResult {
   isContainerized?: boolean;
   /** Scope options ladder for the rule editor modal (narrowest to broadest). */
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  /** Directory scope ladder for the rule editor modal (narrowest to broadest). */
+  riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
 }
 
 export interface ConfirmationRequest {
@@ -172,6 +168,7 @@ export interface ConfirmationRequest {
     pattern: string;
   }>;
   scopeOptions: Array<{ label: string; scope: string }>;
+  directoryScopeOptions?: Array<{ scope: string; label: string }>;
   diff?: {
     filePath: string;
     oldContent: string;
@@ -181,8 +178,6 @@ export interface ConfirmationRequest {
   conversationId?: string;
   /** When false, the client should hide "always allow" / trust-rule persistence affordances. */
   persistentDecisionsAllowed?: boolean;
-  /** Which temporary approval options the client should render (e.g. "Allow for 10 minutes", "Allow for this conversation"). */
-  temporaryOptionsAvailable?: Array<"allow_10m" | "allow_conversation">;
   /** The tool_use block ID for client-side correlation with specific tool calls. */
   toolUseId?: string;
   /** ACP tool kind from the agent (e.g. "read", "edit", "execute"). Present only for ACP permission requests. */
@@ -341,11 +336,16 @@ export interface AssistantActivityState {
   statusText?: string;
 }
 
-/** Broadcast to clients when a conversation's host-access setting changes. */
-export interface ConversationHostAccessUpdated {
-  type: "conversation_host_access_updated";
+/**
+ * Broadcast to clients when a conversation's inference-profile override
+ * changes. `profile` is the profile name (a key in `llm.profiles`) or
+ * `null` when the override is cleared and the conversation falls back to
+ * the workspace `llm.activeProfile` resolution.
+ */
+export interface ConversationInferenceProfileUpdated {
+  type: "conversation_inference_profile_updated";
   conversationId: string;
-  hostAccess: boolean;
+  profile: string | null;
 }
 
 export type TraceEventKind =
@@ -410,4 +410,4 @@ export type _MessagesServerMessages =
   | TraceEvent
   | ConfirmationStateChanged
   | AssistantActivityState
-  | ConversationHostAccessUpdated;
+  | ConversationInferenceProfileUpdated;

package/src/daemon/message-types/schedules.ts

@@ -84,6 +84,7 @@ export interface SchedulesListResponse {
     status: string;
     routingIntent: string;
     reuseConversation: boolean;
+    wakeConversationId: string | null;
     isOneShot: boolean;
   }>;
 }