@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/app/api/wallets/route.ts

@@ -1,74 +1,91 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import { loadWallets, upsertWallet, loadAgents, saveAgents } from '@/lib/server/storage'
-import { generateSolanaKeypair } from '@/lib/server/solana'
-import { notify } from '@/lib/server/ws-hub'
-import type { AgentWallet, WalletChain } from '@/types'
+import { loadAgents, loadWallets } from '@/lib/server/storage'
+import { createAgentWallet, getAgentActiveWalletId, getWalletPortfolioSnapshot, stripWalletPrivateKey } from '@/lib/server/wallet-service'
+import { buildEmptyWalletPortfolio } from '@/lib/server/wallet-portfolio'
+import type { AgentWallet, WalletPortfolioSummary } from '@/types'
 export const dynamic = 'force-dynamic'
+const WALLET_LIST_PORTFOLIO_TIMEOUT_MS = 1500
 
-/** Strip encryptedPrivateKey from wallet for safe API responses */
-function stripPrivateKey(wallet: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(Object.entries(wallet).filter(([k]) => k !== 'encryptedPrivateKey'))
+function withPortfolio(
+  wallet: AgentWallet,
+  portfolio: {
+    balanceAtomic: string
+    balanceFormatted: string
+    balanceSymbol: string
+    balanceDisplay: string
+    balanceLamports?: number
+    balanceSol?: number
+    assets: unknown[]
+    summary: WalletPortfolioSummary
+  },
+  isActive: boolean,
+) {
+  return {
+    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
+    balanceAtomic: portfolio.balanceAtomic,
+    balanceFormatted: portfolio.balanceFormatted,
+    balanceSymbol: portfolio.balanceSymbol,
+    balanceDisplay: portfolio.balanceDisplay,
+    balanceLamports: portfolio.balanceLamports,
+    balanceSol: portfolio.balanceSol,
+    assets: portfolio.assets,
+    portfolioSummary: portfolio.summary,
+    isActive,
+  }
 }
 
-export async function GET() {
+export async function GET(req: Request) {
   const wallets = loadWallets() as Record<string, AgentWallet>
-  const safe = Object.fromEntries(
-    Object.entries(wallets).map(([id, w]) => [id, stripPrivateKey(w as unknown as Record<string, unknown>)]),
+  const agents = loadAgents()
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')?.trim() || ''
+  const walletEntries = Object.entries(wallets)
+    .filter(([, wallet]) => !agentId || wallet.agentId === agentId)
+  const entries = await Promise.all(
+    walletEntries.map(async ([id, wallet]) => {
+      let portfolio = buildEmptyWalletPortfolio(wallet)
+      try {
+        portfolio = await getWalletPortfolioSnapshot(wallet, {
+          timeoutMs: WALLET_LIST_PORTFOLIO_TIMEOUT_MS,
+          allowStale: true,
+        })
+      } catch {
+        // Slow or failed RPC discovery — return empty/stale portfolio for list view
+      }
+      const activeWalletId = getAgentActiveWalletId(agents[wallet.agentId])
+      return [id, withPortfolio(wallet, portfolio, activeWalletId === wallet.id)] as const
+    }),
   )
-  return NextResponse.json(safe)
+  return NextResponse.json(Object.fromEntries(entries))
 }
 
 export async function POST(req: Request) {
   const body = await req.json()
-  const agentId = typeof body.agentId === 'string' ? body.agentId.trim() : ''
-  if (!agentId) {
-    return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
-  }
-
-  const agents = loadAgents()
-  if (!agents[agentId]) {
-    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
-  }
-
-  // Check agent doesn't already have a wallet
-  const existing = loadWallets() as Record<string, AgentWallet>
-  const hasWallet = Object.values(existing).some((w) => w.agentId === agentId)
-  if (hasWallet) {
-    return NextResponse.json({ error: 'Agent already has a wallet' }, { status: 409 })
+  try {
+    const wallet = createAgentWallet({
+      agentId: body.agentId,
+      chain: body.chain,
+      provider: body.provider,
+      label: body.label,
+      requireApproval: body.requireApproval,
+      spendingLimitAtomic: body.spendingLimitAtomic ?? body.spendingLimitLamports,
+      dailyLimitAtomic: body.dailyLimitAtomic ?? body.dailyLimitLamports,
+    })
+    return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    if (message === 'agentId is required') {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    if (/^Unsupported wallet chain or provider: /.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    if (message === 'Agent not found') {
+      return NextResponse.json({ error: message }, { status: 404 })
+    }
+    if (/^Agent already has a (solana|ethereum) wallet$/.test(message)) {
+      return NextResponse.json({ error: message }, { status: 409 })
+    }
+    return NextResponse.json({ error: message }, { status: 500 })
   }
-
-  const chain: WalletChain = body.chain === 'solana' ? 'solana' : 'solana' // extensible later
-  const { publicKey, encryptedPrivateKey } = generateSolanaKeypair()
-
-  const id = genId()
-  const now = Date.now()
-
-  const wallet: AgentWallet = {
-    id,
-    agentId,
-    chain,
-    publicKey,
-    encryptedPrivateKey,
-    label: typeof body.label === 'string' ? body.label : undefined,
-    spendingLimitLamports: typeof body.spendingLimitLamports === 'number' ? body.spendingLimitLamports : 100_000_000,
-    dailyLimitLamports: typeof body.dailyLimitLamports === 'number' ? body.dailyLimitLamports : 1_000_000_000,
-    requireApproval: body.requireApproval !== false,
-    createdAt: now,
-    updatedAt: now,
-  }
-
-  upsertWallet(id, wallet)
-
-  // Link wallet to agent
-  const agent = agents[agentId]
-  agent.walletId = id
-  agent.updatedAt = now
-  agents[agentId] = agent
-  saveAgents(agents)
-
-  notify('wallets')
-  notify('agents')
-
-  return NextResponse.json(stripPrivateKey(wallet as unknown as Record<string, unknown>))
 }

package/src/app/api/webhooks/[id]/route.ts

@@ -13,6 +13,18 @@ import { triggerWebhookWatchJobs } from '@/lib/server/watch-jobs'
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ops: CollectionOps<any> = { load: loadWebhooks, save: saveWebhooks }
 
+type WebhookPostDeps = {
+  enqueueRun: typeof enqueueSessionRun
+  enqueueEvent: typeof enqueueSystemEvent
+  requestHeartbeat: typeof requestHeartbeatNow
+}
+
+const defaultWebhookPostDeps: WebhookPostDeps = {
+  enqueueRun: enqueueSessionRun,
+  enqueueEvent: enqueueSystemEvent,
+  requestHeartbeat: requestHeartbeatNow,
+}
+
 function normalizeEvents(value: unknown): string[] {
   if (!Array.isArray(value)) return []
   return value
@@ -58,8 +70,11 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   return NextResponse.json({ ok: true })
 }
 
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
+export async function handleWebhookPost(
+  req: Request,
+  id: string,
+  deps: WebhookPostDeps = defaultWebhookPostDeps,
+) {
   const webhooks = loadWebhooks()
   const webhook = webhooks[id]
   if (!webhook) return notFound('Webhook not found')
@@ -176,7 +191,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       agentId: agent.id,
       parentSessionId: null,
       tools: agent.tools || [],
-      heartbeatEnabled: agent.heartbeatEnabled ?? true,
+      heartbeatEnabled: agent.heartbeatEnabled ?? false,
       heartbeatIntervalSec: agent.heartbeatIntervalSec ?? null,
     }
     sessions[session.id as string] = session
@@ -200,7 +215,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   ].join('\n')
 
   try {
-    const run = enqueueSessionRun({
+    const run = deps.enqueueRun({
       sessionId: sid,
       message: prompt,
       source: 'webhook',
@@ -209,9 +224,16 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     })
 
     // Enqueue system event + heartbeat wake
-    enqueueSystemEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
+    deps.enqueueEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
     if (webhook.agentId) {
-      requestHeartbeatNow({ agentId: webhook.agentId, reason: 'webhook' })
+      deps.requestHeartbeat({
+        agentId: webhook.agentId,
+        eventId: `webhook:${id}:${incomingEvent}:${Date.now()}`,
+        reason: 'webhook',
+        source: `webhook:${id}`,
+        resumeMessage: `Webhook received: ${webhook.name || id} (${incomingEvent})`,
+        detail: payloadPreview || '(empty payload)',
+      })
     }
 
     appendWebhookLog(genId(8), {
@@ -262,3 +284,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     })
   }
 }
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  return handleWebhookPost(req, id)
+}

package/src/app/api/webhooks/route.test.ts

@@ -0,0 +1,272 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+
+import { GET as getWebhookHistory } from './[id]/history/route'
+import { handleWebhookPost } from './[id]/route'
+import {
+  loadAgents,
+  loadSessions,
+  loadWebhookLogs,
+  loadWebhookRetryQueue,
+  loadWebhooks,
+  saveAgents,
+  saveSessions,
+  saveWebhookLogs,
+  saveWebhookRetryQueue,
+  saveWebhooks,
+} from '@/lib/server/storage'
+
+const originalAgents = loadAgents()
+const originalSessions = loadSessions()
+const originalWebhooks = loadWebhooks()
+const originalWebhookLogs = loadWebhookLogs()
+const originalWebhookRetryQueue = loadWebhookRetryQueue()
+
+afterEach(() => {
+  saveAgents(originalAgents)
+  saveSessions(originalSessions)
+  saveWebhooks(originalWebhooks)
+  saveWebhookLogs(originalWebhookLogs)
+  saveWebhookRetryQueue(originalWebhookRetryQueue)
+})
+
+function seedAgent(agentId: string) {
+  const agents = loadAgents()
+  agents[agentId] = {
+    id: agentId,
+    name: 'Webhook Agent',
+    description: 'Test agent for webhook delivery',
+    systemPrompt: 'Handle inbound webhooks.',
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    credentialId: null,
+    apiEndpoint: null,
+    tools: ['manage_webhooks'],
+    createdAt: 1,
+    updatedAt: 1,
+  }
+  saveAgents(agents)
+}
+
+function seedWebhook(webhookId: string, overrides: Record<string, unknown> = {}) {
+  const webhooks = loadWebhooks()
+  webhooks[webhookId] = {
+    id: webhookId,
+    name: 'Webhook Smoke',
+    source: 'custom',
+    events: ['build.completed'],
+    agentId: 'agent-webhook-smoke',
+    secret: 'secret-smoke',
+    isEnabled: true,
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  }
+  saveWebhooks(webhooks)
+}
+
+test('handleWebhookPost creates a session, records success history, and triggers follow-up wiring', async () => {
+  const webhookId = 'wh-success-smoke'
+  seedAgent('agent-webhook-smoke')
+  seedWebhook(webhookId)
+
+  const calls = {
+    runs: [] as Array<Record<string, unknown>>,
+    events: [] as Array<[string, string]>,
+    heartbeats: [] as Array<Record<string, unknown>>,
+  }
+
+  const response = await handleWebhookPost(
+    new Request(`http://local/api/webhooks/${webhookId}?event=build.completed`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-webhook-secret': 'secret-smoke',
+      },
+      body: JSON.stringify({ event: 'build.completed', payload: { ok: true } }),
+    }),
+    webhookId,
+    {
+      enqueueRun(input) {
+        calls.runs.push(input as Record<string, unknown>)
+        return {
+          runId: 'run-success-smoke',
+          position: 0,
+          promise: Promise.resolve({} as never),
+          abort: () => {},
+        }
+      },
+      enqueueEvent(sessionId, text) {
+        calls.events.push([sessionId, text])
+      },
+      requestHeartbeat(opts) {
+        calls.heartbeats.push(opts as Record<string, unknown>)
+      },
+    },
+  )
+
+  assert.equal(response.status, 200)
+  const payload = await response.json() as Record<string, unknown>
+  assert.equal(payload.ok, true)
+  assert.equal(payload.event, 'build.completed')
+  assert.equal(payload.runId, 'run-success-smoke')
+
+  const sessionId = String(payload.sessionId)
+  const session = loadSessions()[sessionId]
+  assert.ok(session)
+  assert.equal(session.name, `webhook:${webhookId}`)
+  assert.equal(session.agentId, 'agent-webhook-smoke')
+
+  assert.equal(calls.runs.length, 1)
+  assert.equal(calls.runs[0].sessionId, sessionId)
+  assert.equal(calls.runs[0].source, 'webhook')
+  assert.equal(calls.runs[0].mode, 'followup')
+  assert.match(String(calls.runs[0].message), /Webhook event received\./)
+  assert.match(String(calls.runs[0].message), /Event: build\.completed/)
+
+  assert.deepEqual(calls.events, [[sessionId, 'Webhook received: Webhook Smoke (build.completed)']])
+  assert.deepEqual(calls.heartbeats, [{ agentId: 'agent-webhook-smoke', reason: 'webhook' }])
+
+  const logEntries = Object.values(loadWebhookLogs()) as Array<Record<string, unknown>>
+  const successEntry = logEntries.find((entry) => entry.webhookId === webhookId && entry.status === 'success')
+  assert.ok(successEntry)
+  assert.equal(successEntry?.sessionId, sessionId)
+  assert.equal(successEntry?.runId, 'run-success-smoke')
+
+  const historyResponse = await getWebhookHistory(new Request(`http://local/api/webhooks/${webhookId}/history`), {
+    params: Promise.resolve({ id: webhookId }),
+  })
+  assert.equal(historyResponse.status, 200)
+  const history = await historyResponse.json() as Array<Record<string, unknown>>
+  assert.equal(history[0]?.status, 'success')
+  assert.equal(history[0]?.webhookId, webhookId)
+})
+
+test('handleWebhookPost ignores filtered events without dispatching or logging delivery', async () => {
+  const webhookId = 'wh-ignored-smoke'
+  seedAgent('agent-webhook-smoke')
+  seedWebhook(webhookId, { events: ['build.completed'] })
+
+  let runCalls = 0
+  const response = await handleWebhookPost(
+    new Request(`http://local/api/webhooks/${webhookId}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-webhook-secret': 'secret-smoke',
+      },
+      body: JSON.stringify({ event: 'build.started' }),
+    }),
+    webhookId,
+    {
+      enqueueRun() {
+        runCalls += 1
+        return {
+          runId: 'should-not-run',
+          position: 0,
+          promise: Promise.resolve({} as never),
+          abort: () => {},
+        }
+      },
+      enqueueEvent() {},
+      requestHeartbeat() {},
+    },
+  )
+
+  assert.equal(response.status, 200)
+  const payload = await response.json() as Record<string, unknown>
+  assert.equal(payload.ignored, true)
+  assert.equal(payload.event, 'build.started')
+  assert.equal(runCalls, 0)
+  assert.equal(Object.values(loadSessions()).some((session: any) => session?.name === `webhook:${webhookId}`), false)
+  assert.equal(Object.values(loadWebhookLogs()).some((entry: any) => entry?.webhookId === webhookId), false)
+})
+
+test('handleWebhookPost rejects disabled webhooks and invalid secrets with error history', async () => {
+  const disabledId = 'wh-disabled-smoke'
+  seedWebhook(disabledId, { isEnabled: false, secret: '' })
+
+  const disabledResponse = await handleWebhookPost(
+    new Request(`http://local/api/webhooks/${disabledId}`, { method: 'POST' }),
+    disabledId,
+    {
+      enqueueRun() {
+        throw new Error('should not dispatch')
+      },
+      enqueueEvent() {},
+      requestHeartbeat() {},
+    },
+  )
+  assert.equal(disabledResponse.status, 409)
+
+  const invalidSecretId = 'wh-secret-smoke'
+  seedAgent('agent-webhook-smoke')
+  seedWebhook(invalidSecretId, { secret: 'top-secret' })
+
+  const invalidSecretResponse = await handleWebhookPost(
+    new Request(`http://local/api/webhooks/${invalidSecretId}`, {
+      method: 'POST',
+      headers: { 'x-webhook-secret': 'wrong-secret' },
+    }),
+    invalidSecretId,
+    {
+      enqueueRun() {
+        throw new Error('should not dispatch')
+      },
+      enqueueEvent() {},
+      requestHeartbeat() {},
+    },
+  )
+  assert.equal(invalidSecretResponse.status, 401)
+
+  const errors = Object.values(loadWebhookLogs()) as Array<Record<string, unknown>>
+  const disabledEntry = errors.find((entry) => entry.webhookId === disabledId)
+  const invalidSecretEntry = errors.find((entry) => entry.webhookId === invalidSecretId)
+  assert.equal(disabledEntry?.error, 'Webhook is disabled')
+  assert.equal(invalidSecretEntry?.error, 'Invalid webhook secret')
+})
+
+test('handleWebhookPost queues retries when run dispatch throws', async () => {
+  const webhookId = 'wh-retry-smoke'
+  seedAgent('agent-webhook-smoke')
+  seedWebhook(webhookId)
+
+  const heartbeats: Array<Record<string, unknown>> = []
+  const response = await handleWebhookPost(
+    new Request(`http://local/api/webhooks/${webhookId}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-webhook-secret': 'secret-smoke',
+      },
+      body: JSON.stringify({ event: 'build.completed', payload: { ok: false } }),
+    }),
+    webhookId,
+    {
+      enqueueRun() {
+        throw new Error('dispatch exploded')
+      },
+      enqueueEvent() {},
+      requestHeartbeat(opts) {
+        heartbeats.push(opts as Record<string, unknown>)
+      },
+    },
+  )
+
+  assert.equal(response.status, 200)
+  const payload = await response.json() as Record<string, unknown>
+  assert.equal(payload.retryQueued, true)
+  assert.equal(payload.error, 'dispatch exploded')
+  assert.equal(heartbeats.length, 0)
+
+  const retries = Object.values(loadWebhookRetryQueue()) as Array<Record<string, unknown>>
+  const retryEntry = retries.find((entry) => entry.webhookId === webhookId)
+  assert.ok(retryEntry)
+  assert.equal(retryEntry?.attempts, 1)
+  assert.equal(retryEntry?.deadLettered, false)
+
+  const errorLogs = Object.values(loadWebhookLogs()) as Array<Record<string, unknown>>
+  const retryLog = errorLogs.find((entry) => entry.webhookId === webhookId)
+  assert.ok(retryLog)
+  assert.match(String(retryLog?.error), /Dispatch failed, queued for retry: dispatch exploded/)
+})

package/src/cli/index.js

@@ -586,6 +586,7 @@ const COMMAND_GROUPS = [
       cmd('delete', 'DELETE', '/tasks/:id', 'Delete task'),
       cmd('purge', 'DELETE', '/tasks', 'Bulk delete tasks', { expectsJsonBody: true }),
       cmd('approve', 'POST', '/tasks/:id/approve', 'Approve or reject a pending tool execution', { expectsJsonBody: true }),
+      cmd('import-github', 'POST', '/tasks/import/github', 'Import GitHub issues into tasks', { expectsJsonBody: true }),
       cmd('metrics', 'GET', '/tasks/metrics', 'Get task board metrics (supports --query range=24h|7d|30d)'),
     ],
   },

package/src/cli/spec.js

@@ -447,6 +447,7 @@ const COMMAND_GROUPS = {
       delete: { description: 'Archive task', method: 'DELETE', path: '/tasks/:id', params: ['id'] },
       archive: { description: 'Archive task', method: 'DELETE', path: '/tasks/:id', params: ['id'] },
       approve: { description: 'Approve or reject a pending tool execution', method: 'POST', path: '/tasks/:id/approve', params: ['id'] },
+      'import-github': { description: 'Import GitHub issues into tasks', method: 'POST', path: '/tasks/import/github' },
       metrics: { description: 'Get task board metrics (supports --query range=24h|7d|30d)', method: 'GET', path: '/tasks/metrics' },
     },
   },

package/src/components/agents/agent-card.tsx

@@ -63,6 +63,7 @@ export function AgentCard({ agent, isDefault, isRunning, isOnline, isSelected, o
     },
   ].filter((entry) => entry.budget !== null)
   const canDelegateToAgents = agent.platformAssignScope === 'all'
+  const agentDisabled = agent.disabled === true
   useWs(`heartbeat:agent:${agent.id}`, () => {
     setHeartbeatPulse(true)
     setTimeout(() => setHeartbeatPulse(false), 1500)
@@ -125,6 +126,7 @@ export function AgentCard({ agent, isDefault, isRunning, isOnline, isSelected, o
         onClick={handleClick}
         className={`group relative py-3.5 px-4 cursor-pointer rounded-[14px]
           transition-all duration-200 active:scale-[0.98]
+          ${agentDisabled ? 'opacity-70' : ''}
           ${isSelected
             ? 'bg-white/[0.04] border border-white/[0.08]'
             : 'bg-transparent border border-transparent hover:bg-white/[0.05] hover:border-white/[0.08]'}`}
@@ -197,6 +199,11 @@ export function AgentCard({ agent, isDefault, isRunning, isOnline, isSelected, o
               {pendingApprovalCount} {pendingApprovalCount === 1 ? 'approval' : 'approvals'}
             </span>
           )}
+          {agentDisabled && (
+            <span className="shrink-0 text-[10px] font-600 uppercase tracking-wider text-amber-300 bg-amber-400/[0.08] border border-amber-400/15 px-2 py-0.5 rounded-[6px]">
+              disabled
+            </span>
+          )}
           {isDefault && (
             <span className="shrink-0 text-[10px] font-600 uppercase tracking-wider text-accent-bright bg-accent-soft px-2 py-0.5 rounded-[6px]">
               default
@@ -205,12 +212,12 @@ export function AgentCard({ agent, isDefault, isRunning, isOnline, isSelected, o
           {canDelegateToAgents && (
             <button
               onClick={handleRunClick}
-              disabled={running}
+              disabled={running || agentDisabled}
               className="shrink-0 text-[10px] font-600 uppercase tracking-wider px-2.5 py-1 rounded-[6px] cursor-pointer
                 transition-all border-none bg-accent-bright/20 text-accent-bright hover:bg-accent-bright/30 disabled:opacity-40"
               style={{ fontFamily: 'inherit' }}
             >
-              {running ? '...' : 'Run'}
+              {agentDisabled ? 'Off' : running ? '...' : 'Run'}
             </button>
           )}
           {canDelegateToAgents && (

package/src/components/agents/agent-chat-list.tsx

@@ -167,6 +167,10 @@ export function AgentChatList({ inSidebar, onSelect }: Props) {
   }, [filteredAgents.map((a) => a.id).join(',')])
 
   const handleSelect = async (agent: Agent) => {
+    if (agent.disabled === true && !agent.threadSessionId) {
+      toast.error(`${agent.name} is disabled. Re-enable it to start a new chat.`)
+      return
+    }
     await setCurrentAgent(agent.id)
     // Load messages for the thread
     const state = useAppStore.getState()
@@ -274,7 +278,8 @@ export function AgentChatList({ inSidebar, onSelect }: Props) {
           const lastMsg = threadSession?.messages?.at(-1)
           const heartbeatOn = defaultAgent.heartbeatEnabled === true && (defaultAgent.plugins?.length ?? 0) > 0
           const recentlyActive = (threadSession?.lastActiveAt ?? 0) > Date.now() - 30 * 60 * 1000
-          const isWorking = runningAgentIds.has(defaultAgent.id) || (threadSession?.active ?? false) || heartbeatOn || recentlyActive || chatroomActiveAgentIds.has(defaultAgent.id)
+          const isDisabled = defaultAgent.disabled === true
+          const isWorking = !isDisabled && (runningAgentIds.has(defaultAgent.id) || (threadSession?.active ?? false) || heartbeatOn || recentlyActive || chatroomActiveAgentIds.has(defaultAgent.id))
           const isTyping = streamingSessionId === defaultAgent.threadSessionId
           const preview = lastMsg?.text?.slice(0, 100)?.replace(/\n/g, ' ') || 'Your primary shortcut chat.'
           const isActive = currentAgentId === defaultAgent.id
@@ -313,6 +318,11 @@ export function AgentChatList({ inSidebar, onSelect }: Props) {
                       <span className="font-display text-[14px] font-700 truncate text-text tracking-[-0.01em]">
                         {defaultAgent.name}
                       </span>
+                      {isDisabled && (
+                        <span className="px-1.5 py-0.5 rounded-[6px] bg-amber-400/[0.08] text-amber-300 text-[9px] font-700 uppercase tracking-[0.08em]">
+                          Disabled
+                        </span>
+                      )}
                       <span className="px-1.5 py-0.5 rounded-[6px] bg-accent-bright/12 text-accent-bright text-[9px] font-700 uppercase tracking-[0.08em]">
                         Shortcut
                       </span>
@@ -359,7 +369,8 @@ export function AgentChatList({ inSidebar, onSelect }: Props) {
           const isActive = currentAgentId === agent.id
           const heartbeatOn = agent.heartbeatEnabled === true && (agent.plugins?.length ?? 0) > 0
           const recentlyActive = (threadSession?.lastActiveAt ?? 0) > Date.now() - 30 * 60 * 1000
-          const isWorking = runningAgentIds.has(agent.id) || (threadSession?.active ?? false) || heartbeatOn || recentlyActive || chatroomActiveAgentIds.has(agent.id)
+          const isDisabled = agent.disabled === true
+          const isWorking = !isDisabled && (runningAgentIds.has(agent.id) || (threadSession?.active ?? false) || heartbeatOn || recentlyActive || chatroomActiveAgentIds.has(agent.id))
           const isTyping = streamingSessionId === agent.threadSessionId
           const preview = lastMsg?.text?.slice(0, 80)?.replace(/\n/g, ' ') || ''
 
@@ -395,6 +406,11 @@ export function AgentChatList({ inSidebar, onSelect }: Props) {
                     <span className="font-display text-[13.5px] font-600 truncate flex-1 tracking-[-0.01em]">
                       {agent.name}
                     </span>
+                    {isDisabled && (
+                      <span className="px-1.5 py-0.5 rounded-[6px] bg-amber-400/[0.08] text-amber-300 text-[9px] font-700 uppercase tracking-[0.08em] shrink-0">
+                        Disabled
+                      </span>
+                    )}
                     {appSettings.defaultAgentId === agent.id && (
                       <span className="px-1.5 py-0.5 rounded-[6px] bg-accent-bright/10 text-accent-bright text-[9px] font-700 uppercase tracking-[0.08em] shrink-0">
                         Default

package/src/components/agents/agent-list.tsx

@@ -70,6 +70,7 @@ export function AgentList({ inSidebar }: Props) {
     const ids = new Set<string>()
     const recentThreshold = now - 30 * 60 * 1000
     for (const a of Object.values(agents)) {
+      if (a.disabled === true) continue
       if (a.heartbeatEnabled === true && (a.plugins?.length ?? 0) > 0) { ids.add(a.id); continue }
       // Check if any session for this agent was active in the last 30 minutes
       for (const s of Object.values(sessions)) {