@swarmclawai/swarmclaw 0.4.0 → 0.5.0

package/src/lib/server/connectors/pairing.test.ts

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { test } from 'node:test'
+import {
+  addAllowedSender,
+  approvePairingCode,
+  clearConnectorPairingState,
+  createOrTouchPairingRequest,
+  isSenderAllowed,
+  listPendingPairingRequests,
+  listStoredAllowedSenders,
+  parseAllowFromCsv,
+  parsePairingPolicy,
+} from './pairing.ts'
+
+function withTempDataDir<T>(fn: (dir: string) => T): T {
+  const original = process.env.DATA_DIR
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-pairing-test-'))
+  process.env.DATA_DIR = tempDir
+  try {
+    return fn(tempDir)
+  } finally {
+    if (typeof original === 'string') process.env.DATA_DIR = original
+    else delete process.env.DATA_DIR
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('pairing store creates request, approves code, and persists allowlist', () => {
+  withTempDataDir(() => {
+    const connectorId = 'pair-test-1'
+
+    const first = createOrTouchPairingRequest({
+      connectorId,
+      senderId: '+15551234567',
+      senderName: 'Alice',
+      channelId: 'chat:1',
+    })
+    assert.equal(first.created, true)
+    assert.equal(first.code.length, 8)
+
+    const second = createOrTouchPairingRequest({
+      connectorId,
+      senderId: '+15551234567',
+      senderName: 'Alice',
+      channelId: 'chat:1',
+    })
+    assert.equal(second.created, false)
+    assert.equal(second.code, first.code)
+
+    const pendingBefore = listPendingPairingRequests(connectorId)
+    assert.equal(pendingBefore.length, 1)
+    assert.equal(pendingBefore[0].senderId, '+15551234567')
+
+    const bad = approvePairingCode(connectorId, 'INVALID')
+    assert.equal(bad.ok, false)
+
+    const approved = approvePairingCode(connectorId, first.code)
+    assert.equal(approved.ok, true)
+    assert.equal(approved.senderId, '+15551234567')
+
+    const pendingAfter = listPendingPairingRequests(connectorId)
+    assert.equal(pendingAfter.length, 0)
+
+    const stored = listStoredAllowedSenders(connectorId)
+    assert.deepEqual(stored, ['+15551234567'])
+
+    assert.equal(isSenderAllowed({ connectorId, senderId: '+15551234567' }), true)
+    assert.equal(isSenderAllowed({ connectorId, senderId: '+16667778888' }), false)
+
+    clearConnectorPairingState(connectorId)
+    assert.deepEqual(listStoredAllowedSenders(connectorId), [])
+  })
+})
+
+test('pairing helpers normalize policy and allowFrom csv entries', () => {
+  assert.equal(parsePairingPolicy('PAIRING'), 'pairing')
+  assert.equal(parsePairingPolicy('allowlist'), 'allowlist')
+  assert.equal(parsePairingPolicy('unknown', 'open'), 'open')
+
+  const list = parseAllowFromCsv('  +1555,TEST@example.com,+1555  ,   ')
+  assert.deepEqual(list, ['+1555', 'test@example.com'])
+})
+
+test('addAllowedSender deduplicates and normalizes sender ids', () => {
+  withTempDataDir(() => {
+    const connectorId = 'pair-test-2'
+    const first = addAllowedSender(connectorId, '  TEST@Example.com  ')
+    assert.equal(first.added, true)
+    assert.equal(first.normalized, 'test@example.com')
+
+    const second = addAllowedSender(connectorId, 'test@example.com')
+    assert.equal(second.added, false)
+
+    assert.deepEqual(listStoredAllowedSenders(connectorId), ['test@example.com'])
+  })
+})

package/src/lib/server/connectors/pairing.ts

@@ -0,0 +1,256 @@
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const DEFAULT_DATA_DIR = path.join(process.cwd(), 'data')
+const STORE_VERSION = 1
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000
+const MAX_PENDING_PER_CONNECTOR = 100
+const PAIR_CODE_LENGTH = 8
+const PAIR_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
+
+function resolveStorePath(): string {
+  const dataDir = process.env.DATA_DIR || DEFAULT_DATA_DIR
+  return path.join(dataDir, 'connectors', 'pairing-store.json')
+}
+
+export type PairingPolicy = 'open' | 'allowlist' | 'pairing' | 'disabled'
+
+export interface PairingRequest {
+  code: string
+  senderId: string
+  senderName?: string
+  channelId?: string
+  createdAt: number
+  updatedAt: number
+}
+
+interface ConnectorPairingState {
+  allowedSenderIds: string[]
+  pending: PairingRequest[]
+}
+
+interface PairingStore {
+  version: number
+  connectors: Record<string, ConnectorPairingState>
+}
+
+function normalizeSenderId(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function dedupe(items: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const item of items) {
+    const normalized = normalizeSenderId(item)
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    out.push(normalized)
+  }
+  return out
+}
+
+function prunePending(entries: PairingRequest[]): PairingRequest[] {
+  const now = Date.now()
+  return entries.filter((entry) => {
+    if (!entry?.code || !entry?.senderId) return false
+    if (!Number.isFinite(entry.createdAt) || !Number.isFinite(entry.updatedAt)) return false
+    return (now - entry.updatedAt) <= PENDING_TTL_MS
+  }).slice(-MAX_PENDING_PER_CONNECTOR)
+}
+
+function emptyStore(): PairingStore {
+  return { version: STORE_VERSION, connectors: {} }
+}
+
+function loadStore(): PairingStore {
+  const storePath = resolveStorePath()
+  try {
+    if (!fs.existsSync(storePath)) return emptyStore()
+    const raw = fs.readFileSync(storePath, 'utf8')
+    const parsed = JSON.parse(raw) as PairingStore
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.connectors !== 'object') {
+      return emptyStore()
+    }
+
+    const normalized: PairingStore = emptyStore()
+    for (const [connectorId, value] of Object.entries(parsed.connectors || {})) {
+      const state = value as Partial<ConnectorPairingState>
+      const allowedSenderIds = dedupe(Array.isArray(state.allowedSenderIds) ? state.allowedSenderIds.map(String) : [])
+      const pending = prunePending(Array.isArray(state.pending) ? state.pending as PairingRequest[] : [])
+      normalized.connectors[connectorId] = { allowedSenderIds, pending }
+    }
+    return normalized
+  } catch {
+    return emptyStore()
+  }
+}
+
+function saveStore(store: PairingStore): void {
+  const storePath = resolveStorePath()
+  fs.mkdirSync(path.dirname(storePath), { recursive: true })
+  fs.writeFileSync(storePath, `${JSON.stringify(store, null, 2)}\n`)
+}
+
+function ensureConnectorState(store: PairingStore, connectorId: string): ConnectorPairingState {
+  const existing = store.connectors[connectorId]
+  if (existing) {
+    existing.allowedSenderIds = dedupe(existing.allowedSenderIds || [])
+    existing.pending = prunePending(existing.pending || [])
+    return existing
+  }
+  const created: ConnectorPairingState = {
+    allowedSenderIds: [],
+    pending: [],
+  }
+  store.connectors[connectorId] = created
+  return created
+}
+
+function randomPairCode(existing: Set<string>): string {
+  for (let i = 0; i < 256; i++) {
+    const bytes = crypto.randomBytes(PAIR_CODE_LENGTH)
+    let out = ''
+    for (let j = 0; j < PAIR_CODE_LENGTH; j++) {
+      out += PAIR_CODE_ALPHABET[bytes[j] % PAIR_CODE_ALPHABET.length]
+    }
+    if (!existing.has(out)) return out
+  }
+  throw new Error('Unable to generate unique pairing code')
+}
+
+export function parsePairingPolicy(value: unknown, fallback: PairingPolicy = 'open'): PairingPolicy {
+  if (typeof value !== 'string') return fallback
+  const normalized = value.trim().toLowerCase()
+  if (normalized === 'open' || normalized === 'allowlist' || normalized === 'pairing' || normalized === 'disabled') {
+    return normalized
+  }
+  return fallback
+}
+
+export function parseAllowFromCsv(value: unknown): string[] {
+  if (typeof value !== 'string') return []
+  return dedupe(value.split(',').map((item) => item.trim()).filter(Boolean))
+}
+
+export function listStoredAllowedSenders(connectorId: string): string[] {
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  return state.allowedSenderIds.slice()
+}
+
+export function listPendingPairingRequests(connectorId: string): PairingRequest[] {
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  return state.pending.slice().sort((a, b) => b.updatedAt - a.updatedAt)
+}
+
+export function addAllowedSender(connectorId: string, senderId: string): { added: boolean; normalized: string } {
+  const normalized = normalizeSenderId(senderId)
+  if (!normalized) return { added: false, normalized }
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  const hasExisting = state.allowedSenderIds.includes(normalized)
+  if (!hasExisting) {
+    state.allowedSenderIds.push(normalized)
+  }
+
+  // Remove any pending requests for the same sender after approval.
+  state.pending = state.pending.filter((entry) => normalizeSenderId(entry.senderId) !== normalized)
+
+  saveStore(store)
+  return { added: !hasExisting, normalized }
+}
+
+export function createOrTouchPairingRequest(params: {
+  connectorId: string
+  senderId: string
+  senderName?: string
+  channelId?: string
+}): { code: string; created: boolean } {
+  const normalized = normalizeSenderId(params.senderId)
+  if (!normalized) throw new Error('senderId is required')
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, params.connectorId)
+  const now = Date.now()
+
+  const existing = state.pending.find((entry) => normalizeSenderId(entry.senderId) === normalized)
+  if (existing) {
+    existing.updatedAt = now
+    existing.senderName = params.senderName || existing.senderName
+    existing.channelId = params.channelId || existing.channelId
+    saveStore(store)
+    return { code: existing.code, created: false }
+  }
+
+  const existingCodes = new Set(state.pending.map((entry) => entry.code.toUpperCase()))
+  const code = randomPairCode(existingCodes)
+  state.pending.push({
+    code,
+    senderId: normalized,
+    senderName: params.senderName,
+    channelId: params.channelId,
+    createdAt: now,
+    updatedAt: now,
+  })
+  state.pending = prunePending(state.pending)
+  saveStore(store)
+  return { code, created: true }
+}
+
+export function approvePairingCode(connectorId: string, codeRaw: string): {
+  ok: boolean
+  senderId?: string
+  senderName?: string
+  reason?: string
+} {
+  const code = codeRaw.trim().toUpperCase()
+  if (!code) return { ok: false, reason: 'Missing code' }
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, connectorId)
+  const idx = state.pending.findIndex((entry) => entry.code.toUpperCase() === code)
+  if (idx < 0) return { ok: false, reason: 'Code not found or expired' }
+
+  const pending = state.pending[idx]
+  state.pending.splice(idx, 1)
+
+  const normalizedSender = normalizeSenderId(pending.senderId)
+  if (!state.allowedSenderIds.includes(normalizedSender)) {
+    state.allowedSenderIds.push(normalizedSender)
+    state.allowedSenderIds = dedupe(state.allowedSenderIds)
+  }
+
+  saveStore(store)
+  return {
+    ok: true,
+    senderId: normalizedSender,
+    senderName: pending.senderName,
+  }
+}
+
+export function isSenderAllowed(params: {
+  connectorId: string
+  senderId: string
+  configAllowFrom?: string[]
+}): boolean {
+  const normalized = normalizeSenderId(params.senderId)
+  if (!normalized) return false
+
+  const configSet = new Set((params.configAllowFrom || []).map((item) => normalizeSenderId(item)).filter(Boolean))
+  if (configSet.has(normalized)) return true
+
+  const store = loadStore()
+  const state = ensureConnectorState(store, params.connectorId)
+  return state.allowedSenderIds.includes(normalized)
+}
+
+export function clearConnectorPairingState(connectorId: string): void {
+  const store = loadStore()
+  if (!store.connectors[connectorId]) return
+  delete store.connectors[connectorId]
+  saveStore(store)
+}

