@office-xyz/claude-code 0.1.7 → 0.1.9

package/index.js

@@ -37,6 +37,13 @@ const TOOL_NAME_MAP = {
   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',
+  // Claude server-side tools (content_block type → display name)
+  server_tool_use: 'ServerTool', web_search_tool_result: 'WebSearch',
+  web_fetch_tool_result: 'WebFetch', code_execution_tool_result: 'CodeExecution',
+  mcp_tool_use: 'Mcp', mcp_tool_result: 'Mcp',
+  bash_code_execution_tool_result: 'Bash',
+  text_editor_code_execution_tool_result: 'Edit',
+  tool_search_tool_result: 'ToolSearch', container_upload: 'Upload',
   // General aliases
   bash: 'Bash', grep: 'Grep', glob: 'Glob', ls: 'LS',
 }
@@ -98,6 +105,10 @@ const argv = yargs(hideBin(process.argv))
     type: 'string',
     describe: 'Override the CLI binary (e.g. /usr/local/bin/claude)',
   })
+  .option('channel', {
+    type: 'string',
+    describe: 'Only show messages from this channel (web, telegram, slack, discord, office, feishu, wechat)',
+  })
   .example('$0', 'Interactive setup (login, create office, name agent)')
   .example('$0 --agent claude.my.office.xyz --token xxx', 'Direct connect (skip login)')
   .help()
@@ -253,16 +264,28 @@ const model = argv.model || providerConfig.defaultModel
 
 // ── Session tracking ───────────────────────────────────────────────────────
 // Map VO sessionId → Claude session_id for conversation continuity.
-// Cleared on clock-in to avoid stale sessions that ignore --append-system-prompt.
+// Persisted to disk so sessions survive clock-out / clock-in cycles.
+// --resume and --append-system-prompt coexist fine, so resumed sessions
+// still pick up fresh system prompts and MCP tools (registered globally).
 const SESSION_MAP_FILE = path.join(os.tmpdir(), `vo-sessions-${(argv.agent || 'pending').replace(/\./g, '-')}.json`)
 const sessionMap = new Map()
 
-// Clear stale sessions on startup — stale sessions from previous clock-ins
-// ignore new --append-system-prompt and MCP tools.
+// Load persisted sessions from previous clock-in (if any)
 try {
-  require('fs').unlinkSync(SESSION_MAP_FILE)
-  // Will be re-created when first session is mapped
-} catch { /* no file to delete */ }
+  const raw = require('fs').readFileSync(SESSION_MAP_FILE, 'utf-8')
+  const parsed = JSON.parse(raw)
+  // Support both formats: Array of entries [[k,v], ...] and Object {k: v}
+  const entries = Array.isArray(parsed) ? parsed : Object.entries(parsed)
+  for (const [k, v] of entries) sessionMap.set(k, v)
+  log(chalk.dim(`Restored ${sessionMap.size} session mapping(s) from previous clock-in`))
+} catch { /* no file or invalid — start fresh */ }
+
+/** Persist session map to disk (fire-and-forget) */
+function persistSessionMap() {
+  try {
+    require('fs').writeFileSync(SESSION_MAP_FILE, JSON.stringify([...sessionMap]), 'utf-8')
+  } catch { /* best-effort */ }
+}
 
 // Track active command processes PER SESSION for concurrent conversation support.
 // Key: sessionId, Value: { child, commandId }. Different clients (web, Telegram)
