u-foo 1.2.6 → 1.2.8

package/README.md

@@ -1,5 +1,7 @@
 # ufoo
 
+[中文文档](README.zh-CN.md)
+
 🤖 Multi-agent AI collaboration framework for orchestrating Claude Code, OpenAI Codex, and custom AI agents.
 
 📦 **npm**: [https://www.npmjs.com/package/u-foo](https://www.npmjs.com/package/u-foo)

package/README.zh-CN.md

@@ -1,35 +1,168 @@
 # ufoo
 
-多Agent AI 协作工具包，支持 Claude Code 和 OpenAI Codex。
+[English](README.md)
+
+🤖 多Agent AI 协作框架，支持 Claude Code、OpenAI Codex 和自定义 AI Agent 的编排协作。
+
+📦 **npm**: [https://www.npmjs.com/package/u-foo](https://www.npmjs.com/package/u-foo)
+
+[![npm version](https://img.shields.io/npm/v/u-foo.svg)](https://www.npmjs.com/package/u-foo)
+[![npm downloads](https://img.shields.io/npm/dm/u-foo.svg)](https://www.npmjs.com/package/u-foo)
+[![License](https://img.shields.io/badge/license-UNLICENSED-red.svg)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
+[![Platform](https://img.shields.io/badge/platform-macOS-blue.svg)](https://www.apple.com/macos)
+
+## 为什么选择 ufoo？
+
+ufoo 解决多 AI 编程 Agent 协同工作的难题：
+
+- **🔗 统一界面** - 一个聊天 UI 管理所有 AI Agent
+- **📬 消息路由** - Agent 之间通过事件总线通信协作
+- **🧠 上下文共享** - 跨 Agent 共享决策和知识
+- **🚀 自动初始化** - Agent 包装器自动完成配置
+- **📝 决策追踪** - 记录架构决策和权衡取舍
+- **⚡ 实时更新** - 即时查看 Agent 状态和消息
 
 ## 功能特性
 
-- **事件总线** - Agent间实时消息通信 (`ufoo bus`)
+- **聊天界面** - 交互式多 Agent 聊天 UI (`ufoo chat`)
+  - 实时 Agent 通信和状态监控
+  - 仪表盘展示 Agent 列表、在线状态和快捷操作
+  - 使用 `@agent-name` 向特定 Agent 发送消息
+- **事件总线** - Agent 间实时消息通信 (`ufoo bus`)
 - **上下文共享** - 共享决策和项目上下文 (`ufoo ctx`)
-- **Agent包装器** - Claude Code (`uclaude`) 和 Codex (`ucodex`) 自动初始化
-- **技能系统** - 可扩展的Agent能力 (`ufoo skills`)
+- **Agent 包装器** - Claude Code (`uclaude`)、Codex (`ucodex`) 和 ucode 助手 (`ucode`) 自动初始化
+  - **PTY 包装器** - 智能终端模拟与就绪检测
+  - **智能探针注入** - 等待 Agent 初始化完成后再注入命令
+  - **统一命名** - 一致的 Agent 命名规范（如 ucode-1、claude-1、codex-1）
+- **技能系统** - 可扩展的 Agent 能力 (`ufoo skills`)
 
-## 快速开始
+## 安装
+
+```bash
+# 从 npm 全局安装（推荐）
+npm install -g u-foo
+```
+
+或从源码安装：
 
 ```bash
-# 克隆并全局链接
-git clone <repo> ~/.ufoo
-cd ~/.ufoo && npm link
+git clone https://github.com/Icyoung/ufoo.git ~/.ufoo
+cd ~/.ufoo && npm install && npm link
+```
 
+安装后可使用以下全局命令：`ufoo`、`uclaude`、`ucodex`、`ucode`。
+
+## 快速开始
+
+```bash
 # 初始化项目
 cd your-project
 ufoo init
 
-# 或使用Agent包装器（自动初始化 + 加入总线）
-uclaude   # 代替 'claude'
-ucodex    # 代替 'codex'
+# 启动聊天界面（默认命令）
+ufoo chat
+# 或直接
+ufoo
+
+# 使用 Agent 包装器（自动初始化 + 加入总线）
+uclaude   # Claude Code 包装器
+ucodex    # Codex 包装器
+ucode     # ucode 助手（自研 AI 编程 Agent）
+```
+
+## 示例工作流
+
+```bash
+# 1. 启动聊天界面
+$ ufoo
+
+# 2. 从聊天中启动 Agent
+> /launch claude
+> /launch ucode
+
+# 3. 向 Agent 发送任务
+> @claude-1 请分析当前代码库结构
+> @ucode-1 修复认证模块的 bug
+
+# 4. Agent 通过总线通信
+claude-1: 分析完成，发现 3 处需要重构...
+ucode-1: Bug 已修复，正在运行测试...
+
+# 5. 查看已做的决策
+> /decisions
+```
+
+原生自研实现位于 `src/code` 目录。
+
+准备和验证 `ucode` 运行时：
+
+```bash
+ufoo ucode doctor
+ufoo ucode prepare
+ufoo ucode build
+```
+
+尝试原生核心队列运行时（开发中）：
+
+```bash
+ucode-core submit --tool read --args-json '{"path":"README.md"}'
+ucode-core run-once --json
+ucode-core list --json
+```
+
+## Agent 配置
+
+在 `.ufoo/config.json` 中配置 AI 提供商：
+
+### ucode 配置（自研助手）
+```json
+{
+  "ucodeProvider": "openai",
+  "ucodeModel": "gpt-4-turbo-preview",
+  "ucodeBaseUrl": "https://api.openai.com/v1",
+  "ucodeApiKey": "sk-***"
+}
+```
+
+### Claude 配置
+```json
+{
+  "claudeProvider": "claude-cli",
+  "claudeModel": "claude-3-opus"
+}
+```
+
+### Codex 配置
+```json
+{
+  "codexProvider": "codex-cli",
+  "codexModel": "gpt-4"
+}
+```
+
+### 完整示例
+```json
+{
+  "launchMode": "internal",
+  "ucodeProvider": "openai",
+  "ucodeModel": "gpt-4-turbo-preview",
+  "ucodeBaseUrl": "https://api.openai.com/v1",
+  "ucodeApiKey": "sk-***",
+  "claudeProvider": "claude-cli",
+  "claudeModel": "claude-3-opus",
+  "codexProvider": "codex-cli",
+  "codexModel": "gpt-4"
+}
 ```
 
+`ucode` 会将配置写入专用运行时目录（`.ufoo/agent/ucode/pi-agent`），用于原生 planner/engine 调用。
+
 ## 架构
 
 ```
 ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
-│   uclaude   │     │   ucodex    │     │  其他...    │
+│   uclaude   │     │   ucodex    │     │    ucode    │
 └──────┬──────┘     └──────┬──────┘     └──────┬──────┘
        │                   │                   │
        └───────────────────┼───────────────────┘
@@ -49,21 +182,43 @@ Bus 状态存放于 `.ufoo/agent/all-agents.json`（元数据）、`.ufoo/bus/*`
 
 ## 命令列表
 
+### 核心命令
 | 命令 | 说明 |
 |------|------|
+| `ufoo` | 启动聊天界面（默认） |
+| `ufoo chat` | 启动交互式多 Agent 聊天 UI |
 | `ufoo init` | 在当前项目初始化 .ufoo |
 | `ufoo status` | 显示 banner、未读消息和未处理决策 |
-| `ufoo daemon --start|--stop|--status` | 管理 ufoo 守护进程 |
-| `ufoo chat` | 启动 ufoo 交互界面（无参数默认进入） |
-| `ufoo resume [nickname]` | 恢复 agent 会话（可选昵称） |
-| `ufoo bus join` | 加入事件总线（uclaude/ucodex 自动完成）|
-| `ufoo bus send <id> <msg>` | 发送消息给Agent |
+| `ufoo doctor` | 检查安装状态 |
+
+### Agent 管理
+| 命令 | 说明 |
+|------|------|
+| `ufoo daemon start` | 启动 ufoo 守护进程 |
+| `ufoo daemon stop` | 停止 ufoo 守护进程 |
+| `ufoo daemon status` | 查看守护进程状态 |
+| `ufoo resume [nickname]` | 恢复 Agent 会话 |
+
+### 事件总线
+| 命令 | 说明 |
+|------|------|
+| `ufoo bus join` | 加入事件总线（Agent 包装器自动完成） |
+| `ufoo bus send <id> <msg>` | 发送消息给 Agent |
 | `ufoo bus check <id>` | 检查待处理消息 |
-| `ufoo bus status` | 查看总线状态 |
+| `ufoo bus status` | 查看总线状态和在线 Agent |
+
+### 上下文与决策
+| 命令 | 说明 |
+|------|------|
 | `ufoo ctx decisions -l` | 列出所有决策 |
 | `ufoo ctx decisions -n 1` | 显示最新决策 |
+| `ufoo ctx decisions new <title>` | 创建新决策 |
+
+### 技能
+| 命令 | 说明 |
+|------|------|
 | `ufoo skills list` | 列出可用技能 |
-| `ufoo doctor` | 检查安装状态 |
+| `ufoo skills show <skill>` | 显示技能详情 |
 
 备注：
 - Claude CLI 的 headless agent 使用 `--dangerously-skip-permissions`。
@@ -76,13 +231,14 @@ ufoo/
 │   ├── ufoo         # 主 CLI 入口 (bash)
 │   ├── ufoo.js      # Node 包装器
 │   ├── uclaude      # Claude Code 包装器
-│   └── ucodex       # Codex 包装器
+│   ├── ucodex       # Codex 包装器
+│   └── ucode        # ucode 助手包装器
 ├── SKILLS/          # 全局技能（uinit, ustatus）
 ├── src/
 │   ├── bus/         # 事件总线实现（JS）
 │   ├── daemon/      # Daemon + chat bridge
-│   └── agent/       # Agent 启动/运行
-├── scripts/         # 历史遗留（bash，已弃用）
+│   ├── agent/       # Agent 启动/运行
+│   └── code/        # 原生 ucode 核心实现
 ├── modules/
 │   ├── context/     # 决策/上下文协议
 │   ├── bus/         # 总线模块资源
@@ -100,21 +256,52 @@ your-project/
 ├── .ufoo/
 │   ├── bus/
 │   │   ├── events/      # 事件日志（只追加）
-│   │   ├── queues/      # 每个Agent的消息队列
+│   │   ├── queues/      # 每个 Agent 的消息队列
 │   │   └── offsets/     # 读取位置跟踪
 │   └── context/
-│       └── DECISIONS/   # 决策记录
-├── scripts/             # 软链接（历史遗留，可选）
+│       ├── decisions/   # 决策记录
+│       └── decisions.jsonl  # 决策索引
 ├── AGENTS.md            # 注入的协议块
 └── CLAUDE.md            # → AGENTS.md
 ```
 
-## Agent通信
+## 聊天界面
+
+交互式聊天 UI 提供集中化的 Agent 管理中心：
+
+### 功能
+- **实时通信** - 在一个界面查看所有 Agent 消息
+- **Agent 仪表盘** - 监控在线状态、会话 ID 和昵称
+- **定向消息** - 使用 `@agent-name` 向特定 Agent 发送消息
+- **命令补全** - Tab 键补全命令和 Agent 名称
+- **鼠标支持** - `Ctrl+M` 切换鼠标模式（滚动 vs 文本选择）
+- **会话历史** - 跨会话持久化消息记录
+
+### 快捷键
+| 按键 | 操作 |
+|------|------|
+| `Tab` | 自动补全命令/Agent |
+| `Ctrl+C` | 退出聊天 |
+| `Ctrl+M` | 切换鼠标模式 |
+| `Ctrl+L` | 清屏 |
+| `Ctrl+R` | 刷新 Agent 列表 |
+| `↑/↓` | 浏览命令历史 |
+
+### 聊天命令
+| 命令 | 说明 |
+|------|------|
+| `/help` | 显示可用命令 |
+| `/agents` | 列出在线 Agent |
+| `/clear` | 清除聊天记录 |
+| `/settings` | 配置聊天偏好 |
+| `@agent-name <message>` | 向特定 Agent 发送消息 |
 
-Agent通过事件总线通信：
+## Agent 通信
+
+Agent 通过事件总线通信：
 
 ```bash
-# Agent A 向Agent B 发送任务
+# Agent A 向 Agent B 发送任务
 ufoo bus send "codex:abc123" "请分析项目结构"
 
 # Agent B 检查并执行
@@ -124,7 +311,7 @@ ufoo bus check "codex:abc123"
 ufoo bus send "claude-code:xyz789" "分析完成：..."
 ```
 
-## 技能（供Agent使用）
+## 技能（供 Agent 使用）
 
 内置技能通过斜杠命令触发：
 
@@ -135,31 +322,54 @@ ufoo bus send "claude-code:xyz789" "分析完成：..."
 
 ## 系统要求
 
-- macOS（用于 Terminal.app/iTerm2 注入功能）
-- Node.js >= 18（可选，用于 npm 全局安装）
-- Bash 4+
+- **macOS** - 用于 Terminal.app/iTerm2 集成
+- **Node.js >= 18** - npm 安装和 JavaScript 运行时
+- **Bash 4+** - Shell 脚本和命令执行
+- **终端** - iTerm2 或 Terminal.app 用于启动 Agent
 
 ## Codex CLI 说明
 
-如果 Codex CLI 在 `~/.codex` 下报权限错误（例如 sessions 目录），请在启动 daemon/chat 前设置可写的 `CODEX_HOME`：
+`ufoo chat` 会自动启动守护进程（无需单独运行 `ufoo daemon start`）。
+
+如果 Codex CLI 在 `~/.codex` 下报权限错误（例如 sessions 目录），请设置可写的 `CODEX_HOME`：
 
 ```bash
 export CODEX_HOME="$PWD/.ufoo/codex"
-ufoo daemon start
-ufoo chat
+ufoo chat  # 守护进程自动启动
 ```
 
 ## 开发
 
+### 环境搭建
 ```bash
-# 本地开发
-./bin/ufoo --help
+# 克隆仓库
+git clone https://github.com/Icyoung/ufoo.git
+cd ufoo
+
+# 安装依赖
+npm install
 
-# 或通过 Node
+# 本地开发链接
 npm link
-ufoo --help
+
+# 运行测试
+npm test
 ```
 
+### 参与贡献
+- Fork 本仓库
+- 创建功能分支 (`git checkout -b feature/amazing-feature`)
+- 提交更改 (`git commit -m 'Add amazing feature'`)
+- 推送分支 (`git push origin feature/amazing-feature`)
+- 发起 Pull Request
+
+### 项目结构
+- `src/` - 核心 JavaScript 实现
+- `bin/` - CLI 入口
+- `modules/` - 模块化功能（bus、context 等）
+- `test/` - 单元测试和集成测试
+- `SKILLS/` - Agent 技能定义
+
 ## 许可证
 
 UNLICENSED（私有）

package/modules/online/README.md

@@ -0,0 +1,74 @@
+# online
+
+WebSocket relay module for cross-machine agent collaboration. Extends the local ufoo bus to work over the network.
+
+## Overview
+
+online enables agents on different machines to collaborate:
+
+- Public channel chat (broadcast to all connected agents)
+- Private room collaboration (bus/decisions/wake sync)
+- Token-based authentication
+- Auto-reconnect with exponential backoff
+
+## Quick Start
+
+### 1. Start a relay server
+
+```bash
+ufoo online server --port 8787
+```
+
+### 2. Connect an agent
+
+```bash
+# Join a public channel
+ufoo online connect --nickname my-agent --join lobby
+
+# Join a private room
+ufoo online connect --nickname my-agent --room room_001 --room-password secret
+```
+
+### 3. Send messages
+
+```bash
+# To a channel
+ufoo online send --nickname my-agent --channel lobby --text "hello everyone"
+
+# To a room
+ufoo online send --nickname my-agent --room room_001 --text "hello team"
+```
+
+### 4. Check inbox
+
+```bash
+ufoo online inbox my-agent          # All messages
+ufoo online inbox my-agent --unread # Unread only
+ufoo online inbox my-agent --clear  # Clear inbox
+```
+
+## Private Room Sync
+
+In private room mode, agents automatically sync:
+
+- **Bus messages** — local bus ↔ online relay, bidirectional
+- **Decisions** — new `.md` files synced across team
+- **Wake events** — remote agent can wake local agent via bus
+
+## Storage
+
+```
+~/.ufoo/online/
+├── tokens.json           # Auth tokens
+├── inbox/<nickname>.jsonl # Incoming messages
+└── outbox/<nickname>.jsonl # Queued outgoing messages
+```
+
+## Relationship with bus
+
+| Module | Scope |
+|--------|-------|
+| bus | Local file-system based messaging within a single machine |
+| online | Network relay extending bus across machines via WebSocket |
+
+online builds on top of bus — local agents still communicate via the file-system bus, while online bridges messages to remote agents.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -40,7 +40,6 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
-    "import:pi-mono": "node scripts/import-pi-mono.js",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"

package/src/chat/daemonMessageRouter.js

@@ -1,4 +1,5 @@
 const { IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
+const { renderMarkdownLines } = require("../shared/markdownRenderer");
 
 function createDaemonMessageRouter(options = {}) {
   const {
@@ -215,7 +216,12 @@ function createDaemonMessageRouter(options = {}) {
       if (hasStream(publisher)) {
         finalizeStream(publisher, data, "interrupted");
       }
-      const line = `${prefixLabel}${escapeBlessed(displayMessage)}`;
+      const mdState = {};
+      const renderedLines = renderMarkdownLines(displayMessage, mdState, escapeBlessed);
+      const line = renderedLines.map((l, i) => {
+        const p = i === 0 ? prefixLabel : continuationPrefix;
+        return `${p}${l}`;
+      }).join("\n");
       logMessage("bus", line, data);
       if (data.event === "message" && pendingBeforeMessage) {
         consumePendingDelivery(publisher, displayName);

package/src/chat/streamTracker.js

@@ -1,3 +1,5 @@
+const { renderMarkdownLines } = require("../shared/markdownRenderer");
+
 function createStreamTracker(options = {}) {
   const {
     logBox,
@@ -11,11 +13,17 @@ function createStreamTracker(options = {}) {
   const streamStates = new Map();
   const pendingDeliveries = new Map();
 
+  function renderLine(line, mdState) {
+    const rendered = renderMarkdownLines(line, mdState, escapeBlessed);
+    return rendered.length > 0 ? rendered[0] : escapeBlessed(line);
+  }
+
   function buildStreamDisplayText(fullText, prefix, continuationPrefix) {
+    const mdState = {};
     const lines = String(fullText || "").split("\n");
     return lines.map((line, i) => {
       const p = i === 0 ? prefix : continuationPrefix;
-      return `${p}${escapeBlessed(line)}`;
+      return `${p}${renderLine(line, mdState)}`;
     }).join("\n");
   }
 
@@ -36,6 +44,7 @@ function createStreamTracker(options = {}) {
       full: "",
       linesEmitted: 0,
       meta,
+      mdState: {},
     };
     streamStates.set(publisher, state);
     if (typeof onStreamStart === "function") {
@@ -53,7 +62,7 @@ function createStreamTracker(options = {}) {
       const completed = parts.slice(0, -1);
       for (const line of completed) {
         const prefix = state.linesEmitted === 0 ? state.prefix : state.continuationPrefix;
-        logBox.setLine(state.lineIndex, `${prefix}${escapeBlessed(line)}`);
+        logBox.setLine(state.lineIndex, `${prefix}${renderLine(line, state.mdState)}`);
         state.linesEmitted += 1;
         logBox.pushLine(state.continuationPrefix);
         state.lineIndex = logBox.getLines().length - 1;
@@ -61,7 +70,10 @@ function createStreamTracker(options = {}) {
       state.buffer = parts[parts.length - 1];
     }
     const prefix = state.linesEmitted === 0 ? state.prefix : state.continuationPrefix;
-    logBox.setLine(state.lineIndex, `${prefix}${escapeBlessed(state.buffer)}`);
+    // For the current incomplete line, render with a snapshot of mdState
+    // to avoid mutating state on partial lines
+    const snapState = { inCodeBlock: state.mdState.inCodeBlock };
+    logBox.setLine(state.lineIndex, `${prefix}${renderLine(state.buffer, snapState)}`);
   }
 
   function finalizeStream(publisher, meta, reason = "") {

package/src/code/tui.js

@@ -243,106 +243,8 @@ function loadActiveAgents(workspaceRoot) {
 }
 
 function renderLogLinesWithMarkdown(text = "", state = {}, escapeFn = (value) => String(value || "")) {
-  const renderState = state && typeof state === "object" ? state : {};
-  if (typeof renderState.inCodeBlock !== "boolean") {
-    renderState.inCodeBlock = false;
-  }
-
-  const renderInlineCode = (input = "") => {
-    const source = String(input || "");
-    if (!source) return "";
-    if (!source.includes("`")) return escapeFn(source);
-
-    let out = "";
-    let cursor = 0;
-    const pattern = /`([^`\n]+)`/g;
-    let match = pattern.exec(source);
-    while (match) {
-      const index = Number(match.index) || 0;
-      if (index > cursor) {
-        out += escapeFn(source.slice(cursor, index));
-      }
-      out += `{yellow-fg}${escapeFn(match[1])}{/yellow-fg}`;
-      cursor = index + match[0].length;
-      match = pattern.exec(source);
-    }
-    if (cursor < source.length) {
-      out += escapeFn(source.slice(cursor));
-    }
-    return out;
-  };
-
-  const lines = String(text || "").split(/\r?\n/);
-  const out = [];
-
-  for (const line of lines) {
-    const raw = stripLeakedEscapeTags(String(line || ""));
-    const fenceMatch = raw.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
-    if (fenceMatch) {
-      if (!renderState.inCodeBlock) {
-        const language = String(fenceMatch[3] || "").trim();
-        const label = language
-          ? `┌ code:${escapeFn(language)}`
-          : "┌ code";
-        out.push(`{gray-fg}${label}{/gray-fg}`);
-        renderState.inCodeBlock = true;
-      } else {
-        out.push("{gray-fg}└{/gray-fg}");
-        renderState.inCodeBlock = false;
-      }
-      continue;
-    }
-
-    if (renderState.inCodeBlock) {
-      out.push(`{gray-fg}│{/gray-fg} {white-fg}${escapeFn(raw)}{/white-fg}`);
-    } else {
-      const headingMatch = raw.match(/^(\s*)(#{1,6})\s+(.*)$/);
-      if (headingMatch) {
-        const indent = escapeFn(headingMatch[1] || "");
-        const marks = escapeFn(headingMatch[2] || "");
-        const content = renderInlineCode(headingMatch[3] || "");
-        out.push(`${indent}{cyan-fg}${marks}{/cyan-fg} {bold}${content}{/bold}`);
-        continue;
-      }
-
-      const quoteMatch = raw.match(/^(\s*)>\s?(.*)$/);
-      if (quoteMatch) {
-        const indent = escapeFn(quoteMatch[1] || "");
-        const content = renderInlineCode(quoteMatch[2] || "");
-        out.push(`${indent}{gray-fg}▍{/gray-fg} ${content}`);
-        continue;
-      }
-
-      const bulletMatch = raw.match(/^(\s*)([-*+])\s+(.*)$/);
-      if (bulletMatch) {
-        const indent = escapeFn(bulletMatch[1] || "");
-        const content = renderInlineCode(bulletMatch[3] || "");
-        out.push(`${indent}{gray-fg}•{/gray-fg} ${content}`);
-        continue;
-      }
-
-      const orderedMatch = raw.match(/^(\s*)(\d+)\.\s+(.*)$/);
-      if (orderedMatch) {
-        const indent = escapeFn(orderedMatch[1] || "");
-        const order = escapeFn(orderedMatch[2] || "");
-        const content = renderInlineCode(orderedMatch[3] || "");
-        out.push(`${indent}{gray-fg}${order}.{/gray-fg} ${content}`);
-        continue;
-      }
-
-      const errorMatch = raw.match(/^(\s*)(Error:\s+.*)$/i);
-      if (errorMatch) {
-        const indent = escapeFn(errorMatch[1] || "");
-        const content = renderInlineCode(errorMatch[2] || "");
-        out.push(`${indent}{red-fg}${content}{/red-fg}`);
-        continue;
-      }
-
-      out.push(renderInlineCode(raw));
-    }
-  }
-
-  return out;
+  const { renderMarkdownLines } = require("../shared/markdownRenderer");
+  return renderMarkdownLines(text, state, escapeFn);
 }
 
 function shouldEnterAgentSelection(inputValue = "") {

package/src/shared/markdownRenderer.js

@@ -0,0 +1,121 @@
+/**
+ * Shared blessed-compatible markdown renderer for TUI output.
+ *
+ * Used by both ucode TUI and ufoo chat to render agent responses
+ * with fenced code blocks, headings, quotes, bullets, inline code, etc.
+ */
+
+function stripLeakedEscapeTags(text = "") {
+  const source = String(text == null ? "" : text);
+  const withoutClosedTags = source.replace(/\{[^{}\n]*escape[^{}\n]*\}/gi, "");
+  const withoutDanglingEscape = withoutClosedTags.replace(/\{\s*\/?\s*escape[\s\S]*$/gi, "");
+  return withoutDanglingEscape.replace(/\{\s*\/?\s*e?s?c?a?p?e?[^{}\n]*$/gi, "");
+}
+
+function renderMarkdownLines(text = "", state = {}, escapeFn = (value) => String(value || "")) {
+  const renderState = state && typeof state === "object" ? state : {};
+  if (typeof renderState.inCodeBlock !== "boolean") {
+    renderState.inCodeBlock = false;
+  }
+
+  const renderInlineCode = (input = "") => {
+    const source = String(input || "");
+    if (!source) return "";
+    if (!source.includes("`")) return escapeFn(source);
+
+    let out = "";
+    let cursor = 0;
+    const pattern = /`([^`\n]+)`/g;
+    let match = pattern.exec(source);
+    while (match) {
+      const index = Number(match.index) || 0;
+      if (index > cursor) {
+        out += escapeFn(source.slice(cursor, index));
+      }
+      out += `{yellow-fg}${escapeFn(match[1])}{/yellow-fg}`;
+      cursor = index + match[0].length;
+      match = pattern.exec(source);
+    }
+    if (cursor < source.length) {
+      out += escapeFn(source.slice(cursor));
+    }
+    return out;
+  };
+
+  const lines = String(text || "").split(/\r?\n/);
+  const out = [];
+
+  for (const line of lines) {
+    const raw = stripLeakedEscapeTags(String(line || ""));
+    const fenceMatch = raw.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      if (!renderState.inCodeBlock) {
+        const language = String(fenceMatch[3] || "").trim();
+        const label = language
+          ? `┌ code:${escapeFn(language)}`
+          : "┌ code";
+        out.push(`{gray-fg}${label}{/gray-fg}`);
+        renderState.inCodeBlock = true;
+      } else {
+        out.push("{gray-fg}└{/gray-fg}");
+        renderState.inCodeBlock = false;
+      }
+      continue;
+    }
+
+    if (renderState.inCodeBlock) {
+      out.push(`{gray-fg}│{/gray-fg} {white-fg}${escapeFn(raw)}{/white-fg}`);
+    } else {
+      const headingMatch = raw.match(/^(\s*)(#{1,6})\s+(.*)$/);
+      if (headingMatch) {
+        const indent = escapeFn(headingMatch[1] || "");
+        const marks = escapeFn(headingMatch[2] || "");
+        const content = renderInlineCode(headingMatch[3] || "");
+        out.push(`${indent}{cyan-fg}${marks}{/cyan-fg} {bold}${content}{/bold}`);
+        continue;
+      }
+
+      const quoteMatch = raw.match(/^(\s*)>\s?(.*)$/);
+      if (quoteMatch) {
+        const indent = escapeFn(quoteMatch[1] || "");
+        const content = renderInlineCode(quoteMatch[2] || "");
+        out.push(`${indent}{gray-fg}▍{/gray-fg} ${content}`);
+        continue;
+      }
+
+      const bulletMatch = raw.match(/^(\s*)([-*+])\s+(.*)$/);
+      if (bulletMatch) {
+        const indent = escapeFn(bulletMatch[1] || "");
+        const content = renderInlineCode(bulletMatch[3] || "");
+        out.push(`${indent}{gray-fg}•{/gray-fg} ${content}`);
+        continue;
+      }
+
+      const orderedMatch = raw.match(/^(\s*)(\d+)\.\s+(.*)$/);
+      if (orderedMatch) {
+        const indent = escapeFn(orderedMatch[1] || "");
+        const order = escapeFn(orderedMatch[2] || "");
+        const content = renderInlineCode(orderedMatch[3] || "");
+        out.push(`${indent}{gray-fg}${order}.{/gray-fg} ${content}`);
+        continue;
+      }
+
+      const errorMatch = raw.match(/^(\s*)(Error:\s+.*)$/i);
+      if (errorMatch) {
+        const indent = escapeFn(errorMatch[1] || "");
+        const content = renderInlineCode(errorMatch[2] || "");
+        out.push(`${indent}{red-fg}${content}{/red-fg}`);
+        continue;
+      }
+
+      out.push(renderInlineCode(raw));
+    }
+  }
+
+  return out;
+}
+
+module.exports = {
+  stripLeakedEscapeTags,
+  renderMarkdownLines,
+};

package/scripts/import-pi-mono.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable no-console */
-const fs = require("fs");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-function usage() {
-  console.log("Usage: node scripts/import-pi-mono.js <pi-mono-source-path> [--target <target-path>]");
-}
-
-function shouldSkip(name = "") {
-  return name === ".git" || name === "node_modules";
-}
-
-function copyRecursive(source, target) {
-  const stat = fs.statSync(source);
-  if (stat.isDirectory()) {
-    fs.mkdirSync(target, { recursive: true });
-    const entries = fs.readdirSync(source);
-    for (const entry of entries) {
-      if (shouldSkip(entry)) continue;
-      copyRecursive(path.join(source, entry), path.join(target, entry));
-    }
-    return;
-  }
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  fs.copyFileSync(source, target);
-}
-
-function parseArgs(argv = []) {
-  const args = Array.isArray(argv) ? argv : [];
-  const parsed = {
-    source: "",
-    target: "",
-    help: false,
-  };
-  for (let i = 0; i < args.length; i += 1) {
-    const item = String(args[i] || "").trim();
-    if (!item) continue;
-    if (item === "--help" || item === "-h") {
-      parsed.help = true;
-      continue;
-    }
-    if (item === "--target" || item === "-t") {
-      const next = String(args[i + 1] || "").trim();
-      if (next) parsed.target = next;
-      i += 1;
-      continue;
-    }
-    if (!parsed.source) parsed.source = item;
-  }
-  return parsed;
-}
-
-function readGitValue(sourceRoot = "", gitArgs = []) {
-  try {
-    const res = spawnSync("git", ["-C", sourceRoot, ...gitArgs], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    if (res.error || res.status !== 0) return "";
-    return String(res.stdout || "").trim();
-  } catch {
-    return "";
-  }
-}
-
-function readGitMetadata(sourceRoot = "") {
-  return {
-    commit: readGitValue(sourceRoot, ["rev-parse", "HEAD"]),
-    branch: readGitValue(sourceRoot, ["rev-parse", "--abbrev-ref", "HEAD"]),
-    remote: readGitValue(sourceRoot, ["config", "--get", "remote.origin.url"]),
-  };
-}
-
-function main() {
-  const parsedArgs = parseArgs(process.argv.slice(2));
-  if (parsedArgs.help) {
-    usage();
-    process.exit(0);
-  }
-  const sourceArg = parsedArgs.source || "";
-  if (!sourceArg) {
-    usage();
-    process.exit(1);
-  }
-
-  const sourceRoot = path.resolve(sourceArg);
-  const sourcePackage = path.join(sourceRoot, "package.json");
-  if (!fs.existsSync(sourcePackage)) {
-    console.error(`Invalid source: missing package.json at ${sourceRoot}`);
-    process.exit(2);
-  }
-
-  const repoRoot = path.resolve(__dirname, "..");
-  const targetRoot = path.resolve(parsedArgs.target || path.join(repoRoot, "src", "code", "pi-mono"));
-  const backupRoot = `${targetRoot}.backup-${Date.now()}`;
-
-  if (fs.existsSync(targetRoot)) {
-    fs.renameSync(targetRoot, backupRoot);
-    console.log(`Backed up existing fork to ${backupRoot}`);
-  }
-
-  copyRecursive(sourceRoot, targetRoot);
-  const upstream = readGitMetadata(sourceRoot);
-
-  const metadata = {
-    imported_at: new Date().toISOString(),
-    source_root: sourceRoot,
-    target: targetRoot,
-    upstream_commit: upstream.commit,
-    upstream_branch: upstream.branch,
-    upstream_remote: upstream.remote,
-  };
-  fs.writeFileSync(
-    path.join(targetRoot, ".ufoo-import.json"),
-    `${JSON.stringify(metadata, null, 2)}\n`,
-    "utf8",
-  );
-
-  console.log(`Imported pi-mono into ${targetRoot}${upstream.commit ? ` @ ${upstream.commit}` : ""}`);
-}
-
-main();

package/scripts/sync-claude-skills.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-# Sync SKILLS to .claude/commands for Claude Code slash commands
-
-set -e
-
-SKILLS_DIR="SKILLS"
-CLAUDE_COMMANDS_DIR=".claude/commands"
-
-# Create commands directory if it doesn't exist
-mkdir -p "$CLAUDE_COMMANDS_DIR"
-
-# Copy all SKILL.md files to .claude/commands/
-for skill_dir in "$SKILLS_DIR"/*; do
-    if [ -d "$skill_dir" ] && [ -f "$skill_dir/SKILL.md" ]; then
-        skill_name=$(basename "$skill_dir")
-        echo "Syncing $skill_name..."
-        cp "$skill_dir/SKILL.md" "$CLAUDE_COMMANDS_DIR/$skill_name.md"
-    fi
-done
-
-echo "Skills synced to Claude Code commands directory!"