@swarmclawai/swarmclaw 1.2.4 → 1.2.5

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

@@ -6,13 +6,24 @@
  * The main prompt assembly in stream-agent-chat.ts composes these declaratively.
  */
 
+import fs from 'node:fs'
+import path from 'node:path'
 import type { Session, Agent } from '@/types'
+import type { PromptMode } from '@/lib/server/chat-execution/prompt-mode'
+import type { MessageClassification } from '@/lib/server/chat-execution/message-classifier'
 import type { ActiveProjectContext } from '@/lib/server/project-context'
+import type { SessionToolPolicyDecision } from '@/lib/server/tool-capability-policy'
 import { buildIdentityContinuityContext } from '@/lib/server/identity-continuity'
+import {
+  buildDelegationTaskProfile,
+  formatDelegationRationale,
+  resolveDelegationAdvisory,
+} from '@/lib/server/agents/delegation-advisory'
 import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
 import { loadSkills } from '@/lib/server/skills/skill-repository'
 import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import { resolveTeam } from '@/lib/server/agents/team-resolution'
+import { canonicalizeExtensionId } from '@/lib/server/tool-aliases'
 
 // ---------------------------------------------------------------------------
 // Identity: agent name, description, continuity, soul, systemPrompt, skills
@@ -89,6 +100,148 @@ export function buildThinkingSection(
   return text ? `## Reasoning Depth\n${text}` : null
 }
 
