@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/voice-quality.test.ts

@@ -0,0 +1,222 @@
+import { describe, test, expect, mock } from 'bun:test';
+
+let mockConfig: Record<string, unknown> = {};
+
+mock.module('../config/loader.js', () => ({
+  loadConfig: () => mockConfig,
+}));
+
+import { buildElevenLabsVoiceSpec, resolveVoiceQualityProfile, isVoiceProfileValid } from '../calls/voice-quality.js';
+
+describe('buildElevenLabsVoiceSpec', () => {
+  test('returns bare voiceId when no model is set', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: 'abc123' })).toBe('abc123');
+  });
+
+  test('returns empty string when voiceId is empty', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: '' })).toBe('');
+  });
+
+  test('returns empty string when voiceId is whitespace', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: '  ' })).toBe('');
+  });
+
+  test('returns bare voiceId when voiceModelId is empty', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: 'abc123', voiceModelId: '' })).toBe('abc123');
+  });
+
+  test('returns bare voiceId when voiceModelId is whitespace', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: 'abc123', voiceModelId: '  ' })).toBe('abc123');
+  });
+
+  test('appends model and defaults when voiceModelId is provided', () => {
+    const result = buildElevenLabsVoiceSpec({ voiceId: 'abc123', voiceModelId: 'eleven_turbo_v2' });
+    expect(result).toBe('abc123-eleven_turbo_v2-1_0.5_0.75');
+  });
+
+  test('uses custom speed, stability, and similarity values', () => {
+    const result = buildElevenLabsVoiceSpec({
+      voiceId: 'voice1',
+      voiceModelId: 'model1',
+      speed: 1.5,
+      stability: 0.8,
+      similarityBoost: 0.9,
+    });
+    expect(result).toBe('voice1-model1-1.5_0.8_0.9');
+  });
+
+  test('trims whitespace from voiceId', () => {
+    expect(buildElevenLabsVoiceSpec({ voiceId: '  abc123  ' })).toBe('abc123');
+  });
+});
+
+describe('resolveVoiceQualityProfile', () => {
+  test('returns standard profile for twilio_standard mode', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'twilio_standard',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: {},
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.ttsProvider).toBe('Google');
+    expect(profile.voice).toBe('Google.en-US-Journey-O');
+    expect(profile.validationErrors).toHaveLength(0);
+  });
+
+  test('returns elevenlabs profile for twilio_elevenlabs_tts mode', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: 'elvoice1' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.ttsProvider).toBe('ElevenLabs');
+    expect(profile.voice).toBe('elvoice1');
+    expect(profile.validationErrors).toHaveLength(0);
+  });
+
+  test('falls back to standard when voiceId missing and fallback enabled', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: true,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.validationErrors.length).toBeGreaterThan(0);
+    expect(profile.validationErrors[0]).toContain('falling back');
+  });
+
+  test('returns validation error when voiceId missing and fallback disabled', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.validationErrors.length).toBeGreaterThan(0);
+    expect(profile.validationErrors[0]).toContain('voiceId is required');
+  });
+
+  test('returns elevenlabs_agent profile with agentId', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: 'voice1', agentId: 'agent123' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.agentId).toBe('agent123');
+    expect(profile.validationErrors).toHaveLength(0);
+  });
+
+  test('falls back to standard when agentId missing and fallback enabled', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: true,
+          elevenlabs: { voiceId: 'voice1', agentId: '' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.validationErrors[0]).toContain('falling back');
+  });
+
+  test('returns validation error when agentId missing and fallback disabled', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: 'voice1', agentId: '' },
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.validationErrors.length).toBeGreaterThan(0);
+    expect(profile.validationErrors[0]).toContain('agentId is required');
+  });
+
+  test('returns standard profile for unknown mode', () => {
+    mockConfig = {
+      calls: {
+        voice: {
+          mode: 'unknown_mode',
+          language: 'en-US',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: {},
+        },
+      },
+    };
+    const profile = resolveVoiceQualityProfile();
+    expect(profile.mode).toBe('twilio_standard');
+  });
+});
+
+describe('isVoiceProfileValid', () => {
+  test('returns true for profile with no errors', () => {
+    expect(isVoiceProfileValid({
+      mode: 'twilio_standard',
+      language: 'en-US',
+      transcriptionProvider: 'Google',
+      ttsProvider: 'Google',
+      voice: 'Google.en-US-Journey-O',
+      fallbackToStandardOnError: false,
+      validationErrors: [],
+    })).toBe(true);
+  });
+
+  test('returns false for profile with errors', () => {
+    expect(isVoiceProfileValid({
+      mode: 'twilio_elevenlabs_tts',
+      language: 'en-US',
+      transcriptionProvider: 'Google',
+      ttsProvider: 'ElevenLabs',
+      voice: '',
+      fallbackToStandardOnError: false,
+      validationErrors: ['voiceId is required'],
+    })).toBe(false);
+  });
+});

