@vellumai/assistant 0.4.42 → 0.4.44

package/src/runtime/assistant-event.ts

@@ -8,7 +8,7 @@
 
 import { randomUUID } from "node:crypto";
 
-import type { ServerMessage } from "../daemon/ipc-protocol.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
 
 // ── Types ─────────────────────────────────────────────────────────────────────
 

package/src/runtime/auth/__tests__/guard-tests.test.ts

@@ -289,6 +289,7 @@ describe("scope profile contract", () => {
     ],
     gateway_ingress_v1: ["ingress.write", "internal.write"],
     gateway_service_v1: [
+      "chat.read",
       "chat.write",
       "settings.read",
       "settings.write",

package/src/runtime/auth/__tests__/ipc-auth-context.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import { buildIpcAuthContext } from "../../../daemon/ipc-handler.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
+import { buildIpcAuthContext } from "../../local-actor-identity.js";
 import { CURRENT_POLICY_EPOCH } from "../policy.js";
 import { resolveScopeProfile } from "../scopes.js";
 

package/src/runtime/auth/__tests__/scopes.test.ts

@@ -54,13 +54,14 @@ describe("resolveScopeProfile", () => {
 
   test("gateway_service_v1 includes chat, settings, attachments, and internal scopes", () => {
     const scopes = resolveScopeProfile("gateway_service_v1");
+    expect(scopes.has("chat.read")).toBe(true);
     expect(scopes.has("chat.write")).toBe(true);
     expect(scopes.has("settings.read")).toBe(true);
     expect(scopes.has("settings.write")).toBe(true);
     expect(scopes.has("attachments.read")).toBe(true);
     expect(scopes.has("attachments.write")).toBe(true);
     expect(scopes.has("internal.write")).toBe(true);
-    expect(scopes.size).toBe(6);
+    expect(scopes.size).toBe(7);
   });
 
   test("ipc_v1 includes only ipc.all", () => {

package/src/runtime/auth/__tests__/subject.test.ts

@@ -43,6 +43,38 @@ describe("parseSub", () => {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // svc:daemon pattern
+  // -------------------------------------------------------------------------
+
+  test("parses svc:daemon:<identifier>", () => {
+    const result = parseSub("svc:daemon:self");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.principalType).toBe("svc_daemon");
+      expect(result.assistantId).toBe("self");
+      expect(result.actorPrincipalId).toBeUndefined();
+      expect(result.sessionId).toBeUndefined();
+    }
+  });
+
+  test("parses svc:daemon with non-self identifier", () => {
+    const result = parseSub("svc:daemon:pairing");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.principalType).toBe("svc_daemon");
+      expect(result.assistantId).toBe("pairing");
+    }
+  });
+
+  test("fails on svc:daemon with empty identifier", () => {
+    const result = parseSub("svc:daemon:");
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.reason).toContain("empty");
+    }
+  });
+
   // -------------------------------------------------------------------------
   // ipc pattern
   // -------------------------------------------------------------------------

package/src/runtime/auth/route-policy.ts

@@ -127,8 +127,15 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "messages:GET", scopes: ["chat.read"] },
   { endpoint: "messages:POST", scopes: ["chat.write"] },
   { endpoint: "conversations", scopes: ["chat.read"] },
+  { endpoint: "conversations:DELETE", scopes: ["chat.write"] },
+  { endpoint: "conversations/switch", scopes: ["chat.write"] },
+  { endpoint: "conversations/name", scopes: ["chat.write"] },
+  { endpoint: "conversations/cancel", scopes: ["chat.write"] },
+  { endpoint: "conversations/undo", scopes: ["chat.write"] },
+  { endpoint: "conversations/regenerate", scopes: ["chat.write"] },
   { endpoint: "conversations/attention", scopes: ["chat.read"] },
   { endpoint: "conversations/seen", scopes: ["chat.write"] },
+  { endpoint: "conversations/unread", scopes: ["chat.write"] },
   { endpoint: "search", scopes: ["chat.read"] },
   { endpoint: "search/global", scopes: ["chat.read"] },
   { endpoint: "suggestion", scopes: ["chat.read"] },
@@ -163,7 +170,6 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "identity", scopes: ["settings.read"] },
   { endpoint: "brain-graph", scopes: ["settings.read"] },
   { endpoint: "brain-graph-ui", scopes: ["settings.read"] },
