mixdog 0.9.66 → 0.9.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.66",
+  "version": "0.9.67",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -152,6 +152,9 @@ export function _sessionSummary(session) {
         preview: messageProjection.preview,
         generation: typeof session.generation === 'number' ? session.generation : 0,
         implicitBashSessionId: session.implicitBashSessionId || null,
+        // Lifecycle provenance for catalog filters: resume-machinery scratch
+        // forks (detachedReason='cli-resume') must never surface in Recent.
+        detachedReason: session.detachedReason || null,
     };
 }
 
@@ -184,6 +187,7 @@ function _normalizeSummaryRow(row) {
         preview: _cleanPreview(row.preview || ''),
         generation: typeof row.generation === 'number' ? row.generation : 0,
         implicitBashSessionId: row.implicitBashSessionId || null,
+        detachedReason: row.detachedReason || null,
     };
 }
 

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -49,6 +49,11 @@ function cleanText(value, maximum = 240) {
     return String(value || '')
         .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
         .replace(/<mcp-instructions>[\s\S]*?<\/mcp-instructions>/gi, ' ')
+        // Session-context envelope (mirror of session-text.mjs
+        // stripSessionDisplayEnvelope): the "# Session / Cwd / Model /
+        // Workflow" header must never become a Recent title.
+        .replace(/^\s*# Session\r?\n(?:(?:Cwd|Model|Workflow):[^\r\n]*(?:\r?\n|$))+(?:\r?\n)?/i, ' ')
+        .replace(/^\s*#\s*Session\s+Cwd:\s+\S+(?:\s+Model:[^\r\n]*?)?(?:\s+Workflow:\s+\S+)?\s*/i, ' ')
         .replace(/\s+/g, ' ')
         .trim()
         .slice(0, maximum);
@@ -105,6 +110,7 @@ function normalizedRow(row, heartbeatAt = 0) {
         preview: cleanText(row.preview),
         generation: typeof row.generation === 'number' ? row.generation : 0,
         implicitBashSessionId: row.implicitBashSessionId || null,
+        detachedReason: row.detachedReason || null,
     };
 }
 
@@ -112,6 +118,10 @@ function rowFromSession(session, heartbeatAt = 0) {
     const messages = Array.isArray(session?.messages) ? session.messages : [];
     const preview = messages
         .filter((message) => message?.role === 'user')
+        // Cold-path mirror of isSessionPreviewNoise's synthetic skips: compact
+        // handoffs and runtime notices must not become session titles.
+        .filter((message) => !/^\s*(?:a previous model worked on this task|re-attached after compaction\b|reference files:\s|\[mixdog-runtime\]|the async (?:agent|shell) task\b)/i
+            .test(messageText(message.content)))
         .map((message) => cleanText(messageText(message.content)))
         .find(Boolean) || '';
     return normalizedRow({

package/src/runtime/channels/lib/config.mjs

@@ -156,6 +156,13 @@ const HEADLESS_BACKEND = {
   }
 };
 function createBackend(config) {
+  // Channels-module toggle is MESSAGING-ONLY: automation (scheduler/webhooks)
+  // keeps the worker alive, so a disabled module runs the headless backend
+  // instead of blocking the whole runtime.
+  if (config.enabled === false) {
+    process.stderr.write("mixdog: channels messaging disabled; channel runtime running in headless mode\n");
+    return HEADLESS_BACKEND;
+  }
   // Single-backend select: exactly one backend is constructed based on
   // config.backend (discord|telegram). The two are mutually exclusive.
   if (config.backend === "telegram") {

package/src/runtime/channels/lib/status-snapshot.mjs

@@ -3,7 +3,7 @@
  *
  * Writes <DATA_DIR>/channels/status-snapshot.json every 10 seconds so that
  * setup-server can read cross-process state (cron next-fire, deferred count,
- * Discord unread, ngrok tunnel URL) without IPC.
+ * Discord unread, relay hook URL) without IPC.
  *
  * Atomic write: tmp → rename so readers never see a partial file.
  *
@@ -13,10 +13,10 @@
  */
 
 import * as fs from 'fs';
-import * as http from 'http';
 import * as path from 'path';
 import { DATA_DIR } from './config.mjs';
 import { writeJsonAtomicSync } from '../../shared/atomic-file.mjs';
+import { readHookPublicBase } from './webhook/relay-tunnel.mjs';
 
 const SNAPSHOT_DIR  = path.join(DATA_DIR, 'channels');
 const SNAPSHOT_PATH = path.join(SNAPSHOT_DIR, 'status-snapshot.json');
@@ -79,30 +79,6 @@ export function recordFetchedMessages(channelId, channelLabel, messages, options
   });
 }
 
-// ── Ngrok tunnel URL probe ───────────────────────────────────────────────────
-async function probeNgrokUrl() {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => { try { req && req.destroy(); } catch {} resolve(null); }, 400);
-    let req;
-    try {
-      req = http.get('http://127.0.0.1:4040/api/tunnels', (res) => {
-        clearTimeout(timer);
-        let body = '';
-        res.on('data', d => { body += d; });
-        res.on('end', () => {
-          try {
-            const parsed = JSON.parse(body);
-            const tunnel = (parsed.tunnels || []).find(t => t.public_url);
-            resolve(tunnel ? tunnel.public_url : null);
-          } catch { resolve(null); }
-        });
-      });
-      req.on('error', () => { clearTimeout(timer); resolve(null); });
-      req.setTimeout(400, () => { clearTimeout(timer); try { req.destroy(); } catch {} resolve(null); });
-    } catch { clearTimeout(timer); resolve(null); }
-  });
-}
-
 // ── Snapshot computation ─────────────────────────────────────────────────────
 // The legacy HH:MM / everyNm / hourly next-fire fallback was removed: the
 // scheduler accepts cron expressions exclusively (scheduler.mjs:68), so the