package/src/lib/server/connectors/signal.ts

@@ -147,6 +147,7 @@ export async function handleSignalEvent(
     senderId: sender,
     senderName: envelope.sourceName || sender,
     text,
+    isGroup: !!groupId,
   }
 
   try {

package/src/lib/server/connectors/teams.ts

@@ -22,11 +22,11 @@ const teams: PlatformConnector = {
     const conversationReferences = new Map<string, any>()
     let stopped = false
 
-    // Process incoming activities — called from the webhook endpoint
-    // POST /api/connectors/[id]/webhook should pipe req/res through this
-    const processActivity = async (req: any, res: any) => {
+    // Process incoming activities — called from the webhook endpoint.
+    // We use processActivityDirect so this works from Next.js route handlers.
+    const processActivity = async (activity: any) => {
       if (stopped) return
-      await adapter.processActivity(req, res, async (context: any) => {
+      await adapter.processActivityDirect(activity, async (context: any) => {
         if (context.activity.type !== 'message') return
         if (!context.activity.text) return
 
@@ -57,7 +57,7 @@ const teams: PlatformConnector = {
       })
     }
 
-    // Store processActivity on globalThis so the webhook route can access it
+    // Store processActivity on globalThis so the webhook route can access it.
     const handlerKey = `__swarmclaw_teams_handler_${connector.id}__`
     ;(globalThis as any)[handlerKey] = processActivity
 

package/src/lib/server/connectors/types.ts

@@ -21,9 +21,11 @@ export interface InboundMessage {
   senderId: string         // platform-specific user ID
   senderName: string       // display name
   text: string
+  isGroup?: boolean
   imageUrl?: string
   media?: InboundMedia[]
   replyToMessageId?: string
+  agentIdOverride?: string
 }
 
 /** A running connector instance */
@@ -50,6 +52,14 @@ export interface ConnectorInstance {
   authenticated?: boolean
   /** Whether the connector has existing saved credentials (WhatsApp only) */
   hasCredentials?: boolean
+  /** Rich messaging: send a reaction emoji to a message */
+  sendReaction?: (channelId: string, messageId: string, emoji: string) => Promise<void>
+  /** Rich messaging: edit a previously sent message */
+  editMessage?: (channelId: string, messageId: string, newText: string) => Promise<void>
+  /** Rich messaging: delete a message */
+  deleteMessage?: (channelId: string, messageId: string) => Promise<void>
+  /** Rich messaging: pin a message */
+  pinMessage?: (channelId: string, messageId: string) => Promise<void>
 }
 
 /** Platform-specific connector implementation */

package/src/lib/server/daemon-state.ts

@@ -12,6 +12,7 @@ import {
   getConnectorStatus,
 } from './connectors/manager'
 import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
+import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
 
 const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
@@ -179,6 +180,16 @@ function startQueueProcessor() {
       await processNext()
       ds.lastProcessedAt = Date.now()
     }
+    // OpenClaw gateway lifecycle: lazy connect when openclaw agents exist, disconnect when none remain
+    try {
+      if (hasOpenClawAgents()) {
+        if (!getGateway()?.connected) {
+          await ensureGatewayConnected()
+        }
+      } else if (getGateway()?.connected) {
+        disconnectGateway()
+      }
+    } catch { /* gateway errors are non-fatal */ }
   }, QUEUE_CHECK_INTERVAL)
 }
 

package/src/lib/server/execution-log.ts

@@ -1,7 +1,7 @@
 import fs from 'fs'
 import path from 'path'
-import crypto from 'crypto'
 import Database from 'better-sqlite3'
+import { genId } from '@/lib/id'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -94,7 +94,7 @@ export function logExecution(
     detail?: Record<string, unknown>
   },
 ): string {
-  const id = crypto.randomBytes(8).toString('hex')
+  const id = genId(8)
   const ts = Date.now()
   try {
     insertStmt().run(
@@ -133,7 +133,7 @@ export function logExecutionBatch(
   const tx = db.transaction(() => {
     for (const e of entries) {
       stmt.run(
-        crypto.randomBytes(8).toString('hex'),
+        genId(8),
         e.sessionId,
         e.runId ?? null,
         e.agentId ?? null,

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

@@ -158,6 +158,7 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     soul ? `Persona: ${soul.slice(0, 300)}` : '',
     heartbeatFileContent ? `\nHEARTBEAT.md contents:\n${heartbeatFileContent.slice(0, 2000)}` : '',
     recentContext ? `Recent conversation:\n${recentContext}` : '',
+    fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT ? `\nAgent instructions:\n${fallbackPrompt}` : '',
     '',
     'You are running an autonomous heartbeat tick. Review your goal and recent context.',
     'If there is meaningful work to do toward your goal, use your tools and take action.',
@@ -167,7 +168,6 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     'To update your goal or plan, include this line in your response:',
     '[AGENT_HEARTBEAT_META]{"goal": "your evolved goal", "status": "progress", "next_action": "what you plan to do next"}',
     'You can evolve your goal as you learn more. Set status to "progress" while working, "ok" when done, "idle" when waiting.',
-    fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT ? `\nAdditional instructions: ${fallbackPrompt}` : '',
   ].filter(Boolean).join('\n')
 }
 

package/src/lib/server/knowledge-db.test.ts

@@ -104,39 +104,8 @@ function rowToEntry(row: Record<string, unknown>): MemoryEntry {
   }
 }
 
-// ---- Knowledge helpers (mirrors memory-db.ts exported functions) ----
-
-const MEMORY_FTS_STOP_WORDS = new Set([
-  'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how',
-  'i', 'if', 'in', 'is', 'it', 'of', 'on', 'or', 'that', 'the', 'this',
-  'to', 'was', 'we', 'were', 'what', 'when', 'where', 'which', 'who', 'with',
-  'you', 'your',
-])
-const MAX_FTS_QUERY_TERMS = 6
-const MAX_FTS_TERM_LENGTH = 48
-
-function buildFtsQuery(input: string): string {
-  const tokens = String(input || '')
-    .toLowerCase()
-    .match(/[a-z0-9][a-z0-9._:/-]*/g) || []
-  if (!tokens.length) return ''
-  const unique: string[] = []
-  const seen = new Set<string>()
-  for (const token of tokens) {
-    const term = token.slice(0, MAX_FTS_TERM_LENGTH)
-    if (term.length < 3) continue
-    if (MEMORY_FTS_STOP_WORDS.has(term)) continue
-    if (seen.has(term)) continue
-    seen.add(term)
-    unique.push(term)
-    if (unique.length >= MAX_FTS_QUERY_TERMS) break
-  }
-  if (unique.length === 1) {
-    return unique[0].length >= 5 ? `"${unique[0].replace(/"/g, '')}"` : ''
-  }
-  const selected = unique.slice(0, Math.min(4, MAX_FTS_QUERY_TERMS))
-  return selected.map((term) => `"${term.replace(/"/g, '')}"`).join(' AND ')
-}
+// ---- Knowledge helpers (re-exported from memory-db.ts) ----
+import { buildFtsQuery } from './memory-db'
 
 function addRawMemory(data: {
   agentId?: string | null

package/src/lib/server/main-agent-loop.ts

@@ -1,17 +1,16 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { z } from 'zod'
 import type { GoalContract, MessageToolEvent } from '@/types'
 import { loadSessions, saveSessions, loadAgents, saveAgents, loadTasks, saveTasks } from './storage'
 import { log } from './logger'
 import { getMemoryDb } from './memory-db'
+import { isProtectedMainSession } from './main-session'
 import {
   mergeGoalContracts,
   parseGoalContractFromText,
   parseMainLoopPlan,
   parseMainLoopReview,
 } from './autonomy-contract'
-
-const MAIN_SESSION_NAME = '__main__'
 const MAX_PENDING_EVENTS = 40
 const MAX_TIMELINE_EVENTS = 80
 const EVENT_TTL_MS = 7 * 24 * 60 * 60 * 1000
@@ -151,7 +150,7 @@ function appendTimeline(
   const recent = state.timeline.at(-1)
   if (recent && recent.source === source && recent.note === normalizedNote && now - recent.at < 45_000) return
   state.timeline.push({
-    id: `tl_${crypto.randomBytes(4).toString('hex')}`,
+    id: `tl_${genId()}`,
     at: now,
     source,
     note: normalizedNote,
@@ -226,7 +225,7 @@ function normalizeState(raw: any, now = Date.now()): MainLoopState {
         const text = toOneLine(typeof e?.text === 'string' ? e.text : '')
         if (!text) return null
         return {
-          id: typeof e?.id === 'string' && e.id.trim() ? e.id.trim() : `evt_${crypto.randomBytes(3).toString('hex')}`,
+          id: typeof e?.id === 'string' && e.id.trim() ? e.id.trim() : `evt_${genId(3)}`,
           type: typeof e?.type === 'string' && e.type.trim() ? e.type.trim() : 'event',
           text,
           createdAt: typeof e?.createdAt === 'number' ? e.createdAt : now,
@@ -246,7 +245,7 @@ function normalizeState(raw: any, now = Date.now()): MainLoopState {
           ? entry.status
           : undefined
         return {
-          id: typeof entry?.id === 'string' && entry.id.trim() ? entry.id.trim() : `tl_${crypto.randomBytes(3).toString('hex')}`,
+          id: typeof entry?.id === 'string' && entry.id.trim() ? entry.id.trim() : `tl_${genId(3)}`,
           at: typeof entry?.at === 'number' ? entry.at : now,
           source: typeof entry?.source === 'string' && entry.source.trim() ? entry.source.trim() : 'event',
           note,
@@ -303,7 +302,7 @@ function appendEvent(state: MainLoopState, type: string, text: string, now = Dat
     return false
   }
   state.pendingEvents.push({
-    id: `evt_${crypto.randomBytes(4).toString('hex')}`,
+    id: `evt_${genId()}`,
     type,
     text: normalizedText,
     createdAt: now,
@@ -517,7 +516,7 @@ function upsertMissionTask(session: any, state: MainLoopState, now: number): str
   ].filter(Boolean).join('\n')
 
   if (!task) {
-    const id = crypto.randomBytes(4).toString('hex')
+    const id = genId()
     task = {
       id,
       title,
@@ -669,7 +668,7 @@ function buildFollowupPrompt(state: MainLoopState, opts?: { hasMemoryTool?: bool
 }
 
 export function isMainSession(session: any): boolean {
-  return session?.name === MAIN_SESSION_NAME
+  return isProtectedMainSession(session)
 }
 
 export function buildMainLoopHeartbeatPrompt(session: any, fallbackPrompt: string): string {

package/src/lib/server/main-session.ts

@@ -0,0 +1,21 @@
+const MAIN_SESSION_NAME = '__main__'
+
+export function isProtectedMainSession(session: any): boolean {
+  if (!session || typeof session !== 'object') return false
+  if (session.mainSession === true) return true
+
+  const name = typeof session.name === 'string' ? session.name.trim() : ''
+  if (name === MAIN_SESSION_NAME) return true
+
+  const id = typeof session.id === 'string' ? session.id.trim() : ''
+  if (id.startsWith('main-')) return true
+
+  return false
+}
+
+export function ensureMainSessionFlag(session: any): void {
+  if (!session || typeof session !== 'object') return
+  if (isProtectedMainSession(session)) {
+    session.mainSession = true
+  }
+}

package/src/lib/server/memory-db.ts

@@ -1,7 +1,7 @@
 import Database from 'better-sqlite3'
 import path from 'path'
-import crypto from 'crypto'
 import fs from 'fs'
+import { genId } from '@/lib/id'
 import type { MemoryEntry, FileReference, MemoryImage, MemoryReference } from '@/types'
 import { getEmbedding, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from './embeddings'
 import { loadSettings } from './storage'
@@ -20,12 +20,12 @@ const IMAGES_DIR = path.join(DATA_DIR, 'memory-images')
 
 const MAX_IMAGE_INPUT_BYTES = 10 * 1024 * 1024 // 10MB
 const IMAGE_EXT_WHITELIST = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.tiff'])
-const MAX_FTS_QUERY_TERMS = 6
-const MAX_FTS_TERM_LENGTH = 48
+export const MAX_FTS_QUERY_TERMS = 6
+export const MAX_FTS_TERM_LENGTH = 48
 const MAX_FTS_RESULT_ROWS = 30
 const MAX_MERGED_RESULTS = 50
 
-const MEMORY_FTS_STOP_WORDS = new Set([
+export const MEMORY_FTS_STOP_WORDS = new Set([
   'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'how',
   'i', 'if', 'in', 'is', 'it', 'of', 'on', 'or', 'that', 'the', 'this',
   'to', 'was', 'we', 'were', 'what', 'when', 'where', 'which', 'who', 'with',
@@ -184,7 +184,7 @@ function canonicalText(value: unknown): string {
     .trim()
 }
 
-function buildFtsQuery(input: string): string {
+export function buildFtsQuery(input: string): string {
   const tokens = String(input || '')
     .toLowerCase()
     .match(/[a-z0-9][a-z0-9._:/-]*/g) || []
@@ -546,7 +546,7 @@ function initDb() {
 
   return {
     add(data: Omit<MemoryEntry, 'id' | 'createdAt' | 'updatedAt'>): MemoryEntry {
-      const id = crypto.randomBytes(6).toString('hex')
+      const id = genId(6)
       const now = Date.now()
       const references = normalizeReferences(data.references, data.filePaths)
       const legacyFilePaths = referencesToLegacyFilePaths(references)