feat: Hermes architecture, Agentic UI, and CLI optimizations

agents/__tests__/base3.test.ts

@@ -160,4 +160,10 @@ describe('base3 CLI roots', () => {
     // Codebuff's paid modes explain credits; Freebuff has none to explain.
     expect(base3.systemPrompt).toContain('/usage')
   })
+
+  test('ships the optimization rules for long-running commands and anti-looping', () => {
+    expect(base3FreeDeepseek.systemPrompt).toContain('LONG-RUNNING COMMANDS (PREVENT HANGS)')
+    expect(base3FreeDeepseek.systemPrompt).toContain('ANTI-LOOPING')
+    expect(base3FreeDeepseek.systemPrompt).toContain('write_todos')
+  })
 })

agents/base3.ts

@@ -176,6 +176,19 @@ ${
 }
 
 ${PLACEHOLDER.SYSTEM_INFO_PROMPT}
+
+# LONG-RUNNING COMMANDS (PREVENT HANGS)
+- Commands like "bun run build:freebuff", compilations, or dev servers MUST use process_type: "BACKGROUND".
+- NEVER run a compilation in SYNC mode, as it will deadlock the terminal.
+- To wait for a background build, pipe its output (e.g., "> build.log 2>&1 < NUL") and then use "sleep 2" or "sleep 5" in SYNC mode repeatedly as a biological timer, then read the log to check if it finished.
+
+# ANTI-LOOPING
+- If you find yourself repeatedly executing the exact same tool calls without progress (e.g. reading the same file continuously), you MUST STOP. Change your approach, write to a different file, run a different search, or ask the user for help. Do NOT loop blindly.
+
+# METAS E SUBMETAS (write_todos)
+- Você DEVE EXECUTAR A FERRAMENTA/TOOL \`write_todos\` no início de qualquer tarefa para quebrar o objetivo em etapas hiper-granulares.
+- Conforme você avança, chame a tool \`write_todos\` novamente para atualizar o progresso.
+- NUNCA escreva os seus TODOs no texto normal do chat como markdown. Use APENAS a tool \`write_todos\` para que a UI possa ler os dados.
 `
 }
 

agents/mcp-enabled.ts

@@ -0,0 +1,32 @@
+import { FREEBUFF_MIMO_V25_MODEL_ID } from '@codebuff/common/constants/freebuff-models'
+
+import { createBase3CliRoot } from './base3'
+
+const definition = {
+  ...createBase3CliRoot({
+    model: FREEBUFF_MIMO_V25_MODEL_ID,
+    isFreebuff: true,
+  }),
+  id: 'mcp-enabled',
+  displayName: 'Buffy with MCP',
+  mcpServers: {
+    filesystem: {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-filesystem'],
+    },
+    memory: {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-memory'],
+    },
+    'sequential-thinking': {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+    },
+    puppeteer: {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-puppeteer'],
+    },
+  },
+}
+
+export default definition

cli/scripts/build-binary.ts

@@ -168,6 +168,17 @@ async function main() {
     ['process.env.CODEBUFF_CLI_VERSION', `"${version}"`],
     ['process.env.CODEBUFF_CLI_TARGET', `"${getCliTargetLabel(targetInfo)}"`],
     ['process.env.FREEBUFF_MODE', `"${process.env.FREEBUFF_MODE ?? 'false'}"`],
+    ['process.env.NEXT_PUBLIC_API_URL', '"https://www.codebuff.com"'],
+    ['process.env.NEXT_PUBLIC_CODEBUFF_APP_URL', '"https://www.codebuff.com"'],
+    ['process.env.NEXT_PUBLIC_SUPERTOKENS_APP_URL', '"https://www.codebuff.com"'],
+    ['process.env.NEXT_PUBLIC_CB_ENVIRONMENT', '"prod"'],
+    ['process.env.NEXT_PUBLIC_SUPPORT_EMAIL', '"support@codebuff.com"'],
+    ['process.env.NEXT_PUBLIC_POSTHOG_API_KEY', '"dummy"'],
+    ['process.env.NEXT_PUBLIC_POSTHOG_HOST_URL', '"https://app.posthog.com"'],
+    ['process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY', '"pk_dummy"'],
+    ['process.env.NEXT_PUBLIC_STRIPE_CUSTOMER_PORTAL', '"https://stripe.com"'],
+    ['process.env.NEXT_PUBLIC_WEB_PORT', '"3000"'],
+    ['process.env.NEXT_PUBLIC_IS_FREEBUFF', '"true"'],
     ...nextPublicEnvVars,
   ]
 

