handsoff 0.1.1 → 0.1.2-beta.0

package/dist/gateway/process.js

@@ -4077,8 +4077,1004 @@ var ClaudeAdapter = class _ClaudeAdapter {
   }
 };
 
+// src/adapters/agent/claude/session-context.ts
+import { readFile as readFile2 } from "fs/promises";
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var ClaudeSessionContextProvider = class {
+  async getSessionSummary(_sessionId, transcriptPath) {
+    if (!transcriptPath) {
+      return void 0;
+    }
+    const summary = await this.tryReadTranscript(transcriptPath);
+    return summary;
+  }
+  async tryReadTranscript(transcriptPath, maxAttempts = 5, delayMs = 200) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const content = await readFile2(transcriptPath, "utf-8");
+        const summary = this.parseTranscript(content);
+        if (summary && (summary.lastAssistantMessage !== void 0 || summary.durationMs !== void 0)) {
+          return summary;
+        }
+        if (summary) {
+          getLogger().debug({ attempt, summary }, "Transcript read but incomplete, retrying...");
+        }
+      } catch (error2) {
+        lastError = error2;
+      }
+      if (attempt < maxAttempts) {
+        await sleep(delayMs);
+      }
+    }
+    getLogger().warn({ error: lastError instanceof Error ? lastError.message : String(lastError), transcriptPath }, "Failed to read transcript or transcript incomplete");
+    return void 0;
+  }
+  parseTranscript(content) {
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+    let lastAssistantMessage;
+    let inputTokens;
+    let outputTokens;
+    let lastTextAssistant;
+    let lastAnyAssistant;
+    const userTimestamps = /* @__PURE__ */ new Map();
+    const parentMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (parseError) {
+        getLogger().warn(
+          { error: parseError instanceof Error ? parseError.message : String(parseError), line: line.slice(0, 200) },
+          "Skipping malformed transcript line"
+        );
+        continue;
+      }
+      const ts = typeof entry.timestamp === "string" ? new Date(entry.timestamp).getTime() : typeof entry.timestamp === "number" ? entry.timestamp : void 0;
+      if (entry.uuid && typeof entry.parentUuid === "string") {
+        parentMap.set(entry.uuid, entry.parentUuid);
+      }
+      if (entry.type === "user" && ts !== void 0 && entry.uuid) {
+        userTimestamps.set(entry.uuid, ts);
+      }
+      if (entry.type === "assistant" && ts !== void 0) {
+        const arr = Array.isArray(entry.message?.content) ? entry.message.content : [];
+        const textBlock = arr.find((c) => c.type === "text");
+        const assistantRef = { ts, uuid: entry.uuid, parentUuid: entry.parentUuid };
+        lastAnyAssistant = assistantRef;
+        if (textBlock && typeof textBlock.text === "string") {
+          lastAssistantMessage = textBlock.text;
+          lastTextAssistant = assistantRef;
+          const usage = entry.message?.usage;
+          if (usage) {
+            if (typeof usage.input_tokens === "number") {
+              inputTokens = usage.input_tokens;
+            }
+            if (typeof usage.output_tokens === "number") {
+              outputTokens = usage.output_tokens;
+            }
+          }
+        }
+      }
+    }
+    function resolveDuration(assistantRef) {
+      if (!assistantRef) return void 0;
+      if (assistantRef.parentUuid) {
+        const directParentTs = userTimestamps.get(assistantRef.parentUuid);
+        if (directParentTs !== void 0) {
+          return assistantRef.ts - directParentTs;
+        }
+      }
+      let currentUuid = assistantRef.uuid;
+      const visited = /* @__PURE__ */ new Set();
+      while (currentUuid && !visited.has(currentUuid)) {
+        visited.add(currentUuid);
+        const parentUuid = parentMap.get(currentUuid);
+        if (!parentUuid) break;
+        const parentTs = userTimestamps.get(parentUuid);
+        if (parentTs !== void 0) {
+          return assistantRef.ts - parentTs;
+        }
+        currentUuid = parentUuid;
+      }
+      return void 0;
+    }
+    const durationMs = resolveDuration(lastTextAssistant) ?? resolveDuration(lastAnyAssistant);
+    const summary = {
+      ...lastAssistantMessage !== void 0 && { lastAssistantMessage },
+      ...inputTokens !== void 0 && { inputTokens },
+      ...outputTokens !== void 0 && { outputTokens },
+      ...durationMs !== void 0 && { durationMs }
+    };
+    return summary;
+  }
+};
+
+// src/adapters/agent/claude/ClaudeRemoteAdapter.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/adapters/agent/claude/sdk/query.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { existsSync as existsSync5 } from "fs";
+
+// src/adapters/agent/claude/sdk/stream.ts
+var Stream = class {
+  constructor(returned) {
+    this.returned = returned;
+  }
+  returned;
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  async next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({ done: false, value: this.queue.shift() });
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+    return new Promise((resolve2, reject) => {
+      this.readResolve = resolve2;
+      this.readReject = reject;
+    });
+  }
+  enqueue(value) {
+    if (this.isDone || this.hasError) return;
+    if (this.readResolve) {
+      const resolve2 = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve2({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  done() {
+    if (this.isDone || this.hasError) return;
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve2 = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve2({ done: true, value: void 0 });
+    }
+  }
+  error(error2) {
+    if (this.isDone || this.hasError) return;
+    this.hasError = error2;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      reject(error2);
+    }
+  }
+  async return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+};
+
+// src/adapters/agent/claude/sdk/types.ts
+var AbortError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+
+// src/adapters/agent/claude/sdk/query.ts
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    env[actualPathKey] = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+  }
+  return env;
+}
+function buildClaudeArgs(options) {
+  const args = ["--output-format", "stream-json", "--verbose"];
+  if (options.customSystemPrompt) args.push("--system-prompt", options.customSystemPrompt);
+  if (options.appendSystemPrompt) args.push("--append-system-prompt", options.appendSystemPrompt);
+  if (options.maxTurns !== void 0) args.push("--max-turns", String(options.maxTurns));
+  if (options.model) args.push("--model", options.model);
+  if (options.canCallTool) {
+    args.push("--permission-prompt-tool", "stdio");
+  }
+  if (options.continue) args.push("--continue");
+  if (options.resume) args.push("--resume", options.resume);
+  if (options.allowedTools && options.allowedTools.length > 0) {
+    args.push("--allowedTools", options.allowedTools.join(","));
+  }
+  if (options.disallowedTools && options.disallowedTools.length > 0) {
+    args.push("--disallowedTools", options.disallowedTools.join(","));
+  }
+  if (options.mcpServers && Object.keys(options.mcpServers).length > 0) {
+    args.push("--mcp-config", JSON.stringify({ mcpServers: options.mcpServers }));
+  }
+  if (options.strictMcpConfig) args.push("--strict-mcp-config");
+  if (options.permissionMode) args.push("--permission-mode", options.permissionMode);
+  if (options.settingsPath) args.push("--settings", options.settingsPath);
+  if (options.fallbackModel) {
+    if (options.model && options.fallbackModel === options.model) {
+      throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
+    }
+    args.push("--fallback-model", options.fallbackModel);
+  }
+  return args;
+}
+var Query = class {
+  constructor(childStdin, childStdout, processExitPromise, canCallTool) {
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.canCallTool = canCallTool;
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+  childStdin;
+  childStdout;
+  processExitPromise;
+  canCallTool;
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  inputStream = new Stream();
+  sdkMessages;
+  child;
+  setChild(child) {
+    this.child = child;
+  }
+  kill(signal = "SIGTERM") {
+    if (this.child && !this.child.killed) {
+      this.child.kill(signal);
+    }
+  }
+  setError(error2) {
+    this.inputStream.error(error2);
+  }
+  next(...args) {
+    return this.sdkMessages.next(...args);
+  }
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+  async readMessages() {
+    const rl = createInterface({ input: this.childStdout });
+    try {
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        try {
+          const message = JSON.parse(line);
+          if (message.type === "control_response") {
+            const cr = message;
+            const handler = this.pendingControlResponses.get(cr.response.request_id);
+            if (handler) handler(cr.response);
+            continue;
+          }
+          if (message.type === "control_request") {
+            await this.handleControlRequest(message);
+            continue;
+          }
+          if (message.type === "control_cancel_request") {
+            this.handleControlCancelRequest(message);
+            continue;
+          }
+          this.inputStream.enqueue(message);
+        } catch {
+        }
+      }
+      await this.processExitPromise;
+    } catch (error2) {
+      this.inputStream.error(error2);
+    } finally {
+      this.inputStream.done();
+      this.cleanupControllers();
+      rl.close();
+    }
+  }
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+  async interrupt() {
+    if (!this.childStdin) throw new Error("Interrupt requires --input-format stream-json");
+    await this.request({ subtype: "interrupt" }, this.childStdin);
+  }
+  request(request, childStdin) {
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const sdkRequest = {
+      request_id: requestId,
+      type: "control_request",
+      request
+    };
+    return new Promise((resolve2, reject) => {
+      this.pendingControlResponses.set(requestId, (response) => {
+        if (response.subtype === "success") {
+          resolve2(response);
+        } else {
+          reject(new Error(response.error));
+        }
+      });
+      childStdin.write(JSON.stringify(sdkRequest) + "\n");
+    });
+  }
+  async handleControlRequest(request) {
+    if (!this.childStdin) return;
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+    try {
+      const response = await this.processControlRequest(request, controller.signal);
+      const controlResponse = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+    } catch (error2) {
+      const controlErrorResponse = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: error2 instanceof Error ? error2.message : String(error2)
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === "can_use_tool") {
+      if (!this.canCallTool) {
+        throw new Error("canCallTool callback is not provided.");
+      }
+      return this.canCallTool(request.request.tool_name, request.request.input, { signal });
+    }
+    throw new Error("Unsupported control request subtype: " + request.request.subtype);
+  }
+  cleanupControllers() {
+    for (const [requestId, controller] of this.cancelControllers.entries()) {
+      controller.abort();
+      this.cancelControllers.delete(requestId);
+    }
+  }
+};
+function query(config) {
+  const {
+    prompt,
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      executable = "node",
+      executableArgs = [],
+      maxTurns,
+      mcpServers,
+      pathToClaudeCodeExecutable = "claude",
+      permissionMode = "default",
+      continue: continueConversation,
+      resume,
+      model,
+      fallbackModel,
+      strictMcpConfig,
+      canCallTool,
+      settingsPath,
+      env,
+      abort
+    } = {}
+  } = config;
+  if (abort?.aborted) {
+    throw new AbortError("Claude Code process aborted by user");
+  }
+  if (canCallTool && typeof prompt === "string") {
+    throw new Error("canCallTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
+  }
+  if (!process.env.CLAUDE_CODE_ENTRYPOINT) {
+    process.env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+  }
+  const args = buildClaudeArgs({
+    allowedTools,
+    appendSystemPrompt,
+    customSystemPrompt,
+    maxTurns,
+    model,
+    canCallTool,
+    continue: continueConversation,
+    resume,
+    disallowedTools,
+    mcpServers,
+    strictMcpConfig,
+    permissionMode,
+    settingsPath,
+    fallbackModel
+  });
+  if (typeof prompt === "string") {
+    args.push("--print", prompt.trim());
+  } else {
+    args.push("--input-format", "stream-json");
+  }
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !existsSync5(pathToClaudeCodeExecutable)) {
+    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}`);
+  }
+  const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
+  const spawnArgs = isJsFile ? [...executableArgs, pathToClaudeCodeExecutable, ...args] : args;
+  const spawnEnv = isCommandOnly ? { ...getCleanEnv(), ...env } : { ...process.env, ...env };
+  const child = spawn(spawnCommand, spawnArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: abort,
+    env: spawnEnv,
+    shell: !isJsFile && process.platform === "win32",
+    windowsHide: true
+  });
+  child.stderr.resume();
+  let childStdin = null;
+  if (typeof prompt === "string") {
+    child.stdin.end();
+  } else {
+    (async () => {
+      try {
+        for await (const msg of prompt) {
+          if (abort?.aborted) break;
+          const data = JSON.stringify(msg) + "\n";
+          if (!child.stdin.write(data)) {
+            await new Promise((resolve2) => child.stdin.once("drain", resolve2));
+          }
+        }
+      } finally {
+        child.stdin.end();
+      }
+    })();
+    childStdin = child.stdin;
+  }
+  const cleanup = () => {
+    if (!child.killed) child.kill("SIGTERM");
+  };
+  abort?.addEventListener("abort", cleanup);
+  const processExitPromise = new Promise((resolve2) => {
+    child.on("close", (code) => {
+      if (abort?.aborted) {
+        q.setError(new AbortError("Claude Code process aborted by user"));
+      } else if (code !== 0 && code !== null) {
+        q.setError(new Error(`Claude Code process exited with code ${code}`));
+      } else {
+        resolve2();
+      }
+    });
+  });
+  const q = new Query(childStdin, child.stdout, processExitPromise, canCallTool);
+  q.setChild(child);
+  child.on("error", (error2) => {
+    if (abort?.aborted) {
+      q.setError(new AbortError("Claude Code process aborted by user"));
+    } else {
+      q.setError(new Error(`Failed to spawn Claude Code process: ${error2.message}`));
+    }
+  });
+  processExitPromise.finally(() => {
+    cleanup();
+    abort?.removeEventListener("abort", cleanup);
+  });
+  return q;
+}
+
+// src/adapters/agent/claude/ClaudeRemoteAdapter.ts
+var PushableAsyncIterable = class {
+  queue = [];
+  resolvers = [];
+  ended = false;
+  push(value) {
+    if (this.ended) return;
+    if (this.resolvers.length > 0) {
+      const resolve2 = this.resolvers.shift();
+      resolve2({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  end() {
+    this.ended = true;
+    while (this.resolvers.length > 0) {
+      const resolve2 = this.resolvers.shift();
+      resolve2({ done: true, value: void 0 });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.queue.length > 0) {
+          return Promise.resolve({ done: false, value: this.queue.shift() });
+        }
+        if (this.ended) {
+          return Promise.resolve({ done: true, value: void 0 });
+        }
+        return new Promise((resolve2) => {
+          this.resolvers.push(resolve2);
+        });
+      },
+      return: () => {
+        this.end();
+        return Promise.resolve({ done: true, value: void 0 });
+      }
+    };
+  }
+};
+var ClaudeRemoteAdapter = class _ClaudeRemoteAdapter {
+  agentType = "claude";
+  transportType = "remote";
+  version = "1.0.0";
+  protocolHandler = new ClaudeProtocolHandler();
+  static scanner = null;
+  bus;
+  logger;
+  gateway;
+  token;
+  sessions = /* @__PURE__ */ new Map();
+  eventHandler = null;
+  unsubscribeFns = [];
+  command;
+  spawnCwd;
+  envExtra;
+  defaultWorkDir;
+  defaultModel;
+  defaultPermissionMode;
+  constructor(options) {
+    this.bus = options.bus;
+    this.logger = options.logger;
+    this.gateway = options.gateway;
+    this.token = options.token;
+    this.command = options.command?.length ? options.command : ["claude"];
+    this.spawnCwd = options.cwd;
+    this.envExtra = options.env ?? {};
+    this.defaultWorkDir = options.defaultWorkDir;
+    this.defaultModel = options.defaultModel;
+    this.defaultPermissionMode = options.defaultPermissionMode;
+  }
+  async initialize() {
+    this.logger.info("Claude remote adapter initializing");
+    try {
+      const { execSync } = await import("child_process");
+      execSync(`${this.command[0]} --version`, { encoding: "utf8", windowsHide: true });
+      this.logger.info("Claude CLI detected");
+    } catch (err) {
+      this.logger.warn("Claude CLI not found");
+      throw err;
+    }
+    if (!_ClaudeRemoteAdapter.scanner) {
+      _ClaudeRemoteAdapter.scanner = new ClaudeSessionScanner();
+      SessionScannerRegistry.getInstance().register(_ClaudeRemoteAdapter.scanner);
+      this.logger.info("Claude session scanner registered");
+    }
+    AgentAdapterRegistry.getInstance().register(this);
+    if (!this.unsubscribeFns.length) {
+      this.unsubscribeFns.push(this.bus.onInbound((msg) => this.handleInboundMessage(msg)));
+      this.logger.debug("Subscribed to inbound messages");
+    }
+  }
+  async shutdown() {
+    this.logger.info("Claude remote adapter shutting down");
+    for (const [sessionId, state] of this.sessions) {
+      try {
+        state.query.kill("SIGTERM");
+        state.input.end();
+      } catch (err) {
+        this.logger.warn({ sessionId, error: err }, "Error ending session input during shutdown");
+      }
+    }
+    this.sessions.clear();
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    this.logger.info("Claude remote adapter shutdown complete");
+  }
+  async createSession(opts) {
+    const sessionId = opts.sessionId ?? `claude-${randomUUID4().slice(0, 8)}`;
+    const chatId = opts.metadata?.chatId ?? sessionId;
+    const channel = opts.metadata?.channel ?? "broadcast";
+    const cwd = opts.cwd ?? this.defaultWorkDir ?? process.cwd();
+    this.logger.info({ sessionId, chatId, cwd }, "Creating Claude remote session");
+    const input = new PushableAsyncIterable();
+    const q = query({
+      prompt: input,
+      options: {
+        cwd: this.spawnCwd,
+        model: opts.model ?? this.defaultModel,
+        permissionMode: this.defaultPermissionMode,
+        env: this.envExtra,
+        pathToClaudeCodeExecutable: this.command[0],
+        canCallTool: (toolName, toolInput, { signal }) => this.handleCanCallTool(sessionId, toolName, toolInput, signal)
+      }
+    });
+    const handle = {
+      id: sessionId,
+      agentType: this.agentType,
+      transportType: this.transportType,
+      createdAt: /* @__PURE__ */ new Date(),
+      sendCommand: async (command) => {
+        await this.handleCommand(sessionId, command);
+      },
+      close: async () => {
+        this.logger.info({ sessionId }, "Closing Claude remote session");
+        input.end();
+        this.sessions.delete(sessionId);
+      }
+    };
+    const state = {
+      handle,
+      query: q,
+      input,
+      chatId,
+      channel,
+      cwd,
+      turnInProgress: false
+    };
+    this.sessions.set(sessionId, state);
+    this.consumeQueryMessages(q, sessionId, state).catch((err) => {
+      this.logger.error({ sessionId, error: err }, "Query consumer error");
+    });
+    this.logger.info({ sessionId }, "Claude remote session started");
+    return handle;
+  }
+  async closeSession(handle) {
+    await handle.close();
+  }
+  async listSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.handle.id,
+      agentType: this.agentType,
+      transportType: this.transportType,
+      status: "active",
+      startedAt: s.handle.createdAt
+    }));
+  }
+  async getSession(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state) return void 0;
+    return {
+      id: state.handle.id,
+      agentType: this.agentType,
+      transportType: this.transportType,
+      status: "active",
+      startedAt: state.handle.createdAt
+    };
+  }
+  setEventHandler(handler) {
+    this.eventHandler = handler;
+    this.logger.debug("Event handler registered");
+  }
+  async healthCheck() {
+    return { healthy: true, message: `${this.sessions.size} active remote sessions` };
+  }
+  async consumeQueryMessages(q, sessionId, state) {
+    try {
+      for await (const msg of q) {
+        await this.handleSdkMessage(msg, sessionId, state);
+      }
+    } catch (err) {
+      this.logger.error({ sessionId, error: err }, "Claude remote stream ended with error");
+      this.bus.publishOutbound({
+        channel: state.channel,
+        chatId: state.chatId,
+        text: "Claude session ended unexpectedly."
+      });
+    } finally {
+      state.turnInProgress = false;
+      this.sessions.delete(sessionId);
+      this.gateway.handleEvent(this.token, {
+        type: "session:end",
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { reason: "stream_ended" },
+        metadata: { agentType: this.agentType, transportType: this.transportType }
+      }).catch(() => {
+      });
+    }
+  }
+  async handleSdkMessage(msg, sessionId, state) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (msg.type) {
+      case "system": {
+        const system = msg;
+        if (system.subtype === "init" && system.session_id) {
+          this.logger.info({ sessionId, claudeSessionId: system.session_id }, "Claude session initialized");
+          this.gateway.handleEvent(this.token, {
+            type: "session:start",
+            sessionId,
+            timestamp,
+            payload: { claudeSessionId: system.session_id },
+            metadata: { agentType: this.agentType, transportType: this.transportType }
+          }).catch(() => {
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        const assistant = msg;
+        const blocks = Array.isArray(assistant.message?.content) ? assistant.message.content : [];
+        for (const block of blocks) {
+          if (block.type === "text" && typeof block.text === "string") {
+            this.bus.publishAgentMessage({ sessionId, content: block.text });
+          }
+          if (block.type === "thinking" && typeof block.thinking === "string") {
+            this.bus.publishAgentMessage({ sessionId, content: block.thinking });
+          }
+          if (block.type === "tool_use") {
+            const toolName = typeof block.name === "string" ? block.name : "unknown";
+            this.bus.publishToolStart({ sessionId, toolName, toolInput: block.input ?? {} });
+          }
+        }
+        break;
+      }
+      case "user": {
+        const user = msg;
+        const content = user.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+              this.bus.publishToolEnd({ sessionId, toolName: "unknown", output: block.text });
+            } else if (block.type === "text" && typeof block.text === "string") {
+              this.bus.publishAgentMessage({ sessionId, content: block.text });
+            }
+          }
+        }
+        break;
+      }
+      case "result": {
+        const result = msg;
+        this.logger.info({ sessionId, subtype: result.subtype }, "Claude turn result");
+        this.gateway.handleEvent(this.token, {
+          type: "finished",
+          sessionId,
+          timestamp,
+          payload: { result: result.result, subtype: result.subtype },
+          metadata: { agentType: this.agentType, transportType: this.transportType }
+        }).catch(() => {
+        });
+        state.turnInProgress = false;
+        break;
+      }
+      case "log": {
+        const log = msg;
+        const level = log.log?.level ?? "debug";
+        const message = log.log?.message ?? "";
+        if (level === "error") this.logger.error({ sessionId }, message);
+        else if (level === "warn") this.logger.warn({ sessionId }, message);
+        else if (level === "info") this.logger.info({ sessionId }, message);
+        else this.logger.debug({ sessionId }, message);
+        break;
+      }
+    }
+  }
+  async handleCommand(sessionId, command) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      this.logger.warn({ sessionId, commandType: command.type }, "Command received but session not found");
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    switch (command.type) {
+      case "user:message": {
+        if (state.turnInProgress) {
+          this.logger.warn({ sessionId }, "Concurrent turn rejected");
+          this.bus.publishOutbound({
+            channel: state.channel,
+            chatId: state.chatId,
+            text: "Claude is still processing the previous message. Please wait."
+          });
+          return;
+        }
+        state.turnInProgress = true;
+        state.input.push({
+          type: "user",
+          message: { role: "user", content: command.content }
+        });
+        break;
+      }
+      case "interrupt": {
+        this.logger.info({ sessionId }, "Interrupting turn");
+        await state.query.interrupt();
+        break;
+      }
+      case "stop": {
+        this.logger.info({ sessionId }, "Stopping session");
+        state.input.end();
+        this.sessions.delete(sessionId);
+        this.gateway.handleEvent(this.token, {
+          type: "session:end",
+          sessionId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: { reason: "stopped" },
+          metadata: { agentType: this.agentType, transportType: this.transportType }
+        }).catch(() => {
+        });
+        break;
+      }
+      default: {
+        this.logger.warn({ sessionId, commandType: command.type }, "Unsupported command");
+      }
+    }
+  }
+  async handleCanCallTool(sessionId, toolName, toolInput, signal) {
+    const state = this.sessions.get(sessionId);
+    if (!state) {
+      this.logger.warn({ sessionId, toolName }, "Permission request but session not found, auto-denying");
+      return { behavior: "deny", message: "Session not found" };
+    }
+    const requestId = `${sessionId}-${Math.random().toString(36).substring(2, 10)}`;
+    this.logger.info({ sessionId, requestId, toolName }, "Claude remote permission request");
+    const envelope = {
+      type: "permission:request",
+      sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { sessionId, toolName, toolInput: toolInput ?? {} },
+      metadata: {
+        agentType: this.agentType,
+        transportType: this.transportType,
+        permissionRequestId: requestId
+      }
+    };
+    return new Promise((resolve2) => {
+      const timeout = setTimeout(() => {
+        this.logger.warn({ sessionId, requestId }, "Permission request timeout");
+        resolve2({ behavior: "deny", message: "Timeout" });
+      }, 6e4);
+      const onAbort = () => {
+        clearTimeout(timeout);
+        resolve2({ behavior: "deny", message: "Aborted" });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.gateway.handleEvent(this.token, envelope).then((response) => {
+        clearTimeout(timeout);
+        signal.removeEventListener("abort", onAbort);
+        const decision = response?.action === "allow" ? "allow" : "deny";
+        this.logger.info({ sessionId, requestId, toolName, decision }, "Claude remote permission resolved");
+        resolve2({
+          behavior: decision,
+          updatedInput: toolInput ?? {},
+          ...decision === "deny" ? { message: "User denied this tool call" } : {}
+        });
+      }).catch((err) => {
+        clearTimeout(timeout);
+        signal.removeEventListener("abort", onAbort);
+        this.logger.error({ error: err, sessionId, requestId }, "Claude remote permission handler error");
+        resolve2({ behavior: "deny", message: "Error" });
+      });
+    });
+  }
+  async handleInboundMessage(message) {
+    const text = message.text.trim();
+    this.logger.debug({ channel: message.channel, chatId: message.chatId, targetAgent: message.targetAgent, textPreview: text.slice(0, 80) }, "Inbound message received");
+    if (message.systemCommand) return;
+    if (message.targetAgent !== "claude") return;
+    const rawInput = this.normalizeInboundText(message);
+    if (rawInput === null) return;
+    const sessionId = `claude-${message.chatId}`;
+    const existingSession = this.gateway.getSession(sessionId);
+    if (!rawInput) {
+      this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: this.getHelpText() });
+      return;
+    }
+    const [keyword, ...rest] = rawInput.split(/\s+/);
+    const normalizedKeyword = keyword.toLowerCase();
+    const commandOnly = rest.length === 0;
+    if (normalizedKeyword === "help" && commandOnly) {
+      this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: this.getHelpText() });
+      return;
+    }
+    if (normalizedKeyword === "status" && commandOnly) {
+      const active = existingSession && existingSession.getStatus() === "active";
+      this.bus.publishOutbound({
+        channel: message.channel,
+        chatId: message.chatId,
+        text: active ? `Claude remote session is active.
+Session ID: ${sessionId}` : "No active Claude remote session for this chat."
+      });
+      return;
+    }
+    if ((normalizedKeyword === "stop" || normalizedKeyword === "reset") && commandOnly) {
+      if (!existingSession) {
+        this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: "No active session to stop." });
+        return;
+      }
+      await existingSession.sendCommand({ type: "stop" });
+      this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: "Claude session stopped." });
+      return;
+    }
+    let session = existingSession;
+    if (!session) {
+      try {
+        session = await this.gateway.createSession(this.token, sessionId, { chatId: message.chatId, channel: message.channel });
+      } catch (err) {
+        this.logger.error({ error: err, chatId: message.chatId }, "Failed to create Claude remote session");
+        this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: "Failed to start Claude session. Please check that Claude CLI is installed." });
+        return;
+      }
+    }
+    if (session.getStatus() !== "active") {
+      this.bus.publishOutbound({ channel: message.channel, chatId: message.chatId, text: "Session is not active. Please start a new session." });
+      return;
+    }
+    await session.sendCommand({ type: "user:message", content: rawInput });
+  }
+  normalizeInboundText(message) {
+    const text = message.text.trim();
+    const explicitCommand = text.match(/^\/claude(?:@[^\s]+)?(?:\s+(.*))?$/s);
+    if (explicitCommand) {
+      return explicitCommand[1]?.trim() ?? "";
+    }
+    const aliasCommand = message.agentCommand ? text.match(/^\/(status|help|stop|reset)(?:@[^\s]+)?$/i) : null;
+    if (aliasCommand) {
+      return aliasCommand[1].toLowerCase();
+    }
+    return message.agentCommand ? null : text;
+  }
+  getHelpText() {
+    return [
+      "Claude remote commands:",
+      "/claude help - show this help message",
+      "/claude status - show the current chat session state",
+      "/claude stop - stop the active session for this chat",
+      "/claude reset - stop and clear the active session",
+      "/claude <prompt> - run a task in the current chat",
+      "Any other text is sent to Claude as a prompt."
+    ].join("\n");
+  }
+};
+
 // src/adapters/agent/codex/CodexAppServerAdapter.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/adapters/agent/codex/CodexProtocolHandler.ts
 var CodexProtocolHandler = class {
@@ -4101,8 +5097,8 @@ var CodexProtocolHandler = class {
 };
 
 // src/adapters/agent/codex/codexAppServerClient.ts
-import { spawn, execFileSync } from "child_process";
-import { createInterface } from "readline";
+import { spawn as spawn2, execFileSync } from "child_process";
+import { createInterface as createInterface2 } from "readline";
 function isAppServerAvailable(command = "codex") {
   try {
     execFileSync(command, ["--version"], { encoding: "utf8", windowsHide: true });
@@ -4381,7 +5377,7 @@ var CodexAppServerClient = class _CodexAppServerClient {
     if (this.spawnCwd) {
       spawnOpts.cwd = this.spawnCwd;
     }
-    const proc = spawn(cmd, args, spawnOpts);
+    const proc = spawn2(cmd, args, spawnOpts);
     this.process = proc;
     proc.on("error", (err) => {
       this.logger?.debug("Process error:", err);
@@ -4405,7 +5401,7 @@ var CodexAppServerClient = class _CodexAppServerClient {
       const text = chunk.toString().trim();
       if (text) this.logger?.debug(`[CodexAppServer:stderr] ${text}`);
     });
-    this.readline = createInterface({ input: proc.stdout });
+    this.readline = createInterface2({ input: proc.stdout });
     this.readline.on("line", (line) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       this.handleLine(line, epoch);
@@ -5034,7 +6030,7 @@ var CodexAppServerAdapter = class {
     this.logger.info("Codex adapter shutdown complete");
   }
   async createSession(opts) {
-    const sessionId = opts.sessionId ?? `codex-${randomUUID4().slice(0, 8)}`;
+    const sessionId = opts.sessionId ?? `codex-${randomUUID5().slice(0, 8)}`;
     const chatId = opts.metadata?.chatId ?? sessionId;
     const channel = opts.metadata?.channel ?? "broadcast";
     const cwd = opts.cwd ?? this.defaultWorkDir ?? process.cwd();
@@ -5408,10 +6404,10 @@ Session ID: ${sessionId}` : "No active Codex session for this chat."
 };
 
 // src/shared/persistence.ts
