u-foo 1.0.6 → 1.1.9

package/README.md

@@ -6,7 +6,7 @@ Multi-agent AI collaboration toolkit for Claude Code and OpenAI Codex.
 
 - **Event Bus** - Real-time inter-agent messaging (`ufoo bus`)
 - **Context Sharing** - Shared decisions and project context (`ufoo ctx`)
-- **Agent Wrappers** - Auto-initialization for Claude Code (`uclaude`) and Codex (`ucodex`)
+- **Agent Wrappers** - Auto-initialization for Claude Code (`uclaude`), Codex (`ucodex`), and ufoo core (`ucode`)
   - **PTY Wrapper** - Intelligent terminal emulation with ready detection
   - **Smart Probe Injection** - Waits for agent initialization before injecting commands
 - **Skills System** - Extensible agent capabilities (`ufoo skills`)
@@ -25,8 +25,46 @@ ufoo init
 # Or use agent wrappers (auto-init + bus join)
 uclaude   # instead of 'claude'
 ucodex    # instead of 'codex'
+ucode     # ufoo self-developed coding agent entry
 ```
 
+To import a local `pi-mono` checkout as a reference snapshot (reference-only):
+
+```bash
+npm run import:pi-mono -- /path/to/pi-mono
+```
+
+Native self-developed implementation lives under `src/code`.
+
+Prepare and verify `ucode` runtime wiring:
+
+```bash
+ufoo ucode doctor
+ufoo ucode prepare
+ufoo ucode build
+```
+
+Try native core queue runtime (WIP):
+
+```bash
+ucode-core submit --tool read --args-json '{"path":"README.md"}'
+ucode-core run-once --json
+ucode-core list --json
+```
+
+Configure `ucode` provider/model/API in `.ufoo/config.json` (ufoo-managed):
+
+```json
+{
+  "ucodeProvider": "openai",
+  "ucodeModel": "gpt-5.1-codex",
+  "ucodeBaseUrl": "https://api.openai.com/v1",
+  "ucodeApiKey": "sk-***"
+}
+```
+
+`ucode` writes these into a dedicated runtime directory (`.ufoo/agent/ucode/pi-agent`) and uses them for native planner/engine calls.
+
 ## Architecture
 
 ```
