@linghun/tui 0.1.0

package/dist/chunk-66BNE332.js

@@ -0,0 +1,1617 @@
+import {
+  buildOfficialCliInvocation,
+  buildWebhookRequest,
+  defaultRemoteTransportDeps,
+  deliverOfficialCli,
+  deliverWebhook
+} from "./chunk-UT5BOJKU.js";
+import {
+  formatRemoteStatus,
+  formatRemoteTestResult
+} from "./chunk-W6NU7ZAV.js";
+import {
+  startFeishuLongConnection
+} from "./chunk-WJWYRBWH.js";
+import {
+  cancelRemotePairing,
+  clearRemoteInbox,
+  createRemotePairing,
+  createSignedRemoteInboundFixture,
+  drainRemoteInbox,
+  formatRemoteBridgeDoctor,
+  formatRemoteInbox,
+  formatRemotePairing,
+  formatRemotePairingStatus,
+  getRemoteBridgeDoctor,
+  rejectRemoteInboxItem
+} from "./chunk-CFXB5SE5.js";
+import {
+  showCommandPanel
+} from "./chunk-JO5ANTMR.js";
+import {
+  redactRemoteSummary,
+  remoteTranscriptSummary
+} from "./chunk-J7ZE2JKP.js";
+import {
+  applyRemoteSessionDisables,
+  createRemoteState
+} from "./chunk-QLRTQHTR.js";
+import {
+  createDefaultReplBridgeSocketPath,
+  createReplBridgeState,
+  handleReplBridgeMessage,
+  maybeRefreshJwtToken,
+  startReplBridgeSocketServer
+} from "./chunk-4EP3TUFF.js";
+import {
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/remote-command-runtime.ts
+import { randomUUID } from "crypto";
+var runtimeDeps;
+var remoteTransportDeps;
+var feishuLongConnectionHandles = /* @__PURE__ */ new Map();
+function configureRemoteCommandRuntime(deps2) {
+  runtimeDeps = deps2;
+}
+function configureRemoteTransport(deps2) {
+  remoteTransportDeps = deps2;
+}
+function deps() {
+  if (!runtimeDeps) {
+    throw new Error("remote-command-runtime deps not configured");
+  }
+  return runtimeDeps;
+}
+function refreshRemoteState(context) {
+  const previous = context.remote;
+  context.remote = createRemoteState(context.config);
+  context.remote.events = previous.events;
+  context.remote.processedMessageIds = previous.processedMessageIds;
+  context.remote.sessionDisabledChannelIds = previous.sessionDisabledChannelIds;
+  context.remote.localReplBridge = previous.localReplBridge;
+  context.remote.localReplBridgeSocket = previous.localReplBridgeSocket;
+  context.remote.lastDoctor = previous.lastDoctor;
+  context.remote.lastApproval = previous.lastApproval;
+  applyRemoteSessionDisables(context.remote);
+}
+async function handleRemoteCommand(args, context, output) {
+  refreshRemoteState(context);
+  const action = args[0] ?? "status";
+  if (action === "status") {
+    const isEn = context.language === "en-US";
+    const enabled = context.remote.enabled;
+    const lastDoctor = context.remote.lastDoctor;
+    const summary = [
+      isEn ? `Remote ${enabled ? "enabled" : "disabled"}` : `\u8FDC\u7A0B ${enabled ? "\u5DF2\u542F\u7528" : "\u672A\u542F\u7528"}`
+    ];
+    if (!lastDoctor) {
+      summary.push(
+        isEn ? "Not yet diagnosed \u2014 run /remote doctor." : "\u5C1A\u672A\u8BCA\u65AD \u2014 \u8FD0\u884C /remote doctor\u3002"
+      );
+    }
+    showCommandPanel(context, output, {
+      title: "/remote",
+      tone: "neutral",
+      summary,
+      actions: ["/remote doctor"],
+      detailsText: formatRemoteStatus(context.remote)
+    });
+    return;
+  }
+  if (action === "doctor") {
+    const report = formatRemoteDoctor(context);
+    context.remote.lastDoctor = report;
+    await appendRemoteSystemEvent(
+      context,
+      `remote_doctor ${remoteTranscriptSummary(report)}`,
+      "info"
+    );
+    showCommandPanel(context, output, {
+      title: "/remote doctor",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? "Remote doctor \u2014 Ctrl+O for details." : "\u8FDC\u7A0B\u8BCA\u65AD \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002"
+      ],
+      detailsText: report
+    });
+    return;
+  }
+  if (action === "setup") {
+    showCommandPanel(context, output, {
+      title: "/remote setup",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? "Remote setup now recommends /remote bot setup <channel> \u2014 Ctrl+O for details." : "\u8FDC\u7A0B\u63A5\u5165\u73B0\u5728\u63A8\u8350 /remote bot setup <channel> \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002"
+      ],
+      detailsText: [
+        formatRemoteBotSetupDetails(context, args[1]),
+        "",
+        "Legacy /remote setup details\uFF08compatibility\uFF09",
+        formatRemoteSetup(args[1], context)
+      ].join("\n")
+    });
+    return;
+  }
+  if (action === "test") {
+    const channel = findRemoteChannel(context, args[1]);
+    if (!channel) {
+      writeLine(output, "Remote test\uFF1A\u672A\u8BC6\u522B\u901A\u9053\u3002\u7528\u6CD5\uFF1A/remote test feishu|wecom|dingtalk");
+      return;
+    }
+    const event = createRemoteEvent(
+      channel,
+      "job_status",
+      "Remote channel test: Linghun redacted summary only.",
+      [],
+      5 * 60 * 1e3
+    );
+    const result = await sendRemoteEventReal(context, event);
+    const ok = result.status === "sent";
+    await appendRemoteSystemEvent(
+      context,
+      `remote_test channel=${channel.id} status=${result.status} detail=${result.deliveryDetail ?? "none"} summary=${event.redactedSummary}`,
+      ok ? "info" : "warning"
+    );
+    showCommandPanel(context, output, {
+      title: "/remote test",
+      tone: ok ? "neutral" : result.status === "mock" ? "neutral" : "warning",
+      summary: [
+        context.language === "en-US" ? `Remote test ${channel.id} \xB7 ${result.status} \u2014 Ctrl+O for details.` : `\u8FDC\u7A0B\u6D4B\u8BD5 ${channel.id} \xB7 ${result.status} \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatRemoteTestResult(channel, result)
+    });
+    return;
+  }
+  if (action === "disable") {
+    const channel = findRemoteChannel(context, args[1]);
+    if (!channel) {
+      writeLine(output, "Remote disable\uFF1A\u672A\u8BC6\u522B\u901A\u9053\u3002\u7528\u6CD5\uFF1A/remote disable feishu|wecom|dingtalk");
+      return;
+    }
+    if (!context.remote.sessionDisabledChannelIds.includes(channel.id)) {
+      context.remote.sessionDisabledChannelIds.push(channel.id);
+    }
+    channel.runtimeStatus = "disabled";
+    channel.lastError = "disabled_by_user";
+    channel.nextAction = `/remote setup ${channel.id}`;
+    await appendRemoteSystemEvent(context, `remote_disabled channel=${channel.id}`, "info");
+    showCommandPanel(context, output, {
+      title: "/remote disable",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Remote channel disabled: ${channel.id} \u2014 Ctrl+O for details.` : `\u5DF2\u7981\u7528\u8FDC\u7A0B\u901A\u9053\uFF1A${channel.id} \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: `Remote channel disabled\uFF1A${channel.id}
+- \u672C\u5730 TUI \u4E0D\u53D7\u5F71\u54CD\u3002
+- \u5982\u9700\u91CD\u65B0\u8FDE\u63A5\uFF1A/remote setup ${channel.id}`
+    });
+    return;
+  }
+  if (action === "events") {
+    showCommandPanel(context, output, {
+      title: "/remote events",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Recent remote events: ${context.remote.events.length} \u2014 Ctrl+O for details.` : `\u6700\u8FD1\u8FDC\u7A0B\u4E8B\u4EF6\uFF1A${context.remote.events.length} \u6761 \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatRemoteEvents(context)
+    });
+    return;
+  }
+  if (action === "inbox") {
+    await handleRemoteInboxCommand(args.slice(1), context, output);
+    return;
+  }
+  if (action === "bridge") {
+    await handleRemoteBridgeCommand(args.slice(1), context, output);
+    return;
+  }
+  if (action === "bot") {
+    await handleRemoteBotCommand(args.slice(1), context, output);
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/remote bot doctor|setup|start|stop|pair|inbox <channel> | /remote setup <channel> | /remote test <channel> | /remote status | /remote doctor | /remote events | /remote inbox | /remote bridge doctor|pair|start|test-inbound|test-approval|test-status <channel> | /remote disable <channel>"
+  );
+}
+async function handleRemoteBotCommand(args, context, output) {
+  const action = args[0] ?? "doctor";
+  if (action === "inbox") {
+    await handleRemoteInboxCommand(args.slice(1), context, output);
+    return;
+  }
+  if (action === "doctor") {
+    const channelArg = args[1];
+    showCommandPanel(context, output, {
+      title: "/remote bot doctor",
+      tone: "neutral",
+      summary: [formatRemoteBotDoctorSummary(context, channelArg)],
+      detailsText: formatRemoteBotDoctorDetails(context, channelArg)
+    });
+    return;
+  }
+  if (action === "setup") {
+    const channelArg = args[1];
+    showCommandPanel(context, output, {
+      title: "/remote bot setup",
+      tone: "neutral",
+      summary: [formatRemoteBotSetupSummary(context, channelArg)],
+      detailsText: formatRemoteBotSetupDetails(context, channelArg)
+    });
+    return;
+  }
+  if (action === "start") {
+    const channelArg = normalizeRemoteChannelId(args[1] ?? "");
+    if (channelArg === "feishu") {
+      const channel = findRemoteChannel(context, channelArg);
+      if (!channel) {
+        writeLine(output, "Remote bot start\uFF1A\u672A\u8BC6\u522B Feishu Bot \u914D\u7F6E\u3002");
+        return;
+      }
+      const result = await startRemoteFeishuBridge(context, output, channel, "bot");
+      showCommandPanel(context, output, {
+        title: "/remote bot start feishu",
+        tone: result.status === "started" || result.status === "already_running" ? "neutral" : "warning",
+        summary: [toRemoteBotStartSummary("feishu", result.status)],
+        detailsText: [
+          toRemoteBotStartSummary("feishu", result.status),
+          result.detail,
+          "Bot path: Feishu messages enter RemoteInboundMessage -> handleRemoteInboundMessage; no second executor."
+        ].join("\n")
+      });
+      return;
+    }
+    showCommandPanel(context, output, {
+      title: `/remote bot start ${channelArg || "<channel>"}`,
+      tone: "warning",
+      summary: [formatRemoteBotStartBlockedSummary(channelArg)],
+      detailsText: [
+        formatRemoteBotStartBlockedSummary(channelArg),
+        formatRemoteBotSetupDetails(context, channelArg)
+      ].join("\n")
+    });
+    return;
+  }
+  if (action === "stop") {
+    const channelArg = normalizeRemoteChannelId(args[1] ?? "");
+    const stopped = await stopRemoteBotChannel(channelArg);
+    showCommandPanel(context, output, {
+      title: `/remote bot stop ${channelArg || "<channel>"}`,
+      tone: "neutral",
+      summary: [
+        stopped ? `Remote Bot ${channelArg} stopped.` : `Remote Bot ${channelArg || "channel"} is not running.`
+      ],
+      detailsText: stopped ? `Remote Bot ${channelArg} stopped.
+Long connection handle was closed in this process. Secrets were not printed.` : "No active long connection handle exists in this process."
+    });
+    return;
+  }
+  if (action === "pair") {
+    const channelArg = normalizeRemoteChannelId(args[1] ?? "");
+    if (channelArg === "wechat") {
+      showCommandPanel(context, output, {
+        title: "/remote bot pair wechat",
+        tone: "warning",
+        summary: [
+          "Personal WeChat Bot pairing is experimental and blocked until an opt-in plugin bridge exists."
+        ],
+        detailsText: formatWechatBotExperimentalDetails()
+      });
+      return;
+    }
+    const channel = findRemoteChannel(context, channelArg);
+    if (!channel) {
+      writeLine(
+        output,
+        "Remote bot pair\uFF1A\u672A\u8BC6\u522B\u901A\u9053\u3002\u7528\u6CD5\uFF1A/remote bot pair feishu|dingtalk|wechat"
+      );
+      return;
+    }
+    const pairing = createRemotePairing(
+      context.remote,
+      channel,
+      context.projectPath,
+      await deps().ensureSession(context)
+    );
+    await appendRemoteSystemEvent(
+      context,
+      `remote_bot_pair channel=${channel.id} status=${pairing.status} expiresAt=${pairing.status === "created" ? pairing.pairing.expiresAt : "none"}`,
+      "info"
+    );
+    showCommandPanel(context, output, {
+      title: `/remote bot pair ${channel.id}`,
+      tone: pairing.status === "created" ? "neutral" : "warning",
+      summary: [
+        pairing.status === "created" ? `Bot pairing code ${pairing.pairing.code} \u2014 send /bind CODE from your Bot chat.` : pairing.summary
+      ],
+      detailsText: [
+        pairing.status === "created" ? `Bot pairing code ${pairing.pairing.code} \u2014 send /bind CODE from your Bot chat.` : pairing.summary,
+        formatRemotePairing(pairing)
+      ].join("\n")
+    });
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/remote bot doctor [channel] | /remote bot setup feishu|dingtalk|wechat | /remote bot start feishu|dingtalk|wechat | /remote bot stop <channel> | /remote bot pair <channel> | /remote bot inbox"
+  );
+}
+async function handleRemoteInboxCommand(args, context, output) {
+  const action = args[0] ?? "list";
+  let detail = formatRemoteInbox(context.remote);
+  if (action === "clear") {
+    const count = clearRemoteInbox(context.remote);
+    detail = `Remote inbox cleared\uFF1A${count}`;
+  } else if (action === "reject") {
+    const id = args[1] ?? "";
+    detail = rejectRemoteInboxItem(context.remote, id) ? `Remote inbox rejected\uFF1A${id}` : `Remote inbox item not found\uFF1A${id}`;
+  } else if (action === "drain") {
+    const drained = drainRemoteInbox(context.remote);
+    detail = `Remote inbox drain/export and clear\uFF1A${drained.length}
+${drained.map((item) => `- ${item.id}: ${item.channel}; ${item.text}`).join(
+      "\n"
+    )}
+These messages were exported and cleared only; they were not sent to sendMessage.`;
+  }
+  await appendRemoteSystemEvent(
+    context,
+    `remote_inbox action=${action} size=${context.remote.inbox.length}`,
+    "info"
+  );
+  showCommandPanel(context, output, {
+    title: "/remote inbox",
+    tone: "neutral",
+    summary: [
+      context.language === "en-US" ? `Remote inbox: ${context.remote.inbox.length} queued \u2014 Ctrl+O for details.` : `\u8FDC\u7A0B\u6536\u4EF6\u7BB1\uFF1A${context.remote.inbox.length} \u6761\u6392\u961F \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+    ],
+    detailsText: detail
+  });
+}
+async function handleRemoteBridgeCommand(args, context, output) {
+  const action = args[0] ?? "doctor";
+  if (action === "pair" && args[1] === "status") {
+    showCommandPanel(context, output, {
+      title: "/remote bridge pair status",
+      tone: "neutral",
+      summary: ["Remote pairing status \u2014 Ctrl+O for details."],
+      detailsText: formatRemotePairingStatus(context.remote)
+    });
+    return;
+  }
+  if (action === "pair" && args[1] === "cancel") {
+    const decision = cancelRemotePairing(context.remote, args[2]);
+    await appendRemoteSystemEvent(context, `remote_pair_cancel status=${decision.status}`, "info");
+    showCommandPanel(context, output, {
+      title: "/remote bridge pair cancel",
+      tone: decision.status === "cancelled" ? "neutral" : "warning",
+      summary: [decision.summary],
+      detailsText: decision.summary
+    });
+    return;
+  }
+  if (action === "start") {
+    const channel2 = findRemoteChannel(context, args[1]);
+    if (!channel2) {
+      writeLine(output, "Remote bridge start\uFF1A\u672A\u8BC6\u522B\u901A\u9053\u3002\u7528\u6CD5\uFF1A/remote bridge start feishu");
+      return;
+    }
+    if (channel2.id !== "feishu" && channel2.config.type !== "lark") {
+      writeLine(output, "Remote bridge start\uFF1A\u5F53\u524D\u53EA\u652F\u6301 feishu/lark \u957F\u8FDE\u63A5\u3002");
+      return;
+    }
+    const result = await startRemoteFeishuBridge(context, output, channel2);
+    showCommandPanel(context, output, {
+      title: "/remote bridge start",
+      tone: result.status === "started" || result.status === "already_running" ? "neutral" : "warning",
+      summary: [result.summary],
+      detailsText: result.detail
+    });
+    return;
+  }
+  if (action === "local-register") {
+    const clientId = args[1] ?? "local";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "register",
+      clientId
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-register",
+      tone: "neutral",
+      summary: [`Local REPL bridge ${decision.status}: ${clientId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-listen") {
+    const socketPath = args[1] ?? createDefaultReplBridgeSocketPath(context.projectPath);
+    if (context.remote.localReplBridgeSocket) {
+      showCommandPanel(context, output, {
+        title: "/remote bridge local-listen",
+        tone: "neutral",
+        summary: [`Local REPL bridge socket already listening: ${context.remote.localReplBridgeSocket.socketPath}`],
+        detailsText: "Existing local REPL bridge socket is active in this process."
+      });
+      return;
+    }
+    const handle = await startReplBridgeSocketServer({
+      socketPath,
+      bridge: () => ensureLocalReplBridge(context),
+      remote: () => context.remote
+    });
+    context.remote.localReplBridgeSocket = handle;
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-listen",
+      tone: "neutral",
+      summary: [`Local REPL bridge socket listening: ${handle.socketPath}`],
+      detailsText: [
+        `socketPath: ${handle.socketPath}`,
+        "Protocol: JSONL ReplBridgeMessage in, ReplBridgeDecision out.",
+        "Messages still require /remote bridge local-route or an existing inbound handler path; no second executor was created."
+      ].join("\n")
+    });
+    return;
+  }
+  if (action === "local-close") {
+    const handle = context.remote.localReplBridgeSocket;
+    if (!handle) {
+      showCommandPanel(context, output, {
+        title: "/remote bridge local-close",
+        tone: "neutral",
+        summary: ["Local REPL bridge socket is not listening."],
+        detailsText: "No active local REPL bridge socket exists in this process."
+      });
+      return;
+    }
+    await handle.close();
+    context.remote.localReplBridgeSocket = void 0;
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-close",
+      tone: "neutral",
+      summary: [`Local REPL bridge socket closed: ${handle.socketPath}`],
+      detailsText: "Local REPL bridge socket closed; queued bridge state remains in this session."
+    });
+    return;
+  }
+  if (action === "local-inbound") {
+    const clientId = args[1] ?? "local";
+    const text = args.slice(2).join(" ").trim();
+    if (!text) {
+      writeLine(output, "\u7528\u6CD5\uFF1A/remote bridge local-inbound <clientId> <text>");
+      return;
+    }
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "inbound",
+      clientId,
+      text
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-inbound",
+      tone: decision.status === "accepted" ? "neutral" : "warning",
+      summary: [`Local REPL bridge ${decision.status}: ${clientId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-poll") {
+    const clientId = args[1] ?? "local";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "poll",
+      clientId
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-poll",
+      tone: decision.status === "polled" ? "neutral" : "warning",
+      summary: [
+        decision.status === "polled" ? `Local REPL bridge polled: ${(decision.messages ?? []).length} message(s)` : `Local REPL bridge ${decision.status}`
+      ],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-route") {
+    const clientId = args[1] ?? "local";
+    const inbound = deps().handleRemoteInboundMessage;
+    if (!inbound) {
+      showCommandPanel(context, output, {
+        title: "/remote bridge local-route",
+        tone: "warning",
+        summary: ["Local REPL bridge route blocked: inbound handler unavailable."],
+        detailsText: "Local bridge messages must route through handleRemoteInboundMessage; no fallback executor was used."
+      });
+      return;
+    }
+    const poll = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "poll",
+      clientId
+    });
+    if (poll.status !== "polled") {
+      showCommandPanel(context, output, {
+        title: "/remote bridge local-route",
+        tone: "warning",
+        summary: [`Local REPL bridge ${poll.status}: ${clientId}`],
+        detailsText: JSON.stringify(poll, null, 2)
+      });
+      return;
+    }
+    let routed = 0;
+    const decisions = [];
+    for (const message of poll.messages) {
+      const decision = await inbound(message, context, void 0, output);
+      decisions.push(`${message.messageId}: ${decision.status}`);
+      if (decision.status === "accepted" || decision.status === "approved") {
+        routed += 1;
+        handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+          type: "acknowledge",
+          clientId,
+          messageId: message.messageId
+        });
+      }
+    }
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-route",
+      tone: "neutral",
+      summary: [`Local REPL bridge routed: ${routed}/${poll.messages.length} message(s)`],
+      detailsText: [
+        "Messages were routed through handleRemoteInboundMessage; no second executor was used.",
+        ...decisions
+      ].join("\n")
+    });
+    return;
+  }
+  if (action === "local-ack") {
+    const clientId = args[1] ?? "local";
+    const messageId = args[2] ?? "";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "acknowledge",
+      clientId,
+      messageId
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-ack",
+      tone: decision.status === "acknowledged" ? "neutral" : "warning",
+      summary: [`Local REPL bridge ${decision.status}: ${messageId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-heartbeat") {
+    const clientId = args[1] ?? "local";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "heartbeat",
+      clientId,
+      now: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-heartbeat",
+      tone: decision.status === "heartbeat" ? "neutral" : "warning",
+      summary: [`Local REPL bridge ${decision.status}: ${clientId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-stop") {
+    const clientId = args[1] ?? "local";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "stop",
+      clientId,
+      reason: "user requested stop"
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-stop",
+      tone: "neutral",
+      summary: [`Local REPL bridge ${decision.status}: ${clientId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "local-deregister") {
+    const clientId = args[1] ?? "local";
+    const decision = handleReplBridgeMessage(ensureLocalReplBridge(context), context.remote, {
+      type: "deregister",
+      clientId
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge local-deregister",
+      tone: decision.status === "deregistered" ? "neutral" : "warning",
+      summary: [`Local REPL bridge ${decision.status}: ${clientId}`],
+      detailsText: JSON.stringify(decision, null, 2)
+    });
+    return;
+  }
+  if (action === "jwt-refresh-check") {
+    const result = await maybeRefreshJwtToken({
+      token: args[1],
+      expiresAt: args[2],
+      refresh: async () => ({
+        token: "refreshed-token-redacted",
+        expiresAt: new Date(Date.now() + 60 * 60 * 1e3).toISOString()
+      })
+    });
+    showCommandPanel(context, output, {
+      title: "/remote bridge jwt-refresh-check",
+      tone: "neutral",
+      summary: [`JWT refresh: ${result.refreshed ? "refreshed" : result.reason}`],
+      detailsText: JSON.stringify(
+        result.refreshed ? { ...result, token: "[REDACTED]" } : result,
+        null,
+        2
+      )
+    });
+    return;
+  }
+  const channel = findRemoteChannel(context, args[1]);
+  if (!channel) {
+    writeLine(
+      output,
+      "Remote bridge\uFF1A\u672A\u8BC6\u522B\u901A\u9053\u3002\u7528\u6CD5\uFF1A/remote bridge doctor|pair|start|test-inbound|test-approval|test-status feishu|dingtalk|wecom"
+    );
+    return;
+  }
+  const report = getRemoteBridgeDoctor(context.remote, channel.id);
+  if (action === "pair") {
+    if (report.readiness === "notification-only") {
+      showCommandPanel(context, output, {
+        title: "/remote bridge pair",
+        tone: "warning",
+        summary: [
+          context.language === "en-US" ? "Pairing blocked: webhook is notification-only." : "\u7ED1\u5B9A\u88AB\u963B\u65AD\uFF1Awebhook \u53EA\u80FD\u901A\u77E5\uFF0C\u4E0D\u80FD\u771F\u5B9E\u7ED1\u5B9A\u3002"
+        ],
+        detailsText: [
+          formatRemoteBridgeDoctor(report),
+          "Pairing needs a platform app plus callback/daemon; do not treat webhook as mobile control."
+        ].join("\n")
+      });
+      return;
+    }
+    const pairing = createRemotePairing(
+      context.remote,
+      channel,
+      context.projectPath,
+      await deps().ensureSession(context)
+    );
+    await appendRemoteSystemEvent(
+      context,
+      `remote_pair_create channel=${channel.id} status=${pairing.status} expiresAt=${pairing.status === "created" ? pairing.pairing.expiresAt : "none"}`,
+      "info"
+    );
+    showCommandPanel(context, output, {
+      title: "/remote bridge pair",
+      tone: "neutral",
+      summary: [
+        pairing.status === "created" ? `Pairing code ${pairing.pairing.code} \u2014 Ctrl+O for details.` : pairing.summary
+      ],
+      detailsText: formatRemotePairing(pairing)
+    });
+    return;
+  }
+  if (action === "doctor") {
+    showCommandPanel(context, output, {
+      title: "/remote bridge doctor",
+      tone: report.readiness === "notification-only" ? "warning" : "neutral",
+      summary: [
+        context.language === "en-US" ? `Bridge ${channel.id}: ${report.readiness} \u2014 Ctrl+O for details.` : `\u624B\u673A\u6865\u63A5 ${channel.id}: ${report.readiness} \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatRemoteBridgeDoctor(report)
+    });
+    return;
+  }
+  if (action === "test-inbound" || action === "test-status" || action === "test-approval") {
+    if (!report.canRunLocalFixture) {
+      showCommandPanel(context, output, {
+        title: `/remote bridge ${action}`,
+        tone: "warning",
+        summary: [
+          context.language === "en-US" ? `Bridge fixture blocked: ${report.readiness} \u2014 Ctrl+O for details.` : `\u6865\u63A5 fixture \u88AB\u963B\u65AD\uFF1A${report.readiness} \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+        ],
+        detailsText: formatRemoteBridgeDoctor(report)
+      });
+      return;
+    }
+    const kind = action === "test-approval" ? "approval_response" : action === "test-status" ? "status_query" : "natural_language_message";
+    const event = kind === "approval_response" ? context.remote.events.find(
+      (item) => item.channel === channel.id && item.eventType === "approval_request"
+    ) : void 0;
+    const fixture = createSignedRemoteInboundFixture(channel, {
+      kind,
+      text: kind === "natural_language_message" ? "D.14F deterministic bridge fixture" : void 0,
+      eventId: event?.id,
+      nonce: event?.nonce,
+      approve: kind === "approval_response" ? true : void 0
+    });
+    const decision = processRemoteInbound(context, fixture);
+    await appendRemoteSystemEvent(
+      context,
+      `remote_bridge_fixture channel=${channel.id} kind=${kind} status=${decision.status} summary=${decision.summary}`,
+      decision.status === "accepted" || decision.status === "approved" ? "info" : "warning"
+    );
+    showCommandPanel(context, output, {
+      title: `/remote bridge ${action}`,
+      tone: decision.status === "accepted" || decision.status === "approved" ? "neutral" : "warning",
+      summary: [
+        context.language === "en-US" ? `Bridge fixture ${channel.id}: ${decision.status} \u2014 Ctrl+O for details.` : `\u6865\u63A5 fixture ${channel.id}: ${decision.status} \u2014 Ctrl+O \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: [
+        formatRemoteBridgeDoctor(report),
+        `fixture kind: ${kind}`,
+        `decision: ${decision.status}`,
+        `summary: ${decision.summary}`
+      ].join("\n")
+    });
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/remote bridge doctor|pair|start|test-inbound|test-approval|test-status feishu|dingtalk|wecom | local-listen|local-close|local-register|local-inbound|local-poll|local-route|local-ack|local-heartbeat|local-stop|local-deregister"
+  );
+}
+function ensureLocalReplBridge(context) {
+  if (!context.remote.localReplBridge) {
+    context.remote.localReplBridge = createReplBridgeState();
+  }
+  return context.remote.localReplBridge;
+}
+async function startRemoteFeishuBridge(context, output, channel, readinessMode = "bridge") {
+  const report = readinessMode === "bridge" ? getRemoteBridgeDoctor(context.remote, channel.id) : void 0;
+  const botReadiness = readinessMode === "bot" ? getFeishuBotStartReadiness(channel) : void 0;
+  const blockedDetail = botReadiness ? formatFeishuBotStartReadiness(botReadiness) : report ? formatRemoteBridgeDoctor(report) : "";
+  if (botReadiness?.readiness === "notification-only" || report?.readiness === "notification-only") {
+    return {
+      status: "blocked",
+      summary: "Feishu bridge start blocked: webhook is notification-only.",
+      detail: blockedDetail
+    };
+  }
+  if (botReadiness && !botReadiness.canStart) {
+    return {
+      status: "blocked",
+      summary: `Feishu bridge start blocked: ${botReadiness.readiness}.`,
+      detail: blockedDetail
+    };
+  }
+  if (report && report.readiness !== "ready-to-start" && report.readiness !== "fixture-ready") {
+    return {
+      status: "blocked",
+      summary: `Feishu bridge start blocked: ${report.readiness}.`,
+      detail: blockedDetail
+    };
+  }
+  const appId = resolveEnvRef(channel.config.appIdRef);
+  const appSecret = resolveEnvRef(channel.config.appSecretRef);
+  if (!appId || !appSecret) {
+    const missing = [
+      appId ? void 0 : "LINGHUN_REMOTE_FEISHU_APP_ID",
+      appSecret ? void 0 : "LINGHUN_REMOTE_FEISHU_APP_SECRET"
+    ].filter((item) => Boolean(item));
+    return {
+      status: "blocked",
+      summary: "Feishu bridge start blocked: app env missing.",
+      detail: [
+        blockedDetail,
+        `missing env: ${missing.join(", ")}`,
+        "Secret values are not printed."
+      ].join("\n")
+    };
+  }
+  if (feishuLongConnectionHandles.has(channel.id)) {
+    return {
+      status: "already_running",
+      summary: "Feishu bridge already running.",
+      detail: "Long connection handle is active in this process; secrets are not printed."
+    };
+  }
+  try {
+    const start = deps().startFeishuLongConnection ?? startFeishuLongConnection;
+    const handle = await start({
+      appId,
+      appSecret,
+      onMessage: async (message) => {
+        const inbound = deps().handleRemoteInboundMessage;
+        if (!inbound) return;
+        await inbound(message, context, void 0, output);
+      }
+    });
+    feishuLongConnectionHandles.set(channel.id, handle);
+    await appendRemoteSystemEvent(
+      context,
+      `remote_bridge_start channel=${channel.id} status=started`,
+      "info"
+    );
+    return {
+      status: "started",
+      summary: "Feishu bridge started: waiting for mobile messages.",
+      detail: [
+        "Long connection started with official SDK; secrets are not printed.",
+        botReadiness ? formatFeishuBotStartReadiness(botReadiness) : void 0
+      ].filter((item) => Boolean(item)).join("\n")
+    };
+  } catch {
+    await appendRemoteSystemEvent(
+      context,
+      `remote bridge start: channel ${channel.id}; status failed`,
+      "warning"
+    );
+    return {
+      status: "failed",
+      summary: "Feishu bridge start failed: platform connection rejected or unavailable.",
+      detail: [
+        blockedDetail,
+        "Check Feishu app credentials, long connection event subscription, bot ability, and message permissions."
+      ].join("\n")
+    };
+  }
+}
+function getFeishuBotStartReadiness(channel) {
+  if (channel.config.transport === "webhook" || channel.config.transport === "webhook_mock") {
+    return { readiness: "notification-only", canStart: false, missingEnv: [] };
+  }
+  if (channel.config.transport !== "official_cli") {
+    return { readiness: "needs-event-subscription", canStart: false, missingEnv: [] };
+  }
+  if (channel.config.inboundMode !== "callback" || channel.config.callbackEndpoint !== "feishu-long-connection") {
+    return { readiness: "needs-event-subscription", canStart: false, missingEnv: [] };
+  }
+  if (!channel.config.appIdRef) {
+    return { readiness: "needs-app-id", canStart: false, missingEnv: [] };
+  }
+  if (!channel.config.appSecretRef) {
+    return { readiness: "needs-app-secret", canStart: false, missingEnv: [] };
+  }
+  const missingEnv = [channel.config.appIdRef, channel.config.appSecretRef].filter(
+    (ref) => !resolveEnvRef(ref)
+  );
+  if (missingEnv.length) {
+    return { readiness: "needs-env", canStart: false, missingEnv };
+  }
+  if (channel.config.bindingUserId && channel.config.trustedSources.length > 0) {
+    return { readiness: "bound-ready", canStart: true, missingEnv: [] };
+  }
+  return { readiness: "ready-to-start", canStart: true, missingEnv: [] };
+}
+function formatFeishuBotStartReadiness(readiness) {
+  const lines = [
+    "Feishu Bot start readiness",
+    `- readiness: ${readiness.readiness}`,
+    `- can start: ${readiness.canStart ? "yes" : "no"}`
+  ];
+  if (readiness.missingEnv.length) {
+    lines.push(`- missing env: ${readiness.missingEnv.join(", ")}`);
+  }
+  lines.push("- secret values are not printed.");
+  lines.push("- ready-to-start means Bot can run and wait for /bind CODE.");
+  lines.push(
+    "- bound/ready means ordinary mobile messages can pass binding/trusted-source checks."
+  );
+  lines.push("- webhook path remains notification-only.");
+  return lines.join("\n");
+}
+async function stopRemoteBotChannel(channelId) {
+  const handle = feishuLongConnectionHandles.get(channelId);
+  if (!handle) return false;
+  await handle.close();
+  feishuLongConnectionHandles.delete(channelId);
+  return true;
+}
+function resolveEnvRef(ref) {
+  if (!ref) return void 0;
+  return process.env[ref];
+}
+function formatRemoteEvents(context) {
+  if (context.remote.events.length === 0) {
+    return "Remote events\uFF1A\u6682\u65E0\u8FDC\u7A0B\u4E8B\u4EF6\u3002\u8FD0\u884C /remote test <channel> \u53D1\u9001\u4E00\u6761\u8131\u654F\u6D4B\u8BD5\u6458\u8981\u3002";
+  }
+  const lines = ["Remote events\uFF08\u6700\u8FD1\u5728\u524D\uFF0C\u4EC5\u8131\u654F\u6458\u8981\uFF0C\u4E0D\u542B secret/endpoint/\u6B63\u6587\uFF09"];
+  for (const event of context.remote.events.slice(0, 10)) {
+    lines.push(
+      `- ${event.channel} \xB7 ${event.eventType} \xB7 ${event.status}${event.deliveryDetail ? ` \xB7 ${event.deliveryDetail}` : ""}`
+    );
+    lines.push(`  summary: ${event.redactedSummary}`);
+  }
+  return lines.join("\n");
+}
+function formatRemoteDoctor(context) {
+  const lines = [
+    `Remote Doctor\uFF1A${context.remote.enabled ? "enabled" : "disabled"}\uFF1B\u5931\u8D25\u4F1A\u964D\u7EA7\u4E3A disabled/blocked\uFF0C\u4E0D\u963B\u585E\u4E3B TUI\u3002`,
+    "\u63A8\u8350\u5165\u53E3\uFF1A/remote bot doctor\uFF1B\u65E7 /remote bridge \u547D\u4EE4\u4FDD\u7559\u517C\u5BB9\u3002"
+  ];
+  for (const channel of context.remote.channels) {
+    const grade = getRemoteCapabilityGrade(channel);
+    const bridge = getRemoteBridgeDoctor(context.remote, channel.id);
+    lines.push(`- ${channel.id}: ${channel.runtimeStatus}`);
+    lines.push(`  binding: ${channel.bindingStatus}`);
+    lines.push(`  transport: ${channel.config.transport}; status ${channel.transportStatus}`);
+    lines.push(`  capability: ${grade.grade} \u2014 ${grade.reason}`);
+    lines.push(`  bridge: ${bridge.readiness}; ${bridge.nextAction}`);
+    lines.push(`  last error: ${channel.lastError ?? "none"}`);
+    lines.push(`  allowed events: ${channel.config.allowedEventTypes.join(", ")}`);
+    lines.push(`  next action: ${channel.nextAction}`);
+  }
+  lines.push(
+    "Secrets/endpoints are redacted. webhook/webhook_mock \u4EC5\u5355\u5411\u901A\u77E5\uFF1B\u5BA1\u6279/\u81EA\u7136\u8BED\u8A00\u56DE\u4F20\u9700\u5B98\u65B9 CLI/\u5E94\u7528\u5165\u7AD9\u80FD\u529B\u3002"
+  );
+  return lines.join("\n");
+}
+function formatRemoteBotDoctorSummary(context, channelArg) {
+  const channels = selectBotChannels(context, channelArg);
+  if (channels.length === 0 && normalizeRemoteChannelId(channelArg ?? "") === "wechat") {
+    return "Personal WeChat Bot: experimental blocked.";
+  }
+  if (channels.length === 0) return "Remote Bot doctor: choose feishu, dingtalk, or wechat.";
+  return channels.map((channel) => `${formatBotChannelName(channel.id)}: ${getRemoteBotUserStatus(channel)}`).join("\uFF1B");
+}
+function formatRemoteBotDoctorDetails(context, channelArg) {
+  const normalized = normalizeRemoteChannelId(channelArg ?? "");
+  if (normalized === "wechat") return formatWechatBotExperimentalDetails();
+  const channels = selectBotChannels(context, channelArg);
+  if (channels.length === 0) {
+    return "Remote Bot doctor\uFF1A\u8BF7\u9009\u62E9 feishu\u3001dingtalk \u6216 wechat\u3002";
+  }
+  const lines = [
+    "Remote Bot doctor\uFF08\u666E\u901A\u89C6\u56FE\u53EA\u663E\u793A Bot \u72B6\u6001\uFF1B\u5E95\u5C42 bridge \u8BCA\u65AD\u8BF7\u7528 /remote bridge doctor\uFF09"
+  ];
+  for (const channel of channels) {
+    const status = getRemoteBotUserStatus(channel);
+    lines.push(`- ${formatBotChannelName(channel.id)}: ${status}`);
+    lines.push(`  setup: /remote bot setup ${channel.id}`);
+    lines.push(`  start: /remote bot start ${channel.id}`);
+    lines.push(`  pair: /remote bot pair ${channel.id}`);
+    if (channel.id === "feishu") {
+      lines.push(
+        "  needs: App ID, App Secret, Bot enabled, long connection, message receive event."
+      );
+      lines.push(
+        `  readiness: ${formatFeishuBotStartReadiness(getFeishuBotStartReadiness(channel)).replace(/\n/g, "\n  ")}`
+      );
+    } else if (channel.id === "dingtalk") {
+      lines.push("  needs: Client ID, Client Secret, robot Stream mode, published app.");
+      lines.push("  real Stream smoke: NOT RUN without credentials and a published DingTalk bot.");
+    }
+    lines.push(
+      `  pairing: ${channel.config.bindingUserId && channel.config.trustedSources.length > 0 ? "complete" : "needed"}`
+    );
+  }
+  lines.push(
+    "Secrets, endpoints, trusted source lists, binding ids, callback refs, QR/session tokens, and raw payloads are redacted."
+  );
+  lines.push(
+    "Webhook notification remains notification-only; Bot inbound must enter the existing RemoteInboundMessage main chain."
+  );
+  return lines.join("\n");
+}
+function formatRemoteBotSetupSummary(context, channelArg) {
+  const normalized = normalizeRemoteChannelId(channelArg ?? "");
+  if (normalized === "wechat") return "Personal WeChat Bot setup: experimental opt-in only.";
+  const channel = findRemoteChannel(context, normalized);
+  if (!channel) return "Remote Bot setup: choose feishu, dingtalk, or wechat.";
+  return `${formatBotChannelName(channel.id)} setup: ${getRemoteBotUserStatus(channel)}.`;
+}
+function formatRemoteBotSetupDetails(context, channelArg) {
+  const normalized = normalizeRemoteChannelId(channelArg ?? "");
+  if (normalized === "wechat") return formatWechatBotExperimentalDetails();
+  const channel = findRemoteChannel(context, normalized);
+  if (!channel) {
+    return "Remote Bot setup\uFF1A\u8BF7\u9009\u62E9 feishu\u3001dingtalk \u6216 wechat\u3002\u793A\u4F8B\uFF1A/remote bot setup feishu";
+  }
+  if (channel.id === "feishu") return formatFeishuBotSetupDetails(channel);
+  if (channel.id === "dingtalk") return formatDingTalkBotSetupDetails(channel);
+  return "Enterprise WeChat is future/not implemented in this Bot productization stage.";
+}
+function formatFeishuBotSetupDetails(channel) {
+  return [
+    "Feishu Bot setup",
+    "- Prepare a Feishu/Lark app with Bot enabled.",
+    "- Enable long connection and subscribe to im.message.receive_v1.",
+    "- Set env refs: LINGHUN_REMOTE_FEISHU_APP_ID and LINGHUN_REMOTE_FEISHU_APP_SECRET.",
+    "- Webhook notification is optional and not required for mobile control.",
+    "- Start: /remote bot start feishu.",
+    "- Pair from the Bot chat: /remote bot pair feishu, then send /bind CODE.",
+    `- Current Bot status: ${getRemoteBotUserStatus(channel)}.`,
+    "- Secret values are never printed or stored in reports."
+  ].join("\n");
+}
+function formatDingTalkBotSetupDetails(channel) {
+  return [
+    "DingTalk Bot setup",
+    "- Official Stream path uses the dingtalk-stream SDK and Client ID / Client Secret.",
+    "- In DingTalk developer console, enable robot message receiving, choose Stream mode, and publish the app.",
+    "- Robot message topic: /v1.0/im/bot/messages/get.",
+    "- Card callback topic: /v1.0/card/instances/callback; advanced cards must set callbackType=STREAM.",
+    "- Configure env refs as LINGHUN_REMOTE_DINGTALK_CLIENT_ID and LINGHUN_REMOTE_DINGTALK_CLIENT_SECRET.",
+    "- Current build has offline adapter normalization only; real DingTalk Stream start is NOT RUN without SDK wiring and credentials.",
+    `- Current Bot status: ${getRemoteBotUserStatus(channel)}.`,
+    "- sessionWebhook and Client Secret are treated as secrets and never persisted in summaries."
+  ].join("\n");
+}
+function formatWechatBotExperimentalDetails() {
+  return [
+    "Personal WeChat Bot setup: experimental",
+    "- Default: blocked. Set LINGHUN_REMOTE_WECHAT_EXPERIMENTAL=1 only after accepting QR-login, third-party puppet/provider, account restriction, token, and session risks.",
+    "- No Wechaty/PadLocal dependency is bundled in Linghun core in this stage.",
+    "- A real plugin bridge must provide proof before messages can become RemoteInboundMessage.",
+    "- QR payloads, QR images, session files, wxid/openid/unionid, puppet tokens, cookies, and device data must be redacted.",
+    "- No fake WeChat inbound PASS is allowed; without a real opted-in bridge, /remote bot start wechat remains blocked."
+  ].join("\n");
+}
+function formatRemoteBotStartBlockedSummary(channelId) {
+  if (channelId === "dingtalk")
+    return "DingTalk Bot start blocked: Stream SDK wiring and real credentials are not configured.";
+  if (channelId === "wechat") {
+    return process.env.LINGHUN_REMOTE_WECHAT_EXPERIMENTAL === "1" ? "Personal WeChat Bot start blocked: experimental plugin bridge is not installed." : "Personal WeChat Bot start blocked: experimental opt-in is disabled.";
+  }
+  return "Remote Bot start blocked: choose feishu, dingtalk, or wechat.";
+}
+function toRemoteBotStartSummary(channelId, status) {
+  if (status === "started")
+    return `${formatBotChannelName(channelId)} started; waiting for mobile messages.`;
+  if (status === "already_running")
+    return `${formatBotChannelName(channelId)} Bot is already running.`;
+  if (status === "failed")
+    return `${formatBotChannelName(channelId)} Bot start failed; check app settings.`;
+  return `${formatBotChannelName(channelId)} Bot start blocked; finish setup first.`;
+}
+function selectBotChannels(context, channelArg) {
+  const normalized = normalizeRemoteChannelId(channelArg ?? "");
+  if (normalized) {
+    const channel = findRemoteChannel(context, normalized);
+    return channel ? [channel] : [];
+  }
+  return context.remote.channels.filter(
+    (channel) => channel.id === "feishu" || channel.id === "dingtalk"
+  );
+}
+function getRemoteBotUserStatus(channel) {
+  const report = getRemoteBridgeDoctor(
+    {
+      enabled: true,
+      channels: [channel],
+      events: [],
+      processedMessageIds: [],
+      sessionDisabledChannelIds: [],
+      pairings: [],
+      inbox: []
+    },
+    channel.id
+  );
+  if (channel.id === "feishu") {
+    const readiness = getFeishuBotStartReadiness(channel);
+    if (feishuLongConnectionHandles.has(channel.id)) return "running";
+    if (readiness.readiness === "needs-app-id") return "needs app id";
+    if (readiness.readiness === "needs-app-secret") return "needs app secret";
+    if (readiness.readiness === "needs-env") return "needs app env";
+    if (readiness.readiness === "notification-only") return "notification-only";
+    if (readiness.readiness === "ready-to-start") return "ready-to-start";
+    if (readiness.readiness === "bound-ready") return "bound/ready";
+    return "needs event subscription";
+  }
+  if (channel.id === "dingtalk") {
+    if (!channel.config.appIdRef) return "needs client id";
+    if (!channel.config.appSecretRef && !channel.config.tokenRef) return "needs client secret";
+    if (report.readiness === "needs-daemon") return "needs stream permission";
+    return "stream adapter not connected";
+  }
+  return "future/not implemented";
+}
+function formatBotChannelName(channelId) {
+  if (channelId === "feishu") return "Feishu Bot";
+  if (channelId === "dingtalk") return "DingTalk Bot";
+  if (channelId === "wechat") return "Personal WeChat Bot";
+  return `${channelId} Bot`;
+}
+function getRemoteCapabilityGrade(channel) {
+  const { transport, type, inboundMode } = channel.config;
+  if (transport === "webhook" || transport === "webhook_mock") {
+    return {
+      grade: "notification-only",
+      reason: "webhook \u5355\u5411\u6295\u9012\u6458\u8981\uFF1B\u4E0D\u80FD\u63A5\u6536\u5BA1\u6279\u6216\u6D88\u606F\u56DE\u4F20"
+    };
+  }
+  if (!inboundMode || inboundMode === "none") {
+    return {
+      grade: "notification-only",
+      reason: "\u5B98\u65B9 CLI \u4EC5\u7528\u4E8E\u51FA\u7AD9\u901A\u77E5\uFF1BinboundMode=none \u672A\u5F00\u542F\u5165\u7AD9"
+    };
+  }
+  if (type === "feishu" || type === "lark") {
+    if (!channel.config.appIdRef || !channel.config.appSecretRef) {
+      return {
+        grade: "needs-app-setup",
+        reason: "Feishu/Lark \u5165\u7AD9\u9700\u8981 appId/appSecret \u5F15\u7528\u548C\u4E8B\u4EF6\u8BA2\u9605\u914D\u7F6E\uFF1B\u672A\u914D\u7F6E\u4E0D\u80FD\u663E\u793A ready"
+      };
+    }
+    return {
+      grade: "full-mobile-control-capable",
+      reason: "\u5B98\u65B9\u5E94\u7528\u4E8B\u4EF6/\u56DE\u8C03\u6216 CLI \u6D88\u8D39\u53EF\u63A5\u5165\u5BA1\u6279\u4E0E\u81EA\u7136\u8BED\u8A00\uFF1B\u771F\u5B9E\u624B\u673A\u5165\u7AD9\u4ECD\u9700 callback/daemon"
+    };
+  }
+  if (type === "wecom" || type === "enterprise-wechat") {
+    if (!channel.config.appIdRef && !channel.config.tokenRef) {
+      return {
+        grade: "needs-wecom-app",
+        reason: "\u4F01\u4E1A\u5FAE\u4FE1\u5165\u7AD9\u9700\u8981\u5E94\u7528\u56DE\u8C03\u6216 CLI poll \u51ED\u8BC1\uFF1B\u672A\u914D\u7F6E\u663E\u793A needs-wecom-app"
+      };
+    }
+    return {
+      grade: "natural-language-inbound-capable",
+      reason: "\u5E94\u7528\u56DE\u8C03/CLI poll \u53EF\u63A5\u6536\u81EA\u7136\u8BED\u8A00\uFF1Bwebhook \u4ECD\u4EC5\u901A\u77E5"
+    };
+  }
+  if (!channel.config.appIdRef && !channel.config.tokenRef) {
+    return {
+      grade: "needs-dingtalk-app",
+      reason: "\u9489\u9489\u5165\u7AD9/\u5BA1\u6279\u9700\u8981\u5E94\u7528\u6216 Stream \u914D\u7F6E\uFF1B\u672A\u914D\u7F6E\u663E\u793A needs-dingtalk-app"
+    };
+  }
+  return {
+    grade: "approval-capable",
+    reason: "\u5E94\u7528/Stream \u914D\u7F6E\u540E\u53EF\u505A\u5BA1\u6279\u56DE\u4F20\uFF1B\u5B9E\u65F6\u6D88\u606F\u9700 daemon \u6216 callback"
+  };
+}
+function formatRemoteSetup(channelArg, context) {
+  const channel = findRemoteChannel(context, channelArg);
+  if (!channel) {
+    return "Remote setup\uFF1A\u8BF7\u9009\u62E9 feishu\u3001wecom \u6216 dingtalk\u3002\u793A\u4F8B\uFF1A/remote setup feishu";
+  }
+  const config = channel.config;
+  const isWebhook = config.transport === "webhook" || config.transport === "webhook_mock";
+  const grade = getRemoteCapabilityGrade(channel);
+  const field = (label, ok, hint) => `- ${ok ? "[\u5DF2\u586B]" : "[\u5F85\u586B]"} ${label}${ok ? "" : ` \u2014 ${hint}`}`;
+  const lines = [
+    `Remote setup\uFF1A${channel.id}\uFF08\u9ED8\u8BA4\u4E0D\u81EA\u52A8\u542F\u7528\uFF1B\u53EA\u9700\u586B\u5FC5\u8981\u5B57\u6BB5\uFF0C\u65E0\u9700\u7406\u89E3\u5E95\u5C42\u673A\u5236\uFF09`,
+    `- \u901A\u9053\u80FD\u529B\uFF1A${grade.grade} \u2014 ${grade.reason}`
+  ];
+  if (isWebhook) {
+    lines.push(
+      field(
+        "webhook endpoint",
+        Boolean(config.endpoint),
+        `\u914D\u7F6E\u8131\u654F webhook \u5730\u5740\uFF08${getRemoteLoginHint(config.type)}\uFF09`
+      )
+    );
+    lines.push(
+      field(
+        "signing secret \u5F15\u7528",
+        Boolean(config.signingSecretRef),
+        config.type === "wecom" || config.type === "enterprise-wechat" ? "\u4F01\u4E1A\u5FAE\u4FE1\u7FA4\u673A\u5668\u4EBA\u65E0\u72EC\u7ACB\u7B7E\u540D\uFF0C\u5B89\u5168\u6027\u6765\u81EA URL key\uFF08\u53EF\u7559\u7A7A\uFF09" : "\u586B\u73AF\u5883\u53D8\u91CF\u540D\uFF08\u5982 LINGHUN_REMOTE_FEISHU_SECRET\uFF09\uFF0C\u4E0D\u8981\u7C98\u8D34\u660E\u6587"
+      )
+    );
+  } else {
+    lines.push(
+      field(
+        "official CLI \u767B\u5F55",
+        channel.transportStatus === "ready",
+        getRemoteLoginHint(config.type)
+      )
+    );
+    lines.push(
+      field(
+        "appIdRef/appSecretRef \u6216 tokenRef",
+        Boolean(config.appIdRef || config.tokenRef) && (config.type !== "feishu" && config.type !== "lark" || Boolean(config.appSecretRef)),
+        "\u586B\u73AF\u5883\u53D8\u91CF\u5F15\u7528\uFF0C\u4E0D\u586B\u660E\u6587\uFF1B\u672A\u914D\u7F6E\u65F6 bridge \u663E\u793A needs-app-setup"
+      )
+    );
+    lines.push(
+      field(
+        "\u5165\u7AD9\u6A21\u5F0F inboundMode",
+        Boolean(config.inboundMode && config.inboundMode !== "none"),
+        "poll=CLI \u62C9\u53D6\u6D88\u606F / callback=\u5DF2\u90E8\u7F72\u56DE\u8C03\u7AEF\u70B9\uFF1Bnone \u4EC5\u51FA\u7AD9\u901A\u77E5"
+      )
+    );
+  }
+  lines.push(field("\u7ED1\u5B9A\u7528\u6237 bindingUserId", Boolean(config.bindingUserId), "\u586B\u624B\u673A\u7AEF\u53EF\u4FE1\u7528\u6237 id"));
+  lines.push(
+    field(
+      "\u7ED1\u5B9A\u8BBE\u5907 bindingDeviceId",
+      Boolean(config.bindingDeviceId),
+      "\u53EF\u9009\uFF1B\u586B\u4E86\u5219\u5BA1\u6279/\u5165\u7AD9\u4F1A\u6821\u9A8C\u8BBE\u5907"
+    )
+  );
+  lines.push(
+    field(
+      "\u53EF\u4FE1\u6765\u6E90 trustedSources",
+      config.trustedSources.length > 0,
+      "\u81F3\u5C11\u6DFB\u52A0\u4E00\u4E2A\u53EF\u4FE1\u6765\u6E90 id\uFF0C\u5426\u5219\u901A\u9053\u4FDD\u6301 blocked"
+    )
+  );
+  if (!isWebhook) {
+    lines.push(
+      field(
+        "\u56DE\u8C03\u7AEF\u70B9 callbackEndpoint",
+        Boolean(config.callbackEndpoint),
+        "\u4EC5 inboundMode=callback \u9700\u8981\uFF1Bpoll \u6A21\u5F0F\u53EF\u7559\u7A7A"
+      )
+    );
+    lines.push(
+      field(
+        "encryptKeyRef / verificationTokenRef",
+        config.type === "feishu" || config.type === "lark" ? config.callbackEndpoint === "feishu-long-connection" || Boolean(config.encryptKeyRef && config.verificationTokenRef) : true,
+        "Feishu/Lark \u516C\u7F51 callback \u9700\u8981\u4E8B\u4EF6\u56DE\u8C03\u6821\u9A8C\u5F15\u7528\uFF1B\u957F\u8FDE\u63A5\u4E0D\u9700\u8981"
+      )
+    );
+  }
+  lines.push(
+    `- \u5F53\u524D\u72B6\u6001\uFF1Aruntime ${channel.runtimeStatus}; binding ${channel.bindingStatus}; transport ${config.transport}/${channel.transportStatus}`,
+    `- \u4E0B\u4E00\u6B65\uFF1A\u8865\u9F50 [\u5F85\u586B] \u5B57\u6BB5\u540E\u8FD0\u884C /remote test ${channel.id}\uFF0C\u518D\u8FD0\u884C /remote status\uFF1B\u4E0D\u8981\u5728\u4E3B\u5C4F\u7C98\u8D34 secret/token/full endpoint\u3002`
+  );
+  return lines.join("\n");
+}
+function findRemoteChannel(context, channelArg) {
+  const id = normalizeRemoteChannelId(channelArg ?? "");
+  return context.remote.channels.find((channel) => channel.id === id || channel.config.type === id);
+}
+function normalizeRemoteChannelId(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "lark") return "feishu";
+  if (normalized === "enterprise-wechat") return "wecom";
+  return normalized;
+}
+function getRemoteLoginHint(type) {
+  if (type === "feishu" || type === "lark") {
+    return "\u68C0\u6D4B lark-cli / feishu-cli\uFF1B\u672A\u521D\u59CB\u5316\u8BF7\u8FD0\u884C feishu-cli config init \u6216 lark-cli auth login\u3002";
+  }
+  if (type === "dingtalk") {
+    return "\u68C0\u6D4B dws\uFF1B\u672A\u767B\u5F55\u8BF7\u8FD0\u884C dws auth login \u6216 dws device login\u3002";
+  }
+  return "\u68C0\u6D4B wecom-cli\uFF1B\u672A\u521D\u59CB\u5316\u8BF7\u8FD0\u884C wecom-cli init\uFF0C\u7136\u540E\u68C0\u67E5 auth/login \u72B6\u6001\u3002";
+}
+function getRemoteInstallHint(type) {
+  if (type === "feishu" || type === "lark") {
+    return "install lark-cli/feishu-cli, then run feishu-cli config init or lark-cli auth login";
+  }
+  if (type === "dingtalk") {
+    return "install dws, then run dws auth login or dws device login";
+  }
+  return "install wecom-cli, then run wecom-cli init/auth";
+}
+function createRemoteEvent(channel, eventType, summary, refs = [], ttlMs = 10 * 60 * 1e3) {
+  const now = Date.now();
+  const id = `remote-${randomUUID().slice(0, 8)}`;
+  return {
+    id,
+    channel: channel.id,
+    eventType,
+    createdAt: new Date(now).toISOString(),
+    expiresAt: new Date(now + ttlMs).toISOString(),
+    nonce: randomUUID(),
+    messageId: `msg-${randomUUID().slice(0, 12)}`,
+    source: channel.config.trustedSources[0] ?? "local-test",
+    redactedSummary: redactRemoteSummary(summary),
+    refs: refs.map((ref) => truncateDisplay(redactRemoteSummary(ref), 120)),
+    status: "pending"
+  };
+}
+function sendRemoteEvent(context, event) {
+  const channel = context.remote.channels.find((item) => item.id === event.channel);
+  const next = { ...event };
+  if (!channel || channel.runtimeStatus !== "ready") {
+    next.status = "failed";
+  } else if (!channel.config.allowedEventTypes.includes(event.eventType)) {
+    next.status = "rejected";
+  } else if (channel.config.transport === "webhook" && !channel.config.endpoint) {
+    next.status = "failed";
+  } else {
+    next.status = "sent";
+  }
+  context.remote.events.unshift(next);
+  context.remote.events = context.remote.events.slice(0, 20);
+  return next;
+}
+async function sendRemoteEventReal(context, event, depsOverride) {
+  const transport = depsOverride ?? remoteTransportDeps ?? defaultRemoteTransportDeps();
+  const channel = context.remote.channels.find((item) => item.id === event.channel);
+  const next = { ...event };
+  const finalize = (status2, detail) => {
+    next.status = status2;
+    next.deliveryDetail = detail;
+    context.remote.events.unshift(next);
+    context.remote.events = context.remote.events.slice(0, 20);
+    return next;
+  };
+  if (!channel || channel.runtimeStatus !== "ready") {
+    return finalize("failed", "remote channel is not ready");
+  }
+  if (!channel.config.allowedEventTypes.includes(event.eventType)) {
+    return finalize("rejected", `event type ${event.eventType} is not allowed on this channel`);
+  }
+  if (channel.config.transport === "webhook_mock") {
+    return finalize("mock", "webhook_mock diagnostic dry run \u2014 not a real remote delivery");
+  }
+  if (channel.config.transport === "webhook") {
+    const secret = channel.config.signingSecretRef ? transport.resolveSecret(channel.config.signingSecretRef) : void 0;
+    if (channel.config.signingSecretRef && !secret) {
+      return finalize("failed", "signing secret reference could not be resolved");
+    }
+    const build = buildWebhookRequest(channel, event, secret, transport.nowMs());
+    if (!build.ok) {
+      return finalize("failed", "missing redacted webhook endpoint configuration");
+    }
+    const result2 = await deliverWebhook(build.request, transport.fetch);
+    return finalize(result2.status === "sent" ? "sent" : "failed", result2.detail);
+  }
+  const invocation = buildOfficialCliInvocation(channel, event);
+  if (!invocation.ok) {
+    return finalize(
+      "failed",
+      invocation.reason === "missing_binding" ? "official CLI needs a bound user before sending" : "official CLI path is not configured"
+    );
+  }
+  const result = await deliverOfficialCli(invocation.command, invocation.args, transport.runCli);
+  const status = result.status === "sent" ? "sent" : result.status === "blocked" ? "blocked" : "failed";
+  return finalize(status, result.detail);
+}
+function processRemoteApprovalForTest(context, event, message) {
+  const decision = processRemoteApproval(context, event, message);
+  context.remote.lastApproval = decision;
+  return decision;
+}
+function processRemoteApproval(context, event, message) {
+  const channel = context.remote.channels.find((item) => item.id === event.channel);
+  const reject = (status, summary) => {
+    event.status = status === "expired" ? "expired" : "rejected";
+    return { status, summary, evidenceCreated: false };
+  };
+  if (!channel || channel.runtimeStatus !== "ready") {
+    return reject("blocked", "remote channel is not ready");
+  }
+  if (event.eventType !== "approval_request") {
+    return reject("blocked", "remote event is not an approval_request");
+  }
+  if (Date.parse(event.expiresAt) <= Date.now()) {
+    return reject("expired", "remote approval expired");
+  }
+  if (context.remote.processedMessageIds.includes(message.messageId)) {
+    return reject("replayed", "remote approval replayed");
+  }
+  if (message.messageId !== event.messageId || message.nonce !== event.nonce) {
+    return reject("bad_signature", "remote approval nonce/messageId mismatch");
+  }
+  if (!channel.config.trustedSources.includes(message.source)) {
+    return reject("unknown_source", "remote approval source is not trusted");
+  }
+  if (message.bindingUserId !== channel.config.bindingUserId || channel.config.bindingDeviceId && message.bindingDeviceId !== channel.config.bindingDeviceId) {
+    return reject("wrong_binding", "remote approval binding mismatch");
+  }
+  if (!verifyRemoteSignature(channel, event, message)) {
+    return reject("bad_signature", "remote approval signature check failed");
+  }
+  if (!context.pendingLocalApproval) {
+    return reject("blocked", "no local pending approval to resume");
+  }
+  context.remote.processedMessageIds.unshift(message.messageId);
+  context.remote.processedMessageIds = context.remote.processedMessageIds.slice(0, 50);
+  event.status = message.approve ? "approved" : "rejected";
+  return {
+    status: message.approve ? "approved" : "rejected",
+    summary: message.approve ? "remote approval validated; local permission pipeline remains the execution boundary" : "remote approval rejected by user",
+    evidenceCreated: false
+  };
+}
+function verifyRemoteSignature(channel, event, message) {
+  if (!channel.config.signingSecretRef) {
+    return isRemoteMockSignatureAllowed() && message.signature === `mock:${event.messageId}:${event.nonce}`;
+  }
+  return typeof message.signature === "string" && message.signature.startsWith("ref:");
+}
+function verifyRemoteInboundSignature(channel, message) {
+  if (!channel.config.signingSecretRef) {
+    return isRemoteMockSignatureAllowed() && message.origin === "fixture" && message.signature === `mock:inbound:${message.messageId}:${message.nonce}`;
+  }
+  return typeof message.signature === "string" && message.signature.startsWith("ref:");
+}
+function isRemoteMockSignatureAllowed() {
+  return process.env.NODE_ENV !== "production";
+}
+function processRemoteInbound(context, message) {
+  const envelope = validateRemoteInboundEnvelope(context, message);
+  if (envelope.status !== "envelope_accepted") return envelope;
+  const channel = envelope.channel;
+  const consume = () => consumeRemoteInboundMessage(context, message.messageId);
+  if (message.kind === "approval_response") {
+    if (context.permissionMode === "plan") {
+      return {
+        kind: message.kind,
+        status: "blocked",
+        summary: "plan mode keeps writes read-only; remote approval cannot execute mutating operations",
+        evidenceCreated: false
+      };
+    }
+    if (!context.pendingLocalApproval) {
+      return {
+        kind: message.kind,
+        status: "no_pending_approval",
+        summary: "no local pending approval to resume",
+        evidenceCreated: false
+      };
+    }
+    const event = message.eventId ? context.remote.events.find((item) => item.id === message.eventId) : void 0;
+    if (!event || event.eventType !== "approval_request") {
+      return {
+        kind: message.kind,
+        status: "blocked",
+        summary: "approval_response does not match a known approval_request",
+        evidenceCreated: false
+      };
+    }
+    if (Date.parse(event.expiresAt) <= Date.now()) {
+      return {
+        kind: message.kind,
+        status: "expired",
+        summary: "approval_request expired",
+        evidenceCreated: false
+      };
+    }
+    if (message.nonce !== event.nonce) {
+      return {
+        kind: message.kind,
+        status: "bad_signature",
+        summary: "approval_response nonce mismatch",
+        evidenceCreated: false
+      };
+    }
+    consume();
+    event.status = message.approve ? "approved" : "rejected";
+    return {
+      kind: "approval_response",
+      status: message.approve ? "approved" : "rejected",
+      summary: message.approve ? "remote approval validated; local permission pipeline remains the execution boundary" : "remote approval rejected by user",
+      evidenceCreated: false
+    };
+  }
+  if (message.kind === "natural_language_message") {
+    const text = (message.text ?? "").trim();
+    if (!text) {
+      return {
+        kind: message.kind,
+        status: "blocked",
+        summary: "natural_language_message is empty",
+        evidenceCreated: false
+      };
+    }
+    consume();
+    return {
+      kind: "natural_language_message",
+      status: "accepted",
+      summary: "remote natural-language message accepted; routing into local model main chain",
+      routedText: text,
+      evidenceCreated: false
+    };
+  }
+  void channel;
+  consume();
+  return {
+    kind: "status_query",
+    status: "accepted",
+    summary: "remote status query accepted; returning redacted local status summary",
+    evidenceCreated: false
+  };
+}
+function validateRemoteInboundEnvelope(context, message) {
+  const channel = context.remote.channels.find((item) => item.id === message.channel);
+  const reject = (status, summary) => ({ kind: message.kind, status, summary, evidenceCreated: false });
+  if (message.channel === "local-repl") {
+    if (message.origin !== "adapter" || message.source !== "local-repl") {
+      return reject("bad_signature", "local REPL bridge proof is invalid");
+    }
+    if (Date.parse(message.expiresAt) <= Date.now()) {
+      return reject("expired", "local REPL bridge message expired");
+    }
+    if (context.remote.processedMessageIds.includes(message.messageId)) {
+      return reject("replayed", "local REPL bridge message replayed");
+    }
+    const client = context.remote.localReplBridge?.clients.find(
+      (item) => item.active && item.clientId === message.bindingUserId
+    );
+    if (!client || !client.queue.some((item) => item.messageId === message.messageId)) {
+      return reject("wrong_binding", "local REPL bridge client/message mismatch");
+    }
+    return { status: "envelope_accepted", channel: createLocalReplBridgeChannel() };
+  }
+  if (!channel || !canValidateRemoteInboundEnvelope(channel)) {
+    return reject("channel_not_ready", "remote channel is not ready");
+  }
+  if (channel.config.transport !== "official_cli" || !channel.config.inboundMode || channel.config.inboundMode === "none") {
+    return reject("inbound_disabled", "remote channel is notification-only; inbound is disabled");
+  }
+  if (Date.parse(message.expiresAt) <= Date.now()) {
+    return reject("expired", "remote inbound message expired");
+  }
+  if (context.remote.processedMessageIds.includes(message.messageId)) {
+    return reject("replayed", "remote inbound message replayed");
+  }
+  if (!channel.config.trustedSources.includes(message.source)) {
+    return reject("unknown_source", "remote inbound source is not trusted");
+  }
+  if (message.bindingUserId !== channel.config.bindingUserId || channel.config.bindingDeviceId && message.bindingDeviceId !== channel.config.bindingDeviceId) {
+    return reject("wrong_binding", "remote inbound binding mismatch");
+  }
+  if (!verifyRemoteInboundSignature(channel, message)) {
+    return reject("bad_signature", "remote inbound signature check failed");
+  }
+  return { status: "envelope_accepted", channel };
+}
+function createLocalReplBridgeChannel() {
+  return {
+    id: "local-repl",
+    config: {
+      enabled: true,
+      type: "lark",
+      transport: "official_cli",
+      redactionPolicy: "summary_only",
+      allowedEventTypes: [],
+      trustedSources: ["local-repl"],
+      inboundMode: "callback",
+      bindingUserId: "local-repl"
+    },
+    runtimeStatus: "ready",
+    bindingStatus: "bound",
+    transportStatus: "ready",
+    nextAction: "/remote bridge local-route"
+  };
+}
+function validateRemotePairingEnvelope(context, message) {
+  const channel = context.remote.channels.find((item) => item.id === message.channel);
+  const reject = (status, summary) => ({ kind: message.kind, status, summary, evidenceCreated: false });
+  if (!channel || !canValidateRemoteInboundEnvelope(channel)) {
+    return reject("channel_not_ready", "remote channel is not ready");
+  }
+  if (channel.config.transport !== "official_cli" || !channel.config.inboundMode || channel.config.inboundMode === "none") {
+    return reject("inbound_disabled", "remote channel is notification-only; inbound is disabled");
+  }
+  if (Date.parse(message.expiresAt) <= Date.now()) {
+    return reject("expired", "remote pairing message expired");
+  }
+  if (context.remote.processedMessageIds.includes(message.messageId)) {
+    return reject("replayed", "remote pairing message replayed");
+  }
+  if (!verifyRemoteInboundSignature(channel, message)) {
+    return reject("bad_signature", "remote pairing signature check failed");
+  }
+  return { status: "envelope_accepted", channel };
+}
+function canValidateRemoteInboundEnvelope(channel) {
+  if (channel.runtimeStatus === "ready") return true;
+  if (channel.runtimeStatus !== "blocked") return false;
+  if (channel.lastError !== "not_bound" && channel.lastError !== "source_not_trusted") return false;
+  return channel.config.transport === "official_cli" && Boolean(channel.config.inboundMode && channel.config.inboundMode !== "none");
+}
+function consumeRemoteInboundMessage(context, messageId) {
+  context.remote.processedMessageIds.unshift(messageId);
+  context.remote.processedMessageIds = context.remote.processedMessageIds.slice(0, 50);
+}
+async function appendRemoteSystemEvent(context, message, level) {
+  await deps().appendSystemEvent(
+    context,
+    await deps().ensureSession(context),
+    remoteTranscriptSummary(message),
+    level
+  );
+}
+
+export {
+  configureRemoteCommandRuntime,
+  configureRemoteTransport,
+  refreshRemoteState,
+  handleRemoteCommand,
+  formatRemoteEvents,
+  formatRemoteDoctor,
+  getRemoteCapabilityGrade,
+  formatRemoteSetup,
+  findRemoteChannel,
+  normalizeRemoteChannelId,
+  getRemoteLoginHint,
+  getRemoteInstallHint,
+  createRemoteEvent,
+  sendRemoteEvent,
+  sendRemoteEventReal,
+  processRemoteApprovalForTest,
+  processRemoteApproval,
+  verifyRemoteSignature,
+  verifyRemoteInboundSignature,
+  processRemoteInbound,
+  validateRemoteInboundEnvelope,
+  validateRemotePairingEnvelope,
+  consumeRemoteInboundMessage,
+  appendRemoteSystemEvent
+};