metame-cli 1.5.2 → 1.5.4

package/README.md

@@ -26,15 +26,17 @@ curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bas
 
 ---
 
-> ### 🚀 v1.5.0 — Dynamic Engine Default + Distill Coupling
+> ### 🚀 v1.5.4 — Agent Soul Layer Auto-Repair & Intent Engine
 >
+> - **Cross-device dispatch**: Team members can run on remote machines. Add `peer: windows` to a member and messages route automatically via a Feishu relay chat — HMAC-signed, dedup-protected, zero manual routing.
+> - **`/dispatch peers`**: View remote dispatch config, relay chat, and all remote team members from mobile.
+> - **`dispatch_to peer:project`**: Dispatch tasks to remote peers from CLI, admin commands, or Claude sessions.
+> - **Unified team dispatch**: Shared `team-dispatch.js` module — single source of truth for project/member resolution, roster hints, and prompt enrichment.
+> - **Team broadcast**: Real-time cross-agent visibility in shared group chats with nickname routing and sticky follow.
+> - **Unified intent engine**: Config-driven intent dispatcher replacing standalone hooks for team communication, ops assist, and task creation.
+> - **Modular agent wizards**: New streamlined CLI flows for creating teams and cloning agents.
 > - **Dynamic default engine**: auto-detects installed CLI (claude/codex) at startup; pure-codex users work out of the box with zero config.
-> - **`/engine` command**: switch global default engine from mobile (`/engine codex`), with three-layer priority: `project.engine > /engine setting > auto-detect`.
-> - **Engine–distill coupling**: switching engine auto-pairs the distill model (claude→haiku, codex→gpt-5.1-codex-mini) and distill binary.
-> - **Engine-aware distill**: `callDistillModel` now routes through the correct CLI binary and parses codex JSON stream output.
-> - **`/doctor` engine checks**: health check now validates CLI availability against the configured default engine.
 > - **Multi-engine runtime adapter**: daemon supports engine routing by project (`project.engine`) with shared execution flow for Claude/Codex.
-> - **Codex session continuity**: supports `exec`/`resume`, thread id backfill, one-shot resume fallback, and auth/rate-limit error mapping.
 > - **Mentor mode hooks**: pre-flight emotion breaker, context-time mentor prompt, and post-flight reflection debt registration.
 > - **Multi-user ACL**: role-based permissions (admin / member / stranger) with binding protection.
 > - **Windows native support**: cross-platform path handling, Named Pipes IPC, GBK-safe encoding.
@@ -316,6 +318,8 @@ systemctl --user start metame
 | **Auto-Provisioning** | First run deploys default CLAUDE.md, documentation, and `dispatch_to` to `~/.metame/`. Subsequent runs sync scripts without overwriting user config. |
 | **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (5 tasks: distill + memory + skills + nightly reflection + memory index). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
 | **Multi-Agent** | Multiple projects with dedicated chat groups. `/agent bind` for one-tap setup. True parallel execution. |
+| **Team Routing** | Project-level team clones: multiple AI agents work in parallel within a single chat group. Nickname routing, sticky follow, `/stop` per member, broadcast visibility. |
+| **Cross-Device Dispatch** | Team members can run on different machines. `member.peer` marks remote agents — messages route via a Feishu relay chat with HMAC-SHA256 signing and 5-minute TTL dedup. `/dispatch peers` to view config, `dispatch_to peer:project` for explicit routing. |
 | **Browser Automation** | Built-in Playwright MCP. Browser control out of the box for every user. |
 | **Cross-Platform** | Native support for macOS and Windows. Platform abstraction layer handles spawn, IPC, process management, and terminal encoding automatically. |
 | **Provider Relay** | Route through any Anthropic-compatible API. Use GPT-4, DeepSeek, Gemini — zero config file mutation. |
