openclaw-bridge 0.4.9 → 0.5.2

package/README.md

@@ -39,6 +39,20 @@ openclaw-bridge upgrade    # updates both plugin and CLI automatically
 
 **Prerequisites:** [openclaw-bridge-hub](https://www.npmjs.com/package/openclaw-bridge-hub) running on a server, PM2 installed globally (`npm install -g pm2`), Node.js 18+.
 
+## What's New in v0.5.1
+
+### Bug Fixes
+- **Conflict Rename Re-registration** — After agentId conflict rename, the plugin now re-registers with the new ID immediately. Previously, the old ID was deregistered but the new ID was not registered until the next heartbeat, leaving the agent invisible on Hub.
+- **Channel Auto-Detection** — Fixed `discordId` and `channels` always showing as `null` / `[]` on Hub. Root causes: (1) config path had no fallback when `OPENCLAW_CONFIG_PATH` env was unset, (2) `extractChannels()` treated `accounts` as Array instead of Record (always returned `[]`), (3) detection only ran on heartbeat tick, not at startup. All three fixed.
+- **WebSocket Reconnection** — Fixed reconnection stopping permanently if `new WebSocket()` threw synchronously (e.g., DNS failure). Now schedules retry in the catch block.
+- **Stable Machine ID** — `getMachineId()` now persists a stable ID to `~/.openclaw/.machine-id` instead of using `os.hostname()`. Prevents ghost nodes on Hub when macOS hostname changes (hostname vs LocalHostName mismatch).
+
+### v0.5.1 Bug 修复
+- **冲突重命名后重新注册** — agentId 冲突重命名后，现在立即用新 ID 重新注册。此前旧 ID 被注销但新 ID 要等下一次心跳才注册，导致 Hub 上看不到该节点。
+- **Channel 自动检测** — 修复 Hub 上 `discordId` 和 `channels` 始终显示为 `null` / `[]` 的问题。根因：(1) 没设 `OPENCLAW_CONFIG_PATH` 环境变量时 config 路径无 fallback，(2) `extractChannels()` 把 `accounts` 当数组解析（实际是对象），(3) 检测只在心跳 tick 运行不在启动时运行。三个问题全部修复。
+- **WebSocket 重连** — 修复 `new WebSocket()` 同步抛异常（如 DNS 解析失败）时重连永久停止的问题。
+- **稳定机器 ID** — `getMachineId()` 现在将稳定 ID 持久化到 `~/.openclaw/.machine-id`，不再依赖 `os.hostname()`。防止 macOS 主机名变化时 Hub 上产生幽灵节点。
+
 ## What's New in v0.4.0
 
 ### Multi-Device Support

package/dist/circuit-breaker.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectManager } from "./project-manager.js";
+import type { PluginLogger } from "./types.js";
+export interface CircuitBreakerResult {
+    allowed: boolean;
+    reason?: string;
+    level?: "soft" | "hard" | "project";
+}
+export declare class CircuitBreaker {
+    private pm;
+    private logger;
+    constructor(pm: ProjectManager, logger: PluginLogger);
+    /**
+     * Check and increment rounds for a task. Returns whether communication is allowed.
+     * This is the HARD enforcement layer — overrides PM judgment.
+     */
+    checkAndIncrement(projectId: string, taskId: string): CircuitBreakerResult;
+}

package/dist/circuit-breaker.js

@@ -0,0 +1,51 @@
+const HARD_LIMIT_PER_TASK = 15;
+const PROJECT_TOTAL_LIMIT = 30;
+export class CircuitBreaker {
+    pm;
+    logger;
+    constructor(pm, logger) {
+        this.pm = pm;
+        this.logger = logger;
+    }
+    /**
+     * Check and increment rounds for a task. Returns whether communication is allowed.
+     * This is the HARD enforcement layer — overrides PM judgment.
+     */
+    checkAndIncrement(projectId, taskId) {
+        const result = this.pm.incrementRounds(projectId, taskId);
+        if (!result)
+            return { allowed: true };
+        const project = this.pm.readProject(projectId);
+        // Hard per-task limit (15 rounds) — non-negotiable
+        if (result.hardLimit) {
+            this.logger.warn(`[circuit-breaker] HARD LIMIT: task ${taskId} in project ${projectId} hit ${result.task.rounds} rounds`);
+            this.pm.updateTaskStatus(projectId, taskId, "blocked", {
+                blockType: "dependency_failed",
+                blockReason: `Circuit breaker: task exceeded ${HARD_LIMIT_PER_TASK} rounds`,
+            });
+            return {
+                allowed: false,
+                reason: `Task ${taskId} force-stopped: exceeded ${HARD_LIMIT_PER_TASK} communication rounds. Human intervention required.`,
+                level: "hard",
+            };
+        }
+        // Project total limit (30 rounds)
+        if (project && project.totalRounds >= PROJECT_TOTAL_LIMIT) {
+            this.logger.warn(`[circuit-breaker] PROJECT LIMIT: project ${projectId} hit ${project.totalRounds} total rounds`);
+            return {
+                allowed: false,
+                reason: `Project "${project.name}" total communication exceeded ${PROJECT_TOTAL_LIMIT} rounds. Pausing for human review.`,
+                level: "project",
+            };
+        }
+        // Soft per-task limit (8 rounds) — warning, PM should handle
+        if (result.softLimit) {
+            return {
+                allowed: true,
+                reason: `Warning: task ${taskId} has reached ${result.task.rounds} rounds (soft limit: ${result.task.maxRounds})`,
+                level: "soft",
+            };
+        }
+        return { allowed: true };
+    }
+}

package/dist/config.d.ts

@@ -1,3 +1,9 @@
 import type { BridgeConfig } from "./types.js";
 export declare function parseConfig(raw: unknown): BridgeConfig;
+/**
+ * Returns a stable machine identifier.
+ * Persists a UUID to ~/.openclaw/.machine-id on first call so the ID
+ * survives hostname changes (common on macOS where hostname ≠ LocalHostName).
+ * Falls back to hostname() if the file cannot be written.
+ */
 export declare function getMachineId(): string;

package/dist/config.js

