@swarmclawai/swarmclaw 1.2.5 → 1.2.8

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

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

@@ -31,6 +31,7 @@ export const MessageClassificationSchema = z.object({
   taskIntent: TaskIntentSchema,
   isDeliverableTask: z.boolean(),
   isBroadGoal: z.boolean(),
+  isLightweightDirectChat: z.boolean().optional().default(false),
   walletIntent: z.enum(['none', 'read_only', 'transactional']),
   hasHumanSignals: z.boolean(),
   hasSignificantEvent: z.boolean(),
@@ -47,6 +48,7 @@ export interface MessageClassification {
   taskIntent: MessageTaskIntent
   isDeliverableTask: boolean
   isBroadGoal: boolean
+  isLightweightDirectChat?: boolean
   walletIntent: 'none' | 'read_only' | 'transactional'
   hasHumanSignals: boolean
   hasSignificantEvent: boolean
@@ -102,6 +104,7 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     '- taskIntent: The primary execution intent. Use exactly one of: "coding", "research", "browsing", "outreach", "scheduling", or "general". Choose "coding" for repo/code/build/debug/edit tasks. Choose "research" for gathering current info or synthesizing sources. Choose "browsing" for page navigation, rendered-page inspection, form work, or literal browser workflows. Choose "outreach" for sending/sharing/delivering updates to an external channel. Choose "scheduling" for reminders, recurring work, monitoring, or follow-up scheduling. Choose "general" when none of the above clearly fits.',
     '- isDeliverableTask (bool): The user wants a concrete artifact produced — a document, report, plan, proposal, landing page, dashboard, HTML file, markdown file, brief, copy, screenshots, or similar deliverable. NOT simple Q&A, code fixes, or single-command tasks.',
     '- isBroadGoal (bool): The message describes a broad, multi-step goal (50+ chars, no code blocks, no file paths, no numbered lists). Short questions ending with "?" are NOT broad goals.',
+    '- isLightweightDirectChat (bool): This is a low-signal direct chat turn that should get a natural lightweight reply, such as a greeting, acknowledgment, check-in, or simple social/direct question that does NOT require research, file work, planning, delegation, or tool execution.',
     '- walletIntent: "none" if no crypto/wallet/trading context. "read_only" if mentioning wallet/crypto but only for checking balances, viewing transactions, or research. "transactional" if the user wants to swap, trade, buy, sell, mint, claim, deposit, withdraw, bridge, or execute a transaction.',
     '- hasHumanSignals (bool): The message contains personal signals — preferences ("I prefer", "call me"), relationships ("my wife", "my partner", "my kid"), life events ("birthday", "wedding", "promotion", "moving", "graduation", "hospital"), or personal disclosures.',
     '- hasSignificantEvent (bool): The message mentions a notable life/work event or milestone (birthday, anniversary, wedding, graduation, promotion, new job, relocation, illness, funeral, travel, house, deadline, launch).',
@@ -115,13 +118,14 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     '',
     'Rules:',
     '- Be conservative. When unsure, default to false/none/empty.',
+    '- Mark isLightweightDirectChat true only when a short natural reply is enough and escalating into planning, delegation, or tool execution would be unnecessary.',
     '- A message can be both a deliverable task AND a broad goal.',
     '- "walletIntent" should be "transactional" only if the user wants to execute a state-changing action, not just discuss crypto.',
     '- For "explicitToolRequests", only include tools the user explicitly mentions by name or clear synonym. Do not infer tool needs from the task type.',
     '- Prefer the most execution-relevant taskIntent. Example: "research this and send me a voice note" is "research", not "outreach".',
     '',
     'Output shape:',
-    '{"taskIntent":"coding|research|browsing|outreach|scheduling|general","isDeliverableTask":bool,"isBroadGoal":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"workType":"coding|research|writing|review|operations|general","wantsScreenshots":bool,"wantsOutboundDelivery":bool,"wantsVoiceDelivery":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
+    '{"taskIntent":"coding|research|browsing|outreach|scheduling|general","isDeliverableTask":bool,"isBroadGoal":bool,"isLightweightDirectChat":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"workType":"coding|research|writing|review|operations|general","wantsScreenshots":bool,"wantsOutboundDelivery":bool,"wantsVoiceDelivery":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
     '',
     recentHistory ? `Recent context:\n${recentHistory}\n` : '',
     `User message: ${JSON.stringify(message)}`,
@@ -276,6 +280,7 @@ export function toMessageSemanticsSummary(classification: MessageClassification
     isDeliverableTask: classification.isDeliverableTask,
     isBroadGoal: classification.isBroadGoal,
     isResearchSynthesis: classification.isResearchSynthesis,
+    isLightweightDirectChat: classification.isLightweightDirectChat === true,
     hasHumanSignals: classification.hasHumanSignals,
     hasSignificantEvent: classification.hasSignificantEvent,
     wantsScreenshots: classification.wantsScreenshots === true,
@@ -324,3 +329,8 @@ export function isResearchSynthesis(classification: MessageClassification | null
   void routingIntent
   return classification?.isResearchSynthesis === true
 }
+
+export function isLightweightDirectChat(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.isLightweightDirectChat === true
+}

package/src/lib/server/chat-execution/prompt-builder.test.ts

@@ -26,4 +26,32 @@ describe('buildAgenticExecutionPolicy', () => {
     assert.ok(prompt.includes('use the concrete tool now'))
     assert.ok(prompt.includes('prefer the direct `manage_*` tool'))
   })
+
+  it('adds lightweight direct-chat guidance when classification marks the turn as lightweight', () => {
+    const prompt = buildAgenticExecutionPolicy({
+      enabledExtensions: ['memory', 'files', 'delegate'],
+      loopMode: 'bounded',
+      heartbeatPrompt: 'HEARTBEAT',
+      heartbeatIntervalSec: 120,
+      userMessage: 'Hello',
+      history: [],
+      classification: {
+        taskIntent: 'general',
+        isDeliverableTask: false,
+        isBroadGoal: false,
+        isLightweightDirectChat: true,
+        walletIntent: 'none',
+        hasHumanSignals: false,
+        hasSignificantEvent: false,
+        isResearchSynthesis: false,
+        workType: 'general',
+        explicitToolRequests: [],
+        confidence: 0.98,
+      },
+    })
+
+    assert.ok(prompt.includes('## Lightweight Chat'))
+    assert.ok(prompt.includes('Reply naturally and briefly.'))
+    assert.ok(prompt.includes('prefer 1-3 short sentences'))
+  })
 })

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

@@ -75,7 +75,6 @@ function buildExtensionCapabilityLines(enabledExtensions: string[], opts?: { del
 
 const DISPLAY_TOOL_ALIASES: Record<string, string[]> = {
   files: ['send_file'],
-  shell: ['sandbox_exec', 'sandbox_list_runtimes'],
 }
 
 function buildExactToolNameList(enabledExtensions: string[]): string[] {
@@ -158,6 +157,7 @@ export function buildToolDisciplineLines(enabledExtensions: string[]): string[]
     ...(researchSearchTools.length || researchFetchTools.length ? [...researchSearchTools, ...researchFetchTools] : []),
     ...httpTools,
     ...(uniqueTools.includes('shell') ? ['shell'] : []),
+    ...(uniqueTools.includes('execute') ? ['execute'] : []),
     ...(uniqueTools.includes('browser') ? ['browser'] : []),
   ]))
   if (alternateResearchTools.length >= 2) {
@@ -330,6 +330,7 @@ export function buildAgenticExecutionPolicy(opts: {
   const hasManageSessions = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_sessions')
   const hasManageTasks = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_tasks')
   const hasManageSkills = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')
+  const lightweightDirectChat = opts.classification?.isLightweightDirectChat === true && !opts.isDirectConnectorSession
   const hasDelegationTools = opts.enabledExtensions.some((toolId) => {
     const canonical = canonicalizeExtensionId(toolId) || toolId
     return canonical === 'delegate' || canonical === 'spawn_subagent'
@@ -359,6 +360,15 @@ export function buildAgenticExecutionPolicy(opts: {
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
   )
 
+  if (lightweightDirectChat) {
+    parts.push(
+      '## Lightweight Chat',
+      'This turn is a lightweight direct chat. Reply naturally and briefly.',
+      'Do not delegate, create tasks, outline a workflow, or narrate tools unless the user adds a concrete task that actually requires that escalation.',
+      'For greetings, acknowledgements, and simple social questions, a short human-sounding answer is sufficient.',
+    )
+  }
+
   if (hasTooling) {
     parts.push(
       '## Routing Matrix',
@@ -444,6 +454,9 @@ export function buildAgenticExecutionPolicy(opts: {
     ]),
     '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.',
+    ...(lightweightDirectChat
+      ? ['For this turn, prefer 1-3 short sentences over bullets, planning, or process narration.']
+      : []),
     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'

package/src/lib/server/chat-execution/prompt-mode.test.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { resolvePromptMode } from '@/lib/server/chat-execution/prompt-mode'
+
+describe('resolvePromptMode', () => {
+  it('returns full for root sessions by default', () => {
+    assert.equal(resolvePromptMode({ id: 'root' } as never), 'full')
+  })
+
+  it('prefers minimal mode for lightweight direct-chat turns', () => {
+    assert.equal(
+      resolvePromptMode({ id: 'root' } as never, { preferMinimalPrompt: true }),
+      'minimal',
+    )
+  })
+
+  it('keeps delegated child sessions in minimal mode', () => {
+    assert.equal(
+      resolvePromptMode({ id: 'child', parentSessionId: 'parent' } as never, { preferMinimalPrompt: false }),
+      'minimal',
+    )
+  })
+})

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

@@ -20,7 +20,11 @@ export type PromptMode = 'full' | 'minimal' | 'none'
  *   proactive memory, thinking guidance
  * - `none` — reserved for bare identity (light heartbeat path)
  */
-export function resolvePromptMode(session: Session): PromptMode {
+export function resolvePromptMode(
+  session: Session,
+  options?: { preferMinimalPrompt?: boolean },
+): PromptMode {
   if (session.parentSessionId) return 'minimal'
+  if (options?.preferMinimalPrompt) return 'minimal'
   return 'full'
 }

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

@@ -65,14 +65,13 @@ const streamContinuationSource = _readSibling('stream-continuation.ts')
 const streamSources = `${streamAgentChatSource}\n${streamContinuationSource}`
 
 describe('buildToolDisciplineLines', () => {
-  it('lists exact callable tool names for extension families like sandbox and browser', () => {
+  it('lists exact callable tool names for legacy sandbox aliases and browser', () => {
     const lines = buildToolAvailabilityLines(['sandbox', 'browser', 'manage_schedules'])
 
     assert.equal(lines[0], 'Tool names are case-sensitive. Call tools exactly as listed.')
     assert.ok(lines.includes('- `browser`'))
+    assert.ok(lines.includes('- `execute`'))
     assert.ok(lines.includes('- `manage_schedules`'))
-    assert.ok(lines.includes('- `sandbox_exec`'))
-    assert.ok(lines.includes('- `sandbox_list_runtimes`'))
   })
 
   it('tells the agent to use direct platform tools when manage_platform is absent', () => {
@@ -1033,7 +1032,7 @@ describe('shouldForceDeliverableFollowthrough', () => {
           { name: 'web', input: '{"action":"fetch","url":"https://example.com/topic"}', output: '<html>topic</html>' },
         ],
         history: [
-          { role: 'user', text: 'Research 3 topics, take screenshots, write markdown and PDF files, then build a site for each topic.' },
+          { role: 'user', text: 'Research 3 topics, take screenshots, write markdown and PDF files, then build a site for each topic.', time: Date.now() },
         ],
       }),
       true,
@@ -1275,6 +1274,7 @@ describe('parseClassificationResponse', () => {
 
 describe('message classifier adapter functions', () => {
   const deliverableClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: true,
     isBroadGoal: true,
     walletIntent: 'none',
@@ -1286,6 +1286,7 @@ describe('message classifier adapter functions', () => {
   }
 
   const walletClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: false,
     isBroadGoal: false,
     walletIntent: 'transactional',
@@ -1297,6 +1298,7 @@ describe('message classifier adapter functions', () => {
   }
 
   const humanSignalClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: false,
     isBroadGoal: false,
     walletIntent: 'none',

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

@@ -190,6 +190,7 @@ interface StreamAgentChatOpts {
   fallbackCredentialIds?: string[]
   signal?: AbortSignal
   promptMode?: PromptMode
+  classification?: MessageClassification | null
   /** Run source (e.g. 'heartbeat', 'chat', 'scheduler') — used for heartbeat-specific tuning. */
   source?: string
 }
@@ -223,10 +224,23 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
-  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, executionBrief, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const {
+    session,
+    message,
+    imagePath,
+    imageUrl,
+    attachedFiles,
+    apiKey,
+    systemPrompt,
+    executionBrief,
+    extraSystemContext,
+    write,
+    history,
+    fallbackCredentialIds,
+    signal,
+    classification: providedClassification,
+  } = opts
   const isHeartbeat = isHeartbeatSource(opts.source)
-  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
-  const isMinimalPrompt = promptMode === 'minimal'
   const isConnectorSession = isDirectConnectorSession(session)
   const rawExtensions = getEnabledCapabilityIds(session)
   const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
@@ -241,6 +255,23 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   const sessionAgent = session.agentId ? getAgent(session.agentId) : null
 
+  const classificationPromise = providedClassification !== undefined
+    ? Promise.resolve(providedClassification)
+    : classifyMessage({
+        sessionId: session.id,
+        agentId: session.agentId,
+        message,
+        history,
+      }).catch(() => null as MessageClassification | null)
+  const classification = await classificationPromise
+  const lightweightDirectChat = classification?.isLightweightDirectChat === true
+    && !isConnectorSession
+    && !isHeartbeat
+  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session, {
+    preferMinimalPrompt: lightweightDirectChat,
+  })
+  const isMinimalPrompt = promptMode === 'minimal'
+
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
   if (session.thinkingLevel) {
@@ -248,6 +279,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   } else if (sessionAgent) {
     agentThinkingLevel = sessionAgent.thinkingLevel
   }
+  if (lightweightDirectChat) {
+    agentThinkingLevel = 'minimal'
+  }
 
   const llm = buildChatModel({
     provider: session.provider,
@@ -296,16 +330,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     return Math.max(0, Math.min(3600, Math.trunc(parsed)))
   })()
 
-  // -------------------------------------------------------------------------
-  // Start message classification in the background (LLM-based, ~200-800ms)
-  // -------------------------------------------------------------------------
-  const classificationPromise = classifyMessage({
-    sessionId: session.id,
-    agentId: session.agentId,
-    message,
-    history,
-  }).catch(() => null as MessageClassification | null)
-
   // -------------------------------------------------------------------------
   // System prompt assembly (stays inline — many async calls + local state)
   // -------------------------------------------------------------------------
@@ -426,8 +450,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const suggestionsBlock = buildSuggestionsSection(settings.suggestionsEnabled, isMinimalPrompt)
   if (suggestionsBlock) promptParts.push(suggestionsBlock)
 
-  // Await classification before building the agentic execution policy
-  const classification = await classificationPromise
   const delegationAdvisory = sessionAgent && agentDelegationEnabled
     ? resolveDelegationAdvisory({
         currentAgent: sessionAgent,
@@ -1138,7 +1160,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       }
 
       // Async LLM-based incomplete-action check: catches "I'll run the deployment:" with no tool calls
-      if (!shouldContinue && outcome && !state.hasToolCalls && state.fullText.trim().length > 0 && state.fullText.trim().length < 500) {
+      if (
+        !shouldContinue
+        && outcome
+        && !state.hasToolCalls
+        && classification?.isLightweightDirectChat !== true
+        && state.fullText.trim().length > 0
+        && state.fullText.trim().length < 500
+      ) {
         const completeness = await evaluateResponseCompleteness({
           sessionId: session.id,
           agentId: session.agentId,

package/src/lib/server/chatrooms/chatroom-routing.test.ts

@@ -16,6 +16,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['deploy', 'infrastructure'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
   design: {
     id: 'design',
@@ -25,6 +27,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['design', 'ui'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
 }
 

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

@@ -217,8 +217,8 @@ const discord: PlatformConnector = {
             return String(sent.id || '')
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await message.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }