@hasna/conversations 0.2.29 → 0.2.31

package/bin/index.js

@@ -14928,7 +14928,7 @@ var init_presence = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/conversations",
-    version: "0.2.29",
+    version: "0.2.31",
     description: "Real-time CLI messaging for AI agents",
     type: "module",
     bin: {
@@ -15709,6 +15709,140 @@ var init_graph = __esm(() => {
   init_db();
 });
 
+// src/cli/commands/tmux.ts
+import chalk9 from "chalk";
+import { execSync } from "child_process";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function countLines(message) {
+  const matches = message.match(/\r?\n/g);
+  return (matches?.length ?? 0) + 1;
+}
+function getDefaultDelayMs(message) {
+  const byLength = message.length * 1.5;
+  const byLines = countLines(message) * 10;
+  return Math.max(25, Math.min(1500, Math.round(byLength + byLines)));
+}
+function getVerifyPauseMs(message) {
+  return message.length <= 120 ? 50 : 100;
+}
+function getRetryBackoffMs(attempt) {
+  return Math.min(500, 100 * attempt);
+}
+async function tmuxSend(target, message, opts = {}) {
+  const delay = opts.delayMs ?? getDefaultDelayMs(message);
+  const maxRetries = opts.retries ?? 3;
+  const verify = opts.verify !== false;
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    execSync(`tmux send-keys -t ${JSON.stringify(target)} -l ${JSON.stringify(message)}`);
+    await sleep(delay);
+    execSync(`tmux send-keys -t ${JSON.stringify(target)} Enter`);
+    if (!verify)
+      return { success: true, attempts: attempt };
+    await sleep(getVerifyPauseMs(message));
+    const pane = execSync(`tmux capture-pane -t ${JSON.stringify(target)} -p`).toString();
+    const lastLines = pane.split(`
+`).slice(-6).join(`
+`);
+    const marker = message.slice(0, Math.min(32, message.length));
+    if (!lastLines.includes(marker)) {
+      return { success: true, attempts: attempt };
+    }
+    if (attempt < maxRetries)
+      await sleep(getRetryBackoffMs(attempt));
+  }
+  return { success: false, attempts: maxRetries };
+}
+function registerTmuxCommands(program2) {
+  const tmux = program2.command("tmux").description("Dispatch messages to tmux windows (Claude Code sessions)");
+  tmux.command("send").description("Send a message to a tmux window with paste+wait+Enter+verify").requiredOption("--target <target>", "Tmux target: session:window or session:window.pane").requiredOption("--message <text>", "Message text to send").option("--delay <ms>", "Wait time (ms) after paste before hitting Enter (default: adaptive 25-1500ms)", parseInt).option("--retries <n>", "Max retry attempts (default: 3)", parseInt).option("--no-verify", "Skip verification after sending").option("--json", "Output result as JSON").action(async (opts) => {
+    const target = opts.target.trim();
+    const message = opts.message;
+    if (!target) {
+      console.error(chalk9.red("--target is required."));
+      process.exit(1);
+    }
+    if (!message || !message.trim()) {
+      console.error(chalk9.red("--message cannot be empty."));
+      process.exit(1);
+    }
+    try {
+      const result = await tmuxSend(target, message, {
+        delayMs: Number.isFinite(opts.delay) ? opts.delay : undefined,
+        retries: Number.isFinite(opts.retries) ? opts.retries : undefined,
+        verify: opts.verify !== false
+      });
+      if (opts.json) {
+        console.log(JSON.stringify({ target, result }));
+      } else if (result.success) {
+        console.log(chalk9.green(`Sent to ${target}`) + chalk9.dim(` (attempt ${result.attempts})`));
+      } else {
+        console.error(chalk9.red(`Failed to confirm delivery to ${target}`) + chalk9.dim(` after ${result.attempts} attempt(s)`));
+        process.exit(1);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ target, error: msg }));
+      } else {
+        console.error(chalk9.red(`tmux error: ${msg}`));
+      }
+      process.exit(1);
+    }
+  });
+  tmux.command("broadcast").description("Send the same message to multiple tmux windows").requiredOption("--targets <list>", "Comma-separated list of tmux targets").requiredOption("--message <text>", "Message text to send").option("--delay <ms>", "Wait time (ms) after paste before Enter (default: adaptive 25-1500ms)", parseInt).option("--stagger <ms>", "Delay (ms) between each target (default: 500)", parseInt).option("--retries <n>", "Max retry attempts per target (default: 3)", parseInt).option("--no-verify", "Skip verification after sending").option("--json", "Output results as JSON").action(async (opts) => {
+    const targets = opts.targets.split(",").map((t) => t.trim()).filter(Boolean);
+    const message = opts.message;
+    const stagger = Number.isFinite(opts.stagger) && opts.stagger >= 0 ? opts.stagger : 500;
+    if (targets.length === 0) {
+      console.error(chalk9.red("--targets must be a non-empty comma-separated list."));
+      process.exit(1);
+    }
+    if (!message || !message.trim()) {
+      console.error(chalk9.red("--message cannot be empty."));
+      process.exit(1);
+    }
+    const results = new Array(targets.length);
+    await Promise.all(targets.map(async (target, i) => {
+      if (i > 0 && stagger > 0)
+        await sleep(stagger * i);
+      try {
+        const result = await tmuxSend(target, message, {
+          delayMs: Number.isFinite(opts.delay) ? opts.delay : undefined,
+          retries: Number.isFinite(opts.retries) ? opts.retries : undefined,
+          verify: opts.verify !== false
+        });
+        results[i] = { target, ...result };
+        if (!opts.json) {
+          if (result.success) {
+            console.log(chalk9.green(`  \u2713 ${target}`) + chalk9.dim(` (attempt ${result.attempts})`));
+          } else {
+            console.log(chalk9.red(`  \u2717 ${target}`) + chalk9.dim(` (failed after ${result.attempts} attempts)`));
+          }
+        }
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        results[i] = { target, success: false, attempts: 0, error: errMsg };
+        if (!opts.json) {
+          console.log(chalk9.red(`  \u2717 ${target}: ${errMsg}`));
+        }
+      }
+    }));
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.length - succeeded;
+    if (opts.json) {
+      console.log(JSON.stringify({ results, succeeded, failed, total: results.length }));
+    } else {
+      console.log(chalk9.dim(`
+Broadcast complete: ${chalk9.green(succeeded)} succeeded, ${failed > 0 ? chalk9.red(failed) : chalk9.dim(failed)} failed`));
+    }
+    if (failed > 0)
+      process.exit(1);
+  });
+}
+var init_tmux = () => {};
+
 // node_modules/zod/v3/helpers/util.js
 var util2, objectUtil2, ZodParsedType2, getParsedType2 = (data) => {
   const t = typeof data;
@@ -46770,6 +46904,156 @@ var init_cloud = __esm(() => {
   CONFLICT_TABLES = new Set(["spaces", "projects", "agent_presence"]);
 });
 
+// src/mcp/channel.ts
+function registerChannelBridge(server, getAgentId) {
+  server.server.registerCapabilities({
+    experimental: {
+      "claude/channel": {}
+    }
+  });
+  let lastSeenId = 0;
+  let pollTimer = null;
+  function seedLastSeen(agentId) {
+    const latest = readMessages({
+      to: agentId,
+      order: "desc",
+      limit: 1
+    });
+    if (latest.length > 0) {
+      lastSeenId = latest[0].id;
+    }
+  }
+  function startPolling2() {
+    if (pollTimer)
+      return;
+    const agentId = getAgentId();
+    if (!agentId)
+      return;
+    seedLastSeen(agentId);
+    pollTimer = setInterval(() => {
+      const currentAgent = getAgentId();
+      if (!currentAgent)
+        return;
+      try {
+        const newMessages = readMessages({
+          to: currentAgent,
+          order: "asc",
+          limit: 20
+        }).filter((m) => m.id > lastSeenId);
+        for (const msg of newMessages) {
+          lastSeenId = msg.id;
+          server.server.notification({
+            method: "notifications/claude/channel",
+            params: {
+              content: msg.content,
+              meta: {
+                from: msg.from_agent,
+                session_id: msg.session_id,
+                ...msg.space ? { space: msg.space } : {},
+                ...msg.priority !== "normal" ? { priority: msg.priority } : {}
+              }
+            }
+          });
+        }
+      } catch {}
+    }, POLL_INTERVAL_MS);
+  }
+  setTimeout(() => startPolling2(), 500);
+}
+var POLL_INTERVAL_MS = 1000;
+var init_channel = __esm(() => {
+  init_messages();
+});
+
+// src/mcp/tools/tmux.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function registerTmuxTools(server) {
+  server.registerTool("tmux_send", {
+    description: "Send a message to a tmux window (e.g. another agent's Claude Code session). " + "Pastes the text literally, waits for the pane to be idle, hits Enter, then verifies the message was submitted. " + "Retries up to N times on failure.",
+    inputSchema: {
+      target: exports_external2.string().describe("Tmux target: session:window or session:window.pane (e.g. platform-alumia:1)"),
+      message: exports_external2.string().describe("Message text to send"),
+      delay_ms: exports_external2.coerce.number().optional().describe("Wait time (ms) after paste before hitting Enter. Default: adaptive 25-1500ms"),
+      retries: exports_external2.coerce.number().optional().describe("Max retry attempts (default: 3)"),
+      verify: exports_external2.coerce.boolean().optional().describe("Verify message was submitted after Enter (default: true)")
+    }
+  }, async (args) => {
+    const { target, message, delay_ms, retries, verify } = args;
+    if (!target || !target.trim()) {
+      return { content: [{ type: "text", text: "target is required" }], isError: true };
+    }
+    if (!message || !message.trim()) {
+      return { content: [{ type: "text", text: "message cannot be empty" }], isError: true };
+    }
+    try {
+      const result = await tmuxSend(target.trim(), message, {
+        delayMs: typeof delay_ms === "number" && delay_ms > 0 ? delay_ms : undefined,
+        retries: typeof retries === "number" && retries > 0 ? retries : undefined,
+        verify: verify !== false
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ target, result }) }],
+        isError: !result.success
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: `tmux error: ${msg}` }], isError: true };
+    }
+  });
+  server.registerTool("tmux_broadcast", {
+    description: "Send the same message to multiple tmux windows simultaneously. " + "Useful for broadcasting instructions to several agent sessions at once. " + "Supports staggered sending and per-target retry.",
+    inputSchema: {
+      targets: exports_external2.array(exports_external2.string()).describe("List of tmux targets (session:window or session:window.pane)"),
+      message: exports_external2.string().describe("Message text to send to all targets"),
+      delay_ms: exports_external2.coerce.number().optional().describe("Wait time (ms) after paste before Enter. Default: adaptive 25-1500ms"),
+      stagger_ms: exports_external2.coerce.number().optional().describe("Delay (ms) between sending to each target (default: 500)"),
+      retries: exports_external2.coerce.number().optional().describe("Max retry attempts per target (default: 3)"),
+      verify: exports_external2.coerce.boolean().optional().describe("Verify each message was submitted (default: true)")
+    }
+  }, async (args) => {
+    const { targets, message, delay_ms, stagger_ms, retries, verify } = args;
+    if (!Array.isArray(targets) || targets.length === 0) {
+      return { content: [{ type: "text", text: "targets must be a non-empty array" }], isError: true };
+    }
+    if (!message || !message.trim()) {
+      return { content: [{ type: "text", text: "message cannot be empty" }], isError: true };
+    }
+    const stagger = typeof stagger_ms === "number" && stagger_ms >= 0 ? stagger_ms : 500;
+    const results = new Array(targets.length);
+    await Promise.all(targets.map(async (rawTarget, i) => {
+      const target = String(rawTarget).trim();
+      if (i > 0 && stagger > 0)
+        await sleep2(stagger * i);
+      try {
+        const result = await tmuxSend(target, message, {
+          delayMs: typeof delay_ms === "number" && delay_ms > 0 ? delay_ms : undefined,
+          retries: typeof retries === "number" && retries > 0 ? retries : undefined,
+          verify: verify !== false
+        });
+        results[i] = { target, ...result };
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        results[i] = { target, success: false, attempts: 0, error: errMsg };
+      }
+    }));
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.length - succeeded;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ results, succeeded, failed, total: results.length })
+      }],
+      isError: failed > 0
+    };
+  });
+}
+var init_tmux2 = __esm(() => {
+  init_zod2();
+  init_tmux();
+});
+
 // src/mcp/index.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -46804,6 +47088,8 @@ var init_mcp2 = __esm(() => {
   init_agents();
   init_advanced();
   init_cloud();
+  init_channel();
+  init_tmux2();
   import__package2 = __toESM(require_package(), 1);
   server = new McpServer({
     name: "conversations",
@@ -46815,6 +47101,8 @@ var init_mcp2 = __esm(() => {
   registerProjectTools(server);
   registerAgentTools(server, agentFocus, getAgentFocus);
   registerAdvancedTools(server, import__package2.default.version);
+  registerTmuxTools(server);
+  registerChannelBridge(server, () => process.env.CONVERSATIONS_AGENT_ID ?? null);
   isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp.js") || process.argv[1]?.endsWith("mcp.ts");
   if (isDirectRun) {
     startMcpServer().catch((error48) => {
@@ -47403,7 +47691,7 @@ var {
 
 // src/cli/index.tsx
 init_identity();
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { render } from "ink";
 import React8 from "react";
 
@@ -50016,6 +50304,7 @@ function registerAnalyticsCommands(program2) {
 }
 
 // src/cli/index.tsx
+init_tmux();
 var import__package3 = __toESM(require_package(), 1);
 var program2 = new Command;
 program2.name("conversations").description("Real-time CLI messaging for AI agents").version(import__package3.default.version);
@@ -50024,6 +50313,7 @@ registerSpaceCommands(program2);
 registerProjectCommands(program2);
 registerAgentCommands(program2);
 registerAnalyticsCommands(program2);
+registerTmuxCommands(program2);
 program2.command("mcp").description("Start MCP server").action(async () => {
   const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp2(), exports_mcp));
   await startMcpServer2();
@@ -50048,11 +50338,11 @@ registerCloudCommands(program2, "conversations");
         const { PG_MIGRATIONS: PG_MIGRATIONS2 } = await Promise.resolve().then(() => (init_pg_migrations(), exports_pg_migrations));
         const config2 = getCloudConfig2();
         if (config2.mode === "local") {
-          console.error(chalk9.red("Error: cloud mode not configured. Set RDS credentials first."));
+          console.error(chalk10.red("Error: cloud mode not configured. Set RDS credentials first."));
           process.exit(1);
         }
         if (opts.dryRun) {
-          console.log(chalk9.dim(`-- Dry run: SQL that would be executed --
+          console.log(chalk10.dim(`-- Dry run: SQL that would be executed --
 `));
           for (const sql of PG_MIGRATIONS2)
             console.log(sql);
@@ -50060,14 +50350,14 @@ registerCloudCommands(program2, "conversations");
         }
         const pg = new PgAdapterAsync2(getConnectionString2("conversations"));
         for (let i = 0;i < PG_MIGRATIONS2.length; i++) {
-          process.stdout.write(chalk9.dim(`Running migration ${i + 1}/${PG_MIGRATIONS2.length}...`));
+          process.stdout.write(chalk10.dim(`Running migration ${i + 1}/${PG_MIGRATIONS2.length}...`));
           await pg.run(PG_MIGRATIONS2[i]);
-          console.log(chalk9.green(" done"));
+          console.log(chalk10.green(" done"));
         }
         await pg.close();
-        console.log(chalk9.green("\u2713 All migrations applied."));
+        console.log(chalk10.green("\u2713 All migrations applied."));
       } catch (e) {
-        console.error(chalk9.red(`Migration failed: ${e?.message ?? e}`));
+        console.error(chalk10.red(`Migration failed: ${e?.message ?? e}`));
         process.exit(1);
       }
     });
@@ -50075,8 +50365,8 @@ registerCloudCommands(program2, "conversations");
 }
 program2.action(() => {
   if (!process.stdin.isTTY) {
-    console.error(chalk9.red("Interactive mode requires a TTY terminal."));
-    console.error(chalk9.dim("Use subcommands (send, read, sessions, etc.) for non-interactive use."));
+    console.error(chalk10.red("Interactive mode requires a TTY terminal."));
+    console.error(chalk10.dim("Use subcommands (send, read, sessions, etc.) for non-interactive use."));
     process.exit(1);
   }
   const agent = resolveIdentity();

package/bin/mcp.js

@@ -44049,10 +44049,198 @@ function formatError2(e) {
     return e.message;
   return String(e);
 }
+
+// src/mcp/channel.ts
+var POLL_INTERVAL_MS = 1000;
+function registerChannelBridge(server, getAgentId) {
+  server.server.registerCapabilities({
+    experimental: {
+      "claude/channel": {}
+    }
+  });
+  let lastSeenId = 0;
+  let pollTimer = null;
+  function seedLastSeen(agentId) {
+    const latest = readMessages({
+      to: agentId,
+      order: "desc",
+      limit: 1
+    });
+    if (latest.length > 0) {
+      lastSeenId = latest[0].id;
+    }
+  }
+  function startPolling() {
+    if (pollTimer)
+      return;
+    const agentId = getAgentId();
+    if (!agentId)
+      return;
+    seedLastSeen(agentId);
+    pollTimer = setInterval(() => {
+      const currentAgent = getAgentId();
+      if (!currentAgent)
+        return;
+      try {
+        const newMessages = readMessages({
+          to: currentAgent,
+          order: "asc",
+          limit: 20
+        }).filter((m) => m.id > lastSeenId);
+        for (const msg of newMessages) {
+          lastSeenId = msg.id;
+          server.server.notification({
+            method: "notifications/claude/channel",
+            params: {
+              content: msg.content,
+              meta: {
+                from: msg.from_agent,
+                session_id: msg.session_id,
+                ...msg.space ? { space: msg.space } : {},
+                ...msg.priority !== "normal" ? { priority: msg.priority } : {}
+              }
+            }
+          });
+        }
+      } catch {}
+    }, POLL_INTERVAL_MS);
+  }
+  setTimeout(() => startPolling(), 500);
+}
+
+// src/cli/commands/tmux.ts
+import { execSync } from "child_process";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function countLines(message) {
+  const matches = message.match(/\r?\n/g);
+  return (matches?.length ?? 0) + 1;
+}
+function getDefaultDelayMs(message) {
+  const byLength = message.length * 1.5;
+  const byLines = countLines(message) * 10;
+  return Math.max(25, Math.min(1500, Math.round(byLength + byLines)));
+}
+function getVerifyPauseMs(message) {
+  return message.length <= 120 ? 50 : 100;
+}
+function getRetryBackoffMs(attempt) {
+  return Math.min(500, 100 * attempt);
+}
+async function tmuxSend(target, message, opts = {}) {
+  const delay = opts.delayMs ?? getDefaultDelayMs(message);
+  const maxRetries = opts.retries ?? 3;
+  const verify = opts.verify !== false;
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    execSync(`tmux send-keys -t ${JSON.stringify(target)} -l ${JSON.stringify(message)}`);
+    await sleep(delay);
+    execSync(`tmux send-keys -t ${JSON.stringify(target)} Enter`);
+    if (!verify)
+      return { success: true, attempts: attempt };
+    await sleep(getVerifyPauseMs(message));
+    const pane = execSync(`tmux capture-pane -t ${JSON.stringify(target)} -p`).toString();
+    const lastLines = pane.split(`
+`).slice(-6).join(`
+`);
+    const marker = message.slice(0, Math.min(32, message.length));
+    if (!lastLines.includes(marker)) {
+      return { success: true, attempts: attempt };
+    }
+    if (attempt < maxRetries)
+      await sleep(getRetryBackoffMs(attempt));
+  }
+  return { success: false, attempts: maxRetries };
+}
+
+// src/mcp/tools/tmux.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function registerTmuxTools(server) {
+  server.registerTool("tmux_send", {
+    description: "Send a message to a tmux window (e.g. another agent's Claude Code session). " + "Pastes the text literally, waits for the pane to be idle, hits Enter, then verifies the message was submitted. " + "Retries up to N times on failure.",
+    inputSchema: {
+      target: exports_external.string().describe("Tmux target: session:window or session:window.pane (e.g. platform-alumia:1)"),
+      message: exports_external.string().describe("Message text to send"),
+      delay_ms: exports_external.coerce.number().optional().describe("Wait time (ms) after paste before hitting Enter. Default: adaptive 25-1500ms"),
+      retries: exports_external.coerce.number().optional().describe("Max retry attempts (default: 3)"),
+      verify: exports_external.coerce.boolean().optional().describe("Verify message was submitted after Enter (default: true)")
+    }
+  }, async (args) => {
+    const { target, message, delay_ms, retries, verify } = args;
+    if (!target || !target.trim()) {
+      return { content: [{ type: "text", text: "target is required" }], isError: true };
+    }
+    if (!message || !message.trim()) {
+      return { content: [{ type: "text", text: "message cannot be empty" }], isError: true };
+    }
+    try {
+      const result = await tmuxSend(target.trim(), message, {
+        delayMs: typeof delay_ms === "number" && delay_ms > 0 ? delay_ms : undefined,
+        retries: typeof retries === "number" && retries > 0 ? retries : undefined,
+        verify: verify !== false
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ target, result }) }],
+        isError: !result.success
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: `tmux error: ${msg}` }], isError: true };
+    }
+  });
+  server.registerTool("tmux_broadcast", {
+    description: "Send the same message to multiple tmux windows simultaneously. " + "Useful for broadcasting instructions to several agent sessions at once. " + "Supports staggered sending and per-target retry.",
+    inputSchema: {
+      targets: exports_external.array(exports_external.string()).describe("List of tmux targets (session:window or session:window.pane)"),
+      message: exports_external.string().describe("Message text to send to all targets"),
+      delay_ms: exports_external.coerce.number().optional().describe("Wait time (ms) after paste before Enter. Default: adaptive 25-1500ms"),
+      stagger_ms: exports_external.coerce.number().optional().describe("Delay (ms) between sending to each target (default: 500)"),
+      retries: exports_external.coerce.number().optional().describe("Max retry attempts per target (default: 3)"),
+      verify: exports_external.coerce.boolean().optional().describe("Verify each message was submitted (default: true)")
+    }
+  }, async (args) => {
+    const { targets, message, delay_ms, stagger_ms, retries, verify } = args;
+    if (!Array.isArray(targets) || targets.length === 0) {
+      return { content: [{ type: "text", text: "targets must be a non-empty array" }], isError: true };
+    }
+    if (!message || !message.trim()) {
+      return { content: [{ type: "text", text: "message cannot be empty" }], isError: true };
+    }
+    const stagger = typeof stagger_ms === "number" && stagger_ms >= 0 ? stagger_ms : 500;
+    const results = new Array(targets.length);
+    await Promise.all(targets.map(async (rawTarget, i) => {
+      const target = String(rawTarget).trim();
+      if (i > 0 && stagger > 0)
+        await sleep2(stagger * i);
+      try {
+        const result = await tmuxSend(target, message, {
+          delayMs: typeof delay_ms === "number" && delay_ms > 0 ? delay_ms : undefined,
+          retries: typeof retries === "number" && retries > 0 ? retries : undefined,
+          verify: verify !== false
+        });
+        results[i] = { target, ...result };
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        results[i] = { target, success: false, attempts: 0, error: errMsg };
+      }
+    }));
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.length - succeeded;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ results, succeeded, failed, total: results.length })
+      }],
+      isError: failed > 0
+    };
+  });
+}
 // package.json
 var package_default = {
   name: "@hasna/conversations",
-  version: "0.2.29",
+  version: "0.2.31",
   description: "Real-time CLI messaging for AI agents",
   type: "module",
   bin: {
@@ -44154,6 +44342,8 @@ registerSpaceTools(server);
 registerProjectTools(server);
 registerAgentTools(server, agentFocus, getAgentFocus);
 registerAdvancedTools(server, package_default.version);
+registerTmuxTools(server);
+registerChannelBridge(server, () => process.env.CONVERSATIONS_AGENT_ID ?? null);
 async function startMcpServer() {
   const transport = new StdioServerTransport;
   registerCloudSyncTools(server);

package/dist/cli/commands/tmux.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+interface TmuxSendOptions {
+    delayMs?: number;
+    retries?: number;
+    verify?: boolean;
+}
+interface TmuxSendResult {
+    success: boolean;
+    attempts: number;
+}
+export declare function tmuxSend(target: string, message: string, opts?: TmuxSendOptions): Promise<TmuxSendResult>;
+export declare function registerTmuxCommands(program: Command): void;
+export {};

package/dist/mcp/channel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Claude Code channel bridge for conversations MCP server.
+ *
+ * Declares `experimental['claude/channel']` capability so Claude Code
+ * (and agent-claude) can use this server as a channel for inter-session
+ * messaging. When enabled, polls for new DMs to the current agent and
+ * pushes them as `notifications/claude/channel` events.
+ *
+ * Usage: Start agent-claude with:
+ *   agent-claude --channels server:conversations --dangerously-load-development-channels
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register the claude/channel capability and start polling for
+ * inbound messages to push as notifications.
+ */
+export declare function registerChannelBridge(server: McpServer, getAgentId: () => string | null): void;

package/dist/mcp/tools/tmux.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tmux dispatch tools: tmux_send, tmux_broadcast
+ *
+ * Send messages to tmux windows (other Claude Code sessions) with
+ * smart paste → wait → Enter → verify behavior.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTmuxTools(server: McpServer): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/conversations",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "description": "Real-time CLI messaging for AI agents",
   "type": "module",
   "bin": {
@@ -77,4 +77,4 @@
     "url": "https://github.com/hasna/conversations/issues"
   },
   "homepage": "https://github.com/hasna/conversations#readme"
-}
+}