@@ -1,4 +1,7 @@
-import { hostname } from "node:os";
+import { hostname, homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 const DEFAULTS = {
     heartbeatIntervalMs: 30_000,
     offlineThresholdMs: 120_000,
@@ -59,6 +62,33 @@ export function parseConfig(raw) {
             : undefined,
     };
 }
+/**
+ * Returns a stable machine identifier.
+ * Persists a UUID to ~/.openclaw/.machine-id on first call so the ID
+ * survives hostname changes (common on macOS where hostname ≠ LocalHostName).
+ * Falls back to hostname() if the file cannot be written.
+ */
 export function getMachineId() {
-    return hostname();
+    const dir = join(homedir(), ".openclaw");
+    const idFile = join(dir, ".machine-id");
+    try {
+        const existing = readFileSync(idFile, "utf-8").trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        // File doesn't exist yet — generate one
+    }
+    // Use hostname as the base for readability, but append a short UUID suffix
+    // so renames don't change the identity
+    const id = `${hostname()}-${randomUUID().slice(0, 8)}`;
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(idFile, id, "utf-8");
+    }
+    catch {
+        // Can't persist — fall back to hostname
+        return hostname();
+    }
+    return id;
 }

package/dist/discord-api.d.ts

@@ -0,0 +1,24 @@
+import type { PluginLogger } from "./types.js";
+export declare class DiscordApi {
+    private token;
+    private logger;
+    constructor(logger: PluginLogger);
+    /** Extract bot token from openclaw.json config */
+    loadToken(): void;
+    get isAvailable(): boolean;
+    private request;
+    /**
+     * Create a public thread in a channel.
+     * Returns { id, name } of the created thread.
+     */
+    createThread(channelId: string, name: string, message?: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    /**
+     * Send a message to a channel or thread.
+     */
+    sendMessage(channelId: string, content: string): Promise<{
+        id: string;
+    }>;
+}

package/dist/discord-api.js

@@ -0,0 +1,83 @@
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DISCORD_API = "https://discord.com/api/v10";
+export class DiscordApi {
+    token = null;
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /** Extract bot token from openclaw.json config */
+    loadToken() {
+        const configCandidates = [
+            process.env.OPENCLAW_CONFIG_PATH,
+            process.env.OPENCLAW_HOME ? `${process.env.OPENCLAW_HOME}/openclaw.json` : "",
+            join(homedir(), ".openclaw", "openclaw.json"),
+        ].filter(Boolean);
+        for (const configPath of configCandidates) {
+            if (!existsSync(configPath))
+                continue;
+            try {
+                const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+                const accounts = raw.channels?.discord?.accounts ?? raw.channels?.["openclaw-discord"]?.accounts ?? {};
+                for (const acc of Object.values(accounts)) {
+                    if (acc.token) {
+                        this.token = acc.token;
+                        this.logger.info("[discord-api] Bot token loaded");
+                        return;
+                    }
+                }
+            }
+            catch { /* try next */ }
+        }
+        if (!this.token) {
+            this.logger.warn("[discord-api] No Discord bot token found — thread tools will be unavailable");
+        }
+    }
+    get isAvailable() {
+        return this.token !== null;
+    }
+    async request(method, path, body) {
+        if (!this.token)
+            throw new Error("Discord API not available — no bot token");
+        const res = await fetch(`${DISCORD_API}${path}`, {
+            method,
+            headers: {
+                "Authorization": `Bot ${this.token}`,
+                "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Discord API ${method} ${path} failed: ${res.status} ${text.substring(0, 200)}`);
+        }
+        return res.json();
+    }
+    /**
+     * Create a public thread in a channel.
+     * Returns { id, name } of the created thread.
+     */
+    async createThread(channelId, name, message) {
+        const thread = await this.request("POST", `/channels/${channelId}/threads`, {
+            name: name.substring(0, 100),
+            type: 11, // PUBLIC_THREAD
+            auto_archive_duration: 10080, // 7 days
+        });
+        if (message) {
+            await this.sendMessage(thread.id, message);
+        }
+        this.logger.info(`[discord-api] Created thread "${name}" (${thread.id})`);
+        return { id: thread.id, name: thread.name };
+    }
+    /**
+     * Send a message to a channel or thread.
+     */
+    async sendMessage(channelId, content) {
+        const msg = await this.request("POST", `/channels/${channelId}/messages`, {
+            content: content.substring(0, 2000),
+        });
+        return { id: msg.id };
+    }
+}

package/dist/heartbeat.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
 export class BridgeHeartbeat {
     config;
     registry;
@@ -16,7 +18,8 @@ export class BridgeHeartbeat {
         this.fileOps = fileOps;
         this.entry = entry;
         this.logger = logger;
-        this.configPath = process.env.OPENCLAW_CONFIG_PATH;
+        this.configPath = process.env.OPENCLAW_CONFIG_PATH
+            || join(homedir(), '.openclaw', 'openclaw.json');
         this.lastConfigHash = this.computeEntryHash();
     }
     computeEntryHash() {
@@ -32,6 +35,8 @@ export class BridgeHeartbeat {
         return createHash("md5").update(JSON.stringify(data)).digest("hex");
     }
     async start() {
+        // Detect channels/discordId before first registration so Hub sees them immediately
+        await this.detectConfigChanges();
         await this.registry.register(this.entry);
         this.lastConfigHash = this.computeEntryHash();
         const intervalMs = this.config.heartbeatIntervalMs ?? 30_000;
@@ -129,10 +134,10 @@ export class BridgeHeartbeat {
             const raw = readFileSync(configPath, "utf-8");
             const config = JSON.parse(raw);
             const accounts = config.channels?.discord?.accounts;
-            if (!Array.isArray(accounts))
+            if (!accounts || typeof accounts !== "object")
                 return [];
             const result = [];
-            for (const account of accounts) {
+            for (const account of Object.values(accounts)) {
                 if (!Array.isArray(account.channels))
                     continue;
                 for (const ch of account.channels) {

package/dist/index.js

@@ -12,6 +12,10 @@ import { discoverAll, whois } from "./discovery.js";
 import { MessageRelayClient } from "./message-relay.js";
 import * as proxySession from "./session.js";
 import { LocalManager } from "./manager/local-manager.js";
+import { buildMentionMap, applyMentions } from "./mention-interceptor.js";
+import { DiscordApi } from "./discord-api.js";
+import { ProjectManager } from "./project-manager.js";
+import { CircuitBreaker } from "./circuit-breaker.js";
 function resolveWorkspacePath(agentId) {
     // Try reading workspace from openclaw.json config
     const configPath = process.env.OPENCLAW_CONFIG_PATH;
@@ -108,6 +112,10 @@ const bridgePlugin = {
         const registry = new BridgeRegistry(config, api.logger);
         const fileOps = new BridgeFileOps(config, machineId, workspacePath, api.logger);
         const restartManager = new BridgeRestart(config, machineId, registry, api.logger);
+        const discordApi = new DiscordApi(api.logger);
+        discordApi.loadToken();
+        const projectMgr = new ProjectManager(workspacePath, api.logger);
+        const circuitBreaker = new CircuitBreaker(projectMgr, api.logger);
         let relayClient = null;
         const offlineThresholdMs = config.offlineThresholdMs ?? 120_000;
         const entry = {
@@ -154,51 +162,84 @@ const bridgePlugin = {
                 // Build dynamic name mapping from registry
                 const nameMapping = online.map((a) => `${a.agentName}=${a.agentId}`).join(", ");
                 cachedAgentList = `<bridge-context>
-## 跨网关通信（自动注入 — 必须严格遵守）
+## Cross-Gateway Communication (Auto-injected — MUST follow strictly)
 
-当前在线网关（${online.length} 个）：
+Online gateways (${online.length}):
 ${lines.join("\n")}
 ${superuserNote}
 
-### 核心规则：跨网关通信时必须用 Discord mention
-任何需要通知其他 agent 的场景（发文件、传消息、分派任务），都**必须在 Discord 频道用 <@discordId> 格式 mention 对方**。
-mention 格式已列在上方每个 agent 后面，直接复制使用，不要猜测或省略。
+### Core Rule: Use Discord mention for ALL cross-gateway communication
+When notifying another agent (sending files, messages, assigning tasks), you **MUST mention them using <@discordId> format**.
+The mention format is listed next to each agent above — copy and use it exactly.
 
-### 发文件流程（每一步必须做，不可跳过）
-1. bridge_send_file 发送文件
-2. **在 Discord 频道 mention 对方**，说：「发了 [文件名] 到你的 _inbox/，请查收」
-3. 等对方确认
+### File Sending Workflow (every step mandatory)
+1. Call bridge_send_file to send the file
+2. **Mention the recipient in Discord**: "Sent [filename] to your _inbox/, please check"
+3. Wait for confirmation
 
-⚠️ 第2步是强制的！发完文件不 mention 对方 = 任务未完成。
+⚠️ Step 2 is mandatory! Sending a file without mentioning the recipient = task incomplete.
 
-### 收到文件通知时
-- 有人 mention 你说发了文件 → 读取 _inbox/{发送方}/ 下的文件 → mention 发送方回复确认
-- 格式：「收到 [文件名]，内容：[摘要]」
+### When You Receive a File Notification
+- Someone mentions you about a file → read from _inbox/{sender}/ → mention sender to confirm
+- Format: "Received [filename], content: [brief summary]"
 
-### 用户转接（用户让你联系其他 agent）
-- 用户说"帮我找 pm"、"叫老马来"、"@下阿笔" → mention 对方并说明是用户找他
-- 被转接的 agent 收到后：直接 mention 用户回复「你找我什么事？」或「在！有什么需要？」
-- 识别用户：消息中第一个非 bot 的发言者就是用户
+### User Handoff (user asks you to contact another agent)
+- User says "find pm", "call bot1", "@bot2" → mention that agent, explain user is looking for them
+- Contacted agent should reply to user directly
+- Identify user: the first non-bot speaker in the message
 
-### 传递消息/分派任务
-- 直接在频道 mention 对方，对方会自动收到
-- 对方应 mention 你回复确认
+### Passing Messages / Assigning Tasks
+- Mention the target agent directly in the channel
+- Target agent should mention you back to confirm
 
-### 错误处理
-- agent 不在线 → 告诉用户「[agent名] 当前不在线，无法联系」
-- 文件发送失败 → 告诉用户具体错误原因
-- 找不到对应 agent → 告诉用户「没有找到名为 [xxx] 的 agent，当前在线：[列表]」
+### Error Handling
+- Agent offline → tell user "[agent name] is currently offline"
+- File send failed → tell user the specific error
+- Agent not found → tell user "No agent named [xxx] found. Currently online: [list]"
 
-### agent 名称映射（来自注册表，自动更新）
+### Agent Name Mapping (from registry, auto-updated)
 ${nameMapping}
 
-### ⚠️ LANGUAGE RULE (OVERRIDE ALL — HIGHEST PRIORITY)
-- ALWAYS respond in the same language as the message you are replying to
-- If the message is in English → you MUST reply in English
-- If the message is in Chinese → you MUST reply in Chinese
-- On /new or session start → greet in English
-- IGNORE the language of any injected memories or history — match the CURRENT message only
-- This rule overrides everything else including memories
+${config.agentId === "pm" ? `### 🎯 PROJECT MANAGEMENT PROTOCOL (PM ONLY — MANDATORY)
+When user asks you to create something (ad, video, content, script, etc.):
+
+**YOU MUST EXECUTE ALL 6 STEPS IN ORDER. SKIPPING ANY STEP IS A CRITICAL FAILURE.**
+
+1. **CALL bridge_project_create** — name + description → get projectId
+2. **CALL bridge_create_project_thread** — projectName + agent IDs → get threadId
+   ⚠️ THIS IS NON-NEGOTIABLE. You MUST create a Thread for EVERY project. NEVER skip this step.
+3. **CALL bridge_task_assign** — for EACH agent task with projectId, agentId, title, detailed brief
+4. **CALL bridge_post_to_thread** — post kickoff summary TO THE THREAD (not main channel)
+5. **Monitor** — when agent calls bridge_task_complete → check deps → assign next via bridge_task_assign
+6. **All done** → post final summary to Thread, mention user
+
+VIOLATIONS (any of these = protocol failure):
+- Skipping bridge_create_project_thread (MOST COMMON VIOLATION — DO NOT SKIP)
+- Assigning tasks via Discord messages instead of bridge_task_assign
+- Posting project updates to main channel instead of the Thread
+- Saying "relay hub not connected" — it IS connected, use the tools
+- Chatting after project completion — post summary and STOP
+` : `### 🎯 TASK EXECUTION PROTOCOL (WORKER AGENT — MANDATORY)
+When you receive a task (message containing [Project:] [Task:]):
+1. Call bridge_task_update with projectId, taskId, and your approach summary
+2. Do the work — produce the deliverables
+3. Call bridge_asset_publish to register any output files
+4. Call bridge_task_complete with summary and output paths
+5. STOP. Do NOT chat further after completing.
+
+VIOLATIONS (any of these = protocol failure):
+- Chatting after task completion (pleasantries, "looking forward to next stage", etc.)
+- Sending more than 1 confirmation message after task_complete
+- Asking other agents to "send files to _inbox" instead of using bridge_asset_get/bridge_asset_list
+
+If blocked: call bridge_task_blocked with type and reason. Then STOP.
+`}
+### ⚠️ LANGUAGE RULE (HIGHEST PRIORITY — OVERRIDES EVERYTHING)
+- DEFAULT language for ALL agent communication is **English**.
+- All task assignments, status updates, creative briefs, and project summaries MUST be in English.
+- Inter-agent communication is ALWAYS in English regardless of user's language.
+- Only exception: if user EXPLICITLY requests a specific language for deliverable content.
+- IGNORE the language of injected memories, history, or system context — always use English.
 </bridge-context>`;
             }
             catch {
@@ -220,7 +261,7 @@ ${nameMapping}
                     relayClient.setOnConflictRename((newAgentId, newAgentName) => {
                         const oldAgentId = entry.agentId;
                         api.logger.info(`[bridge] Conflict rename: ${oldAgentId} → ${newAgentId}, ${entry.agentName} → ${newAgentName}`);
-                        // Deregister old agentId from Hub registry before switching
+                        // Deregister old agentId from Hub registry, then re-register with new ID
                         registry.deregister(oldAgentId).catch((err) => {
                             api.logger.warn(`[bridge] Failed to deregister old agentId "${oldAgentId}": ${err.message}`);
                         });
@@ -228,6 +269,11 @@ ${nameMapping}
                         entry.agentName = newAgentName;
                         config.agentId = newAgentId;
                         config.agentName = newAgentName;
+                        // Re-register with new agentId so Hub sees us immediately
+                        entry.lastHeartbeat = new Date().toISOString();
+                        registry.register(entry).catch((err) => {
+                            api.logger.warn(`[bridge] Failed to re-register with new agentId "${newAgentId}": ${err.message}`);
+                        });
                         // Persist the renamed agentId to openclaw.json so it survives restarts
                         const configPath = process.env.OPENCLAW_CONFIG_PATH;
                         if (configPath) {
@@ -656,6 +702,302 @@ ${nameMapping}
                 return { status: "switched", newAgent: params.agentId };
             },
         });
+        // ── Thread Management Tools ──────────────────────────────────────
+        api.registerTool({
+            name: "bridge_create_project_thread",
+            label: "Bridge Create Project Thread",
+            description: "Create a Discord Thread for a project in the current channel. Returns threadId.",
+            parameters: Type.Object({
+                projectName: Type.String({ description: "Project name for the thread title" }),
+                agentIds: Type.Array(Type.String(), { description: "Agent IDs to mention in kickoff message" }),
+            }),
+            async execute(_id, params) {
+                if (!discordApi.isAvailable)
+                    return { error: "Discord API not available — no bot token configured" };
+                const projectName = params.projectName;
+                const agentIds = params.agentIds;
+                const discordChannel = entry.channels.find(c => c.type === "discord");
+                if (!discordChannel)
+                    return { error: "No Discord channel configured for this agent" };
+                const agents = await discoverAll(registry, offlineThresholdMs);
+                const mentions = agentIds
+                    .map(id => agents.find(a => a.agentId === id))
+                    .filter(Boolean)
+                    .map(a => a.discordId ? `<@${a.discordId}>` : a.agentName)
+                    .join(" ");
+                const thread = await discordApi.createThread(discordChannel.channelId, `🎬 ${projectName} — PM Managed`.substring(0, 100), `📋 **Project: ${projectName}**\n\nTeam: ${mentions}\n\nProject thread created. Updates will be posted here.`);
+                return { threadId: thread.id, threadName: thread.name };
+            },
+        });
+        api.registerTool({
+            name: "bridge_create_sub_thread",
+            label: "Bridge Create Sub Thread",
+            description: "Create a sub-thread for an agent's isolated task work.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                agentId: Type.String({ description: "Agent ID assigned to this task" }),
+                taskTitle: Type.String({ description: "Brief task title" }),
+            }),
+            async execute(_id, params) {
+                if (!discordApi.isAvailable)
+                    return { error: "Discord API not available" };
+                const discordChannel = entry.channels.find(c => c.type === "discord");
+                if (!discordChannel)
+                    return { error: "No Discord channel configured" };
+                const agents = await discoverAll(registry, offlineThresholdMs);
+                const agent = agents.find(a => a.agentId === params.agentId);
+                const agentName = agent?.agentName || params.agentId;
+                const thread = await discordApi.createThread(discordChannel.channelId, `📋 ${agentName} — ${params.taskTitle}`.substring(0, 100));
+                const project = projectMgr.readProject(params.projectId);
+                if (project) {
+                    const task = project.tasks.find(t => t.agent === params.agentId && !t.subThreadId);
+                    if (task) {
+                        task.subThreadId = thread.id;
+                        projectMgr.writeProject(project);
+                    }
+                }
+                return { subThreadId: thread.id, threadName: thread.name };
+            },
+        });
+        api.registerTool({
+            name: "bridge_post_to_thread",
+            label: "Bridge Post To Thread",
+            description: "Post a message to a specific Discord Thread.",
+            parameters: Type.Object({
+                threadId: Type.String({ description: "Discord Thread ID" }),
+                message: Type.String({ description: "Message content" }),
+            }),
+            async execute(_id, params) {
+                if (!discordApi.isAvailable)
+                    return { error: "Discord API not available" };
+                const agents = await discoverAll(registry, offlineThresholdMs);
+                const mentionMap = buildMentionMap(agents);
+                const processed = applyMentions(params.message, mentionMap);
+                await discordApi.sendMessage(params.threadId, processed);
+                return { success: true };
+            },
+        });
+        // ── Project Management Tools ─────────────────────────────────────
+        api.registerTool({
+            name: "bridge_project_create",
+            label: "Bridge Project Create",
+            description: "Initialize a new project with directory structure and state tracking.",
+            parameters: Type.Object({
+                name: Type.String({ description: "Project name" }),
+                description: Type.String({ description: "Brief project description" }),
+            }),
+            async execute(_id, params) {
+                const project = projectMgr.createProject(params.name, params.description);
+                return { projectId: project.id, projectDir: projectMgr.getProjectDir(project.id) };
+            },
+        });
+        api.registerTool({
+            name: "bridge_project_status",
+            label: "Bridge Project Status",
+            description: "Get project status. Omit projectId to see all active projects.",
+            parameters: Type.Object({
+                projectId: Type.Optional(Type.String({ description: "Project ID (omit for global overview)" })),
+            }),
+            async execute(_id, params) {
+                if (params.projectId) {
+                    const project = projectMgr.readProject(params.projectId);
+                    if (!project)
+                        return { error: `Project "${params.projectId}" not found` };
+                    return { project };
+                }
+                return projectMgr.listProjects();
+            },
+        });
+        // ── Task Management Tools ────────────────────────────────────────
+        api.registerTool({
+            name: "bridge_task_assign",
+            label: "Bridge Task Assign",
+            description: "Assign a task to an agent within a project. Sends the brief via Bridge Hub.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                agentId: Type.String({ description: "Agent to assign to" }),
+                title: Type.String({ description: "Task title" }),
+                brief: Type.String({ description: "Detailed task brief with asset paths" }),
+                dependencies: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that must complete first" })),
+            }),
+            async execute(_id, params) {
+                const task = projectMgr.addTask(params.projectId, params.agentId, params.title, params.brief, params.dependencies || []);
+                if (!task)
+                    return { error: "Failed to create task — project not found" };
+                const ready = task.dependencies.length === 0 ||
+                    projectMgr.getReadyTasks(params.projectId).some(t => t.id === task.id);
+                if (ready) {
+                    projectMgr.updateTaskStatus(params.projectId, task.id, "in_progress");
+                    if (relayClient?.isConnected) {
+                        const msgId = `task_${Date.now()}`;
+                        try {
+                            await relayClient.sendAndWait({
+                                type: "message",
+                                id: msgId,
+                                from: config.agentId,
+                                to: params.agentId,
+                                payload: `[Project: ${params.projectId}] [Task: ${task.id}] ${params.brief}`,
+                            }, 120_000);
+                        }
+                        catch { /* agent may not reply immediately */ }
+                    }
+                }
+                return { taskId: task.id, status: ready ? "in_progress" : "pending" };
+            },
+        });
+        api.registerTool({
+            name: "bridge_task_reassign",
+            label: "Bridge Task Reassign",
+            description: "Reassign a task to a different agent.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                taskId: Type.String({ description: "Task ID" }),
+                newAgentId: Type.String({ description: "New agent ID" }),
+                reason: Type.String({ description: "Reason for reassignment" }),
+            }),
+            async execute(_id, params) {
+                const task = projectMgr.updateTaskStatus(params.projectId, params.taskId, "pending", { agent: params.newAgentId, blockType: null, blockReason: null });
+                if (!task)
+                    return { error: "Task or project not found" };
+                return { taskId: task.id, newAgent: params.newAgentId, status: "pending" };
+            },
+        });
+        api.registerTool({
+            name: "bridge_task_update",
+            label: "Bridge Task Update",
+            description: "Post a progress update / thinking summary to the project's main Thread.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                taskId: Type.String({ description: "Task ID" }),
+                summary: Type.String({ description: "Progress summary" }),
+            }),
+            async execute(_id, params) {
+                const project = projectMgr.readProject(params.projectId);
+                if (!project)
+                    return { error: "Project not found" };
+                const task = project.tasks.find(t => t.id === params.taskId);
+                if (!task)
+                    return { error: "Task not found" };
+                if (project.threadId && discordApi.isAvailable) {
+                    const agents = await discoverAll(registry, offlineThresholdMs);
+                    const mentionMap = buildMentionMap(agents);
+                    const processed = applyMentions(`📊 **${task.title}** (${config.agentName}): ${params.summary}`, mentionMap);
+                    await discordApi.sendMessage(project.threadId, processed);
+                }
+                return { success: true };
+            },
+        });
+        api.registerTool({
+            name: "bridge_task_complete",
+            label: "Bridge Task Complete",
+            description: "Mark a task as completed with summary and output paths.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                taskId: Type.String({ description: "Task ID" }),
+                summary: Type.String({ description: "Completion summary" }),
+                outputPaths: Type.Optional(Type.Array(Type.String(), { description: "Output file paths" })),
+            }),
+            async execute(_id, params) {
+                const outputs = params.outputPaths || [];
+                const task = projectMgr.updateTaskStatus(params.projectId, params.taskId, "completed", { outputs });
+                if (!task)
+                    return { error: "Task or project not found" };
+                if (relayClient?.isConnected && config.agentId !== "pm") {
+                    relayClient.send({
+                        type: "message",
+                        id: `complete_${Date.now()}`,
+                        from: config.agentId,
+                        to: "pm",
+                        payload: `[Task Complete] Project: ${params.projectId}, Task: ${params.taskId}. ${params.summary}`,
+                    });
+                }
+                return { taskId: task.id, status: "completed", outputs };
+            },
+        });
+        api.registerTool({
+            name: "bridge_task_blocked",
+            label: "Bridge Task Blocked",
+            description: "Report that a task is blocked. Types: capability_missing, dependency_failed, clarification_needed.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                taskId: Type.String({ description: "Task ID" }),
+                blockType: Type.String({ description: "capability_missing | dependency_failed | clarification_needed" }),
+                reason: Type.String({ description: "Detailed blocker explanation" }),
+            }),
+            async execute(_id, params) {
+                const task = projectMgr.updateTaskStatus(params.projectId, params.taskId, "blocked", { blockType: params.blockType, blockReason: params.reason });
+                if (!task)
+                    return { error: "Task or project not found" };
+                if (relayClient?.isConnected && config.agentId !== "pm") {
+                    relayClient.send({
+                        type: "message",
+                        id: `blocked_${Date.now()}`,
+                        from: config.agentId,
+                        to: "pm",
+                        payload: `[Task Blocked] Project: ${params.projectId}, Task: ${params.taskId}, Type: ${params.blockType}. ${params.reason}`,
+                    });
+                }
+                return { taskId: task.id, status: "blocked", blockType: params.blockType };
+            },
+        });
+        // ── Asset Management Tools ───────────────────────────────────────
+        api.registerTool({
+            name: "bridge_asset_publish",
+            label: "Bridge Asset Publish",
+            description: "Publish an output asset to the project's asset directory.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                filePath: Type.String({ description: "Path to file (relative to workspace)" }),
+                assetType: Type.String({ description: "Asset type: storyboard, script, reference-images, video, etc." }),
+                description: Type.String({ description: "Brief description" }),
+                taskId: Type.String({ description: "Task ID that produced this asset" }),
+            }),
+            async execute(_id, params) {
+                const fullPath = join(workspacePath, params.filePath);
+                const asset = projectMgr.publishAsset(params.projectId, fullPath, params.assetType, params.description, config.agentId, params.taskId);
+                if (!asset)
+                    return { error: "Project not found" };
+                return { assetId: asset.id, path: asset.path };
+            },
+        });
+        api.registerTool({
+            name: "bridge_asset_list",
+            label: "Bridge Asset List",
+            description: "List all assets in a project, optionally filtered.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                type: Type.Optional(Type.String({ description: "Filter by asset type" })),
+                agent: Type.Optional(Type.String({ description: "Filter by producer agent ID" })),
+            }),
+            async execute(_id, params) {
+                const assets = projectMgr.listAssets(params.projectId, params.type, params.agent);
+                return { assets };
+            },
+        });
+        api.registerTool({
+            name: "bridge_asset_get",
+            label: "Bridge Asset Get",
+            description: "Get the full path and metadata of a specific asset.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "Project ID" }),
+                assetId: Type.Optional(Type.String({ description: "Asset ID" })),
+                assetType: Type.Optional(Type.String({ description: "Asset type to find latest of" })),
+            }),
+            async execute(_id, params) {
+                const assets = projectMgr.listAssets(params.projectId);
+                let asset;
+                if (params.assetId) {
+                    asset = assets.find(a => a.id === params.assetId);
+                }
+                else if (params.assetType) {
+                    asset = assets.filter(a => a.type === params.assetType).pop();
+                }
+                if (!asset)
+                    return { error: "Asset not found" };
+                const fullPath = join(projectMgr.getProjectDir(params.projectId), asset.path);
+                return { ...asset, fullPath };
+            },
+        });
     },
 };
 export default bridgePlugin;

