ofw-mcp 2.1.0 → 2.3.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "OurFamilyWizard tools for Claude Code",
-    "version": "2.1.0"
+    "version": "2.3.0"
   },
   "plugins": [
     {
@@ -14,7 +14,7 @@
       "displayName": "OurFamilyWizard",
       "source": "./",
       "description": "OurFamilyWizard co-parenting tools for Claude — messages, calendar, expenses, and journal via MCP",
-      "version": "2.1.0",
+      "version": "2.3.0",
       "author": {
         "name": "Chris Chall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ofw",
   "displayName": "OurFamilyWizard",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "OurFamilyWizard co-parenting tools for Claude — messages, calendar, expenses, and journal via MCP",
   "author": {
     "name": "Chris Chall"

package/dist/bundle.js

@@ -3112,6 +3112,9 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3304,27 +3307,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3339,7 +3392,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3353,7 +3406,10 @@ var require_utils = __commonJS({
     module.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3577,12 +3633,12 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -3649,19 +3705,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3686,12 +3732,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3726,7 +3772,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3737,6 +3792,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3757,6 +3813,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3795,14 +3856,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3811,7 +3876,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -7308,14 +7395,14 @@ var require_permessage_deflate = __commonJS({
       }
     };
     module.exports = PerMessageDeflate2;
-    function deflateOnData(chunk) {
-      this[kBuffers].push(chunk);
-      this[kTotalLength] += chunk.length;
+    function deflateOnData(chunk2) {
+      this[kBuffers].push(chunk2);
+      this[kTotalLength] += chunk2.length;
     }
-    function inflateOnData(chunk) {
-      this[kTotalLength] += chunk.length;
+    function inflateOnData(chunk2) {
+      this[kTotalLength] += chunk2.length;
       if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
-        this[kBuffers].push(chunk);
+        this[kBuffers].push(chunk2);
         return;
       }
       this[kError] = new RangeError("Max payload size exceeded");
@@ -7615,7 +7702,7 @@ var require_receiver = __commonJS({
        * @param {Function} cb Callback
        * @private
        */
-      _write(chunk, encoding, cb) {
+      _write(chunk2, encoding, cb) {
         if (this._opcode === 8 && this._state == GET_INFO) return cb();
         if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
           cb(
@@ -7629,8 +7716,8 @@ var require_receiver = __commonJS({
           );
           return;
         }
-        this._bufferedBytes += chunk.length;
-        this._buffers.push(chunk);
+        this._bufferedBytes += chunk2.length;
+        this._buffers.push(chunk2);
         this.startLoop(cb);
       }
       /**
@@ -9904,8 +9991,8 @@ var require_websocket = __commonJS({
       this.removeListener("end", socketOnEnd);
       websocket._readyState = WebSocket2.CLOSING;
       if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
-        const chunk = this.read(this._readableState.length);
-        websocket._receiver.write(chunk);
+        const chunk2 = this.read(this._readableState.length);
+        websocket._receiver.write(chunk2);
       }
       websocket._receiver.end();
       this[kWebSocket] = void 0;
@@ -9917,8 +10004,8 @@ var require_websocket = __commonJS({
         websocket._receiver.on("finish", receiverOnFinish);
       }
     }
-    function socketOnData(chunk) {
-      if (!this[kWebSocket]._receiver.write(chunk)) {
+    function socketOnData(chunk2) {
+      if (!this[kWebSocket]._receiver.write(chunk2)) {
         this.pause();
       }
     }
@@ -10021,14 +10108,14 @@ var require_stream = __commonJS({
       duplex._read = function() {
         if (ws.isPaused) ws.resume();
       };
-      duplex._write = function(chunk, encoding, callback) {
+      duplex._write = function(chunk2, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
           ws.once("open", function open() {
-            duplex._write(chunk, encoding, callback);
+            duplex._write(chunk2, encoding, callback);
           });
           return;
         }
-        ws.send(chunk, callback);
+        ws.send(chunk2, callback);
       };
       duplex.on("end", duplexOnEnd);
       duplex.on("error", duplexOnError);
@@ -34460,8 +34547,8 @@ import process3 from "node:process";
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 var ReadBuffer = class {
-  append(chunk) {
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  append(chunk2) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk2]) : chunk2;
   }
   readMessage() {
     if (!this._buffer) {
@@ -34493,8 +34580,8 @@ var StdioServerTransport = class {
     this._stdout = _stdout;
     this._readBuffer = new ReadBuffer();
     this._started = false;
-    this._ondata = (chunk) => {
-      this._readBuffer.append(chunk);
+    this._ondata = (chunk2) => {
+      this._readBuffer.append(chunk2);
       this.processReadBuffer();
     };
     this._onerror = (error51) => {
@@ -35912,6 +35999,19 @@ function classifyFetchError(error51) {
   return "other";
 }
 
+// node_modules/@fetchproxy/server/dist/classify-bridge-error.js
+function classifyBridgeError(err) {
+  if (err instanceof FetchproxyTimeoutError)
+    return "timeout";
+  if (err instanceof FetchproxyBridgeDownError)
+    return "bridge_down";
+  if (err instanceof FetchproxyHttpError)
+    return "http";
+  if (err instanceof FetchproxyProtocolError)
+    return "protocol";
+  return "other";
+}
+
 // node_modules/@fetchproxy/server/dist/ws-server.js
 var FetchproxyProtocolError = class extends Error {
   constructor(message) {
@@ -35941,7 +36041,7 @@ var FetchproxyBridgeDownError = class extends FetchproxyProtocolError {
     const retryAttempted = args.retryAttempted ?? false;
     const op = args.op ?? "fetch";
     const retryClause = retryAttempted ? `Server already burned a one-shot lazy-revive retry; SW is still down. ` : `Server lazy-revive retry was disabled (bridgeReviveDelayMs unset/0). `;
-    const hint = `the fetchproxy extension's service worker is not responding ("${args.originalError}"). Chrome evicts extension service workers after ~30s idle by default. ${retryClause}Wake it by clicking the fetchproxy extension toolbar icon, then retry. If it keeps happening, reload the extension from chrome://extensions.`;
+    const hint = `the fetchproxy extension's service worker is not responding ("${args.originalError}"). Chrome evicts extension service workers after ~30s idle by default. ${retryClause}Make sure a tab for this domain is open, fully loaded, and signed in (the bridge fetches through that tab) \u2014 then retry. If it keeps happening, reload the extension from chrome://extensions and reload the tab.`;
     super(`fetchproxy bridge down during ${op}${args.url ? ` (${args.url})` : ""}. ${hint}`);
     this.name = "FetchproxyBridgeDownError";
     this.originalError = args.originalError;
@@ -35963,6 +36063,14 @@ var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
   port;
   /** 0.8.0+: actual elapsed milliseconds when the timer won the race. */
   elapsedMs;
+  /**
+   * 0.11.0+ (#90/#91): true when the server's lazy-revive retry path
+   * fired for this timeout (a cold-start `timeout` symptom followed by
+   * a warm-and-retry that also timed out). False when the retry was
+   * disabled (`bridgeReviveDelayMs` unset/0) so the timeout surfaced on
+   * the first attempt.
+   */
+  retryAttempted;
   constructor(args) {
     super(`fetchproxy: ${args.url} did not respond within ${args.timeoutMs}ms`);
     this.name = "FetchproxyTimeoutError";
@@ -35971,6 +36079,7 @@ var FetchproxyTimeoutError = class extends FetchproxyProtocolError {
     this.role = args.role ?? null;
     this.port = args.port ?? 0;
     this.elapsedMs = args.elapsedMs ?? args.timeoutMs;
+    this.retryAttempted = args.retryAttempted ?? false;
   }
 };
 var SUBDOMAIN_LABEL_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
@@ -36044,6 +36153,25 @@ var FetchproxyServer = class {
   // for "we're connecting right now" so two parallel first-calls don't
   // race the port bind.
   connectingPromise = null;
+  // 0.8.1+ (#67): server-initiated keep-alive ping. Active when
+  // `keepAliveIntervalMs` is set AND we've seen recent activity
+  // (fetch/capture success or failure, or markActive()) within
+  // `keepAliveMaxIdleMs`. The interval handle is created lazily on
+  // first activity and torn down on close() / extension disconnect.
+  keepAliveTimer = null;
+  lastActiveAt = null;
+  // 0.10.0+ (#73): observability counters surfaced via
+  // bridgeHealth().keepAlive / .swEviction. Monotonic across the process
+  // lifetime so a downstream healthcheck tool can verify the keep-alive
+  // is actually preventing SW eviction. `lastPingAt` and `totalPings`
+  // are stamped from `startKeepaliveIfIdle`'s tick. `lazyRevive*` and
+  // `lastEvictionDetectedAt` are stamped from the lazy-revive code path
+  // in fetch() / captureRequestHeader().
+  lastPingAt = null;
+  totalPings = 0;
+  lazyReviveAttempts = 0;
+  lazyReviveSuccesses = 0;
+  lastEvictionDetectedAt = null;
   constructor(opts) {
     if (!Array.isArray(opts.domains) || opts.domains.length === 0) {
       throw new Error("FetchproxyServer: opts.domains must be a non-empty array of hostnames");
@@ -36096,6 +36224,22 @@ var FetchproxyServer = class {
       // the legacy hang-forever / fail-once-on-SW-eviction behavior.
       fetchTimeoutMs: opts.fetchTimeoutMs ?? 3e4,
       bridgeReviveDelayMs: opts.bridgeReviveDelayMs ?? 2e3,
+      // 0.10.0+ (#72): keep-alive defaults to 25s — round-3 #71 cohort
+      // wave showed every Pattern A consumer was opting into this same
+      // value. Pass `0` to disable; the existing `<= 0` guards in
+      // `startKeepaliveIfIdle` / `noteActivityForKeepalive` honour that.
+      //
+      // #90 (P1-1): tightened to 20s. 25s left only ~5s of slack under
+      // Chrome's ~30s SW-eviction window — slack that timer drift, a
+      // busy host event loop (CPU-bound response parsing between calls),
+      // and the ping's own round-trip latency routinely ate, so the SW
+      // evicted before the next ping landed and the next call cold-
+      // started. 20s restores real margin. (The extension
+      // `chrome.alarms` backstop is clamped by Chrome to a 30s minimum
+      // period, firing *at* the edge — it can't rescue a sub-30s race;
+      // the server ping is the real defense.)
+      keepAliveIntervalMs: opts.keepAliveIntervalMs ?? 2e4,
+      keepAliveMaxIdleMs: opts.keepAliveMaxIdleMs ?? 5 * 60 * 1e3,
       identityDir: opts.identityDir,
       onPairCode: opts.onPairCode
     };
@@ -36196,7 +36340,10 @@ var FetchproxyServer = class {
         onPairCode: this.opts.onPairCode
       });
       this.hostHandle.onOwnInner((inner) => this.onInner(inner));
-      this.hostHandle.onExtensionDisconnect(() => this.rejectAllPending());
+      this.hostHandle.onExtensionDisconnect(() => {
+        this.stopKeepalive();
+        this.rejectAllPending();
+      });
       this.hostHandle.onPendingPair((code) => {
         this.rejectAllPending(this.pairingErrorMessage(code));
       });
@@ -36220,7 +36367,10 @@ var FetchproxyServer = class {
         sessionStoragePointers: this.opts.sessionStoragePointers
       });
       this.peerHandle.onInner((inner) => this.onInner(inner));
-      this.peerHandle.onRenegotiate(() => this.rejectAllPending());
+      this.peerHandle.onRenegotiate(() => {
+        this.stopKeepalive();
+        this.rejectAllPending();
+      });
       this.peerHandle.onPendingPair((code) => {
         this.rejectAllPending(this.pairingErrorMessage(code));
       });
@@ -36261,13 +36411,18 @@ var FetchproxyServer = class {
     }
     const first = await this._fetchOnceWithTimeout(init);
     const reviveMs = this.opts.bridgeReviveDelayMs;
-    let final = first;
-    if (!first.ok && first.kind === "content_script_unreachable" && reviveMs !== void 0 && reviveMs > 0) {
+    const isColdStartSymptom = !first.ok && (first.kind === "content_script_unreachable" || first.kind === "timeout");
+    if (isColdStartSymptom) {
+      this.lastEvictionDetectedAt = Date.now();
+    }
+    if (isColdStartSymptom && reviveMs !== void 0 && reviveMs > 0) {
+      this.lazyReviveAttempts += 1;
       await new Promise((r) => setTimeout(r, reviveMs));
       const second = await this._fetchOnceWithTimeout(init);
-      if (second.ok)
+      if (second.ok) {
+        this.lazyReviveSuccesses += 1;
         this.recordSuccess();
-      else
+      } else
         this.recordFailure(`${second.kind ?? "other"}: ${second.error}`);
       return { ...second, retryAttempted: true };
     }
@@ -36289,6 +36444,9 @@ var FetchproxyServer = class {
    * call (addresses #23 ask 4).
    */
   bridgeHealth() {
+    const intervalMs = this.opts.keepAliveIntervalMs;
+    const maxIdleMs = this.opts.keepAliveMaxIdleMs;
+    const idleSinceMs = this.lastActiveAt === null ? null : Date.now() - this.lastActiveAt;
     return {
       role: this.role,
       port: this.opts.port,
@@ -36299,17 +36457,85 @@ var FetchproxyServer = class {
       lastFailureAt: this.lastFailureAt,
       lastFailureReason: this.lastFailureReason,
       consecutiveFailures: this.consecutiveFailures,
-      lastExtensionMessageAt: this.lastExtensionMessageAt
+      lastExtensionMessageAt: this.lastExtensionMessageAt,
+      keepAlive: {
+        enabled: intervalMs > 0,
+        intervalMs,
+        maxIdleMs,
+        lastPingAt: this.lastPingAt,
+        totalPings: this.totalPings,
+        idleSinceMs
+      },
+      swEviction: {
+        lazyReviveAttempts: this.lazyReviveAttempts,
+        lazyReviveSuccesses: this.lazyReviveSuccesses,
+        lastEvictionDetectedAt: this.lastEvictionDetectedAt
+      }
     };
   }
   recordSuccess() {
     this.lastSuccessAt = Date.now();
     this.consecutiveFailures = 0;
+    this.noteActivityForKeepalive();
   }
   recordFailure(reason) {
     this.lastFailureAt = Date.now();
     this.lastFailureReason = reason;
     this.consecutiveFailures += 1;
+    this.noteActivityForKeepalive();
+  }
+  /**
+   * 0.8.1+ (#67): caller-side hint that work is happening or about to
+   * happen — bumps the keep-alive idle gate so the server keeps pinging
+   * the extension. Useful for MCPs that do a chain of side-effectful
+   * work between bridge calls and don't want the SW to evict in the
+   * gap (e.g. server-side parsing of a previous response that takes
+   * tens of seconds). No-op when `keepAliveIntervalMs` is `0`.
+   */
+  markActive() {
+    this.noteActivityForKeepalive();
+  }
+  noteActivityForKeepalive() {
+    const intervalMs = this.opts.keepAliveIntervalMs;
+    if (intervalMs <= 0)
+      return;
+    this.lastActiveAt = Date.now();
+    this.startKeepaliveIfIdle();
+  }
+  startKeepaliveIfIdle() {
+    if (this.keepAliveTimer !== null)
+      return;
+    const intervalMs = this.opts.keepAliveIntervalMs;
+    if (intervalMs <= 0)
+      return;
+    this.keepAliveTimer = setInterval(() => {
+      const now = Date.now();
+      if (this.lastActiveAt === null || now - this.lastActiveAt > this.opts.keepAliveMaxIdleMs) {
+        this.stopKeepalive();
+        return;
+      }
+      this.totalPings += 1;
+      this.lastPingAt = now;
+      void this.sendKeepalivePing();
+    }, intervalMs);
+  }
+  async sendKeepalivePing() {
+    try {
+      const inner = { type: "ping" };
+      if (this.hostHandle) {
+        await this.hostHandle.sendOwnInner(inner);
+      } else if (this.peerHandle) {
+        await this.peerHandle.sendInner(inner);
+      }
+    } catch (e) {
+      console.error("[fetchproxy] keepalive ping send failed:", e);
+    }
+  }
+  stopKeepalive() {
+    if (this.keepAliveTimer !== null) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
   }
   /**
    * Single bridge round-trip, wrapped by `fetchTimeoutMs` when set.
@@ -36368,7 +36594,8 @@ var FetchproxyServer = class {
         timeoutMs: this.opts.fetchTimeoutMs ?? 0,
         role: this.role,
         port: this.opts.port,
-        elapsedMs: result.elapsedMs
+        elapsedMs: result.elapsedMs,
+        retryAttempted
       });
     }
     if (result.kind === "content_script_unreachable") {
@@ -36499,6 +36726,108 @@ var FetchproxyServer = class {
     const response = await this.get(path, this.applyJsonDefaults(opts));
     return response.body;
   }
+  /**
+   * 0.11.0+: method-generic JSON convenience helper. Generalizes the
+   * `fetchJson<T>(path, { method, headers, body })` that
+   * zillow/redfin/compass/homes hand-rolled char-for-char in their
+   * `src/client.ts`:
+   *
+   *  - sets `Accept: application/json`;
+   *  - adds `Content-Type: application/json` only for a non-GET request
+   *    that carries a `body` (and only if the caller didn't set one);
+   *  - `JSON.stringify`s the body (GET / no-body sends nothing);
+   *  - treats a `204` or an empty body as `data: null` (no parse);
+   *  - otherwise `JSON.parse`s the body.
+   *
+   * Scope is serialization + header defaults + 204-handling +
+   * JSON.parse ONLY. It deliberately does NOT assert on the HTTP status
+   * or look for a sign-in interstitial — those guards differ per site
+   * (Zillow's `captcha-delivery`, Redfin's AWS-WAF challenge, …), so it
+   * returns BOTH the parsed `data` and the raw `FetchResult` and leaves
+   * the consumer to run its own `throwIfNotOk` / `throwIfSignInPage`
+   * over `result`.
+   *
+   * Bridge-level failures (no signed-in tab, SW down, timeout) still
+   * throw the typed errors via `request()`, exactly like the verb
+   * helpers — only successful round-trips (any HTTP status) return.
+   */
+  async requestJson(method, path, opts = {}) {
+    const isGet = method.toUpperCase() === "GET";
+    const sendBody = !isGet && opts.body !== void 0;
+    const headers = {
+      Accept: "application/json",
+      ...sendBody && !this.hasContentType(opts.headers ?? {}) ? { "Content-Type": "application/json" } : {},
+      ...opts.headers ?? {}
+    };
+    const response = await this.request(method, path, {
+      headers,
+      body: sendBody ? JSON.stringify(opts.body) : void 0,
+      ...opts.subdomain !== void 0 ? { subdomain: opts.subdomain } : {},
+      ...opts.domain !== void 0 ? { domain: opts.domain } : {}
+    });
+    const result = {
+      ok: true,
+      status: response.status,
+      url: response.url,
+      body: response.body
+    };
+    if (response.status === 204 || response.body === "") {
+      return { data: null, result };
+    }
+    let data;
+    try {
+      data = JSON.parse(response.body);
+    } catch (e) {
+      throw new Error(`fetchproxy ${method} ${path} \u2014 response was not JSON: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return { data, result };
+  }
+  /**
+   * 0.11.0+: run a single healthcheck probe through `fetchFn`, measure
+   * the elapsed round-trip, classify any thrown error, and project the
+   * post-probe `bridgeHealth()` into a snake-cased `bridge` sub-object.
+   *
+   * This is the transport half of the probe loop zillow/redfin/homes
+   * had duplicated verbatim in `src/tools/healthcheck.ts`. The MCP
+   * supplies its own probe call (`(path) => client.fetchHtml(path)`)
+   * and probe path (e.g. `'/robots.txt'`); the tool registration and
+   * the site-specific plain-English hint text STAY in the consumer.
+   *
+   * `bridgeHealth()` is read AFTER the probe so its freshness counters
+   * (`lastSuccessAt` / `consecutiveFailures` / …) reflect this very
+   * round-trip rather than a stale pre-probe snapshot.
+   */
+  async runProbe(fetchFn, probePath) {
+    const start = Date.now();
+    let ok = false;
+    let error51;
+    try {
+      await fetchFn(probePath);
+      ok = true;
+    } catch (e) {
+      error51 = {
+        kind: classifyBridgeError(e),
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+    const elapsed_ms = Date.now() - start;
+    const health = this.bridgeHealth();
+    return {
+      ok,
+      elapsed_ms,
+      bridge: {
+        role: health.role,
+        port: health.port,
+        server_version: health.serverVersion,
+        fetch_timeout_ms: health.fetchTimeoutMs,
+        last_success_at: health.lastSuccessAt,
+        last_failure_at: health.lastFailureAt,
+        last_failure_reason: health.lastFailureReason,
+        consecutive_failures: health.consecutiveFailures
+      },
+      ...error51 ? { error: error51 } : {}
+    };
+  }
   /**
    * Snapshot the user's non-HttpOnly cookies for the chosen domain.
    *
@@ -36667,11 +36996,14 @@ var FetchproxyServer = class {
         this.recordFailure(`capture_request_header: ${err.message ?? String(err)}`);
         throw err;
       }
+      this.lastEvictionDetectedAt = Date.now();
       const reviveMs = this.opts.bridgeReviveDelayMs ?? 0;
       if (reviveMs > 0) {
+        this.lazyReviveAttempts += 1;
         await new Promise((r) => setTimeout(r, reviveMs));
         try {
           const result = await this._captureRequestHeaderOnce(callOpts);
+          this.lazyReviveSuccesses += 1;
           this.recordSuccess();
           return result;
         } catch (retryErr) {
@@ -36964,6 +37296,7 @@ var FetchproxyServer = class {
    * twice in a row.
    */
   async close() {
+    this.stopKeepalive();
     this.rejectAllPending();
     if (this.connectingPromise) {
       await this.connectingPromise.catch(() => void 0);
@@ -36979,19 +37312,6 @@ var FetchproxyServer = class {
   }
 };
 
-// node_modules/@fetchproxy/server/dist/classify-bridge-error.js
-function classifyBridgeError(err) {
-  if (err instanceof FetchproxyTimeoutError)
-    return "timeout";
-  if (err instanceof FetchproxyBridgeDownError)
-    return "bridge_down";
-  if (err instanceof FetchproxyHttpError)
-    return "http";
-  if (err instanceof FetchproxyProtocolError)
-    return "protocol";
-  return "other";
-}
-
 // node_modules/@fetchproxy/bootstrap/dist/index.js
 var defaultFactory = (opts) => new FetchproxyServer(opts);
 async function bootstrap(opts) {
@@ -37235,7 +37555,7 @@ function getDefaultInlineAttachments() {
 // package.json
 var package_default = {
   name: "ofw-mcp",
-  version: "2.1.0",
+  version: "2.3.0",
   mcpName: "io.github.chrischall/ofw-mcp",
   description: "OurFamilyWizard MCP server for Claude \u2014 developed and maintained by AI (Claude Code)",
   author: "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -37262,8 +37582,8 @@ var package_default = {
     "test:watch": "vitest"
   },
   dependencies: {
-    "@fetchproxy/bootstrap": "^0.8.0",
-    "@fetchproxy/server": "^0.8.0",
+    "@fetchproxy/bootstrap": "^0.11.0",
+    "@fetchproxy/server": "^0.11.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     dotenv: "^17.4.2",
     zod: "^4.4.3"
@@ -37375,6 +37695,13 @@ function redactHeaders(h) {
   if (out.Authorization) out.Authorization = `Bearer ${out.Authorization.slice(7, 17)}\u2026`;
   return out;
 }
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+function getRequestTimeoutMs() {
+  const raw = process.env.OFW_REQUEST_TIMEOUT_MS;
+  if (typeof raw !== "string" || raw.trim().length === 0) return DEFAULT_REQUEST_TIMEOUT_MS;
+  const n = Number(raw.trim());
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_REQUEST_TIMEOUT_MS;
+}
 var OFWClient = class {
   token = null;
   tokenExpiry = null;
@@ -37415,13 +37742,37 @@ var OFWClient = class {
       console.error(`[ofw-debug]   headers: ${JSON.stringify(redactHeaders(headers))}`);
       console.error(`[ofw-debug]   body: ${bodyPreview}`);
     }
-    const response = await fetch(url2, {
-      method,
-      headers,
-      ...body !== void 0 ? { body: isFormData ? body : JSON.stringify(body) } : {}
-    });
+    const timeoutMs = getRequestTimeoutMs();
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    const startedAt = Date.now();
+    let response;
+    try {
+      response = await fetch(url2, {
+        method,
+        headers,
+        signal: ac.signal,
+        ...body !== void 0 ? { body: isFormData ? body : JSON.stringify(body) } : {}
+      });
+    } catch (err) {
+      const elapsed = Date.now() - startedAt;
+      if (ac.signal.aborted) {
+        if (debugLogEnabled()) {
+          console.error(`[ofw-debug] \u23F1 TIMEOUT after ${elapsed}ms: ${method} ${url2}`);
+        }
+        throw new Error(
+          `OFW API request timed out after ${timeoutMs}ms: ${method} ${path}`
+        );
+      }
+      if (debugLogEnabled()) {
+        console.error(`[ofw-debug] \u2717 ${err.message} after ${elapsed}ms: ${method} ${url2}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
     if (debugLogEnabled()) {
-      console.error(`[ofw-debug] \u2190 ${response.status} ${response.statusText}`);
+      console.error(`[ofw-debug] \u2190 ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
     }
     if (response.status === 401 && !isRetry) {
       this.token = null;
@@ -38156,18 +38507,55 @@ function registerMessageTools(server2, client2) {
     return jsonResponse({ ...row, attachments });
   });
   server2.registerTool("ofw_send_message", {
-    description: "Send a message via OurFamilyWizard. If sending from a draft, pass draftId to delete the draft after sending. If replyToId is provided, the cache may rewrite it to the latest reply in the same thread (a note is included in the response when this happens). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After sending, the tool re-fetches the message from OFW to populate the local cache and link attachments to the new message id.",
+    description: "Send a message via OurFamilyWizard. To send an existing draft, pass messageId \u2014 subject/body/recipientIds become optional overrides (missing fields default to the draft's cached values) and the draft is deleted after sending. To send a fresh message, supply subject/body/recipientIds directly. draftId is the legacy spelling of messageId and works the same way. If replyToId is provided, the cache may rewrite it to the latest reply in the same thread (a note is included in the response when this happens). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After sending, the tool re-fetches the message from OFW to populate the local cache and link attachments to the new message id.",
     annotations: { destructiveHint: true },
     inputSchema: {
-      subject: external_exports.string().describe("Message subject"),
-      body: external_exports.string().describe("Message body text"),
-      recipientIds: external_exports.array(external_exports.number()).describe("Array of recipient user IDs (get from ofw_get_profile)"),
+      subject: external_exports.string().describe("Message subject. Required unless messageId/draftId references a cached draft.").optional(),
+      body: external_exports.string().describe("Message body text. Required unless messageId/draftId references a cached draft.").optional(),
+      recipientIds: external_exports.array(external_exports.number()).describe("Array of recipient user IDs (get from ofw_get_profile). Required unless messageId/draftId references a cached draft.").optional(),
       replyToId: external_exports.number().describe("ID of the message being replied to").optional(),
-      draftId: external_exports.number().describe("ID of the draft to delete after sending (omit if not sending from a draft)").optional(),
+      messageId: external_exports.number().describe("ID of an existing draft to send. When set, missing subject/body/recipientIds default to the draft's cached values, and the draft is deleted after sending.").optional(),
+      draftId: external_exports.number().describe("Legacy synonym for messageId. If both are passed they must be equal.").optional(),
       myFileIDs: external_exports.array(external_exports.number()).describe("Attachment file ids (from ofw_upload_attachment) to attach to the message").optional()
     }
   }, async (args) => {
-    const requestedReplyTo = args.replyToId ?? null;
+    if (args.messageId !== void 0 && args.draftId !== void 0 && args.messageId !== args.draftId) {
+      throw new Error(`messageId (${args.messageId}) and draftId (${args.draftId}) refer to different drafts; pass only one.`);
+    }
+    const draftRef = args.messageId ?? args.draftId;
+    let subject = args.subject;
+    let body = args.body;
+    let recipientIds = args.recipientIds;
+    let draftReplyToId = null;
+    let draftLookupAttempted = false;
+    let draftFound = false;
+    if (draftRef !== void 0) {
+      draftLookupAttempted = true;
+      const draft = getDraft(draftRef);
+      if (draft !== null) {
+        draftFound = true;
+        subject = subject ?? draft.subject;
+        body = body ?? draft.body;
+        recipientIds = recipientIds ?? draft.recipients.map((r) => r.userId);
+        draftReplyToId = draft.replyToId;
+      }
+    }
+    if (subject === void 0 || body === void 0 || recipientIds === void 0) {
+      if (draftLookupAttempted && !draftFound) {
+        throw new Error(
+          `draft ${draftRef} not found in local cache. Call ofw_sync_messages first, or supply subject/body/recipientIds explicitly.`
+        );
+      }
+      const missing = [
+        subject === void 0 ? "subject" : null,
+        body === void 0 ? "body" : null,
+        recipientIds === void 0 ? "recipientIds" : null
+      ].filter((n) => n !== null).join(", ");
+      throw new Error(
+        `ofw_send_message requires ${missing}. Pass it directly, or pass messageId to default missing fields from a cached draft.`
+      );
+    }
+    const requestedReplyTo = args.replyToId ?? draftReplyToId ?? null;
     let resolvedReplyTo = requestedReplyTo;
     let chainRootId = null;
     let rewriteNote = null;
@@ -38181,9 +38569,9 @@ function registerMessageTools(server2, client2) {
     }
     const myFileIDs = args.myFileIDs ?? [];
     const { id: newId, detail, raw } = await postMessageAndRefetch(client2, {
-      subject: args.subject,
-      body: args.body,
-      recipientIds: args.recipientIds,
+      subject,
+      body,
+      recipientIds,
       attachments: { myFileIDs },
       draft: false,
       includeOriginal: resolvedReplyTo !== null,
@@ -38194,11 +38582,11 @@ function registerMessageTools(server2, client2) {
       persisted = {
         id: newId,
         folder: "sent",
-        subject: detail.subject ?? args.subject,
+        subject: detail.subject ?? subject,
         fromUser: detail.from?.name ?? "",
         sentAt: detail.date?.dateTime ?? (/* @__PURE__ */ new Date()).toISOString(),
         recipients: mapRecipients(detail.recipients),
-        body: detail.body ?? args.body,
+        body: detail.body ?? body,
         fetchedBodyAt: (/* @__PURE__ */ new Date()).toISOString(),
         replyToId: resolvedReplyTo,
         chainRootId,
@@ -38218,9 +38606,9 @@ function registerMessageTools(server2, client2) {
         });
       }
     }
-    if (args.draftId !== void 0) {
-      await deleteOFWMessages(client2, [args.draftId]);
-      deleteDraft(args.draftId);
+    if (draftRef !== void 0) {
+      await deleteOFWMessages(client2, [draftRef]);
+      deleteDraft(draftRef);
     }
     const responseObj = persisted ?? raw;
     const text = responseObj ? JSON.stringify(responseObj, null, 2) : "Message sent successfully.";
@@ -38629,7 +39017,7 @@ process.emit = function(event, ...args) {
   }
   return originalEmit(event, ...args);
 };
-var server = new McpServer({ name: "ofw", version: "2.1.0" });
+var server = new McpServer({ name: "ofw", version: "2.3.0" });
 registerUserTools(server, client);
 registerMessageTools(server, client);
 registerCalendarTools(server, client);

package/dist/client.js

@@ -40,6 +40,19 @@ function redactHeaders(h) {
         out.Authorization = `Bearer ${out.Authorization.slice(7, 17)}…`;
     return out;
 }
+// Per-request timeout. Overridable via OFW_REQUEST_TIMEOUT_MS. The default
+// (30s) is comfortably above OFW's typical p99 but low enough that a stuck
+// upstream fails fast instead of burning the MCP client-side budget — which
+// is what produced the multi-minute hangs we've seen on ofw_list_messages
+// and ofw_save_draft. Each retry (401/429 replay) gets its own fresh window.
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+function getRequestTimeoutMs() {
+    const raw = process.env.OFW_REQUEST_TIMEOUT_MS;
+    if (typeof raw !== 'string' || raw.trim().length === 0)
+        return DEFAULT_REQUEST_TIMEOUT_MS;
+    const n = Number(raw.trim());
+    return Number.isFinite(n) && n > 0 ? n : DEFAULT_REQUEST_TIMEOUT_MS;
+}
 export class OFWClient {
     token = null;
     tokenExpiry = null;
@@ -85,13 +98,40 @@ export class OFWClient {
             console.error(`[ofw-debug]   headers: ${JSON.stringify(redactHeaders(headers))}`);
             console.error(`[ofw-debug]   body: ${bodyPreview}`);
         }
-        const response = await fetch(url, {
-            method,
-            headers,
-            ...(body !== undefined ? { body: isFormData ? body : JSON.stringify(body) } : {}),
-        });
+        // AbortController + setTimeout (not AbortSignal.timeout) so vitest fake
+        // timers can drive the timeout in tests, and so we can attach a clear
+        // error message instead of a bare DOMException on the abort path.
+        const timeoutMs = getRequestTimeoutMs();
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), timeoutMs);
+        const startedAt = Date.now();
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers,
+                signal: ac.signal,
+                ...(body !== undefined ? { body: isFormData ? body : JSON.stringify(body) } : {}),
+            });
+        }
+        catch (err) {
+            const elapsed = Date.now() - startedAt;
+            if (ac.signal.aborted) {
+                if (debugLogEnabled()) {
+                    console.error(`[ofw-debug] ⏱ TIMEOUT after ${elapsed}ms: ${method} ${url}`);
+                }
+                throw new Error(`OFW API request timed out after ${timeoutMs}ms: ${method} ${path}`);
+            }
+            if (debugLogEnabled()) {
+                console.error(`[ofw-debug] ✗ ${err.message} after ${elapsed}ms: ${method} ${url}`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
         if (debugLogEnabled()) {
-            console.error(`[ofw-debug] ← ${response.status} ${response.statusText}`);
+            console.error(`[ofw-debug] ← ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
         }
         if (response.status === 401 && !isRetry) {
             this.token = null;

package/dist/index.js

@@ -17,7 +17,7 @@ import { registerMessageTools } from './tools/messages.js';
 import { registerCalendarTools } from './tools/calendar.js';
 import { registerExpenseTools } from './tools/expenses.js';
 import { registerJournalTools } from './tools/journal.js';
-const server = new McpServer({ name: 'ofw', version: '2.1.0' }); // x-release-please-version
+const server = new McpServer({ name: 'ofw', version: '2.3.0' }); // x-release-please-version
 registerUserTools(server, client);
 registerMessageTools(server, client);
 registerCalendarTools(server, client);

package/dist/tools/messages.js

@@ -175,18 +175,59 @@ export function registerMessageTools(server, client) {
         return jsonResponse({ ...row, attachments });
     });
     server.registerTool('ofw_send_message', {
-        description: 'Send a message via OurFamilyWizard. If sending from a draft, pass draftId to delete the draft after sending. If replyToId is provided, the cache may rewrite it to the latest reply in the same thread (a note is included in the response when this happens). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After sending, the tool re-fetches the message from OFW to populate the local cache and link attachments to the new message id.',
+        description: 'Send a message via OurFamilyWizard. To send an existing draft, pass messageId — subject/body/recipientIds become optional overrides (missing fields default to the draft\'s cached values) and the draft is deleted after sending. To send a fresh message, supply subject/body/recipientIds directly. draftId is the legacy spelling of messageId and works the same way. If replyToId is provided, the cache may rewrite it to the latest reply in the same thread (a note is included in the response when this happens). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After sending, the tool re-fetches the message from OFW to populate the local cache and link attachments to the new message id.',
         annotations: { destructiveHint: true },
         inputSchema: {
-            subject: z.string().describe('Message subject'),
-            body: z.string().describe('Message body text'),
-            recipientIds: z.array(z.number()).describe('Array of recipient user IDs (get from ofw_get_profile)'),
+            subject: z.string().describe('Message subject. Required unless messageId/draftId references a cached draft.').optional(),
+            body: z.string().describe('Message body text. Required unless messageId/draftId references a cached draft.').optional(),
+            recipientIds: z.array(z.number()).describe('Array of recipient user IDs (get from ofw_get_profile). Required unless messageId/draftId references a cached draft.').optional(),
             replyToId: z.number().describe('ID of the message being replied to').optional(),
-            draftId: z.number().describe('ID of the draft to delete after sending (omit if not sending from a draft)').optional(),
+            messageId: z.number().describe('ID of an existing draft to send. When set, missing subject/body/recipientIds default to the draft\'s cached values, and the draft is deleted after sending.').optional(),
+            draftId: z.number().describe('Legacy synonym for messageId. If both are passed they must be equal.').optional(),
             myFileIDs: z.array(z.number()).describe('Attachment file ids (from ofw_upload_attachment) to attach to the message').optional(),
         },
     }, async (args) => {
-        const requestedReplyTo = args.replyToId ?? null;
+        if (args.messageId !== undefined && args.draftId !== undefined && args.messageId !== args.draftId) {
+            throw new Error(`messageId (${args.messageId}) and draftId (${args.draftId}) refer to different drafts; pass only one.`);
+        }
+        const draftRef = args.messageId ?? args.draftId;
+        // Best-effort draft lookup: when draftRef points at a cached draft, use
+        // its stored fields (including replyToId) as defaults for anything the
+        // caller didn't supply. The "missing draft" case only matters when we
+        // actually NEED the defaults — a caller passing all fields explicitly
+        // can use draftId as a pure delete-target even on an empty cache.
+        let subject = args.subject;
+        let body = args.body;
+        let recipientIds = args.recipientIds;
+        let draftReplyToId = null;
+        let draftLookupAttempted = false;
+        let draftFound = false;
+        if (draftRef !== undefined) {
+            draftLookupAttempted = true;
+            const draft = getDraft(draftRef);
+            if (draft !== null) {
+                draftFound = true;
+                subject = subject ?? draft.subject;
+                body = body ?? draft.body;
+                recipientIds = recipientIds ?? draft.recipients.map((r) => r.userId);
+                draftReplyToId = draft.replyToId;
+            }
+        }
+        if (subject === undefined || body === undefined || recipientIds === undefined) {
+            if (draftLookupAttempted && !draftFound) {
+                throw new Error(`draft ${draftRef} not found in local cache. Call ofw_sync_messages first, or supply subject/body/recipientIds explicitly.`);
+            }
+            const missing = [
+                subject === undefined ? 'subject' : null,
+                body === undefined ? 'body' : null,
+                recipientIds === undefined ? 'recipientIds' : null,
+            ].filter((n) => n !== null).join(', ');
+            throw new Error(`ofw_send_message requires ${missing}. Pass it directly, or pass messageId to default missing fields from a cached draft.`);
+        }
+        // Inherit the draft's replyToId when the caller didn't supply one. A
+        // reply-draft saved with replyToId would otherwise be sent as a
+        // top-level message — silently losing the thread.
+        const requestedReplyTo = args.replyToId ?? draftReplyToId ?? null;
         let resolvedReplyTo = requestedReplyTo;
         let chainRootId = null;
         let rewriteNote = null;
@@ -200,9 +241,9 @@ export function registerMessageTools(server, client) {
         }
         const myFileIDs = args.myFileIDs ?? [];
         const { id: newId, detail, raw } = await postMessageAndRefetch(client, {
-            subject: args.subject,
-            body: args.body,
-            recipientIds: args.recipientIds,
+            subject,
+            body,
+            recipientIds,
             attachments: { myFileIDs },
             draft: false,
             includeOriginal: resolvedReplyTo !== null,
@@ -213,11 +254,11 @@ export function registerMessageTools(server, client) {
             persisted = {
                 id: newId,
                 folder: 'sent',
-                subject: detail.subject ?? args.subject,
+                subject: detail.subject ?? subject,
                 fromUser: detail.from?.name ?? '',
                 sentAt: detail.date?.dateTime ?? new Date().toISOString(),
                 recipients: mapRecipients(detail.recipients),
-                body: detail.body ?? args.body,
+                body: detail.body ?? body,
                 fetchedBodyAt: new Date().toISOString(),
                 replyToId: resolvedReplyTo,
                 chainRootId,
@@ -240,9 +281,9 @@ export function registerMessageTools(server, client) {
                 });
             }
         }
-        if (args.draftId !== undefined) {
-            await deleteOFWMessages(client, [args.draftId]);
-            deleteDraft(args.draftId);
+        if (draftRef !== undefined) {
+            await deleteOFWMessages(client, [draftRef]);
+            deleteDraft(draftRef);
         }
         const responseObj = persisted ?? raw;
         const text = responseObj ? JSON.stringify(responseObj, null, 2) : 'Message sent successfully.';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofw-mcp",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "mcpName": "io.github.chrischall/ofw-mcp",
   "description": "OurFamilyWizard MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -27,8 +27,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@fetchproxy/bootstrap": "^0.8.0",
-    "@fetchproxy/server": "^0.8.0",
+    "@fetchproxy/bootstrap": "^0.11.0",
+    "@fetchproxy/server": "^0.11.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "dotenv": "^17.4.2",
     "zod": "^4.4.3"

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/ofw-mcp",
     "source": "github"
   },
-  "version": "2.1.0",
+  "version": "2.3.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "ofw-mcp",
-      "version": "2.1.0",
+      "version": "2.3.0",
       "transport": {
         "type": "stdio"
       },