@rk0429/agentic-relay 0.3.0 → 0.5.0

package/dist/relay.mjs

@@ -1,27 +1,16 @@
 #!/usr/bin/env node
-
-// src/bin/relay.ts
-import { defineCommand as defineCommand10, runMain } from "citty";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
-
-// src/infrastructure/process-manager.ts
-import { execa } from "execa";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/infrastructure/logger.ts
 import { createConsola } from "consola";
-var LOG_LEVEL_MAP = {
-  silent: -1,
-  fatal: 0,
-  error: 0,
-  warn: 1,
-  log: 2,
-  info: 3,
-  success: 3,
-  debug: 4,
-  trace: 5,
-  verbose: 5
-};
 function resolveLogLevel() {
   const envLevel = process.env["RELAY_LOG_LEVEL"]?.toLowerCase();
   if (envLevel && envLevel in LOG_LEVEL_MAP) {
@@ -29,127 +18,734 @@ function resolveLogLevel() {
   }
   return 3;
 }
-var logger = createConsola({
-  level: resolveLogLevel(),
-  defaults: {
-    tag: "relay"
+var LOG_LEVEL_MAP, logger;
+var init_logger = __esm({
+  "src/infrastructure/logger.ts"() {
+    "use strict";
+    LOG_LEVEL_MAP = {
+      silent: -1,
+      fatal: 0,
+      error: 0,
+      warn: 1,
+      log: 2,
+      info: 3,
+      success: 3,
+      debug: 4,
+      trace: 5,
+      verbose: 5
+    };
+    logger = createConsola({
+      level: resolveLogLevel(),
+      defaults: {
+        tag: "relay"
+      }
+    });
   }
 });
 
-// src/infrastructure/process-manager.ts
-var ProcessManager = class {
-  activeProcesses = /* @__PURE__ */ new Set();
-  constructor() {
-    this.setupSignalHandlers();
-  }
-  async spawnInteractive(command, args, options) {
-    logger.debug(`Spawning interactive: ${command} ${args.join(" ")}`);
-    const execaOptions = {
-      stdio: "inherit",
-      cwd: options?.cwd,
-      env: options?.env,
-      extendEnv: options?.env ? false : true,
-      timeout: options?.timeout,
-      reject: false
+// src/mcp-server/recursion-guard.ts
+import { createHash } from "crypto";
+var RecursionGuard;
+var init_recursion_guard = __esm({
+  "src/mcp-server/recursion-guard.ts"() {
+    "use strict";
+    RecursionGuard = class _RecursionGuard {
+      constructor(config = {
+        maxDepth: 5,
+        maxCallsPerSession: 20,
+        timeoutSec: 300
+      }) {
+        this.config = config;
+      }
+      static MAX_ENTRIES = 1e3;
+      callCounts = /* @__PURE__ */ new Map();
+      promptHashes = /* @__PURE__ */ new Map();
+      /** Remove entries older than timeoutSec and enforce size limits */
+      cleanup() {
+        const now = Date.now();
+        const ttlMs = this.config.timeoutSec * 1e3;
+        for (const [key, value] of this.callCounts) {
+          if (now - value.createdAt > ttlMs) {
+            this.callCounts.delete(key);
+          }
+        }
+        for (const [key, value] of this.promptHashes) {
+          if (now - value.createdAt > ttlMs) {
+            this.promptHashes.delete(key);
+          }
+        }
+        if (this.callCounts.size > _RecursionGuard.MAX_ENTRIES) {
+          const sorted = [...this.callCounts.entries()].sort(
+            (a, b) => a[1].createdAt - b[1].createdAt
+          );
+          for (let i = 0; i < sorted.length - _RecursionGuard.MAX_ENTRIES; i++) {
+            this.callCounts.delete(sorted[i][0]);
+          }
+        }
+        if (this.promptHashes.size > _RecursionGuard.MAX_ENTRIES) {
+          const sorted = [...this.promptHashes.entries()].sort(
+            (a, b) => a[1].createdAt - b[1].createdAt
+          );
+          for (let i = 0; i < sorted.length - _RecursionGuard.MAX_ENTRIES; i++) {
+            this.promptHashes.delete(sorted[i][0]);
+          }
+        }
+      }
+      /** Check if a spawn is allowed */
+      canSpawn(context) {
+        this.cleanup();
+        if (context.depth >= this.config.maxDepth) {
+          return {
+            allowed: false,
+            reason: `Max depth exceeded: ${context.depth} >= ${this.config.maxDepth}`
+          };
+        }
+        const currentCount = this.callCounts.get(context.traceId)?.count ?? 0;
+        if (currentCount >= this.config.maxCallsPerSession) {
+          return {
+            allowed: false,
+            reason: `Max calls per session exceeded: ${currentCount} >= ${this.config.maxCallsPerSession}`
+          };
+        }
+        if (this.detectLoop(context.traceId, context.backend, context.promptHash)) {
+          return {
+            allowed: false,
+            reason: `Loop detected: same (backend=${context.backend}, promptHash=${context.promptHash}) appeared 3+ times in trace ${context.traceId}`
+          };
+        }
+        return { allowed: true };
+      }
+      /** Record a spawn invocation */
+      recordSpawn(context) {
+        this.cleanup();
+        const entry = this.callCounts.get(context.traceId);
+        if (entry) {
+          entry.count += 1;
+        } else {
+          this.callCounts.set(context.traceId, { count: 1, createdAt: Date.now() });
+        }
+        const key = `${context.backend}:${context.promptHash}`;
+        const hashEntry = this.promptHashes.get(context.traceId);
+        if (hashEntry) {
+          hashEntry.hashes.push(key);
+        } else {
+          this.promptHashes.set(context.traceId, { hashes: [key], createdAt: Date.now() });
+        }
+      }
+      /** Detect if the same (backend + promptHash) combination has appeared 3+ times */
+      detectLoop(traceId, backend, promptHash) {
+        const key = `${backend}:${promptHash}`;
+        const hashes = this.promptHashes.get(traceId)?.hashes ?? [];
+        const count = hashes.filter((h) => h === key).length;
+        return count >= 3;
+      }
+      /** Get current config (for testing/inspection) */
+      getConfig() {
+        return { ...this.config };
+      }
+      /** Get call count for a trace */
+      getCallCount(traceId) {
+        return this.callCounts.get(traceId)?.count ?? 0;
+      }
+      /** Utility: compute a prompt hash */
+      static hashPrompt(prompt) {
+        return createHash("sha256").update(prompt).digest("hex").slice(0, 16);
+      }
     };
-    const proc = execa(command, args, execaOptions);
-    this.activeProcesses.add(proc);
-    try {
-      await proc;
-    } finally {
-      this.activeProcesses.delete(proc);
-    }
   }
-  async execute(command, args, options) {
-    logger.debug(`Executing: ${command} ${args.join(" ")}`);
-    const stdinMode = options?.stdinMode ?? "pipe";
-    const stdio = stdinMode === "pipe" ? "pipe" : [stdinMode, "pipe", "pipe"];
-    const execaOptions = {
-      stdio,
-      cwd: options?.cwd,
-      env: options?.env,
-      extendEnv: options?.env ? false : true,
-      timeout: options?.timeout,
-      reject: false
+});
+
+// src/mcp-server/tools/spawn-agent.ts
+import { z as z2 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+function buildContextFromEnv() {
+  const traceId = process.env["RELAY_TRACE_ID"] ?? `trace-${nanoid2()}`;
+  const parentSessionId = process.env["RELAY_PARENT_SESSION_ID"] ?? null;
+  const depth = Number(process.env["RELAY_DEPTH"] ?? "0");
+  return { traceId, parentSessionId, depth };
+}
+async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2) {
+  const envContext = buildContextFromEnv();
+  const promptHash = RecursionGuard.hashPrompt(input.prompt);
+  const context = {
+    traceId: envContext.traceId,
+    depth: envContext.depth,
+    backend: input.backend,
+    promptHash
+  };
+  const guardResult = guard.canSpawn(context);
+  if (!guardResult.allowed) {
+    logger.warn(`Spawn blocked by RecursionGuard: ${guardResult.reason}`);
+    return {
+      sessionId: "",
+      exitCode: 1,
+      stdout: "",
+      stderr: `Spawn blocked: ${guardResult.reason}`
     };
-    const proc = execa(command, args, execaOptions);
-    this.activeProcesses.add(proc);
-    try {
-      const result = await proc;
-      return {
-        exitCode: result.exitCode ?? 1,
-        stdout: result.stdout?.toString() ?? "",
-        stderr: result.stderr?.toString() ?? ""
-      };
-    } finally {
-      this.activeProcesses.delete(proc);
-    }
   }
-  async executeWithInput(command, args, stdinData, options) {
-    logger.debug(`Executing with stdin: ${command} ${args.join(" ")}`);
-    const execaOptions = {
-      stdio: "pipe",
-      input: stdinData,
-      cwd: options?.cwd,
-      env: options?.env,
-      timeout: options?.timeout,
-      reject: false
+  const adapter = registry2.get(input.backend);
+  const installed = await adapter.isInstalled();
+  if (!installed) {
+    return {
+      sessionId: "",
+      exitCode: 1,
+      stdout: "",
+      stderr: `Backend "${input.backend}" is not available. Use list_available_backends to see available options.`
     };
-    const proc = execa(command, args, execaOptions);
-    this.activeProcesses.add(proc);
+  }
+  const session = await sessionManager2.create({
+    backendId: input.backend,
+    parentSessionId: envContext.parentSessionId ?? void 0,
+    depth: envContext.depth + 1
+  });
+  if (hooksEngine2) {
     try {
-      const result = await proc;
-      return {
-        exitCode: result.exitCode ?? 1,
-        stdout: result.stdout?.toString() ?? "",
-        stderr: result.stderr?.toString() ?? ""
+      const hookInput = {
+        event: "pre-spawn",
+        sessionId: session.relaySessionId,
+        backendId: input.backend,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          prompt: input.prompt,
+          agent: input.agent,
+          model: input.model
+        }
       };
-    } finally {
-      this.activeProcesses.delete(proc);
+      await hooksEngine2.emit("pre-spawn", hookInput);
+    } catch (error) {
+      logger.debug(
+        `pre-spawn hook error: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
-  setupSignalHandlers() {
-    const handleSignal = (signal) => {
-      logger.debug(`Received ${signal}, forwarding to child processes`);
-      for (const proc of this.activeProcesses) {
-        proc.kill(signal);
+  try {
+    let result;
+    if (input.resumeSessionId) {
+      if (!adapter.continueSession) {
+        return {
+          sessionId: session.relaySessionId,
+          exitCode: 1,
+          stdout: "",
+          stderr: `Backend "${input.backend}" does not support session continuation (continueSession).`
+        };
       }
-    };
-    process.on("SIGINT", () => handleSignal("SIGINT"));
-    process.on("SIGTERM", () => handleSignal("SIGTERM"));
-  }
-};
-
-// src/adapters/adapter-registry.ts
-var AdapterRegistry = class {
-  adapters = /* @__PURE__ */ new Map();
-  register(adapter) {
-    this.adapters.set(adapter.id, adapter);
-  }
-  get(id) {
-    const adapter = this.adapters.get(id);
-    if (!adapter) {
-      throw new Error(
-        `Backend "${id}" is not registered. Available: ${[...this.adapters.keys()].join(", ")}`
+      result = await adapter.continueSession(input.resumeSessionId, input.prompt);
+    } else {
+      result = await adapter.execute({
+        prompt: input.prompt,
+        agent: input.agent,
+        systemPrompt: input.systemPrompt,
+        model: input.model,
+        maxTurns: input.maxTurns,
+        mcpContext: {
+          parentSessionId: session.relaySessionId,
+          depth: envContext.depth + 1,
+          maxDepth: guard.getConfig().maxDepth,
+          traceId: envContext.traceId
+        }
+      });
+    }
+    if (contextMonitor2) {
+      const estimatedTokens = Math.ceil(
+        (result.stdout.length + result.stderr.length) / 4
+      );
+      contextMonitor2.updateUsage(
+        session.relaySessionId,
+        input.backend,
+        estimatedTokens
       );
     }
-    return adapter;
-  }
-  has(id) {
-    return this.adapters.has(id);
+    guard.recordSpawn(context);
+    const status = result.exitCode === 0 ? "completed" : "error";
+    await sessionManager2.update(session.relaySessionId, { status });
+    if (hooksEngine2) {
+      try {
+        const hookInput = {
+          event: "post-spawn",
+          sessionId: session.relaySessionId,
+          backendId: input.backend,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            exitCode: result.exitCode,
+            status
+          }
+        };
+        await hooksEngine2.emit("post-spawn", hookInput);
+      } catch (hookError) {
+        logger.debug(
+          `post-spawn hook error: ${hookError instanceof Error ? hookError.message : String(hookError)}`
+        );
+      }
+    }
+    return {
+      sessionId: session.relaySessionId,
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      nativeSessionId: result.nativeSessionId
+    };
+  } catch (error) {
+    await sessionManager2.update(session.relaySessionId, { status: "error" });
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      sessionId: session.relaySessionId,
+      exitCode: 1,
+      stdout: "",
+      stderr: message
+    };
   }
-  list() {
-    return [...this.adapters.values()];
+}
+var spawnAgentInputSchema;
+var init_spawn_agent = __esm({
+  "src/mcp-server/tools/spawn-agent.ts"() {
+    "use strict";
+    init_recursion_guard();
+    init_logger();
+    spawnAgentInputSchema = z2.object({
+      backend: z2.enum(["claude", "codex", "gemini"]),
+      prompt: z2.string(),
+      agent: z2.string().optional(),
+      systemPrompt: z2.string().optional(),
+      resumeSessionId: z2.string().optional(),
+      model: z2.string().optional(),
+      maxTurns: z2.number().optional()
+    });
   }
-};
+});
 
-// src/adapters/base-adapter.ts
-var BaseAdapter = class {
-  constructor(processManager2) {
-    this.processManager = processManager2;
-  }
-  async isInstalled() {
-    try {
+// src/mcp-server/tools/list-sessions.ts
+import { z as z3 } from "zod";
+async function executeListSessions(input, sessionManager2) {
+  const sessions = await sessionManager2.list({
+    backendId: input.backend,
+    limit: input.limit
+  });
+  return {
+    sessions: sessions.map((s) => ({
+      relaySessionId: s.relaySessionId,
+      backendId: s.backendId,
+      status: s.status,
+      createdAt: s.createdAt.toISOString()
+    }))
+  };
+}
+var listSessionsInputSchema;
+var init_list_sessions = __esm({
+  "src/mcp-server/tools/list-sessions.ts"() {
+    "use strict";
+    listSessionsInputSchema = z3.object({
+      backend: z3.enum(["claude", "codex", "gemini"]).optional(),
+      limit: z3.number().optional().default(10)
+    });
+  }
+});
+
+// src/mcp-server/tools/get-context-status.ts
+import { z as z4 } from "zod";
+async function executeGetContextStatus(input, sessionManager2, contextMonitor2) {
+  const session = await sessionManager2.get(input.sessionId);
+  if (!session) {
+    throw new Error(`Session not found: ${input.sessionId}`);
+  }
+  if (contextMonitor2) {
+    const usage = contextMonitor2.getUsage(input.sessionId);
+    if (usage) {
+      return {
+        sessionId: input.sessionId,
+        backendId: usage.backendId,
+        usagePercent: usage.usagePercent,
+        isEstimated: usage.isEstimated,
+        contextWindow: usage.contextWindow,
+        compactThreshold: usage.compactThreshold,
+        estimatedTokens: usage.estimatedTokens,
+        remainingBeforeCompact: usage.remainingBeforeCompact,
+        notifyThreshold: usage.notifyThreshold
+      };
+    }
+  }
+  return {
+    sessionId: input.sessionId,
+    usagePercent: 0,
+    isEstimated: true
+  };
+}
+var getContextStatusInputSchema;
+var init_get_context_status = __esm({
+  "src/mcp-server/tools/get-context-status.ts"() {
+    "use strict";
+    getContextStatusInputSchema = z4.object({
+      sessionId: z4.string()
+    });
+  }
+});
+
+// src/mcp-server/tools/list-available-backends.ts
+async function executeListAvailableBackends(registry2) {
+  const backends = [];
+  for (const adapter of registry2.list()) {
+    const health = await adapter.checkHealth();
+    backends.push({
+      id: adapter.id,
+      ...health
+    });
+  }
+  return backends;
+}
+var init_list_available_backends = __esm({
+  "src/mcp-server/tools/list-available-backends.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp-server/server.ts
+var server_exports = {};
+__export(server_exports, {
+  RelayMCPServer: () => RelayMCPServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "http";
+import { randomUUID } from "crypto";
+import { z as z5 } from "zod";
+var RelayMCPServer;
+var init_server = __esm({
+  "src/mcp-server/server.ts"() {
+    "use strict";
+    init_recursion_guard();
+    init_spawn_agent();
+    init_list_sessions();
+    init_get_context_status();
+    init_list_available_backends();
+    init_logger();
+    RelayMCPServer = class {
+      constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2) {
+        this.registry = registry2;
+        this.sessionManager = sessionManager2;
+        this.hooksEngine = hooksEngine2;
+        this.contextMonitor = contextMonitor2;
+        this.guard = new RecursionGuard(guardConfig);
+        this.server = new McpServer({
+          name: "agentic-relay",
+          version: "0.4.0"
+        });
+        this.registerTools();
+      }
+      server;
+      guard;
+      registerTools() {
+        this.server.tool(
+          "spawn_agent",
+          "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result. Use 'agent' for named agent configurations (Claude only), or 'systemPrompt' for custom role instructions (all backends).",
+          {
+            backend: z5.enum(["claude", "codex", "gemini"]),
+            prompt: z5.string(),
+            agent: z5.string().optional().describe("Named agent configuration (Claude only)"),
+            systemPrompt: z5.string().optional().describe(
+              "System prompt / role instructions for the sub-agent (all backends)"
+            ),
+            resumeSessionId: z5.string().optional(),
+            model: z5.string().optional(),
+            maxTurns: z5.number().optional()
+          },
+          async (params) => {
+            try {
+              const result = await executeSpawnAgent(
+                params,
+                this.registry,
+                this.sessionManager,
+                this.guard,
+                this.hooksEngine,
+                this.contextMonitor
+              );
+              const isError = result.exitCode !== 0;
+              const text = isError ? `Error (exit ${result.exitCode}): ${result.stderr || result.stdout}` : `Session: ${result.sessionId}
+
+${result.stdout}`;
+              return {
+                content: [{ type: "text", text }],
+                isError
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
+        this.server.tool(
+          "list_sessions",
+          "List relay sessions, optionally filtered by backend.",
+          {
+            backend: z5.enum(["claude", "codex", "gemini"]).optional(),
+            limit: z5.number().optional()
+          },
+          async (params) => {
+            try {
+              const result = await executeListSessions(
+                { backend: params.backend, limit: params.limit ?? 10 },
+                this.sessionManager
+              );
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                  }
+                ]
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
+        this.server.tool(
+          "get_context_status",
+          "Get the context usage status of a relay session. Returns usage data from ContextMonitor when available, otherwise estimated values.",
+          {
+            sessionId: z5.string()
+          },
+          async (params) => {
+            try {
+              const result = await executeGetContextStatus(
+                params,
+                this.sessionManager,
+                this.contextMonitor
+              );
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                  }
+                ]
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
+        this.server.tool(
+          "list_available_backends",
+          "List all registered backends with their health status. Use this before spawn_agent to check which backends are available.",
+          {},
+          async () => {
+            try {
+              const result = await executeListAvailableBackends(this.registry);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                  }
+                ]
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
+      }
+      async start(options) {
+        const transportType = options?.transport ?? "stdio";
+        if (transportType === "stdio") {
+          logger.info("Starting agentic-relay MCP server (stdio transport)...");
+          const transport = new StdioServerTransport();
+          await this.server.connect(transport);
+          return;
+        }
+        const port = options?.port ?? 3100;
+        logger.info(
+          `Starting agentic-relay MCP server (HTTP transport on port ${port})...`
+        );
+        const httpTransport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID()
+        });
+        const httpServer = createServer(async (req, res) => {
+          const url = req.url ?? "";
+          if (url === "/mcp" || url.startsWith("/mcp?")) {
+            await httpTransport.handleRequest(req, res);
+          } else {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("Not found");
+          }
+        });
+        this._httpServer = httpServer;
+        await this.server.connect(httpTransport);
+        await new Promise((resolve) => {
+          httpServer.listen(port, () => {
+            logger.info(`MCP server listening on http://localhost:${port}/mcp`);
+            resolve();
+          });
+        });
+        await new Promise((resolve) => {
+          httpServer.on("close", resolve);
+        });
+      }
+      /** Exposed for testing and graceful shutdown */
+      get httpServer() {
+        return this._httpServer;
+      }
+      _httpServer;
+    };
+  }
+});
+
+// src/bin/relay.ts
+import { defineCommand as defineCommand10, runMain } from "citty";
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+
+// src/infrastructure/process-manager.ts
+init_logger();
+import { execa } from "execa";
+var ProcessManager = class {
+  activeProcesses = /* @__PURE__ */ new Set();
+  constructor() {
+    this.setupSignalHandlers();
+  }
+  async spawnInteractive(command, args, options) {
+    logger.debug(`Spawning interactive: ${command} ${args.join(" ")}`);
+    const execaOptions = {
+      stdio: "inherit",
+      cwd: options?.cwd,
+      env: options?.env,
+      extendEnv: options?.env ? false : true,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      await proc;
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  async execute(command, args, options) {
+    logger.debug(`Executing: ${command} ${args.join(" ")}`);
+    const stdinMode = options?.stdinMode ?? "pipe";
+    const stdio = stdinMode === "pipe" ? "pipe" : [stdinMode, "pipe", "pipe"];
+    const execaOptions = {
+      stdio,
+      cwd: options?.cwd,
+      env: options?.env,
+      extendEnv: options?.env ? false : true,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      const result = await proc;
+      return {
+        exitCode: result.exitCode ?? 1,
+        stdout: result.stdout?.toString() ?? "",
+        stderr: result.stderr?.toString() ?? ""
+      };
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  async executeWithInput(command, args, stdinData, options) {
+    logger.debug(`Executing with stdin: ${command} ${args.join(" ")}`);
+    const execaOptions = {
+      stdio: "pipe",
+      input: stdinData,
+      cwd: options?.cwd,
+      env: options?.env,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      const result = await proc;
+      return {
+        exitCode: result.exitCode ?? 1,
+        stdout: result.stdout?.toString() ?? "",
+        stderr: result.stderr?.toString() ?? ""
+      };
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  setupSignalHandlers() {
+    const handleSignal = (signal) => {
+      logger.debug(`Received ${signal}, forwarding to child processes`);
+      for (const proc of this.activeProcesses) {
+        proc.kill(signal);
+      }
+    };
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  }
+};
+
+// src/adapters/adapter-registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.factories.delete(adapter.id);
+    this.adapters.set(adapter.id, adapter);
+  }
+  registerLazy(id, factory) {
+    this.adapters.delete(id);
+    this.factories.set(id, factory);
+  }
+  get(id) {
+    let adapter = this.adapters.get(id);
+    if (!adapter) {
+      const factory = this.factories.get(id);
+      if (factory) {
+        adapter = factory();
+        this.adapters.set(id, adapter);
+        this.factories.delete(id);
+      }
+    }
+    if (!adapter) {
+      const allIds = [...this.adapters.keys(), ...this.factories.keys()];
+      throw new Error(
+        `Backend "${id}" is not registered. Available: ${allIds.join(", ")}`
+      );
+    }
+    return adapter;
+  }
+  has(id) {
+    return this.adapters.has(id) || this.factories.has(id);
+  }
+  list() {
+    for (const [id, factory] of this.factories) {
+      this.adapters.set(id, factory());
+    }
+    this.factories.clear();
+    return [...this.adapters.values()];
+  }
+};
+
+// src/adapters/base-adapter.ts
+init_logger();
+var BaseAdapter = class {
+  constructor(processManager2) {
+    this.processManager = processManager2;
+  }
+  async isInstalled() {
+    try {
       const result = await this.processManager.execute("which", [this.command]);
       return result.exitCode === 0;
     } catch {
@@ -167,6 +763,42 @@ var BaseAdapter = class {
     }
     return result.stdout.trim();
   }
+  async continueSession(_nativeSessionId, _prompt) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `continueSession not supported for ${this.id}`
+    };
+  }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: `${this.id} is not installed`
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    return {
+      installed: true,
+      authenticated: true,
+      healthy: true,
+      version
+    };
+  }
   async getMCPConfig() {
     logger.warn(`getMCPConfig not implemented for ${this.id}`);
     return [];
@@ -250,10 +882,13 @@ function mapCommonToNative(backendId, flags) {
 }
 
 // src/adapters/claude-adapter.ts
-import {
-  query,
-  listSessions
-} from "@anthropic-ai/claude-agent-sdk";
+init_logger();
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join, dirname } from "path";
+async function loadClaudeSDK() {
+  return await import("@anthropic-ai/claude-agent-sdk");
+}
 var CLAUDE_NESTING_ENV_VARS = [
   "CLAUDECODE",
   "CLAUDE_CODE_SSE_PORT",
@@ -262,6 +897,51 @@ var CLAUDE_NESTING_ENV_VARS = [
 var ClaudeAdapter = class extends BaseAdapter {
   id = "claude";
   command = "claude";
+  getConfigPath() {
+    return join(homedir(), ".claude.json");
+  }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "claude is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    let authenticated = true;
+    try {
+      const result = await Promise.race([
+        this.processManager.execute(this.command, ["auth", "status"]),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+        )
+      ]);
+      authenticated = result.exitCode === 0;
+    } catch {
+      authenticated = true;
+    }
+    return {
+      installed: true,
+      authenticated,
+      healthy: authenticated,
+      version,
+      ...!authenticated ? { message: "claude authentication not configured" } : {}
+    };
+  }
   mapFlags(flags) {
     return {
       args: mapCommonToNative("claude", flags)
@@ -283,11 +963,13 @@ var ClaudeAdapter = class extends BaseAdapter {
     const env = this.buildCleanEnv(flags);
     const permissionMode = this.getPermissionMode();
     try {
+      const { query } = await loadClaudeSDK();
       const options = {
         env,
         cwd: process.cwd(),
         ...flags.model ? { model: flags.model } : {},
-        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {}
+        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
+        ...flags.systemPrompt ? { systemPrompt: flags.systemPrompt } : {}
       };
       if (permissionMode === "bypassPermissions") {
         options.permissionMode = "bypassPermissions";
@@ -316,7 +998,8 @@ var ClaudeAdapter = class extends BaseAdapter {
       return {
         exitCode: isError ? 1 : 0,
         stdout: resultText,
-        stderr: errorMessages.join("\n")
+        stderr: errorMessages.join("\n"),
+        ...sessionId ? { nativeSessionId: sessionId } : {}
       };
     } catch (error) {
       return {
@@ -333,11 +1016,13 @@ var ClaudeAdapter = class extends BaseAdapter {
     const env = this.buildCleanEnv(flags);
     const permissionMode = this.getPermissionMode();
     try {
+      const { query } = await loadClaudeSDK();
       const options = {
         env,
         cwd: process.cwd(),
         ...flags.model ? { model: flags.model } : {},
-        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {}
+        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
+        ...flags.systemPrompt ? { systemPrompt: flags.systemPrompt } : {}
       };
       if (permissionMode === "bypassPermissions") {
         options.permissionMode = "bypassPermissions";
@@ -371,11 +1056,13 @@ var ClaudeAdapter = class extends BaseAdapter {
             message: `Running ${toolName}...`
           };
         } else if (message.type === "result") {
+          const nativeSessionId = message.session_id || void 0;
           if (message.subtype === "success") {
             const resultText = message.result;
             yield {
               type: "done",
-              result: { exitCode: 0, stdout: resultText, stderr: "" }
+              result: { exitCode: 0, stdout: resultText, stderr: "" },
+              nativeSessionId
             };
           } else {
             const errors = message.errors;
@@ -385,7 +1072,8 @@ var ClaudeAdapter = class extends BaseAdapter {
                 exitCode: 1,
                 stdout: "",
                 stderr: errors.join("\n")
-              }
+              },
+              nativeSessionId
             };
           }
         }
@@ -399,7 +1087,45 @@ var ClaudeAdapter = class extends BaseAdapter {
       };
     }
   }
-  async resumeSession(sessionId, flags) {
+  async continueSession(nativeSessionId, prompt) {
+    try {
+      const { query } = await loadClaudeSDK();
+      const permissionMode = this.getPermissionMode();
+      const options = {
+        resume: nativeSessionId,
+        maxTurns: 1,
+        cwd: process.cwd()
+      };
+      if (permissionMode === "bypassPermissions") {
+        options.permissionMode = "bypassPermissions";
+        options.allowDangerouslySkipPermissions = true;
+      }
+      const q = query({
+        prompt,
+        options
+      });
+      let resultText = "";
+      for await (const message of q) {
+        if (message.type === "result") {
+          if (message.subtype === "success") {
+            resultText = message.result;
+          }
+        }
+      }
+      return {
+        exitCode: 0,
+        stdout: resultText,
+        stderr: ""
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async resumeSession(sessionId, flags) {
     await this.processManager.spawnInteractive(
       this.command,
       ["-r", sessionId],
@@ -422,6 +1148,7 @@ var ClaudeAdapter = class extends BaseAdapter {
   }
   async listNativeSessions() {
     try {
+      const { listSessions } = await loadClaudeSDK();
       const sessions = await listSessions({ limit: 20 });
       return sessions.map((s) => ({
         nativeId: s.sessionId,
@@ -447,13 +1174,214 @@ var ClaudeAdapter = class extends BaseAdapter {
       logger.success(`Claude CLI updated: ${result.stdout.trim()}`);
     }
   }
+  async getMCPConfig() {
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const mcpServers = config.mcpServers;
+      if (!mcpServers || typeof mcpServers !== "object") {
+        return [];
+      }
+      return Object.entries(mcpServers).map(([name, entry]) => {
+        const server = {
+          name,
+          command: entry.command
+        };
+        if (entry.args) server.args = entry.args;
+        if (entry.env) server.env = entry.env;
+        return server;
+      });
+    } catch {
+      return [];
+    }
+  }
+  async setMCPConfig(servers) {
+    const configPath = this.getConfigPath();
+    let config = {};
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const mcpServers = {};
+    for (const server of servers) {
+      const entry = {
+        command: server.command
+      };
+      if (server.args) entry.args = server.args;
+      if (server.env) entry.env = server.env;
+      const serverName = server.name ?? server.command;
+      mcpServers[serverName] = entry;
+    }
+    config.mcpServers = mcpServers;
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", {
+      mode: 384
+    });
+  }
 };
 
 // src/adapters/codex-adapter.ts
-import { Codex } from "@openai/codex-sdk";
+init_logger();
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname as dirname2 } from "path";
+async function loadCodexSDK() {
+  return await import("@openai/codex-sdk");
+}
+function parseTOMLMcpServers(content) {
+  const lines = content.split("\n");
+  const preambleLines = [];
+  const postambleLines = [];
+  const mcpServers = /* @__PURE__ */ new Map();
+  let currentServerName = null;
+  let currentServer = { command: "" };
+  let inMcpSection = false;
+  let pastMcpSections = false;
+  for (const line of lines) {
+    const tableMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (tableMatch) {
+      if (currentServerName !== null) {
+        mcpServers.set(currentServerName, currentServer);
+        currentServerName = null;
+      }
+      const tableName = tableMatch[1].trim();
+      const mcpMatch = tableName.match(/^mcp_servers\.(.+)$/);
+      if (mcpMatch) {
+        inMcpSection = true;
+        pastMcpSections = false;
+        currentServerName = mcpMatch[1];
+        currentServer = { command: "" };
+        continue;
+      } else {
+        if (inMcpSection) {
+          pastMcpSections = true;
+          inMcpSection = false;
+        }
+      }
+    }
+    if (inMcpSection && currentServerName !== null) {
+      const kvMatch = line.match(/^\s*(\w+)\s*=\s*(.+)$/);
+      if (kvMatch) {
+        const key = kvMatch[1];
+        const rawValue = kvMatch[2].trim();
+        if (key === "command") {
+          currentServer.command = parseTOMLString(rawValue);
+        } else if (key === "args") {
+          currentServer.args = parseTOMLStringArray(rawValue);
+        }
+      }
+      continue;
+    }
+    if (pastMcpSections || mcpServers.size > 0 && !inMcpSection && currentServerName === null && tableMatch) {
+      postambleLines.push(line);
+    } else if (!inMcpSection && currentServerName === null) {
+      preambleLines.push(line);
+    } else {
+      postambleLines.push(line);
+    }
+  }
+  if (currentServerName !== null) {
+    mcpServers.set(currentServerName, currentServer);
+  }
+  return { preambleLines, postambleLines, mcpServers };
+}
+function parseTOMLString(raw) {
+  const match = raw.match(/^"(.*)"$/);
+  if (match) {
+    return match[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  const singleMatch = raw.match(/^'(.*)'$/);
+  if (singleMatch) {
+    return singleMatch[1];
+  }
+  return raw;
+}
+function parseTOMLStringArray(raw) {
+  const match = raw.match(/^\[(.*)]\s*$/);
+  if (!match) return [];
+  const inner = match[1].trim();
+  if (!inner) return [];
+  const result = [];
+  const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^']*)'/g;
+  let m;
+  while ((m = regex.exec(inner)) !== null) {
+    if (m[1] !== void 0) {
+      result.push(m[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\"));
+    } else if (m[2] !== void 0) {
+      result.push(m[2]);
+    }
+  }
+  return result;
+}
+function toTOMLString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function toTOMLStringArray(values) {
+  return `[${values.map(toTOMLString).join(", ")}]`;
+}
+function generateMcpServersTOML(servers) {
+  const parts = [];
+  for (const server of servers) {
+    const serverName = server.name ?? server.command;
+    parts.push(`[mcp_servers.${serverName}]`);
+    parts.push(`command = ${toTOMLString(server.command)}`);
+    if (server.args && server.args.length > 0) {
+      parts.push(`args = ${toTOMLStringArray(server.args)}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
 var CodexAdapter = class extends BaseAdapter {
   id = "codex";
   command = "codex";
+  getConfigPath() {
+    return join2(homedir2(), ".codex", "config.toml");
+  }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "codex is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    let authenticated = true;
+    try {
+      const result = await Promise.race([
+        this.processManager.execute(this.command, ["login", "status"]),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+        )
+      ]);
+      authenticated = result.exitCode === 0;
+    } catch {
+      authenticated = true;
+    }
+    return {
+      installed: true,
+      authenticated,
+      healthy: authenticated,
+      version,
+      ...!authenticated ? { message: "codex authentication not configured" } : {}
+    };
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("codex", flags);
     if (flags.outputFormat === "json") {
@@ -471,16 +1399,41 @@ var CodexAdapter = class extends BaseAdapter {
     }
     await this.processManager.spawnInteractive(this.command, args);
   }
+  /**
+   * Resolve the effective system prompt from flags.
+   * Priority: systemPrompt > agent fallback > none
+   */
+  resolveSystemPrompt(flags) {
+    if (flags.systemPrompt) return flags.systemPrompt;
+    if (flags.agent) {
+      return `You are acting as the "${flags.agent}" agent. Follow the instructions and role defined for this agent.`;
+    }
+    return void 0;
+  }
+  /**
+   * Build the effective prompt with system instructions prepended if needed.
+   * Codex SDK does not support a native instructions/systemPrompt parameter,
+   * so we inject role context via a prompt prefix.
+   */
+  buildEffectivePrompt(prompt, systemPrompt) {
+    if (!systemPrompt) return prompt;
+    return `[System Instructions]
+${systemPrompt}
+
+[User Request]
+${prompt}`;
+  }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const systemPrompt = this.resolveSystemPrompt(flags);
+    const effectivePrompt = this.buildEffectivePrompt(
+      flags.prompt,
+      systemPrompt
+    );
     try {
+      const { Codex } = await loadCodexSDK();
       const codexOptions = {};
       if (flags.mcpContext) {
         codexOptions.env = {
@@ -496,11 +1449,12 @@ var CodexAdapter = class extends BaseAdapter {
         workingDirectory: process.cwd(),
         approvalPolicy: "never"
       });
-      const result = await thread.run(flags.prompt);
+      const result = await thread.run(effectivePrompt);
       return {
         exitCode: 0,
         stdout: result.finalResponse,
-        stderr: ""
+        stderr: "",
+        ...thread.id ? { nativeSessionId: thread.id } : {}
       };
     } catch (error) {
       return {
@@ -514,12 +1468,13 @@ var CodexAdapter = class extends BaseAdapter {
     if (!flags.prompt) {
       throw new Error("executeStreaming requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const systemPrompt = this.resolveSystemPrompt(flags);
+    const effectivePrompt = this.buildEffectivePrompt(
+      flags.prompt,
+      systemPrompt
+    );
     try {
+      const { Codex } = await loadCodexSDK();
       const codexOptions = {};
       if (flags.mcpContext) {
         codexOptions.env = {
@@ -535,10 +1490,13 @@ var CodexAdapter = class extends BaseAdapter {
         workingDirectory: process.cwd(),
         approvalPolicy: "never"
       });
-      const streamedTurn = await thread.runStreamed(flags.prompt);
+      const streamedTurn = await thread.runStreamed(effectivePrompt);
       const completedMessages = [];
+      let threadId;
       for await (const event of streamedTurn.events) {
-        if (event.type === "item.started") {
+        if (event.type === "thread.started") {
+          threadId = event.thread_id;
+        } else if (event.type === "item.started") {
           const item = event.item;
           if (item?.type === "agent_message" && item.text) {
             yield { type: "text", text: item.text };
@@ -586,13 +1544,15 @@ var CodexAdapter = class extends BaseAdapter {
           const finalResponse = completedMessages.join("\n");
           yield {
             type: "done",
-            result: { exitCode: 0, stdout: finalResponse, stderr: "" }
+            result: { exitCode: 0, stdout: finalResponse, stderr: "" },
+            nativeSessionId: threadId ?? thread.id ?? void 0
           };
         } else if (event.type === "turn.failed") {
           const errorMessage = event.error?.message ?? "Turn failed";
           yield {
             type: "done",
-            result: { exitCode: 1, stdout: "", stderr: errorMessage }
+            result: { exitCode: 1, stdout: "", stderr: errorMessage },
+            nativeSessionId: threadId ?? thread.id ?? void 0
           };
         } else if (event.type === "error") {
           yield {
@@ -610,6 +1570,28 @@ var CodexAdapter = class extends BaseAdapter {
       };
     }
   }
+  async continueSession(nativeSessionId, prompt) {
+    try {
+      const { Codex } = await loadCodexSDK();
+      const codex = new Codex();
+      const thread = codex.resumeThread(nativeSessionId, {
+        workingDirectory: process.cwd(),
+        approvalPolicy: "never"
+      });
+      const result = await thread.run(prompt);
+      return {
+        exitCode: 0,
+        stdout: result.finalResponse,
+        stderr: ""
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   async resumeSession(sessionId, flags) {
     const args = [];
     if (flags.model) {
@@ -647,12 +1629,94 @@ var CodexAdapter = class extends BaseAdapter {
       logger.success(`Codex CLI updated: ${result.stdout.trim()}`);
     }
   }
+  async getMCPConfig() {
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await readFile2(configPath, "utf-8");
+      const parsed = parseTOMLMcpServers(raw);
+      return Array.from(parsed.mcpServers.entries()).map(
+        ([name, entry]) => {
+          const server = {
+            name,
+            command: entry.command
+          };
+          if (entry.args && entry.args.length > 0) {
+            server.args = entry.args;
+          }
+          return server;
+        }
+      );
+    } catch {
+      return [];
+    }
+  }
+  async setMCPConfig(servers) {
+    const configPath = this.getConfigPath();
+    let existingContent = "";
+    try {
+      existingContent = await readFile2(configPath, "utf-8");
+    } catch {
+    }
+    const parsed = parseTOMLMcpServers(existingContent);
+    let preamble = parsed.preambleLines.join("\n");
+    preamble = preamble.replace(/\n+$/, "");
+    const mcpSection = generateMcpServersTOML(servers);
+    let postamble = parsed.postambleLines.join("\n");
+    postamble = postamble.replace(/^\n+/, "");
+    const parts = [];
+    if (preamble) parts.push(preamble);
+    if (mcpSection) parts.push(mcpSection);
+    if (postamble) parts.push(postamble);
+    let output = parts.join("\n\n");
+    if (!output.endsWith("\n")) output += "\n";
+    await mkdir2(dirname2(configPath), { recursive: true });
+    await writeFile2(configPath, output, { mode: 384 });
+  }
 };
 
 // src/adapters/gemini-adapter.ts
+init_logger();
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join3, dirname as dirname3 } from "path";
 var GeminiAdapter = class extends BaseAdapter {
   id = "gemini";
   command = "gemini";
+  getConfigPath() {
+    return join3(homedir3(), ".gemini", "settings.json");
+  }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "gemini is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    const hasApiKey = !!process.env["GEMINI_API_KEY"];
+    const hasGoogleAdc = !!process.env["GOOGLE_APPLICATION_CREDENTIALS"] || !!process.env["CLOUDSDK_CONFIG"];
+    const authenticated = hasApiKey || hasGoogleAdc || true;
+    return {
+      installed: true,
+      authenticated,
+      healthy: true,
+      version
+    };
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("gemini", flags);
     if (flags.outputFormat) {
@@ -673,15 +1737,34 @@ var GeminiAdapter = class extends BaseAdapter {
     }
     await this.processManager.spawnInteractive(this.command, args);
   }
+  /**
+   * Resolve the effective prompt with system instructions prepended if needed.
+   * Gemini CLI has no native system prompt flag, so we use a prompt prefix.
+   * Priority: systemPrompt > agent fallback > none
+   */
+  buildEffectivePrompt(flags) {
+    const prompt = flags.prompt;
+    if (flags.systemPrompt) {
+      return `[System Instructions]
+${flags.systemPrompt}
+
+[User Request]
+${prompt}`;
+    }
+    if (flags.agent) {
+      return `[System Instructions]
+You are acting as the "${flags.agent}" agent.
+
+[User Request]
+${prompt}`;
+    }
+    return prompt;
+  }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Gemini CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const effectivePrompt = this.buildEffectivePrompt(flags);
     const args = [];
     if (flags.model) {
       args.push("--model", flags.model);
@@ -692,7 +1775,7 @@ var GeminiAdapter = class extends BaseAdapter {
     if (flags.verbose) {
       args.push("--verbose");
     }
-    args.push("-p", flags.prompt);
+    args.push("-p", effectivePrompt);
     return this.processManager.execute(this.command, args);
   }
   async resumeSession(sessionId, flags) {
@@ -756,18 +1839,64 @@ var GeminiAdapter = class extends BaseAdapter {
       logger.success(`Gemini CLI updated: ${result.stdout.trim()}`);
     }
   }
+  async getMCPConfig() {
+    const configPath = this.getConfigPath();
+    try {
+      const raw = await readFile3(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      const mcpServers = config.mcpServers;
+      if (!mcpServers || typeof mcpServers !== "object") {
+        return [];
+      }
+      return Object.entries(mcpServers).map(([name, entry]) => {
+        const server = {
+          name,
+          command: entry.command
+        };
+        if (entry.args) server.args = entry.args;
+        if (entry.env) server.env = entry.env;
+        return server;
+      });
+    } catch {
+      return [];
+    }
+  }
+  async setMCPConfig(servers) {
+    const configPath = this.getConfigPath();
+    let config = {};
+    try {
+      const raw = await readFile3(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    const mcpServers = {};
+    for (const server of servers) {
+      const entry = {
+        command: server.command
+      };
+      if (server.args) entry.args = server.args;
+      if (server.env) entry.env = server.env;
+      const serverName = server.name ?? server.command;
+      mcpServers[serverName] = entry;
+    }
+    config.mcpServers = mcpServers;
+    await mkdir3(dirname3(configPath), { recursive: true });
+    await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", {
+      mode: 384
+    });
+  }
 };
 
 // src/core/session-manager.ts
-import { readFile, writeFile, readdir, mkdir, chmod } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
+import { readFile as readFile4, writeFile as writeFile4, readdir, mkdir as mkdir4, chmod } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 import { nanoid } from "nanoid";
 function getRelayHome() {
-  return process.env["RELAY_HOME"] ?? join(homedir(), ".relay");
+  return process.env["RELAY_HOME"] ?? join4(homedir4(), ".relay");
 }
 function getSessionsDir(relayHome2) {
-  return join(relayHome2, "sessions");
+  return join4(relayHome2, "sessions");
 }
 function toSessionData(session) {
   return {
@@ -791,13 +1920,13 @@ var SessionManager = class _SessionManager {
   }
   /** Ensure the sessions directory exists. */
   async ensureDir() {
-    await mkdir(this.sessionsDir, { recursive: true });
+    await mkdir4(this.sessionsDir, { recursive: true });
   }
   sessionPath(relaySessionId) {
     if (!_SessionManager.SESSION_ID_PATTERN.test(relaySessionId)) {
       throw new Error(`Invalid session ID: ${relaySessionId}`);
     }
-    return join(this.sessionsDir, `${relaySessionId}.json`);
+    return join4(this.sessionsDir, `${relaySessionId}.json`);
   }
   /** Create a new relay session. */
   async create(params) {
@@ -814,7 +1943,7 @@ var SessionManager = class _SessionManager {
       status: "active"
     };
     const sessionFilePath = this.sessionPath(session.relaySessionId);
-    await writeFile(
+    await writeFile4(
       sessionFilePath,
       JSON.stringify(toSessionData(session), null, 2),
       "utf-8"
@@ -834,7 +1963,7 @@ var SessionManager = class _SessionManager {
       updatedAt: /* @__PURE__ */ new Date()
     };
     const updateFilePath = this.sessionPath(relaySessionId);
-    await writeFile(
+    await writeFile4(
       updateFilePath,
       JSON.stringify(toSessionData(updated), null, 2),
       "utf-8"
@@ -845,7 +1974,7 @@ var SessionManager = class _SessionManager {
   async get(relaySessionId) {
     const filePath = this.sessionPath(relaySessionId);
     try {
-      const raw = await readFile(filePath, "utf-8");
+      const raw = await readFile4(filePath, "utf-8");
       return fromSessionData(JSON.parse(raw));
     } catch {
       return null;
@@ -869,7 +1998,7 @@ var SessionManager = class _SessionManager {
     const sessions = [];
     for (const file of jsonFiles) {
       try {
-        const raw = await readFile(join(this.sessionsDir, file), "utf-8");
+        const raw = await readFile4(join4(this.sessionsDir, file), "utf-8");
         const session = fromSessionData(JSON.parse(raw));
         if (filter?.backendId && session.backendId !== filter.backendId) {
           continue;
@@ -889,14 +2018,14 @@ var SessionManager = class _SessionManager {
 };
 
 // src/core/config-manager.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
-import { join as join2 } from "path";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5, chmod as chmod2 } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/schemas/config.schema.ts
 import { z } from "zod";
 var backendIdSchema = z.enum(["claude", "codex", "gemini"]);
 var mcpServerConfigSchema = z.object({
-  name: z.string(),
+  name: z.string().optional(),
   command: z.string(),
   args: z.array(z.string()).optional(),
   env: z.record(z.string()).optional()
@@ -920,6 +2049,10 @@ var hookDefinitionSchema = z.object({
 var hooksConfigSchema = z.object({
   definitions: z.array(hookDefinitionSchema)
 });
+var backendContextConfigSchema = z.object({
+  contextWindow: z.number().positive().optional(),
+  compactThreshold: z.number().positive().optional()
+}).optional();
 var relayConfigSchema = z.object({
   defaultBackend: backendIdSchema.optional(),
   mcpServers: z.record(mcpServerConfigSchema).optional(),
@@ -930,9 +2063,16 @@ var relayConfigSchema = z.object({
   }).optional(),
   hooks: hooksConfigSchema.optional(),
   contextMonitor: z.object({
-    enabled: z.boolean(),
-    thresholdPercent: z.number().min(0).max(100),
-    notifyMethod: z.enum(["stderr", "hook"])
+    enabled: z.boolean().optional(),
+    thresholdPercent: z.number().min(0).max(100).optional(),
+    notifyThreshold: z.number().positive().optional(),
+    notifyPercent: z.number().min(0).max(100).optional(),
+    notifyMethod: z.enum(["stderr", "hook"]).optional(),
+    backends: z.object({
+      claude: backendContextConfigSchema,
+      codex: backendContextConfigSchema,
+      gemini: backendContextConfigSchema
+    }).optional()
   }).optional(),
   mcpServerMode: z.object({
     maxDepth: z.number().int().positive(),
@@ -946,6 +2086,7 @@ var relayConfigSchema = z.object({
 });
 
 // src/core/config-manager.ts
+init_logger();
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -1033,8 +2174,8 @@ var ConfigManager = class {
     const existing = await this.readConfigFile(filePath);
     setByPath(existing, key, value);
     const dir = filePath.substring(0, filePath.lastIndexOf("/"));
-    await mkdir2(dir, { recursive: true });
-    await writeFile2(filePath, JSON.stringify(existing, null, 2), "utf-8");
+    await mkdir5(dir, { recursive: true });
+    await writeFile5(filePath, JSON.stringify(existing, null, 2), "utf-8");
     await chmod2(filePath, 384);
   }
   /**
@@ -1043,7 +2184,12 @@ var ConfigManager = class {
   async syncMCPConfig(registry2) {
     const config = await this.getConfig();
     const mcpServers = config.mcpServers ?? {};
-    const servers = Object.values(mcpServers);
+    const servers = Object.entries(mcpServers).map(
+      ([key, server]) => ({
+        ...server,
+        name: server.name || key
+      })
+    );
     const adapters = registry2.list();
     for (const adapter of adapters) {
       try {
@@ -1060,11 +2206,11 @@ var ConfigManager = class {
   getFilePath(scope) {
     switch (scope) {
       case "global":
-        return join2(this.globalDir, "config.json");
+        return join5(this.globalDir, "config.json");
       case "project":
-        return join2(this.projectDir ?? "", "config.json");
+        return join5(this.projectDir ?? "", "config.json");
       case "local":
-        return join2(this.projectDir ?? "", "config.local.json");
+        return join5(this.projectDir ?? "", "config.local.json");
     }
   }
   mapConfigScope(scope) {
@@ -1081,7 +2227,7 @@ var ConfigManager = class {
   }
   async readConfigFile(filePath) {
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile5(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!isPlainObject(parsed)) return {};
       return parsed;
@@ -1110,6 +2256,7 @@ var ConfigManager = class {
 };
 
 // src/core/auth-manager.ts
+init_logger();
 var AuthManager = class {
   constructor(registry2) {
     this.registry = registry2;
@@ -1183,6 +2330,7 @@ var EventBus = class {
 };
 
 // src/core/hooks-engine.ts
+init_logger();
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_HOOK_OUTPUT = {
   allow: true,
@@ -1320,34 +2468,75 @@ var HooksEngine = class _HooksEngine {
 };
 
 // src/core/context-monitor.ts
+var DEFAULT_BACKEND_CONTEXT = {
+  claude: { contextWindow: 2e5, compactThreshold: 19e4 },
+  codex: { contextWindow: 272e3, compactThreshold: 258400 },
+  gemini: { contextWindow: 1048576, compactThreshold: 524288 }
+};
+var DEFAULT_NOTIFY_PERCENT = 70;
 var DEFAULT_CONFIG = {
   enabled: true,
-  thresholdPercent: 75,
-  notifyMethod: "stderr"
+  notifyMethod: "hook"
 };
 var ContextMonitor = class {
   constructor(hooksEngine2, config) {
     this.hooksEngine = hooksEngine2;
     this.config = { ...DEFAULT_CONFIG, ...config };
+    if (this.config.thresholdPercent !== void 0 && this.config.notifyPercent === void 0 && this.config.notifyThreshold === void 0) {
+      this.config.notifyPercent = this.config.thresholdPercent;
+    }
   }
   config;
   usageMap = /* @__PURE__ */ new Map();
+  /** Get backend context config, merging user overrides with defaults */
+  getBackendConfig(backendId) {
+    const defaults = DEFAULT_BACKEND_CONTEXT[backendId];
+    const overrides = this.config.backends?.[backendId];
+    return {
+      contextWindow: overrides?.contextWindow ?? defaults.contextWindow,
+      compactThreshold: overrides?.compactThreshold ?? defaults.compactThreshold
+    };
+  }
+  /** Calculate the notification threshold in tokens for a given backend */
+  getNotifyThreshold(backendId) {
+    if (this.config.notifyThreshold !== void 0) {
+      return this.config.notifyThreshold;
+    }
+    const backendConfig = this.getBackendConfig(backendId);
+    const notifyPercent = this.config.notifyPercent ?? DEFAULT_NOTIFY_PERCENT;
+    return Math.round(backendConfig.contextWindow * notifyPercent / 100);
+  }
   /** Update token usage for a session and check threshold */
-  updateUsage(sessionId, backendId, estimatedTokens, maxTokens) {
+  updateUsage(sessionId, backendId, estimatedTokens) {
     if (!this.config.enabled) return;
-    const usagePercent = maxTokens > 0 ? Math.round(estimatedTokens / maxTokens * 100) : 0;
+    const backendConfig = this.getBackendConfig(backendId);
+    const contextWindow = backendConfig.contextWindow;
+    const usagePercent = contextWindow > 0 ? Math.round(estimatedTokens / contextWindow * 100) : 0;
     const existing = this.usageMap.get(sessionId);
-    const wasNotified = existing?.notified ?? false;
+    let wasNotified = existing?.notified ?? false;
+    if (existing && estimatedTokens < existing.estimatedTokens * 0.7) {
+      wasNotified = false;
+    }
     this.usageMap.set(sessionId, {
       estimatedTokens,
-      maxTokens,
+      contextWindow,
+      compactThreshold: backendConfig.compactThreshold,
       usagePercent,
       backendId,
       notified: wasNotified
     });
-    if (usagePercent >= this.config.thresholdPercent && !wasNotified) {
-      this.usageMap.get(sessionId).notified = true;
-      this.notify(sessionId, backendId, usagePercent);
+    const notifyAt = this.getNotifyThreshold(backendId);
+    if (estimatedTokens >= notifyAt && !wasNotified) {
+      const entry = this.usageMap.get(sessionId);
+      entry.notified = true;
+      this.notify(
+        sessionId,
+        backendId,
+        usagePercent,
+        estimatedTokens,
+        contextWindow,
+        backendConfig.compactThreshold
+      );
     }
   }
   /** Get usage info for a session */
@@ -1356,17 +2545,31 @@ var ContextMonitor = class {
     if (!entry) return null;
     return {
       usagePercent: entry.usagePercent,
-      isEstimated: true
+      isEstimated: true,
+      backendId: entry.backendId,
+      contextWindow: entry.contextWindow,
+      compactThreshold: entry.compactThreshold,
+      estimatedTokens: entry.estimatedTokens,
+      remainingBeforeCompact: Math.max(
+        0,
+        entry.compactThreshold - entry.estimatedTokens
+      ),
+      notifyThreshold: this.getNotifyThreshold(entry.backendId)
     };
   }
   /** Remove usage tracking for a session */
   removeSession(sessionId) {
     this.usageMap.delete(sessionId);
   }
-  notify(sessionId, backendId, usagePercent) {
+  notify(sessionId, backendId, usagePercent, currentTokens, contextWindow, compactThreshold) {
+    const remainingBeforeCompact = Math.max(
+      0,
+      compactThreshold - currentTokens
+    );
+    const warningMessage = `${backendId} session ${sessionId} at ${usagePercent}% (${currentTokens}/${contextWindow} tokens). Compact in ~${remainingBeforeCompact} tokens. Save your work state now.`;
     if (this.config.notifyMethod === "stderr") {
       process.stderr.write(
-        `[relay] Context usage warning: session ${sessionId} is at ${usagePercent}% (threshold: ${this.config.thresholdPercent}%)
+        `[relay] Context warning: ${warningMessage}
 `
       );
     } else if (this.config.notifyMethod === "hook" && this.hooksEngine) {
@@ -1377,7 +2580,10 @@ var ContextMonitor = class {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data: {
           usagePercent,
-          thresholdPercent: this.config.thresholdPercent
+          currentTokens,
+          contextWindow,
+          compactThreshold,
+          remainingBeforeCompact
         }
       };
       void this.hooksEngine.emit("on-context-threshold", hookInput);
@@ -1386,6 +2592,7 @@ var ContextMonitor = class {
 };
 
 // src/commands/backend.ts
+init_logger();
 import { defineCommand } from "citty";
 
 // src/adapters/install-guides.ts
@@ -1437,6 +2644,11 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
       verbose: {
         type: "boolean",
         description: "Enable verbose output"
+      },
+      dryRun: {
+        type: "boolean",
+        description: "Show what would be executed without running it",
+        default: false
       }
     },
     async run({ args }) {
@@ -1460,6 +2672,23 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
         flags.outputFormat = args.outputFormat;
       }
       if (args.verbose) flags.verbose = true;
+      if (args.dryRun) {
+        const nativeFlags = adapter.mapFlags(flags);
+        const dryRunOutput = {
+          backend: backendId,
+          installed: await adapter.isInstalled(),
+          nativeArgs: nativeFlags.args,
+          relayEnv: {
+            RELAY_HOME: process.env["RELAY_HOME"] ?? "~/.relay",
+            RELAY_LOG_LEVEL: process.env["RELAY_LOG_LEVEL"] ?? "info"
+          },
+          sessionTracking: !!sessionManager2,
+          hooksEnabled: !!hooksEngine2,
+          contextMonitorEnabled: !!contextMonitor2
+        };
+        console.log(JSON.stringify(dryRunOutput, null, 2));
+        return;
+      }
       let relaySessionId;
       if (sessionManager2) {
         try {
@@ -1491,6 +2720,7 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
       try {
         if (flags.prompt) {
           logger.debug(`Executing prompt on ${backendId}`);
+          let nativeSessionId;
           if (adapter.executeStreaming) {
             for await (const event of adapter.executeStreaming(flags)) {
               switch (event.type) {
@@ -1521,18 +2751,25 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
                   break;
                 case "usage": {
                   if (contextMonitor2 && relaySessionId) {
-                    const maxTokens = backendId === "gemini" ? 128e3 : 2e5;
                     contextMonitor2.updateUsage(
                       relaySessionId,
                       backendId,
-                      event.inputTokens + event.outputTokens,
-                      maxTokens
+                      event.inputTokens + event.outputTokens
                     );
                   }
                   break;
                 }
                 case "done":
                   process.exitCode = event.result.exitCode;
+                  nativeSessionId = event.nativeSessionId;
+                  if (event.nativeSessionId && sessionManager2 && relaySessionId) {
+                    try {
+                      await sessionManager2.update(relaySessionId, {
+                        nativeSessionId: event.nativeSessionId
+                      });
+                    } catch {
+                    }
+                  }
                   break;
               }
             }
@@ -1541,6 +2778,15 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
             if (result.stdout) process.stdout.write(result.stdout);
             if (result.stderr) process.stderr.write(result.stderr);
             process.exitCode = result.exitCode;
+            nativeSessionId = result.nativeSessionId;
+            if (result.nativeSessionId && sessionManager2 && relaySessionId) {
+              try {
+                await sessionManager2.update(relaySessionId, {
+                  nativeSessionId: result.nativeSessionId
+                });
+              } catch {
+              }
+            }
           }
         } else if (flags.continue) {
           logger.debug(`Continuing latest session on ${backendId}`);
@@ -1614,642 +2860,187 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
           }
         }
         throw error;
-      }
-    }
-  });
-}
-
-// src/commands/update.ts
-import { defineCommand as defineCommand2 } from "citty";
-
-// src/infrastructure/version-check.ts
-async function getLatestNpmVersion(packageName) {
-  try {
-    const response = await fetch(
-      `https://registry.npmjs.org/${packageName}/latest`,
-      {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(5e3)
-      }
-    );
-    if (!response.ok) {
-      logger.debug(
-        `npm registry returned ${response.status} for ${packageName}`
-      );
-      return null;
-    }
-    const data = await response.json();
-    return data.version ?? null;
-  } catch (error) {
-    logger.debug(
-      `Failed to check npm registry: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return null;
-  }
-}
-function compareSemver(a, b) {
-  const partsA = a.replace(/^v/, "").split(".").map(Number);
-  const partsB = b.replace(/^v/, "").split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
-}
-
-// src/commands/update.ts
-var PACKAGE_NAME = "@rk0429/agentic-relay";
-var CURRENT_VERSION = "0.3.0";
-function createUpdateCommand(registry2) {
-  return defineCommand2({
-    meta: {
-      name: "update",
-      description: "Update relay and all installed backend CLI tools"
-    },
-    async run() {
-      logger.info("Checking for relay updates...");
-      const latestVersion = await getLatestNpmVersion(PACKAGE_NAME);
-      if (latestVersion) {
-        if (compareSemver(latestVersion, CURRENT_VERSION) > 0) {
-          logger.warn(
-            `A newer version of relay is available: ${latestVersion} (current: ${CURRENT_VERSION})`
-          );
-          logger.info(`  Run: npm install -g ${PACKAGE_NAME}@latest`);
-        } else {
-          logger.success(`relay is up to date (${CURRENT_VERSION})`);
-        }
-      } else {
-        logger.debug("Could not check for relay updates");
-      }
-      const adapters = registry2.list();
-      if (adapters.length === 0) {
-        logger.warn("No backends registered");
-        return;
-      }
-      for (const adapter of adapters) {
-        const installed = await adapter.isInstalled();
-        if (!installed) {
-          logger.info(`Skipping ${adapter.id}: not installed`);
-          continue;
-        }
-        logger.info(`Updating ${adapter.id}...`);
-        try {
-          await adapter.update();
-        } catch (error) {
-          logger.error(
-            `Failed to update ${adapter.id}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    }
-  });
-}
-
-// src/commands/config.ts
-import { defineCommand as defineCommand3 } from "citty";
-function createConfigCommand(configManager2) {
-  return defineCommand3({
-    meta: {
-      name: "config",
-      description: "Manage relay configuration"
-    },
-    subCommands: {
-      get: defineCommand3({
-        meta: {
-          name: "get",
-          description: "Get a config value by key (dot-path notation)"
-        },
-        args: {
-          key: {
-            type: "positional",
-            description: "Config key (e.g. mcpServerMode.maxDepth)",
-            required: true
-          }
-        },
-        async run({ args }) {
-          const key = String(args.key);
-          const value = await configManager2.get(key);
-          if (value === void 0) {
-            logger.info(`Key "${key}" is not set`);
-          } else {
-            const output = typeof value === "object" ? JSON.stringify(value, null, 2) : String(value);
-            console.log(output);
-          }
-        }
-      }),
-      set: defineCommand3({
-        meta: {
-          name: "set",
-          description: "Set a config value (default: global scope)"
-        },
-        args: {
-          project: {
-            type: "boolean",
-            description: "Write to project scope instead of global"
-          },
-          key: {
-            type: "positional",
-            description: "Config key (e.g. defaultBackend)",
-            required: true
-          },
-          value: {
-            type: "positional",
-            description: "Config value",
-            required: true
-          }
-        },
-        async run({ args }) {
-          const scope = args.project ? "project" : "global";
-          const key = String(args.key);
-          const rawValue = String(args.value);
-          const parsed = parseValue(rawValue);
-          await configManager2.set(scope, key, parsed);
-          logger.success(`Set ${key} = ${JSON.stringify(parsed)} (${scope})`);
-        }
-      })
-    },
-    async run() {
-      const config = await configManager2.getConfig();
-      console.log(JSON.stringify(config, null, 2));
-    }
-  });
-}
-function parseValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  if (raw === "null") return null;
-  const num = Number(raw);
-  if (!Number.isNaN(num) && raw.trim() !== "") return num;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "object") return parsed;
-  } catch {
-  }
-  return raw;
-}
-
-// src/commands/mcp.ts
-import { defineCommand as defineCommand4 } from "citty";
-
-// src/mcp-server/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { createServer } from "http";
-import { randomUUID } from "crypto";
-import { z as z5 } from "zod";
-
-// src/mcp-server/recursion-guard.ts
-import { createHash } from "crypto";
-var RecursionGuard = class _RecursionGuard {
-  constructor(config = {
-    maxDepth: 5,
-    maxCallsPerSession: 20,
-    timeoutSec: 300
-  }) {
-    this.config = config;
-  }
-  static MAX_ENTRIES = 1e3;
-  callCounts = /* @__PURE__ */ new Map();
-  promptHashes = /* @__PURE__ */ new Map();
-  /** Remove entries older than timeoutSec and enforce size limits */
-  cleanup() {
-    const now = Date.now();
-    const ttlMs = this.config.timeoutSec * 1e3;
-    for (const [key, value] of this.callCounts) {
-      if (now - value.createdAt > ttlMs) {
-        this.callCounts.delete(key);
-      }
-    }
-    for (const [key, value] of this.promptHashes) {
-      if (now - value.createdAt > ttlMs) {
-        this.promptHashes.delete(key);
-      }
-    }
-    if (this.callCounts.size > _RecursionGuard.MAX_ENTRIES) {
-      const sorted = [...this.callCounts.entries()].sort(
-        (a, b) => a[1].createdAt - b[1].createdAt
-      );
-      for (let i = 0; i < sorted.length - _RecursionGuard.MAX_ENTRIES; i++) {
-        this.callCounts.delete(sorted[i][0]);
-      }
-    }
-    if (this.promptHashes.size > _RecursionGuard.MAX_ENTRIES) {
-      const sorted = [...this.promptHashes.entries()].sort(
-        (a, b) => a[1].createdAt - b[1].createdAt
-      );
-      for (let i = 0; i < sorted.length - _RecursionGuard.MAX_ENTRIES; i++) {
-        this.promptHashes.delete(sorted[i][0]);
-      }
-    }
-  }
-  /** Check if a spawn is allowed */
-  canSpawn(context) {
-    this.cleanup();
-    if (context.depth >= this.config.maxDepth) {
-      return {
-        allowed: false,
-        reason: `Max depth exceeded: ${context.depth} >= ${this.config.maxDepth}`
-      };
-    }
-    const currentCount = this.callCounts.get(context.traceId)?.count ?? 0;
-    if (currentCount >= this.config.maxCallsPerSession) {
-      return {
-        allowed: false,
-        reason: `Max calls per session exceeded: ${currentCount} >= ${this.config.maxCallsPerSession}`
-      };
-    }
-    if (this.detectLoop(context.traceId, context.backend, context.promptHash)) {
-      return {
-        allowed: false,
-        reason: `Loop detected: same (backend=${context.backend}, promptHash=${context.promptHash}) appeared 3+ times in trace ${context.traceId}`
-      };
-    }
-    return { allowed: true };
-  }
-  /** Record a spawn invocation */
-  recordSpawn(context) {
-    this.cleanup();
-    const entry = this.callCounts.get(context.traceId);
-    if (entry) {
-      entry.count += 1;
-    } else {
-      this.callCounts.set(context.traceId, { count: 1, createdAt: Date.now() });
-    }
-    const key = `${context.backend}:${context.promptHash}`;
-    const hashEntry = this.promptHashes.get(context.traceId);
-    if (hashEntry) {
-      hashEntry.hashes.push(key);
-    } else {
-      this.promptHashes.set(context.traceId, { hashes: [key], createdAt: Date.now() });
-    }
-  }
-  /** Detect if the same (backend + promptHash) combination has appeared 3+ times */
-  detectLoop(traceId, backend, promptHash) {
-    const key = `${backend}:${promptHash}`;
-    const hashes = this.promptHashes.get(traceId)?.hashes ?? [];
-    const count = hashes.filter((h) => h === key).length;
-    return count >= 3;
-  }
-  /** Get current config (for testing/inspection) */
-  getConfig() {
-    return { ...this.config };
-  }
-  /** Get call count for a trace */
-  getCallCount(traceId) {
-    return this.callCounts.get(traceId)?.count ?? 0;
-  }
-  /** Utility: compute a prompt hash */
-  static hashPrompt(prompt) {
-    return createHash("sha256").update(prompt).digest("hex").slice(0, 16);
-  }
-};
-
-// src/mcp-server/tools/spawn-agent.ts
-import { z as z2 } from "zod";
-import { nanoid as nanoid2 } from "nanoid";
-var spawnAgentInputSchema = z2.object({
-  backend: z2.enum(["claude", "codex", "gemini"]),
-  prompt: z2.string(),
-  agent: z2.string().optional(),
-  resumeSessionId: z2.string().optional(),
-  model: z2.string().optional(),
-  maxTurns: z2.number().optional()
-});
-function buildContextFromEnv() {
-  const traceId = process.env["RELAY_TRACE_ID"] ?? `trace-${nanoid2()}`;
-  const parentSessionId = process.env["RELAY_PARENT_SESSION_ID"] ?? null;
-  const depth = Number(process.env["RELAY_DEPTH"] ?? "0");
-  return { traceId, parentSessionId, depth };
-}
-async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2) {
-  const envContext = buildContextFromEnv();
-  const promptHash = RecursionGuard.hashPrompt(input.prompt);
-  const context = {
-    traceId: envContext.traceId,
-    depth: envContext.depth,
-    backend: input.backend,
-    promptHash
-  };
-  const guardResult = guard.canSpawn(context);
-  if (!guardResult.allowed) {
-    logger.warn(`Spawn blocked by RecursionGuard: ${guardResult.reason}`);
-    return {
-      sessionId: "",
-      exitCode: 1,
-      stdout: "",
-      stderr: `Spawn blocked: ${guardResult.reason}`
-    };
-  }
-  const adapter = registry2.get(input.backend);
-  const installed = await adapter.isInstalled();
-  if (!installed) {
-    return {
-      sessionId: "",
-      exitCode: 1,
-      stdout: "",
-      stderr: `Backend "${input.backend}" is not installed`
-    };
-  }
-  const session = await sessionManager2.create({
-    backendId: input.backend,
-    parentSessionId: envContext.parentSessionId ?? void 0,
-    depth: envContext.depth + 1
-  });
-  if (hooksEngine2) {
-    try {
-      const hookInput = {
-        event: "pre-spawn",
-        sessionId: session.relaySessionId,
-        backendId: input.backend,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        data: {
-          prompt: input.prompt,
-          agent: input.agent,
-          model: input.model
-        }
-      };
-      await hooksEngine2.emit("pre-spawn", hookInput);
-    } catch (error) {
-      logger.debug(
-        `pre-spawn hook error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  try {
-    const result = await adapter.execute({
-      prompt: input.prompt,
-      agent: input.agent,
-      model: input.model,
-      maxTurns: input.maxTurns,
-      resume: input.resumeSessionId,
-      mcpContext: {
-        parentSessionId: session.relaySessionId,
-        depth: envContext.depth + 1,
-        maxDepth: guard.getConfig().maxDepth,
-        traceId: envContext.traceId
-      }
-    });
-    if (contextMonitor2) {
-      const estimatedTokens = Math.ceil(
-        (result.stdout.length + result.stderr.length) / 4
-      );
-      const maxTokens = input.backend === "gemini" ? 128e3 : 2e5;
-      contextMonitor2.updateUsage(
-        session.relaySessionId,
-        input.backend,
-        estimatedTokens,
-        maxTokens
-      );
-    }
-    guard.recordSpawn(context);
-    const status = result.exitCode === 0 ? "completed" : "error";
-    await sessionManager2.update(session.relaySessionId, { status });
-    if (hooksEngine2) {
-      try {
-        const hookInput = {
-          event: "post-spawn",
-          sessionId: session.relaySessionId,
-          backendId: input.backend,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          data: {
-            exitCode: result.exitCode,
-            status
-          }
-        };
-        await hooksEngine2.emit("post-spawn", hookInput);
-      } catch (hookError) {
-        logger.debug(
-          `post-spawn hook error: ${hookError instanceof Error ? hookError.message : String(hookError)}`
-        );
-      }
-    }
-    return {
-      sessionId: session.relaySessionId,
-      exitCode: result.exitCode,
-      stdout: result.stdout,
-      stderr: result.stderr
-    };
-  } catch (error) {
-    await sessionManager2.update(session.relaySessionId, { status: "error" });
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      sessionId: session.relaySessionId,
-      exitCode: 1,
-      stdout: "",
-      stderr: message
-    };
-  }
-}
-
-// src/mcp-server/tools/list-sessions.ts
-import { z as z3 } from "zod";
-var listSessionsInputSchema = z3.object({
-  backend: z3.enum(["claude", "codex", "gemini"]).optional(),
-  limit: z3.number().optional().default(10)
-});
-async function executeListSessions(input, sessionManager2) {
-  const sessions = await sessionManager2.list({
-    backendId: input.backend,
-    limit: input.limit
-  });
-  return {
-    sessions: sessions.map((s) => ({
-      relaySessionId: s.relaySessionId,
-      backendId: s.backendId,
-      status: s.status,
-      createdAt: s.createdAt.toISOString()
-    }))
-  };
-}
-
-// src/mcp-server/tools/get-context-status.ts
-import { z as z4 } from "zod";
-var getContextStatusInputSchema = z4.object({
-  sessionId: z4.string()
-});
-async function executeGetContextStatus(input, sessionManager2, contextMonitor2) {
-  const session = await sessionManager2.get(input.sessionId);
-  if (!session) {
-    throw new Error(`Session not found: ${input.sessionId}`);
-  }
-  if (contextMonitor2) {
-    const usage = contextMonitor2.getUsage(input.sessionId);
-    if (usage) {
-      return {
-        sessionId: input.sessionId,
-        usagePercent: usage.usagePercent,
-        isEstimated: usage.isEstimated
-      };
-    }
-  }
-  return {
-    sessionId: input.sessionId,
-    usagePercent: 0,
-    isEstimated: true
-  };
+      }
+    }
+  });
 }
 
-// src/mcp-server/server.ts
-var RelayMCPServer = class {
-  constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2) {
-    this.registry = registry2;
-    this.sessionManager = sessionManager2;
-    this.hooksEngine = hooksEngine2;
-    this.contextMonitor = contextMonitor2;
-    this.guard = new RecursionGuard(guardConfig);
-    this.server = new McpServer({
-      name: "agentic-relay",
-      version: "0.3.0"
-    });
-    this.registerTools();
-  }
-  server;
-  guard;
-  registerTools() {
-    this.server.tool(
-      "spawn_agent",
-      "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result.",
-      {
-        backend: z5.enum(["claude", "codex", "gemini"]),
-        prompt: z5.string(),
-        agent: z5.string().optional(),
-        resumeSessionId: z5.string().optional(),
-        model: z5.string().optional(),
-        maxTurns: z5.number().optional()
-      },
-      async (params) => {
-        try {
-          const result = await executeSpawnAgent(
-            params,
-            this.registry,
-            this.sessionManager,
-            this.guard,
-            this.hooksEngine,
-            this.contextMonitor
-          );
-          const isError = result.exitCode !== 0;
-          const text = isError ? `Error (exit ${result.exitCode}): ${result.stderr || result.stdout}` : `Session: ${result.sessionId}
+// src/commands/update.ts
+init_logger();
+import { defineCommand as defineCommand2 } from "citty";
 
-${result.stdout}`;
-          return {
-            content: [{ type: "text", text }],
-            isError
-          };
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true
-          };
-        }
+// src/infrastructure/version-check.ts
+init_logger();
+async function getLatestNpmVersion(packageName) {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${packageName}/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(5e3)
       }
     );
-    this.server.tool(
-      "list_sessions",
-      "List relay sessions, optionally filtered by backend.",
-      {
-        backend: z5.enum(["claude", "codex", "gemini"]).optional(),
-        limit: z5.number().optional()
-      },
-      async (params) => {
-        try {
-          const result = await executeListSessions(
-            { backend: params.backend, limit: params.limit ?? 10 },
-            this.sessionManager
+    if (!response.ok) {
+      logger.debug(
+        `npm registry returned ${response.status} for ${packageName}`
+      );
+      return null;
+    }
+    const data = await response.json();
+    return data.version ?? null;
+  } catch (error) {
+    logger.debug(
+      `Failed to check npm registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function compareSemver(a, b) {
+  const partsA = a.replace(/^v/, "").split(".").map(Number);
+  const partsB = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// src/commands/update.ts
+var PACKAGE_NAME = "@rk0429/agentic-relay";
+var CURRENT_VERSION = "0.4.0";
+function createUpdateCommand(registry2) {
+  return defineCommand2({
+    meta: {
+      name: "update",
+      description: "Update relay and all installed backend CLI tools"
+    },
+    async run() {
+      logger.info("Checking for relay updates...");
+      const latestVersion = await getLatestNpmVersion(PACKAGE_NAME);
+      if (latestVersion) {
+        if (compareSemver(latestVersion, CURRENT_VERSION) > 0) {
+          logger.warn(
+            `A newer version of relay is available: ${latestVersion} (current: ${CURRENT_VERSION})`
           );
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(result, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true
-          };
+          logger.info(`  Run: npm install -g ${PACKAGE_NAME}@latest`);
+        } else {
+          logger.success(`relay is up to date (${CURRENT_VERSION})`);
         }
+      } else {
+        logger.debug("Could not check for relay updates");
       }
-    );
-    this.server.tool(
-      "get_context_status",
-      "Get the context usage status of a relay session. Returns usage data from ContextMonitor when available, otherwise estimated values.",
-      {
-        sessionId: z5.string()
-      },
-      async (params) => {
+      const adapters = registry2.list();
+      if (adapters.length === 0) {
+        logger.warn("No backends registered");
+        return;
+      }
+      for (const adapter of adapters) {
+        const installed = await adapter.isInstalled();
+        if (!installed) {
+          logger.info(`Skipping ${adapter.id}: not installed`);
+          continue;
+        }
+        logger.info(`Updating ${adapter.id}...`);
         try {
-          const result = await executeGetContextStatus(
-            params,
-            this.sessionManager,
-            this.contextMonitor
-          );
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(result, null, 2)
-              }
-            ]
-          };
+          await adapter.update();
         } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true
-          };
+          logger.error(
+            `Failed to update ${adapter.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
         }
       }
-    );
-  }
-  async start(options) {
-    const transportType = options?.transport ?? "stdio";
-    if (transportType === "stdio") {
-      logger.info("Starting agentic-relay MCP server (stdio transport)...");
-      const transport = new StdioServerTransport();
-      await this.server.connect(transport);
-      return;
     }
-    const port = options?.port ?? 3100;
-    logger.info(
-      `Starting agentic-relay MCP server (HTTP transport on port ${port})...`
-    );
-    const httpTransport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID()
-    });
-    const httpServer = createServer(async (req, res) => {
-      const url = req.url ?? "";
-      if (url === "/mcp" || url.startsWith("/mcp?")) {
-        await httpTransport.handleRequest(req, res);
-      } else {
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end("Not found");
-      }
-    });
-    this._httpServer = httpServer;
-    await this.server.connect(httpTransport);
-    await new Promise((resolve) => {
-      httpServer.listen(port, () => {
-        logger.info(`MCP server listening on http://localhost:${port}/mcp`);
-        resolve();
-      });
-    });
-    await new Promise((resolve) => {
-      httpServer.on("close", resolve);
-    });
-  }
-  /** Exposed for testing and graceful shutdown */
-  get httpServer() {
-    return this._httpServer;
+  });
+}
+
+// src/commands/config.ts
+init_logger();
+import { defineCommand as defineCommand3 } from "citty";
+function createConfigCommand(configManager2) {
+  return defineCommand3({
+    meta: {
+      name: "config",
+      description: "Manage relay configuration"
+    },
+    subCommands: {
+      get: defineCommand3({
+        meta: {
+          name: "get",
+          description: "Get a config value by key (dot-path notation)"
+        },
+        args: {
+          key: {
+            type: "positional",
+            description: "Config key (e.g. mcpServerMode.maxDepth)",
+            required: true
+          }
+        },
+        async run({ args }) {
+          const key = String(args.key);
+          const value = await configManager2.get(key);
+          if (value === void 0) {
+            logger.info(`Key "${key}" is not set`);
+          } else {
+            const output = typeof value === "object" ? JSON.stringify(value, null, 2) : String(value);
+            console.log(output);
+          }
+        }
+      }),
+      set: defineCommand3({
+        meta: {
+          name: "set",
+          description: "Set a config value (default: global scope)"
+        },
+        args: {
+          project: {
+            type: "boolean",
+            description: "Write to project scope instead of global"
+          },
+          key: {
+            type: "positional",
+            description: "Config key (e.g. defaultBackend)",
+            required: true
+          },
+          value: {
+            type: "positional",
+            description: "Config value",
+            required: true
+          }
+        },
+        async run({ args }) {
+          const scope = args.project ? "project" : "global";
+          const key = String(args.key);
+          const rawValue = String(args.value);
+          const parsed = parseValue(rawValue);
+          await configManager2.set(scope, key, parsed);
+          logger.success(`Set ${key} = ${JSON.stringify(parsed)} (${scope})`);
+        }
+      })
+    },
+    async run() {
+      const config = await configManager2.getConfig();
+      console.log(JSON.stringify(config, null, 2));
+    }
+  });
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  const num = Number(raw);
+  if (!Number.isNaN(num) && raw.trim() !== "") return num;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object") return parsed;
+  } catch {
   }
-  _httpServer;
-};
+  return raw;
+}
 
 // src/commands/mcp.ts
+init_server();
+init_logger();
+import { defineCommand as defineCommand4 } from "citty";
 function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngine2, contextMonitor2) {
   return defineCommand4({
     meta: {
@@ -2424,6 +3215,7 @@ function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngin
 }
 
 // src/commands/auth.ts
+init_logger();
 import { defineCommand as defineCommand5 } from "citty";
 function createBackendAuthCommand(backendId, authManager2) {
   return defineCommand5({
@@ -2478,6 +3270,7 @@ function createAuthCommand(authManager2) {
 }
 
 // src/commands/sessions.ts
+init_logger();
 import { defineCommand as defineCommand6 } from "citty";
 function formatDate(date) {
   const y = date.getFullYear();
@@ -2593,9 +3386,12 @@ function createVersionCommand(registry2) {
 
 // src/commands/doctor.ts
 import { defineCommand as defineCommand8 } from "citty";
-import { access, constants } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { access, constants, readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 async function checkNodeVersion() {
   const version = process.version;
   const major = Number(version.slice(1).split(".")[0]);
@@ -2652,8 +3448,8 @@ async function checkConfig(configManager2) {
   }
 }
 async function checkSessionsDir() {
-  const relayHome2 = process.env["RELAY_HOME"] ?? join3(homedir2(), ".relay");
-  const sessionsDir = join3(relayHome2, "sessions");
+  const relayHome2 = process.env["RELAY_HOME"] ?? join6(homedir5(), ".relay");
+  const sessionsDir = join6(relayHome2, "sessions");
   try {
     await access(sessionsDir, constants.W_OK);
     return {
@@ -2687,6 +3483,107 @@ async function checkMCPSDK() {
     };
   }
 }
+async function checkMCPServerCommands(configManager2) {
+  const results = [];
+  try {
+    const config = await configManager2.getConfig();
+    const mcpServers = config.mcpServers ?? {};
+    for (const [name, server] of Object.entries(mcpServers)) {
+      const command = server.command;
+      try {
+        await execFileAsync("which", [command]);
+        results.push({
+          label: `MCP server: ${name}`,
+          ok: true,
+          detail: `MCP server "${name}": command "${command}" found`
+        });
+      } catch {
+        results.push({
+          label: `MCP server: ${name}`,
+          ok: true,
+          detail: `MCP server "${name}": command "${command}" not found in PATH`,
+          hint: `Ensure "${command}" is installed and available in your PATH`
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+async function checkMCPServerInstantiation() {
+  try {
+    const { RelayMCPServer: RelayMCPServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    if (typeof RelayMCPServer2 !== "function") {
+      return {
+        label: "MCP server",
+        ok: false,
+        detail: "MCP server module is not a constructor",
+        hint: "Reinstall dependencies: pnpm install"
+      };
+    }
+    return {
+      label: "MCP server",
+      ok: true,
+      detail: "MCP server module loadable"
+    };
+  } catch (error) {
+    return {
+      label: "MCP server",
+      ok: false,
+      detail: `MCP server module not loadable: ${error instanceof Error ? error.message : String(error)}`,
+      hint: "Reinstall dependencies: pnpm install"
+    };
+  }
+}
+async function checkBackendAuthEnv() {
+  const envVars = {
+    claude: "ANTHROPIC_API_KEY",
+    codex: "OPENAI_API_KEY",
+    gemini: "GEMINI_API_KEY"
+  };
+  const results = [];
+  for (const [backend, envVar] of Object.entries(envVars)) {
+    const value = process.env[envVar];
+    if (value) {
+      results.push({
+        label: `Auth: ${backend}`,
+        ok: true,
+        detail: `${envVar} is set`
+      });
+    } else {
+      results.push({
+        label: `Auth: ${backend}`,
+        ok: true,
+        detail: `${envVar} not set`,
+        hint: "API key not set; may use subscription auth"
+      });
+    }
+  }
+  return results;
+}
+async function checkSessionsDiskUsage() {
+  const relayHome2 = process.env["RELAY_HOME"] ?? join6(homedir5(), ".relay");
+  const sessionsDir = join6(relayHome2, "sessions");
+  try {
+    const entries = await readdir2(sessionsDir);
+    const fileCount = entries.length;
+    if (fileCount >= 100) {
+      return {
+        label: "Sessions disk usage",
+        ok: true,
+        detail: `${fileCount} session files in ${sessionsDir}`,
+        hint: "Consider cleaning up old sessions: relay sessions list --limit 10"
+      };
+    }
+    return {
+      label: "Sessions disk usage",
+      ok: true,
+      detail: `${fileCount} session files in ${sessionsDir}`
+    };
+  } catch {
+    return null;
+  }
+}
 function createDoctorCommand(registry2, configManager2) {
   return defineCommand8({
     meta: {
@@ -2704,15 +3601,24 @@ function createDoctorCommand(registry2, configManager2) {
       checks.push(await checkConfig(configManager2));
       checks.push(await checkSessionsDir());
       checks.push(await checkMCPSDK());
+      const mcpCommandChecks = await checkMCPServerCommands(configManager2);
+      checks.push(...mcpCommandChecks);
+      checks.push(await checkMCPServerInstantiation());
+      const authChecks = await checkBackendAuthEnv();
+      checks.push(...authChecks);
+      const diskCheck = await checkSessionsDiskUsage();
+      if (diskCheck) {
+        checks.push(diskCheck);
+      }
       let hasFailures = false;
       for (const check of checks) {
         const icon = check.ok ? "\u2713" : "\u2717";
         console.log(`  ${icon} ${check.detail}`);
         if (!check.ok) {
           hasFailures = true;
-          if (check.hint) {
-            console.log(`    ${check.hint}`);
-          }
+        }
+        if (check.hint) {
+          console.log(`    ${check.hint}`);
         }
       }
       if (hasFailures) {
@@ -2728,9 +3634,10 @@ function createDoctorCommand(registry2, configManager2) {
 }
 
 // src/commands/init.ts
+init_logger();
 import { defineCommand as defineCommand9 } from "citty";
-import { mkdir as mkdir3, writeFile as writeFile3, access as access2, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile6, access as access2, readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
 var DEFAULT_CONFIG2 = {
   defaultBackend: "claude",
   backends: {},
@@ -2744,8 +3651,8 @@ function createInitCommand() {
     },
     async run() {
       const projectDir = process.cwd();
-      const relayDir = join4(projectDir, ".relay");
-      const configPath = join4(relayDir, "config.json");
+      const relayDir = join7(projectDir, ".relay");
+      const configPath = join7(relayDir, "config.json");
       try {
         await access2(relayDir);
         logger.info(
@@ -2754,16 +3661,16 @@ function createInitCommand() {
         return;
       } catch {
       }
-      await mkdir3(relayDir, { recursive: true });
-      await writeFile3(
+      await mkdir6(relayDir, { recursive: true });
+      await writeFile6(
         configPath,
         JSON.stringify(DEFAULT_CONFIG2, null, 2) + "\n",
         "utf-8"
       );
       logger.success(`Created ${configPath}`);
-      const gitignorePath = join4(projectDir, ".gitignore");
+      const gitignorePath = join7(projectDir, ".gitignore");
       try {
-        const gitignoreContent = await readFile3(gitignorePath, "utf-8");
+        const gitignoreContent = await readFile6(gitignorePath, "utf-8");
         if (!gitignoreContent.includes(".relay/config.local.json")) {
           logger.info(
             'Tip: Add ".relay/config.local.json" to your .gitignore to keep local config out of version control.'
@@ -2782,12 +3689,12 @@ function createInitCommand() {
 // src/bin/relay.ts
 var processManager = new ProcessManager();
 var registry = new AdapterRegistry();
-registry.register(new ClaudeAdapter(processManager));
-registry.register(new CodexAdapter(processManager));
-registry.register(new GeminiAdapter(processManager));
+registry.registerLazy("claude", () => new ClaudeAdapter(processManager));
+registry.registerLazy("codex", () => new CodexAdapter(processManager));
+registry.registerLazy("gemini", () => new GeminiAdapter(processManager));
 var sessionManager = new SessionManager();
-var relayHome = process.env["RELAY_HOME"] ?? join5(homedir3(), ".relay");
-var projectRelayDir = join5(process.cwd(), ".relay");
+var relayHome = process.env["RELAY_HOME"] ?? join8(homedir6(), ".relay");
+var projectRelayDir = join8(process.cwd(), ".relay");
 var configManager = new ConfigManager(relayHome, projectRelayDir);
 var authManager = new AuthManager(registry);
 var eventBus = new EventBus();