@@ -416,6 +420,63 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 ~/.metame/bin/dispatch_to coder "Run the test suite and report results"
 ```
 
+## Team Routing
+
+MetaMe supports project-level team clones — multiple AI agents (digital twins) sharing the same workspace, working in parallel within a single Feishu group. Team members can run locally or on remote machines.
+
+### Configuration
+
+Add a `team` array and `broadcast: true` under any project in `daemon.yaml`:
+
+```yaml
+projects:
+  metame:
+    name: 超级总管 Jarvis
+    icon: 🤖
+    broadcast: true
+    team:
+      - key: jia
+        name: Jarvis · 甲
+        icon: 🤖
+        color: green
+        cwd: ~/AGI/MetaMe
+        nicknames:
+          - 甲
+        auto_dispatch: true
+      - key: hunter
+        name: 猎手
+        icon: 🎯
+        peer: windows            # runs on another machine
+        nicknames:
+          - 猎手
+```
+
+### Key Features
+
+- **Nickname routing**: mention a member by nickname (e.g. "乙 check this") to route directly to them
+- **Sticky follow**: once you address a member, subsequent messages without a nickname continue going to the same member
+- **`/stop` precision**: `/stop 乙` stops a specific member; `/stop` stops the sticky member; reply-quote `/stop` stops the quoted member
+- **Auto-dispatch**: when the main agent is busy, messages are automatically routed to idle `auto_dispatch` members
+- **Broadcast**: with `broadcast: true`, inter-member `dispatch_to` messages are shown as cards in the group chat
+- **Cross-device members**: add `peer: <device>` to a team member — messages route via a Feishu relay chat with HMAC signing and dedup protection
+
+Each team member runs on a virtual chatId (`_agent_{key}`) and appears with its own card title (e.g. `🤖 Jarvis · 乙`).
+
+### Cross-Device Dispatch
+
+Team members with `peer` field run on a different machine. Configure `feishu.remote_dispatch` on both machines with the same relay chat and shared secret:
+
+```yaml
+feishu:
+  remote_dispatch:
+    enabled: true
+    self: mac                  # unique peer name per machine
+    chat_id: oc_relay_xxx      # shared relay group
+    secret: shared-secret-key  # HMAC signing key
+```
+
+Use from mobile: `/dispatch to windows:hunter research competitors` or just mention by nickname — routing is automatic. Use `/dispatch peers` to check remote config status.
+
 ## Mobile Commands
 
 | Command | Action |
@@ -433,7 +494,14 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | `/distill-model` | Show/update background distill model (default: `haiku`) |
 | `/mentor` | Mentor mode control: on/off/level/status |
 | `/activate` | Activate and bind the most recently created pending agent in a new group |
+| `/agent new` | Interactive wizard to create a new agent |
+| `/agent new team` | Team wizard: create multiple parallel agent clones under a project |
+| `/agent new clone` | Clone wizard: create a clone sharing the current agent's role |
 | `/agent bind <name> [dir]` | Manually register group as dedicated agent |
+| `/agent soul repair` | Idempotent rebuild of agent soul layer (links SOUL.md / MEMORY.md) |
+| `/msg <agent> <message>` | Send a direct message to a team member or agent (e.g. `/msg 乙 check this`) |
+| `/broadcast [on\|off]` | Toggle team broadcast for the current project (show inter-agent dispatches as cards) |
+| `/stop <nickname>` | Stop a specific team member (e.g. `/stop 乙`) |
 | `/mac` | macOS control helper: permissions check/open + AppleScript/JXA execution |
 | `/sh <cmd>` | Raw shell — bypasses Claude |
 | `/memory` | Memory stats: fact count, session tags, DB size |
@@ -444,6 +512,8 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | `/user list` | List all configured users |
 | `/user remove <open_id>` | Remove a user |
 | `/sessions` | Browse recent sessions with last message preview |
+| `/dispatch peers` | View remote dispatch configuration and remote team members |
+| `/dispatch to <target> <prompt>` | Dispatch task to agent or remote peer (`peer:project` format supported) |
 | `/teamtask create <agent> <goal>` | Create a cross-agent collaboration task |
 | `/teamtask` | List recent TeamTasks (last 10) |
 | `/teamtask <task_id>` | View task detail |
@@ -470,8 +540,9 @@ Level mapping:
 
 ## Hook Optimizations (Default On)
 
-MetaMe installs and maintains two core Claude hooks automatically on launch:
+MetaMe installs and maintains core Claude hooks automatically on launch:
 
+- `UserPromptSubmit` hook (`scripts/hooks/intent-engine.js`): Unified intent engine for team dispatch, ops assist, and task creation hints.
 - `UserPromptSubmit` hook (`scripts/signal-capture.js`): captures high-signal preference/task traces with layered filtering.
 - `Stop` hook (`scripts/hooks/stop-session-capture.js`): records session-end/tool-failure signals with watermark protection.
 
@@ -481,7 +552,7 @@ If hook installation fails, MetaMe logs and continues the session (non-blocking
 
 ```
 ┌─────────────┐     Telegram/Feishu      ┌──────────────────────────────┐