@@ -346,7 +369,10 @@ async function registerMcpServer() {
   try {
     const agentHandle = argv.agent
     const officeId = agentHandle.split('.').slice(1).join('.')
-    const mcpServerPath = path.resolve(__dirname, '../mcp-server/skyoffice-mcp-server.js')
+    // Use the lightweight MCP server bundled with the npm package.
+    // It fetches tool schemas from Chat Bridge and proxies all calls via HTTP,
+    // so it doesn't need the 150+ monorepo files that the full MCP server requires.
+    const mcpServerPath = path.resolve(__dirname, 'mcp-server-lite.cjs')
 
     const chatBridgeUrl = process.env.CHAT_BRIDGE_URL ||
       process.env.CHAT_BRIDGE_BASE_URL ||
@@ -397,6 +423,47 @@ function unregisterMcpServer() {
   } catch { /* ignore */ }
 }
 
+// ── Channel resolution ─────────────────────────────────────────────────────
+
+/**
+ * Resolve message channel from platformInfo / metadata / sessionId.
+ * Returns { type, color, sender, chatId } for display formatting.
+ */
+function resolveChannel(message) {
+  const platformInfo = message.platformInfo || {}
+  const meta = message.metadata || {}
+  const source = meta.source || platformInfo.clientType || ''
+  const sessionId = message.sessionId || ''
+
+  if (source.includes('telegram')) {
+    const from = meta.telegram?.from
+    const name = from?.username ? `@${from.username}` : from?.firstName || 'user'
+    return { type: 'Telegram', color: 'blue', sender: name, chatId: platformInfo.chatId }
+  }
+  if (source.includes('slack')) {
+    const channel = meta.slack?.channelId || platformInfo.channelId || ''
+    const user = meta.slack?.username || 'user'
+    return { type: 'Slack', color: 'magenta', sender: channel ? `#${channel} — ${user}` : user, chatId: null }
+  }
+  if (source.includes('discord')) {
+    return { type: 'Discord', color: 'blueBright', sender: meta.discord?.username || 'user', chatId: null }
+  }
+  if (source.includes('feishu') || source.includes('lark')) {
+    return { type: 'Feishu', color: 'cyan', sender: meta.feishu?.username || 'user', chatId: null }
+  }
+  if (source.includes('wecom') || source.includes('wechat') || source.includes('whatsapp')) {
+    const label = source.includes('whatsapp') ? 'WhatsApp' : 'WeChat'
+    return { type: label, color: 'green', sender: 'user', chatId: null }
+  }
+  if (sessionId.includes('office-wide')) {
+    const senderParts = sessionId.split('--')
+    return { type: 'Office Chat', color: 'greenBright', sender: senderParts[0] || 'colleague', chatId: null }
+  }
+  // Default: Web dialog
+  const userId = sessionId.split('--')[1] || 'user'
+  return { type: 'Web', color: 'cyanBright', sender: userId.slice(0, 20), chatId: null }
+}
+
 // ── Message handling ───────────────────────────────────────────────────────
 
 function sendJSON(payload) {
@@ -454,13 +521,21 @@ async function handleMessage(message) {
     const sessionId = message.sessionId || null
     const commandId = message.commandId || message.messageId || `cmd-${Date.now()}`
 
-    const sessionLabel = sessionId ? sessionId.split('--')[1]?.slice(0, 15) || sessionId.slice(0, 20) : 'default'
-    log(chalk.cyan(`→ [${sessionLabel}] ${text.slice(0, 80)}${text.length > 80 ? '...' : ''}`))
+    const channel = resolveChannel(message)
+
+    // --channel filter: skip messages not matching the requested channel
+    if (argv.channel && !channel.type.toLowerCase().includes(argv.channel.toLowerCase())) return
+
+    const badge = chalk[channel.color](`[${channel.type}]`)
+    const time = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
+    const sender = chalk.dim(channel.sender)
+    log(`${badge} ${chalk.dim(time)}  ${sender}`)
+    log(`  ${text.slice(0, 200)}${text.length > 200 ? '...' : ''}`)
 
     // Kill previous command for THIS SESSION only. Other sessions continue in parallel.
     const prev = sessionId ? activeChildren.get(sessionId) : null
     if (prev?.child) {
-      log(chalk.dim(`[${sessionLabel}] Killing previous command for same session`))
+      log(chalk.dim(`[${sessionId}] Killing previous command for same session`))
       sendJSON({
         type: 'streaming.aborted',
         sessionId,
@@ -482,6 +557,9 @@ async function handleMessage(message) {
     const claudeSessionId = sessionId ? sessionMap.get(sessionId) : null
     if (claudeSessionId && providerConfig.resumeFlag) {
       args.push(providerConfig.resumeFlag, claudeSessionId)
+      log(chalk.green(`[session] Resuming: ${sessionId} → ${claudeSessionId}`))
+    } else if (sessionId) {
+      log(chalk.yellow(`[session] No resume binding for ${sessionId} (map size: ${sessionMap.size})`))
     }
     // System prompt + platform context injection.
     // shell: false — no escaping needed, args passed directly.
@@ -523,6 +601,19 @@ async function handleMessage(message) {
       startedAt: new Date().toISOString(),
     })
 
+    // Heartbeat: Send periodic streaming.heartbeat during long-running claude -p execution.
+    // This prevents WS proxies (Cloudflare 100s, ALB 60s) from killing idle connections
+    // when Claude Code is thinking but not emitting any streaming tokens.
+    const HEARTBEAT_INTERVAL_MS = 25_000 // 25s — below Cloudflare/ALB idle timeouts
+    const heartbeatTimer = setInterval(() => {
+      sendJSON({
+        type: 'streaming.heartbeat',
+        sessionId,
+        commandId,
+        timestamp: Date.now(),
+      })
+    }, HEARTBEAT_INTERVAL_MS)
+
     // 2. Spawn the CLI process
     // shell: false — args are passed directly to the process as an array,
     // avoiding ALL shell interpretation issues. The command is resolved via
@@ -665,6 +756,11 @@ async function handleMessage(message) {
           return
         }
 
+        // Citations delta — ignore silently (citations are embedded in final text)
+        if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'citations_delta') {
+          return
+        }
+
         // Thinking deltas
         if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'thinking_delta') {
           const deltaText = streamEvent.delta.thinking || streamEvent.delta.text || ''
@@ -719,19 +815,42 @@ async function handleMessage(message) {
             return
           }
 
-          if (block?.type === 'tool_use') {
-            const toolUseId = block.id || `tool-${now}-${Math.random().toString(36).slice(2, 8)}`
+          // All tool-like block types: tool_use (client), server_tool_use (Anthropic server),
+          // mcp_tool_use, and result blocks that appear as content_block_start in stream-json.
+          // The original Claude CLI sets "tool-input" spinner state for all of these.
+          const TOOL_BLOCK_TYPES = new Set([
+            'tool_use', 'server_tool_use', 'mcp_tool_use',
+            'web_search_tool_result', 'web_fetch_tool_result',
+            'code_execution_tool_result', 'bash_code_execution_tool_result',
+            'text_editor_code_execution_tool_result', 'tool_search_tool_result',
+            'mcp_tool_result', 'container_upload',
+          ])
+          if (TOOL_BLOCK_TYPES.has(block?.type)) {
+            // For server_tool_use, the tool name is in block.name (e.g. "web_search")
+            // For result blocks, derive name from block type itself
+            const rawName = block.name || block.type
+            const toolUseId = block.id || block.tool_use_id || `tool-${now}-${Math.random().toString(36).slice(2, 8)}`
             if (blockIndex !== null) {
               activeToolsByIndex.set(blockIndex, {
                 toolUseId,
-                toolName: block.name || 'tool',
-                input: block.input,
+                toolName: rawName,
+                input: block.input || {},
               })
             }
             emitToolStart({
               toolUseId,
-              toolName: block.name || 'tool',
-              input: block.input,
+              toolName: rawName,
+              input: block.input || {},
+              timestamp: now,
+            })
+          }
+
+          // Compaction events — notify frontend that context is being compressed
+          if (block?.type === 'compaction') {
+            emitToolStart({
+              toolUseId: block.id || `compaction-${now}`,
+              toolName: 'Compaction',
+              input: {},
               timestamp: now,
             })
           }
@@ -796,10 +915,11 @@ async function handleMessage(message) {
             if (block.type === 'text' && block.text) {
               if (!fullText) fullText = block.text
             }
-            // Extract complete tool_use input — the assistant message contains the
+            // Extract complete tool 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) {
+            // This applies to tool_use, server_tool_use, and mcp_tool_use blocks.
+            const isToolBlock = block.type === 'tool_use' || block.type === 'server_tool_use' || block.type === 'mcp_tool_use'
+            if (isToolBlock && block.id && block.input) {
               const existing = activeToolsById.get(block.id)
               if (existing && (!existing.input || Object.keys(existing.input).length === 0)) {
                 existing.input = block.input
@@ -852,6 +972,39 @@ async function handleMessage(message) {
           }
           return
         }
+
+        // System events — forward plan mode, hooks, and other system subtypes
+        // These are top-level events (not wrapped in stream_event) that the CLI
+        // emits in --verbose stream-json mode for UI state changes.
+        if (event.type === 'system') {
+          const subtype = event.subtype
+          // Plan mode transitions — let frontend know agent entered/exited planning
+          if (subtype === 'plan_mode' || subtype === 'plan_mode_exit' || subtype === 'plan_mode_reentry') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, timestamp: now } })
+            return
+          }
+          // Hook lifecycle — show user that hooks are running
+          if (subtype === 'hook_started' || subtype === 'hook_progress' || subtype === 'hook_response') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, hookName: event.hook_name, timestamp: now } })
+            return
+          }
+          // Task/agent notifications (subagent spawned, progress, etc.)
+          if (subtype === 'task_notification' || subtype === 'task_progress') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, message: event.message, timestamp: now } })
+            return
+          }
+          // MCP progress
+          if (subtype === 'mcp_message' || subtype === 'mcp_progress') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, message: event.message, timestamp: now } })
+            return
+          }
+          // Context compaction boundaries
+          if (subtype === 'compact_boundary' || subtype === 'microcompact_boundary') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, timestamp: now } })
+            return
+          }
+          return
+        }
       } catch {
         // Not JSON or unrecognized format — ignore
       }
