@swarmclawai/swarmclaw 1.2.8 → 1.3.0

package/README.md

@@ -100,13 +100,13 @@ A squad of agents mirroring a real engineering team — planning, building, revi
 
 | Role | Agent | Tools |
 |------|-------|-------|
-| **Lead** | Architect | Delegation, tasks, schedules, missions |
+| **Lead** | Architect | Delegation, tasks, schedules, structured sessions |
 | **Dev** | Builder | Shell, files, Claude Code / Codex / OpenCode |
 | **QA** | Tester | Shell, browser, files, web search |
 | **Designer** | Creative | Image generation, browser, web search, files |
 | **Reviewer** | Critic | Files, web search, memory |
 
-- The Lead creates missions and breaks them into tasks on the board
+- The Lead breaks work into tasks on the board and uses structured sessions for bounded runs
 - Dev agents pick up tasks and delegate to Claude Code, Codex, or OpenCode for implementation
 - QA runs tests, takes screenshots, and files bugs back on the task board
 - The Reviewer audits PRs and flags regressions
@@ -188,8 +188,39 @@ These aren't exclusive templates — they're patterns you combine. A virtual com
 
 The building blocks are the same: **agents, tools, memory, delegation, schedules, connectors, and skills**. SwarmClaw just gives you the control plane to wire them together.
 
