@swarmclawai/swarmclaw 0.5.2 → 0.6.0

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

@@ -0,0 +1,50 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { Chatroom, ChatroomMessage } from '@/types'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const chatrooms = loadChatrooms()
+  return NextResponse.json(chatrooms)
+}
+
+export async function POST(req: Request) {
+  const body = await req.json()
+  const chatrooms = loadChatrooms()
+  const id = genId()
+
+  const agentIds: string[] = Array.isArray(body.agentIds) ? body.agentIds : []
+  const now = Date.now()
+
+  // Generate join messages for initial agents
+  const agents = agentIds.length > 0 ? loadAgents() : {}
+  const joinMessages: ChatroomMessage[] = agentIds.map((agentId: string, i: number) => ({
+    id: genId(),
+    senderId: 'system',
+    senderName: 'System',
+    role: 'assistant',
+    text: `${agents[agentId]?.name || 'Unknown agent'} has joined the chat`,
+    mentions: [],
+    reactions: [],
+    time: now + i, // offset by 1ms so they sort in order
+  }))
+
+  const chatroom: Chatroom = {
+    id,
+    name: body.name || 'New Chatroom',
+    description: body.description || '',
+    agentIds,
+    messages: joinMessages,
+    createdAt: now,
+    updatedAt: now,
+  }
+
+  chatrooms[id] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+
+  return NextResponse.json(chatroom)
+}

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

@@ -6,8 +6,8 @@ export const dynamic = 'force-dynamic'
 
 export async function GET(_req: Request) {
   const creds = loadCredentials()
-  const safe: Record<string, any> = {}
-  for (const [id, c] of Object.entries(creds) as [string, any][]) {
+  const safe: Record<string, Record<string, unknown>> = {}
+  for (const [id, c] of Object.entries(creds) as [string, Record<string, unknown>][]) {
     safe[id] = { id: c.id, provider: c.provider, name: c.name, createdAt: c.createdAt }
   }
   return NextResponse.json(safe)
@@ -28,6 +28,5 @@ export async function POST(req: Request) {
     createdAt: Date.now(),
   }
   saveCredentials(creds)
-  console.log(`[credentials] stored ${id} for ${provider}`)
   return NextResponse.json({ id, provider, name: creds[id].name, createdAt: creds[id].createdAt })
 }

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

@@ -25,7 +25,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     return NextResponse.json({ error: 'Invalid JSON body.' }, { status: 400 })
   }
 
-  const { title, content, tags } = body as Record<string, unknown>
+  const { title, content, tags, scope, agentIds } = body as Record<string, unknown>
 
   const updates: Record<string, unknown> = {}
   if (typeof title === 'string' && title.trim()) {
@@ -36,13 +36,24 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   }
 
   const existingMeta = (existing.metadata || {}) as Record<string, unknown>
+  const metaUpdates: Record<string, unknown> = { ...existingMeta }
+
   if (Array.isArray(tags)) {
     const normalizedTags = (tags as unknown[]).filter(
       (t): t is string => typeof t === 'string' && t.trim().length > 0,
     )
-    updates.metadata = { ...existingMeta, tags: normalizedTags }
+    metaUpdates.tags = normalizedTags
+  }
+
+  if (scope === 'global' || scope === 'agent') {
+    metaUpdates.scope = scope
+    metaUpdates.agentIds = scope === 'agent' && Array.isArray(agentIds)
+      ? (agentIds as unknown[]).filter((id): id is string => typeof id === 'string')
+      : []
   }
 
+  updates.metadata = metaUpdates
+
   const updated = db.update(id, updates)
   if (!updated) {
     return notFound()

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

@@ -25,7 +25,7 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'Invalid JSON body.' }, { status: 400 })
   }
 