package/dist/manager/hub-client.js

@@ -1,5 +1,14 @@
 import WebSocket from "ws";
-import { hostname } from "node:os";
+import { hostname, homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+function readMachineId() {
+    try {
+        const id = readFileSync(join(homedir(), ".openclaw", ".machine-id"), "utf-8").trim();
+        if (id) return id;
+    } catch {}
+    return hostname();
+}
 export class ManagerHubClient {
     hubUrl;
     apiKey;
@@ -14,7 +23,7 @@ export class ManagerHubClient {
         this.hubUrl = hubUrl;
         this.apiKey = apiKey;
         this.managerPass = managerPass;
-        this.machineId = hostname();
+        this.machineId = readMachineId();
         this.logger = logger;
     }
     get connected() {

package/dist/mention-interceptor.d.ts

@@ -0,0 +1,16 @@
+import type { RegistryEntry } from "./types.js";
+interface MentionMap {
+    pattern: RegExp;
+    replacement: string;
+}
+/**
+ * Build a list of name→mention mappings from the agent registry.
+ * Each agent can be referenced by agentId, agentName, or description keywords.
+ */
+export declare function buildMentionMap(agents: RegistryEntry[]): MentionMap[];
+/**
+ * Replace agent names in text with Discord <@ID> mentions.
+ * Skips text already in mention format.
+ */
+export declare function applyMentions(text: string, maps: MentionMap[]): string;
+export {};

package/dist/mention-interceptor.js

@@ -0,0 +1,43 @@
+/**
+ * Build a list of name→mention mappings from the agent registry.
+ * Each agent can be referenced by agentId, agentName, or description keywords.
+ */
+export function buildMentionMap(agents) {
+    const maps = [];
+    for (const agent of agents) {
+        if (!agent.discordId)
+            continue;
+        const mention = `<@${agent.discordId}>`;
+        const names = new Set();
+        // Always match agentId and agentName
+        names.add(agent.agentId);
+        if (agent.agentName)
+            names.add(agent.agentName);
+        // Build regex: match any of the names, word-bounded
+        // Sort by length descending so longer names match first
+        const sorted = [...names].filter(n => n.length >= 2).sort((a, b) => b.length - a.length);
+        for (const name of sorted) {
+            // Skip if name is already a Discord mention format
+            if (name.startsWith("<@"))
+                continue;
+            // Escape regex special chars
+            const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            maps.push({
+                pattern: new RegExp(`(?<!<@[!&]?)\\b${escaped}\\b`, "gi"),
+                replacement: mention,
+            });
+        }
+    }
+    return maps;
+}
+/**
+ * Replace agent names in text with Discord <@ID> mentions.
+ * Skips text already in mention format.
+ */
+export function applyMentions(text, maps) {
+    let result = text;
+    for (const { pattern, replacement } of maps) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}

package/dist/message-relay.js

@@ -175,6 +175,10 @@ export class MessageRelayClient {
             }
             catch (err) {
                 settle(reject, err);
+                // No 'close' event will fire if constructor threw — schedule reconnect manually
+                if (this.shouldReconnect) {
+                    this.scheduleReconnect();
+                }
             }
         });
     }
