@swarmclawai/swarmclaw 1.2.1 → 1.2.3

package/src/lib/server/chat-execution/prompt-builder.ts

@@ -73,13 +73,24 @@ function buildExtensionCapabilityLines(enabledExtensions: string[], opts?: { del
   return lines
 }
 
+const DISPLAY_TOOL_ALIASES: Record<string, string[]> = {
+  files: ['send_file'],
+  shell: ['sandbox_exec', 'sandbox_list_runtimes'],
+}
+
 function buildExactToolNameList(enabledExtensions: string[]): string[] {
   const planning = getEnabledToolPlanningView(enabledExtensions)
+  const displayAliases = dedup(
+    enabledExtensions
+      .map((toolId) => canonicalizeExtensionId(toolId))
+      .flatMap((toolId) => DISPLAY_TOOL_ALIASES[toolId] || []),
+  )
   const extensionToolNames = getExtensionManager()
     .getTools(enabledExtensions)
     .map(({ tool }) => tool.name)
   const combined = [
     ...planning.displayToolIds,
+    ...displayAliases,
     ...planning.entries.map((entry) => entry.toolName),
     ...extensionToolNames,
   ]

package/src/lib/server/chat-execution/prompt-sections.ts

@@ -9,7 +9,8 @@
 import type { Session, Agent } from '@/types'
 import type { ActiveProjectContext } from '@/lib/server/project-context'
 import { buildIdentityContinuityContext } from '@/lib/server/identity-continuity'
-import { loadSkills, loadAgents } from '@/lib/server/storage'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
+import { loadSkills } from '@/lib/server/skills/skill-repository'
 import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import { resolveTeam } from '@/lib/server/agents/team-resolution'
 
@@ -127,8 +128,7 @@ export async function buildAgentAwarenessSection(
     // Load agent to get delegation settings so the awareness block respects them
     let delegationOpts: { delegationTargetMode?: 'all' | 'selected'; delegationTargetAgentIds?: string[] } | undefined
     try {
-      const agents = loadAgents() as Record<string, Agent>
-      const agent = agents[session.agentId]
+      const agent = getAgent(session.agentId)
       if (agent?.delegationTargetMode === 'selected') {
         delegationOpts = {
           delegationTargetMode: 'selected',
@@ -334,7 +334,7 @@ export function buildCoordinatorSection(
 ): string | null {
   if (!agent || agent.role !== 'coordinator') return null
 
-  const allAgents = loadAgents()
+  const allAgents = listAgents()
   const selfId = agent.id
 
   // Resolve which agents this coordinator can delegate to
@@ -511,8 +511,7 @@ export function buildCliDelegationContext(opts: {
   // Team roster summary
   if (opts.agent?.id) {
     try {
-      const agents = loadAgents() as Record<string, Agent>
-      const team = resolveTeam(opts.agent.id, agents)
+      const team = resolveTeam(opts.agent.id, listAgents())
       if (team.mode === 'team') {
         const teammates = [
           ...(team.coordinator ? [`${team.coordinator.name} (coordinator)`] : []),

package/src/lib/server/chat-execution/situational-awareness.ts

@@ -1,4 +1,11 @@
-import { loadTasks, loadSchedules, loadSupervisorIncidents, loadMission, loadAgents, loadConnectors, loadChatrooms, loadUsage } from '@/lib/server/storage'
+import { listAgentIncidents } from '@/lib/server/autonomy/supervisor-incident-repository'
+import { listAgents } from '@/lib/server/agents/agent-repository'
+import { loadChatrooms } from '@/lib/server/chatrooms/chatroom-repository'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { loadMission } from '@/lib/server/missions/mission-repository'
+import { loadSchedules } from '@/lib/server/schedules/schedule-repository'
+import { loadTasks } from '@/lib/server/tasks/task-repository'
+import { loadUsage } from '@/lib/server/usage/usage-repository'
 import { listPersistedRuns } from '@/lib/server/runtime/run-ledger'
 import type { BoardTask, Mission, Schedule, SupervisorIncident, SessionRunRecord } from '@/types'
 
@@ -258,7 +265,7 @@ export function buildPlatformStatusSummary(): string {
   const oneDayAgo = now - 86_400_000
 
   // Agents
-  const agents = Object.values(loadAgents())
+  const agents = Object.values(listAgents())
   const activeAgents = agents.filter((a) => a.lastUsedAt && a.lastUsedAt > oneHourAgo)
 
   // Tasks
@@ -276,7 +283,7 @@ export function buildPlatformStatusSummary(): string {
   const connectors = Object.values(loadConnectors())
   const connectorLines: string[] = []
   for (const c of connectors) {
-    const status = c.status === 'running' || c.status === 'connected' ? '✓' : `✗ (${c.status})`
+    const status = c.status === 'running' ? '✓' : `✗ (${c.status})`
     connectorLines.push(`${c.platform || c.id} ${status}`)
   }
 
@@ -285,8 +292,7 @@ export function buildPlatformStatusSummary(): string {
   const activeChatrooms = chatrooms.filter((c) => !c.archivedAt && !c.temporary)
 
   // Incidents
-  const allIncidents = Object.values(loadSupervisorIncidents())
-  const recentIncidents = allIncidents.filter((i) => i.createdAt > oneDayAgo)
+  const recentIncidents = listAgentIncidents().filter((i) => i.createdAt > oneDayAgo)
   const warnings = recentIncidents.filter((i) => i.severity === 'medium').length
   const errors = recentIncidents.filter((i) => i.severity === 'high').length
 
@@ -348,8 +354,7 @@ export function buildSituationalAwarenessBlock(input: SituationalAwarenessInput)
 
   const failedRuns = listPersistedRuns({ sessionId, status: 'failed', limit: 10 })
 
-  const allIncidents = loadSupervisorIncidents()
-  const incidents = Object.values(allIncidents).filter((i) => i.agentId === agentId)
+  const incidents = listAgentIncidents(agentId)
 
   const mission = missionId ? loadMission(missionId) : null
 

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -3,9 +3,10 @@ import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
 import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
+import { getAgent } from '@/lib/server/agents/agent-repository'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
-import { loadSettings, loadAgents } from '@/lib/server/storage'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
 import { getExtensionManager } from '@/lib/server/extensions'
 import {
   collectCapabilityAgentContext,
@@ -228,13 +229,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // fallbackCredentialIds is intentionally accepted for compatibility with caller signatures.
   void fallbackCredentialIds
 
+  const sessionAgent = session.agentId ? getAgent(session.agentId) : null
+
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
   if (session.thinkingLevel) {
     agentThinkingLevel = session.thinkingLevel
-  } else if (session.agentId) {
-    const agentsForThinking = loadAgents()
-    agentThinkingLevel = agentsForThinking[session.agentId]?.thinkingLevel
+  } else if (sessionAgent) {
+    agentThinkingLevel = sessionAgent.thinkingLevel
   }
 
   const llm = buildChatModel({
@@ -320,9 +322,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   let agentResponseStyle: 'concise' | 'normal' | 'detailed' | null = null
   let agentResponseMaxChars: number | null = null
   const activeProjectContext = resolveActiveProjectContext(session)
-  if (session.agentId) {
-    const agents = loadAgents()
-    const agent = agents[session.agentId]
+  if (sessionAgent) {
+    const agent = sessionAgent
     isCoordinatorAgent = agent?.role === 'coordinator'
     agentDelegationEnabled = agent?.delegationEnabled === true
     agentDelegationTargetMode = agent?.delegationTargetMode === 'selected' ? 'selected' : 'all'
@@ -415,10 +416,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Proactive memory recall — full mode only
   {
-    const agents = loadAgents()
-    const agentForMemory = session.agentId ? agents[session.agentId] : null
     const memoryResult = await buildProactiveMemorySection(
-      session, agentForMemory, message, activeProjectContext.projectRoot,
+      session, sessionAgent, message, activeProjectContext.projectRoot,
       isMinimalPrompt, currentThreadRecallRequest,
     )
     if (memoryResult.section) promptParts.push(memoryResult.section)
@@ -926,14 +925,18 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
           && !abortController.signal.aborted)
           || (isTransientProviderError && !abortController.signal.aborted)
 
-        const logLevel = abortController.signal.aborted ? 'warn' : 'error'
-        console[logLevel](`[stream-agent-chat] Error in streamEvents iteration=${iteration}`, {
+        const logPayload = {
           errName, errMsg, errStack,
           statusCode, retryAfterMs: extractedRetryAfterMs,
           isRecursionError, isContextOverflow, isTransientAbort,
           hasToolCalls: state.hasToolCalls, fullTextLen: state.fullText.length,
           parentAborted: abortController.signal.aborted,
-        })
+        }
+        if (abortController.signal.aborted) {
+          log.warn(TAG, `Error in streamEvents iteration=${iteration}`, logPayload)
+        } else {
+          log.error(TAG, `Error in streamEvents iteration=${iteration}`, logPayload)
+        }
 
         if (timers.requiredToolKickoffTimedOut && limits.canContinue('required_tool') && !abortController.signal.aborted) {
           const hadPartialOutput = state.fullText.length > iterationStartState.fullText.length || state.streamedToolEvents.length > iterationStartState.toolEventCount

package/src/lib/server/chatrooms/chatroom-repository.ts

@@ -0,0 +1,32 @@
+import type { Chatroom } from '@/types'
+
+import {
+  loadChatroom as loadStoredChatroom,
+  loadChatrooms as loadStoredChatrooms,
+  saveChatrooms as saveStoredChatrooms,
+  upsertChatroom as upsertStoredChatroom,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const chatroomRepository = createRecordRepository<Chatroom>(
+  'chatrooms',
+  {
+    get(id) {
+      return loadStoredChatroom(id) as Chatroom | null
+    },
+    list() {
+      return loadStoredChatrooms() as Record<string, Chatroom>
+    },
+    upsert(id, value) {
+      upsertStoredChatroom(id, value as Chatroom)
+    },
+    replace(data) {
+      saveStoredChatrooms(data)
+    },
+  },
+)
+
+export const loadChatrooms = () => chatroomRepository.list()
+export const loadChatroom = (id: string) => chatroomRepository.get(id)
+export const saveChatrooms = (items: Record<string, Chatroom | Record<string, unknown>>) => chatroomRepository.replace(items as Record<string, Chatroom>)
+export const upsertChatroom = (id: string, value: Chatroom | Record<string, unknown>) => chatroomRepository.upsert(id, value as Chatroom)

package/src/lib/server/connectors/connector-repository.ts

@@ -0,0 +1,58 @@
+import type { Connector } from '@/types'
+
+import {
+  deleteStoredItem,
+  loadConnectorHealth as loadStoredConnectorHealth,
+  loadConnectors as loadStoredConnectors,
+  loadStoredItem,
+  saveConnectors as saveStoredConnectors,
+  upsertConnectorHealthEvent as upsertStoredConnectorHealthEvent,
+  upsertStoredItem,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const connectorRepository = createRecordRepository<Connector>(
+  'connectors',
+  {
+    get(id) {
+      return loadStoredItem('connectors', id) as Connector | null
+    },
+    list() {
+      return loadStoredConnectors() as Record<string, Connector>
+    },
+    upsert(id, value) {
+      upsertStoredItem('connectors', id, value)
+    },
+    replace(data) {
+      saveStoredConnectors(data)
+    },
+    patch(id, updater) {
+      const current = loadStoredItem('connectors', id) as Connector | null
+      const next = updater(current)
+      if (next === null) {
+        deleteStoredItem('connectors', id)
+        return null
+      }
+      upsertStoredItem('connectors', id, next)
+      return next
+    },
+    delete(id) {
+      deleteStoredItem('connectors', id)
+    },
+  },
+)
+
+export const loadConnectors = () => connectorRepository.list()
+export const loadConnector = (id: string) => connectorRepository.get(id)
+export const saveConnectors = (items: Record<string, Connector | Record<string, unknown>>) => connectorRepository.replace(items as Record<string, Connector>)
+export const upsertConnector = (id: string, value: Connector | Record<string, unknown>) => connectorRepository.upsert(id, value as Connector)
+export const patchConnector = (id: string, updater: (current: Connector | null) => Connector | null) => connectorRepository.patch(id, updater)
+export const deleteConnector = (id: string) => connectorRepository.delete(id)
+
+export function loadConnectorHealth() {
+  return loadStoredConnectorHealth()
+}
+
+export function upsertConnectorHealthEvent(id: string, value: Record<string, unknown>) {
+  upsertStoredConnectorHealthEvent(id, value)
+}

package/src/lib/server/connectors/runtime-state.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { describe, it, before, after } from 'node:test'
+
+const originalEnv = {
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let mod: typeof import('@/lib/server/connectors/runtime-state')
+
+before(async () => {
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  mod = await import('@/lib/server/connectors/runtime-state')
+})
+
+after(() => {
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+})
+
+// ---------------------------------------------------------------------------
+// getConnectorRuntimeState
+// ---------------------------------------------------------------------------
+
+describe('getConnectorRuntimeState', () => {
+  it('returns object with all expected Map keys', () => {
+    const state = mod.getConnectorRuntimeState()
+    assert.ok(state.running instanceof Map)
+    assert.ok(state.lastInboundChannelByConnector instanceof Map)
+    assert.ok(state.lastInboundTimeByConnector instanceof Map)
+    assert.ok(state.locks instanceof Map)
+    assert.ok(state.generationCounter instanceof Map)
+    assert.ok(state.scheduledFollowups instanceof Map)
+    assert.ok(state.recentInboundByKey instanceof Map)
+    assert.ok(state.pendingInboundDebounce instanceof Map)
+    assert.ok(state.scheduledFollowupByDedupe instanceof Map)
+    assert.ok(state.reconnectStates instanceof Map)
+    assert.ok(state.recentOutbound instanceof Map)
+    assert.ok(state.routeMessageHandlerRef)
+    assert.equal(typeof state.routeMessageHandlerRef.current, 'function')
+  })
+
+  it('returns the same instance on repeated calls (singleton)', () => {
+    const a = mod.getConnectorRuntimeState()
+    const b = mod.getConnectorRuntimeState()
+    assert.equal(a, b)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// pruneConnectorTrackingState
+// ---------------------------------------------------------------------------
+
+describe('pruneConnectorTrackingState', () => {
+  it('removes stale entries and retains live ones', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    // Seed tracking maps with stale + live IDs
+    state.lastInboundChannelByConnector.set('live-1', 'channel-a')
+    state.lastInboundChannelByConnector.set('stale-1', 'channel-b')
+    state.lastInboundTimeByConnector.set('live-1', Date.now())
+    state.lastInboundTimeByConnector.set('stale-2', Date.now())
+    state.generationCounter.set('live-1', 5)
+    state.generationCounter.set('stale-1', 3)
+
+    const liveIds = new Set(['live-1'])
+    const removed = mod.pruneConnectorTrackingState(liveIds)
+
+    // Verify stale entries are gone
+    assert.equal(state.lastInboundChannelByConnector.has('stale-1'), false)
+    assert.equal(state.lastInboundTimeByConnector.has('stale-2'), false)
+    assert.equal(state.generationCounter.has('stale-1'), false)
+
+    // Verify live entries are retained
+    assert.equal(state.lastInboundChannelByConnector.get('live-1'), 'channel-a')
+    assert.ok(state.lastInboundTimeByConnector.has('live-1'))
+    assert.equal(state.generationCounter.get('live-1'), 5)
+
+    // Removed count: stale-1 from channel + stale-2 from time + stale-1 from gen = 3
+    assert.equal(removed, 3)
+  })
+
+  it('removes all entries when liveIds is empty', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    state.lastInboundChannelByConnector.set('a', 'ch')
+    state.lastInboundTimeByConnector.set('a', 1)
+    state.generationCounter.set('a', 1)
+
+    const removed = mod.pruneConnectorTrackingState(new Set())
+
+    assert.equal(state.lastInboundChannelByConnector.size, 0)
+    assert.equal(state.lastInboundTimeByConnector.size, 0)
+    assert.equal(state.generationCounter.size, 0)
+    assert.ok(removed >= 3)
+  })
+
+  it('returns 0 when all IDs are live', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    // Clear first
+    state.lastInboundChannelByConnector.clear()
+    state.lastInboundTimeByConnector.clear()
+    state.generationCounter.clear()
+
+    state.lastInboundChannelByConnector.set('x', 'ch')
+    state.lastInboundTimeByConnector.set('x', 1)
+    state.generationCounter.set('x', 1)
+
+    const removed = mod.pruneConnectorTrackingState(new Set(['x']))
+    assert.equal(removed, 0)
+
+    // Entries still present
+    assert.equal(state.lastInboundChannelByConnector.has('x'), true)
+    assert.equal(state.lastInboundTimeByConnector.has('x'), true)
+    assert.equal(state.generationCounter.has('x'), true)
+  })
+})

package/src/lib/server/credentials/credential-repository.ts

@@ -0,0 +1,7 @@
+export {
+  decryptKey,
+  deleteCredential,
+  encryptKey,
+  loadCredentials,
+  saveCredentials,
+} from '@/lib/server/storage'

package/src/lib/server/gateways/gateway-profile-repository.ts

@@ -0,0 +1,4 @@
+export {
+  loadGatewayProfiles,
+  saveGatewayProfiles,
+} from '@/lib/server/storage'

package/src/lib/server/memory/memory-abstract.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { generateAbstract } from './memory-abstract'
+
+// ---------------------------------------------------------------------------
+// Short content guard
+// ---------------------------------------------------------------------------
+
+describe('generateAbstract', () => {
+  it('returns null for content <= 200 chars', async () => {
+    const short = 'A'.repeat(200)
+    assert.equal(await generateAbstract(short, 'title'), null)
+  })
+
+  it('returns null for empty content', async () => {
+    assert.equal(await generateAbstract('', 'title'), null)
+  })
+
+  it('returns null for content exactly 200 chars', async () => {
+    assert.equal(await generateAbstract('x'.repeat(200)), null)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Fallback abstract
+  // ---------------------------------------------------------------------------
+
+  it('returns fallback (truncated prefix) when LLM import fails', async () => {
+    // generateAbstract uses dynamic import('@/lib/server/build-llm')
+    // In a test environment without the full server, the import will fail
+    // and the catch block returns fallbackAbstract
+    const longContent = 'B'.repeat(250)
+    const result = await generateAbstract(longContent, 'title')
+    // Fallback: first 150 chars + '...'
+    assert.ok(result !== null)
+    assert.equal(result, 'B'.repeat(150) + '...')
+  })
+
+  it('returns content as-is when <= 150 chars and LLM fails', async () => {
+    // This case won't trigger because content <= 200 returns null.
+    // The fallback only runs for content > 200 chars.
+    // For content > 200 but fallback returns first 150 + '...'
+    const content = 'C'.repeat(201)
+    const result = await generateAbstract(content, 'title')
+    assert.ok(result !== null)
+    assert.equal(result, 'C'.repeat(150) + '...')
+  })
+
+  it('fallback does not add ellipsis for content <= 150 chars', async () => {
+    // This is a unit test of the fallback logic itself:
+    // Since generateAbstract returns null for content <= 200,
+    // the fallback truncation (150 + '...') only applies to content > 200.
+    // But the fallbackAbstract function itself handles <= 150 without ellipsis.
+    // We test this indirectly — content of 201 chars gets truncated to 150 + '...'
+    const content = 'D'.repeat(201)
+    const result = await generateAbstract(content)
+    assert.equal(result, 'D'.repeat(150) + '...')
+  })
+})

package/src/lib/server/missions/mission-repository.ts

@@ -0,0 +1,74 @@
+import type { Mission, MissionEvent } from '@/types'
+
+import {
+  deleteMission as deleteStoredMission,
+  loadMission as loadStoredMission,
+  loadMissionEvent as loadStoredMissionEvent,
+  loadMissionEvents as loadStoredMissionEvents,
+  loadMissions as loadStoredMissions,
+  patchMission as patchStoredMission,
+  saveMissionEvents as saveStoredMissionEvents,
+  saveMissions as saveStoredMissions,
+  upsertMission as upsertStoredMission,
+  upsertMissionEvent as upsertStoredMissionEvent,
+  upsertMissionEvents as upsertStoredMissionEvents,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const missionRepository = createRecordRepository<Mission>(
+  'missions',
+  {
+    get(id) {
+      return loadStoredMission(id) as Mission | null
+    },
+    list() {
+      return loadStoredMissions() as Record<string, Mission>
+    },
+    upsert(id, value) {
+      upsertStoredMission(id, value as Mission)
+    },
+    replace(data) {
+      saveStoredMissions(data as Record<string, Mission>)
+    },
+    patch(id, updater) {
+      return patchStoredMission(id, updater as (current: Mission | null) => Mission | null) as Mission | null
+    },
+    delete(id) {
+      deleteStoredMission(id)
+    },
+  },
+)
+
+export const missionEventRepository = createRecordRepository<MissionEvent>(
+  'mission-events',
+  {
+    get(id) {
+      return loadStoredMissionEvent(id) as MissionEvent | null
+    },
+    list() {
+      return loadStoredMissionEvents() as Record<string, MissionEvent>
+    },
+    upsert(id, value) {
+      upsertStoredMissionEvent(id, value as MissionEvent)
+    },
+    upsertMany(entries) {
+      upsertStoredMissionEvents(entries as Array<[string, MissionEvent]>)
+    },
+    replace(data) {
+      saveStoredMissionEvents(data as Record<string, MissionEvent>)
+    },
+  },
+)
+
+export const loadMissions = () => missionRepository.list()
+export const loadMission = (id: string) => missionRepository.get(id)
+export const saveMissions = (items: Record<string, Mission | Record<string, unknown>>) => missionRepository.replace(items as Record<string, Mission>)
+export const upsertMission = (id: string, value: Mission | Record<string, unknown>) => missionRepository.upsert(id, value as Mission)
+export const patchMission = (id: string, updater: (current: Mission | null) => Mission | null) => missionRepository.patch(id, updater)
+export const deleteMission = (id: string) => missionRepository.delete(id)
+
+export const loadMissionEvents = () => missionEventRepository.list()
+export const loadMissionEvent = (id: string) => missionEventRepository.get(id)
+export const saveMissionEvents = (items: Record<string, MissionEvent | Record<string, unknown>>) => missionEventRepository.replace(items as Record<string, MissionEvent>)
+export const upsertMissionEvent = (id: string, value: MissionEvent | Record<string, unknown>) => missionEventRepository.upsert(id, value as MissionEvent)
+export const upsertMissionEvents = (entries: Array<[string, MissionEvent | Record<string, unknown>]>) => missionEventRepository.upsertMany(entries as Array<[string, MissionEvent]>)

package/src/lib/server/missions/mission-service/actions.ts

@@ -0,0 +1,6 @@
+export {
+  appendMissionEvent,
+  ensureDelegationMission,
+  performMissionAction,
+  syncDelegationMissionFromJob,
+} from './core'

package/src/lib/server/missions/mission-service/bindings.ts

@@ -0,0 +1,9 @@
+export {
+  bindMissionToSession,
+  bindMissionToTask,
+  ensureMissionForSchedule,
+  ensureMissionForTask,
+  noteMissionTaskFinished,
+  noteMissionTaskStarted,
+  noteScheduleMissionTriggered,
+} from './core'

package/src/lib/server/missions/mission-service/context.ts

@@ -0,0 +1,4 @@
+export {
+  buildMissionContextBlock,
+  buildMissionHeartbeatPrompt,
+} from './core'