@swarmclawai/swarmclaw 0.9.2 → 0.9.4

package/src/lib/server/connectors/manager.ts

@@ -30,6 +30,7 @@ import { markProviderFailure, markProviderSuccess } from '../provider-health'
 import { syncSessionArchiveMemory } from '@/lib/server/memory/session-archive-memory'
 import { buildIdentityContinuityContext } from '../identity-continuity'
 import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-session'
+import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import { getProvider } from '@/lib/providers'
 import type { Agent, Connector, MessageSource, Chatroom, ChatroomMessage, Session } from '@/types'
 import type { ConnectorInstance, InboundMessage } from './types'
@@ -57,6 +58,8 @@ import {
   textMentionsAlias,
 } from './policy'
 import { buildConnectorThreadContextBlock } from './thread-context'
+import { isDirectConnectorSession } from './session-kind'
+import { enforceSenderQuietBoundary } from './contact-boundaries'
 import { shouldSuppressHiddenControlText, stripHiddenControlTokens } from '@/lib/server/agents/assistant-control'
 import {
   buildInboundApprovalSubject as buildInboundApprovalSubjectHelper,
@@ -1198,7 +1201,7 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
     }
 
     const syntheticSession = ensureSyntheticSession(agent, chatroomId)
-    const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent)
+    const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent, syntheticSession.cwd)
     const chatroomContext = buildChatroomSystemPrompt(freshChatroom, agents, agent.id)
     const fullSystemPrompt = [agentSystemPrompt, chatroomContext, threadContextBlock].filter(Boolean).join('\n\n')
     const history = buildHistoryForAgent(freshChatroom, agent.id)
@@ -1418,6 +1421,26 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
     return NO_MESSAGE_SENTINEL
   }
 
