clay-server 2.23.1 → 2.24.0-beta.1

package/lib/sdk-bridge.js

@@ -189,6 +189,26 @@ function createSDKBridge(opts) {
   }
 
   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;
@@ -756,7 +776,9 @@ function createSDKBridge(opts) {
     });
 
     // Create Unix socket server
+    var spawnT0 = Date.now();
     worker.server = net.createServer(function(connection) {
+      console.log("[PERF] spawnWorker: socket connection accepted +" + (Date.now() - spawnT0) + "ms");
       worker.connection = connection;
       connection.on("data", function(chunk) {
         worker.buffer += chunk.toString();
@@ -767,6 +789,7 @@ function createSDKBridge(opts) {
           try {
             var msg = JSON.parse(lines[i]);
             if (msg.type === "ready") {
+              console.log("[PERF] spawnWorker: 'ready' IPC received +" + (Date.now() - spawnT0) + "ms");
               worker.ready = true;
               if (worker._readyResolve) {
                 worker._readyResolve();
@@ -787,6 +810,7 @@ function createSDKBridge(opts) {
     });
 
     worker.server.listen(socketPath, function() {
+      console.log("[PERF] spawnWorker: socket listen ready +" + (Date.now() - spawnT0) + "ms");
       // Set socket permissions so the target user can connect
       try { fs.chmodSync(socketPath, 0o777); } catch (e) {}
 
@@ -933,125 +957,96 @@ function createSDKBridge(opts) {
    * Mirrors the in-process startQuery flow but delegates SDK execution to the worker.
    */
   async function startQueryViaWorker(session, text, images, linuxUser) {
+    var t0 = session._queryStartTs || Date.now();
+    function perf(label) { console.log("[PERF] sdk-bridge: " + label + " +" + (Date.now() - t0) + "ms"); }
+    perf("startQueryViaWorker entered");
+
     // Wait for the previous worker to fully exit before spawning a new one.
     // Without this, the new worker may try to resume the SDK session file
     // while the old worker is still flushing it to disk (800ms grace period),
     // causing "no conversation found" and losing all prior context.
     if (session._workerExitPromise) {
-      console.log("[sdk-bridge] startQueryViaWorker: waiting for old worker exit, localId=" + session.localId);
+      perf("waiting for old worker exit");
       var exitWait = session._workerExitPromise;
       session._workerExitPromise = null;
       await Promise.race([
         exitWait,
         new Promise(function(resolve) { setTimeout(resolve, 3000); }),
       ]);
-      console.log("[sdk-bridge] startQueryViaWorker: old worker exit wait done");
+      perf("old worker exit wait done");
     }
 
-    // Ensure the linux user's .claude directories are writable.
-    // The daemon runs as root, so any dirs it creates (mkdirSync) will be
-    // root-owned. The SDK (running as the linux user) needs write access
-    // to create session files, otherwise resume silently fails.
-    if (linuxUser) {
+    // Reuse existing worker if alive, otherwise spawn a new one.
+    // Spawn FIRST so the worker starts booting while we do dir setup below.
+    var worker;
+    var reusingWorker = false;
+    if (session.worker && session.worker.ready && session.worker.process && !session.worker.process.killed) {
+      worker = session.worker;
+      reusingWorker = true;
+      // Clear old message handlers so they don't fire for the new query
+      worker.messageHandlers = [];
+      worker._queryEnded = false;
+      worker._abortSent = false;
+      perf("reusing existing worker pid=" + (worker.process ? worker.process.pid : "?"));
+    } else {
       try {
-        var osUsersMod0 = require("./os-users");
-        var linuxUserHome0 = osUsersMod0.getLinuxUserHome(linuxUser);
-        var uid0 = osUsersMod0.getLinuxUserUid(linuxUser);
-        if (uid0 != null) {
-          var claudeDir = path.join(linuxUserHome0, ".claude");
-          var projectSlug0 = (cwd || "").replace(/\//g, "-");
-          var projDir = path.join(claudeDir, "projects", projectSlug0);
-          // Create the project directory if missing and chown the whole tree
-          if (!fs.existsSync(projDir)) {
-            fs.mkdirSync(projDir, { recursive: true });
-            try { require("child_process").execSync("chown -R " + uid0 + " " + JSON.stringify(claudeDir)); } catch (e) {}
-          } else {
-            // Fix existing directory if root-owned
-            try {
-              var pstat = fs.statSync(projDir);
-              if (pstat.uid !== uid0) {
-                require("child_process").execSync("chown " + uid0 + " " + JSON.stringify(projDir));
-              }
-            } catch (e) {}
-          }
-        }
+        perf("spawning new worker");
+        worker = spawnWorker(linuxUser);
+        perf("spawnWorker returned");
+        session.worker = worker;
       } catch (e) {
-        console.log("[sdk-bridge] Dir ownership fix skipped:", e.message);
+        session.isProcessing = false;
+        onProcessingChanged();
+        sendAndRecord(session, { type: "error", text: "Failed to spawn worker for " + linuxUser + ": " + (e.message || e) });
+        sendAndRecord(session, { type: "done", code: 1 });
+        sm.broadcastSessionList();
+        return;
       }
     }
 
-    // Pre-copy CLI session file BEFORE spawning worker.
-    // Must happen before spawn so execSync doesn't block the event loop
-    // while worker is alive (which causes ready/exit race conditions).
-    if (session.cliSessionId && linuxUser) {
+    // Ensure the linux user's .claude project directory exists and is writable,
+    // then pre-copy CLI session file if needed. This runs while the worker is
+    // booting (readyPromise pending), so it adds no extra latency.
+    perf("dir setup start");
+    if (linuxUser) {
       try {
         var configMod = require("./config");
         var osUsersMod = require("./os-users");
         var originalHome = configMod.REAL_HOME || require("os").homedir();
         var linuxUserHome = osUsersMod.getLinuxUserHome(linuxUser);
-        if (originalHome !== linuxUserHome) {
+        var uid = osUsersMod.getLinuxUserUid(linuxUser);
+        if (originalHome !== linuxUserHome && uid != null) {
           var projectSlug = (cwd || "").replace(/\//g, "-");
-          var sessionFileName = session.cliSessionId + ".jsonl";
-          var srcFile = path.join(originalHome, ".claude", "projects", projectSlug, sessionFileName);
           var dstDir = path.join(linuxUserHome, ".claude", "projects", projectSlug);
-          var dstFile = path.join(dstDir, sessionFileName);
-          var uid = osUsersMod.getLinuxUserUid(linuxUser);
-          // Ensure the projects directory is owned by the linux user so the
-          // SDK can create new session files. Without this, mkdirSync creates
-          // root-owned directories and the SDK silently fails to save sessions.
+          // Create and chown the project directory once
           if (!fs.existsSync(dstDir)) {
             fs.mkdirSync(dstDir, { recursive: true });
-            if (uid != null) {
-              try { require("child_process").execSync("chown -R " + uid + " " + JSON.stringify(dstDir)); } catch (e2) {}
-            }
+            try { require("child_process").execSync("chown -R " + uid + " " + JSON.stringify(path.join(linuxUserHome, ".claude"))); } catch (e2) {}
           } else {
-            // Fix ownership of existing directories created by root
             try {
               var dirStat = fs.statSync(dstDir);
-              if (uid != null && dirStat.uid !== uid) {
+              if (dirStat.uid !== uid) {
                 require("child_process").execSync("chown " + uid + " " + JSON.stringify(dstDir));
               }
             } catch (e2) {}
           }
-          if (fs.existsSync(srcFile) && !fs.existsSync(dstFile)) {
-            fs.copyFileSync(srcFile, dstFile);
-            if (uid != null) {
+          // Pre-copy CLI session file so the worker can resume the conversation
+          if (session.cliSessionId) {
+            var sessionFileName = session.cliSessionId + ".jsonl";
+            var srcFile = path.join(originalHome, ".claude", "projects", projectSlug, sessionFileName);
+            var dstFile = path.join(dstDir, sessionFileName);
+            if (fs.existsSync(srcFile) && !fs.existsSync(dstFile)) {
+              fs.copyFileSync(srcFile, dstFile);
               try { require("child_process").execSync("chown " + uid + " " + JSON.stringify(dstFile)); } catch (e2) {}
+              console.log("[sdk-bridge] Pre-copied CLI session " + session.cliSessionId + " to " + linuxUser);
             }
-            console.log("[sdk-bridge] Pre-copied CLI session " + session.cliSessionId + " to " + linuxUser);
           }
         }
       } catch (copyErr) {
-        console.log("[sdk-bridge] Session pre-copy skipped:", copyErr.message);
-      }
-    }
-
-    // Reuse existing worker if alive, otherwise spawn a new one.
-    // Keeping the worker alive between queries lets the SDK maintain session
-    // state in memory, avoiding disk-based resume that fails on abort.
-    var worker;
-    var reusingWorker = false;
-    if (session.worker && session.worker.ready && session.worker.process && !session.worker.process.killed) {
-      worker = session.worker;
-      reusingWorker = true;
-      // Clear old message handlers so they don't fire for the new query
-      worker.messageHandlers = [];
-      worker._queryEnded = false;
-      worker._abortSent = false;
-      console.log("[sdk-bridge] Reusing existing worker pid=" + (worker.process ? worker.process.pid : "?"));
-    } else {
-      try {
-        worker = spawnWorker(linuxUser);
-        session.worker = worker;
-      } catch (e) {
-        session.isProcessing = false;
-        onProcessingChanged();
-        sendAndRecord(session, { type: "error", text: "Failed to spawn worker for " + linuxUser + ": " + (e.message || e) });
-        sendAndRecord(session, { type: "done", code: 1 });
-        sm.broadcastSessionList();
-        return;
+        console.log("[sdk-bridge] Dir setup / session pre-copy skipped:", copyErr.message);
       }
     }
+    perf("dir setup done");
 
     session.messageQueue = "worker"; // sentinel: messages go via worker IPC
     session.blocks = {};
@@ -1119,7 +1114,12 @@ function createSDKBridge(opts) {
     }
 
     // Set up message handler for worker events
+    var firstEventLogged = false;
     worker.onMessage(function(msg) {
+      if (!firstEventLogged && msg.type === "sdk_event") {
+        firstEventLogged = true;
+        perf("FIRST sdk_event received (type=" + (msg.event && msg.event.type || "?") + ")");
+      }
       switch (msg.type) {
         case "sdk_event":
           processSDKMessage(session, msg.event);
@@ -1312,8 +1312,10 @@ function createSDKBridge(opts) {
 
     // Wait for worker to be ready, then send query
     if (!reusingWorker) {
+      perf("awaiting readyPromise");
       try {
         await worker.readyPromise;
+        perf("readyPromise resolved");
       } catch (e) {
         session.isProcessing = false;
         onProcessingChanged();
@@ -1325,6 +1327,7 @@ function createSDKBridge(opts) {
       }
     }
 
+    perf("sending query_start to worker");
     worker.send({
       type: "query_start",
       prompt: initialMessage,
@@ -1332,7 +1335,9 @@ function createSDKBridge(opts) {
       singleTurn: !!session.singleTurn,
       originalHome: require("./config").REAL_HOME || null,
       projectPath: session.cwd || null,
+      _perfT0: t0,
     });
+    perf("query_start sent");
   }
 
   function cleanupSessionWorker(session, fromWorker) {

package/lib/sdk-worker.js

@@ -4,8 +4,14 @@
 //
 // Usage: node sdk-worker.js <socket-path>
 
+// Force IPv4-only for all child processes (including SDK CLI subprocess).
+// Without this, Node 22+ happy eyeballs tries IPv6 first (10s timeout on
+// servers without IPv6 outbound), causing massive cold-start delays.
+process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS || "") + " --dns-result-order=ipv4first --no-network-family-autoselection";
+
 // Early diagnostic — writes directly to fd 2 to ensure output even if pipes close fast
-try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=" + (typeof process.getuid === "function" ? process.getuid() : "?") + " argv=" + process.argv.slice(1).join(" ") + "\n"); } catch (e) {}
+var _workerBootTs = Date.now();
+try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=" + (typeof process.getuid === "function" ? process.getuid() : "?") + " argv=" + process.argv.slice(1).join(" ") + " bootTs=" + _workerBootTs + "\n"); } catch (e) {}
 
 var net = require("net");
 var crypto = require("crypto");
@@ -204,9 +210,16 @@ function handleElicitationResponse(msg) {
 
 // --- Query handling ---
 async function handleQueryStart(msg) {
+  var t0 = msg._perfT0 || Date.now();
+  var localT0 = Date.now();
+  function perf(label) { console.log("[PERF] sdk-worker: " + label + " +" + (Date.now() - t0) + "ms (local +" + (Date.now() - localT0) + "ms)"); }
+  perf("handleQueryStart entered");
+
   var sdk;
   try {
+    perf("loading SDK");
     sdk = await getSDK();
+    perf("SDK loaded");
   } catch (e) {
     sendToDaemon({ type: "query_error", error: "Failed to load SDK: " + (e.message || e), exitCode: null, stderr: null });
     return;
@@ -223,6 +236,39 @@ async function handleQueryStart(msg) {
   // Build query options (callbacks are local, everything else from daemon)
   var options = msg.options || {};
   options.abortController = abortController;
+  options.debug = true;
+  options.debugFile = "/tmp/clay-cli-debug-" + process.pid + ".log";
+  // Override CLI subprocess spawn to inject NODE_OPTIONS for IPv4-first DNS.
+  // The SDK constructs its own env for the CLI process, so worker env vars
+  // like NODE_OPTIONS are not inherited. We intercept the spawn to fix this.
+  options.spawnClaudeCodeProcess = function(spawnOpts) {
+    // Force IPv4-only at every level: preload script patches dns.lookup to
+    // only return IPv4, disables autoSelectFamily, and sets ipv4first order.
+    // This is needed because the CLI's Axios-based HTTP client ignores
+    // NODE_OPTIONS dns flags and still attempts IPv6 connections via its
+    // custom TLS agent, causing 5-10s timeouts on IPv6-less servers.
+    var preloadScript = require("path").join(__dirname, "ipv4-only.js");
+    var extraOpts = " --require " + JSON.stringify(preloadScript);
+    extraOpts += " --dns-result-order=ipv4first --no-network-family-autoselection";
+    spawnOpts.env.NODE_OPTIONS = (spawnOpts.env.NODE_OPTIONS || "") + extraOpts;
+    console.log("[sdk-worker] spawnClaudeCodeProcess called, command=" + spawnOpts.command);
+    var cp = require("child_process").spawn(spawnOpts.command, spawnOpts.args, {
+      cwd: spawnOpts.cwd,
+      env: spawnOpts.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    // Capture ALL CLI stderr
+    if (cp.stderr) {
+      cp.stderr.on("data", function(chunk) {
+        var lines = chunk.toString().split("\n");
+        for (var li = 0; li < lines.length; li++) {
+          var line = lines[li].trim();
+          if (line) console.log("[CLI-STDERR] " + line.substring(0, 500));
+        }
+      });
+    }
+    return cp;
+  };
   options.canUseTool = function(toolName, input, toolOpts) {
     // AskUserQuestion is handled specially: we send it as a separate IPC type
     // so the daemon can use its own AskUserQuestion handling logic
@@ -249,11 +295,13 @@ async function handleQueryStart(msg) {
     return onElicitation(request, elicitOpts);
   };
 
+  perf("creating query instance");
   try {
     queryInstance = sdk.query({
       prompt: messageQueue,
       options: options,
     });
+    perf("query instance created");
   } catch (e) {
     sendToDaemon({ type: "query_error", error: "Failed to create query: " + (e.message || e), exitCode: null, stderr: null });
     queryInstance = null;
@@ -269,9 +317,41 @@ async function handleQueryStart(msg) {
 
   // Stream events to daemon
   try {
+    var firstEvent = true;
+    var firstText = true;
+    var eventCounts = {};
     for await (var event of queryInstance) {
+      var etype = (event && event.type || "?");
+      var esubtype = (event && event.subtype || "");
+      eventCounts[etype] = (eventCounts[etype] || 0) + 1;
+      if (firstEvent) {
+        perf("FIRST event from SDK (type=" + etype + " subtype=" + esubtype + ")");
+        firstEvent = false;
+      }
+      // Log every non-content event, and the first content/text event
+      if (etype !== "content_block_delta" && etype !== "content_block_start" && etype !== "content_block_stop") {
+        var extraInfo = "";
+        if (esubtype === "api_retry") {
+          // Dump full event to see all available fields
+          try {
+            var retryDump = JSON.stringify(event, function(k, v) {
+              if (typeof v === "string" && v.length > 200) return v.substring(0, 200) + "...[truncated]";
+              return v;
+            });
+            extraInfo = " FULL=" + retryDump;
+          } catch (je) {
+            extraInfo = " keys=" + Object.keys(event).join(",");
+          }
+        }
+        perf("SDK event #" + eventCounts[etype] + " type=" + etype + " subtype=" + esubtype + extraInfo);
+      }
+      if (firstText && (etype === "content_block_delta" || etype === "assistant" || (etype === "content_block_start"))) {
+        perf("FIRST TEXT/CONTENT event (type=" + etype + " subtype=" + esubtype + ")");
+        firstText = false;
+      }
       sendToDaemon({ type: "sdk_event", event: event });
     }
+    perf("all events streamed (counts=" + JSON.stringify(eventCounts) + "), sending query_done");
     sendToDaemon({ type: "query_done" });
   } catch (err) {
     var errMsg = err.message || String(err);
@@ -424,9 +504,9 @@ function gracefulExit(code) {
 var _keepAlive = setInterval(function() {}, 30000);
 
 // --- Connect to daemon socket ---
-try { require("fs").writeSync(2, "[sdk-worker] Connecting to socket: " + socketPath + "\n"); } catch (e) {}
+try { require("fs").writeSync(2, "[sdk-worker] Connecting to socket: " + socketPath + " +" + (Date.now() - _workerBootTs) + "ms since boot\n"); } catch (e) {}
 conn = net.connect(socketPath, function() {
-  try { require("fs").writeSync(2, "[sdk-worker] Connected, sending ready\n"); } catch (e) {}
+  try { require("fs").writeSync(2, "[sdk-worker] Connected, sending ready +" + (Date.now() - _workerBootTs) + "ms since boot\n"); } catch (e) {}
   sendToDaemon({ type: "ready" });
 });
 

package/lib/server.js

@@ -1132,6 +1132,8 @@ function createServer(opts) {
         profile.userId = mu.id;
         profile.role = mu.role;
         profile.autoContinueOnRateLimit = !!mu.autoContinueOnRateLimit;
+        profile.chatLayout = mu.chatLayout || "channel";
+        profile.mateOnboardingShown = !!mu.mateOnboardingShown;
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(profile));
         return;
@@ -1147,10 +1149,12 @@ function createServer(opts) {
         if (saved.avatarSeed) profile.avatarSeed = saved.avatarSeed;
         if (saved.avatarCustom) profile.avatarCustom = saved.avatarCustom;
       } catch (e) { /* file doesn't exist yet */ }
-      // Single-user auto-continue from daemon config
+      // Single-user settings from daemon config
       if (typeof opts.onGetDaemonConfig === "function") {
         var dc = opts.onGetDaemonConfig();
         profile.autoContinueOnRateLimit = !!dc.autoContinueOnRateLimit;
+        profile.chatLayout = dc.chatLayout || "channel";
+        profile.mateOnboardingShown = !!dc.mateOnboardingShown;
       }
       // Check if custom avatar file exists
       try {
@@ -1262,7 +1266,10 @@ function createServer(opts) {
             }
           }
         } catch (e) {}
-        fs.writeFileSync(path.join(avatarDir, filename), raw);
+        var avatarFilePath = path.join(avatarDir, filename);
+        fs.writeFileSync(avatarFilePath, raw);
+        try { fs.chmodSync(avatarFilePath, 0o644); } catch (e) {}
+        try { fs.chmodSync(avatarDir, 0o755); } catch (e) {}
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true, avatar: "/api/avatar/" + userId + "?v=" + Date.now() }));
       });
@@ -1360,7 +1367,10 @@ function createServer(opts) {
             }
           }
         } catch (e) {}
-        fs.writeFileSync(path.join(avatarDir, filename), raw);
+        var mateAvatarFilePath = path.join(avatarDir, filename);
+        fs.writeFileSync(mateAvatarFilePath, raw);
+        try { fs.chmodSync(mateAvatarFilePath, 0o644); } catch (e) {}
+        try { fs.chmodSync(avatarDir, 0o755); } catch (e) {}
         var avatarPath = "/api/mate-avatar/" + mateIdFromUrl + "?v=" + Date.now();
         // Update mate profile with custom avatar URL
         var profile = mate.profile || {};
@@ -1483,6 +1493,68 @@ function createServer(opts) {
       return;
     }
 
+    // PUT /api/user/chat-layout
+    if (req.method === "PUT" && fullUrl === "/api/user/chat-layout") {
+      var mu = getMultiUserFromReq(req);
+      if (!mu) {
+        // Single-user: save to daemon config
+        var body = "";
+        req.on("data", function (chunk) { body += chunk; });
+        req.on("end", function () {
+          try {
+            var data = JSON.parse(body);
+            var val = (data.layout === "bubble") ? "bubble" : "channel";
+            if (typeof opts.onSetChatLayout === "function") {
+              opts.onSetChatLayout(val);
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, chatLayout: val }));
+          } catch (e) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end('{"error":"Invalid request"}');
+          }
+        });
+        return;
+      }
+      var body = "";
+      req.on("data", function (chunk) { body += chunk; });
+      req.on("end", function () {
+        try {
+          var data = JSON.parse(body);
+          var result = users.setChatLayout(mu.id, data.layout);
+          if (result.error) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: result.error }));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true, chatLayout: result.chatLayout }));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end('{"error":"Invalid request"}');
+        }
+      });
+      return;
+    }
+
+    // POST /api/user/mate-onboarded
+    if (req.method === "POST" && fullUrl === "/api/user/mate-onboarded") {
+      var mu = getMultiUserFromReq(req);
+      if (!mu) {
+        // Single-user: save to daemon config
+        if (typeof opts.onSetMateOnboarded === "function") {
+          opts.onSetMateOnboarded();
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end('{"ok":true}');
+      } else {
+        users.setMateOnboarded(mu.id);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end('{"ok":true}');
+      }
+      return;
+    }
+
     // GET /api/user/auto-continue
     if (req.method === "GET" && fullUrl === "/api/user/auto-continue") {
       var mu = getMultiUserFromReq(req);
@@ -2829,6 +2901,24 @@ function createServer(opts) {
         });
         return list;
       },
+      getAllProjectSessions: function () {
+        var allSessions = [];
+        projects.forEach(function (pCtx, pSlug) {
+          if (pSlug === slug) return; // skip self
+          var status = pCtx.getStatus();
+          if (status.isWorktree) return;
+          var pSm = pCtx.getSessionManager();
+          if (!pSm) return;
+          var projectTitle = status.title || status.project || pSlug;
+          pSm.sessions.forEach(function (s) {
+            if (!s.hidden && s.history && s.history.length > 0) {
+              s._projectTitle = projectTitle;
+              allSessions.push(s);
+            }
+          });
+        });
+        return allSessions;
+      },
       getHubSchedules: function () {
         var allSchedules = [];
         projects.forEach(function (ctx, s) {

package/lib/session-search.js

@@ -412,12 +412,13 @@ function searchSessions(sessions, query, opts) {
 }
 
 /**
- * Unified mate search: digests + session history combined.
- * Returns merged, re-ranked results from both sources.
+ * Unified mate search: digests + session history + knowledge files combined.
+ * Returns merged, re-ranked results from all sources.
  * For global search (e.g. Ally), pass otherDigests array with paths and mate names.
- * @param {object} opts - { digestFilePath, otherDigests, sessions, query, maxResults, minScore }
+ * @param {object} opts - { digestFilePath, otherDigests, sessions, knowledgeFiles, query, maxResults, minScore }
  *   otherDigests: [{ path: string, mateName: string }] - other mates' digest files
- * @returns {Array} [{ source: "digest"|"session", score, mateName, ... }]
+ *   knowledgeFiles: [{ filePath: string, name: string, mateName: string }] - knowledge files to search
+ * @returns {Array} [{ source: "digest"|"session"|"knowledge", score, mateName, ... }]
  */
 function searchMate(opts) {
   if (!opts || !opts.query || !opts.query.trim()) return [];
@@ -447,9 +448,33 @@ function searchMate(opts) {
     }
   }
 
+  // Collect knowledge file docs
+  if (opts.knowledgeFiles && opts.knowledgeFiles.length > 0) {
+    for (var ki = 0; ki < opts.knowledgeFiles.length; ki++) {
+      var kf = opts.knowledgeFiles[ki];
+      try {
+        if (!fs.existsSync(kf.filePath)) continue;
+        var content = fs.readFileSync(kf.filePath, "utf8").trim();
+        if (!content || content.length < 20) continue;
+        // Cap at 4000 chars to avoid oversized docs dominating the index
+        var capped = content.length > 4000 ? content.substring(0, 4000) : content;
+        allDocs.push({
+          id: "knowledge:" + (kf.mateName || "self") + ":" + kf.name,
+          text: kf.name + " " + kf.name + " " + capped,
+          meta: {
+            source: "knowledge",
+            fileName: kf.name,
+            mateName: kf.mateName || null,
+            snippet: content.length > 200 ? content.substring(0, 200) + "..." : content
+          }
+        });
+      } catch (e) {}
+    }
+  }
+
   if (allDocs.length === 0) return [];
 
-  // Build unified index across both sources and search
+  // Build unified index across all sources and search
   var index = buildIndex(allDocs);
   var results = searchIndex(index, opts.query, maxResults);
 
@@ -463,6 +488,10 @@ function searchMate(opts) {
       out.digest = r.meta.digest;
       out.lineIdx = r.meta.lineIdx;
       out.mateName = r.meta.mateName || null;
+    } else if (r.meta.source === "knowledge") {
+      out.fileName = r.meta.fileName;
+      out.mateName = r.meta.mateName || null;
+      out.snippet = r.meta.snippet;
     } else {
       out.sessionId = r.meta.sessionId;
       out.sessionTitle = r.meta.sessionTitle;
@@ -620,6 +649,12 @@ function formatForContext(results) {
       }
       line += " (relevance: " + scorePct + ")";
       lines.push(line);
+    } else if (r.source === "knowledge") {
+      var line = "- [knowledge: " + (r.fileName || "?") + "] ";
+      if (r.mateName) line += "(@" + r.mateName + ") ";
+      line += (r.snippet || "(no preview)");
+      line += " (relevance: " + scorePct + ")";
+      lines.push(line);
     } else if (r.source === "session") {
       var line = "- [session: " + (r.sessionTitle || "?") + "] ";
       line += (r.snippet || "(no preview)");

package/lib/sessions.js

@@ -577,7 +577,7 @@ function createSessionManager(opts) {
       var contentMatch = false;
       for (var i = 0; i < session.history.length; i++) {
         var entry = session.history[i];
-        if ((entry.type === "delta" || entry.type === "user_message" || entry.type === "mention_user" || entry.type === "mention_response" || entry.type === "debate_turn_done") && entry.text) {
+        if ((entry.type === "delta" || entry.type === "user_message" || entry.type === "mention_user" || entry.type === "mention_response" || entry.type === "debate_turn_done" || entry.type === "debate_comment_injected") && entry.text) {
           if (entry.text.toLowerCase().indexOf(q) !== -1) {
             contentMatch = true;
             break;
@@ -614,7 +614,7 @@ function createSessionManager(opts) {
         currentTurnStart = i;
         lastAssistantHitTurn = -1;
       }
-      if ((entry.type === "delta" || entry.type === "user_message" || entry.type === "mention_user" || entry.type === "mention_response" || entry.type === "debate_turn_done") && entry.text) {
+      if ((entry.type === "delta" || entry.type === "user_message" || entry.type === "mention_user" || entry.type === "mention_response" || entry.type === "debate_turn_done" || entry.type === "debate_comment_injected") && entry.text) {
         // Skip duplicate delta hits within the same assistant turn
         if (entry.type === "delta" && currentTurnStart === lastAssistantHitTurn) continue;
         var text = entry.text;