@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/delegation-jobs.ts

@@ -1,26 +1,26 @@
 import { genId } from '@/lib/id'
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { DelegationJobArtifact, DelegationJobCheckpoint, DelegationJobRecord, DelegationJobStatus } from '@/types'
-import { loadDelegationJobs, upsertDelegationJob } from './storage'
+import { loadDelegationJobs, upsertDelegationJob, patchDelegationJob } from './storage'
 import { notify } from './ws-hub'
 
 interface DelegationRuntimeHandle {
   cancel?: () => void
 }
 
-const runtimeKey = '__swarmclaw_delegation_job_runtime__' as const
-const runtimeScope = globalThis as typeof globalThis & {
-  [runtimeKey]?: Map<string, DelegationRuntimeHandle>
-}
-const runtimeHandles = runtimeScope[runtimeKey] ?? (runtimeScope[runtimeKey] = new Map())
-
-function now() {
-  return Date.now()
-}
+const runtimeHandles = hmrSingleton('__swarmclaw_delegation_job_runtime__', () => new Map<string, DelegationRuntimeHandle>())
 
 function isTerminalStatus(status: DelegationJobStatus | null | undefined): boolean {
   return status === 'completed' || status === 'failed' || status === 'cancelled'
 }
 
+function appendCheckpoint(
+  existing: DelegationJobCheckpoint[] | undefined,
+  checkpoint: DelegationJobCheckpoint,
+): DelegationJobCheckpoint[] {
+  return [...(existing || []), checkpoint].slice(-24)
+}
+
 function notifyDelegationJobsChanged() {
   notify('delegation_jobs')
 }
@@ -37,7 +37,7 @@ export interface CreateDelegationJobInput {
 }
 
 export function createDelegationJob(input: CreateDelegationJobInput): DelegationJobRecord {
-  const createdAt = now()
+  const createdAt = Date.now()
   const job: DelegationJobRecord = {
     id: genId(10),
     kind: input.kind,
@@ -92,16 +92,16 @@ export function updateDelegationJob(
   id: string,
   patch: Partial<DelegationJobRecord>,
 ): DelegationJobRecord | null {
-  const current = getDelegationJob(id)
-  if (!current) return null
-  const next: DelegationJobRecord = {
-    ...current,
-    ...patch,
-    updatedAt: now(),
-  }
-  upsertDelegationJob(id, next)
-  notifyDelegationJobsChanged()
-  return next
+  const result = patchDelegationJob(id, (current) => {
+    if (!current) return null
+    return {
+      ...current,
+      ...patch,
+      updatedAt: Date.now(),
+    }
+  })
+  if (result) notifyDelegationJobsChanged()
+  return result
 }
 
 export function appendDelegationCheckpoint(
@@ -114,10 +114,9 @@ export function appendDelegationCheckpoint(
   if (isTerminalStatus(current.status) && status && status !== current.status) {
     return current
   }
-  const checkpoints = [...(current.checkpoints || []), { at: now(), note, status }]
   return updateDelegationJob(id, {
     status: isTerminalStatus(current.status) ? current.status : (status ?? current.status),
-    checkpoints: checkpoints.slice(-24),
+    checkpoints: appendCheckpoint(current.checkpoints, { at: Date.now(), note, status }),
   })
 }
 
@@ -128,7 +127,7 @@ export function startDelegationJob(id: string, patch?: Partial<DelegationJobReco
   return updateDelegationJob(id, {
     ...patch,
     status: 'running',
-    startedAt: now(),
+    startedAt: Date.now(),
   })
 }
 
@@ -147,7 +146,7 @@ export function completeDelegationJob(
     result,
     resultPreview: result.slice(0, 1000),
     error: null,
-    completedAt: now(),
+    completedAt: Date.now(),
   })
 }
 
@@ -160,7 +159,7 @@ export function failDelegationJob(id: string, error: string, patch?: Partial<Del
     ...patch,
     status: 'failed',
     error,
-    completedAt: now(),
+    completedAt: Date.now(),
   })
 }
 
@@ -174,21 +173,20 @@ export function cancelDelegationJob(id: string): DelegationJobRecord | null {
   } catch {
     // best-effort cancel
   }
