@swarmclawai/swarmclaw 0.7.6 → 0.7.8

package/src/lib/server/agent-runtime-config.ts

@@ -26,6 +26,11 @@ export interface ResolvedAgentRoute {
   source: 'agent' | 'routing-target'
 }
 
+interface GatewayRoutePreferences {
+  preferredGatewayTags?: string[]
+  preferredGatewayUseCase?: string | null
+}
+
 interface RouteSeed {
   id: string
   label?: string
@@ -35,6 +40,8 @@ interface RouteSeed {
   fallbackCredentialIds?: string[]
   apiEndpoint?: string | null
   gatewayProfileId?: string | null
+  preferredGatewayTags?: string[]
+  preferredGatewayUseCase?: string | null
   role?: AgentRoutingTarget['role']
   priority?: number
   source: ResolvedAgentRoute['source']
@@ -47,6 +54,68 @@ function ensureStringArray(value: unknown): string[] {
     .filter(Boolean)
 }
 
+function normalizeText(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function normalizeNullableNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function normalizeGatewayDeployment(
+  value: unknown,
+): GatewayProfile['deployment'] {
+  if (!value || typeof value !== 'object') return null
+  const deployment = value as Record<string, unknown>
+  type DeploymentConfig = NonNullable<GatewayProfile['deployment']>
+  return {
+    method: normalizeText(deployment.method) as DeploymentConfig['method'],
+    provider: normalizeText(deployment.provider) as DeploymentConfig['provider'],
+    remoteTarget: normalizeText(deployment.remoteTarget) as DeploymentConfig['remoteTarget'],
+    useCase: normalizeText(deployment.useCase) as DeploymentConfig['useCase'],
+    exposure: normalizeText(deployment.exposure) as DeploymentConfig['exposure'],
+    managedBy: normalizeText(deployment.managedBy) as DeploymentConfig['managedBy'],
+    targetHost: normalizeText(deployment.targetHost),
+    sshHost: normalizeText(deployment.sshHost),
+    sshUser: normalizeText(deployment.sshUser),
+    sshPort: normalizeNullableNumber(deployment.sshPort),
+    sshKeyPath: normalizeText(deployment.sshKeyPath),
+    sshTargetDir: normalizeText(deployment.sshTargetDir),
+    image: normalizeText(deployment.image),
+    version: normalizeText(deployment.version),
+    lastDeployAt: normalizeNullableNumber(deployment.lastDeployAt),
+    lastDeployAction: normalizeText(deployment.lastDeployAction),
+    lastDeployProcessId: normalizeText(deployment.lastDeployProcessId),
+    lastDeploySummary: normalizeText(deployment.lastDeploySummary),
+    lastVerifiedAt: normalizeNullableNumber(deployment.lastVerifiedAt),
+    lastVerifiedOk: typeof deployment.lastVerifiedOk === 'boolean' ? deployment.lastVerifiedOk : null,
+    lastVerifiedMessage: normalizeText(deployment.lastVerifiedMessage),
+    lastBackupPath: normalizeText(deployment.lastBackupPath),
+  }
+}
+
+function normalizeGatewayStats(value: unknown): GatewayProfile['stats'] {
+  if (!value || typeof value !== 'object') return null
+  const stats = value as Record<string, unknown>
+  return {
+    nodeCount: normalizeNullableNumber(stats.nodeCount) ?? undefined,
+    connectedNodeCount: normalizeNullableNumber(stats.connectedNodeCount) ?? undefined,
+    pendingNodePairings: normalizeNullableNumber(stats.pendingNodePairings) ?? undefined,
+    pairedDeviceCount: normalizeNullableNumber(stats.pairedDeviceCount) ?? undefined,
+    pendingDevicePairings: normalizeNullableNumber(stats.pendingDevicePairings) ?? undefined,
+    externalRuntimeCount: normalizeNullableNumber(stats.externalRuntimeCount) ?? undefined,
+  }
+}
+
+function normalizeRoutePreferences(
+  value?: GatewayRoutePreferences | null,
+): GatewayRoutePreferences {
+  return {
+    preferredGatewayTags: ensureStringArray(value?.preferredGatewayTags),
+    preferredGatewayUseCase: normalizeText(value?.preferredGatewayUseCase),
+  }
+}
+
 function normalizeGateway(raw: unknown, id: string): GatewayProfile | null {
   if (!raw || typeof raw !== 'object') return null
   const gateway = raw as Partial<GatewayProfile> & Record<string, unknown>
@@ -72,6 +141,8 @@ function normalizeGateway(raw: unknown, id: string): GatewayProfile | null {
     lastModelCount: typeof gateway.lastModelCount === 'number' ? gateway.lastModelCount : null,
     discoveredHost: typeof gateway.discoveredHost === 'string' ? gateway.discoveredHost : null,
     discoveredPort: typeof gateway.discoveredPort === 'number' ? gateway.discoveredPort : null,
+    deployment: normalizeGatewayDeployment(gateway.deployment),
+    stats: normalizeGatewayStats(gateway.stats),
     isDefault: gateway.isDefault === true,
     createdAt: typeof gateway.createdAt === 'number' ? gateway.createdAt : Date.now(),
     updatedAt: typeof gateway.updatedAt === 'number' ? gateway.updatedAt : Date.now(),
@@ -107,6 +178,50 @@ function defaultGatewayProfile(gatewayProfiles: GatewayProfile[]): GatewayProfil
   return gatewayProfiles.find((profile) => profile.isDefault) || gatewayProfiles[0] || null
 }
 
+function gatewayPreferenceScore(
+  gatewayProfile: GatewayProfile,
+  preferences?: GatewayRoutePreferences | null,
+): number {
+  const normalized = normalizeRoutePreferences(preferences)
+  const preferredTags = normalized.preferredGatewayTags || []
+  const preferredUseCase = normalized.preferredGatewayUseCase || null
+  const gatewayTags = new Set(ensureStringArray(gatewayProfile.tags))
+  const gatewayUseCase = normalizeText(gatewayProfile.deployment?.useCase)
+
+  let score = 0
+  if (preferredUseCase) {
+    if (gatewayUseCase !== preferredUseCase) return -1
+    score += 30
+  }
+  if (preferredTags.length > 0) {
+    const matchedTagCount = preferredTags.filter((tag) => gatewayTags.has(tag)).length
+    if (matchedTagCount === 0) return -1
+    score += matchedTagCount * 10
+    if (matchedTagCount === preferredTags.length) score += 8
+  }
+  if (gatewayProfile.status === 'healthy') score += 4
+  else if (gatewayProfile.status === 'degraded') score += 2
+  if (gatewayProfile.isDefault) score += 3
+  return score
+}
+
+function pickPreferredGatewayProfile(
+  gatewayProfiles: GatewayProfile[],
+  preferences?: GatewayRoutePreferences | null,
+): GatewayProfile | null {
+  const normalized = normalizeRoutePreferences(preferences)
+  if (!(normalized.preferredGatewayTags?.length || normalized.preferredGatewayUseCase)) {
+    return null
+  }
+  return gatewayProfiles
+    .map((profile) => ({ profile, score: gatewayPreferenceScore(profile, normalized) }))
+    .filter((entry) => entry.score >= 0)
+    .sort((left, right) => {
+      if (left.score !== right.score) return right.score - left.score
+      return left.profile.name.localeCompare(right.profile.name)
+    })[0]?.profile || null
+}
+
 function roleWeight(strategy: AgentRoutingStrategy, role?: AgentRoutingTarget['role']): number {
   const normalized = role || 'primary'
   const matrix: Record<AgentRoutingStrategy, Record<string, number>> = {
@@ -135,14 +250,21 @@ function dedupeCredentialIds(primary: string | null | undefined, candidates: str
 function buildRouteFromSeed(
   seed: RouteSeed,
   gatewayProfiles: GatewayProfile[],
+  routePreferences?: GatewayRoutePreferences | null,
   agentGatewayProfileId?: string | null,
 ): ResolvedAgentRoute | null {
   const provider = (seed.provider || 'claude-cli') as ProviderType
-  let gatewayProfileId = seed.gatewayProfileId ?? null
-  if (!gatewayProfileId && provider === 'openclaw') {
-    gatewayProfileId = agentGatewayProfileId ?? defaultGatewayProfile(gatewayProfiles)?.id ?? null
+  const mergedPreferences = normalizeRoutePreferences({
+    preferredGatewayTags: seed.preferredGatewayTags ?? routePreferences?.preferredGatewayTags,
+    preferredGatewayUseCase: seed.preferredGatewayUseCase ?? routePreferences?.preferredGatewayUseCase,
+  })
+  let gatewayProfile = findGatewayProfile(gatewayProfiles, seed.gatewayProfileId ?? null)
+  if (!gatewayProfile && provider === 'openclaw') {
+    gatewayProfile = pickPreferredGatewayProfile(gatewayProfiles, mergedPreferences)
+      || findGatewayProfile(gatewayProfiles, agentGatewayProfileId ?? null)
+      || defaultGatewayProfile(gatewayProfiles)
   }
-  const gatewayProfile = findGatewayProfile(gatewayProfiles, gatewayProfileId)
+  const gatewayProfileId = gatewayProfile?.id ?? seed.gatewayProfileId ?? agentGatewayProfileId ?? null
 
   const providerFromGateway = gatewayProfile?.provider === 'openclaw' ? 'openclaw' : provider
   const apiEndpoint = normalizeProviderEndpoint(
@@ -189,8 +311,9 @@ function dedupeRoutes(routes: ResolvedAgentRoute[]): ResolvedAgentRoute[] {
 export function resolveAgentRouteCandidates(
   agent: Agent | null | undefined,
   preferredStrategy?: AgentRoutingStrategy | null,
+  routePreferences?: GatewayRoutePreferences | null,
 ): ResolvedAgentRoute[] {
-  return resolveAgentRouteCandidatesWithProfiles(agent, getGatewayProfiles('openclaw'), preferredStrategy)
+  return resolveAgentRouteCandidatesWithProfiles(agent, getGatewayProfiles('openclaw'), preferredStrategy, undefined, routePreferences)
 }
 
 export function resolveAgentRouteCandidatesWithProfiles(
@@ -198,9 +321,16 @@ export function resolveAgentRouteCandidatesWithProfiles(
   gatewayProfiles: GatewayProfile[],
   preferredStrategy?: AgentRoutingStrategy | null,
   isCoolingDown: (providerId: string) => boolean = isProviderCoolingDown,
+  routePreferences?: GatewayRoutePreferences | null,
 ): ResolvedAgentRoute[] {
   if (!agent) return []
   const strategy = preferredStrategy || agent.routingStrategy || 'single'
+  const resolvedPreferences = normalizeRoutePreferences({
+    preferredGatewayTags: routePreferences?.preferredGatewayTags?.length
+      ? routePreferences.preferredGatewayTags
+      : agent.preferredGatewayTags,
+    preferredGatewayUseCase: routePreferences?.preferredGatewayUseCase || agent.preferredGatewayUseCase,
+  })
   const seeds: RouteSeed[] = [
     {
       id: 'base',
@@ -211,6 +341,8 @@ export function resolveAgentRouteCandidatesWithProfiles(
       fallbackCredentialIds: agent.fallbackCredentialIds || [],
       apiEndpoint: agent.apiEndpoint ?? null,
       gatewayProfileId: agent.gatewayProfileId ?? null,
+      preferredGatewayTags: agent.preferredGatewayTags || [],
+      preferredGatewayUseCase: agent.preferredGatewayUseCase ?? null,
       role: 'primary',
       priority: 0,
       source: 'agent',
@@ -224,6 +356,8 @@ export function resolveAgentRouteCandidatesWithProfiles(
       fallbackCredentialIds: target.fallbackCredentialIds || [],
       apiEndpoint: target.apiEndpoint ?? null,
       gatewayProfileId: target.gatewayProfileId ?? null,
+      preferredGatewayTags: target.preferredGatewayTags || [],
+      preferredGatewayUseCase: target.preferredGatewayUseCase ?? null,
       role: target.role,
       priority: typeof target.priority === 'number' ? target.priority : index + 1,
       source: 'routing-target' as const,
@@ -232,7 +366,7 @@ export function resolveAgentRouteCandidatesWithProfiles(
 
   return dedupeRoutes(
     seeds
-      .map((seed) => buildRouteFromSeed(seed, gatewayProfiles, agent.gatewayProfileId ?? null))
+      .map((seed) => buildRouteFromSeed(seed, gatewayProfiles, resolvedPreferences, agent.gatewayProfileId ?? null))
       .filter((route): route is ResolvedAgentRoute => Boolean(route)),
   ).sort((left, right) => {
     const leftCooling = isCoolingDown(left.provider)
@@ -249,8 +383,9 @@ export function resolveAgentRouteCandidatesWithProfiles(
 export function resolvePrimaryAgentRoute(
   agent: Agent | null | undefined,
   preferredStrategy?: AgentRoutingStrategy | null,
+  routePreferences?: GatewayRoutePreferences | null,
 ): ResolvedAgentRoute | null {
-  return resolveAgentRouteCandidates(agent, preferredStrategy)[0] || null
+  return resolveAgentRouteCandidates(agent, preferredStrategy, routePreferences)[0] || null
 }
 
 export function applyResolvedRoute<T extends {

package/src/lib/server/agent-thread-session.ts

@@ -26,6 +26,8 @@ function buildThreadSession(agent: Agent, sessionId: string, user: string, creat
     fallbackCredentialIds: agent.fallbackCredentialIds || [],
     apiEndpoint: agent.apiEndpoint || null,
     gatewayProfileId: agent.gatewayProfileId || null,
+    routePreferredGatewayTags: existing?.routePreferredGatewayTags || [],
+    routePreferredGatewayUseCase: existing?.routePreferredGatewayUseCase || null,
     claudeSessionId: existing?.claudeSessionId || null,
     codexThreadId: existing?.codexThreadId || null,
     opencodeSessionId: existing?.opencodeSessionId || null,
@@ -77,7 +79,13 @@ function buildThreadSession(agent: Agent, sessionId: string, user: string, creat
     avatar: existing?.avatar,
     canvasContent: existing?.canvasContent || null,
   }
-  return applyResolvedRoute(baseSession, resolvePrimaryAgentRoute(agent))
+  return applyResolvedRoute(
+    baseSession,
+    resolvePrimaryAgentRoute(agent, undefined, {
+      preferredGatewayTags: baseSession.routePreferredGatewayTags || [],
+      preferredGatewayUseCase: baseSession.routePreferredGatewayUseCase || null,
+    }),
+  )
 }
 
 export function ensureAgentThreadSession(agentId: string, user = 'default'): Session | null {

package/src/lib/server/capability-router.test.ts

@@ -19,3 +19,25 @@ test('routeTaskIntent keeps coding prompts prioritized over memory keywords', ()
   )
   assert.equal(decision.intent, 'coding')
 })
+
+test('routeTaskIntent keeps hybrid research-plus-media prompts in research intent', () => {
+  const decision = routeTaskIntent(
+    'Can you tell me more if there is any news related to the US-Iran war, and can you send me some screenshots and give me a summary and maybe send me a voice note about it?',
+    ['web_search', 'web_fetch', 'browser', 'manage_connectors'],
+    null,
+  )
+
+  assert.equal(decision.intent, 'research')
+  assert.deepEqual(decision.preferredTools, ['web_search', 'web_fetch', 'browser', 'connector_message_tool'])
+})
+
+test('routeTaskIntent treats direct voice-note delivery as outreach', () => {
+  const decision = routeTaskIntent(
+    'Send me a voice note over WhatsApp summarizing what changed.',
+    ['manage_connectors'],
+    null,
+  )
+
+  assert.equal(decision.intent, 'outreach')
+  assert.deepEqual(decision.preferredTools, ['connector_message_tool'])
+})

package/src/lib/server/capability-router.ts

@@ -1,4 +1,5 @@
 import type { AppSettings } from '@/types'
+import { getToolsForCapability, matchToolCapabilitiesForMessage, TOOL_CAPABILITY } from './tool-planning'
 
 export type TaskIntent =
   | 'coding'
@@ -27,6 +28,15 @@ function containsAny(text: string, terms: string[]): boolean {
   return terms.some((term) => text.includes(term))
 }
 
+function dedupe(values: string[]): string[] {
+  return Array.from(new Set(values.filter(Boolean)))
+}
+
+function preferredToolsForCapabilities(enabledPlugins: string[], capabilities: string[], fallback: string[] = []): string[] {
+  const preferred = capabilities.flatMap((capability) => getToolsForCapability(enabledPlugins, capability))
+  return dedupe(preferred.length > 0 ? preferred : fallback)
+}
+
 function normalizeDelegateOrder(value: unknown): DelegateTool[] {
   const fallback: DelegateTool[] = [
     'delegate_to_claude_code',
@@ -59,6 +69,14 @@ export function routeTaskIntent(
   const text = (message || '').toLowerCase()
   const url = findFirstUrl(message || '')
   const delegateOrder = normalizeDelegateOrder(settings?.autonomyPreferredDelegates)
+  const matchedCapabilities = matchToolCapabilitiesForMessage(enabledPlugins, message)
+  const wantsVoiceNote = matchedCapabilities.has(TOOL_CAPABILITY.deliveryVoiceNote)
+  const wantsScreenshots = matchedCapabilities.has(TOOL_CAPABILITY.browserCapture)
+  const wantsMediaDelivery = matchedCapabilities.has(TOOL_CAPABILITY.deliveryMedia)
+  const wantsChannelDelivery = matchedCapabilities.has(TOOL_CAPABILITY.deliveryMessage)
+  const researchLike = matchedCapabilities.has(TOOL_CAPABILITY.researchSearch)
+    || matchedCapabilities.has(TOOL_CAPABILITY.researchFetch)
+    || !!url
 
   const coding = containsAny(text, [
     'build',
@@ -98,12 +116,20 @@ export function routeTaskIntent(
     'discord',
     'notify',
     'broadcast',
-  ])
+  ]) || (!researchLike && (wantsVoiceNote || wantsMediaDelivery || wantsChannelDelivery))
   if (outreach) {
     return {
       intent: 'outreach',
       confidence: 0.8,
-      preferredTools: ['connector_message_tool', 'manage_connectors', 'manage_sessions'],
+      preferredTools: preferredToolsForCapabilities(
+        enabledPlugins,
+        [
+          TOOL_CAPABILITY.deliveryVoiceNote,
+          TOOL_CAPABILITY.deliveryMedia,
+          TOOL_CAPABILITY.deliveryMessage,
+        ],
+        ['connector_message_tool', 'manage_connectors', 'manage_sessions'],
+      ),
       preferredDelegates: delegateOrder,
       primaryUrl: url,
     }
@@ -129,36 +155,46 @@ export function routeTaskIntent(
   }
 
   const browsing = !!url && (
-    containsAny(text, ['browser', 'click', 'fill form', 'log in', 'screenshot', 'navigate'])
-    || enabledPlugins.includes('browser')
+    matchedCapabilities.has(TOOL_CAPABILITY.browserNavigate)
+    || matchedCapabilities.has(TOOL_CAPABILITY.browserCapture)
+    || getToolsForCapability(enabledPlugins, TOOL_CAPABILITY.browserNavigate).length > 0
+    || getToolsForCapability(enabledPlugins, TOOL_CAPABILITY.browserCapture).length > 0
   )
   if (browsing) {
     return {
       intent: 'browsing',
       confidence: 0.7,
-      preferredTools: ['browser', 'web_fetch'],
+      preferredTools: preferredToolsForCapabilities(
+        enabledPlugins,
+        [
+          TOOL_CAPABILITY.browserCapture,
+          TOOL_CAPABILITY.browserNavigate,
+          TOOL_CAPABILITY.researchFetch,
+        ],
+        ['browser', 'web_fetch'],
+      ),
       preferredDelegates: delegateOrder,
       primaryUrl: url,
     }
   }
 
-  const research = containsAny(text, [
-    'research',
-    'look up',
-    'find out',
-    'search for',
-    'compare',
-    'latest',
-    'news',
-    'wikipedia',
-    'summarize this url',
-    'analyze website',
-  ]) || !!url
+  const research = researchLike
   if (research) {
+    const preferred = preferredToolsForCapabilities(
+      enabledPlugins,
+      [
+        TOOL_CAPABILITY.researchSearch,
+        TOOL_CAPABILITY.researchFetch,
+        ...(wantsScreenshots ? [TOOL_CAPABILITY.browserCapture] : []),
+        ...(wantsVoiceNote ? [TOOL_CAPABILITY.deliveryVoiceNote] : []),
+        ...(wantsMediaDelivery || wantsChannelDelivery ? [TOOL_CAPABILITY.deliveryMedia, TOOL_CAPABILITY.deliveryMessage] : []),
+      ],
+      ['web_search', 'web_fetch', 'browser'],
+    )
     return {
       intent: 'research',
       confidence: 0.7,
-      preferredTools: ['web_search', 'web_fetch', 'browser'],
+      preferredTools: preferred,
       preferredDelegates: delegateOrder,
       primaryUrl: url,
     }

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

@@ -18,7 +18,7 @@ import { getProvider } from '@/lib/providers'
 import { estimateCost, checkAgentBudgetLimits } from './cost'
 import { log } from './logger'
 import { logExecution } from './execution-log'
-import { streamAgentChat } from './stream-agent-chat'
+import { buildToolDisciplineLines, streamAgentChat } from './stream-agent-chat'
 import { runLinkUnderstanding } from './link-understanding'
 import { buildSessionTools } from './session-tools'
 import type { StructuredToolInterface } from '@langchain/core/tools'
@@ -46,6 +46,7 @@ import { buildIdentityContinuityContext, refreshSessionIdentityState } from './i
 import { syncSessionArchiveMemory } from './session-archive-memory'
 import { evaluateSessionFreshness, resetSessionRuntime, resolveSessionResetPolicy } from './session-reset-policy'
 import { pruneStreamingAssistantArtifacts, upsertStreamingAssistantArtifact } from '@/lib/chat-streaming-state'
+import { resolveActiveProjectContext } from './project-context'
 type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
 
 /** Slice history from the most recent context-clear marker forward */
@@ -191,6 +192,8 @@ function extractDelegateResponse(outputText: string): string | null {
 const MANAGE_PLATFORM_RESOURCE_TO_TOOL: Record<string, string> = {
   agent: 'manage_agents',
   agents: 'manage_agents',
+  project: 'manage_projects',
+  projects: 'manage_projects',
   task: 'manage_tasks',
   tasks: 'manage_tasks',
   schedule: 'manage_schedules',
@@ -626,7 +629,10 @@ function syncSessionFromAgent(sessionId: string): void {
   if (!agent) return
 
   let changed = false
-  const route = resolvePrimaryAgentRoute(agent)
+  const route = resolvePrimaryAgentRoute(agent, undefined, {
+    preferredGatewayTags: session.routePreferredGatewayTags || [],
+    preferredGatewayUseCase: session.routePreferredGatewayUseCase || null,
+  })
   if (!session.provider && agent.provider) { session.provider = agent.provider; changed = true }
   if ((session.model === undefined || session.model === null || session.model === '') && agent.model !== undefined) {
     session.model = agent.model
@@ -668,6 +674,12 @@ function syncSessionFromAgent(sessionId: string): void {
   }
   const isShortcutChat = session.shortcutForAgentId === agent.id || agent.threadSessionId === sessionId
   if (isShortcutChat) {
+    const desiredPlugins = Array.isArray(agent.plugins) ? [...agent.plugins] : []
+    const currentPlugins = Array.isArray(session.plugins) ? [...session.plugins] : []
+    if (JSON.stringify(currentPlugins) !== JSON.stringify(desiredPlugins)) {
+      session.plugins = desiredPlugins
+      changed = true
+    }
     if (session.shortcutForAgentId !== agent.id) { session.shortcutForAgentId = agent.id; changed = true }
     if (session.name !== agent.name) { session.name = agent.name; changed = true }
   }
@@ -734,6 +746,14 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   ]
   parts.push(thinkingHint.join('\n'))
 
+  const enabledPlugins = Array.isArray(session.plugins) ? session.plugins : (Array.isArray(agent.plugins) ? agent.plugins : [])
+  const toolDisciplineLines = buildToolDisciplineLines(enabledPlugins)
+  if (toolDisciplineLines.length > 0) parts.push(['## Tool Discipline', ...toolDisciplineLines].join('\n'))
+  const operatingGuidance = getPluginManager().collectOperatingGuidance(enabledPlugins)
+  if (operatingGuidance.length > 0) parts.push(['## Tool Guidance', ...operatingGuidance].join('\n'))
+  const capabilityLines = getPluginManager().collectCapabilityDescriptions(enabledPlugins)
+  if (capabilityLines.length > 0) parts.push(['## Tool Capabilities', ...capabilityLines].join('\n'))
+
   // 7. Heartbeat Guidance
   parts.push([
     '## Heartbeats',
@@ -849,7 +869,10 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     ? session
     : { ...session, plugins: pluginsForRun }
   if (agentForSession) {
-    const preferredRoute = resolvePrimaryAgentRoute(agentForSession)
+    const preferredRoute = resolvePrimaryAgentRoute(agentForSession, undefined, {
+      preferredGatewayTags: session.routePreferredGatewayTags || [],
+      preferredGatewayUseCase: session.routePreferredGatewayUseCase || null,
+    })
     if (preferredRoute) {
       sessionForRun = applyResolvedRoute({ ...sessionForRun }, preferredRoute)
     }
@@ -1255,12 +1278,18 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       return false
     }
     const agent = session.agentId ? loadAgents()[session.agentId] : null
+    const activeProjectContext = resolveActiveProjectContext(session)
     const { tools, cleanup } = await buildSessionTools(session.cwd, sessionForRun.plugins || sessionForRun.tools || [], {
       agentId: session.agentId || null,
       sessionId,
       platformAssignScope: agent?.platformAssignScope || 'self',
       mcpServerIds: agent?.mcpServerIds,
       mcpDisabledTools: agent?.mcpDisabledTools,
+      projectId: activeProjectContext.projectId,
+      projectRoot: activeProjectContext.projectRoot,
+      projectName: activeProjectContext.project?.name || null,
+      projectDescription: activeProjectContext.project?.description || null,
+      memoryScopeMode: (((session as unknown as Record<string, unknown>).memoryScopeMode as string | null | undefined) ?? agent?.memoryScopeMode ?? null),
     })
     try {
       const directTool = tools.find((t) => t?.name === toolName) as StructuredToolInterface | undefined
@@ -1502,6 +1531,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         claudeCode: normalizeResumeId(sr.claudeCode ?? cr.claudeCode),
         codex: normalizeResumeId(sr.codex ?? cr.codex),
         opencode: normalizeResumeId(sr.opencode ?? cr.opencode),
+        gemini: normalizeResumeId(sr.gemini ?? cr.gemini),
       }
       if (JSON.stringify(currentResume) !== JSON.stringify(nextResume)) {
         current.delegateResumeIds = nextResume

package/src/lib/server/connectors/manager-reconnect.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  advanceConnectorReconnectState,
+  createConnectorReconnectState,
+} from './manager'
+
+test('advanceConnectorReconnectState applies exponential backoff and exhaustion', () => {
+  const policy = {
+    initialBackoffMs: 30_000,
+    maxBackoffMs: 15 * 60 * 1000,
+    maxAttempts: 3,
+  }
+
+  const initial = createConnectorReconnectState({}, policy)
+
+  const first = advanceConnectorReconnectState(initial, 'boom-1', 1_000, policy)
+  assert.equal(first.attempts, 1)
+  assert.equal(first.backoffMs, 30_000)
+  assert.equal(first.nextRetryAt, 31_000)
+  assert.equal(first.exhausted, false)
+
+  const second = advanceConnectorReconnectState(first, 'boom-2', 31_000, policy)
+  assert.equal(second.attempts, 2)
+  assert.equal(second.backoffMs, 60_000)
+  assert.equal(second.nextRetryAt, 91_000)
+  assert.equal(second.exhausted, false)
+
+  const third = advanceConnectorReconnectState(second, 'boom-3', 91_000, policy)
+  assert.equal(third.attempts, 3)
+  assert.equal(third.backoffMs, 120_000)
+  assert.equal(third.nextRetryAt, 211_000)
+  assert.equal(third.exhausted, true)
+})
+
+test('createConnectorReconnectState respects custom initial backoff', () => {
+  const state = createConnectorReconnectState(
+    { error: 'seeded' },
+    { initialBackoffMs: 45_000 },
+  )
+
+  assert.equal(state.attempts, 0)
+  assert.equal(state.backoffMs, 45_000)
+  assert.equal(state.nextRetryAt, 0)
+  assert.equal(state.error, 'seeded')
+  assert.equal(state.exhausted, false)
+})