@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/telegram/webhook-health.ts

@@ -79,12 +79,33 @@ const ERROR_RECENCY_WINDOW_MS = 15 * 60_000;
 // ── Types ─────────────────────────────────────────────────────────────
 
 export type TelegramWebhookHealthStatus =
-  /** Webhook registered, no recent delivery errors. */
+  /**
+   * Telegram holds the URL the reconciler last registered, and reports no
+   * recent delivery error. This is the only status that may be presented as
+   * confirmed delivery.
+   */
   | "healthy"
   /** Telegram holds no webhook URL at all — the channel is definitively dark. */
   | "not_registered"
+  /**
+   * Telegram holds a webhook URL, but not the one the reconciler registered.
+   * A stale tunnel address or another deployment's callback delivers to
+   * somewhere this assistant is not listening, which reads identically to a
+   * healthy channel until someone sends a message. This is the case
+   * `last_error_date` cannot see on a quiet channel (see the module header's
+   * known limitation).
+   */
+  | "url_mismatch"
   /** Telegram reported a delivery error inside the recency window. */
   | "delivery_failing"
+  /**
+   * A webhook is registered and not erroring, but the reconciler has not
+   * recorded which URL it registered, so ownership cannot be established.
+   * Expected transiently between the credential save and reconciliation, and
+   * persistently for deployments whose last registration predates recording.
+   * Distinct from `healthy` because "no fault found" is not "verified".
+   */
+  | "unverified"
   /** Preconditions unmet (no bot token / no webhook routing) — nothing to check. */
   | "skipped"
   /** Telegram was unreachable or answered unusably — health is unknown. */
@@ -97,6 +118,10 @@ export interface TelegramWebhookHealthResult {
   lastErrorMessage?: string;
   lastErrorDate?: number;
   pendingUpdateCount?: number;
+  /** The URL Telegram currently holds, when one is registered. */
+  registeredUrl?: string;
+  /** The URL the reconciler recorded, when it has recorded one. */
+  expectedUrl?: string;
 }
 
 /**
@@ -133,6 +158,28 @@ function telegramApiBaseUrl(): string {
   }
 }
 
+/**
+ * The webhook URL the gateway reconciler recorded on its last successful
+ * `setWebhook`, or undefined when it has never recorded one.
+ *
+ * This is deliberately a stored fact rather than a re-derivation. The gateway
+ * and the assistant already maintain mirrored copies of the routing tier order
+ * (`resolveExpectedTelegramWebhookUrl` and `hasWebhookRoutingConfigured`, which
+ * cross-reference each other in comments after LUM-2899), and a third copy here
+ * would be a third thing to keep in agreement. It also lets the managed path be
+ * checked at all: resolving a platform callback URL means POSTing a route
+ * registration, which a read-only health check must not do.
+ */
+function recordedWebhookUrl(): string | undefined {
+  try {
+    const recorded = getConfig().telegram.registeredWebhookUrl;
+    const trimmed = recorded?.trim();
+    return trimmed ? trimmed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /** Name the channel concretely when the bot username is known. */
 function channelLabel(): string {
   const username = getTelegramBotUsername();
@@ -246,6 +293,27 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
     };
   }
 
+  const registeredUrl = info.url.trim();
+  const expectedUrl = recordedWebhookUrl();
+
+  // Ownership is checked before delivery errors on purpose. When Telegram is
+  // pointed somewhere we never registered, any error it reports describes
+  // delivery to that other destination, so reporting the error would name a
+  // symptom while the mismatch is the cause, and the two have different fixes
+  // (re-run reconciliation vs. investigate a reachable ingress).
+  if (expectedUrl && registeredUrl !== expectedUrl) {
+    return {
+      status: "url_mismatch",
+      detail:
+        `${label} is registered with Telegram at a different address than this assistant ` +
+        `last registered, so its messages are being delivered somewhere this assistant is not ` +
+        `listening. ${fixPath(usesManagedCallbacks)}`,
+      registeredUrl,
+      expectedUrl,
+      ...(pendingUpdateCount !== undefined ? { pendingUpdateCount } : {}),
+    };
+  }
+
   const lastErrorDate = info.last_error_date;
   const errorIsRecent =
     lastErrorDate !== undefined &&
@@ -270,9 +338,28 @@ export async function checkTelegramWebhookHealth(): Promise<TelegramWebhookHealt
     };
   }
 