@@ -191,7 +195,10 @@ export class MessageRelayClient {
             }
             catch {
                 this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
-                // connect() failure triggers 'close' which calls scheduleReconnect again
+                // If connect() failure didn't trigger 'close' (e.g., constructor threw),
+                // scheduleReconnect was already called in the catch block above.
+                // If 'close' did fire, scheduleReconnect is called from the close handler.
+                // Either way, the next reconnect is already scheduled.
             }
         }, this.reconnectDelay);
     }

package/dist/permissions.js

@@ -1,4 +1,10 @@
-const PUBLIC_ACTIONS = new Set(["discover", "whois", "send_file"]);
+const PUBLIC_ACTIONS = new Set([
+    "discover", "whois", "send_file",
+    "project_create", "project_status",
+    "task_assign", "task_reassign", "task_update", "task_complete", "task_blocked",
+    "asset_publish", "asset_list", "asset_get",
+    "create_project_thread", "create_sub_thread", "post_to_thread",
+]);
 const SUPERUSER_ACTIONS = new Set(["read_file", "write_file", "restart"]);
 export function checkPermission(action, config) {
     if (PUBLIC_ACTIONS.has(action))

package/dist/project-manager.d.ts

@@ -0,0 +1,30 @@
+import type { ProjectData, ProjectIndex, TaskData, AssetData, TaskStatus, BlockType, PluginLogger } from "./types.js";
+export declare class ProjectManager {
+    private baseDir;
+    private logger;
+    constructor(workspacePath: string, logger: PluginLogger);
+    private indexPath;
+    private readIndex;
+    private writeIndex;
+    getProjectDir(projectId: string): string;
+    private projectJsonPath;
+    createProject(name: string, description: string): ProjectData;
+    readProject(projectId: string): ProjectData | null;
+    writeProject(project: ProjectData): void;
+    listProjects(): ProjectIndex;
+    addTask(projectId: string, agent: string, title: string, brief: string, dependencies?: string[]): TaskData | null;
+    updateTaskStatus(projectId: string, taskId: string, status: TaskStatus, extra?: {
+        blockType?: BlockType;
+        blockReason?: string;
+        subThreadId?: string;
+        outputs?: string[];
+    }): TaskData | null;
+    incrementRounds(projectId: string, taskId: string): {
+        task: TaskData;
+        softLimit: boolean;
+        hardLimit: boolean;
+    } | null;
+    getReadyTasks(projectId: string): TaskData[];
+    publishAsset(projectId: string, sourcePath: string, assetType: string, description: string, producer: string, taskId: string): AssetData | null;
+    listAssets(projectId: string, typeFilter?: string, agentFilter?: string): AssetData[];
+}

package/dist/project-manager.js

@@ -0,0 +1,257 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync, } from "node:fs";
+import { join, basename } from "node:path";
+const SOFT_ROUND_LIMIT = 8;
+const HARD_ROUND_LIMIT = 15;
+function nowIso() {
+    return new Date().toISOString();
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+function generateId(prefix) {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 7);
+    return `${prefix}-${ts}-${rand}`;
+}
+export class ProjectManager {
+    baseDir;
+    logger;
+    constructor(workspacePath, logger) {
+        this.baseDir = join(workspacePath, "_projects");
+        this.logger = logger;
+        mkdirSync(this.baseDir, { recursive: true });
+        this.logger.info(`[ProjectManager] base dir: ${this.baseDir}`);
+    }
+    // ── Index helpers ────────────────────────────────────────────────────
+    indexPath() {
+        return join(this.baseDir, "index.json");
+    }
+    readIndex() {
+        const p = this.indexPath();
+        if (!existsSync(p)) {
+            return { activeProjects: [] };
+        }
+        try {
+            return JSON.parse(readFileSync(p, "utf-8"));
+        }
+        catch (err) {
+            this.logger.warn(`[ProjectManager] failed to parse index.json: ${err}`);
+            return { activeProjects: [] };
+        }
+    }
+    writeIndex(index) {
+        writeFileSync(this.indexPath(), JSON.stringify(index, null, 2), "utf-8");
+    }
+    // ── Directory helpers ────────────────────────────────────────────────
+    getProjectDir(projectId) {
+        return join(this.baseDir, projectId);
+    }
+    projectJsonPath(projectId) {
+        return join(this.getProjectDir(projectId), "project.json");
+    }
+    // ── Project CRUD ─────────────────────────────────────────────────────
+    createProject(name, description) {
+        const slug = slugify(name);
+        const id = slug ? `${slug}-${Date.now().toString(36)}` : generateId("proj");
+        const dir = this.getProjectDir(id);
+        mkdirSync(join(dir, "assets"), { recursive: true });
+        mkdirSync(join(dir, "briefs"), { recursive: true });
+        const project = {
+            id,
+            name,
+            description,
+            threadId: null,
+            status: "in_progress",
+            createdAt: nowIso(),
+            tasks: [],
+            assets: [],
+            totalRounds: 0,
+        };
+        writeFileSync(this.projectJsonPath(id), JSON.stringify(project, null, 2), "utf-8");
+        const index = this.readIndex();
+        index.activeProjects.push({ id, status: project.status, threadId: null });
+        this.writeIndex(index);
+        this.logger.info(`[ProjectManager] created project "${name}" → ${id}`);
+        return project;
+    }
+    readProject(projectId) {
+        const p = this.projectJsonPath(projectId);
+        if (!existsSync(p)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(p, "utf-8"));
+        }
+        catch (err) {
+            this.logger.error(`[ProjectManager] failed to read project ${projectId}: ${err}`);
+            return null;
+        }
+    }
+    writeProject(project) {
+        const dir = this.getProjectDir(project.id);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(this.projectJsonPath(project.id), JSON.stringify(project, null, 2), "utf-8");
+        // Sync index entry
+        const index = this.readIndex();
+        const entry = index.activeProjects.find((e) => e.id === project.id);
+        if (entry) {
+            entry.status = project.status;
+            entry.threadId = project.threadId;
+        }
+        else {
+            index.activeProjects.push({
+                id: project.id,
+                status: project.status,
+                threadId: project.threadId,
+            });
+        }
+        this.writeIndex(index);
+    }
+    listProjects() {
+        return this.readIndex();
+    }
+    // ── Task lifecycle ────────────────────────────────────────────────────
+    addTask(projectId, agent, title, brief, dependencies = []) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            this.logger.warn(`[ProjectManager] addTask: project not found: ${projectId}`);
+            return null;
+        }
+        const task = {
+            id: generateId("task"),
+            agent,
+            title,
+            brief,
+            status: "pending",
+            subThreadId: null,
+            dependencies,
+            rounds: 0,
+            maxRounds: HARD_ROUND_LIMIT,
+            outputs: [],
+            blockType: null,
+            blockReason: null,
+            reworkCount: 0,
+            assignedAt: nowIso(),
+            completedAt: null,
+        };
+        project.tasks.push(task);
+        this.writeProject(project);
+        this.logger.info(`[ProjectManager] added task "${title}" (${task.id}) to project ${projectId}`);
+        return task;
+    }
+    updateTaskStatus(projectId, taskId, status, extra) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            this.logger.warn(`[ProjectManager] updateTaskStatus: project not found: ${projectId}`);
+            return null;
+        }
+        const task = project.tasks.find((t) => t.id === taskId);
+        if (!task) {
+            this.logger.warn(`[ProjectManager] updateTaskStatus: task not found: ${taskId}`);
+            return null;
+        }
+        task.status = status;
+        if (status === "completed") {
+            task.completedAt = nowIso();
+            task.blockType = null;
+            task.blockReason = null;
+        }
+        if (extra) {
+            if (extra.blockType !== undefined)
+                task.blockType = extra.blockType;
+            if (extra.blockReason !== undefined)
+                task.blockReason = extra.blockReason;
+            if (extra.subThreadId !== undefined)
+                task.subThreadId = extra.subThreadId;
+            if (extra.outputs !== undefined)
+                task.outputs = extra.outputs;
+        }
+        this.writeProject(project);
+        this.logger.info(`[ProjectManager] task ${taskId} status → ${status}`);
+        return task;
+    }
+    incrementRounds(projectId, taskId) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            this.logger.warn(`[ProjectManager] incrementRounds: project not found: ${projectId}`);
+            return null;
+        }
+        const task = project.tasks.find((t) => t.id === taskId);
+        if (!task) {
+            this.logger.warn(`[ProjectManager] incrementRounds: task not found: ${taskId}`);
+            return null;
+        }
+        task.rounds += 1;
+        project.totalRounds += 1;
+        const softLimit = task.rounds >= SOFT_ROUND_LIMIT;
+        const hardLimit = task.rounds >= HARD_ROUND_LIMIT;
+        this.writeProject(project);
+        if (hardLimit) {
+            this.logger.warn(`[ProjectManager] task ${taskId} hit HARD round limit (${task.rounds}/${HARD_ROUND_LIMIT})`);
+        }
+        else if (softLimit) {
+            this.logger.warn(`[ProjectManager] task ${taskId} hit soft round limit (${task.rounds}/${SOFT_ROUND_LIMIT})`);
+        }
+        return { task, softLimit, hardLimit };
+    }
+    getReadyTasks(projectId) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            return [];
+        }
+        const completedIds = new Set(project.tasks.filter((t) => t.status === "completed").map((t) => t.id));
+        return project.tasks.filter((t) => t.status === "pending" &&
+            t.dependencies.every((depId) => completedIds.has(depId)));
+    }
+    // ── Asset registry ────────────────────────────────────────────────────
+    publishAsset(projectId, sourcePath, assetType, description, producer, taskId) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            this.logger.warn(`[ProjectManager] publishAsset: project not found: ${projectId}`);
+            return null;
+        }
+        const assetsDir = join(this.getProjectDir(projectId), "assets");
+        mkdirSync(assetsDir, { recursive: true });
+        const assetId = generateId("asset");
+        const destFilename = `${assetId}-${basename(sourcePath)}`;
+        const destPath = join(assetsDir, destFilename);
+        try {
+            copyFileSync(sourcePath, destPath);
+        }
+        catch (err) {
+            this.logger.error(`[ProjectManager] failed to copy asset from ${sourcePath}: ${err}`);
+            return null;
+        }
+        const asset = {
+            id: assetId,
+            path: destPath,
+            type: assetType,
+            producer,
+            taskId,
+            description,
+            publishedAt: nowIso(),
+        };
+        project.assets.push(asset);
+        this.writeProject(project);
+        this.logger.info(`[ProjectManager] published asset ${assetId} (${assetType}) for project ${projectId}`);
+        return asset;
+    }
+    listAssets(projectId, typeFilter, agentFilter) {
+        const project = this.readProject(projectId);
+        if (!project) {
+            return [];
+        }
+        let assets = project.assets;
+        if (typeFilter) {
+            assets = assets.filter((a) => a.type === typeFilter);
+        }
+        if (agentFilter) {
+            assets = assets.filter((a) => a.producer === agentFilter);
+        }
+        return assets;
+    }
+}

