@swarmclawai/swarmclaw 0.8.0 → 0.8.2

package/src/lib/server/storage.ts

@@ -8,7 +8,7 @@ import Database from 'better-sqlite3'
 import { DATA_DIR, IS_BUILD_BOOTSTRAP, WORKSPACE_DIR } from './data-dir'
 import { normalizeHeartbeatSettingFields } from '@/lib/heartbeat-defaults'
 import { normalizeRuntimeSettingFields } from '@/lib/runtime-loop'
-import type { ExternalAgentRuntime, GatewayProfile, Message } from '@/types'
+import type { AppNotification, ExternalAgentRuntime, GatewayProfile, Message } from '@/types'
 export const UPLOAD_DIR = path.join(DATA_DIR, 'uploads')
 
 // --- LRU Cache ---
@@ -1175,6 +1175,19 @@ export function deleteNotification(id: string) {
   deleteCollectionItem('notifications', id)
 }
 
+export function findNotificationByDedupKey(dedupKey: string): AppNotification | null {
+  const raw = getCollectionRawCache('notifications')
+  for (const json of raw.values()) {
+    try {
+      const notification = JSON.parse(json) as AppNotification
+      if (notification.dedupKey === dedupKey) return notification
+    } catch {
+      // ignore malformed
+    }
+  }
+  return null
+}
+
 export function hasUnreadNotificationWithKey(dedupKey: string): boolean {
   const raw = getCollectionRawCache('notifications')
   for (const json of raw.values()) {

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

@@ -7,10 +7,13 @@ import {
   buildExternalWalletExecutionBlock,
   buildToolDisciplineLines,
   getExplicitRequiredToolNames,
+  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   looksLikeOpenEndedDeliverableTask,
   resolveContinuationAssistantText,
   resolveFinalStreamResponseText,
+  shouldAllowToolForDirectMemoryWrite,
+  shouldAllowToolForCurrentThreadRecall,
   shouldTerminateOnSuccessfulMemoryMutation,
   shouldForceDeliverableFollowthrough,
   shouldForceExternalExecutionFollowthrough,
@@ -37,6 +40,8 @@ describe('buildToolDisciplineLines', () => {
     const lines = buildToolDisciplineLines(['files'])
 
     assert.ok(lines.some((line) => line.includes('{"action":"read","filePath":"path/to/file.md"}')))
+    assert.ok(lines.some((line) => line.includes('exactly N bullet points')))
+    assert.ok(lines.some((line) => line.includes('Lower-priority logistics belong in FYI')))
   })
 
   it('adds schedule reuse and stop guidance when schedule tools are enabled', () => {
@@ -63,6 +68,7 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(lines.some((line) => line.includes('{"action":"send","to":"user@example.com","subject":"...","body":"..."}')))
     assert.ok(lines.some((line) => line.includes('do not guess or keep re-submitting blank forms')))
     assert.ok(lines.some((line) => line.includes('store it with `manage_secrets`') && line.includes('do not echo the raw value')))
+    assert.ok(lines.some((line) => line.includes('Use `manage_secrets` only for sensitive credentials or tokens')))
   })
 
   it('adds bounded execution guidance for wallet-connected external-service tasks', () => {
@@ -71,6 +77,7 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(lines.some((line) => line.includes('inspect the available wallet first with `wallet_tool`')))
     assert.ok(lines.some((line) => line.includes('use a bounded loop') && line.includes('Do not keep browsing once the blocker is clear')))
     assert.ok(lines.some((line) => line.includes('do not shop across venues indefinitely')))
+    assert.ok(lines.some((line) => line.includes('If a direct tool for the job is already enabled in this session, call that tool immediately')))
   })
 
   it('tells agents to stay local when coding tools are already available', () => {
@@ -126,6 +133,57 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(!streamAgentChatSource.includes('langchainMessages.push(new AIMessage({ content: fullText }))'))
   })
 
+  it('adds a dedicated current-thread recall block and removes long-term memory tools for those turns', () => {
+    assert.ok(streamAgentChatSource.includes('## Current Thread Recall'))
+    assert.ok(streamAgentChatSource.includes('## Immediate Memory Routes'))
+    assert.ok(streamAgentChatSource.includes('## Direct Memory Write'))
+    assert.ok(streamAgentChatSource.includes('call `memory_store` or `memory_update` immediately before any planning, delegation, task creation, or agent management'))
+    assert.ok(streamAgentChatSource.includes('Do not inspect skills, browse the workspace, request capabilities, manage tasks, manage agents, or delegate before the direct memory write is complete.'))
+    assert.ok(streamAgentChatSource.includes('Do NOT call memory tools, web search, or session-history tools'))
+    assert.ok(streamAgentChatSource.includes('const currentThreadRecallRequest = !directMemoryWriteOnlyTurn && isCurrentThreadRecallRequest(message)'))
+    assert.ok(streamAgentChatSource.includes('const directMemoryWriteOnlyTurn = isNarrowDirectMemoryWriteTurn(message)'))
+    assert.ok(streamAgentChatSource.includes('shouldAllowToolForDirectMemoryWrite(toolName)'))
+    assert.ok(streamAgentChatSource.includes('shouldAllowToolForCurrentThreadRecall(toolName)'))
+    assert.ok(streamAgentChatSource.includes('Preserve hard structural constraints from the original request'))
+    assert.ok(streamAgentChatSource.includes('## Exact Structural Constraints'))
+  })
+
+  it('blocks memory, session-history, web, and context tools during same-thread recall turns', () => {
+    assert.equal(shouldAllowToolForCurrentThreadRecall('memory_tool'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('memory_search'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('memory_get'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('memory_store'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('memory_update'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('search_history_tool'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('sessions_tool'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('web_search'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('context_status'), false)
+    assert.equal(shouldAllowToolForCurrentThreadRecall('files'), true)
+  })
+
+  it('only allows direct memory write tools during pure remember/store turns', () => {
+    assert.equal(shouldAllowToolForDirectMemoryWrite('memory_store'), true)
+    assert.equal(shouldAllowToolForDirectMemoryWrite('memory_update'), true)
+    assert.equal(shouldAllowToolForDirectMemoryWrite('memory_tool'), false)
+    assert.equal(shouldAllowToolForDirectMemoryWrite('manage_capabilities'), false)
+    assert.equal(shouldAllowToolForDirectMemoryWrite('files'), false)
+  })
+
+  it('treats long remember-and-confirm turns as narrow direct memory writes', () => {
+    assert.equal(
+      isNarrowDirectMemoryWriteTurn('Remember that my favorite programming language is Rust and I prefer functional programming patterns. Then confirm what you just stored.'),
+      true,
+    )
+    assert.equal(
+      isNarrowDirectMemoryWriteTurn('Remember these facts for future conversations: My favorite programming language is Rust. My deploy target is Fly.io. My team size is 7 people. The project is codenamed "Neptune".'),
+      true,
+    )
+    assert.equal(
+      isNarrowDirectMemoryWriteTurn('Remember that my favorite programming language is Rust, then write a file summarizing it and send it to me.'),
+      false,
+    )
+  })
+
   it('canonicalizes required tool names when checking completion', () => {
     // The requiredToolsPending filter must canonicalize tool names so that
     // alias names (e.g. ask_human) match canonical names from LangGraph events.
@@ -256,7 +314,7 @@ describe('resolveContinuationAssistantText', () => {
   })
 
   it('rolls back partial iteration text before transient retries restart the turn', () => {
-    assert.ok(streamAgentChatSource.includes('const iterationStartState = {'))
+    assert.ok(streamAgentChatSource.includes('const iterationStartState:'))
     assert.ok(streamAgentChatSource.includes('fullText = iterationStartState.fullText'))
     assert.ok(streamAgentChatSource.includes('lastSegment = iterationStartState.lastSegment'))
     assert.ok(streamAgentChatSource.includes('lastSettledSegment = iterationStartState.lastSettledSegment'))
@@ -276,6 +334,25 @@ describe('shouldTerminateOnSuccessfulMemoryMutation', () => {
     )
   })
 
+  it('treats successful narrow memory write tools as terminal', () => {
+    assert.equal(
+      shouldTerminateOnSuccessfulMemoryMutation({
+        toolName: 'memory_store',
+        toolInput: { title: 'Project Kodiak details', value: 'freeze date April 18, 2026' },
+        toolOutput: 'Stored memory "Project Kodiak details" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+      }),
+      true,
+    )
+    assert.equal(
+      shouldTerminateOnSuccessfulMemoryMutation({
+        toolName: 'memory_update',
+        toolInput: { id: 'abc123', value: 'freeze date April 21, 2026' },
+        toolOutput: 'Updated memory "Project Kodiak details" (id: abc123). No further memory lookup is needed unless the user asked you to verify.',
+      }),
+      true,
+    )
+  })
+
   it('parses JSON tool input and accepts canonical update results', () => {
     assert.equal(
       shouldTerminateOnSuccessfulMemoryMutation({

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

@@ -26,6 +26,7 @@ import {
 } from './tool-planning'
 import { ToolLoopTracker } from './tool-loop-detection'
 import type { LoopDetectionResult } from './tool-loop-detection'
+import { isCurrentThreadRecallRequest, isDirectMemoryWriteRequest } from './memory-policy'
 
 /** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
 interface StreamAgentChatOpts {
@@ -125,6 +126,16 @@ export function buildToolDisciplineLines(enabledPlugins: string[]): string[] {
 
   if (uniqueTools.includes('manage_secrets')) {
     lines.push('When a workflow reveals a password, app password, API key, recovery token, or other secret, store it with `manage_secrets` and do not echo the raw value in assistant text. Refer to the secret by name, service, or secret id instead.')
+    lines.push('Use `manage_secrets` only for sensitive credentials or tokens. Do not use it for normal memory, user preferences, durable facts, or project notes.')
+  }
+
+  if (uniqueTools.includes('manage_capabilities')) {
+    lines.push('Use `manage_capabilities` only when a needed tool is actually unavailable. If a direct tool for the job is already enabled in this session, call that tool immediately instead of requesting access or re-running discovery.')
+  }
+
+  if (uniqueTools.includes('files') || uniqueTools.includes('edit_file')) {
+    lines.push('When the user specifies exact counts or exact section titles for file content, treat those as hard constraints. If a file must have exactly N bullet points, keep the total bullet count at N and put extra required detail into short prose under titled sections unless the user explicitly asked for more bullets.')
+    lines.push('When summarizing or restructuring a source document into named sections, make sure each top-level source section is represented somewhere in the output. Lower-priority logistics belong in FYI rather than being dropped.')
   }
 
   if (uniqueTools.includes('delegate') && (uniqueTools.includes('shell') || uniqueTools.includes('files') || uniqueTools.includes('edit_file'))) {
@@ -271,7 +282,12 @@ export function shouldTerminateOnSuccessfulMemoryMutation(params: {
 }): boolean {
   const canonicalToolName = canonicalizePluginId(params.toolName) || params.toolName
   if (canonicalToolName !== 'memory') return false
-  const action = resolveToolAction(params.toolInput)
+  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
@@ -386,9 +402,20 @@ export function shouldForceDeliverableFollowthrough(params: {
   // If the user asked for file output but no file-write tool was used, force continuation
   const userNormalized = params.userMessage.toLowerCase()
   if (/\b(save|write|output)\b[^.!?\n]{0,60}\b(to|as)\b[^.!?\n]{0,40}(\/|~\/|\.[a-z]{2,5}\b)/.test(userNormalized)) {
-    const fileToolNames = ['write_file', 'edit_file', 'files', 'shell', 'execute_command']
-    const usedFileTools = params.toolEvents.some((e) => e.name && fileToolNames.includes(e.name))
-    if (!usedFileTools) return true
+    // Check if a file-writing tool was actually used (not just file-reading).
+    // The `files` tool with action: 'read' or 'list' doesn't count as writing.
+    const usedFileWriteTools = params.toolEvents.some((e) => {
+      if (!e.name) return false
+      if (['write_file', 'edit_file'].includes(e.name)) return true
+      if (e.name === 'shell' || e.name === 'execute_command') return true
+      if (e.name === 'files') {
+        // Only count as a write if the tool input specifies action: "write"
+        const input = e.input || ''
+        return /"action"\s*:\s*"write"/i.test(input)
+      }
+      return false
+    })
+    if (!usedFileWriteTools) return true
   }
   if (looksLikeIncompleteDeliverableResponse(trimmed)) return true
   return trimmed.length < 120 && params.toolEvents.length >= 3
@@ -496,19 +523,51 @@ function buildDeliverableFollowthroughPrompt(params: {
   fullText: string
   toolEvents: MessageToolEvent[]
 }): string {
-  return [
+  const lines = [
     'You are in the middle of a multi-step deliverable and stopped after only a partial batch of work.',
     'Continue from the existing workspace and artifacts. Do not restart from scratch and do not ask the user to restate the request.',
     'Do not stop after one partial batch. Finish every requested deliverable that is still outstanding before concluding.',
     'If a requested artifact cannot be produced, say exactly which artifact is missing, what blocked it, and what you already completed.',
     'Use the existing files, screenshots, and generated outputs first. Inspect them if needed, then complete the remaining work.',
+    'Preserve hard structural constraints from the original request: exact counts stay exact, required titled sections stay present, and source coverage gaps should be filled instead of skipped.',
     'End with a concise grouped completion summary that lists exact file paths, upload URLs, localhost URLs/ports, and screenshots you produced.',
+  ]
+
+  // If the user explicitly asked for file output, remind the model to use file tools
+  const userNormalized = params.userMessage.toLowerCase()
+  const fileOutputMatch = userNormalized.match(/\b(?:save|write|output|export)\b[^.!?\n]{0,80}\b(?:to|as|at|in)\b[^.!?\n]{0,60}(\/[^\s,'"]+|~\/[^\s,'"]+|\.\/[^\s,'"]+)/i)
+  if (fileOutputMatch) {
+    const fileToolNames = ['write_file', 'edit_file', 'files', 'shell', 'execute_command']
+    const usedFileTools = params.toolEvents.some((e) => e.name && fileToolNames.includes(e.name))
+    if (!usedFileTools) {
+      lines.push(
+        '',
+        `CRITICAL: The user asked you to save output to a file path (${fileOutputMatch[1] || 'see objective'}). You have NOT used any file-writing tool yet.`,
+        'You MUST use the `files` or `write_file` tool to write the content to the requested path. Do not just include the content in your text response — actually write the file.',
+      )
+    }
+  }
+
+  lines.push(
     '',
     `Objective:\n${params.userMessage}`,
     '',
     `Current partial response:\n${params.fullText || '(none)'}`,
     '',
     `Recent tool evidence:\n${renderToolEvidence(params.toolEvents) || '(none)'}`,
+  )
+  return lines.join('\n')
+}
+
+function buildExactStructureBlock(userMessage: string): string {
+  const exactBulletMatch = userMessage.match(/\bexactly\s+(\d+)\s+bullet points?\b/i)
+  if (!exactBulletMatch) return ''
+  const bulletCount = exactBulletMatch[1]
+  return [
+    '## Exact Structural Constraints',
+    `The user required exactly ${bulletCount} bullet points.`,
+    'Treat that as a hard file-wide constraint unless the user explicitly says later sections get their own separate bullets.',
+    'If the file also needs titled sections such as Owners or Risks, use short prose under those headings instead of adding more bullet lines.',
   ].join('\n')
 }
 
@@ -529,6 +588,7 @@ const GOAL_DECOMPOSITION_BLOCK = [
   '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.',
+  '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.',
   '5. Update only the durable tasks you actually created; otherwise just continue executing and report progress plainly.',
@@ -541,12 +601,15 @@ function buildAgenticExecutionPolicy(opts: {
   heartbeatIntervalSec: number
   platformAssignScope?: 'self' | 'all'
   userMessage?: string
+  history?: Message[]
   responseStyle?: 'concise' | 'normal' | 'detailed' | null
   responseMaxChars?: number | null
 }) {
   const hasTooling = opts.enabledPlugins.length > 0
   const pluginLines = buildPluginCapabilityLines(opts.enabledPlugins, { platformAssignScope: opts.platformAssignScope })
   const toolDisciplineLines = buildToolDisciplineLines(opts.enabledPlugins)
+  const hasMemoryTools = opts.enabledPlugins.some((toolId) => (canonicalizePluginId(toolId) || toolId) === 'memory')
+  const directMemoryWriteOnlyTurn = Boolean(opts.userMessage && isNarrowDirectMemoryWriteTurn(opts.userMessage))
 
   const parts: string[] = []
 
@@ -556,7 +619,7 @@ function buildAgenticExecutionPolicy(opts: {
     hasTooling
       ? 'I take initiative — plan briefly, execute tools, evaluate, iterate until done. Never stop at advice when action is implied.'
       : 'No tools enabled. Be explicit about what tool access is needed.',
-    'IMPORTANT: If information was already mentioned in THIS conversation, answer from context — do NOT call memory_tool or web search to look it up again. Only use memory_tool to recall info from PREVIOUS conversations not in the current thread.',
+    'IMPORTANT: If information was already mentioned in THIS conversation, answer from context — do NOT call memory tools or web search to look it up again. Only use memory tools to recall info from PREVIOUS conversations not in the current thread.',
     'If a skill applies to the task, follow its recommended approach first. Skill-specific commands are faster and more reliable than generic web search. Minimize tool calls — combine steps where possible.',
     'If a task explicitly names an enabled tool, use that tool before declaring success. A prose request is not a substitute for `ask_human`, and browser work is not a substitute for `email` delivery.',
     'When `ask_human` is enabled, collect required human input through the tool instead of asking for it only in plain assistant text.',
@@ -567,6 +630,18 @@ function buildAgenticExecutionPolicy(opts: {
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
   )
 
+  if (hasMemoryTools) {
+    parts.push(
+      '## Immediate Memory Routes',
+      'If the user asks you to remember, store, or correct a durable fact, call `memory_store` or `memory_update` immediately before any planning, delegation, task creation, or agent management.',
+      '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 (hasMemoryTools && directMemoryWriteOnlyTurn) {
+    parts.push(buildDirectMemoryWriteBlock())
+  }
+
   // Plugin-specific operating guidance (collected dynamically from plugins)
   const guidanceLines = getPluginManager().collectOperatingGuidance(opts.enabledPlugins)
   if (guidanceLines.length) parts.push(...guidanceLines)
@@ -597,10 +672,104 @@ function buildAgenticExecutionPolicy(opts: {
   if (opts.userMessage && looksLikeOpenEndedDeliverableTask(opts.userMessage) && opts.enabledPlugins.some((toolId) => toolId === 'files' || toolId === 'edit_file')) {
     parts.push(OPEN_ENDED_REVISION_BLOCK)
   }
+  if (opts.userMessage) {
+    const exactStructureBlock = buildExactStructureBlock(opts.userMessage)
+    if (exactStructureBlock) parts.push(exactStructureBlock)
+  }
+  if (opts.userMessage && isCurrentThreadRecallRequest(opts.userMessage)) {
+    parts.push(buildCurrentThreadRecallBlock(opts.history || []))
+  }
 
   return parts.filter(Boolean).join('\n')
 }
 
+function compactThreadRecallText(text: string, maxChars = 180): string {
+  const compact = extractSuggestions(text || '').clean.replace(/\s+/g, ' ').trim()
+  if (!compact) return ''
+  return compact.length > maxChars ? `${compact.slice(0, maxChars - 3)}...` : compact
+}
+
+function buildCurrentThreadRecallBlock(history: Message[]): string {
+  const recentUserFacts = history
+    .filter((entry) => entry.role === 'user' && typeof entry.text === 'string' && entry.text.trim())
+    .slice(-3)
+  const relevant = history
+    .filter((entry) => (entry.role === 'user' || entry.role === 'assistant') && typeof entry.text === 'string' && entry.text.trim())
+    .slice(-6)
+  const lines = [
+    '## Current Thread Recall',
+    'The user is asking about information from this same conversation.',
+    'Treat the current chat history as the authoritative source for this request.',
+    'Do NOT call memory tools, web search, or session-history tools unless the user explicitly asks you to verify outside the current thread.',
+    'Answer directly from the existing conversation with the exact values already stated.',
+    'Prefer the user\'s own earlier words and facts over assistant summaries, persona defaults, soul/config values, or generic background context.',
+    'If the answer is present in the recent thread context below, do not say the information is missing, unknown, or from a first exchange.',
+  ]
+  if (recentUserFacts.length > 0) {
+    lines.push('Recent user-provided facts to trust first:')
+    for (const message of recentUserFacts) {
+      const snippet = compactThreadRecallText(message.text || '')
+      if (!snippet) continue
+      lines.push(`- user: ${snippet}`)
+    }
+    lines.push('These user messages override tool traces, failed tool attempts, persona defaults, and generic background context.')
+  }
+  if (relevant.length > 0) {
+    lines.push('Recent thread context:')
+    for (const message of relevant) {
+      const snippet = compactThreadRecallText(message.text || '')
+      if (!snippet) continue
+      lines.push(`- ${message.role}: ${snippet}`)
+    }
+  }
+  return lines.join('\n')
+}
+
+function buildDirectMemoryWriteBlock(): string {
+  return [
+    '## Direct Memory Write',
+    'This turn is a direct request to remember, store, or correct a durable fact.',
+    'Call `memory_store` or `memory_update` immediately, then confirm the stored value succinctly.',
+    'If the user bundled several related facts into one remember request, store them together in one canonical memory write unless they explicitly asked for separate entries.',
+    'Do not inspect skills, browse the workspace, request capabilities, manage tasks, manage agents, or delegate before the direct memory write is complete.',
+  ].join('\n')
+}
+
+const DIRECT_MEMORY_WRITE_CONFIRMATION_ONLY_RE = /\b(?:then|and then|after that)?\s*(?:confirm|recap|repeat|summarize|tell me|say)\b[\s\S]{0,120}\b(?:stored|saved|updated|remembered|wrote|write)\b/i
+const DIRECT_MEMORY_WRITE_EXTRA_ACTION_RE = /\b(?:then|and then|after that|also)\b[\s\S]{0,160}\b(?:write|create|send|email|message|delegate|research|search|browse|open|edit|build|schedule|plan|review|analy[sz]e)\b/i
+
+export function isNarrowDirectMemoryWriteTurn(message: string): boolean {
+  const trimmed = String(message || '').trim()
+  if (!trimmed || !isDirectMemoryWriteRequest(trimmed)) return false
+  if (looksLikeOpenEndedDeliverableTask(trimmed)) return false
+  if (DIRECT_MEMORY_WRITE_EXTRA_ACTION_RE.test(trimmed) && !DIRECT_MEMORY_WRITE_CONFIRMATION_ONLY_RE.test(trimmed)) {
+    return false
+  }
+  return !isBroadGoal(trimmed) || DIRECT_MEMORY_WRITE_CONFIRMATION_ONLY_RE.test(trimmed) || !/[?]$/.test(trimmed)
+}
+
+const CURRENT_THREAD_RECALL_BLOCKED_TOOL_IDS = new Set([
+  'memory',
+  'manage_sessions',
+  'web',
+  'context_mgmt',
+])
+
+export function shouldAllowToolForCurrentThreadRecall(toolName: string): boolean {
+  const canonicalToolName = canonicalizePluginId(toolName) || toolName.trim().toLowerCase()
+  return !CURRENT_THREAD_RECALL_BLOCKED_TOOL_IDS.has(canonicalToolName)
+}
+
+const DIRECT_MEMORY_WRITE_ALLOWED_TOOL_IDS = new Set([
+  'memory_store',
+  'memory_update',
+])
+
+export function shouldAllowToolForDirectMemoryWrite(toolName: string): boolean {
+  const rawToolName = toolName.trim().toLowerCase()
+  return DIRECT_MEMORY_WRITE_ALLOWED_TOOL_IDS.has(rawToolName)
+}
+
 export interface StreamAgentChatResult {
   /** All text accumulated across every LLM turn (for SSE / web UI history). */
   fullText: string
@@ -704,6 +873,8 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
   const stateModifierParts: string[] = []
   const hasProvidedSystemPrompt = typeof systemPrompt === 'string' && systemPrompt.trim().length > 0
+  const directMemoryWriteOnlyTurn = isNarrowDirectMemoryWriteTurn(message)
+  const currentThreadRecallRequest = !directMemoryWriteOnlyTurn && isCurrentThreadRecallRequest(message)
 
   if (hasProvidedSystemPrompt) {
     stateModifierParts.push(systemPrompt!.trim())
@@ -897,6 +1068,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       heartbeatIntervalSec,
       platformAssignScope: agentPlatformAssignScope,
       userMessage: message,
+      history,
       responseStyle: agentResponseStyle,
       responseMaxChars: agentResponseMaxChars,
     }),
@@ -916,7 +1088,22 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     projectDescription: activeProjectContext.project?.description || null,
     memoryScopeMode: agentMemoryScopeMode,
   })
-  const agent = createReactAgent({ llm, tools, stateModifier })
+  const toolsForTurn = currentThreadRecallRequest
+    ? tools.filter((tool) => {
+        const toolName = typeof (tool as { name?: unknown }).name === 'string'
+          ? String((tool as { name?: unknown }).name)
+          : ''
+        return shouldAllowToolForCurrentThreadRecall(toolName)
+      })
+    : directMemoryWriteOnlyTurn
+      ? tools.filter((tool) => {
+          const toolName = typeof (tool as { name?: unknown }).name === 'string'
+            ? String((tool as { name?: unknown }).name)
+            : ''
+          return shouldAllowToolForDirectMemoryWrite(toolName)
+        })
+      : tools
+  const agent = createReactAgent({ llm, tools: toolsForTurn, stateModifier })
   const recursionLimit = getAgentLoopRecursionLimit(runtime)
 
   // Build message history for context
@@ -1112,7 +1299,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   const MAX_REQUIRED_TOOL_CONTINUES = 2
   const MAX_EXECUTION_FOLLOWTHROUGHS = 1
   const MAX_DELIVERABLE_FOLLOWTHROUGHS = 2
-  const MAX_TOOL_SUMMARY_RETRIES = 1
+  const MAX_TOOL_SUMMARY_RETRIES = 2
   let autoContinueCount = 0
   let transientRetryCount = 0
   let requiredToolContinueCount = 0
@@ -1496,10 +1683,18 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
       if (reachedExecutionBoundary) break
 
-      // Tool loop detection: critical severity stops the entire agent turn
+      // Tool loop detection: critical severity stops further tool calls.
+      // However, if tools already produced results but the model has no/trivial text,
+      // we attempt a tool_summary continuation instead of just erroring out.
       if (loopDetectionTriggered) {
-        write(`data: ${JSON.stringify({ t: 'err', text: loopDetectionTriggered.message })}\n\n`)
-        break
+        const loopTextIsTrivial = !fullText.trim() || (fullText.trim().length < 150 && streamedToolEvents.length >= 2)
+        if (loopTextIsTrivial && streamedToolEvents.length > 0 && toolSummaryRetryCount < MAX_TOOL_SUMMARY_RETRIES) {
+          // Override: let the tool_summary check below handle it instead of breaking
+          loopDetectionTriggered = null
+        } else {
+          write(`data: ${JSON.stringify({ t: 'err', text: loopDetectionTriggered.message })}\n\n`)
+          break
+        }
       }
 
       if (
@@ -1590,25 +1785,28 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         })}\n\n`)
       }
 
-      // Generic fallback: tools were called but the model produced no text response.
-      // This catches edge cases (e.g. after transient retry) where specialized
-      // followthrough conditions don't match. Ask the LLM to summarize tool results.
+      // Generic fallback: tools were called but the model produced no substantive text.
+      // Triggers when: (a) text is empty, or (b) text is trivially short (< 150 chars)
+      // and multiple tools ran — the agent likely emitted a "I'll do X" preamble but
+      // never synthesized the tool outputs into a real response.
+      const textIsTrivial = !fullText.trim() || (fullText.trim().length < 150 && streamedToolEvents.length >= 2)
       if (
         !shouldContinue
         && hasToolCalls
-        && !fullText.trim()
+        && textIsTrivial
         && streamedToolEvents.length > 0
         && toolSummaryRetryCount < MAX_TOOL_SUMMARY_RETRIES
       ) {
         shouldContinue = 'tool_summary'
         toolSummaryRetryCount++
-        logExecution(session.id, 'decision', `Tools called but no text generated — forcing summary continuation`, {
+        logExecution(session.id, 'decision', `Tools called but response text is trivial (${fullText.trim().length} chars) — forcing summary continuation`, {
           agentId: session.agentId,
-          detail: { toolEventCount: streamedToolEvents.length, toolSummaryRetryCount },
+          detail: { toolEventCount: streamedToolEvents.length, toolSummaryRetryCount, textLength: fullText.trim().length },
         })
+        const summaryReason = !fullText.trim() ? 'empty_response_after_tools' : 'trivial_preamble_after_tools'
         write(`data: ${JSON.stringify({
           t: 'status',
-          text: JSON.stringify({ toolSummary: toolSummaryRetryCount, reason: 'empty_response_after_tools' }),
+          text: JSON.stringify({ toolSummary: toolSummaryRetryCount, reason: summaryReason }),
         })}\n\n`)
       }
 
@@ -1669,7 +1867,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         }))
         lastSegment = ''
       } else if (shouldContinue === 'tool_summary') {
-        // Model called tools but produced no text — prompt it to summarize the results.
+        // Model called tools but produced no/trivial text — prompt it to synthesize results.
         if (continuationAssistantText) {
           langchainMessages.push(new AIMessage({ content: continuationAssistantText }))
         }
@@ -1677,13 +1875,18 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
           .filter((e) => e.output)
           .map((e) => `[${e.name}]: ${(e.output || '').slice(0, 500)}`)
           .slice(0, 6)
+        const preambleNote = fullText.trim()
+          ? `You started with "${fullText.trim().slice(0, 100)}..." but did not follow through with actual results.`
+          : 'Your tool calls completed but you did not provide a response.'
         langchainMessages.push(new HumanMessage({
           content: [
-            'Your tool calls completed but you did not provide a response.',
+            preambleNote,
             'Here are the tool results:',
             ...toolSummaryLines,
             '',
-            'Now answer the original question using these results. Be concise and direct.',
+            `Original request: ${message.slice(0, 500)}`,
+            '',
+            'Now answer the original request using these tool results. Be concise and direct. Present the findings clearly.',
           ].join('\n'),
         }))
         lastSegment = ''
@@ -1769,7 +1972,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {
     const cost = estimateCost(session.model, totalInputTokens, totalOutputTokens)
-    const pluginDefinitionCosts = buildPluginDefinitionCosts(tools, toolToPluginMap)
+    const pluginDefinitionCosts = buildPluginDefinitionCosts(toolsForTurn, toolToPluginMap)
     const usageRecord: UsageRecord = {
       sessionId: session.id,
       messageIndex: history.length,

package/src/lib/server/tool-aliases.ts

@@ -20,7 +20,7 @@ const PLUGIN_ALIAS_GROUPS: string[][] = [
   ['manage_sessions', 'session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'],
   ['schedule_wake', 'schedule'],
   ['http_request', 'http'],
-  ['memory', 'memory_tool'],
+  ['memory', 'memory_tool', 'memory_search', 'memory_get', 'memory_store', 'memory_update'],
   ['sandbox', 'sandbox_exec', 'sandbox_list_runtimes'],
   ['wallet', 'wallet_tool'],
   ['monitor', 'monitor_tool'],

package/src/lib/server/tool-capability-policy.ts

@@ -55,7 +55,7 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   codex_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_codex_cli'] },
   opencode_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_opencode_cli'] },
   gemini_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_gemini_cli'] },
-  memory: { categories: ['memory'], concreteTools: ['memory', 'memory_tool', 'context_status', 'context_summarize'] },
+  memory: { categories: ['memory'], concreteTools: ['memory', 'memory_tool', 'memory_search', 'memory_get', 'memory_store', 'memory_update', 'context_status', 'context_summarize'] },
   sandbox: { categories: ['execution', 'filesystem'], concreteTools: ['sandbox', 'sandbox_exec', 'sandbox_list_runtimes'] },
   git: { categories: ['execution', 'filesystem'], concreteTools: ['git'] },
   http_request: { categories: ['network'], concreteTools: ['http_request'] },

package/src/stores/use-app-store.ts

@@ -6,6 +6,7 @@ import { fetchChats, fetchDirs, fetchProviders, fetchCredentials } from '../lib/
 import { fetchAgents } from '../lib/agents'
 import { fetchSchedules } from '../lib/schedules'
 import { fetchTasks } from '../lib/tasks'
+import { findLatestObservablePlatformSession, isLocalhostBrowser } from '../lib/local-observability'
 import { api } from '../lib/api-client'
 import { safeStorageGet, safeStorageGetJson, safeStorageRemove, safeStorageSet } from '../lib/safe-storage'
 
@@ -247,7 +248,11 @@ export const useAppStore = create<AppState>((set, get) => ({
   loadSessions: async () => {
     try {
       const sessions = await fetchChats()
-      set({ sessions })
+      const currentSessionId = get().currentSessionId
+      set({
+        sessions,
+        currentSessionId: currentSessionId && sessions[currentSessionId] ? currentSessionId : null,
+      })
     } catch {
       // ignore
     }
@@ -348,6 +353,26 @@ export const useAppStore = create<AppState>((set, get) => ({
     }
     set({ currentAgentId: id })
     safeStorageSet('sc_agent', id)
+    if (isLocalhostBrowser()) {
+      let livePlatformSession = findLatestObservablePlatformSession(get().sessions, id)
+      if (!livePlatformSession) {
+        try {
+          const refreshedSessions = await fetchChats()
+          const currentSessionId = get().currentSessionId
+          set({
+            sessions: refreshedSessions,
+            currentSessionId: currentSessionId && refreshedSessions[currentSessionId] ? currentSessionId : null,
+          })
+          livePlatformSession = findLatestObservablePlatformSession(refreshedSessions, id)
+        } catch {
+          // ignore and fall back to the normal thread path below
+        }
+      }
+      if (livePlatformSession?.id) {
+        set({ currentSessionId: livePlatformSession.id })
+        return
+      }
+    }
     try {
       const user = get().currentUser || 'default'
       const session = await api<Session>('POST', `/agents/${id}/thread`, { user })