@vellumai/assistant 0.4.2 → 0.4.4

package/src/runtime/guardian-reply-router.ts

@@ -21,13 +21,20 @@ import {
   applyCanonicalGuardianDecision,
   type CanonicalDecisionResult,
 } from '../approvals/guardian-decision-primitive.js';
-import type { ActorContext, ChannelDeliveryContext } from '../approvals/guardian-request-resolvers.js';
+import type { ActorContext, ChannelDeliveryContext, ResolverEmissionContext } from '../approvals/guardian-request-resolvers.js';
 import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
   getCanonicalGuardianRequestByCode,
   listCanonicalGuardianRequests,
 } from '../memory/canonical-guardian-store.js';
+import {
+  buildGuardianCodeOnlyClarification,
+  buildGuardianDisambiguationExample,
+  buildGuardianDisambiguationLabel,
+  buildGuardianInvalidActionReply,
+  resolveGuardianInstructionModeForRequest,
+} from '../notifications/guardian-question-mode.js';
 import { getLogger } from '../util/logger.js';
 import { runApprovalConversationTurn } from './approval-conversation-turn.js';
 import type { ApprovalAction } from './channel-approval-types.js';
@@ -60,6 +67,8 @@ export interface GuardianReplyContext {
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Optional channel delivery context for resolver-driven side effects. */
   channelDeliveryContext?: ChannelDeliveryContext;
+  /** Optional emission context threaded to handleConfirmationResponse for correct source attribution. */
+  emissionContext?: ResolverEmissionContext;
 }
 
 export type GuardianReplyResultType =
@@ -235,9 +244,11 @@ function notConsumed(): GuardianReplyResult {
 export async function routeGuardianReply(
   ctx: GuardianReplyContext,
 ): Promise<GuardianReplyResult> {
-  const { messageText, actor, conversationId, callbackData, approvalConversationGenerator, channelDeliveryContext } = ctx;
+  const { messageText, actor, conversationId, callbackData, approvalConversationGenerator, channelDeliveryContext, emissionContext } = ctx;
   const pendingRequests = findPendingCanonicalRequests(actor, ctx.pendingRequestIds, conversationId);
-  const scopedPendingRequestIds = ctx.pendingRequestIds ? new Set(ctx.pendingRequestIds) : null;
+  const scopedPendingRequestIds = ctx.pendingRequestIds && ctx.pendingRequestIds.length > 0
+    ? new Set(ctx.pendingRequestIds)
+    : null;
 
   // ── 1. Deterministic callback parsing (button presses) ──
   // No conversationId scoping here — the guardian's reply comes from a
@@ -247,7 +258,7 @@ export async function routeGuardianReply(
   if (callbackData) {
     const parsed = parseCallbackAction(callbackData);
     if (parsed) {
-      return applyDecision(parsed.requestId, parsed.action, actor, undefined, channelDeliveryContext);
+      return applyDecision(parsed.requestId, parsed.action, actor, undefined, channelDeliveryContext, emissionContext);
     }
   }
 
@@ -280,7 +291,7 @@ export async function routeGuardianReply(
           consumed: true,
           type: 'canonical_decision_stale',
           requestId: request.id,
-          replyText: failureReplyText('already_resolved', request.requestCode),
+          replyText: failureReplyText('already_resolved', request.requestCode, request),
         };
       }
 
@@ -333,7 +344,7 @@ export async function routeGuardianReply(
       // If the text indicates rejection, use reject; otherwise approve_once.
       const action = inferActionFromText(codeResult.remainingText);
 
-      return applyDecision(request.id, action, actor, codeResult.remainingText, channelDeliveryContext);
+      return applyDecision(request.id, action, actor, codeResult.remainingText, channelDeliveryContext, emissionContext);
     }
   }
 
@@ -375,6 +386,7 @@ export async function routeGuardianReply(
           actor,
           messageText,
           channelDeliveryContext,
+          emissionContext,
         );
       }
 