-  const { title, content, tags } = body as Record<string, unknown>
+  const { title, content, tags, scope, agentIds } = body as Record<string, unknown>
 
   if (typeof title !== 'string' || !title.trim()) {
     return NextResponse.json({ error: 'title is required.' }, { status: 400 })
@@ -38,10 +38,17 @@ export async function POST(req: Request) {
     ? (tags as unknown[]).filter((t): t is string => typeof t === 'string' && t.trim().length > 0)
     : undefined
 
+  const normalizedScope = scope === 'agent' ? 'agent' as const : 'global' as const
+  const normalizedAgentIds = Array.isArray(agentIds)
+    ? (agentIds as unknown[]).filter((id): id is string => typeof id === 'string')
+    : []
+
   const entry = addKnowledge({
     title: title.trim(),
     content,
     tags: normalizedTags,
+    scope: normalizedScope,
+    agentIds: normalizedAgentIds,
   })
 
   return NextResponse.json(entry)

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

@@ -26,7 +26,13 @@ export async function GET(req: Request) {
   const requestedLimit = parseOptionalInt(searchParams.get('limit'))
   const requestedLinkedLimit = parseOptionalInt(searchParams.get('linkedLimit'))
 
+  const counts = searchParams.get('counts') === 'true'
   const db = getMemoryDb()
+
+  if (counts) {
+    return NextResponse.json(db.countsByAgent())
+  }
+
   const defaults = getMemoryLookupLimits()
   const limits = resolveLookupRequest(defaults, {
     depth: requestedDepth,
@@ -106,6 +112,8 @@ export async function POST(req: Request) {
     image: image as MemoryImage | null | undefined,
     imagePath: image && typeof image === 'object' && 'path' in image ? String((image as { path: string }).path) : null,
     linkedMemoryIds: body.linkedMemoryIds as string[] | undefined,
+    pinned: body.pinned === true,
+    sharedWith: Array.isArray(body.sharedWith) ? body.sharedWith as string[] : undefined,
   })
   return NextResponse.json(entry)
 }

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

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server'
+import { loadNotifications, markNotificationRead, deleteNotification } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+
+export async function PUT(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const all = loadNotifications()
+  if (!all[id]) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  markNotificationRead(id)
+  notify('notifications')
+  return NextResponse.json({ ok: true })
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const all = loadNotifications()
+  if (!all[id]) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  deleteNotification(id)
+  notify('notifications')
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,68 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { loadNotifications, saveNotification, deleteNotification } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { AppNotification } from '@/types'
+export const dynamic = 'force-dynamic'
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const unreadOnly = searchParams.get('unreadOnly') === 'true'
+  const limit = Math.min(200, Math.max(1, Number(searchParams.get('limit')) || 100))
+
+  const all = loadNotifications()
+  let entries = Object.values(all) as AppNotification[]
+
+  if (unreadOnly) {
+    entries = entries.filter((e) => !e.read)
+  }
+
+  entries.sort((a, b) => b.createdAt - a.createdAt)
+  entries = entries.slice(0, limit)
+
+  return NextResponse.json(entries)
+}
+
+export async function POST(req: Request) {
+  const body = (await req.json()) as Record<string, unknown>
+  const actionLabel = typeof body.actionLabel === 'string' ? body.actionLabel : undefined
+  const actionUrl = typeof body.actionUrl === 'string' ? body.actionUrl : undefined
+  const id = genId()
+  const notification: AppNotification = {
+    id,
+    type: (['info', 'success', 'warning', 'error'].includes(body.type as string) ? body.type : 'info') as AppNotification['type'],
+    title: typeof body.title === 'string' ? body.title : 'Notification',
+    message: typeof body.message === 'string' ? body.message : undefined,
+    actionLabel,
+    actionUrl,
+    entityType: typeof body.entityType === 'string' ? body.entityType : undefined,
+    entityId: typeof body.entityId === 'string' ? body.entityId : undefined,
+    read: false,
+    createdAt: Date.now(),
+  }
+
+  saveNotification(id, notification)
+  notify('notifications')
+  return NextResponse.json(notification, { status: 201 })
+}
+
+export async function DELETE(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const specificId = searchParams.get('id')
+
+  if (specificId) {
+    deleteNotification(specificId)
+  } else {
+    // Clear all read notifications
+    const all = loadNotifications()
+    for (const raw of Object.values(all)) {
+      const entry = raw as AppNotification
+      if (entry.read) {
+        deleteNotification(entry.id)
+      }
+    }
+  }
+
+  notify('notifications')
+  return NextResponse.json({ ok: true })
+}

package/src/app/api/orchestrator/run/route.ts

@@ -4,7 +4,7 @@ import { loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
 import { enqueueTask } from '@/lib/server/queue'
 
 export async function POST(req: Request) {
-  const { agentId, task } = await req.json()
+  const { agentId, task } = await req.json().catch(() => ({}))
   if (!agentId || !task) {
     return NextResponse.json({ error: 'agentId and task are required' }, { status: 400 })
   }

package/src/app/api/plugins/install/route.ts

@@ -49,9 +49,9 @@ export async function POST(req: Request) {
     fs.writeFileSync(dest, code, 'utf8')
 
     return NextResponse.json({ ok: true, filename: sanitized })
-  } catch (err: any) {
+  } catch (err: unknown) {
     return NextResponse.json(
-      { error: 'Failed to install plugin', message: err.message },
+      { error: 'Failed to install plugin', message: err instanceof Error ? err.message : String(err) },
       { status: 500 },
     )
   }

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

@@ -0,0 +1,155 @@
+import { NextResponse } from 'next/server'
+import {
+  loadTasks,
+  loadAgents,
+  loadSessions,
+  loadSchedules,
+  loadWebhooks,
+  loadSkills,
+} from '@/lib/server/storage'
+
+interface SearchResult {
+  type: 'task' | 'agent' | 'session' | 'schedule' | 'webhook' | 'skill' | 'message'
+  id: string
+  title: string
+  description?: string
+  status?: string
+  messageIndex?: number
+}
+
+const MAX_RESULTS = 20
+
+function matches(haystack: string | undefined | null, needle: string): boolean {
+  if (!haystack) return false
+  return haystack.toLowerCase().includes(needle)
+}
+
+function searchCollection(
+  collection: Record<string, Record<string, unknown>>,
+  type: SearchResult['type'],
+  needle: string,
+  titleKey: string,
+  descKey: string,
+  statusKey?: string,
+): SearchResult[] {
+  const results: SearchResult[] = []
+  for (const [id, item] of Object.entries(collection)) {
+    const title = item[titleKey] as string | undefined
+    const desc = item[descKey] as string | undefined
+    const idStr = typeof item.id === 'string' ? item.id : id
+    if (matches(title, needle) || matches(desc, needle) || matches(idStr, needle)) {
+      results.push({
+        type,
+        id,
+        title: title || idStr || id,
+        description: desc ? desc.slice(0, 120) : undefined,
+        status: statusKey ? (item[statusKey] as string | undefined) : undefined,
+      })
+    }
+  }
+  return results
+}
+
+function searchMessages(
+  sessions: Record<string, Record<string, unknown>>,
+  agents: Record<string, Record<string, unknown>>,
+  needle: string,
+): SearchResult[] {
+  const results: SearchResult[] = []
+  const MAX_MSG_RESULTS = 10
+  for (const [sessionId, session] of Object.entries(sessions)) {
+    if (results.length >= MAX_MSG_RESULTS) break
+    const messages = session.messages as Array<{ role: string; text: string; time?: number }> | undefined
+    if (!messages?.length) continue
+    const agentId = session.agentId as string | undefined
+    const agentName = agentId && agents[agentId] ? (agents[agentId].name as string) : undefined
+    const sessionName = (session.name as string) || 'Untitled'
+    for (let i = 0; i < messages.length; i++) {
+      if (results.length >= MAX_MSG_RESULTS) break
+      const msg = messages[i]
+      if (!msg?.text) continue
+      const idx = msg.text.toLowerCase().indexOf(needle)
+      if (idx === -1) continue
+      // Build snippet with context around match
+      const start = Math.max(0, idx - 30)
+      const end = Math.min(msg.text.length, idx + needle.length + 50)
+      const snippet = (start > 0 ? '...' : '') + msg.text.slice(start, end).replace(/\n/g, ' ') + (end < msg.text.length ? '...' : '')
+      const timeAgo = msg.time ? formatTimeAgo(msg.time) : ''
+      results.push({
+        type: 'message',
+        id: sessionId,
+        title: snippet,
+        description: [agentName || sessionName, timeAgo].filter(Boolean).join(' · '),
+        messageIndex: i,
+      })
+    }
+  }
+  return results
+}
+
+function formatTimeAgo(ts: number): string {
+  const diff = Date.now() - ts
+  const mins = Math.floor(diff / 60000)
+  if (mins < 1) return 'just now'
+  if (mins < 60) return `${mins}m ago`
+  const hours = Math.floor(mins / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(hours / 24)
+  return `${days}d ago`
+}
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const q = (searchParams.get('q') || '').trim().toLowerCase()
+
+  if (q.length < 2) {
+    return NextResponse.json({ results: [] })
+  }
+
+  const tasks = loadTasks() as Record<string, Record<string, unknown>>
+  const agents = loadAgents() as Record<string, Record<string, unknown>>
+  const sessions = loadSessions() as Record<string, Record<string, unknown>>
+  const schedules = loadSchedules() as Record<string, Record<string, unknown>>
+  const webhooks = loadWebhooks() as Record<string, Record<string, unknown>>
+  const skills = loadSkills() as Record<string, Record<string, unknown>>
+
+  const buckets: SearchResult[][] = [
+    searchCollection(agents, 'agent', q, 'name', 'description'),
+    searchCollection(tasks, 'task', q, 'title', 'description', 'status'),
+    searchCollection(sessions, 'session', q, 'name', 'cwd'),
+    searchCollection(schedules, 'schedule', q, 'name', 'taskPrompt', 'status'),
+    searchCollection(webhooks, 'webhook', q, 'name', 'source'),
+    searchCollection(skills, 'skill', q, 'name', 'description'),
+    searchMessages(sessions, agents, q),
+  ]
+
+  // Proportional allocation across types
+  const totalRaw = buckets.reduce((s, b) => s + b.length, 0)
+  if (totalRaw === 0) {
+    return NextResponse.json({ results: [] })
+  }
+
+  const results: SearchResult[] = []
+  if (totalRaw <= MAX_RESULTS) {
+    for (const bucket of buckets) results.push(...bucket)
+  } else {
+    // Give each bucket a fair share, round-robin leftover slots
+    const perBucket = Math.floor(MAX_RESULTS / buckets.length)
+    let remaining = MAX_RESULTS
+    for (const bucket of buckets) {
+      const take = Math.min(bucket.length, perBucket)
+      results.push(...bucket.slice(0, take))
+      remaining -= take
+    }
+    // Fill remaining slots from buckets that had more
+    for (const bucket of buckets) {
+      if (remaining <= 0) break
+      const alreadyTaken = Math.min(bucket.length, perBucket)
+      const extra = bucket.slice(alreadyTaken, alreadyTaken + remaining)
+      results.push(...extra)
+      remaining -= extra.length
+    }
+  }
+
+  return NextResponse.json({ results })
+}

package/src/app/api/sessions/[id]/chat/route.ts

@@ -17,6 +17,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const attachedFiles = Array.isArray(body.attachedFiles) ? body.attachedFiles.filter((f: unknown) => typeof f === 'string') as string[] : undefined
   const internal = body.internal === true
   const queueMode = normalizeQueueMode(body.queueMode, internal)
+  const replyToId = typeof body.replyToId === 'string' ? body.replyToId : undefined
 
   const hasFiles = !!(imagePath || imageUrl || (attachedFiles && attachedFiles.length > 0))
   if (!message.trim() && !hasFiles) {
@@ -46,6 +47,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
         source: internal ? 'heartbeat' : 'chat',
         mode: queueMode,
         onEvent: (ev) => writeEvent(ev as unknown as Record<string, unknown>),
+        replyToId,
       })
 
       log.info('chat', `Enqueued session run ${run.runId}`, {

package/src/app/api/sessions/[id]/edit-resend/route.ts

@@ -4,7 +4,7 @@ import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const body = await req.json() as { messageIndex: number; newText: string }
+  const body = await req.json().catch(() => ({})) as { messageIndex: number; newText: string }
   const sessions = loadSessions()
   const session = sessions[id]
   if (!session) return notFound()

package/src/app/api/sessions/[id]/fork/route.ts

@@ -5,7 +5,7 @@ import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const body = await req.json() as { messageIndex: number }
+  const body = await req.json().catch(() => ({})) as { messageIndex: number }
   const sessions = loadSessions()
   const source = sessions[id]
   if (!source) return notFound()

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

@@ -23,7 +23,7 @@ export async function GET(_req: Request) {
 }
 
 export async function DELETE(req: Request) {
-  const { ids } = await req.json() as { ids: string[] }
+  const { ids } = await req.json().catch(() => ({ ids: [] })) as { ids: string[] }
   if (!Array.isArray(ids) || !ids.length) {
     return new NextResponse('Missing ids', { status: 400 })
   }
@@ -43,7 +43,7 @@ export async function DELETE(req: Request) {
 }
 
 export async function POST(req: Request) {
-  const body = await req.json()
+  const body = await req.json().catch(() => ({}))
   let cwd = (body.cwd || '').trim()
   if (cwd.startsWith('~/')) cwd = path.join(os.homedir(), cwd.slice(2))
   else if (cwd === '~') cwd = os.homedir()
@@ -64,7 +64,7 @@ export async function POST(req: Request) {
 
   sessions[id] = {
     id, name: sessionName, cwd,
-    user: body.user || 'wayde',
+    user: body.user || 'user',
     provider: body.provider || agent?.provider || 'claude-cli',
     model: body.model || agent?.model || '',
     credentialId: body.credentialId || agent?.credentialId || null,

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

@@ -56,5 +56,14 @@ export async function PUT(req: Request) {
   settings.maxLinkedMemoriesExpanded = nextLinked
 
   saveSettings(settings)
+
+  // Restart heartbeat service when heartbeat-related settings change
+  const heartbeatKeys = ['heartbeatIntervalSec', 'heartbeatInterval', 'heartbeatPrompt', 'heartbeatEnabled', 'heartbeatActiveStart', 'heartbeatActiveEnd']
+  if (heartbeatKeys.some((k) => k in body)) {
+    import('@/lib/server/heartbeat-service').then(({ restartHeartbeatService }) => {
+      restartHeartbeatService()
+    }).catch(() => { /* heartbeat service may not be initialized yet */ })
+  }
+
   return NextResponse.json(settings)
 }

package/src/app/api/setup/check-provider/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { loadCredentials, decryptKey } from '@/lib/server/storage'
 import { getDeviceId, wsConnect } from '@/lib/providers/openclaw'
+import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 
 type SetupProvider =
   | 'openai'
@@ -15,20 +16,6 @@ type SetupProvider =
   | 'ollama'
   | 'openclaw'
 
-const OPENAI_COMPATIBLE_PROVIDER_INFO: Record<
-  'openai' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks',
-  { name: string; defaultEndpoint: string }
-> = {
-  openai: { name: 'OpenAI', defaultEndpoint: 'https://api.openai.com/v1' },
-  google: { name: 'Google Gemini', defaultEndpoint: 'https://generativelanguage.googleapis.com/v1beta/openai' },
-  deepseek: { name: 'DeepSeek', defaultEndpoint: 'https://api.deepseek.com/v1' },
-  groq: { name: 'Groq', defaultEndpoint: 'https://api.groq.com/openai/v1' },
-  together: { name: 'Together AI', defaultEndpoint: 'https://api.together.xyz/v1' },
-  mistral: { name: 'Mistral AI', defaultEndpoint: 'https://api.mistral.ai/v1' },
-  xai: { name: 'xAI (Grok)', defaultEndpoint: 'https://api.x.ai/v1' },
-  fireworks: { name: 'Fireworks AI', defaultEndpoint: 'https://api.fireworks.ai/inference/v1' },
-}
-
 interface SetupCheckBody {
   provider?: string
   apiKey?: string
@@ -196,7 +183,7 @@ export async function POST(req: Request) {
     switch (provider) {
       case 'openai': {
         if (!apiKey) return NextResponse.json({ ok: false, message: 'OpenAI API key is required.' })
-        const info = OPENAI_COMPATIBLE_PROVIDER_INFO.openai
+        const info = OPENAI_COMPATIBLE_DEFAULTS.openai
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint)
         return NextResponse.json(result)
       }
@@ -212,7 +199,7 @@ export async function POST(req: Request) {
       case 'mistral':
       case 'xai':
       case 'fireworks': {
-        const info = OPENAI_COMPATIBLE_PROVIDER_INFO[provider]
+        const info = OPENAI_COMPATIBLE_DEFAULTS[provider]
         if (!apiKey) return NextResponse.json({ ok: false, message: `${info.name} API key is required.` })
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint)
         return NextResponse.json(result)

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

@@ -18,6 +18,10 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const body = await req.json()
   const result = mutateItem(ops, id, (skill) => {
     const normalized = normalizeSkillPayload({ ...skill, ...body })
+    const updatedScope = body.scope === 'agent' ? 'agent' as const : body.scope === 'global' ? 'global' as const : skill.scope
+    const updatedAgentIds = updatedScope === 'agent' && Array.isArray(body.agentIds)
+      ? (body.agentIds as unknown[]).filter((aid): aid is string => typeof aid === 'string')
+      : updatedScope === 'agent' ? (skill.agentIds || []) : []
     return {
       ...skill,
       ...body,
@@ -27,6 +31,8 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       content: normalized.content,
       sourceUrl: normalized.sourceUrl,
       sourceFormat: normalized.sourceFormat,
+      scope: updatedScope,
+      agentIds: updatedAgentIds,
       id,
       updatedAt: Date.now(),
     }

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

@@ -14,6 +14,10 @@ export async function POST(req: Request) {
   const skills = loadSkills()
   const id = genId()
   const normalized = normalizeSkillPayload(body)
+  const scope = body.scope === 'agent' ? 'agent' as const : 'global' as const
+  const agentIds = scope === 'agent' && Array.isArray(body.agentIds)
+    ? (body.agentIds as unknown[]).filter((id): id is string => typeof id === 'string')
+    : []
   skills[id] = {
     id,
     name: normalized.name,
@@ -22,6 +26,8 @@ export async function POST(req: Request) {
     description: normalized.description || '',
     sourceUrl: normalized.sourceUrl,
     sourceFormat: normalized.sourceFormat,
+    scope,
+    agentIds,
     createdAt: Date.now(),
     updatedAt: Date.now(),
   }

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

@@ -7,6 +7,9 @@ import { ensureTaskCompletionReport } from '@/lib/server/task-reports'
 import { formatValidationFailure, validateTaskCompletion } from '@/lib/server/task-validation'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { notify } from '@/lib/server/ws-hub'
+import { createNotification } from '@/lib/server/create-notification'
+import { enqueueSystemEvent } from '@/lib/server/system-events'
+import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   // Keep completed queue integrity even if daemon is not running.
@@ -33,6 +36,8 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     tasks[id].updatedAt = Date.now()
   } else {
     Object.assign(tasks[id], body, { updatedAt: Date.now() })
+    // Explicitly clear nullable fields when sent as null (Object.assign copies null but not undefined)
+    if (body.projectId === null) delete tasks[id].projectId
   }
   tasks[id].id = id // prevent id overwrite
 
@@ -76,6 +81,21 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   // If task is manually transitioned to a terminal status, disable session heartbeat.
   if (prevStatus !== tasks[id].status && (tasks[id].status === 'completed' || tasks[id].status === 'failed')) {
     disableSessionHeartbeat(tasks[id].sessionId)
+    createNotification({
+      type: tasks[id].status === 'completed' ? 'success' : 'error',
+      title: `Task ${tasks[id].status}: "${tasks[id].title}"`,
+      message: tasks[id].status === 'failed' ? tasks[id].error?.slice(0, 200) : undefined,
+      entityType: 'task',
+      entityId: id,
+    })
+
+    // Enqueue system event + heartbeat wake
+    if (tasks[id].sessionId) {
+      enqueueSystemEvent(tasks[id].sessionId, `Task ${tasks[id].status}: ${tasks[id].title}`)
+    }
+    if (tasks[id].agentId) {
+      requestHeartbeatNow({ agentId: tasks[id].agentId, reason: 'task-completed' })
+    }
   }
 
   // Dependency check: cannot queue a task if any blocker is incomplete