-import { appendFile, mkdir, readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import { appendFile, mkdir, readdir as readdir2, readFile as readFile3 } from "fs/promises";
 import { readdirSync, statSync } from "fs";
 import { join as join4 } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 var Persistence = class {
   baseDir;
   constructor(baseDir) {
@@ -5425,7 +6421,7 @@ var Persistence = class {
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const dateDir = join4(this.baseDir, date);
     const filePath = join4(dateDir, `${agentType}-${sessionId}.jsonl`);
-    if (!existsSync5(dateDir)) {
+    if (!existsSync6(dateDir)) {
       await mkdir(dateDir, { recursive: true });
     }
     const persistedEvent = {
@@ -5448,7 +6444,7 @@ var Persistence = class {
       const fileName = files.find((f) => f.endsWith(`-${sessionId}.jsonl`));
       if (fileName) {
         const filePath = join4(dirPath, fileName);
-        const content = await readFile2(filePath, "utf-8");
+        const content = await readFile3(filePath, "utf-8");
         const lines = content.trim().split("\n").filter((line) => line.length > 0);
         for (const line of lines) {
           try {
@@ -5466,7 +6462,7 @@ var Persistence = class {
    */
   list() {
     const sessions = [];
-    if (!existsSync5(this.baseDir)) {
+    if (!existsSync6(this.baseDir)) {
       return sessions;
     }
     const entries = readdirSync(this.baseDir, { withFileTypes: true });
@@ -5710,7 +6706,8 @@ function setupRoutes(httpServer, gateway, adapter, getClientCount) {
         gateway.registerAgent("claude", token);
       }
       logger2.info({ eventType, token: token.substring(0, 8), body }, "Hook payload received");
-      const envelope = adapter.translate(eventType, body);
+      const translate = adapter.translate;
+      const envelope = typeof translate === "function" ? translate.call(adapter, eventType, body) : null;
       if (!envelope) {
         sendJson(res, 202, { accepted: true });
         return;
@@ -6251,7 +7248,7 @@ function broadcastEvent(wsServer, frame) {
 }
 
 // src/shared/credentials.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 import { join as join5, dirname as dirname4 } from "path";
 import { homedir as homedir2 } from "os";
 function getCredentialsPath() {
@@ -6259,7 +7256,7 @@ function getCredentialsPath() {
 }
 function loadCredentials() {
   const path2 = getCredentialsPath();
-  if (!existsSync6(path2)) {
+  if (!existsSync7(path2)) {
     return null;
   }
   try {
@@ -6275,7 +7272,7 @@ function getHookToken() {
 }
 
 // src/adapters/interaction/queue.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var InteractionQueue = class {
   pending = /* @__PURE__ */ new Map();
   timeoutMs;
@@ -6285,7 +7282,7 @@ var InteractionQueue = class {
     this.defaultOnTimeout = options.defaultOnTimeout ?? "deny";
   }
   request(request) {
-    const requestId = randomUUID5();
+    const requestId = randomUUID6();
     const responsePromise = new Promise((resolve2, reject) => {
       const timeoutId = setTimeout(() => {
         this.pending.delete(requestId);
@@ -8446,121 +9443,6 @@ var NotificationHandler = class {
   }
 };
 
-// src/adapters/agent/claude/session-context.ts
-import { readFile as readFile3 } from "fs/promises";
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-var ClaudeSessionContextProvider = class {
-  async getSessionSummary(_sessionId, transcriptPath) {
-    if (!transcriptPath) {
-      return void 0;
-    }
-    const summary = await this.tryReadTranscript(transcriptPath);
-    return summary;
-  }
-  async tryReadTranscript(transcriptPath, maxAttempts = 5, delayMs = 200) {
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        const content = await readFile3(transcriptPath, "utf-8");
-        const summary = this.parseTranscript(content);
-        if (summary && (summary.lastAssistantMessage !== void 0 || summary.durationMs !== void 0)) {
-          return summary;
-        }
-        if (summary) {
-          getLogger().debug({ attempt, summary }, "Transcript read but incomplete, retrying...");
-        }
-      } catch (error2) {
-        lastError = error2;
-      }
-      if (attempt < maxAttempts) {
-        await sleep(delayMs);
-      }
-    }
-    getLogger().warn({ error: lastError instanceof Error ? lastError.message : String(lastError), transcriptPath }, "Failed to read transcript or transcript incomplete");
-    return void 0;
-  }
-  parseTranscript(content) {
-    const lines = content.split("\n").filter((line) => line.trim().length > 0);
-    let lastAssistantMessage;
-    let inputTokens;
-    let outputTokens;
-    let lastTextAssistant;
-    let lastAnyAssistant;
-    const userTimestamps = /* @__PURE__ */ new Map();
-    const parentMap = /* @__PURE__ */ new Map();
-    for (const line of lines) {
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch (parseError) {
-        getLogger().warn(
-          { error: parseError instanceof Error ? parseError.message : String(parseError), line: line.slice(0, 200) },
-          "Skipping malformed transcript line"
-        );
-        continue;
-      }
-      const ts = typeof entry.timestamp === "string" ? new Date(entry.timestamp).getTime() : typeof entry.timestamp === "number" ? entry.timestamp : void 0;
-      if (entry.uuid && typeof entry.parentUuid === "string") {
-        parentMap.set(entry.uuid, entry.parentUuid);
-      }
-      if (entry.type === "user" && ts !== void 0 && entry.uuid) {
-        userTimestamps.set(entry.uuid, ts);
-      }
-      if (entry.type === "assistant" && ts !== void 0) {
-        const arr = Array.isArray(entry.message?.content) ? entry.message.content : [];
-        const textBlock = arr.find((c) => c.type === "text");
-        const assistantRef = { ts, uuid: entry.uuid, parentUuid: entry.parentUuid };
-        lastAnyAssistant = assistantRef;
-        if (textBlock && typeof textBlock.text === "string") {
-          lastAssistantMessage = textBlock.text;
-          lastTextAssistant = assistantRef;
-          const usage = entry.message?.usage;
-          if (usage) {
-            if (typeof usage.input_tokens === "number") {
-              inputTokens = usage.input_tokens;
-            }
-            if (typeof usage.output_tokens === "number") {
-              outputTokens = usage.output_tokens;
-            }
-          }
-        }
-      }
-    }
-    function resolveDuration(assistantRef) {
-      if (!assistantRef) return void 0;
-      if (assistantRef.parentUuid) {
-        const directParentTs = userTimestamps.get(assistantRef.parentUuid);
-        if (directParentTs !== void 0) {
-          return assistantRef.ts - directParentTs;
-        }
-      }
-      let currentUuid = assistantRef.uuid;
-      const visited = /* @__PURE__ */ new Set();
-      while (currentUuid && !visited.has(currentUuid)) {
-        visited.add(currentUuid);
-        const parentUuid = parentMap.get(currentUuid);
-        if (!parentUuid) break;
-        const parentTs = userTimestamps.get(parentUuid);
-        if (parentTs !== void 0) {
-          return assistantRef.ts - parentTs;
-        }
-        currentUuid = parentUuid;
-      }
-      return void 0;
-    }
-    const durationMs = resolveDuration(lastTextAssistant) ?? resolveDuration(lastAnyAssistant);
-    const summary = {
-      ...lastAssistantMessage !== void 0 && { lastAssistantMessage },
-      ...inputTokens !== void 0 && { inputTokens },
-      ...outputTokens !== void 0 && { outputTokens },
-      ...durationMs !== void 0 && { durationMs }
-    };
-    return summary;
-  }
-};
-
 // src/core/channel/base.ts
 var BaseChannel = class {
   /**
@@ -11173,7 +12055,7 @@ function readFrameId(frame) {
 }
 
 // src/adapters/channels/app/protocol.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/adapters/channels/app/query-service.ts
 var DEFAULT_CAPABILITIES = {
@@ -11329,7 +12211,7 @@ async function handleSessionCreate(frame, connection, gateway, queryService, cre
       "session.create payload.agentId must match the authenticated agent"
     );
   }
-  const sessionId = createSessionId?.() ?? randomUUID6();
+  const sessionId = createSessionId?.() ?? randomUUID7();
   const metadata = {
     channel: connection.channel,
     channelId: connection.channelId,
@@ -11389,7 +12271,7 @@ async function handleMessageSend(frame, connection, gateway, sentMessageResults,
       return ok(frame.id, outcome);
     }
   }
-  const messageId = providedMessageId ?? createMessageId?.() ?? randomUUID6();
+  const messageId = providedMessageId ?? createMessageId?.() ?? randomUUID7();
   const resultPromise = (async () => {
     await session.sendCommand({
       type: "user:message",
@@ -11679,13 +12561,27 @@ async function main() {
     }
     setupAllHandlers(bus, gateway, interactionQueue, logger5);
     logger5.info("Command and permission handlers setup complete");
-    const adapter = new ClaudeAdapter({
+    const claudeConfig = config.agent?.claude;
+    const adapter = claudeConfig?.adapter === "remote" ? new ClaudeRemoteAdapter({
+      logger: createAgentLogger("claude"),
+      bus,
+      gateway,
+      token: hookToken,
+      command: claudeConfig.binary ? [claudeConfig.binary] : void 0,
+      defaultWorkDir: claudeConfig.work_dir,
+      defaultModel: claudeConfig.model,
+      defaultPermissionMode: claudeConfig.permission_mode
+    }) : new ClaudeAdapter({
       logger: createAgentLogger("claude"),
       bus,
       gateway,
       token: hookToken
     });
-    await adapter.initialize();
+    try {
+      await adapter.initialize();
+    } catch (err) {
+      logger5.warn({ error: err instanceof Error ? err.message : String(err) }, "Claude adapter initialization failed, skipping");
+    }
     setupRoutes(httpServer, gateway, adapter, () => wsServer.getClientCount());
     setupWebSocketHandlers(wsServer, gateway, { interactionQueue });
     let appWebSocketServer;