-  { endpoint: "home-base-ui", scopes: ["settings.read"] },
   { endpoint: "contacts", scopes: ["settings.read"] },
   { endpoint: "contacts:POST", scopes: ["settings.write"] },
   { endpoint: "contacts:DELETE", scopes: ["settings.write"] },
@@ -191,19 +197,21 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
     endpoint: "integrations/slack/channel/config:DELETE",
     scopes: ["settings.write"],
   },
-  { endpoint: "integrations/guardian/challenge", scopes: ["settings.write"] },
-  { endpoint: "integrations/guardian/status", scopes: ["settings.read"] },
-  { endpoint: "integrations/guardian/revoke", scopes: ["settings.write"] },
+  { endpoint: "channel-verification-sessions", scopes: ["settings.write"] },
   {
-    endpoint: "integrations/guardian/outbound/start",
+    endpoint: "channel-verification-sessions:DELETE",
     scopes: ["settings.write"],
   },
   {
-    endpoint: "integrations/guardian/outbound/resend",
+    endpoint: "channel-verification-sessions/resend",
     scopes: ["settings.write"],
   },
   {
-    endpoint: "integrations/guardian/outbound/cancel",
+    endpoint: "channel-verification-sessions/status",
+    scopes: ["settings.read"],
+  },
+  {
+    endpoint: "channel-verification-sessions/revoke",
     scopes: ["settings.write"],
   },
   { endpoint: "integrations/twilio/config", scopes: ["settings.read"] },
@@ -228,22 +236,6 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
     endpoint: "integrations/twilio/numbers/release",
     scopes: ["settings.write"],
   },
-  { endpoint: "integrations/twilio/sms/compliance", scopes: ["settings.read"] },
-  {
-    endpoint: "integrations/twilio/sms/compliance/tollfree",
-    scopes: ["settings.write"],
-  },
-  {
-    endpoint: "integrations/twilio/sms/compliance/tollfree:PATCH",
-    scopes: ["settings.write"],
-  },
-  {
-    endpoint: "integrations/twilio/sms/compliance/tollfree:DELETE",
-    scopes: ["settings.write"],
-  },
-  { endpoint: "integrations/twilio/sms/test", scopes: ["settings.write"] },
-  { endpoint: "integrations/twilio/sms/doctor", scopes: ["settings.write"] },
-
   // Slack share
   { endpoint: "slack/channels", scopes: ["settings.read"] },
   { endpoint: "slack/share", scopes: ["settings.write"] },
@@ -262,12 +254,33 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Pairing (authenticated)
   { endpoint: "pairing/register", scopes: ["settings.write"] },
 
-  // Apps
+  // Apps (existing share/shared routes)
   { endpoint: "apps/share", scopes: ["settings.write"] },
   { endpoint: "apps/shared:GET", scopes: ["settings.read"] },
   { endpoint: "apps/shared:DELETE", scopes: ["settings.write"] },
   { endpoint: "apps/shared/metadata", scopes: ["settings.read"] },
 
+  // Apps management (CRUD, bundling, sharing, versioning)
+  { endpoint: "apps", scopes: ["settings.read"] },
+  { endpoint: "apps/data:GET", scopes: ["settings.read"] },
+  { endpoint: "apps/data:POST", scopes: ["settings.write"] },
+  { endpoint: "apps/open", scopes: ["settings.write"] },
+  { endpoint: "apps/delete", scopes: ["settings.write"] },
+  { endpoint: "apps/preview:GET", scopes: ["settings.read"] },
+  { endpoint: "apps/preview:PUT", scopes: ["settings.write"] },
+  { endpoint: "apps/history", scopes: ["settings.read"] },
+  { endpoint: "apps/diff", scopes: ["settings.read"] },
+  { endpoint: "apps/restore", scopes: ["settings.write"] },
+  { endpoint: "apps/bundle", scopes: ["settings.write"] },
+  { endpoint: "apps/open-bundle", scopes: ["settings.write"] },
+  { endpoint: "apps/shared-list", scopes: ["settings.read"] },
+  { endpoint: "apps/fork", scopes: ["settings.write"] },
+  { endpoint: "apps/share-cloud", scopes: ["settings.write"] },
+  { endpoint: "apps/gallery", scopes: ["settings.read"] },
+  { endpoint: "apps/gallery/install", scopes: ["settings.write"] },
+  { endpoint: "apps/sign-bundle", scopes: ["settings.write"] },
+  { endpoint: "apps/signing-identity", scopes: ["settings.read"] },
+
   // Usage / cost telemetry
   { endpoint: "usage/totals", scopes: ["settings.read"] },
   { endpoint: "usage/daily", scopes: ["settings.read"] },