@@ -58,7 +96,7 @@ Bus state lives in `.ufoo/agent/all-agents.json` (metadata), `.ufoo/bus/*` (queu
 | `ufoo daemon --start|--stop|--status` | Manage ufoo daemon |
 | `ufoo chat` | Launch ufoo chat UI (also default when no args) |
 | `ufoo resume [nickname]` | Resume agent sessions (optional nickname) |
-| `ufoo bus join` | Join event bus (auto by uclaude/ucodex) |
+| `ufoo bus join` | Join event bus (auto by uclaude/ucodex/ucode) |
 | `ufoo bus send <id> <msg>` | Send message to agent |
 | `ufoo bus check <id>` | Check pending messages |
 | `ufoo bus status` | Show bus status |
@@ -78,12 +116,14 @@ ufoo/
 │   ├── ufoo         # Main CLI entry (bash)
 │   ├── ufoo.js      # Node wrapper
 │   ├── uclaude      # Claude Code wrapper
-│   └── ucodex       # Codex wrapper
+│   ├── ucodex       # Codex wrapper
+│   └── ucode        # ufoo core wrapper
 ├── SKILLS/          # Global skills (uinit, ustatus)
 ├── src/
 │   ├── bus/         # Event bus implementation (JS)
 │   ├── daemon/      # Daemon + chat bridge
-│   └── agent/       # Agent launch/runtime
+│   ├── agent/       # Agent launch/runtime
+│   └── code/        # Native ucode core implementation
 ├── scripts/         # Legacy helpers (bash, deprecated)
 ├── modules/
 │   ├── context/     # Decision/context protocol

package/SKILLS/ufoo/SKILL.md

@@ -2,7 +2,7 @@
 name: ufoo
 description: |
   Unified ufoo agent protocol: context decisions, event bus, and initialization.
-  Use when: (1) input starts with "/ufoo", (2) agent session startup, (3) any ufoo-related operation.
+  Use when: (1) input starts with "/ufoo" or "$ufoo", (2) agent session startup, (3) any ufoo-related operation.
   Combines uctx (decisions), ubus (messaging), and uinit (initialization).
 ---
 
@@ -16,7 +16,7 @@ ufoo is the multi-agent coordination layer. It provides three capabilities:
 
 ## Session Marker
 
-When you see `/ufoo <marker>` (e.g., `/ufoo claude-9`), this is a daemon probe for session tracking. **Do not reply.** Silently ignore it and wait for the next user input.
+When you see a probe marker command like `/ufoo <marker>` (Claude) or `$ufoo <marker>` (Codex), this is daemon session tracking. **Do not reply.** Silently ignore it and wait for the next user input.
 
 ---
 
@@ -88,6 +88,21 @@ ufoo bus broadcast "<message>"               # Broadcast to all
 ufoo bus status                              # Show bus status
 ```
 
+### Runtime Report (Unified for assistant/ucodex/uclaude)
+
+Use the same report contract for runtime progress sync:
+
+```bash
+ufoo report start "<task>" --task <id> --agent "$UFOO_SUBSCRIBER_ID" --scope public
+ufoo report progress "<detail>" --task <id> --agent "$UFOO_SUBSCRIBER_ID" --scope public
+ufoo report done "<summary>" --task <id> --agent "$UFOO_SUBSCRIBER_ID" --scope public
+ufoo report error "<reason>" --task <id> --agent "$UFOO_SUBSCRIBER_ID" --scope public
+```
+
+Notes:
+- Use `--scope private` for helper-internal reports (assistant-like private channel).
+- `--controller ufoo-agent` routes report events to the ufoo-agent private inbox.
+
 ### Target Resolution
 
 - Exact ID: `claude-code:abc123`

package/SKILLS/uinit/SKILL.md

@@ -46,8 +46,13 @@ ufoo init --modules <selected_modules> --project $(pwd)
 ### 3. If bus module selected, auto-join bus
 
 ```bash
-SUBSCRIBER=$(ufoo bus join | tail -1)
-echo "Joined event bus: $SUBSCRIBER"
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+if [ -n "$SUBSCRIBER" ]; then
+  echo "Using existing subscriber ID: $SUBSCRIBER"
+else
+  SUBSCRIBER=$(ufoo bus join | tail -1)
+  echo "Joined event bus: $SUBSCRIBER"
+fi
 ```
 
 ### 4. Report initialization result
@@ -69,5 +74,5 @@ Next steps:
 ## Notes
 
 - If .ufoo/context, .ufoo/bus, or .ufoo/agent already exists, skip creation
-- After initialization, auto-join event bus (if bus enabled)
+- After initialization, reuse existing subscriber ID first, join only as fallback (if bus enabled)
 - AGENTS.md will have protocol description block injected

package/bin/ucode-core.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+const { runUcodeCoreCli } = require("../src/code/cli");
+
+(async () => {
+  const argv = process.argv.slice(2);
+  const result = await runUcodeCoreCli({ argv, projectRoot: process.cwd() });
+  if (result && typeof result.output === "string" && result.output) {
+    process.stdout.write(result.output);
+  }
+  process.exit(typeof result.exitCode === "number" ? result.exitCode : 0);
+})().catch((err) => {
+  process.stderr.write(`${err && err.message ? err.message : "ucode-core failed"}\n`);
+  process.exit(1);
+});

package/bin/ucode.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * ucode: Launch ufoo self-developed coding agent core
+ *
+ * Usage: ucode [core args...]
+ *
+ * Command resolution order:
+ * 1) UFOO_UCODE_CMD / UFOO_UFOO_CODE_CMD
+ * 2) .ufoo/config.json -> ucodeCommand / ufooCodeCommand
+ * 3) fallback: bundled native core entry
+ */
+
+const fs = require("fs");
+const AgentLauncher = require("../src/agent/launcher");
+const { resolveUcodeLaunch } = require("../src/agent/ucode");
+const { prepareUcodeBootstrap } = require("../src/agent/ucodeBootstrap");
+const { prepareUcodeRuntimeConfig } = require("../src/agent/ucodeRuntimeConfig");
+
+function stripAppendSystemPromptArgs(args = [], targetFile = "") {
+  const normalizedTarget = String(targetFile || "").trim();
+  if (!Array.isArray(args) || args.length === 0) return { args: [], removed: false };
+  const nextArgs = [];
+  let removed = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const item = String(args[i] || "");
+    if (!item) continue;
+    if (item === "--append-system-prompt") {
+      const value = String(args[i + 1] || "");
+      if (!normalizedTarget || value === normalizedTarget) {
+        removed = true;
+        i += 1;
+        continue;
+      }
+      nextArgs.push(item, value);
+      i += 1;
+      continue;
+    }
+    if (item.startsWith("--append-system-prompt=")) {
+      const value = item.slice("--append-system-prompt=".length);
+      if (!normalizedTarget || value === normalizedTarget) {
+        removed = true;
+        continue;
+      }
+    }
+    nextArgs.push(item);
+  }
+  return { args: nextArgs, removed };
+}
+
+function shouldPreserveAppendTarget({
+  appendTarget = "",
+  bootstrapFile = "",
+} = {}) {
+  const append = String(appendTarget || "").trim();
+  if (!append) return false;
+  const bootstrap = String(bootstrapFile || "").trim();
+  if (!bootstrap) return fs.existsSync(append);
+  if (append === bootstrap) return false;
+  return fs.existsSync(append);
+}
+
+const resolved = resolveUcodeLaunch({
+  argv: process.argv.slice(2),
+  env: process.env,
+  cwd: process.cwd(),
+});
+
+if (resolved && resolved.env && typeof resolved.env === "object") {
+  for (const [key, value] of Object.entries(resolved.env)) {
+    if (!key) continue;
+    process.env[key] = String(value);
+  }
+}
+
+try {
+  const runtimePrepared = prepareUcodeRuntimeConfig({
+    projectRoot: process.cwd(),
+    env: process.env,
+  });
+  if (runtimePrepared && runtimePrepared.env && typeof runtimePrepared.env === "object") {
+    for (const [key, value] of Object.entries(runtimePrepared.env)) {
+      if (!key) continue;
+      process.env[key] = String(value);
+    }
+  }
+} catch {
+  // runtime config preparation is best-effort
+}
+
+try {
+  prepareUcodeBootstrap({
+    projectRoot: process.cwd(),
+    promptFile: process.env.UFOO_UCODE_PROMPT_FILE || "",
+    targetFile: process.env.UFOO_UCODE_BOOTSTRAP_FILE || "",
+  });
+} catch (err) {
+  const mode = String(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT_MODE || "auto").trim().toLowerCase();
+  const bootstrapFile = String(process.env.UFOO_UCODE_BOOTSTRAP_FILE || "").trim();
+  const appendTarget = String(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT || bootstrapFile).trim();
+  const preserveCustomAppend = shouldPreserveAppendTarget({ appendTarget, bootstrapFile });
+  if (mode !== "always" && !preserveCustomAppend) {
+    const stripped = stripAppendSystemPromptArgs(resolved.args, appendTarget);
+    resolved.args = stripped.args;
+    if (stripped.removed) {
+      console.error(`[ucode] Warning: bootstrap prepare failed; launching without --append-system-prompt (${err && err.message ? err.message : "unknown error"})`);
+    }
+  } else if (preserveCustomAppend) {
+    console.error(`[ucode] Warning: bootstrap prepare failed; preserving custom --append-system-prompt (${err && err.message ? err.message : "unknown error"})`);
+  }
+}
+
+const mode = String(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT_MODE || "auto").trim().toLowerCase();
+const bootstrapFile = String(process.env.UFOO_UCODE_BOOTSTRAP_FILE || "").trim();
+const appendTarget = String(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT || bootstrapFile).trim();
+const preserveCustomAppend = shouldPreserveAppendTarget({ appendTarget, bootstrapFile });
+if (mode !== "always" && bootstrapFile && !fs.existsSync(bootstrapFile) && !preserveCustomAppend) {
+  const stripped = stripAppendSystemPromptArgs(resolved.args, appendTarget);
+  resolved.args = stripped.args;
+  if (stripped.removed) {
+    console.error("[ucode] Warning: bootstrap file missing; launching without --append-system-prompt");
+  }
+}
+
+const launcher = new AgentLauncher(resolved.agentType, resolved.command);
+launcher.launch(resolved.args);

package/bin/ufoo-assistant-agent.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { runAssistantStdio } = require("../src/assistant/stdio");
+
+runAssistantStdio();

package/bin/ufoo-engine.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const { runUfooEngineCli } = require("../src/assistant/ufooEngineCli");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.resume();
+  });
+}
+
+(async () => {
+  const stdinText = await readStdin();
+  const result = await runUfooEngineCli({
+    argv: process.argv.slice(2),
+    stdinText,
+  });
+  process.stdout.write(result.output);
+  process.exitCode = result.exitCode;
+})();

package/bin/ufoo.js

@@ -27,6 +27,10 @@ async function main() {
     try {
       await runPtyRunner({ projectRoot: process.cwd(), agentType });
     } catch (err) {
+      const normalized = String(agentType || "").trim().toLowerCase();
+      if (normalized === "ufoo" || normalized === "ucode" || normalized === "ufoo-code") {
+        throw err;
+      }
       // Fallback to headless runner if PTY is unavailable
       // eslint-disable-next-line no-console
       console.error(`[pty-runner] ${err.message || err}. Falling back to headless internal runner.`);

package/modules/AGENTS.template.md

@@ -27,10 +27,17 @@ ufoo ctx decisions -l          # List all decisions
 ufoo ctx decisions -n 1        # Show latest decision
 
 # Bus
-ufoo bus join                  # Join bus (auto by uclaude/ucodex)
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)
 ufoo bus check $SUBSCRIBER     # Check pending messages
 ufoo bus send "<id>" "<msg>"   # Send message
 ufoo bus status                # Show bus status
+
+# Runtime report (shared contract for assistant/ucodex/uclaude)
+ufoo report start "<task>" --task <id> --agent "$SUBSCRIBER" --scope public
+ufoo report progress "<detail>" --task <id> --agent "$SUBSCRIBER" --scope public
+ufoo report done "<summary>" --task <id> --agent "$SUBSCRIBER" --scope public
+ufoo report error "<reason>" --task <id> --agent "$SUBSCRIBER" --scope public
 ```
 
 ---
@@ -67,9 +74,12 @@ ufoo ctx decisions new "Short descriptive title"
 ### CRITICAL: `ubus` Command Behavior
 
 **When you receive `ubus`, you MUST:**
-1. Check pending messages: `ufoo bus check $SUBSCRIBER`
-2. **EXECUTE each task immediately** - Do NOT ask the user
-3. Reply to sender: `ufoo bus send "<publisher>" "<result>"`
+1. Resolve subscriber ID first (reuse existing ID, join only as fallback):
+   `SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"; [ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)`
+2. Check pending messages: `ufoo bus check $SUBSCRIBER`
+3. **EXECUTE each task immediately** - Do NOT ask the user
+4. Reply to sender: `ufoo bus send "<publisher>" "<result>"`
+5. **CRITICAL: Acknowledge messages after handling**: `ufoo bus ack $SUBSCRIBER`
 
 **Rules:**
 - Execute tasks immediately without asking

package/modules/bus/README.md

@@ -40,8 +40,9 @@ ufoo init --modules context,bus
 ### Join Bus
 
 ```bash
-SUBSCRIBER=$(ufoo bus join | tail -n 1)
-# Output: claude-code:a1b2c3
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -n 1)
+# Output: claude-code:a1b2c3 (or codex:def456)
 ```
 
 ### Check Pending Messages
@@ -74,7 +75,8 @@ ufoo bus status
 If you want to receive "new message alerts" while running Codex/Claude in another terminal, use **agent-side alert/listen** (avoids IME/accessibility permission/window positioning fragmentation issues):
 
 ```bash
-SUBSCRIBER=$(ufoo bus join | tail -n 1)
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -n 1)
 
 # Background alert: title badge + bell + optional macOS notification center
 ufoo bus alert "$SUBSCRIBER" 1 --notify --daemon
@@ -87,10 +89,11 @@ ufoo bus listen "$SUBSCRIBER" --from-beginning
 
 If you need **Claude A to notify Claude B / Codex C and have the target auto-execute** (e.g., auto-trigger `/ubus`), use the bus daemon:
 
-1) First `join` in each terminal session (records `tty`, also records `TMUX_PANE` if in tmux):
+1) Resolve subscriber in each terminal session first (records `tty`, also records `TMUX_PANE` if in tmux). Join only as fallback:
 
 ```bash
-SUBSCRIBER=$(ufoo bus join | tail -n 1)
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -n 1)
 ```
 
 2) Start the bus daemon in the project (runs as background daemon):

package/modules/bus/SKILLS/ubus/SKILL.md

@@ -34,9 +34,9 @@ fi
 **IMPORTANT**: Always check for existing subscriber ID first to avoid creating duplicates.
 
 ```bash
