@swarmclawai/swarmclaw 1.2.3 → 1.2.5

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

@@ -1,5 +1,6 @@
 import type { Message, MessageToolEvent } from '@/types'
 import { loadSessions, saveSessions } from './storage'
+import { appendMessage } from '@/lib/server/messages/message-repository'
 import { notify } from './ws-hub'
 
 export interface SessionNoteInput {
@@ -27,16 +28,14 @@ export function appendSessionNote(input: SessionNoteInput): Message | null {
   const sessions = loadSessions()
   const session = sessions[input.sessionId]
   if (!session) return null
-  if (!Array.isArray(session.messages)) session.messages = []
 
   const next = buildSessionNoteMessage(input)
   if (!next) return null
 
-  session.messages.push(next)
+  appendMessage(input.sessionId, next)
   session.lastActiveAt = next.time
   sessions[input.sessionId] = session
   saveSessions(sessions)
   notify('sessions')
-  notify(`messages:${input.sessionId}`)
   return next
 }

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

@@ -1,5 +1,6 @@
 import type { Agent, AppSettings, Session, SessionResetMode, SessionResetType } from '@/types'
 import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
+import { clearMessages, getMessageCount } from '@/lib/server/messages/message-repository'
 
 export interface ResolvedSessionResetPolicy {
   type: SessionResetType
@@ -190,7 +191,7 @@ export function evaluateSessionFreshness(params: {
   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 messageCount = typeof session?.id === 'string' ? getMessageCount(session.id) : 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
@@ -275,9 +276,9 @@ export function resetSessionRuntime(
   opts?: { now?: number },
 ): number {
   const now = typeof opts?.now === 'number' ? opts.now : Date.now()
-  const cleared = Array.isArray(session.messages) ? session.messages.length : 0
+  const cleared = getMessageCount(session.id)
 
-  session.messages = []
+  clearMessages(session.id)
   session.claudeSessionId = null
   session.codexThreadId = null
   session.opencodeSessionId = null

package/src/lib/server/session-tools/connector.ts

@@ -10,6 +10,7 @@ import { normalizeToolInputArgs } from './normalize-tool-args'
 import { safeJsonParseObject } from '../json-utils'
 import { tryResolvePathWithinBaseDir } from '../path-utils'
 import { dedup, errorMessage } from '@/lib/shared-utils'
+import { getMessages } from '@/lib/server/messages/message-repository'
 import { isDirectConnectorSession } from '../connectors/session-kind'
 import {
   prepareConnectorVoiceNotePayload,
@@ -135,9 +136,10 @@ function pruneOldConnectorToolState(now: number): void {
 }
 
 function parseLatestUserTurn(
-  session: { messages?: Array<Record<string, unknown>> } | null | undefined,
+  sessionId: string | null | undefined,
 ): { text: string; time: number } {
-  const msgs = Array.isArray(session?.messages) ? session.messages : []
+  if (!sessionId) return { text: '', time: 0 }
+  const msgs = getMessages(sessionId)
   for (let i = msgs.length - 1; i >= 0; i -= 1) {
     const msg = msgs[i]
     if (String(msg?.role || '') !== 'user') continue
@@ -435,10 +437,10 @@ function trimToString(value: unknown): string {
 
 function resolveSessionConnectorTargets(
   session: {
+    id?: string
     user?: string
     name?: string
     connectorContext?: Record<string, unknown>
-    messages?: Array<Record<string, unknown>>
   } | null | undefined,
   connectorId: string,
 ): Array<{ channelId: string; senderId?: string; senderName?: string }> {
@@ -463,7 +465,8 @@ function resolveSessionConnectorTargets(
       : null)
   }
 
-  const messages = Array.isArray(session?.messages) ? session.messages : []
+  const sessionId = typeof session?.id === 'string' ? session.id : ''
+  const messages = sessionId ? getMessages(sessionId) : []
   for (let i = messages.length - 1; i >= 0; i -= 1) {
     if (messages[i]?.historyExcluded === true) continue
     const source = messages[i]?.source as Record<string, unknown> | undefined
@@ -485,10 +488,10 @@ function pickChannelTarget(params: {
   connectorId: string
   to?: string
   currentSession?: {
+    id?: string
     user?: string
     name?: string
     connectorContext?: Record<string, unknown>
-    messages?: Array<Record<string, unknown>>
   } | null
 }): { channelId: string; error?: string } {
   let channelId = params.to?.trim() || ''
@@ -694,7 +697,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
     const currentSession = bctx.resolveCurrentSession?.()
     const sessionId = bctx.ctx?.sessionId || currentSession?.id || undefined
     const connectorScopedSessionId = isDirectConnectorSession(currentSession) ? sessionId : undefined
-    const latestUserTurn = parseLatestUserTurn(currentSession)
+    const latestUserTurn = parseLatestUserTurn(sessionId)
     const turnKey = buildConnectorActionKey([sessionId, latestUserTurn.time || 'no-user-turn'])
 
     if (actionName === 'list_running' || actionName === 'list_targets') {

package/src/lib/server/session-tools/context-mgmt.ts

@@ -1,13 +1,14 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { HumanMessage } from '@langchain/core/messages'
-import { loadSessions, saveSessions } from '../storage'
 import { buildChatModel } from '../build-llm'
 import type { ToolBuildContext } from './context'
 import type { Extension, ExtensionHooks, Session } from '@/types'
 import { registerNativeCapability } from '../native-capabilities'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { errorMessage } from '@/lib/shared-utils'
+import { updateSessionRunContext } from '@/lib/server/run-context'
+import { getMessages, replaceAllMessages } from '@/lib/server/messages/message-repository'
 
 interface ContextToolContext {
   ctx?: { agentId?: string | null; sessionId?: string | null }
@@ -22,7 +23,7 @@ async function executeContextStatus(bctx: ContextToolContext) {
     const { getContextStatus } = await import('../context-manager')
     const session = bctx.resolveCurrentSession?.()
     if (!session) return 'Error: no current session context.'
-    const status = getContextStatus(session.messages || [], 2000, session.provider as string, session.model as string, {
+    const status = getContextStatus(getMessages(session.id), 2000, session.provider as string, session.model as string, {
       includeToolEvents: false,
     })
     return JSON.stringify(status)
@@ -36,7 +37,7 @@ async function executeContextSummarize(args: { keepLastN?: number }, bctx: Conte
     const session = bctx.resolveCurrentSession?.()
     if (!session || !bctx.ctx?.sessionId) return 'Error: no session context.'
     
-    const messages = session.messages || []
+    const messages = getMessages(session.id)
     const keepLastN = normalized.keepLastN as number | undefined
     const keep = Math.max(2, Math.min(keepLastN || 10, messages.length))
     if (messages.length <= keep) return JSON.stringify({ status: 'no_action' })
@@ -58,15 +59,39 @@ async function executeContextSummarize(args: { keepLastN?: number }, bctx: Conte
       provider: session.provider, model: session.model, generateSummary
     })
 
-    const sessions = loadSessions()
-    if (sessions[bctx.ctx.sessionId]) {
-      sessions[bctx.ctx.sessionId].messages = result.messages
-      saveSessions(sessions)
-    }
+    replaceAllMessages(bctx.ctx.sessionId ?? '', result.messages)
     return JSON.stringify({ status: 'compacted', remaining: result.messages.length })
   } catch (err: unknown) { return `Error: ${errorMessage(err)}` }
 }
 
+const PIN_CONTEXT_TYPE_MAP: Record<string, 'keyFacts' | 'failedApproaches' | 'blockers' | 'discoveries'> = {
+  fact: 'keyFacts',
+  failed_approach: 'failedApproaches',
+  blocker: 'blockers',
+  discovery: 'discoveries',
+}
+
+async function executePinContext(
+  args: { type?: string; content?: string },
+  bctx: ContextToolContext,
+) {
+  try {
+    const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+    const type = String(normalized.type || '').toLowerCase()
+    const content = String(normalized.content || '').slice(0, 300).trim()
+    if (!content) return 'Error: content is required.'
+    const field = PIN_CONTEXT_TYPE_MAP[type]
+    if (!field) return `Error: type must be one of: ${Object.keys(PIN_CONTEXT_TYPE_MAP).join(', ')}`
+    const sessionId = bctx.ctx?.sessionId
+    if (!sessionId) return 'Error: no session context.'
+    updateSessionRunContext(sessionId, (ctx) => {
+      ctx[field] = [...ctx[field], content]
+      return ctx
+    })
+    return JSON.stringify({ status: 'pinned', type, field })
+  } catch (err: unknown) { return `Error: ${errorMessage(err)}` }
+}
+
 /**
  * Register as a Built-in Extension
  */
@@ -89,6 +114,19 @@ const ContextExtension: Extension = {
         properties: { keepLastN: { type: 'number' } }
       },
       execute: async (args, context) => executeContextSummarize(args as { keepLastN?: number }, { ctx: { sessionId: context.session.id, agentId: context.session.agentId ?? null }, resolveCurrentSession: () => context.session as unknown as Session })
+    },
+    {
+      name: 'pin_context',
+      description: 'Pin a fact, failed approach, blocker, or discovery to working memory so it survives context compaction and flows to subagents.',
+      parameters: {
+        type: 'object',
+        properties: {
+          type: { type: 'string', enum: ['fact', 'failed_approach', 'blocker', 'discovery'], description: 'What kind of context to pin.' },
+          content: { type: 'string', description: 'The content to pin (max 300 chars).' },
+        },
+        required: ['type', 'content'],
+      },
+      execute: async (args, context) => executePinContext(args as { type?: string; content?: string }, { ctx: { sessionId: context.session.id, agentId: context.session.agentId ?? null }, resolveCurrentSession: () => context.session as unknown as Session })
     }
   ]
 }
@@ -107,6 +145,17 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
     tool(
       async (args) => executeContextSummarize(args as { keepLastN?: number }, bctx),
       { name: 'context_summarize', description: ContextExtension.tools![1].description, schema: z.object({}).passthrough() }
-    )
+    ),
+    tool(
+      async (args) => executePinContext(args as { type?: string; content?: string }, bctx),
+      {
+        name: 'pin_context',
+        description: ContextExtension.tools![2].description,
+        schema: z.object({
+          type: z.enum(['fact', 'failed_approach', 'blocker', 'discovery']).describe('What kind of context to pin.'),
+          content: z.string().describe('The content to pin (max 300 chars).'),
+        }),
+      }
+    ),
   ]
 }

package/src/lib/server/session-tools/crud.ts

@@ -15,6 +15,7 @@ import {
   encryptKey,
   decryptKey,
 } from '../storage'
+import { getMessages } from '@/lib/server/messages/message-repository'
 import { resolveScheduleName } from '@/lib/schedules/schedule-name'
 import type { ScheduleLike } from '@/lib/schedules/schedule-dedupe'
 import {
@@ -38,6 +39,12 @@ import {
   prepareTaskCreation,
 } from '@/lib/server/tasks/task-service'
 import { ensureMissionForTask, enrichTaskWithMissionSummary } from '@/lib/server/missions/mission-service'
+import { classifyMessage } from '@/lib/server/chat-execution/message-classifier'
+import {
+  buildDelegationTaskProfile,
+  formatDelegationRationale,
+  resolveDelegationAdvisory,
+} from '@/lib/server/agents/delegation-advisory'
 import type { ToolBuildContext } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import type { BoardTask } from '@/types'
@@ -76,6 +83,99 @@ function findDuplicateManagedAgent(
   return null
 }
 
+function normalizeStringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const entry of value) {
+    const trimmed = typeof entry === 'string' ? entry.trim() : ''
+    const key = trimmed.toLowerCase()
+    if (!trimmed || seen.has(key)) continue
+    seen.add(key)
+    out.push(trimmed)
+  }
+  return out
+}
+
+function buildTaskDelegationText(parsed: Record<string, unknown>): string {
+  const title = typeof parsed.title === 'string' ? parsed.title.trim() : ''
+  const description = typeof parsed.description === 'string' ? parsed.description.trim() : ''
+  return [title, description].filter(Boolean).join('\n\n').trim()
+}
+
+async function resolveManagedTaskDelegation(params: {
+  parsed: Record<string, unknown>
+  agents: ReturnType<typeof loadAgents>
+  ctx?: ToolBuildContext['ctx']
+  assignedAgentId: string | null
+  explicitAssignment: boolean
+  allowAutoAssignment: boolean
+}): Promise<{
+  assignedAgentId: string | null
+  advisory: Record<string, unknown> | null
+}> {
+  const currentAgentId = typeof params.ctx?.agentId === 'string' ? params.ctx.agentId.trim() : ''
+  if (!currentAgentId || params.ctx?.delegationEnabled !== true) {
+    return { assignedAgentId: params.assignedAgentId, advisory: null }
+  }
+  const currentAgent = params.agents[currentAgentId]
+  if (!currentAgent) {
+    return { assignedAgentId: params.assignedAgentId, advisory: null }
+  }
+
+  const explicitCapabilities = normalizeStringList(params.parsed.requiredCapabilities)
+  const classificationText = buildTaskDelegationText(params.parsed)
+  const classification = (!explicitCapabilities.length && classificationText && params.ctx?.sessionId)
+    ? await classifyMessage({
+        sessionId: params.ctx.sessionId,
+        agentId: currentAgentId,
+        message: classificationText,
+      }).catch(() => null)
+    : null
+
+  const profile = buildDelegationTaskProfile({
+    classification,
+    requiredCapabilities: explicitCapabilities,
+  })
+  if (!profile.substantial) {
+    return { assignedAgentId: params.assignedAgentId, advisory: null }
+  }
+
+  const delegationAdvisory = resolveDelegationAdvisory({
+    currentAgent,
+    agents: params.agents,
+    profile,
+    delegationTargetMode: params.ctx?.delegationTargetMode === 'selected' ? 'selected' : 'all',
+    delegationTargetAgentIds: params.ctx?.delegationTargetAgentIds || [],
+  })
+  const recommended = delegationAdvisory.recommended
+  if (!delegationAdvisory.shouldDelegate || !recommended) {
+    return { assignedAgentId: params.assignedAgentId, advisory: null }
+  }
+  if (params.explicitAssignment && params.assignedAgentId === recommended.agentId) {
+    return { assignedAgentId: params.assignedAgentId, advisory: null }
+  }
+
+  let assignedAgentId = params.assignedAgentId
+  let autoAssigned = false
+  if (!params.explicitAssignment && params.allowAutoAssignment) {
+    assignedAgentId = recommended.agentId
+    autoAssigned = true
+  }
+
+  return {
+    assignedAgentId,
+    advisory: {
+      recommendedAgentId: recommended.agentId,
+      recommendedAgentName: recommended.agentName,
+      rationale: formatDelegationRationale(recommended),
+      workType: profile.workType,
+      requiredCapabilities: profile.requiredCapabilities,
+      autoAssigned,
+    },
+  }
+}
+
 const VALID_CONNECTOR_PLATFORMS = new Set([
   'discord',
   'telegram',
@@ -208,7 +308,7 @@ function deriveScheduleFollowupTarget(sessionId: string | null | undefined): {
 
   if (isMainSession(session)) return {}
 
-  const messages = Array.isArray(session.messages) ? session.messages : []
+  const messages = getMessages(normalizedSessionId)
   for (let i = messages.length - 1; i >= 0; i -= 1) {
     const message = messages[i]
     if ((typeof message?.role === 'string' ? message.role : '') !== 'user') continue
@@ -365,6 +465,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
         description += `\n\nYou may create tasks for yourself, leave them unassigned, or delegate them to other agents. Your agent ID is "${ctx?.agentId || 'unknown'}". When delegating, set a target agent using "agentId", "assignee", "agent", "assignedAgentId", or "assigned_agent_id". Use the target agent's exact ID when possible. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
       }
       description += '\n\nCreate/update calls accept either `data` as a JSON string or direct top-level fields like `title`, `description`, `status`, `agentId`, and `projectId`.'
+      if (canAssignOtherAgents) {
+        description += '\n\nWhen you omit an assignee, the runtime may auto-assign the task to a materially better-fit teammate based on `requiredCapabilities` or the classified work type. If you set an explicit assignee, it is respected in v1, but the response may include `delegationAdvisory` when another teammate is a better fit.'
+      }
       description += '\n\nFor follow-up work, set `continueFromTaskId` (or `followUpToTaskId`) to a prior task ID. The new task will inherit the predecessor\'s project/agent/session context, block on that task by default, and reuse its execution session when possible.'
       if (ctx?.projectId) {
         description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to use this active project by default.`
@@ -492,6 +595,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if ((toolKey === 'manage_tasks' || toolKey === 'manage_schedules' || toolKey === 'manage_secrets') && !Object.prototype.hasOwnProperty.call(parsed, 'projectId') && ctx?.projectId) {
                 parsed.projectId = ctx.projectId
               }
+              let taskDelegationAdvisory: Record<string, unknown> | null = null
               if (toolKey === 'manage_tasks' || toolKey === 'manage_schedules') {
                 const agents = loadAgents()
                 const resolution = resolveManagedAgentAssignment(
@@ -502,12 +606,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     : null,
                   { allowDescription: toolKey === 'manage_tasks' },
                 )
-                  const assignmentError = validateManagedAgentAssignment({
-                    resourceLabel: res.label,
-                    agents,
-                    assignScope: canAssignOtherAgents ? 'all' : 'self',
-                    currentAgentId: ctx?.agentId || null,
-                    targetAgentId: resolution.agentId,
+                const assignmentError = validateManagedAgentAssignment({
+                  resourceLabel: res.label,
+                  agents,
+                  assignScope: canAssignOtherAgents ? 'all' : 'self',
+                  currentAgentId: ctx?.agentId || null,
+                  targetAgentId: resolution.agentId,
                   unresolvedReference: resolution.unresolvedReference,
                   isDelegation: toolKey === 'manage_tasks' ? isDelegationTaskPayload(parsed as Record<string, unknown>) : false,
                   delegatorAgentId: toolKey === 'manage_tasks'
@@ -516,6 +620,18 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 })
                 if (assignmentError) return assignmentError
                 parsed.agentId = resolution.agentId
+                if (toolKey === 'manage_tasks') {
+                  const delegated = await resolveManagedTaskDelegation({
+                    parsed: parsed as Record<string, unknown>,
+                    agents,
+                    ctx,
+                    assignedAgentId: resolution.agentId,
+                    explicitAssignment: resolution.source === 'explicit',
+                    allowAutoAssignment: true,
+                  })
+                  parsed.agentId = delegated.assignedAgentId
+                  taskDelegationAdvisory = delegated.advisory
+                }
               }
               let preparedManagedTask: BoardTask | null = null
               let preparedManagedSchedule: any = null
@@ -639,6 +755,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     missionId: mission.id,
                   })
                 }
+                if (taskDelegationAdvisory && responseEntry && typeof responseEntry === 'object') {
+                  responseEntry = {
+                    ...(responseEntry as Record<string, unknown>),
+                    delegationAdvisory: taskDelegationAdvisory,
+                  }
+                }
               }
               if (toolKey === 'manage_tasks' && entry.status === 'queued') {
                 const { enqueueTask } = await import('@/lib/server/runtime/queue')
@@ -675,6 +797,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 if (continuationError) return continuationError
               }
               const prevStatus = all[effectiveId]?.status
+              let taskDelegationAdvisory: Record<string, unknown> | null = null
               const managedAgents = toolKey === 'manage_tasks' || toolKey === 'manage_schedules'
                 ? loadAgents()
                 : null
@@ -682,6 +805,10 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 const requestedClear = Object.prototype.hasOwnProperty.call(parsedRecord, 'agentId') && parsedRecord.agentId == null
                 const shouldResolveAssignment = requestedClear
                   || hasManagedAgentAssignmentInput(parsedRecord)
+                let resolvedAgentId: string | null = requestedClear
+                  ? null
+                  : (typeof all[effectiveId]?.agentId === 'string' ? all[effectiveId].agentId : null)
+                let explicitAssignment = false
                 if (shouldResolveAssignment) {
                   const resolution = resolveManagedAgentAssignment(
                     parsedRecord,
@@ -689,18 +816,20 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     null,
                     { allowDescription: false },
                   )
+                  resolvedAgentId = requestedClear ? null : resolution.agentId
+                  explicitAssignment = resolution.hadExplicitInput
                   const assignmentError = validateManagedAgentAssignment({
                     resourceLabel: res.label,
                     agents: managedAgents,
                     assignScope: canAssignOtherAgents ? 'all' : 'self',
                     currentAgentId: ctx?.agentId || null,
-                    targetAgentId: requestedClear ? null : resolution.agentId,
+                    targetAgentId: resolvedAgentId,
                     unresolvedReference: requestedClear ? null : resolution.unresolvedReference,
                     isDelegation: toolKey === 'manage_tasks'
                       ? isDelegationTaskPayload({
                           ...all[effectiveId],
                           ...parsedRecord,
-                          agentId: requestedClear ? null : resolution.agentId,
+                          agentId: resolvedAgentId,
                         } as Record<string, unknown>)
                       : false,
                     delegatorAgentId: toolKey === 'manage_tasks'
@@ -711,7 +840,24 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                       : null,
                   })
                   if (assignmentError) return assignmentError
-                  if (!requestedClear) parsedRecord.agentId = resolution.agentId
+                  if (!requestedClear) parsedRecord.agentId = resolvedAgentId
+                }
+                if (toolKey === 'manage_tasks') {
+                  const delegated = await resolveManagedTaskDelegation({
+                    parsed: {
+                      ...all[effectiveId],
+                      ...parsedRecord,
+                    },
+                    agents: managedAgents,
+                    ctx,
+                    assignedAgentId: resolvedAgentId,
+                    explicitAssignment,
+                    allowAutoAssignment: !resolvedAgentId || resolvedAgentId === ctx?.agentId,
+                  })
+                  if (delegated.assignedAgentId !== resolvedAgentId) {
+                    parsedRecord.agentId = delegated.assignedAgentId
+                  }
+                  taskDelegationAdvisory = delegated.advisory
                 }
               }
               if (toolKey === 'manage_schedules') {
@@ -797,6 +943,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (toolKey === 'manage_projects') {
                 return JSON.stringify(buildProjectSnapshot(all[effectiveId]))
               }
+              if (toolKey === 'manage_tasks' && taskDelegationAdvisory) {
+                return JSON.stringify({
+                  ...(all[effectiveId] as Record<string, unknown>),
+                  delegationAdvisory: taskDelegationAdvisory,
+                })
+              }
               if (toolKey === 'manage_schedules' && affectedScheduleIds?.length) {
                 return JSON.stringify({
                   ...all[effectiveId],

package/src/lib/server/session-tools/delegate.ts

@@ -21,7 +21,7 @@ import {
   registerDelegationRuntime,
   startDelegationJob,
 } from '@/lib/server/agents/delegation-jobs'
-import { loadSession } from '@/lib/server/storage'
+import { loadSession } from '@/lib/server/sessions/session-repository'
 import { markProviderFailure, markProviderSuccess } from '../provider-health'
 import { loadRuntimeSettings } from '../runtime/runtime-settings'
 import { getSessionDepth } from '../agents/subagent-runtime'