-  runtimeHandles.delete(id)
-  const checkpoint: DelegationJobCheckpoint = {
-    at: now(),
-    note: 'Job cancelled',
-    status: 'cancelled',
-  }
-  return updateDelegationJob(id, {
+  // Commit state before deleting handle — if the update fails, the handle
+  // stays intact for a future retry rather than being orphaned.
+  const result = updateDelegationJob(id, {
     status: 'cancelled',
-    completedAt: now(),
+    completedAt: Date.now(),
     error: null,
-    checkpoints: [
-      ...(current.checkpoints || []),
-      checkpoint,
-    ].slice(-24),
+    checkpoints: appendCheckpoint(current.checkpoints, {
+      at: Date.now(),
+      note: 'Job cancelled',
+      status: 'cancelled',
+    }),
   })
+  runtimeHandles.delete(id)
+  return result
 }
 
 export function cancelDelegationJobsForParentSession(
@@ -206,16 +204,12 @@ export function cancelDelegationJobsForParentSession(
     const checkpoints = Array.isArray(next.checkpoints) ? next.checkpoints : []
     const last = checkpoints[checkpoints.length - 1]
     if (!last || last.note !== note) {
-      const checkpoint: DelegationJobCheckpoint = {
-        at: now(),
-        note,
-        status: 'cancelled',
-      }
       updateDelegationJob(job.id, {
-        checkpoints: [
-          ...checkpoints,
-          checkpoint,
-        ].slice(-24),
+        checkpoints: appendCheckpoint(next.checkpoints, {
+          at: Date.now(),
+          note,
+          status: 'cancelled',
+        }),
       })
     }
   }
@@ -235,7 +229,7 @@ export function appendDelegationArtifacts(id: string, artifacts: DelegationJobAr
 }
 
 export function recoverStaleDelegationJobs(maxAgeMs = 15 * 60_000): number {
-  const threshold = now() - maxAgeMs
+  const threshold = Date.now() - maxAgeMs
   const stale = listDelegationJobs().filter((job) =>
     (job.status === 'queued' || job.status === 'running')
     && !runtimeHandles.has(job.id)

package/src/lib/server/devserver-launch.ts

@@ -19,7 +19,7 @@ export interface DevServerLaunchResolution {
 const NEXT_CONFIG_FILES = [
   'next.config.js',
   'next.config.mjs',
-  'next.config.ts',
+  'next.config',
 ]
 
 function readPackageJson(dir: string): PackageJsonLike | null {

package/src/lib/server/document-utils.ts

@@ -2,11 +2,13 @@ import fs from 'fs'
 import path from 'path'
 import { spawnSync } from 'child_process'
 import * as cheerio from 'cheerio'
+import { dedup } from '@/lib/shared-utils'
 import { findBinaryOnPath } from './session-tools/context'
+import { safeJsonParse } from './json-utils'
 
 const TEXT_EXTENSIONS = new Set([
   '.txt', '.md', '.markdown', '.json', '.jsonl', '.csv', '.tsv',
-  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs',
+  '', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs',
   '.java', '.yaml', '.yml', '.sql', '.xml', '.css', '.scss', '.html', '.htm',
 ])
 const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.tif', '.tiff'])
@@ -113,7 +115,7 @@ function matrixToTable(name: string, matrix: string[][]): StructuredTable {
 }
 
 function objectsToTable(name: string, rows: Array<Record<string, unknown>>): StructuredTable {
-  const headers = Array.from(new Set(rows.flatMap((row) => Object.keys(row))))
+  const headers = dedup(rows.flatMap((row) => Object.keys(row)))
   const normalizedRows = rows.map((row) => {
     const out: Record<string, unknown> = {}
     for (const header of headers) out[header] = normalizeScalar(row[header])
@@ -264,13 +266,9 @@ export async function extractDocumentArtifact(filePath: string, options?: { maxC
     const raw = fs.readFileSync(resolved, 'utf-8')
     text = raw
     method = 'json'
-    try {
-      const parsed = JSON.parse(raw)
-      if (Array.isArray(parsed) && parsed.every((row) => row && typeof row === 'object' && !Array.isArray(row))) {
-        tables = [objectsToTable(path.basename(resolved), parsed as Array<Record<string, unknown>>)]
-      }
-    } catch {
-      // keep raw json text only
+    const parsed = safeJsonParse<unknown>(raw, null)
+    if (Array.isArray(parsed) && parsed.every((row) => row && typeof row === 'object' && !Array.isArray(row))) {
+      tables = [objectsToTable(path.basename(resolved), parsed as Array<Record<string, unknown>>)]
     }
   } else if (ext === '.html' || ext === '.htm') {
     const html = fs.readFileSync(resolved, 'utf-8')

package/src/lib/server/elevenlabs.ts

@@ -1,4 +1,5 @@
 import { decryptKey, loadSettings, loadSecrets } from './storage'
+import { dedup } from '@/lib/shared-utils'
 
 const DEFAULT_VOICE_ID = 'JBFqnCBsd6RMkjVDRZzb'
 const DEFAULT_MODEL_ID = 'eleven_multilingual_v2'
@@ -56,7 +57,7 @@ function resolveElevenLabsApiKeyCandidates(): string[] {
     }
   }
 
-  return [...new Set(candidates)]
+  return dedup(candidates)
 }
 
 function shouldRetryWithFallbackVoice(voiceId: string, errBody: string): boolean {

package/src/lib/server/embeddings.test.ts

@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+// embeddings.ts exports pure utility functions (cosineSimilarity, serialize/deserialize)
+// that don't need DATA_DIR. getEmbedding needs storage — skip that, test pure logic.
+
+// Direct import is safe for the pure math/serialization functions since the module
+// only touches storage lazily in getEmbedding().
+// However the top-level import of ./storage will trigger DB init,
+// so we use dynamic import with SWARMCLAW_BUILD_MODE.
+
+let embeddings: typeof import('./embeddings')
+
+import { before } from 'node:test'
+
+before(async () => {
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  embeddings = await import('./embeddings')
+})
+
+describe('embeddings - cosineSimilarity', () => {
+  it('identical vectors have similarity 1', () => {
+    const v = [1, 2, 3, 4, 5]
+    const sim = embeddings.cosineSimilarity(v, v)
+    assert.ok(Math.abs(sim - 1) < 1e-10, `expected ~1, got ${sim}`)
+  })
+
+  it('orthogonal vectors have similarity 0', () => {
+    const a = [1, 0, 0]
+    const b = [0, 1, 0]
+    const sim = embeddings.cosineSimilarity(a, b)
+    assert.ok(Math.abs(sim) < 1e-10, `expected ~0, got ${sim}`)
+  })
+
+  it('opposite vectors have similarity -1', () => {
+    const a = [1, 2, 3]
+    const b = [-1, -2, -3]
+    const sim = embeddings.cosineSimilarity(a, b)
+    assert.ok(Math.abs(sim + 1) < 1e-10, `expected ~-1, got ${sim}`)
+  })
+
+  it('different-length vectors return 0', () => {
+    const sim = embeddings.cosineSimilarity([1, 2], [1, 2, 3])
+    assert.equal(sim, 0)
+  })
+
+  it('zero vector returns 0', () => {
+    const sim = embeddings.cosineSimilarity([0, 0, 0], [1, 2, 3])
+    assert.equal(sim, 0)
+  })
+
+  it('both zero vectors return 0', () => {
+    const sim = embeddings.cosineSimilarity([0, 0], [0, 0])
+    assert.equal(sim, 0)
+  })
+
+  it('empty vectors return 0', () => {
+    const sim = embeddings.cosineSimilarity([], [])
+    assert.equal(sim, 0)
+  })
+})
+
+describe('embeddings - serialize/deserialize roundtrip', () => {
+  it('roundtrips a simple embedding', () => {
+    const original = [0.1, 0.2, 0.3, -0.5, 1.0]
+    const buf = embeddings.serializeEmbedding(original)
+    const restored = embeddings.deserializeEmbedding(buf)
+
+    assert.equal(restored.length, original.length)
+    for (let i = 0; i < original.length; i++) {
+      assert.ok(Math.abs(restored[i] - original[i]) < 1e-6, `index ${i}: ${restored[i]} vs ${original[i]}`)
+    }
+  })
+
+  it('roundtrips an empty embedding', () => {
+    const buf = embeddings.serializeEmbedding([])
+    const restored = embeddings.deserializeEmbedding(buf)
+    assert.equal(restored.length, 0)
+  })
+
+  it('roundtrips a large embedding (384 dimensions)', () => {
+    const original = Array.from({ length: 384 }, (_, i) => Math.sin(i) * 0.5)
+    const buf = embeddings.serializeEmbedding(original)
+    assert.equal(buf.byteLength, 384 * 4) // Float32 = 4 bytes each
+    const restored = embeddings.deserializeEmbedding(buf)
+    assert.equal(restored.length, 384)
+    for (let i = 0; i < original.length; i++) {
+      assert.ok(Math.abs(restored[i] - original[i]) < 1e-6)
+    }
+  })
+
+  it('serialize produces a Buffer', () => {
+    const buf = embeddings.serializeEmbedding([1, 2, 3])
+    assert.ok(Buffer.isBuffer(buf))
+  })
+
+  it('preserves special float values', () => {
+    const original = [0, -0, Infinity, -Infinity]
+    const buf = embeddings.serializeEmbedding(original)
+    const restored = embeddings.deserializeEmbedding(buf)
+    assert.equal(restored[0], 0)
+    assert.equal(restored[2], Infinity)
+    assert.equal(restored[3], -Infinity)
+  })
+})

package/src/lib/server/ethereum.ts

@@ -15,6 +15,7 @@ import {
 } from 'ethers'
 
 import { decryptKey, encryptKey } from './storage'
+import { errorMessage } from '@/lib/shared-utils'
 
 export type EvmNetworkId = 'ethereum' | 'arbitrum' | 'base'
 
@@ -490,7 +491,7 @@ export async function simulateEthereumTransaction(
       `estimate gas on ${network.label}`,
     )).toString()
   } catch (err: unknown) {
-    callError = err instanceof Error ? err.message : String(err)
+    callError = errorMessage(err)
   }
 
   try {
@@ -499,7 +500,7 @@ export async function simulateEthereumTransaction(
       `simulate transaction call on ${network.label}`,
     )
   } catch (err: unknown) {
-    if (!callError) callError = err instanceof Error ? err.message : String(err)
+    if (!callError) callError = errorMessage(err)
   }
 
   return {

package/src/lib/server/eval/agent-regression.ts

@@ -5,6 +5,7 @@ import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { genId } from '@/lib/id'
 import type { ApprovalRequest, MessageToolEvent, Session } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 import { submitDecision } from '../approvals'
 import { executeSessionChatTurn, type ExecuteChatTurnResult } from '../chat-execution'
 import { WORKSPACE_DIR } from '../data-dir'
@@ -850,11 +851,11 @@ export function resolveRegressionPlugins(
   agent: Record<string, unknown>,
   pluginMode: RegressionPluginMode,
 ): RegressionPluginResolution {
-  const requiredCanonical = Array.from(new Set(
+  const requiredCanonical = dedup(
     normalizePluginList(requiredPlugins)
       .map((plugin) => canonicalizePluginId(plugin))
       .filter(Boolean),
-  ))
+  )
   if (pluginMode === 'scenario') {
     return {
       requiredPlugins: requiredCanonical,

package/src/lib/server/eval/runner.ts

@@ -9,6 +9,7 @@ import { loadSessions, saveSessions, loadAgents, loadCredentials, decryptKey } f
 import { executeSessionChatTurn } from '../chat-execution'
 import { WORKSPACE_DIR } from '../data-dir'
 import type { Session } from '@/types'
+import { errorMessage } from '@/lib/shared-utils'
 
 export function resolveEvalSessionCwd(runId: string): string {
   const dir = path.join(WORKSPACE_DIR, 'evals', runId)
@@ -98,7 +99,7 @@ export async function runEvalScenario(scenarioId: string, agentId: string): Prom
     run.endedAt = Date.now()
   } catch (err: unknown) {
     run.status = 'failed'
-    run.error = err instanceof Error ? err.message : String(err)
+    run.error = errorMessage(err)
     run.endedAt = Date.now()
   } finally {
     // Clean up eval session

package/src/lib/server/eval/scorer.ts

@@ -1,5 +1,6 @@
 import type { ScoringCriterion, EvalCriterionResult } from './types'
 import type { MessageToolEvent } from '@/types'
+import { errorMessage } from '@/lib/shared-utils'
 
 export async function scoreCriteria(
   criteria: ScoringCriterion[],
@@ -84,7 +85,7 @@ export async function scoreCriteria(
             criterion: criterion.name,
             score: 0,
             maxScore: criterion.weight,
-            evidence: `LLM judge error: ${err instanceof Error ? err.message : String(err)}`,
+            evidence: `LLM judge error: ${errorMessage(err)}`,
           })
         }
         break

package/src/lib/server/evm-swap.ts

@@ -5,6 +5,7 @@ import type { AgentWallet, WalletAssetBalance } from '@/types'
 
 import { getEvmNetworkConfig, getProviderForNetwork, type EvmNetworkId } from './ethereum'
 import { getWalletPortfolioSnapshot } from './wallet-service'
+import { errorMessage } from '@/lib/shared-utils'
 
 const PARASWAP_API_BASE = 'https://api.paraswap.io'
 const PARASWAP_VERSION = '6.2'
@@ -470,6 +471,6 @@ export async function prepareEvmSwapPlan(input: PrepareEvmSwapPlanInput): Promis
 }
 
 export function isLikelyRetryableSwapError(err: unknown): boolean {
-  const message = err instanceof Error ? err.message : String(err)
+  const message = errorMessage(err)
   return /rate|price|slippage|expired|call exception|execution reverted|insufficient output/i.test(message)
 }

package/src/lib/server/gateway/protocol.test.ts

@@ -4,7 +4,7 @@ import {
   createGatewayRequestFrame,
   parseGatewayFrame,
   serializeGatewayFrame,
-} from './protocol.ts'
+} from './protocol'
 
 test('gateway protocol parses request/response/event frames', () => {
   const req = parseGatewayFrame('{"type":"req","id":"1","method":"connect","params":{"foo":"bar"}}')

package/src/lib/server/guardian.ts

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process'
 import path from 'path'
 import fs from 'fs'
+import { errorMessage } from '@/lib/shared-utils'
 
 /**
  * OpenClaw Guardian — Auto-Rollback capability.
@@ -29,6 +30,6 @@ export function performGuardianRollback(cwd: string): { ok: boolean; reason?: st
     return { ok: true }
   } catch (err: unknown) {
     console.error('[guardian] Auto-rollback failed:', err)
-    return { ok: false, reason: `Git operation failed: ${err instanceof Error ? err.message : String(err)}` }
+    return { ok: false, reason: `Git operation failed: ${errorMessage(err)}` }
   }
 }

package/src/lib/server/heartbeat-blocked-suppression.test.ts

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import {
+  stripBlockedItems,
+  isHeartbeatContentEffectivelyEmpty,
+  buildAgentHeartbeatPrompt,
+} from './heartbeat-service'
+
+describe('heartbeat blocked-item suppression', () => {
+  describe('stripBlockedItems', () => {
+    it('removes checklist items marked (blocked, no update)', () => {
+      const input = [
+        '# Heartbeat Tasks',
+        '## Active',
+        '- [ ] Pull SWGOH roster data (blocked, no update)',
+        '- [ ] Send daily summary',
+        '## Completed',
+        '- [x] Do laundry',
+      ].join('\n')
+
+      const result = stripBlockedItems(input)
+
+      assert.ok(!result.includes('SWGOH'), 'blocked item should be stripped')
+      assert.ok(result.includes('Send daily summary'), 'non-blocked item should remain')
+      assert.ok(result.includes('Do laundry'), 'completed item should remain')
+      assert.ok(result.includes('# Heartbeat Tasks'), 'headers should remain')
+    })
+
+    it('removes items with various blocked markers', () => {
+      const input = [
+        '- [ ] Task A (blocked: awaiting input)',
+        '- [ ] Task B (Blocked, pending user decision)',
+        '- [ ] Task C (BLOCKED)',
+        '- [ ] Task D - normal task',
+        '* [ ] Task E (blocked, no update)',
+      ].join('\n')
+
+      const result = stripBlockedItems(input)
+
+      assert.ok(!result.includes('Task A'), 'blocked: variant stripped')
+      assert.ok(!result.includes('Task B'), 'Blocked, variant stripped')
+      assert.ok(!result.includes('Task C'), 'BLOCKED variant stripped')
+      assert.ok(result.includes('Task D'), 'non-blocked task preserved')
+      assert.ok(!result.includes('Task E'), 'asterisk list item stripped')
+    })
+
+    it('preserves non-list lines that mention "blocked"', () => {
+      const input = [
+        '## Notes',
+        'Some items are blocked until user responds.',
+        '- [ ] Actual blocked task (blocked, no update)',
+      ].join('\n')
+
+      const result = stripBlockedItems(input)
+
+      assert.ok(result.includes('Some items are blocked'), 'prose mentioning blocked should stay')
+      assert.ok(!result.includes('Actual blocked task'), 'blocked list item should be stripped')
+    })
+
+    it('returns empty string for empty input', () => {
+      assert.equal(stripBlockedItems(''), '')
+      assert.equal(stripBlockedItems(null as unknown as string), '')
+    })
+
+    it('returns content unchanged when no blocked items', () => {
+      const input = '- [ ] Task A\n- [ ] Task B\n'
+      assert.equal(stripBlockedItems(input), input)
+    })
+  })
+
+  describe('blocked items + effectively empty', () => {
+    it('treats content with only blocked items as effectively empty', () => {
+      const input = [
+        '# Heartbeat Tasks',
+        '## Active',
+        '- [ ] Pull SWGOH data (blocked, no update)',
+        '## Completed',
+      ].join('\n')
+
+      const stripped = stripBlockedItems(input)
+      // After stripping, only headers remain — effectively empty
+      assert.equal(isHeartbeatContentEffectivelyEmpty(stripped), true)
+    })
+
+    it('treats content with blocked + active items as not empty', () => {
+      const input = [
+        '# Heartbeat Tasks',
+        '## Active',
+        '- [ ] Pull SWGOH data (blocked, no update)',
+        '- [ ] Send daily summary',
+      ].join('\n')
+
+      const stripped = stripBlockedItems(input)
+      assert.equal(isHeartbeatContentEffectivelyEmpty(stripped), false)
+    })
+  })
+
+  describe('buildAgentHeartbeatPrompt integration', () => {
+    it('does not include blocked items in the prompt sent to the LLM', () => {
+      const session = {
+        id: 'test-session',
+        cwd: '/tmp',
+        messages: [],
+      }
+      const agent = {
+        id: 'test-agent',
+        name: 'Test',
+        description: 'Test agent',
+      }
+
+      const heartbeatFileContent = [
+        '# Heartbeat Tasks',
+        '## Active',
+        '- [ ] Pull SWGOH roster data (blocked, no update)',
+        '- [ ] Check weather forecast',
+        '## Completed',
+        '- [x] Laundry done',
+      ].join('\n')
+
+      const prompt = buildAgentHeartbeatPrompt(session, agent, 'default prompt', heartbeatFileContent)
+
+      assert.ok(!prompt.includes('SWGOH'), 'blocked SWGOH task should not appear in prompt')
+      assert.ok(prompt.includes('Check weather forecast'), 'non-blocked task should appear')
+      assert.ok(prompt.includes('Laundry done'), 'completed task should appear')
+    })
+
+    it('produces no HEARTBEAT.md section when all active items are blocked', () => {
+      const session = {
+        id: 'test-session',
+        cwd: '/tmp',
+        messages: [],
+      }
+      const agent = {
+        id: 'test-agent',
+        name: 'Test',
+        description: 'Test agent',
+      }
+
+      const heartbeatFileContent = [
+        '# Heartbeat Tasks',
+        '## Active',
+        '- [ ] Task A (blocked, no update)',
+        '- [ ] Task B (blocked: awaiting user)',
+      ].join('\n')
+
+      const prompt = buildAgentHeartbeatPrompt(session, agent, 'default prompt', heartbeatFileContent)
+
+      assert.ok(!prompt.includes('HEARTBEAT.md contents:'), 'should not include HEARTBEAT.md section when all items are blocked')
+    })
+  })
+})

package/src/lib/server/heartbeat-service-timer.test.ts

@@ -37,9 +37,9 @@ describe('heartbeat-service scheduling', () => {
   it('does not fire periodic heartbeats for agents that are explicitly off', () => {
     const output = runWithTempDataDir(`
       const { setTimeout: delay } = await import('node:timers/promises')
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const heartbeatMod = await import('./src/lib/server/heartbeat-service.ts')
-      const runsMod = await import('./src/lib/server/session-run-manager.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const heartbeatMod = await import('./src/lib/server/heartbeat-service')
+      const runsMod = await import('./src/lib/server/session-run-manager')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
       const heartbeat = heartbeatMod.default || heartbeatMod['module.exports'] || heartbeatMod
       const runs = runsMod.default || runsMod['module.exports'] || runsMod
@@ -100,9 +100,9 @@ describe('heartbeat-service scheduling', () => {
   it('fires periodic heartbeats only after the service tick window when enabled', () => {
     const output = runWithTempDataDir(`
       const { setTimeout: delay } = await import('node:timers/promises')
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const heartbeatMod = await import('./src/lib/server/heartbeat-service.ts')
-      const runsMod = await import('./src/lib/server/session-run-manager.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const heartbeatMod = await import('./src/lib/server/heartbeat-service')
+      const runsMod = await import('./src/lib/server/session-run-manager')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
       const heartbeat = heartbeatMod.default || heartbeatMod['module.exports'] || heartbeatMod
       const runs = runsMod.default || runsMod['module.exports'] || runsMod