+  if (!expectedUrl) {
+    // A webhook is registered and quiet, but nothing recorded which URL we
+    // registered, so this cannot be distinguished from a stranger's webhook
+    // that happens not to be erroring. Reporting "healthy" here is the
+    // overclaim this status exists to prevent.
+    return {
+      status: "unverified",
+      detail:
+        `${label} has a webhook registered with Telegram and reports no recent delivery errors, ` +
+        `but this assistant has no record of registering it, so it cannot confirm the messages ` +
+        `reach here. Re-running setup records the registration.`,
+      registeredUrl,
+      ...(lastErrorDate !== undefined ? { lastErrorDate } : {}),
+      ...(pendingUpdateCount !== undefined ? { pendingUpdateCount } : {}),
+    };
+  }
+
   return {
     status: "healthy",
-    detail: `${label} webhook is registered and reporting no recent delivery errors`,
+    detail: `${label} is registered at the address this assistant last set, and Telegram reports no recent delivery errors`,
+    registeredUrl,
+    expectedUrl,
     ...(lastErrorDate !== undefined ? { lastErrorDate } : {}),
     ...(pendingUpdateCount !== undefined ? { pendingUpdateCount } : {}),
   };
@@ -385,7 +472,18 @@ export async function runTelegramWebhookHealthCheck(): Promise<TelegramWebhookHe
   // Neither evidence of health nor of failure — leave the latch as-is so an
   // unreachable Telegram (or a channel that isn't set up) can't either raise a
   // false alarm or silently clear a real one.
