@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -4,10 +4,6 @@
  * Provides a `startVoiceTurn()` function that manages a voice turn
  * directly through the conversation, translating agent-loop events into
  * simple callbacks suitable for real-time TTS streaming.
- *
- * Dependency injection follows the same module-level setter pattern used by
- * setRelayBroadcast in relay-server.ts: the daemon lifecycle injects
- * dependencies at startup via `setVoiceBridgeDeps()`.
  */
 
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
@@ -18,6 +14,7 @@ import type {
   TurnInterfaceContext,
 } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import { ABORT_WATCHDOG_MS } from "../daemon/abort-watchdog.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
@@ -35,28 +32,19 @@ import {
 
 const log = getLogger("voice-session-bridge");
 
-// ---------------------------------------------------------------------------
-// Module-level dependency injection
-// ---------------------------------------------------------------------------
-
-export interface VoiceBridgeDeps {
-  resolveAttachments: (attachmentIds: string[]) => Array<{
-    id: string;
-    filename: string;
-    mimeType: string;
-    data: string;
-    filePath?: string;
-  }>;
-}
-
-let deps: VoiceBridgeDeps | undefined;
-
+const PROCESSING_WAIT_MARGIN_MS = 1000;
 /**
- * Inject dependencies from daemon lifecycle.
- * Must be called during daemon startup before any voice turns are executed.
+ * How long startVoiceTurn waits for a prior turn to release the processing
+ * lock before giving up. The prior turn can hold the lock for the abort
+ * unwind budget PLUS the awaited turn-boundary commit window, so the wait
+ * must cover both (+ margin) or a barge-in can still surface
+ * "Conversation is already processing a message".
  */
-export function setVoiceBridgeDeps(d: VoiceBridgeDeps): void {
-  deps = d;
+export function resolveProcessingWaitMs(
+  turnCommitMaxWaitMs: number,
+  abortUnwindMs: number,
+): number {
+  return turnCommitMaxWaitMs + abortUnwindMs + PROCESSING_WAIT_MARGIN_MS;
 }
 
 // ---------------------------------------------------------------------------
@@ -265,18 +253,12 @@ function buildVoiceCallControlPrompt(opts: {
  *   - event sink wired to the provided callbacks
  *   - abort propagated from the returned handle
  *
- * The caller (CallController via relay-server) can use the returned handle
- * to cancel the turn on barge-in.
+ * The caller (CallController) can use the returned handle to cancel the
+ * turn on barge-in.
  */
 export async function startVoiceTurn(
   opts: VoiceTurnOptions,
 ): Promise<VoiceTurnHandle> {
-  if (!deps) {
-    throw new Error(
-      "Voice bridge not initialized — setVoiceBridgeDeps() was not called",
-    );
-  }
-
   const eventSink: VoiceRunEventSink = {
     onTextDelta: (msg) => {
       opts.onTextDelta?.(msg.text);
@@ -360,7 +342,11 @@ export async function startVoiceTurn(
   if (conversation.isProcessing()) {
     // Voice barge-in can race with turn teardown. Wait briefly for the
     // previous turn to finish aborting before giving up.
-    const maxWaitMs = 3000;
+    const config = getConfig();
+    const maxWaitMs = resolveProcessingWaitMs(
+      config.workspaceGit?.turnCommitMaxWaitMs ?? 4000,
+      ABORT_WATCHDOG_MS,
+    );
     const pollIntervalMs = 50;
     let waited = 0;
     while (conversation.isProcessing() && waited < maxWaitMs) {
@@ -374,6 +360,10 @@ export async function startVoiceTurn(
       throw new Error("Turn aborted while waiting for conversation");
     }
     if (conversation.isProcessing()) {
+      // Waited the full budget (see resolveProcessingWaitMs) without the lock
+      // releasing, so the prior turn is genuinely wedged. The controller
+      // catches this terminal error and speaks a brief non-technical
+      // re-prompt rather than staying silent.
       throw new Error("Conversation is already processing a message");
     }
   }
@@ -625,8 +615,8 @@ export async function startVoiceTurn(
     }
   };
 
-  // If the caller provided an external AbortSignal (e.g. from a
-  // RelayConnection's AbortController), wire it to the turn's abort.
+  // If the caller provided an external AbortSignal (e.g. from the call
+  // controller's AbortController), wire it to the turn's abort.
   if (opts.signal) {
     if (opts.signal.aborted) {
       abortFn();

package/src/channels/__tests__/types.test.ts

@@ -1,9 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  CLIENT_OS_VALUES,
   INTERACTIVE_INTERFACES,
   INTERFACE_IDS,
   isInterfaceId,
+  parseClientOs,
   parseInterfaceId,
   supportsHostProxy,
 } from "../types.js";
@@ -154,3 +156,29 @@ describe("supportsHostProxy", () => {
     expect(supportsHostProxy("email", "host_browser")).toBe(false);
   });
 });
+
+describe("parseClientOs", () => {
+  test("accepts every declared client OS surface", () => {
+    for (const os of CLIENT_OS_VALUES) {
+      expect(parseClientOs(os)).toBe(os);
+    }
+  });
+
+  test("includes android (mobile-web parity with ios)", () => {
+    expect(parseClientOs("android")).toBe("android");
+    expect((CLIENT_OS_VALUES as readonly string[]).includes("android")).toBe(
+      true,
+    );
+  });
+
+  test("rejects transport-only interface ids and unknown values", () => {
+    // `clientOs` is an OS surface, not a transport interface — values like
+    // "cli"/"telegram" (real interfaces) are not valid OS surfaces.
+    expect(parseClientOs("cli")).toBeNull();
+    expect(parseClientOs("telegram")).toBeNull();
+    expect(parseClientOs("vellum")).toBeNull();
+    expect(parseClientOs("linux")).toBeNull();
+    expect(parseClientOs(undefined)).toBeNull();
+    expect(parseClientOs(42)).toBeNull();
+  });
+});

package/src/channels/channel-verification-sessions.ts

@@ -44,7 +44,12 @@ export interface GuardianBinding {
   channel: string;
   guardianExternalUserId: string;
   guardianDeliveryChatId: string;
-  guardianPrincipalId: string;
+  /**
+   * Canonical principal from the gateway guardian contact. `null` when the
+   * gateway row carries no principal — callers must treat that as UNRESOLVED
+   * (repair via the vellum anchor / adopt path), never as an empty principal.
+   */
+  guardianPrincipalId: string | null;
   status: BindingStatus;
   verifiedAt: number;
   verifiedVia: string;
@@ -218,7 +223,7 @@ export function findPendingSessionByHash(
 /**
  * Find any pending inbound (non-expired) session for a given channel.
  * Scoped to 'pending' status only — this is the inbound verification path used by
- * the relay-server to gate incoming voice calls. Outbound session states
+ * the call setup router to gate incoming voice calls. Outbound session states
  * (pending_bootstrap, awaiting_response) are excluded so that an active outbound
  * verification does not inadvertently force unrelated inbound callers into the
  * verification flow.

package/src/channels/config.ts

@@ -14,17 +14,11 @@ export type ConversationStrategy =
   | "not_deliverable"
   | "push_only";
 
-export interface ChannelInvitePolicy {
-  /** Whether inbound invite code redemption is supported on this channel. */
-  codeRedemptionEnabled: boolean;
-}
-
 export interface ChannelNotificationPolicy {
   notification: {
     deliveryEnabled: boolean;
     conversationStrategy: ConversationStrategy;
   };
-  invite: ChannelInvitePolicy;
 }
 
 const CHANNEL_POLICIES = {
@@ -33,45 +27,30 @@ const CHANNEL_POLICIES = {
       deliveryEnabled: true,
       conversationStrategy: "start_new_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: false,
-    },
   },
   telegram: {
     notification: {
       deliveryEnabled: true,
       conversationStrategy: "continue_existing_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: true,
-    },
   },
   whatsapp: {
     notification: {
       deliveryEnabled: false,
       conversationStrategy: "continue_existing_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: true,
-    },
   },
   slack: {
     notification: {
       deliveryEnabled: true,
       conversationStrategy: "continue_existing_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: true,
-    },
   },
   email: {
     notification: {
       deliveryEnabled: false,
       conversationStrategy: "continue_existing_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: true,
-    },
   },
   platform: {
     notification: {
@@ -81,27 +60,18 @@ const CHANNEL_POLICIES = {
       // the channel is non-deliverable (which not_deliverable would).
       conversationStrategy: "push_only",
     },
-    invite: {
-      codeRedemptionEnabled: false,
-    },
   },
   phone: {
     notification: {
       deliveryEnabled: false,
       conversationStrategy: "not_deliverable",
     },
-    invite: {
-      codeRedemptionEnabled: false,
-    },
   },
   a2a: {
     notification: {
       deliveryEnabled: false,
       conversationStrategy: "continue_existing_conversation",
     },
-    invite: {
-      codeRedemptionEnabled: false,
-    },
   },
 } as const satisfies Record<ChannelId, ChannelNotificationPolicy>;
 
@@ -137,15 +107,3 @@ export function getConversationStrategy(
 ): ConversationStrategy {
   return CHANNEL_POLICIES[channelId].notification.conversationStrategy;
 }
-
-/** Returns the invite policy for the given channel. */
-export function getChannelInvitePolicy(
-  channelId: ChannelId,
-): ChannelInvitePolicy {
-  return CHANNEL_POLICIES[channelId].invite;
-}
-
-/** Whether invite code redemption is enabled for the given channel. */
-export function isInviteCodeRedemptionEnabled(channelId: ChannelId): boolean {
-  return CHANNEL_POLICIES[channelId].invite.codeRedemptionEnabled;
-}

package/src/channels/slack-thread-store.ts

@@ -132,6 +132,18 @@ export function extractMessageTsFromCallbackUrl(
   }
 }
 
+/**
+ * Whether a reply callback URL targets the Slack delivery endpoint.
+ */
+export function isSlackDeliveryCallbackUrl(callbackUrl?: string): boolean {
+  if (!callbackUrl) return false;
+  try {
+    return new URL(callbackUrl).pathname.endsWith("/deliver/slack");
+  } catch {
+    return callbackUrl.endsWith("/deliver/slack");
+  }
+}
+
 /**
  * Extract the channel from a Slack reply callback URL, if present.
  */

package/src/channels/types.ts

@@ -186,6 +186,29 @@ export function parseInterfaceId(value: unknown): InterfaceId | null {
   return null;
 }
 
+/**
+ * Client OS surfaces — the value set for the message-body `clientOs` field.
+ *
+ * This is deliberately SEPARATE from {@link INTERFACE_IDS}: `clientOs`
+ * describes which OS the user's device runs, not which transport the turn
+ * arrived on. `"android"` (and `"ios"` for a mobile browser) are real OS
+ * surfaces but not transports — they must never answer transport questions
+ * (`supportsHostProxy`, `isInteractiveInterface`), so they live here rather
+ * than polluting the interface vocabulary. Drives only the per-turn
+ * `client_os` context line (e.g. app-builder mobile-first for `ios`/`android`).
+ */
+export const CLIENT_OS_VALUES = ["web", "ios", "macos", "android"] as const;
+
+export type ClientOs = (typeof CLIENT_OS_VALUES)[number];
+
+/** Parse/validate a reported `clientOs`. Returns `null` for unknown values. */
+export function parseClientOs(value: unknown): ClientOs | null {
+  if (typeof value !== "string") return null;
+  return (CLIENT_OS_VALUES as readonly string[]).includes(value)
+    ? (value as ClientOs)
+    : null;
+}
+
 /**
  * Interfaces that have an SSE client capable of displaying interactive
  * permission prompts. Channel interfaces (telegram, slack, etc.) route

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -101,7 +101,7 @@ mock.module("../../../messaging/providers/slack/send.js", () => ({
     if (slackReplyError) throw slackReplyError;
     return { ok: true, ts: "1700000000.000200" };
   },
-  sendSlackTypingIndicator: async () => "1700000000.000200",
+  sendSlackStreamOp: async () => ({ ok: true, ts: "1700000000.000200" }),
   sendSlackReaction: async () => {},
   sendSlackAssistantThreadStatus: async () => {},
   sendSlackAttachments: async () => ({

package/src/cli/commands/__tests__/schedules.test.ts

@@ -107,6 +107,7 @@ describe("schedules command", () => {
       "cancel",
       "delete",
       "execute",
+      "worker",
     ]);
   });
 });
@@ -670,33 +671,31 @@ describe("schedules create", () => {
     mockIpcResult = {
       ok: true,
       result: {
-        schedules: [
-          {
-            id: "new-schedule-id",
-            name: "Heartbeat",
-            enabled: true,
-            syntax: "cron",
-            expression: "*/30 * * * *",
-            cronExpression: "*/30 * * * *",
-            timezone: null,
-            message: "run heartbeat",
-            script: null,
-            nextRunAt: 1_778_800_000_000,
-            lastRunAt: null,
-            lastStatus: null,
-            retryCount: 0,
-            maxRetries: 3,
-            retryBackoffMs: 60_000,
-            description: "Checks service heartbeat",
-            cadenceDescription: "Every 30 minutes",
-            mode: "execute",
-            status: "active",
-            routingIntent: "all_channels",
-            reuseConversation: false,
-            wakeConversationId: null,
-            isOneShot: false,
-          },
-        ],
+        schedule: {
+          id: "new-schedule-id",
+          name: "Heartbeat",
+          enabled: true,
+          syntax: "cron",
+          expression: "*/30 * * * *",
+          cronExpression: "*/30 * * * *",
+          timezone: null,
+          message: "run heartbeat",
+          script: null,
+          nextRunAt: 1_778_800_000_000,
+          lastRunAt: null,
+          lastStatus: null,
+          retryCount: 0,
+          maxRetries: 3,
+          retryBackoffMs: 60_000,
+          description: "Checks service heartbeat",
+          cadenceDescription: "Every 30 minutes",
+          mode: "execute",
+          status: "active",
+          routingIntent: "all_channels",
+          reuseConversation: false,
+          wakeConversationId: null,
+          isOneShot: false,
+        },
       },
     };
 
@@ -715,13 +714,11 @@ describe("schedules create", () => {
 
     expect(exitCode).toBe(0);
     expect(JSON.parse(stdout)).toEqual({
-      schedules: [
-        expect.objectContaining({
-          id: "new-schedule-id",
-          description: "Checks service heartbeat",
-          cadenceDescription: "Every 30 minutes",
-        }),
-      ],
+      schedule: expect.objectContaining({
+        id: "new-schedule-id",
+        description: "Checks service heartbeat",
+        cadenceDescription: "Every 30 minutes",
+      }),
     });
     expect(logLines).toEqual([]);
   });
@@ -748,6 +745,58 @@ describe("schedules create", () => {
     expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
     expect(errorLines).toEqual([]);
   });
+
+  test("creates a script-mode schedule with --mode script --script", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "GitHub watcher",
+      "--mode",
+      "script",
+      "--script",
+      'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+      "--expression",
+      "*/15 * * * *",
+      "--description",
+      "Polls GitHub notifications",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "createSchedule",
+        params: {
+          body: {
+            name: "GitHub watcher",
+            expression: "*/15 * * * *",
+            description: "Polls GitHub notifications",
+            enabled: true,
+            mode: "script",
+            script:
+              'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+          },
+        },
+      },
+    ]);
+  });
+
+  test("exits 1 when --mode script is missing --script", async () => {
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Broken",
+      "--mode",
+      "script",
+      "--expression",
+      "*/15 * * * *",
+      "--description",
+      "no script",
+    ]);
+
+    expect(exitCode).toBe(1);
+  });
 });
 
 describe("schedules update", () => {

package/src/cli/commands/__tests__/status.test.ts

@@ -51,6 +51,12 @@ mock.module("../../../util/platform.js", () => ({
   getWorkspaceDirDisplay: () => "~/.vellum/workspace",
 }));
 
+// Fixed installed CLI version so drift-vs-match is deterministic.
+const INSTALLED_CLI_VERSION = "9.9.9";
+mock.module("../../../version.js", () => ({
+  APP_VERSION: INSTALLED_CLI_VERSION,
+}));
+
 mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -182,13 +188,13 @@ describe("status command — daemon unreachable (ENOENT/ECONNREFUSED)", () => {
     expect(stdout).toContain("Assistant: running");
   });
 
-  test("does not print version or memory when daemon is unreachable", async () => {
+  test("prints the installed CLI version but no runtime health when unreachable", async () => {
     mockResponse = { ok: false, error: DAEMON_UNREACHABLE_ERROR };
     socketExists = false;
 
     const { stdout, stderr } = await runStatusCommand();
 
-    expect(stdout + stderr).not.toContain("Version");
+    expect(stdout).toContain(`CLI Version: ${INSTALLED_CLI_VERSION}`);
     expect(stdout + stderr).not.toContain("Memory");
   });
 });
@@ -242,8 +248,42 @@ describe("status command — daemon up", () => {
     const { stdout, stderr } = await runStatusCommand();
     const combined = stdout + stderr;
 
+    expect(combined).toContain("Assistant Version");
     expect(combined).toContain("1.2.3");
     expect(combined).toContain("100");
     expect(combined).toContain("500");
   });
+
+  test("flags the runtime as stale when it differs from the installed CLI", async () => {
+    mockResponse = {
+      ok: true,
+      result: {
+        version: "1.2.3",
+        memory: { currentMb: 100, maxMb: 500 },
+        disk: null,
+      },
+    };
+
+    const { stdout } = await runStatusCommand();
+
+    expect(stdout).toContain(
+      `1.2.3 (stale — restart to run ${INSTALLED_CLI_VERSION})`,
+    );
+  });
+
+  test("shows a bare version with no stale note when versions match", async () => {
+    mockResponse = {
+      ok: true,
+      result: {
+        version: INSTALLED_CLI_VERSION,
+        memory: { currentMb: 100, maxMb: 500 },
+        disk: null,
+      },
+    };
+
+    const { stdout } = await runStatusCommand();
+
+    expect(stdout).toContain(`Assistant Version  ${INSTALLED_CLI_VERSION}`);
+    expect(stdout).not.toContain("stale");
+  });
 });

