@swarmclawai/swarmclaw 0.9.2 → 0.9.3

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

@@ -1,14 +1,11 @@
 import type { MessageToolEvent } from '@/types'
 import { canonicalizePluginId } from '@/lib/server/tool-aliases'
 import { extractSuggestions } from '@/lib/server/suggestions'
-import { isDirectMemoryWriteRequest } from '@/lib/server/memory/memory-policy'
 import {
-  isBroadGoal,
   looksLikeExternalWalletTask,
-  looksLikeOpenEndedDeliverableTask,
 } from '@/lib/server/chat-execution/stream-continuation'
 
-const EXPLICIT_ARTIFACT_OUTPUT_RE = /\b(?:save|write|output|export)\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
+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
 
 export function isLikelyToolErrorOutput(output: string): boolean {
   const trimmed = String(output || '').trim()
@@ -168,37 +165,3 @@ export function compactThreadRecallText(text: string, maxChars = 180): string {
   return compact.length > maxChars ? `${compact.slice(0, maxChars - 3)}...` : compact
 }
 
-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)
-}

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

@@ -8,13 +8,10 @@ import {
   buildExternalWalletExecutionBlock,
   buildToolDisciplineLines,
   getExplicitRequiredToolNames,
-  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   looksLikeOpenEndedDeliverableTask,
   resolveContinuationAssistantText,
   resolveFinalStreamResponseText,
-  shouldAllowToolForDirectMemoryWrite,
-  shouldAllowToolForCurrentThreadRecall,
   shouldForceAttachmentFollowthrough,
   shouldForceRecoverableToolErrorFollowthrough,
   shouldTerminateOnSuccessfulMemoryMutation,
@@ -208,57 +205,16 @@ describe('buildToolDisciplineLines', () => {
     assert.ok(streamAgentChatSource.includes('did not start the required workspace tool step'))
   })
 
-  it('adds a dedicated current-thread recall block and removes long-term memory tools for those turns', () => {
+  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'))
-    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('const currentThreadRecallRequest = isCurrentThreadRecallRequest(message)'))
     assert.ok(streamSources.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.

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

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
+import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
@@ -51,31 +52,43 @@ import {
 import type { ContinuationType } from '@/lib/server/chat-execution/stream-continuation'
 import { dedup, errorMessage, sleep } from '@/lib/shared-utils'
 import { perf } from '@/lib/server/runtime/perf'
-import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
 import {
   compactThreadRecallText,
   getExplicitRequiredToolNames,
   getWalletApprovalBoundaryAction,
-  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   resolveToolAction,
-  shouldAllowToolForDirectMemoryWrite,
-  shouldAllowToolForCurrentThreadRecall,
   shouldForceExternalServiceSummary,
   shouldTerminateOnSuccessfulMemoryMutation,
   updateStreamedToolEvents,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
 import { LangGraphToolEventTracker } from '@/lib/server/chat-execution/tool-event-tracker'
 
+// LangGraph's streamEvents leaves dangling internal promises when the for-await
+// loop exits early (break on tool loop detection, execution boundary, etc.).
+// These promises may later reject with GraphRecursionError or AbortError.
+// Register a permanent handler to prevent process crashes from these expected
+// background rejections.  Only LangGraph-specific errors (identified by
+// pregelTaskId or lc_error_code) are suppressed; all other rejections propagate
+// normally.
+process.on('unhandledRejection', (err: unknown) => {
+  if (
+    err && typeof err === 'object'
+    && ('pregelTaskId' in err
+      || (err instanceof Error && (err.name === 'AbortError' || err.name === 'GraphRecursionError'))
+      || (err as Record<string, unknown>).lc_error_code === 'GRAPH_RECURSION_LIMIT')
+  ) {
+    // Silently suppress — expected background rejection from LangGraph
+    return
+  }
+})
+
 // Re-export continuation functions so existing consumers don't need to change imports
 export {
   getExplicitRequiredToolNames,
-  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   looksLikeOpenEndedDeliverableTask,
   shouldForceRecoverableToolErrorFollowthrough,
-  shouldAllowToolForDirectMemoryWrite,
-  shouldAllowToolForCurrentThreadRecall,
   shouldForceExternalExecutionFollowthrough,
   shouldForceDeliverableFollowthrough,
   shouldForceExternalServiceSummary,
@@ -101,9 +114,6 @@ interface StreamAgentChatOpts {
 
 // LangGraph uses this internal configurable key to bypass subgraph lookup when
 // resolving state from a namespaced checkpoint. It is not exported publicly in
-// @langchain/langgraph 1.x, so keep the literal here instead of importing a
-// non-exported symbol that breaks Next compilation.
-const LANGGRAPH_CHECKPOINTER_CONFIG_KEY = '__pregel_checkpointer'
 const CONTEXT_WARNING_OVERHEAD_TOKENS = 192
 
 /** Extract HTTP status code and Retry-After from provider error objects (OpenAI SDK, etc.) */
@@ -341,7 +351,6 @@ function buildAgenticExecutionPolicy(opts: {
   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[] = []
 
@@ -371,10 +380,6 @@ function buildAgenticExecutionPolicy(opts: {
       '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())
-  }
-
   if (opts.hasAttachmentContext) {
     parts.push(
       '## Attachments',
@@ -393,6 +398,7 @@ function buildAgenticExecutionPolicy(opts: {
     'Execute by default — only confirm on high-risk actions.',
     'If a tool errors, retry or explain the blocker. Never claim success without evidence.',
     'Keep responses concise. Bullet points over prose. After file operations, confirm the result briefly (path and status) without echoing the full file contents.',
+    'Do not end every reply with a question. Only ask when a specific missing detail blocks progress. When a task is done, state the result and stop.',
     opts.responseStyle === 'concise'
       ? `IMPORTANT: Be extremely concise.${opts.responseMaxChars ? ` Keep responses under ${opts.responseMaxChars} characters.` : ' Target under 500 characters.'} Lead with the answer, skip preamble.`
       : opts.responseStyle === 'detailed'
@@ -458,16 +464,6 @@ function buildCurrentThreadRecallBlock(history: Message[]): string {
   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')
-}
-
 export interface StreamAgentChatResult {
   /** All text accumulated across every LLM turn (for SSE / web UI history). */
   fullText: string
@@ -543,8 +539,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   const promptParts: string[] = []
   const hasProvidedSystemPrompt = typeof systemPrompt === 'string' && systemPrompt.trim().length > 0
-  const directMemoryWriteOnlyTurn = isNarrowDirectMemoryWriteTurn(message)
-  const currentThreadRecallRequest = !directMemoryWriteOnlyTurn && isCurrentThreadRecallRequest(message)
+  const currentThreadRecallRequest = isCurrentThreadRecallRequest(message)
   const hasAttachmentContext = Boolean(
     imagePath
     || attachedFiles?.length
@@ -653,8 +648,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   try {
     const pluginContextParts = await getPluginManager().collectAgentContext(session, sessionPlugins, message, history)
     promptParts.push(...pluginContextParts)
-  } catch {
-    // Plugin context injection is non-critical
+  } catch (err: unknown) {
+    console.error('[stream-agent-chat] Plugin context injection failed:', err instanceof Error ? err.message : String(err))
   }
 
   if (!hasProvidedSystemPrompt && activeProjectContext.projectId) {
@@ -757,7 +752,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Proactive memory recall: inject relevant memories into context before LLM invocation
   // Skips heartbeat polls, very short messages, and thread-recall requests (which use chat history instead)
-  if (session.agentId && !directMemoryWriteOnlyTurn && !currentThreadRecallRequest && message.length > 12) {
+  if (session.agentId && !currentThreadRecallRequest && message.length > 12) {
     try {
       const agents = loadAgents()
       const agentForMemory = agents[session.agentId]
@@ -794,23 +789,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     memoryScopeMode: agentMemoryScopeMode,
   })
   endToolBuildPerf({ toolCount: tools.length })
-  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 checkpointNamespace = `chat:${startTs}`
-  const checkpointSaver = getCheckpointSaver()
   const recursionLimit = getAgentLoopRecursionLimit(runtime)
 
   // Build message history for context
@@ -997,11 +975,17 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     // Warning failure is non-critical
   }
 
+  // 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.
+  // MemorySaver avoids the SQLite serde round-trip that dropped tool_call IDs
+  // or ToolMessages, causing OpenAI to reject with "tool_calls must be
+  // followed by tool messages" errors.
   const agent = createReactAgent({
     llm,
-    tools: toolsForTurn,
+    tools,
     prompt,
-    checkpointer: checkpointSaver,
+    checkpointer: new MemorySaver(),
   })
 
   const langchainMessages: Array<HumanMessage | AIMessage> = []
@@ -1018,7 +1002,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const currentContent = await buildLangChainContent(message, imagePath, attachedFiles)
   langchainMessages.push(new HumanMessage({ content: currentContent }))
   let pendingGraphMessages = [...langchainMessages]
-  let currentCheckpointId: string | undefined
 
   let fullText = ''
   let lastSegment = ''
@@ -1073,7 +1056,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     MAX_TOOL_SUMMARY_RETRIES = 1
     MAX_UNFINISHED_TOOL_FOLLOWTHROUGHS = 1
   }
-  const REQUIRED_TOOL_KICKOFF_TIMEOUT_MS = 20_000
+  const REQUIRED_TOOL_KICKOFF_TIMEOUT_MS = runtime.requiredToolKickoffMs
   let autoContinueCount = 0
   let transientRetryCount = 0
   let pendingRetryAfterMs: number | null = null
@@ -1154,7 +1137,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         idleTimer = setTimeout(() => {
           idleTimedOut = true
           iterationController.abort()
-        }, 90_000)
+        }, runtime.streamIdleStallMs)
       }
 
       const armRequiredToolKickoff = () => {
@@ -1175,23 +1158,21 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       const toolPerfEnds = new Map<string, (extra?: Record<string, unknown>) => number>()
       const iterationInputMessages = pendingGraphMessages
       let iterationSucceeded = false
+      const eventStream = agent.streamEvents(
+        { messages: iterationInputMessages },
+        {
+          version: 'v2',
+          recursionLimit,
+          signal: iterationController.signal,
+          configurable: {
+            thread_id: `${session.id}:${startTs}:${iteration}`,
+          },
+        },
+      )
 
       try {
         armIdleWatchdog()
         armRequiredToolKickoff()
-        const eventStream = agent.streamEvents(
-          { messages: iterationInputMessages },
-          {
-            version: 'v2',
-            recursionLimit,
-            signal: iterationController.signal,
-            configurable: {
-              thread_id: session.id,
-              checkpoint_ns: checkpointNamespace,
-              ...(currentCheckpointId ? { checkpoint_id: currentCheckpointId } : {}),
-            },
-          },
-        )
 
         for await (const event of eventStream) {
           const kind = event.event
@@ -1434,7 +1415,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       } catch (innerErr: unknown) {
         const errName = innerErr instanceof Error ? innerErr.constructor.name : ''
         const errMsg = idleTimedOut
-          ? 'Model stream stalled without emitting text or tool results for 90 seconds.'
+          ? `Model stream stalled without emitting text or tool results for ${Math.trunc(runtime.streamIdleStallMs / 1000)} seconds.`
           : requiredToolKickoffTimedOut
             ? `The turn did not start the required workspace tool step within ${Math.trunc(REQUIRED_TOOL_KICKOFF_TIMEOUT_MS / 1000)} seconds.`
           : errorMessage(innerErr)
@@ -1539,24 +1520,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         abortController.signal.removeEventListener('abort', onParentAbort)
       }
 
-      if (iterationSucceeded) {
-        try {
-          const state = await agent.getState({
-            configurable: {
-              thread_id: session.id,
-              checkpoint_ns: checkpointNamespace,
-              [LANGGRAPH_CHECKPOINTER_CONFIG_KEY]: checkpointSaver,
-            },
-          }) as { config?: { configurable?: { checkpoint_id?: unknown } } } | null
-          const latestCheckpointId = state?.config?.configurable?.checkpoint_id
-          if (typeof latestCheckpointId === 'string' && latestCheckpointId.trim()) {
-            currentCheckpointId = latestCheckpointId
-          }
-        } catch (checkpointErr) {
-          console.warn('[stream-agent-chat] Failed to refresh latest checkpoint state:', errorMessage(checkpointErr))
-        }
-      }
-
       if (reachedExecutionBoundary) break
 
       if (!shouldContinue
@@ -1808,7 +1771,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         const promptMessage = new HumanMessage({ content: continuationPrompt })
         langchainMessages.push(promptMessage)
         continuationMessages.push(promptMessage)
-        pendingGraphMessages = continuationMessages
+        // Provide full conversation history since the agent has no checkpointer
+        // and each iteration starts with only the messages we explicitly pass.
+        pendingGraphMessages = [...langchainMessages]
         lastSegment = ''
       } else if (shouldContinue === 'transient') {
         // Exponential backoff before retrying transient errors; respect Retry-After if present
@@ -1896,7 +1861,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {
     const cost = estimateCost(session.model, totalInputTokens, totalOutputTokens)
-    const pluginDefinitionCosts = buildPluginDefinitionCosts(toolsForTurn, toolToPluginMap)
+    const pluginDefinitionCosts = buildPluginDefinitionCosts(tools, toolToPluginMap)
     const usageRecord: UsageRecord = {
       sessionId: session.id,
       messageIndex: history.length,

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

@@ -100,7 +100,7 @@ function looksLikeIncompleteDeliverableResponse(text: string): boolean {
 }
 
 const ARTIFACT_PATH_EXT_RE = /\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|ts|tsx|js|jsx|mjs|cjs|py|sql|sh)$/i
-const EXPLICIT_ARTIFACT_OUTPUT_RE = /\b(?:save|write|output|export)\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
+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
 
 function hasExplicitFileOutputRequest(text: string): boolean {
   const normalized = text.toLowerCase()

package/src/lib/server/connectors/manager.ts

@@ -1534,7 +1534,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   const threadContextBlock = buildConnectorThreadContextBlock(msg, { isFirstThreadTurn: wasCreated })
   if (threadContextBlock) promptParts.push(threadContextBlock)
   // Add connector context
-  promptParts.push(`\nYou are receiving messages via ${msg.platform}. The user "${msg.senderName}" is messaging from channel "${msg.channelName || msg.channelId}". Respond naturally and conversationally.
+  promptParts.push(`\nYou are receiving messages via ${msg.platform}. The user "${msg.senderName}" (ID: ${msg.senderId}) is messaging from channel "${msg.channelName || msg.channelId}". Respond naturally and conversationally.
 
 ## Response Style
 Be action-first and autonomous: when the user gives an instruction, execute it instead of asking routine follow-up questions.

package/src/lib/server/memory/memory-policy.test.ts

@@ -2,7 +2,6 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import {
   inferAutomaticMemoryCategory,
-  isDirectMemoryWriteRequest,
   isCurrentThreadRecallRequest,
   normalizeMemoryCategory,
   shouldAutoCaptureMemory,
@@ -42,17 +41,6 @@ test('isCurrentThreadRecallRequest detects same-thread recall without matching s
   )
 })
 
-test('isDirectMemoryWriteRequest detects remember-and-confirm turns without matching recall questions', () => {
-  assert.equal(
-    isDirectMemoryWriteRequest('Remember that my favorite programming language is Rust and I prefer functional programming patterns. Then confirm what you just stored.'),
-    true,
-  )
-  assert.equal(
-    isDirectMemoryWriteRequest('What preferences did I tell you earlier in this conversation?'),
-    false,
-  )
-})
-
 test('shouldAutoCaptureMemory filters noisy turns', () => {
   assert.equal(shouldAutoCaptureMemory({ message: 'thanks', response: 'Happy to help with that.' }), false)
   assert.equal(shouldAutoCaptureMemory({ message: 'Please save this to memory', response: 'Stored memory "note".' }), false)
@@ -63,13 +51,15 @@ test('shouldAutoCaptureMemory filters noisy turns', () => {
   }), true)
 })
 
-test('inferAutomaticMemoryCategory picks a stable automatic bucket', () => {
+test('inferAutomaticMemoryCategory falls back to knowledge/facts without content-sniffing', () => {
+  // Content-sniffing regex removed — the agent picks categories via guidance.
+  // inferAutomaticMemoryCategory (called with category "note") should fall through.
   assert.equal(
     inferAutomaticMemoryCategory('The user prefers direct status updates.', 'I will keep future updates terse and direct.'),
-    'identity/preferences',
+    'knowledge/facts',
   )
   assert.equal(
     inferAutomaticMemoryCategory('We decided to ship the GitHub import first.', 'Decision locked for the next milestone.'),
-    'projects/decisions',
+    'knowledge/facts',
   )
 })

package/src/lib/server/memory/memory-policy.ts

@@ -6,7 +6,7 @@ const MEMORY_META_RE = /\b(?:remember|memory|memorize|store this|save this|forge
 const LOW_SIGNAL_RESPONSE_RE = /^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i
 const CURRENT_THREAD_RECALL_MARKER_RE = /\b(?:this conversation|this chat|this thread|current conversation|current chat|current thread|same thread|same chat|same conversation|earlier in (?:this )?(?:conversation|chat|thread)|from (?:this|our) (?:conversation|chat|thread)|you just stored|you just said|we just discussed|we just decided)\b/i
 const CURRENT_THREAD_RECALL_INTENT_RE = /\b(?:what|which|who|when|where|did|remind|recap|summarize|repeat|list|tell me|answer|confirm|recall|mention)\b/i
-const DIRECT_MEMORY_WRITE_MARKER_RE = /\b(?:remember|memorize|store|save|write to memory|add to memory|update.*memory|correct.*memory)\b/i
+const DIRECT_MEMORY_WRITE_MARKER_RE = /\b(?:remember|memorize|store (?:this|that|the fact|it)|save (?:this|that|the fact|it) (?:to|in) memory|write to memory|add to memory|update.*memory|correct.*memory)\b/i
 const DIRECT_MEMORY_WRITE_FOLLOWUP_RE = /\b(?:confirm|recap|repeat|summarize|what you just stored|what you saved|what you updated)\b/i
 
 function normalizeWhitespace(value: string): string {
@@ -36,16 +36,6 @@ export function isCurrentThreadRecallRequest(message: string): boolean {
   return CURRENT_THREAD_RECALL_INTENT_RE.test(trimmed) || /\?\s*$/.test(trimmed)
 }
 
-export function isDirectMemoryWriteRequest(message: string): boolean {
-  const trimmed = normalizeWhitespace(message)
-  if (!trimmed) return false
-  const directWriteLike = DIRECT_MEMORY_WRITE_MARKER_RE.test(trimmed)
-  if (!directWriteLike) return false
-  if (/\?\s*$/.test(trimmed) && !DIRECT_MEMORY_WRITE_FOLLOWUP_RE.test(trimmed)) return false
-  if (isCurrentThreadRecallRequest(trimmed) && !DIRECT_MEMORY_WRITE_FOLLOWUP_RE.test(trimmed)) return false
-  return true
-}
-
 export function shouldAutoCaptureMemoryTurn(message: string, response: string): boolean {
   const normalizedMessage = normalizeWhitespace(message)
   const normalizedResponse = normalizeWhitespace(response)
@@ -67,19 +57,20 @@ export function shouldAutoCaptureMemory(
   return shouldAutoCaptureMemoryTurn(input.message || '', input.response || '')
 }
 
-export function normalizeMemoryCategory(
-  input: string | null | undefined,
-  title: string | null | undefined,
-  content: string | null | undefined,
-): string {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function normalizeMemoryCategory(input: string | null | undefined, _title?: string | null, _content?: string | null): string {
   const explicit = lower(input)
-  const sample = `${lower(title)}\n${lower(content)}`
 
   const mapExplicit = (value: string): string | null => {
     if (!value || value === 'note' || value === 'notes') return null
     if (['preference', 'preferences', 'likes', 'dislikes'].includes(value)) return 'identity/preferences'
     if (['identity', 'profile', 'persona'].includes(value)) return 'identity/profile'
     if (['relationship', 'relationships', 'people'].includes(value)) return 'identity/relationships'
+    if (['contact', 'contacts'].includes(value)) return 'identity/contacts'
+    if (['routine', 'routines', 'schedule', 'habit', 'habits'].includes(value)) return 'identity/routines'
+    if (['event', 'events', 'life event', 'life events', 'significant', 'milestone'].includes(value)) return 'identity/events'
+    if (['goal', 'goals', 'objective', 'objectives', 'target', 'targets'].includes(value)) return 'identity/goals'
+    if (['instruction', 'instructions', 'directive', 'directives', 'standing order', 'rule', 'rules'].includes(value)) return 'knowledge/instructions'
     if (['decision', 'decisions', 'choice'].includes(value)) return 'projects/decisions'
     if (['learning', 'learnings', 'lesson', 'lessons'].includes(value)) return 'projects/learnings'
     if (['project', 'projects', 'task', 'tasks'].includes(value)) return 'projects/context'
@@ -94,30 +85,9 @@ export function normalizeMemoryCategory(
   const explicitMapped = mapExplicit(explicit)
   if (explicitMapped) return explicitMapped
 
-  if (/\b(?:prefer(?:s|ence)?|likes?|dislikes?|favorite|timezone|pronouns|call me)\b/.test(sample)) {
-    return 'identity/preferences'
-  }
-  if (/\b(?:wife|husband|partner|friend|manager|teammate|client|customer|relationship)\b/.test(sample)) {
-    return 'identity/relationships'
-  }
-  if (/\b(?:decided|decision|approved|picked|selected|going with|will use)\b/.test(sample)) {
-    return 'projects/decisions'
-  }
-  if (/\b(?:learned|lesson|fixed|solved|root cause|failure|bug|regression|postmortem)\b/.test(sample)) {
-    return 'projects/learnings'
-  }
-  if (/\b(?:error|incident|stack trace|exception|crash)\b/.test(sample)) {
-    return 'execution/errors'
-  }
-  if (/\b(?:project|repo|repository|ticket|task|milestone|deadline|roadmap)\b/.test(sample)) {
-    return 'projects/context'
-  }
-  if (/\b(?:config|credential|endpoint|workspace|path|env var|environment|docker|sandbox)\b/.test(sample)) {
-    return 'operations/environment'
-  }
-  if (/\b(?:fact|documentation|reference|api|schema)\b/.test(sample)) {
-    return 'knowledge/facts'
-  }
+  // No content-sniffing regex — the agent picks the category via the guidance
+  // in its memory policy block. We just normalize explicit aliases above and
+  // fall back to knowledge/facts for uncategorized entries.
   return explicit && explicit !== 'note' && explicit !== 'notes' ? explicit : 'knowledge/facts'
 }
 

package/src/lib/server/runtime/heartbeat-service.test.ts

@@ -404,3 +404,49 @@ describe('buildAgentHeartbeatPrompt', () => {
     assert.ok(result.includes('Another active task'))
   })
 })
+
+// ── lightContext config ─────────────────────────────────────────────────
+
+describe('heartbeatConfigForSession lightContext', () => {
+  it('defaults to false when not set', () => {
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1' },
+      { heartbeatIntervalSec: 60 },
+      {},
+    )
+    assert.equal(cfg.lightContext, false)
+  })
+
+  it('inherits from global settings', () => {
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: true },
+      {},
+    )
+    assert.equal(cfg.lightContext, true)
+  })
+
+  it('agent overrides global', () => {
+    const agents: Record<string, Record<string, unknown>> = {
+      'a1': { heartbeatLightContext: true },
+    }
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1', agentId: 'a1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: false },
+      agents,
+    )
+    assert.equal(cfg.lightContext, true)
+  })
+
+  it('agent false overrides global true', () => {
+    const agents: Record<string, Record<string, unknown>> = {
+      'a1': { heartbeatLightContext: false },
+    }
+    const cfg = mod.heartbeatConfigForSession(
+      { id: 's1', agentId: 'a1' },
+      { heartbeatIntervalSec: 60, heartbeatLightContext: true },
+      agents,
+    )
+    assert.equal(cfg.lightContext, false)
+  })
+})