@rk0429/agentic-relay 0.4.0 → 0.6.0

package/dist/relay.mjs

@@ -158,19 +158,117 @@ var init_recursion_guard = __esm({
 // src/mcp-server/tools/spawn-agent.ts
 import { z as z2 } from "zod";
 import { nanoid as nanoid2 } from "nanoid";
+import { existsSync, readFileSync } from "fs";
+import { join as join6 } from "path";
+function buildContextInjection(metadata) {
+  const parts = [];
+  if (metadata.stateContent && typeof metadata.stateContent === "string") {
+    parts.push(`<context-injection type="state">
+${metadata.stateContent}
+</context-injection>`);
+  }
+  if (Array.isArray(metadata.results) && metadata.results.length > 0) {
+    const formatted = metadata.results.map((r, i) => `[${i + 1}] ${r.title} (${r.date}, score: ${r.score})
+${r.snippet}`).join("\n\n");
+    parts.push(`<context-injection type="search-results">
+${formatted}
+</context-injection>`);
+  }
+  return parts.join("\n\n");
+}
+function readPreviousState(dailynoteDir) {
+  try {
+    const statePath = join6(dailynoteDir, "_state.md");
+    if (existsSync(statePath)) {
+      return readFileSync(statePath, "utf-8");
+    }
+    return null;
+  } catch (error) {
+    logger.warn(
+      `Failed to read _state.md: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function readAgentDefinition(definitionPath) {
+  try {
+    if (!existsSync(definitionPath)) {
+      logger.warn(`Agent definition file not found at ${definitionPath}`);
+      return null;
+    }
+    const content = readFileSync(definitionPath, "utf-8");
+    if (content.trim().length === 0) {
+      logger.warn(`Agent definition file is empty at ${definitionPath}`);
+      return null;
+    }
+    return content;
+  } catch (error) {
+    logger.warn(
+      `Failed to read agent definition: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function readSkillContext(skillContext) {
+  try {
+    const skillMdPath = join6(skillContext.skillPath, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+      logger.warn(
+        `SKILL.md not found at ${skillMdPath}`
+      );
+      return null;
+    }
+    const parts = [];
+    const skillContent = readFileSync(skillMdPath, "utf-8");
+    parts.push(skillContent);
+    if (skillContext.subskill) {
+      const subskillPath = join6(
+        skillContext.skillPath,
+        "subskills",
+        skillContext.subskill,
+        "SUBSKILL.md"
+      );
+      if (existsSync(subskillPath)) {
+        const subskillContent = readFileSync(subskillPath, "utf-8");
+        parts.push(subskillContent);
+      } else {
+        logger.warn(
+          `SUBSKILL.md not found at ${subskillPath}`
+        );
+      }
+    }
+    return parts.join("\n\n");
+  } catch (error) {
+    logger.warn(
+      `Failed to read skill context: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
 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) {
+async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2, contextMonitor2, backendSelector) {
+  let effectiveBackend = input.backend;
+  if (backendSelector) {
+    const availableBackends = registry2.listIds();
+    const selectionContext = {
+      availableBackends,
+      preferredBackend: input.preferredBackend,
+      agentType: input.agent,
+      taskType: input.taskType
+    };
+    effectiveBackend = backendSelector.selectBackend(selectionContext);
+  }
   const envContext = buildContextFromEnv();
   const promptHash = RecursionGuard.hashPrompt(input.prompt);
   const context = {
     traceId: envContext.traceId,
     depth: envContext.depth,
-    backend: input.backend,
+    backend: effectiveBackend,
     promptHash
   };
   const guardResult = guard.canSpawn(context);
@@ -183,27 +281,54 @@ async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooks
       stderr: `Spawn blocked: ${guardResult.reason}`
     };
   }
-  const adapter = registry2.get(input.backend);
+  const adapter = registry2.get(effectiveBackend);
   const installed = await adapter.isInstalled();
   if (!installed) {
     return {
       sessionId: "",
       exitCode: 1,
       stdout: "",
-      stderr: `Backend "${input.backend}" is not installed`
+      stderr: `Backend "${effectiveBackend}" is not available. Use list_available_backends to see available options.`
     };
   }
+  const spawnStartedAt = (/* @__PURE__ */ new Date()).toISOString();
   const session = await sessionManager2.create({
-    backendId: input.backend,
+    backendId: effectiveBackend,
     parentSessionId: envContext.parentSessionId ?? void 0,
     depth: envContext.depth + 1
   });
+  let collectedMetadata = {};
+  if (hooksEngine2 && !input.resumeSessionId) {
+    try {
+      const cwd = process.cwd();
+      const dailynoteDir = join6(cwd, "daily_note");
+      const hookInput = {
+        schemaVersion: "1.0",
+        event: "session-init",
+        sessionId: session.relaySessionId,
+        backendId: effectiveBackend,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          workingDirectory: cwd,
+          dailynoteDir,
+          isFirstSession: !existsSync(join6(dailynoteDir, "_state.md")),
+          previousState: readPreviousState(dailynoteDir)
+        }
+      };
+      const { mergedMetadata } = await hooksEngine2.emitAndCollectMetadata("session-init", hookInput);
+      collectedMetadata = { ...collectedMetadata, ...mergedMetadata };
+    } catch (error) {
+      logger.warn(
+        `session-init hook error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   if (hooksEngine2) {
     try {
       const hookInput = {
         event: "pre-spawn",
         sessionId: session.relaySessionId,
-        backendId: input.backend,
+        backendId: effectiveBackend,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data: {
           prompt: input.prompt,
@@ -211,37 +336,75 @@ async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooks
           model: input.model
         }
       };
-      await hooksEngine2.emit("pre-spawn", hookInput);
+      const { mergedMetadata } = await hooksEngine2.emitAndCollectMetadata("pre-spawn", hookInput);
+      collectedMetadata = { ...collectedMetadata, ...mergedMetadata };
     } catch (error) {
       logger.debug(
         `pre-spawn hook error: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
+  const injectionText = buildContextInjection(collectedMetadata);
+  let enhancedSystemPrompt = injectionText ? input.systemPrompt ? `${input.systemPrompt}
+
+${injectionText}` : injectionText : input.systemPrompt;
+  if (input.skillContext) {
+    const skillText = readSkillContext(input.skillContext);
+    if (skillText) {
+      const wrapped = `<skill-context path="${input.skillContext.skillPath}"${input.skillContext.subskill ? ` subskill="${input.skillContext.subskill}"` : ""}>
+${skillText}
+</skill-context>`;
+      enhancedSystemPrompt = enhancedSystemPrompt ? `${enhancedSystemPrompt}
+
+${wrapped}` : wrapped;
+    }
+  }
+  if (input.agentDefinition) {
+    const defText = readAgentDefinition(input.agentDefinition.definitionPath);
+    if (defText) {
+      const wrapped = `<agent-definition source="${input.agentDefinition.definitionPath}">
+${defText}
+</agent-definition>`;
+      enhancedSystemPrompt = enhancedSystemPrompt ? `${enhancedSystemPrompt}
+
+${wrapped}` : wrapped;
+    }
+  }
   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
+    let result;
+    if (input.resumeSessionId) {
+      if (!adapter.continueSession) {
+        return {
+          sessionId: session.relaySessionId,
+          exitCode: 1,
+          stdout: "",
+          stderr: `Backend "${effectiveBackend}" does not support session continuation (continueSession).`
+        };
       }
-    });
+      result = await adapter.continueSession(input.resumeSessionId, input.prompt);
+    } else {
+      result = await adapter.execute({
+        prompt: input.prompt,
+        agent: input.agent,
+        systemPrompt: enhancedSystemPrompt,
+        model: input.model,
+        maxTurns: input.maxTurns,
+        mcpContext: {
+          parentSessionId: session.relaySessionId,
+          depth: envContext.depth + 1,
+          maxDepth: guard.getConfig().maxDepth,
+          traceId: envContext.traceId
+        }
+      });
+    }
     if (contextMonitor2) {
       const estimatedTokens = Math.ceil(
         (result.stdout.length + result.stderr.length) / 4
       );
-      const maxTokens = input.backend === "gemini" ? 128e3 : 2e5;
       contextMonitor2.updateUsage(
         session.relaySessionId,
-        input.backend,
-        estimatedTokens,
-        maxTokens
+        effectiveBackend,
+        estimatedTokens
       );
     }
     guard.recordSpawn(context);
@@ -249,15 +412,27 @@ async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooks
     await sessionManager2.update(session.relaySessionId, { status });
     if (hooksEngine2) {
       try {
+        const postSpawnData = {
+          exitCode: result.exitCode,
+          status,
+          taskDescription: input.prompt,
+          startedAt: spawnStartedAt,
+          backgroundMode: false,
+          sessionId: session.relaySessionId,
+          selectedBackend: effectiveBackend
+        };
+        if (input.agent !== void 0) {
+          postSpawnData.agentType = input.agent;
+        }
+        if (input.model !== void 0) {
+          postSpawnData.model = input.model;
+        }
         const hookInput = {
           event: "post-spawn",
           sessionId: session.relaySessionId,
-          backendId: input.backend,
+          backendId: effectiveBackend,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          data: {
-            exitCode: result.exitCode,
-            status
-          }
+          data: postSpawnData
         };
         await hooksEngine2.emit("post-spawn", hookInput);
       } catch (hookError) {
@@ -270,7 +445,8 @@ async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooks
       sessionId: session.relaySessionId,
       exitCode: result.exitCode,
       stdout: result.stdout,
-      stderr: result.stderr
+      stderr: result.stderr,
+      nativeSessionId: result.nativeSessionId
     };
   } catch (error) {
     await sessionManager2.update(session.relaySessionId, { status: "error" });
@@ -293,9 +469,19 @@ var init_spawn_agent = __esm({
       backend: z2.enum(["claude", "codex", "gemini"]),
       prompt: z2.string(),
       agent: z2.string().optional(),
+      systemPrompt: z2.string().optional(),
       resumeSessionId: z2.string().optional(),
       model: z2.string().optional(),
-      maxTurns: z2.number().optional()
+      maxTurns: z2.number().optional(),
+      skillContext: z2.object({
+        skillPath: z2.string().describe("Path to the skill directory (e.g., '.agents/skills/software-engineer/')"),
+        subskill: z2.string().optional().describe("Specific subskill to activate")
+      }).optional().describe("Skill context to inject into the subagent's system prompt"),
+      agentDefinition: z2.object({
+        definitionPath: z2.string().describe("Path to the agent definition file (e.g., '.claude/agents/software-engineer.md')")
+      }).optional().describe("Agent definition file to inject into the sub-agent's system prompt"),
+      preferredBackend: z2.enum(["claude", "codex", "gemini"]).optional().describe("Preferred backend override. Takes priority over automatic selection based on agent/task type."),
+      taskType: z2.enum(["code", "document", "analysis", "mixed"]).optional().describe("Task type hint for automatic backend selection when preferredBackend is not specified.")
     });
   }
 });
@@ -339,8 +525,14 @@ async function executeGetContextStatus(input, sessionManager2, contextMonitor2)
     if (usage) {
       return {
         sessionId: input.sessionId,
+        backendId: usage.backendId,
         usagePercent: usage.usagePercent,
-        isEstimated: usage.isEstimated
+        isEstimated: usage.isEstimated,
+        contextWindow: usage.contextWindow,
+        compactThreshold: usage.compactThreshold,
+        estimatedTokens: usage.estimatedTokens,
+        remainingBeforeCompact: usage.remainingBeforeCompact,
+        notifyThreshold: usage.notifyThreshold
       };
     }
   }
@@ -360,6 +552,83 @@ var init_get_context_status = __esm({
   }
 });
 
+// src/mcp-server/tools/list-available-backends.ts
+async function executeListAvailableBackends(registry2) {
+  const backends = [];
+  for (const adapter of registry2.list()) {
+    const health = await adapter.checkHealth();
+    backends.push({
+      id: adapter.id,
+      ...health
+    });
+  }
+  return backends;
+}
+var init_list_available_backends = __esm({
+  "src/mcp-server/tools/list-available-backends.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/backend-selector.ts
+var DEFAULT_AGENT_TO_BACKEND_MAP, TASK_TYPE_TO_BACKEND_MAP, DEFAULT_BACKEND, BackendSelector;
+var init_backend_selector = __esm({
+  "src/core/backend-selector.ts"() {
+    "use strict";
+    DEFAULT_AGENT_TO_BACKEND_MAP = {
+      "software-engineer": "codex",
+      "devops-engineer": "codex",
+      "skill-developer": "codex",
+      "security-auditor": "codex",
+      "analytics-engineer": "codex",
+      "payments-billing": "codex"
+    };
+    TASK_TYPE_TO_BACKEND_MAP = {
+      code: "codex",
+      document: "claude",
+      analysis: "claude",
+      mixed: "claude"
+    };
+    DEFAULT_BACKEND = "claude";
+    BackendSelector = class {
+      defaultBackend;
+      agentToBackendMap;
+      constructor(config) {
+        this.defaultBackend = config?.defaultBackend ?? DEFAULT_BACKEND;
+        this.agentToBackendMap = config?.agentToBackendMap ?? DEFAULT_AGENT_TO_BACKEND_MAP;
+      }
+      selectBackend(context) {
+        const { availableBackends, preferredBackend, agentType, taskType } = context;
+        if (availableBackends.length === 0) {
+          throw new Error("No backends available");
+        }
+        if (preferredBackend && availableBackends.includes(preferredBackend)) {
+          return preferredBackend;
+        }
+        if (agentType) {
+          const mapped = this.agentToBackendMap[agentType];
+          if (mapped && availableBackends.includes(mapped)) {
+            return mapped;
+          }
+          if (!mapped && availableBackends.includes("claude")) {
+            return "claude";
+          }
+        }
+        if (taskType) {
+          const mapped = TASK_TYPE_TO_BACKEND_MAP[taskType];
+          if (mapped && availableBackends.includes(mapped)) {
+            return mapped;
+          }
+        }
+        if (availableBackends.includes(this.defaultBackend)) {
+          return this.defaultBackend;
+        }
+        return availableBackends[0];
+      }
+    };
+  }
+});
+
 // src/mcp-server/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -379,6 +648,8 @@ var init_server = __esm({
     init_spawn_agent();
     init_list_sessions();
     init_get_context_status();
+    init_list_available_backends();
+    init_backend_selector();
     init_logger();
     RelayMCPServer = class {
       constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2) {
@@ -387,6 +658,7 @@ var init_server = __esm({
         this.hooksEngine = hooksEngine2;
         this.contextMonitor = contextMonitor2;
         this.guard = new RecursionGuard(guardConfig);
+        this.backendSelector = new BackendSelector();
         this.server = new McpServer({
           name: "agentic-relay",
           version: "0.4.0"
@@ -395,17 +667,30 @@ var init_server = __esm({
       }
       server;
       guard;
+      backendSelector;
       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.",
+          "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result. Use 'agent' for named agent configurations (Claude only), 'systemPrompt' for custom role instructions (all backends), 'skillContext' to inject a skill definition (SKILL.md/SUBSKILL.md), 'agentDefinition' to inject an agent definition file into the sub-agent's system prompt, 'preferredBackend' to override automatic backend selection, or 'taskType' to hint at the task nature for backend selection.",
           {
             backend: z5.enum(["claude", "codex", "gemini"]),
             prompt: z5.string(),
-            agent: z5.string().optional(),
+            agent: z5.string().optional().describe("Named agent configuration (Claude only)"),
+            systemPrompt: z5.string().optional().describe(
+              "System prompt / role instructions for the sub-agent (all backends)"
+            ),
             resumeSessionId: z5.string().optional(),
             model: z5.string().optional(),
-            maxTurns: z5.number().optional()
+            maxTurns: z5.number().optional(),
+            skillContext: z5.object({
+              skillPath: z5.string().describe("Path to the skill directory (e.g., '.agents/skills/software-engineer/')"),
+              subskill: z5.string().optional().describe("Specific subskill to activate")
+            }).optional().describe("Skill context to inject into the sub-agent's system prompt"),
+            agentDefinition: z5.object({
+              definitionPath: z5.string().describe("Path to the agent definition file (e.g., '.claude/agents/software-engineer.md')")
+            }).optional().describe("Agent definition file to inject into the sub-agent's system prompt"),
+            preferredBackend: z5.enum(["claude", "codex", "gemini"]).optional().describe("Preferred backend override. Takes priority over automatic selection based on agent/task type."),
+            taskType: z5.enum(["code", "document", "analysis", "mixed"]).optional().describe("Task type hint for automatic backend selection when preferredBackend is not specified.")
           },
           async (params) => {
             try {
@@ -415,7 +700,8 @@ var init_server = __esm({
                 this.sessionManager,
                 this.guard,
                 this.hooksEngine,
-                this.contextMonitor
+                this.contextMonitor,
+                this.backendSelector
               );
               const isError = result.exitCode !== 0;
               const text = isError ? `Error (exit ${result.exitCode}): ${result.stderr || result.stdout}` : `Session: ${result.sessionId}
@@ -494,6 +780,30 @@ ${result.stdout}`;
             }
           }
         );
+        this.server.tool(
+          "list_available_backends",
+          "List all registered backends with their health status. Use this before spawn_agent to check which backends are available.",
+          {},
+          async () => {
+            try {
+              const result = await executeListAvailableBackends(this.registry);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                  }
+                ]
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true
+              };
+            }
+          }
+        );
       }
       async start(options) {
         const transportType = options?.transport ?? "stdio";
@@ -542,7 +852,7 @@ ${result.stdout}`;
 
 // src/bin/relay.ts
 import { defineCommand as defineCommand10, runMain } from "citty";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir6 } from "os";
 
 // src/infrastructure/process-manager.ts
@@ -671,6 +981,10 @@ var AdapterRegistry = class {
     this.factories.clear();
     return [...this.adapters.values()];
   }
+  /** Return registered backend IDs without instantiating lazy adapters */
+  listIds() {
+    return [.../* @__PURE__ */ new Set([...this.adapters.keys(), ...this.factories.keys()])];
+  }
 };
 
 // src/adapters/base-adapter.ts
@@ -698,6 +1012,42 @@ var BaseAdapter = class {
     }
     return result.stdout.trim();
   }
+  async continueSession(_nativeSessionId, _prompt) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `continueSession not supported for ${this.id}`
+    };
+  }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: `${this.id} is not installed`
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    return {
+      installed: true,
+      authenticated: true,
+      healthy: true,
+      version
+    };
+  }
   async getMCPConfig() {
     logger.warn(`getMCPConfig not implemented for ${this.id}`);
     return [];
@@ -799,6 +1149,48 @@ var ClaudeAdapter = class extends BaseAdapter {
   getConfigPath() {
     return join(homedir(), ".claude.json");
   }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "claude is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    let authenticated = true;
+    try {
+      const result = await Promise.race([
+        this.processManager.execute(this.command, ["auth", "status"]),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+        )
+      ]);
+      authenticated = result.exitCode === 0;
+    } catch {
+      authenticated = true;
+    }
+    return {
+      installed: true,
+      authenticated,
+      healthy: authenticated,
+      version,
+      ...!authenticated ? { message: "claude authentication not configured" } : {}
+    };
+  }
   mapFlags(flags) {
     return {
       args: mapCommonToNative("claude", flags)
@@ -825,7 +1217,8 @@ var ClaudeAdapter = class extends BaseAdapter {
         env,
         cwd: process.cwd(),
         ...flags.model ? { model: flags.model } : {},
-        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {}
+        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
+        ...flags.systemPrompt ? { systemPrompt: flags.systemPrompt } : {}
       };
       if (permissionMode === "bypassPermissions") {
         options.permissionMode = "bypassPermissions";
@@ -877,7 +1270,8 @@ var ClaudeAdapter = class extends BaseAdapter {
         env,
         cwd: process.cwd(),
         ...flags.model ? { model: flags.model } : {},
-        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {}
+        ...flags.maxTurns ? { maxTurns: flags.maxTurns } : {},
+        ...flags.systemPrompt ? { systemPrompt: flags.systemPrompt } : {}
       };
       if (permissionMode === "bypassPermissions") {
         options.permissionMode = "bypassPermissions";
@@ -942,6 +1336,44 @@ var ClaudeAdapter = class extends BaseAdapter {
       };
     }
   }
+  async continueSession(nativeSessionId, prompt) {
+    try {
+      const { query } = await loadClaudeSDK();
+      const permissionMode = this.getPermissionMode();
+      const options = {
+        resume: nativeSessionId,
+        maxTurns: 1,
+        cwd: process.cwd()
+      };
+      if (permissionMode === "bypassPermissions") {
+        options.permissionMode = "bypassPermissions";
+        options.allowDangerouslySkipPermissions = true;
+      }
+      const q = query({
+        prompt,
+        options
+      });
+      let resultText = "";
+      for await (const message of q) {
+        if (message.type === "result") {
+          if (message.subtype === "success") {
+            resultText = message.result;
+          }
+        }
+      }
+      return {
+        exitCode: 0,
+        stdout: resultText,
+        stderr: ""
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   async resumeSession(sessionId, flags) {
     await this.processManager.spawnInteractive(
       this.command,
@@ -1157,6 +1589,48 @@ var CodexAdapter = class extends BaseAdapter {
   getConfigPath() {
     return join2(homedir2(), ".codex", "config.toml");
   }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "codex is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    let authenticated = true;
+    try {
+      const result = await Promise.race([
+        this.processManager.execute(this.command, ["login", "status"]),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+        )
+      ]);
+      authenticated = result.exitCode === 0;
+    } catch {
+      authenticated = true;
+    }
+    return {
+      installed: true,
+      authenticated,
+      healthy: authenticated,
+      version,
+      ...!authenticated ? { message: "codex authentication not configured" } : {}
+    };
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("codex", flags);
     if (flags.outputFormat === "json") {
@@ -1174,15 +1648,39 @@ var CodexAdapter = class extends BaseAdapter {
     }
     await this.processManager.spawnInteractive(this.command, args);
   }
+  /**
+   * Resolve the effective system prompt from flags.
+   * Priority: systemPrompt > agent fallback > none
+   */
+  resolveSystemPrompt(flags) {
+    if (flags.systemPrompt) return flags.systemPrompt;
+    if (flags.agent) {
+      return `You are acting as the "${flags.agent}" agent. Follow the instructions and role defined for this agent.`;
+    }
+    return void 0;
+  }
+  /**
+   * Build the effective prompt with system instructions prepended if needed.
+   * Codex SDK does not support a native instructions/systemPrompt parameter,
+   * so we inject role context via a prompt prefix.
+   */
+  buildEffectivePrompt(prompt, systemPrompt) {
+    if (!systemPrompt) return prompt;
+    return `[System Instructions]
+${systemPrompt}
+
+[User Request]
+${prompt}`;
+  }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const systemPrompt = this.resolveSystemPrompt(flags);
+    const effectivePrompt = this.buildEffectivePrompt(
+      flags.prompt,
+      systemPrompt
+    );
     try {
       const { Codex } = await loadCodexSDK();
       const codexOptions = {};
@@ -1200,11 +1698,12 @@ var CodexAdapter = class extends BaseAdapter {
         workingDirectory: process.cwd(),
         approvalPolicy: "never"
       });
-      const result = await thread.run(flags.prompt);
+      const result = await thread.run(effectivePrompt);
       return {
         exitCode: 0,
         stdout: result.finalResponse,
-        stderr: ""
+        stderr: "",
+        ...thread.id ? { nativeSessionId: thread.id } : {}
       };
     } catch (error) {
       return {
@@ -1218,11 +1717,11 @@ var CodexAdapter = class extends BaseAdapter {
     if (!flags.prompt) {
       throw new Error("executeStreaming requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const systemPrompt = this.resolveSystemPrompt(flags);
+    const effectivePrompt = this.buildEffectivePrompt(
+      flags.prompt,
+      systemPrompt
+    );
     try {
       const { Codex } = await loadCodexSDK();
       const codexOptions = {};
@@ -1240,10 +1739,13 @@ var CodexAdapter = class extends BaseAdapter {
         workingDirectory: process.cwd(),
         approvalPolicy: "never"
       });
-      const streamedTurn = await thread.runStreamed(flags.prompt);
+      const streamedTurn = await thread.runStreamed(effectivePrompt);
       const completedMessages = [];
+      let threadId;
       for await (const event of streamedTurn.events) {
-        if (event.type === "item.started") {
+        if (event.type === "thread.started") {
+          threadId = event.thread_id;
+        } else if (event.type === "item.started") {
           const item = event.item;
           if (item?.type === "agent_message" && item.text) {
             yield { type: "text", text: item.text };
@@ -1291,13 +1793,15 @@ var CodexAdapter = class extends BaseAdapter {
           const finalResponse = completedMessages.join("\n");
           yield {
             type: "done",
-            result: { exitCode: 0, stdout: finalResponse, stderr: "" }
+            result: { exitCode: 0, stdout: finalResponse, stderr: "" },
+            nativeSessionId: threadId ?? thread.id ?? void 0
           };
         } else if (event.type === "turn.failed") {
           const errorMessage = event.error?.message ?? "Turn failed";
           yield {
             type: "done",
-            result: { exitCode: 1, stdout: "", stderr: errorMessage }
+            result: { exitCode: 1, stdout: "", stderr: errorMessage },
+            nativeSessionId: threadId ?? thread.id ?? void 0
           };
         } else if (event.type === "error") {
           yield {
@@ -1315,6 +1819,28 @@ var CodexAdapter = class extends BaseAdapter {
       };
     }
   }
+  async continueSession(nativeSessionId, prompt) {
+    try {
+      const { Codex } = await loadCodexSDK();
+      const codex = new Codex();
+      const thread = codex.resumeThread(nativeSessionId, {
+        workingDirectory: process.cwd(),
+        approvalPolicy: "never"
+      });
+      const result = await thread.run(prompt);
+      return {
+        exitCode: 0,
+        stdout: result.finalResponse,
+        stderr: ""
+      };
+    } catch (error) {
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   async resumeSession(sessionId, flags) {
     const args = [];
     if (flags.model) {
@@ -1408,6 +1934,38 @@ var GeminiAdapter = class extends BaseAdapter {
   getConfigPath() {
     return join3(homedir3(), ".gemini", "settings.json");
   }
+  async checkHealth() {
+    const HEALTH_TIMEOUT = 5e3;
+    const installed = await Promise.race([
+      this.isInstalled(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => false);
+    if (!installed) {
+      return {
+        installed: false,
+        authenticated: false,
+        healthy: false,
+        message: "gemini is not installed"
+      };
+    }
+    const version = await Promise.race([
+      this.getVersion(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), HEALTH_TIMEOUT)
+      )
+    ]).catch(() => void 0);
+    const hasApiKey = !!process.env["GEMINI_API_KEY"];
+    const hasGoogleAdc = !!process.env["GOOGLE_APPLICATION_CREDENTIALS"] || !!process.env["CLOUDSDK_CONFIG"];
+    const authenticated = hasApiKey || hasGoogleAdc || true;
+    return {
+      installed: true,
+      authenticated,
+      healthy: true,
+      version
+    };
+  }
   mapFlags(flags) {
     const args = mapCommonToNative("gemini", flags);
     if (flags.outputFormat) {
@@ -1428,15 +1986,34 @@ var GeminiAdapter = class extends BaseAdapter {
     }
     await this.processManager.spawnInteractive(this.command, args);
   }
+  /**
+   * Resolve the effective prompt with system instructions prepended if needed.
+   * Gemini CLI has no native system prompt flag, so we use a prompt prefix.
+   * Priority: systemPrompt > agent fallback > none
+   */
+  buildEffectivePrompt(flags) {
+    const prompt = flags.prompt;
+    if (flags.systemPrompt) {
+      return `[System Instructions]
+${flags.systemPrompt}
+
+[User Request]
+${prompt}`;
+    }
+    if (flags.agent) {
+      return `[System Instructions]
+You are acting as the "${flags.agent}" agent.
+
+[User Request]
+${prompt}`;
+    }
+    return prompt;
+  }
   async execute(flags) {
     if (!flags.prompt) {
       throw new Error("execute requires a prompt (-p flag)");
     }
-    if (flags.agent) {
-      logger.warn(
-        `Gemini CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
-      );
-    }
+    const effectivePrompt = this.buildEffectivePrompt(flags);
     const args = [];
     if (flags.model) {
       args.push("--model", flags.model);
@@ -1447,7 +2024,7 @@ var GeminiAdapter = class extends BaseAdapter {
     if (flags.verbose) {
       args.push("--verbose");
     }
-    args.push("-p", flags.prompt);
+    args.push("-p", effectivePrompt);
     return this.processManager.execute(this.command, args);
   }
   async resumeSession(sessionId, flags) {
@@ -1703,6 +2280,7 @@ var mcpServerConfigSchema = z.object({
   env: z.record(z.string()).optional()
 });
 var hookEventSchema = z.enum([
+  "session-init",
   "pre-prompt",
   "post-response",
   "on-error",
@@ -1718,9 +2296,24 @@ var hookDefinitionSchema = z.object({
   enabled: z.boolean().optional(),
   onError: z.enum(["ignore", "warn", "abort"]).optional()
 });
+var hookChainStepSchema = z.object({
+  stepId: z.string(),
+  hook: hookDefinitionSchema,
+  pipeOutput: z.boolean().optional()
+});
+var hookChainSchema = z.object({
+  name: z.string(),
+  steps: z.array(hookChainStepSchema).min(1),
+  onError: z.enum(["ignore", "warn", "fail"]).optional()
+});
 var hooksConfigSchema = z.object({
-  definitions: z.array(hookDefinitionSchema)
+  definitions: z.array(hookDefinitionSchema),
+  chains: z.array(hookChainSchema).optional()
 });
+var backendContextConfigSchema = z.object({
+  contextWindow: z.number().positive().optional(),
+  compactThreshold: z.number().positive().optional()
+}).optional();
 var relayConfigSchema = z.object({
   defaultBackend: backendIdSchema.optional(),
   mcpServers: z.record(mcpServerConfigSchema).optional(),
@@ -1731,9 +2324,16 @@ var relayConfigSchema = z.object({
   }).optional(),
   hooks: hooksConfigSchema.optional(),
   contextMonitor: z.object({
-    enabled: z.boolean(),
-    thresholdPercent: z.number().min(0).max(100),
-    notifyMethod: z.enum(["stderr", "hook"])
+    enabled: z.boolean().optional(),
+    thresholdPercent: z.number().min(0).max(100).optional(),
+    notifyThreshold: z.number().positive().optional(),
+    notifyPercent: z.number().min(0).max(100).optional(),
+    notifyMethod: z.enum(["stderr", "hook"]).optional(),
+    backends: z.object({
+      claude: backendContextConfigSchema,
+      codex: backendContextConfigSchema,
+      gemini: backendContextConfigSchema
+    }).optional()
   }).optional(),
   mcpServerMode: z.object({
     maxDepth: z.number().int().positive(),
@@ -2006,6 +2606,7 @@ var HooksEngine = class _HooksEngine {
   static COMMAND_PATTERN = /^[a-zA-Z0-9_./-]+$/;
   static ARG_PATTERN = /^[a-zA-Z0-9_.=:/-]+$/;
   definitions = [];
+  chains = [];
   registered = false;
   validateCommand(command) {
     if (!command || command.trim().length === 0) {
@@ -2046,6 +2647,7 @@ var HooksEngine = class _HooksEngine {
         return false;
       }
     });
+    this.chains = config.chains ?? [];
     if (!this.registered) {
       for (const event of this.getUniqueEvents()) {
         this.eventBus.on(event, async () => {
@@ -2087,10 +2689,132 @@ var HooksEngine = class _HooksEngine {
     await this.eventBus.emit(event, input);
     return results;
   }
+  /**
+   * Emit a hook event, execute all matching hooks, and return merged metadata.
+   * Merge rule: later hooks overwrite earlier hooks' metadata fields.
+   * If any hook returns allow: false, subsequent hooks are skipped.
+   */
+  async emitAndCollectMetadata(event, hookInput) {
+    const matchingDefs = this.definitions.filter((def) => def.event === event);
+    const results = [];
+    let mergedMetadata = {};
+    for (const def of matchingDefs) {
+      try {
+        const result = await this.executeHook(def, hookInput);
+        results.push(result);
+        if (result.output.metadata && typeof result.output.metadata === "object") {
+          mergedMetadata = { ...mergedMetadata, ...result.output.metadata };
+        }
+        if (!result.output.allow) {
+          logger.info(
+            `Hook "${def.command}" returned allow: false, skipping subsequent hooks for event "${event}"`
+          );
+          break;
+        }
+      } catch (error) {
+        const strategy = def.onError ?? "warn";
+        const message = error instanceof Error ? error.message : String(error);
+        if (strategy === "abort") {
+          throw new Error(
+            `Hook "${def.command}" failed (abort): ${message}`
+          );
+        }
+        if (strategy === "warn") {
+          logger.warn(
+            `Hook "${def.command}" failed (warn): ${message}`
+          );
+        }
+        results.push({
+          exitCode: 1,
+          stdout: "",
+          stderr: message,
+          durationMs: 0,
+          output: { ...DEFAULT_HOOK_OUTPUT }
+        });
+      }
+    }
+    await this.eventBus.emit(event, hookInput);
+    return { results, mergedMetadata };
+  }
   /** Get the count of enabled definitions for a given event */
   getDefinitionCount(event) {
     return this.definitions.filter((def) => def.event === event).length;
   }
+  /** Get all loaded chain names */
+  getChainNames() {
+    return this.chains.map((c) => c.name);
+  }
+  /**
+   * Execute a named hook chain.
+   * Steps execute in sequence. If pipeOutput is true, previous step's
+   * HookOutput is merged into the next step's HookInput.data.
+   */
+  async executeChain(chainName, initialInput) {
+    const chain = this.chains.find((c) => c.name === chainName);
+    if (!chain) {
+      throw new Error(`Hook chain "${chainName}" not found`);
+    }
+    const errorStrategy = chain.onError ?? "warn";
+    const stepResults = [];
+    let mergedMetadata = {};
+    let previousOutput;
+    let overallSuccess = true;
+    for (const step of chain.steps) {
+      const startTime = Date.now();
+      let stepInput;
+      if (step.pipeOutput && previousOutput) {
+        stepInput = {
+          ...initialInput,
+          data: {
+            ...initialInput.data,
+            ...previousOutput.metadata,
+            _previousMessage: previousOutput.message,
+            _previousAllow: previousOutput.allow
+          }
+        };
+      } else {
+        stepInput = { ...initialInput };
+      }
+      try {
+        const result = await this.executeHook(step.hook, stepInput);
+        const durationMs = Date.now() - startTime;
+        stepResults.push({
+          stepId: step.stepId,
+          success: true,
+          output: result.output,
+          durationMs
+        });
+        if (result.output.metadata && typeof result.output.metadata === "object") {
+          mergedMetadata = { ...mergedMetadata, ...result.output.metadata };
+        }
+        previousOutput = result.output;
+      } catch (error) {
+        const durationMs = Date.now() - startTime;
+        const message = error instanceof Error ? error.message : String(error);
+        stepResults.push({
+          stepId: step.stepId,
+          success: false,
+          error: message,
+          durationMs
+        });
+        overallSuccess = false;
+        if (errorStrategy === "fail") {
+          break;
+        }
+        if (errorStrategy === "warn") {
+          logger.warn(
+            `Hook chain "${chainName}" step "${step.stepId}" failed (warn): ${message}`
+          );
+        }
+      }
+    }
+    return {
+      chainName,
+      stepResults,
+      success: overallSuccess,
+      mergedMetadata
+    };
+  }
   async executeHook(def, input) {
     this.validateCommand(def.command);
     this.validateArgs(def.args ?? []);
@@ -2129,34 +2853,75 @@ var HooksEngine = class _HooksEngine {
 };
 
 // src/core/context-monitor.ts
+var DEFAULT_BACKEND_CONTEXT = {
+  claude: { contextWindow: 2e5, compactThreshold: 19e4 },
+  codex: { contextWindow: 272e3, compactThreshold: 258400 },
+  gemini: { contextWindow: 1048576, compactThreshold: 524288 }
+};
+var DEFAULT_NOTIFY_PERCENT = 70;
 var DEFAULT_CONFIG = {
   enabled: true,
-  thresholdPercent: 75,
-  notifyMethod: "stderr"
+  notifyMethod: "hook"
 };
 var ContextMonitor = class {
   constructor(hooksEngine2, config) {
     this.hooksEngine = hooksEngine2;
     this.config = { ...DEFAULT_CONFIG, ...config };
+    if (this.config.thresholdPercent !== void 0 && this.config.notifyPercent === void 0 && this.config.notifyThreshold === void 0) {
+      this.config.notifyPercent = this.config.thresholdPercent;
+    }
   }
   config;
   usageMap = /* @__PURE__ */ new Map();
+  /** Get backend context config, merging user overrides with defaults */
+  getBackendConfig(backendId) {
+    const defaults = DEFAULT_BACKEND_CONTEXT[backendId];
+    const overrides = this.config.backends?.[backendId];
+    return {
+      contextWindow: overrides?.contextWindow ?? defaults.contextWindow,
+      compactThreshold: overrides?.compactThreshold ?? defaults.compactThreshold
+    };
+  }
+  /** Calculate the notification threshold in tokens for a given backend */
+  getNotifyThreshold(backendId) {
+    if (this.config.notifyThreshold !== void 0) {
+      return this.config.notifyThreshold;
+    }
+    const backendConfig = this.getBackendConfig(backendId);
+    const notifyPercent = this.config.notifyPercent ?? DEFAULT_NOTIFY_PERCENT;
+    return Math.round(backendConfig.contextWindow * notifyPercent / 100);
+  }
   /** Update token usage for a session and check threshold */
-  updateUsage(sessionId, backendId, estimatedTokens, maxTokens) {
+  updateUsage(sessionId, backendId, estimatedTokens) {
     if (!this.config.enabled) return;
-    const usagePercent = maxTokens > 0 ? Math.round(estimatedTokens / maxTokens * 100) : 0;
+    const backendConfig = this.getBackendConfig(backendId);
+    const contextWindow = backendConfig.contextWindow;
+    const usagePercent = contextWindow > 0 ? Math.round(estimatedTokens / contextWindow * 100) : 0;
     const existing = this.usageMap.get(sessionId);
-    const wasNotified = existing?.notified ?? false;
+    let wasNotified = existing?.notified ?? false;
+    if (existing && estimatedTokens < existing.estimatedTokens * 0.7) {
+      wasNotified = false;
+    }
     this.usageMap.set(sessionId, {
       estimatedTokens,
-      maxTokens,
+      contextWindow,
+      compactThreshold: backendConfig.compactThreshold,
       usagePercent,
       backendId,
       notified: wasNotified
     });
-    if (usagePercent >= this.config.thresholdPercent && !wasNotified) {
-      this.usageMap.get(sessionId).notified = true;
-      this.notify(sessionId, backendId, usagePercent);
+    const notifyAt = this.getNotifyThreshold(backendId);
+    if (estimatedTokens >= notifyAt && !wasNotified) {
+      const entry = this.usageMap.get(sessionId);
+      entry.notified = true;
+      this.notify(
+        sessionId,
+        backendId,
+        usagePercent,
+        estimatedTokens,
+        contextWindow,
+        backendConfig.compactThreshold
+      );
     }
   }
   /** Get usage info for a session */
@@ -2165,17 +2930,31 @@ var ContextMonitor = class {
     if (!entry) return null;
     return {
       usagePercent: entry.usagePercent,
-      isEstimated: true
+      isEstimated: true,
+      backendId: entry.backendId,
+      contextWindow: entry.contextWindow,
+      compactThreshold: entry.compactThreshold,
+      estimatedTokens: entry.estimatedTokens,
+      remainingBeforeCompact: Math.max(
+        0,
+        entry.compactThreshold - entry.estimatedTokens
+      ),
+      notifyThreshold: this.getNotifyThreshold(entry.backendId)
     };
   }
   /** Remove usage tracking for a session */
   removeSession(sessionId) {
     this.usageMap.delete(sessionId);
   }
-  notify(sessionId, backendId, usagePercent) {
+  notify(sessionId, backendId, usagePercent, currentTokens, contextWindow, compactThreshold) {
+    const remainingBeforeCompact = Math.max(
+      0,
+      compactThreshold - currentTokens
+    );
+    const warningMessage = `${backendId} session ${sessionId} at ${usagePercent}% (${currentTokens}/${contextWindow} tokens). Compact in ~${remainingBeforeCompact} tokens. Save your work state now.`;
     if (this.config.notifyMethod === "stderr") {
       process.stderr.write(
-        `[relay] Context usage warning: session ${sessionId} is at ${usagePercent}% (threshold: ${this.config.thresholdPercent}%)
+        `[relay] Context warning: ${warningMessage}
 `
       );
     } else if (this.config.notifyMethod === "hook" && this.hooksEngine) {
@@ -2186,7 +2965,10 @@ var ContextMonitor = class {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data: {
           usagePercent,
-          thresholdPercent: this.config.thresholdPercent
+          currentTokens,
+          contextWindow,
+          compactThreshold,
+          remainingBeforeCompact
         }
       };
       void this.hooksEngine.emit("on-context-threshold", hookInput);
@@ -2323,6 +3105,7 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
       try {
         if (flags.prompt) {
           logger.debug(`Executing prompt on ${backendId}`);
+          let nativeSessionId;
           if (adapter.executeStreaming) {
             for await (const event of adapter.executeStreaming(flags)) {
               switch (event.type) {
@@ -2353,18 +3136,17 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
                   break;
                 case "usage": {
                   if (contextMonitor2 && relaySessionId) {
-                    const maxTokens = backendId === "gemini" ? 128e3 : 2e5;
                     contextMonitor2.updateUsage(
                       relaySessionId,
                       backendId,
-                      event.inputTokens + event.outputTokens,
-                      maxTokens
+                      event.inputTokens + event.outputTokens
                     );
                   }
                   break;
                 }
                 case "done":
                   process.exitCode = event.result.exitCode;
+                  nativeSessionId = event.nativeSessionId;
                   if (event.nativeSessionId && sessionManager2 && relaySessionId) {
                     try {
                       await sessionManager2.update(relaySessionId, {
@@ -2381,6 +3163,7 @@ function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine
             if (result.stdout) process.stdout.write(result.stdout);
             if (result.stderr) process.stderr.write(result.stderr);
             process.exitCode = result.exitCode;
+            nativeSessionId = result.nativeSessionId;
             if (result.nativeSessionId && sessionManager2 && relaySessionId) {
               try {
                 await sessionManager2.update(relaySessionId, {
@@ -2989,7 +3772,7 @@ function createVersionCommand(registry2) {
 // src/commands/doctor.ts
 import { defineCommand as defineCommand8 } from "citty";
 import { access, constants, readdir as readdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir5 } from "os";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -3050,8 +3833,8 @@ async function checkConfig(configManager2) {
   }
 }
 async function checkSessionsDir() {
-  const relayHome2 = process.env["RELAY_HOME"] ?? join6(homedir5(), ".relay");
-  const sessionsDir = join6(relayHome2, "sessions");
+  const relayHome2 = process.env["RELAY_HOME"] ?? join7(homedir5(), ".relay");
+  const sessionsDir = join7(relayHome2, "sessions");
   try {
     await access(sessionsDir, constants.W_OK);
     return {
@@ -3164,8 +3947,8 @@ async function checkBackendAuthEnv() {
   return results;
 }
 async function checkSessionsDiskUsage() {
-  const relayHome2 = process.env["RELAY_HOME"] ?? join6(homedir5(), ".relay");
-  const sessionsDir = join6(relayHome2, "sessions");
+  const relayHome2 = process.env["RELAY_HOME"] ?? join7(homedir5(), ".relay");
+  const sessionsDir = join7(relayHome2, "sessions");
   try {
     const entries = await readdir2(sessionsDir);
     const fileCount = entries.length;
@@ -3239,7 +4022,7 @@ function createDoctorCommand(registry2, configManager2) {
 init_logger();
 import { defineCommand as defineCommand9 } from "citty";
 import { mkdir as mkdir6, writeFile as writeFile6, access as access2, readFile as readFile6 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var DEFAULT_CONFIG2 = {
   defaultBackend: "claude",
   backends: {},
@@ -3253,8 +4036,8 @@ function createInitCommand() {
     },
     async run() {
       const projectDir = process.cwd();
-      const relayDir = join7(projectDir, ".relay");
-      const configPath = join7(relayDir, "config.json");
+      const relayDir = join8(projectDir, ".relay");
+      const configPath = join8(relayDir, "config.json");
       try {
         await access2(relayDir);
         logger.info(
@@ -3270,7 +4053,7 @@ function createInitCommand() {
         "utf-8"
       );
       logger.success(`Created ${configPath}`);
-      const gitignorePath = join7(projectDir, ".gitignore");
+      const gitignorePath = join8(projectDir, ".gitignore");
       try {
         const gitignoreContent = await readFile6(gitignorePath, "utf-8");
         if (!gitignoreContent.includes(".relay/config.local.json")) {
@@ -3295,8 +4078,8 @@ 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"] ?? join8(homedir6(), ".relay");
-var projectRelayDir = join8(process.cwd(), ".relay");
+var relayHome = process.env["RELAY_HOME"] ?? join9(homedir6(), ".relay");
+var projectRelayDir = join9(process.cwd(), ".relay");
 var configManager = new ConfigManager(relayHome, projectRelayDir);
 var authManager = new AuthManager(registry);
 var eventBus = new EventBus();