Refactor bridge config and runtime status

src/loop/bridge-claude-registration.ts

@@ -0,0 +1,88 @@
+import { buildClaudeChannelServerConfig } from "./bridge-config";
+
+const CLAUDE_CHANNEL_SCOPE = "local";
+const MCP_ALREADY_EXISTS_RE = /already exists/i;
+
+interface BridgeCommandResult {
+  exitCode?: number | null;
+  stderr?: string | Uint8Array;
+}
+
+type BridgeCommand = (args: string[]) => BridgeCommandResult;
+
+const stderrText = (value: BridgeCommandResult["stderr"]): string => {
+  if (!value) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  return new TextDecoder().decode(value).trim();
+};
+
+const logClaudeChannelServerRemovalFailure = (
+  serverName: string,
+  detail: string,
+  log: (line: string) => void
+): void => {
+  log(
+    `[loop] failed to remove Claude channel server "${serverName}": ${detail}`
+  );
+};
+
+export const registerClaudeChannelServer = (
+  launchArgv: string[],
+  serverName: string,
+  runDir: string,
+  runCommand: BridgeCommand
+): void => {
+  const result = runCommand([
+    "claude",
+    "mcp",
+    "add-json",
+    "--scope",
+    CLAUDE_CHANNEL_SCOPE,
+    serverName,
+    buildClaudeChannelServerConfig(launchArgv, runDir),
+  ]);
+  const stderr = stderrText(result.stderr);
+  if (result.exitCode === 0 || MCP_ALREADY_EXISTS_RE.test(stderr)) {
+    return;
+  }
+  const suffix = stderr ? `: ${stderr}` : ".";
+  throw new Error(`[loop] failed to register Claude channel server${suffix}`);
+};
+
+export const removeClaudeChannelServer = (
+  serverName: string,
+  runCommand: BridgeCommand,
+  log: (line: string) => void = console.error
+): void => {
+  if (!serverName) {
+    return;
+  }
+  try {
+    const result = runCommand([
+      "claude",
+      "mcp",
+      "remove",
+      "--scope",
+      CLAUDE_CHANNEL_SCOPE,
+      serverName,
+    ]);
+    if (result.exitCode === 0) {
+      return;
+    }
+    logClaudeChannelServerRemovalFailure(
+      serverName,
+      stderrText(result.stderr) || `exit code ${result.exitCode ?? "unknown"}`,
+      log
+    );
+  } catch (error: unknown) {
+    logClaudeChannelServerRemovalFailure(
+      serverName,
+      error instanceof Error ? error.message : String(error),
+      log
+    );
+  }
+};

src/loop/bridge-config.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { BRIDGE_SERVER, BRIDGE_SUBCOMMAND } from "./bridge-constants";
+import { sanitizeBase } from "./git";
 import { buildLaunchArgv } from "./launch";
 import type { Agent } from "./types";
 
@@ -10,19 +11,110 @@ const CODEX_AUTO_APPROVED_BRIDGE_TOOLS = [
   "receive_messages",
 ] as const;
 const CODEX_BRIDGE_APPROVAL_MODE = "approve";
+const REPO_ID_HASH_SUFFIX_RE = /-[0-9a-f]{12}$/;
 
 const ensureParentDir = (path: string): void => {
   mkdirSync(dirname(path), { recursive: true });
 };
 
 const stringifyToml = (value: string): string => JSON.stringify(value);
 
