@swarmclawai/swarmclaw 0.9.4 → 0.9.6

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

@@ -14,6 +14,7 @@ import {
   resolveFinalStreamResponseText,
   shouldSkipToolSummaryForShortResponse,
   shouldForceAttachmentFollowthrough,
+  shouldForceExternalExecutionKickoffFollowthrough,
   shouldForceRecoverableToolErrorFollowthrough,
   shouldTerminateOnSuccessfulMemoryMutation,
   shouldForceDeliverableFollowthrough,
@@ -193,6 +194,15 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(!streamAgentChatSource.includes('langchainMessages.push(new AIMessage({ content: fullText }))'))
   })
 
+  it('wires prompt-build hooks and pre-tool loop guards into the runtime path', () => {
+    assert.ok(streamAgentChatSource.includes('runBeforePromptBuild'))
+    assert.ok(streamAgentChatSource.includes('applyBeforePromptBuildResult'))
+    assert.ok(streamAgentChatSource.includes('beforeToolCall: ({ toolName, input }) =>'))
+    assert.ok(streamAgentChatSource.includes("phase: 'before_tool_call'"))
+    assert.ok(streamAgentChatSource.includes('loopTracker.preview(toolName, input)'))
+    assert.ok(streamAgentChatSource.includes('runId,'))
+  })
+
   it('forces early workspace-tool kickoff for explicit saved-artifact deliverables', () => {
     assert.ok(streamAgentChatSource.includes('shouldEnforceEarlyRequiredToolKickoff'))
     assert.ok(streamAgentChatSource.includes('REQUIRED_TOOL_KICKOFF_TIMEOUT_MS'))
@@ -200,6 +210,12 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(streamAgentChatSource.includes('did not start the required workspace tool step'))
   })
 
+  it('wires a bounded execution-kickoff continuation for intent-only live task replies', () => {
+    assert.ok(streamSources.includes('execution_kickoff_followthrough'))
+    assert.ok(streamAgentChatSource.includes('shouldForceExternalExecutionKickoffFollowthrough'))
+    assert.ok(streamAgentChatSource.includes('externalExecutionKickoff'))
+  })
+
   it('adds current-thread recall guidance and immediate memory routes in the system prompt', () => {
     assert.ok(streamAgentChatSource.includes('## Current Thread Recall'))
     assert.ok(streamAgentChatSource.includes('## Immediate Memory Routes'))
@@ -615,6 +631,41 @@ describe('shouldForceExternalExecutionFollowthrough', () => {
   })
 })
 