+## SwarmDock Marketplace
+
+SwarmClaw agents can register on [SwarmDock](https://swarmdock.ai) — a peer-to-peer marketplace where autonomous AI agents discover tasks, bid competitively, complete work, and earn USDC payments on Base L2. SwarmDock is the marketplace; SwarmClaw is the control plane.
+
+- **Register** your agents on SwarmDock with their Ed25519 identity and skill set
+- **Discover** paid tasks matching your agents' capabilities via polling or real-time SSE
+- **Bid** autonomously within configured budget and confidence thresholds
+- **Earn** USDC on Base L2 with 7% platform fee, sub-2-second settlement
+- **Track** assignments, payouts, and task history from the SwarmClaw task board and connectors UI
+
+Read the full setup guide in [`SWARMDOCK.md`](./SWARMDOCK.md), browse the public docs at [swarmclaw.ai/docs/swarmdock](https://swarmclaw.ai/docs/swarmdock), and visit [swarmdock.ai](https://swarmdock.ai) for the marketplace itself.
+
+---
+
 ## Release Notes
 
+### v1.3.0 Highlights
+
+- **SwarmDock SDK v0.2.0**: upgraded marketplace integration to handle the new task lifecycle — `review` and `disputed` states are now tracked on board tasks, skill registration supports `inputModes`/`outputModes`, task submission accepts `notes`, and connector config supports `paymentPrivateKey` for on-chain payment signing.
+- **Comprehensive audit logging**: activity log now covers approval decisions, settings changes, budget modifications, and credential operations, with SQL-indexed paginated queries replacing the in-memory full-collection scan.
+- **Push-based cost rollups**: agent spend fields (`spentHourlyCents`, `spentDailyCents`, `spentMonthlyCents`) update atomically on every usage event, with automatic budget warning/exceeded activity entries and window reset detection — replacing the pull-based full-scan approach.
+- **Goal hierarchy**: new goals system with organization → team → project → agent → task levels, parent-child chains, and automatic injection of the "why chain" into agent execution briefs. Full CRUD API and CLI support.
+- **Extended approval workflows**: new `agent_create`, `budget_change`, and `delegation_enable` approval categories with configurable policies in settings. When enabled, agent creation returns a pending approval instead of creating the agent directly.
+- **Shared validation schemas**: Zod schemas in `src/lib/validation/schemas.ts` are now safe for client-side import (server-only DAG validation moved to `server-schemas.ts`), enabling form-level pre-validation.
+
+### v1.2.9 Highlights
+
+- **SwarmDock marketplace connector**: SwarmClaw agents can now register on SwarmDock, auto-bid on matching work, receive assignments as board tasks, and submit results back through the connector runtime.
+- **Secure SwarmDock credentials**: Ed25519 identity keys now live in encrypted credentials instead of connector config, legacy plaintext keys auto-migrate on load, connector API responses redact secrets, and failed result submissions now surface properly for retry/recovery.
+- **Portable config transfer**: new portability import/export flows move agents, skills, and schedules between installs, with manifest validation that rejects malformed imports cleanly instead of crashing.
+- **Wallet surface simplification**: wallets are now lightweight Base-linked agent records with stricter validation for missing agents and invalid addresses, replacing the older action-heavy wallet route surface.
+- **UI surface cleanup**: the app now centers work around tasks, structured sessions, autonomy, connectors, and projects, with the old Missions, Canvas, and legacy wallet action screens removed from the shipped interface.
+
 ### v1.2.8 Highlights
 
 - **Linux/WSL compatibility**: subprocess spawning now uses `$SHELL` instead of hardcoded `/bin/zsh`, fixing `ENOENT` errors on Linux and WSL systems.
@@ -345,12 +376,12 @@ Then open `http://localhost:3456`.
 
 - **Providers**: OpenClaw, OpenAI, Anthropic, Ollama, Google, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, plus compatible custom endpoints.
 - **Delegation**: built-in delegation to Claude Code, Codex CLI, OpenCode CLI, Gemini CLI, and native SwarmClaw subagents.
-- **Autonomy**: heartbeat loops, schedules, background jobs, task execution, supervisor recovery, mission control, and agent wakeups.
-- **Orchestration**: durable structured execution with branching, repeat loops, parallel branches, explicit joins, restart-safe run state, and contextual launch from chats, chatrooms, tasks, missions, schedules, and API flows.
+- **Autonomy**: heartbeat loops, schedules, background jobs, task execution, supervisor recovery, and agent wakeups.
+- **Orchestration**: durable structured execution with branching, repeat loops, parallel branches, explicit joins, restart-safe run state, and contextual launch from chats, chatrooms, tasks, schedules, and API flows.
 - **Structured Sessions**: reusable bounded runs with templates, facilitators, participants, hidden live rooms, chatroom `/breakout`, durable transcripts, outputs, and operator controls.
 - **Memory**: hybrid recall, graph traversal, journaling, durable documents, project-scoped context, automatic reflection memory, communication preferences, profile and boundary memory, significant events, and open follow-up loops.
-- **Wallets**: balances, transfers, signatures, EVM call/quote/swap flows, and approval-gated execution.
-- **Connectors**: Discord, Slack, Telegram, WhatsApp, Teams, Matrix, OpenClaw, and more.
+- **Wallets**: linked Base wallet generation, address management, approval-oriented limits, and agent payout identity.
+- **Connectors**: Discord, Slack, Telegram, WhatsApp, Teams, Matrix, OpenClaw, SwarmDock, and more.
 - **Extensions**: external tool extensions, UI modules, hooks, and install/update flows.
 
 ## Requirements
@@ -373,5 +404,7 @@ Then open `http://localhost:3456`.
 - OpenClaw setup: https://swarmclaw.ai/docs/openclaw-setup
 - Agents: https://swarmclaw.ai/docs/agents
 - Connectors: https://swarmclaw.ai/docs/connectors
+- SwarmDock: https://swarmclaw.ai/docs/swarmdock
+- SwarmDock marketplace: https://swarmdock.ai
 - Extensions: https://swarmclaw.ai/docs/extensions
 - CLI reference: https://swarmclaw.ai/docs/cli

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "description": "Self-hosted AI runtime for OpenClaw, delegation, autonomy, runtime skills, crypto wallets, and chat platform connectors.",
   "license": "MIT",
   "publishConfig": {
@@ -87,7 +87,7 @@
     "@multiavatar/multiavatar": "^1.0.7",
     "@playwright/mcp": "^0.0.68",
     "@slack/bolt": "^4.6.0",
-    "@solana/web3.js": "^1.98.4",
+    "@swarmdock/sdk": "^0.2.0",
     "@tailwindcss/postcss": "^4",
     "@tanstack/react-query": "^5.91.0",
     "@types/better-sqlite3": "^7.6.13",

package/src/app/agents/[id]/page.tsx

@@ -1,19 +1,13 @@
 'use client'
 
-import { useEffect, useState } from 'react'
+import { useEffect } from 'react'
 import { useParams } from 'next/navigation'
 import { useAppStore } from '@/stores/use-app-store'
-import { selectActiveSessionId } from '@/stores/slices/session-slice'
 import { ChatArea } from '@/components/chat/chat-area'
-import { CanvasPanel } from '@/components/canvas/canvas-panel'
 
 export default function AgentChatPage() {
   const { id } = useParams<{ id: string }>()
   const setCurrentAgent = useAppStore((s) => s.setCurrentAgent)
-  const activeSessionId = useAppStore(selectActiveSessionId)
-  const sessions = useAppStore((s) => s.sessions)
-  const agents = useAppStore((s) => s.agents)
-  const [canvasDismissedFor, setCanvasDismissedFor] = useState<string | null>(null)
 
   // Sync URL param to store
   useEffect(() => {
@@ -22,22 +16,11 @@ export default function AgentChatPage() {
     }
   }, [id, setCurrentAgent])
 
-  const currentSession = activeSessionId ? sessions[activeSessionId] : null
-  const hasCanvas = !!(currentSession?.canvasContent && canvasDismissedFor !== activeSessionId)
-  const canvasAgentName = currentSession?.agentId && agents[currentSession.agentId] ? agents[currentSession.agentId].name : undefined
-
   return (
     <div className="flex-1 flex h-full min-h-0 min-w-0">
       <div className="flex-1 min-h-0 min-w-0 overflow-hidden">
         <ChatArea key={id} />
       </div>
-      {hasCanvas && activeSessionId && (
-        <CanvasPanel
-          sessionId={activeSessionId}
-          agentName={canvasAgentName}
-          onClose={() => activeSessionId && setCanvasDismissedFor(activeSessionId)}
-        />
-      )}
     </div>
   )
 }

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

@@ -1,32 +1,18 @@
 import { NextResponse } from 'next/server'
-import { loadActivity } from '@/lib/server/storage'
+import { queryActivity } from '@/lib/server/activity/activity-log'
 export const dynamic = 'force-dynamic'
 
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url)
-  const entityType = searchParams.get('entityType')
-  const entityId = searchParams.get('entityId')
-  const actor = searchParams.get('actor')
-  const action = searchParams.get('action')
-  const since = searchParams.get('since')
+  const entityType = searchParams.get('entityType') ?? undefined
+  const entityId = searchParams.get('entityId') ?? undefined
+  const actor = searchParams.get('actor') ?? undefined
+  const action = searchParams.get('action') ?? undefined
+  const sinceRaw = searchParams.get('since')
+  const since = sinceRaw ? Number(sinceRaw) : undefined
   const limit = Math.min(200, Math.max(1, Number(searchParams.get('limit')) || 50))
+  const offset = Math.max(0, Number(searchParams.get('offset')) || 0)
 
-  const all = loadActivity()
-  let entries = Object.values(all) as unknown as Array<Record<string, unknown>>
-
-  if (entityType) entries = entries.filter((e) => e.entityType === entityType)
-  if (entityId) entries = entries.filter((e) => e.entityId === entityId)
-  if (actor) entries = entries.filter((e) => e.actor === actor)
-  if (action) entries = entries.filter((e) => e.action === action)
-  if (since) {
-    const sinceMs = Number(since)
-    if (Number.isFinite(sinceMs)) {
-      entries = entries.filter((e) => typeof e.timestamp === 'number' && e.timestamp >= sinceMs)
-    }
-  }
-
-  entries.sort((a, b) => (b.timestamp as number) - (a.timestamp as number))
-  entries = entries.slice(0, limit)
-
+  const entries = queryActivity({ entityType, entityId, actor, action, since, limit, offset })
   return NextResponse.json(entries)
 }

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

@@ -5,6 +5,8 @@ import { AgentCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 import { z } from 'zod'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { loadSettings } from '@/lib/server/storage'
+import { requestApproval } from '@/lib/server/approvals'
 export const dynamic = 'force-dynamic'
 
 
@@ -36,6 +38,20 @@ export async function POST(req: Request) {
   if (!parsed.success) {
     return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
   }
-  const agent = createAgent({ body: parsed.data as unknown as Record<string, unknown>, rawRecord })
+  const body = parsed.data as unknown as Record<string, unknown>
+
+  // Check approval policy — if enabled, create an approval request instead of the agent
+  const settings = loadSettings()
+  if (settings.approvalPolicies?.requireApprovalForAgentCreate) {
+    const approval = requestApproval({
+      category: 'agent_create',
+      title: `Create agent: ${body.name}`,
+      description: `Request to create agent "${body.name}" with provider ${body.provider}`,
+      data: { pendingAgentConfig: body, agentName: String(body.name || ''), provider: String(body.provider || '') },
+    })
+    return NextResponse.json({ pendingApproval: true, approvalId: approval.id }, { status: 202 })
+  }
+
+  const agent = createAgent({ body, rawRecord })
   return NextResponse.json(agent)
 }

package/src/app/api/agents/thread-route.test.ts

@@ -116,7 +116,6 @@ test('POST /api/agents/[id]/thread reuses an existing thread for a disabled agen
     file: null,
     queuedCount: 0,
     currentRunId: null,
-    canvasContent: null,
   }
   saveSessions(sessions)
 

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

@@ -46,11 +46,6 @@ test('GET and POST /api/approvals handle human-loop approvals only', () => {
       title: 'Approve deploy',
       data: { question: 'Deploy now?' },
     })
-    approvals.requestApproval({
-      category: 'wallet_action',
-      title: 'Legacy wallet approval',
-      data: { action: 'sign_message' },
-    })
 
     const pendingBefore = await route.GET()
     const pendingBeforeJson = await pendingBefore.json()
@@ -84,43 +79,32 @@ test('GET and POST /api/approvals handle human-loop approvals only', () => {
   assert.equal(output.storedStatus, 'approved')
 })
 
-test('POST /api/approvals rejects invalid and non-human-loop approvals', () => {
+test('POST /api/approvals rejects invalid payloads', () => {
   const output = runWithTempDataDir(`
     const approvalsMod = await import('./src/lib/server/approvals')
     const routeMod = await import('./src/app/api/approvals/route')
     const approvals = approvalsMod.default || approvalsMod
     const route = routeMod.default || routeMod
 
-    const walletApproval = approvals.requestApproval({
-      category: 'wallet_action',
-      title: 'Legacy wallet approval',
-      data: { action: 'sign_message' },
+    const humanApproval = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Test approval',
+      data: { question: 'Proceed?' },
     })
 
     const invalidResponse = await route.POST(new Request('http://local/api/approvals', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ id: walletApproval.id }),
+      body: JSON.stringify({ id: humanApproval.id }),
     }))
     const invalidPayload = await invalidResponse.json()
 
-    const wrongCategory = await route.POST(new Request('http://local/api/approvals', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ id: walletApproval.id, approved: true }),
-    }))
-    const wrongCategoryPayload = await wrongCategory.json()
-
     console.log(JSON.stringify({
       invalidStatus: invalidResponse.status,
       invalidError: invalidPayload?.error || null,
-      wrongCategoryStatus: wrongCategory.status,
-      wrongCategoryError: wrongCategoryPayload?.error || null,
     }))
   `)
 
   assert.equal(output.invalidStatus, 400)
   assert.match(String(output.invalidError || ''), /id and approved required/i)
-  assert.equal(output.wrongCategoryStatus, 400)
-  assert.match(String(output.wrongCategoryError || ''), /human-loop/i)
 })

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

@@ -2,11 +2,22 @@ import { NextResponse } from 'next/server'
 import { listPendingApprovals, submitDecision } from '@/lib/server/approvals'
 import { loadApprovals } from '@/lib/server/storage'
 import { errorMessage } from '@/lib/shared-utils'
+import type { ApprovalCategory } from '@/types'
 
 export const dynamic = 'force-dynamic'
 
-export async function GET() {
-  return NextResponse.json(listPendingApprovals('human_loop'))
+const ALLOWED_CATEGORIES: ApprovalCategory[] = [
+  'human_loop', 'tool_access', 'extension_scaffold', 'extension_install',
+  'task_tool', 'connector_sender', 'agent_create', 'budget_change', 'delegation_enable',
+]
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const categoryParam = searchParams.get('category') as ApprovalCategory | null
+  const category = categoryParam && ALLOWED_CATEGORIES.includes(categoryParam)
+    ? categoryParam
+    : undefined
+  return NextResponse.json(listPendingApprovals(category))
 }
 
 export async function POST(req: Request) {
@@ -20,9 +31,6 @@ export async function POST(req: Request) {
     if (!approval) {
       return NextResponse.json({ error: 'approval not found' }, { status: 404 })
     }
-    if (approval.category !== 'human_loop') {
-      return NextResponse.json({ error: 'only human-loop approvals are supported here' }, { status: 400 })
-    }
     await submitDecision(id, approved)
     return NextResponse.json({ ok: true })
   } catch (err: unknown) {

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

@@ -6,10 +6,10 @@ import { z } from 'zod'
 import {
   autoStartConnectorIfNeeded,
   createConnector,
+  getConnectorWithRuntime,
   listConnectorsWithRuntime,
 } from '@/lib/server/connectors/connector-service'
 import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
-import { loadConnector } from '@/lib/server/connectors/connector-repository'
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
@@ -29,5 +29,5 @@ export async function POST(req: Request) {
   }
   const connector = createConnector(parsed.data as unknown as Record<string, unknown>)
   await autoStartConnectorIfNeeded(connector, parsed.data as unknown as Record<string, unknown>)
-  return NextResponse.json(loadConnector(connector.id) || connector)
+  return NextResponse.json(await getConnectorWithRuntime(connector.id) || connector)
 }

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

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { deleteCredentialRecord } from '@/lib/server/credentials/credential-service'
 import { notFound } from '@/lib/server/collection-helpers'
 import { log } from '@/lib/server/logger'
+import { logActivity } from '@/lib/server/activity/activity-log'
 
 const TAG = 'api-credentials'
 
@@ -11,5 +12,6 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
     return notFound()
   }
   log.info(TAG, `deleted ${credId}`)
+  logActivity({ entityType: 'credential', entityId: credId, action: 'deleted', actor: 'user', summary: `Credential deleted: ${credId}` })
   return new NextResponse('OK')
 }

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

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { createCredentialRecord, listCredentialSummaries } from '@/lib/server/credentials/credential-service'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { logActivity } from '@/lib/server/activity/activity-log'
 export const dynamic = 'force-dynamic'
 
 
@@ -16,7 +17,9 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'provider and apiKey are required' }, { status: 400 })
   }
   try {
-    return NextResponse.json(createCredentialRecord({ provider, name, apiKey }))
+    const result = createCredentialRecord({ provider, name, apiKey })
+    logActivity({ entityType: 'credential', entityId: result.id, action: 'created', actor: 'user', summary: `Credential created: "${name}" (${provider})` })
+    return NextResponse.json(result)
   } catch (err: unknown) {
     return NextResponse.json(
       { error: err instanceof Error ? err.message : 'Failed to create credential' },

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

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { getGoalById, updateGoal, deleteGoal, getGoalChain } from '@/lib/server/goals/goal-service'
+import { notFound } from '@/lib/server/collection-helpers'
+export const dynamic = 'force-dynamic'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const goal = getGoalById(id)
+  if (!goal) return notFound()
+  const chain = getGoalChain(id)
+  return NextResponse.json({ ...goal, chain })
+}
+
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const updated = updateGoal(id, body)
+  if (!updated) return notFound()
+  return NextResponse.json(updated)
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  if (!deleteGoal(id)) return notFound()
+  return new NextResponse('OK')
+}

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

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { getAllGoals, createGoal } from '@/lib/server/goals/goal-service'
+import { formatZodError } from '@/lib/validation/schemas'
+export const dynamic = 'force-dynamic'
+
+const GoalCreateSchema = z.object({
+  title: z.string().min(1, 'Goal title is required'),
+  description: z.string().optional().default(''),
+  level: z.enum(['organization', 'team', 'project', 'agent', 'task']),
+  parentGoalId: z.string().nullable().optional().default(null),
+  projectId: z.string().nullable().optional().default(null),
+  agentId: z.string().nullable().optional().default(null),
+  taskId: z.string().nullable().optional().default(null),
+  objective: z.string().min(1, 'Objective is required'),
+  constraints: z.array(z.string()).optional().default([]),
+  successMetric: z.string().nullable().optional().default(null),
+  budgetUsd: z.number().positive().nullable().optional().default(null),
+  deadlineAt: z.number().nullable().optional().default(null),
+})
+
+export async function GET() {
+  return NextResponse.json(getAllGoals())
+}
+
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const parsed = GoalCreateSchema.safeParse(body)
+  if (!parsed.success) return NextResponse.json(formatZodError(parsed.error), { status: 400 })
+  return NextResponse.json(createGoal(parsed.data))
+}