-  if (result.status === "skipped" || result.status === "unknown") {
+  //
+  // `unverified` belongs here rather than with the failures below: a webhook
+  // that is registered and quiet, on a deployment that never recorded its
+  // registration, is unproven, not broken. Alerting on it would page the
+  // guardian about every install whose last reconciliation predates URL
+  // recording. Note the asymmetry with `url_mismatch`, which falls through to
+  // the alert: there we know the address is wrong, which is a fault.
+  if (
+    result.status === "skipped" ||
+    result.status === "unknown" ||
+    result.status === "unverified"
+  ) {
     log.debug({ status: result.status }, result.detail);
     return result;
   }

package/src/telemetry/__tests__/telemetry-event-fixtures.ts

@@ -43,6 +43,8 @@ const llmUsage: LlmUsageTelemetryEvent = {
   // Zero is legitimate (wire bound is min(0)): a subagent can be spawned
   // before the parent's first real user turn.
   parent_turn_index: 0,
+  subagent_role: "advisor",
+  subagent_spawn_mode: "advisor_consult",
   provider: "anthropic",
   model: "claude-fable-5",
   input_tokens: 1200,

package/src/telemetry/activation-funnel.ts

@@ -157,10 +157,15 @@ export function activationStepIndex(stepName: ActivationStepName): number {
  * `funnel_version` so the id stays stable across a version bump — otherwise
  * queued/offline v1 rows would be keyed with the new binary's version and
  * stop collapsing with already-ingested v1 rows from the same session.
+ *
+ * `stepName` is a plain string rather than an `ActivationStepName`: every
+ * funnel riding the onboarding substrate shares this keying (the live-voice
+ * session funnel is the other one today), and the dedup property depends only
+ * on the triple being stable per row, not on which funnel produced it.
  */
 export function buildActivationDaemonEventId(
   sessionId: string,
-  stepName: ActivationStepName,
+  stepName: string,
   funnelVersion: string = ACTIVATION_FUNNEL_VERSION,
 ): string {
   return `${funnelVersion}:${sessionId}:${stepName}`;

package/src/telemetry/live-voice-funnel.ts

@@ -0,0 +1,75 @@
+/**
+ * Live-voice session telemetry vocabulary: the single source of truth for the
+ * step names, funnel version, and end-reason values the live-voice session
+ * emitter uses.
+ *
+ * Rides the existing onboarding telemetry substrate (`type: "onboarding"`),
+ * exactly as `activation-funnel.ts` does: the backend stores `step_name` and
+ * `funnel_version` as open strings, so this funnel needs no platform serializer
+ * and no wire-contract change.
+ *
+ * **Duration is not a field.** The onboarding event shape carries no numeric
+ * slot for it, so the two events below are keyed by the live-voice `sessionId`
+ * in `session_id` and the warehouse subtracts their `recorded_at` stamps. That
+ * yields exact percentiles rather than the bucketed-string dimension the tips
+ * and tour funnels pack into `screen`.
+ *
+ * **Turn count is not a field either.** It comes from the `turn` telemetry
+ * events voice turns already produce, which carry this session's id in their
+ * `client` bag (see `voice-session-bridge.ts`), so a turn count is a count of
+ * those rows rather than a number restated here.
+ *
+ * A session that starts and never ends is **censored, not infinite**: a daemon
+ * crash or kill emits no end event, so downstream duration math must drop
+ * unmatched `started` rows instead of treating them as open-ended sessions.
+ */
+
+import type { LiveVoiceSessionCloseReason } from "../live-voice/live-voice-session-manager.js";
+import type { LiveVoiceProtocolErrorCode } from "../live-voice/protocol.js";
+
+/** Funnel version stamped on every live-voice session event. */
+export const LIVE_VOICE_FUNNEL_VERSION = "live_voice_v1_2026_08";
+
+/**
+ * Live-voice session funnel steps. `stepName` is the wire value; `stepIndex`
+ * is the ordinal position.
+ *
+ * `sessionStarted` fires for every *attempted* session, before the credential
+ * preflight that can reject it. A session that fails to connect is exactly the
+ * one worth counting, and gating the start event on `ready` would hide it from
+ * the failure rate entirely.
+ */
+export const LIVE_VOICE_STEPS = {
+  sessionStarted: { stepName: "live_voice_session_started", stepIndex: 0 },
+  sessionEnded: { stepName: "live_voice_session_ended", stepIndex: 1 },
+} as const;
+
+export type LiveVoiceStepName =
+  (typeof LIVE_VOICE_STEPS)[keyof typeof LIVE_VOICE_STEPS]["stepName"];
+
+/**
+ * How a session ended, stamped as `outcome`.
+ *
+ * `failed` means the session died on an error: a credential preflight
+ * rejection before `ready`, or an utterance-arm failure after it. Everything
+ * else, including a dropped socket, is `completed`: the session ran and then
+ * stopped, and the close reason on `screen` says how.
+ */
+export type LiveVoiceSessionOutcome = "completed" | "failed";
+
+/**
+ * The `screen` dimension for an ended session: how it closed, plus the
+ * protocol error code when a failure is what closed it.
+ *
+ * Both halves are the daemon's own vocabulary verbatim
+ * (`LiveVoiceSessionCloseReason`, `LiveVoiceProtocolErrorCode`) rather than a
+ * mapping, so a rename on either side surfaces here as a compile error instead
+ * of a silently-empty dashboard facet. The longest pair this can produce is
+ * well inside the wire field's 64-char bound.
+ */
+export function liveVoiceEndScreen(
+  reason: LiveVoiceSessionCloseReason,
+  failureCode?: LiveVoiceProtocolErrorCode | null,
+): string {
+  return failureCode ? `ended_${reason}:${failureCode}` : `ended_${reason}`;
+}

package/src/telemetry/telemetry-event-sources.ts

@@ -281,6 +281,12 @@ const usageSource = simpleSource(
     turn_index: e.turnIndex,
     parent_conversation_id: e.parentConversationId,
     parent_turn_index: e.parentTurnIndex,
+    // Delegated-work decomposition. Every subagent variety shares
+    // `llm_call_site = "subagentSpawn"`; these two orthogonal dimensions are
+    // what make advisor consults, forks, and regular spawns separable. Null
+    // for the vast majority of calls, which are not delegated at all.
+    subagent_role: e.subagentRole,
+    subagent_spawn_mode: e.subagentSpawnMode,
     provider: e.provider,
     model: e.model,
     input_tokens: e.inputTokens,

package/src/telemetry/telemetry-wire-source.json

@@ -1,4 +1,4 @@
 {
   "sourceRepo": "vellum-ai/vellum-assistant-platform",
-  "sourceSha": "3bb9cb22eb289bd55d4a732e579acd93f20e3114"
+  "sourceSha": "16dd2b8e758355014768a09f974ae509dcf5dc0d"
 }

package/src/telemetry/telemetry-wire.generated.ts

@@ -95,6 +95,8 @@ export const llmUsageTelemetryEventSchema = z.object({
     .nullable()
     .optional(),
   parent_turn_index: z.number().int().min(0).nullable().optional(),
+  subagent_role: z.string().trim().min(1).max(64).nullable().optional(),
+  subagent_spawn_mode: z.string().trim().min(1).max(64).nullable().optional(),
 });
 export type LlmUsageTelemetryEvent = z.infer<
   typeof llmUsageTelemetryEventSchema

package/src/telemetry/types.ts

@@ -114,6 +114,26 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
    * parent conversation.
    */
   parent_turn_index: number | null;
+  /**
+   * Role the subagent that owns this event's conversation was spawned with
+   * (`researcher`, `builder`, `advisor`; a spawn that named no role records
+   * the default, `builder`). An open string set: older rows carry role names
+   * nothing emits any more.
+   * The advisor is a ROLE, not an `LLMCallSiteEnum` value, so this is the only
+   * thing that tells an advisor consult apart from a regular subagent, since both
+   * emit under `llm_call_site = "subagentSpawn"`. Null when the LLM call did
+   * not run inside a subagent conversation.
+   */
+  subagent_role: string | null;
+  /**
+   * How that subagent was spawned, one of the modes described on
+   * `SubagentSpawnMode` in `subagent/types.ts`, carried here as an open string
+   * set. Orthogonal to `subagent_role`: the role selects the child's
+   * capabilities, the spawn mode selects its context inheritance and lifecycle
+   * (a fork's inherited transcript dominates its input tokens regardless of
+   * role). Null under the same condition as `subagent_role`.
+   */
+  subagent_spawn_mode: string | null;
   provider: string;
   model: string;
   input_tokens: number;
@@ -164,10 +184,9 @@ export interface TurnTelemetryClientInfo {
   browser_version?: string;
   /**
    * OS surface reported by the client at message time
-   * ("web" | "ios" | "macos" | "android"). The web, iOS, and macOS apps all
-   * run the same web renderer and report `interface_id: "web"` (the
-   * transport surface, which host-proxy capability gating keys off), so
-   * this field is the only per-platform attribution in turn telemetry.
+   * ("web" | "ios" | "macos" | "windows" | "android"). Browser, mobile, and
+   * desktop apps all run the same renderer and report `interface_id: "web"`.
+   * This field is the only per-platform attribution in turn telemetry.
    */
   os?: string;
   /**

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -260,6 +260,8 @@ type UnreportedUsageEventFixture = UsageEvent & {
   turnIndex: number | null;
   parentConversationId: string | null;
   parentTurnIndex: number | null;
+  subagentRole: string | null;
+  subagentSpawnMode: string | null;
 };
 
 function makeUsageEvent(
@@ -290,6 +292,8 @@ function makeUsageEvent(
     turnIndex: 1,
     parentConversationId: null,
     parentTurnIndex: null,
+    subagentRole: null,
+    subagentSpawnMode: null,
     llmCallCount: 1,
     ...overrides,
   };

package/src/tools/__tests__/subagent-workflow-tool-input-schemas.test.ts

@@ -48,7 +48,7 @@ const CASES: {
       fork: "deliberate `=== true` coercion owns malformed values",
       send_result_to_user:
         "deliberate `=== true` / `!== false` coercions own malformed values",
-      role: "SubagentManager.spawn's 'Invalid subagent role' error (test-asserted) owns non-enum values",
+      role: "resolveSubagentRole is total: every string lands on a type, so there is nothing to reject",
     },
   },
   {

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
+  QuestionPromptOutcome,
   QuestionPromptParams,
   QuestionPromptResult,
 } from "../../permissions/question-prompter.js";
@@ -25,16 +26,22 @@ function setNextResult(result: QuestionPromptResult): void {
 
 mock.module("../../permissions/question-prompter.js", () => ({
   QuestionPrompter: class {
-    async prompt(params: QuestionPromptParams): Promise<QuestionPromptResult> {
+    async prompt(params: QuestionPromptParams): Promise<QuestionPromptOutcome> {
       calls.push(params);
-      return nextResult;
+      // Mirror the real prompter: it mints the request id and assigns the
+      // per-question `q1..qN` ids, then returns them alongside the resolution.
+      return {
+        requestId: "req-stub",
+        questions: params.questions.map((q, i) => ({ id: `q${i + 1}`, ...q })),
+        ...nextResult,
+      };
     }
   },
 }));
 
 // Import after the mock so the tool's `import { QuestionPrompter }` binds
 // to the stub class above.
-const { askQuestionTool, formatQuestionsAsTextFallback } =
+const { askQuestionTool, formatQuestionsAsTextFallback, toAnsweredQuestion } =
   await import("./ask-question-tool.js");
 
 type PromptParams = QuestionPromptParams;
@@ -710,3 +717,111 @@ describe("askQuestionTool definition (batched schema)", () => {
     expect(schema.properties.options).toBeUndefined();
   });
 });
+
+describe("answered-question record", () => {
+  test("carries the option the user chose, keyed to the questions as asked", async () => {
+    setNextResult({
+      entries: [{ questionId: "q1", decision: "option", optionId: "b" }],
+      overall: "completed",
+    });
+
+    const result = await askQuestionTool.execute(validInput, makeContext());
+
+    expect(result.answeredQuestion).toEqual({
+      requestId: "req-stub",
+      questions: [{ id: "q1", ...singleQ }],
+      responses: [{ questionId: "q1", decision: "option", optionId: "b" }],
+      overall: "completed",
+    });
+  });
+
+  test("carries a free-text answer", async () => {
+    setNextResult({
+      entries: [{ questionId: "q1", decision: "free_text", text: "Cherry" }],
+      overall: "completed",
+    });
+
+    const result = await askQuestionTool.execute(validInput, makeContext());
+
+    expect(result.answeredQuestion?.responses).toEqual([
+      { questionId: "q1", decision: "free_text", text: "Cherry" },
+    ]);
+  });
+
+  test("records a closed card as every question skipped", async () => {
+    setNextResult({
+      entries: [
+        { questionId: "q1", decision: "skipped" },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "closed",
+    });
+
+    const result = await askQuestionTool.execute(
+      { questions: [singleQ, singleQ] },
+      makeContext(),
+    );
+
+    expect(result.answeredQuestion?.overall).toBe("closed");
+    expect(result.answeredQuestion?.responses).toEqual([
+      { questionId: "q1", decision: "skipped" },
+      { questionId: "q2", decision: "skipped" },
+    ]);
+  });
+
+  test("keeps per-question skips inside an otherwise completed batch", async () => {
+    setNextResult({
+      entries: [
+        { questionId: "q1", decision: "option", optionId: "a" },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "completed",
+    });
+
+    const result = await askQuestionTool.execute(
+      { questions: [singleQ, singleQ] },
+      makeContext(),
+    );
+
+    expect(result.answeredQuestion?.responses).toEqual([
+      { questionId: "q1", decision: "option", optionId: "a" },
+      { questionId: "q2", decision: "skipped" },
+    ]);
+  });
+
+  test("records nothing for a prompt that timed out or was aborted", async () => {
+    for (const overall of ["timed_out", "aborted"] as const) {
+      setNextResult({
+        entries: [{ questionId: "q1", decision: overall }],
+        overall,
+      });
+
+      const result = await askQuestionTool.execute(validInput, makeContext());
+
+      expect(result.isError).toBe(true);
+      expect(result.answeredQuestion).toBeUndefined();
+    }
+  });
+
+  test("records nothing when the channel degrades to the text fallback", async () => {
+    const result = await askQuestionTool.execute(
+      validInput,
+      makeContext({ supportsDynamicUi: false }),
+    );
+
+    // No card was ever shown, so there is no answered state to keep.
+    expect(result.answeredQuestion).toBeUndefined();
+    expect(calls).toHaveLength(0);
+  });
+
+  test("toAnsweredQuestion is undefined for non-user outcomes", () => {
+    expect(
+      toAnsweredQuestion({
+        requestId: "req-1",
+        questions: [],
+        entries: [],
+        overall: "timed_out",
+      }),
+    ).toBeUndefined();
+  });
+});

package/src/tools/ask-question/ask-question-tool.ts

@@ -1,6 +1,13 @@
 import { z } from "zod";
 
-import { QuestionPrompter } from "../../permissions/question-prompter.js";
+import type {
+  AnsweredQuestion,
+  AnsweredQuestionResponse,
+} from "../../api/events/question-answered.js";
+import {
+  QuestionPrompter,
+  type QuestionPromptOutcome,
+} from "../../permissions/question-prompter.js";
 import { RiskLevel } from "../../permissions/types.js";
 import {
   invalidToolInputResult,
@@ -161,6 +168,47 @@ export function formatQuestionsAsTextFallback(
   return [header, "", blocks.join("\n\n")].join("\n");
 }
 
+/**
+ * Project a settled prompt into the durable answered-question record the
+ * daemon persists on the tool call. Returns undefined for outcomes that carry
+ * no user decision (timeout, abort), which have nothing to show in history.
+ */
+export function toAnsweredQuestion(
+  outcome: QuestionPromptOutcome,
+): AnsweredQuestion | undefined {
+  if (outcome.overall !== "completed" && outcome.overall !== "closed") {
+    return undefined;
+  }
+  const responses: AnsweredQuestionResponse[] = [];
+  for (const entry of outcome.entries) {
+    if (entry.decision === "option") {
+      responses.push({
+        questionId: entry.questionId,
+        decision: "option",
+        optionId: entry.optionId,
+      });
+    } else if (entry.decision === "free_text") {
+      responses.push({
+        questionId: entry.questionId,
+        decision: "free_text",
+        text: entry.text,
+      });
+    } else {
+      // A `completed` batch can still carry per-question skips, and a `closed`
+      // card reports every question as skipped. `timed_out` / `aborted` cannot
+      // reach here: they only ever appear on a batch-wide outcome of the same
+      // name, which is filtered above.
+      responses.push({ questionId: entry.questionId, decision: "skipped" });
+    }
+  }
+  return {
+    requestId: outcome.requestId,
+    questions: outcome.questions,
+    responses,
+    overall: outcome.overall,
+  };
+}
+
 // ── Tool ────────────────────────────────────────────────────────────
 
 /**
@@ -254,15 +302,21 @@ export const askQuestionTool = {
       return `${prefix} Skipped`;
     });
 
+    // The user's decision belongs in the transcript, not just in the string
+    // handed to the model: the daemon persists this on the tool call so the
+    // answered card survives a conversation switch, reload, or history reopen.
+    const answeredQuestion = toAnsweredQuestion(result);
+
     switch (result.overall) {
       case "completed":
-        return { content: lines.join("\n"), isError: false };
+        return { content: lines.join("\n"), isError: false, answeredQuestion };
       case "closed": {
         const summary =
           "User closed the question card without answering. All questions skipped.";
         return {
           content: [summary, ...lines].join("\n"),
           isError: false,
+          answeredQuestion,
         };
       }
       case "timed_out":

package/src/tools/browser/browser-execution.ts

@@ -1410,7 +1410,7 @@ export async function executeBrowserScreenshot(
     // capture of a tall or high-DPI page can exceed Anthropic's 5 MB
     // per-image cap, which would otherwise persist into the conversation
     // history inside this tool_result and reject every subsequent turn.
-    const { data: base64Data, mediaType } = optimizeImageForTransport(
+    const { data: base64Data, mediaType } = await optimizeImageForTransport(
       rawBase64,
       "image/jpeg",
     );

package/src/tools/calls/call-start.ts

@@ -48,11 +48,14 @@ export async function executeCallStart(
 
   const requestedPhone = normalizePhoneNumber(parsed.phone_number);
   if (requestedPhone) {
-    const activeVoiceVerification = await findActiveSession("phone");
-    const verificationDestination =
-      activeVoiceVerification?.destinationAddress ??
-      activeVoiceVerification?.expectedPhoneE164;
-    if (verificationDestination === requestedPhone) {
+    // Scoped to the number being called. Voice sessions bind
+    // `expectedExternalUserId` to the E.164 number, and several can be live
+    // at once, so reading the latest and comparing would miss a verification
+    // for this number whenever another one started more recently.
+    const activeVoiceVerification = await findActiveSession("phone", {
+      expectedExternalUserId: requestedPhone,
+    });
+    if (activeVoiceVerification) {
       return {
         content: [
           "Error: A guardian voice verification call is already active for this number.",

package/src/tools/conversation-groups/move_to_group.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 import {
-  batchSetDisplayOrders,
+  batchSetConversationPlacement,
   getConversation,
   getDisplayMetaForConversations,
 } from "../../persistence/conversation-crud.js";
@@ -73,15 +73,7 @@ export async function executeConversationMoveToGroup(
     };
   }
 
-  // Preserve the conversation's manual sort slot across the move; only the
-  // group assignment changes.
-  batchSetDisplayOrders([
-    {
-      id: conversationId,
-      displayOrder: meta?.displayOrder ?? null,
-      groupId: group.id,
-    },
-  ]);
+  batchSetConversationPlacement([{ id: conversationId, groupId: group.id }]);
   publishConversationListAndMetadataChanged("reordered", [conversationId]);
 
   const notes: string[] = [];
@@ -93,9 +85,15 @@ export async function executeConversationMoveToGroup(
       `Moving into ${group.name} demotes it out of the Recents listing.`,
     );
   }
-  if (conversation.conversationType !== "standard") {
+  // Only Pinned and custom groups surface a hidden conversation. Recents is a
+  // removal target, and the Scheduled/Background groups are demotions, so
+  // claiming any of them made the conversation visible would misreport the
+  // outcome to the model and the user.
+  const surfacesConversation =
+    group.id === "system:pinned" || !group.id.startsWith("system:");
+  if (conversation.conversationType !== "standard" && surfacesConversation) {
     notes.push(
-      `Note: this is a ${conversation.conversationType} conversation, which stays hidden from the sidebar regardless of group.`,
+      `Note: this is a ${conversation.conversationType} conversation, so filing it here also surfaces it into the sidebar.`,
     );
   }