package/dist/types.d.ts

@@ -88,3 +88,50 @@ export type OpenClawPluginApi = {
         priority?: number;
     }) => void;
 };
+export interface AssetData {
+    id: string;
+    path: string;
+    type: string;
+    producer: string;
+    taskId: string;
+    description: string;
+    publishedAt: string;
+}
+export type TaskStatus = "pending" | "in_progress" | "completed" | "blocked" | "cancelled";
+export type BlockType = "capability_missing" | "dependency_failed" | "clarification_needed";
+export interface TaskData {
+    id: string;
+    agent: string;
+    title: string;
+    brief: string;
+    status: TaskStatus;
+    subThreadId: string | null;
+    dependencies: string[];
+    rounds: number;
+    maxRounds: number;
+    outputs: string[];
+    blockType: BlockType | null;
+    blockReason: string | null;
+    reworkCount: number;
+    assignedAt: string;
+    completedAt: string | null;
+}
+export type ProjectStatus = "in_progress" | "waiting_clarification" | "completed" | "paused" | "cancelled";
+export interface ProjectData {
+    id: string;
+    name: string;
+    description: string;
+    threadId: string | null;
+    status: ProjectStatus;
+    createdAt: string;
+    tasks: TaskData[];
+    assets: AssetData[];
+    totalRounds: number;
+}
+export interface ProjectIndex {
+    activeProjects: Array<{
+        id: string;
+        status: ProjectStatus;
+        threadId: string | null;
+    }>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-bridge",
-  "version": "0.4.9",
+  "version": "0.5.2",
   "author": "Bill Zhao (https://www.linkedin.com/in/billzhaodi/)",
   "description": "OpenClaw plugin for cross-gateway communication — agent discovery, file transfer, real-time messaging, session handoff, and local process management. Install as plugin: openclaw plugins install openclaw-bridge",
   "type": "module",