@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/app/api/preview-server/route.ts

@@ -4,6 +4,7 @@ import http from 'http'
 import fs from 'fs'
 import path from 'path'
 import { localIP } from '@/lib/server/storage'
+import { resolveDevServerLaunchDir } from '@/lib/server/devserver-launch'
 
 // ---------------------------------------------------------------------------
 // MIME types for static server
@@ -77,6 +78,13 @@ interface ProjectInfo {
   framework?: string      // e.g. 'vite', 'next', 'cra'
 }
 
+function buildFrameworkArgs(framework: string | undefined, port: number): string[] {
+  if (framework === 'next') {
+    return ['--', '--hostname', '0.0.0.0', '--port', String(port)]
+  }
+  return ['--', '--port', String(port), '--host', '0.0.0.0']
+}
+
 function detectProject(dir: string): ProjectInfo {
   const pkgPath = path.join(dir, 'package.json')
   if (!fs.existsSync(pkgPath)) {
@@ -168,7 +176,7 @@ function createStaticServer(dir: string): http.Server {
 // npm dev server
 // ---------------------------------------------------------------------------
 
-async function startNpmServer(dir: string, command: string[], port: number): Promise<PreviewServer> {
+async function startNpmServer(dir: string, command: string[], port: number, framework?: string): Promise<PreviewServer> {
   // Install deps if node_modules missing
   if (!fs.existsSync(path.join(dir, 'node_modules'))) {
     console.log(`[preview] Installing dependencies in ${dir}`)
@@ -190,7 +198,7 @@ async function startNpmServer(dir: string, command: string[], port: number): Pro
   const args = [...command.slice(1)]
   const cmdName = command[0]
 
-  const proc = spawn(cmdName, [...args, '--', '--port', String(port), '--host', '0.0.0.0'], {
+  const proc = spawn(cmdName, [...args, ...buildFrameworkArgs(framework, port)], {
     cwd: dir,
     stdio: ['ignore', 'pipe', 'pipe'],
     env,
@@ -234,6 +242,10 @@ async function startNpmServer(dir: string, command: string[], port: number): Pro
 
   // Wait for the server to start and detect the actual port
   await new Promise((resolve) => setTimeout(resolve, 5000))
+  if (proc.exitCode !== null) {
+    servers.delete(dirKey(dir))
+    throw new Error(`npm dev server exited early with code ${proc.exitCode}\n${log.slice(-4000)}`)
+  }
   entry.port = detectedPort
   entry.log = log
 
@@ -263,7 +275,8 @@ export async function POST(req: Request) {
   }
 
   const dir = resolveServeDir(filePath)
-  const key = dirKey(dir)
+  const launch = resolveDevServerLaunchDir(dir)
+  const key = dirKey(launch.launchDir)
 
   if (action === 'start') {
     if (servers.has(key)) {
@@ -274,16 +287,18 @@ export async function POST(req: Request) {
       return NextResponse.json({ error: 'Directory not found' }, { status: 404 })
     }
 
-    const project = detectProject(dir)
+    const project = detectProject(launch.launchDir)
     const port = await findFreePort()
 
     if (project.type === 'npm' && project.devCommand) {
-      console.log(`[preview] Detected ${project.framework} project in ${dir}, running: ${project.devCommand.join(' ')}`)
+      console.log(`[preview] Detected ${project.framework} project in ${launch.launchDir}, running: ${project.devCommand.join(' ')}`)
       try {
-        const entry = await startNpmServer(dir, project.devCommand, port)
+        const entry = await startNpmServer(launch.launchDir, project.devCommand, port, project.framework)
         return NextResponse.json({
           ...buildResponse(entry),
           framework: project.framework,
+          inputDir: dir,
+          launchDir: launch.launchDir,
         })
       } catch (err: unknown) {
         console.error(`[preview] npm server failed, falling back to static:`, err)
@@ -313,15 +328,15 @@ export async function POST(req: Request) {
       }
       if (srv.server) srv.server.close()
       servers.delete(key)
-      console.log(`[preview] Stopped server for ${dir}`)
+      console.log(`[preview] Stopped server for ${launch.launchDir}`)
     }
-    return NextResponse.json({ running: false, dir })
+    return NextResponse.json({ running: false, dir: launch.launchDir })
 
   } else if (action === 'status') {
     if (servers.has(key)) {
       return NextResponse.json(buildResponse(servers.get(key)!))
     }
-    return NextResponse.json({ running: false, dir })
+    return NextResponse.json({ running: false, dir: launch.launchDir })
 
   } else if (action === 'list') {
     const list = Array.from(servers.values()).map((s) => ({
@@ -331,8 +346,8 @@ export async function POST(req: Request) {
     return NextResponse.json({ servers: list })
 
   } else if (action === 'detect') {
-    const project = detectProject(dir)
-    return NextResponse.json({ dir, ...project })
+    const project = detectProject(launch.launchDir)
+    return NextResponse.json({ dir, launchDir: launch.launchDir, frameworkHint: launch.framework, ...project })
   }
 
   return NextResponse.json({ error: 'Invalid action' }, { status: 400 })

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

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
-import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills } from '@/lib/server/storage'
+import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills, loadSecrets, saveSecrets } from '@/lib/server/storage'
 import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import { ensureProjectWorkspace, normalizeProjectPatchInput } from '@/lib/server/project-utils'
 import { notify } from '@/lib/server/ws-hub'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -17,12 +18,14 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const { id } = await params
   const body = await req.json()
   const result = mutateItem(ops, id, (project) => {
-    Object.assign(project, body, { updatedAt: Date.now() })
+    const patch = normalizeProjectPatchInput(body && typeof body === 'object' ? body as Record<string, unknown> : {})
+    Object.assign(project, patch, { updatedAt: Date.now() })
     delete (project as Record<string, unknown>).id
     project.id = id
     return project
   })
   if (!result) return notFound()
+  ensureProjectWorkspace(id, result.name)
   return NextResponse.json(result)
 }
 
@@ -50,6 +53,7 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   clearProjectId(loadTasks, saveTasks, 'tasks')
   clearProjectId(loadSchedules, saveSchedules, 'schedules')
   clearProjectId(loadSkills, saveSkills, 'skills')
+  clearProjectId(loadSecrets, saveSecrets, 'secrets')
 
   return NextResponse.json({ ok: true })
 }

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

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadProjects, saveProjects } from '@/lib/server/storage'
+import { ensureProjectWorkspace, normalizeProjectCreateInput } from '@/lib/server/project-utils'
 import { notify } from '@/lib/server/ws-hub'
 export const dynamic = 'force-dynamic'
 
@@ -13,15 +14,15 @@ export async function POST(req: Request) {
   const id = genId()
   const now = Date.now()
   const projects = loadProjects()
+  const normalized = normalizeProjectCreateInput(body && typeof body === 'object' ? body as Record<string, unknown> : {})
   projects[id] = {
     id,
-    name: body.name || 'Unnamed Project',
-    description: body.description || '',
-    color: body.color || undefined,
+    ...normalized,
     createdAt: now,
     updatedAt: now,
   }
   saveProjects(projects)
+  ensureProjectWorkspace(id, projects[id].name)
   notify('projects')
   return NextResponse.json(projects[id])
 }

package/src/app/api/schedules/[id]/run/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { notFound } from '@/lib/server/collection-helpers'
 import { loadSchedules, saveSchedules, loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
+import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agent-availability'
 import { enqueueTask } from '@/lib/server/queue'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
@@ -20,6 +21,9 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
   const agents = loadAgents()
   const agent = agents[schedule.agentId]
   if (!agent) return NextResponse.json({ error: 'Agent not found' }, { status: 400 })
+  if (isAgentDisabled(agent)) {
+    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'run schedules') }, { status: 409 })
+  }
 
   const tasks = loadTasks()
   const scheduleSignature = getScheduleSignatureKey(schedule)

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

@@ -0,0 +1,86 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+
+import { POST as createSchedule } from './route'
+import { POST as runSchedule } from './[id]/run/route'
+import { loadAgents, loadSchedules, saveAgents, saveSchedules } from '@/lib/server/storage'
+
+const originalAgents = loadAgents()
+const originalSchedules = loadSchedules()
+
+function routeParams(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+function seedAgent(id: string, overrides: Record<string, unknown> = {}) {
+  const agents = loadAgents()
+  const now = Date.now()
+  agents[id] = {
+    id,
+    name: 'Schedule Test Agent',
+    description: 'Schedule smoke test agent',
+    systemPrompt: 'Handle schedules.',
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    credentialId: null,
+    fallbackCredentialIds: [],
+    apiEndpoint: null,
+    plugins: ['manage_schedules'],
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+  saveAgents(agents)
+}
+
+afterEach(() => {
+  saveAgents(originalAgents)
+  saveSchedules(originalSchedules)
+})
+
+test('POST /api/schedules rejects disabled agents', async () => {
+  seedAgent('schedule-disabled-agent', { disabled: true })
+
+  const response = await createSchedule(new Request('http://local/api/schedules', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      agentId: 'schedule-disabled-agent',
+      name: 'Disabled smoke',
+      taskPrompt: 'Send a reminder',
+      scheduleType: 'once',
+      runAt: Date.now() + 60_000,
+      status: 'active',
+    }),
+  }))
+
+  assert.equal(response.status, 409)
+  const payload = await response.json() as Record<string, unknown>
+  assert.match(String(payload.error || ''), /disabled/i)
+})
+
+test('POST /api/schedules/[id]/run rejects disabled agents', async () => {
+  seedAgent('schedule-run-disabled-agent', { disabled: true })
+  const schedules = loadSchedules()
+  schedules['schedule-disabled-run'] = {
+    id: 'schedule-disabled-run',
+    name: 'Disabled Run',
+    agentId: 'schedule-run-disabled-agent',
+    taskPrompt: 'Send a reminder',
+    scheduleType: 'once',
+    runAt: Date.now() + 60_000,
+    status: 'active',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+  saveSchedules(schedules)
+
+  const response = await runSchedule(
+    new Request('http://local/api/schedules/schedule-disabled-run/run', { method: 'POST' }),
+    routeParams('schedule-disabled-run'),
+  )
+
+  assert.equal(response.status, 409)
+  const payload = await response.json() as Record<string, unknown>
+  assert.match(String(payload.error || ''), /disabled/i)
+})

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

@@ -3,6 +3,7 @@ import { genId } from '@/lib/id'
 import { loadAgents, loadSchedules, saveSchedules } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
+import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agent-availability'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule } from '@/lib/schedule-dedupe'
 import { notify } from '@/lib/server/ws-hub'
@@ -45,9 +46,13 @@ export async function POST(req: Request) {
 
   const candidate = normalizedSchedule.value
   const agents = loadAgents()
-  if (!agents[String(candidate.agentId)]) {
+  const agent = agents[String(candidate.agentId)]
+  if (!agent) {
     return NextResponse.json({ error: `Agent not found: ${String(candidate.agentId)}` }, { status: 400 })
   }
+  if (isAgentDisabled(agent)) {
+    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'take scheduled work') }, { status: 409 })
+  }
   const scheduleType = asScheduleType(candidate.scheduleType)
   const candidateAgentId = asString(candidate.agentId) || null
   const candidateTaskPrompt = asString(candidate.taskPrompt)

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

@@ -19,6 +19,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     if (body.service !== undefined) secret.service = body.service
     if (body.scope !== undefined) secret.scope = body.scope
     if (body.agentIds !== undefined) secret.agentIds = body.agentIds
+    if (body.projectId !== undefined) secret.projectId = body.projectId || undefined
     secret.updatedAt = Date.now()
     return secret
   })

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

@@ -10,7 +10,7 @@ export async function GET(_req: Request) {
   const safe = Object.fromEntries(
     Object.entries(secrets).map(([id, s]: [string, any]) => [
       id,
-      { id: s.id, name: s.name, service: s.service, scope: s.scope, agentIds: s.agentIds, createdAt: s.createdAt, updatedAt: s.updatedAt },
+      { id: s.id, name: s.name, service: s.service, scope: s.scope, agentIds: s.agentIds, projectId: s.projectId, createdAt: s.createdAt, updatedAt: s.updatedAt },
     ])
   )
   return NextResponse.json(safe)
@@ -33,6 +33,7 @@ export async function POST(req: Request) {
     encryptedValue: encryptKey(body.value),
     scope: body.scope || 'global',
     agentIds: body.agentIds || [],
+    projectId: typeof body.projectId === 'string' && body.projectId.trim() ? body.projectId.trim() : undefined,
     createdAt: now,
     updatedAt: now,
   }

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

@@ -126,6 +126,8 @@ export async function PUT(req: Request) {
   settings.taskQualityGateRequireVerification = parseBoolSetting(settings.taskQualityGateRequireVerification, false)
   settings.taskQualityGateRequireArtifact = parseBoolSetting(settings.taskQualityGateRequireArtifact, false)
   settings.taskQualityGateRequireReport = parseBoolSetting(settings.taskQualityGateRequireReport, false)
+  settings.taskManagementEnabled = parseBoolSetting(settings.taskManagementEnabled, true)
+  settings.projectManagementEnabled = parseBoolSetting(settings.projectManagementEnabled, true)
   settings.integrityMonitorEnabled = parseBoolSetting(settings.integrityMonitorEnabled, true)
   settings.sessionResetMode = settings.sessionResetMode === 'daily' ? 'daily' : settings.sessionResetMode === 'idle' ? 'idle' : null
   settings.sessionIdleTimeoutSec = parseIntSetting(

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

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { normalizeOllamaSetupEndpoint } from './route'
+
+test('normalizeOllamaSetupEndpoint strips local /v1 suffixes but preserves cloud endpoints', () => {
+  assert.equal(
+    normalizeOllamaSetupEndpoint('http://localhost:11434/v1', false),
+    'http://localhost:11434',
+  )
+  assert.equal(
+    normalizeOllamaSetupEndpoint('http://localhost:11434/', false),
+    'http://localhost:11434',
+  )
+  assert.equal(
+    normalizeOllamaSetupEndpoint('https://ollama.com/v1', true),
+    'https://ollama.com/v1',
+  )
+})

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

@@ -2,6 +2,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'
+import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 
 type SetupProvider =
   | 'openai'
@@ -28,6 +29,12 @@ function clean(value: unknown): string {
   return typeof value === 'string' ? value.trim() : ''
 }
 
+export function normalizeOllamaSetupEndpoint(endpoint: string, useCloud: boolean): string {
+  const normalized = endpoint.replace(/\/+$/, '')
+  if (useCloud) return normalized
+  return normalized.replace(/\/v1$/i, '')
+}
+
 function parseBody(input: unknown): SetupCheckBody {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
   return input as SetupCheckBody
@@ -101,9 +108,28 @@ async function checkAnthropic(apiKey: string, modelRaw: string): Promise<{ ok: b
   return { ok: true, message: text ? `Connected to Anthropic. Sample: ${text.slice(0, 120)}` : 'Connected to Anthropic.' }
 }
 
-async function checkOllama(endpointRaw: string): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; recommendedModel?: string }> {
-  const normalizedEndpoint = (endpointRaw || 'http://localhost:11434').replace(/\/+$/, '')
-  const res = await fetch(`${normalizedEndpoint}/api/tags`, {
+async function checkOllama(params: {
+  endpointRaw: string
+  modelRaw: string
+  apiKey?: string
+}): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; recommendedModel?: string }> {
+  const runtime = resolveOllamaRuntimeConfig({
+    model: params.modelRaw,
+    apiKey: params.apiKey,
+    apiEndpoint: params.endpointRaw,
+  })
+  const normalizedEndpoint = normalizeOllamaSetupEndpoint(runtime.endpoint, runtime.useCloud)
+  const tagsPath = runtime.useCloud ? '/v1/models' : '/api/tags'
+  const headers = runtime.apiKey ? { authorization: `Bearer ${runtime.apiKey}` } : undefined
+  if (runtime.useCloud && !runtime.apiKey) {
+    return {
+      ok: false,
+      message: 'Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.',
+      normalizedEndpoint,
+    }
+  }
+  const res = await fetch(`${normalizedEndpoint}${tagsPath}`, {
+    headers,
     signal: AbortSignal.timeout(8_000),
     cache: 'no-store',
   })
@@ -112,20 +138,24 @@ async function checkOllama(endpointRaw: string): Promise<{ ok: boolean; message:
     return { ok: false, message: detail, normalizedEndpoint }
   }
   const payload = await res.json().catch(() => ({} as any))
-  const models = Array.isArray(payload?.models) ? payload.models : []
-  const firstModel = typeof models[0]?.name === 'string'
-    ? String(models[0].name).replace(/:latest$/, '')
-    : undefined
+  const models = runtime.useCloud
+    ? (Array.isArray(payload?.data) ? payload.data : [])
+    : (Array.isArray(payload?.models) ? payload.models : [])
+  const firstModel = runtime.useCloud
+    ? (typeof models[0]?.id === 'string' ? String(models[0].id) : undefined)
+    : (typeof models[0]?.name === 'string' ? String(models[0].name).replace(/:latest$/, '') : undefined)
   if (models.length === 0) {
     return {
       ok: true,
-      message: 'Connected to Ollama, but no models are installed yet. Run `ollama pull <model>` to add one.',
+      message: runtime.useCloud
+        ? 'Connected to Ollama Cloud, but no models were returned.'
+        : 'Connected to Ollama, but no models are installed yet. Run `ollama pull <model>` to add one.',
       normalizedEndpoint,
     }
   }
   return {
     ok: true,
-    message: `Connected to Ollama. ${models.length} model(s) available.`,
+    message: `Connected to ${runtime.useCloud ? 'Ollama Cloud' : 'Ollama'}. ${models.length} model(s) available.`,
     normalizedEndpoint,
     recommendedModel: firstModel,
   }
@@ -205,7 +235,7 @@ export async function POST(req: Request) {
         return NextResponse.json(result)
       }
       case 'ollama': {
-        const result = await checkOllama(endpoint)
+        const result = await checkOllama({ endpointRaw: endpoint, modelRaw: model, apiKey })
         return NextResponse.json(result)
       }
       case 'openclaw': {

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

@@ -31,6 +31,18 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       content: normalized.content,
       sourceUrl: normalized.sourceUrl,
       sourceFormat: normalized.sourceFormat,
+      author: normalized.author ?? skill.author,
+      tags: normalized.tags ?? skill.tags,
+      version: normalized.version ?? null,
+      homepage: normalized.homepage ?? null,
+      primaryEnv: normalized.primaryEnv ?? null,
+      skillKey: normalized.skillKey ?? null,
+      always: typeof normalized.always === 'boolean' ? normalized.always : false,
+      installOptions: normalized.installOptions,
+      skillRequirements: normalized.skillRequirements,
+      detectedEnvVars: normalized.detectedEnvVars,
+      security: normalized.security,
+      frontmatter: normalized.frontmatter,
       scope: updatedScope,
       agentIds: updatedAgentIds,
       id,

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

@@ -1,6 +1,4 @@
-import { genId } from '@/lib/id'
 import { NextResponse } from 'next/server'
-import { loadSkills, saveSkills } from '@/lib/server/storage'
 import { normalizeSkillPayload } from '@/lib/server/skills-normalize'
 
 const MAX_SKILL_BYTES = 2 * 1024 * 1024
@@ -46,22 +44,26 @@ export async function POST(req: Request) {
       sourceUrl: url,
     })
 
-    const skills = loadSkills()
-    const id = genId()
-    skills[id] = {
-      id,
+    return NextResponse.json({
       name: normalized.name,
       filename: normalized.filename,
       description: normalized.description,
       content: normalized.content,
       sourceUrl: normalized.sourceUrl,
       sourceFormat: normalized.sourceFormat,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    }
-    saveSkills(skills)
-
-    return NextResponse.json(skills[id])
+      author: normalized.author,
+      tags: normalized.tags,
+      version: normalized.version,
+      homepage: normalized.homepage,
+      primaryEnv: normalized.primaryEnv,
+      skillKey: normalized.skillKey,
+      always: normalized.always,
+      installOptions: normalized.installOptions,
+      skillRequirements: normalized.skillRequirements,
+      detectedEnvVars: normalized.detectedEnvVars,
+      security: normalized.security,
+      frontmatter: normalized.frontmatter,
+    })
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : 'Failed to import skill'
     return NextResponse.json({ error: message }, { status: 400 })

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

@@ -5,7 +5,7 @@ import { normalizeSkillPayload } from '@/lib/server/skills-normalize'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET() {
   return NextResponse.json(loadSkills())
 }
 
@@ -26,6 +26,18 @@ export async function POST(req: Request) {
     description: normalized.description || '',
     sourceUrl: normalized.sourceUrl,
     sourceFormat: normalized.sourceFormat,
+    author: normalized.author,
+    tags: normalized.tags,
+    version: normalized.version,
+    homepage: normalized.homepage,
+    primaryEnv: normalized.primaryEnv,
+    skillKey: normalized.skillKey,
+    always: normalized.always,
+    installOptions: normalized.installOptions,
+    skillRequirements: normalized.skillRequirements,
+    detectedEnvVars: normalized.detectedEnvVars,
+    security: normalized.security,
+    frontmatter: normalized.frontmatter,
     scope,
     agentIds,
     createdAt: Date.now(),

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

@@ -126,7 +126,16 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       enqueueSystemEvent(tasks[id].sessionId, `Task ${tasks[id].status}: ${tasks[id].title}`)
     }
     if (tasks[id].agentId) {
-      requestHeartbeatNow({ agentId: tasks[id].agentId, reason: 'task-completed' })
+      requestHeartbeatNow({
+        agentId: tasks[id].agentId,
+        eventId: `task:${id}:${tasks[id].status}`,
+        reason: 'task-completed',
+        source: `task:${id}`,
+        resumeMessage: `Task ${tasks[id].status}: ${tasks[id].title}`,
+        detail: tasks[id].status === 'failed'
+          ? String(tasks[id].error || '').slice(0, 400)
+          : JSON.stringify(tasks[id].result || '').slice(0, 400),
+      })
     }
   }
 

package/src/app/api/tasks/import/github/route.test.ts

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  buildGitHubIssueTaskDescription,
+  buildGitHubIssueTaskTags,
+  buildGitHubIssueTaskTitle,
+  parseGitHubRepoInput,
+} from './route'
+
+test('parseGitHubRepoInput accepts repo slugs and GitHub URLs', () => {
+  assert.deepEqual(parseGitHubRepoInput('swarmclawai/swarmclaw'), {
+    owner: 'swarmclawai',
+    repo: 'swarmclaw',
+    fullName: 'swarmclawai/swarmclaw',
+  })
+
+  assert.deepEqual(parseGitHubRepoInput('https://github.com/swarmclawai/swarmclaw/issues'), {
+    owner: 'swarmclawai',
+    repo: 'swarmclaw',
+    fullName: 'swarmclawai/swarmclaw',
+  })
+
+  assert.equal(parseGitHubRepoInput('not-a-repo'), null)
+  assert.equal(parseGitHubRepoInput('https://example.com/swarmclawai/swarmclaw'), null)
+})
+
+test('GitHub issue mapping builds a source-aware task payload shape', () => {
+  const issue = {
+    id: 12345,
+    number: 87,
+    title: 'Import GitHub issues into the board',
+    body: 'Bring open issues into SwarmClaw tasks.',
+    state: 'open',
+    html_url: 'https://github.com/swarmclawai/swarmclaw/issues/87',
+    labels: [{ name: 'feature' }, { name: 'task board' }, { name: 'feature' }],
+    assignee: { login: 'waydelyle' },
+    user: { login: 'octocat' },
+  }
+
+  assert.equal(
+    buildGitHubIssueTaskTitle(issue, 'swarmclawai/swarmclaw'),
+    '[swarmclawai/swarmclaw#87] Import GitHub issues into the board',
+  )
+
+  assert.equal(
+    buildGitHubIssueTaskDescription(issue, 'swarmclawai/swarmclaw'),
+    [
+      'Imported from GitHub issue swarmclawai/swarmclaw#87',
+      'URL: https://github.com/swarmclawai/swarmclaw/issues/87',
+      'State: open',
+      'Labels: feature, task board, feature',
+      'Assignee: waydelyle',
+      'Opened by: octocat',
+      '',
+      'Bring open issues into SwarmClaw tasks.',
+    ].join('\n'),
+  )
+
+  assert.deepEqual(buildGitHubIssueTaskTags(issue, 'swarmclawai/swarmclaw'), [
+    'github',
+    'swarmclawai/swarmclaw',
+    'feature',
+    'task board',
+  ])
+})