@brainjar/cli 0.4.0 → 0.5.0

package/src/commands/soul.ts

@@ -39,6 +39,15 @@ export const soul = Cli.create('soul', {
         lines.push(c.options.description)
         lines.push('')
       }
+      lines.push('## Voice')
+      lines.push('- ')
+      lines.push('')
+      lines.push('## Character')
+      lines.push('- ')
+      lines.push('')
+      lines.push('## Standards')
+      lines.push('- ')
+      lines.push('')
 
       const content = lines.join('\n')
       await api.put<ApiSoul>(`/api/v1/souls/${name}`, { content })
@@ -55,6 +64,47 @@ export const soul = Cli.create('soul', {
       }
     },
   })
+  .command('update', {
+    description: 'Update a soul\'s content (reads from stdin)',
+    args: z.object({
+      name: z.string().describe('Soul name'),
+    }),
+    async run(c) {
+      const name = normalizeSlug(c.args.name, 'soul name')
+      const api = await getApi()
+
+      // Validate it exists
+      try {
+        await api.get<ApiSoul>(`/api/v1/souls/${name}`)
+      } catch (e) {
+        if (e instanceof IncurError && e.code === ErrorCode.NOT_FOUND) {
+          throw createError(ErrorCode.SOUL_NOT_FOUND, { params: [name] })
+        }
+        throw e
+      }
+
+      const chunks: Uint8Array[] = []
+      for await (const chunk of Bun.stdin.stream()) {
+        chunks.push(chunk)
+      }
+      const content = Buffer.concat(chunks).toString().trim()
+
+      if (!content) {
+        throw createError(ErrorCode.MISSING_ARG, {
+          message: 'No content provided. Pipe content via stdin.',
+          hint: `echo "# ${name}\\n..." | brainjar soul update ${name}`,
+        })
+      }
+
+      await api.put<ApiSoul>(`/api/v1/souls/${name}`, { content })
+
+      // Sync if this soul is active
+      const state = await getEffectiveState(api)
+      if (state.soul === name) await sync({ api })
+
+      return { updated: name }
+    },
+  })
   .command('list', {
     description: 'List available souls',
     async run() {

package/src/commands/upgrade.ts

@@ -0,0 +1,35 @@
+import { Cli, z } from 'incur'
+import { upgradeCli, upgradeServerBinary } from '../upgrade.js'
+import type { UpgradeResult } from '../upgrade.js'
+import { ErrorCode, createError } from '../errors.js'
+
+export const upgrade = Cli.create('upgrade', {
+  description: 'Upgrade brainjar CLI and server to latest versions',
+  options: z.object({
+    'cli-only': z.boolean().default(false).describe('Only upgrade the CLI'),
+    'server-only': z.boolean().default(false).describe('Only upgrade the server'),
+  }),
+  async run(c) {
+    const cliOnly = c.options['cli-only']
+    const serverOnly = c.options['server-only']
+
+    if (cliOnly && serverOnly) {
+      throw createError(ErrorCode.MUTUALLY_EXCLUSIVE, {
+        message: '--cli-only and --server-only are mutually exclusive.',
+      })
+    }
+
+    const result: UpgradeResult = {}
+
+    if (!serverOnly) {
+      result.cli = await upgradeCli()
+    }
+
+    // Server upgrade always targets the local binary, regardless of active context
+    if (!cliOnly) {
+      result.server = await upgradeServerBinary()
+    }
+
+    return result
+  },
+})

package/src/config.ts

@@ -4,31 +4,67 @@ import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
 import { getBrainjarDir, paths } from './paths.js'
 import type { Backend } from './paths.js'
 
-export interface ServerConfig {
+// ─── Context types ──────────────────────────────────────────────────────────
+
+export interface LocalContext {
   url: string
-  mode: 'local' | 'remote'
+  mode: 'local'
   bin: string
   pid_file: string
   log_file: string
+  workspace: string
 }
 
-export interface Config {
-  server: ServerConfig
+export interface RemoteContext {
+  url: string
+  mode: 'remote'
   workspace: string
+}
+
+export type ServerContext = LocalContext | RemoteContext
+
+export function isLocalContext(ctx: ServerContext): ctx is LocalContext {
+  return ctx.mode === 'local'
+}
+
+// ─── Config types ───────────────────────────────────────────────────────────
+
+export interface Config {
+  version: 2
+  current_context: string
+  contexts: Record<string, ServerContext>
   backend: Backend
 }
 
-function defaults(): Config {
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/** Get the active context from config. */
+export function activeContext(config: Config): ServerContext {
+  return config.contexts[config.current_context]
+}
+
+/** Get the local context from config. Always present. */
+export function localContext(config: Config): LocalContext {
+  return config.contexts.local as LocalContext
+}
+
+function defaultLocalContext(): LocalContext {
   const dir = getBrainjarDir()
   return {
-    server: {
-      url: 'http://localhost:7742',
-      mode: 'local',
-      bin: `${dir}/bin/brainjar-server`,
-      pid_file: `${dir}/server.pid`,
-      log_file: `${dir}/server.log`,
-    },
+    url: 'http://localhost:7742',
+    mode: 'local',
+    bin: `${dir}/bin/brainjar-server`,
+    pid_file: `${dir}/server.pid`,
+    log_file: `${dir}/server.log`,
     workspace: 'default',
+  }
+}
+
+function defaults(): Config {
+  return {
+    version: 2,
+    current_context: 'local',
+    contexts: { local: defaultLocalContext() },
     backend: 'claude',
   }
 }
@@ -41,15 +77,80 @@ function isValidBackend(v: unknown): v is Backend {
   return v === 'claude' || v === 'codex'
 }
 
+/** Derive a context name from a URL hostname. */
+export function contextNameFromUrl(url: string): string {
+  try {
+    const hostname = new URL(url).hostname
+    return hostname.replace(/\./g, '-')
+  } catch {
+    return 'remote'
+  }
+}
+
+/** Find a unique context name, appending -2, -3, etc. if needed. */
+export function uniqueContextName(base: string, existing: Record<string, unknown>): string {
+  if (!(base in existing)) return base
+  let i = 2
+  while (`${base}-${i}` in existing) i++
+  return `${base}-${i}`
+}
+
+// ─── Migration: v1 → v2 ────────────────────────────────────────────────────
+
+interface V1Config {
+  server: {
+    url: string
+    mode: 'local' | 'remote'
+    bin: string
+    pid_file: string
+    log_file: string
+  }
+  workspace: string
+  backend: Backend
+}
+
+function migrateV1(v1: V1Config): Config {
+  const dir = getBrainjarDir()
+  const localCtx: LocalContext = {
+    url: 'http://localhost:7742',
+    mode: 'local',
+    bin: v1.server.bin || `${dir}/bin/brainjar-server`,
+    pid_file: v1.server.pid_file || `${dir}/server.pid`,
+    log_file: v1.server.log_file || `${dir}/server.log`,
+    workspace: v1.workspace || 'default',
+  }
+
+  const config: Config = {
+    version: 2,
+    current_context: 'local',
+    contexts: { local: localCtx },
+    backend: v1.backend || 'claude',
+  }
+
+  if (v1.server.mode === 'remote') {
+    const name = contextNameFromUrl(v1.server.url)
+    const uniqueName = uniqueContextName(name, config.contexts)
+    config.contexts[uniqueName] = {
+      url: v1.server.url,
+      mode: 'remote',
+      workspace: v1.workspace || 'default',
+    }
+    config.current_context = uniqueName
+  }
+
+  return config
+}
+
+// ─── Read / Write ───────────────────────────────────────────────────────────
+
 /**
  * Read config from ~/.brainjar/config.yaml.
  * Returns defaults if file doesn't exist.
+ * Migrates v1 configs to v2 on read.
  * Applies env var overrides on top.
- * Throws if file exists but is corrupt YAML.
  */
 export async function readConfig(): Promise<Config> {
-  const def = defaults()
-  let config = { ...def, server: { ...def.server } }
+  let config: Config
 
   try {
     const raw = await readFile(paths.config, 'utf-8')
@@ -63,32 +164,107 @@ export async function readConfig(): Promise<Config> {
     if (parsed && typeof parsed === 'object') {
       const p = parsed as Record<string, unknown>
 
-      if (typeof p.workspace === 'string') config.workspace = p.workspace
-      if (isValidBackend(p.backend)) config.backend = p.backend
-
-      if (p.server && typeof p.server === 'object') {
-        const s = p.server as Record<string, unknown>
-        if (typeof s.url === 'string') config.server.url = s.url
-        if (isValidMode(s.mode)) config.server.mode = s.mode
-        if (typeof s.bin === 'string') config.server.bin = s.bin
-        if (typeof s.pid_file === 'string') config.server.pid_file = s.pid_file
-        if (typeof s.log_file === 'string') config.server.log_file = s.log_file
+      if (p.version === 2) {
+        // v2 config
+        config = parseV2(p)
+      } else {
+        // v1 config (no version field)
+        config = parseV1(p)
       }
+    } else {
+      config = defaults()
     }
   } catch (e) {
-    if ((e as NodeJS.ErrnoException).code === 'ENOENT') return applyEnvOverrides(config)
+    if ((e as NodeJS.ErrnoException).code === 'ENOENT') return applyEnvOverrides(defaults())
     throw e
   }
 
   return applyEnvOverrides(config)
 }
 
+function parseV2(p: Record<string, unknown>): Config {
+  const def = defaults()
+  const defLocal = localContext(def)
+  const config: Config = {
+    version: 2,
+    current_context: typeof p.current_context === 'string' ? p.current_context : 'local',
+    contexts: {},
+    backend: isValidBackend(p.backend) ? p.backend : def.backend,
+  }
+
+  if (p.contexts && typeof p.contexts === 'object') {
+    for (const [name, raw] of Object.entries(p.contexts as Record<string, unknown>)) {
+      if (!raw || typeof raw !== 'object') continue
+      const ctx = raw as Record<string, unknown>
+      if (ctx.mode === 'local') {
+        config.contexts[name] = {
+          url: typeof ctx.url === 'string' ? ctx.url : 'http://localhost:7742',
+          mode: 'local',
+          bin: typeof ctx.bin === 'string' ? ctx.bin : defLocal.bin,
+          pid_file: typeof ctx.pid_file === 'string' ? ctx.pid_file : defLocal.pid_file,
+          log_file: typeof ctx.log_file === 'string' ? ctx.log_file : defLocal.log_file,
+          workspace: typeof ctx.workspace === 'string' ? ctx.workspace : 'default',
+        }
+      } else {
+        config.contexts[name] = {
+          url: typeof ctx.url === 'string' ? ctx.url : '',
+          mode: 'remote',
+          workspace: typeof ctx.workspace === 'string' ? ctx.workspace : 'default',
+        }
+      }
+    }
+  }
+
+  // Ensure local context always exists
+  if (!config.contexts.local) {
+    config.contexts.local = defaultLocalContext()
+  }
+
+  // Ensure current_context points to an existing context
+  if (!(config.current_context in config.contexts)) {
+    config.current_context = 'local'
+  }
+
+  return config
+}
+
+function parseV1(p: Record<string, unknown>): Config {
+  const dir = getBrainjarDir()
+  const v1: V1Config = {
+    server: {
+      url: 'http://localhost:7742',
+      mode: 'local',
+      bin: `${dir}/bin/brainjar-server`,
+      pid_file: `${dir}/server.pid`,
+      log_file: `${dir}/server.log`,
+    },
+    workspace: 'default',
+    backend: 'claude',
+  }
+
+  if (typeof p.workspace === 'string') v1.workspace = p.workspace
+  if (isValidBackend(p.backend)) v1.backend = p.backend
+
+  if (p.server && typeof p.server === 'object') {
+    const s = p.server as Record<string, unknown>
+    if (typeof s.url === 'string') v1.server.url = s.url
+    if (isValidMode(s.mode)) v1.server.mode = s.mode
+    if (typeof s.bin === 'string') v1.server.bin = s.bin
+    if (typeof s.pid_file === 'string') v1.server.pid_file = s.pid_file
+    if (typeof s.log_file === 'string') v1.server.log_file = s.log_file
+  }
+
+  return migrateV1(v1)
+}
+
 function applyEnvOverrides(config: Config): Config {
+  const ctx = activeContext(config)
+
   const url = process.env.BRAINJAR_SERVER_URL
-  if (typeof url === 'string' && url) config.server.url = url
+  if (typeof url === 'string' && url) ctx.url = url
 
   const workspace = process.env.BRAINJAR_WORKSPACE
-  if (typeof workspace === 'string' && workspace) config.workspace = workspace
+  if (typeof workspace === 'string' && workspace) ctx.workspace = workspace
 
   const backend = process.env.BRAINJAR_BACKEND
   if (isValidBackend(backend)) config.backend = backend
@@ -98,21 +274,36 @@ function applyEnvOverrides(config: Config): Config {
 
 /**
  * Write config to ~/.brainjar/config.yaml.
- * Atomic write (tmp + rename).
+ * Always writes v2 format. Atomic write (tmp + rename).
  */
 export async function writeConfig(config: Config): Promise<void> {
-  const doc = {
-    server: {
-      url: config.server.url,
-      mode: config.server.mode,
-      bin: config.server.bin,
-      pid_file: config.server.pid_file,
-      log_file: config.server.log_file,
-    },
-    workspace: config.workspace,
+  const doc: Record<string, unknown> = {
+    version: 2,
+    current_context: config.current_context,
+    contexts: {} as Record<string, unknown>,
     backend: config.backend,
   }
 
+  const contexts = doc.contexts as Record<string, unknown>
+  for (const [name, ctx] of Object.entries(config.contexts)) {
+    if (isLocalContext(ctx)) {
+      contexts[name] = {
+        url: ctx.url,
+        mode: ctx.mode,
+        bin: ctx.bin,
+        pid_file: ctx.pid_file,
+        log_file: ctx.log_file,
+        workspace: ctx.workspace,
+      }
+    } else {
+      contexts[name] = {
+        url: ctx.url,
+        mode: ctx.mode,
+        workspace: ctx.workspace,
+      }
+    }
+  }
+
   await mkdir(dirname(paths.config), { recursive: true })
   const tmp = `${paths.config}.tmp`
   await writeFile(tmp, stringifyYaml(doc))

package/src/daemon.ts

@@ -4,17 +4,39 @@ import { readFile, writeFile, rm, access, open, chmod, mkdir } from 'node:fs/pro
 import { dirname, join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { Errors } from 'incur'
-import { readConfig } from './config.js'
+import { readConfig, activeContext, localContext } from './config.js'
 import { ErrorCode, createError } from './errors.js'
 
 export const DIST_BASE = 'https://get.brainjar.sh/brainjar-server'
 
+/**
+ * Compare two semver strings. Returns -1, 0, or 1.
+ * Strips leading 'v' prefix. Only compares major.minor.patch.
+ */
+export function compareSemver(a: string, b: string): number {
+  const parse = (v: string) => v.replace(/^v/, '').split('.').map(Number)
+  const pa = parse(a)
+  const pb = parse(b)
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0)
+    if (diff !== 0) return diff > 0 ? 1 : -1
+  }
+  return 0
+}
+
 const { IncurError } = Errors
 
+/**
+ * Minimum server version this CLI is compatible with.
+ * Bump when the CLI depends on server features/API changes.
+ */
+export const MIN_SERVER_VERSION = '0.2.1'
+
 export interface HealthStatus {
   healthy: boolean
   url: string
   latencyMs?: number
+  serverVersion?: string
   error?: string
 }
 
@@ -26,13 +48,27 @@ export interface DaemonStatus {
   healthy: boolean
 }
 
+/**
+ * Assert the server version is compatible with this CLI.
+ * No-op if the server doesn't report a version (old servers).
+ */
+function assertCompatible(serverVersion: string | undefined): void {
+  if (!serverVersion) return
+  if (compareSemver(serverVersion, MIN_SERVER_VERSION) < 0) {
+    throw createError(ErrorCode.SERVER_INCOMPATIBLE, {
+      message: `Server ${serverVersion} is incompatible with this CLI (requires >= ${MIN_SERVER_VERSION}).`,
+    })
+  }
+}
+
 /**
  * Check if the server is healthy.
  * Returns health status without throwing.
  */
 export async function healthCheck(options?: { timeout?: number; url?: string }): Promise<HealthStatus> {
   const config = await readConfig()
-  const url = options?.url ?? config.server.url
+  const ctx = activeContext(config)
+  const url = options?.url ?? ctx.url
   const timeout = options?.timeout ?? 2000
   const start = Date.now()
 
@@ -44,9 +80,9 @@ export async function healthCheck(options?: { timeout?: number; url?: string }):
 
     if (response.status === 200) {
       try {
-        const body = await response.json() as { status?: string }
+        const body = await response.json() as { status?: string; version?: string }
         if (body.status === 'ok') {
-          return { healthy: true, url, latencyMs }
+          return { healthy: true, url, latencyMs, serverVersion: body.version }
         }
       } catch {}
       return { healthy: true, url, latencyMs }
@@ -200,7 +236,8 @@ export async function downloadAndVerify(binPath: string, versionBase: string): P
  */
 export async function ensureBinary(): Promise<void> {
   const config = await readConfig()
-  const binPath = config.server.bin
+  const local = localContext(config)
+  const binPath = local.bin
 
   try {
     await access(binPath)
@@ -221,7 +258,8 @@ export async function ensureBinary(): Promise<void> {
 export async function upgradeServer(): Promise<{ version: string; alreadyLatest: boolean }> {
   const { getInstalledServerVersion, setInstalledServerVersion } = await import('./version-check.js')
   const config = await readConfig()
-  const binPath = config.server.bin
+  const local = localContext(config)
+  const binPath = local.bin
 
   const version = await fetchLatestVersion()
   const installed = await getInstalledServerVersion()
@@ -242,7 +280,8 @@ export async function upgradeServer(): Promise<{ version: string; alreadyLatest:
  */
 export async function start(): Promise<{ pid: number }> {
   const config = await readConfig()
-  const { bin, pid_file, log_file, url } = config.server
+  const local = localContext(config)
+  const { bin, pid_file, log_file, url } = local
 
   try {
     await access(bin)
@@ -290,7 +329,7 @@ export async function start(): Promise<{ pid: number }> {
  */
 export async function stop(): Promise<{ stopped: boolean }> {
   const config = await readConfig()
-  const { pid_file } = config.server
+  const { pid_file } = localContext(config)
 
   const pid = await readPid(pid_file)
   if (pid === null) return { stopped: false }
@@ -324,15 +363,16 @@ export async function stop(): Promise<{ stopped: boolean }> {
  */
 export async function status(): Promise<DaemonStatus> {
   const config = await readConfig()
-  const { mode, url, pid_file } = config.server
+  const ctx = activeContext(config)
+  const local = localContext(config)
 
-  const pid = await readPid(pid_file)
+  const pid = await readPid(local.pid_file)
   const running = pid !== null && isAlive(pid)
-  const health = await healthCheck({ timeout: 2000, url })
+  const health = await healthCheck({ timeout: 2000, url: ctx.url })
 
   return {
-    mode,
-    url,
+    mode: ctx.mode,
+    url: ctx.url,
     running,
     pid: running ? pid : null,
     healthy: health.healthy,
@@ -346,7 +386,7 @@ export async function readLogFile(options?: { lines?: number }): Promise<string>
   const config = await readConfig()
   const lines = options?.lines ?? 50
   try {
-    const content = await readFile(config.server.log_file, 'utf-8')
+    const content = await readFile(localContext(config).log_file, 'utf-8')
     const allLines = content.trimEnd().split('\n')
     return allLines.slice(-lines).join('\n')
   } catch (e) {
@@ -363,21 +403,25 @@ export async function readLogFile(options?: { lines?: number }): Promise<string>
  */
 export async function ensureRunning(): Promise<void> {
   const config = await readConfig()
-  const { mode, url } = config.server
+  const ctx = activeContext(config)
+  const local = localContext(config)
 
   // Check health first — fast path
-  const health = await healthCheck({ timeout: 2000, url })
-  if (health.healthy) return
+  const health = await healthCheck({ timeout: 2000, url: ctx.url })
+  if (health.healthy) {
+    assertCompatible(health.serverVersion)
+    return
+  }
 
-  if (mode === 'remote') {
+  if (ctx.mode === 'remote') {
     throw createError(ErrorCode.SERVER_UNREACHABLE, {
-      params: [url],
-      hint: `Check the URL or run 'brainjar server remote <url>'.`,
+      params: [ctx.url],
+      hint: `Check the URL or run 'brainjar context add <name> <url>'.`,
     })
   }
 
   // Local mode: auto-start
-  await cleanStalePid(config.server.pid_file)
+  await cleanStalePid(local.pid_file)
 
   try {
     await start()
@@ -385,7 +429,7 @@ export async function ensureRunning(): Promise<void> {
     if (e instanceof IncurError) throw e
     throw createError(ErrorCode.SERVER_START_FAILED, {
       message: 'Failed to start brainjar server.',
-      hint: `Check ${config.server.log_file}`,
+      hint: `Check ${local.log_file}`,
     })
   }
 
@@ -393,12 +437,15 @@ export async function ensureRunning(): Promise<void> {
   const deadline = Date.now() + 10_000
   while (Date.now() < deadline) {
     await new Promise(r => setTimeout(r, 200))
-    const check = await healthCheck({ timeout: 2000, url })
-    if (check.healthy) return
+    const check = await healthCheck({ timeout: 2000, url: ctx.url })
+    if (check.healthy) {
+      assertCompatible(check.serverVersion)
+      return
+    }
   }
 
   throw createError(ErrorCode.SERVER_START_FAILED, {
     message: 'Server started but failed health check after 10s.',
-    hint: `Check ${config.server.log_file}`,
+    hint: `Check ${local.log_file}`,
   })
 }

package/src/errors.ts

@@ -53,12 +53,19 @@ export const ErrorCode = {
   SERVER_UNREACHABLE: 'SERVER_UNREACHABLE',
   BINARY_NOT_FOUND: 'BINARY_NOT_FOUND',
   SERVER_START_FAILED: 'SERVER_START_FAILED',
+  SERVER_INCOMPATIBLE: 'SERVER_INCOMPATIBLE',
 
   // Validation
   MUTUALLY_EXCLUSIVE: 'MUTUALLY_EXCLUSIVE',
   MISSING_ARG: 'MISSING_ARG',
   NO_OVERRIDES: 'NO_OVERRIDES',
 
+  // Contexts
+  CONTEXT_NOT_FOUND: 'CONTEXT_NOT_FOUND',
+  CONTEXT_PROTECTED: 'CONTEXT_PROTECTED',
+  CONTEXT_EXISTS: 'CONTEXT_EXISTS',
+  CONTEXT_ACTIVE: 'CONTEXT_ACTIVE',
+
   // Other
   INVALID_MODE: 'INVALID_MODE',
   SHELL_ERROR: 'SHELL_ERROR',
@@ -99,6 +106,12 @@ export const Messages: Partial<Record<ErrorCode, string | ((...args: string[]) =
   PACK_NOT_DIR: (path: string) => `Pack path "${path}" is a file, not a directory. Packs are directories.`,
   PACK_NOT_FOUND: (path: string) => `Pack path "${path}" does not exist.`,
 
+  // Contexts
+  CONTEXT_NOT_FOUND: (name: string) => `Context "${name}" not found.`,
+  CONTEXT_EXISTS: (name: string) => `Context "${name}" already exists.`,
+  CONTEXT_PROTECTED: (name: string) => `Context "${name}" is protected and cannot be removed or renamed.`,
+  CONTEXT_ACTIVE: (name: string) => `Context "${name}" is the active context. Switch first.`,
+
   // Infra
   SERVER_UNREACHABLE: (url: string) => `Cannot reach server at ${url}`,
 }
@@ -132,10 +145,17 @@ export const Hints: Partial<Record<ErrorCode, string | ((...args: string[]) => s
   PACK_DIR_EXISTS: 'Remove the directory first, or use --out to write elsewhere.',
   PACK_NO_MANIFEST: 'A valid pack needs a pack.yaml at its root.',
 
+  // Contexts
+  CONTEXT_NOT_FOUND: 'List available contexts: `brainjar context list`',
+  CONTEXT_EXISTS: 'Pick a different name.',
+  CONTEXT_PROTECTED: 'The local context is always present and cannot be modified.',
+  CONTEXT_ACTIVE: 'Switch to a different context first: `brainjar context use <name>`',
+
   // Infra
   BINARY_NOT_FOUND: 'Install the server: `brainjar init`',
   SERVER_UNREACHABLE: 'Start the server: `brainjar server start`, or set a remote: `brainjar server remote <url>`',
   SERVER_START_FAILED: 'Check server logs: `brainjar server logs`',
+  SERVER_INCOMPATIBLE: 'Run `brainjar upgrade` to update both CLI and server.',
   SERVER_UNAVAILABLE: 'Server is starting up. Retry in a moment, or check: `brainjar server status`',
   UNAUTHORIZED: 'Verify server config: `brainjar server status`',
   SERVER_ERROR: 'Check server logs: `brainjar server logs`',