@@ -867,6 +1020,7 @@ async function handleMessage(message) {
 
     // 4. On process exit, send completion events
     child.on('close', (code) => {
+      clearInterval(heartbeatTimer) // Stop heartbeat — task is done
       if (sessionId && activeChildren.get(sessionId)?.child === child) activeChildren.delete(sessionId)
 
       // Clean up system prompt temp file
@@ -877,12 +1031,13 @@ async function handleMessage(message) {
       // Store Claude session_id for conversation continuity
       if (resultSessionId && sessionId) {
         sessionMap.set(sessionId, resultSessionId)
+        persistSessionMap()
         log(chalk.dim(`Session mapped: ${sessionId} → ${resultSessionId}`))
       }
 
       if (fullText) {
         process.stdout.write('\n')
-        log(chalk.green(`← ${fullText.slice(0, 80)}${fullText.length > 80 ? '...' : ''}`))
+        log(chalk[channel.color](`[${channel.type}] ←`) + chalk.dim(` ${fullText.slice(0, 120)}${fullText.length > 120 ? '...' : ''}`))
       }
 
       // Send streaming.completed
@@ -964,6 +1119,7 @@ async function handleMessage(message) {
     })
 
     child.on('error', (err) => {
+      clearInterval(heartbeatTimer) // Stop heartbeat on error
       log(chalk.red(`CLI process error: ${err.message}`))
       if (err.code === 'ENOENT') {
         log(chalk.yellow(`"${cmd}" not found. Install it with: ${providerConfig.installHint}`))
@@ -1061,18 +1217,14 @@ function connect() {
       if (mcpRegistered) mcpConfigPath = 'registered'  // flag to skip re-registration
     }
 
-    // Banner
-    console.log('')
-    console.log(chalk.bold.cyan('  ╔══════════════════════════════════════╗'))
-    console.log(chalk.bold.cyan('  ║  Clocked in to Virtual Office       ║'))
-    console.log(chalk.bold.cyan('  ╚══════════════════════════════════════╝'))
-    console.log(chalk.dim(`  Agent:    ${argv.agent}`))
-    console.log(chalk.dim(`  Provider: ${argv.provider}`))
-    console.log(chalk.dim(`  Workspace: ${workspace}`))
-    console.log(chalk.dim(`  Identity: ${cachedSystemPrompt ? 'loaded' : 'default'}`))
-    console.log(chalk.dim(`  Tools:    ${mcpRegistered ? 'VO MCP registered ✓' : 'basic only'}`))
-    console.log(chalk.dim(`  Press Ctrl+C to clock out`))
-    console.log('')
+    // Banner — use the printClockInBanner from onboarding for consistent look
+    const { printClockInBanner: printBanner } = await import('./onboarding.js')
+    printBanner({
+      agentHandle: argv.agent,
+      model: argv.provider,
+      seat: null,
+      workspace,
+    })
   })
 
   ws.on('message', (data) => {

package/mcp-server-lite.cjs

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════════════════
+// MCP Server Lite — Lightweight MCP server for the @office-xyz/claude-code npm package
+//
+// This is a self-contained MCP server that:
+//   1. Fetches tool schemas from Chat Bridge at startup
+//   2. Proxies all tool calls to Chat Bridge / Registry via HTTP
+//   3. Requires zero monorepo dependencies — works with Node.js 18+ built-in fetch
+//
+// Used by the npm package instead of the full skyoffice-mcp-server.js which
+// requires 150+ files from the monorepo.
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const readline = require('readline')
+
+// ── Config from environment ──────────────────────────────────────────────────
+
+const CHAT_BRIDGE_URL = process.env.CHAT_BRIDGE_URL || process.env.CHAT_BRIDGE_BASE_URL || 'https://chatbridge.aladdinagi.xyz'
+const CANONICAL_AGENT_HANDLE = process.env.CANONICAL_AGENT_HANDLE || null
+const REGISTRY_OFFICE_ID = process.env.REGISTRY_OFFICE_ID || null
+const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || process.cwd()
+
+function log(...args) {
+  console.error(`[mcp-lite] ${new Date().toISOString()}`, ...args)
+}
+
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+const HTTP_TIMEOUT_MS = 30_000
+
+async function fetchJSON(url, options = {}) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS)
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        ...(options.headers || {}),
+      },
+    })
+    if (!response.ok) {
+      const text = await response.text().catch(() => '')
+      throw new Error(`HTTP ${response.status}: ${text.slice(0, 200)}`)
+    }
+    return response.json()
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      throw new Error(`Request timed out after ${HTTP_TIMEOUT_MS / 1000}s: ${url}`)
+    }
+    throw err
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+// ── Tool schema loading ──────────────────────────────────────────────────────
+
+let cachedTools = null
+
+async function loadToolSchemas() {
+  if (cachedTools) return cachedTools
+
+  if (!CANONICAL_AGENT_HANDLE) {
+    log('WARNING: No agent handle — returning empty tool list')
+    cachedTools = []
+    return cachedTools
+  }
+
+  try {
+    const url = `${CHAT_BRIDGE_URL}/api/cli/mcp-tools/${encodeURIComponent(CANONICAL_AGENT_HANDLE)}`
+    log(`Fetching tool schemas from ${url}`)
+    const data = await fetchJSON(url)
+
+    if (data?.success && Array.isArray(data.tools)) {
+      cachedTools = data.tools
+      log(`Loaded ${cachedTools.length} tool schemas from Chat Bridge`)
+      return cachedTools
+    }
+  } catch (err) {
+    log(`Failed to fetch tool schemas: ${err.message}`)
+  }
+
+  // Fallback: return empty (tools will fail gracefully)
+  log('WARNING: Using empty tool list — tool calls will be proxied but may fail')
+  cachedTools = []
+  return cachedTools
+}
+
+// ── Tool call routing ────────────────────────────────────────────────────────
+//
+// Most tools follow: POST /api/{handle}/tools/{kebab-name}
+// Special tools have custom URL patterns mapped below.
+
+function toKebab(snakeName) {
+  return snakeName.replace(/_/g, '-')
+}
+
+// Tools with non-standard URL patterns
+const SPECIAL_ROUTES = {
+  // SkyOffice endpoints (no /tools/ prefix)
+  get_skyoffice_location: { method: 'GET', path: (h) => `/api/${h}/skyoffice/location` },
+  list_skyoffice_seats:   { method: 'GET', path: (h) => `/api/${h}/skyoffice/seats` },
+  list_skyoffice_rooms:   { method: 'GET', path: (h) => `/api/${h}/skyoffice/rooms` },
+
+  // Office auth (different path)
+  office_auth_status: { method: 'GET', path: (h) => `/api/${h}/services/available` },
+
+  // SkyOffice chat (no agent handle, uses args for IDs)
+  react_to_message:     { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.messageId)}/reactions` },
+  reply_in_thread:      { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.parentMessageId)}/thread` },
+  get_thread_messages:  { method: 'GET',  path: (h, a) => `/api/skyoffice/messages/${enc(a.parentMessageId)}/thread` },
+  send_channel_message: { method: 'POST', path: (h, a) => `/api/skyoffice/channels/${enc(a.channelId)}/messages` },
+  get_channel_messages: { method: 'GET',  path: (h, a) => `/api/skyoffice/channels/${enc(a.channelId)}/messages?limit=${Math.min(a.limit || 50, 200)}` },
+  create_channel:       { method: 'POST', path: () => `/api/skyoffice/channels` },
+  pin_message:          { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.messageId)}/pin` },
+  search_chat_messages: { method: 'GET',  path: (h, a) => `/api/skyoffice/messages/search?officeId=${enc(REGISTRY_OFFICE_ID)}&q=${enc(a.query || '')}&limit=${Math.min(a.limit || 20, 100)}${a.channelId ? `&channelId=${enc(a.channelId)}` : ''}` },
+
+  // Meetings (no agent handle in URL)
+  join_meeting:              { method: 'POST', path: () => `/api/meetings/join` },
+  leave_meeting:             { method: 'POST', path: () => `/api/meetings/leave` },
+  get_meeting_transcript:    { method: 'GET',  path: (h, a) => `/api/meetings/${enc(a.meetingId)}/transcript` },
+  generate_meeting_notes:    { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes/generate` },
+  list_meetings:             { method: 'GET',  path: () => `/api/meetings` },
+  get_meeting_notes:         { method: 'GET',  path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes` },
+  distribute_meeting_notes:  { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes/distribute` },
+  speak_in_meeting:          { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/speak` },
+
+  // Google auth (GET instead of POST)
+  list_connected_google_accounts:    { method: 'GET', path: (h) => `/api/${h}/tools/list-connected-google-accounts` },
+  list_connected_microsoft_accounts: { method: 'GET', path: (h) => `/api/${h}/tools/list-connected-microsoft-accounts` },
+}
+
+function enc(v) { return encodeURIComponent(v || '') }
+
+// ── Custom tool handlers ─────────────────────────────────────────────────────
+// Tools that need officeId or have multi-step logic can't use simple routing.
+
+const CUSTOM_HANDLERS = {
+  // File management → /api/offices/{officeId}/files
+  list_files: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams()
+    if (args.prefix) params.append('prefix', args.prefix)
+    if (args.maxKeys) params.append('maxKeys', String(args.maxKeys))
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files?${params}`)
+  },
+  get_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const qs = args.metadataOnly ? '?metadataOnly=true' : ''
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${args.filePath}${qs}`)
+  },
+  read_document: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const fp = args.path || args.filePath
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${fp}?parseContent=true`)
+  },
+  delete_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${args.filePath}`, { method: 'DELETE' })
+  },
+  upload_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files`, {
+      method: 'POST',
+      body: JSON.stringify(args),
+    })
+  },
+
+  // Draft management → /api/offices/{officeId}/drafts
+  create_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE, ...args }),
+    })
+  },
+  save_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ content: args.content, agentHandle: CANONICAL_AGENT_HANDLE }),
+    })
+  },
+  submit_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}/submit`, { method: 'POST' })
+  },
+  get_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}`)
+  },
+  list_drafts: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams()
+    if (CANONICAL_AGENT_HANDLE) params.set('agentHandle', CANONICAL_AGENT_HANDLE)
+    if (args.status) params.set('status', args.status)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts?${params}`)
+  },
+  discard_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}/discard`, { method: 'POST' })
+  },
+
+  // Task management → /api/offices/{officeId}/tasks
+  create_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks`, {
+      method: 'POST',
+      body: JSON.stringify({
+        title: args.title,
+        description: args.description || '',
+        priority: args.priority || 'medium',
+        executionMode: args.executionMode || 'agent',
+        createdBy: CANONICAL_AGENT_HANDLE || 'agent',
+        assigneeIds: args.assigneeIds || [],
+        contextFiles: args.contextFiles || [],
+      }),
+    })
+  },
+  batch_create_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const results = { created: [], failed: [] }
+    for (const t of (args.tasks || [])) {
+      try {
+        const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks`, {
+          method: 'POST',
+          body: JSON.stringify({
+            title: t.title, description: t.description || '',
+            priority: t.priority || args.defaultPriority || 'medium',
+            executionMode: t.executionMode || args.defaultExecutionMode || 'agent',
+            createdBy: CANONICAL_AGENT_HANDLE || 'agent',
+            assigneeIds: t.assigneeIds || [],
+          }),
+        })
+        if (r.success && r.data) results.created.push({ id: r.data.id, title: t.title })
+        else results.failed.push({ title: t.title, error: r.error || 'Unknown' })
+      } catch (e) { results.failed.push({ title: t.title, error: e.message }) }
+    }
+    return { success: results.created.length > 0, ...results, summary: `Created ${results.created.length}/${args.tasks?.length || 0} tasks` }
+  },
+  assign_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ assigneeIds: args.agentHandles }),
+    })
+  },
+  list_available_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams({ unassigned: 'true', limit: String(args.limit || 10) })
+    if (args.status) params.append('status', args.status)
+    if (args.priority) params.append('priority', args.priority)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks?${params}`)
+  },
+  list_my_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams({ assigneeId: CANONICAL_AGENT_HANDLE, limit: '20' })
+    if (args.status) params.append('status', args.status)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks?${params}`)
+  },
+  get_task_details: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`)
+  },
+  claim_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/claim`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE, agentLabel: CANONICAL_AGENT_HANDLE?.split('.')[0] }),
+    })
+  },
+  unclaim_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/unclaim`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE }),
+    })
+  },
+  update_task_progress: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/outputs`, {
+      method: 'POST',
+      body: JSON.stringify({ type: 'result', content: args.notes, agentId: CANONICAL_AGENT_HANDLE, agentName: CANONICAL_AGENT_HANDLE?.split('.')[0] || 'Agent' }),
+    })
+    if (args.status) {
+      await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+        method: 'PATCH', body: JSON.stringify({ status: args.status }),
+      }).catch(() => {})
+    }
+    return r
+  },
+  complete_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    if (args.notes) {
+      const note = `✅ COMPLETED by ${CANONICAL_AGENT_HANDLE || 'Agent'}\n\n${args.notes}${args.artifacts?.length ? `\n\nArtifacts:\n${args.artifacts.map(a => `• ${a}`).join('\n')}` : ''}`
+      await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/outputs`, {
+        method: 'POST',
+        body: JSON.stringify({ type: 'result', content: note, agentId: CANONICAL_AGENT_HANDLE }),
+      }).catch(() => {})
+    }
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+      method: 'PATCH', body: JSON.stringify({ status: 'done' }),
+    })
+  },
+
+  // Spawn task session → /api/{agentId}/conversations
+  spawn_task_session: async (args) => {
+    const h = enc(args.agentId || CANONICAL_AGENT_HANDLE)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/${h}/conversations`, {
+      method: 'POST',
+      body: JSON.stringify({
+        taskId: args.taskId, projectPath: args.projectPath,
+        branchName: args.branchName, provider: args.provider,
+        modelId: args.modelId, systemPromptAddition: args.systemPromptAddition,
+      }),
+    })
+  },
+  batch_spawn_task_sessions: async (args) => {
+    const results = { spawned: [], failed: [] }
+    for (const s of (args.sessions || [])) {
+      try {
+        const h = enc(s.agentId || CANONICAL_AGENT_HANDLE)
+        const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/${h}/conversations`, {
+          method: 'POST',
+          body: JSON.stringify({ taskId: s.taskId, provider: s.provider || args.defaultProvider, modelId: s.modelId, systemPromptAddition: s.systemPromptAddition }),
+        })
+        results.spawned.push({ taskId: s.taskId, agentId: s.agentId, ...r })
+      } catch (e) { results.failed.push({ taskId: s.taskId, error: e.message }) }
+    }
+    return { success: results.spawned.length > 0, ...results }
+  },
+}
+
+async function callTool(name, args) {
+  const handle = CANONICAL_AGENT_HANDLE
+  if (!handle) return { success: false, error: 'Agent handle not configured' }
+  const h = encodeURIComponent(handle)
+
+  try {
+    // 1. Check custom handlers (file/task/draft tools with complex logic)
+    const custom = CUSTOM_HANDLERS[name]
+    if (custom) {
+      if (!REGISTRY_OFFICE_ID && name !== 'spawn_task_session' && name !== 'batch_spawn_task_sessions') {
+        return { success: false, error: 'Office ID not configured' }
+      }
+      log(`[call] ${name} → custom handler`)
+      return await custom(args || {})
+    }
+
+    // 2. Check special routes (non-standard URL patterns)
+    const special = SPECIAL_ROUTES[name]
+    let method, urlPath
+    if (special) {
+      method = special.method
+      urlPath = special.path(h, args)
+    } else {
+      // 3. Default pattern: POST /api/{handle}/tools/{kebab-name}
+      method = 'POST'
+      urlPath = `/api/${h}/tools/${toKebab(name)}`
+    }
+
+    const url = `${CHAT_BRIDGE_URL}${urlPath}`
+    log(`[call] ${name} → ${method} ${urlPath}`)
+
+    const options = method === 'GET'
+      ? { method: 'GET' }
+      : { method, body: JSON.stringify(args || {}) }
+
+    return await fetchJSON(url, options)
+  } catch (err) {
+    log(`[call] ${name} failed:`, err.message)
+    return { success: false, error: err.message }
+  }
+}
+
+// ── MCP JSON-RPC protocol ────────────────────────────────────────────────────
+
+class McpServer {
+  constructor() {
+    this.toolsLoaded = false
+    this.tools = []
+  }
+
+  async ensureToolsLoaded() {
+    if (!this.toolsLoaded) {
+      this.tools = await loadToolSchemas()
+      this.toolsLoaded = true
+    }
+  }
+
+  async handleRequest(request) {
+    const { method, params, id } = request
+
+    switch (method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            serverInfo: { name: 'vo-mcp-lite', version: '1.0.0' },
+          },
+        }
+
+      case 'tools/list':
+        await this.ensureToolsLoaded()
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            tools: this.tools.map(t => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema,
+            })),
+          },
+        }
+
+      case 'tools/call': {
+        const { name, arguments: toolArgs } = params || {}
+        if (!name) return this.error(id, -32602, 'Tool name is required')
+
+        log(`Tool call: ${name}`)
+        const result = await callTool(name, toolArgs || {})
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+          },
+        }
+      }
+
+      case 'notifications/initialized':
+        return null
+
+      default:
+        return this.error(id, -32601, `Method not found: ${method}`)
+    }
+  }
+
+  error(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } }
+  }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  log('Starting VO MCP Lite v1.0.0')
+  log('Chat Bridge:', CHAT_BRIDGE_URL)
+  log('Agent:', CANONICAL_AGENT_HANDLE || '(not set)')
+  log('Office:', REGISTRY_OFFICE_ID || '(not set)')
+
+  const server = new McpServer()
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  })
+
+  rl.on('line', async (line) => {
+    if (!line.trim()) return
+    try {
+      const request = JSON.parse(line)
+      const response = await server.handleRequest(request)
+      if (response) console.log(JSON.stringify(response))
+    } catch (error) {
+      log('Parse error:', error.message)
+      console.log(JSON.stringify({
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32700, message: 'Parse error' },
+      }))
+    }
+  })
+
+  rl.on('close', () => {
+    log('Connection closed')
+    process.exit(0)
+  })
+}
+
+main().catch(error => {
+  log('Fatal error:', error)
+  process.exit(1)
+})

package/onboarding.js

@@ -125,38 +125,67 @@ export async function checkForUpdate() {
   }
 }
 
+// ── Adam Sprite Art (auto-generated from pixel art sprite sheet) ──────────
+// Half-block rendering: 2x2 pixels → 1 char, truecolor ANSI
+import { ADAM_IDLE_FRAMES, ADAM_SIT_FRAME, ADAM_FRAMES } from './adam-frames.js'
+
 // ── Banner ────────────────────────────────────────────────────────────────
 
 export function printBanner(subtitle = 'Manage Your AI Agents') {
+  const frame = ADAM_IDLE_FRAMES[0]
+
+  // Text lines aligned to Adam sprite rows (~23 rows)
+  // Adam is ~32 chars wide; text appears to the right with padding
+  const textLines = [
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    chalk.bold.white('  Virtual Office'),
+    chalk.dim(`  ${subtitle}`),
+    '',
+    chalk.dim('  office.xyz'),
+  ]
+
   console.log('')
-  console.log(chalk.cyan('  ┌─────────────────────────────────────────┐'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('   ▓▓▓') + '                                   ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('  ▓░░▓') + chalk.bold.white('   Virtual Office') + '                  ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('  ▓▓▓▓') + chalk.dim(`   ${subtitle}`) + '           ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('   ██') + '                                    ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.dim('  ▓▓▓▓   office.xyz') + '                      ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  └─────────────────────────────────────────┘'))
+  for (let i = 0; i < frame.length; i++) {
+    console.log('  ' + frame[i] + (textLines[i] || ''))
+  }
   console.log('')
 }
 
 export function printClockInBanner({ agentHandle, model, seat, workspace }) {
+  const frame = ADAM_SIT_FRAME
+
+  // Right-side info lines aligned to Adam's sitting sprite (~23 rows)
+  const infoLines = [
+    '',
+    '',
+    '',
+    '',
+    '',
+    chalk.green.bold('  ✓ Clocked in to Virtual Office'),
+    '',
+    chalk.dim('  Agent:  ') + chalk.bold.white(agentHandle),
+    chalk.dim('  Model:  ') + chalk.white(model || 'Claude Opus 4.6'),
+    seat ? (chalk.dim('  Seat:   ') + chalk.white(seat)) : '',
+    chalk.dim('  Dir:    ') + chalk.white(workspace || process.cwd()),
+    '',
+    chalk.dim('  Web:    ') + chalk.underline.cyan('https://beta.office.xyz'),
+    '',
+    chalk.dim('  Press ') + chalk.yellow('Ctrl+C') + chalk.dim(' to clock out'),
+  ]
+
   console.log('')
-  console.log(chalk.cyan('  ┌─────────────────────────────────────────┐'))
-  console.log(chalk.cyan('  │') + chalk.green.bold('  ✓ Clocked in to Virtual Office') + '         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.dim('  Agent:     ') + chalk.bold.white(agentHandle))
-  console.log(chalk.cyan('  │') + chalk.dim('  Model:     ') + chalk.white(model || 'Claude Opus 4.6'))
-  if (seat) {
-    console.log(chalk.cyan('  │') + chalk.dim('  Seat:      ') + chalk.white(seat))
+  for (let i = 0; i < Math.max(frame.length, infoLines.length); i++) {
+    const sprite = (i < frame.length) ? frame[i] : ''
+    const info = (i < infoLines.length) ? infoLines[i] : ''
+    console.log('  ' + sprite + info)
   }
-  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('')
 }
 
@@ -510,19 +539,54 @@ export async function runOnboarding() {
   // 1. Check cached session
   const cached = loadSession()
 
-  if (cached?.sessionToken && cached?.lastAgent?.handle && cached?.lastAgent?.connectionToken) {
-    // Quick reconnect path
+  if (cached?.sessionToken && cached?.lastAgent?.handle) {
+    // Quick reconnect path — always refresh token to avoid stale token rejection
     const spinner = ora('Validating session...').start()
     try {
       const validation = await api('GET', '/api/cli/auth/session', null, cached.sessionToken)
       if (validation.success) {
+        spinner.text = 'Refreshing connection...'
+
+        // Re-hire with same agent name to get a fresh connectionToken.
+        // This is idempotent — if agent exists, it just refreshes the token.
+        const agentName = cached.lastAgent.handle.split('.')[0]
+        const officeId = cached.lastOfficeId || null
+
+        let freshToken = cached.lastAgent.connectionToken
+        let seat = cached.lastAgent.seat
+
+        if (agentName && officeId) {
+          try {
+            const result = await api('POST', '/api/cli/office/hire', {
+              officeId,
+              agentName,
+              provider: 'claude-code',
+            }, cached.sessionToken)
+            freshToken = result.connectionToken || freshToken
+            seat = result.seat || seat
+
+            // Update cached session with fresh token
+            saveSession({
+              ...cached,
+              lastAgent: {
+                ...cached.lastAgent,
+                connectionToken: freshToken,
+                seat,
+              },
+            })
+          } catch (err) {
+            // If refresh fails, try with cached token anyway
+            console.log(chalk.dim(`  Token refresh failed (${err.message}), using cached token`))
+          }
+        }
+
         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,
-          seat: cached.lastAgent.seat,
+          token: freshToken,
+          seat,
         }
       }
     } catch {
@@ -548,6 +612,7 @@ export async function runOnboarding() {
     sessionToken: session.sessionToken,
     expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
     lastOffice: domain,
+    lastOfficeId: officeId,
     lastAgent: {
       handle: hired.agentHandle,
       connectionToken: hired.connectionToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@office-xyz/claude-code",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Connect Claude Code to Office.xyz — a shared working environment for all your AI agents, cloud and local",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   "files": [
     "index.js",
     "onboarding.js",
+    "mcp-server-lite.cjs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"