clay-server 2.27.0-beta.8 → 2.27.0

package/lib/sdk-bridge.js

@@ -6,123 +6,9 @@ var net = require("net");
 var { execSync, spawn } = require("child_process");
 var { resolveOsUserInfo } = require("./os-users");
 var usersModule = require("./users");
-
-// Split shell command on operators (&&, ||, ;, |) while respecting quotes
-// and parentheses. Returns array of command segments.
-function splitShellSegments(cmd) {
-  var segments = [];
-  var current = "";
-  var inSingle = false;
-  var inDouble = false;
-  var parenDepth = 0;
-  var i = 0;
-  while (i < cmd.length) {
-    var ch = cmd[i];
-
-    // Handle escape
-    if (ch === "\\" && i + 1 < cmd.length && !inSingle) {
-      current += ch + cmd[i + 1];
-      i += 2;
-      continue;
-    }
-
-    // Quote tracking
-    if (ch === "'" && !inDouble) { inSingle = !inSingle; current += ch; i++; continue; }
-    if (ch === '"' && !inSingle) { inDouble = !inDouble; current += ch; i++; continue; }
-
-    // Inside quotes: no splitting
-    if (inSingle || inDouble) { current += ch; i++; continue; }
-
-    // Parentheses/subshell tracking
-    if (ch === "(" || ch === "$" && i + 1 < cmd.length && cmd[i + 1] === "(") {
-      parenDepth++;
-      current += ch;
-      i++;
-      continue;
-    }
-    if (ch === ")" && parenDepth > 0) {
-      parenDepth--;
-      current += ch;
-      i++;
-      continue;
-    }
-
-    // Inside subshell: no splitting
-    if (parenDepth > 0) { current += ch; i++; continue; }
-
-    // Check for operators: &&, ||, ;, |
-    if (ch === "&" && i + 1 < cmd.length && cmd[i + 1] === "&") {
-      segments.push(current);
-      current = "";
-      i += 2;
-      continue;
-    }
-    if (ch === "|" && i + 1 < cmd.length && cmd[i + 1] === "|") {
-      segments.push(current);
-      current = "";
-      i += 2;
-      continue;
-    }
-    if (ch === "|") {
-      segments.push(current);
-      current = "";
-      i++;
-      continue;
-    }
-    if (ch === ";") {
-      segments.push(current);
-      current = "";
-      i++;
-      continue;
-    }
-
-    current += ch;
-    i++;
-  }
-  if (current) segments.push(current);
-  return segments;
-}
-
-// Async message queue for streaming input to SDK
-function createMessageQueue() {
-  var queue = [];
-  var waiting = null;
-  var ended = false;
-  return {
-    push: function(msg) {
-      if (waiting) {
-        var resolve = waiting;
-        waiting = null;
-        resolve({ value: msg, done: false });
-      } else {
-        queue.push(msg);
-      }
-    },
-    end: function() {
-      ended = true;
-      if (waiting) {
-        var resolve = waiting;
-        waiting = null;
-        resolve({ value: undefined, done: true });
-      }
-    },
-    [Symbol.asyncIterator]: function() {
-      return {
-        next: function() {
-          if (queue.length > 0) {
-            return Promise.resolve({ value: queue.shift(), done: false });
-          }
-          if (ended) {
-            return Promise.resolve({ value: undefined, done: true });
-          }
-          return new Promise(function(resolve) {
-            waiting = resolve;
-          });
-        },
-      };
-    },
-  };
-}
+var { splitShellSegments, attachSkillDiscovery } = require("./sdk-skill-discovery");
+var { createMessageQueue } = require("./sdk-message-queue");
+var { attachMessageProcessor } = require("./sdk-message-processor");
 
 function createSDKBridge(opts) {
   var cwd = opts.cwd;
@@ -130,6 +16,7 @@ function createSDKBridge(opts) {
   var sm = opts.sessionManager;   // session manager instance
   var send = opts.send;           // broadcast to all clients
   var pushModule = opts.pushModule;
+  var getNotificationsModule = opts.getNotificationsModule || function () { return null; };
   var getSDK = opts.getSDK;
   var mateDisplayName = opts.mateDisplayName || "";
   var isMate = opts.isMate || (slug.indexOf("mate-") === 0);
@@ -138,596 +25,80 @@ function createSDKBridge(opts) {
   var onProcessingChanged = opts.onProcessingChanged || function () {};
   var onTurnDone = opts.onTurnDone || null;
 
-  // --- Skill discovery helpers ---
-
-  function discoverSkillDirs() {
-    var skills = {};
-    var dirs = [
-      path.join(require("./config").REAL_HOME, ".claude", "skills"),
-      path.join(cwd, ".claude", "skills"),
-    ];
-    for (var d = 0; d < dirs.length; d++) {
-      var base = dirs[d];
-      var entries;
-      try {
-        entries = fs.readdirSync(base, { withFileTypes: true });
-      } catch (e) {
-        continue; // directory doesn't exist
-      }
-      for (var i = 0; i < entries.length; i++) {
-        var entry = entries[i];
-        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-        var skillDir = path.join(base, entry.name);
-        var skillMd = path.join(skillDir, "SKILL.md");
-        try {
-          fs.accessSync(skillMd, fs.constants.R_OK);
-          // project skills override global skills with same name
-          skills[entry.name] = skillDir;
-        } catch (e) {
-          // no SKILL.md, skip
-        }
-      }
-    }
-    return skills;
-  }
-
-  function mergeSkills(sdkSkills, fsSkills) {
-    var merged = new Set();
-    if (Array.isArray(sdkSkills)) {
-      for (var i = 0; i < sdkSkills.length; i++) {
-        merged.add(sdkSkills[i]);
-      }
-    }
-    var fsNames = Object.keys(fsSkills);
-    for (var i = 0; i < fsNames.length; i++) {
-      merged.add(fsNames[i]);
-    }
-    return merged;
-  }
-
-  function sendAndRecord(session, obj) {
-    sm.sendAndRecord(session, obj);
-  }
-
-  function sendToSession(session, obj) {
-    sm.sendToSession(session, obj);
-  }
-
-  function processSDKMessage(session, parsed) {
-    // Timing: log key SDK milestones relative to query start
-    if (session._queryStartTs) {
-      var _elapsed = Date.now() - session._queryStartTs;
-      if (parsed.type === "system" && parsed.subtype === "init") {
-        console.log("[PERF] processSDKMessage: system/init +" + _elapsed + "ms");
-      }
-      if (parsed.type === "stream_event" && parsed.event) {
-        if (parsed.event.type === "message_start") {
-          console.log("[PERF] processSDKMessage: message_start (API response begun) +" + _elapsed + "ms");
-        }
-        if (parsed.event.type === "content_block_delta" && !session._firstTextLogged) {
-          session._firstTextLogged = true;
-          console.log("[PERF] processSDKMessage: FIRST content_block_delta (visible text) +" + _elapsed + "ms");
-        }
-      }
-      if (parsed.type === "result") {
-        console.log("[PERF] processSDKMessage: result +" + _elapsed + "ms");
-      }
-    }
-
-    // Extract session_id from any message that carries it
-    if (parsed.session_id && !session.cliSessionId) {
-      session.cliSessionId = parsed.session_id;
-      sm.saveSessionFile(session);
-      sendAndRecord(session, { type: "session_id", cliSessionId: session.cliSessionId });
-    } else if (parsed.session_id) {
-      session.cliSessionId = parsed.session_id;
-    }
-
-    // Capture message UUIDs for rewind support
-    if (parsed.uuid) {
-      if (parsed.type === "user" && !parsed.parent_tool_use_id) {
-        session.messageUUIDs.push({ uuid: parsed.uuid, type: "user", historyIndex: session.history.length });
-        sendAndRecord(session, { type: "message_uuid", uuid: parsed.uuid, messageType: "user" });
-      } else if (parsed.type === "assistant") {
-        session.messageUUIDs.push({ uuid: parsed.uuid, type: "assistant", historyIndex: session.history.length });
-        sendAndRecord(session, { type: "message_uuid", uuid: parsed.uuid, messageType: "assistant" });
-      }
-    }
-
-    // Cache slash_commands and model from CLI init message
-    if (parsed.type === "system" && parsed.subtype === "init") {
-      var fsSkills = discoverSkillDirs();
-      sm.skillNames = mergeSkills(parsed.skills, fsSkills);
-      if (parsed.slash_commands) {
-        // Union: SDK slash_commands + merged skills (deduplicated)
-        var seen = new Set();
-        var combined = [];
-        var all = parsed.slash_commands.concat(Array.from(sm.skillNames));
-        for (var k = 0; k < all.length; k++) {
-          if (!seen.has(all[k])) {
-            seen.add(all[k]);
-            combined.push(all[k]);
-          }
-        }
-        sm.slashCommands = combined;
-        send({ type: "slash_commands", commands: sm.slashCommands });
-      }
-      if (parsed.model) {
-        sm.currentModel = sm._savedDefaultModel || parsed.model;
-        send({ type: "model_info", model: sm.currentModel, models: sm.availableModels || [] });
-      }
-      if (parsed.fast_mode_state) {
-        sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
-      }
-    }
-
-    if (parsed.type === "stream_event" && parsed.event) {
-      var evt = parsed.event;
-
-      if (evt.type === "message_start" && evt.message && evt.message.usage) {
-        var u = evt.message.usage;
-        session.lastStreamInputTokens = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0);
-      }
-
-      if (evt.type === "content_block_start") {
-        var block = evt.content_block;
-        var idx = evt.index;
-
-        if (block.type === "tool_use") {
-          session.blocks[idx] = { type: "tool_use", id: block.id, name: block.name, inputJson: "" };
-          sendAndRecord(session, { type: "tool_start", id: block.id, name: block.name });
-        } else if (block.type === "thinking") {
-          session.blocks[idx] = { type: "thinking", thinkingText: "", startTime: Date.now() };
-          sendAndRecord(session, { type: "thinking_start" });
-        } else if (block.type === "text") {
-          session.blocks[idx] = { type: "text" };
-        }
-      }
-
-      if (evt.type === "content_block_delta" && evt.delta) {
-        var idx = evt.index;
-
-        if (evt.delta.type === "text_delta" && typeof evt.delta.text === "string") {
-          session.streamedText = true;
-          if (session.responsePreview.length < 200) {
-            session.responsePreview += evt.delta.text;
-          }
-          // Accumulate text for mate DM response
-          if (typeof session._mateDmResponseText === "string") {
-            session._mateDmResponseText += evt.delta.text;
-          }
-          sendAndRecord(session, { type: "delta", text: evt.delta.text });
-        } else if (evt.delta.type === "input_json_delta" && session.blocks[idx]) {
-          session.blocks[idx].inputJson += evt.delta.partial_json;
-        } else if (evt.delta.type === "thinking_delta" && session.blocks[idx]) {
-          session.blocks[idx].thinkingText += evt.delta.thinking;
-          sendAndRecord(session, { type: "thinking_delta", text: evt.delta.thinking });
-        }
-      }
-
-      if (evt.type === "content_block_stop") {
-        var idx = evt.index;
-        var block = session.blocks[idx];
-
-        if (block && block.type === "tool_use") {
-          var input = {};
-          try { input = JSON.parse(block.inputJson); } catch {}
-          sendAndRecord(session, { type: "tool_executing", id: block.id, name: block.name, input: input });
-
-          // Track active Task tools for sub-agent done detection
-          if (block.name === "Task") {
-            if (!session.activeTaskToolIds) session.activeTaskToolIds = {};
-            session.activeTaskToolIds[block.id] = true;
-          }
-
-          if (pushModule && block.name === "AskUserQuestion" && input.questions) {
-            var q = input.questions[0];
-            pushModule.sendPush({
-              type: "ask_user",
-              slug: slug,
-              title: (mateDisplayName || "Claude") + " has a question",
-              body: q ? q.question : "Waiting for your response",
-              tag: "claude-ask",
-            });
-          }
-        } else if (block && block.type === "thinking") {
-          var duration = block.startTime ? (Date.now() - block.startTime) / 1000 : 0;
-          sendAndRecord(session, { type: "thinking_stop", duration: duration });
-        }
-
-        delete session.blocks[idx];
-      }
-
-    } else if ((parsed.type === "assistant" || parsed.type === "user") && parsed.message && parsed.message.content) {
-      // Sub-agent messages: extract tool_use blocks for activity display
-      if (parsed.parent_tool_use_id) {
-        processSubagentMessage(session, parsed);
-        return;
-      }
-
-      var content = parsed.message.content;
-
-      // Fallback: if assistant text wasn't streamed via deltas, send it now
-      if (parsed.type === "assistant" && !session.streamedText && Array.isArray(content)) {
-        var assistantText = content
-          .filter(function(c) { return c.type === "text"; })
-          .map(function(c) { return c.text; })
-          .join("");
-        if (assistantText) {
-          if (session.responsePreview.length < 200) {
-            session.responsePreview += assistantText;
-          }
-          sendAndRecord(session, { type: "delta", text: assistantText });
-        }
-      }
-
-      // Check for local slash command output in user messages
-      if (parsed.type === "user") {
-        var fullText = "";
-        if (typeof content === "string") {
-          fullText = content;
-        } else if (Array.isArray(content)) {
-          fullText = content
-            .filter(function(c) { return c.type === "text"; })
-            .map(function(c) { return c.text; })
-            .join("\n");
-        }
-        if (fullText.indexOf("local-command-stdout") !== -1) {
-          var m = fullText.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
-          if (m) {
-            sendAndRecord(session, { type: "slash_command_result", text: m[1].trim() });
-          }
-        }
-      }
-
-      if (Array.isArray(content)) {
-        for (var i = 0; i < content.length; i++) {
-          var block = content[i];
-          if (block.type === "tool_result" && !session.sentToolResults[block.tool_use_id]) {
-            // Clear active Task tool when its result arrives
-            if (session.activeTaskToolIds && session.activeTaskToolIds[block.tool_use_id]) {
-              sendAndRecord(session, {
-                type: "subagent_done",
-                parentToolId: block.tool_use_id,
-              });
-              delete session.activeTaskToolIds[block.tool_use_id];
-            }
-            var resultText = "";
-            var resultImages = [];
-            if (typeof block.content === "string") {
-              resultText = block.content;
-            } else if (Array.isArray(block.content)) {
-              resultText = block.content
-                .filter(function(c) { return c.type === "text"; })
-                .map(function(c) { return c.text; })
-                .join("\n");
-              for (var ri = 0; ri < block.content.length; ri++) {
-                var rc = block.content[ri];
-                if (rc.type === "image" && rc.source) {
-                  resultImages.push({
-                    mediaType: rc.source.media_type,
-                    data: rc.source.data,
-                  });
-                }
-              }
-            }
-            session.sentToolResults[block.tool_use_id] = true;
-            var toolResultMsg = {
-              type: "tool_result",
-              id: block.tool_use_id,
-              content: resultText,
-              is_error: block.is_error || false,
-            };
-            if (resultImages.length > 0) toolResultMsg.images = resultImages;
-            sendAndRecord(session, toolResultMsg);
-          }
-        }
-      }
-
-    } else if (parsed.type === "result") {
-      session.blocks = {};
-      session.sentToolResults = {};
-      session.pendingPermissions = {};
-      session.pendingElicitations = {};
-      // Record ask_user_answered for any leftover pending questions so replay pairs correctly
-      var leftoverAskIds = Object.keys(session.pendingAskUser);
-      for (var lai = 0; lai < leftoverAskIds.length; lai++) {
-        sendAndRecord(session, { type: "ask_user_answered", toolId: leftoverAskIds[lai] });
-      }
-      session.pendingAskUser = {};
-      session.activeTaskToolIds = {};
-      session.taskIdMap = {};
-      // Only clear rateLimitResetsAt on genuine success (non-zero cost).
-      // When rate-limited, the SDK sends result with zero cost right after
-      // rate_limit_event; clearing here would prevent auto-continue scheduling.
-      if (parsed.total_cost_usd && parsed.total_cost_usd > 0) {
-        session.rateLimitResetsAt = null;
-      }
-      console.log("[sdk-bridge] result handler: session " + session.localId + " cost=" + parsed.total_cost_usd + " rateLimitResetsAt=" + session.rateLimitResetsAt);
-
-      // Handle SDK execution errors: show the error to the user instead of
-      // silently swallowing it. These have subtype "error_during_execution".
-      if (parsed.subtype === "error_during_execution") {
-        var execErrors = parsed.errors || [];
-        var execError = execErrors.length > 0
-          ? execErrors.join("; ")
-          : "Unknown SDK error";
-        if (parsed.terminal_reason) execError += " (reason: " + parsed.terminal_reason + ")";
-        console.error("[sdk-bridge] Execution error for session " + session.localId + ": " + execError);
-        session.isProcessing = false;
-        onProcessingChanged();
-        sendAndRecord(session, { type: "error", text: "Claude error: " + execError });
-        sendAndRecord(session, { type: "done", code: 1 });
-        sm.broadcastSessionList();
-        return;
-      }
-
-      session.isProcessing = false;
-      onProcessingChanged();
-      // Detect "Not logged in" scenario early for the check below
-      var previewTrimmed = (session.responsePreview || "").trim();
-      var isZeroCost = !parsed.total_cost_usd || parsed.total_cost_usd === 0;
-      var isLoginPrompt = isZeroCost && previewTrimmed.length < 100
-        && /not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed);
-      // Fetch rich context usage breakdown (fire-and-forget, non-blocking)
-      if (session.queryInstance && typeof session.queryInstance.getContextUsage === "function") {
-        session.queryInstance.getContextUsage().then(function(ctxUsage) {
-          session.lastContextUsage = ctxUsage;
-          sendToSession(session, { type: "context_usage", data: ctxUsage });
-        }).catch(function(e) {
-          console.error("[sdk-bridge] getContextUsage failed (non-fatal):", e.message || e);
-        });
-      }
-      var lastStreamInput = session.lastStreamInputTokens || null;
-      session.lastStreamInputTokens = null;
-      sendAndRecord(session, {
-        type: "result",
-        cost: parsed.total_cost_usd,
-        duration: parsed.duration_ms,
-        usage: parsed.usage || null,
-        modelUsage: parsed.modelUsage || null,
-        sessionId: parsed.session_id,
-        lastStreamInputTokens: lastStreamInput,
-      });
-      if (parsed.fast_mode_state) {
-        sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
-      }
-      // Detect "Not logged in · Please run /login" from SDK.
-      // This is a short canned response with zero cost, not actual AI output.
-      if (isLoginPrompt) {
-        var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
-        var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
-        var canAutoLogin = !usersModule.isMultiUser()
-          || !!authLinuxUser
-          || (authUser && authUser.role === "admin");
-        sendAndRecord(session, {
-          type: "auth_required",
-          text: "Claude Code is not logged in.",
-          linuxUser: authLinuxUser,
-          canAutoLogin: canAutoLogin,
-        });
-        // Reset CLI session so next query starts fresh with new auth
-        session.cliSessionId = null;
-      }
-      sendAndRecord(session, { type: "done", code: 0 });
-      if (pushModule) {
-        var preview = (session.responsePreview || "").replace(/\s+/g, " ").trim();
-        if (preview.length > 140) preview = preview.substring(0, 140) + "...";
-        pushModule.sendPush({
-          type: "done",
-          slug: slug,
-          title: mateDisplayName ? (mateDisplayName + " responded") : (session.title || "Claude"),
-          body: preview || "Response ready",
-          tag: "claude-done",
-        });
-      }
-      // Reset for next turn in the same query
-      var donePreview = session.responsePreview || "";
-      session.responsePreview = "";
-      session.streamedText = false;
-      sm.broadcastSessionList();
-      if (onTurnDone) {
-        try { onTurnDone(session, donePreview); } catch (e) {}
-      }
-
-    } else if (parsed.type === "system" && parsed.subtype === "status") {
-      if (parsed.status === "compacting") {
-        sendAndRecord(session, { type: "compacting", active: true });
-      } else if (session.compacting) {
-        sendAndRecord(session, { type: "compacting", active: false });
-      }
-      session.compacting = parsed.status === "compacting";
-
-    } else if (parsed.type === "system" && parsed.subtype === "task_started") {
-      var parentId = parsed.tool_use_id;
-      if (parentId) {
-        if (!session.taskIdMap) session.taskIdMap = {};
-        session.taskIdMap[parentId] = parsed.task_id;
-        sendAndRecord(session, {
-          type: "task_started",
-          parentToolId: parentId,
-          taskId: parsed.task_id,
-          description: parsed.description || "",
-        });
-      }
-
-    } else if (parsed.type === "system" && parsed.subtype === "task_progress") {
-      var parentId = parsed.tool_use_id;
-      if (parentId) {
-        sendAndRecord(session, {
-          type: "task_progress",
-          parentToolId: parentId,
-          taskId: parsed.task_id,
-          usage: parsed.usage || null,
-          lastToolName: parsed.last_tool_name || null,
-          description: parsed.description || "",
-          summary: parsed.summary || null,
-        });
-      }
-
-    } else if (parsed.type === "tool_progress") {
-      // Sub-agent tool_progress: forward as activity update
-      var parentId = parsed.parent_tool_use_id;
-      if (parentId) {
-        sendAndRecord(session, {
-          type: "subagent_activity",
-          parentToolId: parentId,
-          text: parsed.content || "",
-        });
-      }
-
-    } else if (parsed.type === "task_notification") {
-      var parentId = parsed.parent_tool_use_id;
-      if (parentId) {
-        sendAndRecord(session, {
-          type: "subagent_done",
-          parentToolId: parentId,
-          status: parsed.status || "completed",
-          summary: parsed.summary || "",
-          usage: parsed.usage || null,
-        });
-      }
-      if (session.taskIdMap) {
-        for (var k in session.taskIdMap) {
-          if (session.taskIdMap[k] === parsed.task_id) {
-            delete session.taskIdMap[k];
-            break;
+  // --- Idle session reaper ---
+  // In single-user (in-process) mode, each session's Claude child process stays
+  // alive between turns because the messageQueue push-stream is never ended.
+  // Without a reaper, processes accumulate indefinitely as users switch between
+  // sessions and projects. This reaper ends the messageQueue for sessions that
+  // have been idle for IDLE_TIMEOUT_MS, allowing processQueryStream's finally
+  // block to clean up the child process. Session state on disk is preserved —
+  // the next startQuery() call resumes with a fresh process.
+  var IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+  var IDLE_CHECK_INTERVAL_MS = 60 * 1000; // check every 60 seconds
+  var _idleReaperTimer = null;
+
+  function startIdleReaper() {
+    if (_idleReaperTimer) return;
+    _idleReaperTimer = setInterval(function () {
+      var now = Date.now();
+      sm.sessions.forEach(function (session) {
+        // Skip sessions that are actively processing, have no query, use workers,
+        // or are single-turn (Ralph Loop — managed by onQueryComplete).
+        if (session.isProcessing) return;
+        if (!session.queryInstance) return;
+        if (session.worker) return;
+        if (session.singleTurn) return;
+        if (session.destroying) return;
+
+        var lastActivity = session.lastActivityAt || 0;
+        if (now - lastActivity > IDLE_TIMEOUT_MS) {
+          console.log("[sdk-bridge] Reaping idle session " + session.localId +
+            " (idle " + Math.round((now - lastActivity) / 60000) + "min)" +
+            (session.title ? " title=" + JSON.stringify(session.title) : ""));
+          // End the message queue so the for-await loop in processQueryStream
+          // exits naturally, triggering the finally block cleanup.
+          if (session.messageQueue && typeof session.messageQueue.end === "function") {
+            try { session.messageQueue.end(); } catch (e) {}
           }
         }
-      }
-
-    } else if (parsed.type === "rate_limit_event" && parsed.rate_limit_info) {
-      var info = parsed.rate_limit_info;
-      console.log("[sdk-bridge] rate_limit_event for session " + session.localId + ": status=" + info.status + " resetsAt=" + info.resetsAt + " isUsingOverage=" + info.isUsingOverage + " isProcessing=" + session.isProcessing);
-
-      // Broadcast reset time for top-bar usage link
-      if (info.rateLimitType && info.resetsAt) {
-        send({
-          type: "rate_limit_usage",
-          rateLimitType: info.rateLimitType,
-          resetsAt: info.resetsAt * 1000,
-          status: info.status,
-        });
-      }
-
-      // Warning/rejection handling (existing behavior)
-      if (info.status === "allowed_warning" || info.status === "rejected") {
-        sendAndRecord(session, {
-          type: "rate_limit",
-          status: info.status,
-          resetsAt: info.resetsAt ? info.resetsAt * 1000 : null,
-          rateLimitType: info.rateLimitType || null,
-          utilization: info.utilization || null,
-          isUsingOverage: info.isUsingOverage || false,
-        });
-        // Track rejection for auto-continue / scheduled message support
-        if (info.status === "rejected" && info.resetsAt) {
-          session.rateLimitResetsAt = info.resetsAt * 1000;
-
-          // Schedule auto-continue immediately on rejection (don't wait for
-          // query completion which has timing issues with worker/non-worker paths).
-          if (!session.scheduledMessage && !session.destroying) {
-            var acEnabled = session.onQueryComplete ||
-              (typeof opts.getAutoContinueSetting === "function" && opts.getAutoContinueSetting(session));
-            console.log("[sdk-bridge] rate_limit rejected: acEnabled=" + acEnabled + " overage=" + !!info.isUsingOverage + " session=" + session.localId);
-            if (acEnabled) {
-              session.rateLimitAutoContinuePending = true;
-              if (info.isUsingOverage) {
-                // Extra usage available: send continue immediately (5s delay for query to finish)
-                console.log("[sdk-bridge] Overage available, sending immediate continue for session " + session.localId);
-                session.rateLimitResetsAt = null;
-                if (typeof opts.scheduleMessage === "function") {
-                  opts.scheduleMessage(session, "continue", Date.now());
-                }
-              } else {
-                // No overage: schedule after rate limit resets
-                var acResetsAt = session.rateLimitResetsAt;
-                session.rateLimitResetsAt = null;
-                console.log("[sdk-bridge] Scheduling auto-continue on rate limit rejection for session " + session.localId);
-                if (typeof opts.scheduleMessage === "function") {
-                  opts.scheduleMessage(session, "continue", acResetsAt);
-                }
-              }
-            }
-          }
-        }
-      }
-
-    } else if (parsed.type === "prompt_suggestion") {
-      sendAndRecord(session, {
-        type: "prompt_suggestion",
-        suggestion: parsed.suggestion || "",
       });
-
-    } else if (parsed.type === "system") {
-      // Catch-all for unhandled system subtypes (e.g. hook-block errors).
-      // Extract any error text and surface it in the UI.
-      var sysText = parsed.error || parsed.message || parsed.text || "";
-      if (!sysText && Array.isArray(parsed.content)) {
-        sysText = parsed.content
-          .filter(function(c) { return c.type === "text"; })
-          .map(function(c) { return c.text; })
-          .join("\n");
-      }
-      if (sysText) {
-        console.log("[sdk-bridge] Unhandled system message (subtype=" + (parsed.subtype || "none") + "): " + sysText.substring(0, 200));
-        sendAndRecord(session, { type: "error", text: sysText });
-      }
-    } else if (parsed.type && parsed.type !== "user") {
-    }
+    }, IDLE_CHECK_INTERVAL_MS);
+    // Don't prevent process exit
+    if (_idleReaperTimer.unref) _idleReaperTimer.unref();
   }
 
-  // --- Sub-agent message processing ---
-
-  function toolActivityTextForSubagent(name, input) {
-    if (name === "Bash" && input && input.description) return input.description;
-    if (name === "Read" && input && input.file_path) return "Reading " + input.file_path.split("/").pop();
-    if (name === "Edit" && input && input.file_path) return "Editing " + input.file_path.split("/").pop();
-    if (name === "Write" && input && input.file_path) return "Writing " + input.file_path.split("/").pop();
-    if (name === "Grep" && input && input.pattern) return "Searching for " + input.pattern;
-    if (name === "Glob" && input && input.pattern) return "Finding " + input.pattern;
-    if (name === "WebSearch" && input && input.query) return "Searching: " + input.query;
-    if (name === "WebFetch") return "Fetching URL...";
-    if (name === "Task" && input && input.description) return input.description;
-    return "Running " + name + "...";
-  }
-
-  function processSubagentMessage(session, parsed) {
-    var parentId = parsed.parent_tool_use_id;
-    var content = parsed.message.content;
-    if (!Array.isArray(content)) return;
-
-    if (parsed.type === "assistant") {
-      // Extract tool_use blocks from sub-agent assistant messages
-      for (var i = 0; i < content.length; i++) {
-        var block = content[i];
-        if (block.type === "tool_use") {
-          var activityText = toolActivityTextForSubagent(block.name, block.input);
-          sendAndRecord(session, {
-            type: "subagent_tool",
-            parentToolId: parentId,
-            toolName: block.name,
-            toolId: block.id,
-            text: activityText,
-          });
-        } else if (block.type === "thinking") {
-          sendAndRecord(session, {
-            type: "subagent_activity",
-            parentToolId: parentId,
-            text: "Thinking...",
-          });
-        } else if (block.type === "text" && block.text) {
-          sendAndRecord(session, {
-            type: "subagent_activity",
-            parentToolId: parentId,
-            text: "Writing response...",
-          });
-        }
-      }
+  function stopIdleReaper() {
+    if (_idleReaperTimer) {
+      clearInterval(_idleReaperTimer);
+      _idleReaperTimer = null;
     }
-    // user messages with parent_tool_use_id contain tool_results — skip silently
   }
 
+  // --- Skill discovery (extracted to sdk-skill-discovery.js) ---
+  var skills = attachSkillDiscovery({ cwd: cwd });
+  var discoverSkillDirs = skills.discoverSkillDirs;
+  var mergeSkills = skills.mergeSkills;
+
+  // --- Message processing (extracted to sdk-message-processor.js) ---
+  var msgProcessor = attachMessageProcessor({
+    sm: sm,
+    send: send,
+    slug: slug,
+    isMate: isMate,
+    mateDisplayName: mateDisplayName,
+    pushModule: pushModule,
+    getNotificationsModule: getNotificationsModule,
+    getSDK: getSDK,
+    onProcessingChanged: onProcessingChanged,
+    onTurnDone: onTurnDone,
+    opts: opts,
+    discoverSkillDirs: discoverSkillDirs,
+    mergeSkills: mergeSkills,
+  });
+  var processSDKMessage = msgProcessor.processSDKMessage;
+  var sendAndRecord = msgProcessor.sendAndRecord;
+  var sendToSession = msgProcessor.sendToSession;
+
   // --- MCP elicitation ---
 
   function handleElicitation(session, request, opts) {
@@ -1378,15 +749,6 @@ function createSDKBridge(opts) {
                 sendAndRecord(session, { type: "error", text: "Claude process error: " + errText });
               }
               sendAndRecord(session, { type: "done", code: 1 });
-              if (pushModule) {
-                pushModule.sendPush({
-                  type: "error",
-                  slug: slug,
-                  title: (mateDisplayName || "Claude") + ": Connection Lost",
-                  body: (mateDisplayName || "Claude") + " process disconnected: " + (msg.error || "unknown error"),
-                  tag: "claude-error",
-                });
-              }
             }
             sm.broadcastSessionList();
           }
@@ -1669,6 +1031,12 @@ function createSDKBridge(opts) {
   }
 
   function handleCanUseTool(session, toolName, input, opts) {
+    // Full-auto mode: auto-approve everything except AskUserQuestion
+    // (which still needs to go through the user interaction flow).
+    if (sm.currentPermissionMode === "bypassPermissions" && toolName !== "AskUserQuestion") {
+      return Promise.resolve({ behavior: "allow", updatedInput: input });
+    }
+
     // Ralph Loop execution: auto-approve all tools, deny interactive ones.
     // Crafting sessions are interactive — user and Claude collaborate to build PROMPT.md / JUDGE.md.
     if (session.loop && session.loop.active && session.loop.role !== "crafting") {
@@ -1712,6 +1080,7 @@ function createSDKBridge(opts) {
     // Regular tool permission request: send to client and wait
     return new Promise(function(resolve) {
       var requestId = crypto.randomUUID();
+      sm.permissionRequestIndex[requestId] = session.localId;
       session.pendingPermissions[requestId] = {
         resolve: resolve,
         requestId: requestId,
@@ -1742,9 +1111,24 @@ function createSDKBridge(opts) {
         });
       }
 
+      var _nm = getNotificationsModule();
+      if (_nm) {
+        _nm.notify("permission_request", {
+          title: permissionPushTitle(toolName, input),
+          body: permissionPushBody(toolName, input),
+          slug: slug,
+          sessionId: session.localId,
+          ownerId: session.ownerId || null,
+          requestId: requestId,
+          toolName: toolName,
+          toolInput: input,
+        });
+      }
+
       if (opts.signal) {
         opts.signal.addEventListener("abort", function() {
           delete session.pendingPermissions[requestId];
+          delete sm.permissionRequestIndex[requestId];
           sendAndRecord(session, { type: "permission_cancel", requestId: requestId });
           onProcessingChanged(); // update cross-project permission badge
           resolve({ behavior: "deny", message: "Request cancelled" });
@@ -1894,15 +1278,6 @@ function createSDKBridge(opts) {
             }
           }
           sendAndRecord(session, { type: "done", code: 1 });
-          if (pushModule) {
-            pushModule.sendPush({
-              type: "error",
-              slug: slug,
-              title: (mateDisplayName || "Claude") + ": Connection Lost",
-              body: (mateDisplayName || "Claude") + " process disconnected: " + (err.message || "unknown error"),
-              tag: "claude-error",
-            });
-          }
         }
         sm.broadcastSessionList();
       }
@@ -2129,6 +1504,7 @@ function createSDKBridge(opts) {
       session.messageQueue.end();
     }
 
+    session.lastActivityAt = Date.now();
     session.streamPromise = processQueryStream(session).catch(function(err) {
     });
   }
@@ -2150,6 +1526,7 @@ function createSDKBridge(opts) {
       type: "user",
       message: { role: "user", content: content },
     };
+    session.lastActivityAt = Date.now();
     // Route through worker if active, otherwise direct to message queue
     if (session.worker) {
       session.worker.send({ type: "push_message", content: userMsg });
@@ -2566,6 +1943,8 @@ function createSDKBridge(opts) {
     warmup: warmup,
     stopTask: stopTask,
     createMentionSession: createMentionSession,
+    startIdleReaper: startIdleReaper,
+    stopIdleReaper: stopIdleReaper,
   };
 }