@swarmclawai/swarmclaw 1.2.0 → 1.2.1

package/src/lib/providers/index.ts

@@ -8,8 +8,11 @@ import { streamAnthropicChat } from './anthropic'
 import { streamOpenClawChat } from './openclaw'
 import { errorMessage, sleep, jitteredBackoff } from '@/lib/shared-utils'
 import { classifyProviderError } from './error-classification'
+import { log } from '@/lib/server/logger'
 import type { ProviderInfo, ProviderConfig as CustomProviderConfig, ProviderType } from '../../types'
 
+const TAG = 'providers'
+
 export interface ProviderHandler {
   streamChat: (opts: StreamChatOptions) => Promise<string>
 }
@@ -439,7 +442,7 @@ export async function streamChatWithFailover(
       if (classified.reason === 'auth_permanent') throw err
 
       if (i < credentialIds.length - 1) {
-        console.log(`[failover] Credential ${credId} failed (${classified.reason}: ${errMessage?.slice(0, 80)}), trying fallback...`)
+        log.info(TAG, `Credential ${credId} failed (${classified.reason}: ${errMessage?.slice(0, 80)}), trying fallback...`)
         opts.write(`data: ${JSON.stringify({
           t: 'md',
           text: JSON.stringify({ failover: { from: credId, reason: errMessage?.slice(0, 100) } }),

package/src/lib/providers/ollama.ts

@@ -3,9 +3,12 @@ import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
 import { IMAGE_EXTS, TEXT_EXTS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
+import { log } from '@/lib/server/logger'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
+const TAG = 'provider-ollama'
+
 export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve, reject) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
@@ -69,7 +72,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
         apiRes.on('data', (c: Buffer) => errBody += c)
         apiRes.on('end', () => {
           const msg = `Ollama error ${apiRes.statusCode}: ${errBody.slice(0, 200)}`
-          console.error(`[${session.id}] ${msg}`)
+          log.error(TAG, `[${session.id}] ${msg}`)
           writeSSE(write, 'err', msg.slice(0, 120))
           active.delete(session.id)
           reject(new Error(msg))
@@ -114,7 +117,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
     apiReq.on('error', (e: NodeJS.ErrnoException) => {
-      console.error(`[${session.id}] ollama request error:`, e.message)
+      log.error(TAG, `[${session.id}] ollama request error:`, e.message)
       let errMsg = e.message
       if (e.code === 'ECONNREFUSED') {
         errMsg = `Cannot connect to Ollama at ${endpoint}. Is Ollama running?`

package/src/lib/providers/openai.ts

@@ -1,8 +1,11 @@
 import fs from 'fs'
 import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS, IMAGE_EXTS, TEXT_EXTS, PDF_MAX_CHARS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
+import { log } from '@/lib/server/logger'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
+const TAG = 'provider-openai'
+
 async function fileToContentParts(filePath: string): Promise<Array<Record<string, unknown>>> {
   if (!filePath || !fs.existsSync(filePath)) return []
   const name = filePath.split('/').pop() || 'file'
@@ -108,7 +111,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
       const resContentType = res.headers.get('content-type') || ''
       if (resContentType.includes('text/html')) {
         const msg = 'Received HTML instead of API response. The endpoint may be misconfigured or returning a landing page.'
-        console.error(`[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
+        log.error(TAG, `[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
         writeSSE(write, 'err', msg)
         active.delete(session.id)
         reject(new Error(msg))
@@ -117,7 +120,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 
       if (!res.ok) {
         const errBody = await res.text().catch(() => '')
-        console.error(`[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
+        log.error(TAG, `[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
         let errMsg = `API error (${res.status})`
         try {
           const parsed = JSON.parse(errBody)
@@ -133,7 +136,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 
       if (!res.body) {
         const msg = `No response body from ${baseUrl}`
-        console.error(`[${session.id}] ${msg}`)
+        log.error(TAG, `[${session.id}] ${msg}`)
         active.delete(session.id)
         reject(new Error(msg))
         return
@@ -175,12 +178,12 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
       }
 
       if (!fullResponse) {
-        console.error(`[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
+        log.error(TAG, `[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
       }
     } catch (err: unknown) {
       const errObj = err as { name?: string; message?: string }
       if (errObj.name !== 'AbortError') {
-        console.error(`[${session.id}] openai request error:`, errObj.message)
+        log.error(TAG, `[${session.id}] openai request error:`, errObj.message)
         writeSSE(write, 'err', `Connection failed: ${errObj.message}`)
       }
       active.delete(session.id)

package/src/lib/providers/opencode-cli.ts

@@ -2,7 +2,7 @@ import { spawn } from 'child_process'
 import type { StreamChatOptions } from './index'
 import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
-import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler } from './cli-utils'
+import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, isStderrNoise } from './cli-utils'
 
 /**
  * OpenCode CLI provider — spawns `opencode run <message> --format json` for non-interactive usage.
@@ -120,7 +120,11 @@ export function streamOpenCodeCliChat({ session, message, imagePath, systemPromp
     const text = chunk.toString()
     stderrText += text
     if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
-    log.warn('opencode-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    if (isStderrNoise(text)) {
+      log.debug('opencode-cli', `stderr noise [${session.id}]`, text.slice(0, 500))
+    } else {
+      log.warn('opencode-cli', `stderr [${session.id}]`, text.slice(0, 500))
+    }
   })
 
   return new Promise((resolve) => {

package/src/lib/server/agents/agent-registry.ts

@@ -52,19 +52,36 @@ export function getAgentDirectory(excludeId?: string): AgentDirectoryEntry[] {
   return entries
 }
 
-export function buildAgentAwarenessBlock(excludeId: string): string {
-  const directory = getAgentDirectory(excludeId)
+export function buildAgentAwarenessBlock(
+  excludeId: string,
+  opts?: {
+    delegationTargetMode?: 'all' | 'selected'
+    delegationTargetAgentIds?: string[]
+  },
+): string {
+  let directory = getAgentDirectory(excludeId)
   if (!directory.length) return ''
 
+  const isFiltered = opts?.delegationTargetMode === 'selected'
+  if (isFiltered) {
+    const allowedIds = new Set(opts.delegationTargetAgentIds || [])
+    directory = directory.filter((entry) => allowedIds.has(entry.id))
+    if (!directory.length) return ''
+  }
+
   const lines = directory.map((entry) => {
     const caps = entry.capabilities.length ? ` (${entry.capabilities.join(', ')})` : ''
     const status = entry.statusDetail || entry.status
     return `- **${entry.name}** [id: ${entry.id}]${caps} — ${status}`
   })
 
+  const header = isFiltered
+    ? 'These are the ONLY agents I can delegate tasks to. Do not attempt to delegate to any other agents:'
+    : 'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:'
+
   return [
     '## My Colleagues',
-    'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:',
+    header,
     ...lines,
   ].join('\n')
 }

package/src/lib/server/agents/main-agent-loop.ts

@@ -12,7 +12,7 @@ const MAX_PENDING_EVENTS = 16
 const MAX_TIMELINE_ITEMS = 40
 const MAX_WORKING_MEMORY_NOTES = 12
 const DEFAULT_FOLLOWUP_DELAY_MS = 1500
-const DEFAULT_MAX_FOLLOWUP_CHAIN = 6
+const DEFAULT_MAX_FOLLOWUP_CHAIN = 4
 const MAX_LIFETIME_ITERATIONS = 200
 
 export interface MainLoopState {
@@ -778,6 +778,7 @@ export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: s
     boundedFallbackPrompt ? `Base heartbeat instructions:\n${boundedFallbackPrompt}` : '',
     '',
     'You are checking the durable main mission thread for this agent.',
+    'Keep this status check brief — 5-10 tool calls maximum. Read key state, summarize progress, and report. Do not attempt fixes or deep investigation during heartbeats.',
     'Use only the current goal, plan, next action, and pending external events shown above.',
     'Do not infer or repeat old tasks from prior heartbeats.',
     'Prefer taking the single highest-value next step over restating the plan. Do not repeat completed work.',
@@ -1072,8 +1073,8 @@ export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): Ma
         || (needsReplan
           ? 'Replan from the latest outcome, then execute only the highest-value remaining step. Do not repeat completed work.'
           : state.nextAction
-            ? `Continue the objective. Resume from this next action: ${state.nextAction}`
-            : 'Continue the objective and finish the next highest-value remaining step.')
+            ? `Continue. Next action: ${state.nextAction}. Do not repeat tool calls from previous turns.`
+            : `Continue. You have used ${state.followupChainCount} of ${limit} followup turns. Focus on completing one concrete step, then summarize progress.`)
       followup = {
         message,
         delayMs: DEFAULT_FOLLOWUP_DELAY_MS,

package/src/lib/server/autonomy/supervisor-reflection.ts

@@ -34,6 +34,8 @@ import { logExecution } from '@/lib/server/execution-log'
 import { logActivity } from '@/lib/server/storage'
 import { createNotification } from '@/lib/server/create-notification'
 
+const TAG = 'supervisor-reflection'
+
 const MAIN_LOOP_META_LINE_RE = /\[(?:MAIN_LOOP_META|MAIN_LOOP_PLAN|MAIN_LOOP_REVIEW|AGENT_HEARTBEAT_META)\]\s*(\{[^\n]*\})?/i
 const DEFAULT_TRANSCRIPT_MESSAGES = 12
 const DEFAULT_SNIPPET_CHARS = 800
@@ -368,6 +370,17 @@ export function assessAutonomyRun(input: {
   if (strongest?.kind === 'budget_pressure' && strongest.severity === 'high') shouldBlock = true
   if (strongest?.kind === 'run_error' && (status === 'failed' || status === 'cancelled')) shouldBlock = true
 
+  // Block after 3+ no_progress or repeated_tool incidents within 30 minutes for the same session
+  if (!shouldBlock && strongest && (strongest.kind === 'no_progress' || strongest.kind === 'repeated_tool')) {
+    const existingIncidents = Object.values(loadSupervisorIncidents()) as SupervisorIncident[]
+    const recentSame = existingIncidents.filter((i) =>
+      i.sessionId === input.sessionId
+      && i.createdAt > Date.now() - 30 * 60_000
+      && (i.kind === 'no_progress' || i.kind === 'repeated_tool'),
+    )
+    if (recentSame.length >= 3) shouldBlock = true
+  }
+
   const seen = new Set<string>()
   const autoActions: AutonomyAssessment['autoActions'] = []
   for (const incident of incidents) {
@@ -1023,7 +1036,7 @@ export async function observeAutonomyRunOutcome(
   try {
     parsed = parseReflectionResponse(responseText)
   } catch {
-    console.warn(`[autonomy] Reflection parse failed for run ${input.runId}, skipping reflection`)
+    log.warn(TAG, `Reflection parse failed for run ${input.runId}, skipping reflection`)
     return { incidents, reflection: null }
   }
   if (parsed.skip) return { incidents, reflection: null }

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

@@ -109,6 +109,8 @@ import {
   resolveMissionForTurn,
 } from '@/lib/server/missions/mission-service'
 
+const TAG = 'chat-execution'
+
 export {
   shouldApplySessionFreshnessReset,
   shouldAutoRouteHeartbeatAlerts,
@@ -1218,6 +1220,15 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const emit = (ev: SSEEvent) => {
     let shouldPersistPartial = false
     let immediatePartialPersist = false
+    if (ev.t === 'reset') {
+      // stream-agent-chat rolls back state after a transient error — reset
+      // accumulated text/thinking/tools so the partial persist stays in sync.
+      streamingPartialText = ev.text || ''
+      thinkingText = ''
+      toolEvents.length = 0
+      shouldPersistPartial = true
+      immediatePartialPersist = true
+    }
     if (ev.t === 'd' && typeof ev.text === 'string') {
       streamingPartialText += ev.text
       shouldPersistPartial = true
@@ -1378,7 +1389,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
         ? (heartbeatLightContext ? [] : getSessionMessages(sessionId).slice(-6))
         : undefined
 
-      console.log(`[chat-execution] provider=${providerType}, hasExtensions=${hasExtensions}, localOpenClawNative=${useLocalOpenClawNativeRuntime}, imagePath=${resolvedImagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, extensions=${enabledSessionExtensions.length}`)
+      log.info(TAG, `provider=${providerType}, hasExtensions=${hasExtensions}, localOpenClawNative=${useLocalOpenClawNativeRuntime}, imagePath=${resolvedImagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, extensions=${enabledSessionExtensions.length}`)
       if (hasExtensions) {
         const result = await streamAgentChat({
           session: sessionForRun,
@@ -1392,6 +1403,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           write: (raw) => parseAndEmit(raw),
           history: heartbeatHistory ?? applyContextClearBoundary(getSessionMessages(sessionId)),
           signal: abortController.signal,
+          source,
         })
         fullResponse = result.finalResponse || result.fullText
       } else {
@@ -1760,7 +1772,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           now: nowTs,
         })) {
           persistedResponseForHooks = nextAssistantMessage.text
-        } else if ((previous?.streaming && previous?.runId === lifecycleRunId) || shouldReplaceRecentAssistantMessage({
+        } else if (previous?.runId === lifecycleRunId || shouldReplaceRecentAssistantMessage({
           previous,
           nextToolEvents,
           nextKind,

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

@@ -143,9 +143,10 @@ function checkLoopDetection(ctx: ContinuationContext): ContinuationDecision | nu
     }
   }
 
-  // Terminal — caller should break
-  const errMessage = ctx.state.loopDetectionTriggered?.message || 'Tool frequency limit exceeded.'
-  ctx.write(`data: ${JSON.stringify({ t: 'err', text: errMessage })}\n\n`) // err, not status
+  // Terminal — caller should break.
+  // Emit a user-friendly message instead of the raw diagnostic (which is internal).
+  // The structured diagnostic data is already carried via the `status` event in iteration-event-handler.
+  ctx.write(`data: ${JSON.stringify({ t: 'err', text: 'The agent got stuck in a repetitive loop and has been stopped. Please try rephrasing your request or breaking it into smaller steps.' })}\n\n`)
   return { type: false, requiredToolReminderNames: [] }
 }
 

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

@@ -54,7 +54,7 @@ const MAX_COORDINATOR_SYNTHESIS = 3
 const MAX_COORDINATOR_DELEGATION_NUDGE = 1
 
 /** Max loop recovery continuations (tool_frequency limit resets) */
-const MAX_LOOP_RECOVERY = 2
+const MAX_LOOP_RECOVERY = 1
 
 /** Max context overflow retries (emergency context reduction) */
 const MAX_CONTEXT_OVERFLOW = 2
@@ -64,7 +64,7 @@ const MAX_CONTEXT_OVERFLOW = 2
 export class ContinuationLimits {
   private readonly limits: Record<BudgetedContinuation, LimitEntry>
 
-  constructor(isConnectorSession: boolean) {
+  constructor(isConnectorSession: boolean, isHeartbeat = false) {
     let maxDeliverableFollowthroughs = MAX_DELIVERABLE_FOLLOWTHROUGH
     let maxExecutionFollowthroughs = MAX_EXECUTION_FOLLOWTHROUGH
     let maxAttachmentFollowthroughs = MAX_ATTACHMENT_FOLLOWTHROUGH
@@ -79,6 +79,9 @@ export class ContinuationLimits {
       maxUnfinishedToolFollowthroughs = 1
     }
 
+    // Heartbeats should not need loop recovery — they are brief status checks
+    const maxLoopRecovery = isHeartbeat ? 0 : MAX_LOOP_RECOVERY
+
     this.limits = {
       recursion: { count: 0, max: MAX_RECURSION },
       transient: { count: 0, max: MAX_TRANSIENT },
@@ -94,7 +97,7 @@ export class ContinuationLimits {
       tool_summary: { count: 0, max: maxToolSummaryRetries },
       coordinator_synthesis: { count: 0, max: MAX_COORDINATOR_SYNTHESIS },
       coordinator_delegation_nudge: { count: 0, max: MAX_COORDINATOR_DELEGATION_NUDGE },
-      loop_recovery: { count: 0, max: MAX_LOOP_RECOVERY },
+      loop_recovery: { count: 0, max: maxLoopRecovery },
     }
   }
 

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

@@ -13,9 +13,12 @@ import crypto from 'node:crypto'
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { buildLLM } from '@/lib/server/build-llm'
+import { log } from '@/lib/server/logger'
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { Message } from '@/types'
 
+const TAG = 'message-classifier'
+
 // ---------------------------------------------------------------------------
 // Schema
 // ---------------------------------------------------------------------------
@@ -221,7 +224,7 @@ export async function classifyMessage(
     ])
 
     const durationMs = Date.now() - startMs
-    console.log(`[message-classifier] session=${input.sessionId} completed in ${durationMs}ms`)
+    log.info(TAG, `session=${input.sessionId} completed in ${durationMs}ms`)
 
     const classification = parseClassificationResponse(responseText)
     if (classification) {
@@ -230,7 +233,7 @@ export async function classifyMessage(
     return classification
   } catch (err: unknown) {
     const durationMs = Date.now() - startMs
-    console.warn(`[message-classifier] session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
+    log.warn(TAG, `session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
     return null
   }
 }

package/src/lib/server/chat-execution/post-stream-finalization.ts

@@ -6,7 +6,10 @@
  * and OpenClaw sync.
  */
 import type { Session, UsageRecord } from '@/types'
+import { log } from '@/lib/server/logger'
 import type { ChatTurnState } from '@/lib/server/chat-execution/chat-turn-state'
+
+const TAG = 'post-stream'
 import { extractSuggestions } from '@/lib/server/suggestions'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import { estimateCost, buildExtensionDefinitionCosts } from '@/lib/server/cost'
@@ -39,7 +42,7 @@ function stripLeakedClassificationJson(text: string): { cleaned: string; strippe
     else if (text[i] === '}') { depth--; if (depth === 0) { end = i + 1; break } }
   }
   if (end === -1) return { cleaned: text, stripped: false }
-  console.warn('[post-stream-finalization] Stripped leaked classification JSON from model output')
+  log.warn(TAG, 'Stripped leaked classification JSON from model output')
   return { cleaned: (text.slice(0, startIdx) + text.slice(end)).trimStart(), stripped: true }
 }
 

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

@@ -120,6 +120,16 @@ export function buildToolDisciplineLines(enabledExtensions: string[]): string[]
 
   lines.push(...planning.disciplineGuidance)
 
+  // Universal tool efficiency guidance — tool-specific lines live in CORE_TOOL_PLANNING (tool-planning.ts)
+  lines.push(
+    '## Tool Efficiency',
+    'Plan your approach before starting tool calls. State what you will do, then do it.',
+    'Prefer fewer, larger tool calls over many small ones.',
+    'Do not poll for status in a loop. If waiting on a process, check once and move on.',
+    'If stuck after 2-3 attempts with the same approach, stop and state the blocker — do not keep retrying.',
+    'When delegating to subagents, use waitForCompletion or wait/wait_all instead of polling status in a loop.',
+  )
+
   const researchSearchTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.researchSearch)
   const researchFetchTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.researchFetch)
   const browserCaptureTools = getToolsForCapability(enabledExtensions, TOOL_CAPABILITY.browserCapture)
@@ -275,7 +285,7 @@ const GOAL_DECOMPOSITION_BLOCK = [
   '## Goal Decomposition',
   'When you receive a broad, open-ended goal:',
   '1. Break it into 3-7 concrete, sequentially-executable subtasks before taking action.',
-  '2. If manage_tasks is available, use it only for durable tracking: multi-turn work, delegation, explicit backlog requests, or work you expect to resume later. Do not create a task for every micro-step.',
+  '2. If manage_tasks is available, use it only for durable tracking: multi-turn work, delegation, explicit backlog requests, or work you expect to resume later. Do not create a task for every micro-step. Do not re-read the task list after every update. Read once, make your changes, then move on.',
   'Single-step instructions are not broad goals. For direct actions like storing a memory, answering a recall question, editing one file, or sending one message, execute the relevant tool immediately instead of creating tasks or delegating.',
   '3. Present the plan as a short checklist or numbered list in plain language. If durable tracking is unnecessary, keep it inline instead of creating tasks.',
   '4. Execute the first substantive subtask immediately — do not stop after planning.',

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

@@ -123,7 +123,21 @@ export async function buildAgentAwarenessSection(
   if (!hasMultiAgentTool || !session.agentId) return null
   try {
     const { buildAgentAwarenessBlock } = await import('@/lib/server/agents/agent-registry')
-    return buildAgentAwarenessBlock(session.agentId) || null
+
+    // 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]
+      if (agent?.delegationTargetMode === 'selected') {
+        delegationOpts = {
+          delegationTargetMode: 'selected',
+          delegationTargetAgentIds: agent.delegationTargetAgentIds || [],
+        }
+      }
+    } catch { /* non-critical */ }
+
+    return buildAgentAwarenessBlock(session.agentId, delegationOpts) || null
   } catch { return null }
 }
 
@@ -185,6 +199,8 @@ export function buildProjectSection(
       `project secrets ${summary.secretCount}`,
     ]
     if (summary.topTaskTitles.length > 0) lines.push(`Top open tasks: ${summary.topTaskTitles.join('; ')}`)
+    if (summary.failedTaskCount > 0) lines.push(`Failed tasks needing attention: ${summary.failedTaskCount}`)
+    if (summary.staleTaskCount > 0) lines.push(`Stale tasks (no update in 3+ days): ${summary.staleTaskCount}`)
     if (summary.scheduleNames.length > 0) lines.push(`Active schedules: ${summary.scheduleNames.join('; ')}`)
     if (summary.secretNames.length > 0) lines.push(`Known project secrets: ${summary.secretNames.join('; ')}`)
     lines.push(`Project resource summary: ${resourceBits.join(', ')}.`)
@@ -257,6 +273,11 @@ export function buildSuggestionsSection(
 // Proactive Memory Recall (async)
 // ---------------------------------------------------------------------------
 
+export interface ProactiveMemoryResult {
+  section: string | null
+  injectedIds: Record<string, number>
+}
+
 export async function buildProactiveMemorySection(
   session: Session,
   agent: Agent | null | undefined,
@@ -264,9 +285,10 @@ export async function buildProactiveMemorySection(
   activeProjectRoot: string | null,
   isMinimalPrompt: boolean,
   currentThreadRecallRequest: boolean,
-): Promise<string | null> {
-  if (isMinimalPrompt || !session.agentId || currentThreadRecallRequest || message.length <= 12) return null
-  if (!agent?.proactiveMemory) return null
+): Promise<ProactiveMemoryResult> {
+  const noResult: ProactiveMemoryResult = { section: null, injectedIds: {} }
+  if (isMinimalPrompt || !session.agentId || currentThreadRecallRequest || message.length <= 12) return noResult
+  if (!agent?.proactiveMemory) return noResult
   try {
     const { getMemoryDb } = await import('@/lib/server/memory/memory-db')
     const { buildSessionMemoryScopeFilter } = await import('@/lib/server/memory/session-memory-scope')
@@ -274,13 +296,29 @@ export async function buildProactiveMemorySection(
     const recalled = memDb.search(message, session.agentId, {
       scope: buildSessionMemoryScopeFilter(session, agent.memoryScopeMode || null, activeProjectRoot),
     })
-    const topRecalled = recalled.slice(0, 3)
+
+    // Dedup: skip memories already injected 2+ times in this session
+    const priorCounts = session.injectedMemoryIds || {}
+    const filtered = recalled.filter((entry) => (priorCounts[entry.id] || 0) < 2)
+
+    const topRecalled = filtered.slice(0, 3)
     if (topRecalled.length > 0) {
-      const recalledLines = topRecalled.map((entry) => `- ${entry.content.slice(0, 300)}`)
-      return `## Recalled Context\nRelevant memories from previous interactions:\n${recalledLines.join('\n')}`
+      // Track injection counts
+      const updatedCounts: Record<string, number> = { ...priorCounts }
+      for (const entry of topRecalled) {
+        updatedCounts[entry.id] = (updatedCounts[entry.id] || 0) + 1
+      }
+
+      const recalledLines = topRecalled.map((entry) =>
+        `- ${entry.abstract || entry.content.slice(0, 300)}`,
+      )
+      return {
+        section: `## Recalled Context\nRelevant memories from previous interactions:\n${recalledLines.join('\n')}`,
+        injectedIds: updatedCounts,
+      }
     }
   } catch { /* non-critical */ }
-  return null
+  return noResult
 }
 
 // ---------------------------------------------------------------------------
@@ -328,7 +366,7 @@ export function buildCoordinatorSection(
   for (const w of listed) {
     const caps = w.capabilities?.length ? ` [${w.capabilities.join(', ')}]` : ''
     const desc = w.description ? ` — ${w.description.slice(0, 100)}` : ''
-    const line = `- **${w.name}**${caps}${desc}`
+    const line = `- **${w.name}** [id: ${w.id}]${caps}${desc}`
     if (charBudget - line.length < 0) break
     charBudget -= line.length + 1
     lines.push(line)
@@ -338,6 +376,11 @@ export function buildCoordinatorSection(
     lines.push(`- ... and ${workers.length - COORDINATOR_MAX_WORKERS} more workers`)
   }
 
+  if (delegateMode === 'selected') {
+    lines.push('')
+    lines.push('**IMPORTANT:** You may ONLY delegate to the workers listed above. Do NOT attempt to delegate to any other agents — such attempts will be rejected.')
+  }
+
   lines.push('')
   lines.push('### Orchestration Tools')
   lines.push('- **`spawn_subagent`** — Simple fire-and-forget delegation. Best for: single tasks, batch parallel/serial, basic swarm. Use when tasks are independent.')

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

@@ -9,6 +9,9 @@ import crypto from 'node:crypto'
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { buildLLM } from '@/lib/server/build-llm'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'response-completeness'
 
 // ---------------------------------------------------------------------------
 // Schema
@@ -191,7 +194,7 @@ export async function evaluateResponseCompleteness(
     ])
 
     const durationMs = Date.now() - startMs
-    console.log(`[response-completeness] session=${input.sessionId} completed in ${durationMs}ms`)
+    log.info(TAG, `session=${input.sessionId} completed in ${durationMs}ms`)
 
     const completeness = parseCompletenessResponse(responseText)
     if (completeness) {
@@ -200,7 +203,7 @@ export async function evaluateResponseCompleteness(
     return completeness
   } catch (err: unknown) {
     const durationMs = Date.now() - startMs
-    console.warn(`[response-completeness] session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
+    log.warn(TAG, `session=${input.sessionId} failed in ${durationMs}ms: ${err instanceof Error ? err.message : 'unknown'}`)
     return null
   }
 }