-│  Your Phone  │ ◄──────────────────────► │   MetaMe Daemon              │
+│  Your Phone  │ ◄──────────────────────► │   MetaMe Daemon (Mac)        │
 └─────────────┘                           │   (your machine, 24/7)       │
                                           │                              │
                                           │   ┌──────────────┐           │
@@ -490,18 +561,20 @@ If hook installation fails, MetaMe logs and continues the session (non-blocking
                                           │   └──────────────┘           │
                                           │                              │
                                           │   ~/.claude_profile          │
-                                          │   (6-dim soul schema)        │
-                                          │                              │
                                           │   ~/.metame/memory.db        │
-                                          │   session_tags.json          │
-                                          │   (5-layer memory)           │
-                                          │                              │
                                           │   dispatch_to (auto-deployed)│
+                                          └──────────┬───────────────────┘
+                                                     │
+                                          ┌──────────▼───────────────────┐
+                                          │   Feishu Relay Chat          │
+                                          │   (HMAC-signed packets)      │
+                                          └──────────┬───────────────────┘
+                                                     │
+                                          ┌──────────▼───────────────────┐
+                                          │   MetaMe Daemon (Windows)    │
+                                          │   peer: "windows"            │
+                                          │   Remote team members here   │
                                           └──────────────────────────────┘
-                                                       ↑
-                                          idle → summaries + memory tasks
-                                          01:00 → nightly reflection
-                                          01:30 → memory index rebuild
 ```
 
 - **Profile** (`~/.claude_profile.yaml`): 6-dimension soul schema. Injected into every Claude session via `CLAUDE.md`.

package/index.js

@@ -83,8 +83,15 @@ if (!fs.existsSync(METAME_DIR)) {
 // DEPLOY PHASE: sync scripts, docs, bin to ~/.metame/
 // ---------------------------------------------------------
 
+// Dev mode: when running from git repo, symlink instead of copy.
+// This ensures source files and runtime files are always the same,
+// preventing agents from accidentally editing copies instead of source.
+const IS_DEV_MODE = fs.existsSync(path.join(__dirname, '.git'));
+
 /**
- * Sync files from srcDir to destDir. Only writes when content differs.
+ * Sync files from srcDir to destDir.
+ * - Dev mode (git repo): creates symlinks so source === runtime.
+ * - Production (npm install): copies files, only writes when content differs.
  * @param {string} srcDir - source directory
  * @param {string} destDir - destination directory
  * @param {object} [opts]
@@ -102,12 +109,35 @@ function syncDirFiles(srcDir, destDir, { fileList, chmod } = {}) {
     const dest = path.join(destDir, f);
     try {
       if (!fs.existsSync(src)) continue;
-      const srcContent = fs.readFileSync(src, 'utf8');
-      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
-      if (srcContent !== destContent) {
-        fs.writeFileSync(dest, srcContent, 'utf8');
-        if (chmod) try { fs.chmodSync(dest, chmod); } catch { /* Windows */ }
-        updated = true;
+
+      if (IS_DEV_MODE) {
+        // Dev mode: symlink dest → src (replace copy/stale symlink if needed)
+        const srcReal = fs.realpathSync(src);
+        let needLink = true;
+        try {
+          const existing = fs.lstatSync(dest);
+          if (existing.isSymbolicLink()) {
+            if (fs.realpathSync(dest) === srcReal) needLink = false;
+            else fs.unlinkSync(dest);
+          } else {
+            // Replace regular file with symlink
+            fs.unlinkSync(dest);
+          }
+        } catch { /* dest doesn't exist */ }
+        if (needLink) {
+          fs.symlinkSync(srcReal, dest);
+          if (chmod) try { fs.chmodSync(dest, chmod); } catch { /* Windows */ }
+          updated = true;
+        }
+      } else {
+        // Production: copy when content differs
+        const srcContent = fs.readFileSync(src, 'utf8');
+        const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
+        if (srcContent !== destContent) {
+          fs.writeFileSync(dest, srcContent, 'utf8');
+          if (chmod) try { fs.chmodSync(dest, chmod); } catch { /* Windows */ }
+          updated = true;
+        }
       }
     } catch { /* non-fatal per file */ }
   }
@@ -168,7 +198,7 @@ if (syntaxErrors.length > 0) {
   // and has defer logic (waits for active Claude tasks to finish before restarting).
   // Killing here bypasses that and interrupts ongoing conversations.
   if (scriptsUpdated) {
-    console.log(`${icon("pkg")} Scripts synced to ~/.metame/ — daemon will auto-restart when idle.`);
+    console.log(`${icon("pkg")} Scripts ${IS_DEV_MODE ? 'symlinked' : 'synced'} to ~/.metame/ — daemon will auto-restart when idle.`);
   }
 }
 
@@ -217,6 +247,7 @@ if (fs.existsSync(bundledSkillsDir)) {
   }
 }
 
+
 // Ensure ~/.codex/skills and ~/.agents/skills are symlinks to ~/.claude/skills
 // This keeps skill evolution unified across all engines.
 for (const altDir of [
@@ -348,6 +379,41 @@ function ensureHookInstalled() {
       console.log(`${icon("hook")} MetaMe: Stop session capture hook installed.`);
     }
 
+    // Migrate: remove standalone team-context.js hook (superseded by intent-engine)
+    if (settings.hooks?.UserPromptSubmit) {
+      const before = settings.hooks.UserPromptSubmit.length;
+      for (const entry of settings.hooks.UserPromptSubmit) {
+        if (entry.hooks) {
+          entry.hooks = entry.hooks.filter(h => !(h.command && h.command.includes('team-context.js')));
+        }
+      }
+      settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
+        entry => entry.hooks && entry.hooks.length > 0
+      );
+      if (settings.hooks.UserPromptSubmit.length !== before) modified = true;
+    }
+
+    // Ensure intent-engine hook (unified intent detection + hint injection)
+    const intentEngineScript = path.join(METAME_DIR, 'hooks', 'intent-engine.js').replace(/\\/g, '/');
+    const intentEngineCommand = `node "${intentEngineScript}"`;
+    const intentEngineInstalled = (settings.hooks?.UserPromptSubmit || []).some(entry =>
+      entry.hooks?.some(h => h.command && h.command.includes('intent-engine.js'))
+    );
+
+    if (!intentEngineInstalled) {
+      if (!settings.hooks) settings.hooks = {};
+      if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+
+      settings.hooks.UserPromptSubmit.push({
+        hooks: [{
+          type: 'command',
+          command: intentEngineCommand,
+        }]
+      });
+      modified = true;
+      console.log(`${icon("hook")} MetaMe: Intent engine hook installed.`);
+    }
+
     if (modified) {
       fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), 'utf8');
     }
@@ -872,26 +938,11 @@ const KERNEL_BODY = PROTOCOL_NORMAL
   .replace(/^<!-- METAME:START -->\n/, '')  // remove project-level marker
   .trimEnd();
 
+// Most capability hints migrated to intent engine (on-demand injection).
+// Only keep Skills here — it's a fallback behavior that can't be keyword-matched.
 const CAPABILITY_SECTIONS = [
-  '## Agent Dispatch',
-  '识别到"告诉X/让X/通知X"等转发意图时 → 先 `cat ~/.metame/docs/dispatch-table.md` 获取路由表（昵称→project_key），再执行转发。不要凭记忆猜测昵称对应关系。',
-  '',
-  '## Agent 创建与管理',
-  '用户问创建/管理/绑定 Agent 时 → 先 `cat ~/.metame/docs/agent-guide.md` 再回答。',
-  '用户问代码结构/升级进度/脚本入口时 → 先 `cat ~/.metame/docs/pointer-map.md` 再回答。',
-  '',
-  '## 手机端文件交互',
-  '用户要文件（"发给我"/"发过来"/"导出"）→ 先 `cat ~/.metame/docs/file-transfer.md` 再执行。',
-  '**收**：用户发图片/文件自动存到 `upload/`，用 Read 查看。',
-  '**发**：回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发手机。不要读内容再复述。',
-  '',
-  '## 跨会话记忆',
-  '用户提"上次/之前"时搜索：`node ~/.metame/memory-search.js "关键词1" "keyword2"`',
-  '一次传 3-4 个关键词（中文+英文+函数名），`--facts` 只搜事实，`--sessions` 只搜会话。',
-  '',
   '## Skills',
   '能力不足/工具缺失/任务失败 → 先查 `cat ~/.claude/skills/skill-manager/SKILL.md`，不要自己猜。',
-
 ].join('\n');
 
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.2",
+    "version": "1.5.4",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/bin/dispatch_to

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
 /**
- * dispatch_to [--new] [--from <project_key>] <project_key> "<prompt>"
+ * dispatch_to [--new] [--from <project_key>] [--team] <project_key> "<prompt>"
+ *
+ * --team: broadcast to all members of the named project team.
+ *         Each member receives the full task + a team roster hint so they know
+ *         who their teammates are and how to dispatch_to them.
+ *
  * Tries Unix socket / Named Pipe first (low-latency), falls back to pending.jsonl.
  */
 'use strict';
@@ -10,124 +15,196 @@ const net = require('net');
 const crypto = require('crypto');
 const os = require('os');
 const { socketPath } = require('../platform');
+const yaml = require('../resolve-yaml');
+const { buildEnrichedPrompt, buildTeamRosterHint } = require('../team-dispatch');
+const { parseRemoteTargetRef, normalizeRemoteDispatchConfig, encodePacket } = require('../daemon-remote-dispatch');
 
+const METAME_DIR = path.join(os.homedir(), '.metame');
+const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
+const PENDING = path.join(DISPATCH_DIR, 'pending.jsonl');
+const DISPATCH_SECRET_FILE = path.join(METAME_DIR, '.dispatch_secret');
+const SOCK_PATH = socketPath(METAME_DIR);
+
+// ── Parse flags ──────────────────────────────────────────────────────────────
 const args = process.argv.slice(2);
 const newSession = args[0] === '--new' ? (args.shift(), true) : false;
 
-// --from <project_key>: identifies the calling agent for callback routing
-let fromKey = '_claude_session';
+let fromKey = process.env.METAME_PROJECT || '_claude_session';
 const fromIdx = args.indexOf('--from');
 if (fromIdx !== -1 && args[fromIdx + 1]) {
   fromKey = args.splice(fromIdx, 2)[1];
 }
 
+const teamMode = args[0] === '--team' ? (args.shift(), true) : false;
+
 const [target, ...rest] = args;
 const prompt = rest.join(' ').replace(/^["']|["']$/g, '');
+
 if (!target || !prompt) {
-  console.error('Usage: dispatch_to [--new] [--from <project_key>] <project_key> "<prompt>"');
+  console.error(
+    'Usage: dispatch_to [--new] [--from <key>] [--team] <project_key> "<prompt>"\n' +
+    '       --team: broadcast to all members of the named project team'
+  );
   process.exit(1);
 }
 
-const METAME_DIR = path.join(os.homedir(), '.metame');
-const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
-const PENDING = path.join(DISPATCH_DIR, 'pending.jsonl');
-const DISPATCH_SECRET_FILE = path.join(METAME_DIR, '.dispatch_secret');
-const SOCK_PATH = socketPath(METAME_DIR);
-
+// ── Shared helpers ────────────────────────────────────────────────────────────
 function getDispatchSecret() {
   try {
     if (fs.existsSync(DISPATCH_SECRET_FILE)) {
       return fs.readFileSync(DISPATCH_SECRET_FILE, 'utf8').trim();
     }
-  } catch { /* fall through to generate */ }
+  } catch { /* fall through */ }
   const secret = crypto.randomBytes(32).toString('hex');
-  try {
-    fs.writeFileSync(DISPATCH_SECRET_FILE, secret, { mode: 0o600 });
-  } catch { /* ignore write errors */ }
+  try { fs.writeFileSync(DISPATCH_SECRET_FILE, secret, { mode: 0o600 }); } catch {}
   return secret;
 }
 
-const ts = new Date().toISOString();
-const secret = getDispatchSecret();
-
-// Auto-inject shared context: now/shared.md + target's _latest.md
-function buildEnrichedPrompt(rawPrompt) {
-  const nowFile = path.join(METAME_DIR, 'memory', 'now', 'shared.md');
-  const agentFile = path.join(METAME_DIR, 'memory', 'agents', `${target}_latest.md`);
-  let ctx = '';
-  try { if (fs.existsSync(nowFile)) ctx += `[共享进度 now.md]\n${fs.readFileSync(nowFile, 'utf8').trim()}\n\n`; } catch {}
-  try { if (fs.existsSync(agentFile)) ctx += `[${target} 上次产出]\n${fs.readFileSync(agentFile, 'utf8').trim()}\n\n`; } catch {}
-  // Push model: inject unread inbox messages and immediately archive them
-  try {
-    const inboxDir = path.join(METAME_DIR, 'memory', 'inbox', target);
-    const readDir = path.join(inboxDir, 'read');
-    const files = fs.readdirSync(inboxDir).filter(f => f.endsWith('.md')).sort();
-    if (files.length > 0) {
-      ctx += `[📬 Agent Inbox — ${files.length} 条未读消息]\n`;
-      fs.mkdirSync(readDir, { recursive: true });
-      for (const f of files) {
-        const filePath = path.join(inboxDir, f);
-        ctx += fs.readFileSync(filePath, 'utf8').trim() + '\n---\n';
-        fs.renameSync(filePath, path.join(readDir, f));
-      }
-      ctx += '\n';
+function sendOne(memberTarget, memberPrompt, opts = {}) {
+  return new Promise((resolve) => {
+    const ts = new Date().toISOString();
+    const secret = getDispatchSecret();
+    const enriched = opts.skipEnrich ? memberPrompt : buildEnrichedPrompt(memberTarget, memberPrompt, METAME_DIR);
+    const sigPayload = JSON.stringify({ target: memberTarget, prompt: enriched, ts });
+    const sig = crypto.createHmac('sha256', secret).update(sigPayload).digest('hex');
+
+    const callback = fromKey !== '_claude_session';
+    const msg = {
+      target: memberTarget,
+      prompt: enriched,
+      from: fromKey,
+      new_session: newSession,
+      created_at: ts,
+      ts,
+      sig,
+      team_roster_injected: opts.team_roster_injected || false,
+      ...(callback && { callback: true }),
+    };
+
+    // Ensure target inbox dir
+    fs.mkdirSync(path.join(METAME_DIR, 'memory', 'inbox', memberTarget, 'read'), { recursive: true });
+
+    function fallback() {
+      fs.mkdirSync(DISPATCH_DIR, { recursive: true });
+      fs.appendFileSync(PENDING, JSON.stringify(msg) + '\n');
+      console.log(`DISPATCH_OK(file): ${memberTarget} → ${memberPrompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+      resolve();
     }
-  } catch {}
-  return ctx ? `${ctx}---\n${rawPrompt}` : rawPrompt;
-}
-
-const enrichedPrompt = buildEnrichedPrompt(prompt);
-const sigPayload = JSON.stringify({ target, prompt: enrichedPrompt, ts });
-const sig = crypto.createHmac('sha256', secret).update(sigPayload).digest('hex');
 