package/src/app/api/portability/export/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from 'next/server'
+import { exportConfig } from '@/lib/server/portability/export'
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const manifest = exportConfig()
+  return NextResponse.json(manifest)
+}

package/src/app/api/portability/import/route.test.ts

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-portability-import-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('POST /api/portability/import validates manifest arrays before importing', () => {
+  const output = runWithTempDataDir(`
+    const routeMod = await import('./src/app/api/portability/import/route')
+    const route = routeMod.default || routeMod
+
+    const invalidResponse = await route.POST(new Request('http://local/api/portability/import', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ formatVersion: 1, agents: [] }),
+    }))
+    const invalidPayload = await invalidResponse.json()
+
+    const validResponse = await route.POST(new Request('http://local/api/portability/import', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        formatVersion: 1,
+        exportedAt: '2026-03-29T00:00:00.000Z',
+        agents: [],
+        skills: [],
+        schedules: [],
+      }),
+    }))
+    const validPayload = await validResponse.json()
+
+    console.log(JSON.stringify({
+      invalidStatus: invalidResponse.status,
+      invalidError: invalidPayload?.error || null,
+      invalidPaths: Array.isArray(invalidPayload?.issues)
+        ? invalidPayload.issues.map((issue) => issue.path).sort()
+        : [],
+      validStatus: validResponse.status,
+      validAgentsCreated: validPayload?.agents?.created ?? null,
+      validSkillsCreated: validPayload?.skills?.created ?? null,
+      validSchedulesCreated: validPayload?.schedules?.created ?? null,
+    }))
+  `)
+
+  assert.equal(output.invalidStatus, 400)
+  assert.equal(output.invalidError, 'Validation failed')
+  assert.deepEqual(output.invalidPaths, ['schedules', 'skills'])
+  assert.equal(output.validStatus, 200)
+  assert.equal(output.validAgentsCreated, 0)
+  assert.equal(output.validSkillsCreated, 0)
+  assert.equal(output.validSchedulesCreated, 0)
+})

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

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { importConfig } from '@/lib/server/portability/import'
+import type { PortableManifest } from '@/lib/server/portability/export'
+import { PortableManifestSchema, formatZodError } from '@/lib/validation/schemas'
+import { z } from 'zod'
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request) {
+  const { data: raw, error } = await safeParseBody(req)
+  if (error) return error
+
+  const parsed = PortableManifestSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+
+  try {
+    const result = importConfig(parsed.data as PortableManifest)
+    return NextResponse.json(result)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to import manifest'
+    if (/^Unsupported format version /i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/src/app/api/protocols/templates/[id]/route.ts

@@ -1,7 +1,8 @@
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import { notFound } from '@/lib/server/collection-helpers'
-import { formatZodError, ProtocolTemplateUpsertSchema } from '@/lib/validation/schemas'
+import { formatZodError } from '@/lib/validation/schemas'
+import { ProtocolTemplateUpsertSchema } from '@/lib/validation/server-schemas'
 import {
   deleteProtocolTemplateById,
   loadProtocolTemplateById,

package/src/app/api/protocols/templates/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
-import { formatZodError, ProtocolTemplateUpsertSchema } from '@/lib/validation/schemas'
+import { formatZodError } from '@/lib/validation/schemas'
+import { ProtocolTemplateUpsertSchema } from '@/lib/validation/server-schemas'
 import {
   createProtocolTemplate,
   listProtocolTemplates,

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

@@ -6,6 +6,7 @@ import { loadPublicSettings, loadSettings, saveSettings } from '@/lib/server/sto
 import { normalizeRuntimeSettingFields } from '@/lib/runtime/runtime-loop'
 import { normalizeSupervisorSettings } from '@/lib/autonomy/supervisor-settings'
 import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
+import { logActivity } from '@/lib/server/activity/activity-log'
 export const dynamic = 'force-dynamic'
 
 
@@ -141,11 +142,9 @@ export async function PUT(req: Request) {
   settings.taskQualityGateRequireReport = parseBoolSetting(settings.taskQualityGateRequireReport, false)
   settings.taskManagementEnabled = parseBoolSetting(settings.taskManagementEnabled, true)
   settings.projectManagementEnabled = parseBoolSetting(settings.projectManagementEnabled, true)
-  settings.walletApprovalsEnabled = parseBoolSetting(settings.walletApprovalsEnabled, true)
   settings.integrityMonitorEnabled = parseBoolSetting(settings.integrityMonitorEnabled, true)
   settings.daemonAutostartEnabled = parseBoolSetting(settings.daemonAutostartEnabled, true)
   settings.autonomyResumeApprovalsEnabled = parseBoolSetting(settings.autonomyResumeApprovalsEnabled, false)
-  settings.missionHumanLoopEnabled = parseBoolSetting(settings.missionHumanLoopEnabled, false)
   settings.untrustedContentGuardMode = parseGuardMode(settings.untrustedContentGuardMode)
   settings.sessionResetMode = settings.sessionResetMode === 'daily' ? 'daily' : settings.sessionResetMode === 'idle' ? 'idle' : null
   settings.whatsappApprovedContacts = normalizeWhatsAppApprovedContacts(settings.whatsappApprovedContacts)
@@ -166,6 +165,18 @@ export async function PUT(req: Request) {
 
   saveSettings(settings)
 
+  const changedKeys = Object.keys(sanitizedBody).filter((k) => !SECRET_SETTING_KEYS.includes(k as typeof SECRET_SETTING_KEYS[number]))
+  if (changedKeys.length > 0) {
+    logActivity({
+      entityType: 'settings',
+      entityId: 'app',
+      action: 'configured',
+      actor: 'user',
+      summary: `Settings updated: ${changedKeys.join(', ')}`,
+      detail: { changedKeys },
+    })
+  }
+
   if ('daemonAutostartEnabled' in sanitizedBody && settings.daemonAutostartEnabled) {
     void ensureDaemonProcessRunning('api/settings:put:daemon-autostart', { manualStart: true }).catch(() => {
       // The daemon launcher may not be available during early bootstrap.