package/src/cli/commands/contacts.ts

@@ -32,7 +32,7 @@ interface ContactWithChannels {
   principalId?: string;
   createdAt: string | number;
   updatedAt: string | number;
-  interactionCount: number;
+  interactionCount: number | null;
   channels: ContactChannel[];
 }
 
@@ -133,7 +133,7 @@ function formatContactDetail(
   if (c.principalId) lines.push(`Principal:    ${c.principalId}`);
   lines.push(`Created:      ${new Date(c.createdAt).toISOString()}`);
   lines.push(`Updated:      ${new Date(c.updatedAt).toISOString()}`);
-  lines.push(`Interactions: ${c.interactionCount}`);
+  lines.push(`Interactions: ${c.interactionCount ?? 0}`);
   if (c.channels.length > 0) {
     lines.push("");
     lines.push("Channels:");

package/src/cli/commands/credentials.ts

@@ -689,6 +689,23 @@ Examples:
             }
 
             if (!ipc.result?.ok) {
+              // An explicit user cancel is a valid outcome, not a failure.
+              // Surface it as an informational message and exit 130 — the
+              // conventional "user interrupt" (SIGINT) code — so callers and
+              // setup skills can tell a deliberate cancel apart from a genuine
+              // error (which stays exit 1). Nothing was stored either way.
+              if (ipc.result?.cancelled) {
+                if (shouldOutputJson(cmd)) {
+                  writeOutput(cmd, ipc.result);
+                } else {
+                  log.info(
+                    ipc.result.error ??
+                      "Credential prompt cancelled by the user",
+                  );
+                }
+                process.exitCode = 130;
+                return;
+              }
               writeError(cmd, ipc.result?.error ?? "Credential prompt failed");
               process.exitCode = 1;
               return;