vellum 0.2.12 → 0.2.14

package/src/__tests__/session-conflict-gate.test.ts

@@ -8,6 +8,8 @@ let resolverCallCount = 0;
 let markAskedCalls: string[] = [];
 let conflictScopeCalls: string[] = [];
 let memoryEnabled = true;
+let askOnIrrelevantTurns = false;
+let resolveConflictCalls: Array<{ id: string; input: { status: string; resolutionNote?: string | null } }> = [];
 let pendingConflicts: Array<{
   id: string;
   scopeId: string;
@@ -23,6 +25,8 @@ let pendingConflicts: Array<{
   updatedAt: number;
   existingStatement: string;
   candidateStatement: string;
+  existingKind: string;
+  candidateKind: string;
 }> = [];
 
 let resolverResult: {
@@ -96,6 +100,8 @@ mock.module('../config/loader.js', () => ({
         reaskCooldownTurns: 3,
         resolverLlmTimeoutMs: 250,
         relevanceThreshold: 0.2,
+        askOnIrrelevantTurns,
+        conflictableKinds: ['preference', 'profile', 'constraint', 'instruction', 'style'],
       },
     },
   }),
@@ -212,6 +218,16 @@ mock.module('../memory/conflict-store.js', () => ({
     return true;
   },
   applyConflictResolution: () => true,
+  resolveConflict: (id: string, input: { status: string; resolutionNote?: string | null }) => {
+    resolveConflictCalls.push({ id, input });
+    // Remove dismissed conflicts so the second listPendingConflictDetails call
+    // reflects the dismissal (mirrors real DB behavior).
+    if (input.status === 'dismissed') {
+      const idx = pendingConflicts.findIndex((c) => c.id === id);
+      if (idx !== -1) pendingConflicts.splice(idx, 1);
+    }
+    return null;
+  },
 }));
 
 mock.module('../memory/clarification-resolver.js', () => ({
@@ -249,7 +265,7 @@ mock.module('../agent/loop.js', () => ({
 }));
 
 import { Session, type SessionMemoryPolicy } from '../daemon/session.js';
-import { looksLikeClarificationReply } from '../daemon/session-conflict-gate.js';
+import { ConflictGate, looksLikeClarificationReply } from '../daemon/session-conflict-gate.js';
 
 function makeSession(memoryPolicy?: SessionMemoryPolicy): Session {
   const provider = {
@@ -279,7 +295,9 @@ describe('Session conflict soft gate', () => {
     resolverCallCount = 0;
     markAskedCalls = [];
     conflictScopeCalls = [];
+    resolveConflictCalls = [];
     memoryEnabled = true;
+    askOnIrrelevantTurns = false;
     pendingConflicts = [];
     persistedMessages.length = 0;
     resolverResult = {
@@ -306,6 +324,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use React for frontend work.',
       candidateStatement: 'Use Vue for frontend work.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -325,9 +345,9 @@ describe('Session conflict soft gate', () => {
     expect(events.some((event) => event.type === 'message_complete')).toBe(true);
   });
 
-  test('irrelevant unresolved conflict does not inject side-question into normal answer flow', async () => {
+  test('irrelevant unresolved conflict does not inject side-question when askOnIrrelevantTurns is false (default)', async () => {
     pendingConflicts = [{
-      id: 'conflict-irrelevant',
+      id: 'conflict-irrelevant-silent',
       scopeId: 'default',
       existingItemId: 'existing-b',
       candidateItemId: 'candidate-b',
@@ -341,6 +361,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use Postgres as the default database.',
       candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
     const session = makeSession();
     await session.loadFromDb();
@@ -348,17 +370,57 @@ describe('Session conflict soft gate', () => {
     const events: ServerMessage[] = [];
     await session.processMessage('How do I set up pre-commit hooks?', [], (event) => events.push(event));
 
+    // Agent loop runs without conflict side-question injection
     expect(runCalls).toHaveLength(1);
     const injectedUser = runCalls[0][runCalls[0].length - 1];
     expect(injectedUser.role).toBe('user');
     const injectedText = extractText(injectedUser);
     expect(injectedText).not.toContain('Memory clarification request');
-    expect(injectedText).not.toContain('Should I assume Postgres or MySQL?');
     expect(resolverCallCount).toBe(0);
     expect(markAskedCalls).toEqual([]);
     expect(events.some((event) => event.type === 'message_complete')).toBe(true);
   });
 
+  test('irrelevant unresolved conflict injects soft clarification when askOnIrrelevantTurns is explicitly true', async () => {
+    askOnIrrelevantTurns = true;
+    pendingConflicts = [{
+      id: 'conflict-irrelevant',
+      scopeId: 'default',
+      existingItemId: 'existing-b',
+      candidateItemId: 'candidate-b',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I assume Postgres or MySQL?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use Postgres as the default database.',
+      candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+    const session = makeSession();
+    await session.loadFromDb();
+
+    const events: ServerMessage[] = [];
+    await session.processMessage('How do I set up pre-commit hooks?', [], (event) => events.push(event));
+
+    // Agent loop still runs (soft ask, not a hard block)
+    expect(runCalls).toHaveLength(1);
+    const injectedUser = runCalls[0][runCalls[0].length - 1];
+    expect(injectedUser.role).toBe('user');
+    const injectedText = extractText(injectedUser);
+    // With askOnIrrelevantTurns=true, the irrelevant conflict is soft-injected
+    expect(injectedText).toContain('Memory clarification request');
+    expect(injectedText).toContain('Should I assume Postgres or MySQL?');
+    expect(resolverCallCount).toBe(0);
+    // Zero-relevance conflicts are surfaced but not tracked as asked
+    expect(markAskedCalls).toEqual([]);
+    expect(events.some((event) => event.type === 'message_complete')).toBe(true);
+  });
+
   test('recently asked conflicts still resolve directional clarification replies', async () => {
     pendingConflicts = [{
       id: 'conflict-followup',
@@ -375,6 +437,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use Postgres as the default database.',
       candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -416,6 +480,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use Postgres as the default database.',
       candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -456,6 +522,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use Postgres as the default database.',
       candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -498,6 +566,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use Postgres as the default database.',
       candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -523,9 +593,9 @@ describe('Session conflict soft gate', () => {
     expect(runCalls).toHaveLength(1);
   });
 
-  test('irrelevant conflicts remain silent across subsequent turns', async () => {
+  test('irrelevant conflicts remain silent across subsequent turns when askOnIrrelevantTurns is false (default)', async () => {
     pendingConflicts = [{
-      id: 'conflict-cooldown',
+      id: 'conflict-silent-multi',
       scopeId: 'default',
       existingItemId: 'existing-c',
       candidateItemId: 'candidate-c',
@@ -539,6 +609,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use pnpm for workspace installs.',
       candidateStatement: 'Use npm for workspace installs.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -550,11 +622,52 @@ describe('Session conflict soft gate', () => {
     expect(runCalls).toHaveLength(2);
     const firstUserText = extractText(runCalls[0][runCalls[0].length - 1]);
     const secondUserText = extractText(runCalls[1][runCalls[1].length - 1]);
+    // Both turns: no soft injection because askOnIrrelevantTurns=false
     expect(firstUserText).not.toContain('Memory clarification request');
     expect(secondUserText).not.toContain('Memory clarification request');
     expect(markAskedCalls).toEqual([]);
   });
 
+  test('zero-relevance conflict is soft-asked on every turn (not tracked) when askOnIrrelevantTurns is explicitly true', async () => {
+    askOnIrrelevantTurns = true;
+    pendingConflicts = [{
+      id: 'conflict-cooldown',
+      scopeId: 'default',
+      existingItemId: 'existing-c',
+      candidateItemId: 'candidate-c',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I use pnpm or npm?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use pnpm for workspace installs.',
+      candidateStatement: 'Use npm for workspace installs.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const session = makeSession();
+    await session.loadFromDb();
+
+    await session.processMessage('How should I structure my repo?', [], () => {});
+    await session.processMessage('What branch naming should I use?', [], () => {});
+
+    expect(runCalls).toHaveLength(2);
+    const firstUserText = extractText(runCalls[0][runCalls[0].length - 1]);
+    const secondUserText = extractText(runCalls[1][runCalls[1].length - 1]);
+    // First turn: askOnIrrelevantTurns=true causes soft injection
+    expect(firstUserText).toContain('Memory clarification request');
+    // Second turn: cooldown prevents re-asking (but since relevance is 0,
+    // the first ask was not tracked, so cooldown doesn't apply — the conflict
+    // is surfaced again on the second turn too)
+    expect(secondUserText).toContain('Memory clarification request');
+    // Zero-relevance conflicts are never tracked as asked
+    expect(markAskedCalls).toEqual([]);
+  });
+
   test('passes session scopeId through to conflict store queries', async () => {
     pendingConflicts = [{
       id: 'conflict-scoped',
@@ -571,6 +684,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use tabs for indentation.',
       candidateStatement: 'Use spaces for indentation.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession({
@@ -618,6 +733,8 @@ describe('Session conflict soft gate', () => {
       updatedAt: 1,
       existingStatement: 'Use React for frontend work.',
       candidateStatement: 'Use Vue for frontend work.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
     }];
 
     const session = makeSession();
@@ -631,6 +748,117 @@ describe('Session conflict soft gate', () => {
     expect(resolverCallCount).toBe(0);
     expect(markAskedCalls).toEqual([]);
   });
+
+  test('pending transient conflict is dismissed and not asked', async () => {
+    pendingConflicts = [{
+      id: 'conflict-transient',
+      scopeId: 'default',
+      existingItemId: 'existing-transient',
+      candidateItemId: 'candidate-transient',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Which PR should we track?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Track PR #5526 for review.',
+      candidateStatement: 'Track PR #5525 for review.',
+      existingKind: 'instruction',
+      candidateKind: 'instruction',
+    }];
+
+    const session = makeSession();
+    await session.loadFromDb();
+
+    const events: ServerMessage[] = [];
+    await session.processMessage('Check latest PRs', [], (event) => events.push(event));
+
+    // Should run normal agent loop, no clarification asked
+    expect(runCalls).toHaveLength(1);
+    expect(markAskedCalls).toEqual([]);
+    // The conflict should have been dismissed
+    expect(resolveConflictCalls).toEqual([{
+      id: 'conflict-transient',
+      input: {
+        status: 'dismissed',
+        resolutionNote: 'Dismissed by conflict policy (transient/non-durable).',
+      },
+    }]);
+  });
+
+  test('incoherent conflict (zero statement overlap) is dismissed', async () => {
+    pendingConflicts = [{
+      id: 'conflict-incoherent',
+      scopeId: 'default',
+      existingItemId: 'existing-incoherent',
+      candidateItemId: 'candidate-incoherent',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'I have conflicting notes: "The default model for the summarize CLI is google/gemini-3-flash-preview" vs "User\'s favorite color is blue." Which one is correct?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'The default model for the summarize CLI is google/gemini-3-flash-preview.',
+      candidateStatement: "User's favorite color is blue.",
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const session = makeSession();
+    await session.loadFromDb();
+
+    const events: ServerMessage[] = [];
+    await session.processMessage('my favorite color is white', [], (event) => events.push(event));
+
+    // Should run normal agent loop, no clarification asked
+    expect(runCalls).toHaveLength(1);
+    expect(markAskedCalls).toEqual([]);
+    // The conflict should have been dismissed as incoherent
+    expect(resolveConflictCalls).toEqual([{
+      id: 'conflict-incoherent',
+      input: {
+        status: 'dismissed',
+        resolutionNote: 'Dismissed by conflict policy (incoherent — zero statement overlap).',
+      },
+    }]);
+  });
+
+  test('pending durable preference conflict still follows normal flow', async () => {
+    pendingConflicts = [{
+      id: 'conflict-durable',
+      scopeId: 'default',
+      existingItemId: 'existing-durable',
+      candidateItemId: 'candidate-durable',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Do you want React or Vue?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use React for frontend work.',
+      candidateStatement: 'Use Vue for frontend work.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const session = makeSession();
+    await session.loadFromDb();
+
+    const events: ServerMessage[] = [];
+    await session.processMessage('Should I use React or Vue?', [], (event) => events.push(event));
+
+    // Should ask clarification for relevant durable conflict
+    expect(runCalls).toHaveLength(0);
+    expect(markAskedCalls).toEqual(['conflict-durable']);
+    // No dismissal should have happened
+    expect(resolveConflictCalls).toEqual([]);
+  });
 });
 
 describe('looksLikeClarificationReply', () => {
@@ -698,3 +926,211 @@ describe('looksLikeClarificationReply', () => {
     expect(looksLikeClarificationReply('sounds good')).toBe(false);
   });
 });
+
+describe('ConflictGate askOnIrrelevantTurns knob', () => {
+
+  const baseConfig = {
+    enabled: true,
+    gateMode: 'soft' as const,
+    relevanceThreshold: 0.2,
+    reaskCooldownTurns: 3,
+    resolverLlmTimeoutMs: 250,
+    conflictableKinds: ['preference', 'profile', 'constraint', 'instruction', 'style'] as readonly string[],
+  };
+
+  beforeEach(() => {
+    markAskedCalls = [];
+    pendingConflicts = [];
+    resolveConflictCalls = [];
+    resolverCallCount = 0;
+    resolverResult = {
+      resolution: 'still_unclear',
+      strategy: 'heuristic',
+      resolvedStatement: null,
+      explanation: 'Need user clarification.',
+    };
+  });
+
+  test('with askOnIrrelevantTurns=false, irrelevant conflict is not asked', async () => {
+    pendingConflicts = [{
+      id: 'conflict-irrel-false',
+      scopeId: 'default',
+      existingItemId: 'existing-irrel',
+      candidateItemId: 'candidate-irrel',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I assume Postgres or MySQL?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use Postgres as the default database.',
+      candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const gate = new ConflictGate();
+    const result = await gate.evaluate(
+      'How do I set up pre-commit hooks?',
+      { ...baseConfig, askOnIrrelevantTurns: false },
+    );
+
+    expect(result).toBeNull();
+    expect(markAskedCalls).toEqual([]);
+  });
+
+  test('with askOnIrrelevantTurns=true, irrelevant conflict is asked as non-relevant', async () => {
+    pendingConflicts = [{
+      id: 'conflict-irrel-true',
+      scopeId: 'default',
+      existingItemId: 'existing-irrel2',
+      candidateItemId: 'candidate-irrel2',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I assume Postgres or MySQL?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use Postgres as the default database.',
+      candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const gate = new ConflictGate();
+    const result = await gate.evaluate(
+      'How do I set up pre-commit hooks?',
+      { ...baseConfig, askOnIrrelevantTurns: true },
+    );
+
+    expect(result).not.toBeNull();
+    expect(result!.relevant).toBe(false);
+    expect(result!.question).toContain('Postgres or MySQL');
+    // Zero-relevance conflicts are surfaced but not tracked as asked
+    expect(markAskedCalls).toEqual([]);
+  });
+
+  test('zero-relevance conflict asked via askOnIrrelevantTurns does not cause wasRecentlyAsked on next turn', async () => {
+    pendingConflicts = [{
+      id: 'conflict-zero-rel',
+      scopeId: 'default',
+      existingItemId: 'existing-zero',
+      candidateItemId: 'candidate-zero',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I assume Postgres or MySQL?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use Postgres as the default database.',
+      candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const gate = new ConflictGate();
+
+    // First turn: zero-relevance conflict is surfaced via askOnIrrelevantTurns
+    const result1 = await gate.evaluate(
+      'How do I set up pre-commit hooks?',
+      { ...baseConfig, askOnIrrelevantTurns: true },
+    );
+    expect(result1).not.toBeNull();
+    expect(result1!.relevant).toBe(false);
+    // Not tracked as asked because relevance is 0
+    expect(markAskedCalls).toEqual([]);
+
+    // Second turn: an unrelated short imperative that looks like a clarification reply.
+    // If the zero-relevance conflict had been tracked, wasRecentlyAsked would return
+    // true and shouldAttemptConflictResolution would try to resolve it — which is wrong.
+    // Since we don't track zero-relevance asks, the resolver should NOT be called.
+    const result2 = await gate.evaluate(
+      'keep it',
+      { ...baseConfig, askOnIrrelevantTurns: false },
+    );
+
+    // The conflict should not have been resolved by the resolver
+    expect(resolverCallCount).toBe(0);
+    // With askOnIrrelevantTurns=false and the conflict being irrelevant, result is null
+    expect(result2).toBeNull();
+  });
+
+  test('zero-relevance conflict on primary askable path (relevanceThreshold=0) is tracked as asked', async () => {
+    pendingConflicts = [{
+      id: 'conflict-zero-threshold',
+      scopeId: 'default',
+      existingItemId: 'existing-zt',
+      candidateItemId: 'candidate-zt',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Should I assume Postgres or MySQL?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use Postgres as the default database.',
+      candidateStatement: 'Use MySQL as the default database.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    const gate = new ConflictGate();
+    // relevanceThreshold=0 means zero-relevance conflicts pass the primary askable filter
+    const result1 = await gate.evaluate(
+      'How do I set up pre-commit hooks?',
+      { ...baseConfig, relevanceThreshold: 0, askOnIrrelevantTurns: false },
+    );
+
+    expect(result1).not.toBeNull();
+    expect(result1!.relevant).toBe(true);
+    // Should be tracked as asked since it came through the primary askable path
+    expect(markAskedCalls).toEqual(['conflict-zero-threshold']);
+
+    // Second turn within cooldown: the conflict should NOT be re-asked
+    const result2 = await gate.evaluate(
+      'Another unrelated question',
+      { ...baseConfig, relevanceThreshold: 0, askOnIrrelevantTurns: false },
+    );
+    expect(result2).toBeNull();
+  });
+
+  test('relevant conflict is asked regardless of askOnIrrelevantTurns value', async () => {
+    pendingConflicts = [{
+      id: 'conflict-rel-knob',
+      scopeId: 'default',
+      existingItemId: 'existing-rel',
+      candidateItemId: 'candidate-rel',
+      relationship: 'ambiguous_contradiction',
+      status: 'pending_clarification',
+      clarificationQuestion: 'Do you want React or Vue for frontend work?',
+      resolutionNote: null,
+      lastAskedAt: null,
+      resolvedAt: null,
+      createdAt: 1,
+      updatedAt: 1,
+      existingStatement: 'Use React for frontend work.',
+      candidateStatement: 'Use Vue for frontend work.',
+      existingKind: 'preference',
+      candidateKind: 'preference',
+    }];
+
+    // Test with askOnIrrelevantTurns=false — relevant conflicts should still be asked
+    const gate = new ConflictGate();
+    const result = await gate.evaluate(
+      'Should I use React or Vue here?',
+      { ...baseConfig, askOnIrrelevantTurns: false },
+    );
+
+    expect(result).not.toBeNull();
+    expect(result!.relevant).toBe(true);
+    expect(result!.question).toContain('React or Vue');
+    expect(markAskedCalls).toEqual(['conflict-rel-knob']);
+  });
+});

package/src/__tests__/session-init.benchmark.test.ts

@@ -188,6 +188,9 @@ mock.module('../calls/call-state.js', () => ({
   registerCallQuestionNotifier: () => {},
   unregisterCallQuestionNotifier: () => {},
   fireCallQuestionNotifier: () => {},
+  registerCallTranscriptNotifier: () => {},
+  unregisterCallTranscriptNotifier: () => {},
+  fireCallTranscriptNotifier: () => {},
   registerCallCompletionNotifier: () => {},
   unregisterCallCompletionNotifier: () => {},
   fireCallCompletionNotifier: () => {},