@rk0429/agentic-relay 0.2.0 → 0.4.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,129 +18,671 @@ 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 installed`
     };
-    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 {
+    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
       }
-    };
-    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(", ")}`
+    });
+    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
       );
     }
-    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
+    };
+  } 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(),
+      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 {
-      const result = await this.processManager.execute("which", [this.command]);
-      return result.exitCode === 0;
+// 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,
+        usagePercent: usage.usagePercent,
+        isEstimated: usage.isEstimated
+      };
+    }
+  }
+  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/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_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.",
+          {
+            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}
+
+${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
+              };
+            }
+          }
+        );
+      }
+      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 {
       return false;
     }
@@ -250,10 +781,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 +796,9 @@ var CLAUDE_NESTING_ENV_VARS = [
 var ClaudeAdapter = class extends BaseAdapter {
   id = "claude";
   command = "claude";
+  getConfigPath() {
+    return join(homedir(), ".claude.json");
+  }
   mapFlags(flags) {
     return {
       args: mapCommonToNative("claude", flags)
@@ -273,22 +810,30 @@ var ClaudeAdapter = class extends BaseAdapter {
       env: this.buildCleanEnv(flags)
     });
   }
+  getPermissionMode() {
+    return process.env["RELAY_CLAUDE_PERMISSION_MODE"] === "default" ? "default" : "bypassPermissions";
+  }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
     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 } : {}
+      };
+      if (permissionMode === "bypassPermissions") {
+        options.permissionMode = "bypassPermissions";
+        options.allowDangerouslySkipPermissions = true;
+      }
       const q = query({
         prompt: flags.prompt,
-        options: {
-          env,
-          cwd: process.cwd(),
-          ...flags.model ? { model: flags.model } : {},
-          ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
-          permissionMode: "bypassPermissions",
-          allowDangerouslySkipPermissions: true
-        }
+        options
       });
       let resultText = "";
       let sessionId = "";
@@ -309,7 +854,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 {
@@ -319,6 +865,83 @@ var ClaudeAdapter = class extends BaseAdapter {
       };
     }
   }