+  const quietBoundary = enforceSenderQuietBoundary({
+    agent,
+    connector,
+    session,
+    msg,
+  })
+  if (quietBoundary.suppress) {
+    logExecution(session.id, 'decision', 'Connector inbound suppressed by sender quiet boundary', {
+      agentId: agent.id,
+      detail: {
+        platform: msg.platform,
+        channelId: msg.channelId,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        memoryTitle: quietBoundary.memoryTitle || null,
+      },
+    })
+    return NO_MESSAGE_SENTINEL
+  }
+
   if (parsedCommand) {
     const commandResult = await handleConnectorCommand({
       command: parsedCommand,
@@ -1520,13 +1543,21 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   promptParts.push(buildCurrentDateTimePromptContext())
   if (agent.soul) promptParts.push(agent.soul)
   if (agent.systemPrompt) promptParts.push(agent.systemPrompt)
-  if (agent.skillIds?.length) {
-    const allSkills = loadSkills()
-    for (const skillId of agent.skillIds) {
-      const skill = allSkills[skillId]
-      if (skill?.content) promptParts.push(`## Skill: ${skill.name}\n${skill.content}`)
-    }
-  }
+  try {
+    const enabledPlugins = dedup([
+      ...(Array.isArray(session.plugins) ? session.plugins : []),
+      ...(Array.isArray(agent.plugins) ? agent.plugins : []),
+      ...(Array.isArray(agent.tools) ? agent.tools : []),
+    ])
+    const runtimeSkills = resolveRuntimeSkills({
+      cwd: session.cwd,
+      enabledPlugins,
+      agentSkillIds: agent.skillIds || [],
+      storedSkills: loadSkills(),
+      selectedSkillId: session.skillRuntimeState?.selectedSkillId || null,
+    })
+    promptParts.push(...buildRuntimeSkillPromptBlocks(runtimeSkills))
+  } catch { /* non-critical */ }
   const thinkLevel = resolveConnectorSessionPolicy(connector, msg, session).thinkingLevel || ''
   if (thinkLevel) {
     promptParts.push(`Connector thinking guidance: ${thinkLevel}. Keep responses concise and useful for chat.`)
@@ -1534,7 +1565,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   const threadContextBlock = buildConnectorThreadContextBlock(msg, { isFirstThreadTurn: wasCreated })
   if (threadContextBlock) promptParts.push(threadContextBlock)
   // Add connector context
-  promptParts.push(`\nYou are receiving messages via ${msg.platform}. The user "${msg.senderName}" is messaging from channel "${msg.channelName || msg.channelId}". Respond naturally and conversationally.
+  promptParts.push(`\nYou are receiving messages via ${msg.platform}. The user "${msg.senderName}" (ID: ${msg.senderId}) is messaging from channel "${msg.channelName || msg.channelId}". Respond naturally and conversationally.
 
 ## Response Style
 Be action-first and autonomous: when the user gives an instruction, execute it instead of asking routine follow-up questions.
@@ -2343,7 +2374,7 @@ export async function sendConnectorMessage(params: {
   if (params.sessionId) {
     const sessions = loadSessions()
     const session = sessions[params.sessionId]
-    if (session) {
+    if (session && isDirectConnectorSession(session)) {
       session.connectorContext = {
         ...(session.connectorContext || {}),
         connectorId,

package/src/lib/server/connectors/session-consolidation.ts

@@ -4,6 +4,7 @@
  */
 import { loadSessions, loadSettings, saveSettings, upsertStoredItem } from '../storage'
 import type { Session } from '@/types'
+import { isDirectConnectorSession } from './session-kind'
 
 const MIGRATION_FLAG = '_migration_allKnownPeerIds'
 
@@ -17,6 +18,7 @@ export function backfillAllKnownPeerIds(): { migrated: number; skipped: boolean
   let migrated = 0
 
   for (const session of Object.values(sessions)) {
+    if (!isDirectConnectorSession(session)) continue
     const ctx = session?.connectorContext
     if (!ctx?.connectorId) continue
     if (Array.isArray(ctx.allKnownPeerIds) && ctx.allKnownPeerIds.length > 0) continue

package/src/lib/server/connectors/session-kind.ts

@@ -0,0 +1,7 @@
+export function isDirectConnectorSession(session?: unknown): boolean {
+  if (!session || typeof session !== 'object') return false
+  const record = session as Record<string, unknown>
+  const user = typeof record.user === 'string' ? record.user.trim() : ''
+  const name = typeof record.name === 'string' ? record.name.trim() : ''
+  return user === 'connector' || name.startsWith('connector:')
+}

package/src/lib/server/connectors/session.test.ts

@@ -193,6 +193,110 @@ describe('connectors/session', () => {
       assert.ok(found)
       assert.equal(found!.id, created.session.id)
     })
+
+    it('returns null when multiple direct sessions match without a unique thread or sender match', () => {
+      const now = Date.now()
+      storage.saveSessions({
+        'sess-a': {
+          id: 'sess-a',
+          name: 'connector:discord:alice',
+          user: 'connector',
+          provider: 'anthropic',
+          model: 'claude-3',
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          agentId: 'agent-1',
+          connectorContext: {
+            connectorId: 'conn-1',
+            channelId: 'shared-channel',
+            senderId: 'alice-1',
+          },
+        },
+        'sess-b': {
+          id: 'sess-b',
+          name: 'connector:discord:bob',
+          user: 'connector',
+          provider: 'anthropic',
+          model: 'claude-3',
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          agentId: 'agent-1',
+          connectorContext: {
+            connectorId: 'conn-1',
+            channelId: 'shared-channel',
+            senderId: 'bob-1',
+          },
+        },
+      })
+
+      const connector = {
+        id: 'conn-1',
+        name: 'Test',
+        platform: 'discord' as const,
+        agentId: 'agent-1',
+        config: {},
+        enabled: true,
+        createdAt: now,
+        updatedAt: now,
+      } as unknown as Connector
+
+      const result = mod.findDirectSessionForInbound(connector, {
+        platform: 'discord',
+        channelId: 'shared-channel',
+        senderId: 'unknown-user',
+        senderName: 'Unknown',
+        text: 'hello',
+      })
+
+      assert.equal(result, null)
+    })
+
+    it('returns null when the inbound thread id does not match an existing direct thread session', () => {
+      const now = Date.now()
+      storage.saveSessions({
+        'sess-thread': {
+          id: 'sess-thread',
+          name: 'connector:discord:thread',
+          user: 'connector',
+          provider: 'anthropic',
+          model: 'claude-3',
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          agentId: 'agent-1',
+          connectorContext: {
+            connectorId: 'conn-1',
+            channelId: 'channel-1',
+            senderId: 'user-1',
+            threadId: 'thread-1',
+          },
+        },
+      })
+
+      const connector = {
+        id: 'conn-1',
+        name: 'Test',
+        platform: 'discord' as const,
+        agentId: 'agent-1',
+        config: {},
+        enabled: true,
+        createdAt: now,
+        updatedAt: now,
+      } as unknown as Connector
+
+      const result = mod.findDirectSessionForInbound(connector, {
+        platform: 'discord',
+        channelId: 'channel-1',
+        senderId: 'user-1',
+        senderName: 'User',
+        text: 'hello',
+        threadId: 'thread-2',
+      })
+
+      assert.equal(result, null)
+    })
   })
 
   // ---- updateSessionConnectorContext ----

package/src/lib/server/connectors/session.ts

@@ -12,6 +12,7 @@ import {
   resetConnectorSessionRuntime,
   resolveConnectorSessionPolicy,
 } from './policy'
+import { isDirectConnectorSession } from './session-kind'
 import { resolveThreadPersonaLabel } from './thread-context'
 import type { InboundMessage } from './types'
 
@@ -40,7 +41,8 @@ export function findDirectSessionForInbound(connector: Connector, msg: InboundMe
   const senderIds = new Set([msg.senderId, msg.senderIdAlt].filter(Boolean))
   const sessions = Object.values(loadSessions() as Record<string, ConnectorSession>)
   const candidates = sessions.filter((session) =>
-    session?.agentId === effectiveAgentId
+    isDirectConnectorSession(session)
+      && session?.agentId === effectiveAgentId
       && session?.connectorContext?.connectorId === connector.id
       && (
         channelIds.has(session?.connectorContext?.channelId || '')
@@ -51,6 +53,7 @@ export function findDirectSessionForInbound(connector: Connector, msg: InboundMe
   if (msg.threadId) {
     const threadExact = candidates.find((session) => session?.connectorContext?.threadId === msg.threadId)
     if (threadExact) return threadExact
+    return null
   }
   const senderExact = candidates.find((session) =>
     senderIds.has(session?.connectorContext?.senderId || '')
@@ -64,7 +67,7 @@ export function findDirectSessionForInbound(connector: Connector, msg: InboundMe
   )
   if (peerIdMatch) return peerIdMatch
 
-  return candidates[0] || null
+  return candidates.length === 1 ? candidates[0] : null
 }
 
 export function persistSessionRecord(session: ConnectorSession): void {

package/src/lib/server/identity-continuity.test.ts

@@ -32,9 +32,9 @@ test('buildIdentityContinuityContext merges agent and session continuity', () =>
 test('refreshSessionIdentityState derives fallback continuity fields', () => {
   const session = {
     id: 's1',
-    name: 'Checkout Bug',
+    name: 'connector:checkout-bug',
     cwd: process.cwd(),
-    user: 'Taylor',
+    user: 'connector',
     provider: 'openai',
     model: 'gpt-4.1',
     claudeSessionId: null,
@@ -61,7 +61,8 @@ test('refreshSessionIdentityState derives fallback continuity fields', () => {
 test('buildIdentityContinuityContext prefers thread persona labels from connector context', () => {
   const block = buildIdentityContinuityContext(
     {
-      name: 'Connector Session',
+      name: 'connector:session',
+      user: 'connector',
       connectorContext: {
         threadId: 'thread-9',
         threadPersonaLabel: 'Checkout Incident',

package/src/lib/server/identity-continuity.ts

@@ -1,4 +1,5 @@
 import type { Agent, IdentityContinuityState, Session } from '@/types'
+import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 
 function normalizeText(value: unknown, maxChars: number): string | null {
   if (typeof value !== 'string') return null
@@ -49,11 +50,12 @@ function fallbackSelfSummary(agent?: Partial<Agent> | null): string | null {
 }
 
 function fallbackPersonaLabel(session?: Partial<Session> | null, agent?: Partial<Agent> | null): string | null {
-  const threadPersona = normalizeText(session?.connectorContext?.threadPersonaLabel, 120)
+  const connectorContext = isDirectConnectorSession(session) ? session?.connectorContext : null
+  const threadPersona = normalizeText(connectorContext?.threadPersonaLabel, 120)
   if (threadPersona) return threadPersona
-  const threadTitle = normalizeText(session?.connectorContext?.threadTitle, 120)
+  const threadTitle = normalizeText(connectorContext?.threadTitle, 120)
   if (threadTitle) return threadTitle
-  const threadId = normalizeText(session?.connectorContext?.threadId, 80)
+  const threadId = normalizeText(connectorContext?.threadId, 80)
   if (threadId) return `${agent?.name || 'Agent'} thread ${threadId}`
   const sessionName = normalizeText(session?.name, 120)
   if (sessionName && !/^new chat$/i.test(sessionName)) return sessionName
@@ -61,7 +63,9 @@ function fallbackPersonaLabel(session?: Partial<Session> | null, agent?: Partial
 }
 
 function fallbackRelationshipSummary(session?: Partial<Session> | null): string | null {
-  const sender = normalizeText(session?.connectorContext?.senderName, 80)
+  const sender = isDirectConnectorSession(session)
+    ? normalizeText(session?.connectorContext?.senderName, 80)
+    : null
   if (sender) return `Ongoing conversation with ${sender}.`
   const user = normalizeText(session?.user, 80)
   if (user && user !== 'user') return `Ongoing conversation with ${user}.`

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

@@ -2,7 +2,6 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import {
   inferAutomaticMemoryCategory,
-  isDirectMemoryWriteRequest,
   isCurrentThreadRecallRequest,
   normalizeMemoryCategory,
   shouldAutoCaptureMemory,
@@ -42,17 +41,6 @@ test('isCurrentThreadRecallRequest detects same-thread recall without matching s
   )
 })
 
-test('isDirectMemoryWriteRequest detects remember-and-confirm turns without matching recall questions', () => {
-  assert.equal(
-    isDirectMemoryWriteRequest('Remember that my favorite programming language is Rust and I prefer functional programming patterns. Then confirm what you just stored.'),
-    true,
-  )
-  assert.equal(
-    isDirectMemoryWriteRequest('What preferences did I tell you earlier in this conversation?'),
-    false,
-  )
-})
-
 test('shouldAutoCaptureMemory filters noisy turns', () => {
   assert.equal(shouldAutoCaptureMemory({ message: 'thanks', response: 'Happy to help with that.' }), false)
   assert.equal(shouldAutoCaptureMemory({ message: 'Please save this to memory', response: 'Stored memory "note".' }), false)
@@ -63,13 +51,15 @@ test('shouldAutoCaptureMemory filters noisy turns', () => {
   }), true)
 })
 
-test('inferAutomaticMemoryCategory picks a stable automatic bucket', () => {
+test('inferAutomaticMemoryCategory falls back to knowledge/facts without content-sniffing', () => {
+  // Content-sniffing regex removed — the agent picks categories via guidance.
+  // inferAutomaticMemoryCategory (called with category "note") should fall through.
   assert.equal(
     inferAutomaticMemoryCategory('The user prefers direct status updates.', 'I will keep future updates terse and direct.'),
-    'identity/preferences',
+    'knowledge/facts',
   )
   assert.equal(
     inferAutomaticMemoryCategory('We decided to ship the GitHub import first.', 'Decision locked for the next milestone.'),
-    'projects/decisions',
+    'knowledge/facts',
   )
 })

package/src/lib/server/memory/memory-policy.ts

@@ -6,7 +6,7 @@ const MEMORY_META_RE = /\b(?:remember|memory|memorize|store this|save this|forge
 const LOW_SIGNAL_RESPONSE_RE = /^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i
 const CURRENT_THREAD_RECALL_MARKER_RE = /\b(?:this conversation|this chat|this thread|current conversation|current chat|current thread|same thread|same chat|same conversation|earlier in (?:this )?(?:conversation|chat|thread)|from (?:this|our) (?:conversation|chat|thread)|you just stored|you just said|we just discussed|we just decided)\b/i
 const CURRENT_THREAD_RECALL_INTENT_RE = /\b(?:what|which|who|when|where|did|remind|recap|summarize|repeat|list|tell me|answer|confirm|recall|mention)\b/i
-const DIRECT_MEMORY_WRITE_MARKER_RE = /\b(?:remember|memorize|store|save|write to memory|add to memory|update.*memory|correct.*memory)\b/i
+const DIRECT_MEMORY_WRITE_MARKER_RE = /\b(?:remember|memorize|store (?:this|that|the fact|it)|save (?:this|that|the fact|it) (?:to|in) memory|write to memory|add to memory|update.*memory|correct.*memory)\b/i
 const DIRECT_MEMORY_WRITE_FOLLOWUP_RE = /\b(?:confirm|recap|repeat|summarize|what you just stored|what you saved|what you updated)\b/i
 
 function normalizeWhitespace(value: string): string {
@@ -36,16 +36,6 @@ export function isCurrentThreadRecallRequest(message: string): boolean {
   return CURRENT_THREAD_RECALL_INTENT_RE.test(trimmed) || /\?\s*$/.test(trimmed)
 }
 
-export function isDirectMemoryWriteRequest(message: string): boolean {
-  const trimmed = normalizeWhitespace(message)
-  if (!trimmed) return false
-  const directWriteLike = DIRECT_MEMORY_WRITE_MARKER_RE.test(trimmed)
-  if (!directWriteLike) return false
-  if (/\?\s*$/.test(trimmed) && !DIRECT_MEMORY_WRITE_FOLLOWUP_RE.test(trimmed)) return false
-  if (isCurrentThreadRecallRequest(trimmed) && !DIRECT_MEMORY_WRITE_FOLLOWUP_RE.test(trimmed)) return false
-  return true
-}
-
 export function shouldAutoCaptureMemoryTurn(message: string, response: string): boolean {
   const normalizedMessage = normalizeWhitespace(message)
   const normalizedResponse = normalizeWhitespace(response)
@@ -67,19 +57,20 @@ export function shouldAutoCaptureMemory(
   return shouldAutoCaptureMemoryTurn(input.message || '', input.response || '')
 }
 
-export function normalizeMemoryCategory(
-  input: string | null | undefined,
-  title: string | null | undefined,
-  content: string | null | undefined,
-): string {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function normalizeMemoryCategory(input: string | null | undefined, _title?: string | null, _content?: string | null): string {
   const explicit = lower(input)
-  const sample = `${lower(title)}\n${lower(content)}`
 
   const mapExplicit = (value: string): string | null => {
     if (!value || value === 'note' || value === 'notes') return null
     if (['preference', 'preferences', 'likes', 'dislikes'].includes(value)) return 'identity/preferences'
     if (['identity', 'profile', 'persona'].includes(value)) return 'identity/profile'
     if (['relationship', 'relationships', 'people'].includes(value)) return 'identity/relationships'
+    if (['contact', 'contacts'].includes(value)) return 'identity/contacts'
+    if (['routine', 'routines', 'schedule', 'habit', 'habits'].includes(value)) return 'identity/routines'
+    if (['event', 'events', 'life event', 'life events', 'significant', 'milestone'].includes(value)) return 'identity/events'
+    if (['goal', 'goals', 'objective', 'objectives', 'target', 'targets'].includes(value)) return 'identity/goals'
+    if (['instruction', 'instructions', 'directive', 'directives', 'standing order', 'rule', 'rules'].includes(value)) return 'knowledge/instructions'
     if (['decision', 'decisions', 'choice'].includes(value)) return 'projects/decisions'
     if (['learning', 'learnings', 'lesson', 'lessons'].includes(value)) return 'projects/learnings'
     if (['project', 'projects', 'task', 'tasks'].includes(value)) return 'projects/context'
@@ -94,30 +85,9 @@ export function normalizeMemoryCategory(
   const explicitMapped = mapExplicit(explicit)
   if (explicitMapped) return explicitMapped
 
-  if (/\b(?:prefer(?:s|ence)?|likes?|dislikes?|favorite|timezone|pronouns|call me)\b/.test(sample)) {
-    return 'identity/preferences'
-  }
-  if (/\b(?:wife|husband|partner|friend|manager|teammate|client|customer|relationship)\b/.test(sample)) {
-    return 'identity/relationships'
-  }
-  if (/\b(?:decided|decision|approved|picked|selected|going with|will use)\b/.test(sample)) {
-    return 'projects/decisions'
-  }
-  if (/\b(?:learned|lesson|fixed|solved|root cause|failure|bug|regression|postmortem)\b/.test(sample)) {
-    return 'projects/learnings'
-  }
-  if (/\b(?:error|incident|stack trace|exception|crash)\b/.test(sample)) {
-    return 'execution/errors'
-  }
-  if (/\b(?:project|repo|repository|ticket|task|milestone|deadline|roadmap)\b/.test(sample)) {
-    return 'projects/context'
-  }
-  if (/\b(?:config|credential|endpoint|workspace|path|env var|environment|docker|sandbox)\b/.test(sample)) {
-    return 'operations/environment'
-  }
-  if (/\b(?:fact|documentation|reference|api|schema)\b/.test(sample)) {
-    return 'knowledge/facts'
-  }
+  // No content-sniffing regex — the agent picks the category via the guidance
+  // in its memory policy block. We just normalize explicit aliases above and
+  // fall back to knowledge/facts for uncategorized entries.
   return explicit && explicit !== 'note' && explicit !== 'notes' ? explicit : 'knowledge/facts'
 }
 

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

@@ -5,6 +5,7 @@ import type { Agent, MemoryEntry, MemoryReference, Session } from '@/types'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
 import { loadAgents, loadSessions, saveSessions } from '@/lib/server/storage'
 import { DATA_DIR } from '@/lib/server/data-dir'
+import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 
 const MAX_ARCHIVE_MESSAGES = 36
 const MAX_ARCHIVE_LINE_CHARS = 320
@@ -16,7 +17,7 @@ function toOneLine(value: unknown, maxChars: number): string {
 
 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'
+  return (isDirectConnectorSession(session) ? session.connectorContext?.senderName : null) || session.user || 'user'
 }
 
 function slugifySegment(value: string, fallback: string): string {

package/src/lib/server/runtime/heartbeat-service.test.ts

@@ -404,3 +404,49 @@ describe('buildAgentHeartbeatPrompt', () => {
     assert.ok(result.includes('Another active task'))
   })
 })
+
+// ── lightContext config ─────────────────────────────────────────────────
+
+describe('heartbeatConfigForSession lightContext', () => {
+  it('defaults to false when not set', () => {
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1' },
+      { heartbeatIntervalSec: 60 },
+      {},
+    )
+    assert.equal(cfg.lightContext, false)
+  })
+
+  it('inherits from global settings', () => {
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: true },
+      {},
+    )
+    assert.equal(cfg.lightContext, true)
+  })
+
+  it('agent overrides global', () => {
+    const agents: Record<string, Record<string, unknown>> = {
+      'a1': { heartbeatLightContext: true },
+    }
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1', agentId: 'a1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: false },
+      agents,
+    )
+    assert.equal(cfg.lightContext, true)
+  })
+
+  it('agent false overrides global true', () => {
+    const agents: Record<string, Record<string, unknown>> = {
+      'a1': { heartbeatLightContext: false },
+    }
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1', agentId: 'a1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: true },
+      agents,
+    )
+    assert.equal(cfg.lightContext, false)
+  })
+})

package/src/lib/server/runtime/heartbeat-service.ts

@@ -146,6 +146,7 @@ export interface HeartbeatConfig {
   showOk: boolean
   showAlerts: boolean
   target: string | null
+  lightContext: boolean
 }
 
 interface HeartbeatFileSession {
@@ -345,6 +346,7 @@ export function heartbeatConfigForSession(session: any, settings: Record<string,
   let showOk = resolveBool(settings, 'heartbeatShowOk', DEFAULT_HEARTBEAT_SHOW_OK)
   let showAlerts = resolveBool(settings, 'heartbeatShowAlerts', DEFAULT_HEARTBEAT_SHOW_ALERTS)
   let target: string | null = resolveStr(settings, 'heartbeatTarget', null)
+  let lightContext = resolveBool(settings, 'heartbeatLightContext', false)
 
   // Agent layer overrides
   if (session.agentId) {
@@ -361,6 +363,7 @@ export function heartbeatConfigForSession(session: any, settings: Record<string,
       showOk = resolveBool(agent, 'heartbeatShowOk', showOk)
       showAlerts = resolveBool(agent, 'heartbeatShowAlerts', showAlerts)
       target = resolveStr(agent, 'heartbeatTarget', target)
+      lightContext = resolveBool(agent, 'heartbeatLightContext', lightContext)
     }
   }
 
@@ -373,7 +376,7 @@ export function heartbeatConfigForSession(session: any, settings: Record<string,
   }
   target = resolveStr(session, 'heartbeatTarget', target)
 
-  return { enabled: enabled && intervalSec > 0, intervalSec, prompt, model, ackMaxChars, showOk, showAlerts, target }
+  return { enabled: enabled && intervalSec > 0, intervalSec, prompt, model, ackMaxChars, showOk, showAlerts, target, lightContext }
 }
 
 function lastUserMessageAt(session: any): number {
@@ -560,6 +563,7 @@ async function tickHeartbeats() {
         showOk: cfg.showOk,
         showAlerts: cfg.showAlerts,
         target: cfg.target,
+        lightContext: cfg.lightContext,
       },
     })
 

package/src/lib/server/runtime/runtime-settings.test.ts

@@ -46,13 +46,13 @@ describe('runtime settings defaults', () => {
     `)
 
     assert.equal(output.settings.loopMode, 'bounded')
-    assert.equal(output.settings.agentLoopRecursionLimit, 120)
+    assert.equal(output.settings.agentLoopRecursionLimit, 300)
     assert.equal(output.settings.orchestratorLoopRecursionLimit, 80)
     assert.equal(output.settings.legacyOrchestratorMaxTurns, 16)
     assert.equal(output.settings.ongoingLoopMaxIterations, 250)
     assert.equal(output.settings.ongoingLoopMaxRuntimeMinutes, 60)
     assert.equal(output.settings.delegationMaxDepth, 3)
-    assert.equal(output.settings.shellCommandTimeoutSec, 30)
+    assert.equal(output.settings.shellCommandTimeoutSec, 120)
     assert.equal(output.settings.claudeCodeTimeoutSec, 1800)
     assert.equal(output.settings.cliProcessTimeoutSec, 1800)
     assert.equal(output.settings.heartbeatIntervalSec, 1800)
@@ -61,7 +61,7 @@ describe('runtime settings defaults', () => {
     assert.equal(output.settings.heartbeatShowAlerts, true)
     assert.equal(output.settings.heartbeatTarget, null)
     assert.equal(output.settings.heartbeatPrompt, null)
-    assert.equal(output.runtime.agentLoopRecursionLimit, 120)
+    assert.equal(output.runtime.agentLoopRecursionLimit, 300)
     assert.equal(output.runtime.orchestratorLoopRecursionLimit, 80)
     assert.equal(output.runtime.legacyOrchestratorMaxTurns, 16)
   })
@@ -99,7 +99,7 @@ describe('runtime settings defaults', () => {
     `)
 
     assert.equal(output.settings.loopMode, 'bounded')
-    assert.equal(output.settings.agentLoopRecursionLimit, 200)
+    assert.equal(output.settings.agentLoopRecursionLimit, 500)
     assert.equal(output.settings.orchestratorLoopRecursionLimit, 1)
     assert.equal(output.settings.legacyOrchestratorMaxTurns, 1)
     assert.equal(output.settings.ongoingLoopMaxIterations, 5000)

package/src/lib/server/runtime/runtime-settings.ts

@@ -15,6 +15,8 @@ export interface RuntimeSettings {
   shellCommandTimeoutMs: number
   claudeCodeTimeoutMs: number
   cliProcessTimeoutMs: number
+  streamIdleStallMs: number
+  requiredToolKickoffMs: number
 }
 
 export function loadRuntimeSettings(): RuntimeSettings {
@@ -32,6 +34,8 @@ export function loadRuntimeSettings(): RuntimeSettings {
     shellCommandTimeoutMs: normalized.shellCommandTimeoutSec * 1000,
     claudeCodeTimeoutMs: normalized.claudeCodeTimeoutSec * 1000,
     cliProcessTimeoutMs: normalized.cliProcessTimeoutSec * 1000,
+    streamIdleStallMs: normalized.streamIdleStallSec * 1000,
+    requiredToolKickoffMs: normalized.requiredToolKickoffSec * 1000,
   }
 }
 

package/src/lib/server/runtime/session-run-manager.ts

@@ -52,6 +52,7 @@ interface QueueEntry {
     showAlerts: boolean
     target: string | null
     deliveryMode?: 'default' | 'tool_only'
+    lightContext?: boolean
   }
   replyToId?: string
   resolve: (value: ExecuteChatTurnResult) => void
@@ -567,6 +568,7 @@ export interface EnqueueSessionRunInput {
     showAlerts: boolean
     target: string | null
     deliveryMode?: 'default' | 'tool_only'
+    lightContext?: boolean
   }
   replyToId?: string
   /** Optional shared execution lane key. When set, multiple sessions can be serialized together. */