@@ -172,8 +148,8 @@ async function computeSnapshot(scheduler) {
     totalUnread += entry.unseenCount;
   }
 
-  // ── Ngrok tunnel URL ───────────────────────────────────────────────────────
-  const tunnelUrl = await probeNgrokUrl();
+  // ── Relay hook URL (identity file read; assigned on first tunnel start) ────
+  const hookPublicUrl = readHookPublicBase();
 
   return {
     writtenAt: now,
@@ -188,8 +164,8 @@ async function computeSnapshot(scheduler) {
       unread: unreadList,
       totalUnread,
     },
-    ngrok: {
-      tunnelUrl,
+    hook: {
+      publicUrl: hookPublicUrl,
     },
   };
 }

package/src/runtime/channels/lib/webhook/relay-tunnel.mjs

@@ -0,0 +1,203 @@
+// Relay-backed public webhook tunnel — the ngrok child process replacement.
+//
+// The channel worker keeps ONE outbound WebSocket to the Mixdog relay
+// (apps/relay/server.mjs `/hookleg`). Inbound requests on
+//   https://<relay>/hook/<deviceId>/webhook/<name>
+// arrive over that leg as JSON frames and are replayed against the LOCAL
+// webhook HTTP server; the response returns verbatim. Endpoint HMAC
+// verification stays local — the relay never inspects payloads. Works out
+// of the box: no binary, no authtoken, no reserved domain.
+import * as http from "http";
+import { randomBytes, randomUUID } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import WebSocket from "ws";
+import { DATA_DIR } from "../config.mjs";
+import { logWebhook } from "./log.mjs";
+
+/** Packaged default mirrors the desktop pairing relay. */
+const DEFAULT_RELAY_URL = "wss://192-255-139-161.sslip.io";
+const MAX_TUNNEL_BODY_BYTES = 1024 * 1024;
+const HEARTBEAT_MS = 25_000;
+const LOCAL_TIMEOUT_MS = 25_000;
+
+export function resolveHookRelayUrl(env = process.env) {
+  const raw = String(env.MIXDOG_RELAY_URL || "").trim();
+  const flag = raw.toLowerCase();
+  if (flag === "0" || flag === "false" || flag === "off") return null;
+  return raw || DEFAULT_RELAY_URL;
+}
+
+export function hookIdentityPath() {
+  return join(DATA_DIR, "relay-hook-device.json");
+}
+
+// Stable per-install identity (trust-on-first-use at the relay, mirroring
+// the desktop leg). The secret never leaves this machine except toward the
+// relay; the deviceId doubles as the public URL path segment.
+export function loadOrCreateHookIdentity() {
+  const path = hookIdentityPath();
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.deviceId === "string" && /^[0-9a-f-]{8,64}$/.test(parsed.deviceId)
+      && typeof parsed.deviceSecret === "string" && parsed.deviceSecret.length >= 16) {
+      return { deviceId: parsed.deviceId, deviceSecret: parsed.deviceSecret };
+    }
+  } catch { /* first run */ }
+  const identity = { deviceId: randomUUID(), deviceSecret: randomBytes(24).toString("hex") };
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(path, JSON.stringify(identity, null, 2), "utf8");
+  } catch (err) {
+    logWebhook(`hook tunnel: identity persist failed — ${err?.message || err}`);
+  }
+  return identity;
+}
+
+export function hookPublicBase(relayUrl, deviceId) {
+  const url = new URL(relayUrl);
+  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  url.pathname = `/hook/${deviceId}`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+/** Public base URL for status surfaces; null until the first tunnel start
+ *  persisted an identity (no identity is ever created here). */
+export function readHookPublicBase(env = process.env) {
+  const relayUrl = resolveHookRelayUrl(env);
+  if (!relayUrl) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(hookIdentityPath(), "utf8"));
+    if (typeof parsed.deviceId === "string" && parsed.deviceId) {
+      return hookPublicBase(relayUrl, parsed.deviceId);
+    }
+  } catch { /* tunnel has not started yet */ }
+  return null;
+}
+
+export function startHookTunnel({ relayUrl, getLocalPort }) {
+  const { deviceId, deviceSecret } = loadOrCreateHookIdentity();
+  let socket = null;
+  let closed = false;
+  let retryMs = 1_000;
+  let reconnectTimer = null;
+  let announced = false;
+
+  const scheduleReconnect = () => {
+    if (closed) return;
+    reconnectTimer = setTimeout(connect, retryMs);
+    reconnectTimer.unref?.();
+    retryMs = Math.min(30_000, retryMs * 2);
+  };
+
+  const respond = (ws, id, status, headers, bodyBuffer) => {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    try {
+      ws.send(JSON.stringify({
+        type: "http-response",
+        id,
+        status,
+        headers: headers || {},
+        body: bodyBuffer && bodyBuffer.length ? bodyBuffer.toString("base64") : "",
+      }));
+    } catch { /* relay vanished; it times the request out */ }
+  };
+
+  const forwardToLocal = (frame, ws) => {
+    const port = getLocalPort();
+    if (!port) {
+      respond(ws, frame.id, 503, { "content-type": "application/json" },
+        Buffer.from('{"error":"webhook server not listening"}'));
+      return;
+    }
+    const body = frame.body ? Buffer.from(String(frame.body), "base64") : null;
+    const request = http.request({
+      host: "127.0.0.1",
+      port,
+      method: typeof frame.method === "string" ? frame.method : "GET",
+      path: typeof frame.path === "string" && frame.path.startsWith("/") ? frame.path : "/",
+      headers: frame.headers && typeof frame.headers === "object" ? frame.headers : {},
+      timeout: LOCAL_TIMEOUT_MS,
+    }, (response) => {
+      const chunks = [];
+      let total = 0;
+      response.on("data", (chunk) => {
+        total += chunk.length;
+        if (total <= MAX_TUNNEL_BODY_BYTES) chunks.push(chunk);
+      });
+      response.on("end", () => respond(ws, frame.id, response.statusCode || 502,
+        { "content-type": response.headers["content-type"] || "application/json" },
+        Buffer.concat(chunks)));
+      response.on("error", () => respond(ws, frame.id, 502, {}, null));
+    });
+    request.on("timeout", () => request.destroy(new Error("local webhook timeout")));
+    request.on("error", (err) => respond(ws, frame.id, 502, { "content-type": "application/json" },
+      Buffer.from(JSON.stringify({ error: String(err?.message || err) }))));
+    if (body && body.length) request.write(body);
+    request.end();
+  };
+
+  const connect = () => {
+    if (closed) return;
+    const target = new URL(relayUrl);
+    target.pathname = "/hookleg";
+    target.search = `device=${encodeURIComponent(deviceId)}&secret=${encodeURIComponent(deviceSecret)}`;
+    let ws;
+    try {
+      ws = new WebSocket(target.toString(), { maxPayload: 8 * 1024 * 1024 });
+    } catch (err) {
+      logWebhook(`hook tunnel: dial failed — ${err?.message || err}`);
+      scheduleReconnect();
+      return;
+    }
+    socket = ws;
+    // NAT paths silently drop idle sockets; protocol pings keep the leg warm
+    // and detect a half-dead link so the reconnect loop restores it.
+    let alive = true;
+    ws.on("pong", () => { alive = true; });
+    const heartbeat = setInterval(() => {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      if (!alive) { try { ws.terminate(); } catch { /* close reconnects */ } return; }
+      alive = false;
+      try { ws.ping(); } catch { /* close reconnects */ }
+    }, HEARTBEAT_MS);
+    heartbeat.unref?.();
+    ws.on("open", () => {
+      retryMs = 1_000;
+      if (!announced) {
+        announced = true;
+        logWebhook(`hook tunnel up: ${hookPublicBase(relayUrl, deviceId)}`);
+      }
+    });
+    ws.on("message", (raw) => {
+      alive = true;
+      let frame;
+      try { frame = JSON.parse(String(raw)); } catch { return; }
+      if (frame?.type !== "http" || typeof frame.id !== "string") return;
+      forwardToLocal(frame, ws);
+    });
+    ws.on("error", () => { /* surfaced as close */ });
+    ws.on("close", () => {
+      clearInterval(heartbeat);
+      if (socket === ws) socket = null;
+      scheduleReconnect();
+    });
+  };
+
+  connect();
+  return {
+    deviceId,
+    publicBase: hookPublicBase(relayUrl, deviceId),
+    close() {
+      if (closed) return;
+      closed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (socket) {
+        try { socket.terminate(); } catch { /* already gone */ }
+        socket = null;
+      }
+    },
+  };
+}