+interface BridgeServerConfig {
+  args: string[];
+  command: string;
+  type: "stdio";
+}
+
+const buildBridgeServerConfig = (
+  runDir: string,
+  source: Agent,
+  launchArgv: string[]
+): BridgeServerConfig => {
+  const [command, ...baseArgs] = launchArgv;
+  return {
+    args: [...baseArgs, BRIDGE_SUBCOMMAND, runDir, source],
+    command,
+    type: "stdio",
+  };
+};
+
+const buildBridgeFileConfig = (
+  serverName: string,
+  config: BridgeServerConfig
+): { mcpServers: Record<string, BridgeServerConfig> } => ({
+  mcpServers: {
+    [serverName]: config,
+  },
+});
+
+export const legacyClaudeChannelServerName = (runId: string): string =>
+  `${BRIDGE_SERVER}-${sanitizeBase(runId)}`;
+
+const readableRepoSegment = (repoId?: string): string | undefined => {
+  const value = repoId?.trim();
+  if (!value) {
+    return undefined;
+  }
+  return sanitizeBase(value.replace(REPO_ID_HASH_SUFFIX_RE, ""));
+};
+
+export const legacyRepoScopedClaudeChannelServerName = (
+  runId: string,
+  repoId: string
+): string => `${BRIDGE_SERVER}-${sanitizeBase(repoId)}-${sanitizeBase(runId)}`;
+
+export const claudeChannelServerName = (
+  runId: string,
+  repoId?: string
+): string => {
+  const repoSegment = readableRepoSegment(repoId);
+  return repoSegment
+    ? `${BRIDGE_SERVER}-${repoSegment}-${sanitizeBase(runId)}`
+    : legacyClaudeChannelServerName(runId);
+};
+
+export const generatedClaudeChannelServerNames = (
+  runId: string,
+  repoId?: string
+): string[] => {
+  const names = [legacyClaudeChannelServerName(runId)];
+  if (!repoId?.trim()) {
+    return names;
+  }
+  return Array.from(
+    new Set([
+      claudeChannelServerName(runId, repoId),
+      legacyRepoScopedClaudeChannelServerName(runId, repoId),
+      ...names,
+    ])
+  );
+};
+
+export const resolveClaudeChannelServerName = (
+  runId: string,
+  repoId: string | undefined,
+  storedName?: string
+): string => {
+  const nextServer = claudeChannelServerName(runId, repoId);
+  if (!storedName?.trim()) {
+    return nextServer;
+  }
+  return generatedClaudeChannelServerNames(runId, repoId).includes(storedName)
+    ? nextServer
+    : storedName;
+};
+
+export const buildClaudeChannelServerConfig = (
+  launchArgv: string[],
+  runDir: string
+): string =>
+  JSON.stringify(buildBridgeServerConfig(runDir, "claude", launchArgv));
+
 export const buildCodexBridgeConfigArgs = (
   runDir: string,
   source: Agent
 ): string[] => {
-  const [command, ...baseArgs] = buildLaunchArgv();
-  const args = [...baseArgs, BRIDGE_SUBCOMMAND, runDir, source];
+  const config = buildBridgeServerConfig(runDir, source, buildLaunchArgv());
   const approvalArgs = CODEX_AUTO_APPROVED_BRIDGE_TOOLS.flatMap((tool) => [
     "-c",
     `mcp_servers.${BRIDGE_SERVER}.tools.${tool}.approval_mode=${stringifyToml(
@@ -31,32 +123,27 @@ export const buildCodexBridgeConfigArgs = (
   ]);
   return [
     "-c",
-    `mcp_servers.${BRIDGE_SERVER}.command=${stringifyToml(command)}`,
+    `mcp_servers.${BRIDGE_SERVER}.command=${stringifyToml(config.command)}`,
     "-c",
-    `mcp_servers.${BRIDGE_SERVER}.args=${JSON.stringify(args)}`,
+    `mcp_servers.${BRIDGE_SERVER}.args=${JSON.stringify(config.args)}`,
     ...approvalArgs,
   ];
 };
 
 export const ensureClaudeBridgeConfig = (
   runDir: string,
-  source: Agent
+  source: Agent,
+  serverName = BRIDGE_SERVER
 ): string => {
-  const [command, ...baseArgs] = buildLaunchArgv();
   const path = join(runDir, `${source}-mcp.json`);
   ensureParentDir(path);
   writeFileSync(
     path,
     `${JSON.stringify(
-      {
-        mcpServers: {
-          [BRIDGE_SERVER]: {
-            args: [...baseArgs, BRIDGE_SUBCOMMAND, runDir, source],
-            command,
-            type: "stdio",
-          },
-        },
-      },
+      buildBridgeFileConfig(
+        serverName,
+        buildBridgeServerConfig(runDir, source, buildLaunchArgv())
+      ),
       null,
       2
     )}\n`,

src/loop/bridge-dispatch.ts

@@ -24,9 +24,6 @@ export const bridgeChatId = (runDir: string): string => {
   return `codex_${runId}`;
 };
 
-export const isActiveBridgeChatId = (runDir: string, chatId: string): boolean =>
-  chatId === bridgeChatId(runDir);
-
 export const acknowledgeBridgeDelivery = (
   runDir: string,
   message: BridgeMessage,

src/loop/bridge-guidance.ts

@@ -3,12 +3,6 @@ import type { Agent } from "./types";
 
 const bridgeTargetLiteral = (agent: Agent): string => `target: "${agent}"`;
 
-export const claudeReplyGuidance =
-  'When you are replying to an inbound channel message, use the "reply" tool and pass back the same chat_id.';
-
-export const claudeTmuxReplyGuidance =
-  'Reply to inbound Codex channel messages with the "reply" tool and the same chat_id.';
-
 export const bridgeStatusStuckGuidance =
   'Use "bridge_status" only when direct delivery appears stuck.';
 
@@ -19,13 +13,12 @@ export const sendToClaudeGuidance = (): string =>
   `Use "send_to_agent" with ${bridgeTargetLiteral("claude")} for Claude-facing messages, not a human-facing message.`;
 
 export const sendProactiveCodexGuidance = (): string =>
-  `Use "send_to_agent" with ${bridgeTargetLiteral("codex")} only for new proactive messages to Codex; do not send Codex-facing responses as a human-facing message.`;
+  `Use "send_to_agent" with ${bridgeTargetLiteral("codex")} for Codex-facing messages, including replies to inbound Codex channel messages; do not send Codex-facing responses as a human-facing message.`;
 
 export const claudeChannelInstructions = (): string =>
   [
-    `Messages from the Codex agent arrive as <channel source="${BRIDGE_SERVER}" chat_id="..." user="${CLAUDE_CHANNEL_USER}" ...>.`,
-    claudeReplyGuidance,
-    "Never answer the human when the inbound message came from Codex. Send the response back through the bridge tools instead.",
+    `Messages from the Codex agent arrive as <channel source="${BRIDGE_SERVER}" chat_id="..." user="${CLAUDE_CHANNEL_USER}" ...>. The chat_id is informational only.`,
     sendProactiveCodexGuidance(),
+    "Never answer the human when the inbound message came from Codex. Send the response back through the bridge tools instead.",
     bridgeStatusStuckGuidance,
   ].join("\n");

src/loop/bridge-message-format.ts

@@ -0,0 +1,18 @@
+import type { Agent } from "./types";
+
+const BRIDGE_PREFIX_RE =
+  /^(?:Message from (?:Claude|Codex) via the loop bridge:|(?:Claude|Codex):)\s*/i;
+
+export const formatCodexBridgeMessage = (
+  source: Agent,
+  message: string
+): string => {
+  const trimmed = message.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return source === "claude" ? `Claude: ${trimmed}` : trimmed;
+};
+
+export const normalizeBridgeMessage = (message: string): string =>
+  message.trim().replace(BRIDGE_PREFIX_RE, "").replace(/\s+/g, " ");