-// Set callback: true when dispatched by another agent (not a user session)
-const callback = fromKey !== '_claude_session';
-const msg = { target, prompt: enrichedPrompt, from: fromKey, new_session: newSession, created_at: ts, ts, sig, ...(callback && { callback: true }) };
-
-// Ensure target's inbox exists — lazy init, safe for new users and new agents
-fs.mkdirSync(path.join(METAME_DIR, 'memory', 'inbox', target, 'read'), { recursive: true });
+    const sock = net.createConnection({ path: SOCK_PATH });
+    let done = false;
+
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      sock.destroy();
+      fallback();
+    }, 2000);
+
+    sock.on('connect', () => { sock.write(JSON.stringify(msg)); sock.end(); });
+    sock.on('data', (data) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try {
+        const res = JSON.parse(data.toString().trim());
+        if (res.ok) {
+          console.log(`DISPATCH_OK(socket): ${memberTarget} → ${memberPrompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+        } else {
+          fallback();
+          return;
+        }
+      } catch { fallback(); return; }
+      sock.destroy();
+      resolve();
+    });
+    sock.on('error', () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      fallback();
+    });
+  });
+}
 
-function fallbackToFile() {
+// ── Remote dispatch helpers ───────────────────────────────────────────────────
+function sendRemoteViaRelay(peer, project, memberPrompt) {
+  let config;
+  try {
+    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8'));
+  } catch (e) {
+    console.error(`dispatch_to: failed to load daemon.yaml: ${e.message}`);
+    process.exit(1);
+  }
+  const rd = normalizeRemoteDispatchConfig(config);
+  if (!rd) {
+    console.error('dispatch_to: feishu.remote_dispatch not configured or disabled');
+    process.exit(1);
+  }
+  const ts = new Date().toISOString();
+  const id = `${rd.selfPeer}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const body = encodePacket({
+    v: 1, id, ts,
+    type: 'task',
+    from_peer: rd.selfPeer,
+    to_peer: peer,
+    target_project: project,
+    prompt: memberPrompt,
+    source_sender_key: fromKey,
+  }, rd.secret);
+
+  // Write to dispatch/remote-pending.jsonl for daemon to pick up and send via bot
+  const remotePending = path.join(DISPATCH_DIR, 'remote-pending.jsonl');
   fs.mkdirSync(DISPATCH_DIR, { recursive: true });
-  fs.appendFileSync(PENDING, JSON.stringify(msg) + '\n');
-  console.log(`DISPATCH_OK(file): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
+  fs.appendFileSync(remotePending, JSON.stringify({ relay_chat_id: rd.chatId, body }) + '\n');
+  console.log(`DISPATCH_OK(remote): ${peer}:${project} → ${memberPrompt.slice(0, 60)}`);
 }
 
-const sock = net.createConnection({ path: SOCK_PATH });
-let done = false;
-
-const timer = setTimeout(() => {
-  if (done) return;
-  done = true;
-  sock.destroy();
-  fallbackToFile();
-}, 2000);
-
-sock.on('connect', () => {
-  sock.write(JSON.stringify(msg));
-  sock.end();
-});
-
-sock.on('data', (data) => {
-  if (done) return;
-  done = true;
-  clearTimeout(timer);
+// ── Team broadcast mode ───────────────────────────────────────────────────────
+if (teamMode) {
+  let config = null;
   try {
-    const res = JSON.parse(data.toString().trim());
-    if (res.ok) {
-      console.log(`DISPATCH_OK(socket): ${target} → ${prompt.slice(0, 60)}${newSession ? ' [new session]' : ''}`);
-    } else {
-      fallbackToFile();
-    }
-  } catch {
-    fallbackToFile();
+    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8'));
+  } catch (e) {
+    console.error(`dispatch_to --team: failed to load daemon.yaml: ${e.message}`);
+    process.exit(1);
   }
-  sock.destroy();
-});
-
-sock.on('error', () => {
-  if (done) return;
-  done = true;
-  clearTimeout(timer);
-  fallbackToFile();
-});
+
+  const project = config && config.projects && config.projects[target];
+  if (!project) {
+    console.error(`dispatch_to --team: project "${target}" not found in daemon.yaml`);
+    process.exit(1);
+  }
+
+  const team = Array.isArray(project.team) ? project.team : [];
+  if (team.length === 0) {
+    console.error(`dispatch_to --team: project "${target}" has no team members`);
+    process.exit(1);
+  }
+
+  console.log(`📢 Team broadcast → ${target} (${team.length} members): ${prompt.slice(0, 60)}`);
+
+  // Await all dispatches before exiting so async socket/file ops complete
+  Promise.all(team.map((member) => {
+    const roster = buildTeamRosterHint(target, member.key, config.projects);
+    const enriched = buildEnrichedPrompt(member.key, prompt, METAME_DIR);
+    const memberPrompt = roster ? `${roster}\n\n---\n${enriched}` : enriched;
+    // Remote member → relay dispatch
+    if (member.peer) {
+      sendRemoteViaRelay(member.peer, member.key, memberPrompt);
+      return Promise.resolve();
+    }
+    return sendOne(member.key, memberPrompt, { team_roster_injected: true, skipEnrich: true });
+  })).then(() => process.exit(0));
+} else {
+
+// ── Normal single-target dispatch ─────────────────────────────────────────────
+const remoteTarget = parseRemoteTargetRef(target);
+if (remoteTarget) {
+  const enriched = buildEnrichedPrompt(remoteTarget.project, prompt, METAME_DIR);
+  sendRemoteViaRelay(remoteTarget.peer, remoteTarget.project, enriched);
+  process.exit(0);
+} else {
+  sendOne(target, prompt).then(() => process.exit(0));
+}
+}