@@ -276,6 +289,49 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Debug
   { endpoint: "debug", scopes: ["settings.read"] },
 
+  // Workspace file browsing
+  { endpoint: "workspace/tree", scopes: ["settings.read"] },
+  { endpoint: "workspace/file", scopes: ["settings.read"] },
+  { endpoint: "workspace/file/content", scopes: ["settings.read"] },
+  { endpoint: "workspace/write", scopes: ["settings.write"] },
+  { endpoint: "workspace/mkdir", scopes: ["settings.write"] },
+  { endpoint: "workspace/rename", scopes: ["settings.write"] },
+  { endpoint: "workspace/delete", scopes: ["settings.write"] },
+
+  // Documents
+  { endpoint: "documents:GET", scopes: ["settings.read"] },
+  { endpoint: "documents:POST", scopes: ["settings.write"] },
+
+  // Work items
+  { endpoint: "work-items:GET", scopes: ["settings.read"] },
+  { endpoint: "work-items:PATCH", scopes: ["settings.write"] },
+  { endpoint: "work-items:DELETE", scopes: ["settings.write"] },
+  { endpoint: "work-items/complete", scopes: ["settings.write"] },
+  { endpoint: "work-items/cancel", scopes: ["settings.write"] },
+  { endpoint: "work-items/approve-permissions", scopes: ["approval.write"] },
+  { endpoint: "work-items/preflight", scopes: ["settings.read"] },
+  { endpoint: "work-items/run", scopes: ["settings.write"] },
+  { endpoint: "work-items/output", scopes: ["settings.read"] },
+
+  // Subagents
+  { endpoint: "subagents:GET", scopes: ["chat.read"] },
+  { endpoint: "subagents/abort", scopes: ["chat.write"] },
+  { endpoint: "subagents/message", scopes: ["chat.write"] },
+
+  // Model config
+  { endpoint: "model:GET", scopes: ["settings.read"] },
+  { endpoint: "model:PUT", scopes: ["settings.write"] },
+  { endpoint: "model/image-gen", scopes: ["settings.write"] },
+
+  // Conversation search
+  { endpoint: "conversations/search", scopes: ["chat.read"] },
+
+  // Message content
+  { endpoint: "messages/content", scopes: ["chat.read"] },
+
+  // Queued message deletion
+  { endpoint: "messages/queued", scopes: ["chat.write"] },
+
   // Browser relay
   { endpoint: "browser-relay/status", scopes: ["settings.read"] },
   { endpoint: "browser-relay/command", scopes: ["settings.write"] },
@@ -283,14 +339,39 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Interfaces
   { endpoint: "interfaces", scopes: ["settings.read"] },
 
+  // Skills
+  { endpoint: "skills:GET", scopes: ["settings.read"] },
+  { endpoint: "skills:POST", scopes: ["settings.write"] },
+  { endpoint: "skills:DELETE", scopes: ["settings.write"] },
+  { endpoint: "skills:PATCH", scopes: ["settings.write"] },
+
   // Trust rule CRUD management
   { endpoint: "trust-rules/manage:GET", scopes: ["settings.read"] },
   { endpoint: "trust-rules/manage:POST", scopes: ["settings.write"] },
   { endpoint: "trust-rules/manage:DELETE", scopes: ["settings.write"] },
   { endpoint: "trust-rules/manage:PATCH", scopes: ["settings.write"] },
 
