@vellumai/assistant 0.6.5 → 0.7.0

package/src/browser/operations.ts

@@ -10,11 +10,6 @@
  *   - Dispatch to existing browser-execution.ts implementations.
  *   - Command-oriented metadata for CLI subcommand generation.
  *   - `wait_for_download` mode-constraint enforcement.
- *
- * Identifier-only exports (BROWSER_TOOL_NAMES, name mapping helpers)
- * live in `browser/identifiers.ts` to avoid pulling the browser
- * execution stack into policy/classification modules. This module
- * re-exports them for backwards compatibility.
  */
 
 import {
@@ -38,31 +33,7 @@ import {
 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 {
-  BROWSER_OPERATIONS,
-  type BrowserOperation,
-  type BrowserOperationMeta,
-} from "./types.js";
-
-// ── Re-exports from identifiers.ts ───────────────────────────────────
-//
-// Identifier-only constants and helpers are defined in the lightweight
-// `browser/identifiers.ts` module so that policy/classification
-// consumers can import them without pulling in the browser execution
-// stack. Re-exported here for backwards compatibility with existing
-// callers that import from `browser/operations.js`.
-
-export {
-  BROWSER_TOOL_NAMES,
-  browserOperationToToolName,
-  browserToolNameToOperation,
-} from "./identifiers.js";
-
-/**
- * All canonical browser operation identifiers (re-exported from types).
- */
-export const BROWSER_OPERATION_NAMES: readonly BrowserOperation[] =
-  BROWSER_OPERATIONS;
+import type { BrowserOperation, BrowserOperationMeta } from "./types.js";
 
 // ── Dispatch handlers ────────────────────────────────────────────────
 
@@ -641,20 +612,3 @@ Examples:
   $ assistant browser --json status`,
   },
 ];
-
-// ── Lookup helper ────────────────────────────────────────────────────
-
-/** Index for O(1) metadata lookups by operation. */
-const META_BY_OPERATION = new Map<BrowserOperation, BrowserOperationMeta>(
-  BROWSER_OPERATION_META.map((m) => [m.operation, m]),
-);
-
-/**
- * Get metadata for a specific operation. Returns `undefined` if the
- * operation is not recognized.
- */
-export function getBrowserOperationMeta(
-  operation: BrowserOperation,
-): BrowserOperationMeta | undefined {
-  return META_BY_OPERATION.get(operation);
-}

package/src/bundler/app-compiler.ts

@@ -268,14 +268,97 @@ async function resolveAppImports(srcDir: string): Promise<void> {
   }
 }
 
+/**
+ * Per-appDir compile serialisation.
+ *
+ * compileApp() begins by `rm -rf dist/`, so two concurrent compiles on the
+ * same appDir can wipe each other's intermediate output. To prevent that
+ * while still picking up source edits that arrive mid-build, we track a
+ * two-slot queue per appDir:
+ *
+ * - `current`: the compile that is currently writing to dist/.
+ * - `pending`: at most one coalesced follow-up compile queued because a new
+ *   caller arrived while `current` was running. Additional callers arriving
+ *   during that window share `pending` — they do not spawn yet another run.
+ *   Once `current` settles, `pending` is promoted to `current` and begins
+ *   executing; new callers arriving after promotion queue a fresh `pending`.
+ *
+ * This keeps dist/ consistent under concurrency while guaranteeing that any
+ * source mutation observed after a compile starts will be reflected in a
+ * subsequent compile pass rather than silently dropped.
+ */
+interface CompileSlot {
+  current: Promise<CompileResult>;
+  pending?: Promise<CompileResult>;
+}
+
+const compileSlots = new Map<string, CompileSlot>();
+
 /**
  * Compile a TSX app from appDir/src/ into appDir/dist/.
  *
  * Expects appDir/src/main.tsx as the entry point and appDir/src/index.html
  * as the HTML shell. Produces appDir/dist/main.js and appDir/dist/index.html
  * (with script and optional stylesheet tags injected).
+ *
+ * Concurrent calls for the same appDir are serialised (see `compileSlots`
+ * above). Callers never see a partial or racing dist/ write; callers that
+ * represent work requested after a compile started always get a subsequent
+ * fresh compile.
  */
-export async function compileApp(appDir: string): Promise<CompileResult> {
+export function compileApp(appDir: string): Promise<CompileResult> {
+  const slot = compileSlots.get(appDir);
+
+  if (!slot) {
+    const current = runCompile(appDir);
+    const onSettled = () => slotCompileSettled(appDir, current);
+    current.then(onSettled, onSettled);
+    compileSlots.set(appDir, { current });
+    return current;
+  }
+
+  if (slot.pending) return slot.pending;
+
+  // A second distinct caller arrived while `current` is running. Queue a
+  // follow-up that starts once `current` settles (success or failure) so
+  // any source edits that happened mid-build still get compiled.
+  const rerun = async (): Promise<CompileResult> => {
+    try {
+      await slot.current;
+    } catch {
+      // Ignore: we want to rerun regardless of the prior compile's outcome.
+    }
+    return runCompile(appDir);
+  };
+  const pending = rerun();
+  const onSettled = () => slotCompileSettled(appDir, pending);
+  pending.then(onSettled, onSettled);
+  slot.pending = pending;
+  return pending;
+}
+
+function slotCompileSettled(
+  appDir: string,
+  finished: Promise<CompileResult>,
+): void {
+  const slot = compileSlots.get(appDir);
+  if (!slot) return;
+
+  if (slot.current !== finished) {
+    // finished is a rerun that hasn't been promoted yet, or a stale entry.
+    // Promotion happens below when `current` settles; there is nothing to do
+    // here because a subsequent slotCompileSettled(current) will run first.
+    return;
+  }
+
+  if (slot.pending) {
+    compileSlots.set(appDir, { current: slot.pending });
+  } else {
+    compileSlots.delete(appDir);
+  }
+}
+
+async function runCompile(appDir: string): Promise<CompileResult> {
   const start = performance.now();
   const srcDir = join(appDir, "src");
   const distDir = join(appDir, "dist");

package/src/bundler/package-resolver.ts

@@ -7,11 +7,11 @@
 
 import { existsSync } from "node:fs";
 import { mkdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { ensureBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 const log = getLogger("package-resolver");
 
@@ -33,11 +33,7 @@ const inflight = new Map<string, Promise<string | null>>();
 
 /** Where all cached packages live on disk. */
 export function getCacheDir(): string {
-  // Package cache is intentionally shared across all local assistants to
-  // avoid re-downloading the same bundler deps per instance. Resolved
-  // against the real home directory so the cache is a single host-wide
-  // location regardless of BASE_DATA_DIR / per-instance containers.
-  return join(homedir(), ".vellum", "package-cache");
+  return join(getWorkspaceDir(), "package-cache");
 }
 
 /**

package/src/calls/active-call-lease.ts

@@ -150,7 +150,7 @@ export function upsertActiveCallLease(params: {
   return nextLease;
 }
 
-export function removeActiveCallLease(callSessionId: string): boolean {
+function removeActiveCallLease(callSessionId: string): boolean {
   const current = loadLeaseFile().leases;
   const next = current.filter((lease) => lease.callSessionId !== callSessionId);
   if (next.length === current.length) {

package/src/calls/call-constants.ts

@@ -1,7 +1,7 @@
 import { getConfig } from "../config/loader.js";
 
 // Emergency/high-risk numbers that should never be called
-export const DENIED_NUMBERS = new Set([
+const DENIED_NUMBERS = new Set([
   "911",
   "112",
   "999",

package/src/calls/call-controller.ts

@@ -8,10 +8,9 @@
  * barge-in, state machine, guardian verification).
  */
 
-import { getGatewayInternalBaseUrl } from "../config/env.js";
 import { loadConfig } from "../config/loader.js";
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
 import {
   expireCanonicalGuardianRequest,
@@ -21,7 +20,6 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { revokeScopedApprovalGrantsForContext } from "../memory/scoped-approval-grants.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
-import { mintDaemonDeliveryToken } from "../runtime/auth/token-service.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getCatalogProvider } from "../tts/provider-catalog.js";
 import type { TtsProvider, TtsProviderId } from "../tts/types.js";
@@ -1272,8 +1270,6 @@ export class CallController {
         void sendGuardianExpiryNotices(
           canonicalDeliveries,
           this.assistantId,
-          getGatewayInternalBaseUrl(),
-          () => mintDaemonDeliveryToken(),
         ).catch((err) => {
           log.error(
             {

package/src/calls/call-domain.ts

@@ -66,20 +66,20 @@ function postFailedCallPointer(
 
 // ── Result types ─────────────────────────────────────────────────────
 
-export interface StartCallResult {
+interface StartCallResult {
   ok: true;
   session: CallSession;
   callSid: string;
   callerIdentityMode: "assistant_number" | "user_number";
 }
 
-export interface CallError {
+interface CallError {
   ok: false;
   error: string;
   status?: number;
 }
 
-export type StartCallInput = {
+type StartCallInput = {
   phoneNumber: string;
   task: string;
   context?: string;
@@ -89,32 +89,32 @@ export type StartCallInput = {
   skipDisclosure?: boolean;
 };
 
-export type CancelCallInput = {
+type CancelCallInput = {
   callSessionId: string;
   reason?: string;
 };
 
-export type AnswerCallInput = {
+type AnswerCallInput = {
   callSessionId: string;
   answer: string;
   /** When provided, the answer is matched to this specific pending question/consultation. */
   pendingQuestionId?: string;
 };
 
-export type RelayInstructionInput = {
+type RelayInstructionInput = {
   callSessionId: string;
   instructionText: string;
 };
 
 // ── Caller identity resolution ───────────────────────────────────────
 
-export type CallerIdentitySource =
+type CallerIdentitySource =
   | "per_call_override"
   | "implicit_default"
   | "user_config"
   | "secure_key";
 
-export type CallerIdentityResult =
+type CallerIdentityResult =
   | {
       ok: true;
       mode: "assistant_number" | "user_number";
@@ -247,14 +247,14 @@ export async function resolveCallerIdentity(
 
 // ── Inbound voice session bootstrap ──────────────────────────────────
 
-export type CreateInboundVoiceSessionInput = {
+type CreateInboundVoiceSessionInput = {
   callSid: string;
   fromNumber: string;
   toNumber: string;
   assistantId?: string;
 };
 
-export type CreateInboundVoiceSessionResult = {
+type CreateInboundVoiceSessionResult = {
   session: CallSession;
   created: boolean;
 };
@@ -897,7 +897,7 @@ export async function relayInstruction(
 
 // ── Verification call ─────────────────────────────────────────────────
 
-export type StartVerificationCallInput = {
+type StartVerificationCallInput = {
   phoneNumber: string;
   verificationSessionId: string;
   assistantId?: string;
@@ -905,7 +905,7 @@ export type StartVerificationCallInput = {
   originConversationId?: string;
 };
 
-export type StartVerificationCallResult =
+type StartVerificationCallResult =
   | { ok: true; callSessionId: string; callSid: string }
   | CallError;
 
@@ -1032,14 +1032,14 @@ export async function startVerificationCall(
 
 // ── Invite call ───────────────────────────────────────────────────────
 
-export type StartInviteCallInput = {
+type StartInviteCallInput = {
   phoneNumber: string;
   friendName: string;
   guardianName: string;
   assistantId?: string;
 };
 
-export type StartInviteCallResult = { ok: true; callSid: string } | CallError;
+type StartInviteCallResult = { ok: true; callSid: string } | CallError;
 
 /**
  * Initiate an outbound call to deliver a voice invite to a contact.

package/src/calls/call-pointer-messages.ts

@@ -13,7 +13,6 @@ import {
   addMessage,
   getConversationOriginChannel,
   getConversationRecentProvenanceTrustClass,
-  getConversationType,
 } from "../memory/conversation-crud.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -24,14 +23,14 @@ import {
 
 const log = getLogger("call-pointer-messages");
 
-export type PointerEvent =
+type PointerEvent =
   | "started"
   | "completed"
   | "failed"
   | "verification_succeeded"
   | "verification_failed";
 
-export type PointerAudienceMode = "auto" | "trusted" | "untrusted";
+type PointerAudienceMode = "auto" | "trusted" | "untrusted";
 
 /**
  * Daemon-injected function that sends a message through the daemon conversation
@@ -43,7 +42,7 @@ export type PointerAudienceMode = "auto" | "trusted" | "untrusted";
  *   should validate the output and throw if any are missing so the
  *   deterministic fallback fires.
  */
-export type PointerMessageProcessor = (
+type PointerMessageProcessor = (
   conversationId: string,
   instruction: string,
   requiredFacts?: string[],
@@ -80,7 +79,6 @@ export function resetPointerMessageProcessor(): void {
  *
  * Trusted when:
  * - recent message provenance trust class is 'guardian' or 'trusted_contact'
- * - conversation conversationType is 'private' (local desktop-origin context)
  * - conversation origin channel is 'vellum' (desktop app)
  *
  * Untrusted by default when insufficient evidence.
@@ -89,15 +87,12 @@ function resolvePointerAudienceTrust(conversationId: string): boolean {
   try {
     // Check provenance trust class on recent messages first — this catches
     // trusted contacts who initiate calls from gateway channels (e.g. WhatsApp)
-    // where the conversation itself isn't a desktop-origin private conversation.
+    // where the conversation itself isn't desktop-origin.
     const provenance =
       getConversationRecentProvenanceTrustClass(conversationId);
     if (provenance === "guardian" || provenance === "trusted_contact")
       return true;
 
-    const conversationType = getConversationType(conversationId);
-    if (conversationType === "private") return true;
-
     const originChannel = getConversationOriginChannel(conversationId);
     if (originChannel === "vellum") return true;
   } catch {

package/src/calls/call-state.ts

@@ -1,8 +1,8 @@
 /**
  * Call session notifiers and controller registry.
  *
- * Follows the same notifier pattern as watch-state.ts: module-level Maps
- * with register/unregister/fire helpers keyed by conversationId.
+ * Uses module-level Maps with register/unregister/fire helpers keyed by
+ * conversationId.
  */
 
 import { getLogger } from "../util/logger.js";

package/src/calls/call-store.ts

@@ -1,7 +1,8 @@
 import { and, desc, eq, notInArray, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb, rawChanges, rawGet, rawRun } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { rawChanges, rawGet, rawRun } from "../memory/raw-query.js";
 import {
   callEvents,
   callPendingQuestions,

package/src/calls/guardian-action-sweep.ts

@@ -49,8 +49,6 @@ export interface ExpiryDeliveryInfo {
 export async function sendGuardianExpiryNotices(
   deliveries: ExpiryDeliveryInfo[],
   assistantId: string,
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): Promise<void> {
   for (const delivery of deliveries) {
@@ -79,21 +77,17 @@ export async function sendGuardianExpiryNotices(
             userMessageChannel: "phone",
             assistantMessageChannel: "vellum",
             userMessageInterface: "phone",
-            assistantMessageInterface: "vellum",
+            assistantMessageInterface: "web",
           },
         );
       } else if (delivery.destinationChatId) {
-        // External channel — send expiry notice
-        const deliverUrl = `${gatewayBaseUrl}/deliver/${delivery.destinationChannel}`;
-        await deliverChannelReply(
-          deliverUrl,
-          {
-            chatId: delivery.destinationChatId,
-            text: expiryText,
-            assistantId,
-          },
-          mintBearerToken?.(),
-        );
+        // External channel — send expiry notice via direct delivery
+        const deliverUrl = `/deliver/${delivery.destinationChannel}`;
+        await deliverChannelReply(deliverUrl, {
+          chatId: delivery.destinationChatId,
+          text: expiryText,
+          assistantId,
+        });
       }
     } catch (err) {
       log.error(
@@ -108,8 +102,6 @@ export async function sendGuardianExpiryNotices(
  * Sweep expired guardian action requests and clean up.
  */
 export async function sweepExpiredGuardianActions(
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): Promise<void> {
   const expired = getExpiredGuardianActionRequests();
@@ -132,16 +124,12 @@ export async function sweepExpiredGuardianActions(
     await sendGuardianExpiryNotices(
       deliveries,
       DAEMON_INTERNAL_ASSISTANT_ID,
-      gatewayBaseUrl,
-      mintBearerToken,
       guardianActionCopyGenerator,
     );
   }
 }
 
 export function startGuardianActionSweep(
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): void {
   if (sweepTimer) return;
@@ -149,11 +137,7 @@ export function startGuardianActionSweep(
     if (sweepInProgress) return;
     sweepInProgress = true;
     try {
-      await sweepExpiredGuardianActions(
-        gatewayBaseUrl,
-        mintBearerToken,
-        guardianActionCopyGenerator,
-      );
+      await sweepExpiredGuardianActions(guardianActionCopyGenerator);
     } catch (err) {
       log.error({ err }, "Guardian action sweep failed");
     } finally {

package/src/calls/guardian-dispatch.ts

@@ -17,7 +17,6 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import type { NotificationDeliveryResult } from "../notifications/types.js";
-import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { getLogger } from "../util/logger.js";
 import { getUserConsultationTimeoutMs } from "./call-constants.js";
 import type { CallPendingQuestion } from "./types.js";
@@ -106,28 +105,10 @@ async function dispatchGuardianQuestionInner(
       guardianPrincipalId = guardianResult.contact.principalId;
     }
 
-    // Self-heal: if contacts don't have a principalId, bootstrap via
-    // ensureVellumGuardianBinding so the pending_question request can
-    // be attributed.
-    if (!guardianPrincipalId) {
-      log.info(
-        { callSessionId, assistantId },
-        "No guardian principal from contacts — self-healing for voice dispatch",
-      );
-      try {
-        guardianPrincipalId = ensureVellumGuardianBinding(assistantId);
-      } catch (err) {
-        log.warn(
-          { err, callSessionId, assistantId },
-          "ensureVellumGuardianBinding failed during voice dispatch self-heal",
-        );
-      }
-    }
-
     if (!guardianPrincipalId) {
       log.error(
         { callSessionId, assistantId },
-        "Voice guardian dispatch: no guardianPrincipalId after contacts + self-heal — cannot create pending_question",
+        "Voice guardian dispatch: no guardianPrincipalId — gateway may not have started yet; cannot create pending_question",
       );
       return;
     }

package/src/calls/media-stream-audio-transcode.ts

@@ -24,7 +24,7 @@
  * 8000 samples/sec * 0.020 sec = 160 samples per frame.
  * Each mu-law sample is 1 byte, so each frame is 160 bytes.
  */
-export const MULAW_FRAME_SIZE = 160;
+const MULAW_FRAME_SIZE = 160;
 
 /**
  * Bias constant used in the linear-to-mu-law compression formula
@@ -52,7 +52,7 @@ const MULAW_SEG_TABLE = [0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3];
  * signed 16-bit integer (range: -32768 to +32767). The output is an
  * unsigned 8-bit mu-law value.
  */
-export function linearToMulaw(sample: number): number {
+function linearToMulaw(sample: number): number {
   // Determine sign and clamp magnitude
   const sign = (sample >> 8) & 0x80;
   if (sign !== 0) sample = -sample;
@@ -132,42 +132,3 @@ export function chunkMulawToBase64Frames(mulawBuffer: Buffer): string[] {
 // ---------------------------------------------------------------------------
 // High-level: raw audio bytes to sendable base64 frames
 // ---------------------------------------------------------------------------
-
-/**
- * Accepted audio formats for transcoding into mu-law frames.
- *
- * Currently only `mulaw` (already in the target format) and `pcm16` (16-bit
- * signed LE PCM at 8 kHz) are supported. Higher-level formats (mp3, wav,
- * opus) require decoding to PCM first -- callers should handle that
- * conversion before invoking this helper.
- */
-export type TranscodeInputFormat = "mulaw" | "pcm16";
-
-/**
- * Transcode raw audio bytes into Twilio-compatible base64-encoded mu-law
- * frames.
- *
- * @param audio - Raw audio bytes in the specified format.
- * @param format - The format of the input audio.
- * @returns Array of base64-encoded mu-law frames ready for
- *   `MediaStreamOutput.sendAudioPayload()`.
- */
-export function transcodeToMulawFrames(
-  audio: Uint8Array,
-  format: TranscodeInputFormat,
-): string[] {
-  let mulawBuffer: Buffer;
-
-  switch (format) {
-    case "mulaw":
-      mulawBuffer = Buffer.from(audio);
-      break;
-    case "pcm16":
-      mulawBuffer = pcm16ToMulaw(audio);
-      break;
-    default:
-      throw new Error(`Unsupported transcode format: ${format as string}`);
-  }
-
-  return chunkMulawToBase64Frames(mulawBuffer);
-}

package/src/calls/media-stream-server.ts

@@ -53,6 +53,7 @@ import {
 import { finalizeCall } from "./finalize-call.js";
 import { MediaStreamOutput } from "./media-stream-output.js";
 import { parseMediaStreamFrame } from "./media-stream-parser.js";
+import type { MediaStreamStartEvent } from "./media-stream-protocol.js";
 import {
   MediaStreamSttSession,
   type MediaStreamSttSessionCallbacks,
@@ -295,9 +296,7 @@ export class MediaStreamCallSession {
 
   // ── Internal: media-stream event handlers ─────────────────────────
 
-  private handleStart(
-    event: import("./media-stream-protocol.js").MediaStreamStartEvent,
-  ): void {
+  private handleStart(event: MediaStreamStartEvent): void {
     this.streamSid = event.streamSid;
     this.callSid = event.start.callSid;
 

package/src/calls/media-stream-stt-session.ts

@@ -350,12 +350,10 @@ export class MediaStreamSttSession {
  * threshold. The threshold is tuned for Twilio's 8 kHz, 8-bit mu-law
  * stream where typical silence RMS is ~50-100 and speech is >300.
  *
- * Exported for testing.
- *
  * @param base64Payload - Base64-encoded mu-law audio chunk from Twilio.
  * @returns `true` if the chunk likely contains speech, `false` otherwise.
  */
-export function detectSpeechActivity(base64Payload: string): boolean {
+function detectSpeechActivity(base64Payload: string): boolean {
   const SPEECH_ENERGY_THRESHOLD = 200;
 
   let raw: Buffer;