@vellumai/assistant 0.3.14 → 0.3.16

package/src/__tests__/update-bulletin.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// --- In-memory checkpoint store ---
+const store = new Map<string, string>();
+
+mock.module('../memory/checkpoints.js', () => ({
+  getMemoryCheckpoint: mock((key: string) => store.get(key) ?? null),
+  setMemoryCheckpoint: mock((key: string, value: string) => store.set(key, value)),
+}));
+
+// --- Temp directory for workspace paths ---
+let tempDir: string;
+
+// Mock platform to avoid env-registry transitive imports.
+// All needed exports are stubbed; getWorkspacePromptPath is the only one
+// exercised by update-bulletin.ts.
+mock.module('../util/platform.js', () => ({
+  getWorkspacePromptPath: mock((file: string) => join(tempDir, file)),
+  getWorkspaceDir: () => tempDir,
+  getRootDir: () => tempDir,
+  getDataDir: () => join(tempDir, 'data'),
+  getPlatformName: () => 'darwin',
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+  ensureDataDir: () => {},
+  getDbPath: () => '',
+  getLogPath: () => '',
+  getHistoryPath: () => '',
+  getHooksDir: () => '',
+  getSocketPath: () => '',
+  getSessionTokenPath: () => '',
+  getHttpTokenPath: () => '',
+  getPlatformTokenPath: () => '',
+  getPidPath: () => '',
+  getWorkspaceConfigPath: () => '',
+  getWorkspaceSkillsDir: () => '',
+  getWorkspaceHooksDir: () => '',
+  getIpcBlobDir: () => '',
+  getSandboxRootDir: () => '',
+  getSandboxWorkingDir: () => '',
+  getInterfacesDir: () => '',
+  getClipboardCommand: () => null,
+  readLockfile: () => null,
+  normalizeAssistantId: (id: string) => id,
+  writeLockfile: () => {},
+  readPlatformToken: () => null,
+  readSessionToken: () => null,
+  readHttpToken: () => null,
+  removeSocketFile: () => {},
+  getTCPPort: () => 8765,
+  isTCPEnabled: () => false,
+  getTCPHost: () => '127.0.0.1',
+  isIOSPairingEnabled: () => false,
+  migrateToDataLayout: () => {},
+  migratePath: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+// Mock system-prompt to provide only stripCommentLines without pulling in
+// the rest of the system-prompt transitive dependency tree.
+mock.module('../config/system-prompt.js', () => {
+  // Inline a minimal implementation of stripCommentLines matching production behavior.
+  function stripCommentLines(content: string): string {
+    const normalized = content.replace(/\r\n/g, '\n');
+    let openFenceChar: string | null = null;
+    const filtered = normalized.split('\n').filter((line) => {
+      const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+      if (fenceMatch) {
+        const char = fenceMatch[1][0];
+        if (!openFenceChar) {
+          openFenceChar = char;
+        } else if (char === openFenceChar) {
+          openFenceChar = null;
+        }
+      }
+      if (openFenceChar) return true;
+      return !line.trimStart().startsWith('_');
+    });
+    return filtered
+      .join('\n')
+      .replace(/\n{3,}/g, '\n\n')
+      .trim();
+  }
+  return { stripCommentLines };
+});
+
+mock.module('../version.js', () => ({
+  APP_VERSION: '1.0.0',
+}));
+
+const { syncUpdateBulletinOnStartup } = await import('../config/update-bulletin.js');
+
+describe('syncUpdateBulletinOnStartup', () => {
+  beforeEach(() => {
+    store.clear();
+    tempDir = join(tmpdir(), `update-bulletin-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates workspace file on first eligible run', () => {
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    expect(existsSync(workspacePath)).toBe(false);
+
+    syncUpdateBulletinOnStartup();
+
+    expect(existsSync(workspacePath)).toBe(true);
+    const content = readFileSync(workspacePath, 'utf-8');
+    expect(content).toContain('<!-- vellum-update-release:1.0.0 -->');
+    expect(content).toContain("What's New");
+  });
+
+  it('appends release block when workspace file exists without current marker', () => {
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    const preExisting = '<!-- vellum-update-release:0.9.0 -->\nOld release notes.\n';
+    writeFileSync(workspacePath, preExisting, 'utf-8');
+
+    syncUpdateBulletinOnStartup();
+
+    const content = readFileSync(workspacePath, 'utf-8');
+    expect(content).toContain('<!-- vellum-update-release:0.9.0 -->');
+    expect(content).toContain('<!-- vellum-update-release:1.0.0 -->');
+    expect(content).toContain('Old release notes.');
+  });
+
+  it('does not duplicate same marker on repeated runs', () => {
+    syncUpdateBulletinOnStartup();
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    const afterFirst = readFileSync(workspacePath, 'utf-8');
+
+    syncUpdateBulletinOnStartup();
+    const afterSecond = readFileSync(workspacePath, 'utf-8');
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  it('skips completed release', () => {
+    store.set('updates:completed_releases', JSON.stringify(['1.0.0']));
+    const workspacePath = join(tempDir, 'UPDATES.md');
+
+    syncUpdateBulletinOnStartup();
+
+    expect(existsSync(workspacePath)).toBe(false);
+  });
+
+  it('adds current release to active set', () => {
+    syncUpdateBulletinOnStartup();
+
+    const raw = store.get('updates:active_releases');
+    expect(raw).toBeDefined();
+    const active: string[] = JSON.parse(raw!);
+    expect(active).toContain('1.0.0');
+  });
+
+  it('marks active releases as completed when UPDATES.md is deleted', () => {
+    // Pre-populate active releases in the store
+    store.set('updates:active_releases', JSON.stringify(['0.8.0', '0.9.0']));
+
+    // Workspace file does not exist — simulates the assistant having deleted it
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    expect(existsSync(workspacePath)).toBe(false);
+
+    syncUpdateBulletinOnStartup();
+
+    // Active set should be cleared (except for the newly-added current release)
+    const activeRaw = store.get('updates:active_releases');
+    expect(activeRaw).toBeDefined();
+    const active: string[] = JSON.parse(activeRaw!);
+    // The old releases should not be in the active set
+    expect(active).not.toContain('0.8.0');
+    expect(active).not.toContain('0.9.0');
+
+    // The old releases should now be completed
+    const completedRaw = store.get('updates:completed_releases');
+    expect(completedRaw).toBeDefined();
+    const completed: string[] = JSON.parse(completedRaw!);
+    expect(completed).toContain('0.8.0');
+    expect(completed).toContain('0.9.0');
+  });
+
+  it('does not recreate completed release after deletion', () => {
+    // First run — creates the workspace file and marks 1.0.0 active
+    syncUpdateBulletinOnStartup();
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    expect(existsSync(workspacePath)).toBe(true);
+
+    // Simulate assistant deleting the file to signal completion
+    rmSync(workspacePath);
+    expect(existsSync(workspacePath)).toBe(false);
+
+    // Second run — deletion-completion should mark 1.0.0 completed
+    syncUpdateBulletinOnStartup();
+
+    // The file should NOT be recreated since the release is now completed
+    expect(existsSync(workspacePath)).toBe(false);
+  });
+
+  it('merges pending old block with new release block', () => {
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    // Pre-create workspace file with an old release block
+    const oldContent =
+      '<!-- vellum-update-release:0.9.0 -->\nOld release notes for 0.9.0.\n<!-- /vellum-update-release:0.9.0 -->\n';
+    writeFileSync(workspacePath, oldContent, 'utf-8');
+
+    syncUpdateBulletinOnStartup();
+
+    const content = readFileSync(workspacePath, 'utf-8');
+    // Both old and new release blocks should be present
+    expect(content).toContain('<!-- vellum-update-release:0.9.0 -->');
+    expect(content).toContain('Old release notes for 0.9.0.');
+    expect(content).toContain('<!-- vellum-update-release:1.0.0 -->');
+  });
+
+  it('idempotent on repeated sync calls', () => {
+    // First call
+    syncUpdateBulletinOnStartup();
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    const afterFirst = readFileSync(workspacePath, 'utf-8');
+
+    // Second call
+    syncUpdateBulletinOnStartup();
+    const afterSecond = readFileSync(workspacePath, 'utf-8');
+
+    expect(afterSecond).toBe(afterFirst);
+
+    // Third call for good measure
+    syncUpdateBulletinOnStartup();
+    const afterThird = readFileSync(workspacePath, 'utf-8');
+
+    expect(afterThird).toBe(afterFirst);
+  });
+
+  it('write path produces valid UTF-8 with trailing newline', () => {
+    syncUpdateBulletinOnStartup();
+    const workspacePath = join(tempDir, 'UPDATES.md');
+    const content = readFileSync(workspacePath, 'utf-8');
+
+    expect(content.length).toBeGreaterThan(0);
+    expect(content.endsWith('\n')).toBe(true);
+
+    // Verify round-trip through Buffer produces identical content (valid UTF-8)
+    const roundTripped = Buffer.from(content, 'utf-8').toString('utf-8');
+    expect(roundTripped).toBe(content);
+  });
+
+  it('no temp file leftovers after successful write', () => {
+    syncUpdateBulletinOnStartup();
+
+    const entries = readdirSync(tempDir);
+    const tmpFiles = entries.filter((e) => e.includes('.tmp.'));
+    expect(tmpFiles).toHaveLength(0);
+  });
+});

package/src/__tests__/update-template-contract.test.ts

@@ -0,0 +1,29 @@
+/**
+ * Contract test: ensures the bundled UPDATES.md template exists and meets
+ * the format expectations that the bulletin system depends on at runtime.
+ *
+ * The "## What's New" heading is a structural contract — bulletin rendering
+ * logic expects this section to be present in the template.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, test } from 'bun:test';
+
+const TEMPLATE_PATH = join(import.meta.dirname, '..', 'config', 'templates', 'UPDATES.md');
+
+describe('UPDATES.md template contract', () => {
+  test('template file exists', () => {
+    expect(existsSync(TEMPLATE_PATH)).toBe(true);
+  });
+
+  test('template contains non-whitespace content', () => {
+    const content = readFileSync(TEMPLATE_PATH, 'utf-8');
+    expect(content.trim().length).toBeGreaterThan(0);
+  });
+
+  test('template contains the "## What\'s New" heading', () => {
+    const content = readFileSync(TEMPLATE_PATH, 'utf-8');
+    expect(content).toContain("## What's New");
+  });
+});

package/src/agent/loop.ts

@@ -85,7 +85,7 @@ export class AgentLoop {
 
   async run(
     messages: Message[],
-    onEvent: (event: AgentEvent) => void,
+    onEvent: (event: AgentEvent) => void | Promise<void>,
     signal?: AbortSignal,
     requestId?: string,
     onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
@@ -244,7 +244,7 @@ export class AgentLoop {
         };
         history.push(assistantMessage);
 
-        onEvent({ type: 'message_complete', message: assistantMessage });
+        await onEvent({ type: 'message_complete', message: assistantMessage });
 
         // Check for tool use
         toolUseBlocks = response.content.filter(

package/src/amazon/client.ts

@@ -50,7 +50,7 @@
 
 import type { ExtensionCommand, ExtensionResponse } from '../browser-extension-relay/protocol.js';
 import { extensionRelayServer } from '../browser-extension-relay/server.js';
-import { getRuntimeHttpPort } from '../config/env.js';
+import { getGatewayInternalBaseUrl } from '../config/env.js';
 import type { ExtractedCredential } from '../tools/browser/network-recording-types.js';
 import { readHttpToken } from '../util/platform.js';
 import {
@@ -81,8 +81,7 @@ export async function sendRelayCommand(command: Record<string, unknown>): Promis
     throw new Error('Browser extension relay is not connected and no HTTP token found. Is the daemon running?');
   }
 
-  const port = getRuntimeHttpPort() ?? 7821;
-  const resp = await fetch(`http://127.0.0.1:${port}/v1/browser-relay/command`, {
+  const resp = await fetch(`${getGatewayInternalBaseUrl()}/v1/browser-relay/command`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',

package/src/calls/call-controller.ts

@@ -10,6 +10,11 @@
 
 import type { ServerMessage } from '../daemon/ipc-contract.js';
 import type { GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
+import {
+  getDeliveriesByRequestId,
+  getPendingRequestByCallSessionId,
+  markTimedOutWithReason,
+} from '../memory/guardian-action-store.js';
 import { getLogger } from '../util/logger.js';
 import { getMaxCallDurationMs, getUserConsultationTimeoutMs, SILENCE_TIMEOUT_MS } from './call-constants.js';
 import { persistCallCompletionMessage } from './call-conversation-messages.js';
@@ -22,7 +27,10 @@ import {
   recordCallEvent,
   updateCallSession,
 } from './call-store.js';
+import { getGatewayInternalBaseUrl } from '../config/env.js';
+import { readHttpToken } from '../util/platform.js';
 import { dispatchGuardianQuestion } from './guardian-dispatch.js';
+import { sendGuardianExpiryNotices } from './guardian-action-sweep.js';
 import type { RelayConnection } from './relay-server.js';
 import type { PromptSpeakerContext } from './speaker-identification.js';
 import { startVoiceTurn, type VoiceTurnHandle } from './voice-session-bridge.js';
@@ -38,6 +46,8 @@ const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
 const CALL_OPENING_MARKER_REGEX = /\[CALL_OPENING\]/g;
 const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
 const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
+const GUARDIAN_TIMEOUT_MARKER_REGEX = /\[GUARDIAN_TIMEOUT\]/g;
+const GUARDIAN_UNAVAILABLE_MARKER_REGEX = /\[GUARDIAN_UNAVAILABLE\]/g;
 const CALL_OPENING_MARKER = '[CALL_OPENING]';
 const CALL_OPENING_ACK_MARKER = '[CALL_OPENING_ACK]';
 const END_CALL_MARKER = '[END_CALL]';
@@ -49,7 +59,9 @@ function stripInternalSpeechMarkers(text: string): string {
     .replace(USER_INSTRUCTION_MARKER_REGEX, '')
     .replace(CALL_OPENING_MARKER_REGEX, '')
     .replace(CALL_OPENING_ACK_MARKER_REGEX, '')
-    .replace(END_CALL_MARKER_REGEX, '');
+    .replace(END_CALL_MARKER_REGEX, '')
+    .replace(GUARDIAN_TIMEOUT_MARKER_REGEX, '')
+    .replace(GUARDIAN_UNAVAILABLE_MARKER_REGEX, '');
 }
 
 export class CallController {
@@ -92,6 +104,13 @@ export class CallController {
    * alternation in the underlying session pipeline.
    */
   private lastSentWasOpener = false;
+  /**
+   * Set to true after a guardian consultation timeout occurs in this call.
+   * Subsequent ASK_GUARDIAN attempts skip the full wait and immediately
+   * inject a guardian-unavailable instruction so the model can adapt
+   * without blocking the caller.
+   */
+  private guardianUnavailableForCall = false;
 
   constructor(
     callSessionId: string,
@@ -401,6 +420,8 @@ export class CallController {
             '[CALL_OPENING]'.startsWith(afterBracket) ||
             '[CALL_OPENING_ACK]'.startsWith(afterBracket) ||
             '[END_CALL]'.startsWith(afterBracket) ||
+            '[GUARDIAN_TIMEOUT]'.startsWith(afterBracket) ||
+            '[GUARDIAN_UNAVAILABLE]'.startsWith(afterBracket) ||
             afterBracket.startsWith('[ASK_GUARDIAN:') ||
             afterBracket.startsWith('[USER_ANSWERED:') ||
             afterBracket.startsWith('[USER_INSTRUCTION:') ||
@@ -409,7 +430,11 @@ export class CallController {
             afterBracket === '[CALL_OPENING_ACK' ||
             afterBracket.startsWith('[CALL_OPENING_ACK]') ||
             afterBracket === '[END_CALL' ||
-            afterBracket.startsWith('[END_CALL]');
+            afterBracket.startsWith('[END_CALL]') ||
+            afterBracket === '[GUARDIAN_TIMEOUT' ||
+            afterBracket.startsWith('[GUARDIAN_TIMEOUT]') ||
+            afterBracket === '[GUARDIAN_UNAVAILABLE' ||
+            afterBracket.startsWith('[GUARDIAN_UNAVAILABLE]');
 
           if (!couldBeControl) {
             // Not a control marker prefix — flush up to the next '[' (if any)
@@ -514,6 +539,19 @@ export class CallController {
           log.info({ callSessionId: this.callSessionId }, 'Caller is guardian — skipping ASK_GUARDIAN dispatch, asking directly');
           this.pendingInstructions.push(`You just tried to use [ASK_GUARDIAN] but the person on the phone IS your guardian. Ask them directly: "${questionText}"`);
           // Fall through to normal turn completion (idle + flushPendingInstructions)
+        } else if (this.guardianUnavailableForCall) {
+          // Guardian already timed out earlier in this call — skip the full
+          // consultation wait and immediately tell the model to proceed
+          // without guardian input.
+          log.info({ callSessionId: this.callSessionId }, 'Guardian unavailable for call — skipping ASK_GUARDIAN wait');
+          recordCallEvent(this.callSessionId, 'guardian_unavailable_skipped', { question: questionText });
+          this.pendingInstructions.push(
+            `[GUARDIAN_UNAVAILABLE] You tried to consult your guardian again, but they were already unreachable earlier in this call. `
+            + `Do NOT use [ASK_GUARDIAN] again. Instead, let the caller know you cannot reach the guardian right now, `
+            + `and continue the conversation by asking if there is anything else you can help with or if they would like a callback. `
+            + `The unanswered question was: "${questionText}"`,
+          );
+          // Fall through to normal turn completion (idle + flushPendingInstructions)
         } else {
           const pendingQuestion = createPendingQuestion(this.callSessionId, questionText);
           this.state = 'waiting_on_user';
@@ -536,39 +574,74 @@ export class CallController {
 
           // Set a consultation timeout
           this.consultationTimer = setTimeout(() => {
-            if (this.state === 'waiting_on_user') {
-              log.info({ callSessionId: this.callSessionId }, 'User consultation timed out');
-              this.relay.sendTextToken(
-                'I\'m sorry, I wasn\'t able to get that information in time. Let me move on.',
-                true,
+            if (this.state !== 'waiting_on_user') return;
+
+            log.info({ callSessionId: this.callSessionId }, 'User consultation timed out');
+
+            // Mark the linked guardian action request as timed out and
+            // send expiry notices to guardian destinations. Deliveries
+            // must be captured before markTimedOutWithReason changes
+            // their status.
+            const pendingActionRequest = getPendingRequestByCallSessionId(this.callSessionId);
+            if (pendingActionRequest) {
+              const deliveries = getDeliveriesByRequestId(pendingActionRequest.id);
+              markTimedOutWithReason(pendingActionRequest.id, 'call_timeout');
+              log.info(
+                { callSessionId: this.callSessionId, requestId: pendingActionRequest.id },
+                'Marked guardian action request as timed out',
               );
-              this.state = 'idle';
-              updateCallSession(this.callSessionId, { status: 'in_progress' });
-              expirePendingQuestions(this.callSessionId);
-              // Restart silence detection now that we're back to idle.
-              // flushPendingInstructions / drainPendingCallerUtterances will
-              // reset it again when they start a new turn, but we need the
-              // fallback in case neither queue has work.
-              this.resetSilenceTimer();
-
-              const hasInstructions = this.pendingInstructions.length > 0;
-              const hasUtterances = this.pendingCallerUtterances.length > 0;
-
-              if (hasInstructions && hasUtterances) {
-                // Merge both queues into a single turn to avoid the race where
-                // flushPendingInstructions fires a turn that gets aborted by
-                // drainPendingCallerUtterances, losing the instructions.
-                const instructionPrefix = this.pendingInstructions
-                  .map((instr) => `[USER_INSTRUCTION: ${instr}]`)
-                  .join('\n');
-                this.pendingInstructions = [];
-                this.drainPendingCallerUtterances(instructionPrefix);
-              } else if (hasInstructions) {
-                this.flushPendingInstructions();
-              } else if (hasUtterances) {
-                this.drainPendingCallerUtterances();
+              void sendGuardianExpiryNotices(
+                deliveries,
+                pendingActionRequest.assistantId,
+                getGatewayInternalBaseUrl(),
+                readHttpToken() ?? undefined,
+              ).catch((err) => {
+                log.error(
+                  { err, callSessionId: this.callSessionId, requestId: pendingActionRequest.id },
+                  'Failed to send guardian action expiry notices after call timeout',
+                );
+              });
+            }
+
+            // Expire pending questions and update call state
+            expirePendingQuestions(this.callSessionId);
+            this.state = 'idle';
+            updateCallSession(this.callSessionId, { status: 'in_progress' });
+            this.guardianUnavailableForCall = true;
+            recordCallEvent(this.callSessionId, 'guardian_consultation_timed_out', { question: questionText });
+
+            // Restart silence detection before firing the generated turn
+            this.resetSilenceTimer();
+
+            // Build a generated turn instruction instead of hardcoded text.
+            // Merge any queued instructions and caller utterances into the
+            // timeout turn to avoid concurrent-turn races.
+            const timeoutInstruction =
+              `[GUARDIAN_TIMEOUT] Your guardian did not respond in time to your question: "${questionText}". `
+              + `Apologize to the caller for the delay, let them know you were unable to reach your guardian, `
+              + `ask if they would like to leave a message or receive a callback, `
+              + `and ask if there are any other questions you can help with right now.`;
+
+            const parts: string[] = [];
+            for (const instr of this.pendingInstructions) {
+              parts.push(`[USER_INSTRUCTION: ${instr}]`);
+            }
+            this.pendingInstructions = [];
+            parts.push(`[USER_INSTRUCTION: ${timeoutInstruction}]`);
+
+            if (this.pendingCallerUtterances.length > 0) {
+              const latest = this.pendingCallerUtterances[this.pendingCallerUtterances.length - 1];
+              this.pendingCallerUtterances = [];
+              const callerContent = this.formatCallerUtterance(latest.transcript, latest.speaker);
+              if (callerContent.length > 0) {
+                parts.push(callerContent);
               }
             }
+
+            const content = parts.join('\n');
+            this.runTurn(content).catch((err) =>
+              log.error({ err, callSessionId: this.callSessionId }, 'runTurn failed after guardian consultation timeout'),
+            );
           }, getUserConsultationTimeoutMs());
           return;
         }
@@ -587,7 +660,9 @@ export class CallController {
 
         // Notify the voice conversation
         if (shouldNotifyCompletion && currentSession) {
-          persistCallCompletionMessage(currentSession.conversationId, this.callSessionId);
+          persistCallCompletionMessage(currentSession.conversationId, this.callSessionId).catch((err) => {
+            log.error({ err, conversationId: currentSession.conversationId, callSessionId: this.callSessionId }, 'Failed to persist call completion message');
+          });
           fireCallCompletionNotifier(currentSession.conversationId, this.callSessionId);
         }
 
@@ -596,6 +671,8 @@ export class CallController {
           const durationMs = currentSession.startedAt ? Date.now() - currentSession.startedAt : 0;
           addPointerMessage(currentSession.initiatedFromConversationId, 'completed', currentSession.toNumber, {
             duration: durationMs > 0 ? formatDuration(durationMs) : undefined,
+          }).catch((err) => {
+            log.warn({ conversationId: currentSession.initiatedFromConversationId, err }, 'Skipping pointer write — origin conversation may no longer exist');
           });
         }
         this.state = 'idle';
@@ -761,7 +838,9 @@ export class CallController {
         updateCallSession(this.callSessionId, { status: 'completed', endedAt: Date.now() });
         recordCallEvent(this.callSessionId, 'call_ended', { reason: 'max_duration' });
         if (shouldNotifyCompletion && currentSession) {
-          persistCallCompletionMessage(currentSession.conversationId, this.callSessionId);
+          persistCallCompletionMessage(currentSession.conversationId, this.callSessionId).catch((err) => {
+            log.error({ err, conversationId: currentSession.conversationId, callSessionId: this.callSessionId }, 'Failed to persist call completion message');
+          });
           fireCallCompletionNotifier(currentSession.conversationId, this.callSessionId);
         }
 
@@ -770,6 +849,8 @@ export class CallController {
           const durationMs = currentSession.startedAt ? Date.now() - currentSession.startedAt : 0;
           addPointerMessage(currentSession.initiatedFromConversationId, 'completed', currentSession.toNumber, {
             duration: durationMs > 0 ? formatDuration(durationMs) : undefined,
+          }).catch((err) => {
+            log.warn({ conversationId: currentSession.initiatedFromConversationId, err }, 'Skipping pointer write — origin conversation may no longer exist');
           });
         }
       }, 3000);

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

@@ -21,9 +21,9 @@ export function buildCallCompletionMessage(callSessionId: string): string {
   return `**${statusLabel}**${durationStr}. ${events.length} event(s) recorded.`;
 }
 
-export function persistCallCompletionMessage(conversationId: string, callSessionId: string): string {
+export async function persistCallCompletionMessage(conversationId: string, callSessionId: string): Promise<string> {
   const summaryText = buildCallCompletionMessage(callSessionId);
-  conversationStore.addMessage(
+  await conversationStore.addMessage(
     conversationId,
     'assistant',
     JSON.stringify([{ type: 'text', text: summaryText }]),

package/src/calls/call-domain.ts

@@ -366,7 +366,9 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     log.info({ callSessionId: session.id, callSid }, 'Call initiated successfully');
 
     // Post a concise pointer message in the initiating conversation
-    addPointerMessage(conversationId, 'started', phoneNumber);
+    addPointerMessage(conversationId, 'started', phoneNumber).catch((err) => {
+      log.warn({ conversationId, err }, 'Failed to post call-started pointer message');
+    });
 
     return {
       ok: true,
@@ -392,7 +394,9 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     }
 
     // Post a failure pointer message in the initiating conversation
-    addPointerMessage(conversationId, 'failed', phoneNumber, { reason: msg });
+    addPointerMessage(conversationId, 'failed', phoneNumber, { reason: msg }).catch((pointerErr) => {
+      log.warn({ conversationId, err: pointerErr }, 'Failed to post call-failed pointer message');
+    });
 
     return { ok: false, error: `Error initiating call: ${msg}`, status: 500 };
   }
@@ -572,6 +576,8 @@ export type StartGuardianVerificationCallInput = {
   phoneNumber: string;
   guardianVerificationSessionId: string;
   assistantId?: string;
+  /** Origin conversation ID so completion/failure pointers can route back. */
+  originConversationId?: string;
 };
 
 export type StartGuardianVerificationCallResult =
@@ -588,7 +594,7 @@ export type StartGuardianVerificationCallResult =
 export async function startGuardianVerificationCall(
   input: StartGuardianVerificationCallInput,
 ): Promise<StartGuardianVerificationCallResult> {
-  const { phoneNumber, guardianVerificationSessionId, assistantId = 'self' } = input;
+  const { phoneNumber, guardianVerificationSessionId, assistantId = 'self', originConversationId } = input;
 
   if (!phoneNumber || !E164_REGEX.test(phoneNumber)) {
     return { ok: false, error: 'phone_number must be in E.164 format', status: 400 };
@@ -626,6 +632,7 @@ export async function startGuardianVerificationCall(
       callMode: 'guardian_verification',
       guardianVerificationSessionId,
       assistantId,
+      initiatedFromConversationId: originConversationId,
     });
     sessionId = session.id;