-# Check environment variable first (set by launcher/daemon)
-if [ -n "$UFOO_SUBSCRIBER_ID" ]; then
-  SUBSCRIBER="$UFOO_SUBSCRIBER_ID"
+# Reuse existing subscriber first (env -> whoami), join only if missing
+SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
+if [ -n "$SUBSCRIBER" ]; then
   echo "Using existing subscriber ID: $SUBSCRIBER"
 else
   # Not launched via uclaude/ucodex, need to join manually
@@ -48,7 +48,8 @@ fi
 
 **Why this matters**:
 - `uclaude`/`ucodex` automatically set `UFOO_SUBSCRIBER_ID` during launch
-- Re-joining creates a new ID, causing message loss
+- `ufoo bus whoami` can recover current ID even when env is missing
+- Re-joining may create identity drift and message routing issues
 - Always reuse existing ID when available
 
 To join with a custom nickname:

package/modules/context/SKILLS/uctx/SKILL.md

@@ -40,17 +40,19 @@ Create a new decision (recommended before replying when required):
 ufoo ctx decisions new "Short Title"
 ```
 
-**File naming:** `NNNN-short-title.md` (4-digit prefix + kebab-case slug).
+**File naming:** `NNNN-<nickname>-short-title.md` (4-digit prefix + nickname + kebab-case slug).
 
 **Template for new decisions:**
 ```yaml
 ---
 status: open