+  // Computer use
+  { endpoint: "computer-use/sessions", scopes: ["chat.write"] },
+  { endpoint: "computer-use/sessions/abort", scopes: ["chat.write"] },
+  { endpoint: "computer-use/observations", scopes: ["chat.write"] },
+  { endpoint: "computer-use/tasks", scopes: ["chat.write"] },
+  { endpoint: "computer-use/ride-shotgun/start", scopes: ["chat.write"] },
+  { endpoint: "computer-use/ride-shotgun/stop", scopes: ["chat.write"] },
+  { endpoint: "computer-use/ride-shotgun/status", scopes: ["chat.write"] },
+  { endpoint: "computer-use/watch", scopes: ["chat.write"] },
+
+  // Recordings
+  { endpoint: "recordings/start", scopes: ["settings.write"] },
+  { endpoint: "recordings/stop", scopes: ["settings.write"] },
+  { endpoint: "recordings/pause", scopes: ["settings.write"] },
+  { endpoint: "recordings/resume", scopes: ["settings.write"] },
+  { endpoint: "recordings/status", scopes: ["settings.read"] },
+  { endpoint: "recordings/status:POST", scopes: ["settings.write"] },
+
   // Surface actions
   { endpoint: "surface-actions", scopes: ["chat.write"] },
+  { endpoint: "surfaces/undo", scopes: ["chat.write"] },
 
   // Conversation deletion (channel-facing)
   { endpoint: "channels/conversation:DELETE", scopes: ["chat.write"] },
@@ -303,12 +384,43 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "migrations/export", scopes: ["settings.write"] },
   { endpoint: "migrations/import-preflight", scopes: ["settings.write"] },
   { endpoint: "migrations/import", scopes: ["settings.write"] },
+
+  // Settings (voice, avatar, client settings)
+  { endpoint: "settings/voice", scopes: ["settings.write"] },
+  { endpoint: "settings/avatar/generate", scopes: ["settings.write"] },
+  { endpoint: "settings/client", scopes: ["settings.write"] },
+
+  // Schedules
+  { endpoint: "schedules", scopes: ["settings.read"] },
+  { endpoint: "schedules:DELETE", scopes: ["settings.write"] },
+  { endpoint: "schedules/toggle", scopes: ["settings.write"] },
+  { endpoint: "schedules/run", scopes: ["settings.write"] },
+
+  // Diagnostics
+  { endpoint: "diagnostics/export", scopes: ["settings.read"] },
+  { endpoint: "diagnostics/env-vars", scopes: ["settings.read"] },
+
+  // Dictation
+  { endpoint: "dictation", scopes: ["chat.write"] },
+
+  // OAuth / integrations
+  { endpoint: "integrations/oauth/start", scopes: ["settings.write"] },
+  { endpoint: "integrations/twitter/auth/start", scopes: ["settings.write"] },
+  { endpoint: "integrations/twitter/auth/status", scopes: ["settings.read"] },
+
+  // Workspace files (IPC-migrated)
+  { endpoint: "workspace-files", scopes: ["settings.read"] },
+  { endpoint: "workspace-files/read", scopes: ["settings.read"] },
+
+  // Tools
+  { endpoint: "tools", scopes: ["settings.read"] },
+  { endpoint: "tools/simulate-permission", scopes: ["settings.read"] },
 ];
 
 for (const { endpoint, scopes } of ACTOR_ENDPOINTS) {
   registerPolicy(endpoint, {
     requiredScopes: scopes,
-    allowedPrincipalTypes: ["actor", "svc_gateway", "ipc"],
+    allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "ipc"],
   });
 }
 

package/src/runtime/auth/scopes.ts

