@swarmclawai/swarmclaw 1.2.6 → 1.2.8

package/src/lib/chat/queued-message-queue.test.ts

@@ -1,9 +1,11 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 import {
+  buildQueuedTranscriptMessages,
   createOptimisticQueuedMessage,
   clearQueuedMessagesForSession,
   listQueuedMessagesForSession,
+  mergeQueuedTranscriptMessages,
   removeQueuedMessageById,
   replaceQueuedMessagesForSession,
   snapshotToQueuedMessages,
@@ -82,12 +84,22 @@ describe('queued-message-queue', () => {
     const queued = snapshotToQueuedMessages({
       sessionId: 'session-a',
       activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'sending now',
+        queuedAt: 4,
+        position: 0,
+      },
       queueLength: 1,
       items: [
         { runId: 'run-queued', sessionId: 'session-a', text: 'queued', queuedAt: 5, position: 1 },
       ],
     })
-    assert.deepEqual(queued.map((item) => item.runId), ['run-queued'])
+    assert.deepEqual(
+      queued.map((item) => [item.runId, item.sending === true]),
+      [['run-active', true], ['run-queued', false]],
+    )
   })
 
   it('preserves attachment and reply metadata from queue snapshots', () => {
@@ -123,6 +135,27 @@ describe('queued-message-queue', () => {
     })
   })
 
+  it('deduplicates an active turn when the snapshot also contains it in the queued items', () => {
+    const queued = snapshotToQueuedMessages({
+      sessionId: 'session-a',
+      activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'already running',
+        queuedAt: 6,
+        position: 0,
+      },
+      queueLength: 1,
+      items: [
+        { runId: 'run-active', sessionId: 'session-a', text: 'already running', queuedAt: 6, position: 1 },
+      ],
+    })
+
+    assert.deepEqual(queued.map((item) => item.runId), ['run-active'])
+    assert.equal(queued[0]?.sending, true)
+  })
+
   it('sorts queued messages by position and queued time within a session', () => {
     const unsorted: QueuedSessionMessage[] = [
       { runId: 'q4', sessionId: 'session-a', text: 'later', queuedAt: 9, position: 2 },
@@ -135,4 +168,104 @@ describe('queued-message-queue', () => {
       ['q5', 'q6', 'q4'],
     )
   })
+
+  it('builds transcript-ready user messages from sending queued turns', () => {
+    const transcript = buildQueuedTranscriptMessages([
+      { runId: 'q1', sessionId: 'session-a', text: 'sending row', queuedAt: 20, position: 0, sending: true },
+      { runId: 'q2', sessionId: 'session-a', text: 'pending row', queuedAt: 21, position: 1 },
+      { runId: 'q3', sessionId: 'session-b', text: 'other session', queuedAt: 22, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(transcript, [
+      {
+        role: 'user',
+        text: 'sending row',
+        time: 20,
+        kind: 'chat',
+        clientRenderId: 'queued:q1',
+        imagePath: undefined,
+        imageUrl: undefined,
+        attachedFiles: undefined,
+        replyToId: undefined,
+        runId: 'q1',
+      },
+    ])
+  })
+
+  it('merges sending queued turns into the transcript ahead of later assistant output', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
+
+  it('preserves existing sending items when replacing queue for a session', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'sending-1', sessionId: 'session-a', text: 'already sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q3', sessionId: 'session-a', text: 'queued', queuedAt: 2, position: 1 },
+      { runId: 'q2', sessionId: 'session-b', text: 'other', queuedAt: 3, position: 1 },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'q4', sessionId: 'session-a', text: 'new queued', queuedAt: 4, position: 1 },
+    ], { activeRunId: null })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => [item.runId, item.sending === true]),
+      [['sending-1', true], ['q4', false]],
+    )
+  })
+
+  it('deduplicates sending items that appear in nextItems', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q5', sessionId: 'session-a', text: 'next', queuedAt: 2, position: 1 },
+    ], { activeRunId: 'run-active' })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => item.runId),
+      ['run-active', 'q5'],
+    )
+  })
+
+  it('inserts sending messages after last persisted message, not by timestamp', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'First', time: 100 },
+      { role: 'assistant', text: 'Reply', time: 200 },
+      { role: 'user', text: 'Second', time: 300 },
+      { role: 'assistant', text: 'Reply 2', time: 400 },
+    ], [
+      // queuedAt is earlier than the last persisted message
+      { runId: 'run-late', sessionId: 'session-a', text: 'queued early', queuedAt: 150, position: 0, sending: true },
+    ], 'session-a')
+
+    // Should appear at the END, not spliced into the middle at time=150
+    assert.deepEqual(merged.map((msg) => msg.text), [
+      'First', 'Reply', 'Second', 'Reply 2', 'queued early',
+    ])
+  })
+
+  it('skips a sending queued turn once the persisted user message is already present', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'queued first', time: 20, runId: 'run-active' },
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
 })