+  async *executeStreaming(flags) {
+    if (!flags.prompt) {
+      throw new Error("executeStreaming requires a prompt (-p flag)");
+    }
+    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 } : {}
+      };
+      if (permissionMode === "bypassPermissions") {
+        options.permissionMode = "bypassPermissions";
+        options.allowDangerouslySkipPermissions = true;
+      }
+      const q = query({
+        prompt: flags.prompt,
+        options
+      });
+      for await (const message of q) {
+        if (message.type === "assistant") {
+          const betaMessage = message.message;
+          if (betaMessage?.content) {
+            for (const block of betaMessage.content) {
+              if (block.type === "text" && block.text) {
+                yield { type: "text", text: block.text };
+              }
+            }
+          }
+          if (betaMessage?.usage) {
+            yield {
+              type: "usage",
+              inputTokens: betaMessage.usage.input_tokens ?? 0,
+              outputTokens: betaMessage.usage.output_tokens ?? 0
+            };
+          }
+        } else if (message.type === "tool_progress") {
+          const toolName = message.tool_name ?? "unknown";
+          yield {
+            type: "status",
+            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: "" },
+              nativeSessionId
+            };
+          } else {
+            const errors = message.errors;
+            yield {
+              type: "done",
+              result: {
+                exitCode: 1,
+                stdout: "",
+                stderr: errors.join("\n")
+              },
+              nativeSessionId
+            };
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      yield { type: "error", message: errorMessage };
+      yield {
+        type: "done",
+        result: { exitCode: 1, stdout: "", stderr: errorMessage }
+      };
+    }
+  }
   async resumeSession(sessionId, flags) {
     await this.processManager.spawnInteractive(
       this.command,
@@ -342,6 +965,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,
@@ -367,13 +991,172 @@ var ClaudeAdapter = class extends BaseAdapter {
       logger.success(`Claude CLI updated: ${result.stdout.trim()}`);
     }
   }
-};
-
-// src/adapters/codex-adapter.ts
-import { Codex } from "@openai/codex-sdk";
+  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
+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");
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("codex", flags);
     if (flags.outputFormat === "json") {
@@ -401,6 +1184,7 @@ var CodexAdapter = class extends BaseAdapter {
       );
     }
     try {
+      const { Codex } = await loadCodexSDK();
       const codexOptions = {};
       if (flags.mcpContext) {
         codexOptions.env = {
@@ -430,6 +1214,107 @@ var CodexAdapter = class extends BaseAdapter {
       };
     }
   }
+  async *executeStreaming(flags) {
+    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}".`
+      );
+    }
+    try {
+      const { Codex } = await loadCodexSDK();
+      const codexOptions = {};
+      if (flags.mcpContext) {
+        codexOptions.env = {
+          ...process.env,
+          RELAY_TRACE_ID: flags.mcpContext.traceId,
+          RELAY_PARENT_SESSION_ID: flags.mcpContext.parentSessionId,
+          RELAY_DEPTH: String(flags.mcpContext.depth)
+        };
+      }
+      const codex = new Codex(codexOptions);
+      const thread = codex.startThread({
+        ...flags.model ? { model: flags.model } : {},
+        workingDirectory: process.cwd(),
+        approvalPolicy: "never"
+      });
+      const streamedTurn = await thread.runStreamed(flags.prompt);
+      const completedMessages = [];
+      for await (const event of streamedTurn.events) {
+        if (event.type === "item.started") {
+          const item = event.item;
+          if (item?.type === "agent_message" && item.text) {
+            yield { type: "text", text: item.text };
+          } else if (item?.type === "command_execution") {
+            yield {
+              type: "tool_start",
+              tool: item.command ?? "command",
+              id: item.id ?? ""
+            };
+          } else if (item?.type === "file_change") {
+            yield {
+              type: "tool_start",
+              tool: "file_change",
+              id: item.id ?? ""
+            };
+          }
+        } else if (event.type === "item.completed") {
+          const item = event.item;
+          if (item?.type === "agent_message" && item.text) {
+            completedMessages.push(item.text);
+            yield { type: "text", text: item.text };
+          } else if (item?.type === "command_execution") {
+            yield {
+              type: "tool_end",
+              tool: item.command ?? "command",
+              id: item.id ?? "",
+              result: item.aggregated_output
+            };
+          } else if (item?.type === "file_change") {
+            yield {
+              type: "tool_end",
+              tool: "file_change",
+              id: item.id ?? ""
+            };
+          }
+        } else if (event.type === "turn.completed") {
+          const usage = event.usage;
+          if (usage) {
+            yield {
+              type: "usage",
+              inputTokens: (usage.input_tokens ?? 0) + (usage.cached_input_tokens ?? 0),
+              outputTokens: usage.output_tokens ?? 0
+            };
+          }
+          const finalResponse = completedMessages.join("\n");
+          yield {
+            type: "done",
+            result: { exitCode: 0, stdout: finalResponse, stderr: "" }
+          };
+        } else if (event.type === "turn.failed") {
+          const errorMessage = event.error?.message ?? "Turn failed";
+          yield {
+            type: "done",
+            result: { exitCode: 1, stdout: "", stderr: errorMessage }
+          };
+        } else if (event.type === "error") {
+          yield {
+            type: "error",
+            message: event.message ?? "Unknown error"
+          };
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      yield { type: "error", message: errorMessage };
+      yield {
+        type: "done",
+        result: { exitCode: 1, stdout: "", stderr: errorMessage }
+      };
+    }
+  }
   async resumeSession(sessionId, flags) {
     const args = [];
     if (flags.model) {
@@ -467,12 +1352,62 @@ 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");
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("gemini", flags);
     if (flags.outputFormat) {
@@ -576,18 +1511,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 } 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 {
@@ -603,17 +1584,21 @@ function fromSessionData(data) {
     updatedAt: new Date(data.updatedAt)
   };
 }
-var SessionManager = class {
+var SessionManager = class _SessionManager {
+  static SESSION_ID_PATTERN = /^relay-[A-Za-z0-9_-]+$/;
   sessionsDir;
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir ?? getSessionsDir(getRelayHome());
   }
   /** Ensure the sessions directory exists. */
   async ensureDir() {
-    await mkdir(this.sessionsDir, { recursive: true });
+    await mkdir4(this.sessionsDir, { recursive: true });
   }
   sessionPath(relaySessionId) {
-    return join(this.sessionsDir, `${relaySessionId}.json`);
+    if (!_SessionManager.SESSION_ID_PATTERN.test(relaySessionId)) {
+      throw new Error(`Invalid session ID: ${relaySessionId}`);
+    }
+    return join4(this.sessionsDir, `${relaySessionId}.json`);
   }
   /** Create a new relay session. */
   async create(params) {
@@ -629,11 +1614,13 @@ var SessionManager = class {
       updatedAt: now,
       status: "active"
     };
-    await writeFile(
-      this.sessionPath(session.relaySessionId),
+    const sessionFilePath = this.sessionPath(session.relaySessionId);
+    await writeFile4(
+      sessionFilePath,
       JSON.stringify(toSessionData(session), null, 2),
       "utf-8"
     );
+    await chmod(sessionFilePath, 384);
     return session;
   }
   /** Update an existing session. */
@@ -647,16 +1634,19 @@ var SessionManager = class {
       ...updates,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    await writeFile(
-      this.sessionPath(relaySessionId),
+    const updateFilePath = this.sessionPath(relaySessionId);
+    await writeFile4(
+      updateFilePath,
       JSON.stringify(toSessionData(updated), null, 2),
       "utf-8"
     );
+    await chmod(updateFilePath, 384);
   }
   /** Get a session by relay session ID. */
   async get(relaySessionId) {
+    const filePath = this.sessionPath(relaySessionId);
     try {
-      const raw = await readFile(this.sessionPath(relaySessionId), "utf-8");
+      const raw = await readFile4(filePath, "utf-8");
       return fromSessionData(JSON.parse(raw));
     } catch {
       return null;
@@ -680,7 +1670,7 @@ var SessionManager = class {
     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;
@@ -700,14 +1690,14 @@ var SessionManager = class {
 };
 
 // src/core/config-manager.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } 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()
@@ -752,10 +1742,12 @@ var relayConfigSchema = z.object({
   }).optional(),
   telemetry: z.object({
     enabled: z.boolean()
-  }).optional()
+  }).optional(),
+  claudePermissionMode: z.enum(["default", "bypassPermissions"]).optional()
 });
 
 // src/core/config-manager.ts
+init_logger();
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -843,8 +1835,9 @@ 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);
   }
   /**
    * Syncs MCP server config to all registered backend adapters.
@@ -852,7 +1845,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 {
@@ -869,11 +1867,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) {
@@ -890,7 +1888,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;
@@ -919,6 +1917,7 @@ var ConfigManager = class {
 };
 
 // src/core/auth-manager.ts
+init_logger();
 var AuthManager = class {
   constructor(registry2) {
     this.registry = registry2;
@@ -992,24 +1991,61 @@ var EventBus = class {
 };
 
 // src/core/hooks-engine.ts
+init_logger();
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_HOOK_OUTPUT = {
   allow: true,
   message: "",
   metadata: {}
 };
-var HooksEngine = class {
+var HooksEngine = class _HooksEngine {
   constructor(eventBus2, processManager2) {
     this.eventBus = eventBus2;
     this.processManager = processManager2;
   }
+  static COMMAND_PATTERN = /^[a-zA-Z0-9_./-]+$/;
+  static ARG_PATTERN = /^[a-zA-Z0-9_.=:/-]+$/;
   definitions = [];
   registered = false;
+  validateCommand(command) {
+    if (!command || command.trim().length === 0) {
+      throw new Error("Hook command cannot be empty");
+    }
+    if (!_HooksEngine.COMMAND_PATTERN.test(command)) {
+      throw new Error(
+        `Hook command contains invalid characters: "${command}". Only alphanumeric characters, dots, underscores, hyphens, and slashes are allowed.`
+      );
+    }
+    if (command.includes("..")) {
+      throw new Error(
+        `Hook command contains path traversal: "${command}"`
+      );
+    }
+  }
+  validateArgs(args) {
+    for (const arg of args) {
+      if (!_HooksEngine.ARG_PATTERN.test(arg)) {
+        throw new Error(
+          `Hook argument contains invalid characters: "${arg}". Only alphanumeric characters, dots, underscores, equals, colons, hyphens, and slashes are allowed.`
+        );
+      }
+    }
+  }
   /** Load hook definitions from config and register listeners on EventBus */
   loadConfig(config) {
-    this.definitions = config.definitions.filter(
-      (def) => def.enabled !== false
-    );
+    this.definitions = config.definitions.filter((def) => {
+      if (def.enabled === false) return false;
+      try {
+        this.validateCommand(def.command);
+        this.validateArgs(def.args ?? []);
+        return true;
+      } catch (error) {
+        logger.warn(
+          `Skipping hook with invalid command: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    });
     if (!this.registered) {
       for (const event of this.getUniqueEvents()) {
         this.eventBus.on(event, async () => {
@@ -1056,6 +2092,8 @@ var HooksEngine = class {
     return this.definitions.filter((def) => def.event === event).length;
   }
   async executeHook(def, input) {
+    this.validateCommand(def.command);
+    this.validateArgs(def.args ?? []);
     const timeoutMs = def.timeout ?? DEFAULT_TIMEOUT_MS;
     const stdinData = JSON.stringify(input);
     const startTime = Date.now();
@@ -1157,6 +2195,7 @@ var ContextMonitor = class {
 };
 
 // src/commands/backend.ts
+init_logger();
 import { defineCommand } from "citty";
 
 // src/adapters/install-guides.ts
@@ -1167,7 +2206,7 @@ var INSTALL_GUIDES = {
 };
 
 // src/commands/backend.ts
-function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine2) {
+function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine2, contextMonitor2) {
   return defineCommand({
     meta: {
       name: backendId,
@@ -1208,6 +2247,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 }) {
@@ -1231,6 +2275,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 {
@@ -1262,10 +2323,73 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
       try {
         if (flags.prompt) {
           logger.debug(`Executing prompt on ${backendId}`);
-          const result = await adapter.execute(flags);
-          if (result.stdout) process.stdout.write(result.stdout);
-          if (result.stderr) process.stderr.write(result.stderr);
-          process.exitCode = result.exitCode;
+          if (adapter.executeStreaming) {
+            for await (const event of adapter.executeStreaming(flags)) {
+              switch (event.type) {
+                case "text":
+                  process.stdout.write(event.text);
+                  break;
+                case "tool_start":
+                  if (flags.verbose) {
+                    process.stderr.write(`
+[${event.tool}] started
+`);
+                  }
+                  break;
+                case "tool_end":
+                  if (flags.verbose) {
+                    process.stderr.write(`[${event.tool}] completed
+`);
+                  }
+                  break;
+                case "status":
+                  if (flags.verbose) {
+                    process.stderr.write(`[status] ${event.message}
+`);
+                  }
+                  break;
+                case "error":
+                  process.stderr.write(event.message);
+                  break;
+                case "usage": {
+                  if (contextMonitor2 && relaySessionId) {
+                    const maxTokens = backendId === "gemini" ? 128e3 : 2e5;
+                    contextMonitor2.updateUsage(
+                      relaySessionId,
+                      backendId,
+                      event.inputTokens + event.outputTokens,
+                      maxTokens
+                    );
+                  }
+                  break;
+                }
+                case "done":
+                  process.exitCode = event.result.exitCode;
+                  if (event.nativeSessionId && sessionManager2 && relaySessionId) {
+                    try {
+                      await sessionManager2.update(relaySessionId, {
+                        nativeSessionId: event.nativeSessionId
+                      });
+                    } catch {
+                    }
+                  }
+                  break;
+              }
+            }
+          } else {
+            const result = await adapter.execute(flags);
+            if (result.stdout) process.stdout.write(result.stdout);
+            if (result.stderr) process.stderr.write(result.stderr);
+            process.exitCode = result.exitCode;
+            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}`);
           if (sessionManager2) {
@@ -1332,502 +2456,193 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
               data: {
                 error: error instanceof Error ? error.message : String(error)
               }
-            };
-            await hooksEngine2.emit("on-error", hookInput);
-          } catch {
-          }
-        }
-        throw error;
-      }
-    }
-  });
-}
-
-// src/commands/update.ts
-import { defineCommand as defineCommand2 } from "citty";
-function createUpdateCommand(registry2) {
-  return defineCommand2({
-    meta: {
-      name: "update",
-      description: "Update all installed backend CLI tools"
-    },
-    async run() {
-      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 { z as z5 } from "zod";
-
-// src/mcp-server/recursion-guard.ts
-import { createHash } from "crypto";
-var RecursionGuard = class {
-  constructor(config = {
-    maxDepth: 5,
-    maxCallsPerSession: 20,
-    timeoutSec: 300
-  }) {
-    this.config = config;
-  }
-  callCounts = /* @__PURE__ */ new Map();
-  promptHashes = /* @__PURE__ */ new Map();
-  /** Check if a spawn is allowed */
-  canSpawn(context) {
-    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) ?? 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) {
-    const currentCount = this.callCounts.get(context.traceId) ?? 0;
-    this.callCounts.set(context.traceId, currentCount + 1);
-    const key = `${context.backend}:${context.promptHash}`;
-    const existing = this.promptHashes.get(context.traceId) ?? [];
-    existing.push(key);
-    this.promptHashes.set(context.traceId, existing);
-  }
-  /** 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) ?? [];
-    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) ?? 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) {
-  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
-      }
-    });
-    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
+            };
+            await hooksEngine2.emit("on-error", hookInput);
+          } catch {
+          }
+        }
+        throw error;
+      }
+    }
   });
-  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
-      };
+// src/commands/update.ts
+init_logger();
+import { defineCommand as defineCommand2 } from "citty";
+
+// 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)
+      }
+    );
+    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;
   }
-  return {
-    sessionId: input.sessionId,
-    usagePercent: 0,
-    isEstimated: true
-  };
+}
+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/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.1.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
+// 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})`
           );
-          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
-          };
+          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(
-      "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
-          };
-        }
+      const adapters = registry2.list();
+      if (adapters.length === 0) {
+        logger.warn("No backends registered");
+        return;
       }
-    );
-    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) => {
+      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() {
-    logger.info("Starting agentic-relay MCP server (stdio transport)...");
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
+    }
+  });
+}
+
+// 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 {
   }
-};
+  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: {
@@ -1948,9 +2763,21 @@ function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngin
       serve: defineCommand4({
         meta: {
           name: "serve",
-          description: "Start relay as an MCP server (stdio transport)"
+          description: "Start relay as an MCP server"
         },
-        async run() {
+        args: {
+          transport: {
+            type: "string",
+            description: "Transport type: stdio or http (default: stdio)",
+            default: "stdio"
+          },
+          port: {
+            type: "string",
+            description: "Port for HTTP transport (default: 3100)",
+            default: "3100"
+          }
+        },
+        async run({ args }) {
           if (!sessionManager2) {
             logger.error("SessionManager is required for MCP server mode");
             process.exitCode = 1;
@@ -1968,6 +2795,8 @@ function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngin
             }
           } catch {
           }
+          const transport = args.transport === "http" ? "http" : "stdio";
+          const port = parseInt(String(args.port), 10) || 3100;
           const server = new RelayMCPServer(
             registry2,
             sessionManager2,
@@ -1975,7 +2804,7 @@ function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngin
             hooksEngine2,
             contextMonitor2
           );
-          await server.start();
+          await server.start({ transport, port });
         }
       })
     },
@@ -1988,6 +2817,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({
@@ -2042,6 +2872,7 @@ function createAuthCommand(authManager2) {
 }
 
 // src/commands/sessions.ts
+init_logger();
 import { defineCommand as defineCommand6 } from "citty";
 function formatDate(date) {
   const y = date.getFullYear();
@@ -2157,9 +2988,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]);
@@ -2216,8 +3050,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 {
@@ -2251,6 +3085,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: {
@@ -2268,15 +3203,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) {
@@ -2292,9 +3236,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: {},
@@ -2308,8 +3253,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(
@@ -2318,16 +3263,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.'
@@ -2346,25 +3291,23 @@ 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();
 var hooksEngine = new HooksEngine(eventBus, processManager);
-var contextMonitor = new ContextMonitor(hooksEngine, {
-  enabled: false
-  // Will be enabled from config at runtime
-});
+var contextMonitor = new ContextMonitor(hooksEngine);
 void configManager.getConfig().then((config) => {
   if (config.hooks) {
     hooksEngine.loadConfig(config.hooks);
   }
   if (config.contextMonitor) {
+    contextMonitor = new ContextMonitor(hooksEngine, config.contextMonitor);
   }
 }).catch(() => {
 });
@@ -2375,9 +3318,9 @@ var main = defineCommand10({
     description: "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI"
   },
   subCommands: {
-    claude: createBackendCommand("claude", registry, sessionManager, hooksEngine),
-    codex: createBackendCommand("codex", registry, sessionManager, hooksEngine),
-    gemini: createBackendCommand("gemini", registry, sessionManager, hooksEngine),
+    claude: createBackendCommand("claude", registry, sessionManager, hooksEngine, contextMonitor),
+    codex: createBackendCommand("codex", registry, sessionManager, hooksEngine, contextMonitor),
+    gemini: createBackendCommand("gemini", registry, sessionManager, hooksEngine, contextMonitor),
     update: createUpdateCommand(registry),
     config: createConfigCommand(configManager),
     mcp: createMCPCommand(configManager, registry, sessionManager, hooksEngine, contextMonitor),