@swarmclawai/swarmclaw 0.7.2 → 0.7.4

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

@@ -1,3 +1,5 @@
+import fs from 'node:fs'
+import path from 'node:path'
 import { genId } from '@/lib/id'
 import type { EvalScenario, EvalRun, EvalSuiteResult } from './types'
 import { getScenario, EVAL_SCENARIOS } from './scenarios'
@@ -5,8 +7,15 @@ import { scoreCriteria } from './scorer'
 import { saveEvalRun } from './store'
 import { loadSessions, saveSessions, loadAgents, loadCredentials, decryptKey } from '../storage'
 import { executeSessionChatTurn } from '../chat-execution'
+import { WORKSPACE_DIR } from '../data-dir'
 import type { Session } from '@/types'
 
+export function resolveEvalSessionCwd(runId: string): string {
+  const dir = path.join(WORKSPACE_DIR, 'evals', runId)
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
 export async function runEvalScenario(scenarioId: string, agentId: string): Promise<EvalRun> {
   const scenario = getScenario(scenarioId)
   if (!scenario) throw new Error(`Unknown eval scenario: ${scenarioId}`)
@@ -18,6 +27,7 @@ export async function runEvalScenario(scenarioId: string, agentId: string): Prom
   const runId = genId()
   const sessionId = `eval-${runId}`
   const now = Date.now()
+  const sessionCwd = resolveEvalSessionCwd(runId)
 
   const run: EvalRun = {
     id: runId,
@@ -36,7 +46,7 @@ export async function runEvalScenario(scenarioId: string, agentId: string): Prom
   const evalSession: Session = {
     id: sessionId,
     name: `Eval: ${scenario.name}`,
-    cwd: process.cwd(),
+    cwd: sessionCwd,
     user: 'eval-runner',
     provider: (agent.provider as Session['provider']) ?? 'anthropic',
     model: (agent.model as string) ?? '',

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

@@ -1,8 +1,9 @@
 import Database from 'better-sqlite3'
 import path from 'path'
 import type { EvalRun } from './types'
+import { DATA_DIR } from '../data-dir'
 
-const DB_PATH = path.join(process.cwd(), 'data', 'eval-runs.db')
+const DB_PATH = path.join(DATA_DIR, 'eval-runs.db')
 
 let db: Database.Database | null = null
 

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

@@ -1,11 +1,17 @@
 import fs from 'fs'
 import path from 'path'
+import {
+  DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
+  DEFAULT_HEARTBEAT_INTERVAL_SEC,
+  DEFAULT_HEARTBEAT_SHOW_ALERTS,
+  DEFAULT_HEARTBEAT_SHOW_OK,
+} from '@/lib/heartbeat-defaults'
 import { loadAgents, loadSessions, loadSettings } from './storage'
 import { enqueueSessionRun, getSessionRunState } from './session-run-manager'
 import { log } from './logger'
-import { buildMainLoopHeartbeatPrompt, getMainLoopStateForSession, isMainSession } from './main-agent-loop'
 import { WORKSPACE_DIR } from './data-dir'
 import { drainSystemEvents } from './system-events'
+import { buildIdentityContinuityContext } from './identity-continuity'
 
 const HEARTBEAT_TICK_MS = 5_000
 
@@ -188,6 +194,7 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
   if (!agent) return fallbackPrompt
 
   const identityContext = buildIdentityContext(session, agent)
+  const continuityContext = buildIdentityContinuityContext(session, agent)
   // Drain system events accumulated since last heartbeat
   const events = drainSystemEvents(session.id)
   const eventBlock = events.length > 0
@@ -219,6 +226,7 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     'AGENT_HEARTBEAT_TICK',
     `Time: ${new Date().toISOString()}`,
     identityContext,
+    continuityContext,
     description ? `Description: ${description}` : '',
     eventBlock ? `Events since last heartbeat:\n${eventBlock}` : '',
     dynamicGoal
@@ -242,14 +250,6 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
   ].filter(Boolean).join('\n')
 }
 
-function applyMomentumMultiplier(intervalSec: number, momentumScore: number): number {
-  let multiplier = 1.0
-  if (momentumScore >= 80) multiplier = 0.5
-  else if (momentumScore < 40) multiplier = 2.0
-  const adjusted = Math.round(intervalSec * multiplier)
-  return Math.max(30, Math.min(7200, adjusted))
-}
-
 function resolveInterval(obj: Record<string, any>, currentSec: number): number {
   // Prefer heartbeatInterval (duration string) over heartbeatIntervalSec (raw number)
   if (obj.heartbeatInterval !== undefined && obj.heartbeatInterval !== null) {
@@ -281,7 +281,7 @@ function resolveNum(obj: Record<string, any>, key: string, current: number): num
 
 function heartbeatConfigForSession(session: any, settings: Record<string, any>, agents: Record<string, any>): HeartbeatConfig {
   // Global defaults — 30 min interval (was 120s)
-  let intervalSec = resolveInterval(settings, 1800)
+  let intervalSec = resolveInterval(settings, DEFAULT_HEARTBEAT_INTERVAL_SEC)
   const globalPrompt = (typeof settings.heartbeatPrompt === 'string' && settings.heartbeatPrompt.trim())
     ? settings.heartbeatPrompt.trim()
     : DEFAULT_HEARTBEAT_PROMPT
@@ -289,9 +289,9 @@ function heartbeatConfigForSession(session: any, settings: Record<string, any>,
   let enabled = intervalSec > 0
   let prompt = globalPrompt
   let model: string | null = resolveStr(settings, 'heartbeatModel', null)
-  let ackMaxChars = resolveNum(settings, 'heartbeatAckMaxChars', 300)
-  let showOk = resolveBool(settings, 'heartbeatShowOk', false)
-  let showAlerts = resolveBool(settings, 'heartbeatShowAlerts', true)
+  let ackMaxChars = resolveNum(settings, 'heartbeatAckMaxChars', DEFAULT_HEARTBEAT_ACK_MAX_CHARS)
+  let showOk = resolveBool(settings, 'heartbeatShowOk', DEFAULT_HEARTBEAT_SHOW_OK)
+  let showAlerts = resolveBool(settings, 'heartbeatShowAlerts', DEFAULT_HEARTBEAT_SHOW_ALERTS)
   let target: string | null = resolveStr(settings, 'heartbeatTarget', null)
 
   // Agent layer overrides
@@ -378,7 +378,7 @@ async function tickHeartbeats() {
   for (const session of Object.values(sessions) as any[]) {
     if (!session?.id) continue
     if (!Array.isArray(session.plugins) || session.plugins.length === 0) continue
-    if (session.sessionType && session.sessionType !== 'human' && session.sessionType !== 'orchestrated') continue
+    if (session.sessionType && session.sessionType !== 'human') continue
 
     // Check if this session or its agent has explicit heartbeat opt-in
     const agent = session.agentId ? agents[session.agentId] : null
@@ -395,10 +395,6 @@ async function tickHeartbeats() {
     const cfg = heartbeatConfigForSession(session, settings, agents)
     if (!cfg.enabled) continue
 
-    // Apply momentum-based multiplier to heartbeat interval
-    const momentumScore = session.mainLoopState?.momentumScore ?? 40
-    cfg.intervalSec = applyMomentumMultiplier(cfg.intervalSec, momentumScore)
-
     // For sessions with explicit opt-in, use a shorter idle threshold (just intervalSec * 2).
     // For inherited/global heartbeats, keep the 180s minimum to avoid noisy auto-fire.
     const defaultIdleSec = explicitOptIn
@@ -410,38 +406,22 @@ async function tickHeartbeats() {
     const idleMs = now - lastUserAt
     if (idleMs < userIdleThresholdSec * 1000) continue
 
-    if (isMainSession(session)) {
-      const loopState = getMainLoopStateForSession(session.id)
-      if (loopState?.paused) continue
-      // Only suppress idle main sessions when heartbeat is inherited (not explicitly enabled)
-      if (!explicitOptIn) {
-        const loopStatus = loopState?.status || 'idle'
-        const pendingEvents = loopState?.pendingEvents?.length || 0
-        if ((loopStatus === 'ok' || loopStatus === 'idle') && pendingEvents === 0) continue
-      }
-    }
-
     const last = state.lastBySession.get(session.id) || 0
     if (now - last < cfg.intervalSec * 1000) continue
 
     const runState = getSessionRunState(session.id)
     if (runState.runningRunId) continue
 
-    let heartbeatMessage: string
-    if (isMainSession(session)) {
-      heartbeatMessage = buildMainLoopHeartbeatPrompt(session, cfg.prompt)
-    } else {
-      const rawHeartbeatFileContent = readHeartbeatFile(session)
-      const heartbeatFileContent = isHeartbeatContentEffectivelyEmpty(rawHeartbeatFileContent) ? '' : rawHeartbeatFileContent
-      const hasGoal = !!(agent?.heartbeatGoal || agent?.description || agent?.systemPrompt || agent?.soul)
-      const hasCustomPrompt = cfg.prompt !== DEFAULT_HEARTBEAT_PROMPT
-      // Skip heartbeat only if there's truly nothing to drive it:
-      // no agent goal, no HEARTBEAT.md content, AND no custom prompt configured
-      if (!hasGoal && !heartbeatFileContent && !hasCustomPrompt) {
-        continue
-      }
-      heartbeatMessage = buildAgentHeartbeatPrompt(session, agent, cfg.prompt, heartbeatFileContent)
+    const rawHeartbeatFileContent = readHeartbeatFile(session)
+    const heartbeatFileContent = isHeartbeatContentEffectivelyEmpty(rawHeartbeatFileContent) ? '' : rawHeartbeatFileContent
+    const hasGoal = !!(agent?.heartbeatGoal || agent?.description || agent?.systemPrompt || agent?.soul)
+    const hasCustomPrompt = cfg.prompt !== DEFAULT_HEARTBEAT_PROMPT
+    // Skip heartbeat only if there's truly nothing to drive it:
+    // no agent goal, no HEARTBEAT.md content, AND no custom prompt configured
+    if (!hasGoal && !heartbeatFileContent && !hasCustomPrompt) {
+      continue
     }
+    const heartbeatMessage = buildAgentHeartbeatPrompt(session, agent, cfg.prompt, heartbeatFileContent)
 
     const enqueue = enqueueSessionRun({
       sessionId: session.id,

package/src/lib/server/heartbeat-source.test.ts

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { isHeartbeatSource, isInternalHeartbeatRun } from './heartbeat-source'
+
+describe('heartbeat-source', () => {
+  it('treats scheduled heartbeat polls as heartbeat traffic', () => {
+    assert.equal(isHeartbeatSource('heartbeat'), true)
+    assert.equal(isInternalHeartbeatRun(true, 'heartbeat'), true)
+  })
+
+  it('treats wake-triggered heartbeat polls as heartbeat traffic', () => {
+    assert.equal(isHeartbeatSource('heartbeat-wake'), true)
+    assert.equal(isInternalHeartbeatRun(true, 'heartbeat-wake'), true)
+  })
+
+  it('does not classify other sources as heartbeat traffic', () => {
+    assert.equal(isHeartbeatSource('task'), false)
+    assert.equal(isHeartbeatSource('chat'), false)
+    assert.equal(isInternalHeartbeatRun(false, 'heartbeat'), false)
+    assert.equal(isInternalHeartbeatRun(true, 'task'), false)
+  })
+})

package/src/lib/server/heartbeat-source.ts

@@ -0,0 +1,7 @@
+export function isHeartbeatSource(source: string | null | undefined): boolean {
+  return source === 'heartbeat' || source === 'heartbeat-wake'
+}
+
+export function isInternalHeartbeatRun(internal: boolean | null | undefined, source: string | null | undefined): boolean {
+  return internal === true && isHeartbeatSource(source)
+}

package/src/lib/server/identity-continuity.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import type { Session } from '@/types'
+import { buildIdentityContinuityContext, refreshSessionIdentityState } from './identity-continuity'
+
+test('buildIdentityContinuityContext merges agent and session continuity', () => {
+  const block = buildIdentityContinuityContext(
+    {
+      name: 'Thread A',
+      conversationTone: 'technical',
+      identityState: {
+        personaLabel: 'Debugger',
+        relationshipSummary: 'Working with the user on a production issue.',
+      },
+    } as Partial<Session>,
+    {
+      name: 'Swarmy',
+      description: 'Helpful coding agent',
+      identityState: {
+        boundaries: ['Do not pretend work is complete without evidence.'],
+        continuityNotes: ['User prefers concise explanations.'],
+      },
+    },
+  )
+
+  assert.match(block, /Identity Continuity/)
+  assert.match(block, /Current persona: Debugger/)
+  assert.match(block, /Observed tone: technical/)
+  assert.match(block, /User prefers concise explanations/)
+})
+
+test('refreshSessionIdentityState derives fallback continuity fields', () => {
+  const session = {
+    id: 's1',
+    name: 'Checkout Bug',
+    cwd: process.cwd(),
+    user: 'Taylor',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    messages: [{ role: 'user', text: 'Help', time: 1 }],
+    createdAt: 1,
+    lastActiveAt: 1,
+    conversationTone: 'focused',
+    connectorContext: { threadId: 'thread-9', senderName: 'Taylor' },
+  } as Session
+
+  const state = refreshSessionIdentityState(session, {
+    name: 'Swarmy',
+    description: 'Helpful coding agent',
+  }, 100)
+
+  assert.equal(state.personaLabel, 'Swarmy thread thread-9')
+  assert.equal(state.relationshipSummary, 'Ongoing conversation with Taylor.')
+  assert.equal(state.toneStyle, 'focused')
+  assert.equal(state.updatedAt, 100)
+})
+
+test('buildIdentityContinuityContext prefers thread persona labels from connector context', () => {
+  const block = buildIdentityContinuityContext(
+    {
+      name: 'Connector Session',
+      connectorContext: {
+        threadId: 'thread-9',
+        threadPersonaLabel: 'Checkout Incident',
+      },
+    } as Partial<Session>,
+    {
+      name: 'Swarmy',
+      description: 'Helpful coding agent',
+    },
+  )
+
+  assert.match(block, /Current persona: Checkout Incident/)
+})

package/src/lib/server/identity-continuity.ts

@@ -0,0 +1,127 @@
+import type { Agent, IdentityContinuityState, Session } from '@/types'
+
+function normalizeText(value: unknown, maxChars: number): string | null {
+  if (typeof value !== 'string') return null
+  const normalized = value.replace(/\s+/g, ' ').trim()
+  return normalized ? normalized.slice(0, maxChars) : null
+}
+
+function normalizeList(value: unknown, maxItems: number, maxChars: number): string[] {
+  if (!Array.isArray(value)) return []
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const raw of value) {
+    const normalized = normalizeText(raw, maxChars)
+    if (!normalized) continue
+    const key = normalized.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(normalized)
+    if (out.length >= maxItems) break
+  }
+  return out
+}
+
+export function normalizeIdentityContinuityState(raw: unknown): IdentityContinuityState | null {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+  const record = raw as Record<string, unknown>
+  const state: IdentityContinuityState = {
+    selfSummary: normalizeText(record.selfSummary, 320),
+    relationshipSummary: normalizeText(record.relationshipSummary, 320),
+    personaLabel: normalizeText(record.personaLabel, 120),
+    toneStyle: normalizeText(record.toneStyle, 120),
+    boundaries: normalizeList(record.boundaries, 6, 180),
+    continuityNotes: normalizeList(record.continuityNotes, 8, 220),
+    updatedAt: typeof record.updatedAt === 'number' && Number.isFinite(record.updatedAt)
+      ? Math.trunc(record.updatedAt)
+      : null,
+  }
+  return state
+}
+
+function fallbackSelfSummary(agent?: Partial<Agent> | null): string | null {
+  const description = normalizeText(agent?.description, 220)
+  if (description) return `${agent?.name || 'Agent'}: ${description}`
+  const soul = normalizeText(agent?.soul, 220)
+  if (soul) return `${agent?.name || 'Agent'}: ${soul}`
+  const name = normalizeText(agent?.name, 80)
+  return name ? `${name}: persistent companion agent` : null
+}
+
+function fallbackPersonaLabel(session?: Partial<Session> | null, agent?: Partial<Agent> | null): string | null {
+  const threadPersona = normalizeText(session?.connectorContext?.threadPersonaLabel, 120)
+  if (threadPersona) return threadPersona
+  const threadTitle = normalizeText(session?.connectorContext?.threadTitle, 120)
+  if (threadTitle) return threadTitle
+  const threadId = normalizeText(session?.connectorContext?.threadId, 80)
+  if (threadId) return `${agent?.name || 'Agent'} thread ${threadId}`
+  const sessionName = normalizeText(session?.name, 120)
+  if (sessionName && !/^new chat$/i.test(sessionName)) return sessionName
+  return null
+}
+
+function fallbackRelationshipSummary(session?: Partial<Session> | null): string | null {
+  const sender = normalizeText(session?.connectorContext?.senderName, 80)
+  if (sender) return `Ongoing conversation with ${sender}.`
+  const user = normalizeText(session?.user, 80)
+  if (user && user !== 'user') return `Ongoing conversation with ${user}.`
+  return 'Ongoing conversation with the user.'
+}
+
+export function buildIdentityContinuityContext(
+  session?: Partial<Session> | null,
+  agent?: Partial<Agent> | null,
+): string {
+  const agentState = normalizeIdentityContinuityState(agent?.identityState)
+  const sessionState = normalizeIdentityContinuityState(session?.identityState)
+  const selfSummary = sessionState?.selfSummary || agentState?.selfSummary || fallbackSelfSummary(agent)
+  const relationshipSummary = sessionState?.relationshipSummary || agentState?.relationshipSummary || fallbackRelationshipSummary(session)
+  const personaLabel = sessionState?.personaLabel || fallbackPersonaLabel(session, agent)
+  const toneStyle = sessionState?.toneStyle || normalizeText(session?.conversationTone, 80) || agentState?.toneStyle
+  const boundaries = sessionState?.boundaries?.length
+    ? sessionState.boundaries
+    : agentState?.boundaries?.length
+      ? agentState.boundaries
+      : []
+  const continuityNotes = [
+    ...(agentState?.continuityNotes || []),
+    ...(sessionState?.continuityNotes || []),
+  ].slice(-6)
+
+  const lines: string[] = []
+  if (selfSummary) lines.push(`Core self: ${selfSummary}`)
+  if (personaLabel) lines.push(`Current persona: ${personaLabel}`)
+  if (relationshipSummary) lines.push(`Relationship context: ${relationshipSummary}`)
+  if (toneStyle) lines.push(`Observed tone: ${toneStyle}`)
+  if (boundaries.length) lines.push(`Boundaries: ${boundaries.join(' | ')}`)
+  if (continuityNotes.length) lines.push(`Continuity notes: ${continuityNotes.join(' | ')}`)
+  if (!lines.length) return ''
+  return `## Identity Continuity\n${lines.join('\n')}`
+}
+
+export function refreshSessionIdentityState(
+  session: Session,
+  agent?: Partial<Agent> | null,
+  now = Date.now(),
+): IdentityContinuityState {
+  const existing = normalizeIdentityContinuityState(session.identityState) || {}
+  const agentState = normalizeIdentityContinuityState(agent?.identityState) || {}
+  const boundaries = existing.boundaries?.length ? existing.boundaries : (agentState.boundaries || [])
+  const continuityNotes = [
+    ...(agentState.continuityNotes || []),
+    ...(existing.continuityNotes || []),
+  ].slice(-8)
+
+  const next: IdentityContinuityState = {
+    selfSummary: existing.selfSummary || agentState.selfSummary || fallbackSelfSummary(agent),
+    relationshipSummary: existing.relationshipSummary || agentState.relationshipSummary || fallbackRelationshipSummary(session),
+    personaLabel: existing.personaLabel || fallbackPersonaLabel(session, agent),
+    toneStyle: normalizeText(session.conversationTone, 80) || existing.toneStyle || agentState.toneStyle,
+    boundaries,
+    continuityNotes,
+    updatedAt: now,
+  }
+
+  session.identityState = next
+  return next
+}