package/src/__tests__/web-search.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
 
 // No mock.module calls — this test file uses its own inline executeWebSearch
@@ -45,7 +44,7 @@ describe('WebSearchTool', () => {
       globalThis.fetch = (async () => {
         fetchCalled = true;
         return new Response('{}', { status: 200 });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       process.env.BRAVE_API_KEY = 'test-key';
 
@@ -74,7 +73,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test', count: 50 }, 'test-key', 'brave');
       expect(capturedUrl).toContain('count=20');
@@ -91,7 +90,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test', offset: 20 }, 'test-key', 'brave');
       expect(capturedUrl).toContain('offset=9');
@@ -105,7 +104,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test', freshness: 'pw' }, 'test-key', 'brave');
       expect(capturedUrl).toContain('freshness=pw');
@@ -119,7 +118,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test', freshness: 'invalid' }, 'test-key', 'brave');
       expect(capturedUrl).not.toContain('freshness');
@@ -142,7 +141,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -159,7 +158,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'noresults' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -172,7 +171,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'empty' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -182,7 +181,7 @@ describe('WebSearchTool', () => {
     test('handles 401 unauthorized', async () => {
       globalThis.fetch = (async () =>
         new Response('Unauthorized', { status: 401 })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'bad-key', 'brave');
       expect(result.isError).toBe(true);
@@ -200,7 +199,7 @@ describe('WebSearchTool', () => {
           JSON.stringify({ web: { results: [{ title: 'Result', url: 'https://example.com', description: 'Found it' }] } }),
           { status: 200, headers: { 'Content-Type': 'application/json' } },
         );
-      }) as any;
+      }) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -211,7 +210,7 @@ describe('WebSearchTool', () => {
     test('returns error after exhausting 429 retries', async () => {
       globalThis.fetch = (async () =>
         new Response('Too Many Requests', { status: 429 })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(true);
@@ -235,7 +234,7 @@ describe('WebSearchTool', () => {
           JSON.stringify({ web: { results: [] } }),
           { status: 200, headers: { 'Content-Type': 'application/json' } },
         );
-      }) as any;
+      }) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -245,7 +244,7 @@ describe('WebSearchTool', () => {
     test('handles network errors', async () => {
       globalThis.fetch = (async () => {
         throw new Error('Network unreachable');
-      }) as any;
+      }) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(true);
@@ -254,7 +253,7 @@ describe('WebSearchTool', () => {
 
     test('sends correct headers', async () => {
       let capturedHeaders: Record<string, string> = {};
-      globalThis.fetch = (async (_url: string, init: any) => {
+      globalThis.fetch = (async (_url: string, init: RequestInit) => {
         capturedHeaders = Object.fromEntries(
           Object.entries(init.headers as Record<string, string>),
         );
@@ -262,7 +261,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test' }, 'my-api-key', 'brave');
       expect(capturedHeaders['X-Subscription-Token']).toBe('my-api-key');
@@ -288,7 +287,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'test-key', 'brave');
       expect(result.isError).toBe(false);
@@ -309,7 +308,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'pplx-key', 'perplexity');
       expect(result.isError).toBe(false);
@@ -328,7 +327,7 @@ describe('WebSearchTool', () => {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'noresults' }, 'pplx-key', 'perplexity');
       expect(result.isError).toBe(false);
@@ -338,7 +337,7 @@ describe('WebSearchTool', () => {
     test('handles 401 unauthorized', async () => {
       globalThis.fetch = (async () =>
         new Response('Unauthorized', { status: 401 })
-      ) as any;
+      ) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'bad-key', 'perplexity');
       expect(result.isError).toBe(true);
@@ -347,23 +346,23 @@ describe('WebSearchTool', () => {
 
     test('sends correct headers', async () => {
       let capturedHeaders: Record<string, string> = {};
-      let capturedBody: any;
-      globalThis.fetch = (async (_url: string, init: any) => {
+      let capturedBody: Record<string, unknown> = {};
+      globalThis.fetch = (async (_url: string, init: RequestInit) => {
         capturedHeaders = Object.fromEntries(
           Object.entries(init.headers as Record<string, string>),
         );
-        capturedBody = JSON.parse(init.body);
+        capturedBody = JSON.parse(init.body as string);
         return new Response(JSON.stringify({ choices: [{ message: { content: 'result' } }] }), {
           status: 200,
           headers: { 'Content-Type': 'application/json' },
         });
-      }) as any;
+      }) as unknown as typeof fetch;
 
       await executeWebSearch({ query: 'test query' }, 'pplx-my-key', 'perplexity');
       expect(capturedHeaders['Authorization']).toBe('Bearer pplx-my-key');
       expect(capturedHeaders['Content-Type']).toBe('application/json');
       expect(capturedBody.model).toBe('sonar');
-      expect(capturedBody.messages[0].content).toBe('test query');
+      expect((capturedBody.messages as Array<{ content: string }>)[0].content).toBe('test query');
     });
 
     test('retries on 429 and succeeds', async () => {
@@ -377,7 +376,7 @@ describe('WebSearchTool', () => {
           JSON.stringify({ choices: [{ message: { content: 'Found it' } }] }),
           { status: 200, headers: { 'Content-Type': 'application/json' } },
         );
-      }) as any;
+      }) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'pplx-key', 'perplexity');
       expect(result.isError).toBe(false);
@@ -388,7 +387,7 @@ describe('WebSearchTool', () => {
     test('handles network errors', async () => {
       globalThis.fetch = (async () => {
         throw new Error('Network unreachable');
-      }) as any;
+      }) as unknown as typeof fetch;
 
       const result = await executeWebSearch({ query: 'test' }, 'pplx-key', 'perplexity');
       expect(result.isError).toBe(true);
@@ -397,6 +396,23 @@ describe('WebSearchTool', () => {
   });
 });
 
+interface BraveSearchResult {
+  title: string;
+  url: string;
+  description?: string;
+  age?: string;
+  extra_snippets?: string[];
+}
+
+interface BraveSearchResponse {
+  web?: { results: BraveSearchResult[] };
+}
+
+interface PerplexityResponse {
+  choices?: Array<{ message: { content: string } }>;
+  citations?: string[];
+}
+
 /**
  * Helper that exercises the web search logic directly, bypassing module
  * registration concerns. This replicates the core execute path from
@@ -414,7 +430,7 @@ async function executeWebSearch(
 
   if (!apiKey) {
     return {
-      content: 'Error: No web search API key configured. Set PERPLEXITY_API_KEY or BRAVE_API_KEY environment variable, or configure a key in settings.',
+      content: 'Error: No web search API key configured. Provide a PERPLEXITY_API_KEY or BRAVE_API_KEY here in the chat using the secure credential prompt, or set it from the Settings page.',
       isError: true,
     };
   }
@@ -461,7 +477,7 @@ async function executeBraveSearchHelper(
       });
 
       if (response.ok) {
-        const data = await response.json() as any;
+        const data = await response.json() as BraveSearchResponse;
         const results = data.web?.results ?? [];
 
         if (results.length === 0) {
@@ -536,7 +552,7 @@ async function executePerplexitySearchHelper(
       });
 
       if (response.ok) {
-        const data = await response.json() as any;
+        const data = await response.json() as PerplexityResponse;
         const content = data.choices?.[0]?.message?.content;
         if (!content) {
           return { content: `No results found for "${query}".`, isError: false };

package/src/__tests__/work-item-output.test.ts

@@ -0,0 +1,110 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import type { Database } from 'bun:sqlite';
+import * as net from 'node:net';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const testDir = mkdtempSync(join(tmpdir(), 'work-item-output-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+mock.module('./indexer.js', () => ({
+  indexMessageNow: () => {},
+}));
+
+import { addMessage, createConversation } from '../memory/conversation-store.js';
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { createTask, createTaskRun, updateTaskRun } from '../tasks/task-store.js';
+import { createWorkItem, updateWorkItem } from '../work-items/work-item-store.js';
+import { handleWorkItemOutput } from '../daemon/handlers/work-items.js';
+import type { HandlerContext } from '../daemon/handlers/shared.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+});
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+describe('handleWorkItemOutput', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('uses only the latest assistant text block for summary output', () => {
+    const task = createTask({
+      title: 'Delete weather report',
+      template: 'Delete weather_report_task.txt',
+    });
+    const run = createTaskRun(task.id);
+    const item = createWorkItem({
+      taskId: task.id,
+      title: 'Delete weather_report_task.txt',
+    });
+    const conversation = createConversation('Task output test');
+
+    updateTaskRun(run.id, {
+      status: 'completed',
+      conversationId: conversation.id,
+      finishedAt: Date.now(),
+    });
+    updateWorkItem(item.id, {
+      status: 'awaiting_review',
+      lastRunId: run.id,
+      lastRunConversationId: conversation.id,
+      lastRunStatus: 'completed',
+    });
+
+    addMessage(conversation.id, 'assistant', JSON.stringify([
+      { type: 'text', text: "I'll need to delete the weather report file from your Documents folder. This will permanently remove it." },
+      { type: 'text', text: "Looks like that file has already been deleted — it's no longer there. I'll mark this task as done." },
+      { type: 'text', text: 'The file is already deleted, so the task is complete.' },
+    ]));
+
+    const sent: Array<{ type: string; [key: string]: unknown }> = [];
+    const socket = {} as net.Socket;
+    const ctx = {
+      send: (_socket: net.Socket, msg: { type: string; [key: string]: unknown }) => sent.push(msg),
+    } as unknown as HandlerContext;
+
+    handleWorkItemOutput({ type: 'work_item_output', id: item.id }, socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const response = sent[0];
+    expect(response.type).toBe('work_item_output_response');
+    expect(response.success).toBe(true);
+    expect((response.output as { summary: string }).summary).toBe('The file is already deleted, so the task is complete.');
+  });
+});

package/src/agent/loop.ts

@@ -35,7 +35,7 @@ export type AgentEvent =
   | { type: 'usage'; inputTokens: number; outputTokens: number; cacheCreationInputTokens?: number; cacheReadInputTokens?: number; model: string; providerDurationMs: number; rawRequest?: unknown; rawResponse?: unknown };
 
 const DEFAULT_CONFIG: AgentLoopConfig = {
-  maxTokens: 64000,
+  maxTokens: 16000,
   maxToolUseTurns: 30,
 };
 

package/src/agent-heartbeat/agent-heartbeat-service.ts

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { readTextFileSync } from '../util/fs.js';
 import { getLogger } from '../util/logger.js';
 import { getWorkspacePromptPath } from '../util/platform.js';
 import { getConfig } from '../config/loader.js';
@@ -115,15 +115,7 @@ export class AgentHeartbeatService {
   }
 
   private readChecklist(): string {
-    const heartbeatPath = getWorkspacePromptPath('HEARTBEAT.md');
-    if (existsSync(heartbeatPath)) {
-      try {
-        return readFileSync(heartbeatPath, 'utf-8');
-      } catch (err) {
-        log.warn({ err, heartbeatPath }, 'Failed to read HEARTBEAT.md, using default checklist');
-      }
-    }
-    return DEFAULT_CHECKLIST;
+    return readTextFileSync(getWorkspacePromptPath('HEARTBEAT.md')) ?? DEFAULT_CHECKLIST;
   }
 
   /** @internal Exposed for testing. */