@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/session-archive-memory.ts

@@ -0,0 +1,230 @@
+import { createHash } from 'crypto'
+import fs from 'fs'
+import path from 'path'
+import type { Agent, MemoryEntry, MemoryReference, Session } from '@/types'
+import { getMemoryDb } from './memory-db'
+import { loadAgents, loadSessions, saveSessions } from './storage'
+import { DATA_DIR } from './data-dir'
+
+const MAX_ARCHIVE_MESSAGES = 36
+const MAX_ARCHIVE_LINE_CHARS = 320
+const SESSION_ARCHIVE_EXPORT_DIR = path.join(DATA_DIR, 'session-archives')
+
+function toOneLine(value: unknown, maxChars: number): string {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, maxChars)
+}
+
+function messageSpeaker(session: Session, agent: Partial<Agent> | null | undefined, message: Session['messages'][number]): string {
+  if (message.role === 'assistant') return agent?.name || 'assistant'
+  return session.connectorContext?.senderName || session.user || 'user'
+}
+
+function slugifySegment(value: string, fallback: string): string {
+  const normalized = value
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return normalized || fallback
+}
+
+export function buildSessionArchivePayload(
+  session: Session,
+  agent?: Partial<Agent> | null,
+): {
+  title: string
+  content: string
+  metadata: Record<string, unknown>
+  references: MemoryReference[]
+  hash: string
+} | null {
+  if (!Array.isArray(session.messages) || session.messages.length < 2) return null
+
+  const excerpt = session.messages.slice(-MAX_ARCHIVE_MESSAGES).map((message) => {
+    const speaker = messageSpeaker(session, agent, message)
+    const kind = message.kind && message.kind !== 'chat' ? ` [${message.kind}]` : ''
+    const text = toOneLine(message.text, MAX_ARCHIVE_LINE_CHARS)
+    const tools = Array.isArray(message.toolEvents) && message.toolEvents.length > 0
+      ? ` | tools=${message.toolEvents.map((event) => event.name).join(',')}`
+      : ''
+    return `- ${speaker}${kind}: ${text}${tools}`
+  }).join('\n')
+
+  const title = `Session archive: ${session.name || session.id}`
+  const content = [
+    `session_id: ${session.id}`,
+    `session_name: ${toOneLine(session.name, 160)}`,
+    `session_type: ${toOneLine(session.sessionType || 'human', 32)}`,
+    `agent_name: ${toOneLine(agent?.name || '', 80)}`,
+    `last_active_iso: ${new Date(session.lastActiveAt || Date.now()).toISOString()}`,
+    `message_count: ${session.messages.length}`,
+    session.identityState?.personaLabel ? `persona_label: ${toOneLine(session.identityState.personaLabel, 120)}` : '',
+    '',
+    'Transcript excerpt:',
+    excerpt,
+  ].filter(Boolean).join('\n')
+
+  const hash = createHash('sha256').update(`${title}\n${content}`).digest('hex').slice(0, 16)
+  return {
+    title,
+    content,
+    metadata: {
+      tier: 'archive',
+      archiveHash: hash,
+      sessionName: session.name,
+      sessionType: session.sessionType || 'human',
+      messageCount: session.messages.length,
+      lastActiveAt: session.lastActiveAt || Date.now(),
+      personaLabel: session.identityState?.personaLabel || null,
+    },
+    references: [{
+      type: 'session',
+      path: session.id,
+      title: session.name,
+      note: 'Searchable session archive snapshot',
+      timestamp: Date.now(),
+    }],
+    hash,
+  }
+}
+
+export function buildSessionArchiveMarkdown(
+  session: Session,
+  payload: NonNullable<ReturnType<typeof buildSessionArchivePayload>>,
+  agent?: Partial<Agent> | null,
+): string {
+  const transcriptLines = session.messages.slice(-MAX_ARCHIVE_MESSAGES).map((message) => {
+    const speaker = messageSpeaker(session, agent, message)
+    const kind = message.kind && message.kind !== 'chat' ? ` (${message.kind})` : ''
+    const toolSummary = Array.isArray(message.toolEvents) && message.toolEvents.length > 0
+      ? ` [tools: ${message.toolEvents.map((event) => event.name).join(', ')}]`
+      : ''
+    return `- **${speaker}**${kind}: ${toOneLine(message.text, MAX_ARCHIVE_LINE_CHARS)}${toolSummary}`
+  })
+
+  return [
+    `# ${payload.title}`,
+    '',
+    `- Session ID: ${session.id}`,
+    `- Session Name: ${toOneLine(session.name, 160)}`,
+    `- Session Type: ${toOneLine(session.sessionType || 'human', 32)}`,
+    `- Agent: ${toOneLine(agent?.name || session.agentId || 'unknown', 80)}`,
+    `- Last Active: ${new Date(session.lastActiveAt || Date.now()).toISOString()}`,
+    `- Messages: ${session.messages.length}`,
+    session.identityState?.personaLabel ? `- Persona: ${toOneLine(session.identityState.personaLabel, 120)}` : '',
+    '',
+    '## Archive Snapshot',
+    '',
+    '```text',
+    payload.content,
+    '```',
+    '',
+    '## Transcript Excerpt',
+    '',
+    ...transcriptLines,
+    '',
+  ].filter(Boolean).join('\n')
+}
+
+function exportSessionArchiveMarkdown(
+  session: Session,
+  payload: NonNullable<ReturnType<typeof buildSessionArchivePayload>>,
+  agent?: Partial<Agent> | null,
+): string | null {
+  try {
+    const agentSegment = slugifySegment(agent?.name || session.agentId || 'shared', 'shared')
+    const sessionSegment = slugifySegment(session.name || session.id, session.id)
+    const dir = path.join(SESSION_ARCHIVE_EXPORT_DIR, agentSegment)
+    fs.mkdirSync(dir, { recursive: true })
+    const filePath = path.join(dir, `${sessionSegment}-${session.id}.md`)
+    fs.writeFileSync(filePath, buildSessionArchiveMarkdown(session, payload, agent))
+    return filePath
+  } catch {
+    return null
+  }
+}
+
+export function syncSessionArchiveMemory(
+  session: Session,
+  opts?: { agent?: Partial<Agent> | null },
+): { stored: boolean; memoryId?: string; reason?: string } {
+  const agent = opts?.agent ?? (session.agentId ? loadAgents()[session.agentId] : null)
+  if (!session.agentId && !agent?.id) {
+    return { stored: false, reason: 'missing_agent' }
+  }
+
+  const payload = buildSessionArchivePayload(session, agent)
+  if (!payload) {
+    return { stored: false, reason: 'insufficient_messages' }
+  }
+
+  const memDb = getMemoryDb()
+  const existing = memDb.getLatestBySessionCategory(session.id, 'session_archive')
+  const existingHash = typeof existing?.metadata?.archiveHash === 'string'
+    ? existing.metadata.archiveHash
+    : null
+  if (session.sessionArchiveState?.lastHash === payload.hash || existingHash === payload.hash) {
+    session.sessionArchiveState = {
+      memoryId: session.sessionArchiveState?.memoryId || existing?.id || null,
+      lastHash: payload.hash,
+      lastSyncedAt: session.sessionArchiveState?.lastSyncedAt || existing?.updatedAt || null,
+      messageCount: session.messages.length,
+      exportPath: session.sessionArchiveState?.exportPath || null,
+    }
+    return { stored: false, memoryId: existing?.id || session.sessionArchiveState.memoryId || undefined, reason: 'unchanged' }
+  }
+  const entry: MemoryEntry | null = existing
+    ? memDb.update(existing.id, {
+        title: payload.title,
+        content: payload.content,
+        metadata: payload.metadata,
+        references: payload.references,
+        linkedMemoryIds: existing.linkedMemoryIds,
+      })
+    : memDb.add({
+        agentId: session.agentId || agent?.id || null,
+        sessionId: session.id,
+        category: 'session_archive',
+        title: payload.title,
+        content: payload.content,
+        metadata: payload.metadata,
+        references: payload.references,
+        linkedMemoryIds: [],
+      })
+
+  if (!entry) return { stored: false, reason: 'store_failed' }
+  const exportPath = exportSessionArchiveMarkdown(session, payload, agent)
+
+  session.sessionArchiveState = {
+    memoryId: entry.id,
+    lastHash: payload.hash,
+    lastSyncedAt: Date.now(),
+    messageCount: session.messages.length,
+    exportPath,
+  }
+
+  return { stored: true, memoryId: entry.id }
+}
+
+export function syncAllSessionArchiveMemories(): { synced: number; skipped: number; sessionIds: string[] } {
+  const sessions = loadSessions()
+  const agents = loadAgents()
+  let changed = false
+  let synced = 0
+  let skipped = 0
+  const sessionIds: string[] = []
+
+  for (const session of Object.values(sessions) as Session[]) {
+    const agent = session.agentId ? agents[session.agentId] : null
+    const result = syncSessionArchiveMemory(session, { agent })
+    if (result.stored) {
+      synced += 1
+      sessionIds.push(session.id)
+      changed = true
+    } else {
+      skipped += 1
+    }
+  }
+
+  if (changed) saveSessions(sessions)
+  return { synced, skipped, sessionIds }
+}

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

