@swarmclawai/swarmclaw 1.0.8 → 1.0.9

package/README.md

@@ -17,12 +17,12 @@ Extension tutorial: https://swarmclaw.ai/docs/extension-tutorial
 
 ## Release Notes
 
-### v1.0.8 Highlights
+### v1.0.9 Highlights
 
-- **Learned skills and self-healing**: SwarmClaw now keeps agent-scoped learned skills and shadow revisions so repeated successes and repeated external integration failures can harden into reusable local behavior without silently mutating the shared skill library.
-- **Direct chat stability**: chat-origin runs now stop after the visible answer instead of enqueueing hidden follow-up loops, leaked control tokens such as `NO_MESSAGE` stay out of the user transcript, and repeated internal reruns no longer replace the reply the user already saw.
-- **OpenClaw and Ollama route hardening**: agent thread sessions now repair stale credential/endpoint resolution more aggressively, including Ollama Cloud vs local endpoint selection and OpenClaw gateway fallback behavior.
-- **Operator UX fixes**: new agents appear in the list immediately, gateway-disconnected chat CTAs now route to the current agent's settings instead of global settings, setup-wizard flicker after access-key login is gone, and screenshot-heavy tool runs no longer render duplicate previews in chat.
+- **Quieter chat and inbox replies**: chat-origin and connector turns now suppress more hidden control text, stop replaying connector-tool output as normal assistant prose, and avoid extra empty follow-up chatter after successful tool work.
+- **Sender-aware direct inbox replies**: direct connector sessions can honor stored sender display names and reply-medium preferences, including voice-note-first replies when the connector supports binary media and the agent has a configured voice.
+- **Cleaner connector delivery reconciliation**: connector delivery markers now track what was actually sent, response previews prefer the delivered transcript, and task/connector followups resolve local output files more reliably.
+- **Memory-write followthrough hardening**: successful memory store/update turns terminate more cleanly, which reduces unnecessary post-tool loops while still allowing a natural acknowledgement when the user needs one.
 
 ## What SwarmClaw Focuses On
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Self-hosted AI runtime for OpenClaw, delegation, autonomy, runtime skills, crypto wallets, and chat platform connectors.",
   "license": "MIT",
   "publishConfig": {

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

@@ -112,6 +112,10 @@ describe('shouldAutoRouteHeartbeatAlerts', () => {
     assert.equal(shouldAutoRouteHeartbeatAlerts({ deliveryMode: 'tool_only' }), false)
   })
 
+  it('returns false when deliveryMode is silent', () => {
+    assert.equal(shouldAutoRouteHeartbeatAlerts({ deliveryMode: 'silent' }), false)
+  })
+
   it('returns true for default deliveryMode with showAlerts true', () => {
     assert.equal(shouldAutoRouteHeartbeatAlerts({ showAlerts: true, deliveryMode: 'default' }), true)
   })
@@ -253,6 +257,17 @@ describe('hasPersistableAssistantPayload', () => {
     assert.equal(hasPersistableAssistantPayload('', '', [{ name: 'shell', input: 'ls' }]), true)
   })
 
+  it('returns false for successful memory-write tool events without visible text', () => {
+    assert.equal(
+      hasPersistableAssistantPayload('', '', [{
+        name: 'memory_store',
+        input: '{"title":"Siobhan contact"}',
+        output: 'Stored memory "Siobhan contact" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+      }]),
+      false,
+    )
+  })
+
   it('returns false for all-whitespace text, thinking, and empty events', () => {
     assert.equal(hasPersistableAssistantPayload('  ', '   ', []), false)
   })
@@ -284,6 +299,15 @@ describe('getPersistedAssistantText', () => {
     // buildToolEventAssistantSummary with empty array returns empty
     assert.equal(result, '')
   })
+
+  it('suppresses successful memory-write tool-only fallbacks', () => {
+    const result = getPersistedAssistantText('', [{
+      name: 'memory_store',
+      input: '{"title":"Siobhan contact"}',
+      output: 'Stored memory "Siobhan contact" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+    }])
+    assert.equal(result, '')
+  })
 })
 
 // ---------------------------------------------------------------------------

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

@@ -6,6 +6,7 @@ import { getUsageSpendSince } from '@/lib/server/storage'
 import { pluginIdMatches } from '@/lib/server/tool-aliases'
 import { buildToolEventAssistantSummary } from '@/lib/chat/tool-event-summary'
 import { looksLikePositiveConnectorDeliveryText } from '@/lib/server/chat-execution/chat-execution-connector-delivery'
+import { hasOnlySuccessfulMemoryMutationToolEvents } from '@/lib/server/chat-execution/memory-mutation-tools'
 import { getEnabledCapabilityIds } from '@/lib/capability-selection'
 
 export interface SessionWithTools {
@@ -33,10 +34,10 @@ export function shouldApplySessionFreshnessReset(source: string): boolean {
 
 export function shouldAutoRouteHeartbeatAlerts(config?: {
   showAlerts?: boolean
-  deliveryMode?: 'default' | 'tool_only'
+  deliveryMode?: 'default' | 'tool_only' | 'silent'
 } | null): boolean {
   if (config?.showAlerts === false) return false
-  return config?.deliveryMode !== 'tool_only'
+  return config?.deliveryMode !== 'tool_only' && config?.deliveryMode !== 'silent'
 }
 
 export function shouldPersistInboundUserMessage(internal: boolean, source: string): boolean {
@@ -257,12 +258,14 @@ export function shouldSuppressRedundantConnectorDeliveryFollowup(params: {
 }
 
 export function hasPersistableAssistantPayload(text: string, thinking: string, toolEvents: MessageToolEvent[]): boolean {
+  if (!text.trim() && !thinking.trim() && hasOnlySuccessfulMemoryMutationToolEvents(toolEvents)) return false
   return text.trim().length > 0 || thinking.trim().length > 0 || toolEvents.length > 0
 }
 
 export function getPersistedAssistantText(text: string, toolEvents: MessageToolEvent[]): string {
   const trimmed = text.trim()
   if (trimmed) return trimmed
+  if (hasOnlySuccessfulMemoryMutationToolEvents(toolEvents)) return ''
   return buildToolEventAssistantSummary(toolEvents)
 }
 

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

@@ -217,7 +217,7 @@ export interface ExecuteChatTurnInput {
     showAlerts: boolean
     target: string | null
     lightContext?: boolean
-    deliveryMode?: 'default' | 'tool_only'
+    deliveryMode?: 'default' | 'tool_only' | 'silent'
   }
   replyToId?: string
 }
@@ -1449,7 +1449,10 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     && !hideAssistantTranscript
     && hasPersistableAssistantPayload(persistedText, thinkingText, persistedToolEvents)
     && heartbeatClassification !== 'suppress'
-    && !(isHeartbeatRun && heartbeatConfig?.deliveryMode === 'tool_only' && !isDirectConnectorSession(session))
+    && !(isHeartbeatRun && (
+      heartbeatConfig?.deliveryMode === 'silent'
+      || (heartbeatConfig?.deliveryMode === 'tool_only' && !isDirectConnectorSession(session))
+    ))
 
   const normalizeResumeId = (value: unknown): string | null =>
     typeof value === 'string' && value.trim() ? value.trim() : null

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

@@ -4,6 +4,10 @@ import { extractSuggestions } from '@/lib/server/suggestions'
 import {
   looksLikeExternalWalletTask,
 } from '@/lib/server/chat-execution/stream-continuation'
+import {
+  resolveToolAction,
+  shouldTerminateOnSuccessfulMemoryMutation,
+} from '@/lib/server/chat-execution/memory-mutation-tools'
 
 const EXPLICIT_ARTIFACT_OUTPUT_RE = /\b(?:save|write|output|export|create|generate)\b[^.!?\n]{0,80}\b(?:to|as|at|in)\b[^.!?\n]{0,60}(\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|~\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|\.\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|[a-z0-9._/-]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)\b)/i
 
@@ -80,42 +84,6 @@ export function shouldForceExternalServiceSummary(params: {
   return /:$/.test(trimmed) || /(let me|i'll|i will|checking|verify|promising|look into|explore|access their interface)/i.test(trimmed) || trimmed.length < 240
 }
 
-export function resolveToolAction(input: unknown): string {
-  if (input && typeof input === 'object' && !Array.isArray(input)) {
-    const action = (input as Record<string, unknown>).action
-    return typeof action === 'string' ? action.trim().toLowerCase() : ''
-  }
-  if (typeof input !== 'string') return ''
-  const trimmed = input.trim()
-  if (!trimmed.startsWith('{')) return ''
-  try {
-    const parsed = JSON.parse(trimmed) as Record<string, unknown>
-    return typeof parsed.action === 'string' ? parsed.action.trim().toLowerCase() : ''
-  } catch {
-    return ''
-  }
-}
-
-export function shouldTerminateOnSuccessfulMemoryMutation(params: {
-  toolName: string
-  toolInput: unknown
-  toolOutput: string
-}): boolean {
-  const canonicalToolName = canonicalizePluginId(params.toolName) || params.toolName
-  if (canonicalToolName !== 'memory') return false
-  const exactToolName = String(params.toolName || '').trim().toLowerCase()
-  const action = exactToolName === 'memory_store'
-    ? 'store'
-    : exactToolName === 'memory_update'
-      ? 'update'
-      : resolveToolAction(params.toolInput)
-  if (action !== 'store' && action !== 'update') return false
-  const output = extractSuggestions(params.toolOutput || '').clean.trim()
-  if (!output || /^error[:\s]/i.test(output)) return false
-  if (!/^(stored|updated) memory\b/i.test(output)) return false
-  return /no further memory lookup is needed unless the user asked you to verify/i.test(output)
-}
-
 export type TerminalToolBoundary =
   | { kind: 'memory_write'; responseText?: string }
   | { kind: 'durable_wait' }
@@ -138,10 +106,8 @@ export function resolveSuccessfulTerminalToolBoundary(params: {
   toolOutput: string
 }): TerminalToolBoundary | null {
   if (shouldTerminateOnSuccessfulMemoryMutation(params)) {
-    const responseText = extractSuggestions(params.toolOutput || '').clean.trim()
     return {
       kind: 'memory_write',
-      responseText: responseText || undefined,
     }
   }
 

package/src/lib/server/chat-execution/memory-mutation-tools.ts

@@ -0,0 +1,53 @@
+import type { MessageToolEvent } from '@/types'
+import { canonicalizePluginId } from '@/lib/server/tool-aliases'
+import { extractSuggestions } from '@/lib/server/suggestions'
+
+export function resolveToolAction(input: unknown): string {
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    const action = (input as Record<string, unknown>).action
+    return typeof action === 'string' ? action.trim().toLowerCase() : ''
+  }
+  if (typeof input !== 'string') return ''
+  const trimmed = input.trim()
+  if (!trimmed.startsWith('{')) return ''
+  try {
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>
+    return typeof parsed.action === 'string' ? parsed.action.trim().toLowerCase() : ''
+  } catch {
+    return ''
+  }
+}
+
+export function shouldTerminateOnSuccessfulMemoryMutation(params: {
+  toolName: string
+  toolInput: unknown
+  toolOutput: string
+}): boolean {
+  const canonicalToolName = canonicalizePluginId(params.toolName) || params.toolName
+  if (canonicalToolName !== 'memory') return false
+  const exactToolName = String(params.toolName || '').trim().toLowerCase()
+  const action = exactToolName === 'memory_store'
+    ? 'store'
+    : exactToolName === 'memory_update'
+      ? 'update'
+      : resolveToolAction(params.toolInput)
+  if (action !== 'store' && action !== 'update') return false
+  const output = extractSuggestions(params.toolOutput || '').clean.trim()
+  if (!output || /^error[:\s]/i.test(output)) return false
+  if (!/^(stored|updated) memory\b/i.test(output)) return false
+  return /no further memory lookup is needed unless the user asked you to verify/i.test(output)
+}
+
+export function isSuccessfulMemoryMutationToolEvent(event: Pick<MessageToolEvent, 'name' | 'input' | 'output'> | null | undefined): boolean {
+  if (!event || typeof event.name !== 'string') return false
+  return shouldTerminateOnSuccessfulMemoryMutation({
+    toolName: event.name,
+    toolInput: event.input,
+    toolOutput: typeof event.output === 'string' ? event.output : '',
+  })
+}
+
+export function hasOnlySuccessfulMemoryMutationToolEvents(toolEvents: MessageToolEvent[] | undefined): boolean {
+  const events = Array.isArray(toolEvents) ? toolEvents : []
+  return events.length > 0 && events.every((event) => isSuccessfulMemoryMutationToolEvent(event))
+}

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

@@ -371,18 +371,22 @@ describe('resolveFinalStreamResponseText', () => {
     assert.equal(result, 'Simple direct answer.')
   })
 
-  it('falls back to the latest meaningful tool result when tool calls finished without prose', () => {
+  it('does not surface successful memory-write tool output when tool calls finished without prose', () => {
     const result = resolveFinalStreamResponseText({
       fullText: '',
       lastSegment: '',
       lastSettledSegment: '',
       hasToolCalls: true,
       toolEvents: [
-        { name: 'memory_tool', input: '', output: 'Stored memory "Project Kodiak details" (id: abc123).' } as MessageToolEvent,
+        {
+          name: 'memory_tool',
+          input: '{"action":"store","title":"Project Kodiak details"}',
+          output: 'Stored memory "Project Kodiak details" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+        } as MessageToolEvent,
       ],
     })
 
-    assert.equal(result, 'Stored memory "Project Kodiak details" (id: abc123).')
+    assert.equal(result, '')
   })
 
   it('surfaces a useful fallback from spawn_subagent JSON output', () => {
@@ -547,6 +551,17 @@ describe('shouldTerminateOnSuccessfulMemoryMutation', () => {
 })
 
 describe('resolveSuccessfulTerminalToolBoundary', () => {
+  it('treats successful memory writes as followthrough boundaries without surfacing raw tool text', () => {
+    assert.deepEqual(
+      resolveSuccessfulTerminalToolBoundary({
+        toolName: 'memory_store',
+        toolInput: { title: 'Brendon prefers to be called Jesus', value: 'Call him Jesus from now on.' },
+        toolOutput: 'Stored memory "Brendon prefers to be called Jesus" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+      }),
+      { kind: 'memory_write' },
+    )
+  })
+
   it('treats durable ask_human waits as terminal boundaries', () => {
     assert.deepEqual(
       resolveSuccessfulTerminalToolBoundary({

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

@@ -73,11 +73,14 @@ import {
   isWalletSimulationResult,
   pruneIncompleteToolEvents,
   resolveSuccessfulTerminalToolBoundary,
-  resolveToolAction,
   shouldForceExternalServiceSummary,
-  shouldTerminateOnSuccessfulMemoryMutation,
   updateStreamedToolEvents,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
+import {
+  hasOnlySuccessfulMemoryMutationToolEvents,
+  resolveToolAction,
+  shouldTerminateOnSuccessfulMemoryMutation,
+} from '@/lib/server/chat-execution/memory-mutation-tools'
 import { LangGraphToolEventTracker } from '@/lib/server/chat-execution/tool-event-tracker'
 
 // LangGraph's streamEvents leaves dangling internal promises when the for-await
@@ -383,6 +386,7 @@ function buildAgenticExecutionPolicy(opts: {
   heartbeatPrompt: string
   heartbeatIntervalSec: number
   allowSilentReplies?: boolean
+  isDirectConnectorSession?: boolean
   delegationEnabled?: boolean
   userMessage?: string
   history?: Message[]
@@ -422,6 +426,12 @@ function buildAgenticExecutionPolicy(opts: {
       'If the user asks about prior work, decisions, dates, people, preferences, or todos from earlier conversations, start with `memory_search`. Use `memory_get` only when you need one targeted follow-up read.',
       'Do not use `manage_tasks`, `manage_agents`, or `delegate` as a substitute for a direct memory write or recall step.',
     )
+    if (opts.isDirectConnectorSession) {
+      parts.push(
+        'For direct connector chats, when storing a standing sender preference such as preferred name or reply medium, include structured `metadata.connectorPreference` fields so runtime can reuse them without reparsing prose.',
+        'Use fields like `preferredDisplayName` and `preferredReplyMedium:"voice_note"` when they are relevant.',
+      )
+    }
   }
   if (hasTooling) {
     parts.push(
@@ -556,6 +566,8 @@ export interface StreamAgentChatResult {
   /** Text from only the final LLM turn — after the last tool call completed.
    *  Use this for connector delivery so intermediate planning text isn't sent. */
   finalResponse: string
+  /** Tool events emitted during the streamed run. */
+  toolEvents: MessageToolEvent[]
 }
 
 type LangChainContentPart =
@@ -823,6 +835,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       heartbeatPrompt,
       heartbeatIntervalSec,
       allowSilentReplies: isConnectorSession,
+      isDirectConnectorSession: isConnectorSession,
       delegationEnabled: agentDelegationEnabled,
       userMessage: message,
       history,
@@ -1208,6 +1221,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const MAX_AUTO_CONTINUES = 3
   const MAX_TRANSIENT_RETRIES = 3
   const MAX_REQUIRED_TOOL_CONTINUES = 2
+  const MAX_MEMORY_WRITE_FOLLOWTHROUGHS = 2
   let MAX_EXECUTION_FOLLOWTHROUGHS = 1
   const MAX_EXECUTION_KICKOFF_FOLLOWTHROUGHS = 1
   let MAX_ATTACHMENT_FOLLOWTHROUGHS = 1
@@ -1230,6 +1244,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   let transientRetryCount = 0
   let pendingRetryAfterMs: number | null = null
   let requiredToolContinueCount = 0
+  let memoryWriteFollowthroughCount = 0
   let executionFollowthroughCount = 0
   let executionKickoffFollowthroughCount = 0
   let attachmentFollowthroughCount = 0
@@ -1242,11 +1257,11 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     && looksLikeOpenEndedDeliverableTask(message)
   const usedToolNames = new Set<string>()
   let loopDetectionTriggered: LoopDetectionResult | null = null
-  let terminalToolBoundary: 'memory_write' | 'durable_wait' | 'context_compaction' | null = null
+  let terminalToolBoundary: 'durable_wait' | 'context_compaction' | null = null
   let terminalToolResponse = ''
 
   try {
-  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
+  const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES + MAX_REQUIRED_TOOL_CONTINUES + MAX_MEMORY_WRITE_FOLLOWTHROUGHS + 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[] = []
@@ -1526,21 +1541,39 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
               toolOutput: outputStr || '',
             })
             if (toolBoundary) {
-              terminalToolBoundary = toolBoundary.kind
-              terminalToolResponse = 'responseText' in toolBoundary ? (toolBoundary.responseText || '') : ''
-              if (terminalToolResponse) {
-                lastSegment = terminalToolResponse
-                lastSettledSegment = terminalToolResponse
+              if (toolBoundary.kind === 'memory_write') {
+                if (iterationText.trim() || fullText.trim()) {
+                  write(`data: ${JSON.stringify({ t: 'reset', text: '' })}\n\n`)
+                }
+                shouldContinue = 'memory_write_followthrough'
+                memoryWriteFollowthroughCount = Math.max(memoryWriteFollowthroughCount, 1)
+                fullText = ''
+                iterationText = ''
+                lastSegment = ''
+                lastSettledSegment = ''
+                needsTextSeparator = false
+                logExecution(session.id, 'decision', 'Successful memory write completed; requesting natural acknowledgement followthrough.', {
+                  agentId: session.agentId,
+                  detail: { toolName, action: resolveToolAction(event.data?.input) || null, boundary: toolBoundary.kind },
+                })
+                write(`data: ${JSON.stringify({
+                  t: 'status',
+                  text: JSON.stringify({ terminalToolResult: toolBoundary.kind }),
+                })}\n\n`)
+                break
+              } else {
+                terminalToolBoundary = toolBoundary.kind
+                terminalToolResponse = ''
+                logExecution(session.id, 'decision', `Terminal tool boundary reached: ${toolBoundary.kind}.`, {
+                  agentId: session.agentId,
+                  detail: { toolName, action: resolveToolAction(event.data?.input) || null, boundary: toolBoundary.kind },
+                })
+                write(`data: ${JSON.stringify({
+                  t: 'status',
+                  text: JSON.stringify({ terminalToolResult: toolBoundary.kind }),
+                })}\n\n`)
+                break
               }
-              logExecution(session.id, 'decision', `Terminal tool boundary reached: ${toolBoundary.kind}.`, {
-                agentId: session.agentId,
-                detail: { toolName, action: resolveToolAction(event.data?.input) || null, boundary: toolBoundary.kind },
-              })
-              write(`data: ${JSON.stringify({
-                t: 'status',
-                text: JSON.stringify({ terminalToolResult: toolBoundary.kind }),
-              })}\n\n`)
-              break
             }
             if (boundedExternalExecutionTask && getWalletApprovalBoundaryAction(outputStr || '')) {
               reachedExecutionBoundary = true
@@ -1785,6 +1818,23 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         }
       }
 
+      if (!shouldContinue
+        && !fullText.trim()
+        && hasOnlySuccessfulMemoryMutationToolEvents(streamedToolEvents)
+        && memoryWriteFollowthroughCount < MAX_MEMORY_WRITE_FOLLOWTHROUGHS
+      ) {
+        shouldContinue = 'memory_write_followthrough'
+        memoryWriteFollowthroughCount++
+        write(`data: ${JSON.stringify({
+          t: 'status',
+          text: JSON.stringify({
+            memoryWriteFollowthrough: memoryWriteFollowthroughCount,
+            maxFollowthroughs: MAX_MEMORY_WRITE_FOLLOWTHROUGHS,
+            reason: 'empty_reply_after_memory_write',
+          }),
+        })}\n\n`)
+      }
+
       if (!shouldContinue
         && attachmentFollowthroughCount < MAX_ATTACHMENT_FOLLOWTHROUGHS
         && shouldForceAttachmentFollowthrough({
@@ -1959,10 +2009,12 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
       if (!shouldContinue) break
 
-      const continuationAssistantText = resolveContinuationAssistantText({
-        iterationText,
-        lastSegment,
-      })
+      const continuationAssistantText = shouldContinue === 'memory_write_followthrough'
+        ? ''
+        : resolveContinuationAssistantText({
+            iterationText,
+            lastSegment,
+          })
 
       const continuationPrompt = buildContinuationPrompt({
         type: shouldContinue,
@@ -2074,7 +2126,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     }
     await emitLlmOutputHook(finalResponse)
     await cleanup()
-    return { fullText, finalResponse }
+    return { fullText, finalResponse, toolEvents: streamedToolEvents }
   }
 
   // Extract LLM-generated suggestions from the response and strip the tag
@@ -2168,5 +2220,5 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // Clean up browser and other session resources
   await cleanup()
 
-  return { fullText, finalResponse }
+  return { fullText, finalResponse, toolEvents: streamedToolEvents }
 }

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

@@ -10,12 +10,14 @@ import os from 'node:os'
 import path from 'node:path'
 import type { MessageToolEvent } from '@/types'
 import { extractSuggestions } from '@/lib/server/suggestions'
+import { isSuccessfulMemoryMutationToolEvent } from '@/lib/server/chat-execution/memory-mutation-tools'
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
 export type ContinuationType =
+  | 'memory_write_followthrough'
   | 'recursion'
   | 'transient'
   | 'required_tool'
@@ -584,6 +586,17 @@ function buildRequiredToolPrompt(params: {
   return `You have not yet completed the required explicit tool step(s): ${params.requiredToolReminderNames.join(', ')}. Use those enabled tools now before declaring success. Do not replace ask_human with a plain-text request, do not replace outbound delivery tools with prose, and do not replace screenshot requests with text-only summaries.`
 }
 
+function buildMemoryWriteFollowthroughPrompt(): string {
+  return [
+    'The memory write already succeeded.',
+    'Do not repeat the raw tool output, memory ID, category, or any "stored memory" wording.',
+    'Do not call another memory, web, or history tool unless the user explicitly asked you to verify.',
+    'Do not answer with NO_MESSAGE or HEARTBEAT_OK.',
+    'Reply naturally in one short sentence that acknowledges what changed.',
+    'If the stored memory was a name, nickname, or reply-medium preference, immediately use that preference in the acknowledgement itself.',
+  ].join('\n')
+}
+
 // ---------------------------------------------------------------------------
 // buildContinuationPrompt — unified prompt builder for all continuation types
 // ---------------------------------------------------------------------------
@@ -601,6 +614,9 @@ export function buildContinuationPrompt(params: {
   cwd?: string
 }): string | null {
   switch (params.type) {
+    case 'memory_write_followthrough':
+      return buildMemoryWriteFollowthroughPrompt()
+
     case 'recursion':
       return 'Continue where you left off. Complete the remaining steps of the objective.'
 
@@ -674,6 +690,7 @@ function resolveToolOnlyFinalResponse(toolEvents: MessageToolEvent[] | undefined
   const events = Array.isArray(toolEvents) ? toolEvents : []
   for (let index = events.length - 1; index >= 0; index--) {
     const event = events[index]
+    if (isSuccessfulMemoryMutationToolEvent(event)) continue
     const output = typeof event?.output === 'string'
       ? extractSuggestions(event.output).clean.trim()
       : ''

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

@@ -0,0 +1,118 @@
+import type { Agent, MemoryEntry, Session } from '@/types'
+import { dedup } from '@/lib/shared-utils'
+import { getMemoryDb } from '@/lib/server/memory/memory-db'
+import type { InboundMessage } from './types'
+
+const SENDER_PREFERENCE_CATEGORIES = new Set([
+  'identity/preferences',
+  'identity/contacts',
+  'identity/relationships',
+])
+
+function summaryForPrompt(entry: MemoryEntry): string {
+  const title = String(entry.title || '').trim()
+  const firstLine = String(entry.content || '').split('\n').find((line) => line.trim())?.trim() || ''
+  const summary = [title, firstLine].filter(Boolean).join(': ')
+  if (!summary) return ''
+  return summary.length > 220 ? `${summary.slice(0, 217)}...` : summary
+}
+
+function connectorPreferenceMetadata(entry: MemoryEntry): Record<string, unknown> | null {
+  const metadata = entry.metadata as Record<string, unknown> | undefined
+  const direct = metadata?.connectorPreference
+  if (direct && typeof direct === 'object' && !Array.isArray(direct)) {
+    return direct as Record<string, unknown>
+  }
+  return metadata && typeof metadata === 'object' && !Array.isArray(metadata)
+    ? metadata
+    : null
+}
+
+function preferredDisplayNameFromMetadata(entry: MemoryEntry): string | null {
+  const metadata = connectorPreferenceMetadata(entry)
+  const value = typeof metadata?.preferredDisplayName === 'string' ? metadata.preferredDisplayName.trim() : ''
+  return value || null
+}
+
+function preferredReplyMediumFromMetadata(entry: MemoryEntry): 'voice_note' | null {
+  const metadata = connectorPreferenceMetadata(entry)
+  return metadata?.preferredReplyMedium === 'voice_note' ? 'voice_note' : null
+}
+
+function listSenderPreferenceMemories(params: {
+  agent?: Partial<Agent> | null
+  session?: Partial<Session> | null
+}): MemoryEntry[] {
+  const agentId = typeof params.agent?.id === 'string' ? params.agent.id.trim() : ''
+  const sessionId = typeof params.session?.id === 'string' ? params.session.id.trim() : ''
+  if (!agentId || !sessionId) return []
+  const memDb = getMemoryDb()
+  return memDb.list(agentId, 250)
+    .filter((entry) => entry.sessionId === sessionId)
+    .filter((entry) => SENDER_PREFERENCE_CATEGORIES.has(String(entry.category || '').trim()))
+    .sort((a, b) => (a.updatedAt || a.createdAt || 0) - (b.updatedAt || b.createdAt || 0))
+}
+
+export interface ResolvedSenderPreferencePolicy {
+  preferredDisplayName: string | null
+  preferredReplyMedium: 'voice_note' | null
+  styleInstructions: string[]
+}
+
+export function resolveSenderPreferencePolicy(params: {
+  agent?: Partial<Agent> | null
+  session?: Partial<Session> | null
+  msg: InboundMessage
+}): ResolvedSenderPreferencePolicy {
+  if (params.msg.isGroup) {
+    return {
+      preferredDisplayName: null,
+      preferredReplyMedium: null,
+      styleInstructions: [],
+    }
+  }
+
+  const memories = listSenderPreferenceMemories(params)
+  let preferredDisplayName: string | null = null
+  let preferredReplyMedium: 'voice_note' | null = null
+  const styleInstructions: string[] = []
+
+  for (const entry of memories) {
+    const displayName = preferredDisplayNameFromMetadata(entry)
+    if (displayName) preferredDisplayName = displayName
+
+    const replyMedium = preferredReplyMediumFromMetadata(entry)
+    if (replyMedium) preferredReplyMedium = replyMedium
+
+    const summary = summaryForPrompt(entry)
+    if (summary) styleInstructions.push(summary)
+  }
+
+  return {
+    preferredDisplayName,
+    preferredReplyMedium,
+    styleInstructions: dedup(styleInstructions).slice(-4),
+  }
+}
+
+export function buildSenderPreferenceContextBlock(
+  policy: ResolvedSenderPreferencePolicy,
+  senderLabel: string,
+): string {
+  const lines: string[] = []
+  if (policy.preferredDisplayName) {
+    lines.push(`- Address this sender as "${policy.preferredDisplayName}".`)
+  }
+  if (policy.preferredReplyMedium === 'voice_note') {
+    lines.push('- Reply with a voice note in this direct chat unless one has already been sent this turn.')
+  }
+  for (const instruction of policy.styleInstructions) {
+    lines.push(`- ${instruction}`)
+  }
+  if (lines.length === 0) return ''
+  return [
+    '## Sender Preferences',
+    `These stored preferences apply to the current sender "${senderLabel}":`,
+    ...lines,
+  ].join('\n')
+}