aisnitch 0.2.17 → 0.2.18

package/dist/cli/index.cjs

@@ -41,7 +41,7 @@ var import_commander = require("commander");
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.17";
+var AISNITCH_VERSION = "0.2.18";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 
 // src/core/events/schema.ts
@@ -78,6 +78,10 @@ var TOOL_NAMES = [
   "openclaw",
   "openhands",
   "kilo",
+  "devin",
+  "kiro",
+  "augment-code",
+  "mistral",
   "unknown"
 ];
 var ERROR_TYPES = [
@@ -2459,13 +2463,13 @@ function toConfigPathOptions(options) {
 }
 
 // src/cli/runtime.ts
-var import_node_child_process12 = require("child_process");
+var import_node_child_process15 = require("child_process");
 var import_node_fs4 = require("fs");
-var import_promises15 = require("fs/promises");
+var import_promises18 = require("fs/promises");
 var import_node_net4 = require("net");
 var import_node_os5 = require("os");
-var import_node_path16 = require("path");
-var import_node_util11 = require("util");
+var import_node_path19 = require("path");
+var import_node_util14 = require("util");
 
 // src/adapters/generic-pty.ts
 var import_node_path5 = require("path");
@@ -2518,23 +2522,27 @@ var PROCESS_NAME_MAP = {
   "tmux: server": "tmux"
 };
 var TOOL_BINARY_MAP = {
-  aider: "aider",
-  amp: "amp",
-  cline: "cline",
+  "aider": "aider",
+  "amp": "amp",
+  "augment-code": "auggie",
   "claude-code": "claude",
+  "cline": "cline",
+  "codex": "codex",
+  "continue": "continue",
   "copilot-cli": "copilot",
-  codex: "codex",
-  continue: "continue",
-  cursor: "cursor",
+  "cursor": "cursor",
+  "devin": "devin",
   "gemini-cli": "gemini",
-  goose: "goose",
-  kilo: "kilo",
-  openclaw: "openclaw",
-  opencode: "opencode",
-  openhands: "openhands",
+  "goose": "goose",
+  "kilo": "kilo",
+  "kiro": "kiro",
+  "mistral": "mistral",
+  "openhands": "openhands",
+  "openclaw": "openclaw",
+  "opencode": "opencode",
   "qwen-code": "qwen",
-  unknown: "unknown",
-  windsurf: "windsurf"
+  "unknown": "unknown",
+  "windsurf": "windsurf"
 };
 var ContextDetector = class {
   cache = /* @__PURE__ */ new Map();
@@ -4053,7 +4061,7 @@ var UDSServer = class {
 };
 
 // src/core/engine/pipeline.ts
-var import_node_path13 = require("path");
+var import_node_path16 = require("path");
 var import_zod4 = require("zod");
 
 // src/adapters/aider.ts
@@ -6697,41 +6705,49 @@ function getString3(payload, key) {
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
 
-// src/adapters/gemini-cli.ts
+// src/adapters/cursor.ts
 var import_node_child_process7 = require("child_process");
 var import_promises9 = require("fs/promises");
 var import_node_path10 = require("path");
 var import_node_util7 = require("util");
 var import_chokidar5 = require("chokidar");
 var execFile7 = (0, import_node_util7.promisify)(import_node_child_process7.execFile);
-var GEMINI_CODING_TOOLS = /* @__PURE__ */ new Set([
-  "edit",
-  "replace",
-  "write",
-  "write_file"
+var CURSOR_CODING_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "CreateFile",
+  "DeleteFile",
+  "MoveFile"
 ]);
-var GeminiCLIAdapter = class extends BaseAdapter {
-  displayName = "Gemini CLI";
-  name = "gemini-cli";
+var CursorAdapter = class extends BaseAdapter {
+  displayName = "Cursor CLI";
+  name = "cursor";
   strategies = [
-    "hooks",
-    "log-watch",
-    "process-detect"
+    "process-detect",
+    "jsonl-watch"
   ];
   fallbackProcessSessionId = null;
-  logsDirectory;
-  observedLogMessageIds = /* @__PURE__ */ new Map();
-  projectRootCache = /* @__PURE__ */ new Map();
+  logDirectory;
   pollIntervalMs;
   processPoller = null;
   processListCommand;
+  transcriptOffsets = /* @__PURE__ */ new Map();
+  transcriptRemainders = /* @__PURE__ */ new Map();
   watcher = null;
   watcherFactory;
   constructor(options) {
     super(options);
-    this.logsDirectory = options.logsDirectory ?? (0, import_node_path10.join)(this.getUserHomeDirectory(), ".gemini", "tmp");
     this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
-    this.processListCommand = options.processListCommand ?? (async () => await execFile7("pgrep", ["-lf", "gemini"]).then((result) => result.stdout));
+    this.processListCommand = options.processListCommand ?? (async () => {
+      const results = await Promise.all([
+        execFile7("pgrep", ["-lf", "cursor-agent"]).catch(() => ({ stdout: "" })),
+        execFile7("pgrep", ["-lf", "cursor"]).catch(() => ({ stdout: "" }))
+      ]);
+      return results.map((r) => r.stdout).join("\n");
+    });
+    this.logDirectory = options.logDirectory ?? (0, import_node_path10.join)(this.getUserHomeDirectory(), "Library", "Application Support", "Cursor");
     this.watcherFactory = options.watcherFactory ?? import_chokidar5.watch;
   }
   async start() {
@@ -6739,22 +6755,19 @@ var GeminiCLIAdapter = class extends BaseAdapter {
       return;
     }
     this.setRunning(true);
-    await this.seedObservedLogState();
-    const logsGlob = (0, import_node_path10.join)(this.logsDirectory, "**", "logs.json");
-    this.watcher = this.watcherFactory(logsGlob, {
-      awaitWriteFinish: {
-        stabilityThreshold: 200
-      },
+    await this.seedTranscriptOffsets();
+    const logPatterns = [
+      (0, import_node_path10.join)(this.logDirectory, "logs", "**", "*.jsonl"),
+      (0, import_node_path10.join)(this.logDirectory, "agent", "**", "*.jsonl")
+    ];
+    this.watcher = this.watcherFactory(logPatterns[0], {
+      awaitWriteFinish: { stabilityThreshold: 200 },
       ignoreInitial: true
     });
-    this.watcher.on("add", (filePath) => {
-      void this.processLogsFile(filePath);
-    });
-    this.watcher.on("change", (filePath) => {
-      void this.processLogsFile(filePath);
-    });
+    this.watcher.on("add", (filePath) => void this.processTranscriptUpdate(filePath, true));
+    this.watcher.on("change", (filePath) => void this.processTranscriptUpdate(filePath, false));
     this.watcher.on("error", (error) => {
-      logger.warn({ error }, "Gemini logs watcher error");
+      logger.warn({ error }, "Cursor log watcher error");
     });
     this.startProcessPolling();
   }
@@ -6768,8 +6781,8 @@ var GeminiCLIAdapter = class extends BaseAdapter {
       this.processPoller = null;
     }
     this.fallbackProcessSessionId = null;
-    this.observedLogMessageIds.clear();
-    this.projectRootCache.clear();
+    this.transcriptOffsets.clear();
+    this.transcriptRemainders.clear();
     this.setRunning(false);
   }
   async handleHook(payload) {
@@ -6781,6 +6794,7 @@ var GeminiCLIAdapter = class extends BaseAdapter {
           activeFile: normalizedPayload.data?.activeFile,
           cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
           pid: normalizedPayload.pid,
+          project: normalizedPayload.data?.project,
           projectPath: normalizedPayload.data?.projectPath,
           sessionId: normalizedPayload.sessionId,
           tool: this.name,
@@ -6790,253 +6804,263 @@ var GeminiCLIAdapter = class extends BaseAdapter {
       return;
     }
     if (!isRecord5(payload)) {
-      logger.warn({ payload }, "Gemini hook payload must be an object");
+      logger.warn({ payload }, "Cursor hook payload must be an object");
       return;
     }
-    const hookEventName = getString4(payload, "hook_event_name") ?? getString4(payload, "hookEventName");
-    if (!hookEventName) {
-      logger.warn({ payload }, "Gemini hook payload is missing its event name");
-      return;
-    }
-    const cwd = getString4(payload, "cwd");
-    const transcriptPath = getString4(payload, "transcript_path") ?? getString4(payload, "transcriptPath");
     const sessionId = resolveSessionId({
-      activeFile: extractGeminiActiveFile(payload),
-      cwd,
-      projectPath: cwd,
-      sessionId: getString4(payload, "session_id") ?? getString4(payload, "sessionId"),
-      tool: this.name,
-      transcriptPath
+      cwd: getString4(payload, "cwd"),
+      pid: getNumber2(payload, "pid"),
+      projectPath: getString4(payload, "projectPath"),
+      sessionId: getString4(payload, "sessionId") ?? getString4(payload, "session_id"),
+      tool: this.name
     });
     const context = {
-      cwd,
+      cwd: getString4(payload, "cwd"),
+      env: this.env ?? process.env,
       hookPayload: payload,
       pid: getNumber2(payload, "pid"),
       sessionId,
-      source: "aisnitch://adapters/gemini-cli",
-      transcriptPath
+      source: "aisnitch://adapters/cursor"
     };
+    const eventType = getString4(payload, "event") ?? getString4(payload, "type");
+    const toolName = getString4(payload, "tool") ?? getString4(payload, "toolName");
+    const toolInput = extractToolInput(payload);
     const sharedData = {
-      activeFile: extractGeminiActiveFile(payload),
-      cwd,
-      errorMessage: extractGeminiErrorMessage(payload),
-      errorType: extractGeminiErrorType(payload),
-      model: extractGeminiModel(payload),
-      projectPath: cwd,
+      activeFile: toolInput?.filePath,
+      cwd: context.cwd,
+      model: getString4(payload, "model"),
+      projectPath: getString4(payload, "projectPath"),
       raw: payload,
-      tokensUsed: extractGeminiTokens(payload),
-      toolInput: extractGeminiToolInput(payload),
-      toolName: extractGeminiToolName(payload)
+      toolInput,
+      toolName
     };
-    switch (hookEventName) {
+    switch (eventType) {
+      case "session_start":
       case "SessionStart": {
-        this.fallbackProcessSessionId = null;
         await this.emitStateChange("session.start", sharedData, context);
         await this.emitStateChange("agent.idle", sharedData, context);
         return;
       }
+      case "session_end":
       case "SessionEnd": {
         await this.emitStateChange("session.end", sharedData, context);
         return;
       }
-      case "BeforeAgent": {
+      case "task_start":
+      case "TaskStart":
+      case "UserPromptSubmit": {
         await this.emitStateChange("task.start", sharedData, context);
         return;
       }
-      case "AfterAgent": {
-        if (sharedData.errorMessage) {
-          await this.emitStateChange("agent.error", sharedData, context);
-          return;
-        }
+      case "task_complete":
+      case "TaskComplete":
+      case "TaskCompleted": {
         await this.emitStateChange("task.complete", sharedData, context);
         await this.emitStateChange("agent.idle", sharedData, context);
         return;
       }
-      case "BeforeTool": {
+      case "tool_call":
+      case "PreToolUse": {
         await this.emitStateChange("agent.tool_call", sharedData, context);
         return;
       }
-      case "AfterTool": {
-        if (sharedData.errorMessage) {
-          await this.emitStateChange("agent.error", sharedData, context);
-          return;
-        }
-        const emittedType = isGeminiCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
+      case "tool_result":
+      case "PostToolUse": {
+        const emittedType = isCursorCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
         await this.emitStateChange(emittedType, sharedData, context);
         return;
       }
-      case "AfterModel": {
-        await this.emitStateChange("agent.streaming", sharedData, context);
+      case "thinking":
+      case "Thinking": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
         return;
       }
-      case "Notification": {
-        await this.emitStateChange("agent.asking_user", sharedData, context);
+      case "streaming":
+      case "Streaming":
+      case "assistant_message": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
         return;
       }
-      case "PreCompress": {
-        await this.emitStateChange("agent.compact", sharedData, context);
+      case "error":
+      case "Error": {
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString4(payload, "error") ?? getString4(payload, "message") ?? "Cursor error",
+          errorType: inferCursorErrorType(payload)
+        }, context);
         return;
       }
-      default: {
-        logger.debug({ hookEventName }, "Gemini hook event ignored by adapter");
+      case "asking_user":
+      case "PermissionRequest":
+      case "Notification": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
       }
+      default:
+        logger.debug({ eventType }, "Cursor hook event ignored by adapter");
     }
   }
-  async processLogsFile(filePath) {
+  async processTranscriptUpdate(filePath, readFromStart) {
     let fileContent;
     try {
-      fileContent = await (0, import_promises9.readFile)(filePath, "utf8");
+      fileContent = await (0, import_promises9.readFile)(filePath);
     } catch (error) {
-      logger.debug({ error, filePath }, "Gemini logs read skipped");
+      logger.debug({ error, filePath }, "Cursor transcript read skipped");
       return;
     }
-    let parsedContent;
+    const knownOffset = this.transcriptOffsets.get(filePath);
+    const previousOffset = knownOffset ?? (readFromStart ? 0 : fileContent.byteLength);
+    const safeOffset = previousOffset > fileContent.byteLength ? 0 : previousOffset;
+    const newChunk = fileContent.subarray(safeOffset).toString("utf8");
+    const bufferedChunk = (safeOffset === 0 ? "" : this.transcriptRemainders.get(filePath) ?? "") + newChunk;
+    const lines = bufferedChunk.split(/\r?\n/u);
+    const remainder = bufferedChunk.endsWith("\n") || bufferedChunk.endsWith("\r") ? "" : lines.pop() ?? "";
+    this.transcriptOffsets.set(filePath, fileContent.byteLength);
+    this.transcriptRemainders.set(filePath, remainder);
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.length === 0) {
+        continue;
+      }
+      await this.processTranscriptLine(trimmedLine, filePath);
+    }
+  }
+  async processTranscriptLine(line, transcriptPath) {
+    let parsedLine;
     try {
-      parsedContent = JSON.parse(fileContent);
+      parsedLine = JSON.parse(line);
     } catch (error) {
-      logger.warn({ error, filePath }, "Gemini logs file is not valid JSON");
+      logger.warn({ error, transcriptPath }, "Cursor transcript line is not valid JSON");
       return;
     }
-    if (!Array.isArray(parsedContent)) {
-      logger.warn({ filePath }, "Gemini logs file does not contain an array");
+    if (!isRecord5(parsedLine)) {
       return;
     }
-    const knownMessageIds = this.observedLogMessageIds.get(filePath) ?? /* @__PURE__ */ new Set();
-    this.observedLogMessageIds.set(filePath, knownMessageIds);
-    for (const entry of parsedContent) {
-      if (!isRecord5(entry)) {
-        continue;
-      }
-      const messageId = getString4(entry, "messageId") ?? getString4(entry, "message_id");
-      if (!messageId || knownMessageIds.has(messageId)) {
-        continue;
-      }
-      knownMessageIds.add(messageId);
-      await this.processLogEntry(entry, filePath);
-    }
-  }
-  async processLogEntry(entry, filePath) {
-    const messageType = getString4(entry, "type");
     const sessionId = resolveSessionId({
-      cwd: await this.readProjectRoot(filePath),
-      projectPath: await this.readProjectRoot(filePath),
-      sessionId: getString4(entry, "sessionId") ?? `${this.name}:session`,
-      tool: this.name
+      sessionId: getString4(parsedLine, "sessionId") ?? getString4(parsedLine, "session_id") ?? (0, import_node_path10.basename)(transcriptPath, ".jsonl"),
+      tool: this.name,
+      transcriptPath
     });
-    const projectPath = await this.readProjectRoot(filePath);
     const context = {
-      cwd: projectPath,
-      hookPayload: entry,
+      env: process.env,
+      hookPayload: parsedLine,
       sessionId,
-      source: "aisnitch://adapters/gemini-cli/log-watch"
+      source: "aisnitch://adapters/cursor/log",
+      transcriptPath
     };
+    const eventType = getString4(parsedLine, "type") ?? getString4(parsedLine, "event");
+    const data = getRecord3(parsedLine.data) ?? parsedLine;
+    const toolName = getString4(data, "toolName") ?? getString4(data, "tool");
+    const toolInput = extractToolInput(data);
     const sharedData = {
-      cwd: projectPath,
-      projectPath,
-      raw: entry
+      activeFile: toolInput?.filePath,
+      model: getString4(data, "model"),
+      raw: parsedLine,
+      toolInput,
+      toolName
     };
-    await this.ensureObservedSession(sessionId, sharedData, context);
-    switch (messageType) {
-      case "user": {
+    switch (eventType) {
+      case "session.start":
+      case "session_start": {
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "session.end":
+      case "session_end": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
+      }
+      case "task.start":
+      case "task_start": {
         await this.emitStateChange("task.start", sharedData, context);
         return;
       }
-      case "model":
-      case "assistant": {
-        await this.emitStateChange("agent.streaming", sharedData, context);
+      case "task.complete":
+      case "task_complete": {
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
         return;
       }
+      case "agent.thinking":
       case "thinking": {
         await this.emitStateChange("agent.thinking", sharedData, context);
         return;
       }
-      default: {
-        logger.debug({ filePath, messageType }, "Gemini log entry ignored by adapter");
+      case "agent.streaming":
+      case "streaming":
+      case "assistant.message": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
       }
+      case "agent.tool_call":
+      case "tool_use": {
+        const emittedType = isCursorCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
+        return;
+      }
+      case "agent.error":
+      case "error": {
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString4(data, "error") ?? getString4(data, "message"),
+          errorType: inferCursorErrorType(data)
+        }, context);
+        return;
+      }
+      case "agent.asking_user":
+      case "permission_required": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
+      }
+      default:
+        return;
     }
   }
-  async ensureObservedSession(sessionId, data, context) {
-    if (this.currentSessionId === sessionId) {
-      return;
-    }
-    await this.emitStateChange("session.start", data, context);
-    await this.emitStateChange("agent.idle", data, context);
-  }
-  async readProjectRoot(filePath) {
-    if (this.projectRootCache.has(filePath)) {
-      return this.projectRootCache.get(filePath);
-    }
-    const rootPath = (0, import_node_path10.join)((0, import_node_path10.dirname)(filePath), ".project_root");
+  async seedTranscriptOffsets() {
     try {
-      const projectRoot = (await (0, import_promises9.readFile)(rootPath, "utf8")).trim();
-      const normalizedRoot = projectRoot.length > 0 ? projectRoot : void 0;
-      this.projectRootCache.set(filePath, normalizedRoot);
-      return normalizedRoot;
+      const files = await collectFilesRecursively3(
+        (0, import_node_path10.join)(this.logDirectory, "logs"),
+        ".jsonl"
+      );
+      await Promise.all(
+        files.map(async (filePath) => {
+          try {
+            const fileStats = await (0, import_promises9.stat)(filePath);
+            this.transcriptOffsets.set(filePath, fileStats.size);
+          } catch {
+          }
+        })
+      );
     } catch {
-      this.projectRootCache.set(filePath, void 0);
-      return void 0;
     }
   }
-  async seedObservedLogState() {
-    const files = await collectFilesRecursively3(this.logsDirectory, "logs.json");
-    await Promise.all(
-      files.map(async (filePath) => {
-        try {
-          const fileStats = await (0, import_promises9.stat)(filePath);
-          if (!fileStats.isFile()) {
-            return;
-          }
-          const fileContent = await (0, import_promises9.readFile)(filePath, "utf8");
-          const parsedContent = JSON.parse(fileContent);
-          const messageIds = /* @__PURE__ */ new Set();
-          if (Array.isArray(parsedContent)) {
-            for (const entry of parsedContent) {
-              if (!isRecord5(entry)) {
-                continue;
-              }
-              const messageId = getString4(entry, "messageId") ?? getString4(entry, "message_id");
-              if (messageId) {
-                messageIds.add(messageId);
-              }
-            }
-          }
-          this.observedLogMessageIds.set(filePath, messageIds);
-        } catch {
-        }
-      })
-    );
-  }
   startProcessPolling() {
     if (this.pollIntervalMs <= 0) {
       return;
     }
     this.processPoller = setInterval(() => {
-      void this.pollGeminiProcesses();
+      void this.pollCursorProcesses();
     }, this.pollIntervalMs);
     this.processPoller.unref();
-    void this.pollGeminiProcesses();
+    void this.pollCursorProcesses();
   }
-  async pollGeminiProcesses() {
+  async pollCursorProcesses() {
     const processes = await listProcesses4(this.processListCommand);
     if (processes.length > 0 && this.getStatus().activeSessions === 0) {
       const processInfo = processes[0];
       if (!processInfo) {
         return;
       }
-      const sessionId = `gemini-cli-process-${processInfo.pid}`;
+      const sessionId = `cursor-process-${processInfo.pid}`;
       this.fallbackProcessSessionId = sessionId;
       await this.emitStateChange(
         "session.start",
-        {
-          raw: {
-            process: processInfo,
-            source: "process-detect"
-          }
-        },
+        { raw: { process: processInfo, source: "process-detect" } },
         {
           pid: processInfo.pid,
           sessionId,
-          source: "aisnitch://adapters/gemini-cli/process-detect"
+          source: "aisnitch://adapters/cursor/process-detect"
         }
       );
       return;
@@ -7046,32 +7070,25 @@ var GeminiCLIAdapter = class extends BaseAdapter {
       this.fallbackProcessSessionId = null;
       await this.emitStateChange(
         "session.end",
-        {
-          raw: {
-            reason: "process-exit",
-            source: "process-detect"
-          }
-        },
+        { raw: { reason: "process-exit", source: "process-detect" } },
         {
           sessionId,
-          source: "aisnitch://adapters/gemini-cli/process-detect"
+          source: "aisnitch://adapters/cursor/process-detect"
         }
       );
     }
   }
 };
-async function collectFilesRecursively3(directoryPath, fileName) {
+async function collectFilesRecursively3(directoryPath, extension) {
   try {
-    const entries = await (0, import_promises9.readdir)(directoryPath, {
-      withFileTypes: true
-    });
+    const entries = await (0, import_promises9.readdir)(directoryPath, { withFileTypes: true });
     const nestedResults = await Promise.all(
       entries.map(async (entry) => {
         const entryPath = (0, import_node_path10.join)(directoryPath, entry.name);
         if (entry.isDirectory()) {
-          return await collectFilesRecursively3(entryPath, fileName);
+          return await collectFilesRecursively3(entryPath, extension);
         }
-        return entry.name === fileName ? [entryPath] : [];
+        return entry.name.endsWith(extension) ? [entryPath] : [];
       })
     );
     return nestedResults.flat();
@@ -7082,65 +7099,33 @@ async function collectFilesRecursively3(directoryPath, fileName) {
     throw error;
   }
 }
-function extractGeminiToolName(payload) {
-  return getString4(payload, "tool_name") ?? getString4(payload, "toolName");
-}
-function extractGeminiToolInput(payload) {
-  const toolInput = getRecord3(payload.tool_input) ?? getRecord3(payload.toolInput);
-  if (!toolInput) {
+function extractToolInput(payload) {
+  if (!payload) {
     return void 0;
   }
-  const filePath = getString4(toolInput, "file_path") ?? getString4(toolInput, "filePath") ?? getString4(toolInput, "path");
+  const toolInput = getRecord3(payload.tool_input) ?? getRecord3(payload.toolInput) ?? getRecord3(payload.arguments);
+  const filePath = getString4(toolInput, "filePath") ?? getString4(toolInput, "file_path") ?? getString4(toolInput, "path");
   const command = getString4(toolInput, "command") ?? getString4(toolInput, "cmd");
   if (!filePath && !command) {
     return void 0;
   }
-  return {
-    command,
-    filePath
-  };
-}
-function extractGeminiActiveFile(payload) {
-  const toolInput = extractGeminiToolInput(payload);
-  if (toolInput?.filePath) {
-    return toolInput.filePath;
-  }
-  return getString4(payload, "active_file") ?? getString4(payload, "activeFile") ?? getString4(payload, "file_path");
+  return { command, filePath };
 }
-function extractGeminiErrorMessage(payload) {
-  const toolResponse = getRecord3(payload.tool_response) ?? getRecord3(payload.toolResponse);
-  const llmResponse = getRecord3(payload.llm_response) ?? getRecord3(payload.llmResponse);
-  return getString4(getRecord3(toolResponse?.error), "message") ?? getString4(payload, "reason") ?? getString4(payload, "message") ?? getString4(llmResponse, "error");
+function isCursorCodingTool(toolName) {
+  return toolName !== void 0 && CURSOR_CODING_TOOLS.has(toolName);
 }
-function extractGeminiErrorType(payload) {
-  const rawType = getString4(payload, "error_type") ?? getString4(payload, "errorType") ?? getString4(payload, "stopReason");
-  switch (rawType) {
-    case "rate_limit":
-      return "rate_limit";
-    case "max_output_tokens":
-    case "context_overflow":
-      return "context_overflow";
-    case "api_error":
-    case "provider_error":
-    case "invalid_request":
-      return "api_error";
-    case "tool_failure":
-      return "tool_failure";
-    default:
-      return void 0;
+function inferCursorErrorType(payload) {
+  const message = getString4(payload, "error") ?? getString4(payload, "message") ?? "";
+  if (/rate.?limit|quota|credit/i.test(message)) {
+    return "rate_limit";
   }
-}
-function extractGeminiModel(payload) {
-  return getString4(getRecord3(payload.llm_request), "model") ?? getString4(payload, "model");
-}
-function extractGeminiTokens(payload) {
-  const llmResponse = getRecord3(payload.llm_response) ?? getRecord3(payload.llmResponse);
-  const usageMetadata = getRecord3(llmResponse?.usageMetadata);
-  const totalTokens = getNumber2(usageMetadata, "totalTokenCount") ?? getNumber2(usageMetadata, "total_tokens");
-  return totalTokens;
-}
-function isGeminiCodingTool(toolName) {
-  return toolName !== void 0 && GEMINI_CODING_TOOLS.has(toolName);
+  if (/context|token.?limit|too.?long/i.test(message)) {
+    return "context_overflow";
+  }
+  if (/tool|permission|denied/i.test(message)) {
+    return "tool_failure";
+  }
+  return "api_error";
 }
 async function listProcesses4(listCommand) {
   if (process.platform === "win32") {
@@ -7148,13 +7133,9 @@ async function listProcesses4(listCommand) {
   }
   try {
     const stdout = await listCommand();
-    return stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map(parseProcessLine3).filter((processInfo) => processInfo !== null);
+    return stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0 && line.includes("cursor")).map(parseProcessLine3).filter((processInfo) => processInfo !== null);
   } catch (error) {
-    const errorCode = isErrnoException4(error) ? String(error.code) : "";
-    if (isErrnoException4(error) && (errorCode === "ENOENT" || errorCode === "1")) {
-      return [];
-    }
-    logger.debug({ error }, "Gemini process detection failed");
+    logger.debug({ error }, "Cursor process detection failed");
     return [];
   }
 }
@@ -7183,9 +7164,6 @@ function getRecord3(value) {
   return isRecord5(value) ? value : void 0;
 }
 function getNumber2(payload, key) {
-  if (!payload) {
-    return void 0;
-  }
   const value = payload[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -7197,70 +7175,54 @@ function getString4(payload, key) {
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
 
-// src/adapters/goose.ts
+// src/adapters/devin.ts
 var import_node_child_process8 = require("child_process");
 var import_promises10 = require("fs/promises");
 var import_node_path11 = require("path");
 var import_node_util8 = require("util");
 var import_chokidar6 = require("chokidar");
 var execFile8 = (0, import_node_util8.promisify)(import_node_child_process8.execFile);
-var DEFAULT_GOOSED_BASE_URL = "http://127.0.0.1:8080";
-var DEFAULT_SQLITE_QUERY = [
-  "SELECT",
-  "  id,",
-  "  name,",
-  "  working_dir,",
-  "  updated_at,",
-  "  message_count,",
-  "  provider_name,",
-  "  accumulated_total_tokens,",
-  "  total_tokens,",
-  "  model_config",
-  "FROM sessions",
-  "ORDER BY updated_at DESC",
-  "LIMIT 24;"
-].join("\n");
-var MAX_STREAMED_SESSIONS = 6;
-var GOOSE_CODING_TOOL_HINT = /apply|create|delete|edit|move|patch|rename|replace|write/iu;
-var GOOSE_RATE_LIMIT_HINT = /credit|quota|rate limit|exhausted/iu;
-var GooseAdapter = class extends BaseAdapter {
-  displayName = "Goose";
-  name = "goose";
+var DEVIN_CODING_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "Create",
+  "Delete",
+  "Move",
+  "Read",
+  "Grep",
+  "Bash",
+  "WebSearch"
+]);
+var DevinAdapter = class extends BaseAdapter {
+  displayName = "Devin CLI";
+  name = "devin";
   strategies = [
-    "api-client",
-    "sqlite-watch",
-    "process-detect"
+    "process-detect",
+    "hooks",
+    "jsonl-watch"
   ];
-  apiPoller = null;
-  apiBaseUrl;
-  apiKey;
-  databasePath;
-  databaseWatcher = null;
   fallbackProcessSessionId = null;
-  fetchImplementation;
-  apiDiscoverySeeded = false;
-  observedSessions = /* @__PURE__ */ new Set();
   pollIntervalMs;
   processPoller = null;
   processListCommand;
-  sessionEventFingerprints = /* @__PURE__ */ new Map();
-  sessionSnapshots = /* @__PURE__ */ new Map();
-  sessionStreams = /* @__PURE__ */ new Map();
-  sqliteQueryCommand;
+  sessionDirectory;
+  sessionMetadata = /* @__PURE__ */ new Map();
+  transcriptOffsets = /* @__PURE__ */ new Map();
+  transcriptRemainders = /* @__PURE__ */ new Map();
+  watcher = null;
   watcherFactory;
   constructor(options) {
     super(options);
-    this.apiBaseUrl = options.apiBaseUrl ?? options.env?.AISNITCH_GOOSE_API_BASE_URL ?? DEFAULT_GOOSED_BASE_URL;
-    this.apiKey = options.apiKey ?? options.env?.AISNITCH_GOOSE_API_KEY ?? options.env?.GOOSE_API_KEY;
-    this.databasePath = options.databasePath ?? (0, import_node_path11.join)(this.getUserHomeDirectory(), ".config", "goose", "sessions.db");
-    this.fetchImplementation = options.fetchImplementation ?? fetch;
     this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
-    this.processListCommand = options.processListCommand ?? (async () => await execFile8("pgrep", ["-lf", "goose|goosed"]).then(
-      (result) => result.stdout
-    ));
-    this.sqliteQueryCommand = options.sqliteQueryCommand ?? (async (databasePath, query) => await execFile8("sqlite3", ["-json", databasePath, query]).then(
-      (result) => result.stdout
-    ));
+    this.processListCommand = options.processListCommand ?? (async () => {
+      const results = await Promise.all([
+        execFile8("pgrep", ["-lf", "devin"]).catch(() => ({ stdout: "" })),
+        execFile8("pgrep", ["-lf", "cognition"]).catch(() => ({ stdout: "" }))
+      ]);
+      return results.map((r) => r.stdout).join("\n");
+    });
+    this.sessionDirectory = options.sessionDirectory ?? (0, import_node_path11.join)(this.getUserHomeDirectory(), ".devin");
     this.watcherFactory = options.watcherFactory ?? import_chokidar6.watch;
   }
   async start() {
@@ -7268,598 +7230,2204 @@ var GooseAdapter = class extends BaseAdapter {
       return;
     }
     this.setRunning(true);
-    await this.seedSqliteSessions();
-    this.databaseWatcher = this.watcherFactory(this.databasePath, {
-      awaitWriteFinish: {
-        stabilityThreshold: 200
-      },
-      ignoreInitial: true
-    });
-    this.databaseWatcher.on("add", () => {
-      void this.pollSqliteSessions(true);
-    });
-    this.databaseWatcher.on("change", () => {
-      void this.pollSqliteSessions(true);
-    });
-    this.databaseWatcher.on("error", (error) => {
-      logger.warn({ error }, "Goose SQLite watcher error");
+    await this.seedTranscriptOffsets();
+    this.watcher = this.watcherFactory(
+      (0, import_node_path11.join)(this.sessionDirectory, "**", "*.jsonl"),
+      {
+        awaitWriteFinish: { stabilityThreshold: 200 },
+        ignoreInitial: true
+      }
+    );
+    this.watcher.on("add", (filePath) => void this.processTranscriptUpdate(filePath, true));
+    this.watcher.on("change", (filePath) => void this.processTranscriptUpdate(filePath, false));
+    this.watcher.on("error", (error) => {
+      logger.warn({ error }, "Devin log watcher error");
     });
-    this.startApiPolling();
     this.startProcessPolling();
   }
   async stop() {
-    if (this.databaseWatcher !== null) {
-      await this.databaseWatcher.close();
-      this.databaseWatcher = null;
-    }
-    if (this.apiPoller !== null) {
-      clearInterval(this.apiPoller);
-      this.apiPoller = null;
+    if (this.watcher !== null) {
+      await this.watcher.close();
+      this.watcher = null;
     }
     if (this.processPoller !== null) {
       clearInterval(this.processPoller);
       this.processPoller = null;
     }
-    for (const streamHandle of this.sessionStreams.values()) {
-      streamHandle.abortController.abort();
-      void streamHandle.promise.catch(() => void 0);
-    }
-    this.apiDiscoverySeeded = false;
     this.fallbackProcessSessionId = null;
-    this.observedSessions.clear();
-    this.sessionEventFingerprints.clear();
-    this.sessionSnapshots.clear();
-    this.sessionStreams.clear();
+    this.sessionMetadata.clear();
+    this.transcriptOffsets.clear();
+    this.transcriptRemainders.clear();
     this.setRunning(false);
   }
   async handleHook(payload) {
     const normalizedPayload = this.parseNormalizedHookPayload(payload);
-    if (normalizedPayload === null) {
-      logger.debug({ payload }, "Goose ignores non-normalized hook payloads");
+    if (normalizedPayload !== null) {
+      await this.emitNormalizedPayload({
+        ...normalizedPayload,
+        sessionId: resolveSessionId({
+          activeFile: normalizedPayload.data?.activeFile,
+          cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
+          pid: normalizedPayload.pid,
+          project: normalizedPayload.data?.project,
+          projectPath: normalizedPayload.data?.projectPath,
+          sessionId: normalizedPayload.sessionId,
+          tool: this.name,
+          transcriptPath: normalizedPayload.transcriptPath
+        })
+      });
       return;
     }
-    await this.emitNormalizedPayload({
-      ...normalizedPayload,
-      sessionId: resolveSessionId({
-        activeFile: normalizedPayload.data?.activeFile,
-        cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
-        pid: normalizedPayload.pid,
-        projectPath: normalizedPayload.data?.projectPath,
-        sessionId: normalizedPayload.sessionId,
-        tool: this.name,
-        transcriptPath: normalizedPayload.transcriptPath
-      })
-    });
-  }
-  startApiPolling() {
-    if (this.pollIntervalMs <= 0) {
+    if (!isRecord6(payload)) {
+      logger.warn({ payload }, "Devin hook payload must be an object");
       return;
     }
-    this.apiPoller = setInterval(() => {
-      void this.pollGooseApi(true);
-    }, this.pollIntervalMs);
-    this.apiPoller.unref();
-    void this.pollGooseApi(false);
+    const sessionId = resolveSessionId({
+      cwd: getString5(payload, "cwd"),
+      pid: getNumber3(payload, "pid"),
+      projectPath: getString5(payload, "projectPath"),
+      sessionId: getString5(payload, "sessionId") ?? getString5(payload, "session_id") ?? getString5(payload, "id") ?? getString5(getRecord4(payload.data), "sessionId"),
+      tool: this.name
+    });
+    const context = {
+      cwd: getString5(payload, "cwd"),
+      env: this.env ?? process.env,
+      hookPayload: payload,
+      pid: getNumber3(payload, "pid"),
+      sessionId,
+      source: "aisnitch://adapters/devin"
+    };
+    const eventType = getString5(payload, "event") ?? getString5(payload, "type") ?? getString5(payload, "action");
+    const data = getRecord4(payload.data) ?? payload;
+    const toolName = getString5(data, "tool") ?? getString5(data, "toolName") ?? getString5(data, "name");
+    const toolInput = extractToolInput2(data);
+    const sharedData = {
+      activeFile: toolInput?.filePath,
+      cwd: context.cwd,
+      model: getString5(data, "model") ?? getString5(payload, "model"),
+      projectPath: getString5(data, "projectPath") ?? getString5(payload, "projectPath"),
+      raw: payload,
+      toolInput,
+      toolName
+    };
+    switch (eventType) {
+      case "session.start":
+      case "sessionStart":
+      case "SessionStart": {
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "session.end":
+      case "sessionEnd":
+      case "SessionEnd": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
+      }
+      case "task.start":
+      case "taskStart":
+      case "task_create":
+      case "TaskCreate": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "task.complete":
+      case "taskComplete":
+      case "TaskComplete":
+      case "task_done": {
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "tool.call":
+      case "toolCall":
+      case "ToolCall": {
+        await this.emitStateChange("agent.tool_call", sharedData, context);
+        return;
+      }
+      case "tool.result":
+      case "toolResult":
+      case "ToolResult": {
+        const emittedType = isDevinCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
+        return;
+      }
+      case "thinking":
+      case "Thinking":
+      case "reasoning": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
+        return;
+      }
+      case "output":
+      case "streaming":
+      case "Output": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "error":
+      case "Error":
+      case "ErrorOccurred": {
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString5(data, "error") ?? getString5(payload, "error") ?? "Devin error",
+          errorType: inferDevinErrorType(data)
+        }, context);
+        return;
+      }
+      case "asking_user":
+      case "PermissionRequest":
+      case "user_input_required":
+      case "InputRequired": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
+      }
+      default:
+        logger.debug({ eventType }, "Devin hook event ignored by adapter");
+    }
   }
-  startProcessPolling() {
-    if (this.pollIntervalMs <= 0) {
+  async processTranscriptUpdate(filePath, readFromStart) {
+    let fileContent;
+    try {
+      fileContent = await (0, import_promises10.readFile)(filePath);
+    } catch (error) {
+      logger.debug({ error, filePath }, "Devin transcript read skipped");
       return;
     }
-    this.processPoller = setInterval(() => {
-      void this.pollGooseProcesses();
-    }, this.pollIntervalMs);
-    this.processPoller.unref();
-    void this.pollGooseProcesses();
-  }
-  async seedSqliteSessions() {
-    try {
-      await (0, import_promises10.stat)(this.databasePath);
-    } catch {
-      return;
+    const knownOffset = this.transcriptOffsets.get(filePath);
+    const previousOffset = knownOffset ?? (readFromStart ? 0 : fileContent.byteLength);
+    const safeOffset = previousOffset > fileContent.byteLength ? 0 : previousOffset;
+    const newChunk = fileContent.subarray(safeOffset).toString("utf8");
+    const bufferedChunk = (safeOffset === 0 ? "" : this.transcriptRemainders.get(filePath) ?? "") + newChunk;
+    const lines = bufferedChunk.split(/\r?\n/u);
+    const remainder = bufferedChunk.endsWith("\n") || bufferedChunk.endsWith("\r") ? "" : lines.pop() ?? "";
+    this.transcriptOffsets.set(filePath, fileContent.byteLength);
+    this.transcriptRemainders.set(filePath, remainder);
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.length === 0) {
+        continue;
+      }
+      await this.processTranscriptLine(trimmedLine, filePath);
     }
-    const sessions = await this.readSqliteSessions();
-    this.syncSessionSnapshots(sessions, false, "sqlite-seed");
-  }
-  async pollSqliteSessions(emitChanges) {
-    const sessions = await this.readSqliteSessions();
-    this.syncSessionSnapshots(sessions, emitChanges, "sqlite");
   }
-  async readSqliteSessions() {
-    let rawOutput;
+  async processTranscriptLine(line, transcriptPath) {
+    let parsedLine;
     try {
-      rawOutput = await this.sqliteQueryCommand(
-        this.databasePath,
-        DEFAULT_SQLITE_QUERY
-      );
+      parsedLine = JSON.parse(line);
     } catch (error) {
-      logger.debug({ error }, "Goose SQLite session query skipped");
-      return [];
+      logger.warn({ error, transcriptPath }, "Devin transcript line is not valid JSON");
+      return;
     }
-    let parsedOutput;
-    try {
-      parsedOutput = JSON.parse(rawOutput);
-    } catch (error) {
-      logger.warn({ error }, "Goose SQLite JSON output is invalid");
-      return [];
+    if (!isRecord6(parsedLine)) {
+      return;
     }
-    if (!Array.isArray(parsedOutput)) {
-      return [];
+    const eventType = getString5(parsedLine, "type") ?? getString5(parsedLine, "event");
+    const sessionId = resolveSessionId({
+      sessionId: getString5(parsedLine, "sessionId") ?? getString5(parsedLine, "session_id") ?? getString5(parsedLine, "id") ?? (0, import_node_path11.basename)(transcriptPath, ".jsonl"),
+      tool: this.name,
+      transcriptPath
+    });
+    const context = {
+      env: process.env,
+      hookPayload: parsedLine,
+      sessionId,
+      source: "aisnitch://adapters/devin/log",
+      transcriptPath
+    };
+    const data = getRecord4(parsedLine.data) ?? parsedLine;
+    const toolName = getString5(data, "tool") ?? getString5(data, "toolName");
+    const toolInput = extractToolInput2(data);
+    const sharedData = {
+      activeFile: toolInput?.filePath,
+      cwd: getString5(data, "cwd"),
+      model: getString5(data, "model"),
+      raw: parsedLine,
+      toolInput,
+      toolName
+    };
+    switch (eventType) {
+      case "session.start":
+      case "SessionStart": {
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "session.end":
+      case "SessionEnd": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
+      }
+      case "task.start":
+      case "TaskStart": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "task.complete":
+      case "TaskComplete": {
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "thinking":
+      case "Thinking": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
+        return;
+      }
+      case "output":
+      case "assistant_message": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "tool_use":
+      case "ToolUse": {
+        const emittedType = isDevinCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
+        return;
+      }
+      case "error":
+      case "Error": {
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString5(data, "error") ?? getString5(data, "message"),
+          errorType: inferDevinErrorType(data)
+        }, context);
+        return;
+      }
+      case "permission_request":
+      case "asking_user": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
+      }
+      default:
+        return;
     }
-    return parsedOutput.map((entry) => normalizeGooseSession(entry)).filter((entry) => entry !== null);
   }
-  async pollGooseApi(emitChanges) {
-    let statusResponse;
+  async seedTranscriptOffsets() {
     try {
-      statusResponse = await this.fetchImplementation(
-        new URL("/status", this.apiBaseUrl)
+      const files = await collectFilesRecursively4(this.sessionDirectory, ".jsonl");
+      await Promise.all(
+        files.map(async (filePath) => {
+          try {
+            const fileStats = await (0, import_promises10.stat)(filePath);
+            this.transcriptOffsets.set(filePath, fileStats.size);
+          } catch {
+          }
+        })
       );
-    } catch (error) {
-      logger.debug({ error }, "Goosed status endpoint is unavailable");
-      return;
+    } catch {
     }
-    if (!statusResponse.ok) {
+  }
+  startProcessPolling() {
+    if (this.pollIntervalMs <= 0) {
       return;
     }
-    let sessionsResponse;
-    try {
-      sessionsResponse = await this.fetchImplementation(
-        new URL("/sessions", this.apiBaseUrl),
+    this.processPoller = setInterval(() => {
+      void this.pollDevinProcesses();
+    }, this.pollIntervalMs);
+    this.processPoller.unref();
+    void this.pollDevinProcesses();
+  }
+  async pollDevinProcesses() {
+    const processes = await listProcesses5(this.processListCommand);
+    if (processes.length > 0 && this.getStatus().activeSessions === 0) {
+      const processInfo = processes[0];
+      if (!processInfo) {
+        return;
+      }
+      const sessionId = `devin-process-${processInfo.pid}`;
+      this.fallbackProcessSessionId = sessionId;
+      await this.emitStateChange(
+        "session.start",
+        { raw: { process: processInfo, source: "process-detect" } },
         {
-          headers: this.createApiHeaders()
+          pid: processInfo.pid,
+          sessionId,
+          source: "aisnitch://adapters/devin/process-detect"
         }
       );
-    } catch (error) {
-      logger.debug({ error }, "Goosed sessions endpoint request failed");
       return;
     }
-    if (!sessionsResponse.ok) {
-      logger.debug(
-        { status: sessionsResponse.status },
-        "Goosed sessions endpoint rejected the request"
+    if (processes.length === 0 && this.fallbackProcessSessionId !== null) {
+      const sessionId = this.fallbackProcessSessionId;
+      this.fallbackProcessSessionId = null;
+      await this.emitStateChange(
+        "session.end",
+        { raw: { reason: "process-exit", source: "process-detect" } },
+        {
+          sessionId,
+          source: "aisnitch://adapters/devin/process-detect"
+        }
       );
-      return;
-    }
-    let parsedPayload;
-    try {
-      parsedPayload = await sessionsResponse.json();
-    } catch (error) {
-      logger.warn({ error }, "Goosed sessions payload is not valid JSON");
-      return;
-    }
-    const responsePayload = parsedPayload;
-    const rawSessions = Array.isArray(responsePayload.sessions) ? responsePayload.sessions : [];
-    const sessions = rawSessions.map((entry) => normalizeGooseSession(entry)).filter((entry) => entry !== null);
-    this.syncSessionSnapshots(
-      sessions,
-      emitChanges && this.apiDiscoverySeeded,
-      "api"
-    );
-    this.apiDiscoverySeeded = true;
-  }
-  syncSessionSnapshots(nextSnapshots, emitChanges, source) {
-    for (const snapshot of nextSnapshots) {
-      const previousSnapshot = this.sessionSnapshots.get(snapshot.sessionId);
-      this.sessionSnapshots.set(snapshot.sessionId, snapshot);
-      this.ensureTrackedSessionStream(snapshot);
-      if (!emitChanges) {
-        continue;
-      }
-      if (previousSnapshot === void 0) {
-        void this.ensureObservedSession(snapshot, source);
-        continue;
-      }
-      if (!didGooseSessionAdvance(previousSnapshot, snapshot)) {
-        continue;
-      }
-      void this.ensureObservedSession(snapshot, source).then(async () => {
-        await this.emitStateChange(
-          "agent.streaming",
-          buildGooseSessionData(snapshot, {
-            raw: {
-              snapshot,
-              source
-            }
-          }),
-          this.createSessionContext(snapshot, `aisnitch://adapters/goose/${source}`)
-        );
-      });
     }
-    this.trimTrackedSessionStreams(nextSnapshots);
   }
-  ensureTrackedSessionStream(snapshot) {
-    if (this.sessionStreams.has(snapshot.sessionId)) {
-      return;
-    }
-    const abortController = new AbortController();
-    const streamPromise = this.consumeSessionEvents(snapshot, abortController).finally(
-      () => {
-        const activeStream = this.sessionStreams.get(snapshot.sessionId);
-        if (activeStream?.abortController === abortController) {
-          this.sessionStreams.delete(snapshot.sessionId);
+};
+async function collectFilesRecursively4(directoryPath, extension) {
+  try {
+    const entries = await (0, import_promises10.readdir)(directoryPath, { withFileTypes: true });
+    const nestedResults = await Promise.all(
+      entries.map(async (entry) => {
+        const entryPath = (0, import_node_path11.join)(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+          return await collectFilesRecursively4(entryPath, extension);
         }
-      }
-    );
-    this.sessionStreams.set(snapshot.sessionId, {
-      abortController,
-      promise: streamPromise
-    });
-  }
-  trimTrackedSessionStreams(nextSnapshots) {
-    const keepSessionIds = new Set(
-      [...nextSnapshots].sort(compareGooseSessionsByRecency).slice(0, MAX_STREAMED_SESSIONS).map((snapshot) => snapshot.sessionId)
+        return entry.name.endsWith(extension) ? [entryPath] : [];
+      })
     );
-    for (const [sessionId, streamHandle] of this.sessionStreams) {
-      if (keepSessionIds.has(sessionId)) {
-        continue;
-      }
-      streamHandle.abortController.abort();
-      this.sessionStreams.delete(sessionId);
+    return nestedResults.flat();
+  } catch (error) {
+    if (isErrnoException5(error) && error.code === "ENOENT") {
+      return [];
     }
+    throw error;
   }
-  async consumeSessionEvents(snapshot, abortController) {
-    let response;
-    try {
-      response = await this.fetchImplementation(
-        new URL(
-          `/sessions/${encodeURIComponent(snapshot.gooseSessionId)}/events`,
-          this.apiBaseUrl
-        ),
-        {
-          headers: {
-            ...this.createApiHeaders(),
-            Accept: "text/event-stream"
-          },
-          signal: abortController.signal
-        }
-      );
-    } catch (error) {
-      if (abortController.signal.aborted) {
-        return;
-      }
+}
+function extractToolInput2(payload) {
+  if (!payload) {
+    return void 0;
+  }
+  const toolInput = getRecord4(payload.tool_input) ?? getRecord4(payload.toolInput) ?? getRecord4(payload.arguments) ?? getRecord4(payload.params);
+  const filePath = getString5(toolInput, "filePath") ?? getString5(toolInput, "file_path") ?? getString5(toolInput, "path") ?? getString5(toolInput, "target");
+  const command = getString5(toolInput, "command") ?? getString5(toolInput, "cmd") ?? getString5(toolInput, "script");
+  if (!filePath && !command) {
+    return void 0;
+  }
+  return { command, filePath };
+}
+function isDevinCodingTool(toolName) {
+  return toolName !== void 0 && DEVIN_CODING_TOOLS.has(toolName);
+}
+function inferDevinErrorType(payload) {
+  const message = getString5(payload, "error") ?? getString5(payload, "message") ?? "";
+  if (/rate.?limit|quota|credit|api.?key/i.test(message)) {
+    return "rate_limit";
+  }
+  if (/context|token.?limit|too.?long|exceeded/i.test(message)) {
+    return "context_overflow";
+  }
+  if (/tool|permission|denied|access/i.test(message)) {
+    return "tool_failure";
+  }
+  return "api_error";
+}
+async function listProcesses5(listCommand) {
+  if (process.platform === "win32") {
+    return [];
+  }
+  try {
+    const stdout = await listCommand();
+    return stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).filter(
+      (line) => line.includes("devin") || line.includes("cognition") || line.includes("swe")
+    ).map(parseProcessLine4).filter((processInfo) => processInfo !== null);
+  } catch (error) {
+    logger.debug({ error }, "Devin process detection failed");
+    return [];
+  }
+}
+function parseProcessLine4(line) {
+  const match = line.match(/^(\d+)\s+(.+)$/u);
+  if (!match) {
+    return null;
+  }
+  const pidText = match[1];
+  const command = match[2];
+  if (!pidText || !command) {
+    return null;
+  }
+  return {
+    command,
+    pid: Number.parseInt(pidText, 10)
+  };
+}
+function isErrnoException5(error) {
+  return error instanceof Error && "code" in error;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRecord4(value) {
+  return isRecord6(value) ? value : void 0;
+}
+function getNumber3(payload, key) {
+  const value = payload[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getString5(payload, key) {
+  if (!payload) {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+
+// src/adapters/gemini-cli.ts
+var import_node_child_process9 = require("child_process");
+var import_promises11 = require("fs/promises");
+var import_node_path12 = require("path");
+var import_node_util9 = require("util");
+var import_chokidar7 = require("chokidar");
+var execFile9 = (0, import_node_util9.promisify)(import_node_child_process9.execFile);
+var GEMINI_CODING_TOOLS = /* @__PURE__ */ new Set([
+  "edit",
+  "replace",
+  "write",
+  "write_file"
+]);
+var GeminiCLIAdapter = class extends BaseAdapter {
+  displayName = "Gemini CLI";
+  name = "gemini-cli";
+  strategies = [
+    "hooks",
+    "log-watch",
+    "process-detect"
+  ];
+  fallbackProcessSessionId = null;
+  logsDirectory;
+  observedLogMessageIds = /* @__PURE__ */ new Map();
+  projectRootCache = /* @__PURE__ */ new Map();
+  pollIntervalMs;
+  processPoller = null;
+  processListCommand;
+  watcher = null;
+  watcherFactory;
+  constructor(options) {
+    super(options);
+    this.logsDirectory = options.logsDirectory ?? (0, import_node_path12.join)(this.getUserHomeDirectory(), ".gemini", "tmp");
+    this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
+    this.processListCommand = options.processListCommand ?? (async () => await execFile9("pgrep", ["-lf", "gemini"]).then((result) => result.stdout));
+    this.watcherFactory = options.watcherFactory ?? import_chokidar7.watch;
+  }
+  async start() {
+    if (this.getStatus().running) {
+      return;
+    }
+    this.setRunning(true);
+    await this.seedObservedLogState();
+    const logsGlob = (0, import_node_path12.join)(this.logsDirectory, "**", "logs.json");
+    this.watcher = this.watcherFactory(logsGlob, {
+      awaitWriteFinish: {
+        stabilityThreshold: 200
+      },
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (filePath) => {
+      void this.processLogsFile(filePath);
+    });
+    this.watcher.on("change", (filePath) => {
+      void this.processLogsFile(filePath);
+    });
+    this.watcher.on("error", (error) => {
+      logger.warn({ error }, "Gemini logs watcher error");
+    });
+    this.startProcessPolling();
+  }
+  async stop() {
+    if (this.watcher !== null) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.processPoller !== null) {
+      clearInterval(this.processPoller);
+      this.processPoller = null;
+    }
+    this.fallbackProcessSessionId = null;
+    this.observedLogMessageIds.clear();
+    this.projectRootCache.clear();
+    this.setRunning(false);
+  }
+  async handleHook(payload) {
+    const normalizedPayload = this.parseNormalizedHookPayload(payload);
+    if (normalizedPayload !== null) {
+      await this.emitNormalizedPayload({
+        ...normalizedPayload,
+        sessionId: resolveSessionId({
+          activeFile: normalizedPayload.data?.activeFile,
+          cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
+          pid: normalizedPayload.pid,
+          projectPath: normalizedPayload.data?.projectPath,
+          sessionId: normalizedPayload.sessionId,
+          tool: this.name,
+          transcriptPath: normalizedPayload.transcriptPath
+        })
+      });
+      return;
+    }
+    if (!isRecord7(payload)) {
+      logger.warn({ payload }, "Gemini hook payload must be an object");
+      return;
+    }
+    const hookEventName = getString6(payload, "hook_event_name") ?? getString6(payload, "hookEventName");
+    if (!hookEventName) {
+      logger.warn({ payload }, "Gemini hook payload is missing its event name");
+      return;
+    }
+    const cwd = getString6(payload, "cwd");
+    const transcriptPath = getString6(payload, "transcript_path") ?? getString6(payload, "transcriptPath");
+    const sessionId = resolveSessionId({
+      activeFile: extractGeminiActiveFile(payload),
+      cwd,
+      projectPath: cwd,
+      sessionId: getString6(payload, "session_id") ?? getString6(payload, "sessionId"),
+      tool: this.name,
+      transcriptPath
+    });
+    const context = {
+      cwd,
+      hookPayload: payload,
+      pid: getNumber4(payload, "pid"),
+      sessionId,
+      source: "aisnitch://adapters/gemini-cli",
+      transcriptPath
+    };
+    const sharedData = {
+      activeFile: extractGeminiActiveFile(payload),
+      cwd,
+      errorMessage: extractGeminiErrorMessage(payload),
+      errorType: extractGeminiErrorType(payload),
+      model: extractGeminiModel(payload),
+      projectPath: cwd,
+      raw: payload,
+      tokensUsed: extractGeminiTokens(payload),
+      toolInput: extractGeminiToolInput(payload),
+      toolName: extractGeminiToolName(payload)
+    };
+    switch (hookEventName) {
+      case "SessionStart": {
+        this.fallbackProcessSessionId = null;
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "SessionEnd": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
+      }
+      case "BeforeAgent": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "AfterAgent": {
+        if (sharedData.errorMessage) {
+          await this.emitStateChange("agent.error", sharedData, context);
+          return;
+        }
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "BeforeTool": {
+        await this.emitStateChange("agent.tool_call", sharedData, context);
+        return;
+      }
+      case "AfterTool": {
+        if (sharedData.errorMessage) {
+          await this.emitStateChange("agent.error", sharedData, context);
+          return;
+        }
+        const emittedType = isGeminiCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
+        return;
+      }
+      case "AfterModel": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "Notification": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
+      }
+      case "PreCompress": {
+        await this.emitStateChange("agent.compact", sharedData, context);
+        return;
+      }
+      default: {
+        logger.debug({ hookEventName }, "Gemini hook event ignored by adapter");
+      }
+    }
+  }
+  async processLogsFile(filePath) {
+    let fileContent;
+    try {
+      fileContent = await (0, import_promises11.readFile)(filePath, "utf8");
+    } catch (error) {
+      logger.debug({ error, filePath }, "Gemini logs read skipped");
+      return;
+    }
+    let parsedContent;
+    try {
+      parsedContent = JSON.parse(fileContent);
+    } catch (error) {
+      logger.warn({ error, filePath }, "Gemini logs file is not valid JSON");
+      return;
+    }
+    if (!Array.isArray(parsedContent)) {
+      logger.warn({ filePath }, "Gemini logs file does not contain an array");
+      return;
+    }
+    const knownMessageIds = this.observedLogMessageIds.get(filePath) ?? /* @__PURE__ */ new Set();
+    this.observedLogMessageIds.set(filePath, knownMessageIds);
+    for (const entry of parsedContent) {
+      if (!isRecord7(entry)) {
+        continue;
+      }
+      const messageId = getString6(entry, "messageId") ?? getString6(entry, "message_id");
+      if (!messageId || knownMessageIds.has(messageId)) {
+        continue;
+      }
+      knownMessageIds.add(messageId);
+      await this.processLogEntry(entry, filePath);
+    }
+  }
+  async processLogEntry(entry, filePath) {
+    const messageType = getString6(entry, "type");
+    const sessionId = resolveSessionId({
+      cwd: await this.readProjectRoot(filePath),
+      projectPath: await this.readProjectRoot(filePath),
+      sessionId: getString6(entry, "sessionId") ?? `${this.name}:session`,
+      tool: this.name
+    });
+    const projectPath = await this.readProjectRoot(filePath);
+    const context = {
+      cwd: projectPath,
+      hookPayload: entry,
+      sessionId,
+      source: "aisnitch://adapters/gemini-cli/log-watch"
+    };
+    const sharedData = {
+      cwd: projectPath,
+      projectPath,
+      raw: entry
+    };
+    await this.ensureObservedSession(sessionId, sharedData, context);
+    switch (messageType) {
+      case "user": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "model":
+      case "assistant": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "thinking": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
+        return;
+      }
+      default: {
+        logger.debug({ filePath, messageType }, "Gemini log entry ignored by adapter");
+      }
+    }
+  }
+  async ensureObservedSession(sessionId, data, context) {
+    if (this.currentSessionId === sessionId) {
+      return;
+    }
+    await this.emitStateChange("session.start", data, context);
+    await this.emitStateChange("agent.idle", data, context);
+  }
+  async readProjectRoot(filePath) {
+    if (this.projectRootCache.has(filePath)) {
+      return this.projectRootCache.get(filePath);
+    }
+    const rootPath = (0, import_node_path12.join)((0, import_node_path12.dirname)(filePath), ".project_root");
+    try {
+      const projectRoot = (await (0, import_promises11.readFile)(rootPath, "utf8")).trim();
+      const normalizedRoot = projectRoot.length > 0 ? projectRoot : void 0;
+      this.projectRootCache.set(filePath, normalizedRoot);
+      return normalizedRoot;
+    } catch {
+      this.projectRootCache.set(filePath, void 0);
+      return void 0;
+    }
+  }
+  async seedObservedLogState() {
+    const files = await collectFilesRecursively5(this.logsDirectory, "logs.json");
+    await Promise.all(
+      files.map(async (filePath) => {
+        try {
+          const fileStats = await (0, import_promises11.stat)(filePath);
+          if (!fileStats.isFile()) {
+            return;
+          }
+          const fileContent = await (0, import_promises11.readFile)(filePath, "utf8");
+          const parsedContent = JSON.parse(fileContent);
+          const messageIds = /* @__PURE__ */ new Set();
+          if (Array.isArray(parsedContent)) {
+            for (const entry of parsedContent) {
+              if (!isRecord7(entry)) {
+                continue;
+              }
+              const messageId = getString6(entry, "messageId") ?? getString6(entry, "message_id");
+              if (messageId) {
+                messageIds.add(messageId);
+              }
+            }
+          }
+          this.observedLogMessageIds.set(filePath, messageIds);
+        } catch {
+        }
+      })
+    );
+  }
+  startProcessPolling() {
+    if (this.pollIntervalMs <= 0) {
+      return;
+    }
+    this.processPoller = setInterval(() => {
+      void this.pollGeminiProcesses();
+    }, this.pollIntervalMs);
+    this.processPoller.unref();
+    void this.pollGeminiProcesses();
+  }
+  async pollGeminiProcesses() {
+    const processes = await listProcesses6(this.processListCommand);
+    if (processes.length > 0 && this.getStatus().activeSessions === 0) {
+      const processInfo = processes[0];
+      if (!processInfo) {
+        return;
+      }
+      const sessionId = `gemini-cli-process-${processInfo.pid}`;
+      this.fallbackProcessSessionId = sessionId;
+      await this.emitStateChange(
+        "session.start",
+        {
+          raw: {
+            process: processInfo,
+            source: "process-detect"
+          }
+        },
+        {
+          pid: processInfo.pid,
+          sessionId,
+          source: "aisnitch://adapters/gemini-cli/process-detect"
+        }
+      );
+      return;
+    }
+    if (processes.length === 0 && this.fallbackProcessSessionId !== null) {
+      const sessionId = this.fallbackProcessSessionId;
+      this.fallbackProcessSessionId = null;
+      await this.emitStateChange(
+        "session.end",
+        {
+          raw: {
+            reason: "process-exit",
+            source: "process-detect"
+          }
+        },
+        {
+          sessionId,
+          source: "aisnitch://adapters/gemini-cli/process-detect"
+        }
+      );
+    }
+  }
+};
+async function collectFilesRecursively5(directoryPath, fileName) {
+  try {
+    const entries = await (0, import_promises11.readdir)(directoryPath, {
+      withFileTypes: true
+    });
+    const nestedResults = await Promise.all(
+      entries.map(async (entry) => {
+        const entryPath = (0, import_node_path12.join)(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+          return await collectFilesRecursively5(entryPath, fileName);
+        }
+        return entry.name === fileName ? [entryPath] : [];
+      })
+    );
+    return nestedResults.flat();
+  } catch (error) {
+    if (isErrnoException6(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function extractGeminiToolName(payload) {
+  return getString6(payload, "tool_name") ?? getString6(payload, "toolName");
+}
+function extractGeminiToolInput(payload) {
+  const toolInput = getRecord5(payload.tool_input) ?? getRecord5(payload.toolInput);
+  if (!toolInput) {
+    return void 0;
+  }
+  const filePath = getString6(toolInput, "file_path") ?? getString6(toolInput, "filePath") ?? getString6(toolInput, "path");
+  const command = getString6(toolInput, "command") ?? getString6(toolInput, "cmd");
+  if (!filePath && !command) {
+    return void 0;
+  }
+  return {
+    command,
+    filePath
+  };
+}
+function extractGeminiActiveFile(payload) {
+  const toolInput = extractGeminiToolInput(payload);
+  if (toolInput?.filePath) {
+    return toolInput.filePath;
+  }
+  return getString6(payload, "active_file") ?? getString6(payload, "activeFile") ?? getString6(payload, "file_path");
+}
+function extractGeminiErrorMessage(payload) {
+  const toolResponse = getRecord5(payload.tool_response) ?? getRecord5(payload.toolResponse);
+  const llmResponse = getRecord5(payload.llm_response) ?? getRecord5(payload.llmResponse);
+  return getString6(getRecord5(toolResponse?.error), "message") ?? getString6(payload, "reason") ?? getString6(payload, "message") ?? getString6(llmResponse, "error");
+}
+function extractGeminiErrorType(payload) {
+  const rawType = getString6(payload, "error_type") ?? getString6(payload, "errorType") ?? getString6(payload, "stopReason");
+  switch (rawType) {
+    case "rate_limit":
+      return "rate_limit";
+    case "max_output_tokens":
+    case "context_overflow":
+      return "context_overflow";
+    case "api_error":
+    case "provider_error":
+    case "invalid_request":
+      return "api_error";
+    case "tool_failure":
+      return "tool_failure";
+    default:
+      return void 0;
+  }
+}
+function extractGeminiModel(payload) {
+  return getString6(getRecord5(payload.llm_request), "model") ?? getString6(payload, "model");
+}
+function extractGeminiTokens(payload) {
+  const llmResponse = getRecord5(payload.llm_response) ?? getRecord5(payload.llmResponse);
+  const usageMetadata = getRecord5(llmResponse?.usageMetadata);
+  const totalTokens = getNumber4(usageMetadata, "totalTokenCount") ?? getNumber4(usageMetadata, "total_tokens");
+  return totalTokens;
+}
+function isGeminiCodingTool(toolName) {
+  return toolName !== void 0 && GEMINI_CODING_TOOLS.has(toolName);
+}
+async function listProcesses6(listCommand) {
+  if (process.platform === "win32") {
+    return [];
+  }
+  try {
+    const stdout = await listCommand();
+    return stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map(parseProcessLine5).filter((processInfo) => processInfo !== null);
+  } catch (error) {
+    const errorCode = isErrnoException6(error) ? String(error.code) : "";
+    if (isErrnoException6(error) && (errorCode === "ENOENT" || errorCode === "1")) {
+      return [];
+    }
+    logger.debug({ error }, "Gemini process detection failed");
+    return [];
+  }
+}
+function parseProcessLine5(line) {
+  const match = line.match(/^(\d+)\s+(.+)$/u);
+  if (!match) {
+    return null;
+  }
+  const pidText = match[1];
+  const command = match[2];
+  if (!pidText || !command) {
+    return null;
+  }
+  return {
+    command,
+    pid: Number.parseInt(pidText, 10)
+  };
+}
+function isErrnoException6(error) {
+  return error instanceof Error && "code" in error;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRecord5(value) {
+  return isRecord7(value) ? value : void 0;
+}
+function getNumber4(payload, key) {
+  if (!payload) {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getString6(payload, key) {
+  if (!payload) {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+
+// src/adapters/goose.ts
+var import_node_child_process10 = require("child_process");
+var import_promises12 = require("fs/promises");
+var import_node_path13 = require("path");
+var import_node_util10 = require("util");
+var import_chokidar8 = require("chokidar");
+var execFile10 = (0, import_node_util10.promisify)(import_node_child_process10.execFile);
+var DEFAULT_GOOSED_BASE_URL = "http://127.0.0.1:8080";
+var DEFAULT_SQLITE_QUERY = [
+  "SELECT",
+  "  id,",
+  "  name,",
+  "  working_dir,",
+  "  updated_at,",
+  "  message_count,",
+  "  provider_name,",
+  "  accumulated_total_tokens,",
+  "  total_tokens,",
+  "  model_config",
+  "FROM sessions",
+  "ORDER BY updated_at DESC",
+  "LIMIT 24;"
+].join("\n");
+var MAX_STREAMED_SESSIONS = 6;
+var GOOSE_CODING_TOOL_HINT = /apply|create|delete|edit|move|patch|rename|replace|write/iu;
+var GOOSE_RATE_LIMIT_HINT = /credit|quota|rate limit|exhausted/iu;
+var GooseAdapter = class extends BaseAdapter {
+  displayName = "Goose";
+  name = "goose";
+  strategies = [
+    "api-client",
+    "sqlite-watch",
+    "process-detect"
+  ];
+  apiPoller = null;
+  apiBaseUrl;
+  apiKey;
+  databasePath;
+  databaseWatcher = null;
+  fallbackProcessSessionId = null;
+  fetchImplementation;
+  apiDiscoverySeeded = false;
+  observedSessions = /* @__PURE__ */ new Set();
+  pollIntervalMs;
+  processPoller = null;
+  processListCommand;
+  sessionEventFingerprints = /* @__PURE__ */ new Map();
+  sessionSnapshots = /* @__PURE__ */ new Map();
+  sessionStreams = /* @__PURE__ */ new Map();
+  sqliteQueryCommand;
+  watcherFactory;
+  constructor(options) {
+    super(options);
+    this.apiBaseUrl = options.apiBaseUrl ?? options.env?.AISNITCH_GOOSE_API_BASE_URL ?? DEFAULT_GOOSED_BASE_URL;
+    this.apiKey = options.apiKey ?? options.env?.AISNITCH_GOOSE_API_KEY ?? options.env?.GOOSE_API_KEY;
+    this.databasePath = options.databasePath ?? (0, import_node_path13.join)(this.getUserHomeDirectory(), ".config", "goose", "sessions.db");
+    this.fetchImplementation = options.fetchImplementation ?? fetch;
+    this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
+    this.processListCommand = options.processListCommand ?? (async () => await execFile10("pgrep", ["-lf", "goose|goosed"]).then(
+      (result) => result.stdout
+    ));
+    this.sqliteQueryCommand = options.sqliteQueryCommand ?? (async (databasePath, query) => await execFile10("sqlite3", ["-json", databasePath, query]).then(
+      (result) => result.stdout
+    ));
+    this.watcherFactory = options.watcherFactory ?? import_chokidar8.watch;
+  }
+  async start() {
+    if (this.getStatus().running) {
+      return;
+    }
+    this.setRunning(true);
+    await this.seedSqliteSessions();
+    this.databaseWatcher = this.watcherFactory(this.databasePath, {
+      awaitWriteFinish: {
+        stabilityThreshold: 200
+      },
+      ignoreInitial: true
+    });
+    this.databaseWatcher.on("add", () => {
+      void this.pollSqliteSessions(true);
+    });
+    this.databaseWatcher.on("change", () => {
+      void this.pollSqliteSessions(true);
+    });
+    this.databaseWatcher.on("error", (error) => {
+      logger.warn({ error }, "Goose SQLite watcher error");
+    });
+    this.startApiPolling();
+    this.startProcessPolling();
+  }
+  async stop() {
+    if (this.databaseWatcher !== null) {
+      await this.databaseWatcher.close();
+      this.databaseWatcher = null;
+    }
+    if (this.apiPoller !== null) {
+      clearInterval(this.apiPoller);
+      this.apiPoller = null;
+    }
+    if (this.processPoller !== null) {
+      clearInterval(this.processPoller);
+      this.processPoller = null;
+    }
+    for (const streamHandle of this.sessionStreams.values()) {
+      streamHandle.abortController.abort();
+      void streamHandle.promise.catch(() => void 0);
+    }
+    this.apiDiscoverySeeded = false;
+    this.fallbackProcessSessionId = null;
+    this.observedSessions.clear();
+    this.sessionEventFingerprints.clear();
+    this.sessionSnapshots.clear();
+    this.sessionStreams.clear();
+    this.setRunning(false);
+  }
+  async handleHook(payload) {
+    const normalizedPayload = this.parseNormalizedHookPayload(payload);
+    if (normalizedPayload === null) {
+      logger.debug({ payload }, "Goose ignores non-normalized hook payloads");
+      return;
+    }
+    await this.emitNormalizedPayload({
+      ...normalizedPayload,
+      sessionId: resolveSessionId({
+        activeFile: normalizedPayload.data?.activeFile,
+        cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
+        pid: normalizedPayload.pid,
+        projectPath: normalizedPayload.data?.projectPath,
+        sessionId: normalizedPayload.sessionId,
+        tool: this.name,
+        transcriptPath: normalizedPayload.transcriptPath
+      })
+    });
+  }
+  startApiPolling() {
+    if (this.pollIntervalMs <= 0) {
+      return;
+    }
+    this.apiPoller = setInterval(() => {
+      void this.pollGooseApi(true);
+    }, this.pollIntervalMs);
+    this.apiPoller.unref();
+    void this.pollGooseApi(false);
+  }
+  startProcessPolling() {
+    if (this.pollIntervalMs <= 0) {
+      return;
+    }
+    this.processPoller = setInterval(() => {
+      void this.pollGooseProcesses();
+    }, this.pollIntervalMs);
+    this.processPoller.unref();
+    void this.pollGooseProcesses();
+  }
+  async seedSqliteSessions() {
+    try {
+      await (0, import_promises12.stat)(this.databasePath);
+    } catch {
+      return;
+    }
+    const sessions = await this.readSqliteSessions();
+    this.syncSessionSnapshots(sessions, false, "sqlite-seed");
+  }
+  async pollSqliteSessions(emitChanges) {
+    const sessions = await this.readSqliteSessions();
+    this.syncSessionSnapshots(sessions, emitChanges, "sqlite");
+  }
+  async readSqliteSessions() {
+    let rawOutput;
+    try {
+      rawOutput = await this.sqliteQueryCommand(
+        this.databasePath,
+        DEFAULT_SQLITE_QUERY
+      );
+    } catch (error) {
+      logger.debug({ error }, "Goose SQLite session query skipped");
+      return [];
+    }
+    let parsedOutput;
+    try {
+      parsedOutput = JSON.parse(rawOutput);
+    } catch (error) {
+      logger.warn({ error }, "Goose SQLite JSON output is invalid");
+      return [];
+    }
+    if (!Array.isArray(parsedOutput)) {
+      return [];
+    }
+    return parsedOutput.map((entry) => normalizeGooseSession(entry)).filter((entry) => entry !== null);
+  }
+  async pollGooseApi(emitChanges) {
+    let statusResponse;
+    try {
+      statusResponse = await this.fetchImplementation(
+        new URL("/status", this.apiBaseUrl)
+      );
+    } catch (error) {
+      logger.debug({ error }, "Goosed status endpoint is unavailable");
+      return;
+    }
+    if (!statusResponse.ok) {
+      return;
+    }
+    let sessionsResponse;
+    try {
+      sessionsResponse = await this.fetchImplementation(
+        new URL("/sessions", this.apiBaseUrl),
+        {
+          headers: this.createApiHeaders()
+        }
+      );
+    } catch (error) {
+      logger.debug({ error }, "Goosed sessions endpoint request failed");
+      return;
+    }
+    if (!sessionsResponse.ok) {
+      logger.debug(
+        { status: sessionsResponse.status },
+        "Goosed sessions endpoint rejected the request"
+      );
+      return;
+    }
+    let parsedPayload;
+    try {
+      parsedPayload = await sessionsResponse.json();
+    } catch (error) {
+      logger.warn({ error }, "Goosed sessions payload is not valid JSON");
+      return;
+    }
+    const responsePayload = parsedPayload;
+    const rawSessions = Array.isArray(responsePayload.sessions) ? responsePayload.sessions : [];
+    const sessions = rawSessions.map((entry) => normalizeGooseSession(entry)).filter((entry) => entry !== null);
+    this.syncSessionSnapshots(
+      sessions,
+      emitChanges && this.apiDiscoverySeeded,
+      "api"
+    );
+    this.apiDiscoverySeeded = true;
+  }
+  syncSessionSnapshots(nextSnapshots, emitChanges, source) {
+    for (const snapshot of nextSnapshots) {
+      const previousSnapshot = this.sessionSnapshots.get(snapshot.sessionId);
+      this.sessionSnapshots.set(snapshot.sessionId, snapshot);
+      this.ensureTrackedSessionStream(snapshot);
+      if (!emitChanges) {
+        continue;
+      }
+      if (previousSnapshot === void 0) {
+        void this.ensureObservedSession(snapshot, source);
+        continue;
+      }
+      if (!didGooseSessionAdvance(previousSnapshot, snapshot)) {
+        continue;
+      }
+      void this.ensureObservedSession(snapshot, source).then(async () => {
+        await this.emitStateChange(
+          "agent.streaming",
+          buildGooseSessionData(snapshot, {
+            raw: {
+              snapshot,
+              source
+            }
+          }),
+          this.createSessionContext(snapshot, `aisnitch://adapters/goose/${source}`)
+        );
+      });
+    }
+    this.trimTrackedSessionStreams(nextSnapshots);
+  }
+  ensureTrackedSessionStream(snapshot) {
+    if (this.sessionStreams.has(snapshot.sessionId)) {
+      return;
+    }
+    const abortController = new AbortController();
+    const streamPromise = this.consumeSessionEvents(snapshot, abortController).finally(
+      () => {
+        const activeStream = this.sessionStreams.get(snapshot.sessionId);
+        if (activeStream?.abortController === abortController) {
+          this.sessionStreams.delete(snapshot.sessionId);
+        }
+      }
+    );
+    this.sessionStreams.set(snapshot.sessionId, {
+      abortController,
+      promise: streamPromise
+    });
+  }
+  trimTrackedSessionStreams(nextSnapshots) {
+    const keepSessionIds = new Set(
+      [...nextSnapshots].sort(compareGooseSessionsByRecency).slice(0, MAX_STREAMED_SESSIONS).map((snapshot) => snapshot.sessionId)
+    );
+    for (const [sessionId, streamHandle] of this.sessionStreams) {
+      if (keepSessionIds.has(sessionId)) {
+        continue;
+      }
+      streamHandle.abortController.abort();
+      this.sessionStreams.delete(sessionId);
+    }
+  }
+  async consumeSessionEvents(snapshot, abortController) {
+    let response;
+    try {
+      response = await this.fetchImplementation(
+        new URL(
+          `/sessions/${encodeURIComponent(snapshot.gooseSessionId)}/events`,
+          this.apiBaseUrl
+        ),
+        {
+          headers: {
+            ...this.createApiHeaders(),
+            Accept: "text/event-stream"
+          },
+          signal: abortController.signal
+        }
+      );
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return;
+      }
       logger.debug({ error, sessionId: snapshot.sessionId }, "Goose SSE request failed");
       return;
     }
-    if (!response.ok || response.body === null) {
-      logger.debug(
-        { sessionId: snapshot.sessionId, status: response.status },
-        "Goose SSE stream is unavailable"
-      );
+    if (!response.ok || response.body === null) {
+      logger.debug(
+        { sessionId: snapshot.sessionId, status: response.status },
+        "Goose SSE stream is unavailable"
+      );
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const readResult = await reader.read();
+        if (readResult.done) {
+          break;
+        }
+        buffer += decoder.decode(readResult.value, { stream: true });
+        while (true) {
+          const delimiterIndex = buffer.indexOf("\n\n");
+          if (delimiterIndex === -1) {
+            break;
+          }
+          const frame = buffer.slice(0, delimiterIndex);
+          buffer = buffer.slice(delimiterIndex + 2);
+          await this.processSSEFrame(snapshot, frame);
+        }
+      }
+    } catch (error) {
+      if (!abortController.signal.aborted) {
+        logger.debug(
+          { error, sessionId: snapshot.sessionId },
+          "Goose SSE stream closed unexpectedly"
+        );
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async processSSEFrame(snapshot, frame) {
+    const payloadText = frame.split(/\r?\n/u).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+    if (payloadText.length === 0) {
+      return;
+    }
+    let parsedPayload;
+    try {
+      parsedPayload = JSON.parse(payloadText);
+    } catch (error) {
+      logger.warn({ error }, "Goose SSE frame is not valid JSON");
+      return;
+    }
+    await this.processSessionEvent(snapshot, parsedPayload);
+  }
+  async processSessionEvent(snapshot, payload) {
+    if (!isRecord8(payload)) {
+      return;
+    }
+    const fingerprint = createGooseFingerprint(payload);
+    if (fingerprint && !this.markSessionEventSeen(snapshot.sessionId, fingerprint)) {
+      return;
+    }
+    const eventType = getString7(payload, "type");
+    switch (eventType) {
+      case "Message": {
+        await this.processGooseMessage(snapshot, payload);
+        return;
+      }
+      case "Finish": {
+        await this.ensureObservedSession(snapshot, "sse");
+        await this.emitStateChange(
+          "task.complete",
+          buildGooseSessionData(snapshot, {
+            raw: payload,
+            tokensUsed: extractGooseTokenCount(getRecord6(payload.token_state))
+          }),
+          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+        );
+        return;
+      }
+      case "Error": {
+        const errorMessage = getString7(payload, "error");
+        await this.ensureObservedSession(snapshot, "sse");
+        await this.emitStateChange(
+          "agent.error",
+          buildGooseSessionData(snapshot, {
+            errorMessage,
+            errorType: inferGooseErrorType(errorMessage),
+            raw: payload
+          }),
+          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+        );
+        return;
+      }
+      case "Notification": {
+        await this.ensureObservedSession(snapshot, "sse");
+        await this.emitStateChange(
+          "agent.asking_user",
+          buildGooseSessionData(snapshot, {
+            errorMessage: extractLooseString2(payload, ["message"]),
+            raw: payload
+          }),
+          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+        );
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  async processGooseMessage(snapshot, payload) {
+    const message = getRecord6(payload.message);
+    if (!message) {
+      return;
+    }
+    const role = getString7(message, "role");
+    const content = getRecordArray(message.content);
+    const tokenState = getRecord6(payload.token_state);
+    const tokensUsed = extractGooseTokenCount(tokenState);
+    await this.ensureObservedSession(snapshot, "sse");
+    if (role === "user") {
+      const promptText = content.filter((part) => getString7(part, "type") === "text").map((part) => getString7(part, "text")).filter((part) => typeof part === "string").join("\n").trim();
+      await this.emitStateChange(
+        "task.start",
+        buildGooseSessionData(snapshot, {
+          raw: {
+            message,
+            prompt: promptText,
+            tokenState
+          },
+          tokensUsed
+        }),
+        this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+      );
+      return;
+    }
+    if (role !== "assistant") {
+      return;
+    }
+    for (const part of content) {
+      const partType = getString7(part, "type");
+      switch (partType) {
+        case "thinking": {
+          await this.emitStateChange(
+            "agent.thinking",
+            buildGooseSessionData(snapshot, {
+              raw: {
+                message: {
+                  content: [part],
+                  role
+                },
+                tokenState
+              },
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        case "redactedThinking": {
+          await this.emitStateChange(
+            "agent.thinking",
+            buildGooseSessionData(snapshot, {
+              raw: {
+                message: {
+                  content: [
+                    {
+                      thinking: getString7(part, "data"),
+                      type: "thinking"
+                    }
+                  ],
+                  role
+                },
+                tokenState
+              },
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        case "text": {
+          await this.emitStateChange(
+            "agent.streaming",
+            buildGooseSessionData(snapshot, {
+              raw: {
+                message: {
+                  content: [part],
+                  role
+                },
+                tokenState
+              },
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        case "toolRequest": {
+          const toolName = extractGooseToolName(part);
+          const toolInput = extractGooseToolInput(part);
+          const activeFile = toolInput?.filePath;
+          const emittedType = isGooseCodingTool(toolName, toolInput) ? "agent.coding" : "agent.tool_call";
+          await this.emitStateChange(
+            emittedType,
+            buildGooseSessionData(snapshot, {
+              activeFile,
+              raw: {
+                message: {
+                  content: [part],
+                  role
+                },
+                tokenState
+              },
+              toolInput,
+              toolName,
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        case "toolConfirmationRequest":
+        case "actionRequired": {
+          await this.emitStateChange(
+            "agent.asking_user",
+            buildGooseSessionData(snapshot, {
+              errorMessage: getString7(part, "prompt") ?? extractLooseString2(getRecord6(part.data), ["message"]),
+              raw: {
+                message: {
+                  content: [part],
+                  role
+                },
+                tokenState
+              },
+              toolInput: extractGooseToolInput(part),
+              toolName: extractGooseToolName(part),
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        case "systemNotification": {
+          const notificationType = getString7(part, "notificationType");
+          const eventTypeToEmit = notificationType === "thinkingMessage" ? "agent.thinking" : "agent.asking_user";
+          await this.emitStateChange(
+            eventTypeToEmit,
+            buildGooseSessionData(snapshot, {
+              errorMessage: getString7(part, "msg"),
+              errorType: notificationType === "creditsExhausted" ? "rate_limit" : void 0,
+              raw: {
+                message: notificationType === "thinkingMessage" ? {
+                  content: [
+                    {
+                      thinking: getString7(part, "msg"),
+                      type: "thinking"
+                    }
+                  ],
+                  role
+                } : {
+                  content: [part],
+                  role
+                },
+                tokenState
+              },
+              tokensUsed
+            }),
+            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+          );
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  async ensureObservedSession(snapshot, source) {
+    if (this.observedSessions.has(snapshot.sessionId)) {
+      return;
+    }
+    this.observedSessions.add(snapshot.sessionId);
+    const context = this.createSessionContext(
+      snapshot,
+      `aisnitch://adapters/goose/${source}`
+    );
+    const eventData = buildGooseSessionData(snapshot, {
+      raw: {
+        snapshot,
+        source
+      }
+    });
+    await this.emitStateChange("session.start", eventData, context);
+    await this.emitStateChange("agent.idle", eventData, context);
+  }
+  createSessionContext(snapshot, source) {
+    return {
+      cwd: snapshot.workingDir,
+      sessionId: snapshot.sessionId,
+      source
+    };
+  }
+  markSessionEventSeen(sessionId, fingerprint) {
+    const knownFingerprints = this.sessionEventFingerprints.get(sessionId) ?? /* @__PURE__ */ new Set();
+    if (knownFingerprints.has(fingerprint)) {
+      return false;
+    }
+    if (knownFingerprints.size >= 256) {
+      knownFingerprints.clear();
+    }
+    knownFingerprints.add(fingerprint);
+    this.sessionEventFingerprints.set(sessionId, knownFingerprints);
+    return true;
+  }
+  createApiHeaders() {
+    if (!this.apiKey) {
+      return void 0;
+    }
+    return {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async pollGooseProcesses() {
+    const processes = await listProcesses7(this.processListCommand);
+    if (processes.length > 0 && this.getStatus().activeSessions === 0) {
+      const processInfo = processes[0];
+      if (!processInfo) {
+        return;
+      }
+      const sessionId = `goose-process-${processInfo.pid}`;
+      this.fallbackProcessSessionId = sessionId;
+      await this.emitStateChange(
+        "session.start",
+        {
+          raw: {
+            process: processInfo,
+            source: "process-detect"
+          }
+        },
+        {
+          pid: processInfo.pid,
+          sessionId,
+          source: "aisnitch://adapters/goose/process-detect"
+        }
+      );
+      return;
+    }
+    if (processes.length === 0 && this.fallbackProcessSessionId !== null) {
+      const sessionId = this.fallbackProcessSessionId;
+      this.fallbackProcessSessionId = null;
+      await this.emitStateChange(
+        "session.end",
+        {
+          raw: {
+            reason: "process-exit",
+            source: "process-detect"
+          }
+        },
+        {
+          sessionId,
+          source: "aisnitch://adapters/goose/process-detect"
+        }
+      );
+    }
+  }
+};
+function normalizeGooseSession(payload) {
+  if (!isRecord8(payload)) {
+    return null;
+  }
+  const gooseSessionId = getString7(payload, "id");
+  if (!gooseSessionId) {
+    return null;
+  }
+  const workingDir = getString7(payload, "working_dir") ?? getString7(payload, "workingDir");
+  const name = getString7(payload, "name");
+  const providerName = getString7(payload, "provider_name") ?? getString7(payload, "providerName");
+  const updatedAt = getString7(payload, "updated_at") ?? getString7(payload, "updatedAt");
+  const messageCount = getNumber5(payload, "message_count") ?? getNumber5(payload, "messageCount");
+  const totalTokens = getNumber5(payload, "accumulated_total_tokens") ?? getNumber5(payload, "total_tokens") ?? getNumber5(payload, "accumulatedTotalTokens") ?? getNumber5(payload, "totalTokens");
+  const modelConfig = getRecord6(payload.model_config) ?? getRecord6(payload.modelConfig);
+  const rawModelConfig = getString7(payload, "model_config");
+  const parsedModelConfig = modelConfig ?? parseJsonRecord2(rawModelConfig);
+  const model = getString7(parsedModelConfig, "model_name") ?? getString7(parsedModelConfig, "modelName");
+  const sessionId = resolveSessionId({
+    cwd: workingDir,
+    projectPath: workingDir,
+    sessionId: gooseSessionId,
+    tool: "goose"
+  });
+  return {
+    gooseSessionId,
+    messageCount,
+    model,
+    name,
+    providerName,
+    sessionId,
+    totalTokens,
+    updatedAt,
+    workingDir
+  };
+}
+function buildGooseSessionData(snapshot, overrides = {}) {
+  return {
+    cwd: overrides.cwd ?? snapshot.workingDir,
+    model: overrides.model ?? snapshot.model,
+    project: overrides.project ?? snapshot.name,
+    projectPath: overrides.projectPath ?? snapshot.workingDir,
+    raw: overrides.raw,
+    tokensUsed: overrides.tokensUsed ?? snapshot.totalTokens,
+    ...overrides
+  };
+}
+function compareGooseSessionsByRecency(left, right) {
+  return Date.parse(right.updatedAt ?? "") - Date.parse(left.updatedAt ?? "");
+}
+function didGooseSessionAdvance(previousSnapshot, nextSnapshot) {
+  return previousSnapshot.updatedAt !== nextSnapshot.updatedAt || previousSnapshot.messageCount !== nextSnapshot.messageCount || previousSnapshot.totalTokens !== nextSnapshot.totalTokens;
+}
+function createGooseFingerprint(payload) {
+  const eventType = getString7(payload, "type");
+  if (!eventType) {
+    return null;
+  }
+  if (eventType === "Message") {
+    const message = getRecord6(payload.message);
+    const messageId = getString7(message, "id");
+    const created = getNumber5(message, "created");
+    const role = getString7(message, "role");
+    return [eventType, messageId, created, role].filter((value) => value !== void 0).join(":");
+  }
+  if (eventType === "Finish") {
+    return `${eventType}:${getString7(payload, "reason") ?? "unknown"}`;
+  }
+  if (eventType === "Error") {
+    return `${eventType}:${getString7(payload, "error") ?? "unknown"}`;
+  }
+  return eventType;
+}
+function extractGooseTokenCount(tokenState) {
+  return getNumber5(tokenState, "accumulatedTotalTokens") ?? getNumber5(tokenState, "totalTokens");
+}
+function extractGooseToolName(payload) {
+  const toolCall = getRecord6(payload.toolCall);
+  return getString7(toolCall, "name") ?? getString7(toolCall, "toolName") ?? getString7(payload, "toolName");
+}
+function extractGooseToolInput(payload) {
+  const toolCall = getRecord6(payload.toolCall);
+  const argumentsRecord = getRecord6(toolCall?.arguments) ?? getRecord6(toolCall?.args) ?? getRecord6(toolCall?.input) ?? getRecord6(payload.arguments);
+  const filePath = extractFirstString2(argumentsRecord, [
+    "file",
+    "file_path",
+    "filePath",
+    "path",
+    "target",
+    "target_path",
+    "targetPath"
+  ]);
+  const command = extractFirstString2(argumentsRecord, [
+    "cmd",
+    "command",
+    "script"
+  ]);
+  if (!filePath && !command) {
+    return void 0;
+  }
+  return {
+    command,
+    filePath
+  };
+}
+function isGooseCodingTool(toolName, toolInput) {
+  if (toolName && GOOSE_CODING_TOOL_HINT.test(toolName)) {
+    return true;
+  }
+  const filePath = toolInput?.filePath;
+  if (!filePath) {
+    return false;
+  }
+  return !/read|view|glob|grep|list|search/iu.test(toolName ?? "");
+}
+function inferGooseErrorType(errorMessage) {
+  if (!errorMessage) {
+    return void 0;
+  }
+  if (GOOSE_RATE_LIMIT_HINT.test(errorMessage)) {
+    return "rate_limit";
+  }
+  if (/context|token limit|too long/iu.test(errorMessage)) {
+    return "context_overflow";
+  }
+  if (/tool/iu.test(errorMessage)) {
+    return "tool_failure";
+  }
+  return "api_error";
+}
+async function listProcesses7(processListCommand) {
+  try {
+    const commandOutput = await processListCommand();
+    return commandOutput.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+      const [pidPart, ...commandParts] = line.split(/\s+/u);
+      const pid = pidPart ? Number.parseInt(pidPart, 10) : Number.NaN;
+      return {
+        command: commandParts.join(" "),
+        pid
+      };
+    }).filter((processInfo) => Number.isInteger(processInfo.pid));
+  } catch (error) {
+    logger.debug({ error }, "Goose process listing skipped");
+    return [];
+  }
+}
+function parseJsonRecord2(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    const parsedValue = JSON.parse(value);
+    return getRecord6(parsedValue);
+  } catch {
+    return void 0;
+  }
+}
+function extractFirstString2(payload, keys) {
+  if (!payload) {
+    return void 0;
+  }
+  for (const key of keys) {
+    const directValue = getString7(payload, key);
+    if (directValue) {
+      return directValue;
+    }
+  }
+  return void 0;
+}
+function extractLooseString2(payload, keys) {
+  if (!payload) {
+    return void 0;
+  }
+  for (const key of keys) {
+    const directValue = getString7(payload, key);
+    if (directValue) {
+      return directValue;
+    }
+    const nestedValue = getString7(getRecord6(payload[key]), "message");
+    if (nestedValue) {
+      return nestedValue;
+    }
+  }
+  return void 0;
+}
+function getRecordArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => isRecord8(entry));
+}
+function getRecord6(value) {
+  return isRecord8(value) ? value : void 0;
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getString7(payload, key) {
+  if (!payload) {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function getNumber5(payload, key) {
+  if (!payload) {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/adapters/kilo.ts
+var import_node_child_process11 = require("child_process");
+var import_promises13 = require("fs/promises");
+var import_node_path14 = require("path");
+var import_node_util11 = require("util");
+var import_chokidar9 = require("chokidar");
+var execFile11 = (0, import_node_util11.promisify)(import_node_child_process11.execFile);
+var KILO_CODING_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "Create",
+  "Delete",
+  "Move",
+  "ApplyDiff"
+]);
+var KiloAdapter = class extends BaseAdapter {
+  displayName = "Kilo CLI";
+  name = "kilo";
+  strategies = [
+    "process-detect",
+    "jsonl-watch",
+    "hooks"
+  ];
+  fallbackProcessSessionId = null;
+  configDirectory;
+  dataDirectory;
+  pollIntervalMs;
+  processPoller = null;
+  processListCommand;
+  sessionMetadata = /* @__PURE__ */ new Map();
+  transcriptOffsets = /* @__PURE__ */ new Map();
+  transcriptRemainders = /* @__PURE__ */ new Map();
+  watcher = null;
+  watcherFactory;
+  constructor(options) {
+    super(options);
+    this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
+    this.processListCommand = options.processListCommand ?? (async () => {
+      const results = await Promise.all([
+        execFile11("pgrep", ["-lf", "kilo"]).catch(() => ({ stdout: "" })),
+        execFile11("pgrep", ["-lf", "kilocode"]).catch(() => ({ stdout: "" })),
+        execFile11("pgrep", ["-lf", "kilocode"]).catch(() => ({ stdout: "" }))
+      ]);
+      return results.map((r) => r.stdout).join("\n");
+    });
+    this.configDirectory = options.configDirectory ?? (0, import_node_path14.join)(this.getUserHomeDirectory(), ".config", "kilo");
+    this.dataDirectory = options.dataDirectory ?? (0, import_node_path14.join)(this.getUserHomeDirectory(), ".local", "share", "kilo");
+    this.watcherFactory = options.watcherFactory ?? import_chokidar9.watch;
+  }
+  async start() {
+    if (this.getStatus().running) {
+      return;
+    }
+    this.setRunning(true);
+    await this.seedTranscriptOffsets();
+    const _logPatterns = [
+      (0, import_node_path14.join)(this.dataDirectory, "**", "*.jsonl"),
+      (0, import_node_path14.join)(this.configDirectory, "logs", "**", "*.jsonl")
+    ];
+    this.watcher = this.watcherFactory((0, import_node_path14.join)(this.dataDirectory, "**", "*.jsonl"), {
+      awaitWriteFinish: { stabilityThreshold: 200 },
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (filePath) => void this.processTranscriptUpdate(filePath, true));
+    this.watcher.on("change", (filePath) => void this.processTranscriptUpdate(filePath, false));
+    this.watcher.on("error", (error) => {
+      logger.warn({ error }, "Kilo log watcher error");
+    });
+    this.startProcessPolling();
+  }
+  async stop() {
+    if (this.watcher !== null) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.processPoller !== null) {
+      clearInterval(this.processPoller);
+      this.processPoller = null;
+    }
+    this.fallbackProcessSessionId = null;
+    this.sessionMetadata.clear();
+    this.transcriptOffsets.clear();
+    this.transcriptRemainders.clear();
+    this.setRunning(false);
+  }
+  async handleHook(payload) {
+    const normalizedPayload = this.parseNormalizedHookPayload(payload);
+    if (normalizedPayload !== null) {
+      await this.emitNormalizedPayload({
+        ...normalizedPayload,
+        sessionId: resolveSessionId({
+          activeFile: normalizedPayload.data?.activeFile,
+          cwd: normalizedPayload.data?.cwd ?? normalizedPayload.cwd,
+          pid: normalizedPayload.pid,
+          project: normalizedPayload.data?.project,
+          projectPath: normalizedPayload.data?.projectPath,
+          sessionId: normalizedPayload.sessionId,
+          tool: this.name,
+          transcriptPath: normalizedPayload.transcriptPath
+        })
+      });
       return;
     }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const readResult = await reader.read();
-        if (readResult.done) {
-          break;
-        }
-        buffer += decoder.decode(readResult.value, { stream: true });
-        while (true) {
-          const delimiterIndex = buffer.indexOf("\n\n");
-          if (delimiterIndex === -1) {
-            break;
-          }
-          const frame = buffer.slice(0, delimiterIndex);
-          buffer = buffer.slice(delimiterIndex + 2);
-          await this.processSSEFrame(snapshot, frame);
-        }
+    if (!isRecord9(payload)) {
+      logger.warn({ payload }, "Kilo hook payload must be an object");
+      return;
+    }
+    const sessionId = resolveSessionId({
+      cwd: getString8(payload, "cwd"),
+      pid: getNumber6(payload, "pid"),
+      projectPath: getString8(payload, "projectPath"),
+      sessionId: getString8(payload, "sessionId") ?? getString8(payload, "session_id") ?? getString8(getRecord7(payload.data), "sessionId"),
+      tool: this.name
+    });
+    const context = {
+      cwd: getString8(payload, "cwd"),
+      env: this.env ?? process.env,
+      hookPayload: payload,
+      pid: getNumber6(payload, "pid"),
+      sessionId,
+      source: "aisnitch://adapters/kilo"
+    };
+    const eventType = getString8(payload, "event") ?? getString8(payload, "type") ?? getString8(payload, "method");
+    const data = getRecord7(payload.data) ?? payload;
+    const toolName = getString8(data, "tool") ?? getString8(data, "toolName") ?? getString8(data, "name");
+    const toolInput = extractToolInput3(data);
+    const sharedData = {
+      activeFile: toolInput?.filePath,
+      cwd: context.cwd,
+      model: getString8(data, "model") ?? getString8(payload, "model"),
+      projectPath: getString8(data, "projectPath") ?? getString8(payload, "projectPath"),
+      raw: payload,
+      toolInput,
+      toolName
+    };
+    switch (eventType) {
+      case "session.start":
+      case "sessionStart":
+      case "SessionStart": {
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
       }
-    } catch (error) {
-      if (!abortController.signal.aborted) {
-        logger.debug(
-          { error, sessionId: snapshot.sessionId },
-          "Goose SSE stream closed unexpectedly"
-        );
+      case "session.end":
+      case "sessionEnd":
+      case "SessionEnd": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
       }
-    } finally {
-      reader.releaseLock();
+      case "task.start":
+      case "taskStart":
+      case "UserPrompt":
+      case "user_message": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "task.complete":
+      case "taskComplete":
+      case "TaskComplete": {
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "tool.call":
+      case "toolCall":
+      case "PreToolUse": {
+        await this.emitStateChange("agent.tool_call", sharedData, context);
+        return;
+      }
+      case "tool.result":
+      case "toolResult":
+      case "PostToolUse": {
+        const emittedType = isKiloCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
+        return;
+      }
+      case "thinking":
+      case "Thinking":
+      case "reasoning": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
+        return;
+      }
+      case "streaming":
+      case "Streaming":
+      case "assistant_message": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "error":
+      case "Error": {
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString8(data, "error") ?? getString8(payload, "error") ?? "Kilo error",
+          errorType: inferKiloErrorType(data)
+        }, context);
+        return;
+      }
+      case "asking_user":
+      case "PermissionRequest":
+      case "input_required": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
+        return;
+      }
+      default:
+        logger.debug({ eventType }, "Kilo hook event ignored by adapter");
     }
   }
-  async processSSEFrame(snapshot, frame) {
-    const payloadText = frame.split(/\r?\n/u).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
-    if (payloadText.length === 0) {
-      return;
-    }
-    let parsedPayload;
+  async processTranscriptUpdate(filePath, readFromStart) {
+    let fileContent;
     try {
-      parsedPayload = JSON.parse(payloadText);
+      fileContent = await (0, import_promises13.readFile)(filePath);
     } catch (error) {
-      logger.warn({ error }, "Goose SSE frame is not valid JSON");
+      logger.debug({ error, filePath }, "Kilo transcript read skipped");
       return;
     }
-    await this.processSessionEvent(snapshot, parsedPayload);
+    const knownOffset = this.transcriptOffsets.get(filePath);
+    const previousOffset = knownOffset ?? (readFromStart ? 0 : fileContent.byteLength);
+    const safeOffset = previousOffset > fileContent.byteLength ? 0 : previousOffset;
+    const newChunk = fileContent.subarray(safeOffset).toString("utf8");
+    const bufferedChunk = (safeOffset === 0 ? "" : this.transcriptRemainders.get(filePath) ?? "") + newChunk;
+    const lines = bufferedChunk.split(/\r?\n/u);
+    const remainder = bufferedChunk.endsWith("\n") || bufferedChunk.endsWith("\r") ? "" : lines.pop() ?? "";
+    this.transcriptOffsets.set(filePath, fileContent.byteLength);
+    this.transcriptRemainders.set(filePath, remainder);
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.length === 0) {
+        continue;
+      }
+      await this.processTranscriptLine(trimmedLine, filePath);
+    }
   }
-  async processSessionEvent(snapshot, payload) {
-    if (!isRecord6(payload)) {
+  async processTranscriptLine(line, transcriptPath) {
+    let parsedLine;
+    try {
+      parsedLine = JSON.parse(line);
+    } catch (error) {
+      logger.warn({ error, transcriptPath }, "Kilo transcript line is not valid JSON");
       return;
     }
-    const fingerprint = createGooseFingerprint(payload);
-    if (fingerprint && !this.markSessionEventSeen(snapshot.sessionId, fingerprint)) {
+    if (!isRecord9(parsedLine)) {
       return;
     }
-    const eventType = getString5(payload, "type");
-    switch (eventType) {
-      case "Message": {
-        await this.processGooseMessage(snapshot, payload);
+    const acpType = getString8(parsedLine, "type") ?? getString8(parsedLine, "method");
+    const sessionId = resolveSessionId({
+      sessionId: getString8(parsedLine, "sessionId") ?? getString8(parsedLine, "session_id") ?? getString8(parsedLine, "id") ?? (0, import_node_path14.basename)(transcriptPath, ".jsonl"),
+      tool: this.name,
+      transcriptPath
+    });
+    const context = {
+      env: process.env,
+      hookPayload: parsedLine,
+      sessionId,
+      source: "aisnitch://adapters/kilo/log",
+      transcriptPath
+    };
+    const data = getRecord7(parsedLine.data) ?? parsedLine;
+    const toolName = getString8(data, "tool") ?? getString8(data, "toolName");
+    const toolInput = extractToolInput3(data);
+    const sharedData = {
+      activeFile: toolInput?.filePath,
+      cwd: getString8(data, "cwd"),
+      model: getString8(data, "model"),
+      raw: parsedLine,
+      toolInput,
+      toolName
+    };
+    switch (acpType) {
+      case "session.start":
+      case "SessionStart": {
+        await this.emitStateChange("session.start", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
         return;
       }
-      case "Finish": {
-        await this.ensureObservedSession(snapshot, "sse");
-        await this.emitStateChange(
-          "task.complete",
-          buildGooseSessionData(snapshot, {
-            raw: payload,
-            tokensUsed: extractGooseTokenCount(getRecord4(payload.token_state))
-          }),
-          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-        );
+      case "session.end":
+      case "SessionEnd": {
+        await this.emitStateChange("session.end", sharedData, context);
+        return;
+      }
+      case "task.start":
+      case "TaskStart":
+      case "user_message": {
+        await this.emitStateChange("task.start", sharedData, context);
+        return;
+      }
+      case "task.complete":
+      case "TaskComplete": {
+        await this.emitStateChange("task.complete", sharedData, context);
+        await this.emitStateChange("agent.idle", sharedData, context);
+        return;
+      }
+      case "thinking":
+      case "Thinking":
+      case "reasoning": {
+        await this.emitStateChange("agent.thinking", sharedData, context);
+        return;
+      }
+      case "streaming":
+      case "assistant_message": {
+        await this.emitStateChange("agent.streaming", sharedData, context);
+        return;
+      }
+      case "tool_call":
+      case "tool_use": {
+        const emittedType = isKiloCodingTool(toolName) ? "agent.coding" : "agent.tool_call";
+        await this.emitStateChange(emittedType, sharedData, context);
         return;
       }
+      case "error":
       case "Error": {
-        const errorMessage = getString5(payload, "error");
-        await this.ensureObservedSession(snapshot, "sse");
-        await this.emitStateChange(
-          "agent.error",
-          buildGooseSessionData(snapshot, {
-            errorMessage,
-            errorType: inferGooseErrorType(errorMessage),
-            raw: payload
-          }),
-          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-        );
+        await this.emitStateChange("agent.error", {
+          ...sharedData,
+          errorMessage: getString8(data, "error") ?? getString8(data, "message"),
+          errorType: inferKiloErrorType(data)
+        }, context);
         return;
       }
-      case "Notification": {
-        await this.ensureObservedSession(snapshot, "sse");
-        await this.emitStateChange(
-          "agent.asking_user",
-          buildGooseSessionData(snapshot, {
-            errorMessage: extractLooseString2(payload, ["message"]),
-            raw: payload
-          }),
-          this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-        );
+      case "permission_request":
+      case "asking_user": {
+        await this.emitStateChange("agent.asking_user", sharedData, context);
         return;
       }
       default:
+        if (acpType === "ping" || acpType === "pong" || acpType === "heartbeat") {
+          return;
+        }
         return;
     }
   }
-  async processGooseMessage(snapshot, payload) {
-    const message = getRecord4(payload.message);
-    if (!message) {
-      return;
-    }
-    const role = getString5(message, "role");
-    const content = getRecordArray(message.content);
-    const tokenState = getRecord4(payload.token_state);
-    const tokensUsed = extractGooseTokenCount(tokenState);
-    await this.ensureObservedSession(snapshot, "sse");
-    if (role === "user") {
-      const promptText = content.filter((part) => getString5(part, "type") === "text").map((part) => getString5(part, "text")).filter((part) => typeof part === "string").join("\n").trim();
-      await this.emitStateChange(
-        "task.start",
-        buildGooseSessionData(snapshot, {
-          raw: {
-            message,
-            prompt: promptText,
-            tokenState
-          },
-          tokensUsed
-        }),
-        this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
+  async seedTranscriptOffsets() {
+    try {
+      const files = await collectFilesRecursively6(this.dataDirectory, ".jsonl");
+      await Promise.all(
+        files.map(async (filePath) => {
+          try {
+            const fileStats = await (0, import_promises13.stat)(filePath);
+            this.transcriptOffsets.set(filePath, fileStats.size);
+          } catch {
+          }
+        })
       );
-      return;
-    }
-    if (role !== "assistant") {
-      return;
-    }
-    for (const part of content) {
-      const partType = getString5(part, "type");
-      switch (partType) {
-        case "thinking": {
-          await this.emitStateChange(
-            "agent.thinking",
-            buildGooseSessionData(snapshot, {
-              raw: {
-                message: {
-                  content: [part],
-                  role
-                },
-                tokenState
-              },
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        case "redactedThinking": {
-          await this.emitStateChange(
-            "agent.thinking",
-            buildGooseSessionData(snapshot, {
-              raw: {
-                message: {
-                  content: [
-                    {
-                      thinking: getString5(part, "data"),
-                      type: "thinking"
-                    }
-                  ],
-                  role
-                },
-                tokenState
-              },
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        case "text": {
-          await this.emitStateChange(
-            "agent.streaming",
-            buildGooseSessionData(snapshot, {
-              raw: {
-                message: {
-                  content: [part],
-                  role
-                },
-                tokenState
-              },
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        case "toolRequest": {
-          const toolName = extractGooseToolName(part);
-          const toolInput = extractGooseToolInput(part);
-          const activeFile = toolInput?.filePath;
-          const emittedType = isGooseCodingTool(toolName, toolInput) ? "agent.coding" : "agent.tool_call";
-          await this.emitStateChange(
-            emittedType,
-            buildGooseSessionData(snapshot, {
-              activeFile,
-              raw: {
-                message: {
-                  content: [part],
-                  role
-                },
-                tokenState
-              },
-              toolInput,
-              toolName,
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        case "toolConfirmationRequest":
-        case "actionRequired": {
-          await this.emitStateChange(
-            "agent.asking_user",
-            buildGooseSessionData(snapshot, {
-              errorMessage: getString5(part, "prompt") ?? extractLooseString2(getRecord4(part.data), ["message"]),
-              raw: {
-                message: {
-                  content: [part],
-                  role
-                },
-                tokenState
-              },
-              toolInput: extractGooseToolInput(part),
-              toolName: extractGooseToolName(part),
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        case "systemNotification": {
-          const notificationType = getString5(part, "notificationType");
-          const eventTypeToEmit = notificationType === "thinkingMessage" ? "agent.thinking" : "agent.asking_user";
-          await this.emitStateChange(
-            eventTypeToEmit,
-            buildGooseSessionData(snapshot, {
-              errorMessage: getString5(part, "msg"),
-              errorType: notificationType === "creditsExhausted" ? "rate_limit" : void 0,
-              raw: {
-                message: notificationType === "thinkingMessage" ? {
-                  content: [
-                    {
-                      thinking: getString5(part, "msg"),
-                      type: "thinking"
-                    }
-                  ],
-                  role
-                } : {
-                  content: [part],
-                  role
-                },
-                tokenState
-              },
-              tokensUsed
-            }),
-            this.createSessionContext(snapshot, "aisnitch://adapters/goose/sse")
-          );
-          break;
-        }
-        default:
-          break;
-      }
-    }
-  }
-  async ensureObservedSession(snapshot, source) {
-    if (this.observedSessions.has(snapshot.sessionId)) {
-      return;
-    }
-    this.observedSessions.add(snapshot.sessionId);
-    const context = this.createSessionContext(
-      snapshot,
-      `aisnitch://adapters/goose/${source}`
-    );
-    const eventData = buildGooseSessionData(snapshot, {
-      raw: {
-        snapshot,
-        source
-      }
-    });
-    await this.emitStateChange("session.start", eventData, context);
-    await this.emitStateChange("agent.idle", eventData, context);
-  }
-  createSessionContext(snapshot, source) {
-    return {
-      cwd: snapshot.workingDir,
-      sessionId: snapshot.sessionId,
-      source
-    };
-  }
-  markSessionEventSeen(sessionId, fingerprint) {
-    const knownFingerprints = this.sessionEventFingerprints.get(sessionId) ?? /* @__PURE__ */ new Set();
-    if (knownFingerprints.has(fingerprint)) {
-      return false;
-    }
-    if (knownFingerprints.size >= 256) {
-      knownFingerprints.clear();
+    } catch {
     }
-    knownFingerprints.add(fingerprint);
-    this.sessionEventFingerprints.set(sessionId, knownFingerprints);
-    return true;
-  }
-  createApiHeaders() {
-    if (!this.apiKey) {
-      return void 0;
+  }
+  startProcessPolling() {
+    if (this.pollIntervalMs <= 0) {
+      return;
     }
-    return {
-      Authorization: `Bearer ${this.apiKey}`
-    };
+    this.processPoller = setInterval(() => {
+      void this.pollKiloProcesses();
+    }, this.pollIntervalMs);
+    this.processPoller.unref();
+    void this.pollKiloProcesses();
   }
-  async pollGooseProcesses() {
-    const processes = await listProcesses5(this.processListCommand);
+  async pollKiloProcesses() {
+    const processes = await listProcesses8(this.processListCommand);
     if (processes.length > 0 && this.getStatus().activeSessions === 0) {
       const processInfo = processes[0];
       if (!processInfo) {
         return;
       }
-      const sessionId = `goose-process-${processInfo.pid}`;
+      const sessionId = `kilo-process-${processInfo.pid}`;
       this.fallbackProcessSessionId = sessionId;
       await this.emitStateChange(
         "session.start",
-        {
-          raw: {
-            process: processInfo,
-            source: "process-detect"
-          }
-        },
+        { raw: { process: processInfo, source: "process-detect" } },
         {
           pid: processInfo.pid,
           sessionId,
-          source: "aisnitch://adapters/goose/process-detect"
+          source: "aisnitch://adapters/kilo/process-detect"
         }
       );
       return;
@@ -7869,240 +9437,119 @@ var GooseAdapter = class extends BaseAdapter {
       this.fallbackProcessSessionId = null;
       await this.emitStateChange(
         "session.end",
-        {
-          raw: {
-            reason: "process-exit",
-            source: "process-detect"
-          }
-        },
+        { raw: { reason: "process-exit", source: "process-detect" } },
         {
           sessionId,
-          source: "aisnitch://adapters/goose/process-detect"
+          source: "aisnitch://adapters/kilo/process-detect"
         }
       );
     }
   }
 };
-function normalizeGooseSession(payload) {
-  if (!isRecord6(payload)) {
-    return null;
-  }
-  const gooseSessionId = getString5(payload, "id");
-  if (!gooseSessionId) {
-    return null;
+async function collectFilesRecursively6(directoryPath, extension) {
+  try {
+    const entries = await (0, import_promises13.readdir)(directoryPath, { withFileTypes: true });
+    const nestedResults = await Promise.all(
+      entries.map(async (entry) => {
+        const entryPath = (0, import_node_path14.join)(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+          return await collectFilesRecursively6(entryPath, extension);
+        }
+        return entry.name.endsWith(extension) ? [entryPath] : [];
+      })
+    );
+    return nestedResults.flat();
+  } catch (error) {
+    if (isErrnoException7(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
   }
-  const workingDir = getString5(payload, "working_dir") ?? getString5(payload, "workingDir");
-  const name = getString5(payload, "name");
-  const providerName = getString5(payload, "provider_name") ?? getString5(payload, "providerName");
-  const updatedAt = getString5(payload, "updated_at") ?? getString5(payload, "updatedAt");
-  const messageCount = getNumber3(payload, "message_count") ?? getNumber3(payload, "messageCount");
-  const totalTokens = getNumber3(payload, "accumulated_total_tokens") ?? getNumber3(payload, "total_tokens") ?? getNumber3(payload, "accumulatedTotalTokens") ?? getNumber3(payload, "totalTokens");
-  const modelConfig = getRecord4(payload.model_config) ?? getRecord4(payload.modelConfig);
-  const rawModelConfig = getString5(payload, "model_config");
-  const parsedModelConfig = modelConfig ?? parseJsonRecord2(rawModelConfig);
-  const model = getString5(parsedModelConfig, "model_name") ?? getString5(parsedModelConfig, "modelName");
-  const sessionId = resolveSessionId({
-    cwd: workingDir,
-    projectPath: workingDir,
-    sessionId: gooseSessionId,
-    tool: "goose"
-  });
-  return {
-    gooseSessionId,
-    messageCount,
-    model,
-    name,
-    providerName,
-    sessionId,
-    totalTokens,
-    updatedAt,
-    workingDir
-  };
-}
-function buildGooseSessionData(snapshot, overrides = {}) {
-  return {
-    cwd: overrides.cwd ?? snapshot.workingDir,
-    model: overrides.model ?? snapshot.model,
-    project: overrides.project ?? snapshot.name,
-    projectPath: overrides.projectPath ?? snapshot.workingDir,
-    raw: overrides.raw,
-    tokensUsed: overrides.tokensUsed ?? snapshot.totalTokens,
-    ...overrides
-  };
-}
-function compareGooseSessionsByRecency(left, right) {
-  return Date.parse(right.updatedAt ?? "") - Date.parse(left.updatedAt ?? "");
-}
-function didGooseSessionAdvance(previousSnapshot, nextSnapshot) {
-  return previousSnapshot.updatedAt !== nextSnapshot.updatedAt || previousSnapshot.messageCount !== nextSnapshot.messageCount || previousSnapshot.totalTokens !== nextSnapshot.totalTokens;
 }
-function createGooseFingerprint(payload) {
-  const eventType = getString5(payload, "type");
-  if (!eventType) {
-    return null;
-  }
-  if (eventType === "Message") {
-    const message = getRecord4(payload.message);
-    const messageId = getString5(message, "id");
-    const created = getNumber3(message, "created");
-    const role = getString5(message, "role");
-    return [eventType, messageId, created, role].filter((value) => value !== void 0).join(":");
-  }
-  if (eventType === "Finish") {
-    return `${eventType}:${getString5(payload, "reason") ?? "unknown"}`;
-  }
-  if (eventType === "Error") {
-    return `${eventType}:${getString5(payload, "error") ?? "unknown"}`;
+function extractToolInput3(payload) {
+  if (!payload) {
+    return void 0;
   }
-  return eventType;
-}
-function extractGooseTokenCount(tokenState) {
-  return getNumber3(tokenState, "accumulatedTotalTokens") ?? getNumber3(tokenState, "totalTokens");
-}
-function extractGooseToolName(payload) {
-  const toolCall = getRecord4(payload.toolCall);
-  return getString5(toolCall, "name") ?? getString5(toolCall, "toolName") ?? getString5(payload, "toolName");
-}
-function extractGooseToolInput(payload) {
-  const toolCall = getRecord4(payload.toolCall);
-  const argumentsRecord = getRecord4(toolCall?.arguments) ?? getRecord4(toolCall?.args) ?? getRecord4(toolCall?.input) ?? getRecord4(payload.arguments);
-  const filePath = extractFirstString2(argumentsRecord, [
-    "file",
-    "file_path",
-    "filePath",
-    "path",
-    "target",
-    "target_path",
-    "targetPath"
-  ]);
-  const command = extractFirstString2(argumentsRecord, [
-    "cmd",
-    "command",
-    "script"
-  ]);
+  const toolInput = getRecord7(payload.tool_input) ?? getRecord7(payload.toolInput) ?? getRecord7(payload.arguments) ?? getRecord7(payload.params);
+  const filePath = getString8(toolInput, "filePath") ?? getString8(toolInput, "file_path") ?? getString8(toolInput, "path") ?? getString8(toolInput, "target");
+  const command = getString8(toolInput, "command") ?? getString8(toolInput, "cmd") ?? getString8(toolInput, "script");
   if (!filePath && !command) {
     return void 0;
   }
-  return {
-    command,
-    filePath
-  };
+  return { command, filePath };
 }
-function isGooseCodingTool(toolName, toolInput) {
-  if (toolName && GOOSE_CODING_TOOL_HINT.test(toolName)) {
-    return true;
-  }
-  const filePath = toolInput?.filePath;
-  if (!filePath) {
-    return false;
-  }
-  return !/read|view|glob|grep|list|search/iu.test(toolName ?? "");
+function isKiloCodingTool(toolName) {
+  return toolName !== void 0 && KILO_CODING_TOOLS.has(toolName);
 }
-function inferGooseErrorType(errorMessage) {
-  if (!errorMessage) {
-    return void 0;
-  }
-  if (GOOSE_RATE_LIMIT_HINT.test(errorMessage)) {
+function inferKiloErrorType(payload) {
+  const message = getString8(payload, "error") ?? getString8(payload, "message") ?? "";
+  if (/rate.?limit|quota|credit/i.test(message)) {
     return "rate_limit";
   }
-  if (/context|token limit|too long/iu.test(errorMessage)) {
+  if (/context|token.?limit|too.?long/i.test(message)) {
     return "context_overflow";
   }
-  if (/tool/iu.test(errorMessage)) {
+  if (/tool|permission|denied/i.test(message)) {
     return "tool_failure";
   }
   return "api_error";
 }
-async function listProcesses5(processListCommand) {
-  try {
-    const commandOutput = await processListCommand();
-    return commandOutput.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-      const [pidPart, ...commandParts] = line.split(/\s+/u);
-      const pid = pidPart ? Number.parseInt(pidPart, 10) : Number.NaN;
-      return {
-        command: commandParts.join(" "),
-        pid
-      };
-    }).filter((processInfo) => Number.isInteger(processInfo.pid));
-  } catch (error) {
-    logger.debug({ error }, "Goose process listing skipped");
+async function listProcesses8(listCommand) {
+  if (process.platform === "win32") {
     return [];
   }
-}
-function parseJsonRecord2(value) {
-  if (!value) {
-    return void 0;
-  }
   try {
-    const parsedValue = JSON.parse(value);
-    return getRecord4(parsedValue);
-  } catch {
-    return void 0;
-  }
-}
-function extractFirstString2(payload, keys) {
-  if (!payload) {
-    return void 0;
-  }
-  for (const key of keys) {
-    const directValue = getString5(payload, key);
-    if (directValue) {
-      return directValue;
-    }
+    const stdout = await listCommand();
+    return stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => line.includes("kilo") || line.includes("kilocode")).map(parseProcessLine6).filter((processInfo) => processInfo !== null);
+  } catch (error) {
+    logger.debug({ error }, "Kilo process detection failed");
+    return [];
   }
-  return void 0;
 }
-function extractLooseString2(payload, keys) {
-  if (!payload) {
-    return void 0;
-  }
-  for (const key of keys) {
-    const directValue = getString5(payload, key);
-    if (directValue) {
-      return directValue;
-    }
-    const nestedValue = getString5(getRecord4(payload[key]), "message");
-    if (nestedValue) {
-      return nestedValue;
-    }
+function parseProcessLine6(line) {
+  const match = line.match(/^(\d+)\s+(.+)$/u);
+  if (!match) {
+    return null;
   }
-  return void 0;
-}
-function getRecordArray(value) {
-  if (!Array.isArray(value)) {
-    return [];
+  const pidText = match[1];
+  const command = match[2];
+  if (!pidText || !command) {
+    return null;
   }
-  return value.filter((entry) => isRecord6(entry));
+  return {
+    command,
+    pid: Number.parseInt(pidText, 10)
+  };
 }
-function getRecord4(value) {
-  return isRecord6(value) ? value : void 0;
+function isErrnoException7(error) {
+  return error instanceof Error && "code" in error;
 }
-function isRecord6(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getString5(payload, key) {
-  if (!payload) {
-    return void 0;
-  }
+function getRecord7(value) {
+  return isRecord9(value) ? value : void 0;
+}
+function getNumber6(payload, key) {
   const value = payload[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function getNumber3(payload, key) {
+function getString8(payload, key) {
   if (!payload) {
     return void 0;
   }
   const value = payload[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
 
 // src/adapters/openclaw.ts
-var import_node_child_process9 = require("child_process");
-var import_promises11 = require("fs/promises");
-var import_node_path12 = require("path");
-var import_node_util9 = require("util");
-var import_chokidar7 = require("chokidar");
+var import_node_child_process12 = require("child_process");
+var import_promises14 = require("fs/promises");
+var import_node_path15 = require("path");
+var import_node_util12 = require("util");
+var import_chokidar10 = require("chokidar");
 var import_pid_cwd3 = __toESM(require("pid-cwd"), 1);
-var execFile9 = (0, import_node_util9.promisify)(import_node_child_process9.execFile);
+var execFile12 = (0, import_node_util12.promisify)(import_node_child_process12.execFile);
 var COMMAND_START_THINKING_DELAY_MS = 2e3;
 var POST_TOOL_THINKING_DELAY_MS = 500;
 var OPENCLAW_CODING_TOOL_HINT = /apply|bash|create|delete|edit|exec|file|patch|replace|shell|write/iu;
@@ -8137,22 +9584,22 @@ var OpenClawAdapter = class extends BaseAdapter {
   fileRemainders = /* @__PURE__ */ new Map();
   constructor(options) {
     super(options);
-    const openclawHome = (0, import_node_path12.join)(this.getUserHomeDirectory(), ".openclaw");
-    this.agentsDirectory = options.agentsDirectory ?? (0, import_node_path12.join)(openclawHome, "agents");
-    this.commandsLogPath = options.commandsLogPath ?? (0, import_node_path12.join)(openclawHome, "logs", "commands.log");
+    const openclawHome = (0, import_node_path15.join)(this.getUserHomeDirectory(), ".openclaw");
+    this.agentsDirectory = options.agentsDirectory ?? (0, import_node_path15.join)(openclawHome, "agents");
+    this.commandsLogPath = options.commandsLogPath ?? (0, import_node_path15.join)(openclawHome, "logs", "commands.log");
     this.cwdResolver = options.cwdResolver ?? (async (pid) => {
       return await (0, import_pid_cwd3.default)(pid);
     });
     this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
-    this.processListCommand = options.processListCommand ?? (async () => await execFile9("pgrep", ["-ifl", "openclaw"]).then(
+    this.processListCommand = options.processListCommand ?? (async () => await execFile12("pgrep", ["-ifl", "openclaw"]).then(
       (result) => result.stdout
     ));
-    this.watcherFactory = options.watcherFactory ?? import_chokidar7.watch;
+    this.watcherFactory = options.watcherFactory ?? import_chokidar10.watch;
     this.memoryRootGlobs = [
-      (0, import_node_path12.join)(openclawHome, "workspace", "MEMORY.md"),
-      (0, import_node_path12.join)(openclawHome, "workspace", "memory", "*.md"),
-      (0, import_node_path12.join)(openclawHome, "workspace-*", "MEMORY.md"),
-      (0, import_node_path12.join)(openclawHome, "workspace-*", "memory", "*.md")
+      (0, import_node_path15.join)(openclawHome, "workspace", "MEMORY.md"),
+      (0, import_node_path15.join)(openclawHome, "workspace", "memory", "*.md"),
+      (0, import_node_path15.join)(openclawHome, "workspace-*", "MEMORY.md"),
+      (0, import_node_path15.join)(openclawHome, "workspace-*", "memory", "*.md")
     ];
   }
   async start() {
@@ -8181,7 +9628,7 @@ var OpenClawAdapter = class extends BaseAdapter {
       logger.warn({ error }, "OpenClaw commands.log watcher error");
     });
     this.transcriptWatcher = this.watcherFactory(
-      (0, import_node_path12.join)(this.agentsDirectory, "*", "sessions", "*.jsonl"),
+      (0, import_node_path15.join)(this.agentsDirectory, "*", "sessions", "*.jsonl"),
       {
         awaitWriteFinish: {
           stabilityThreshold: 200
@@ -8263,7 +9710,7 @@ var OpenClawAdapter = class extends BaseAdapter {
       });
       return;
     }
-    if (!isRecord7(payload)) {
+    if (!isRecord10(payload)) {
       logger.warn({ payload }, "OpenClaw payload must be an object");
       return;
     }
@@ -8281,7 +9728,7 @@ var OpenClawAdapter = class extends BaseAdapter {
     const sessionId = resolveSessionId({
       activeFile: extractOpenClawActiveFile(payload),
       cwd: extractOpenClawCwd(payload),
-      pid: getNumber4(payload, "pid"),
+      pid: getNumber7(payload, "pid"),
       project: extractOpenClawProject(payload),
       projectPath: extractOpenClawCwd(payload),
       sessionId: extractOpenClawSessionKey(payload),
@@ -8291,7 +9738,7 @@ var OpenClawAdapter = class extends BaseAdapter {
     const context = {
       cwd: extractOpenClawCwd(payload),
       hookPayload: payload,
-      pid: getNumber4(payload, "pid"),
+      pid: getNumber7(payload, "pid"),
       sessionId,
       source,
       transcriptPath
@@ -8429,24 +9876,24 @@ var OpenClawAdapter = class extends BaseAdapter {
     await this.seedFileOffset(this.commandsLogPath);
   }
   async seedTranscriptOffsets() {
-    const files = await collectFilesRecursively4(this.agentsDirectory, ".jsonl");
+    const files = await collectFilesRecursively7(this.agentsDirectory, ".jsonl");
     await Promise.all(files.map(async (filePath) => await this.seedFileOffset(filePath)));
   }
   async seedMemoryOffsets() {
-    for (const root of [(0, import_node_path12.join)(this.getUserHomeDirectory(), ".openclaw", "workspace")]) {
+    for (const root of [(0, import_node_path15.join)(this.getUserHomeDirectory(), ".openclaw", "workspace")]) {
       await Promise.all([
-        this.seedDirectoryFileOffsets((0, import_node_path12.join)(root, "memory"), ".md"),
-        this.seedFileOffset((0, import_node_path12.join)(root, "MEMORY.md"))
+        this.seedDirectoryFileOffsets((0, import_node_path15.join)(root, "memory"), ".md"),
+        this.seedFileOffset((0, import_node_path15.join)(root, "MEMORY.md"))
       ]);
     }
   }
   async seedDirectoryFileOffsets(directory, extension) {
-    const files = await collectFilesRecursively4(directory, extension);
+    const files = await collectFilesRecursively7(directory, extension);
     await Promise.all(files.map(async (filePath) => await this.seedFileOffset(filePath)));
   }
   async seedFileOffset(filePath) {
     try {
-      const fileStats = await (0, import_promises11.stat)(filePath);
+      const fileStats = await (0, import_promises14.stat)(filePath);
       this.fileOffsets.set(filePath, fileStats.size);
     } catch {
     }
@@ -8478,7 +9925,7 @@ var OpenClawAdapter = class extends BaseAdapter {
   }
   async processTranscriptLine(line, filePath) {
     const rawSessionId = extractOpenClawSessionKey(line) ?? inferOpenClawSessionIdFromTranscriptPath(filePath);
-    const cwd = extractOpenClawCwd(line) ?? (0, import_node_path12.dirname)((0, import_node_path12.dirname)(filePath));
+    const cwd = extractOpenClawCwd(line) ?? (0, import_node_path15.dirname)((0, import_node_path15.dirname)(filePath));
     const sessionId = resolveSessionId({
       cwd,
       projectPath: cwd,
@@ -8486,7 +9933,7 @@ var OpenClawAdapter = class extends BaseAdapter {
       tool: this.name,
       transcriptPath: filePath
     });
-    const eventFingerprint = getString6(line, "id") ?? `${filePath}:${getString6(line, "timestamp") ?? JSON.stringify(line).slice(0, 120)}`;
+    const eventFingerprint = getString9(line, "id") ?? `${filePath}:${getString9(line, "timestamp") ?? JSON.stringify(line).slice(0, 120)}`;
     const dedupeKey = `${sessionId}:${eventFingerprint}`;
     if (this.observedTranscriptEntries.has(dedupeKey)) {
       return;
@@ -8503,7 +9950,7 @@ var OpenClawAdapter = class extends BaseAdapter {
     };
     const sharedData = {
       cwd,
-      project: (0, import_node_path12.basename)(cwd) || cwd,
+      project: (0, import_node_path15.basename)(cwd) || cwd,
       projectPath: cwd,
       raw: line
     };
@@ -8513,11 +9960,11 @@ var OpenClawAdapter = class extends BaseAdapter {
       sessionId,
       transcriptPath: filePath
     });
-    if (getString6(line, "type") === "session") {
+    if (getString9(line, "type") === "session") {
       await this.emitOpenClawSessionStart(sharedData, context);
       return;
     }
-    if (getString6(line, "type") === "compaction") {
+    if (getString9(line, "type") === "compaction") {
       await this.ensureSessionStarted(sharedData, context);
       await this.emitStateChange("agent.compact", sharedData, context);
       return;
@@ -8572,7 +10019,7 @@ var OpenClawAdapter = class extends BaseAdapter {
     }
   }
   async processMemoryUpdate(filePath, readFromStart) {
-    const baseName = (0, import_node_path12.basename)(filePath);
+    const baseName = (0, import_node_path15.basename)(filePath);
     const resolvedSession = this.resolveMemorySession(filePath);
     if (!resolvedSession) {
       return;
@@ -8643,7 +10090,7 @@ var OpenClawAdapter = class extends BaseAdapter {
     );
   }
   resolveMemorySession(filePath) {
-    const workspaceDirectory = (0, import_node_path12.basename)(filePath) === "MEMORY.md" ? (0, import_node_path12.dirname)(filePath) : (0, import_node_path12.dirname)((0, import_node_path12.dirname)(filePath));
+    const workspaceDirectory = (0, import_node_path15.basename)(filePath) === "MEMORY.md" ? (0, import_node_path15.dirname)(filePath) : (0, import_node_path15.dirname)((0, import_node_path15.dirname)(filePath));
     for (const snapshot of this.sessionSnapshots.values()) {
       if (snapshot.cwd === workspaceDirectory) {
         return snapshot;
@@ -8652,19 +10099,19 @@ var OpenClawAdapter = class extends BaseAdapter {
     const sessionId = resolveSessionId({
       cwd: workspaceDirectory,
       projectPath: workspaceDirectory,
-      sessionId: `openclaw:${(0, import_node_path12.basename)(workspaceDirectory)}:memory`,
+      sessionId: `openclaw:${(0, import_node_path15.basename)(workspaceDirectory)}:memory`,
       tool: this.name
     });
     return {
       cwd: workspaceDirectory,
-      project: (0, import_node_path12.basename)(workspaceDirectory) || workspaceDirectory,
+      project: (0, import_node_path15.basename)(workspaceDirectory) || workspaceDirectory,
       sessionId
     };
   }
   async readIncrementalLines(filePath, readFromStart) {
     let fileContent;
     try {
-      fileContent = await (0, import_promises11.readFile)(filePath);
+      fileContent = await (0, import_promises14.readFile)(filePath);
     } catch (error) {
       logger.debug({ error, filePath }, "OpenClaw source read skipped");
       return [];
@@ -8708,7 +10155,7 @@ var OpenClawAdapter = class extends BaseAdapter {
       });
       const data = {
         cwd,
-        project: cwd ? (0, import_node_path12.basename)(cwd) || cwd : void 0,
+        project: cwd ? (0, import_node_path15.basename)(cwd) || cwd : void 0,
         projectPath: cwd,
         raw: {
           process: processInfo,
@@ -8750,18 +10197,18 @@ var OpenClawAdapter = class extends BaseAdapter {
     }
   }
 };
-async function collectFilesRecursively4(directory, extension) {
+async function collectFilesRecursively7(directory, extension) {
   try {
-    const directoryEntries = await (0, import_promises11.readdir)(directory, {
+    const directoryEntries = await (0, import_promises14.readdir)(directory, {
       withFileTypes: true
     });
     const nestedFiles = await Promise.all(
       directoryEntries.map(async (entry) => {
-        const entryPath = (0, import_node_path12.join)(directory, entry.name);
+        const entryPath = (0, import_node_path15.join)(directory, entry.name);
         if (entry.isDirectory()) {
-          return await collectFilesRecursively4(entryPath, extension);
+          return await collectFilesRecursively7(entryPath, extension);
         }
-        return (0, import_node_path12.extname)(entry.name) === extension ? [entryPath] : [];
+        return (0, import_node_path15.extname)(entry.name) === extension ? [entryPath] : [];
       })
     );
     return nestedFiles.flat();
@@ -8818,12 +10265,12 @@ function buildOpenClawEventData(payload) {
   };
 }
 function extractOpenClawEventName(payload) {
-  const explicitEvent = getString6(payload, "event") ?? getString6(payload, "hook_event_name") ?? getString6(payload, "hookEventName");
+  const explicitEvent = getString9(payload, "event") ?? getString9(payload, "hook_event_name") ?? getString9(payload, "hookEventName");
   if (explicitEvent) {
     return explicitEvent;
   }
-  const type = getString6(payload, "type");
-  const action = getString6(payload, "action");
+  const type = getString9(payload, "type");
+  const action = getString9(payload, "action");
   if (!type) {
     return void 0;
   }
@@ -8836,31 +10283,31 @@ function extractOpenClawEventName(payload) {
   return `${type}:${action}`;
 }
 function extractOpenClawSessionKey(payload) {
-  return getString6(payload, "sessionKey") ?? getString6(payload, "sessionId") ?? getString6(payload, "session_id") ?? getString6(getRecord5(payload.context), "sessionKey") ?? getString6(getRecord5(payload.context), "sessionId") ?? getString6(getRecord5(payload.context), "session_id") ?? getString6(getRecord5(payload.context), "sessionEntry");
+  return getString9(payload, "sessionKey") ?? getString9(payload, "sessionId") ?? getString9(payload, "session_id") ?? getString9(getRecord8(payload.context), "sessionKey") ?? getString9(getRecord8(payload.context), "sessionId") ?? getString9(getRecord8(payload.context), "session_id") ?? getString9(getRecord8(payload.context), "sessionEntry");
 }
 function extractOpenClawCwd(payload) {
-  const context = getRecord5(payload.context);
-  return getString6(payload, "cwd") ?? getString6(payload, "workspaceDir") ?? getString6(context, "workspaceDir") ?? getString6(context, "cwd");
+  const context = getRecord8(payload.context);
+  return getString9(payload, "cwd") ?? getString9(payload, "workspaceDir") ?? getString9(context, "workspaceDir") ?? getString9(context, "cwd");
 }
 function extractOpenClawProject(payload) {
   const cwd = extractOpenClawCwd(payload);
   if (cwd) {
-    return (0, import_node_path12.basename)(cwd) || cwd;
+    return (0, import_node_path15.basename)(cwd) || cwd;
   }
-  return getString6(payload, "project") ?? getString6(getRecord5(payload.context), "project");
+  return getString9(payload, "project") ?? getString9(getRecord8(payload.context), "project");
 }
 function extractOpenClawActiveFile(payload) {
   const toolInput = extractOpenClawToolInput(payload);
-  return getString6(payload, "activeFile") ?? getString6(payload, "filePath") ?? getString6(getRecord5(payload.context), "filePath") ?? toolInput?.filePath;
+  return getString9(payload, "activeFile") ?? getString9(payload, "filePath") ?? getString9(getRecord8(payload.context), "filePath") ?? toolInput?.filePath;
 }
 function extractOpenClawToolName(payload) {
-  return getString6(payload, "toolName") ?? getString6(payload, "tool_name") ?? getString6(getRecord5(payload.tool), "name") ?? getString6(getRecord5(payload.data), "toolName") ?? getString6(getRecord5(payload.result), "toolName");
+  return getString9(payload, "toolName") ?? getString9(payload, "tool_name") ?? getString9(getRecord8(payload.tool), "name") ?? getString9(getRecord8(payload.data), "toolName") ?? getString9(getRecord8(payload.result), "toolName");
 }
 function extractOpenClawToolInput(payload) {
-  const context = getRecord5(payload.context);
-  const argsRecord = getRecord5(payload.toolInput) ?? getRecord5(payload.tool_input) ?? getRecord5(payload.params) ?? getRecord5(payload.arguments) ?? getRecord5(getRecord5(payload.tool)?.params) ?? getRecord5(getRecord5(payload.tool)?.arguments) ?? getRecord5(context?.params) ?? getRecord5(context?.arguments);
-  const filePath = getString6(payload, "filePath") ?? getString6(argsRecord, "filePath") ?? getString6(argsRecord, "path");
-  const command = getString6(payload, "command") ?? getString6(argsRecord, "command") ?? getString6(argsRecord, "cmd");
+  const context = getRecord8(payload.context);
+  const argsRecord = getRecord8(payload.toolInput) ?? getRecord8(payload.tool_input) ?? getRecord8(payload.params) ?? getRecord8(payload.arguments) ?? getRecord8(getRecord8(payload.tool)?.params) ?? getRecord8(getRecord8(payload.tool)?.arguments) ?? getRecord8(context?.params) ?? getRecord8(context?.arguments);
+  const filePath = getString9(payload, "filePath") ?? getString9(argsRecord, "filePath") ?? getString9(argsRecord, "path");
+  const command = getString9(payload, "command") ?? getString9(argsRecord, "command") ?? getString9(argsRecord, "cmd");
   if (!filePath && !command) {
     return void 0;
   }
@@ -8870,7 +10317,7 @@ function extractOpenClawToolInput(payload) {
   };
 }
 function extractOpenClawErrorMessage(payload) {
-  return getString6(payload, "error") ?? getString6(payload, "message") ?? getString6(getRecord5(payload.error), "message") ?? getString6(getRecord5(payload.result), "error");
+  return getString9(payload, "error") ?? getString9(payload, "message") ?? getString9(getRecord8(payload.error), "message") ?? getString9(getRecord8(payload.result), "error");
 }
 function inferOpenClawErrorType(payload) {
   const errorMessage = extractOpenClawErrorMessage(payload);
@@ -8887,10 +10334,10 @@ function inferOpenClawErrorType(payload) {
   return OPENCLAW_ERROR_HINT.test(errorMessage) ? "tool_failure" : "api_error";
 }
 function extractOpenClawModel(payload) {
-  return getString6(payload, "model") ?? getString6(getRecord5(payload.context), "model") ?? getString6(getRecord5(payload.sessionEntry), "model");
+  return getString9(payload, "model") ?? getString9(getRecord8(payload.context), "model") ?? getString9(getRecord8(payload.sessionEntry), "model");
 }
 function extractOpenClawTokens(payload) {
-  const directTokens = getNumber4(payload, "totalTokens") ?? getNumber4(payload, "tokensUsed") ?? getNumber4(getRecord5(payload.sessionEntry), "totalTokens") ?? getNumber4(getRecord5(payload.stats), "totalTokens");
+  const directTokens = getNumber7(payload, "totalTokens") ?? getNumber7(payload, "tokensUsed") ?? getNumber7(getRecord8(payload.sessionEntry), "totalTokens") ?? getNumber7(getRecord8(payload.stats), "totalTokens");
   return directTokens === void 0 ? void 0 : Math.max(0, directTokens);
 }
 function isOpenClawCodingTool(toolName, toolInput) {
@@ -8899,18 +10346,18 @@ function isOpenClawCodingTool(toolName, toolInput) {
   );
 }
 function inferOpenClawSessionIdFromTranscriptPath(filePath) {
-  const fileName = (0, import_node_path12.basename)(filePath, (0, import_node_path12.extname)(filePath));
+  const fileName = (0, import_node_path15.basename)(filePath, (0, import_node_path15.extname)(filePath));
   return fileName.length > 0 ? fileName : void 0;
 }
 function extractOpenClawTranscriptToolObservation(payload) {
-  const nestedMessage = getRecord5(payload.message) ?? getRecord5(payload.data);
-  const role = getString6(payload, "role") ?? getString6(nestedMessage, "role") ?? getString6(getRecord5(payload.entry), "role");
-  const toolName = extractOpenClawToolName(payload) ?? getString6(nestedMessage, "name") ?? getString6(getRecord5(payload.tool), "name");
+  const nestedMessage = getRecord8(payload.message) ?? getRecord8(payload.data);
+  const role = getString9(payload, "role") ?? getString9(nestedMessage, "role") ?? getString9(getRecord8(payload.entry), "role");
+  const toolName = extractOpenClawToolName(payload) ?? getString9(nestedMessage, "name") ?? getString9(getRecord8(payload.tool), "name");
   const toolInput = extractOpenClawToolInput(payload);
-  const activeFile = extractOpenClawActiveFile(payload) ?? getString6(nestedMessage, "filePath") ?? toolInput?.filePath;
-  const content = getString6(nestedMessage, "content");
+  const activeFile = extractOpenClawActiveFile(payload) ?? getString9(nestedMessage, "filePath") ?? toolInput?.filePath;
+  const content = getString9(nestedMessage, "content");
   const looksLikeToolPayload = Boolean(
-    role === "tool" || role === "tool_result" || toolName || getString6(payload, "type") === "tool_result" || content?.includes("tool") || Array.isArray(getRecord5(nestedMessage)?.content)
+    role === "tool" || role === "tool_result" || toolName || getString9(payload, "type") === "tool_result" || content?.includes("tool") || Array.isArray(getRecord8(nestedMessage)?.content)
   );
   if (!looksLikeToolPayload) {
     return null;
@@ -8923,37 +10370,37 @@ function extractOpenClawTranscriptToolObservation(payload) {
   };
 }
 function extractOpenClawTranscriptThinkingText(payload) {
-  const directReasoning = getString6(payload, "reasoning") ?? getString6(getRecord5(payload.message), "reasoning") ?? getString6(getRecord5(payload.data), "reasoning");
+  const directReasoning = getString9(payload, "reasoning") ?? getString9(getRecord8(payload.message), "reasoning") ?? getString9(getRecord8(payload.data), "reasoning");
   if (directReasoning) {
     return directReasoning;
   }
-  const content = getRecord5(payload.message)?.content;
+  const content = getRecord8(payload.message)?.content;
   if (!Array.isArray(content)) {
     return void 0;
   }
   for (const item of content) {
-    const itemRecord = getRecord5(item);
-    const itemType = getString6(itemRecord, "type");
+    const itemRecord = getRecord8(item);
+    const itemType = getString9(itemRecord, "type");
     if (itemType === "thinking" || itemType === "reasoning") {
-      return getString6(itemRecord, "thinking") ?? getString6(itemRecord, "text") ?? getString6(itemRecord, "content");
+      return getString9(itemRecord, "thinking") ?? getString9(itemRecord, "text") ?? getString9(itemRecord, "content");
     }
   }
   return void 0;
 }
 function extractOpenClawTranscriptStreamingText(payload) {
-  const directText = getString6(payload, "text") ?? getString6(getRecord5(payload.message), "text") ?? getString6(getRecord5(payload.data), "text");
+  const directText = getString9(payload, "text") ?? getString9(getRecord8(payload.message), "text") ?? getString9(getRecord8(payload.data), "text");
   if (directText) {
     return directText;
   }
-  const content = getRecord5(payload.message)?.content;
+  const content = getRecord8(payload.message)?.content;
   if (!Array.isArray(content)) {
     return void 0;
   }
   for (const item of content) {
-    const itemRecord = getRecord5(item);
-    const itemType = getString6(itemRecord, "type");
+    const itemRecord = getRecord8(item);
+    const itemType = getString9(itemRecord, "type");
     if (itemType === "text" || itemType === "output_text") {
-      return getString6(itemRecord, "text") ?? getString6(itemRecord, "content");
+      return getString9(itemRecord, "text") ?? getString9(itemRecord, "content");
     }
   }
   return void 0;
@@ -8961,30 +10408,30 @@ function extractOpenClawTranscriptStreamingText(payload) {
 function parseJsonRecord3(value) {
   try {
     const parsedValue = JSON.parse(value);
-    return getRecord5(parsedValue) ?? null;
+    return getRecord8(parsedValue) ?? null;
   } catch {
     return null;
   }
 }
-function getRecord5(value) {
+function getRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function getString6(payload, key) {
+function getString9(payload, key) {
   const value = payload?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-function getNumber4(payload, key) {
+function getNumber7(payload, key) {
   const value = payload?.[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function isRecord7(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/adapters/opencode.ts
-var import_node_child_process10 = require("child_process");
-var import_node_util10 = require("util");
-var execFile10 = (0, import_node_util10.promisify)(import_node_child_process10.execFile);
+var import_node_child_process13 = require("child_process");
+var import_node_util13 = require("util");
+var execFile13 = (0, import_node_util13.promisify)(import_node_child_process13.execFile);
 var OPENCODE_CODING_TOOLS = /* @__PURE__ */ new Set(["edit", "multi_edit", "write"]);
 var OpenCodeAdapter = class extends BaseAdapter {
   displayName = "OpenCode";
@@ -9000,7 +10447,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
   constructor(options) {
     super(options);
     this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
-    this.processListCommand = options.processListCommand ?? (async () => await execFile10("pgrep", ["-lf", "opencode"]).then((result) => result.stdout));
+    this.processListCommand = options.processListCommand ?? (async () => await execFile13("pgrep", ["-lf", "opencode"]).then((result) => result.stdout));
   }
   start() {
     if (this.getStatus().running) {
@@ -9036,11 +10483,11 @@ var OpenCodeAdapter = class extends BaseAdapter {
       });
       return;
     }
-    if (!isRecord8(payload)) {
+    if (!isRecord11(payload)) {
       logger.warn({ payload }, "OpenCode payload must be an object");
       return;
     }
-    const eventType = getString7(payload, "type");
+    const eventType = getString10(payload, "type");
     if (!eventType) {
       logger.warn({ payload }, "OpenCode payload is missing its event type");
       return;
@@ -9048,7 +10495,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
     const sessionId = resolveSessionId({
       activeFile: extractOpenCodeActiveFile(payload),
       cwd: extractOpenCodeCwd(payload),
-      pid: getNumber5(payload, "pid"),
+      pid: getNumber8(payload, "pid"),
       project: extractOpenCodeProject(payload),
       sessionId: extractOpenCodeSessionId(payload),
       tool: this.name
@@ -9058,7 +10505,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
       // 📖 Pass process.env so the context detector can detect the terminal
       env: this.env ?? process.env,
       hookPayload: payload,
-      pid: getNumber5(payload, "pid"),
+      pid: getNumber8(payload, "pid"),
       sessionId,
       source: "aisnitch://adapters/opencode"
     };
@@ -9068,7 +10515,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
       errorMessage: extractOpenCodeErrorMessage(payload),
       errorType: extractOpenCodeErrorType(payload),
       // 📖 Extract model from payload — OpenCode may send it as "model" or nested in properties
-      model: getString7(payload, "model") ?? getString7(getRecord6(payload.properties), "model"),
+      model: getString10(payload, "model") ?? getString10(getRecord9(payload.properties), "model"),
       project: extractOpenCodeProject(payload),
       raw: payload,
       toolInput: extractOpenCodeToolInput(payload),
@@ -9131,7 +10578,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
     void this.pollOpenCodeProcesses();
   }
   async pollOpenCodeProcesses() {
-    const processes = await listProcesses6(this.processListCommand);
+    const processes = await listProcesses9(this.processListCommand);
     if (processes.length > 0 && this.getStatus().activeSessions === 0) {
       const processInfo = processes[0];
       if (!processInfo) {
@@ -9174,7 +10621,7 @@ var OpenCodeAdapter = class extends BaseAdapter {
     }
   }
 };
-async function listProcesses6(listCommand) {
+async function listProcesses9(listCommand) {
   if (process.platform === "win32") {
     return [];
   }
@@ -9205,33 +10652,33 @@ async function listProcesses6(listCommand) {
   }
 }
 function extractOpenCodeSessionId(payload) {
-  const directSessionId = getString7(payload, "sessionID") ?? getString7(payload, "sessionId");
+  const directSessionId = getString10(payload, "sessionID") ?? getString10(payload, "sessionId");
   if (directSessionId) {
     return directSessionId;
   }
-  const properties = getRecord6(payload.properties);
-  return getString7(properties, "sessionID") ?? getString7(properties, "sessionId");
+  const properties = getRecord9(payload.properties);
+  return getString10(properties, "sessionID") ?? getString10(properties, "sessionId");
 }
 function extractOpenCodeCwd(payload) {
-  return getString7(payload, "cwd") ?? getString7(getRecord6(payload.properties), "cwd");
+  return getString10(payload, "cwd") ?? getString10(getRecord9(payload.properties), "cwd");
 }
 function extractOpenCodeProject(payload) {
-  return getString7(payload, "project") ?? getString7(getRecord6(payload.properties), "project");
+  return getString10(payload, "project") ?? getString10(getRecord9(payload.properties), "project");
 }
 function extractOpenCodeToolName(payload) {
-  const tool = getRecord6(payload.tool);
-  return getString7(tool, "name") ?? getString7(payload, "tool");
+  const tool = getRecord9(payload.tool);
+  return getString10(tool, "name") ?? getString10(payload, "tool");
 }
 function extractOpenCodeActiveFile(payload) {
-  return getString7(payload, "file") ?? getString7(getRecord6(payload.properties), "file") ?? extractOpenCodeToolInput(payload)?.filePath;
+  return getString10(payload, "file") ?? getString10(getRecord9(payload.properties), "file") ?? extractOpenCodeToolInput(payload)?.filePath;
 }
 function extractOpenCodeToolInput(payload) {
-  const args = getRecord6(payload.args) ?? getRecord6(getRecord6(payload.output)?.args) ?? getRecord6(getRecord6(payload.properties)?.args);
+  const args = getRecord9(payload.args) ?? getRecord9(getRecord9(payload.output)?.args) ?? getRecord9(getRecord9(payload.properties)?.args);
   if (!args) {
     return void 0;
   }
-  const command = getString7(args, "command") ?? getString7(args, "cmd");
-  const filePath = getString7(args, "filePath") ?? getString7(args, "file_path") ?? getString7(args, "path");
+  const command = getString10(args, "command") ?? getString10(args, "cmd");
+  const filePath = getString10(args, "filePath") ?? getString10(args, "file_path") ?? getString10(args, "path");
   if (!command && !filePath) {
     return void 0;
   }
@@ -9241,10 +10688,10 @@ function extractOpenCodeToolInput(payload) {
   };
 }
 function extractOpenCodeErrorMessage(payload) {
-  return getString7(getRecord6(payload.error), "message") ?? getString7(payload, "message");
+  return getString10(getRecord9(payload.error), "message") ?? getString10(payload, "message");
 }
 function extractOpenCodeErrorType(payload) {
-  const rawType = getString7(payload, "errorType") ?? getString7(getRecord6(payload.error), "type");
+  const rawType = getString10(payload, "errorType") ?? getString10(getRecord9(payload.error), "type");
   switch (rawType) {
     case "rate_limit":
       return "rate_limit";
@@ -9262,17 +10709,17 @@ function extractOpenCodeErrorType(payload) {
 function isOpenCodeCodingTool(toolName) {
   return toolName !== void 0 && OPENCODE_CODING_TOOLS.has(toolName);
 }
-function isRecord8(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getRecord6(value) {
-  return isRecord8(value) ? value : void 0;
+function getRecord9(value) {
+  return isRecord11(value) ? value : void 0;
 }
-function getNumber5(payload, key) {
+function getNumber8(payload, key) {
   const value = payload[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function getString7(payload, key) {
+function getString10(payload, key) {
   if (!payload) {
     return void 0;
   }
@@ -9356,8 +10803,11 @@ function createDefaultAdapters(options) {
     new AiderAdapter(options),
     new ClaudeCodeAdapter(options),
     new CopilotCLIAdapter(options),
+    new CursorAdapter(options),
+    new DevinAdapter(options),
     new GeminiCLIAdapter(options),
     new GooseAdapter(options),
+    new KiloAdapter(options),
     new CodexAdapter(options),
     new OpenClawAdapter(options),
     new OpenCodeAdapter(options)
@@ -9381,7 +10831,7 @@ function getSocketPath(aisnitchHomePath) {
   if (process.platform === "win32") {
     return "\\\\.\\pipe\\aisnitch.sock";
   }
-  return (0, import_node_path13.join)(aisnitchHomePath, "aisnitch.sock");
+  return (0, import_node_path16.join)(aisnitchHomePath, "aisnitch.sock");
 }
 var Pipeline = class {
   eventBus = new EventBus();
@@ -9685,7 +11135,7 @@ function formatEventDetail(event) {
   return segments.length > 0 ? segments.join(" | ") : null;
 }
 function getEventDetailSegments(event) {
-  const raw = getRecord7(event.data.raw);
+  const raw = getRecord10(event.data.raw);
   const segments = [];
   switch (event.type) {
     case "agent.tool_call":
@@ -9727,7 +11177,7 @@ function getEventDetailSegments(event) {
       break;
     case "agent.asking_user":
       segments.push(
-        getString8(raw, "notification_type") ?? getString8(raw, "notificationType") ?? getString8(raw, "type")
+        getString11(raw, "notification_type") ?? getString11(raw, "notificationType") ?? getString11(raw, "type")
       );
       segments.push(event.data.errorMessage ?? extractLooseString3(raw, [
         "message",
@@ -9794,17 +11244,17 @@ function extractContentPart(raw, partType, valueKey) {
   if (!raw) {
     return void 0;
   }
-  const message = getRecord7(raw.message);
+  const message = getRecord10(raw.message);
   const content = message?.content ?? raw.content;
   if (!Array.isArray(content)) {
     return void 0;
   }
   for (const part of content) {
-    const record = getRecord7(part);
-    if (!record || getString8(record, "type") !== partType) {
+    const record = getRecord10(part);
+    if (!record || getString11(record, "type") !== partType) {
       continue;
     }
-    const value = getString8(record, valueKey);
+    const value = getString11(record, valueKey);
     if (value) {
       return value;
     }
@@ -9816,12 +11266,12 @@ function extractLooseString3(raw, keys) {
     return void 0;
   }
   for (const key of keys) {
-    const directValue = getString8(raw, key);
+    const directValue = getString11(raw, key);
     if (directValue) {
       return directValue;
     }
-    const nestedRecord = getRecord7(raw[key]);
-    const nestedValue = getString8(nestedRecord, "text") ?? getString8(nestedRecord, "message") ?? getString8(nestedRecord, "content");
+    const nestedRecord = getRecord10(raw[key]);
+    const nestedValue = getString11(nestedRecord, "text") ?? getString11(nestedRecord, "message") ?? getString11(nestedRecord, "content");
     if (nestedValue) {
       return nestedValue;
     }
@@ -9835,13 +11285,13 @@ function truncateSegment(value) {
   }
   return `${normalized.slice(0, DETAIL_SEGMENT_LIMIT - 1)}\u2026`;
 }
-function isRecord9(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getRecord7(value) {
-  return isRecord9(value) ? value : void 0;
+function getRecord10(value) {
+  return isRecord12(value) ? value : void 0;
 }
-function getString8(payload, key) {
+function getString11(payload, key) {
   if (!payload) {
     return void 0;
   }
@@ -9851,23 +11301,27 @@ function getString8(payload, key) {
 
 // src/tui/theme.ts
 var TOOL_COLORS = {
-  aider: "#14b8a6",
-  amp: "#fb7185",
+  "aider": "#14b8a6",
+  "amp": "#fb7185",
+  "augment-code": "#c084fc",
   "claude-code": "#f59e0b",
-  cline: "#f43f5e",
-  codex: "#f97316",
-  continue: "#06b6d4",
+  "cline": "#f43f5e",
+  "codex": "#f97316",
+  "continue": "#06b6d4",
   "copilot-cli": "#60a5fa",
-  cursor: "#8b5cf6",
+  "cursor": "#8b5cf6",
+  "devin": "#f59e0b",
   "gemini-cli": "#38bdf8",
-  goose: "#ec4899",
-  kilo: "#84cc16",
-  openclaw: "#ef4444",
-  opencode: "#10b981",
-  openhands: "#facc15",
+  "goose": "#ec4899",
+  "kilo": "#84cc16",
+  "kiro": "#06b6d4",
+  "mistral": "#fb923c",
+  "openhands": "#facc15",
+  "openclaw": "#ef4444",
+  "opencode": "#10b981",
   "qwen-code": "#22c55e",
-  unknown: "#94a3b8",
-  windsurf: "#c084fc"
+  "unknown": "#94a3b8",
+  "windsurf": "#a855f7"
 };
 var EVENT_COLORS = {
   "agent.asking_user": "#ef4444",
@@ -11621,10 +13075,10 @@ async function renderManagedTui(options) {
 
 // src/cli/pid.ts
 var import_node_fs3 = require("fs");
-var import_promises12 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_net3 = require("net");
 var import_node_os4 = require("os");
-var import_node_path14 = require("path");
+var import_node_path17 = require("path");
 var import_zod5 = require("zod");
 var DaemonStateSchema = import_zod5.z.strictObject({
   pid: import_zod5.z.number().int().positive(),
@@ -11639,14 +13093,14 @@ function getDefaultSocketPath(options) {
   if (process.platform === "win32") {
     return "\\\\.\\pipe\\aisnitch.sock";
   }
-  return (0, import_node_path14.join)(getAISnitchHomePath(options), "aisnitch.sock");
+  return (0, import_node_path17.join)(getAISnitchHomePath(options), "aisnitch.sock");
 }
 async function cleanupSocketPathIfStale(socketPath) {
   if (process.platform === "win32") {
     return false;
   }
   try {
-    await (0, import_promises12.access)(socketPath, import_node_fs3.constants.F_OK);
+    await (0, import_promises15.access)(socketPath, import_node_fs3.constants.F_OK);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return false;
@@ -11670,20 +13124,20 @@ async function cleanupSocketPathIfStale(socketPath) {
   if (!staleSocket) {
     return false;
   }
-  await (0, import_promises12.rm)(socketPath, { force: true });
+  await (0, import_promises15.rm)(socketPath, { force: true });
   return true;
 }
 function getPidFilePath(options = {}) {
-  return (0, import_node_path14.join)(getAISnitchHomePath(options), "aisnitch.pid");
+  return (0, import_node_path17.join)(getAISnitchHomePath(options), "aisnitch.pid");
 }
 function getDaemonStatePath(options = {}) {
-  return (0, import_node_path14.join)(getAISnitchHomePath(options), "daemon-state.json");
+  return (0, import_node_path17.join)(getAISnitchHomePath(options), "daemon-state.json");
 }
 function getDaemonLogPath(options = {}) {
-  return (0, import_node_path14.join)(getAISnitchHomePath(options), "daemon.log");
+  return (0, import_node_path17.join)(getAISnitchHomePath(options), "daemon.log");
 }
 function getLaunchAgentPath(options = {}) {
-  return (0, import_node_path14.join)(
+  return (0, import_node_path17.join)(
     options.launchAgentHomeDirectory ?? (0, import_node_os4.homedir)(),
     "Library",
     "LaunchAgents",
@@ -11693,13 +13147,13 @@ function getLaunchAgentPath(options = {}) {
 async function writePid(pid, options = {}) {
   await ensureConfigDir(options);
   const pidFilePath = getPidFilePath(options);
-  await (0, import_promises12.writeFile)(pidFilePath, `${pid}
+  await (0, import_promises15.writeFile)(pidFilePath, `${pid}
 `, "utf8");
   return pidFilePath;
 }
 async function readPid(options = {}) {
   try {
-    const rawPid = await (0, import_promises12.readFile)(getPidFilePath(options), "utf8");
+    const rawPid = await (0, import_promises15.readFile)(getPidFilePath(options), "utf8");
     const parsedPid = Number.parseInt(rawPid.trim(), 10);
     if (!Number.isInteger(parsedPid) || parsedPid <= 0) {
       throw new Error("Invalid PID file contents.");
@@ -11713,13 +13167,13 @@ async function readPid(options = {}) {
   }
 }
 async function removePid(options = {}) {
-  await (0, import_promises12.rm)(getPidFilePath(options), { force: true });
+  await (0, import_promises15.rm)(getPidFilePath(options), { force: true });
 }
 async function writeDaemonState(state, options = {}) {
   await ensureConfigDir(options);
   const daemonStatePath = getDaemonStatePath(options);
   const validatedState = DaemonStateSchema.parse(state);
-  await (0, import_promises12.writeFile)(
+  await (0, import_promises15.writeFile)(
     daemonStatePath,
     `${JSON.stringify(validatedState, null, 2)}
 `,
@@ -11729,7 +13183,7 @@ async function writeDaemonState(state, options = {}) {
 }
 async function readDaemonState(options = {}) {
   try {
-    const rawJson = await (0, import_promises12.readFile)(getDaemonStatePath(options), "utf8");
+    const rawJson = await (0, import_promises15.readFile)(getDaemonStatePath(options), "utf8");
     const parsedJson = JSON.parse(rawJson);
     return DaemonStateSchema.parse(parsedJson);
   } catch (error) {
@@ -11740,7 +13194,7 @@ async function readDaemonState(options = {}) {
   }
 }
 async function removeDaemonState(options = {}) {
-  await (0, import_promises12.rm)(getDaemonStatePath(options), { force: true });
+  await (0, import_promises15.rm)(getDaemonStatePath(options), { force: true });
 }
 function isProcessRunning(pid) {
   try {
@@ -11776,13 +13230,13 @@ async function cleanupStaleDaemonFiles(options = {}) {
 }
 async function ensureLaunchAgentDir(options = {}) {
   const launchAgentPath = getLaunchAgentPath(options);
-  const directoryPath = (0, import_node_path14.dirname)(launchAgentPath);
-  await (0, import_promises12.mkdir)(directoryPath, { recursive: true });
+  const directoryPath = (0, import_node_path17.dirname)(launchAgentPath);
+  await (0, import_promises15.mkdir)(directoryPath, { recursive: true });
   return directoryPath;
 }
 async function getDaemonLogSize(options = {}) {
   try {
-    const logStats = await (0, import_promises12.stat)(getDaemonLogPath(options));
+    const logStats = await (0, import_promises15.stat)(getDaemonLogPath(options));
     return logStats.size;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -11796,16 +13250,16 @@ function getEffectiveCliConfigPath(options = {}) {
 }
 
 // src/cli/auto-update.ts
-var import_node_child_process11 = require("child_process");
-var import_promises13 = require("fs/promises");
-var import_promises14 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_node_child_process14 = require("child_process");
+var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
+var import_node_path18 = require("path");
 var AUTO_UPDATE_STATE_FILE = "auto-update.json";
 var AUTO_UPDATE_LOG_FILE = "auto-update.log";
 function createAutoUpdateController(dependencies = {}) {
   const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
   const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
-  const spawnImplementation = dependencies.spawn ?? import_node_child_process11.spawn;
+  const spawnImplementation = dependencies.spawn ?? import_node_child_process14.spawn;
   return {
     runDetachedUpdate: async (options) => {
       const pathOptions = toPathOptions(options);
@@ -11813,8 +13267,8 @@ function createAutoUpdateController(dependencies = {}) {
       const command = resolveUpdateCommand(options.manager);
       const args = resolveUpdateArgs(options.manager);
       const aisnitchHomePath = getAISnitchHomePath(pathOptions);
-      await (0, import_promises13.mkdir)(aisnitchHomePath, { recursive: true });
-      const logFilePath = (0, import_node_path15.join)(aisnitchHomePath, AUTO_UPDATE_LOG_FILE);
+      await (0, import_promises16.mkdir)(aisnitchHomePath, { recursive: true });
+      const logFilePath = (0, import_node_path18.join)(aisnitchHomePath, AUTO_UPDATE_LOG_FILE);
       const startedAt = now().toISOString();
       await writeAutoUpdateState(
         {
@@ -11847,7 +13301,7 @@ function createAutoUpdateController(dependencies = {}) {
       });
       combinedLog += `[${now().toISOString()}] finished with code ${exitCode}
 `;
-      await (0, import_promises13.writeFile)(logFilePath, combinedLog, "utf8");
+      await (0, import_promises16.writeFile)(logFilePath, combinedLog, "utf8");
       await writeAutoUpdateState(
         {
           attemptedVersion: options.latestVersion,
@@ -11938,7 +13392,7 @@ async function detectInstallManager(options) {
   }
   let resolvedCliPath = options.cliEntryPath;
   try {
-    resolvedCliPath = await (0, import_promises14.realpath)(options.cliEntryPath);
+    resolvedCliPath = await (0, import_promises17.realpath)(options.cliEntryPath);
   } catch {
   }
   if (resolvedCliPath.includes("/Cellar/aisnitch/")) {
@@ -12002,7 +13456,7 @@ function resolveUpdateArgs(manager) {
 async function readAutoUpdateState(options) {
   const statePath = getAutoUpdateStatePath(options);
   try {
-    const rawJson = await (0, import_promises13.readFile)(statePath, "utf8");
+    const rawJson = await (0, import_promises16.readFile)(statePath, "utf8");
     return JSON.parse(rawJson);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -12013,8 +13467,8 @@ async function readAutoUpdateState(options) {
 }
 async function writeAutoUpdateState(state, options) {
   const aisnitchHomePath = getAISnitchHomePath(options);
-  await (0, import_promises13.mkdir)(aisnitchHomePath, { recursive: true });
-  await (0, import_promises13.writeFile)(
+  await (0, import_promises16.mkdir)(aisnitchHomePath, { recursive: true });
+  await (0, import_promises16.writeFile)(
     getAutoUpdateStatePath(options),
     `${JSON.stringify(state, null, 2)}
 `,
@@ -12022,7 +13476,7 @@ async function writeAutoUpdateState(state, options) {
   );
 }
 function getAutoUpdateStatePath(options) {
-  return (0, import_node_path15.join)(getAISnitchHomePath(options), AUTO_UPDATE_STATE_FILE);
+  return (0, import_node_path18.join)(getAISnitchHomePath(options), AUTO_UPDATE_STATE_FILE);
 }
 function toPathOptions(options) {
   return {
@@ -12120,7 +13574,7 @@ function flattenValue(lines, currentPath, value) {
     });
     return;
   }
-  if (isRecord10(value)) {
+  if (isRecord13(value)) {
     const entries = Object.entries(value).sort(
       ([left], [right]) => left.localeCompare(right)
     );
@@ -12203,17 +13657,17 @@ function parseSocketMessage(data) {
   }
 }
 function isWelcomeMessage(payload) {
-  if (!isRecord10(payload)) {
+  if (!isRecord13(payload)) {
     return false;
   }
   return payload.type === "welcome" && typeof payload.version === "string" && Array.isArray(payload.tools);
 }
-function isRecord10(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/cli/runtime.ts
-var execFile11 = (0, import_node_util11.promisify)(import_node_child_process12.execFile);
+var execFile14 = (0, import_node_util14.promisify)(import_node_child_process15.execFile);
 var DAEMON_READY_TIMEOUT_MS = 4e3;
 var DAEMON_READY_POLL_INTERVAL_MS = 100;
 var DAEMON_STOP_TIMEOUT_MS = 4e3;
@@ -12223,13 +13677,13 @@ function createCliRuntime(dependencies = {}) {
   const output = dependencies.output ?? createProcessOutput();
   const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
   const renderManagedTuiImplementation = dependencies.renderManagedTui ?? renderManagedTui;
-  const spawnImplementation = dependencies.spawn ?? import_node_child_process12.spawn;
+  const spawnImplementation = dependencies.spawn ?? import_node_child_process15.spawn;
   const autoUpdateController = createAutoUpdateController({
     fetch: fetchImplementation,
     spawn: spawnImplementation
   });
   const execFileImplementation = dependencies.execFile ?? (async (file, args) => {
-    return await execFile11(file, [...args], {
+    return await execFile14(file, [...args], {
       encoding: "utf8"
     });
   });
@@ -12368,8 +13822,8 @@ function createCliRuntime(dependencies = {}) {
     if (logSize < DAEMON_LOG_MAX_BYTES) {
       return;
     }
-    await (0, import_promises15.rm)(backupPath, { force: true });
-    await (0, import_promises15.rename)(logFilePath, backupPath);
+    await (0, import_promises18.rm)(backupPath, { force: true });
+    await (0, import_promises18.rename)(logFilePath, backupPath);
   }
   async function waitForDaemonReady(pathOptions) {
     const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
@@ -12404,7 +13858,7 @@ function createCliRuntime(dependencies = {}) {
   }
   async function readDaemonStartupFailure(pathOptions) {
     try {
-      const daemonLog = await (0, import_promises15.readFile)(getDaemonLogPath(pathOptions), "utf8");
+      const daemonLog = await (0, import_promises18.readFile)(getDaemonLogPath(pathOptions), "utf8");
       const logLines = daemonLog.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
       const lastLine = logLines.at(-1);
       if (!lastLine) {
@@ -12774,7 +14228,7 @@ function createCliRuntime(dependencies = {}) {
     }
     const { config } = await loadEffectiveConfig(options);
     setLoggerLevel(getForegroundSafeLogLevel(config.logLevel, false));
-    const ephemeralHomeDirectory = await (0, import_promises15.mkdtemp)((0, import_node_path16.join)((0, import_node_os5.tmpdir)(), "aisnitch-mock-"));
+    const ephemeralHomeDirectory = await (0, import_promises18.mkdtemp)((0, import_node_path19.join)((0, import_node_os5.tmpdir)(), "aisnitch-mock-"));
     const ephemeralPipeline = new Pipeline();
     const status2 = await ephemeralPipeline.start({
       config: {
@@ -12813,7 +14267,7 @@ function createCliRuntime(dependencies = {}) {
     } finally {
       await Promise.resolve(monitorClose());
       await ephemeralPipeline.stop();
-      await (0, import_promises15.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
+      await (0, import_promises18.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
     }
   }
   async function install(options) {
@@ -12835,7 +14289,7 @@ function createCliRuntime(dependencies = {}) {
       await execFileImplementation("launchctl", ["bootout", domainTarget, launchAgentPath]);
     } catch {
     }
-    await (0, import_promises15.writeFile)(launchAgentPath, plistContents, "utf8");
+    await (0, import_promises18.writeFile)(launchAgentPath, plistContents, "utf8");
     await execFileImplementation("launchctl", ["bootstrap", domainTarget, launchAgentPath]);
     output.stdout(`AISnitch LaunchAgent installed at ${launchAgentPath}
 `);
@@ -12858,7 +14312,7 @@ function createCliRuntime(dependencies = {}) {
     } else {
       const { config } = await loadEffectiveConfig(options);
       setLoggerLevel(getForegroundSafeLogLevel(config.logLevel, false));
-      ephemeralHomeDirectory = await (0, import_promises15.mkdtemp)((0, import_node_path16.join)((0, import_node_os5.tmpdir)(), "aisnitch-wrap-"));
+      ephemeralHomeDirectory = await (0, import_promises18.mkdtemp)((0, import_node_path19.join)((0, import_node_os5.tmpdir)(), "aisnitch-wrap-"));
       ephemeralPipeline = new Pipeline();
       await ephemeralPipeline.start({
         config: {
@@ -12913,7 +14367,7 @@ function createCliRuntime(dependencies = {}) {
         await ephemeralPipeline.stop();
       }
       if (ephemeralHomeDirectory !== null) {
-        await (0, import_promises15.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
+        await (0, import_promises18.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
       }
     }
     process.exit(wrappedExitCode);
@@ -12933,7 +14387,7 @@ function createCliRuntime(dependencies = {}) {
           },
           pid: process.ppid > 1 ? process.ppid : void 0,
           source: "aisnitch://adapters/aider/notifications-command",
-          transcriptPath: (0, import_node_path16.join)(process.cwd(), ".aider.chat.history.md"),
+          transcriptPath: (0, import_node_path19.join)(process.cwd(), ".aider.chat.history.md"),
           type: "agent.idle"
         }),
         headers: {
@@ -12955,7 +14409,7 @@ function createCliRuntime(dependencies = {}) {
       await execFileImplementation("launchctl", ["bootout", domainTarget, launchAgentPath]);
     } catch {
     }
-    await (0, import_promises15.rm)(launchAgentPath, { force: true });
+    await (0, import_promises18.rm)(launchAgentPath, { force: true });
     output.stdout(`AISnitch LaunchAgent removed from ${launchAgentPath}
 `);
   }
@@ -13134,7 +14588,7 @@ function joinSocketPath(pathOptions) {
 }
 function resolveCliEntryPath() {
   const cliEntryPath = process.argv[1];
-  if (!cliEntryPath || (0, import_node_path16.basename)(cliEntryPath).length === 0) {
+  if (!cliEntryPath || (0, import_node_path19.basename)(cliEntryPath).length === 0) {
     throw new Error("Unable to resolve the AISnitch CLI entry path.");
   }
   return cliEntryPath;