+// ---------------------------------------------------------------------------
+// Runtime Orientation
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_MARKER_FILES = [
+  'AGENTS.md',
+  'BOOTSTRAP.md',
+  'HEARTBEAT.md',
+  'IDENTITY.md',
+  'TOOLS.md',
+  'USER.md',
+]
+
+function normalizeRuntimeExtensionId(extensionId: string): string {
+  const normalized = extensionId.trim().toLowerCase()
+  if (!normalized) return ''
+  if (normalized === 'delegate_to_claude_code' || normalized === 'claude_code') return 'claude_code'
+  if (normalized === 'delegate_to_codex_cli' || normalized === 'codex_cli') return 'codex_cli'
+  if (normalized === 'delegate_to_opencode_cli' || normalized === 'opencode_cli') return 'opencode_cli'
+  if (normalized === 'delegate_to_gemini_cli' || normalized === 'gemini_cli') return 'gemini_cli'
+  if (['session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'].includes(normalized)) return 'manage_sessions'
+  return canonicalizeExtensionId(normalized)
+}
+
+function canonicalizeEnabledExtensions(enabledExtensions: string[]): string[] {
+  const seen = new Set<string>()
+  const values: string[] = []
+  for (const extensionId of enabledExtensions) {
+    const normalized = normalizeRuntimeExtensionId(extensionId)
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    values.push(normalized)
+  }
+  return values
+}
+
+function formatInlineCodeList(values: string[], maxItems = 8): string {
+  if (values.length === 0) return '(none)'
+  const head = values.slice(0, maxItems).map((value) => `\`${value}\``)
+  if (values.length > maxItems) head.push(`... +${values.length - maxItems} more`)
+  return head.join(', ')
+}
+
+function formatPolicyBlocks(blocked: SessionToolPolicyDecision['blockedExtensions'], maxItems = 3): string {
+  const lines = blocked
+    .slice(0, maxItems)
+    .map((entry) => `\`${canonicalizeExtensionId(entry.tool)}\` (${entry.reason})`)
+  if (blocked.length > maxItems) lines.push(`... +${blocked.length - maxItems} more`)
+  return lines.join(', ')
+}
+
+function collectWorkspaceMarkers(cwd: string | null | undefined): string[] {
+  if (typeof cwd !== 'string' || !cwd.trim()) return []
+  return WORKSPACE_MARKER_FILES.filter((filename) => {
+    try {
+      return fs.existsSync(path.join(cwd, filename))
+    } catch {
+      return false
+    }
+  })
+}
+
+function resolveRuntimeSessionKind(params: {
+  session: Session
+  isHeartbeat?: boolean
+  isConnectorSession?: boolean
+}): string {
+  if (params.isHeartbeat) return 'heartbeat'
+  if (params.isConnectorSession) return 'connector'
+  if (params.session.parentSessionId) return 'delegated_child'
+  return 'root_chat'
+}
+
+export function buildRuntimeOrientationSection(params: {
+  session: Session
+  promptMode: PromptMode
+  sessionExtensions: string[]
+  toolPolicy?: SessionToolPolicyDecision | null
+  agent?: Agent | null
+  activeProjectContext?: ActiveProjectContext | null
+  rootSessionId?: string | null
+  isHeartbeat?: boolean
+  isConnectorSession?: boolean
+}): string {
+  const { session, agent } = params
+  const activeProjectContext = params.activeProjectContext || null
+  const enabledExtensions = canonicalizeEnabledExtensions(params.sessionExtensions)
+  const workspaceMarkers = collectWorkspaceMarkers(session.cwd)
+  const delegationEnabled = enabledExtensions.some((extensionId) =>
+    ['delegate', 'spawn_subagent', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli'].includes(extensionId),
+  )
+
+  const lines = [
+    '## Runtime Orientation',
+    `Session: ${resolveRuntimeSessionKind({ session, isHeartbeat: params.isHeartbeat, isConnectorSession: params.isConnectorSession })} | prompt=${params.promptMode} | id=${session.id}`,
+    session.parentSessionId || params.rootSessionId
+      ? `Lineage: parent=${session.parentSessionId || '(none)'} | root=${params.rootSessionId || session.id}`
+      : `Lineage: root=${session.id}`,
+    `Agent: ${agent?.name || session.agentId || 'Unassigned'}${session.agentId ? ` [id: ${session.agentId}]` : ''}`,
+    `Provider/model: ${session.provider} / ${session.model || '(default)'}`,
+    `CWD: ${session.cwd || '(none)'}`,
+  ]
+
+  if (workspaceMarkers.length > 0) {
+    lines.push(`Workspace markers: ${workspaceMarkers.join(', ')}`)
+  }
+
+  if (activeProjectContext?.projectId) {
+    const projectLabel = activeProjectContext.project?.name || activeProjectContext.projectId
+    const projectRoot = activeProjectContext.projectRoot ? ` | root=${activeProjectContext.projectRoot}` : ''
+    lines.push(`Active project: ${projectLabel}${projectRoot}`)
+  }
+
+  lines.push(`Enabled capabilities now: ${formatInlineCodeList(enabledExtensions)}`)
+
+  if (params.toolPolicy?.blockedExtensions?.length) {
+    lines.push(`Policy blocked: ${formatPolicyBlocks(params.toolPolicy.blockedExtensions)}`)
+  }
+
+  if (delegationEnabled) {
+    const delegateMode = agent?.delegationTargetMode === 'selected' ? 'selected' : 'all'
+    const targetIds = Array.isArray(agent?.delegationTargetAgentIds)
+      ? agent!.delegationTargetAgentIds.filter((value) => typeof value === 'string' && value.trim())
+      : []
+    lines.push(
+      delegateMode === 'selected'
+        ? `Delegation: enabled (${delegateMode}) | targets=${targetIds.length ? targetIds.join(', ') : '(none configured)'}`
+        : 'Delegation: enabled (all allowed targets)',
+    )
+  } else {
+    lines.push('Delegation: disabled in this runtime')
+  }
+
+  if (enabledExtensions.includes('manage_sessions')) {
+    lines.push('Harness inspection: use `sessions_tool` action `identity` for live session/platform context; use action `history` only when you need earlier messages from this same session.')
+  }
+
+  lines.push('Platform routing: prefer direct `manage_*` tools when enabled; use `manage_platform` only as fallback.')
+
+  return lines.join('\n')
+}
+
 // ---------------------------------------------------------------------------
 // Workspace Context (async — dynamic import)
 // ---------------------------------------------------------------------------
@@ -414,6 +567,43 @@ export function buildCoordinatorSection(
   return lines.join('\n')
 }
 
+export function buildDelegationRecommendationSection(params: {
+  agent: Agent | null | undefined
+  classification?: MessageClassification | null
+}): string | null {
+  const agent = params.agent
+  if (!agent || agent.delegationEnabled !== true) return null
+  const profile = buildDelegationTaskProfile({
+    classification: params.classification,
+  })
+  if (!profile.substantial) return null
+
+  const advisory = resolveDelegationAdvisory({
+    currentAgent: agent,
+    agents: listAgents(),
+    profile,
+    delegationTargetMode: agent.delegationTargetMode === 'selected' ? 'selected' : 'all',
+    delegationTargetAgentIds: agent.delegationTargetAgentIds || [],
+  })
+  if (!advisory.shouldDelegate || !advisory.recommended) return null
+
+  const recommendation = advisory.recommended
+  const workLabel = profile.workType === 'general' ? 'substantial work' : `${profile.workType} work`
+  const recommendationLabel = advisory.style === 'managerial'
+    ? 'Managerial Delegation Recommendation'
+    : 'Delegation Recommendation'
+
+  return [
+    `## ${recommendationLabel}`,
+    `This request looks like ${workLabel}.`,
+    `Best-fit teammate: **${recommendation.agentName}** [id: ${recommendation.agentId}]`,
+    `Why: ${formatDelegationRationale(recommendation)}.`,
+    advisory.style === 'managerial'
+      ? 'Prefer delegating the execution and keep your direct work to reconnaissance, validation, and synthesis.'
+      : 'Prefer delegating the execution and reserve direct tool use for quick lookups or validation.',
+  ].join('\n')
+}
+
 // ---------------------------------------------------------------------------
 // Credential Awareness
 // ---------------------------------------------------------------------------
@@ -527,3 +717,6 @@ export function buildCliDelegationContext(opts: {
 
   return parts.join('\n')
 }
+
+// Re-export RunContext prompt builder from its canonical home
+export { buildRunContextSection } from '@/lib/server/run-context'

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

@@ -3,7 +3,7 @@ import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
 import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
-import { getAgent } from '@/lib/server/agents/agent-repository'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
 import { loadSettings } from '@/lib/server/settings/settings-repository'
@@ -18,6 +18,7 @@ import { truncateToolResultText } from '@/lib/server/chat-execution/tool-result-
 import {
   buildIdentitySection,
   buildThinkingSection,
+  buildRuntimeOrientationSection,
   buildWorkspaceSection,
   buildAgentAwarenessSection,
   buildSituationalSection,
@@ -27,13 +28,15 @@ import {
   buildProactiveMemorySection,
   buildCoordinatorSection,
   buildCredentialAwarenessSection,
+  buildDelegationRecommendationSection,
+  buildRunContextSection,
 } from '@/lib/server/chat-execution/prompt-sections'
 
 import { log } from '@/lib/server/logger'
 import { logExecution } from '@/lib/server/execution-log'
 import { buildCurrentDateTimePromptContext } from '@/lib/server/prompt-runtime-context'
 import { expandExtensionIds } from '@/lib/server/tool-aliases'
-import type { Session, Message } from '@/types'
+import type { ExecutionBrief, Session, Message } from '@/types'
 import { getEnabledCapabilityIds } from '@/lib/capability-selection'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { resolveActiveProjectContext } from '@/lib/server/project-context'
@@ -89,6 +92,7 @@ import {
   DEFAULT_PROMPT_BUDGET,
   MINIMAL_PROMPT_BUDGET,
 } from '@/lib/server/chat-execution/prompt-budget'
+import { resolveSessionLineageIds } from '@/lib/server/sessions/session-lineage'
 import { IterationTimers } from '@/lib/server/chat-execution/iteration-timers'
 import { processIterationEvents } from '@/lib/server/chat-execution/iteration-event-handler'
 import { evaluateContinuation } from '@/lib/server/chat-execution/continuation-evaluator'
@@ -101,6 +105,11 @@ import {
   isResearchSynthesis as classifiedIsResearchSynthesis,
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
+import {
+  buildDelegationTaskProfile,
+  formatDelegationRationale,
+  resolveDelegationAdvisory,
+} from '@/lib/server/agents/delegation-advisory'
 
 const TAG = 'stream-agent-chat'
 
@@ -174,6 +183,7 @@ interface StreamAgentChatOpts {
   attachedFiles?: string[]
   apiKey: string | null
   systemPrompt?: string
+  executionBrief?: ExecutionBrief | null
   extraSystemContext?: string[]
   write: (data: string) => void
   history: Message[]
@@ -213,7 +223,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
-  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, executionBrief, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
   const isHeartbeat = isHeartbeatSource(opts.source)
   const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
   const isMinimalPrompt = promptMode === 'minimal'
@@ -221,7 +231,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const rawExtensions = getEnabledCapabilityIds(session)
   const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
   const extensionManager = getExtensionManager()
-  const sessionExtensions = expandExtensionIds([
+  const requestedExtensions = expandExtensionIds([
     ...rawExtensions,
     ...(hasShellCapability ? ['process'] : []),
   ]).filter((id) => !extensionManager.isExplicitlyDisabled(id))
@@ -249,10 +259,15 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Build agent prompt
   const settings = loadSettings()
+  const toolPolicy = resolveSessionToolPolicy(requestedExtensions, settings)
+  const blockedExtensionIds = new Set(expandExtensionIds(toolPolicy.blockedExtensions.map((entry) => entry.tool)))
+  const sessionExtensions = expandExtensionIds(toolPolicy.enabledExtensions)
+    .filter((id) => !blockedExtensionIds.has(id))
+    .filter((id) => !extensionManager.isExplicitlyDisabled(id))
   const requestedToolPreflightResponse = resolveRequestedToolPreflightResponse({
     message,
     enabledExtensions: sessionExtensions,
-    toolPolicy: resolveSessionToolPolicy(sessionExtensions, settings),
+    toolPolicy,
     appSettings: settings,
     internal: false,
     source: 'chat',
@@ -296,6 +311,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // -------------------------------------------------------------------------
   const promptParts: string[] = []
   const hasProvidedSystemPrompt = typeof systemPrompt === 'string' && systemPrompt.trim().length > 0
+  const hasCanonicalExecutionBrief = Boolean(executionBrief)
   const currentThreadRecallRequest = isCurrentThreadRecallRequest(message)
   const hasAttachmentContext = Boolean(
     imagePath
@@ -347,18 +363,37 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // Composable prompt sections — each builder returns string | null (or string[])
   const thinkingBlock = buildThinkingSection(agentThinkingLevel, isMinimalPrompt)
   if (thinkingBlock) promptParts.push(thinkingBlock)
+  const { rootSessionId } = resolveSessionLineageIds(session)
 
   // Async sections — run concurrently where possible
-  const [workspaceBlock, awarenessBlock, situationalBlock, extensionAuditBlock] = await Promise.all([
+  const [runtimeOrientationBlock, workspaceBlock, awarenessBlock, situationalBlock, extensionAuditBlock] = await Promise.all([
+    buildRuntimeOrientationSection({
+      session,
+      promptMode,
+      sessionExtensions,
+      toolPolicy,
+      agent: sessionAgent,
+      activeProjectContext,
+      rootSessionId,
+      isHeartbeat,
+      isConnectorSession,
+    }),
     !hasProvidedSystemPrompt ? buildWorkspaceSection(session, isMinimalPrompt, agentHeartbeatEnabled) : null,
     buildAgentAwarenessSection(session, sessionExtensions, isMinimalPrompt),
     buildSituationalSection(session, isMinimalPrompt),
     buildExtensionAccessAuditSection(sessionExtensions, agentMcpDisabledTools, isMinimalPrompt),
   ])
+  if (runtimeOrientationBlock) promptParts.push(runtimeOrientationBlock)
   if (workspaceBlock) promptParts.push(workspaceBlock)
   if (awarenessBlock) promptParts.push(awarenessBlock)
   if (situationalBlock) promptParts.push(situationalBlock)
 
+  // RunContext — structured working memory that survives compaction
+  if (!hasProvidedSystemPrompt && !hasCanonicalExecutionBrief) {
+    const runContextBlock = buildRunContextSection(session.runContext, isMinimalPrompt)
+    if (runContextBlock) promptParts.push(runContextBlock)
+  }
+
   // Extra system context — always included (caller-provided context is always relevant)
   if (Array.isArray(extraSystemContext)) {
     for (const block of extraSystemContext) {
@@ -393,6 +428,22 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Await classification before building the agentic execution policy
   const classification = await classificationPromise
+  const delegationAdvisory = sessionAgent && agentDelegationEnabled
+    ? resolveDelegationAdvisory({
+        currentAgent: sessionAgent,
+        agents: listAgents(),
+        profile: buildDelegationTaskProfile({ classification }),
+        delegationTargetMode: agentDelegationTargetMode,
+        delegationTargetAgentIds: agentDelegationTargetAgentIds,
+      })
+    : null
+  const delegationRecommendationBlock = !isMinimalPrompt
+    ? buildDelegationRecommendationSection({
+        agent: sessionAgent,
+        classification,
+      })
+    : null
+  if (delegationRecommendationBlock) promptParts.push(delegationRecommendationBlock)
 
   promptParts.push(
     buildAgenticExecutionPolicy({
@@ -813,7 +864,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // -------------------------------------------------------------------------
   const state = new ChatTurnState()
   const limits = new ContinuationLimits(isConnectorSession, isHeartbeat)
-  const routingDecision = routeTaskIntent(message, sessionExtensions, null)
+  const routingDecision = routeTaskIntent(message, sessionExtensions, null, classification)
   const explicitRequiredToolNames = getExplicitRequiredToolNames(message, sessionExtensions)
 
   const boundedExternalExecutionTask = classifiedHasTransactionalWalletIntent(classification, message)
@@ -1071,6 +1122,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
           likelyResearchSynthesisTask,
           abortControllerAborted: abortController.signal.aborted,
           classification,
+          delegationEnabled: agentDelegationEnabled,
+          delegationPreferenceActive: delegationAdvisory?.shouldDelegate === true,
         })
         shouldContinue = decision.type
         if (decision.requiredToolReminderNames.length > 0) {
@@ -1123,6 +1176,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         cwd: session.cwd,
         frequencyLimitedToolName,
         sessionExtensions,
+        isCoordinatorAgent,
+        recommendedDelegateName: delegationAdvisory?.recommended?.agentName || null,
+        delegationRationale: formatDelegationRationale(delegationAdvisory?.recommended),
       })
 
       if (continuationPrompt) {

package/src/lib/server/chat-execution/stream-continuation.test.ts

@@ -290,5 +290,41 @@ describe('stream-continuation', () => {
       assert.equal(typeof prompt, 'string')
       assert.ok(prompt!.includes('memory write'))
     })
+
+    it('renders a coordinator delegation nudge with the recommended delegate', () => {
+      const prompt = mod.buildContinuationPrompt({
+        type: 'coordinator_delegation_nudge',
+        message: 'test',
+        fullText: '',
+        toolEvents: [],
+        requiredToolReminderNames: [],
+        isCoordinatorAgent: true,
+        recommendedDelegateName: 'Builder',
+        delegationRationale: 'capability match: coding; worker role fits execution-heavy work',
+      })
+
+      assert.ok(prompt)
+      assert.ok(prompt!.includes('Builder'))
+      assert.ok(prompt!.includes('orchestrate'))
+      assert.ok(prompt!.includes('Reason: capability match: coding; worker role fits execution-heavy work.'))
+    })
+
+    it('renders an advisory delegation nudge for non-coordinator agents', () => {
+      const prompt = mod.buildContinuationPrompt({
+        type: 'coordinator_delegation_nudge',
+        message: 'test',
+        fullText: '',
+        toolEvents: [],
+        requiredToolReminderNames: [],
+        isCoordinatorAgent: false,
+        recommendedDelegateName: 'Reviewer',
+        delegationRationale: 'capability match: review; currently idle',
+      })
+
+      assert.ok(prompt)
+      assert.ok(prompt!.includes('materially better fit'))
+      assert.ok(prompt!.includes('Reviewer'))
+      assert.ok(prompt!.includes('reconnaissance, validation, or synthesis'))
+    })
   })
 })

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

@@ -8,7 +8,7 @@
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import type { MessageToolEvent } from '@/types'
+import type { Message, MessageToolEvent } from '@/types'
 import { extractSuggestions } from '@/lib/server/suggestions'
 import { isSuccessfulMemoryMutationToolEvent } from '@/lib/server/chat-execution/memory-mutation-tools'
 import type { MessageClassification } from '@/lib/server/chat-execution/message-classifier'
@@ -108,7 +108,7 @@ function looksLikeIncompleteDeliverableResponse(text: string): boolean {
 }
 
 function hasRecentDeliverableContext(
-  history: Array<{ role?: string; text?: string }> | undefined,
+  history: Message[] | undefined,
   userMessage: string,
 ): boolean {
   if (!Array.isArray(history) || history.length === 0) return false
@@ -116,7 +116,7 @@ function hasRecentDeliverableContext(
   if (!trimmed || trimmed.length > 160) return false
   return history
     .slice(-8)
-    .some((entry) => entry.role === 'user' && looksLikeOpenEndedDeliverableTask((entry.text || '').trim()))
+    .some((entry) => entry.role === 'user' && entry.semantics?.isDeliverableTask === true)
 }
 
 const ARTIFACT_PATH_EXT_RE = /\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|ts|tsx|js|jsx|mjs|cjs|py|sql|sh)$/i
@@ -245,7 +245,7 @@ export function shouldForceExternalExecutionFollowthrough(params: {
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification ? params.classification.walletIntent === 'transactional' : looksLikeBoundedExternalExecutionTask(params.userMessage)
+  const isTransactional = params.classification?.walletIntent === 'transactional'
   if (!isTransactional) return false
   if (!params.hasToolCalls || params.toolEvents.length < 4) return false
   if (hasStateChangingWalletEvidence(params.toolEvents)) return false
@@ -266,7 +266,7 @@ export function shouldForceExternalExecutionKickoffFollowthrough(params: {
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification ? params.classification.walletIntent === 'transactional' : looksLikeBoundedExternalExecutionTask(params.userMessage)
+  const isTransactional = params.classification?.walletIntent === 'transactional'
   if (!isTransactional) return false
   if (params.hasToolCalls || params.toolEvents.length > 0) return false
 
@@ -289,11 +289,11 @@ export function shouldForceDeliverableFollowthrough(params: {
   hasToolCalls: boolean
   toolEvents: MessageToolEvent[]
   cwd?: string
-  history?: Array<{ role?: string; text?: string }>
+  history?: Message[]
   classification?: MessageClassification | null
 }): boolean {
   const recentDeliverableContext = hasRecentDeliverableContext(params.history, params.userMessage)
-  const isDeliverable = params.classification ? params.classification.isDeliverableTask : looksLikeOpenEndedDeliverableTask(params.userMessage)
+  const isDeliverable = params.classification?.isDeliverableTask === true
   const deliverableIntent = isDeliverable || recentDeliverableContext
   const requestedArtifacts = getRequestedArtifactStatus({
     userMessage: params.userMessage,
@@ -744,6 +744,9 @@ export function buildContinuationPrompt(params: {
   cwd?: string
   frequencyLimitedToolName?: string
   sessionExtensions?: string[]
+  isCoordinatorAgent?: boolean
+  recommendedDelegateName?: string | null
+  delegationRationale?: string | null
 }): string | null {
   switch (params.type) {
     case 'memory_write_followthrough':
@@ -819,12 +822,24 @@ export function buildContinuationPrompt(params: {
       ].filter(Boolean).join('\n')
 
     case 'coordinator_delegation_nudge':
-      return [
-        'IMPORTANT: You have specialist workers available but you have been doing substantial work directly with tools.',
-        'You MUST delegate the remaining work via `spawn_subagent` to the appropriate specialist worker NOW.',
-        'As a coordinator, your job is to orchestrate — not to do the work yourself. Direct tool use is only for quick lookups and validation.',
-        'Review the workers listed in your system prompt and delegate immediately.',
-      ].join('\n')
+      return params.isCoordinatorAgent
+        ? [
+            'IMPORTANT: You have specialist workers available but you have been doing substantial work directly with tools.',
+            params.recommendedDelegateName
+              ? `Delegate the remaining execution via \`spawn_subagent\` to ${params.recommendedDelegateName} now.`
+              : 'You MUST delegate the remaining work via `spawn_subagent` to the appropriate specialist worker NOW.',
+            'As a coordinator, your job is to orchestrate — not to do the work yourself. Direct tool use is only for quick lookups and validation.',
+            params.delegationRationale ? `Reason: ${params.delegationRationale}.` : '',
+            'Review the workers listed in your system prompt and delegate immediately.',
+          ].filter(Boolean).join('\n')
+        : [
+            'You have delegation available and a teammate is a materially better fit for the remaining work.',
+            params.recommendedDelegateName
+              ? `Use \`spawn_subagent\` to hand the execution to ${params.recommendedDelegateName} now.`
+              : 'Use `spawn_subagent` to hand the execution to the best-fit teammate now.',
+            params.delegationRationale ? `Reason: ${params.delegationRationale}.` : '',
+            'Keep your direct tool use to reconnaissance, validation, or synthesis unless delegation is blocked.',
+          ].filter(Boolean).join('\n')
 
     case 'loop_recovery': {
       const freqTool = params.frequencyLimitedToolName

package/src/lib/server/chatrooms/chatroom-agent-signals.ts

@@ -1,5 +1,5 @@
 import type { Chatroom, Agent } from '@/types'
-import { loadChatrooms, saveChatrooms } from '@/lib/server/storage'
+import { patchChatroom } from '@/lib/server/chatrooms/chatroom-repository'
 import { notify } from '@/lib/server/ws-hub'
 
 /**
@@ -35,25 +35,33 @@ export function isImplicitlyMentioned(text: string, agent: Agent): boolean {
  * Useful for acknowledging tasks or agreeing with teammates.
  */
 export function addAgentReaction(chatroomId: string, messageId: string, agentId: string, emoji: string) {
-  const chatrooms = loadChatrooms()
-  const chatroom = chatrooms[chatroomId] as Chatroom | undefined
-  if (!chatroom) return
+  const updated = patchChatroom(chatroomId, (current) => {
+    const chatroom = current as Chatroom | null
+    if (!chatroom) return null
+    const message = chatroom.messages.find(m => m.id === messageId)
+    if (!message) return chatroom
+    if (message.reactions.some(r => r.reactorId === agentId && r.emoji === emoji)) return chatroom
 
-  const message = chatroom.messages.find(m => m.id === messageId)
-  if (!message) return
-
-  // Prevent duplicate reactions from the same agent
-  if (message.reactions.some(r => r.reactorId === agentId && r.emoji === emoji)) return
-
-  message.reactions.push({
-    emoji,
-    reactorId: agentId,
-    time: Date.now()
+    return {
+      ...chatroom,
+      messages: chatroom.messages.map((entry) => (
+        entry.id !== messageId
+          ? entry
+          : {
+              ...entry,
+              reactions: [
+                ...entry.reactions,
+                {
+                  emoji,
+                  reactorId: agentId,
+                  time: Date.now(),
+                },
+              ],
+            }
+      )),
+    }
   })
-
-  chatrooms[chatroomId] = chatroom
-  saveChatrooms(chatrooms)
-  notify(`chatroom:${chatroomId}`)
+  if (updated) notify(`chatroom:${chatroomId}`)
 }
 
 /**