@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.3

package/src/apps/app-store.ts

@@ -43,6 +43,7 @@ import type { EditEngineResult } from "../tools/shared/filesystem/edit-engine.js
 import { applyEdit } from "../tools/shared/filesystem/edit-engine.js";
 import { getLogger } from "../util/logger.js";
 import { getDataDir, getWorkspacePluginsDir } from "../util/platform.js";
+import { hasPluginManifest } from "../util/plugin-manifest.js";
 
 const log = getLogger("app-store");
 
@@ -787,8 +788,8 @@ function listAppsForPlugin(
  * `<workspace>/plugins/<name>/apps/`.
  *
  * Plugin discovery mirrors the plugin loader's `scanPlugins`: a plugin is an
- * entry that resolves to a directory (following symlinks) and carries a
- * `package.json` manifest. Stray directories without a manifest are ignored,
+ * entry that resolves to a directory (following symlinks) and carries a root
+ * plugin manifest. Stray directories without a manifest are ignored,
  * and disabled plugins (those with a `.disabled` sentinel) contribute nothing,
  * matching how their other surfaces (tools, hooks, routes) are gated.
  */
@@ -813,7 +814,7 @@ export function listPluginApps(): EnumeratedApp[] {
     } catch {
       continue;
     }
-    if (!existsSync(join(pluginDir, "package.json"))) {
+    if (!hasPluginManifest(pluginDir)) {
       continue;
     }
     if (isPluginDisabled(name)) {
@@ -874,7 +875,7 @@ function isSafeIdSegment(segment: string): boolean {
  * (`plugins~<name>~<app>`, resolved by direct path build). Returns null when
  * the app does not exist, when the id is not a safe path segment, or when a
  * plugin id fails the same installed-plugin gates as discovery (directory,
- * `package.json` manifest, not disabled).
+ * root manifest, not disabled).
  */
 export function resolveAppSource(id: string): ResolvedAppSource | null {
   if (id.startsWith(PLUGIN_APP_ID_PREFIX)) {
@@ -900,7 +901,7 @@ export function resolveAppSource(id: string): ResolvedAppSource | null {
     } catch {
       return null;
     }
-    if (!existsSync(join(pluginDir, "package.json"))) {
+    if (!hasPluginManifest(pluginDir)) {
       return null;
     }
     if (isPluginDisabled(pluginName)) {

package/src/browser/operations.ts

@@ -32,7 +32,8 @@ import {
 } from "../tools/browser/browser-execution.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { normalizeBrowserMode } from "../tools/browser/browser-mode.js";
-import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+import type { BrowserOperationContext as ToolContext } from "./types.js";
 import type { BrowserOperation } from "./types.js";
 
 // ── Dispatch handlers ────────────────────────────────────────────────

package/src/browser/types.ts

@@ -1,3 +1,10 @@
+import type { ScopedCdpClient } from "../tools/browser/cdp-client/types.js";
+import type { ToolContext } from "../tools/types.js";
+
+export interface BrowserOperationContext extends ToolContext {
+  cdpClient?: ScopedCdpClient;
+}
+
 /**
  * Canonical browser operation identifiers and typed metadata.
  *

package/src/browser/virtual-desktop-target.ts

@@ -0,0 +1,34 @@
+import { getConfig } from "../config/loader.js";
+import { isVirtualDesktopEnabled } from "../desktop/virtual-desktop-feature.js";
+import { browserManager } from "../tools/browser/browser-manager.js";
+import { normalizeBrowserMode } from "../tools/browser/browser-mode.js";
+import { getPinnedTab } from "../tools/browser/pinned-tabs.js";
+import type { ToolContext } from "../tools/types.js";
+
+export function shouldUseVirtualDesktopBrowser(
+  desktop: boolean | undefined,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): boolean {
+  if (desktop !== undefined) {
+    return desktop;
+  }
+  const mode = normalizeBrowserMode(input.browser_mode);
+  if (
+    "error" in mode ||
+    mode.mode !== "auto" ||
+    input.target_client_id ||
+    input.use_active_tab ||
+    context.transportInterface !== "web" ||
+    context.clientOs === "macos" ||
+    context.clientOs === "windows" ||
+    context.clientOs === "linux" ||
+    context.trustClass !== "guardian" ||
+    !context.sourceActorPrincipalId ||
+    browserManager.getPreferredBackendKind(context.conversationId) !== null ||
+    getPinnedTab(context.conversationId)
+  ) {
+    return false;
+  }
+  return isVirtualDesktopEnabled(getConfig());
+}

package/src/calls/__tests__/progress-narration.test.ts

@@ -185,6 +185,29 @@ describe("createVoiceProgressNarrator", () => {
     expect(Date.now() - startedAt).toBeLessThan(1000);
   });
 
+  test("an update that runs out of budget aborts as a narration timeout, not a session abort", async () => {
+    // The budget lapsing means this beat goes unspoken; it does not mean the
+    // call ended. Sharing `voice_session_aborted` made a narrator whose budget
+    // sat below the model's roundtrip read in the logs as a session dying once
+    // per update, which is what hid a turn that had gone silent for minutes.
+    let seen: AbortSignal | undefined;
+    const narrator = createVoiceProgressNarrator({
+      config: VoiceProgressConfigSchema.parse({ generationTimeoutMs: 20 }),
+      getProvider: async () =>
+        stubProvider((_messages, options) => {
+          seen = options?.signal;
+          return new Promise<ProviderResponse>(() => {});
+        }),
+    });
+
+    expect(await narrator.generateProgressText(progressInput)).toBeNull();
+    expect(seen?.aborted).toBe(true);
+    expect(seen?.reason).toMatchObject({
+      kind: "voice_progress_narration_timeout",
+      source: "voice-progress-narration",
+    });
+  });
+
   test("a caller abort settles promptly", async () => {
     const narrator = createVoiceProgressNarrator({
       config: VoiceProgressConfigSchema.parse({

package/src/calls/__tests__/voice-control-protocol.test.ts

@@ -6,7 +6,10 @@ import {
   HOLD_VERDICT_TOKEN,
   isIncompleteControlMarkerTail,
   MINIMIZE_ROOM_MARKER,
+  parseTerminalSessionControl,
+  type SessionControlRequest,
   stripInternalSpeechMarkers,
+  terminalControlMarkerLength,
 } from "../voice-control-protocol.js";
 
 describe("front-door verdict tokens", () => {
@@ -136,3 +139,69 @@ describe("createControlMarkerHoldback", () => {
     expect(chunks).toEqual([]);
   });
 });
+
+describe("session control markers", () => {
+  test("strips untimed and timed mute markers", () => {
+    expect(stripInternalSpeechMarkers("Muted. [MUTE]").trim()).toBe("Muted.");
+    expect(stripInternalSpeechMarkers("Muted. [MUTE:30]").trim()).toBe(
+      "Muted.",
+    );
+  });
+
+  test("holds a streaming timed mute until its bracket arrives", () => {
+    expect(isIncompleteControlMarkerTail("[MU")).toBe(true);
+    expect(isIncompleteControlMarkerTail("[MUTE:3")).toBe(true);
+    expect(isIncompleteControlMarkerTail("[MUTE:30]")).toBe(false);
+    expect(isIncompleteControlMarkerTail("[UPDATES:FEW")).toBe(true);
+    expect(isIncompleteControlMarkerTail("[UPDATES:FEWER]")).toBe(false);
+    expect(isIncompleteControlMarkerTail("[LOOK:SCR")).toBe(true);
+    expect(
+      stripInternalSpeechMarkers("Taking a look. [LOOK:SCREEN]").trim(),
+    ).toBe("Taking a look.");
+  });
+
+  test.each([
+    ["Okay, talk soon. [END_CALL]", { action: "end" }],
+    ["Muted. [MUTE]", { action: "mute" }],
+    ["Taking a look. [LOOK:SCREEN]", { action: "look_screen" }],
+    ["Show me. [LOOK:CAMERA]", { action: "look_camera" }],
+    ["Okay, I'll stop looking. [LOOK:STOP]", { action: "look_stop" }],
+    [
+      "I'll check in less. [UPDATES:FEWER]",
+      { action: "updates", cadence: "fewer" },
+    ],
+    [
+      "Updates are back on. [UPDATES:NORMAL]",
+      { action: "updates", cadence: "normal" },
+    ],
+    [
+      "Muting for half a minute. [MUTE:30]  ",
+      { action: "mute", durationMs: 30_000 },
+    ],
+    ["Muted. [MUTE: 1.5]", { action: "mute", durationMs: 1_500 }],
+    // A garbled or oversized duration still mutes, just until unmuted.
+    ["Muted. [MUTE:soon]", { action: "mute" }],
+    ["Muted. [MUTE:0]", { action: "mute" }],
+    ["Muted. [MUTE:99999]", { action: "mute" }],
+  ] as Array<[string, SessionControlRequest]>)(
+    "parses the terminal control in %j",
+    (text, expected) => {
+      expect(parseTerminalSessionControl(text)).toEqual(expected);
+    },
+  );
+
+  test("a marker anywhere but the end controls nothing", () => {
+    expect(
+      parseTerminalSessionControl("Say [END_CALL] and I would hang up."),
+    ).toBeNull();
+    expect(parseTerminalSessionControl("No markers here.")).toBeNull();
+  });
+
+  test("measures the terminal marker the transcript pass strips", () => {
+    expect(terminalControlMarkerLength("Done [-1]")).toBe(4);
+    expect(terminalControlMarkerLength("Bye [END_CALL] ")).toBe(10);
+    expect(terminalControlMarkerLength("Muted [MUTE:30]")).toBe(9);
+    expect(terminalControlMarkerLength("Okay [UPDATES:FEWER]")).toBe(15);
+    expect(terminalControlMarkerLength("The array [-1] sorts")).toBe(0);
+  });
+});

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -2146,6 +2146,68 @@ describe("front-door leg tool suppression", () => {
   });
 });
 
+describe("desktop skill preactivation", () => {
+  async function preactivatedFor(turn: Record<string, unknown>): Promise<{
+    skillIds: string[];
+    proxyInterfaces: unknown[];
+    skillIdsDuringLoop: string[];
+  }> {
+    const skillIds: string[] = [];
+    const proxyInterfaces: unknown[] = [];
+    let skillIdsDuringLoop: string[] = [];
+    const fake = makeFakeConversation({
+      processing: false,
+      runAgentLoop: async () => {
+        skillIdsDuringLoop = [...skillIds];
+      },
+    });
+    Object.assign(fake.conversation, {
+      addPreactivatedSkillId: (id: string) => {
+        skillIds.push(id);
+      },
+      ensureHostProxiesForTurn: (sourceInterface: unknown) => {
+        proxyInterfaces.push(sourceInterface);
+      },
+    });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(undefined, "conv-desktop-skills"),
+      userMessageInterface: "macos",
+      ...turn,
+    });
+    await flushMicrotasks();
+    return { skillIds, proxyInterfaces, skillIdsDuringLoop };
+  }
+
+  test("an escalated leg of a macOS desktop session starts with computer use active", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "escalated",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIdsDuringLoop).toContain("computer-use");
+    expect(result.proxyInterfaces).toEqual(["macos"]);
+  });
+
+  test("a session from any other client leaves the desktop skills to be loaded", async () => {
+    const result = await preactivatedFor({ routingLeg: "escalated" });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+
+  test("the toolless front-door leg is never preactivated", async () => {
+    const result = await preactivatedFor({
+      routingLeg: "front-door",
+      macosDesktopSession: true,
+    });
+
+    expect(result.skillIds).toEqual([]);
+    expect(result.proxyInterfaces).toEqual([]);
+  });
+});
+
 describe("cutFrontDoorContentAtVerdict", () => {
   test("null when the content carries no verdict token (committed answer)", () => {
     expect(
@@ -2513,6 +2575,25 @@ describe("transcript hygiene (teardown pass)", () => {
     expect(events).toContain("loadFromDb");
   });
 
+  test("a row ending with a session control marker persists with it stripped", async () => {
+    const { events } = makeReservedRowConversation();
+    getMessageByIdImpl = () =>
+      makeRow("Muting you for thirty seconds. [MUTE:30]");
+
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    await flushMicrotasks();
+
+    expect(crudLog.updates).toEqual([
+      {
+        messageId: "assistant-row-1",
+        content: JSON.stringify([
+          { type: "text", text: "Muting you for thirty seconds." },
+        ]),
+      },
+    ]);
+    expect(events).toContain("loadFromDb");
+  });
+
   test("a mid-text [-1] (content, not command) leaves the row untouched", async () => {
     const { events } = makeReservedRowConversation();
     getMessageByIdImpl = () =>

package/src/calls/progress-narration.ts

@@ -16,7 +16,7 @@ import type {
   ProviderResponse,
   ToolDefinition,
 } from "../providers/types.js";
-import { createAbortReason } from "../util/abort-reasons.js";
+import { createAbortReason, isAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("voice-progress-narration");
@@ -164,7 +164,10 @@ async function requestBoundedResponse(args: {
   const timeoutTimer = setTimeout(
     () =>
       timeoutController.abort(
-        createAbortReason("voice_session_aborted", "voice-progress-narration"),
+        createAbortReason(
+          "voice_progress_narration_timeout",
+          "voice-progress-narration",
+        ),
       ),
     args.timeoutMs,
   );
@@ -260,9 +263,19 @@ export function createVoiceProgressNarrator(options: {
         }
         return trimmed;
       } catch (error) {
+        // Why the beat went unspoken, as one greppable field. A narrator whose
+        // budget is below the model's real roundtrip drops every update at the
+        // deadline and reads in the logs as a run of unrelated failures; naming
+        // the outcome is what makes that run legible as "the feature is off".
+        const outcome = isAbortReason(error)
+          ? error.kind === "voice_progress_narration_timeout"
+            ? "timed_out"
+            : "session_ended"
+          : "error";
         log.info(
           {
             error,
+            outcome,
             providerResolveMs,
             totalMs: Math.round(performance.now() - startedAt),
             timeoutMs: options.config.generationTimeoutMs,

package/src/calls/voice-control-protocol.ts

@@ -37,6 +37,41 @@ export const ESCALATE_VERDICT_TOKEN = "[1]";
  */
 export const MINIMIZE_ROOM_MARKER = "[-1]";
 
+/**
+ * Mic-mute session control for live voice: `[MUTE]` mutes until the user
+ * unmutes, `[MUTE:<seconds>]` mutes for that long. Like {@link END_CALL_MARKER}
+ * on a live-voice session, it is acted on only at the very end of a reply
+ * (see {@link parseTerminalSessionControl}), after the acknowledgement that
+ * precedes it has been spoken.
+ */
+export const MUTE_MARKER = "[MUTE]";
+const MUTE_MARKER_PREFIX = "[MUTE:";
+
+/** Longest timed mute a marker can ask for; longer asks mute until unmuted. */
+export const MAX_TIMED_MUTE_SECONDS = 3600;
+
+/**
+ * Progress-update cadence for the rest of a live-voice session:
+ * {@link FEWER_UPDATES_MARKER} after "don't give me updates so often",
+ * {@link NORMAL_UPDATES_MARKER} to go back. Terminal like the other session
+ * controls, but carried out by the session itself: narration is the daemon's.
+ */
+export const FEWER_UPDATES_MARKER = "[UPDATES:FEWER]";
+export const NORMAL_UPDATES_MARKER = "[UPDATES:NORMAL]";
+const UPDATES_MARKER_PREFIX = "[UPDATES:";
+
+/**
+ * Look session controls for live voice: turn on a screen share
+ * ({@link LOOK_SCREEN_MARKER}) or the camera ({@link LOOK_CAMERA_MARKER}) so
+ * the call can see what the user means by "take a look". Carried out by the
+ * client, like mute and end.
+ */
+export const LOOK_SCREEN_MARKER = "[LOOK:SCREEN]";
+export const LOOK_CAMERA_MARKER = "[LOOK:CAMERA]";
+/** Stop showing the call the screen and the camera, whichever is on. */
+export const LOOK_STOP_MARKER = "[LOOK:STOP]";
+const LOOK_MARKER_PREFIX = "[LOOK:";
+
 // ---------------------------------------------------------------------------
 // Regexes
 // ---------------------------------------------------------------------------
@@ -57,6 +92,9 @@ const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
 const HOLD_VERDICT_TOKEN_REGEX = /\[0\]/g;
 const ESCALATE_VERDICT_TOKEN_REGEX = /\[1\]/g;
 const MINIMIZE_ROOM_MARKER_REGEX = /\[-1\]/g;
+const MUTE_MARKER_REGEX = /\[MUTE(?::\s*[^\]]*)?\]/g;
+const UPDATES_MARKER_REGEX = /\[UPDATES:\s*[^\]]*\]/g;
+const LOOK_MARKER_REGEX = /\[LOOK:\s*[^\]]*\]/g;
 const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
 const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 
@@ -182,6 +220,9 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(HOLD_VERDICT_TOKEN_REGEX, "")
     .replace(ESCALATE_VERDICT_TOKEN_REGEX, "")
     .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
+    .replace(MUTE_MARKER_REGEX, "")
+    .replace(UPDATES_MARKER_REGEX, "")
+    .replace(LOOK_MARKER_REGEX, "")
     .replace(GUARDIAN_TIMEOUT_MARKER_REGEX, "")
     .replace(GUARDIAN_UNAVAILABLE_MARKER_REGEX, "");
   return result;
@@ -207,6 +248,10 @@ const CONTROL_MARKER_STRINGS = [
   "[0]",
   "[1]",
   "[-1]",
+  MUTE_MARKER,
+  MUTE_MARKER_PREFIX,
+  UPDATES_MARKER_PREFIX,
+  LOOK_MARKER_PREFIX,
   "[GUARDIAN_TIMEOUT]",
   "[GUARDIAN_UNAVAILABLE]",
 ];
@@ -220,6 +265,9 @@ const FIRST_BRACKET_TERMINATED_PREFIXES = [
   "[ASK_GUARDIAN:",
   "[USER_ANSWERED:",
   "[USER_INSTRUCTION:",
+  MUTE_MARKER_PREFIX,
+  UPDATES_MARKER_PREFIX,
+  LOOK_MARKER_PREFIX,
 ];
 
 const GUARDIAN_APPROVAL_PREFIX = "[ASK_GUARDIAN_APPROVAL:";
@@ -299,3 +347,87 @@ export function createControlMarkerHoldback(
     }
   };
 }
+
+// ---------------------------------------------------------------------------
+// Live-voice session controls
+// ---------------------------------------------------------------------------
+
+/**
+ * A session control a live-voice reply asked for with a terminal marker:
+ * `end` from {@link END_CALL_MARKER}, `mute` from {@link MUTE_MARKER} or its
+ * timed form, `updates` from the progress-cadence markers, `look_screen` and
+ * `look_camera` and `look_stop` from the look markers.
+ */
+export type SessionControlRequest =
+  | { readonly action: "end" }
+  | { readonly action: "mute"; readonly durationMs?: number }
+  | { readonly action: "updates"; readonly cadence: "fewer" | "normal" }
+  | { readonly action: "look_screen" }
+  | { readonly action: "look_camera" }
+  | { readonly action: "look_stop" };
+
+const TERMINAL_SESSION_CONTROL_REGEX =
+  /(\[END_CALL\]|\[UPDATES:(FEWER|NORMAL)\]|\[LOOK:(SCREEN|CAMERA|STOP)\]|\[MUTE\]|\[MUTE:\s*([^\]]*)\])\s*$/;
+
+/**
+ * The session control a reply ends with, or null.
+ *
+ * **Terminal position only.** The marker follows the spoken acknowledgement
+ * ("Okay, talk soon."), so a reply that merely mentions a marker mid-text, or
+ * parrots one from history before carrying on, controls nothing. This is the
+ * same rule the minimize marker's transcript hygiene applies.
+ *
+ * A timed mute whose body is not a positive number of seconds degrades to an
+ * untimed mute rather than to nothing: the user asked to be muted, and muting
+ * until they unmute is the conservative reading of a garbled duration. Asks
+ * past {@link MAX_TIMED_MUTE_SECONDS} degrade the same way.
+ */
+export function parseTerminalSessionControl(
+  text: string,
+): SessionControlRequest | null {
+  const match = TERMINAL_SESSION_CONTROL_REGEX.exec(text);
+  if (!match) {
+    return null;
+  }
+  if (match[1] === END_CALL_MARKER) {
+    return { action: "end" };
+  }
+  if (match[2] !== undefined) {
+    return {
+      action: "updates",
+      cadence: match[2] === "FEWER" ? "fewer" : "normal",
+    };
+  }
+  if (match[3] !== undefined) {
+    return {
+      action:
+        match[3] === "SCREEN"
+          ? "look_screen"
+          : match[3] === "CAMERA"
+            ? "look_camera"
+            : "look_stop",
+    };
+  }
+  const seconds = match[4] === undefined ? NaN : Number(match[4].trim());
+  if (
+    Number.isFinite(seconds) &&
+    seconds > 0 &&
+    seconds <= MAX_TIMED_MUTE_SECONDS
+  ) {
+    return { action: "mute", durationMs: Math.round(seconds * 1000) };
+  }
+  return { action: "mute" };
+}
+
+/**
+ * Length of the marker a row's text ends with, ignoring trailing whitespace,
+ * when it is one the transcript hygiene pass strips from the persisted row
+ * (the minimize marker or a session control); 0 otherwise.
+ */
+export function terminalControlMarkerLength(text: string): number {
+  const trimmed = text.trimEnd();
+  if (trimmed.endsWith(MINIMIZE_ROOM_MARKER)) {
+    return MINIMIZE_ROOM_MARKER.length;
+  }
+  return TERMINAL_SESSION_CONTROL_REGEX.exec(trimmed)?.[1]?.length ?? 0;
+}

package/src/calls/voice-session-bridge.ts

@@ -31,6 +31,7 @@ import {
 import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import { preactivateHostProxySkills } from "../daemon/host-proxy-preactivation.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
   newestPersistedSightFrame,
@@ -70,8 +71,8 @@ import {
   CALL_VERIFICATION_COMPLETE_MARKER,
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
-  MINIMIZE_ROOM_MARKER,
   stripInternalSpeechMarkers,
+  terminalControlMarkerLength,
 } from "./voice-control-protocol.js";
 import {
   createFrontDoorStreamGate,
@@ -464,6 +465,14 @@ export interface VoiceTurnOptions {
    * path has always used.
    */
   actorFallbackSuppressed?: boolean;
+  /**
+   * Whether the session was opened from the macOS desktop client. A leg that
+   * can run tools then starts with the desktop skills (computer use, app
+   * control, screen annotation) already active, as a typed turn from that
+   * client does. The turn interface cannot answer this: every live-voice
+   * session reports `macos` for its channel capabilities, iOS included.
+   */
+  macosDesktopSession?: boolean;
   /** Whether this is an inbound call (no outbound task). */
   isInbound: boolean;
   /** The outbound call task, if any. */
@@ -767,17 +776,22 @@ function stripMarkersFromBlocks(blocks: ContentBlock[]): ContentBlock[] {
 }
 
 /**
- * Remove the terminal MINIMIZE_ROOM_MARKER from the end of a row's text,
- * walking text blocks from the last one backward so a marker split across
- * block boundaries (e.g. `"Done [-"` + `"1]"`) is removed whole — the
- * per-block strip in {@link stripMarkersFromBlocks} only sees fragments and
- * would leave both halves in place. Callers must have established that the
- * row's joined text ends with the marker after trimming trailing whitespace.
+ * Remove a terminal control marker (the minimize marker or a session control,
+ * `markerLength` characters long) from the end of a row's text, walking text
+ * blocks from the last one backward so a marker split across block boundaries
+ * (e.g. `"Done [-"` + `"1]"`) is removed whole — the per-block strip in
+ * {@link stripMarkersFromBlocks} only sees fragments and would leave both
+ * halves in place. Callers must have established, with
+ * {@link terminalControlMarkerLength}, that the row's joined text ends with
+ * the marker after trimming trailing whitespace.
  */
-function stripTerminalMinimizeMarker(blocks: ContentBlock[]): ContentBlock[] {
+function stripTerminalControlMarker(
+  blocks: ContentBlock[],
+  markerLength: number,
+): ContentBlock[] {
   const result = blocks.map((block) => ({ ...block }));
   const joined = joinedTextOfBlocks(result);
-  const cutAt = joined.trimEnd().length - MINIMIZE_ROOM_MARKER.length;
+  const cutAt = joined.trimEnd().length - markerLength;
   let blockEnd = joined.length;
   for (let i = result.length - 1; i >= 0 && blockEnd > cutAt; i--) {
     const block = result[i]!;
@@ -1810,14 +1824,14 @@ export async function startVoiceTurn(
    *   never the verdict token or the text streamed past the cap (issue
    *   #37850). A row with no spoken bridge (canned-fallback case — that
    *   bridge is audio-only) is deleted.
-   * - Any leg whose row ENDS with the `[-1]` minimize marker (swallowed
-   *   before TTS on the live path) has its text blocks rewritten through
+   * - Any leg whose row ENDS with the `[-1]` minimize marker or a session
+   *   control marker (`[END_CALL]`, `[MUTE]`, `[MUTE:<seconds>]`), all
+   *   swallowed before TTS, has its text blocks rewritten through
    *   `stripInternalSpeechMarkers` so the marker never renders in the chat
-   *   transcript. This covers front-door answers too: that leg is never
-   *   taught the marker, but it can parrot one from visible conversation
-   *   history, and the parroted marker is never spoken and never minimizes
-   *   the room. Deliberately scoped to that marker: rows without it
-   *   persist byte-identical.
+   *   transcript. This covers front-door answers too: a front-door answer
+   *   may end with a session control, and it can parrot `[-1]` from visible
+   *   conversation history. Deliberately scoped to terminal markers: rows
+   *   without one persist byte-identical.
    *
    * After a rewrite, in-memory history is reloaded from the clean DB before
    * the escalated leg — blocked on this turn's teardown — snapshots it, so
@@ -1851,6 +1865,9 @@ export async function startVoiceTurn(
         action = "delete_discarded";
       } else {
         const row = getMessageById(reservedAssistantRowId, opts.conversationId);
+        const terminalMarkerLength = row
+          ? terminalControlMarkerLength(joinedTextOfBlocks(row.content))
+          : 0;
         const cut =
           row && opts.routingLeg === "front-door"
             ? cutFrontDoorContentAtVerdict(row.content)
@@ -1869,19 +1886,18 @@ export async function startVoiceTurn(
             action = "delete_empty";
           }
         } else if (
-          // Terminal position only — mirrors the live latch in
-          // createControlMarkerHoldback: a reply whose CONTENT contains
-          // "[-1]" mid-text never minimized the room, so its transcript
-          // keeps that content untouched too. Front-door answer rows (no
-          // verdict token to cut) take this branch as well.
-          joinedTextOfBlocks(row.content)
-            .trimEnd()
-            .endsWith(MINIMIZE_ROOM_MARKER)
+          // Terminal position only — mirrors parseTerminalSessionControl: a
+          // reply whose CONTENT contains a marker mid-text never acted on it,
+          // so its transcript keeps that content untouched too. Front-door
+          // answer rows (no verdict token to cut) take this branch as well.
+          terminalMarkerLength > 0
         ) {
           // Terminal marker first (boundary-aware — it may span text blocks),
           // then the per-block strip for any interior complete markers.
           const cleaned = trimOuterTextEdges(
-            stripMarkersFromBlocks(stripTerminalMinimizeMarker(row.content)),
+            stripMarkersFromBlocks(
+              stripTerminalControlMarker(row.content, terminalMarkerLength),
+            ),
           );
           // A marker-only reply (the model said nothing beyond "[-1]") strips
           // to nothing at all; keeping the row would render a blank assistant
@@ -1895,7 +1911,7 @@ export async function startVoiceTurn(
               reservedAssistantRowId,
               JSON.stringify(cleaned),
             );
-            action = "strip_minimize_marker";
+            action = "strip_control_marker";
           }
         }
       }
@@ -2009,6 +2025,20 @@ export async function startVoiceTurn(
         (needsImagePin
           ? VOICE_IMAGE_PROFILE
           : (conversationProfile?.profile ?? null));
+      if (opts.macosDesktopSession === true && !frontDoorToolsSuppressed) {
+        const sourceInterface = turnInterfaceContext.userMessageInterface;
+        const sourceActorPrincipalId =
+          voiceTurnValues.actorPrincipalId ?? undefined;
+        conversation.ensureHostProxiesForTurn(
+          sourceInterface,
+          sourceActorPrincipalId,
+        );
+        preactivateHostProxySkills(
+          conversation,
+          sourceInterface,
+          sourceActorPrincipalId,
+        );
+      }
       await conversation.runAgentLoop(persistedContent, messageId, {
         onEvent: (msg: AssistantEvent) => {
           if (msg.type === "assistant_turn_start") {