@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/bin/server-cmd.js

@@ -1,10 +1,16 @@
 #!/usr/bin/env node
 'use strict'
+/* eslint-disable @typescript-eslint/no-require-imports */
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { spawn, execSync } = require('node:child_process')
+const { spawn, execFileSync } = require('node:child_process')
 const os = require('node:os')
+const {
+  LOCKFILE_NAMES,
+  detectPackageManager,
+  getInstallCommand,
+} = require('./package-manager.js')
 
 // ---------------------------------------------------------------------------
 // Paths
@@ -26,7 +32,7 @@ const BUILD_COPY_ENTRIES = [
   'tsconfig.json',
   'postcss.config.mjs',
   'package.json',
-  'package-lock.json',
+  ...LOCKFILE_NAMES,
 ]
 
 // ---------------------------------------------------------------------------
@@ -73,13 +79,26 @@ function symlinkPath(src, dest) {
   fs.symlinkSync(src, dest)
 }
 
+function readBuiltInfo() {
+  if (!fs.existsSync(BUILT_MARKER)) return null
+  try {
+    const raw = JSON.parse(fs.readFileSync(BUILT_MARKER, 'utf8'))
+    return raw && typeof raw === 'object' ? raw : null
+  } catch {
+    return null
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Build
 // ---------------------------------------------------------------------------
 
 function needsBuild(forceBuild) {
   if (forceBuild) return true
-  if (!fs.existsSync(BUILT_MARKER)) return true
+  const info = readBuiltInfo()
+  if (!info) return true
+  if (info.version !== getVersion()) return true
+  if (!findStandaloneServer()) return true
   return false
 }
 
@@ -110,15 +129,18 @@ function runBuild() {
     symlinkPath(nmSrc, nmDest)
   } else {
     // If node_modules doesn't exist at PKG_ROOT, install
-    log('Installing dependencies...')
-    execSync('npm install', { cwd: SWARMCLAW_HOME, stdio: 'inherit' })
+    const packageManager = detectPackageManager(SWARMCLAW_HOME, process.env)
+    const install = getInstallCommand(packageManager)
+    log(`Installing dependencies with ${packageManager}...`)
+    execFileSync(install.command, install.args, { cwd: SWARMCLAW_HOME, stdio: 'inherit' })
   }
 
   // Run Next.js build
   log('Building Next.js application (this may take a minute)...')
   // Use webpack for production build reliability in packaged/fresh-install
   // environments (Turbopack has intermittently failed during prerender).
-  execSync('npx next build --webpack', {
+  const nextCli = path.join(SWARMCLAW_HOME, 'node_modules', 'next', 'dist', 'bin', 'next')
+  execFileSync(process.execPath, [nextCli, 'build', '--webpack'], {
     cwd: SWARMCLAW_HOME,
     stdio: 'inherit',
     env: {
@@ -373,4 +395,13 @@ function main() {
   startServer({ port, wsPort, host, detach })
 }
 
-main()
+if (require.main === module) {
+  main()
+}
+
+module.exports = {
+  getVersion,
+  main,
+  needsBuild,
+  readBuiltInfo,
+}

package/bin/swarmclaw.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict'
+/* eslint-disable @typescript-eslint/no-require-imports */
 
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
@@ -34,12 +35,45 @@ function shouldUseLegacyTsCli(argv) {
   return actions.has(action)
 }
 
+function supportsStripTypes() {
+  return process.allowedNodeEnvironmentFlags.has('--experimental-strip-types')
+}
+
+function hasTsxRuntime() {
+  try {
+    require.resolve('tsx/package.json')
+    return true
+  } catch {
+    return false
+  }
+}
+
+function buildLegacyTsCliArgs(cliPath, argv, options = {}) {
+  const stripTypesSupported = options.supportsStripTypes ?? supportsStripTypes()
+  if (stripTypesSupported) {
+    return ['--no-warnings', '--experimental-strip-types', cliPath, ...argv]
+  }
+
+  const tsxAvailable = options.hasTsxRuntime ?? hasTsxRuntime()
+  if (tsxAvailable) {
+    return ['--no-warnings', '--import', 'tsx', cliPath, ...argv]
+  }
+
+  return null
+}
+
 function runLegacyTsCli(argv) {
   const cliPath = path.join(__dirname, '..', 'src', 'cli', 'index.ts')
+  const args = buildLegacyTsCliArgs(cliPath, argv)
+  const env = normalizeLegacyCliEnv(process.env)
+  if (!args) {
+    process.stderr.write('Legacy CLI commands require Node 22.6+ or an available local tsx runtime.\n')
+    return 1
+  }
   const child = spawnSync(
     process.execPath,
-    ['--no-warnings', '--experimental-strip-types', cliPath, ...argv],
-    { stdio: 'inherit' },
+    args,
+    { stdio: 'inherit', env },
   )
 
   if (child.error) {
@@ -50,6 +84,18 @@ function runLegacyTsCli(argv) {
   return 1
 }
 
+function normalizeLegacyCliEnv(env) {
+  const nextEnv = { ...env }
+  if (!nextEnv.SWARMCLAW_URL && nextEnv.SWARMCLAW_BASE_URL) {
+    nextEnv.SWARMCLAW_URL = nextEnv.SWARMCLAW_BASE_URL
+  }
+  if (!nextEnv.SWARMCLAW_ACCESS_KEY) {
+    const key = nextEnv.SWARMCLAW_API_KEY || nextEnv.SC_ACCESS_KEY || ''
+    if (key) nextEnv.SWARMCLAW_ACCESS_KEY = key
+  }
+  return nextEnv
+}
+
 async function runMappedCli(argv) {
   const cliPath = path.join(__dirname, '..', 'src', 'cli', 'index.js')
   const cliModule = await import(cliPath)
@@ -66,11 +112,11 @@ async function main() {
 
   // Route 'server' and 'update' subcommands to CJS scripts (no TS dependency).
   if (top === 'server') {
-    require('./server-cmd.js')
+    require('./server-cmd.js').main()
     return
   }
   if (top === 'update') {
-    require('./update-cmd.js')
+    require('./update-cmd.js').main()
     return
   }
 
@@ -86,6 +132,10 @@ if (require.main === module) {
 }
 
 module.exports = {
+  buildLegacyTsCliArgs,
+  hasTsxRuntime,
   TS_CLI_ACTIONS,
+  normalizeLegacyCliEnv,
+  supportsStripTypes,
   shouldUseLegacyTsCli,
 }

package/bin/update-cmd.js

@@ -1,11 +1,20 @@
 #!/usr/bin/env node
 'use strict'
+/* eslint-disable @typescript-eslint/no-require-imports */
 
-const { execSync } = require('node:child_process')
+const { execSync, execFileSync } = require('node:child_process')
 const path = require('node:path')
+const {
+  dependenciesChanged,
+  detectPackageManager,
+  getGlobalUpdateSpec,
+  getInstallCommand,
+} = require('./package-manager.js')
 
 const PKG_ROOT = path.resolve(__dirname, '..')
+const PACKAGE_NAME = '@swarmclawai/swarmclaw'
 const RELEASE_TAG_RE = /^v\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/
+const PACKAGE_MANAGER = detectPackageManager(PKG_ROOT)
 
 function run(cmd) {
   return execSync(cmd, { encoding: 'utf-8', cwd: PKG_ROOT, timeout: 60_000 }).trim()
@@ -27,15 +36,37 @@ function getLatestStableTag() {
   return tags.find((t) => RELEASE_TAG_RE.test(t)) || null
 }
 
+function runRegistrySelfUpdate(
+  packageManager = PACKAGE_MANAGER,
+  execImpl = execFileSync,
+  logger = { log, logError },
+) {
+  const update = getGlobalUpdateSpec(packageManager, PACKAGE_NAME)
+  logger.log(`No git checkout detected. Updating the global ${PACKAGE_NAME} install via ${packageManager}...`)
+  try {
+    execImpl(update.command, update.args, {
+      cwd: PKG_ROOT,
+      stdio: 'inherit',
+      timeout: 120_000,
+    })
+    logger.log(`Global update complete via ${packageManager}.`)
+    logger.log('Restart the server to apply changes: swarmclaw server stop && swarmclaw server start')
+    return 0
+  } catch (err) {
+    logger.logError(`Registry update failed: ${err.message}`)
+    logger.logError(`Retry manually with: ${update.display}`)
+    return 1
+  }
+}
+
 function main() {
   const args = process.argv.slice(3)
   if (args.includes('-h') || args.includes('--help')) {
     console.log(`
 Usage: swarmclaw update
 
-Pull the latest SwarmClaw release via git.
-Prefers stable release tags (v*); falls back to origin/main.
-Runs npm install if package files changed.
+If running from a git checkout, pull the latest SwarmClaw release tag.
+If running from a registry install, update the global package with ${PACKAGE_MANAGER}.
 `.trim())
     process.exit(0)
   }
@@ -44,8 +75,7 @@ Runs npm install if package files changed.
   try {
     run('git rev-parse --git-dir')
   } catch {
-    logError('Not a git repository. Cannot update.')
-    process.exit(1)
+    process.exit(runRegistrySelfUpdate(PACKAGE_MANAGER))
   }
 
   const beforeRef = run('git rev-parse HEAD')
@@ -105,9 +135,10 @@ Runs npm install if package files changed.
   // Install deps if package files changed
   try {
     const diff = run(`git diff --name-only ${beforeSha}..HEAD`)
-    if (diff.includes('package-lock.json') || diff.includes('package.json')) {
-      log('Package files changed — running npm install...')
-      execSync('npm install --omit=dev', { cwd: PKG_ROOT, stdio: 'inherit', timeout: 120_000 })
+    if (dependenciesChanged(diff)) {
+      const install = getInstallCommand(PACKAGE_MANAGER, true)
+      log(`Package files changed — running ${PACKAGE_MANAGER} install...`)
+      execFileSync(install.command, install.args, { cwd: PKG_ROOT, stdio: 'inherit', timeout: 120_000 })
     }
   } catch {
     // If diff fails, skip install check
@@ -117,4 +148,11 @@ Runs npm install if package files changed.
   log('Restart the server to apply changes: swarmclaw server stop && swarmclaw server start')
 }
 
-main()
+if (require.main === module) {
+  main()
+}
+
+module.exports = {
+  main,
+  runRegistrySelfUpdate,
+}

package/bin/update-cmd.test.js

@@ -0,0 +1,55 @@
+'use strict'
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+
+const { runRegistrySelfUpdate } = require('./update-cmd.js')
+
+test('runRegistrySelfUpdate executes the manager-specific global update command', () => {
+  const messages = []
+  let captured = null
+
+  const exitCode = runRegistrySelfUpdate(
+    'pnpm',
+    (command, args, options) => {
+      captured = { command, args, options }
+    },
+    {
+      log: (message) => messages.push(`log:${message}`),
+      logError: (message) => messages.push(`err:${message}`),
+    },
+  )
+
+  assert.equal(exitCode, 0)
+  assert.deepEqual(captured, {
+    command: 'pnpm',
+    args: ['add', '-g', '@swarmclawai/swarmclaw@latest'],
+    options: {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      timeout: 120_000,
+    },
+  })
+  assert.match(messages.join('\n'), /updating the global @swarmclawai\/swarmclaw install via pnpm/i)
+  assert.match(messages.join('\n'), /global update complete via pnpm/i)
+})
+
+test('runRegistrySelfUpdate reports a manual retry command when the registry update fails', () => {
+  const messages = []
+
+  const exitCode = runRegistrySelfUpdate(
+    'bun',
+    () => {
+      throw new Error('spawn bun ENOENT')
+    },
+    {
+      log: (message) => messages.push(`log:${message}`),
+      logError: (message) => messages.push(`err:${message}`),
+    },
+  )
+
+  assert.equal(exitCode, 1)
+  assert.match(messages.join('\n'), /registry update failed: spawn bun ENOENT/i)
+  assert.match(messages.join('\n'), /retry manually with: bun add -g @swarmclawai\/swarmclaw@latest/i)
+})

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
   "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/swarmclawai/swarmclaw.git"
@@ -46,13 +50,14 @@
     "start": "next start",
     "start:standalone": "node .next/standalone/server.js",
     "benchmark:autonomy": "node ./scripts/benchmark-autonomy-harness.mjs",
+    "benchmark:agent-regression": "node --import tsx ./scripts/run-agent-regression-suite.ts",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "lint:baseline": "node ./scripts/lint-baseline.mjs check",
     "lint:baseline:update": "node ./scripts/lint-baseline.mjs update",
     "cli": "node ./bin/swarmclaw.js",
-    "test:cli": "node --test src/cli/index.test.js",
-    "test:openclaw": "tsx --test src/lib/server/connectors/openclaw.test.ts src/lib/openclaw-endpoint.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/server/task-validation.test.ts src/lib/server/task-quality-gate.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts",
+    "test:cli": "node --test src/cli/*.test.js bin/*.test.js",
+    "test:openclaw": "tsx --test src/lib/openclaw-agent-id.test.ts src/lib/openclaw-endpoint.test.ts src/lib/server/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw-agent-resolver.test.ts src/lib/server/openclaw-skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/task-quality-gate.test.ts src/lib/server/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",
     "postinstall": "node ./scripts/postinstall.mjs"
   },

package/scripts/postinstall.mjs

@@ -1,6 +1,32 @@
 #!/usr/bin/env node
 
+import { writeFileSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
+const INSTALL_METADATA_FILE = '.swarmclaw-install.json'
+
+function detectPackageManagerFromUserAgent(userAgent) {
+  const normalized = String(userAgent || '').toLowerCase()
+  if (normalized.startsWith('pnpm/')) return 'pnpm'
+  if (normalized.startsWith('yarn/')) return 'yarn'
+  if (normalized.startsWith('bun/')) return 'bun'
+  if (normalized.startsWith('npm/')) return 'npm'
+  return null
+}
+
+const installedWith = detectPackageManagerFromUserAgent(process.env.npm_config_user_agent) || 'npm'
+
+try {
+  writeFileSync(
+    new URL(`../${INSTALL_METADATA_FILE}`, import.meta.url),
+    JSON.stringify({
+      packageManager: installedWith,
+      installedAt: new Date().toISOString(),
+    }, null, 2),
+    'utf8',
+  )
+} catch {
+  // Ignore metadata write failures for install resilience.
+}
 
 const result = spawnSync('npm', ['rebuild', 'better-sqlite3', '--silent'], {
   stdio: 'ignore',

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

@@ -11,17 +11,60 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const body = await req.json()
   const result = mutateItem(ops, id, (agent) => {
     Object.assign(agent, body, { updatedAt: Date.now() })
+    if (body.platformAssignScope === 'all' || body.platformAssignScope === 'self') {
+      agent.platformAssignScope = body.platformAssignScope
+      agent.isOrchestrator = body.platformAssignScope === 'all'
+    } else if (agent.platformAssignScope === 'all' || agent.platformAssignScope === 'self') {
+      agent.isOrchestrator = agent.platformAssignScope === 'all'
+    }
     if (body.apiEndpoint !== undefined) {
       agent.apiEndpoint = normalizeProviderEndpoint(
         body.provider || agent.provider,
         body.apiEndpoint,
       )
     }
+    if (body.routingTargets !== undefined && Array.isArray(body.routingTargets)) {
+      agent.routingTargets = body.routingTargets.map((target: Record<string, unknown>, index: number) => ({
+        id: typeof target.id === 'string' && target.id.trim() ? target.id.trim() : `route-${index + 1}`,
+        label: typeof target.label === 'string' ? target.label : undefined,
+        role: target.role,
+        provider: (typeof target.provider === 'string' && target.provider.trim() ? target.provider : agent.provider),
+        model: typeof target.model === 'string' ? target.model : '',
+        credentialId: target.credentialId ?? null,
+        fallbackCredentialIds: Array.isArray(target.fallbackCredentialIds) ? target.fallbackCredentialIds : [],
+        apiEndpoint: normalizeProviderEndpoint(
+          typeof target.provider === 'string' ? target.provider : agent.provider,
+          typeof target.apiEndpoint === 'string' ? target.apiEndpoint : null,
+        ),
+        gatewayProfileId: target.gatewayProfileId ?? null,
+        priority: typeof target.priority === 'number' ? target.priority : index + 1,
+      }))
+    }
+    delete (agent as Record<string, unknown>).isOrchestrator
+    agent.isOrchestrator = agent.platformAssignScope === 'all'
     delete (agent as Record<string, unknown>).id
     agent.id = id
     return agent
   })
   if (!result) return notFound()
+
+  if (result.threadSessionId) {
+    const sessions = loadSessions()
+    const shortcut = sessions[result.threadSessionId]
+    if (shortcut) {
+      let changed = false
+      if (shortcut.name !== result.name) {
+        shortcut.name = result.name
+        changed = true
+      }
+      if (shortcut.shortcutForAgentId !== id) {
+        shortcut.shortcutForAgentId = id
+        changed = true
+      }
+      if (changed) saveSessions(sessions)
+    }
+  }
+
   logActivity({ entityType: 'agent', entityId: id, action: 'updated', actor: 'user', summary: `Agent updated: "${result.name}"` })
   return NextResponse.json(result)
 }

package/src/app/api/agents/[id]/thread/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadAgents, saveAgents, loadSessions, saveSessions } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agent-runtime-config'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id: agentId } = await params
@@ -15,28 +16,57 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const user = body.user || 'default'
   const sessions = loadSessions()
 
-  // If agent already has a thread session that exists, return it
+  // If the agent already has a shortcut chat session, return it.
   if (agent.threadSessionId && sessions[agent.threadSessionId]) {
-    return NextResponse.json(sessions[agent.threadSessionId])
+    const existing = sessions[agent.threadSessionId] as Record<string, unknown>
+    let changed = false
+    if (existing.shortcutForAgentId !== agentId) {
+      existing.shortcutForAgentId = agentId
+      changed = true
+    }
+    if (existing.name !== agent.name) {
+      existing.name = agent.name
+      changed = true
+    }
+    if (changed) saveSessions(sessions)
+    return NextResponse.json(existing)
   }
 
-  // Check if an existing session is already linked to this agent as a thread
+  // Legacy fallback for older shortcut sessions that were named using the
+  // old agent-thread convention before the explicit link was persisted.
   const existing = Object.values(sessions).find(
-    (s: Record<string, unknown>) => s.name === `agent-thread:${agentId}` && s.user === user
+    (s: Record<string, unknown>) =>
+      (
+        s.shortcutForAgentId === agentId
+        || s.name === `agent-thread:${agentId}`
+      )
+      && s.user === user
   )
   if (existing) {
     agent.threadSessionId = (existing as Record<string, unknown>).id as string
     agent.updatedAt = Date.now()
     saveAgents(agents)
+    let changed = false
+    const existingRecord = existing as Record<string, unknown>
+    if (existingRecord.shortcutForAgentId !== agentId) {
+      existingRecord.shortcutForAgentId = agentId
+      changed = true
+    }
+    if (existingRecord.name !== agent.name) {
+      existingRecord.name = agent.name
+      changed = true
+    }
+    if (changed) saveSessions(sessions)
     return NextResponse.json(existing)
   }
 
-  // Create a new thread session
-  const sessionId = `agent-thread-${agentId}-${genId()}`
+  // Create a new shortcut chat session for this agent.
+  const sessionId = `agent-chat-${agentId}-${genId()}`
   const now = Date.now()
-  const session = {
+  const baseSession = {
     id: sessionId,
-    name: `agent-thread:${agentId}`,
+    name: agent.name,
+    shortcutForAgentId: agentId,
     cwd: WORKSPACE_DIR,
     user: user,
     provider: agent.provider,
@@ -55,6 +85,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     heartbeatEnabled: agent.heartbeatEnabled || false,
     heartbeatIntervalSec: agent.heartbeatIntervalSec || null,
   }
+  const session = applyResolvedRoute(baseSession, resolvePrimaryAgentRoute(agent))
 
   sessions[sessionId] = session as Record<string, unknown>
   saveSessions(sessions)

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

@@ -13,6 +13,9 @@ export async function GET(req: Request) {
   const agents = loadAgents()
   const sessions = loadSessions()
   const usage = loadUsage()
+  for (const agent of Object.values(agents)) {
+    agent.isOrchestrator = agent.platformAssignScope === 'all'
+  }
   // Enrich agents that have spend limits with current spend windows
   for (const agent of Object.values(agents)) {
     if (
@@ -48,26 +51,56 @@ export async function POST(req: Request) {
   const id = genId()
   const now = Date.now()
   const agents = loadAgents()
+  const platformAssignScope = body.platformAssignScope
   agents[id] = {
     id,
     name: body.name,
     description: body.description,
+    soul: body.soul || undefined,
     systemPrompt: body.systemPrompt,
     provider: body.provider,
     model: body.model,
     credentialId: body.credentialId,
+    fallbackCredentialIds: body.fallbackCredentialIds,
     apiEndpoint: normalizeProviderEndpoint(body.provider, body.apiEndpoint || null),
-    isOrchestrator: body.isOrchestrator,
+    gatewayProfileId: body.gatewayProfileId,
+    routingStrategy: body.routingStrategy,
+    routingTargets: body.routingTargets?.map((target) => ({
+      ...target,
+      apiEndpoint: normalizeProviderEndpoint(target.provider, target.apiEndpoint || null),
+    })),
+    isOrchestrator: platformAssignScope === 'all',
+    platformAssignScope,
     subAgentIds: body.subAgentIds,
     plugins: body.plugins?.length ? body.plugins : (body.tools || []),
+    skills: body.skills,
+    skillIds: body.skillIds,
+    mcpServerIds: body.mcpServerIds,
+    mcpDisabledTools: body.mcpDisabledTools?.length ? body.mcpDisabledTools : undefined,
     capabilities: body.capabilities,
     thinkingLevel: body.thinkingLevel || undefined,
     autoRecovery: body.autoRecovery || false,
+    heartbeatEnabled: body.heartbeatEnabled || false,
+    heartbeatInterval: body.heartbeatInterval,
+    heartbeatIntervalSec: body.heartbeatIntervalSec,
+    heartbeatModel: body.heartbeatModel,
+    heartbeatPrompt: body.heartbeatPrompt,
+    elevenLabsVoiceId: body.elevenLabsVoiceId,
     monthlyBudget: body.monthlyBudget ?? null,
     dailyBudget: body.dailyBudget ?? null,
     hourlyBudget: body.hourlyBudget ?? null,
     budgetAction: body.budgetAction || 'warn',
-    soul: body.soul || undefined,
+    identityState: body.identityState ?? null,
+    memoryScopeMode: body.memoryScopeMode,
+    memoryTierPreference: body.memoryTierPreference,
+    projectId: body.projectId,
+    avatarSeed: body.avatarSeed,
+    avatarUrl: body.avatarUrl,
+    sessionResetMode: body.sessionResetMode ?? null,
+    sessionIdleTimeoutSec: body.sessionIdleTimeoutSec ?? null,
+    sessionMaxAgeSec: body.sessionMaxAgeSec ?? null,
+    sessionDailyResetAt: body.sessionDailyResetAt ?? null,
+    sessionResetTimezone: body.sessionResetTimezone ?? null,
     createdAt: now,
     updatedAt: now,
   }