@swarmclawai/swarmclaw 0.7.1 → 0.7.3

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

@@ -0,0 +1,397 @@
+import fs from 'fs'
+import path from 'path'
+import { spawnSync } from 'child_process'
+import * as cheerio from 'cheerio'
+import { findBinaryOnPath } from './session-tools/context'
+
+const TEXT_EXTENSIONS = new Set([
+  '.txt', '.md', '.markdown', '.json', '.jsonl', '.csv', '.tsv',
+  '.ts', '.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'])
+
+export interface StructuredTable {
+  name: string
+  headers: string[]
+  rows: Array<Record<string, unknown>>
+  rowCount: number
+}
+
+export interface DocumentArtifact {
+  filePath: string
+  fileName: string
+  ext: string
+  method: string
+  text: string
+  metadata: Record<string, unknown>
+  tables: StructuredTable[]
+}
+
+function trimText(text: string, maxChars = 200_000): string {
+  const normalized = text.replace(/\r\n/g, '\n').replace(/\u0000/g, '').trim()
+  if (normalized.length <= maxChars) return normalized
+  return `${normalized.slice(0, maxChars)}\n... [truncated]`
+}
+
+function normalizeScalar(value: unknown): unknown {
+  if (value === undefined) return null
+  if (value === null) return null
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string') return value
+  if (value instanceof Date) return value.toISOString()
+  return String(value)
+}
+
+function parseDelimitedText(input: string, delimiter: string): string[][] {
+  const rows: string[][] = []
+  let row: string[] = []
+  let field = ''
+  let inQuotes = false
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index]
+    const next = input[index + 1]
+
+    if (inQuotes) {
+      if (char === '"' && next === '"') {
+        field += '"'
+        index += 1
+        continue
+      }
+      if (char === '"') {
+        inQuotes = false
+        continue
+      }
+      field += char
+      continue
+    }
+
+    if (char === '"') {
+      inQuotes = true
+      continue
+    }
+    if (char === delimiter) {
+      row.push(field)
+      field = ''
+      continue
+    }
+    if (char === '\n') {
+      row.push(field)
+      rows.push(row)
+      row = []
+      field = ''
+      continue
+    }
+    if (char === '\r') continue
+    field += char
+  }
+
+  if (field.length > 0 || row.length > 0) {
+    row.push(field)
+    rows.push(row)
+  }
+
+  return rows.filter((cells) => cells.some((cell) => cell.trim().length > 0))
+}
+
+function matrixToTable(name: string, matrix: string[][]): StructuredTable {
+  if (matrix.length === 0) return { name, headers: [], rows: [], rowCount: 0 }
+  const headerRow = matrix[0].map((cell, index) => cell.trim() || `column_${index + 1}`)
+  const rows = matrix.slice(1).map((cells) => {
+    const row: Record<string, unknown> = {}
+    for (let index = 0; index < headerRow.length; index += 1) {
+      row[headerRow[index]] = cells[index] ?? ''
+    }
+    return row
+  })
+  return {
+    name,
+    headers: headerRow,
+    rows,
+    rowCount: rows.length,
+  }
+}
+
+function objectsToTable(name: string, rows: Array<Record<string, unknown>>): StructuredTable {
+  const headers = Array.from(new Set(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])
+    return out
+  })
+  return {
+    name,
+    headers,
+    rows: normalizedRows,
+    rowCount: normalizedRows.length,
+  }
+}
+
+function tablesToText(tables: StructuredTable[]): string {
+  return tables
+    .map((table) => {
+      const header = table.headers.join('\t')
+      const body = table.rows.slice(0, 100).map((row) => table.headers.map((key) => String(row[key] ?? '')).join('\t')).join('\n')
+      return `${table.name}\n${header}${body ? `\n${body}` : ''}`
+    })
+    .join('\n\n')
+}
+
+function worksheetRowToArray(values: unknown): unknown[] {
+  if (Array.isArray(values)) return values.slice(1)
+  if (values && typeof values === 'object') {
+    return Object.entries(values as Record<string, unknown>)
+      .filter(([key]) => Number.isFinite(Number(key)) && Number(key) >= 1)
+      .sort((left, right) => Number(left[0]) - Number(right[0]))
+      .map(([, value]) => value)
+  }
+  return []
+}
+
+function listZipEntries(filePath: string): { entries: string[]; method: string } {
+  const unzip = findBinaryOnPath('unzip') || findBinaryOnPath('zipinfo')
+  if (!unzip) throw new Error('ZIP listing requires `unzip` or `zipinfo` on PATH.')
+  const args = path.basename(unzip).includes('zipinfo') ? ['-1', filePath] : ['-Z1', filePath]
+  const out = spawnSync(unzip, args, {
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+    timeout: 20_000,
+  })
+  if ((out.status ?? 1) !== 0) {
+    throw new Error(`Failed to inspect ZIP: ${(out.stderr || out.stdout || '').trim() || 'unknown error'}`)
+  }
+  const entries = (out.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  return { entries, method: path.basename(unzip) }
+}
+
+async function extractPdfText(filePath: string): Promise<{ text: string; method: string }> {
+  try {
+    const pdfMod = await import(/* webpackIgnore: true */ 'pdf-parse')
+    const pdfParse = ((pdfMod as Record<string, unknown>).default ?? pdfMod) as (buf: Buffer) => Promise<{ text: string }>
+    const result = await pdfParse(fs.readFileSync(filePath))
+    if ((result.text || '').trim()) {
+      return { text: result.text, method: 'pdf-parse' }
+    }
+  } catch {
+    // fall through to pdftotext
+  }
+
+  const pdftotext = findBinaryOnPath('pdftotext')
+  if (!pdftotext) throw new Error('PDF extraction requires `pdf-parse` or `pdftotext`.')
+  const out = spawnSync(pdftotext, ['-layout', '-nopgbrk', '-q', filePath, '-'], {
+    encoding: 'utf-8',
+    maxBuffer: 25 * 1024 * 1024,
+    timeout: 20_000,
+  })
+  if ((out.status ?? 1) !== 0) {
+    throw new Error(`pdftotext failed: ${(out.stderr || out.stdout || '').trim() || 'unknown error'}`)
+  }
+  return { text: out.stdout || '', method: 'pdftotext' }
+}
+
+function extractImageText(filePath: string): { text: string; method: string } {
+  const tesseract = findBinaryOnPath('tesseract')
+  if (!tesseract) {
+    throw new Error('Image OCR requires `tesseract` on PATH.')
+  }
+  const out = spawnSync(tesseract, [filePath, 'stdout', '--psm', '6'], {
+    encoding: 'utf-8',
+    maxBuffer: 25 * 1024 * 1024,
+    timeout: 30_000,
+  })
+  if ((out.status ?? 1) !== 0) {
+    throw new Error(`tesseract failed: ${(out.stderr || out.stdout || '').trim() || 'unknown error'}`)
+  }
+  return { text: out.stdout || '', method: 'tesseract' }
+}
+
+function extractRichText(filePath: string): { text: string; method: string } {
+  const textutil = findBinaryOnPath('textutil')
+  if (!textutil) throw new Error('DOC/DOCX/RTF extraction requires `textutil` on PATH.')
+  const out = spawnSync(textutil, ['-convert', 'txt', '-stdout', filePath], {
+    encoding: 'utf-8',
+    maxBuffer: 25 * 1024 * 1024,
+    timeout: 20_000,
+  })
+  if ((out.status ?? 1) !== 0 || !(out.stdout || '').trim()) {
+    throw new Error(`textutil failed: ${(out.stderr || out.stdout || '').trim() || 'unknown error'}`)
+  }
+  return { text: out.stdout || '', method: 'textutil' }
+}
+
+export async function extractDocumentArtifact(filePath: string, options?: { maxChars?: number; preferOcr?: boolean }): Promise<DocumentArtifact> {
+  const resolved = path.resolve(filePath)
+  if (!fs.existsSync(resolved)) throw new Error(`File not found: ${filePath}`)
+  const stat = fs.statSync(resolved)
+  if (!stat.isFile()) throw new Error(`Expected a file: ${filePath}`)
+
+  const ext = path.extname(resolved).toLowerCase()
+  const metadata: Record<string, unknown> = {
+    sizeBytes: stat.size,
+    modifiedAt: stat.mtimeMs,
+  }
+  const maxChars = options?.maxChars || 200_000
+  let text = ''
+  let method = 'utf8'
+  let tables: StructuredTable[] = []
+
+  if (ext === '.pdf') {
+    const pdf = await extractPdfText(resolved)
+    text = pdf.text
+    method = pdf.method
+  } else if (ext === '.csv' || ext === '.tsv') {
+    const delimiter = ext === '.tsv' ? '\t' : ','
+    const raw = fs.readFileSync(resolved, 'utf-8')
+    const table = matrixToTable(path.basename(resolved), parseDelimitedText(raw, delimiter))
+    tables = [table]
+    text = tablesToText(tables)
+    method = ext === '.tsv' ? 'tsv' : 'csv'
+  } else if (ext === '.xlsx' || ext === '.xlsm') {
+    const ExcelJS = await import('exceljs')
+    const workbook = new ExcelJS.Workbook()
+    await workbook.xlsx.readFile(resolved)
+    tables = workbook.worksheets.map((worksheet) => {
+      const matrix: string[][] = []
+      worksheet.eachRow((row) => {
+        matrix.push(worksheetRowToArray(row.values).map((cell) => String(normalizeScalar(cell) ?? '')))
+      })
+      return matrixToTable(worksheet.name, matrix)
+    }).filter((table) => table.headers.length > 0 || table.rowCount > 0)
+    text = tablesToText(tables)
+    method = 'exceljs'
+    metadata.sheetNames = workbook.worksheets.map((sheet) => sheet.name)
+  } else if (ext === '.json') {
+    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
+    }
+  } else if (ext === '.html' || ext === '.htm') {
+    const html = fs.readFileSync(resolved, 'utf-8')
+    const $ = cheerio.load(html)
+    $('script, style, noscript').remove()
+    text = $('body').text() || $.text()
+    method = 'html-strip'
+  } else if (ext === '.zip') {
+    const zip = listZipEntries(resolved)
+    text = zip.entries.join('\n')
+    method = zip.method
+    metadata.entries = zip.entries
+  } else if (ext === '.doc' || ext === '.docx' || ext === '.rtf') {
+    const rich = extractRichText(resolved)
+    text = rich.text
+    method = rich.method
+  } else if (IMAGE_EXTENSIONS.has(ext) || options?.preferOcr === true) {
+    const image = extractImageText(resolved)
+    text = image.text
+    method = image.method
+  } else if (TEXT_EXTENSIONS.has(ext) || !ext) {
+    text = fs.readFileSync(resolved, 'utf-8')
+    method = 'utf8'
+  } else {
+    text = fs.readFileSync(resolved, 'utf-8')
+    method = 'utf8-fallback'
+  }
+
+  return {
+    filePath: resolved,
+    fileName: path.basename(resolved),
+    ext,
+    method,
+    text: trimText(text, maxChars),
+    metadata,
+    tables,
+  }
+}
+
+export async function loadTabularFile(filePath: string, options?: { sheetName?: string }): Promise<StructuredTable> {
+  const resolved = path.resolve(filePath)
+  const ext = path.extname(resolved).toLowerCase()
+  if (ext === '.csv' || ext === '.tsv') {
+    const delimiter = ext === '.tsv' ? '\t' : ','
+    return matrixToTable(path.basename(resolved), parseDelimitedText(fs.readFileSync(resolved, 'utf-8'), delimiter))
+  }
+  if (ext === '.json') {
+    const parsed = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+    if (!Array.isArray(parsed) || !parsed.every((row) => row && typeof row === 'object' && !Array.isArray(row))) {
+      throw new Error('JSON table inputs must be an array of objects.')
+    }
+    return objectsToTable(path.basename(resolved), parsed as Array<Record<string, unknown>>)
+  }
+  if (ext === '.xlsx' || ext === '.xlsm') {
+    const ExcelJS = await import('exceljs')
+    const workbook = new ExcelJS.Workbook()
+    await workbook.xlsx.readFile(resolved)
+    const target = options?.sheetName
+      ? workbook.getWorksheet(options.sheetName)
+      : workbook.worksheets[0]
+    if (!target) throw new Error(`Worksheet not found: ${options?.sheetName || '(first worksheet)'}`)
+    const matrix: string[][] = []
+    target.eachRow((row) => {
+      matrix.push(worksheetRowToArray(row.values).map((cell) => String(normalizeScalar(cell) ?? '')))
+    })
+    return matrixToTable(target.name, matrix)
+  }
+  throw new Error(`Unsupported tabular file: ${ext || '(no extension)'}`)
+}
+
+export function normalizeInlineRows(value: unknown): StructuredTable {
+  if (!Array.isArray(value)) throw new Error('rows must be an array.')
+  if (value.length === 0) return { name: 'rows', headers: [], rows: [], rowCount: 0 }
+  if (value.every((row) => Array.isArray(row))) {
+    return matrixToTable('rows', value.map((row) => (row as unknown[]).map((cell) => String(normalizeScalar(cell) ?? ''))))
+  }
+  if (value.every((row) => row && typeof row === 'object' && !Array.isArray(row))) {
+    return objectsToTable('rows', value as Array<Record<string, unknown>>)
+  }
+  throw new Error('rows must be an array of objects or arrays.')
+}
+
+function escapeDelimitedCell(value: unknown, delimiter: string): string {
+  const raw = String(normalizeScalar(value) ?? '')
+  if (raw.includes('"') || raw.includes('\n') || raw.includes(delimiter)) {
+    return `"${raw.replace(/"/g, '""')}"`
+  }
+  return raw
+}
+
+export function serializeTable(table: StructuredTable, delimiter = ','): string {
+  const header = table.headers.map((cell) => escapeDelimitedCell(cell, delimiter)).join(delimiter)
+  const rows = table.rows.map((row) => table.headers.map((headerCell) => escapeDelimitedCell(row[headerCell], delimiter)).join(delimiter))
+  return [header, ...rows].join('\n')
+}
+
+export async function writeStructuredTable(filePath: string, table: StructuredTable): Promise<{ filePath: string; format: string }> {
+  const resolved = path.resolve(filePath)
+  const ext = path.extname(resolved).toLowerCase()
+  fs.mkdirSync(path.dirname(resolved), { recursive: true })
+
+  if (ext === '.json') {
+    fs.writeFileSync(resolved, JSON.stringify(table.rows, null, 2), 'utf-8')
+    return { filePath: resolved, format: 'json' }
+  }
+  if (ext === '.tsv') {
+    fs.writeFileSync(resolved, serializeTable(table, '\t'), 'utf-8')
+    return { filePath: resolved, format: 'tsv' }
+  }
+  if (ext === '.xlsx') {
+    const ExcelJS = await import('exceljs')
+    const workbook = new ExcelJS.Workbook()
+    const worksheet = workbook.addWorksheet(table.name || 'Sheet1')
+    worksheet.addRow(table.headers)
+    for (const row of table.rows) {
+      worksheet.addRow(table.headers.map((header) => row[header] ?? null))
+    }
+    await workbook.xlsx.writeFile(resolved)
+    return { filePath: resolved, format: 'xlsx' }
+  }
+
+  fs.writeFileSync(resolved, serializeTable(table, ','), 'utf-8')
+  return { filePath: resolved, format: 'csv' }
+}

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

@@ -3,9 +3,9 @@ import path from 'path'
 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 +188,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 +220,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 +244,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) {
@@ -377,8 +371,8 @@ async function tickHeartbeats() {
 
   for (const session of Object.values(sessions) as any[]) {
     if (!session?.id) continue
-    if (!Array.isArray(session.tools) || session.tools.length === 0) continue
-    if (session.sessionType && session.sessionType !== 'human' && session.sessionType !== 'orchestrated') continue
+    if (!Array.isArray(session.plugins) || session.plugins.length === 0) 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 +389,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 +400,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/)
+})