@office-xyz/claude-code 0.1.0 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to `@office-xyz/claude-code` will be documented in this file.
 
+## [0.1.2] - 2026-02-15
+
+### Changed
+- Integrate public repo sync into npm publish workflow
+- Fall back to Cloudflare URL for SSE/WebSocket connections
+
+## [0.1.1] - 2026-02-15
+
+### Fixed
+- Fix crash when running `npx @office-xyz/claude-code` without `--agent` flag (`argv.agent` undefined → `.split()` TypeError)
+- `label` variable now defaults to `'local-host'` in interactive onboarding mode and updates after onboarding completes
+
 ## [0.1.0] - 2026-02-15
 
 ### Added

package/index.js

@@ -23,6 +23,28 @@ import { execSync } from 'child_process'
 import path from 'path'
 import os from 'os'
 import { fileURLToPath } from 'url'
+// Inline tool name normalizer (can't import from parent CJS package — ESM/CJS conflict)
+// Maps raw CLI tool names to standard frontend TOOL_CONFIG keys
+const TOOL_NAME_MAP = {
+  // Codex CLI
+  command_execution: 'Bash', file_edit: 'FileEdit', file_read: 'FileRead',
+  file_change: 'FileEdit', file_write: 'FileWrite', web_search: 'WebSearch',
+  mcp_call: 'Mcp', mcp_tool_call: 'Mcp', unknown_tool: 'default',
+  // Gemini CLI
+  shell: 'Bash', edit: 'Edit', read: 'Read', write: 'Write',
+  search_files: 'Grep', list_files: 'LS', web_fetch: 'WebFetch', google_search: 'WebSearch',
+  // Kimi / DeepSeek / Qwen CLI
+  execute_command: 'Bash', read_file: 'Read', write_file: 'Write', edit_file: 'Edit',
+  search: 'Grep', run_command: 'Bash', code_edit: 'FileEdit', code_search: 'Grep',
+  terminal: 'Bash', file_operation: 'FileEdit',
+  // General aliases
+  bash: 'Bash', grep: 'Grep', glob: 'Glob', ls: 'LS',
+}
+function normalizeToolName(rawName) {
+  if (!rawName || typeof rawName !== 'string') return 'default'
+  const lower = rawName.toLowerCase()
+  return TOOL_NAME_MAP[lower] || TOOL_NAME_MAP[rawName] || rawName
+}
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -144,7 +166,7 @@ function shellEscapeArg(s) {
 
 // ── Logging ────────────────────────────────────────────────────────────────
 
-const label = argv.agent.split('.')[0] || argv.agent
+let label = argv.agent ? (argv.agent.split('.')[0] || argv.agent) : 'local-host'
 function log(...args) {
   console.log(chalk.dim(`[${new Date().toISOString()}][${label}]`), ...args)
 }
@@ -224,6 +246,8 @@ if (argv.agent) {
 let wsRef = null
 let reconnectAttempts = 0
 const MAX_RECONNECT_DELAY_MS = 30_000
+let registryHeartbeatTimer = null
+const REGISTRY_HEARTBEAT_INTERVAL_MS = 30_000  // Report liveness to Registry every 30s
 const workspace = path.resolve(argv.workspace)
 const model = argv.model || providerConfig.defaultModel
 
@@ -451,6 +475,11 @@ async function handleMessage(message) {
     args.push(text)
 
     log(chalk.blue(`Running: ${cmd} ${args.slice(0, 5).join(' ')}... [${args.length} args]`))
+    if (process.env.ANTHROPIC_API_KEY) {
+      log(chalk.dim(`  Auth: Claude login session (stripped inherited API key from env)`))
+    } else {
+      log(chalk.dim(`  Auth: Claude login session`))
+    }
 
     // 1. Send streaming.started
     sendJSON({
@@ -467,9 +496,16 @@ async function handleMessage(message) {
     // PATH by Node's child_process (works for npm global bins).
     let child
     try {
+      // Strip ANTHROPIC_API_KEY from child env so Claude Code CLI uses the
+      // user's local login session (claude login / Max subscription) instead
+      // of consuming API credits from a shared key that may have been loaded
+      // by load-aladdin-env.sh or other infra scripts in the same shell.
+      const childEnv = { ...process.env }
+      delete childEnv.ANTHROPIC_API_KEY
+
       child = spawn(cmd, args, {
         cwd: workspace,
-        env: { ...process.env },
+        env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
         shell: false,
       })
@@ -494,14 +530,16 @@ async function handleMessage(message) {
     const emitToolStart = ({ toolUseId, toolName, input, timestamp }) => {
       const normalizedId = toolUseId || `tool-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
       const startedAt = Number.isFinite(timestamp) ? timestamp : Date.now()
-      activeToolsById.set(normalizedId, { toolName: toolName || 'tool', input, startedAt })
+      // Normalize tool names for consistent frontend display across all CLI providers
+      const normalized = normalizeToolName(toolName || 'tool')
+      activeToolsById.set(normalizedId, { toolName: normalized, input, startedAt })
       sendJSON({
         type: 'tool_event',
         sessionId,
         commandId,
         event: {
           eventType: 'tool_start',
-          toolName: toolName || 'tool',
+          toolName: normalized,
           toolUseId: normalizedId,
           input,
           status: 'running',
@@ -515,7 +553,8 @@ async function handleMessage(message) {
       if (finalizedToolIds.has(toolUseId) && !force) return
       finalizedToolIds.add(toolUseId)
       const endedAt = Number.isFinite(timestamp) ? timestamp : Date.now()
-      const resolvedTool = toolName || activeToolsById.get(toolUseId)?.toolName || 'tool'
+      const rawTool = toolName || activeToolsById.get(toolUseId)?.toolName || 'tool'
+      const resolvedTool = normalizeToolName(rawTool)
       const resolvedInput = input ?? activeToolsById.get(toolUseId)?.input
       const status = error ? 'error' : 'completed'
       const compactResult = compactToolValue(result)
@@ -570,6 +609,29 @@ async function handleMessage(message) {
           return
         }
 
+        // Input JSON deltas — accumulate tool input as it streams in
+        // Claude CLI sends tool input progressively: content_block_start has input: {},
+        // then input_json_delta events carry the actual JSON. Without accumulating these,
+        // tool indicators show "(no command)" because input is empty.
+        if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'input_json_delta') {
+          const partialJson = streamEvent.delta.partial_json || ''
+          if (blockIndex !== null) {
+            const toolState = activeToolsByIndex.get(blockIndex)
+            if (toolState) {
+              // Accumulate raw JSON string — we'll parse the complete object later
+              if (!toolState._inputJsonBuffer) toolState._inputJsonBuffer = ''
+              toolState._inputJsonBuffer += partialJson
+              // Try to parse accumulated JSON to update input (best-effort)
+              try {
+                toolState.input = JSON.parse(toolState._inputJsonBuffer)
+              } catch {
+                // Not complete JSON yet — that's fine, keep accumulating
+              }
+            }
+          }
+          return
+        }
+
         // Thinking deltas
         if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'thinking_delta') {
           const deltaText = streamEvent.delta.thinking || streamEvent.delta.text || ''
@@ -695,12 +757,35 @@ async function handleMessage(message) {
 
         // Message event with assistant content
         if (event.type === 'message' && event.message?.role === 'assistant') {
-          // Extract text from content blocks
           const content = event.message.content || []
           for (const block of content) {
+            // Extract text blocks
             if (block.type === 'text' && block.text) {
               if (!fullText) fullText = block.text
             }
+            // Extract complete tool_use input — the assistant message contains the
+            // fully accumulated input (unlike content_block_start which has {}).
+            // This allows us to retroactively update tool events with real input data.
+            if (block.type === 'tool_use' && block.id && block.input) {
+              const existing = activeToolsById.get(block.id)
+              if (existing && (!existing.input || Object.keys(existing.input).length === 0)) {
+                existing.input = block.input
+                // Re-emit tool_start with complete input so frontend can display details
+                sendJSON({
+                  type: 'tool_event',
+                  sessionId,
+                  commandId,
+                  event: {
+                    eventType: 'tool_start',
+                    toolName: existing.toolName,
+                    toolUseId: block.id,
+                    input: block.input,
+                    status: 'running',
+                    timestamp: existing.startedAt || now,
+                  },
+                })
+              }
+            }
           }
           return
         }
@@ -892,22 +977,44 @@ function connect() {
   const ws = new WebSocket(managerUrl.href)
   wsRef = ws
 
-  const pingMs = 10_000
+  const PING_INTERVAL_MS = 10_000
+  const PONG_TIMEOUT_MS = 8_000   // must be < PING_INTERVAL_MS
   let pingTimer = null
+  let pongTimer = null
+  let isAlive = false
+
+  const stopHeartbeat = () => {
+    if (pingTimer) { clearInterval(pingTimer); pingTimer = null }
+    if (pongTimer) { clearTimeout(pongTimer); pongTimer = null }
+  }
 
   ws.on('open', async () => {
     log(chalk.green('Connected to Virtual Office'))
     reconnectAttempts = 0
+    isAlive = true
 
-    // Keepalive pings
+    // Heartbeat: ping + pong timeout detection (matches cloud managerHostProxy pattern)
     pingTimer = setInterval(() => {
-      if (ws.readyState === WebSocket.OPEN) {
-        try { ws.ping() } catch { /* ignore */ }
+      if (ws.readyState !== WebSocket.OPEN) { stopHeartbeat(); return }
+      if (!isAlive) {
+        log(chalk.red('Heartbeat timeout — no pong received, forcing reconnect'))
+        stopHeartbeat()
+        try { ws.terminate() } catch { /* ignore */ }
+        return
       }
-    }, pingMs)
+      isAlive = false
+      try { ws.ping() } catch { /* ignore */ }
+    }, PING_INTERVAL_MS)
+
+    ws.on('pong', () => { isAlive = true })
 
     sendHostMeta(ws)
 
+    // Registry heartbeat: report liveness independently of WS ping/pong.
+    // This lets Chat Bridge know the agent process is alive even during
+    // brief WS reconnection windows.
+    startRegistryHeartbeat()
+
     // Build system prompt and register MCP server (first-class citizen setup)
     log(chalk.blue('Setting up agent identity and tools...'))
     if (!cachedSystemPrompt) {
@@ -950,7 +1057,9 @@ function connect() {
     const reasonStr = reason?.toString() || ''
     log(chalk.red(`Disconnected (${code} ${reasonStr})`))
     wsRef = null
-    if (pingTimer) clearInterval(pingTimer)
+    stopHeartbeat()
+    // Keep registry heartbeat running during reconnection — it's independent
+    // of the WS connection and tells Chat Bridge the process is still alive.
 
     // Kill all active CLI processes on disconnect
     for (const [, entry] of activeChildren) {
@@ -983,6 +1092,53 @@ function scheduleReconnect() {
   setTimeout(connect, delay)
 }
 
+// ── Registry Heartbeat ────────────────────────────────────────────────────
+// Reports agent liveness to Registry via Chat Bridge, independent of WS state.
+// This ensures Chat Bridge knows the agent process is alive even during
+// WS reconnection (up to 30s exponential backoff window).
+
+function startRegistryHeartbeat() {
+  if (registryHeartbeatTimer) return  // already running
+  const agentHandle = argv.agent
+  if (!agentHandle) return
+
+  const chatBridgeHttpUrl =
+    process.env.CHAT_BRIDGE_HTTP_URL ||
+    process.env.CHAT_BRIDGE_URL ||
+    process.env.CHAT_BRIDGE_BASE_URL ||
+    'https://chatbridge.aladdinagi.xyz'
+
+  const sendHeartbeat = async () => {
+    try {
+      const url = `${chatBridgeHttpUrl}/api/${encodeURIComponent(agentHandle)}/heartbeat`
+      const resp = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ timestamp: new Date().toISOString() }),
+        signal: AbortSignal.timeout(10000),
+      })
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => '')
+        log(chalk.dim(`[heartbeat] Registry heartbeat failed: ${resp.status} ${text}`))
+      }
+    } catch (err) {
+      // Silent — heartbeat failures are non-critical
+      log(chalk.dim(`[heartbeat] ${err.message}`))
+    }
+  }
+
+  // Send immediately, then every 30s
+  sendHeartbeat()
+  registryHeartbeatTimer = setInterval(sendHeartbeat, REGISTRY_HEARTBEAT_INTERVAL_MS)
+}
+
+function stopRegistryHeartbeat() {
+  if (registryHeartbeatTimer) {
+    clearInterval(registryHeartbeatTimer)
+    registryHeartbeatTimer = null
+  }
+}
+
 // ── Local Device Connection (file system access for Workspace Panel) ───────
 // Second WebSocket to Chat Bridge /local-agent — registers as a local device
 // so the web UI can browse local files via Workspace Panel.
@@ -1006,8 +1162,17 @@ function connectLocalDevice() {
   const dws = new WebSocket(deviceUrl)
   deviceWsRef = dws
 
+  const DEVICE_PING_INTERVAL_MS = 25_000
+  const DEVICE_PONG_TIMEOUT_MS = 10_000
+  let deviceIsAlive = false
+
+  const stopDeviceHeartbeat = () => {
+    if (devicePingTimer) { clearInterval(devicePingTimer); devicePingTimer = null }
+  }
+
   dws.on('open', () => {
     log(chalk.green('Local device connected'))
+    deviceIsAlive = true
     const agentHandle = argv.agent
     const officeId = agentHandle.split('.').slice(1).join('.')
     // Register as agent-bound device (NOT office-wide).
@@ -1029,13 +1194,21 @@ function connectLocalDevice() {
       },
     }))
 
-    // Keepalive ping every 30s to prevent Cloudflare/ALB idle timeout
-    if (devicePingTimer) clearInterval(devicePingTimer)
+    // Heartbeat: ping + pong timeout detection
+    stopDeviceHeartbeat()
     devicePingTimer = setInterval(() => {
-      if (dws.readyState === WebSocket.OPEN) {
-        try { dws.ping() } catch { /* ignore */ }
+      if (dws.readyState !== WebSocket.OPEN) { stopDeviceHeartbeat(); return }
+      if (!deviceIsAlive) {
+        log(chalk.red('[device] Heartbeat timeout — no pong received, forcing reconnect'))
+        stopDeviceHeartbeat()
+        try { dws.terminate() } catch { /* ignore */ }
+        return
       }
-    }, 30_000)
+      deviceIsAlive = false
+      try { dws.ping() } catch { /* ignore */ }
+    }, DEVICE_PING_INTERVAL_MS)
+
+    dws.on('pong', () => { deviceIsAlive = true })
   })
 
   dws.on('message', async (data) => {
@@ -1058,7 +1231,7 @@ function connectLocalDevice() {
   dws.on('close', (code) => {
     log(chalk.yellow(`Local device disconnected (${code})`))
     deviceWsRef = null
-    if (devicePingTimer) { clearInterval(devicePingTimer); devicePingTimer = null }
+    stopDeviceHeartbeat()
     // Reconnect after delay (only if not shutting down)
     if (code !== 1000) {
       deviceReconnectTimer = setTimeout(connectLocalDevice, 5000)
@@ -1139,7 +1312,8 @@ async function executeLocalTool(toolName, params) {
 function shutdown() {
   console.log('')
   log(chalk.yellow('Clocking out...'))
-  // Unregister MCP server so it doesn't linger in ~/.claude.json
+  // Stop registry heartbeat and unregister MCP server
+  stopRegistryHeartbeat()
   unregisterMcpServer()
   for (const [, entry] of activeChildren) {
     try { entry?.child?.kill('SIGTERM') } catch { /* ignore */ }
@@ -1186,6 +1360,7 @@ async function startup() {
     argv.agent = result.agent
     argv.token = result.token
     hostId = result.agent
+    label = result.agent.split('.')[0] || result.agent
 
     // Rebuild manager URL with new agent/token
     const newManagerUrl = new URL(argv.manager)

package/onboarding.js

@@ -30,6 +30,55 @@ const CHAT_BRIDGE_URL =
 
 const PKG_NAME = '@office-xyz/claude-code'
 
+// ── Pre-flight Check ──────────────────────────────────────────────────────
+
+async function checkClaudeCodeCli() {
+  const { execSync } = await import('child_process')
+
+  // Check if claude is installed
+  let version = null
+  try {
+    version = execSync('claude --version', { encoding: 'utf-8', timeout: 5000 }).trim()
+  } catch {
+    console.log(chalk.red('  Claude Code CLI is not installed.'))
+    console.log('')
+    console.log(chalk.white('  Install it:'))
+    console.log(chalk.cyan('    curl -fsSL https://claude.ai/install.sh | bash'))
+    console.log('')
+    console.log(chalk.dim('  Or via npm: npm install -g @anthropic-ai/claude-code'))
+    console.log('')
+    process.exit(1)
+  }
+
+  console.log(chalk.dim(`  Detected: Claude Code ${version}`))
+
+  // Check if logged in by running a quick command
+  try {
+    const result = execSync('claude -p "ping" --output-format text --max-turns 1', {
+      encoding: 'utf-8',
+      timeout: 15000,
+      env: { ...process.env, ANTHROPIC_API_KEY: undefined },
+    })
+    // If we get any response, auth works
+    console.log(chalk.dim('  Auth: Claude login session ✓'))
+  } catch (err) {
+    const msg = (err.stderr || err.stdout || err.message || '').toLowerCase()
+    if (msg.includes('credit') || msg.includes('balance') || msg.includes('unauthorized') || msg.includes('auth')) {
+      console.log(chalk.red('  Claude Code is not logged in.'))
+      console.log('')
+      console.log(chalk.white('  Run this first:'))
+      console.log(chalk.cyan('    claude login'))
+      console.log('')
+      console.log(chalk.dim('  You need a Claude Pro, Max, or Team subscription.'))
+      console.log('')
+      process.exit(1)
+    }
+    // Other errors (timeout, etc.) — proceed anyway, might work
+    console.log(chalk.dim('  Auth: could not verify (will try anyway)'))
+  }
+  console.log('')
+}
+
 // ── Update Check ──────────────────────────────────────────────────────────
 
 /**
@@ -104,6 +153,8 @@ export function printClockInBanner({ agentHandle, model, seat, workspace }) {
   }
   console.log(chalk.cyan('  │') + chalk.dim('  Workspace: ') + chalk.white(workspace || process.cwd()))
   console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
+  console.log(chalk.cyan('  │') + chalk.dim('  Web UI:    ') + chalk.underline.cyan('https://beta.office.xyz'))
+  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
   console.log(chalk.cyan('  │') + chalk.yellow('  Press Ctrl+C to clock out') + '              ' + chalk.cyan('│'))
   console.log(chalk.cyan('  └─────────────────────────────────────────┘'))
   console.log('')
@@ -280,9 +331,135 @@ async function createOffice(sessionToken) {
   }
 }
 
-// ── Agent Hire ────────────────────────────────────────────────────────────
+// ── Role Selection ────────────────────────────────────────────────────────
+
+const ROLE_CATEGORIES = [
+  { id: 'business',  icon: '💼', label: 'Business',   description: 'Operations, Marketing, Sales, Support, Executive, HR' },
+  { id: 'science',   icon: '🔬', label: 'Science',    description: 'Research, Data Science, Bioinformatics, Lab, Clinical' },
+  { id: 'developer', icon: '💻', label: 'Developer',  description: 'Full-Stack, Frontend, Backend, DevOps, AI Engineering' },
+  { id: 'education', icon: '📖', label: 'Education',  description: 'Learning, Tutoring, Knowledge Exploration' },
+]
+
+const ROLES = [
+  // Business
+  { id: 'operations',  category: 'business',  icon: '📈', label: 'Operations' },
+  { id: 'marketing',   category: 'business',  icon: '📣', label: 'Marketing' },
+  { id: 'sales',       category: 'business',  icon: '🤝', label: 'Sales' },
+  { id: 'support',     category: 'business',  icon: '💬', label: 'Support' },
+  { id: 'executive',   category: 'business',  icon: '👔', label: 'Executive' },
+  { id: 'hr',          category: 'business',  icon: '👥', label: 'HR' },
+  // Science
+  { id: 'researcher',      category: 'science', icon: '🔬', label: 'Researcher' },
+  { id: 'data-scientist',  category: 'science', icon: '📊', label: 'Data Scientist' },
+  { id: 'bioinformatics',  category: 'science', icon: '🧬', label: 'Bioinformatics' },
+  { id: 'lab-manager',     category: 'science', icon: '🧪', label: 'Lab Manager' },
+  { id: 'clinical',        category: 'science', icon: '🏥', label: 'Clinical' },
+  // Developer
+  { id: 'fullstack', category: 'developer', icon: '🖥️', label: 'Full-Stack' },
+  { id: 'frontend',  category: 'developer', icon: '🎨', label: 'Frontend' },
+  { id: 'backend',   category: 'developer', icon: '⚙️',  label: 'Backend' },
+  { id: 'devops',    category: 'developer', icon: '🔧', label: 'DevOps' },
+  { id: 'ai-engineer', category: 'developer', icon: '🤖', label: 'AI Engineer' },
+  // Education
+  { id: 'learner', category: 'education', icon: '📖', label: 'Learner' },
+]
+
+async function selectRole() {
+  const category = await select({
+    message: 'What does your agent do?',
+    choices: ROLE_CATEGORIES.map(c => ({
+      name: `${c.icon} ${c.label}  ${chalk.dim(c.description)}`,
+      value: c.id,
+    })),
+  })
+
+  const rolesInCategory = ROLES.filter(r => r.category === category)
+
+  const roleId = await select({
+    message: 'Select a role:',
+    choices: rolesInCategory.map(r => ({
+      name: `${r.icon} ${r.label}`,
+      value: r.id,
+    })),
+  })
 
-async function hireAgent(officeId, sessionToken) {
+  const role = ROLES.find(r => r.id === roleId)
+  return { roleId, roleCategory: category, roleLabel: role?.label || roleId }
+}
+
+// ── Agent Selection / Hire ─────────────────────────────────────────────────
+
+const PROVIDER_LABELS = {
+  claude: 'Claude Code',
+  anthropic: 'Claude',
+  openai: 'Codex',
+  gemini: 'Gemini',
+  deepseek: 'DeepSeek',
+  qwen: 'Qwen',
+  kimi: 'Kimi',
+  ollama: 'Ollama',
+}
+
+async function selectOrHireAgent(officeId, sessionToken) {
+  // 1. Check for existing agents in this office
+  let existingAgents = []
+  try {
+    const data = await api('GET', `/api/cli/office/${encodeURIComponent(officeId)}/agents`, null, sessionToken)
+    existingAgents = data.agents || []
+  } catch {
+    // Continue — will go straight to hire
+  }
+
+  // Only show local Claude agents — cloud agents and non-Claude agents can't be clocked in from this CLI
+  const localAgents = existingAgents.filter(a =>
+    a.deploymentMode === 'local' &&
+    (a.provider === 'claude' || a.provider === 'claude-code' || a.provider === 'anthropic')
+  )
+
+  if (localAgents.length > 0) {
+    // Show local agents + option to hire new
+    const providerLabel = (p) => PROVIDER_LABELS[p] || p || 'unknown'
+
+    const choices = [
+      ...localAgents.map(a => ({
+        name: `${a.name}  ${chalk.dim(`${a.role} · ${providerLabel(a.provider)} · ${a.seat || 'no seat'}`)}`,
+        value: a.id,
+      })),
+      {
+        name: chalk.cyan('+ Hire a new agent'),
+        value: '__hire__',
+      },
+    ]
+
+    const choice = await select({
+      message: 'Select an agent to clock in:',
+      choices,
+    })
+
+    if (choice !== '__hire__') {
+      // Reconnect existing agent
+      const agent = localAgents.find(a => a.id === choice)
+      const spinner = ora('Reconnecting...').start()
+      try {
+        const result = await api('POST', '/api/cli/office/hire', {
+          officeId,
+          agentName: agent.name,
+          provider: 'claude-code',
+        }, sessionToken)
+
+        spinner.succeed(`Reconnected: ${chalk.bold(result.agentHandle)} ${chalk.dim(`(${agent.role})`)}${result.seat ? chalk.dim(` · seat: ${result.seat}`) : ''}`)
+        return result
+      } catch (err) {
+        spinner.fail(`Failed to reconnect: ${err.message}`)
+        process.exit(1)
+      }
+    }
+  }
+
+  // 2. Hire new agent: select role
+  const { roleId, roleCategory, roleLabel } = await selectRole()
+
+  // 3. Name agent
   const agentName = await input({
     message: 'Name your Claude Code agent:',
     validate: (v) => {
@@ -294,15 +471,18 @@ async function hireAgent(officeId, sessionToken) {
     transformer: (v) => v.toLowerCase(),
   })
 
+  // 4. Hire
   const spinner = ora('Setting up agent...').start()
   try {
     const result = await api('POST', '/api/cli/office/hire', {
       officeId,
       agentName: agentName.trim().toLowerCase(),
       provider: 'claude-code',
+      roleId,
+      roleCategory,
     }, sessionToken)
 
-    spinner.succeed(`Agent ready: ${chalk.bold(result.agentHandle)}${result.seat ? chalk.dim(` (seat: ${result.seat})`) : ''}`)
+    spinner.succeed(`Agent ready: ${chalk.bold(result.agentHandle)} ${chalk.dim(`(${roleLabel})`)}${result.seat ? chalk.dim(` · seat: ${result.seat}`) : ''}`)
     return result
   } catch (err) {
     spinner.fail(`Failed to create agent: ${err.message}`)
@@ -324,6 +504,9 @@ export async function runOnboarding() {
   // Check for updates (non-blocking, runs in background)
   checkForUpdate()
 
+  // 0. Pre-flight: check Claude Code CLI is installed and logged in
+  await checkClaudeCodeCli()
+
   // 1. Check cached session
   const cached = loadSession()
 
@@ -335,6 +518,7 @@ export async function runOnboarding() {
       if (validation.success) {
         spinner.succeed(`Welcome back, ${chalk.bold(cached.email || cached.displayName || 'user')}!`)
         console.log(chalk.dim(`  Reconnecting as ${cached.lastAgent.handle}...`))
+        console.log(chalk.dim(`  Web interface: ${chalk.underline.cyan('https://beta.office.xyz')}`))
         return {
           agent: cached.lastAgent.handle,
           token: cached.lastAgent.connectionToken,
@@ -353,8 +537,8 @@ export async function runOnboarding() {
   // 3. Select or create office
   const { officeId, domain } = await selectOrCreateOffice(offices, session.sessionToken)
 
-  // 4. Name and hire agent
-  const hired = await hireAgent(officeId, session.sessionToken)
+  // 4. Select existing agent or hire new
+  const hired = await selectOrHireAgent(officeId, session.sessionToken)
 
   // 5. Save session
   saveSession({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@office-xyz/claude-code",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Connect Claude Code to your Virtual Office — manage your AI agents from the terminal",
   "type": "module",
   "bin": {