package/src/runtime/channels/lib/webhook.mjs

@@ -1,10 +1,7 @@
 import * as http from "http";
-import { spawn, spawnSync } from "child_process";
 import { randomUUID } from "crypto";
-import { getWebhookAuthtoken } from "../../shared/config.mjs";
 import { logWebhook } from "./webhook/log.mjs";
 import { SIGNATURE_HEADERS, extractSignature, STRIPE_TOLERANCE_MS, verifySignature } from "./webhook/signature.mjs";
-import { detachedSpawnOpts } from "../../shared/spawn-flags.mjs";
 import {
   loadEndpointConfig,
   readEndpointSecret,
@@ -15,20 +12,7 @@ import {
   extractDeliveryId,
   buildHeadersSummary,
 } from "./webhook/deliveries.mjs";
-import {
-  NGROK_MAX_AGE_MS,
-  resolveNgrokBin,
-  normalizeDomain,
-  readNgrokMeta,
-  writeNgrokMeta,
-  clearNgrokMeta,
-  isLikelyNgrok,
-  isProcessAlive,
-  parseStrictPidLine,
-  resolvePortOwnerPid,
-  handleWebhookPortInUse,
-  checkNgrokHealth,
-} from "./webhook/ngrok.mjs";
+import { resolveHookRelayUrl, startHookTunnel } from "./webhook/relay-tunnel.mjs";
 
 class WebhookServer {
   config;
@@ -38,7 +22,7 @@ class WebhookServer {
   boundPort = 0;
   listenInFlight = false;
   noSecretWarned = false;
-  ngrokProcess = null;
+  hookTunnel = null;
   constructor(config) {
     this.config = config;
   }
@@ -311,42 +295,19 @@ class WebhookServer {
     const basePort = this.config.port || 3333;
     const maxPort = basePort + 7;
     let currentPort = basePort;
-    let baseReclaimAttempted = false;
     const tryListen = () => {
       this.server.listen(currentPort, () => {
         this.listenInFlight = false;
         this.boundPort = currentPort;
         logWebhook(`listening on port ${currentPort}`);
-        this.startNgrok();
+        this._startHookTunnel();
       });
     };
     this.server.on("error", (err) => {
-      if (err.code === "EADDRINUSE" && currentPort === basePort && !baseReclaimAttempted) {
-        baseReclaimAttempted = true;
-        void handleWebhookPortInUse(basePort, this.config.ngrokDomain || this.config.domain).then((result) => {
-          if (result.ok) {
-            currentPort = basePort;
-            logWebhook(`reclaimed base port ${basePort}, retrying bind`);
-            tryListen();
-            return;
-          }
-          if (result.bump && currentPort < maxPort) {
-            logWebhook(
-              `port ${basePort} not reclaimable (live non-ngrok PID ${result.ownerPid ?? "unknown"}), trying ${currentPort + 1}`,
-            );
-            currentPort++;
-            tryListen();
-            return;
-          }
-          if (err.code === "EADDRINUSE") {
-            logWebhook(`all ports ${basePort}-${maxPort} in use \u2014 webhook server disabled`);
-            this.listenInFlight = false;
-            this.server = null;
-          }
-        });
-        return;
-      }
       if (err.code === "EADDRINUSE" && currentPort < maxPort) {
+        // The relay tunnel forwards to whatever port this process binds, so
+        // port identity no longer matters (the ngrok-era domain↔port coupling
+        // is gone) — walk up the range.
         logWebhook(`port ${currentPort} already in use, trying ${currentPort + 1}`);
         currentPort++;
         tryListen();
@@ -364,166 +325,27 @@ class WebhookServer {
     });
     tryListen();
   }
-  /**
-   * Check if a previous ngrok process can be reused.
-   * Returns true if the existing ngrok is alive, healthy, and serving the right domain.
-   * Returns false otherwise. External processes are never killed; stale or
-   * incompatible metadata is ignored so another terminal's tunnel stays alive.
-   */
-  async reuseNgrokIfHealthy(domain, expectedPort = null) {
-    const meta = readNgrokMeta();
-    if (!meta || !(meta.pid > 0)) {
-      clearNgrokMeta();
-      return false;
-    }
-
-    const { pid } = meta;
-
-    // Metadata domain mismatch — different config. Do not kill another terminal's tunnel.
-    if (meta.domain && normalizeDomain(meta.domain) !== normalizeDomain(domain)) {
-      logWebhook(`ngrok meta domain mismatch (${meta.domain} vs ${domain}), ignoring PID ${pid}`);
-      clearNgrokMeta();
-      return false;
-    }
-    if (expectedPort && meta.port && Number(meta.port) !== Number(expectedPort)) {
-      // A tunnel forwarding to the OLD local port cannot serve this server.
-      // Ignore the metadata and let this process try its own tunnel without
-      // touching the existing process.
-      logWebhook(`ngrok meta port mismatch (${meta.port} vs ${expectedPort}) — ignoring PID ${pid}`);
-      clearNgrokMeta();
-      return false;
-    }
-
-    // Stale check — older than 24 hours (ngrok session realistic lifetime;
-    // ngrok free-tier tunnels expire after ~2h but paid/reserved-domain
-    // tunnels survive much longer; 24h is a safe conservative ceiling).
-    if (meta.startedAt && (Date.now() - new Date(meta.startedAt).getTime()) > NGROK_MAX_AGE_MS) {
-      logWebhook(`ngrok meta stale (started ${meta.startedAt}), ignoring PID ${pid}`);
-      clearNgrokMeta();
-      return false;
-    }
-
-    // Check if process is alive
-    let alive = false;
-    try { process.kill(pid, 0); alive = true } catch {}
-
-    if (!alive) {
-      logWebhook(`ngrok PID ${pid} is dead, cleaning up`);
-      clearNgrokMeta();
-      return false;
-    }
-
-    // Process alive + domain matches — verify tunnel via 4040 API
-    const healthy = await checkNgrokHealth(domain, expectedPort);
-    if (healthy) {
-      logWebhook(`reusing ngrok (PID ${pid}, domain ${domain}, port ${meta.port})`);
-      return true;
-    }
-
-    // Alive but tunnel unhealthy. Leave it alone; it may belong to another terminal.
-    logWebhook(`ngrok PID ${pid} alive but tunnel unhealthy, ignoring`);
-    clearNgrokMeta();
-    return false;
-  }
-  async startNgrok() {
-    // Mutex: skip only when THIS process still owns a live ngrok child. Fresh
-    // daemon restarts always have ngrokProcess=null and must proceed; stale
-    // in-memory refs after exit must not block respawn.
-    if (this.ngrokProcess && this.ngrokProcess.exitCode == null && !this.ngrokProcess.killed) return;
-    if (this._ngrokStartPromise) return this._ngrokStartPromise;
-    this._ngrokStartPromise = this._doStartNgrok();
-    try { await this._ngrokStartPromise; } finally { this._ngrokStartPromise = null; }
-  }
-  async _doStartNgrok() {
-    const authtoken = getWebhookAuthtoken();
-    const domain = this.config.ngrokDomain || this.config.domain;
-    if (!authtoken || !domain) return;
-    let attempts = 0;
-    while (!this.boundPort) {
-      if (++attempts > 30) {
-        logWebhook("ngrok: gave up waiting for port");
-        return;
-      }
-      await new Promise((r) => setTimeout(r, 500));
-    }
-
-    // Try to reuse an existing ngrok process
-    const reused = await this.reuseNgrokIfHealthy(domain, this.boundPort);
-    if (reused) {
+  // Relay-backed public tunnel (replaces the ngrok child): one outbound
+  // WebSocket to the Mixdog relay serves every inbound webhook — no binary,
+  // no authtoken, no reserved domain.
+  _startHookTunnel() {
+    if (this.hookTunnel) return;
+    const relayUrl = resolveHookRelayUrl();
+    if (!relayUrl) {
+      logWebhook("hook tunnel disabled (MIXDOG_RELAY_URL=off)");
       return;
     }
-
-    let ngrokBin;
     try {
-      ngrokBin = resolveNgrokBin();
+      this.hookTunnel = startHookTunnel({ relayUrl, getLocalPort: () => this.boundPort });
+      logWebhook(`public hook base: ${this.hookTunnel.publicBase}`);
     } catch (err) {
-      if (!this._ngrokDisabledLogged) {
-        logWebhook(`ngrok disabled — ${err.message}`);
-        this._ngrokDisabledLogged = true;
-      }
-      return;
-    }
-    spawnSync(ngrokBin, ["config", "add-authtoken", authtoken], { stdio: "ignore", timeout: 1e4, windowsHide: true });
-    attempts = 0;
-    const waitAndStart = () => {
-      if (!this.boundPort) {
-        if (++attempts > 30) {
-          logWebhook("ngrok: gave up waiting for port");
-          return;
-        }
-        setTimeout(waitAndStart, 500);
-        return;
-      }
-      try {
-        // stdio fully ignored so Node does not pass inheritable stdio handles
-        // (bInheritHandles stays false on Windows). There is no portable Node API
-        // to mark the http.Server listen socket non-inheritable; detached ngrok
-        // can still inherit stale handles in edge cases — layer-1 port reclaim
-        // on EADDRINUSE is the guaranteed safety net.
-        this.ngrokProcess = spawn(ngrokBin, ["http", String(this.boundPort), "--url=" + domain], {
-          stdio: ["ignore", "ignore", "ignore"],
-          ...detachedSpawnOpts,
-        });
-        this.ngrokProcess.unref();
-        if (this.ngrokProcess.pid) {
-          writeNgrokMeta({
-            pid: this.ngrokProcess.pid,
-            domain,
-            port: this.boundPort,
-            startedAt: new Date().toISOString(),
-            binaryPath: ngrokBin,
-          });
-        }
-        this.ngrokProcess.on("exit", () => {
-          this.ngrokProcess = null;
-          clearNgrokMeta();
-        });
-        this.ngrokProcess.on("error", () => {
-          this.ngrokProcess = null;
-          clearNgrokMeta();
-        });
-        logWebhook(`ngrok tunnel started: ${domain} \u2192 localhost:${this.boundPort} (PID ${this.ngrokProcess.pid})`);
-      } catch (e) {
-        logWebhook(`ngrok start failed: ${e}`);
-      }
-    };
-    setTimeout(waitAndStart, 1e3);
-    // Hold the outer startNgrok() mutex (`_ngrokStartPromise`) until
-    // waitAndStart actually spawns ngrok OR exhausts its 30-attempt
-    // budget. Pre-fix the mutex released as soon as the setTimeout was
-    // scheduled, letting a duplicate startNgrok() call within the wait
-    // window arm a second timer and spawn a second ngrok process.
-    // Deadline: 1s initial + 30 × 500ms attempts = 16s, +1.5s slack.
-    const _deadline = Date.now() + 17500;
-    while (!this.ngrokProcess && Date.now() < _deadline) {
-      await new Promise((r) => setTimeout(r, 100));
+      logWebhook(`hook tunnel start failed: ${err?.message || err}`);
     }
   }
   stop() {
-    // Intentionally do NOT kill ngrok — let it survive across MCP restarts.
-    // The next start() can reuse it if reuseNgrokIfHealthy() validates it.
-    if (this.ngrokProcess) {
-      this.ngrokProcess = null;
+    if (this.hookTunnel) {
+      try { this.hookTunnel.close(); } catch { /* already closed */ }
+      this.hookTunnel = null;
     }
     let closed = Promise.resolve();
     if (this.server) {
@@ -538,7 +360,7 @@ class WebhookServer {
         }
       });
     }
-    logWebhook("stopped (ngrok left running for reuse)");
+    logWebhook("stopped");
     return closed;
   }
   // reloadConfig(webhookCfg, options?)
@@ -673,8 +495,8 @@ ${payload}
   }
   /** Get the webhook URL for an endpoint name */
   getUrl(name) {
-    if (this.config.ngrokDomain) {
-      return `https://${this.config.ngrokDomain}/webhook/${name}`;
+    if (this.hookTunnel) {
+      return `${this.hookTunnel.publicBase}/webhook/${name}`;
     }
     return `http://localhost:${this.boundPort || this.config.port}/webhook/${name}`;
   }

package/src/runtime/shared/config.mjs

@@ -437,7 +437,6 @@ function getCapabilities() {
 export const SECRET_ACCOUNTS = Object.freeze({
   discordToken: 'discord.token',
   telegramToken: 'telegram.token',
-  webhookAuth:  'webhook.authtoken',
   agentApiKey:  (provider) => `agent.${provider}.apiKey`,
   openaiUsageSessionKey: 'agent.openai.usageSessionKey',
   opencodeGoAuthCookie: 'agent.opencode-go.authCookie',
@@ -497,14 +496,6 @@ export function getTelegramToken() {
   return _readSecret(SECRET_ACCOUNTS.telegramToken)
 }
 
-/**
- * Returns the ngrok/webhook authtoken.
- * Priority: MIXDOG_WEBHOOK_AUTHTOKEN → keychain('webhook.authtoken') → null
- */
-export function getWebhookAuthtoken() {
-  return _readSecret(SECRET_ACCOUNTS.webhookAuth)
-}
-
 export function getOpenAIUsageSessionKey() {
   return process.env.OPENAI_USAGE_SESSION_KEY
     || process.env.OPENAI_DASHBOARD_SESSION_KEY