@@ -29,6 +29,7 @@ const PROFILE_SCOPES: Record<ScopeProfile, ReadonlySet<Scope>> = {
   ]),
   gateway_ingress_v1: new Set<Scope>(["ingress.write", "internal.write"]),
   gateway_service_v1: new Set<Scope>([
+    "chat.read",
     "chat.write",
     "settings.read",
     "settings.write",

package/src/runtime/auth/subject.ts

@@ -31,6 +31,7 @@ export type ParseSubResult =
  * Supported patterns:
  *   actor:<assistantId>:<actorPrincipalId>
  *   svc:gateway:<assistantId>
+ *   svc:daemon:<identifier>
  *   ipc:<assistantId>:<sessionId>
  */
 export function parseSub(sub: string): ParseSubResult {
@@ -59,6 +60,14 @@ export function parseSub(sub: string): ParseSubResult {
     return { ok: true, principalType: "svc_gateway", assistantId };
   }
 
+  if (parts[0] === "svc" && parts[1] === "daemon" && parts.length === 3) {
+    const identifier = parts[2];
+    if (!identifier) {
+      return { ok: false, reason: "svc:daemon sub has empty identifier" };
+    }
+    return { ok: true, principalType: "svc_daemon", assistantId: identifier };
+  }
+
   if (parts[0] === "ipc" && parts.length === 3) {
     const [, assistantId, sessionId] = parts;
     if (!assistantId || !sessionId) {

package/src/runtime/auth/token-service.ts

@@ -111,6 +111,17 @@ export function isSigningKeyInitialized(): boolean {
   return _authSigningKey !== undefined;
 }
 
+/**
+ * Returns a short hex fingerprint of the current signing key.
+ * Used by daemon_status to let clients detect instance switches.
+ */
+export function getSigningKeyFingerprint(): string {
+  return createHash("sha256")
+    .update(getSigningKey())
+    .digest("hex")
+    .slice(0, 16);
+}
+
 // ---------------------------------------------------------------------------
 // Base64url helpers
 // ---------------------------------------------------------------------------
@@ -298,7 +309,7 @@ export function mintEdgeRelayToken(): string {
 
 /**
  * Mint a long-lived JWT for embedding in browser-served UI pages
- * (brain-graph, home-base).
+ * (brain-graph).
  *
  * These pages make API calls that route through the gateway, which validates
  * tokens with validateEdgeToken() expecting aud=vellum-gateway. A 1-hour TTL

package/src/runtime/auth/types.ts

@@ -41,7 +41,7 @@ export type Scope =
 // Principal types — derived from the sub pattern
 // ---------------------------------------------------------------------------
 
-export type PrincipalType = "actor" | "svc_gateway" | "ipc";
+export type PrincipalType = "actor" | "svc_gateway" | "svc_daemon" | "ipc";
 
 // ---------------------------------------------------------------------------
 // Token audience — which service the JWT is intended for

package/src/runtime/channel-approval-types.ts

@@ -2,7 +2,7 @@
  * Channel-agnostic approval flow types.
  *
  * These types model the approval prompt/decision lifecycle for tool-use
- * confirmations surfaced through external channels (Telegram, SMS, etc.).
+ * confirmations surfaced through external channels (Telegram, Slack, etc.).
  * They are intentionally decoupled from any specific channel so that the
  * same approval flow can be reused across transports.
  */

package/src/runtime/channel-approvals.ts

@@ -1,7 +1,7 @@
 /**
  * Channel-agnostic approval orchestration module.
  *
- * Bridges the gap between external channel adapters (Telegram, SMS, etc.)
+ * Bridges the gap between external channel adapters (Telegram, Slack, etc.)
  * and the pending-interactions tracker / permission system:
  *
  *   1. Detect pending confirmations for a conversation

package/src/runtime/channel-invite-transport.ts

@@ -133,7 +133,6 @@ export async function resolveAdapterHandle(
 
 import { emailInviteAdapter } from "./channel-invite-transports/email.js";
 import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
-import { smsInviteAdapter } from "./channel-invite-transports/sms.js";
 import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
 import { voiceInviteAdapter } from "./channel-invite-transports/voice.js";
 import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
@@ -143,7 +142,6 @@ export function createInviteAdapterRegistry(): InviteAdapterRegistry {
   const registry = new InviteAdapterRegistry();
   registry.register(emailInviteAdapter);
   registry.register(slackInviteAdapter);
-  registry.register(smsInviteAdapter);
   registry.register(telegramInviteAdapter);
   registry.register(voiceInviteAdapter);
   registry.register(whatsappInviteAdapter);

package/src/runtime/channel-invite-transports/slack.ts

@@ -8,7 +8,7 @@
  */
 
 import type { ChannelId } from "../../channels/types.js";
-import { getCredentialMetadata } from "../../tools/credentials/metadata-store.js";
+import { getConfig } from "../../config/loader.js";
 import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
 
 // ---------------------------------------------------------------------------
@@ -21,26 +21,12 @@ interface SlackBotInfo {
 }
 
 /**
- * Resolve the Slack bot username and team name from credential metadata.
- * Mirrors the metadata parsing pattern in `config-slack-channel.ts`.
+ * Resolve the Slack bot username and team name from config.
  */
 function resolveSlackBotInfo(): SlackBotInfo | undefined {
-  const meta = getCredentialMetadata("slack_channel", "bot_token");
-  if (!meta?.accountInfo) return undefined;
-
-  try {
-    const parsed = JSON.parse(meta.accountInfo) as {
-      botUsername?: string;
-      teamName?: string;
-    };
-    if (!parsed.botUsername) return undefined;
-    return {
-      botUsername: parsed.botUsername,
-      teamName: parsed.teamName,
-    };
-  } catch {
-    return undefined;
-  }
+  const { botUsername, teamName } = getConfig().slack;
+  if (!botUsername) return undefined;
+  return { botUsername, teamName: teamName || undefined };
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/channel-invite-transports/telegram.ts

@@ -10,11 +10,14 @@
  */
 
 import type { ChannelId } from "../../channels/types.js";
-import { getSecureKey } from "../../security/secure-keys.js";
 import {
-  getCredentialMetadata,
-  upsertCredentialMetadata,
-} from "../../tools/credentials/metadata-store.js";
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
+import { getSecureKey } from "../../security/secure-keys.js";
+import { getTelegramBotUsername } from "../../telegram/bot-username.js";
 import { getLogger } from "../../util/logger.js";
 import type {
   ChannelInviteAdapter,
@@ -26,37 +29,15 @@ import type {
 // ---------------------------------------------------------------------------
 
 /**
- * Resolve the Telegram bot username from credential metadata, falling back
- * to the TELEGRAM_BOT_USERNAME environment variable. Mirrors the resolution
- * strategy used in `guardian-outbound-actions.ts`.
- */
-function getTelegramBotUsername(): string | undefined {
-  const meta = getCredentialMetadata("telegram", "bot_token");
-  if (
-    meta?.accountInfo &&
-    typeof meta.accountInfo === "string" &&
-    meta.accountInfo.trim().length > 0
-  ) {
-    return meta.accountInfo.trim();
-  }
-  return process.env.TELEGRAM_BOT_USERNAME || undefined;
-}
-
-/**
- * Ensure the Telegram bot username is resolved and cached in credential
- * metadata. When the bot token was configured via CLI `credential set`,
+ * Ensure the Telegram bot username is resolved and cached in config.
+ * When the bot token was configured via CLI `credential set`,
  * `credential_store` tool, or ingress secret redirect, the `getMe` API
- * call that populates `accountInfo` is skipped — this function fills that
+ * call that populates the config is skipped — this function fills that
  * gap so that invite share links can be generated.
  */
 export async function ensureTelegramBotUsernameResolved(): Promise<void> {
-  const meta = getCredentialMetadata("telegram", "bot_token");
-  if (
-    meta?.accountInfo &&
-    typeof meta.accountInfo === "string" &&
-    meta.accountInfo.trim().length > 0
-  ) {
-    return; // Username already cached
+  if (getTelegramBotUsername()) {
+    return; // Username already cached in config
   }
 
   const token = getSecureKey("credential:telegram:bot_token");
@@ -91,9 +72,11 @@ export async function ensureTelegramBotUsernameResolved(): Promise<void> {
       );
       return;
     }
-    upsertCredentialMetadata("telegram", "bot_token", {
-      accountInfo: username,
-    });
+    // Write to config
+    const raw = loadRawConfig();
+    setNestedValue(raw, "telegram.botUsername", username);
+    saveRawConfig(raw);
+    invalidateConfigCache();
   } catch (err) {
     getLogger("telegram-invite").warn(
       { err },

package/src/runtime/channel-invite-transports/voice.ts

@@ -22,7 +22,7 @@ import type {
 // ---------------------------------------------------------------------------
 
 export const voiceInviteAdapter: ChannelInviteAdapter = {
-  channel: "voice" as ChannelId,
+  channel: "phone" as ChannelId,
 
   buildShareLink(_params: {
     rawToken: string;