@swarmclawai/swarmclaw 0.6.4 → 0.6.7

package/src/components/wallets/wallet-section.tsx

@@ -0,0 +1,100 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+import { api } from '@/lib/api-client'
+import type { AgentWallet, WalletChain } from '@/types'
+
+interface WalletSectionProps {
+  agentId: string
+  wallet: (Omit<AgentWallet, 'encryptedPrivateKey'> & { balanceLamports?: number; balanceSol?: number }) | null
+  onWalletCreated: () => void
+}
+
+export function WalletSection({ agentId, wallet, onWalletCreated }: WalletSectionProps) {
+  const [creating, setCreating] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [copied, setCopied] = useState(false)
+
+  const createWallet = useCallback(async () => {
+    setCreating(true)
+    setError(null)
+    try {
+      await api('POST', '/wallets', { agentId, chain: 'solana' as WalletChain })
+      onWalletCreated()
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+    } finally {
+      setCreating(false)
+    }
+  }, [agentId, onWalletCreated])
+
+  const copyAddress = useCallback(() => {
+    if (!wallet) return
+    navigator.clipboard.writeText(wallet.publicKey)
+    setCopied(true)
+    setTimeout(() => setCopied(false), 2000)
+  }, [wallet])
+
+  return (
+    <div className="mb-8">
+      <div className="flex items-center gap-2 mb-3">
+        <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em]">
+          Wallet
+        </label>
+        <span className="px-1.5 py-0.5 rounded-[4px] bg-amber-500/15 text-amber-400 text-[9px] font-600 uppercase tracking-wide">
+          Experimental
+        </span>
+      </div>
+
+      {!wallet ? (
+        <div className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50">
+          <p className="text-[12px] text-text-3/70 mb-3">
+            Create a Solana wallet for this agent to hold funds, pay for services, and trade autonomously.
+          </p>
+          <button
+            type="button"
+            onClick={createWallet}
+            disabled={creating}
+            className="px-3 py-1.5 rounded-[8px] bg-accent-soft text-accent-bright text-[11px] font-600 hover:bg-accent-bright/15 transition-all cursor-pointer disabled:opacity-50 border border-accent-bright/20"
+            style={{ fontFamily: 'inherit' }}
+          >
+            {creating ? 'Creating...' : 'Create Wallet'}
+          </button>
+          {error && <p className="text-[11px] text-red-400 mt-2">{error}</p>}
+        </div>
+      ) : (
+        <div className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50 space-y-3">
+          <div className="flex items-center gap-2">
+            <span className="text-[10px] text-text-3/60 uppercase tracking-wide font-600">
+              {wallet.chain}
+            </span>
+            <span className="flex-1" />
+            {typeof wallet.balanceSol === 'number' && (
+              <span className="text-[13px] font-600 text-text-1">
+                {wallet.balanceSol.toFixed(4)} SOL
+              </span>
+            )}
+          </div>
+          <div className="flex items-center gap-2">
+            <code className="text-[11px] text-text-3 bg-black/20 px-2 py-1 rounded-[6px] font-mono truncate flex-1">
+              {wallet.publicKey}
+            </code>
+            <button
+              type="button"
+              onClick={copyAddress}
+              className="shrink-0 px-2 py-1 rounded-[6px] text-[10px] text-text-3 hover:text-text-2 border border-white/[0.08] bg-surface transition-colors cursor-pointer"
+              style={{ fontFamily: 'inherit' }}
+            >
+              {copied ? 'Copied!' : 'Copy'}
+            </button>
+          </div>
+          <div className="flex items-center gap-3 text-[10px] text-text-3/60">
+            <span>Limit: {((wallet.spendingLimitLamports ?? 100_000_000) / 1e9).toFixed(2)} SOL/tx</span>
+            <span>Daily: {((wallet.dailyLimitLamports ?? 1_000_000_000) / 1e9).toFixed(1)} SOL</span>
+            <span>{wallet.requireApproval ? 'Approval required' : 'Auto-send'}</span>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}

package/src/hooks/use-swipe.ts

@@ -0,0 +1,49 @@
+import { useRef, useCallback } from 'react'
+
+interface UseSwipeOptions {
+  onSwipe: (direction: 'left' | 'right') => void
+  /** Only trigger right-swipe from this many pixels from the left edge */
+  edgeWidth?: number
+  /** Minimum horizontal distance to count as a swipe */
+  threshold?: number
+  /** Whether left-swipe is currently allowed (e.g. sidebar is open) */
+  leftSwipeEnabled?: boolean
+}
+
+export function useSwipe({
+  onSwipe,
+  edgeWidth = 40,
+  threshold = 50,
+  leftSwipeEnabled = false,
+}: UseSwipeOptions) {
+  const startX = useRef(0)
+  const startY = useRef(0)
+  const isEdge = useRef(false)
+
+  const onTouchStart = useCallback((e: React.TouchEvent) => {
+    const touch = e.touches[0]
+    startX.current = touch.clientX
+    startY.current = touch.clientY
+    isEdge.current = touch.clientX <= edgeWidth
+  }, [edgeWidth])
+
+  // No-op — we only evaluate on touchend, but callers may wire this for consistency
+  const onTouchMove = useCallback(() => {}, [])
+
+  const onTouchEnd = useCallback((e: React.TouchEvent) => {
+    const touch = e.changedTouches[0]
+    const dx = touch.clientX - startX.current
+    const dy = touch.clientY - startY.current
+    // Ignore if vertical movement dominates
+    if (Math.abs(dy) > Math.abs(dx)) return
+    if (Math.abs(dx) < threshold) return
+
+    if (dx > 0 && isEdge.current) {
+      onSwipe('right')
+    } else if (dx < 0 && leftSwipeEnabled) {
+      onSwipe('left')
+    }
+  }, [threshold, leftSwipeEnabled, onSwipe])
+
+  return { onTouchStart, onTouchMove, onTouchEnd }
+}

package/src/lib/providers/anthropic.ts

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import https from 'https'
 import type { StreamChatOptions } from './index'
+import { PROVIDER_DEFAULTS } from './provider-defaults'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -23,7 +24,7 @@ function fileToContentBlocks(filePath: string): any[] {
   return [{ type: 'text', text: `[Attached file: ${filePath.split('/').pop()}]` }]
 }
 
-export function streamAnthropicChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
+export function streamAnthropicChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
     const messages = buildMessages(session, message, imagePath, loadHistory, imageUrl)
     const model = session.model || 'claude-sonnet-4-6'
@@ -43,9 +44,21 @@ export function streamAnthropicChat({ session, message, imagePath, imageUrl, api
     const payload = JSON.stringify(body)
     const abortController = { aborted: false }
     let fullResponse = ''
+    let apiReqRef: ReturnType<typeof https.request> | null = null
+
+    if (signal) {
+      if (signal.aborted) {
+        abortController.aborted = true
+      } else {
+        signal.addEventListener('abort', () => {
+          abortController.aborted = true
+          apiReqRef?.destroy()
+        }, { once: true })
+      }
+    }
 
     const apiReq = https.request({
-      hostname: 'api.anthropic.com',
+      hostname: PROVIDER_DEFAULTS.anthropic,
       path: '/v1/messages',
       method: 'POST',
       headers: {
@@ -109,6 +122,7 @@ export function streamAnthropicChat({ session, message, imagePath, imageUrl, api
       })
     })
 
+    apiReqRef = apiReq
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
     apiReq.on('error', (e) => {

package/src/lib/providers/claude-cli.ts

@@ -24,7 +24,7 @@ function findClaude(): string {
 
 const CLAUDE = findClaude()
 
-export function streamClaudeCliChat({ session, message, imagePath, systemPrompt, write, active }: StreamChatOptions): Promise<string> {
+export function streamClaudeCliChat({ session, message, imagePath, systemPrompt, write, active, signal }: StreamChatOptions): Promise<string> {
   const processTimeoutMs = loadRuntimeSettings().cliProcessTimeoutMs
   let prompt = message
   if (imagePath) {
@@ -108,6 +108,12 @@ export function streamClaudeCliChat({ session, message, imagePath, systemPrompt,
   proc.stdin!.end()
 
   active.set(session.id, proc)
+
+  if (signal) {
+    if (signal.aborted) { proc.kill(); }
+    else signal.addEventListener('abort', () => { proc.kill() }, { once: true })
+  }
+
   let fullResponse = ''
   let buf = ''
   let eventCount = 0

package/src/lib/providers/index.ts

@@ -29,6 +29,8 @@ export interface StreamChatOptions {
   active: Map<string, any>
   loadHistory: (sessionId: string) => any[]
   onUsage?: (usage: StreamChatUsage) => void
+  /** Abort signal from the caller — providers should use this to cancel in-flight requests. */
+  signal?: AbortSignal
 }
 
 interface BuiltinProviderConfig extends ProviderInfo {
@@ -351,6 +353,11 @@ export async function streamChatWithFailover(
           t: 'md',
           text: JSON.stringify({ failover: { from: credId, reason: err.message?.slice(0, 100) } }),
         })}\n\n`)
+        // Exponential backoff for rate-limit / server errors (skip for auth rotation)
+        if (statusCode !== 401) {
+          const delay = Math.min(500 * Math.pow(2, i), 8000)
+          await new Promise((r) => setTimeout(r, delay))
+        }
         continue
       }
       throw err

package/src/lib/providers/ollama.ts

@@ -2,16 +2,17 @@ import fs from 'fs'
 import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
+import { PROVIDER_DEFAULTS } from './provider-defaults'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
 
-export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
+export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
     const model = session.model || 'llama3'
     // Cloud: no endpoint but API key present → use Ollama cloud
-    const endpoint = session.apiEndpoint || (apiKey ? 'https://ollama.com' : 'http://localhost:11434')
+    const endpoint = session.apiEndpoint || (apiKey ? PROVIDER_DEFAULTS.ollamaCloud : PROVIDER_DEFAULTS.ollama)
 
     const parsed = new URL(endpoint)
     const isHttps = parsed.protocol === 'https:'
@@ -26,6 +27,18 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
 
     const abortController = { aborted: false }
     let fullResponse = ''
+    let apiReqRef: ReturnType<typeof http.request> | null = null
+
+    if (signal) {
+      if (signal.aborted) {
+        abortController.aborted = true
+      } else {
+        signal.addEventListener('abort', () => {
+          abortController.aborted = true
+          apiReqRef?.destroy()
+        }, { once: true })
+      }
+    }
 
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
@@ -87,6 +100,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
       })
     })
 
+    apiReqRef = apiReq
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
     apiReq.on('error', (e: NodeJS.ErrnoException) => {

package/src/lib/providers/openai.ts

@@ -1,5 +1,6 @@
 import fs from 'fs'
 import type { StreamChatOptions } from './index'
+import { PROVIDER_DEFAULTS } from './provider-defaults'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -43,7 +44,7 @@ async function fileToContentParts(filePath: string): Promise<any[]> {
   return [{ type: 'text', text: `[Attached file: ${name}]` }]
 }
 
-export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
+export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise(async (resolve) => {
     const messages = await buildMessages(session, message, imagePath, systemPrompt, loadHistory, imageUrl)
     const model = session.model || 'gpt-4o'
@@ -58,7 +59,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
     let fullResponse = ''
 
     // Support custom base URLs for custom providers
-    const baseUrl = session.apiEndpoint || 'https://api.openai.com/v1'
+    const baseUrl = session.apiEndpoint || PROVIDER_DEFAULTS.openai
     const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`
 
     // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware
@@ -67,6 +68,10 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
     const contentType = session.contentType || 'application/json'
 
     const abortController = new AbortController()
+    if (signal) {
+      if (signal.aborted) abortController.abort()
+      else signal.addEventListener('abort', () => abortController.abort(), { once: true })
+    }
     active.set(session.id, { kill: () => abortController.abort() })
 
     try {

package/src/lib/providers/openclaw.ts

@@ -279,7 +279,7 @@ async function connectToGateway(
 
 // --- Provider ---
 
-export function streamOpenClawChat({ session, message, imagePath, apiKey, write, active }: StreamChatOptions): Promise<string> {
+export function streamOpenClawChat({ session, message, imagePath, apiKey, write, active, signal }: StreamChatOptions): Promise<string> {
   let prompt = message
   if (imagePath) {
     prompt = `[The user has shared an image at: ${imagePath}]\n\n${message}`
@@ -316,6 +316,11 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
 
       active.set(session.id, { kill: () => { ws.close(); clearTimeout(timeout); finish('Aborted.') } })
 
+      if (signal) {
+        if (signal.aborted) { ws.close(); clearTimeout(timeout); finish('Aborted.'); return }
+        signal.addEventListener('abort', () => { ws.close(); clearTimeout(timeout); finish('Aborted.') }, { once: true })
+      }
+
       const agentReqId = randomUUID()
       ws.send(JSON.stringify({
         type: 'req',

package/src/lib/providers/provider-defaults.ts

@@ -0,0 +1,7 @@
+/** Default base URLs for built-in LLM providers */
+export const PROVIDER_DEFAULTS = {
+  openai: 'https://api.openai.com/v1',
+  anthropic: 'api.anthropic.com',
+  ollama: 'http://localhost:11434',
+  ollamaCloud: 'https://ollama.com',
+} as const

package/src/lib/schedule-templates.ts

@@ -0,0 +1,115 @@
+export interface ScheduleTemplate {
+  id: string
+  name: string
+  description: string
+  icon: string
+  category: 'monitoring' | 'reporting' | 'maintenance' | 'content'
+  defaults: {
+    taskPrompt: string
+    scheduleType: 'cron' | 'interval'
+    cron?: string
+    intervalMs?: number
+  }
+}
+
+export const SCHEDULE_TEMPLATES: ScheduleTemplate[] = [
+  {
+    id: 'daily-digest',
+    name: 'Daily Digest',
+    description: 'Summarize activity from the past 24 hours each morning',
+    icon: 'Newspaper',
+    category: 'reporting',
+    defaults: {
+      taskPrompt: 'Summarize all notable activity, events, and updates from the past 24 hours. Highlight key metrics, completed tasks, and anything that needs attention.',
+      scheduleType: 'cron',
+      cron: '0 9 * * *',
+    },
+  },
+  {
+    id: 'weekly-report',
+    name: 'Weekly Report',
+    description: 'Generate a weekly metrics and progress report every Monday',
+    icon: 'BarChart3',
+    category: 'reporting',
+    defaults: {
+      taskPrompt: 'Generate a comprehensive weekly report covering key metrics, completed tasks, ongoing work, blockers, and recommendations for the coming week.',
+      scheduleType: 'cron',
+      cron: '0 10 * * 1',
+    },
+  },
+  {
+    id: 'health-monitor',
+    name: 'Health Monitor',
+    description: 'Check system health and service status every 5 minutes',
+    icon: 'HeartPulse',
+    category: 'monitoring',
+    defaults: {
+      taskPrompt: 'Perform a system health check. Verify all services are running, check resource usage (CPU, memory, disk), and report any anomalies or degraded performance.',
+      scheduleType: 'interval',
+      intervalMs: 300000,
+    },
+  },
+  {
+    id: 'content-generation',
+    name: 'Content Generation',
+    description: 'Generate daily content such as posts, summaries, or briefs',
+    icon: 'PenLine',
+    category: 'content',
+    defaults: {
+      taskPrompt: 'Generate fresh content based on current trends and recent activity. Create a well-structured draft ready for review and publishing.',
+      scheduleType: 'cron',
+      cron: '0 8 * * *',
+    },
+  },
+  {
+    id: 'data-cleanup',
+    name: 'Data Cleanup',
+    description: 'Run weekly cleanup of stale data and temporary files',
+    icon: 'Trash2',
+    category: 'maintenance',
+    defaults: {
+      taskPrompt: 'Identify and clean up stale data, expired records, orphaned files, and temporary resources. Log what was removed and any issues encountered.',
+      scheduleType: 'cron',
+      cron: '0 2 * * 0',
+    },
+  },
+  {
+    id: 'metric-snapshot',
+    name: 'Metric Snapshot',
+    description: 'Capture an hourly snapshot of key metrics and KPIs',
+    icon: 'Activity',
+    category: 'monitoring',
+    defaults: {
+      taskPrompt: 'Capture a snapshot of all key metrics and KPIs. Record current values, compare against previous snapshots, and flag any significant changes or threshold breaches.',
+      scheduleType: 'interval',
+      intervalMs: 3600000,
+    },
+  },
+  {
+    id: 'security-audit',
+    name: 'Security Audit',
+    description: 'Run a daily security scan and vulnerability check',
+    icon: 'ShieldCheck',
+    category: 'monitoring',
+    defaults: {
+      taskPrompt: 'Perform a security audit. Check for unusual access patterns, review authentication logs, scan for known vulnerabilities, and report any security concerns.',
+      scheduleType: 'cron',
+      cron: '0 0 * * *',
+    },
+  },
+  {
+    id: 'backup-check',
+    name: 'Backup Check',
+    description: 'Verify backup integrity and completeness daily',
+    icon: 'DatabaseBackup',
+    category: 'maintenance',
+    defaults: {
+      taskPrompt: 'Verify that all scheduled backups completed successfully. Check backup integrity, storage usage, and retention policy compliance. Alert on any failures.',
+      scheduleType: 'cron',
+      cron: '0 3 * * *',
+    },
+  },
+]
+
+/** Subset of templates to feature in the empty state */
+export const FEATURED_TEMPLATE_IDS = ['daily-digest', 'health-monitor', 'content-generation'] as const

package/src/lib/server/agent-registry.ts

@@ -63,8 +63,8 @@ export function buildAgentAwarenessBlock(excludeId: string): string {
   })
 
   return [
-    '## Available Agents',
+    '## My Colleagues',
+    'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:',
     ...lines,
-    'You can delegate tasks to any agent using the delegate_to_agent tool.',
   ].join('\n')
 }

package/src/lib/server/alert-dispatch.ts

@@ -0,0 +1,64 @@
+import { loadSettings } from './storage'
+import type { AppNotification } from '@/types'
+
+/** In-memory rate limiter: dedupKey → last dispatch timestamp */
+const recentDispatches = new Map<string, number>()
+const DEDUP_WINDOW_MS = 60_000
+
+export async function dispatchAlert(notification: AppNotification): Promise<void> {
+  const settings = loadSettings()
+  const url = typeof settings.alertWebhookUrl === 'string' ? settings.alertWebhookUrl.trim() : ''
+  if (!url) return
+
+  const allowedEvents: string[] = Array.isArray(settings.alertWebhookEvents)
+    ? settings.alertWebhookEvents
+    : ['error']
+  if (!allowedEvents.includes(notification.type)) return
+
+  // Rate limit by dedupKey (or notification id as fallback)
+  const dedupKey = notification.dedupKey || notification.id
+  const now = Date.now()
+  const lastSent = recentDispatches.get(dedupKey)
+  if (lastSent && now - lastSent < DEDUP_WINDOW_MS) return
+  recentDispatches.set(dedupKey, now)
+
+  // Prune stale entries periodically
+  if (recentDispatches.size > 200) {
+    for (const [key, ts] of recentDispatches) {
+      if (now - ts > DEDUP_WINDOW_MS) recentDispatches.delete(key)
+    }
+  }
+
+  const webhookType = settings.alertWebhookType || 'custom'
+  let body: string
+
+  if (webhookType === 'discord') {
+    body = JSON.stringify({
+      content: `⚠️ **${notification.title}**${notification.message ? `\n${notification.message}` : ''}`,
+    })
+  } else if (webhookType === 'slack') {
+    body = JSON.stringify({
+      text: `⚠️ *${notification.title}*${notification.message ? `\n${notification.message}` : ''}`,
+    })
+  } else {
+    body = JSON.stringify({
+      type: notification.type,
+      title: notification.title,
+      message: notification.message || null,
+      entityType: notification.entityType || null,
+      entityId: notification.entityId || null,
+      timestamp: notification.createdAt,
+    })
+  }
+
+  try {
+    await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+      signal: AbortSignal.timeout(5000),
+    })
+  } catch (err: unknown) {
+    console.warn('[alert-dispatch] Webhook delivery failed:', err instanceof Error ? err.message : String(err))
+  }
+}

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

@@ -13,7 +13,7 @@ import {
   active,
 } from './storage'
 import { getProvider } from '@/lib/providers'
-import { estimateCost } from './cost'
+import { estimateCost, checkBudget } from './cost'
 import { log } from './logger'
 import { logExecution } from './execution-log'
 import { streamAgentChat } from './stream-agent-chat'
@@ -109,6 +109,21 @@ function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
   }
 }
 
+function shouldReplaceRecentAssistantMessage(params: {
+  previous: Message | null | undefined
+  nextToolEvents: MessageToolEvent[]
+  nextKind: Message['kind']
+  now: number
+}): boolean {
+  const { previous, nextToolEvents, nextKind, now } = params
+  if (!previous || previous.role !== 'assistant') return false
+  if (nextToolEvents.length === 0) return false
+  if (previous.kind && nextKind && previous.kind !== nextKind) return false
+  if (typeof previous.time === 'number' && now - previous.time > 45_000) return false
+  const prevTools = Array.isArray(previous.toolEvents) ? previous.toolEvents.length : 0
+  return prevTools === 0
+}
+
 function requestedToolNamesFromMessage(message: string): string[] {
   const lower = message.toLowerCase()
   const candidates = [
@@ -377,6 +392,11 @@ function buildAgentSystemPrompt(session: any): string | undefined {
 
   const settings = loadSettings()
   const parts: string[] = []
+  // Identity block — agent needs to know who it is
+  const identityLines = [`## My Identity`, `My name is ${agent.name}.`]
+  if (agent.description) identityLines.push(agent.description)
+  identityLines.push('I should always refer to myself by this name. I am not "Assistant" — I have my own name and identity.')
+  parts.push(identityLines.join(' '))
   if (settings.userPrompt) parts.push(settings.userPrompt)
   parts.push(buildCurrentDateTimePromptContext())
   if (agent.soul) parts.push(agent.soul)
@@ -562,6 +582,45 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     onEvent?.({ t: 'err', text: `Capability policy blocked tools for this run: ${blockedSummary}` })
   }
 
+  // --- Agent monthly budget enforcement ---
+  if (session.agentId) {
+    const agentsMap = loadAgents()
+    const agent = agentsMap[session.agentId]
+    if (agent?.monthlyBudget && agent.monthlyBudget > 0) {
+      const budgetResult = checkBudget(agent)
+      if (!budgetResult.ok) {
+        const action = agent.budgetAction || 'warn'
+        if (action === 'block') {
+          const budgetError = budgetResult.message || `Agent budget exceeded: $${budgetResult.spend.toFixed(4)} / $${budgetResult.budget.toFixed(2)}`
+          onEvent?.({ t: 'err', text: budgetError })
+
+          let persisted = false
+          if (!internal) {
+            session.messages.push({
+              role: 'assistant',
+              text: budgetError,
+              time: Date.now(),
+            })
+            session.lastActiveAt = Date.now()
+            saveSessions(sessions)
+            persisted = true
+          }
+
+          return {
+            runId,
+            sessionId,
+            text: budgetError,
+            persisted,
+            toolEvents: [],
+            error: budgetError,
+          }
+        }
+        // budgetAction === 'warn': emit a warning but continue
+        onEvent?.({ t: 'status', text: JSON.stringify({ budgetWarning: budgetResult.message }) })
+      }
+    }
+  }
+
   const dailySpendLimitUsd = parseUsdLimit(appSettings.safetyMaxDailySpendUsd)
   if (dailySpendLimitUsd !== null) {
     const todaySpendUsd = getTodaySpendUsd()
@@ -711,6 +770,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           active,
           loadHistory: isAutoRunNoHistory ? () => getSessionMessages(sessionId).slice(-6) : (sid: string) => applyContextClearBoundary(getSessionMessages(sid)),
           onUsage: (u) => { directUsage.inputTokens = u.inputTokens; directUsage.outputTokens = u.outputTokens; directUsage.received = true },
+          signal: abortController.signal,
         })
   } catch (err: any) {
     errorMessage = err?.message || String(err)
@@ -1014,14 +1074,26 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       const persistedText = heartbeatClassification === 'strip'
         ? textForPersistence.replace(/HEARTBEAT_OK/gi, '').trim()
         : textForPersistence
-      current.messages.push({
+      const nowTs = Date.now()
+      const nextAssistantMessage: Message = {
         role: 'assistant',
         text: persistedText,
-        time: Date.now(),
+        time: nowTs,
         thinking: thinkingText || undefined,
         toolEvents: toolEvents.length ? toolEvents : undefined,
         kind: persistedKind,
-      })
+      }
+      const previous = current.messages.at(-1)
+      if (shouldReplaceRecentAssistantMessage({
+        previous,
+        nextToolEvents: toolEvents,
+        nextKind: persistedKind,
+        now: nowTs,
+      })) {
+        current.messages[current.messages.length - 1] = nextAssistantMessage
+      } else {
+        current.messages.push(nextAssistantMessage)
+      }
       changed = true
 
       // Conversation tone detection