+nickname: <nickname>
 ---
 # DECISION NNNN: <Title>
 
 Date: YYYY-MM-DD
 Author: <agent>
+Nickname: <nickname>
 
 Context:
 What led to this decision?

package/modules/online/SKILLS/ufoo-online/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: ufoo-online
+description: |
+  Connect any agent to the ufoo-online WebSocket relay for public channel chat,
+  public rooms, or private room collaboration. Use when users ask to join ufoo online,
+  chat with other agents, or check inbox.
+---
+
+# /ufoo-online - Online Relay Client
+
+Connect to the ufoo-online WebSocket relay, join channels/rooms, send messages, and check inbox.
+
+## Quick Start
+
+### 1. Start a local relay server
+
+```bash
+ufoo online server --port 8787
+```
+
+### 2. Connect (long-running, run in background)
+
+```bash
+# Join a public channel
+ufoo online connect --nickname my-agent --join lobby --ping-ms 15000
+
+# Join a private room (enables bus/decisions/wake sync)
+ufoo online connect --nickname my-agent --room room_001 --room-password secret --ping-ms 15000
+```
+
+Use `run_in_background: true` to keep the connection alive in agent sessions.
+
+### 3. Send a message
+
+```bash
+# Send to a channel
+ufoo online send --nickname my-agent --channel lobby --text "hello everyone"
+
+# Send to a room
+ufoo online send --nickname my-agent --room room_001 --text "hello team"
+```
+
+Messages are queued to the local outbox (`~/.ufoo/online/outbox/<nickname>.jsonl`)
+and delivered by the running `connect` process. The connect process must be running
+for messages to be sent.
+
+### 4. Check inbox
+
+```bash
+# View all messages
+ufoo online inbox my-agent
+
+# View unread only
+ufoo online inbox my-agent --unread
+
+# Clear inbox
+ufoo online inbox my-agent --clear
+```
+
+Inbox retention: channel messages 7 days, room messages 30 days.
+
+## Full Connect Options
+
+```bash
+ufoo online connect --nickname <name> [--url <ws://...>] [--subscriber <id>]
+  [--token <tok>] [--token-hash <hash>] [--world <name>] [--ping-ms <ms>]
+  [--join <channel>] [--room <room-id> --room-password <pwd>]
+  [--interval <ms>] [--allow-insecure-ws]
+  [--trust-remote] [--allow-from <subscriberId>]
+```
+
+Features:
+- Auto-reconnect with exponential backoff (500ms -> 8s)
+- Auto-generates token if none exists; persists to `~/.ufoo/online/tokens.json`
+- Incoming messages saved to `~/.ufoo/online/inbox/<nickname>.jsonl`
+- Polls outbox for queued sends
+- Prints all messages to stdout as JSON; prints `CONNECTED` on handshake
+- Non-local `ws://` is blocked by default; use `wss://` or `--allow-insecure-ws`.
+- **Private room mode** (`--room`): bus/decisions/wake sync is gated; use
+  `--trust-remote` or `--allow-from` to allow inbound sync.
+
+## Server Management
+
+```bash
+# Start relay (dev mode — any token accepted)
+ufoo online server --port 8787
+
+# Start with token validation
+ufoo online server --port 8787 --token-file ~/.ufoo/online/tokens.json
+
+# Custom host/idle timeout
+ufoo online server --host 0.0.0.0 --port 8787 --idle-timeout 60000
+```
+
+## Token Management
+
+```bash
+ufoo online token <subscriber-id> --nickname <name> [--server <url>]
+```
+
+Tokens are stored in `~/.ufoo/online/tokens.json`. The connect command
+auto-resolves tokens by subscriber ID or nickname lookup.
+
+## Room & Channel Management
+
+```bash
+# Channels (public broadcast, can join multiple)
+ufoo online channel list [--server <url>]
+ufoo online channel create --name <name> [--type world|public] [--server <url>]
+
+# Rooms (collaboration, can join one)
+ufoo online room list [--server <url>]
+ufoo online room create --type public|private [--name <room>] [--password <pwd>] [--server <url>]
+```
+
+If the relay requires auth, pass `--auth-token <token>` (or `--token-file` +
+`--subscriber`/`--nickname`) to room/channel commands to send the Bearer token.
+
+## Usage Scenarios
+
+### 1. Public channel chat
+
+```bash
+ufoo online server --port 8787                          # Terminal 1
+ufoo online connect --nickname agent-a --join lobby     # Terminal 2 (background)
+ufoo online connect --nickname agent-b --join lobby     # Terminal 3 (background)
+ufoo online send --nickname agent-a --channel lobby --text "hi all"
+ufoo online inbox agent-b                               # See agent-a's message
+```
+
+### 2. Private room collaboration
+
+```bash
+ufoo online room create --type private --password secret --server http://127.0.0.1:8787
+# → returns room_id
+
+ufoo online connect --nickname dev-1 --room room_001 --room-password secret
+ufoo online connect --nickname dev-2 --room room_001 --room-password secret
+```
+
+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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.0.6",
+  "version": "1.1.9",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -18,11 +18,16 @@
   "bin": {
     "ufoo": "bin/ufoo.js",
     "uclaude": "bin/uclaude.js",
-    "ucodex": "bin/ucodex.js"
+    "ucodex": "bin/ucodex.js",
+    "ucode": "bin/ucode.js",
+    "ucode-core": "bin/ucode-core.js",
+    "ufoo-assistant-agent": "bin/ufoo-assistant-agent.js",
+    "ufoo-engine": "bin/ufoo-engine.js"
   },
   "files": [
     "bin/",
     "src/",
+    "online/",
     "scripts/",
     "SKILLS/",
     "modules/",
@@ -35,6 +40,7 @@
   },
   "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"
@@ -44,7 +50,10 @@
     "chalk": "^4.1.2",
     "commander": "^13.1.0",
     "gray-matter": "^4.0.3",
-    "node-pty": "^1.1.0"
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0",
+    "xterm-addon-serialize": "^0.11.0",
+    "xterm-headless": "^5.3.0"
   },
   "devDependencies": {
     "jest": "^30.2.0"