+describe('shouldForceExternalExecutionKickoffFollowthrough', () => {
+  it('forces a bounded continuation when an execution task stops at an intent-only kickoff', () => {
+    assert.equal(
+      shouldForceExternalExecutionKickoffFollowthrough({
+        userMessage: 'Try buy one NFT on Arbitrum and show me what happened.',
+        finalResponse: 'Let me try to interact directly with the NFT contract and see if I can mint one:',
+        hasToolCalls: false,
+        toolEvents: [],
+      }),
+      true,
+    )
+  })
+
+  it('does not force kickoff when the model already surfaced a real blocker or asked a blocking question', () => {
+    assert.equal(
+      shouldForceExternalExecutionKickoffFollowthrough({
+        userMessage: 'Try buy one NFT on Arbitrum and show me what happened.',
+        finalResponse: 'Exact blocker: this wallet cannot complete the required signature in the current runtime.',
+        hasToolCalls: false,
+        toolEvents: [],
+      }),
+      false,
+    )
+    assert.equal(
+      shouldForceExternalExecutionKickoffFollowthrough({
+        userMessage: 'Try buy one NFT on Arbitrum and show me what happened.',
+        finalResponse: 'Which collection do you want me to target?',
+        hasToolCalls: false,
+        toolEvents: [],
+      }),
+      false,
+    )
+  })
+})
+
 describe('shouldForceAttachmentFollowthrough', () => {
   it('forces a retry for attachment-backed research turns that still skipped tools', () => {
     assert.equal(

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

@@ -14,7 +14,7 @@ import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/serve
 import { logExecution } from '@/lib/server/execution-log'
 import { buildCurrentDateTimePromptContext } from '@/lib/server/prompt-runtime-context'
 import { canonicalizePluginId, expandPluginIds, pluginIdMatches } from '@/lib/server/tool-aliases'
-import type { Session, Message, UsageRecord, PluginInvocationRecord, MessageToolEvent } from '@/types'
+import type { Session, Message, UsageRecord, PluginInvocationRecord, MessageToolEvent, PluginPromptBuildResult } from '@/types'
 import { extractSuggestions } from '@/lib/server/suggestions'
 import { buildIdentityContinuityContext } from '@/lib/server/identity-continuity'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
@@ -38,6 +38,7 @@ import {
   looksLikeBoundedExternalExecutionTask,
   looksLikeOpenEndedDeliverableTask,
   shouldForceRecoverableToolErrorFollowthrough,
+  shouldForceExternalExecutionKickoffFollowthrough,
   shouldForceExternalExecutionFollowthrough,
   shouldForceDeliverableFollowthrough,
   hasStateChangingWalletEvidence,
@@ -88,6 +89,7 @@ export {
   getExplicitRequiredToolNames,
   isWalletSimulationResult,
   looksLikeOpenEndedDeliverableTask,
+  shouldForceExternalExecutionKickoffFollowthrough,
   shouldForceRecoverableToolErrorFollowthrough,
   shouldForceExternalExecutionFollowthrough,
   shouldForceDeliverableFollowthrough,
@@ -503,6 +505,32 @@ function buildCurrentThreadRecallBlock(history: Message[]): string {
   return lines.join('\n')
 }
 
+function joinPromptSegments(...segments: Array<string | null | undefined>): string {
+  return segments
+    .map((segment) => (typeof segment === 'string' ? segment.trim() : ''))
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+function applyBeforePromptBuildResult(
+  basePrompt: string,
+  hookResult: PluginPromptBuildResult | null | undefined,
+): string {
+  if (!hookResult) return basePrompt
+
+  const baseSystemPrompt = typeof hookResult.systemPrompt === 'string' && hookResult.systemPrompt.trim()
+    ? hookResult.systemPrompt.trim()
+    : basePrompt
+
+  const systemPromptWithContext = joinPromptSegments(
+    hookResult.prependSystemContext,
+    baseSystemPrompt,
+    hookResult.appendSystemContext,
+  ) || baseSystemPrompt
+
+  return joinPromptSegments(hookResult.prependContext, systemPromptWithContext) || systemPromptWithContext
+}
+
 export interface StreamAgentChatResult {
   /** All text accumulated across every LLM turn (for SSE / web UI history). */
   fullText: string
@@ -802,21 +830,13 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   }
 
   let prompt = promptParts.join('\n\n')
-
-  const endToolBuildPerf = perf.start('stream-agent-chat', 'buildSessionTools', { sessionId: session.id })
-  const { tools, cleanup, toolToPluginMap, abortSignalRef } = await buildSessionTools(session.cwd, sessionPlugins, {
-    agentId: session.agentId,
-    sessionId: session.id,
-    platformAssignScope: agentPlatformAssignScope,
-    mcpServerIds: agentMcpServerIds,
-    mcpDisabledTools: agentMcpDisabledTools,
-    projectId: activeProjectContext.projectId,
-    projectRoot: activeProjectContext.projectRoot,
-    projectName: activeProjectContext.project?.name || null,
-    projectDescription: activeProjectContext.project?.description || null,
-    memoryScopeMode: agentMemoryScopeMode,
+  const runId = `${session.id}:${startTs}`
+  const loopTracker = new ToolLoopTracker({
+    ...(typeof settings.toolLoopFrequencyWarn === 'number' && { toolFrequencyWarn: settings.toolLoopFrequencyWarn }),
+    ...(typeof settings.toolLoopFrequencyCritical === 'number' && { toolFrequencyCritical: settings.toolLoopFrequencyCritical }),
+    ...(typeof settings.toolLoopCircuitBreaker === 'number' && { circuitBreaker: settings.toolLoopCircuitBreaker }),
   })
-  endToolBuildPerf({ toolCount: tools.length })
+  const emittedPreToolWarnings = new Set<string>()
   const recursionLimit = getAgentLoopRecursionLimit(runtime)
 
   // Build message history for context
@@ -971,6 +991,43 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     // Context manager failure — continue with recent history
   }
 
+  const langchainMessages: Array<HumanMessage | AIMessage> = []
+  for (const m of effectiveHistory) {
+    if (m.role === 'user') {
+      const resolvedImg = resolveImagePath(m.imagePath, m.imageUrl)
+      langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, resolvedImg ?? undefined, m.attachedFiles) }))
+    } else {
+      langchainMessages.push(new AIMessage({ content: m.text }))
+    }
+  }
+
+  // Add current message
+  const currentContent = await buildLangChainContent(message, imagePath, attachedFiles)
+  langchainMessages.push(new HumanMessage({ content: currentContent }))
+
+  const pluginMgr = getPluginManager()
+  const promptHookResult = await pluginMgr.runBeforePromptBuild(
+    {
+      session,
+      prompt,
+      message,
+      history,
+      messages: [
+        ...effectiveHistory,
+        {
+          role: 'user',
+          text: message,
+          time: Date.now(),
+          ...(imagePath ? { imagePath } : {}),
+          ...(imageUrl ? { imageUrl } : {}),
+          ...(attachedFiles?.length ? { attachedFiles } : {}),
+        },
+      ],
+    },
+    { enabledIds: sessionPlugins },
+  )
+  prompt = applyBeforePromptBuildResult(prompt, promptHookResult)
+
   // Context degradation warning: prepend warning to system prompt when nearing limits
   try {
     const {
@@ -996,13 +1053,85 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       },
     )
     if (warning) {
-      promptParts.unshift(warning)
-      prompt = promptParts.join('\n\n')
+      prompt = joinPromptSegments(warning, prompt)
     }
   } catch {
     // Warning failure is non-critical
   }
 
+  await pluginMgr.runHook(
+    'llmInput',
+    {
+      session,
+      runId,
+      provider: session.provider,
+      model: session.model,
+      systemPrompt: prompt,
+      prompt: message,
+      historyMessages: effectiveHistory,
+      imagesCount: imagePath ? 1 : 0,
+    },
+    { enabledIds: sessionPlugins },
+  )
+
+  const endToolBuildPerf = perf.start('stream-agent-chat', 'buildSessionTools', { sessionId: session.id })
+  const { tools, cleanup, toolToPluginMap, abortSignalRef } = await buildSessionTools(session.cwd, sessionPlugins, {
+    agentId: session.agentId,
+    sessionId: session.id,
+    runId,
+    platformAssignScope: agentPlatformAssignScope,
+    mcpServerIds: agentMcpServerIds,
+    mcpDisabledTools: agentMcpDisabledTools,
+    projectId: activeProjectContext.projectId,
+    projectRoot: activeProjectContext.projectRoot,
+    projectName: activeProjectContext.project?.name || null,
+    projectDescription: activeProjectContext.project?.description || null,
+    memoryScopeMode: agentMemoryScopeMode,
+    beforeToolCall: ({ toolName, input }) => {
+      const preview = loopTracker.preview(toolName, input)
+      if (!preview) return undefined
+      const previewKey = `${preview.severity}:${preview.detector}:${toolName}`
+      if (preview.severity === 'warning' && emittedPreToolWarnings.has(previewKey)) {
+        return undefined
+      }
+      if (preview.severity === 'warning') emittedPreToolWarnings.add(previewKey)
+      logExecution(session.id, 'loop_detection', preview.message, {
+        agentId: session.agentId,
+        detail: {
+          detector: preview.detector,
+          severity: preview.severity,
+          toolName,
+          phase: 'before_tool_call',
+        },
+      })
+      if (preview.severity === 'critical') {
+        write(`data: ${JSON.stringify({
+          t: 'status',
+          text: JSON.stringify({
+            loopDetection: preview.detector,
+            severity: 'critical',
+            message: preview.message,
+            phase: 'before_tool_call',
+          }),
+        })}\n\n`)
+        return { blockReason: preview.message }
+      }
+      return { warning: preview.message }
+    },
+    onToolCallWarning: ({ toolName, message }) => {
+      write(`data: ${JSON.stringify({
+        t: 'status',
+        text: JSON.stringify({
+          toolWarning: toolName,
+          severity: 'warning',
+          message,
+          phase: 'before_tool_call',
+        }),
+      })}\n\n`)
+    },
+  })
+  endToolBuildPerf({ toolCount: tools.length })
+
   // Use a fresh in-memory checkpointer instead of the SQLite one.  We manage
   // conversation history externally via langchainMessages — each iteration
   // receives full history, so no cross-iteration checkpoint state is needed.
@@ -1015,20 +1144,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     prompt,
     checkpointer: new MemorySaver(),
   })
-
-  const langchainMessages: Array<HumanMessage | AIMessage> = []
-  for (const m of effectiveHistory) {
-    if (m.role === 'user') {
-      const resolvedImg = resolveImagePath(m.imagePath, m.imageUrl)
-      langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, resolvedImg ?? undefined, m.attachedFiles) }))
-    } else {
-      langchainMessages.push(new AIMessage({ content: m.text }))
-    }
-  }
-
-  // Add current message
-  const currentContent = await buildLangChainContent(message, imagePath, attachedFiles)
-  langchainMessages.push(new HumanMessage({ content: currentContent }))
   let pendingGraphMessages = [...langchainMessages]
 
   let fullText = ''