@@ -1,23 +1,7 @@
 import { genId } from '@/lib/id'
+import type { MailboxEnvelope } from '@/types'
 import { loadSessions, saveSessions } from './storage'
 
-export type MailboxStatus = 'new' | 'ack'
-
-export interface MailboxEnvelope {
-  id: string
-  type: string
-  payload: string
-  fromSessionId?: string | null
-  fromAgentId?: string | null
-  toSessionId: string
-  toAgentId?: string | null
-  correlationId?: string | null
-  status: MailboxStatus
-  createdAt: number
-  expiresAt?: number | null
-  ackAt?: number | null
-}
-
 interface MailboxOptions {
   limit?: number
   includeAcked?: boolean
@@ -78,6 +62,13 @@ export function sendMailboxEnvelope(input: {
   target.lastActiveAt = now
   sessions[input.toSessionId] = target
   saveSessions(sessions)
+  import('./watch-jobs')
+    .then(({ triggerMailboxWatchJobs }) => {
+      triggerMailboxWatchJobs({ sessionId: input.toSessionId, envelope })
+    })
+    .catch(() => {
+      // best-effort trigger only
+    })
   return envelope
 }
 
@@ -126,4 +117,3 @@ export function clearMailbox(sessionId: string, includeAcked = true): { before:
   saveSessions(sessions)
   return { before, after: afterList.length }
 }
-

package/src/lib/server/session-reset-policy.test.ts

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import type { Session } from '@/types'
+import {
+  evaluateSessionFreshness,
+  inferSessionResetType,
+  resetSessionRuntime,
+  resolveSessionResetPolicy,
+} from './session-reset-policy'
+
+function makeSession(overrides: Partial<Session> = {}): Session {
+  return {
+    id: 's1',
+    name: 'Test Session',
+    cwd: process.cwd(),
+    user: 'user',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    messages: [{ role: 'user', text: 'hello', time: 1 }],
+    createdAt: 1,
+    lastActiveAt: 1,
+    ...overrides,
+  }
+}
+
+test('inferSessionResetType distinguishes direct, group, and thread sessions', () => {
+  assert.equal(inferSessionResetType(makeSession()), 'direct')
+  assert.equal(inferSessionResetType(makeSession({ connectorContext: { isGroup: true } })), 'group')
+  assert.equal(inferSessionResetType(makeSession({ connectorContext: { threadId: 'thread-1' } })), 'thread')
+})
+
+test('resolveSessionResetPolicy falls back to type defaults', () => {
+  const direct = resolveSessionResetPolicy({ session: makeSession() })
+  assert.equal(direct.mode, 'idle')
+  assert.equal(direct.idleTimeoutSec, 12 * 60 * 60)
+
+  const thread = resolveSessionResetPolicy({ session: makeSession({ connectorContext: { threadId: 'thread-1' } }) })
+  assert.equal(thread.mode, 'idle')
+  assert.equal(thread.idleTimeoutSec, 4 * 60 * 60)
+})
+
+test('evaluateSessionFreshness expires idle sessions', () => {
+  const session = makeSession({ createdAt: 0, lastActiveAt: 0 })
+  const policy = resolveSessionResetPolicy({
+    session: { ...session, sessionIdleTimeoutSec: 10, sessionMaxAgeSec: 60 },
+  })
+  const freshness = evaluateSessionFreshness({ session, policy, now: 11_000 })
+  assert.deepEqual(freshness.reason, 'idle_timeout:10')
+  assert.equal(freshness.fresh, false)
+})
+
+test('evaluateSessionFreshness supports daily reset boundaries', () => {
+  const session = makeSession({
+    createdAt: Date.parse('2026-03-04T00:00:00.000Z'),
+    lastActiveAt: Date.parse('2026-03-05T03:30:00.000Z'),
+  })
+  const policy = resolveSessionResetPolicy({
+    session: {
+      ...session,
+      sessionResetMode: 'daily',
+      sessionDailyResetAt: '04:00',
+      sessionResetTimezone: 'UTC',
+      sessionMaxAgeSec: 999999,
+      sessionIdleTimeoutSec: 0,
+    },
+  })
+  const freshness = evaluateSessionFreshness({
+    session,
+    policy,
+    now: Date.parse('2026-03-05T10:00:00.000Z'),
+  })
+  assert.equal(freshness.fresh, false)
+  assert.equal(freshness.reason, 'daily_reset:04:00')
+})
+
+test('resetSessionRuntime clears transient state but preserves continuity state', () => {
+  const session = makeSession({
+    claudeSessionId: 'claude',
+    codexThreadId: 'codex',
+    opencodeSessionId: 'open',
+    delegateResumeIds: { claudeCode: 'a', codex: 'b', opencode: 'c', gemini: 'd' },
+    lastHeartbeatText: 'heartbeat',
+    lastHeartbeatSentAt: 123,
+    lastAutoMemoryAt: 456,
+    conversationTone: 'formal',
+    identityState: { personaLabel: 'Planner' },
+  })
+
+  const cleared = resetSessionRuntime(session, 'idle_timeout:10', { now: 1000 })
+
+  assert.equal(cleared, 1)
+  assert.deepEqual(session.messages, [])
+  assert.equal(session.claudeSessionId, null)
+  assert.equal(session.identityState?.personaLabel, 'Planner')
+  assert.equal(session.lastSessionResetReason, 'idle_timeout:10')
+})

package/src/lib/server/session-reset-policy.ts

@@ -0,0 +1,311 @@
+import type { Agent, AppSettings, Session, SessionResetMode, SessionResetType } from '@/types'
+
+export interface ResolvedSessionResetPolicy {
+  type: SessionResetType
+  mode: SessionResetMode
+  idleTimeoutSec: number | null
+  maxAgeSec: number | null
+  dailyResetAt: string | null
+  timezone: string | null
+}
+
+export interface SessionFreshnessSnapshot {
+  fresh: boolean
+  reason?: string
+  policy: ResolvedSessionResetPolicy
+  idleExpiresAt: number | null
+  dailyBoundaryKey: string | null
+}
+
+const DEFAULT_POLICIES: Record<SessionResetType, ResolvedSessionResetPolicy> = {
+  direct: {
+    type: 'direct',
+    mode: 'idle',
+    idleTimeoutSec: 12 * 60 * 60,
+    maxAgeSec: 7 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  group: {
+    type: 'group',
+    mode: 'idle',
+    idleTimeoutSec: 6 * 60 * 60,
+    maxAgeSec: 3 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  thread: {
+    type: 'thread',
+    mode: 'idle',
+    idleTimeoutSec: 4 * 60 * 60,
+    maxAgeSec: 2 * 24 * 60 * 60,
+    dailyResetAt: null,
+    timezone: null,
+  },
+  main: {
+    type: 'main',
+    mode: 'daily',
+    idleTimeoutSec: 24 * 60 * 60,
+    maxAgeSec: 14 * 24 * 60 * 60,
+    dailyResetAt: '04:00',
+    timezone: null,
+  },
+}
+
+function parseIntBounded(value: unknown, min: number, max: number): number | null {
+  if (value === null || value === undefined || value === '') return null
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value.trim(), 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return null
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+function normalizeMode(raw: unknown, fallback: SessionResetMode): SessionResetMode {
+  const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
+  return value === 'daily' ? 'daily' : value === 'idle' ? 'idle' : fallback
+}
+
+function normalizeTimeHHMM(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null
+  const value = raw.trim()
+  const match = value.match(/^(\d{1,2}):(\d{2})$/)
+  if (!match) return null
+  const hours = Number.parseInt(match[1], 10)
+  const minutes = Number.parseInt(match[2], 10)
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return null
+  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) return null
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`
+}
+
+function normalizeTimezone(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null
+  const value = raw.trim()
+  return value || null
+}
+
+function getClockParts(date: Date, timezone?: string | null): { dateKey: string; minutes: number } | null {
+  try {
+    const formatter = new Intl.DateTimeFormat('en-CA', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+      timeZone: timezone || undefined,
+    })
+    const parts = formatter.formatToParts(date)
+    const year = parts.find((part) => part.type === 'year')?.value
+    const month = parts.find((part) => part.type === 'month')?.value
+    const day = parts.find((part) => part.type === 'day')?.value
+    const hour = Number.parseInt(parts.find((part) => part.type === 'hour')?.value || '', 10)
+    const minute = Number.parseInt(parts.find((part) => part.type === 'minute')?.value || '', 10)
+    if (!year || !month || !day || !Number.isFinite(hour) || !Number.isFinite(minute)) return null
+    return {
+      dateKey: `${year}-${month}-${day}`,
+      minutes: hour * 60 + minute,
+    }
+  } catch {
+    return null
+  }
+}
+
+function boundaryKeyForNow(now: number, boundaryMinutes: number, timezone?: string | null): string | null {
+  const current = getClockParts(new Date(now), timezone)
+  if (!current) return null
+  if (current.minutes >= boundaryMinutes) return current.dateKey
+  const previous = getClockParts(new Date(now - 24 * 60 * 60 * 1000), timezone)
+  return previous?.dateKey || null
+}
+
+function rawField(
+  session: Partial<Session> | null | undefined,
+  overrides: Record<string, unknown> | undefined,
+  agent: Partial<Agent> | null | undefined,
+  settings: Partial<AppSettings> | null | undefined,
+  key: 'sessionResetMode' | 'sessionIdleTimeoutSec' | 'sessionMaxAgeSec' | 'sessionDailyResetAt' | 'sessionResetTimezone',
+): unknown {
+  if (session && session[key] !== undefined) return session[key]
+  if (overrides && overrides[key] !== undefined) return overrides[key]
+  if (agent && agent[key] !== undefined) return agent[key]
+  if (settings && settings[key] !== undefined) return settings[key]
+  return undefined
+}
+
+export function inferSessionResetType(
+  session: Partial<Session> | null | undefined,
+  opts?: { isGroup?: boolean | null; threadId?: string | null },
+): SessionResetType {
+  if ((session?.sessionType as string | undefined) === 'orchestrated') return 'main'
+  const threadId = opts?.threadId ?? session?.connectorContext?.threadId ?? null
+  if (threadId) return 'thread'
+  const isGroup = opts?.isGroup ?? session?.connectorContext?.isGroup ?? false
+  return isGroup ? 'group' : 'direct'
+}
+
+export function resolveSessionResetPolicy(params: {
+  session?: Partial<Session> | null
+  agent?: Partial<Agent> | null
+  settings?: Partial<AppSettings> | null
+  resetType?: SessionResetType
+  overrides?: Record<string, unknown>
+}): ResolvedSessionResetPolicy {
+  const type = params.resetType ?? inferSessionResetType(params.session)
+  const defaults = DEFAULT_POLICIES[type]
+  return {
+    type,
+    mode: normalizeMode(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionResetMode'),
+      defaults.mode,
+    ),
+    idleTimeoutSec: parseIntBounded(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionIdleTimeoutSec'),
+      0,
+      180 * 24 * 60 * 60,
+    ) ?? defaults.idleTimeoutSec,
+    maxAgeSec: parseIntBounded(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionMaxAgeSec'),
+      0,
+      365 * 24 * 60 * 60,
+    ) ?? defaults.maxAgeSec,
+    dailyResetAt: normalizeTimeHHMM(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionDailyResetAt'),
+    ) ?? defaults.dailyResetAt,
+    timezone: normalizeTimezone(
+      rawField(params.session, params.overrides, params.agent, params.settings, 'sessionResetTimezone'),
+    ) ?? defaults.timezone,
+  }
+}
+
+export function evaluateSessionFreshness(params: {
+  session?: Partial<Session> | null
+  policy: ResolvedSessionResetPolicy
+  now?: number
+}): SessionFreshnessSnapshot {
+  const now = typeof params.now === 'number' ? params.now : Date.now()
+  const session = params.session
+  const policy = params.policy
+  const messageCount = Array.isArray(session?.messages) ? session.messages.length : 0
+  const createdAt = typeof session?.createdAt === 'number' ? session.createdAt : now
+  const lastActiveAt = typeof session?.lastActiveAt === 'number' ? session.lastActiveAt : createdAt
+  const idleExpiresAt = typeof policy.idleTimeoutSec === 'number' && policy.idleTimeoutSec > 0
+    ? lastActiveAt + policy.idleTimeoutSec * 1000
+    : null
+
+  if (!session || messageCount === 0) {
+    return {
+      fresh: true,
+      policy,
+      idleExpiresAt,
+      dailyBoundaryKey: null,
+    }
+  }
+
+  if (idleExpiresAt !== null && now > idleExpiresAt) {
+    return {
+      fresh: false,
+      reason: `idle_timeout:${policy.idleTimeoutSec}`,
+      policy,
+      idleExpiresAt,
+      dailyBoundaryKey: null,
+    }
+  }
+
+  if (typeof policy.maxAgeSec === 'number' && policy.maxAgeSec > 0) {
+    const maxAgeMs = policy.maxAgeSec * 1000
+    if (now - createdAt > maxAgeMs) {
+      return {
+        fresh: false,
+        reason: `max_age:${policy.maxAgeSec}`,
+        policy,
+        idleExpiresAt,
+        dailyBoundaryKey: null,
+      }
+    }
+  }
+
+  if (policy.mode === 'daily' && policy.dailyResetAt) {
+    const boundary = normalizeTimeHHMM(policy.dailyResetAt)
+    if (boundary) {
+      const [hours, minutes] = boundary.split(':').map((value) => Number.parseInt(value, 10))
+      const boundaryMinutes = hours * 60 + minutes
+      const nowBoundaryKey = boundaryKeyForNow(now, boundaryMinutes, policy.timezone)
+      const lastActiveParts = getClockParts(new Date(lastActiveAt), policy.timezone)
+      if (
+        nowBoundaryKey
+        && lastActiveParts
+        && (
+          lastActiveParts.dateKey < nowBoundaryKey
+          || (lastActiveParts.dateKey === nowBoundaryKey && lastActiveParts.minutes < boundaryMinutes)
+        )
+      ) {
+        return {
+          fresh: false,
+          reason: `daily_reset:${policy.dailyResetAt}`,
+          policy,
+          idleExpiresAt,
+          dailyBoundaryKey: nowBoundaryKey,
+        }
+      }
+      return {
+        fresh: true,
+        policy,
+        idleExpiresAt,
+        dailyBoundaryKey: nowBoundaryKey,
+      }
+    }
+  }
+
+  return {
+    fresh: true,
+    policy,
+    idleExpiresAt,
+    dailyBoundaryKey: null,
+  }
+}
+
+export function resetSessionRuntime(
+  session: Session,
+  reason: string,
+  opts?: { now?: number },
+): number {
+  const now = typeof opts?.now === 'number' ? opts.now : Date.now()
+  const cleared = Array.isArray(session.messages) ? session.messages.length : 0
+
+  session.messages = []
+  session.claudeSessionId = null
+  session.codexThreadId = null
+  session.opencodeSessionId = null
+  session.delegateResumeIds = {
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+  session.createdAt = now
+  session.lastActiveAt = now
+  session.lastAutoMemoryAt = null
+  session.lastHeartbeatText = null
+  session.lastHeartbeatSentAt = null
+  session.conversationTone = undefined
+  session.lastSessionResetAt = now
+  session.lastSessionResetReason = reason
+
+  if (session.connectorContext) {
+    session.connectorContext = {
+      ...session.connectorContext,
+      lastResetAt: now,
+      lastResetReason: reason,
+      lastInboundMessageId: null,
+      lastInboundReplyToMessageId: null,
+      lastInboundThreadId: null,
+      lastOutboundMessageId: null,
+      lastOutboundAt: null,
+    }
+  }
+
+  return cleared
+}