cli/src/chat.tsx

@@ -11,10 +11,14 @@ import {
   useState,
 } from 'react'
 import { useShallow } from 'zustand/react/shallow'
+import fs from 'node:fs'
+import path from 'node:path'
 
 import { getAdsEnabled } from './commands/ads'
 import { routeUserPrompt, addBashMessageToHistory } from './commands/router'
+import { MissionTodosTracker } from './components/mission-todos-tracker'
 import { SingleAdBanner } from './components/ad-banner'
+import { getMissionPath } from './missions/mission-store'
 import { ChatInputBar } from './components/chat-input-bar'
 import { ChatHeader } from './components/chat-header'
 import { FreebuffActiveSessionSummary } from './components/freebuff-active-session-summary'
@@ -1628,6 +1632,8 @@ export const Chat = ({
           />
         )}
 
+        <MissionTodosTracker messages={messages} />
+
         {reviewMode ? (
           // Review and ask_user take precedence over the session-ended banner:
           // during the grace window the agent may still be asking to run tools
@@ -1652,6 +1658,14 @@ export const Chat = ({
         ) : isFreebuffSessionOver && !askUserState ? (
           <SessionEndedBanner
             isStreaming={isStreaming || isWaitingForResponse}
+            onSessionRenewed={() => {
+              const missionPath = getMissionPath(getProjectRoot() ?? process.cwd())
+              if (fs.existsSync(missionPath)) {
+                setTimeout(() => {
+                  onSubmitPrompt('continue', agentMode).catch(() => {})
+                }, 100)
+              }
+            }}
           />
         ) : (
           <>

cli/src/commands/command-registry.ts

@@ -4,6 +4,8 @@ import { handleAdsEnable, handleAdsDisable } from './ads'
 import { handleCopyConversationCommand } from './copy-conversation'
 import { handleHelpCommand } from './help'
 import { handleImageCommand } from './image'
+import { runMCPCommand } from './mcp'
+import { runMissionCommand } from './mission'
 import { handleInitializationFlowLocally } from './init'
 import {
   collectProcessDiagnostics,
@@ -186,6 +188,40 @@ const FREEBUFF_ONLY_COMMANDS = new Set([
 ])
 
 const ALL_COMMANDS: CommandDefinition[] = [
+  defineCommandWithArgs({
+    name: 'mcp',
+    handler: async (params, args) => {
+      const input = params.inputValue.trim()
+      params.saveToHistory(input)
+      clearInput(params)
+      const message = await runMCPCommand(args)
+      params.setMessages((prev) => [
+        ...prev,
+        getUserMessage(input),
+        getSystemMessage(message),
+      ])
+    },
+  }),
+  defineCommandWithArgs({
+    name: 'mission',
+    aliases: ['goal'],
+    handler: (params, args) => {
+      const input = params.inputValue.trim()
+      params.saveToHistory(input)
+      clearInput(params)
+      const result = runMissionCommand(args)
+      if (result.kind === 'start') {
+        params.sendMessage({ content: result.prompt, agentMode: params.agentMode })
+        setTimeout(() => params.scrollToLatest(), 0)
+        return
+      }
+      params.setMessages((prev) => [
+        ...prev,
+        getUserMessage(input),
+        getSystemMessage(result.message),
+      ])
+    },
+  }),
   defineCommand({
     name: 'ads:enable',
     handler: (params) => {

cli/src/commands/mcp.ts

@@ -0,0 +1,71 @@
+import {
+  closeAllMCPClients,
+  getMCPClient,
+  getMCPClientId,
+  getMCPClientStatuses,
+  listMCPTools,
+} from '@codebuff/common/mcp/client'
+
+import {
+  getLoadedMCPServers,
+  initializeAgentRegistry,
+} from '../utils/local-agent-registry'
+
+import type { MCPConfig } from '@codebuff/common/types/mcp'
+
+function describeConfig(config: MCPConfig): string {
+  if (config.type === 'stdio') return `stdio · ${config.command}`
+  try {
+    const url = new URL(config.url)
+    return `${config.type} · ${url.origin}${url.pathname}`
+  } catch {
+    return `${config.type} · endereço inválido`
+  }
+}
+
+export function formatMCPStatus(): string {
+  const servers = getLoadedMCPServers()
+  const statuses = getMCPClientStatuses()
+  if (!Object.keys(servers).length) {
+    return 'Nenhum servidor MCP configurado. Use .agents/mcp.json, .mcp.json ou .cursor/mcp.json.'
+  }
+
+  const readyIds = new Set(
+    statuses.filter((status) => status.state === 'ready').map((status) => status.id),
+  )
+  return Object.entries(servers)
+    .map(([name, config]) => {
+      const active = readyIds.has(getMCPClientId(config))
+        ? 'conectado'
+        : 'configurado'
+      return `${name} · ${describeConfig(config)} · ${active}`
+    })
+    .join('\n')
+}
+
+export async function runMCPCommand(args: string): Promise<string> {
+  const trimmed = args.trim()
+  const [verb, name] = trimmed ? trimmed.split(/\s+/, 2) : ['status']
+  if (verb === 'status' || verb === 'list') return formatMCPStatus()
+
+  if (verb === 'reload') {
+    await closeAllMCPClients()
+    await initializeAgentRegistry()
+    return `MCP recarregado.\n${formatMCPStatus()}`
+  }
+
+  if (verb === 'test') {
+    if (!name) return 'Uso: /mcp test <servidor>'
+    const config = getLoadedMCPServers()[name]
+    if (!config) return `Servidor MCP não encontrado: ${name}`
+    try {
+      const clientId = await getMCPClient(config)
+      const result = await listMCPTools(clientId)
+      return `${name} conectado · ${result.tools.length} ferramentas disponíveis`
+    } catch (error) {
+      return `${name} falhou: ${error instanceof Error ? error.message : String(error)}`
+    }
+  }
+
+  return 'Uso: /mcp [status|list|reload|test <servidor>]'
+}

cli/src/commands/mission.ts

@@ -0,0 +1,66 @@
+import { getProjectRoot } from '../project-files'
+import {
+  buildMissionPrompt,
+  cancelMission,
+  completeMission,
+  createMission,
+  formatMissionStatus,
+  loadMission,
+} from '../missions/mission-store'
+
+function root(): string {
+  return getProjectRoot() || process.cwd()
+}
+
+export type MissionCommandResult =
+  | { kind: 'message'; message: string }
+  | { kind: 'start'; prompt: string }
+
+export function runMissionCommand(args: string): MissionCommandResult {
+  const trimmed = args.trim()
+  let [verb, ...rest] = trimmed ? trimmed.split(/\s+/) : ['status']
+
+  if (verb.endsWith(',')) {
+    verb = verb.slice(0, -1)
+  }
+
+  const value = rest.join(' ').trim()
+
+  if (verb === 'status') {
+    return { kind: 'message', message: formatMissionStatus(loadMission(root())) }
+  }
+  if (verb === 'start') {
+    if (!value) {
+      return { kind: 'message', message: 'Uso: /mission start <objetivo>' }
+    }
+    const mission = createMission(root(), value)
+    return { kind: 'start', prompt: buildMissionPrompt(mission) }
+  }
+  if (verb === 'complete') {
+    const evidence = value ? value.split('|').map((item) => item.trim()) : []
+    try {
+      const mission = completeMission(root(), evidence)
+      return { kind: 'message', message: formatMissionStatus(mission) }
+    } catch (error) {
+      return {
+        kind: 'message',
+        message: error instanceof Error ? error.message : String(error),
+      }
+    }
+  }
+  if (verb === 'cancel') {
+    try {
+      const mission = cancelMission(root())
+      return { kind: 'message', message: formatMissionStatus(mission) }
+    } catch (error) {
+      return {
+        kind: 'message',
+        message: error instanceof Error ? error.message : String(error),
+      }
+    }
+  }
+  return {
+    kind: 'message',
+    message: 'Uso: /mission [status|start <objetivo>|complete [evidência]|cancel]',
+  }
+}