@@ -1047,7 +1162,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const likelyResearchSynthesisTask = routingDecision.intent === 'research' || routingDecision.intent === 'browsing'
 
   // Plugin hooks: beforeAgentStart
-  const pluginMgr = getPluginManager()
   await pluginMgr.runHook('beforeAgentStart', { session, message }, { enabledIds: sessionPlugins })
 
   const abortController = new AbortController()
@@ -1069,6 +1183,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const MAX_TRANSIENT_RETRIES = 3
   const MAX_REQUIRED_TOOL_CONTINUES = 2
   let MAX_EXECUTION_FOLLOWTHROUGHS = 1
+  const MAX_EXECUTION_KICKOFF_FOLLOWTHROUGHS = 1
   let MAX_ATTACHMENT_FOLLOWTHROUGHS = 1
   let MAX_DELIVERABLE_FOLLOWTHROUGHS = 2
   let MAX_UNFINISHED_TOOL_FOLLOWTHROUGHS = 2
@@ -1090,6 +1205,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   let pendingRetryAfterMs: number | null = null
   let requiredToolContinueCount = 0
   let executionFollowthroughCount = 0
+  let executionKickoffFollowthroughCount = 0
   let attachmentFollowthroughCount = 0
   let deliverableFollowthroughCount = 0
   let unfinishedToolFollowthroughCount = 0