@@ -475,12 +487,13 @@ export async function routeGuardianReply(
       };
     }
 
-    const result = await applyDecision(targetId, decisionAction, actor, messageText, channelDeliveryContext);
+    const result = await applyDecision(targetId, decisionAction, actor, messageText, channelDeliveryContext, emissionContext);
 
     // Attach the engine's reply text for stale/expired/identity-mismatch cases,
-    // but preserve the explicit failure text when the resolver failed — the engine
-    // reply is typically an affirmative confirmation that would be misleading.
-    if (engineResult.replyText && result.type !== 'canonical_resolver_failed') {
+    // but preserve resolver-authored replies (for example verification codes)
+    // and explicit resolver-failure text.
+    const hasResolverReplyText = Boolean(result.canonicalResult?.applied && result.canonicalResult.resolverReplyText);
+    if (engineResult.replyText && result.type !== 'canonical_resolver_failed' && !hasResolverReplyText) {
       result.replyText = engineResult.replyText;
     }
 
@@ -504,6 +517,7 @@ async function applyDecision(
   actor: ActorContext,
   userText?: string,
   channelDeliveryContext?: ChannelDeliveryContext,
+  emissionContext?: ResolverEmissionContext,
 ): Promise<GuardianReplyResult> {
   const canonicalResult = await applyCanonicalGuardianDecision({
     requestId,
@@ -511,6 +525,7 @@ async function applyDecision(
     actorContext: actor,
     userText,
     channelDeliveryContext,
+    emissionContext,
   });
 
   if (canonicalResult.applied) {
@@ -549,6 +564,7 @@ async function applyDecision(
       decisionApplied: true,
       consumed: true,
       type: 'canonical_decision_applied',
+      ...(canonicalResult.resolverReplyText ? { replyText: canonicalResult.resolverReplyText } : {}),
       requestId,
       canonicalResult,
     };
@@ -570,13 +586,15 @@ async function applyDecision(
     return notConsumed();
   }
 
+  const request = getCanonicalGuardianRequest(requestId);
+
   return {
     decisionApplied: false,
     consumed: true,
     type: 'canonical_decision_stale',
     requestId,
     canonicalResult,
-    replyText: failureReplyText(canonicalResult.reason),
+    replyText: failureReplyText(canonicalResult.reason, request?.requestCode, request ?? undefined),
   };
 }
 
@@ -643,6 +661,12 @@ function inferActionFromText(text: string): ApprovalAction {
   return 'approve_once';
 }
 
+function resolveRequestInstructionMode(
+  request?: Pick<CanonicalGuardianRequest, 'kind' | 'toolName'> | null,
+): 'approval' | 'answer' {
+  return resolveGuardianInstructionModeForRequest(request);
+}
+
 // ---------------------------------------------------------------------------
 // Failure reason reply text
 // ---------------------------------------------------------------------------
@@ -653,7 +677,11 @@ type CanonicalFailureReason = 'already_resolved' | 'identity_mismatch' | 'invali
  * Map a canonical decision failure reason to a distinct, actionable reply
  * so the guardian understands exactly what happened and what to do next.
  */
-function failureReplyText(reason: CanonicalFailureReason, requestCode?: string | null): string {
+function failureReplyText(
+  reason: CanonicalFailureReason,
+  requestCode?: string | null,
+  request?: CanonicalGuardianRequest,
+): string {
   switch (reason) {
     case 'already_resolved':
       return 'This request has already been resolved.';
@@ -662,9 +690,7 @@ function failureReplyText(reason: CanonicalFailureReason, requestCode?: string |
     case 'identity_mismatch':
       return "You don't have permission to decide on this request.";
     case 'invalid_action':
-      return requestCode
-        ? `I found request ${requestCode}, but I need to know your decision. Reply "${requestCode} approve" or "${requestCode} reject".`
-        : "I couldn't determine your intended action. Reply with the request code followed by 'approve' or 'reject' (e.g., \"ABC123 approve\").";
+      return buildGuardianInvalidActionReply(resolveRequestInstructionMode(request), requestCode ?? undefined);
     default:
       return "I couldn't process that request. Please try again.";
   }
@@ -681,15 +707,12 @@ function failureReplyText(reason: CanonicalFailureReason, requestCode?: string |
  */
 function composeCodeOnlyClarification(request: CanonicalGuardianRequest): string {
   const code = request.requestCode ?? 'unknown';
-  const toolLabel = request.toolName ?? 'an action';
-  const lines: string[] = [
-    `I found request ${code} for ${toolLabel}.`,
-  ];
-  if (request.questionText) {
-    lines.push(`Details: ${request.questionText}`);
-  }
-  lines.push(`Reply "${code} approve" to approve or "${code} reject" to reject.`);
-  return lines.join('\n');
+  const mode = resolveRequestInstructionMode(request);
+  return buildGuardianCodeOnlyClarification(mode, {
+    requestCode: code,
+    questionText: request.questionText,
+    toolName: request.toolName,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -706,6 +729,10 @@ function composeDisambiguationReply(
   engineReplyText?: string,
 ): string {
   const lines: string[] = [];
+  const requestsWithMode = pendingRequests.map((request) => ({
+    request,
+    mode: resolveRequestInstructionMode(request),
+  }));
 
   if (engineReplyText) {
     lines.push(engineReplyText);
@@ -714,16 +741,26 @@ function composeDisambiguationReply(
 
   lines.push(`You have ${pendingRequests.length} pending requests. Please specify which one:`);
 
-  for (const req of pendingRequests) {
-    const toolLabel = req.toolName ?? 'action';
-    const code = req.requestCode ?? req.id.slice(0, 6).toUpperCase();
+  for (const { request, mode } of requestsWithMode) {
+    const toolLabel = buildGuardianDisambiguationLabel(mode, {
+      questionText: request.questionText,
+      toolName: request.toolName,
+    });
+    const code = request.requestCode ?? request.id.slice(0, 6).toUpperCase();
     lines.push(`  - ${code}: ${toolLabel}`);
   }
 
-  // Include a concrete example using the first request's code
-  const exampleCode = pendingRequests[0].requestCode ?? pendingRequests[0].id.slice(0, 6).toUpperCase();
+  const questionRequest = requestsWithMode.find(({ mode }) => mode === 'answer');
+  const decisionRequest = requestsWithMode.find(({ mode }) => mode === 'approval');
   lines.push('');
-  lines.push(`Reply "${exampleCode} approve" to approve a specific request.`);
+  if (questionRequest) {
+    const exampleCode = questionRequest.request.requestCode ?? questionRequest.request.id.slice(0, 6).toUpperCase();
+    lines.push(buildGuardianDisambiguationExample(questionRequest.mode, exampleCode));
+  }
+  if (decisionRequest) {
+    const exampleCode = decisionRequest.request.requestCode ?? decisionRequest.request.id.slice(0, 6).toUpperCase();
+    lines.push(buildGuardianDisambiguationExample(decisionRequest.mode, exampleCode));
+  }
 
   return lines.join('\n');
 }

package/src/runtime/guardian-vellum-migration.ts

@@ -0,0 +1,57 @@
+/**
+ * Startup migration: backfill channel='vellum' guardian binding.
+ *
+ * On runtime start, ensures that a guardian binding exists for the
+ * 'vellum' channel with a guardianPrincipalId. This is required for
+ * the identity-bound hatch bootstrap flow.
+ *
+ * - If a vellum binding already exists, no-op.
+ * - If no vellum binding exists, creates one with a fresh principal.
+ * - Preserves existing guardian bindings for other channels unchanged.
+ */
+
+import { v4 as uuid } from 'uuid';
+
+import {
+  createBinding,
+  getActiveBinding,
+} from '../memory/guardian-bindings.js';
+import { getLogger } from '../util/logger.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from './assistant-scope.js';
+
+const log = getLogger('guardian-vellum-migration');
+
+/**
+ * Ensure a vellum guardian binding exists for the given assistant.
+ * Called during daemon startup to backfill existing installations.
+ *
+ * Returns the guardianPrincipalId (existing or newly created).
+ */
+export function ensureVellumGuardianBinding(assistantId: string = DAEMON_INTERNAL_ASSISTANT_ID): string {
+  const existing = getActiveBinding(assistantId, 'vellum');
+  if (existing) {
+    log.debug(
+      { assistantId, guardianPrincipalId: existing.guardianExternalUserId },
+      'Vellum guardian binding already exists',
+    );
+    return existing.guardianExternalUserId;
+  }
+
+  const guardianPrincipalId = `vellum-principal-${uuid()}`;
+
+  createBinding({
+    assistantId,
+    channel: 'vellum',
+    guardianExternalUserId: guardianPrincipalId,
+    guardianDeliveryChatId: 'local',
+    verifiedVia: 'startup-migration',
+    metadataJson: JSON.stringify({ migratedAt: Date.now() }),
+  });
+
+  log.info(
+    { assistantId, guardianPrincipalId },
+    'Backfilled vellum guardian binding on startup',
+  );
+
+  return guardianPrincipalId;
+}

package/src/runtime/http-server.ts

@@ -40,6 +40,7 @@ import { consumeCallback, consumeCallbackError } from '../security/oauth-callbac
 import { getLogger } from '../util/logger.js';
 import { buildAssistantEvent } from './assistant-event.js';
 import { assistantEventHub } from './assistant-event-hub.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from './assistant-scope.js';
 import { sweepFailedEvents } from './channel-retry-sweep.js';
 import { httpError } from './http-errors.js';
 // Middleware
@@ -86,6 +87,7 @@ import {
   handleGetAttachmentContent,
   handleUploadAttachment,
 } from './routes/attachment-routes.js';
+import { handleGetBrainGraph, handleServeBrainGraphUI, handleServeHomeBaseUI } from './routes/brain-graph-routes.js';
 import {
   handleAnswerCall,
   handleCancelCall,
@@ -97,7 +99,10 @@ import {
   startCanonicalGuardianExpirySweep,
   stopCanonicalGuardianExpirySweep,
 } from './routes/canonical-guardian-expiry-sweep.js';
-import { canonicalChannelAssistantId } from './routes/channel-route-shared.js';
+import {
+  handleGetChannelReadiness,
+  handleRefreshChannelReadiness,
+} from './routes/channel-readiness-routes.js';
 import {
   handleChannelDeliveryAck,
   handleChannelInbound,
@@ -126,6 +131,7 @@ import {
   handleGuardianActionDecision,
   handleGuardianActionsPending,
 } from './routes/guardian-action-routes.js';
+import { handleGuardianBootstrap } from './routes/guardian-bootstrap-routes.js';
 import { handleGetIdentity,handleHealth } from './routes/identity-routes.js';
 import {
   handleBlockMember,
@@ -160,6 +166,21 @@ import {
   handlePairingStatus,
 } from './routes/pairing-routes.js';
 import { handleAddSecret } from './routes/secret-routes.js';
+import {
+  handleAssignTwilioNumber,
+  handleClearTwilioCredentials,
+  handleDeleteTollfreeVerification,
+  handleGetSmsCompliance,
+  handleGetTwilioConfig,
+  handleListTwilioNumbers,
+  handleProvisionTwilioNumber,
+  handleReleaseTwilioNumber,
+  handleSetTwilioCredentials,
+  handleSmsDoctor,
+  handleSmsSendTest,
+  handleSubmitTollfreeVerification,
+  handleUpdateTollfreeVerification,
+} from './routes/twilio-routes.js';
 
 // Re-export for consumers
 export { isPrivateAddress } from './middleware/auth.js';
@@ -270,7 +291,7 @@ export class RuntimeHttpServer {
             ipcBroadcast(msg);
             // Also publish to the event hub so HTTP/SSE clients (e.g. macOS
             // app with localHttpEnabled) receive pairing approval requests.
-            void assistantEventHub.publish(buildAssistantEvent('self', msg));
+            void assistantEventHub.publish(buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, msg));
           }
         : undefined,
     };
@@ -445,7 +466,7 @@ export class RuntimeHttpServer {
         return rateLimitResponse(result);
       }
       // Attach rate limit headers to the eventual response
-      const originalResponse = await this.handleAuthenticatedRequest(req, url, path);
+      const originalResponse = await this.handleAuthenticatedRequest(req, url, path, server);
       const headers = new Headers(originalResponse.headers);
       for (const [k, v] of Object.entries(rateLimitHeaders(result))) {
         headers.set(k, v);
@@ -457,13 +478,13 @@ export class RuntimeHttpServer {
       });
     }
 
-    return this.handleAuthenticatedRequest(req, url, path);
+    return this.handleAuthenticatedRequest(req, url, path, server);
   }
 
   /**
    * Handle requests that have already passed auth and rate limiting.
    */
-  private async handleAuthenticatedRequest(req: Request, url: URL, path: string): Promise<Response> {
+  private async handleAuthenticatedRequest(req: Request, url: URL, path: string, server: ReturnType<typeof Bun.serve>): Promise<Response> {
     // Pairing registration (bearer-authenticated)
     if (path === '/v1/pairing/register' && req.method === 'POST') {
       return await handlePairingRegister(req, this.pairingContext);
@@ -521,22 +542,13 @@ export class RuntimeHttpServer {
       }
     }
 
-    // New assistant-less runtime routes: /v1/<endpoint>
-    const newRouteMatch = path.match(/^\/v1\/(?!assistants\/)(.+)$/);
-    if (newRouteMatch) {
-      return this.dispatchEndpoint(newRouteMatch[1], req, url);
-    }
-
-    // Legacy: /v1/assistants/:assistantId/<endpoint>
-    const match = path.match(/^\/v1\/assistants\/([^/]+)\/(.+)$/);
-    if (!match) {
-      return httpError('NOT_FOUND', 'Not found', 404);
+    // Runtime routes: /v1/<endpoint>
+    const routeMatch = path.match(/^\/v1\/(.+)$/);
+    if (routeMatch) {
+      return this.dispatchEndpoint(routeMatch[1], req, url, server);
     }
 
-    const assistantId = canonicalChannelAssistantId(match[1]);
-    const endpoint = match[2];
-    log.warn({ endpoint, assistantId }, '[deprecated] /v1/assistants/:assistantId/... route used; migrate to /v1/...');
-    return this.dispatchEndpoint(endpoint, req, url, assistantId);
+    return httpError('NOT_FOUND', 'Not found', 404);
   }
 
   private handleBrowserRelayUpgrade(req: Request, server: ReturnType<typeof Bun.serve>): Response {
@@ -616,8 +628,9 @@ export class RuntimeHttpServer {
     endpoint: string,
     req: Request,
     url: URL,
-    assistantId: string = 'self',
+    server: ReturnType<typeof Bun.serve>,
   ): Promise<Response> {
+    const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
     return withErrorHandling(endpoint, async () => {
       if (endpoint === 'health' && req.method === 'GET') return handleHealth();
       if (endpoint === 'debug' && req.method === 'GET') return handleDebug();
@@ -690,7 +703,7 @@ export class RuntimeHttpServer {
         try {
           recordConversationSeenSignal({
             conversationId,
-            assistantId: 'self',
+            assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
             sourceChannel: (body.sourceChannel as string) ?? 'vellum',
             signalType: (body.signalType as string ?? 'macos_conversation_opened') as SignalType,
             confidence: (body.confidence as string ?? 'explicit') as Confidence,
@@ -715,18 +728,18 @@ export class RuntimeHttpServer {
           persistAndProcessMessage: this.persistAndProcessMessage,
           sendMessageDeps: this.sendMessageDeps,
           approvalConversationGenerator: this.approvalConversationGenerator,
-        });
+        }, server);
       }
 
       // Standalone approval endpoints — keyed by requestId, orthogonal to message sending
-      if (endpoint === 'confirm' && req.method === 'POST') return await handleConfirm(req);
-      if (endpoint === 'secret' && req.method === 'POST') return await handleSecret(req);
-      if (endpoint === 'trust-rules' && req.method === 'POST') return await handleTrustRule(req);
-      if (endpoint === 'pending-interactions' && req.method === 'GET') return handleListPendingInteractions(url);
+      if (endpoint === 'confirm' && req.method === 'POST') return await handleConfirm(req, server);
+      if (endpoint === 'secret' && req.method === 'POST') return await handleSecret(req, server);
+      if (endpoint === 'trust-rules' && req.method === 'POST') return await handleTrustRule(req, server);
+      if (endpoint === 'pending-interactions' && req.method === 'GET') return handleListPendingInteractions(url, req, server);
 
       // Guardian action endpoints — deterministic button-based decisions
-      if (endpoint === 'guardian-actions/pending' && req.method === 'GET') return handleGuardianActionsPending(req);
-      if (endpoint === 'guardian-actions/decision' && req.method === 'POST') return await handleGuardianActionDecision(req);
+      if (endpoint === 'guardian-actions/pending' && req.method === 'GET') return handleGuardianActionsPending(req, server);
+      if (endpoint === 'guardian-actions/decision' && req.method === 'POST') return await handleGuardianActionDecision(req, server);
 
       // Contacts
       if (endpoint === 'contacts' && req.method === 'GET') return handleListContacts(url);
@@ -768,6 +781,34 @@ export class RuntimeHttpServer {
       if (endpoint === 'integrations/guardian/outbound/resend' && req.method === 'POST') return await handleResendOutbound(req);
       if (endpoint === 'integrations/guardian/outbound/cancel' && req.method === 'POST') return await handleCancelOutbound(req);
 
+      // Guardian vellum channel bootstrap
+      if (endpoint === 'integrations/guardian/vellum/bootstrap' && req.method === 'POST') return await handleGuardianBootstrap(req, server);
+
+      // Integrations — Twilio config
+      if (endpoint === 'integrations/twilio/config' && req.method === 'GET') return handleGetTwilioConfig();
+      if (endpoint === 'integrations/twilio/credentials' && req.method === 'POST') return await handleSetTwilioCredentials(req);
+      if (endpoint === 'integrations/twilio/credentials' && req.method === 'DELETE') return handleClearTwilioCredentials();
+      if (endpoint === 'integrations/twilio/numbers' && req.method === 'GET') return await handleListTwilioNumbers();
+      if (endpoint === 'integrations/twilio/numbers/provision' && req.method === 'POST') return await handleProvisionTwilioNumber(req);
+      if (endpoint === 'integrations/twilio/numbers/assign' && req.method === 'POST') return await handleAssignTwilioNumber(req);
+      if (endpoint === 'integrations/twilio/numbers/release' && req.method === 'POST') return await handleReleaseTwilioNumber(req);
+      if (endpoint === 'integrations/twilio/sms/compliance' && req.method === 'GET') return await handleGetSmsCompliance();
+      if (endpoint === 'integrations/twilio/sms/compliance/tollfree' && req.method === 'POST') return await handleSubmitTollfreeVerification(req);
+      if (endpoint === 'integrations/twilio/sms/test' && req.method === 'POST') return await handleSmsSendTest(req);
+      if (endpoint === 'integrations/twilio/sms/doctor' && req.method === 'POST') return await handleSmsDoctor();
+
+      // Twilio toll-free verification PATCH/DELETE with :verificationSid
+      const tollfreeVerificationMatch = endpoint.match(/^integrations\/twilio\/sms\/compliance\/tollfree\/([^/]+)$/);
+      if (tollfreeVerificationMatch) {
+        const verificationSid = tollfreeVerificationMatch[1];
+        if (req.method === 'PATCH') return await handleUpdateTollfreeVerification(req, verificationSid);
+        if (req.method === 'DELETE') return await handleDeleteTollfreeVerification(verificationSid);
+      }
+
+      // Channel readiness
+      if (endpoint === 'channels/readiness' && req.method === 'GET') return await handleGetChannelReadiness(url);
+      if (endpoint === 'channels/readiness/refresh' && req.method === 'POST') return await handleRefreshChannelReadiness(req);
+
       if (endpoint === 'attachments' && req.method === 'POST') return await handleUploadAttachment(req);
       if (endpoint === 'attachments' && req.method === 'DELETE') return await handleDeleteAttachment(req);
 
@@ -813,11 +854,11 @@ export class RuntimeHttpServer {
 
       // Internal Twilio forwarding endpoints (gateway -> runtime)
       if (endpoint === 'internal/twilio/voice-webhook' && req.method === 'POST') {
-        const json = await req.json() as { params: Record<string, string>; originalUrl?: string; assistantId?: string };
+        const json = await req.json() as { params: Record<string, string>; originalUrl?: string };
         const formBody = new URLSearchParams(json.params).toString();
         const reconstructedUrl = json.originalUrl ?? req.url;
         const fakeReq = new Request(reconstructedUrl, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: formBody });
-        return await handleVoiceWebhook(fakeReq, json.assistantId);
+        return await handleVoiceWebhook(fakeReq);
       }
 
       if (endpoint === 'internal/twilio/status' && req.method === 'POST') {
@@ -835,7 +876,10 @@ export class RuntimeHttpServer {
       }
 
       if (endpoint === 'identity' && req.method === 'GET') return handleGetIdentity();
-      if (endpoint === 'events' && req.method === 'GET') return handleSubscribeAssistantEvents(req, url);
+      if (endpoint === 'brain-graph' && req.method === 'GET') return handleGetBrainGraph();
+      if (endpoint === 'brain-graph-ui' && req.method === 'GET') return handleServeBrainGraphUI(this.bearerToken);
+      if (endpoint === 'home-base-ui' && req.method === 'GET') return handleServeHomeBaseUI(this.bearerToken);
+      if (endpoint === 'events' && req.method === 'GET') return handleSubscribeAssistantEvents(req, url, { server });
 
       // Internal OAuth callback endpoint (gateway -> runtime)
       if (endpoint === 'internal/oauth/callback' && req.method === 'POST') {

package/src/runtime/http-types.ts

@@ -1,6 +1,10 @@
 /**
  * Shared types for the runtime HTTP server and its route handlers.
  */
+import type {
+  CallPointerMessageContext,
+  ComposeCallPointerMessageOptions,
+} from '../calls/call-pointer-message-composer.js';
 import type { ChannelId, InterfaceId } from '../channels/types.js';
 import type { Session } from '../daemon/session.js';
 import type { GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
@@ -55,6 +59,15 @@ export type ApprovalConversationGenerator = (
   context: ApprovalConversationContext,
 ) => Promise<ApprovalConversationResult>;
 
+/**
+ * Daemon-injected function that generates call pointer copy using a provider.
+ * Returns generated text or `null` on failure (caller falls back to deterministic text).
+ */
+export type PointerCopyGenerator = (
+  context: CallPointerMessageContext,
+  options?: ComposeCallPointerMessageOptions,
+) => Promise<string | null>;
+
 /**
  * Daemon-injected function that generates guardian action copy using a provider.
  * Returns generated text or `null` on failure (caller falls back to deterministic text).

package/src/runtime/ingress-service.ts

@@ -57,6 +57,8 @@ export interface InviteResponseData {
   expectedExternalUserId?: string;
   voiceCode?: string;
   voiceCodeDigits?: number;
+  friendName?: string;
+  guardianName?: string;
   createdAt: number;
 }
 
@@ -110,6 +112,8 @@ function inviteToResponse(inv: IngressInvite, opts?: { rawToken?: string; voiceC
     ...(inv.expectedExternalUserId ? { expectedExternalUserId: inv.expectedExternalUserId } : {}),
     ...(opts?.voiceCode ? { voiceCode: opts.voiceCode } : {}),
     ...(inv.voiceCodeDigits != null ? { voiceCodeDigits: inv.voiceCodeDigits } : {}),
+    ...(inv.friendName ? { friendName: inv.friendName } : {}),
+    ...(inv.guardianName ? { guardianName: inv.guardianName } : {}),
     createdAt: inv.createdAt,
   };
 }
@@ -149,6 +153,8 @@ export function createIngressInvite(params: {
   // Voice invite parameters
   expectedExternalUserId?: string;
   voiceCodeDigits?: number;
+  friendName?: string;
+  guardianName?: string;
 }): IngressResult<InviteResponseData> {
   if (!params.sourceChannel) {
     return { ok: false, error: 'sourceChannel is required for create' };
@@ -168,6 +174,12 @@ export function createIngressInvite(params: {
     if (!isValidE164(params.expectedExternalUserId)) {
       return { ok: false, error: 'expectedExternalUserId must be in E.164 format (e.g., +15551234567)' };
     }
+    if (typeof params.friendName !== 'string' || !params.friendName.trim()) {
+      return { ok: false, error: 'friendName is required for voice invites' };
+    }
+    if (typeof params.guardianName !== 'string' || !params.guardianName.trim()) {
+      return { ok: false, error: 'guardianName is required for voice invites' };
+    }
     voiceCode = generateVoiceCode(6);
     voiceCodeHash = hashVoiceCode(voiceCode);
   }
@@ -181,6 +193,8 @@ export function createIngressInvite(params: {
       expectedExternalUserId: params.expectedExternalUserId,
       voiceCodeHash,
       voiceCodeDigits: 6,
+      friendName: params.friendName,
+      guardianName: params.guardianName,
     } : {}),
   });
   // Voice invites must not expose the token — callers must redeem via the

package/src/runtime/invite-redemption-service.ts

@@ -13,6 +13,7 @@ import { findActiveVoiceInvites,findByTokenHash, hashToken, markInviteExpired, r
 import { findMember, upsertMember } from '../memory/ingress-member-store.js';
 import { canonicalizeInboundIdentity } from '../util/canonicalize-identity.js';
 import { hashVoiceCode } from '../util/voice-code.js';
+import { DAEMON_INTERNAL_ASSISTANT_ID } from './assistant-scope.js';
 
 // ---------------------------------------------------------------------------
 // Outcome type
@@ -223,7 +224,7 @@ export function redeemVoiceInviteCode(params: {
   sourceChannel: 'voice';
   code: string;
 }): VoiceRedemptionOutcome {
-  const { assistantId = 'self', callerExternalUserId, code } = params;
+  const { assistantId = DAEMON_INTERNAL_ASSISTANT_ID, callerExternalUserId, code } = params;
 
   if (!callerExternalUserId) {
     return { ok: false, reason: 'invalid_or_expired' };
@@ -285,12 +286,20 @@ export function redeemVoiceInviteCode(params: {
   const STALE_INVITE = Symbol('stale_invite');
   let memberId: string | undefined;
 
+  // Reactivation should not overwrite a guardian-managed nickname (same
+  // protection as the token-based redemption path above).
+  const preservedDisplayName = existingMember?.displayName?.trim().length
+    ? existingMember.displayName
+    : (invite.friendName ?? undefined);
+
   try {
     getSqlite().transaction(() => {
       const member = upsertMember({
         assistantId: invite.assistantId,
         sourceChannel: 'voice',
         externalUserId: callerExternalUserId,
+        externalChatId: callerExternalUserId,
+        displayName: preservedDisplayName,
         status: 'active',
         policy: 'allow',
         inviteId: invite.id,