adhdev 0.9.55 → 0.9.57

package/dist/cli/index.js

@@ -14705,6 +14705,12 @@ var init_provider_cli_adapter = __esm({
       accumulatedRawBuffer = "";
       /** Current visible terminal screen snapshot */
       terminalScreen = new TerminalScreen(24, 80);
+      static MAX_RESPONSE_BUFFER = 8e3;
+      static MAX_RECENT_OUTPUT_BUFFER = 1e3;
+      responseBufferDroppedChars = 0;
+      recentOutputDroppedChars = 0;
+      accumulatedBufferDroppedChars = 0;
+      accumulatedRawBufferDroppedChars = 0;
       /** Max accumulated buffer size. Sized to comfortably hold a single long
        *  Hermes turn (tool calls + reasoning + final bubble) without the
        *  rolling window pushing the turn's ╭─ opening line out of view. */
@@ -14722,6 +14728,23 @@ var init_provider_cli_adapter = __esm({
       providerResolutionMeta;
       static FINISH_RETRY_DELAY_MS = 300;
       static MAX_FINISH_RETRIES = 2;
+      getBufferState() {
+        const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
+        const responseBuffer = build(this.responseBufferDroppedChars, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+        const recentOutputBuffer = build(this.recentOutputDroppedChars, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
+        const accumulatedBuffer = build(this.accumulatedBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const accumulatedRawBuffer = build(this.accumulatedRawBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        if (!responseBuffer && !recentOutputBuffer && !accumulatedBuffer && !accumulatedRawBuffer) return void 0;
+        return {
+          ...responseBuffer ? { responseBuffer } : {},
+          ...recentOutputBuffer ? { recentOutputBuffer } : {},
+          ...accumulatedBuffer ? { accumulatedBuffer } : {},
+          ...accumulatedRawBuffer ? { accumulatedRawBuffer } : {}
+        };
+      }
+      recordBoundedAppendDrop(previousLength, appendedLength, nextLength) {
+        return Math.max(0, previousLength + appendedLength - nextLength);
+      }
       buildCommittedMessagesActivitySignature() {
         const last = this.committedMessages[this.committedMessages.length - 1];
         return [
@@ -15087,7 +15110,9 @@ var init_provider_cli_adapter = __esm({
           this.scheduleStartupSettleCheck();
         }
         if (this.isWaitingForResponse && cleanData) {
-          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, 8e3);
+          const previousResponseLen = this.responseBuffer.length;
+          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+          this.responseBufferDroppedChars += this.recordBoundedAppendDrop(previousResponseLen, cleanData.length, this.responseBuffer.length);
         }
         if (cleanData.trim()) {
           if (this.serverConn) {
@@ -15096,14 +15121,19 @@ var init_provider_cli_adapter = __esm({
             this.logBuffer.push({ message: cleanData.trim(), level: "info" });
           }
         }
+        const prevRecentLen = this.recentOutputBuffer.length;
         const prevAccumulatedLen = this.accumulatedBuffer.length;
         const prevAccumulatedRawLen = this.accumulatedRawBuffer.length;
-        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, 1e3);
+        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
         this.accumulatedBuffer = appendBoundedText(this.accumulatedBuffer, cleanData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
         this.accumulatedRawBuffer = appendBoundedText(this.accumulatedRawBuffer, rawData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const droppedRecent = this.recordBoundedAppendDrop(prevRecentLen, cleanData.length, this.recentOutputBuffer.length);
+        const droppedClean = this.recordBoundedAppendDrop(prevAccumulatedLen, cleanData.length, this.accumulatedBuffer.length);
+        const droppedRaw = this.recordBoundedAppendDrop(prevAccumulatedRawLen, rawData.length, this.accumulatedRawBuffer.length);
+        this.recentOutputDroppedChars += droppedRecent;
+        this.accumulatedBufferDroppedChars += droppedClean;
+        this.accumulatedRawBufferDroppedChars += droppedRaw;
         if (this.currentTurnScope) {
-          const droppedClean = prevAccumulatedLen + cleanData.length - this.accumulatedBuffer.length;
-          const droppedRaw = prevAccumulatedRawLen + rawData.length - this.accumulatedRawBuffer.length;
           if (droppedClean > 0) {
             this.currentTurnScope.bufferStart = Math.max(0, this.currentTurnScope.bufferStart - droppedClean);
           }
@@ -15933,13 +15963,15 @@ var init_provider_cli_adapter = __esm({
             effectiveModal = parsedModal;
           }
         }
+        const bufferState = this.getBufferState();
         return {
           status: effectiveStatus,
           messages: [...this.committedMessages],
           workingDir: this.workingDir,
           activeModal: effectiveModal,
           errorMessage: this.parseErrorMessage || void 0,
-          errorReason: this.parseErrorMessage ? "parse_error" : void 0
+          errorReason: this.parseErrorMessage ? "parse_error" : void 0,
+          ...bufferState ? { bufferState } : {}
         };
       }
       seedCommittedMessages(messages) {
@@ -16121,10 +16153,12 @@ var init_provider_cli_adapter = __esm({
             messages: hydratedMessages,
             activeModal: parsed.activeModal ?? this.activeModal,
             providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0,
+            ...this.getBufferState() ? { bufferState: this.getBufferState() } : {},
             ...this.providerOwnsTranscript() ? { transcriptAuthority: "provider", coverage: this.shouldUseFullProviderTranscriptContext() ? "full" : "tail" } : {}
           };
         } else {
           const messages = [...this.committedMessages];
+          const bufferState = this.getBufferState();
           result = {
             id: "cli_session",
             status: this.currentStatus,
@@ -16135,7 +16169,8 @@ var init_provider_cli_adapter = __esm({
               index: typeof message.index === "number" ? message.index : index,
               receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
             })),
-            activeModal: this.activeModal
+            activeModal: this.activeModal,
+            ...bufferState ? { bufferState } : {}
           };
         }
         const hasVisibleAssistantMessage = Array.isArray(result?.messages) && result.messages.some((message) => message?.role === "assistant" && typeof message?.content === "string" && message.content.trim());
@@ -35856,7 +35891,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolvedDir,
             resolvedCliArgs,
             resolvedProvider,
-            {},
+            this.providerLoader.getSettings(normalizedType),
             false,
             {
               providerSessionId: sessionBinding.providerSessionId,
@@ -38006,9 +38041,9 @@ function validateProviderDefinition(raw) {
   const typedProvider = provider;
   const controls = Array.isArray(provider.controls) ? provider.controls : [];
   if (category === "cli" || category === "acp") {
-    const spawn6 = provider.spawn;
-    const command = spawn6 && typeof spawn6 === "object" ? spawn6.command : void 0;
-    if (!spawn6 || typeof spawn6 !== "object") {
+    const spawn7 = provider.spawn;
+    const command = spawn7 && typeof spawn7 === "object" ? spawn7.command : void 0;
+    if (!spawn7 || typeof spawn7 !== "object") {
       errors.push(`${String(category).toUpperCase()}/CLI providers must have spawn config`);
     } else if (typeof command !== "string" || !command.trim()) {
       errors.push("spawn.command is required");
@@ -46232,8 +46267,8 @@ async function handleAutoImplement(ctx, type, req, res) {
     fs14.writeFileSync(promptFile, prompt2, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt2.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
-    const spawn6 = agentProvider?.spawn;
-    if (!spawn6?.command) {
+    const spawn7 = agentProvider?.spawn;
+    if (!spawn7?.command) {
       try {
         fs14.unlinkSync(promptFile);
       } catch {
@@ -46243,22 +46278,22 @@ async function handleAutoImplement(ctx, type, req, res) {
     }
     const agentCategory = agentProvider?.category;
     if (agentCategory === "acp") {
-      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn6.command} ${(spawn6.args || []).join(" ")}` } });
+      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn7.command} ${(spawn7.args || []).join(" ")}` } });
       ctx.autoImplStatus.running = true;
       ctx.autoImplStatus.type = type;
       const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
       const { Readable: Readable3, Writable: Writable3 } = await import("stream");
       const { spawn: spawnFn2 } = await import("child_process");
-      const acpArgs = [...spawn6.args || []];
+      const acpArgs = [...spawn7.args || []];
       if (model) {
         acpArgs.push("--model", model);
         ctx.log(`Auto-implement ACP using model: ${model}`);
       }
-      const child2 = spawnFn2(spawn6.command, acpArgs, {
+      const child2 = spawnFn2(spawn7.command, acpArgs, {
         cwd: providerDir,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: spawn6.shell ?? false,
-        env: { ...process.env, ...spawn6.env || {} }
+        shell: spawn7.shell ?? false,
+        env: { ...process.env, ...spawn7.env || {} }
       });
       ctx.autoImplProcess = child2;
       child2.stderr?.on("data", (d) => {
@@ -46368,7 +46403,7 @@ async function handleAutoImplement(ctx, type, req, res) {
       ctx.json(res, 202, {
         started: true,
         type,
-        agent: spawn6.command,
+        agent: spawn7.command,
         functions,
         providerDir,
         message: "ACP Auto-implement started. Connect to SSE for progress.",
@@ -46376,10 +46411,10 @@ async function handleAutoImplement(ctx, type, req, res) {
       });
       return;
     }
-    const command = spawn6.command;
-    const autoImpl = spawn6.autoImpl;
+    const command = spawn7.command;
+    const autoImpl = spawn7.autoImpl;
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
-    const baseArgs = [...spawn6.args || []].filter((a) => !interactiveFlags.includes(a));
+    const baseArgs = [...spawn7.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
     const isWin = os24.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
@@ -46426,7 +46461,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         cols: 120,
         rows: 40,
         cwd: providerDir,
-        env: { ...process.env, ...spawn6.env || {} }
+        env: { ...process.env, ...spawn7.env || {} }
       });
       isPty = true;
     } catch (err) {
@@ -46438,7 +46473,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdio: ["pipe", "pipe", "pipe"],
         env: {
           ...process.env,
-          ...spawn6.env || {}
+          ...spawn7.env || {}
         }
       });
       child.on("error", (err2) => {
@@ -47610,16 +47645,16 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn6 = provider.spawn;
-        if (!spawn6) {
+        const spawn7 = provider.spawn;
+        if (!spawn7) {
           this.json(res, 400, { error: `Provider ${type} has no spawn config` });
           return;
         }
         const { spawn: spawnFn } = await import("child_process");
         const start = Date.now();
         try {
-          const child = spawnFn(spawn6.command, [...spawn6.args || []], {
-            shell: spawn6.shell ?? false,
+          const child = spawnFn(spawn7.command, [...spawn7.args || []], {
+            shell: spawn7.shell ?? false,
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           });
@@ -47651,7 +47686,7 @@ var init_dev_server = __esm({
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: true,
-            command: `${spawn6.command} ${(spawn6.args || []).join(" ")}`,
+            command: `${spawn7.command} ${(spawn7.args || []).join(" ")}`,
             elapsed,
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -47661,7 +47696,7 @@ var init_dev_server = __esm({
           const elapsed = Date.now() - start;
           this.json(res, 200, {
             success: false,
-            command: `${spawn6.command} ${(spawn6.args || []).join(" ")}`,
+            command: `${spawn7.command} ${(spawn7.args || []).join(" ")}`,
             elapsed,
             error: e.message
           });
@@ -48124,20 +48159,20 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const spawn6 = provider.spawn;
-        if (!spawn6) {
+        const spawn7 = provider.spawn;
+        if (!spawn7) {
           this.json(res, 400, { error: `Provider ${type} has no spawn config` });
           return;
         }
         const { spawn: spawnFn } = await import("child_process");
         const start = Date.now();
         try {
-          const args = [...spawn6.args || [], message];
-          const child = spawnFn(spawn6.command, args, {
-            shell: spawn6.shell ?? false,
+          const args = [...spawn7.args || [], message];
+          const child = spawnFn(spawn7.command, args, {
+            shell: spawn7.shell ?? false,
             timeout,
             stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env, ...spawn6.env || {} }
+            env: { ...process.env, ...spawn7.env || {} }
           });
           let stdout = "";
           let stderr = "";
@@ -80944,6 +80979,58 @@ var init_server_connection = __esm({
       onStateChange(callback) {
         this.stateChangeCallbacks.push(callback);
       }
+      /**
+       * Send a command to another daemon owned by the same user, via server relay.
+       * The server validates ownership before forwarding to the target daemon.
+       *
+       * Returns the command result or throws on timeout / auth failure.
+       */
+      sendMeshCommand(targetDaemonId, command, args = {}, timeoutMs = 3e4) {
+        return new Promise((resolve21, reject) => {
+          const requestId = `mesh_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+          const timer = setTimeout(() => {
+            this.off("daemon_mesh_result", handler);
+            reject(new Error(`Mesh command timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          const handler = (msg) => {
+            if (msg.payload?.requestId !== requestId) return;
+            this.off("daemon_mesh_result", handler);
+            clearTimeout(timer);
+            if (msg.payload?.success === false) {
+              reject(new Error(msg.payload?.error ?? "Mesh command failed"));
+            } else {
+              resolve21(msg.payload?.result);
+            }
+          };
+          this.on("daemon_mesh_result", handler);
+          const sent = this.ws?.readyState === 1 && (() => {
+            try {
+              this.ws.send(JSON.stringify({
+                type: "daemon_mesh_command",
+                requestId,
+                targetDaemonId,
+                command,
+                args,
+                timestamp: Date.now()
+              }));
+              return true;
+            } catch {
+              return false;
+            }
+          })();
+          if (!sent) {
+            clearTimeout(timer);
+            this.off("daemon_mesh_result", handler);
+            reject(new Error("Not connected to server"));
+          }
+        });
+      }
+      off(type, handler) {
+        const handlers = this.messageHandlers.get(type);
+        if (!handlers) return;
+        const idx = handlers.indexOf(handler);
+        if (idx !== -1) handlers.splice(idx, 1);
+      }
       getState() {
         return this.state;
       }
@@ -81253,7 +81340,7 @@ function sendToPeer(peer, data) {
     return false;
   }
   const json2 = JSON.stringify(data);
-  if (messageType === "command_result" && json2.length > MAX_INLINE_JSON_MESSAGE_CHARS) {
+  if (messageType === "command_result" && Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_CHARS) {
     return sendChunkedCommandResult(peer, peerId, requestId, json2);
   }
   try {
@@ -81266,21 +81353,51 @@ function sendToPeer(peer, data) {
     return false;
   }
 }
+function buildCommandResultChunkEnvelope(requestId, chunkId, index, total, data) {
+  return JSON.stringify({
+    type: "command_result_chunk",
+    id: requestId,
+    chunkId,
+    index,
+    total,
+    data
+  });
+}
+function splitJsonIntoCommandResultChunks(json2, requestId, chunkId) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < json2.length) {
+    let end = Math.min(json2.length, offset + JSON_CHUNK_PAYLOAD_CHARS);
+    while (end > offset) {
+      const candidate = json2.slice(offset, end);
+      const envelope = buildCommandResultChunkEnvelope(requestId, chunkId, chunks.length, MAX_JSON_CHUNKS, candidate);
+      if (Buffer.byteLength(envelope, "utf8") <= MAX_INLINE_JSON_MESSAGE_BYTES) break;
+      end = offset + Math.max(1, Math.floor((end - offset) * 0.8));
+    }
+    chunks.push(json2.slice(offset, end));
+    if (chunks.length > MAX_JSON_CHUNKS) return [];
+    offset = end;
+  }
+  return chunks;
+}
 function sendChunkedCommandResult(peer, peerId, requestId, json2) {
   const chunkId = requestId || `command_result_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  const total = Math.ceil(json2.length / JSON_CHUNK_PAYLOAD_CHARS);
+  const chunks = splitJsonIntoCommandResultChunks(json2, requestId, chunkId);
+  const total = chunks.length;
+  if (total === 0 || total > MAX_JSON_CHUNKS) {
+    log(`command_result send failed: peer=${peerId} id=${requestId || "-"} reason=too_many_chunks chunks=${total || "unknown"}`);
+    return false;
+  }
   logDebug(`command_result chunked: peer=${peerId} id=${requestId || "-"} chars=${json2.length} chunks=${total}`);
   for (let index = 0; index < total; index += 1) {
-    const chunk = json2.slice(index * JSON_CHUNK_PAYLOAD_CHARS, (index + 1) * JSON_CHUNK_PAYLOAD_CHARS);
+    const chunk = chunks[index] || "";
     try {
-      peer.dataChannel?.sendMessage(JSON.stringify({
-        type: "command_result_chunk",
-        id: requestId,
-        chunkId,
-        index,
-        total,
-        data: chunk
-      }));
+      const envelope = buildCommandResultChunkEnvelope(requestId, chunkId, index, total, chunk);
+      if (Buffer.byteLength(envelope, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES) {
+        log(`command_result send failed: peer=${peerId} id=${requestId || "-"} chunk=${index + 1}/${total} reason=chunk_too_large`);
+        return false;
+      }
+      peer.dataChannel?.sendMessage(envelope);
     } catch (error48) {
       log(`command_result send failed: peer=${peerId} id=${requestId || "-"} chunk=${index + 1}/${total} error=${error48?.message || error48}`);
       return false;
@@ -81288,10 +81405,58 @@ function sendChunkedCommandResult(peer, peerId, requestId, json2) {
   }
   return true;
 }
+function parseChunkedJsonMessage(peerId, parsed) {
+  const chunkType = typeof parsed?.type === "string" ? parsed.type : "";
+  if (!chunkType.endsWith("_chunk")) return parsed;
+  const chunkId = typeof parsed?.chunkId === "string" ? parsed.chunkId : "";
+  const id = typeof parsed?.id === "string" ? parsed.id : "";
+  const index = Number(parsed?.index);
+  const total = Number(parsed?.total);
+  const data = typeof parsed?.data === "string" ? parsed.data : "";
+  if (!chunkId || !Number.isInteger(index) || !Number.isInteger(total) || index < 0 || total <= 0 || total > MAX_JSON_CHUNKS || index >= total || !data) {
+    log(`chunked JSON ignored: peer=${peerId} type=${chunkType || "unknown"} reason=malformed`);
+    return null;
+  }
+  const now = Date.now();
+  incomingJsonChunks.forEach((entry2, key2) => {
+    if (now - entry2.createdAt > JSON_CHUNK_TTL_MS) incomingJsonChunks.delete(key2);
+  });
+  const key = `${peerId}:${chunkId}`;
+  let entry = incomingJsonChunks.get(key);
+  if (!entry || entry.total !== total || entry.type !== chunkType) {
+    entry = { total, chunks: new Array(total).fill(""), received: 0, createdAt: now, type: chunkType, id };
+    incomingJsonChunks.set(key, entry);
+  }
+  if (!entry.chunks[index]) {
+    entry.chunks[index] = data;
+    entry.received += 1;
+  }
+  if (entry.received < entry.total) return null;
+  incomingJsonChunks.delete(key);
+  try {
+    return JSON.parse(entry.chunks.join(""));
+  } catch (error48) {
+    log(`chunked JSON parse failed: peer=${peerId} type=${chunkType} id=${entry.id || "-"} error=${error48?.message || error48}`);
+    return CHUNK_PARSE_FAILED;
+  }
+}
 function routeDataChannelMessage(peerId, msg, peers, handlers) {
   const text = typeof msg === "string" ? msg : msg.toString("utf-8");
   try {
-    const parsed = JSON.parse(text);
+    let parsed = JSON.parse(text);
+    const chunked = parseChunkedJsonMessage(peerId, parsed);
+    if (chunked === null) return;
+    if (chunked === CHUNK_PARSE_FAILED) {
+      const peer = peers.get(peerId);
+      const id = typeof parsed?.id === "string" ? parsed.id : "";
+      if (parsed?.type === "command_chunk") {
+        sendToPeer(peer, { type: "command_result", id, success: false, error: "Failed to reassemble chunked command" });
+      } else if (id) {
+        sendToPeer(peer, { id, type: "response", success: false, error: "Failed to reassemble chunked request" });
+      }
+      return;
+    }
+    parsed = chunked;
     if (parsed.type !== "command" && parsed.type !== "pty_input" && parsed.type !== "pty_resize" && parsed.type !== "ping" && parsed.type !== "pong") {
       logDebug(`Files message from peer ${peerId}: type=${parsed.type}`);
     }
@@ -81587,7 +81752,7 @@ async function handleFileRequest(peerId, req, peers, handlers) {
   }
   sendToPeer(peer, response);
 }
-var MAX_INLINE_JSON_MESSAGE_CHARS, JSON_CHUNK_PAYLOAD_CHARS;
+var MAX_INLINE_JSON_MESSAGE_CHARS, MAX_INLINE_JSON_MESSAGE_BYTES, JSON_CHUNK_PAYLOAD_CHARS, JSON_CHUNK_TTL_MS, MAX_JSON_CHUNKS, CHUNK_PARSE_FAILED, incomingJsonChunks;
 var init_data_channel_router = __esm({
   "src/daemon-p2p/data-channel-router.ts"() {
     "use strict";
@@ -81595,18 +81760,23 @@ var init_data_channel_router = __esm({
     init_permission();
     init_log();
     MAX_INLINE_JSON_MESSAGE_CHARS = 6e4;
-    JSON_CHUNK_PAYLOAD_CHARS = 32e3;
+    MAX_INLINE_JSON_MESSAGE_BYTES = 6e4;
+    JSON_CHUNK_PAYLOAD_CHARS = 16e3;
+    JSON_CHUNK_TTL_MS = 6e4;
+    MAX_JSON_CHUNKS = 1024;
+    CHUNK_PARSE_FAILED = /* @__PURE__ */ Symbol("chunk_parse_failed");
+    incomingJsonChunks = /* @__PURE__ */ new Map();
   }
 });
 
 // src/daemon-p2p/screenshot-sender.ts
-var CHUNK_SIZE, MAX_INLINE_JSON_MESSAGE_BYTES, JSON_CHUNK_PAYLOAD_CHARS2, ScreenshotSender;
+var CHUNK_SIZE, MAX_INLINE_JSON_MESSAGE_BYTES2, JSON_CHUNK_PAYLOAD_CHARS2, ScreenshotSender;
 var init_screenshot_sender = __esm({
   "src/daemon-p2p/screenshot-sender.ts"() {
     "use strict";
     init_log();
     CHUNK_SIZE = 6e4;
-    MAX_INLINE_JSON_MESSAGE_BYTES = 6e4;
+    MAX_INLINE_JSON_MESSAGE_BYTES2 = 6e4;
     JSON_CHUNK_PAYLOAD_CHARS2 = 16e3;
     ScreenshotSender = class {
       _ssDebugDone = false;
@@ -81650,7 +81820,7 @@ var init_screenshot_sender = __esm({
           type: "topic_update",
           update
         });
-        if (Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES) {
+        if (Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES2) {
           return this.sendChunkedTopicUpdate(peer, update, json2);
         }
         try {
@@ -81689,6 +81859,10 @@ var init_screenshot_sender = __esm({
         let sentAny = false;
         for (const peer of peers.values()) {
           if (peer.state !== "connected" || !peer.dataChannel?.isOpen()) continue;
+          if (Buffer.byteLength(msg, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES2) {
+            if (this.sendChunkedSessionOutput(peer, sessionId, msg)) sentAny = true;
+            continue;
+          }
           try {
             peer.dataChannel.sendMessage(msg);
             sentAny = true;
@@ -81697,6 +81871,27 @@ var init_screenshot_sender = __esm({
         }
         return sentAny;
       }
+      sendChunkedSessionOutput(peer, sessionId, json2) {
+        const chunkId = `session_output:${sessionId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+        const total = Math.ceil(json2.length / JSON_CHUNK_PAYLOAD_CHARS2);
+        logDebug(`session_output chunked: peer=${peer.peerId || "unknown"} sessionId=${sessionId || "-"} chars=${json2.length} chunks=${total}`);
+        for (let index = 0; index < total; index += 1) {
+          const chunk = json2.slice(index * JSON_CHUNK_PAYLOAD_CHARS2, (index + 1) * JSON_CHUNK_PAYLOAD_CHARS2);
+          try {
+            peer.dataChannel?.sendMessage(JSON.stringify({
+              type: "session_output_chunk",
+              sessionId,
+              chunkId,
+              index,
+              total,
+              data: chunk
+            }));
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      }
       sendScreenshot(peers, base64Data, targetSessionId) {
         const buffer = Buffer.from(base64Data, "base64");
         return this.sendScreenshotBuffer(peers, buffer, targetSessionId);
@@ -89792,6 +89987,64 @@ var init_session_host_controller = __esm({
   }
 });
 
+// src/daemon-mesh-manager.ts
+var daemon_mesh_manager_exports = {};
+__export(daemon_mesh_manager_exports, {
+  DaemonMeshManager: () => DaemonMeshManager
+});
+function interpolateArgs(args, context) {
+  const result = {};
+  for (const [k, v] of Object.entries(args)) {
+    result[k] = typeof v === "string" ? interpolateString(v, context) : v;
+  }
+  return result;
+}
+function interpolateString(template, ctx) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_2, key) => {
+    const val = ctx[key];
+    return val !== void 0 ? String(val) : `{{${key}}}`;
+  });
+}
+var DaemonMeshManager;
+var init_daemon_mesh_manager = __esm({
+  "src/daemon-mesh-manager.ts"() {
+    "use strict";
+    init_src();
+    DaemonMeshManager = class {
+      rules = [];
+      serverConn;
+      constructor(serverConn) {
+        this.serverConn = serverConn;
+      }
+      setRules(rules) {
+        this.rules = rules;
+        LOG.info("Mesh", `[Mesh] ${rules.length} rule(s) loaded`);
+      }
+      async emit(event) {
+        const matching = this.rules.filter((r) => r.trigger === event.trigger);
+        if (matching.length === 0) return;
+        await Promise.allSettled(
+          matching.map((rule) => this.executeRule(rule, event.context ?? {}))
+        );
+      }
+      async executeRule(rule, context) {
+        const args = interpolateArgs(rule.args ?? {}, context);
+        try {
+          LOG.info("Mesh", `[Mesh] Relaying '${rule.command}' \u2192 ${rule.targetDaemonId.slice(0, 12)}\u2026`);
+          await this.serverConn.sendMeshCommand(rule.targetDaemonId, rule.command, args);
+          LOG.info("Mesh", `[Mesh] Relay '${rule.command}' complete`);
+        } catch (err) {
+          LOG.warn("Mesh", `[Mesh] Relay '${rule.command}' failed: ${err?.message ?? err}`);
+        }
+      }
+      /** Convenience: send a one-off mesh command without a rule. */
+      async sendCommand(targetDaemonId, command, args = {}) {
+        return this.serverConn.sendMeshCommand(targetDaemonId, command, args);
+      }
+    };
+  }
+});
+
 // src/adhdev-daemon.ts
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
@@ -90036,13 +90289,14 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.55" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.57" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
       localClients = /* @__PURE__ */ new Set();
       serverConn = null;
       p2p = null;
+      meshManager = null;
       screenshotController = null;
       statusReporter = null;
       topicSubscriptionTimer = null;
@@ -90626,6 +90880,12 @@ ${err?.stack || ""}`);
             }
           });
           this.p2p = new DaemonP2PSender(this.serverConn);
+          const { DaemonMeshManager: DaemonMeshManager2 } = await Promise.resolve().then(() => (init_daemon_mesh_manager(), daemon_mesh_manager_exports));
+          this.meshManager = new DaemonMeshManager2(this.serverConn);
+          const meshRules = config2.meshRules;
+          if (Array.isArray(meshRules) && meshRules.length > 0) {
+            this.meshManager.setRules(meshRules);
+          }
           if (this.p2p.isAvailable) {
             console.log(source_default.green("  \u{1F517} P2P available (node-datachannel)"));
             this.p2p.onInput(async (event) => {
@@ -90964,6 +91224,16 @@ ${err?.stack || ""}`);
           if (cmdType.startsWith("git_")) {
             void this.flushP2PWorkspaceGitSubscriptions();
           }
+          if (cmdType === "git_checkpoint" && routed.success && this.meshManager) {
+            void this.meshManager.emit({
+              trigger: "git_checkpoint_complete",
+              context: {
+                workspace: String(normalizedData.workspace ?? ""),
+                checkpoint_message: routed.checkpoint?.message ?? String(normalizedData.message ?? ""),
+                commit: routed.checkpoint?.commit ?? ""
+              }
+            });
+          }
           return { ...routed, interactionId };
         } catch (e) {
           logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd: cmdType, source: "p2p", interactionId, success: false, error: e.message, durationMs: Date.now() - cmdStart });
@@ -93674,9 +93944,9 @@ async function requestSessionHostDirect(request) {
   }
 }
 async function runRuntimeLaunchSpec(spec) {
-  const { spawn: spawn6 } = await import("child_process");
+  const { spawn: spawn7 } = await import("child_process");
   return await new Promise((resolve21, reject) => {
-    const child = spawn6(spec.command, spec.args, {
+    const child = spawn7(spec.command, spec.args, {
       stdio: "inherit",
       env: spec.env,
       shell: process.platform === "win32" && spec.command !== process.execPath
@@ -93945,7 +94215,7 @@ async function handleTraceCommand(options) {
 async function runDaemonUpgrade(options, pkgVersion3) {
   const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
   const { stopManagedSessionHostProcess: stopManagedSessionHostProcess2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-  const { execSync: execSync8, spawn: spawn6 } = await import("child_process");
+  const { execSync: execSync8, spawn: spawn7 } = await import("child_process");
   const fsMod = await import("fs");
   const pathMod = await import("path");
   console.log(source_default.bold("\n  \u{1F504} ADHDev Upgrade\n"));
@@ -94029,7 +94299,7 @@ async function runDaemonUpgrade(options, pkgVersion3) {
     await new Promise((r) => setTimeout(r, 2e3));
     stopManagedSessionHostProcess2();
     await new Promise((r) => setTimeout(r, 500));
-    const child = spawn6(process.execPath, [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT], {
+    const child = spawn7(process.execPath, [process.argv[1], "daemon", "-p", DEFAULT_DAEMON_PORT_TEXT], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -94076,7 +94346,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     }
   });
   program2.command("standalone").description("\u{1F5A5}\uFE0F  Start ADHDev Standalone Server (Local Dashboard & Embedded Daemon)").option("-p, --port <port>", "Local HTTP/WS server port", "3847").option("--host <host>", "Bind to specific host (use 0.0.0.0 for LAN access)").option("--no-open", "Prevent opening browser automatically").option("--token <token>", "Require token authentication").option("--dev", "Enable Dev Mode").action(async (options) => {
-    const { spawn: spawn6, execSync: execSync8 } = await import("child_process");
+    const { spawn: spawn7, execSync: execSync8 } = await import("child_process");
     const { DEFAULT_STANDALONE_SESSION_HOST_APP_NAME: DEFAULT_STANDALONE_SESSION_HOST_APP_NAME2, resolveSessionHostAppNameResolution: resolveSessionHostAppNameResolution2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     console.log(source_default.cyan("\n  Starting ADHDev Standalone Server..."));
     const args = [];
@@ -94105,7 +94375,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     }
     console.log(source_default.gray(`  Session host namespace: ${sessionHostName}${sessionHostResolution.source === "default" ? " (default isolated standalone namespace)" : sessionHostResolution.source === "explicit" ? " (from ADHDEV_SESSION_HOST_NAME)" : " (auto-corrected for standalone isolation)"}`));
     const spawnArgs = bin === "npx" ? npxArgs : args;
-    const child = spawn6(bin, spawnArgs, {
+    const child = spawn7(bin, spawnArgs, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: standaloneEnv
@@ -94579,7 +94849,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
   hideCommand(program2.command("daemon:restart").description("Restart ADHDev Daemon (stop \u2192 start)").option("-p, --port <port>", "Local WS server port", DEFAULT_DAEMON_PORT_TEXT).option("--server <url>", "Override server URL").option("--dev", "Enable Dev Mode").action(async (options) => {
     const { stopDaemon: stopDaemon2, isDaemonRunning: isDaemonRunning2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const { stopManagedSessionHostProcess: stopManagedSessionHostProcess2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
-    const { spawn: spawn6 } = await import("child_process");
+    const { spawn: spawn7 } = await import("child_process");
     if (isDaemonRunning2({ port: parseInt(options.port, 10) || DEFAULT_DAEMON_PORT })) {
       console.log(source_default.yellow("\n  Stopping existing daemon..."));
       stopDaemon2({ port: parseInt(options.port, 10) || DEFAULT_DAEMON_PORT });
@@ -94591,7 +94861,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
     const args = ["daemon", "-p", options.port || DEFAULT_DAEMON_PORT_TEXT];
     if (options.server) args.push("--server", options.server);
     if (options.dev) args.push("--dev");
-    const child = spawn6(process.execPath, [process.argv[1], ...args], {
+    const child = spawn7(process.execPath, [process.argv[1], ...args], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -96595,6 +96865,64 @@ function registerCdpCommands(program2) {
   });
 }
 
+// src/cli/mcp-commands.ts
+var import_node_child_process3 = require("child_process");
+var import_node_module3 = require("module");
+init_source();
+function registerMcpCommands(program2) {
+  program2.command("mcp").description("Start an MCP server to expose IDE agents as tools (for Claude Desktop, etc.)").option("--api-key <key>", "ADHDev cloud API key (switches to cloud mode)").option("--port <n>", "Standalone daemon port (default: 3847)", "3847").option("--password <pass>", "Standalone daemon password (if set)").option("--base-url <url>", "Override cloud API base URL").addHelpText("after", `
+Examples:
+  adhdev mcp                          Local mode (requires: adhdev standalone)
+  adhdev mcp --api-key adk_xxx        Cloud mode (no local daemon needed)
+
+Claude Desktop config (~/.claude_desktop_config.json):
+  {
+    "mcpServers": {
+      "adhdev": {
+        "command": "adhdev",
+        "args": ["mcp"]
+      }
+    }
+  }
+
+Tools available (local):  list_sessions, read_chat, send_chat, approve, screenshot, git_status
+Tools available (cloud):  list_sessions, read_chat, send_chat, approve
+        `).action(async (opts) => {
+    const mcpBin = resolveMcpBin();
+    if (!mcpBin) {
+      console.error(source_default.red("\u2717 @adhdev/mcp-server not found. Run: npm install -g @adhdev/mcp-server"));
+      process.exit(1);
+    }
+    const args = [];
+    if (opts.apiKey) args.push("--api-key", opts.apiKey);
+    if (opts.port && opts.port !== "3847") args.push("--port", opts.port);
+    if (opts.password) args.push("--password", opts.password);
+    if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
+    const env3 = { ...process.env };
+    if (opts.apiKey) env3.ADHDEV_API_KEY = opts.apiKey;
+    if (opts.password) env3.ADHDEV_PASSWORD = opts.password;
+    const child = (0, import_node_child_process3.spawn)(process.execPath, [mcpBin, ...args], {
+      stdio: "inherit",
+      env: env3
+    });
+    child.on("error", (err) => {
+      console.error(source_default.red(`\u2717 MCP server error: ${err.message}`));
+      process.exit(1);
+    });
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+}
+function resolveMcpBin() {
+  try {
+    const req = (0, import_node_module3.createRequire)(__filename);
+    return req.resolve("@adhdev/mcp-server");
+  } catch {
+    return null;
+  }
+}
+
 // src/cli/index.ts
 init_version();
 var pkgVersion2 = resolvePackageVersion();
@@ -96614,6 +96942,7 @@ registerDoctorCommands(program, pkgVersion2);
 registerProviderCommands(program);
 registerCdpCommands(program);
 registerServiceCommands(program);
+registerMcpCommands(program);
 void (async () => {
   const helperMode = await maybeRunDaemonUpgradeHelperFromEnv();
   if (helperMode) {
@@ -96640,6 +96969,7 @@ void (async () => {
     console.log(source_default.gray("  Advanced tools:"));
     console.log(source_default.gray("    adhdev trace --category session_host \u2014 Inspect structured daemon trace"));
     console.log(source_default.gray("    adhdev service           \u2014 Manage OS background auto-start service"));
+    console.log(source_default.gray("    adhdev mcp               \u2014 Start MCP server (expose agents to Claude Desktop, etc.)"));
     console.log(source_default.gray("    adhdev provider ...      \u2014 Provider development commands"));
     console.log(source_default.gray("    adhdev cdp ...           \u2014 CDP debugging tools"));
     console.log();