@@ -1099,16 +1215,11 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const shouldEnforceEarlyRequiredToolKickoff = explicitRequiredToolNames.length > 0
     && looksLikeOpenEndedDeliverableTask(message)
   const usedToolNames = new Set<string>()
-  const loopTracker = new ToolLoopTracker({
-    ...(typeof settings.toolLoopFrequencyWarn === 'number' && { toolFrequencyWarn: settings.toolLoopFrequencyWarn }),
-    ...(typeof settings.toolLoopFrequencyCritical === 'number' && { toolFrequencyCritical: settings.toolLoopFrequencyCritical }),
-    ...(typeof settings.toolLoopCircuitBreaker === 'number' && { circuitBreaker: settings.toolLoopCircuitBreaker }),
-  })
   let loopDetectionTriggered: LoopDetectionResult | null = null
   let terminalToolResponse = ''
 
   try {
-  const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES + MAX_REQUIRED_TOOL_CONTINUES + MAX_EXECUTION_FOLLOWTHROUGHS + MAX_DELIVERABLE_FOLLOWTHROUGHS + MAX_UNFINISHED_TOOL_FOLLOWTHROUGHS + MAX_TOOL_ERROR_FOLLOWTHROUGHS + MAX_TOOL_SUMMARY_RETRIES
+  const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES + MAX_REQUIRED_TOOL_CONTINUES + MAX_EXECUTION_KICKOFF_FOLLOWTHROUGHS + MAX_EXECUTION_FOLLOWTHROUGHS + MAX_DELIVERABLE_FOLLOWTHROUGHS + MAX_UNFINISHED_TOOL_FOLLOWTHROUGHS + MAX_TOOL_ERROR_FOLLOWTHROUGHS + MAX_TOOL_SUMMARY_RETRIES
     for (let iteration = 0; iteration <= maxIterations; iteration++) {
       let shouldContinue: ContinuationType = false
       let requiredToolReminderNames: string[] = []
@@ -1659,6 +1770,31 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         })}\n\n`)
       }
 
+      if (!shouldContinue
+        && executionKickoffFollowthroughCount < MAX_EXECUTION_KICKOFF_FOLLOWTHROUGHS
+        && shouldForceExternalExecutionKickoffFollowthrough({
+          userMessage: message,
+          finalResponse: resolveFinalStreamResponseText({
+            fullText,
+            lastSegment,
+            lastSettledSegment,
+            hasToolCalls,
+            toolEvents: streamedToolEvents,
+          }),
+          hasToolCalls,
+          toolEvents: streamedToolEvents,
+        })) {
+        shouldContinue = 'execution_kickoff_followthrough'
+        executionKickoffFollowthroughCount++
+        write(`data: ${JSON.stringify({
+          t: 'status',
+          text: JSON.stringify({
+            externalExecutionKickoff: executionKickoffFollowthroughCount,
+            maxFollowthroughs: MAX_EXECUTION_KICKOFF_FOLLOWTHROUGHS,
+          }),
+        })}\n\n`)
+      }
+
       if (!shouldContinue
         && executionFollowthroughCount < MAX_EXECUTION_FOLLOWTHROUGHS
         && shouldForceExternalExecutionFollowthrough({
@@ -1852,6 +1988,30 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     if (signal) signal.removeEventListener('abort', abortFromSignal)
   }
 
+  const emitLlmOutputHook = async (response: string) => {
+    const total = totalInputTokens + totalOutputTokens
+    await pluginMgr.runHook(
+      'llmOutput',
+      {
+        session,
+        runId,
+        provider: session.provider,
+        model: session.model,
+        assistantTexts: response ? [response] : [],
+        response,
+        usage: total > 0
+          ? {
+              input: totalInputTokens,
+              output: totalOutputTokens,
+              total,
+              estimatedCost: estimateCost(session.model, totalInputTokens, totalOutputTokens),
+            }
+          : undefined,
+      },
+      { enabledIds: sessionPlugins },
+    )
+  }
+
   // Skip post-stream work if the client disconnected mid-stream
   if (signal?.aborted) {
     let finalResponse = resolveFinalStreamResponseText({
@@ -1878,6 +2038,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         finalResponse = forcedSummary
       }
     }
+    await emitLlmOutputHook(finalResponse)
     await cleanup()
     return { fullText, finalResponse }
   }
@@ -1957,6 +2118,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     }
   }
 
+  await emitLlmOutputHook(finalResponse)
+
   // Plugin hooks: afterAgentComplete
   await pluginMgr.runHook('afterAgentComplete', { session, response: fullText }, { enabledIds: sessionPlugins })
 

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

@@ -20,6 +20,7 @@ export type ContinuationType =
   | 'transient'
   | 'required_tool'
   | 'attachment_followthrough'
+  | 'execution_kickoff_followthrough'
   | 'execution_followthrough'
   | 'deliverable_followthrough'
   | 'unfinished_tool_followthrough'
@@ -237,6 +238,28 @@ export function shouldForceExternalExecutionFollowthrough(params: {
   return /(let me|i'll|i will|trying|research|query|check|look|promising|now let me|good -|good,)/i.test(trimmed) || trimmed.length < 500
 }
 
+export function shouldForceExternalExecutionKickoffFollowthrough(params: {
+  userMessage: string
+  finalResponse: string
+  hasToolCalls: boolean
+  toolEvents: MessageToolEvent[]
+}): boolean {
+  if (!looksLikeBoundedExternalExecutionTask(params.userMessage)) return false
+  if (params.hasToolCalls || params.toolEvents.length > 0) return false
+
+  const trimmed = params.finalResponse.trim()
+  if (!trimmed) return true
+  if (/^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i.test(trimmed)) return false
+  if (/\?\s*$/.test(trimmed)) return false
+  if (/\b(last reversible step|exact blocker|blocked|cannot|can't|missing capability|need approval|requires approval|approval boundary|requires human|ask_human|credential|authentication|login|2fa|mfa|captcha)\b/i.test(trimmed)) {
+    return false
+  }
+  if (/\b(done|completed|finished|sent|broadcast|minted|purchased|bought|swapped|claimed)\b/i.test(trimmed)) {
+    return false
+  }
+  return looksLikeIncompleteDeliverableResponse(trimmed) || trimmed.length < 220
+}
+
 export function shouldForceDeliverableFollowthrough(params: {
   userMessage: string
   finalResponse: string
@@ -360,6 +383,23 @@ function buildExternalExecutionFollowthroughPrompt(params: {
   ].join('\n')
 }
 
+function buildExternalExecutionKickoffPrompt(params: {
+  userMessage: string
+  fullText: string
+}): string {
+  return [
+    'The previous iteration stopped after an intent update before taking the first concrete execution step.',
+    'Do not send another preamble like "let me check", "I will try", or "I\'m going to".',
+    'Continue immediately from the same objective and take the first concrete reversible step now using the available tools.',
+    'If a real blocker appears before any safe action, state the exact blocker with evidence instead of narrating your plan.',
+    'Do not ask the user to repeat the task. Either act now or report the blocker.',
+    '',
+    `Objective:\n${params.userMessage}`,
+    '',
+    `Previous response:\n${params.fullText || '(none)'}`,
+  ].join('\n')
+}
+
 function buildDeliverableFollowthroughPrompt(params: {
   userMessage: string
   fullText: string
@@ -578,6 +618,12 @@ export function buildContinuationPrompt(params: {
         fullText: params.fullText,
       })
 
+    case 'execution_kickoff_followthrough':
+      return buildExternalExecutionKickoffPrompt({
+        userMessage: params.message,
+        fullText: params.fullText,
+      })
+
     case 'execution_followthrough':
       return buildExternalExecutionFollowthroughPrompt({
         userMessage: params.message,

package/src/lib/server/connectors/contact-boundaries.ts

@@ -23,10 +23,52 @@ function collectSenderIds(
   ].filter((value): value is string => typeof value === 'string' && value.trim().length > 0))
 }
 
+function normalizeFreeText(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, ' ')
+}
+
+function extractMemoryLabels(entry: MemoryEntry): string[] {
+  const content = String(entry.content || '').trim()
+  const firstLine = content.split('\n', 1)[0]?.trim() || ''
+  const prefix = firstLine.includes(':') ? firstLine.split(':', 1)[0]?.trim() || '' : firstLine
+  return dedup([
+    String(entry.title || '').trim(),
+    prefix,
+  ].filter((value) => value.length > 0))
+}
+
+function labelMatchesSenderName(label: string, senderName: string): boolean {
+  const normalizedLabel = normalizeFreeText(label)
+  const normalizedSenderName = normalizeFreeText(senderName)
+  if (!normalizedLabel || !normalizedSenderName) return false
+  if (normalizedLabel === normalizedSenderName) return true
+  if (!normalizedLabel.startsWith(normalizedSenderName)) return false
+  const suffix = normalizedLabel.slice(normalizedSenderName.length).trim()
+  if (!suffix) return true
+  return /^[\s,.:;()+\-_/0-9@]+$/.test(suffix)
+}
+
+function extractExplicitMemoryIdentifiers(entry: MemoryEntry): string[] {
+  const metadata = entry.metadata as Record<string, unknown> | undefined
+  const metadataIdentifiers = Array.isArray(metadata?.identifiers)
+    ? metadata.identifiers.filter((value): value is string => typeof value === 'string')
+    : []
+  const text = `${entry.title || ''}\n${entry.content || ''}`
+  const jidLikeIdentifiers = text.match(/[0-9a-z_.:+-]+@[0-9a-z_.:-]+/gi) || []
+  return dedup([
+    ...metadataIdentifiers,
+    ...jidLikeIdentifiers,
+  ].map((value) => value.trim().toLowerCase()).filter(Boolean))
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
 function memoryMatchesSender(entry: MemoryEntry, senderIds: string[], senderName: string): boolean {
   const title = String(entry.title || '').toLowerCase()
   const content = String(entry.content || '').toLowerCase()
-  const normalizedSenderName = senderName.trim().toLowerCase()
+  const normalizedSenderName = normalizeFreeText(senderName)
 
   for (const rawId of senderIds) {
     const lowered = rawId.toLowerCase()
@@ -42,6 +84,7 @@ function memoryMatchesSender(entry: MemoryEntry, senderIds: string[], senderName
         .map(toDigits)
       : []),
   ].filter((value) => value.length >= 6)
+  const explicitMemoryIdentifiers = extractExplicitMemoryIdentifiers(entry)
 
   for (const memoryDigit of memoryDigits) {
     for (const senderDigit of senderDigits) {
@@ -49,16 +92,34 @@ function memoryMatchesSender(entry: MemoryEntry, senderIds: string[], senderName
     }
   }
 
+  if (explicitMemoryIdentifiers.length > 0 || memoryDigits.length > 0) {
+    return false
+  }
+
   if (!normalizedSenderName) return false
-  return title.includes(normalizedSenderName) || content.includes(normalizedSenderName)
+  return extractMemoryLabels(entry).some((label) => labelMatchesSenderName(label, normalizedSenderName))
 }
 
-function memoryDefinesQuietBoundary(entry: MemoryEntry): boolean {
+function memoryDefinesQuietBoundary(
+  entry: MemoryEntry,
+  aliases: string[],
+): boolean {
+  const metadata = entry.metadata as Record<string, unknown> | undefined
+  if (metadata?.boundaryType === 'quiet_until_directly_addressed') return true
+  if (metadata?.directAddressRequired === true && metadata?.suppressReplies === true) return true
+
   const text = `${entry.title || ''}\n${entry.content || ''}`.toLowerCase()
   const boundaryRule = /\b(?:do not respond|do not reply|don't respond|don't reply|no replies|stay quiet|stay silent|remain quiet|be quiet)\b[\s\S]{0,140}\bunless\b/i
-  const directAddressRule = /\b(?:address(?:es|ed)?|mention(?:s|ed)?|refer(?:s|red)?|talk(?:ing)? to)\b[\s\S]{0,80}\bhal\b/i
-  const verifyRule = /\bverify whether\b[\s\S]{0,80}\b(?:wayde|hal)\b/i
-  return boundaryRule.test(text) && (directAddressRule.test(text) || verifyRule.test(text))
+  const aliasPattern = dedup(aliases.map((alias) => normalizeFreeText(alias)).filter(Boolean))
+    .map((alias) => escapeRegExp(alias))
+    .join('|')
+  const aliasTargetRule = aliasPattern
+    ? new RegExp(`\\b(?:address(?:es|ed)?|mention(?:s|ed)?|refer(?:s|red)?|talk(?:ing)? to)\\b[\\s\\S]{0,80}\\b(?:${aliasPattern})\\b`, 'i')
+    : null
+  const genericTargetRule = /\b(?:address(?:es|ed)?|mention(?:s|ed)?|refer(?:s|red)?|talk(?:ing)? to)\b[\s\S]{0,80}\b(?:you|the agent|assistant|bot)\b/i
+  const verifyRule = /\bverify whether\b[\s\S]{0,120}\b(?:message|reply|response|it)\b[\s\S]{0,80}\b(?:is for|is meant for|was intended for|is addressed to)\b[\s\S]{0,80}\b(?:you|the agent|assistant|bot)\b/i
+  const directAddressRule = (aliasTargetRule ? aliasTargetRule.test(text) : false) || genericTargetRule.test(text)
+  return boundaryRule.test(text) && (directAddressRule || verifyRule.test(text))
 }
 
 function buildDirectAddressAliases(agent: Partial<Agent> | null | undefined, connector: Partial<Connector> | null | undefined): string[] {
@@ -85,14 +146,15 @@ export function enforceSenderQuietBoundary(params: {
   if (senderIds.length === 0 && !senderName.trim()) return { suppress: false }
 
   const memDb = getMemoryDb()
+  const aliases = buildDirectAddressAliases(agent, connector)
   const memories = memDb.list(agent.id, 200).filter((entry) =>
     entry.category?.startsWith('identity/')
     && memoryMatchesSender(entry, senderIds, senderName),
   )
-  const matchedBoundary = memories.find(memoryDefinesQuietBoundary)
+  const matchedBoundary = memories.find((entry) => memoryDefinesQuietBoundary(entry, aliases))
   if (!matchedBoundary) return { suppress: false }
 
-  const explicitlyAddressed = textMentionsAlias(msg.text || '', buildDirectAddressAliases(agent, connector))
+  const explicitlyAddressed = textMentionsAlias(msg.text || '', aliases)
     || isReplyToLastOutbound(msg, session)
 
   return explicitlyAddressed