@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/provider-health.ts

@@ -1,6 +1,6 @@
 import { spawnSync } from 'child_process'
 
-type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'
+type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
 
 interface ProviderHealthState {
   failures: number
@@ -15,6 +15,7 @@ const states: Map<string, ProviderHealthState> =
   (globalThis as any)[gk] ?? ((globalThis as any)[gk] = new Map<string, ProviderHealthState>())
 
 const cliCheckCache = new Map<string, { at: number; ok: boolean }>()
+const delegateReadyCache = new Map<string, { at: number; ok: boolean }>()
 const CLI_CHECK_TTL_MS = 30_000
 
 function commandExists(binary: string): boolean {
@@ -66,12 +67,43 @@ export function isProviderCoolingDown(providerId: string): boolean {
 function delegateBinary(delegateTool: DelegateTool): string {
   if (delegateTool === 'delegate_to_claude_code') return 'claude'
   if (delegateTool === 'delegate_to_codex_cli') return 'codex'
+  if (delegateTool === 'delegate_to_gemini_cli') return 'gemini'
   return 'opencode'
 }
 
+function delegateToolReady(delegateTool: DelegateTool): boolean {
+  const now = Date.now()
+  const cached = delegateReadyCache.get(delegateTool)
+  if (cached && now - cached.at < CLI_CHECK_TTL_MS) return cached.ok
+
+  const binary = delegateBinary(delegateTool)
+  let ok = commandExists(binary)
+  if (ok && delegateTool === 'delegate_to_claude_code') {
+    const probe = spawnSync(binary, ['auth', 'status'], { encoding: 'utf-8', timeout: 8000 })
+    if ((probe.status ?? 1) !== 0) {
+      let loggedIn = false
+      try {
+        const parsed = JSON.parse(probe.stdout || '{}') as { loggedIn?: boolean }
+        loggedIn = parsed.loggedIn === true
+      } catch {
+        loggedIn = false
+      }
+      ok = loggedIn
+    }
+  } else if (ok && delegateTool === 'delegate_to_codex_cli') {
+    const probe = spawnSync(binary, ['login', 'status'], { encoding: 'utf-8', timeout: 8000 })
+    const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()
+    ok = (probe.status ?? 1) === 0 && probeText.includes('logged in')
+  }
+
+  delegateReadyCache.set(delegateTool, { at: now, ok })
+  return ok
+}
+
 function delegateProviderId(delegateTool: DelegateTool): string {
   if (delegateTool === 'delegate_to_claude_code') return 'claude-cli'
   if (delegateTool === 'delegate_to_codex_cli') return 'codex-cli'
+  if (delegateTool === 'delegate_to_gemini_cli') return 'gemini-cli'
   return 'opencode-cli'
 }
 
@@ -83,9 +115,9 @@ export function rankDelegatesByHealth(order: DelegateTool[]): DelegateTool[] {
     return true
   })
   return deduped.sort((a, b) => {
-    const aBinOk = commandExists(delegateBinary(a))
-    const bBinOk = commandExists(delegateBinary(b))
-    if (aBinOk !== bBinOk) return aBinOk ? -1 : 1
+    const aReady = delegateToolReady(a)
+    const bReady = delegateToolReady(b)
+    if (aReady !== bReady) return aReady ? -1 : 1
 
     const aCool = isProviderCoolingDown(delegateProviderId(a))
     const bCool = isProviderCoolingDown(delegateProviderId(b))
@@ -202,14 +234,14 @@ export async function pingOpenClaw(
 
 /**
  * Ping a provider to check reachability. Returns `{ ok, message }`.
- * Skips CLI-based providers (claude-cli, codex-cli, opencode-cli) — returns ok.
+ * Skips CLI-based providers (claude-cli, codex-cli, opencode-cli, gemini-cli) — returns ok.
  */
 export async function pingProvider(
   provider: string,
   apiKey: string | undefined,
   endpoint: string | undefined,
 ): Promise<{ ok: boolean; message: string }> {
-  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli']
+  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli']
   if (CLI_PROVIDERS.includes(provider)) return { ok: true, message: 'CLI provider — skipped.' }
 
   try {

package/src/lib/server/queue.ts

@@ -4,14 +4,13 @@ import path from 'node:path'
 import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings, loadConnectors, UPLOAD_DIR } from './storage'
 import { notify } from './ws-hub'
 import { WORKSPACE_DIR } from './data-dir'
-import { createOrchestratorSession, executeOrchestrator } from './orchestrator'
+import { createOrchestratorSession } from './orchestrator'
 import { formatValidationFailure, validateTaskCompletion } from './task-validation'
 import { ensureTaskCompletionReport } from './task-reports'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
-import { isProtectedMainSession } from './main-session'
 import { cascadeUnblock } from './dag-validation'
 import { performGuardianRollback } from './guardian'
 import type { Agent, BoardTask, Connector, Message } from '@/types'
@@ -282,10 +281,6 @@ function pushQueueUnique(queue: string[], id: string): void {
   if (!queueContains(queue, id)) queue.push(id)
 }
 
-function isMainSession(session: SessionLike | null | undefined): boolean {
-  return isProtectedMainSession(session)
-}
-
 function resolveTaskOwnerUser(task: ScheduleTaskMeta, sessions: Record<string, SessionLike>): string | null {
   const direct = typeof task.user === 'string' ? task.user.trim() : ''
   if (direct) return direct
@@ -521,10 +516,8 @@ async function executeTaskRun(
     '- Include concrete evidence in your final summary: changed file paths, commands run, and verification results.',
     '- If blocked, state the blocker explicitly and what input or permission is missing.',
   ].join('\n')
-  if (agent?.isOrchestrator) {
-    return executeOrchestrator(agent, prompt, sessionId, task.id)
-  }
-
+  // All agents (including orchestrators) go through the unified chat execution path.
+  // Agents with subAgentIds get delegation tools automatically via session-tools.
   const run = await executeSessionChatTurn({
     sessionId,
     message: prompt,
@@ -596,18 +589,7 @@ function notifyMainChatScheduleResult(task: BoardTask): void {
     return msg
   }
 
-  for (const session of Object.values(sessions) as SessionLike[]) {
-    if (!isMainSession(session)) continue
-    if (ownerUser && session?.user && session.user !== ownerUser) continue
-    const last = Array.isArray(session.messages) ? session.messages.at(-1) : null
-    if (last?.role === 'assistant' && last?.text === body && typeof last?.time === 'number' && now - last.time < 30_000) continue
-    if (!Array.isArray(session.messages)) session.messages = []
-    session.messages.push(buildMsg())
-    session.lastActiveAt = now
-    changed = true
-  }
-
-  // Also push to the agent's persistent thread session
+  // Push to the agent's shortcut chat session.
   try {
     const agents = loadAgents()
     const agent = agents[task.agentId]
@@ -773,6 +755,7 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
   if (task.claudeResumeId) resumeLines.push(`Claude session: \`${task.claudeResumeId}\``)
   if (task.codexResumeId) resumeLines.push(`Codex thread: \`${task.codexResumeId}\``)
   if (task.opencodeResumeId) resumeLines.push(`OpenCode session: \`${task.opencodeResumeId}\``)
+  if (task.geminiResumeId) resumeLines.push(`Gemini session: \`${task.geminiResumeId}\``)
   // Fallback to legacy field
   if (resumeLines.length === 0 && task.cliResumeId) {
     resumeLines.push(`${task.cliProvider || 'CLI'} session: \`${task.cliResumeId}\``)
@@ -831,13 +814,12 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     }
 
     // Push to delegating agent's active user-facing chat sessions
-    // so the result is visible in the chat the user is looking at
+    // so the result is visible in the chat the user is looking at.
     if (delegator) {
       for (const session of Object.values(sessions)) {
         if (!session || session.agentId !== delegatedBy) continue
-        // Skip thread sessions and orchestrated/subagent sessions
+        // Skip the agent shortcut session itself.
         if (session.id === delegator.threadSessionId) continue
-        if (session.sessionType === 'orchestrated') continue
         // Only push to recently-active sessions (within last 30 minutes)
         const lastActive = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : 0
         if (now - lastActive > 30 * 60_000) continue
@@ -1315,24 +1297,27 @@ export async function processNext() {
             const execSession = execSessions[sessionId] as Record<string, unknown> | undefined
             if (execSession) {
               const delegateIds = execSession.delegateResumeIds as
-                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null }
+                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null; gemini?: string | null }
                 | undefined
               // Store each CLI resume ID separately
               const claudeId = (execSession.claudeSessionId as string) || delegateIds?.claudeCode || null
               const codexId = (execSession.codexThreadId as string) || delegateIds?.codex || null
               const opencodeId = (execSession.opencodeSessionId as string) || delegateIds?.opencode || null
+              const geminiId = delegateIds?.gemini || null
               if (claudeId) t2[taskId].claudeResumeId = claudeId
               if (codexId) t2[taskId].codexResumeId = codexId
               if (opencodeId) t2[taskId].opencodeResumeId = opencodeId
+              if (geminiId) t2[taskId].geminiResumeId = geminiId
               // Keep backward-compat single field (first available)
-              const primaryId = claudeId || codexId || opencodeId
+              const primaryId = claudeId || codexId || opencodeId || geminiId
               if (primaryId) {
                 t2[taskId].cliResumeId = primaryId
                 if (claudeId) t2[taskId].cliProvider = 'claude-cli'
                 else if (codexId) t2[taskId].cliProvider = 'codex-cli'
                 else if (opencodeId) t2[taskId].cliProvider = 'opencode-cli'
+                else if (geminiId) t2[taskId].cliProvider = 'gemini-cli'
               }
-              console.log(`[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}`)
+              console.log(`[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}, gemini=${geminiId}`)
             }
           } catch (e) {
             console.warn(`[queue] Failed to extract CLI resume IDs for task ${taskId}:`, e)

package/src/lib/server/scheduler.ts

@@ -6,6 +6,7 @@ import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
 import { enqueueSystemEvent } from './system-events'
 import { requestHeartbeatNow } from './heartbeat-wake'
+import { processDueWatchJobs } from './watch-jobs'
 
 const TICK_INTERVAL = 60_000 // 60 seconds
 let intervalId: ReturnType<typeof setInterval> | null = null
@@ -73,6 +74,7 @@ function computeNextRuns() {
 
 async function tick() {
   const now = Date.now()
+  await processDueWatchJobs(now)
   const schedules = loadSchedules()
   const agents = loadAgents()
   const tasks = loadTasks()

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

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import type { Session } from '@/types'
+import { buildSessionArchiveMarkdown, buildSessionArchivePayload } from './session-archive-memory'
+
+test('buildSessionArchivePayload summarizes session transcript and metadata', () => {
+  const session = {
+    id: 'session-1',
+    name: 'Support Thread',
+    cwd: process.cwd(),
+    user: 'Alice',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: Date.parse('2026-03-05T00:00:00.000Z'),
+    lastActiveAt: Date.parse('2026-03-05T10:00:00.000Z'),
+    sessionType: 'human',
+    messages: [
+      { role: 'user', text: 'Can you help me debug this issue?', time: 1 },
+      { role: 'assistant', text: 'Yes, show me the stack trace.', time: 2, toolEvents: [{ name: 'files', input: '{}' }] },
+    ],
+    identityState: { personaLabel: 'Debugger' },
+  } as Session
+
+  const payload = buildSessionArchivePayload(session, { name: 'Swarmy' })
+
+  assert.ok(payload)
+  assert.equal(payload?.title, 'Session archive: Support Thread')
+  assert.match(payload?.content || '', /Transcript excerpt:/)
+  assert.match(payload?.content || '', /Swarmy/)
+  assert.equal(payload?.metadata.tier, 'archive')
+  assert.equal(payload?.references[0]?.type, 'session')
+})
+
+test('buildSessionArchiveMarkdown creates a portable markdown snapshot', () => {
+  const session = {
+    id: 'session-3',
+    name: 'Architecture Review',
+    cwd: process.cwd(),
+    user: 'Alice',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: Date.parse('2026-03-05T00:00:00.000Z'),
+    lastActiveAt: Date.parse('2026-03-05T10:00:00.000Z'),
+    sessionType: 'human',
+    messages: [
+      { role: 'user', text: 'Summarize the new connector policy.', time: 1 },
+      { role: 'assistant', text: 'It now uses scoped sessions and freshness resets.', time: 2 },
+    ],
+    identityState: { personaLabel: 'Reviewer' },
+  } as Session
+
+  const payload = buildSessionArchivePayload(session, { name: 'Swarmy' })
+  assert.ok(payload)
+
+  const markdown = buildSessionArchiveMarkdown(session, payload!, { name: 'Swarmy' })
+  assert.match(markdown, /^# Session archive: Architecture Review/m)
+  assert.match(markdown, /## Archive Snapshot/)
+  assert.match(markdown, /## Transcript Excerpt/)
+  assert.match(markdown, /\*\*Swarmy\*\*/)
+})
+
+test('buildSessionArchivePayload skips trivial sessions', () => {
+  const session = {
+    id: 'session-2',
+    name: 'Too Short',
+    cwd: process.cwd(),
+    user: 'Bob',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    createdAt: 1,
+    lastActiveAt: 1,
+    messages: [{ role: 'user', text: 'hi', time: 1 }],
+  } as Session
+
+  assert.equal(buildSessionArchivePayload(session), null)
+})

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')
+})