package/src/lib/chat/queued-message-queue.ts

@@ -1,4 +1,4 @@
-import type { SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
+import type { Message, SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
 
 export interface QueuedSessionMessage extends SessionQueuedTurn {
   optimistic?: boolean
@@ -38,7 +38,23 @@ export function createOptimisticQueuedMessage(
 }
 
 export function snapshotToQueuedMessages(snapshot: SessionQueueSnapshot): QueuedSessionMessage[] {
-  return snapshot.items.map((item) => ({ ...item }))
+  const activeRunId = typeof snapshot.activeRunId === 'string' && snapshot.activeRunId.trim()
+    ? snapshot.activeRunId
+    : null
+  const nextItems: QueuedSessionMessage[] = []
+  if (snapshot.activeTurn && activeRunId && snapshot.activeTurn.runId === activeRunId) {
+    nextItems.push({
+      ...snapshot.activeTurn,
+      sending: true,
+    })
+  }
+  const seenRunIds = new Set(nextItems.map((item) => item.runId))
+  for (const item of snapshot.items) {
+    if (seenRunIds.has(item.runId)) continue
+    nextItems.push({ ...item })
+    seenRunIds.add(item.runId)
+  }
+  return nextItems
 }
 
 interface ReplaceQueuedMessagesOptions {
@@ -60,11 +76,17 @@ export function replaceQueuedMessagesForSession(
   const activeRunId = typeof options.activeRunId === 'string' && options.activeRunId.trim()
     ? options.activeRunId
     : null
+  // Preserve existing "sending" items not covered by the new snapshot —
+  // they'll be cleaned up later by setMessages or the timeout.
+  const existingSending = queue.filter((item) =>
+    item.sessionId === sessionId && item.sending && !nextRunIds.has(item.runId),
+  )
   const consumed = previousForSession
     .filter((item) => !item.optimistic && !nextRunIds.has(item.runId) && activeRunId === item.runId)
     .map((item) => ({ ...item, sending: true }))
   return [
     ...otherSessions,
+    ...existingSending,
     ...consumed,
     ...nextItems,
   ]
@@ -80,6 +102,59 @@ export function listQueuedMessagesForSession(
     .sort((left, right) => left.position - right.position || left.queuedAt - right.queuedAt)
 }
 
+export function buildQueuedTranscriptMessages(
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  return listQueuedMessagesForSession(queue, sessionId)
+    .filter((item) => item.sending === true)
+    .map((item) => ({
+      role: 'user',
+      text: item.text,
+      time: item.queuedAt,
+      kind: 'chat',
+      clientRenderId: `queued:${item.runId}`,
+      imagePath: item.imagePath,
+      imageUrl: item.imageUrl,
+      attachedFiles: item.attachedFiles,
+      replyToId: item.replyToId,
+      runId: item.runId,
+    }))
+}
+
+export function mergeQueuedTranscriptMessages(
+  messages: Message[],
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  const queuedTranscript = buildQueuedTranscriptMessages(queue, sessionId)
+  if (queuedTranscript.length === 0) return messages
+  const merged = [...messages]
+  for (const queuedMessage of queuedTranscript) {
+    const queuedRunId = typeof queuedMessage.runId === 'string' && queuedMessage.runId.trim()
+      ? queuedMessage.runId
+      : null
+    if (queuedRunId && merged.some((message) => message.role === 'user' && message.runId === queuedRunId)) {
+      continue
+    }
+    // Place queued user message before its corresponding assistant response
+    // (same runId), otherwise append after the last persisted message.
+    const sameRunAssistantIndex = queuedRunId
+      ? merged.findIndex((msg) => msg.role === 'assistant' && msg.runId === queuedRunId)
+      : -1
+    if (sameRunAssistantIndex >= 0) {
+      merged.splice(sameRunAssistantIndex, 0, queuedMessage)
+    } else {
+      const lastPersistedIndex = merged.findLastIndex(
+        (msg) => !msg.clientRenderId?.startsWith('queued:'),
+      )
+      const insertAt = lastPersistedIndex >= 0 ? lastPersistedIndex + 1 : merged.length
+      merged.splice(insertAt, 0, queuedMessage)
+    }
+  }
+  return merged
+}
+
 export function removeQueuedMessageById(
   queue: QueuedSessionMessage[],
   id: string,

package/src/lib/server/agents/agent-service.ts

@@ -1,5 +1,6 @@
 import { genId } from '@/lib/id'
 import { resolveAgentToolSelection } from '@/lib/agent-default-tools'
+import { normalizeAgentExecuteConfig } from '@/lib/agent-execute-defaults'
 import { normalizeAgentSandboxConfig } from '@/lib/agent-sandbox-defaults'
 import { normalizeCapabilitySelection } from '@/lib/capability-selection'
 import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
@@ -180,6 +181,7 @@ export function createAgent(input: {
     sessionDailyResetAt: typeof body.sessionDailyResetAt === 'string' ? body.sessionDailyResetAt : null,
     sessionResetTimezone: typeof body.sessionResetTimezone === 'string' ? body.sessionResetTimezone : null,
     sandboxConfig: normalizeAgentSandboxConfig(body.sandboxConfig),
+    executeConfig: body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig),
     createdAt: now,
     updatedAt: now,
   }
@@ -225,6 +227,9 @@ export function updateAgent(agentId: string, body: Record<string, unknown>): Age
     if (body.sandboxConfig !== undefined) {
       agent.sandboxConfig = normalizeAgentSandboxConfig(body.sandboxConfig)
     }
+    if (body.executeConfig !== undefined) {
+      agent.executeConfig = body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig)
+    }
     if (
       body.provider !== undefined
       || body.orchestratorEnabled !== undefined

package/src/lib/server/builtin-extensions.ts

@@ -1,4 +1,5 @@
 import '@/lib/server/session-tools/shell'
+import '@/lib/server/session-tools/execute'
 import '@/lib/server/session-tools/file'
 import '@/lib/server/session-tools/edit_file'
 import '@/lib/server/session-tools/web'

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

@@ -470,7 +470,7 @@ describe('hasDirectLocalCodingTools', () => {
     assert.equal(hasDirectLocalCodingTools({ tools: ['files'] }), true)
   })
 
-  it('returns true for sandbox extension', () => {
+  it('returns true for legacy sandbox alias', () => {
     assert.equal(hasDirectLocalCodingTools({ tools: ['sandbox'] }), true)
   })
 })

package/src/lib/server/chat-execution/chat-execution-tool-events.test.ts

@@ -259,6 +259,7 @@ describe('hasDirectLocalCodingTools', () => {
   it('treats shell and file tooling as local coding capability', () => {
     assert.equal(hasDirectLocalCodingTools({ extensions: ['files'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['shell'] }), true)
+    assert.equal(hasDirectLocalCodingTools({ extensions: ['execute'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['edit_file'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['delegate'] }), false)
   })

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

@@ -324,8 +324,6 @@ export function requestedToolNamesFromMessage(message: string): string[] {
     'wallet_tool',
     'http_request',
     'send_file',
-    'sandbox_exec',
-    'sandbox_list_runtimes',
     'schedule_wake',
     'spawn_subagent',
     'ask_human',
@@ -338,6 +336,7 @@ export function requestedToolNamesFromMessage(message: string): string[] {
     'browser',
     'web',
     'shell',
+    'execute',
     'files',
     'edit_file',
     'canvas',
@@ -370,6 +369,7 @@ export function enabledDelegationTools(session: SessionWithTools): DelegateTool[
 export function hasDirectLocalCodingTools(session: SessionWithTools): boolean {
   return [
     'shell',
+    'execute',
     'execute_command',
     'files',
     'edit_file',

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

@@ -76,6 +76,7 @@ import {
 import { checkAgentBudgetLimits } from '@/lib/server/cost'
 import {
   classifyMessage,
+  type MessageClassification,
   toMessageSemanticsSummary,
 } from '@/lib/server/chat-execution/message-classifier'
 import {
@@ -87,6 +88,7 @@ import {
 } from '@/lib/server/chat-execution/chat-execution-utils'
 import { loadEstopState } from '@/lib/server/runtime/estop'
 import { buildToolSection, joinPromptSegments } from '@/lib/server/chat-execution/prompt-builder'
+import { resolvePromptMode, type PromptMode } from '@/lib/server/chat-execution/prompt-mode'
 import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 import type { ExecuteChatTurnInput } from '@/lib/server/chat-execution/chat-execution'
 
@@ -320,13 +322,17 @@ function buildLightHeartbeatSystemPrompt(session: Session): string | undefined {
   return parts.join('\n\n')
 }
 
-function buildAgentSystemPrompt(session: Session): string | undefined {
+function buildAgentSystemPrompt(
+  session: Session,
+  options?: { lightweightDirectChat?: boolean },
+): string | undefined {
   if (!session.agentId) return undefined
   const agent = getAgent(session.agentId)
   if (!agent) return undefined
 
   const settings = loadSettings()
   const allowSilentReplies = isDirectConnectorSession(session)
+  const lightweightDirectChat = options?.lightweightDirectChat === true
   const parts: string[] = []
   const enabledExtensions = listUniversalToolAccessExtensionIds(
     getEnabledCapabilityIds(session).length > 0 ? getEnabledCapabilityIds(session) : getEnabledCapabilityIds(agent),
@@ -341,7 +347,7 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   if (agent.description) identityLines.push(`Description: ${agent.description}`)
   identityLines.push('I should always embody this identity. I am not just an "Assistant" — I am a persistent companion with my own soul and presence.')
   parts.push(identityLines.join('\n'))
-  const continuityBlock = buildIdentityContinuityContext(session, agent)
+  const continuityBlock = lightweightDirectChat ? null : buildIdentityContinuityContext(session, agent)
   if (continuityBlock) parts.push(continuityBlock)
 
   const runtimeLines = [
@@ -358,50 +364,57 @@ function buildAgentSystemPrompt(session: Session): string | undefined {
   if (agent.soul) parts.push(`## Soul\n${agent.soul}`)
   if (agent.systemPrompt) parts.push(`## System Prompt\n${agent.systemPrompt}`)
 
-  try {
-    const runtimeSkills = resolveRuntimeSkills({
-      cwd: session.cwd,
-      enabledExtensions,
-      agentId: agent.id,
-      sessionId: session.id,
-      userId: session.user,
-      agentSkillIds: agent.skillIds || [],
-      storedSkills: loadSkills(),
-      selectedSkillId: session.skillRuntimeState?.selectedSkillId || null,
-    })
-    parts.push(...buildRuntimeSkillPromptBlocks(runtimeSkills))
-  } catch {
-    // Runtime skills are non-critical during prompt assembly.
-  }
+  if (!lightweightDirectChat) {
+    try {
+      const runtimeSkills = resolveRuntimeSkills({
+        cwd: session.cwd,
+        enabledExtensions,
+        agentId: agent.id,
+        sessionId: session.id,
+        userId: session.user,
+        agentSkillIds: agent.skillIds || [],
+        storedSkills: loadSkills(),
+        selectedSkillId: session.skillRuntimeState?.selectedSkillId || null,
+      })
+      parts.push(...buildRuntimeSkillPromptBlocks(runtimeSkills))
+    } catch {
+      // Runtime skills are non-critical during prompt assembly.
+    }
 
-  try {
-    const wsCtx = buildWorkspaceContext({ cwd: session.cwd })
-    if (wsCtx.block) parts.push(wsCtx.block)
-  } catch {
-    // Workspace context is non-critical.
+    try {
+      const wsCtx = buildWorkspaceContext({ cwd: session.cwd })
+      if (wsCtx.block) parts.push(wsCtx.block)
+    } catch {
+      // Workspace context is non-critical.
+    }
   }
 
   const thinkingHint = [
     '## Output Format',
     'If your model supports internal reasoning/thinking, put all internal analysis inside <think>...</think> tags.',
     'Your final response to the user should be clear and concise.',
+    ...(lightweightDirectChat
+      ? ['This is a lightweight direct chat turn. Reply naturally in 1-3 short sentences. Do not delegate, plan, or narrate tools unless the user adds a concrete task that needs that escalation.']
+      : []),
     allowSilentReplies
       ? 'When you truly have nothing to say, respond with ONLY: NO_MESSAGE'
       : 'For direct user chats, always send a visible reply. Never answer with NO_MESSAGE or HEARTBEAT_OK unless this is an explicit heartbeat poll.',
   ]
   parts.push(thinkingHint.join('\n'))
 
-  if (enabledExtensions.length === 0) {
-    parts.push(buildNoToolsGuidance().join('\n'))
-  } else {
-    parts.push(buildEnabledToolsAutonomyGuidance().join('\n'))
+  if (!lightweightDirectChat) {
+    if (enabledExtensions.length === 0) {
+      parts.push(buildNoToolsGuidance().join('\n'))
+    } else {
+      parts.push(buildEnabledToolsAutonomyGuidance().join('\n'))
+    }
+    const toolSectionLines = buildToolSection(enabledExtensions)
+    if (toolSectionLines.length > 0) parts.push(['## Tool Discipline', ...toolSectionLines].join('\n'))
+    const operatingGuidance = collectCapabilityOperatingGuidance(enabledExtensions)
+    if (operatingGuidance.length > 0) parts.push(['## Tool Guidance', ...operatingGuidance].join('\n'))
+    const capabilityLines = collectCapabilityDescriptions(enabledExtensions)
+    if (capabilityLines.length > 0) parts.push(['## Tool Capabilities', ...capabilityLines].join('\n'))
   }
-  const toolSectionLines = buildToolSection(enabledExtensions)
-  if (toolSectionLines.length > 0) parts.push(['## Tool Discipline', ...toolSectionLines].join('\n'))
-  const operatingGuidance = collectCapabilityOperatingGuidance(enabledExtensions)
-  if (operatingGuidance.length > 0) parts.push(['## Tool Guidance', ...operatingGuidance].join('\n'))
-  const capabilityLines = collectCapabilityDescriptions(enabledExtensions)
-  if (capabilityLines.length > 0) parts.push(['## Tool Capabilities', ...capabilityLines].join('\n'))
 
   parts.push([
     '## Heartbeats',
@@ -470,6 +483,8 @@ export interface PreparedExecutableChatTurn {
   runStartedAt: number
   runMessageStartIndex: number
   toolPolicy: ReturnType<typeof resolveSessionToolPolicy>
+  classification: MessageClassification | null
+  promptMode: PromptMode
 }
 
 export type PreparedChatTurn = PreparedBlockedChatTurn | PreparedExecutableChatTurn
@@ -620,6 +635,24 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
     }
   }
 
+  const turnHistory = getMessages(sessionId)
+  const classification = !internal
+    ? await classifyMessage({
+        sessionId,
+        agentId: session.agentId || null,
+        message,
+        history: turnHistory,
+      }).catch(() => null as MessageClassification | null)
+    : null
+  const lightweightDirectChat = classification?.isLightweightDirectChat === true
+    && !internal
+    && source === 'chat'
+    && !isDirectConnectorSession(sessionForRun)
+  const promptMode = resolvePromptMode(sessionForRun, { preferMinimalPrompt: lightweightDirectChat })
+  if (lightweightDirectChat && sessionForRun.thinkingLevel !== 'minimal') {
+    sessionForRun = { ...sessionForRun, thinkingLevel: 'minimal' }
+  }
+
   if (isHeartbeatRun && input.modelOverride) {
     sessionForRun = { ...sessionForRun, model: input.modelOverride }
   }
@@ -632,7 +665,10 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
   if (extensionsForRun.length > 0) {
     const modelResolvePrompt = heartbeatLightContext
       ? (joinSystemPromptBlocks(buildLightHeartbeatSystemPrompt(sessionForRun), executionBriefContextBlock) || '')
-      : (joinSystemPromptBlocks(buildAgentSystemPrompt(sessionForRun), executionBriefContextBlock) || '')
+      : (joinSystemPromptBlocks(
+          buildAgentSystemPrompt(sessionForRun, { lightweightDirectChat }),
+          executionBriefContextBlock,
+        ) || '')
     const modelResolve = await runCapabilityBeforeModelResolve(
       {
         session: sessionForRun,
@@ -724,14 +760,7 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
   if (shouldPersistUserMessage) {
     const [linkAnalysis, semantics] = await Promise.all([
       !internal ? runLinkUnderstanding(message) : Promise.resolve([]),
-      classifyMessage({
-        sessionId,
-        agentId: session.agentId || null,
-        message,
-        history: getMessages(sessionId),
-      })
-        .then((classification) => toMessageSemanticsSummary(classification))
-        .catch(() => undefined),
+      Promise.resolve(toMessageSemanticsSummary(classification)),
     ])
     const guardedUserText = guardUntrustedText({
       text: message,
@@ -745,6 +774,7 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
         role: 'user',
         text: guardedUserText,
         time: Date.now(),
+        runId: lifecycleRunId,
         imagePath: imagePath || undefined,
         imageUrl: imageUrl || undefined,
         attachedFiles: attachedFiles?.length ? attachedFiles : undefined,
@@ -805,7 +835,12 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
 
   const systemPrompt = heartbeatLightContext
     ? joinSystemPromptBlocks(buildLightHeartbeatSystemPrompt(sessionForRun), executionBriefContextBlock)
-    : (hasExtensions ? undefined : joinSystemPromptBlocks(buildAgentSystemPrompt(sessionForRun), executionBriefContextBlock))
+    : (hasExtensions
+        ? undefined
+        : joinSystemPromptBlocks(
+            buildAgentSystemPrompt(sessionForRun, { lightweightDirectChat }),
+            executionBriefContextBlock,
+          ))
 
   return {
     kind: 'ready',
@@ -837,5 +872,7 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
     runStartedAt,
     runMessageStartIndex,
     toolPolicy,
+    classification,
+    promptMode,
   }
 }

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

@@ -76,6 +76,8 @@ export async function executePreparedChatTurn(params: {
     isAutoRunNoHistory,
     executionBrief,
     executionBriefContextBlock,
+    classification,
+    promptMode,
   } = prepared
 
   const emit = partialPersistence.emit
@@ -151,6 +153,8 @@ export async function executePreparedChatTurn(params: {
         history: heartbeatHistory ?? applyContextClearBoundary(getSessionMessages(sessionId)),
         signal: abortController.signal,
         source,
+        classification,
+        promptMode,
       })
       fullResponse = result.finalResponse || result.fullText
     } else {

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

@@ -102,6 +102,13 @@ function checkUnfinishedToolCallsPending(ctx: ContinuationContext): Continuation
   return null
 }
 
+function checkLightweightDirectChat(ctx: ContinuationContext): ContinuationDecision | null {
+  if (ctx.classification?.isLightweightDirectChat !== true) return null
+  if (!ctx.state.fullText.trim()) return null
+  if (ctx.state.hasToolCalls || ctx.state.streamedToolEvents.length > 0) return null
+  return { type: false, requiredToolReminderNames: [] }
+}
+
 function checkLoopDetection(ctx: ContinuationContext): ContinuationDecision | null {
   const isToolFrequency = (ctx.state.loopDetectionTriggered?.detector === 'tool_frequency') || ctx.state.toolFrequencyBlocked
   if (!ctx.state.loopDetectionTriggered && !isToolFrequency) return null
@@ -412,6 +419,7 @@ export function evaluateContinuation(ctx: ContinuationContext): ContinuationDeci
   const checks = [
     checkUnfinishedToolCallsPending,
     checkLoopDetection,
+    checkLightweightDirectChat,
     checkCoordinatorDelegation,
     checkExecutionContinuation,
     checkRequiredTools,

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

@@ -112,7 +112,7 @@ export function shouldTerminateOnSuccessfulMemoryMutation(params: {
     : exactToolName === 'memory_update'
       ? 'update'
       : resolveToolAction(params.toolInput)
-  if (action !== 'store' && action !== 'update') return false
+  if (action !== 'store' && action !== 'update' && action !== 'write') 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