@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

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

@@ -156,7 +156,9 @@ export async function createInboundChallenge(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Revoke the existing binding first, or set rebind: true to replace.",
+        resolvedChannel === "phone"
+          ? "A guardian is already bound for this channel. On phone, verify through an outbound call with rebind: true. To a new number, it replaces the bound number once the code is entered. To the bound number, it confirms that number again and leaves the binding as it is. An inbound challenge cannot be completed by phone: a call collects a six-digit code, which an inbound challenge does not issue."
+          : "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel: resolvedChannel,
     };
   }

package/src/daemon/handlers/conversation-history.ts

@@ -14,6 +14,12 @@ export interface ConversationSearchParams {
   query: string;
   limit?: number;
   maxMessagesPerConversation?: number;
+  /**
+   * Reach archived conversations as well as live ones. Defaults to false, so
+   * this search matches what the sidebar shows. Callers opt in where an
+   * archived chat is a filed chat rather than a hidden one.
+   */
+  includeArchived?: boolean;
 }
 
 /** Search conversations and return results (no transport dependency). */
@@ -22,7 +28,10 @@ export async function performConversationSearch(
 ) {
   // Treat "*" as a list-all wildcard — FTS treats it as a literal character.
   if (params.query.trim() === "*") {
-    const rows = listConversations({ limit: params.limit });
+    const rows = listConversations({
+      limit: params.limit,
+      archiveStatus: params.includeArchived ? "all" : "active",
+    });
     return rows.map((r) => ({
       conversationId: r.id,
       conversationTitle: r.title,
@@ -33,6 +42,7 @@ export async function performConversationSearch(
   return searchConversations(params.query, {
     limit: params.limit,
     maxMessagesPerConversation: params.maxMessagesPerConversation,
+    includeArchived: params.includeArchived,
   });
 }
 

package/src/daemon/handlers/conversations.ts

@@ -10,9 +10,11 @@ import { resolveConversationId } from "../../persistence/conversation-key-store.
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { resolveCapabilities } from "../../runtime/capabilities.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
+import { resolvePendingQuestion } from "../../runtime/question-resolution.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { UserError } from "../../util/errors.js";
+import type { Conversation } from "../conversation.js";
 import { touchConversation } from "../conversation-evictor.js";
 import { forceClearStaleProcessing } from "../conversation-lifecycle.js";
 import {
@@ -24,7 +26,7 @@ import {
   conversationEntries,
   findConversation,
 } from "../conversation-registry.js";
-import { resolveSlash } from "../conversation-slash.js";
+import { classifySlash, resolveSlash } from "../conversation-slash.js";
 import {
   clearAllActiveConversations,
   getOrCreateConversation,
@@ -328,23 +330,36 @@ export function deleteQueuedMessage(
     );
     return { removed: false, reason: "forbidden" };
   }
-  conversation.removeQueuedMessage(requestId);
-  // Queue events come in pairs, so an entry that never produced a
-  // `message_queued` ack (a suppressed daemon-injected send, or a hidden
-  // machine send) must not produce a delete either: clients have no row to
-  // retire and an unpaired event would decrement a counter that was never
-  // incremented.
+  consumeQueuedMessage(conversation, conversationId, queued);
+  return { removed: true };
+}
+
+/**
+ * Drop a queued message from the queue and close out the client row it
+ * created, so a message that will never run leaves no pending indicator
+ * behind.
+ *
+ * Queue events come in pairs, so an entry that never produced a
+ * `message_queued` ack (a suppressed daemon-injected send, or a hidden machine
+ * send) must not produce a delete either: clients have no row to retire and an
+ * unpaired event would decrement a counter that was never incremented.
+ */
+function consumeQueuedMessage(
+  conversation: Conversation,
+  conversationId: string,
+  queued: QueuedMessage,
+): void {
+  conversation.removeQueuedMessage(queued.requestId);
   if (!isSuppressedQueuedMessage(queued.metadata)) {
     queued.onEvent({
       type: "message_queued_deleted",
       conversationId,
-      requestId,
+      requestId: queued.requestId,
       ...(queued.clientMessageId
         ? { clientMessageId: queued.clientMessageId }
         : {}),
     });
   }
-  return { removed: true };
 }
 
 /**
@@ -458,6 +473,92 @@ export function steerToMessage(
   return { steered: true };
 }
 
+/**
+ * Answer an open `ask_question` prompt with a message the user typed into the
+ * chat while the card was up.
+ *
+ * Typing an answer instead of using the card is the same act as typing it into
+ * the card's free-text field, so it resolves the prompt rather than cancelling
+ * it: the parked turn keeps running and the model reads the answer in the tool
+ * result. Channel replies already work this way (the bare-text branch of
+ * `runtime/guardian-reply-router.ts`); this is the app path saying the same
+ * thing through the same `resolvePendingQuestion` core.
+ *
+ * The message is consumed, not run as a turn of its own: it reaches the model
+ * once, through the tool result, and the answered card carries the user's own
+ * words in the transcript. Consuming it retires the client's queued row the
+ * same way a queue delete does.
+ *
+ * Deliberately narrow. Anything the free-text field of a card could not have
+ * carried, or that a single answer cannot honestly stand in for, falls through
+ * to {@link steerOnEnqueuedMessageIfQuestionParked} and supersedes as before:
+ *  - more than one parked question, so which prompt the text answers is a guess
+ *  - a message no longer on the queue, which cannot be consumed
+ *  - attachments, which the tool result has no way to carry
+ *  - a send that is not a person typing: automated, non-interactive, or
+ *    echo-suppressed machine signals
+ *  - empty text, which answers nothing
+ *  - a slash command, which is an instruction to the assistant rather than prose
+ *
+ * Returns `true` when a parked question was answered and the message consumed.
+ */
+export function answerParkedQuestionWithEnqueuedMessage(
+  conversationId: string,
+  enqueuedRequestId: string,
+): boolean {
+  const conversation = findConversation(conversationId);
+  if (!conversation) {
+    return false;
+  }
+
+  const parked = pendingInteractions
+    .getByConversation(conversationId)
+    .filter((interaction) => interaction.kind === "question");
+  if (parked.length !== 1) {
+    return false;
+  }
+
+  const queued = conversation.queue.findByRequestId(enqueuedRequestId);
+  if (!queued || queued.attachments.length > 0) {
+    return false;
+  }
+  if (
+    queued.isInteractive === false ||
+    queued.metadata?.automated === true ||
+    isSuppressedQueuedMessage(queued.metadata)
+  ) {
+    return false;
+  }
+
+  const text = queued.content.trim();
+  if (text.length === 0 || classifySlash(text) !== "passthrough") {
+    return false;
+  }
+
+  const outcome = resolvePendingQuestion(parked[0].requestId, {
+    kind: "chat_reply",
+    text,
+  });
+  if (outcome.status !== "resolved") {
+    log.warn(
+      {
+        conversationId,
+        requestId: parked[0].requestId,
+        outcome: outcome.status,
+      },
+      "Parked question did not resolve from the enqueued message",
+    );
+    return false;
+  }
+
+  consumeQueuedMessage(conversation, conversationId, queued);
+  log.info(
+    { conversationId, requestId: parked[0].requestId, enqueuedRequestId },
+    "Enqueued message answered a parked question",
+  );
+  return true;
+}
+
 /**
  * Supersede an open `ask_question` prompt when a new chat message is enqueued
  * for the same conversation.
@@ -495,7 +596,9 @@ export function steerOnEnqueuedMessageIfQuestionParked(
  *     gateway request-status sync *before* clearing the prompter-owned
  *     confirmations, so a later guardian reply can't match a stale "pending"
  *     record and fail with `pending_interaction_not_found`.
- *  2. Supersede a parked ask_question by steering to the enqueued message.
+ *  2. Answer a parked ask_question with the enqueued message when the message
+ *     reads as an answer ({@link answerParkedQuestionWithEnqueuedMessage}), and
+ *     otherwise supersede it by steering to the enqueued message.
  *
  * Order matters: the steer aborts the turn, which denies the prompter's
  * confirmations as a side effect, so the status/notification sync must be
@@ -508,6 +611,11 @@ export function supersedePendingInteractionsOnEnqueue(
   enqueuedRequestId: string,
 ): void {
   denyPendingConfirmationsOnSupersession(conversationId);
+  if (
+    answerParkedQuestionWithEnqueuedMessage(conversationId, enqueuedRequestId)
+  ) {
+    return;
+  }
   steerOnEnqueuedMessageIfQuestionParked(conversationId, enqueuedRequestId);
 }
 

package/src/daemon/pkb-reminder-builder.test.ts

@@ -6,7 +6,7 @@ import { buildPkbReminder } from "./pkb-reminder-builder.js";
 // future edit to the BODY text is caught by tests.
 const BASE_REMINDER =
   "<system_reminder>" +
-  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
+  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark: corrections (highest priority), plans, decisions, felt moments. A later pass may review this conversation and save what you did not capture, but it is not guaranteed and never runs over scheduled work, so save now anything that must survive." +
   "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
   "\n</system_reminder>";
 
@@ -19,7 +19,7 @@ describe("buildPkbReminder", () => {
     const out = buildPkbReminder(["projects/alpha.md"]);
     const expected =
       "<system_reminder>" +
-      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
+      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark: corrections (highest priority), plans, decisions, felt moments. A later pass may review this conversation and save what you did not capture, but it is not guaranteed and never runs over scheduled work, so save now anything that must survive." +
       "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- projects/alpha.md" +
@@ -39,7 +39,7 @@ describe("buildPkbReminder", () => {
     const out = buildPkbReminder(hints);
     const expected =
       "<system_reminder>" +
-      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
+      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark: corrections (highest priority), plans, decisions, felt moments. A later pass may review this conversation and save what you did not capture, but it is not guaranteed and never runs over scheduled work, so save now anything that must survive." +
       "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- a.md" +
@@ -57,6 +57,13 @@ describe("buildPkbReminder", () => {
     expect(idxC).toBeGreaterThan(idxB);
   });
 
+  test("says later capture is conditional and never covers scheduled work", () => {
+    const out = buildPkbReminder([]);
+    expect(out).toContain("not guaranteed");
+    expect(out).toContain("never runs over scheduled work");
+    expect(out).not.toContain("reviews this conversation in the background");
+  });
+
   test("hints with special chars (< and &) are emitted verbatim (no escaping)", () => {
     const hints = ["weird<name>.md", "foo&bar.md"];
     const out = buildPkbReminder(hints);

package/src/daemon/pkb-reminder-builder.ts

@@ -1,5 +1,5 @@
 const BODY =
-  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
+  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark: corrections (highest priority), plans, decisions, felt moments. A later pass may review this conversation and save what you did not capture, but it is not guaranteed and never runs over scheduled work, so save now anything that must survive." +
   "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing.";
 
 /**

package/src/desktop/desktop-browser-endpoint.ts

@@ -134,6 +134,7 @@ export function desktopChromeArguments(
     `--class=${DESKTOP_CHROME_WINDOW_CLASS}`,
     "--force-renderer-accessibility",
     "--disable-dev-shm-usage",
+    "--disable-features=Prerender2",
     ...(shouldRestoreDesktopChromeSession(profileDir)
       ? ["--restore-last-session", "--hide-crash-restore-bubble"]
       : []),

package/src/home/feed-types.ts

@@ -39,6 +39,8 @@ export {
   FeedItemSchema as feedItemSchema,
   type FeedItemStatus,
   type FeedItemType,
+  type FeedItemUpdate,
+  FeedItemUpdateSchema as feedItemUpdateSchema,
   type FeedItemUrgency,
   isPendingGuardianFeedItem,
   type SuggestedPrompt,

package/src/inbound/platform-callback-registration.ts

@@ -24,7 +24,10 @@ import { getConfig } from "../config/loader.js";
 import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { ipcRegisterWebhookRoute } from "../ipc/gateway-client.js";
 import { credentialKey } from "../security/credential-key.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
+import {
+  getSecureKeyAsync,
+  getSecureKeyResultAsync,
+} from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import { resolveClaimedPodWebhookUrl } from "./pod-webhook-claim.js";
 import {
@@ -39,17 +42,23 @@ export interface PlatformCallbackRegistrationContext {
   isPlatform: boolean;
   platformBaseUrl: string;
   assistantId: string;
-  hasAssistantApiKey: boolean;
+  /**
+   * Whether a managed assistant API key is available: `null` when the
+   * credential store could not be read, so its absence is not evidence that
+   * no key is stored. A client deciding whether to provision one must not
+   * read `null` as "missing".
+   */
+  hasAssistantApiKey: boolean | null;
   authHeader: string | null;
   enabled: boolean;
 }
 
 export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
   const platform = getIsPlatform();
-  const [storedBaseUrlRaw, storedAssistantApiKeyRaw, assistantId] =
+  const [storedBaseUrlRaw, storedAssistantApiKey, assistantId] =
     await Promise.all([
       getSecureKeyAsync(credentialKey("vellum", "platform_base_url")),
-      getSecureKeyAsync(credentialKey("vellum", "assistant_api_key")),
+      getSecureKeyResultAsync(credentialKey("vellum", "assistant_api_key")),
       resolvePlatformAssistantId(),
     ]);
 
@@ -60,16 +69,20 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
   );
   const envAssistantCredential = process.env.ASSISTANT_API_KEY?.trim();
   const assistantCredential =
-    storedAssistantApiKeyRaw?.trim() || envAssistantCredential || undefined;
+    storedAssistantApiKey.value?.trim() || envAssistantCredential || undefined;
   const authHeader = assistantCredential
     ? `Api-Key ${assistantCredential}`
     : null;
+  const hasAssistantApiKey =
+    !assistantCredential && storedAssistantApiKey.unreachable
+      ? null
+      : !!assistantCredential;
 
   return {
     isPlatform: platform,
     platformBaseUrl,
     assistantId,
-    hasAssistantApiKey: !!assistantCredential,
+    hasAssistantApiKey,
     authHeader,
     // Enabled when we have enough context to register callback routes.
     // Does NOT require IS_PLATFORM — self-hosted assistants with stored

package/src/ipc/routes/__tests__/conversation-sync-ipc-routes.test.ts

@@ -16,6 +16,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const recordCalls: Array<[string, number]> = [];
 const publishCalls: string[] = [];
+const listPublishCalls: Array<[string, string | string[]]> = [];
 
 mock.module("../../../persistence/conversation-crud.js", () => ({
   recordConversationPersistedSeq: (id: string, seq: number) => {
@@ -27,6 +28,12 @@ mock.module("../../../runtime/sync/resource-sync-events.js", () => ({
   publishConversationMessagesChanged: (id: string) => {
     publishCalls.push(id);
   },
+  publishConversationListAndMetadataChanged: (
+    reason: string,
+    ids: string | string[],
+  ) => {
+    listPublishCalls.push([reason, ids]);
+  },
 }));
 
 import type { AssistantEventEnvelope } from "../../../api/index.js";
@@ -40,9 +47,13 @@ import {
   _resetStreamStateForTesting,
   stampAndBuffer,
 } from "../../../runtime/assistant-stream-state.js";
-import { NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD } from "../../../runtime/sync/worker-daemon-notify.js";
+import {
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
+  NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
+} from "../../../runtime/sync/worker-daemon-notify.js";
 import {
   CONVERSATION_SYNC_IPC_METHODS,
+  handleNotifyConversationListChanged,
   handleNotifyConversationPersisted,
 } from "../conversation-sync-ipc-routes.js";
 
@@ -176,3 +187,40 @@ describe("conversation-sync IPC route", () => {
     ).toBe(false);
   });
 });
+
+describe("conversation-list-changed IPC route", () => {
+  beforeEach(() => {
+    listPublishCalls.length = 0;
+  });
+
+  test("republishes the worker's list invalidation on the daemon's hub", () => {
+    const result = handleNotifyConversationListChanged({
+      body: { reason: "reordered", conversationIds: ["conv-1"] },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(listPublishCalls).toEqual([["reordered", ["conv-1"]]]);
+  });
+
+  test("rejects an unknown reason and an empty id list", () => {
+    expect(() =>
+      handleNotifyConversationListChanged({
+        body: { reason: "resurfaced", conversationIds: ["conv-1"] },
+      }),
+    ).toThrow();
+    expect(() =>
+      handleNotifyConversationListChanged({
+        body: { reason: "reordered", conversationIds: [] },
+      }),
+    ).toThrow();
+    expect(listPublishCalls).toEqual([]);
+  });
+
+  test("is reachable on the IPC surface under the shared method name", () => {
+    expect(
+      typeof CONVERSATION_SYNC_IPC_METHODS[
+        NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD
+      ],
+    ).toBe("function");
+  });
+});

package/src/ipc/routes/conversation-sync-ipc-routes.ts

@@ -29,13 +29,30 @@ import { getInflightFlushedContentSeq } from "../../daemon/inflight-turn-registr
 import { recordConversationPersistedSeq } from "../../persistence/conversation-crud.js";
 import { getCurrentSeq } from "../../runtime/assistant-stream-state.js";
 import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
-import { publishConversationMessagesChanged } from "../../runtime/sync/resource-sync-events.js";
-import { NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD } from "../../runtime/sync/worker-daemon-notify.js";
+import {
+  publishConversationListAndMetadataChanged,
+  publishConversationMessagesChanged,
+} from "../../runtime/sync/resource-sync-events.js";
+import {
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
+  NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
+} from "../../runtime/sync/worker-daemon-notify.js";
 
 const NotifyConversationPersistedParamsSchema = z.object({
   conversationId: z.string().min(1),
 });
 
+const NotifyConversationListChangedParamsSchema = z.object({
+  reason: z.enum([
+    "created",
+    "renamed",
+    "deleted",
+    "reordered",
+    "seen_changed",
+  ]),
+  conversationIds: z.array(z.string().min(1)).min(1),
+});
+
 /**
  * Record the daemon-issued snapshot anchor for a worker-persisted turn and
  * republish its messages-changed invalidation to the daemon's subscribers.
@@ -61,6 +78,23 @@ export function handleNotifyConversationPersisted({
   return { ok: true };
 }
 
+/**
+ * Republish a worker's conversation-list-and-metadata invalidation on the
+ * daemon's hub, where the SSE subscribers live.
+ *
+ * A worker turn that changes which rows belong in the list (clearing
+ * `archived_at` on a Done conversation it woke) has to reach connected
+ * sidebars, and a publish in the worker reaches none of them.
+ */
+export function handleNotifyConversationListChanged({
+  body = {},
+}: RouteHandlerArgs) {
+  const { reason, conversationIds } =
+    NotifyConversationListChangedParamsSchema.parse(body);
+  publishConversationListAndMetadataChanged(reason, conversationIds);
+  return { ok: true };
+}
+
 /**
  * IPC-only conversation-sync methods, keyed by operationId. Registered directly
  * on the assistant IPC server (see `assistant-server.ts`).
@@ -70,4 +104,6 @@ export const CONVERSATION_SYNC_IPC_METHODS: Record<
   (args: RouteHandlerArgs) => unknown
 > = {
   [NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD]: handleNotifyConversationPersisted,
+  [NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD]:
+    handleNotifyConversationListChanged,
 };

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -238,6 +238,33 @@ function assistantDeltaTexts(frames: LiveVoiceServerFrame[]): string[] {
 }
 
 describe("LiveVoiceSession assistant turn", () => {
+  test.each([true, false])(
+    "passes current screen sharing state %p to the desktop voice bridge",
+    async (screenSharing) => {
+      const startVoiceTurn = mock(async (_options: VoiceTurnOptions) => ({
+        turnId: "bridge-turn-1",
+        abort: mock(),
+      }));
+      const { session, transcriber } = createSessionHarness({
+        startFrame: { ...START_FRAME, client: "macos" },
+        startVoiceTurn,
+      });
+      await session.start();
+      await session.handleClientFrame({
+        type: "update_config",
+        screenSharing: true,
+      });
+      await session.handleClientFrame({ type: "update_config", screenSharing });
+      transcriber.emit({ type: "final", text: "Show me the speed control" });
+      await session.handleClientFrame({ type: "ptt_release" });
+      expect(startVoiceTurn.mock.calls[0]?.[0]).toMatchObject({
+        macosDesktopSession: true,
+        screenSharing,
+      });
+      await session.close("client_end");
+    },
+  );
+
   test("runs final transcripts through the voice bridge and forwards ordered assistant events", async () => {
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       options.callbacks?.assistant_text_delta?.({

package/src/live-voice/__tests__/protocol.test.ts

@@ -77,6 +77,28 @@ describe("parseLiveVoiceClientTextFrame", () => {
     expect(result).toEqual({ ok: true, frame });
   });
 
+  test.each([true, false])(
+    "parses screen sharing state %p",
+    (screenSharing) => {
+      const frame = { type: "update_config", screenSharing } as const;
+      expect(parseLiveVoiceClientTextFrame(JSON.stringify(frame))).toEqual({
+        ok: true,
+        frame,
+      });
+    },
+  );
+
+  test("rejects malformed screen sharing state", () => {
+    expect(
+      parseLiveVoiceClientTextFrame(
+        JSON.stringify({
+          type: "update_config",
+          screenSharing: "true",
+        }),
+      ).ok,
+    ).toBe(false);
+  });
+
   test("parses an update_config frame with a single field, omitting the other", () => {
     const result = parseLiveVoiceClientTextFrame(
       JSON.stringify({ type: "update_config", silenceThresholdMs: 900 }),

package/src/live-voice/continuation-judge.ts

@@ -17,7 +17,7 @@
 import {
   askTypesafeNoul,
   resolveTypesafeProvider,
-} from "../calls/typesafe-noul.js";
+} from "../providers/jev/ask.js";
 import type { Provider } from "../providers/types.js";
 
 export const VOICE_CONTINUATION_JUDGE_CALL_SITE = "voiceContinuationJudge";

package/src/live-voice/live-voice-session.ts

@@ -1217,6 +1217,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private releaseModeSessionResidency?: () => void;
   private cameraModeSessions?: CameraModeSessionProducer;
   private sightFrameSequence: Promise<void> = Promise.resolve();
+  private screenSharing = false;
   /**
    * Mirrors phase changes to the iOS Live Activity through the platform, for
    * the case the client cannot cover: an app backgrounded long enough for iOS
@@ -2084,13 +2085,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   }
 
   /**
-   * Apply a mid-session `update_config` frame: retune the live turn detector's
-   * pause ("pause before reply") and/or the barge-in guard ("interrupt
-   * sensitivity") without reconnecting. Each field is optional and independent;
-   * changes take effect from the next utterance. A no-op on manual (non-
-   * server_vad) sessions, which have no turn detector.
+   * Apply screen-sharing state and turn-detection tuning independently.
+   * Changes take effect from the next utterance.
    */
   private applyConfigUpdate(frame: LiveVoiceClientUpdateConfigFrame): void {
+    if (frame.screenSharing !== undefined) {
+      this.screenSharing = frame.screenSharing;
+    }
     if (frame.silenceThresholdMs !== undefined) {
       this.turnDetector?.setSilenceThresholdMs(frame.silenceThresholdMs);
       this.silenceThresholdMs = frame.silenceThresholdMs;
@@ -6602,7 +6603,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         userMessageInterface: "macos",
         assistantMessageInterface: "macos",
         ...(this.context.startFrame.client === "macos"
-          ? { macosDesktopSession: true }
+          ? { macosDesktopSession: true, screenSharing: this.screenSharing }
           : {}),
         voiceTelemetry: {
           sessionId: this.context.sessionId,

package/src/live-voice/protocol.ts

@@ -276,16 +276,16 @@ export interface LiveVoiceClientEndFrame {
 }
 
 /**
- * Mid-session tuning update: applies the same turn-detection knobs the start
- * frame carries to the *running* session, so the client can retune "pause
- * before reply" / "interrupt sensitivity" without reconnecting. Each field is
- * optional and independently applied; the same bounds as the start frame apply.
- * Only meaningful for `server_vad` sessions.
+ * Mid-session screen-sharing state and turn-detection tuning. Each field is
+ * optional and independently applied. Tuning uses the start frame's bounds
+ * and affects `server_vad` sessions.
  */
 export interface LiveVoiceClientUpdateConfigFrame {
   readonly type: "update_config";
   readonly silenceThresholdMs?: number;
   readonly bargeInMinSpeechMs?: number;
+  /** A shared desktop surface is available for annotation. */
+  readonly screenSharing?: boolean;
 }
 
 /**
@@ -1279,6 +1279,14 @@ function validateSightFrameTiming(
 function validateUpdateConfigFrame(
   value: Record<string, unknown>,
 ): LiveVoiceParseResult<LiveVoiceClientUpdateConfigFrame> {
+  if ("screenSharing" in value && typeof value.screenSharing !== "boolean") {
+    return protocolError(
+      "invalid_field",
+      "update_config field screenSharing must be a boolean",
+      "screenSharing",
+      "update_config",
+    );
+  }
   if (
     "silenceThresholdMs" in value &&
     !isIntInRange(
@@ -1315,6 +1323,9 @@ function validateUpdateConfigFrame(
     ok: true,
     frame: {
       type: "update_config",
+      ...(typeof value.screenSharing === "boolean"
+        ? { screenSharing: value.screenSharing }
+        : {}),
       ...(typeof value.silenceThresholdMs === "number"
         ? { silenceThresholdMs: value.silenceThresholdMs }
         : {}),