actual-mcp-server 0.22.31 → 0.22.37

package/README.md

@@ -525,8 +525,8 @@ All configuration is via environment variables. Copy `.env.example` to `.env` to
 | `OIDC_JWKS_URI` | _(none)_ | No | Direct JWKS URL that bypasses OpenID discovery (#462), for issuers with no discovery document (Cloudflare Access: `https://<team>.cloudflareaccess.com/cdn-cgi/access/certs`). Same https, credentials and origin-or-trusted-host rules as a discovered `jwks_uri`, plus no query or fragment. When set, `/.well-known/oauth-authorization-server` is not served and `AUTH_BUDGET_ACL_IDENTITY_SOURCE=userinfo` is refused |
 | `OIDC_TOKEN_SOURCE` | `authorization` | No | Where the bearer JWT is read from (#462): `authorization` (default) or `cf-access-jwt-assertion` for an MCP server behind Cloudflare Access with Managed OAuth (the edge forwards the signed Access JWT in that header; `Authorization` is then never consulted, `OIDC_SCOPES` must be empty, `OIDC_SCOPES_SUPPORTED` is allowed, and the origin must be reachable only via Cloudflare). See the Cloudflare recipe in `docs/guides/AI_CLIENT_SETUP.md` |
 | `OIDC_SCOPES` | _(none)_ | No | Comma-separated required (enforced) scopes, also advertised. Leave empty when the IdP's JWTs carry no `scope` claim (Cloudflare Access for SaaS, or Casdoor when the client requests no scope) |
-| `OIDC_SCOPES_SUPPORTED` | _(none)_ | No | Comma-separated scopes advertised in `scopes_supported` but not enforced. Use when the IdP's JWTs carry no `scope` claim but the client needs a scope such as `offline_access` advertised (e.g. Gemini with Cloudflare Access for SaaS). Required scopes from `OIDC_SCOPES` are always advertised too |
-| `AUTH_BUDGET_ACL` | _(none)_ | No | Per-user budget ACL; see [AI Client Setup](docs/guides/AI_CLIENT_SETUP.md#oidc-authentication-multi-user) |
+| `OIDC_SCOPES_SUPPORTED` | _(none)_ | No | Comma-separated scopes advertised in `scopes_supported` but not enforced. Use when the IdP's JWTs carry no `scope` claim but the client needs a scope such as `offline_access` advertised (e.g. Gemini with Cloudflare Access for SaaS). Required scopes from `OIDC_SCOPES` are always advertised too. Advertising `offline_access` unlocks a refresh token this server cannot revoke: see [Limiting a leaked refresh token](docs/SECURITY_AND_PRIVACY.md#limiting-a-leaked-refresh-token-488) |
+| `AUTH_BUDGET_ACL` | _(none)_ | No | Per-user budget ACL; see [AI Client Setup](docs/guides/AI_CLIENT_SETUP.md#oidc-authentication-multi-user). Validated at startup: a value that is not a JSON object of string arrays refuses to start (#551). Unset or `{}` means no restrictions |
 | `AUTH_BUDGET_ACL_SOURCE` | `static` | No | `static` uses the `AUTH_BUDGET_ACL` map above. `actual` derives the ACL from the Actual server's own per-file access list, so revoking someone in Actual takes effect here without a config edit. Requires a multi-user (OpenID) Actual server that was password-bootstrapped first |
 | `AUTH_BUDGET_ACL_CLAIM` | `auto` | No | Which token claim identifies the principal when the source is `actual`. `auto` mirrors Actual's own precedence (`preferred_username`, `login`, `email`, `id`, `sub`) and matches the result against Actual's `userName`. Set a single claim name to pin one instead |
 | `AUTH_BUDGET_ACL_IDENTITY_MAP` | _(empty)_ | No | Explicit `<sub>=<Actual userName>` bindings, comma separated, used when the source is `actual`. Consulted before the claim precedence and authoritative: a bound `sub` whose target matches no budget file is denied rather than falling back to a claim. Use it when your access token does not carry the claim Actual stored, or after an IdP-side rename |
@@ -836,7 +836,7 @@ The software is provided **as-is**, without warranty of any kind. The author acc
 
 ---
 
-**Version:** 0.22.31 | **Tool Count:** 84 (verified LibreChat-compatible)
+**Version:** 0.22.37 | **Tool Count:** 84 (verified LibreChat-compatible)
 
 ## Sponsor
 

package/dist/src/actualConnection.js

@@ -16,6 +16,10 @@ let initializing = false;
 let initializationError = null;
 // Feature flag to enable connection pooling - can be disabled via environment variable
 let useConnectionPool = process.env.USE_CONNECTION_POOL !== 'false';
+/** #530: httpServer registers sessions with the pool only when the pool is in use. */
+export function isConnectionPoolEnabled() {
+    return useConnectionPool;
+}
 export async function connectToActual() {
     if (initialized)
         return;

package/dist/src/auth/budget-acl-parse.js

@@ -0,0 +1,82 @@
+// src/auth/budget-acl-parse.ts
+//
+// #551: the pure parser for AUTH_BUDGET_ACL, shared by config.ts (startup
+// validation) and budget-acl.ts (runtime classification).
+//
+// Before #551 a set-but-invalid value was parsed lazily in budget-acl.ts, logged
+// once, and replaced by an EMPTY map, which getAllowedBudgets read as "no ACL
+// configured": every authenticated principal was granted every budget. A typo in
+// the one variable that restricts users to their budgets opened them all. Now a
+// set value is validated at startup, and the runtime path denies on failure.
+//
+// WHY THIS MODULE HAS NO IMPORTS. config.ts validates the raw env value at
+// startup by calling parseBudgetAcl. If the parser lived in budget-acl.ts, config
+// would import a module that imports config (an ESM cycle leaving one of them
+// half-initialised at evaluation time) and would also pull in the chain
+// budget-acl.ts -> budget-acl-dynamic.ts -> lib/actual-adapter.ts -> @actual-app/api
+// into every config load, stdio included. Keeping this file dependency-free (no
+// logger, no config, no zod) is what makes validation at config-parse time
+// possible at all. It throws and never logs.
+//
+// ERROR-TEXT CONTRACT. A thrown message may contain only the variable name, the
+// problem class (not JSON, not an object, entry not an array of non-empty
+// strings), the zero-based entry index in PARSED key order (JSON.parse puts
+// integer-like keys first, so it is not always the order the operator wrote; the
+// message says so), and the JSON type found.
+// Never a key, a value, JSON.parse's own message (on Node 22 it echoes the input,
+// which may hold email addresses), or an Error `cause` carrying any of those. The
+// message is printed to stderr at startup and logged at runtime, so it must be
+// safe to surface verbatim.
+function jsonTypeOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Parse the raw `AUTH_BUDGET_ACL` value.
+ *
+ * Accepts a JSON object whose every value is an array of non-empty strings
+ * (`["*"]` is the wildcard). `{}` is valid and means no restrictions; an empty
+ * array for a principal is valid and denies that principal. Throws a TypeError
+ * under the error-text contract above on anything else, including whitespace-only
+ * input, `null`, an array, a scalar, a non-array entry, and an array holding a
+ * non-string or an empty string. The caller decides what unset and '' mean.
+ */
+export function parseBudgetAcl(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new TypeError('AUTH_BUDGET_ACL: not valid JSON');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new TypeError(`AUTH_BUDGET_ACL: must be a JSON object (got ${jsonTypeOf(parsed)})`);
+    }
+    // Null prototype on purpose (see BudgetAclMap). On such an object a plain
+    // assignment of the "__proto__" key stores an own property, so no setter can fire.
+    const map = Object.create(null);
+    // The index follows Object.entries order: integer-like keys (a numeric `sub`)
+    // come first and a duplicate key keeps only its last copy, so the message
+    // states the order rather than letting the operator count lines in the file.
+    const order = '; indexes are zero-based in parsed key order, integer-like keys first';
+    let index = 0;
+    for (const [key, value] of Object.entries(parsed)) {
+        if (!Array.isArray(value)) {
+            throw new TypeError(`AUTH_BUDGET_ACL: entry ${index} must be an array of non-empty strings (got ${jsonTypeOf(value)}${order})`);
+        }
+        for (const id of value) {
+            if (typeof id !== 'string') {
+                throw new TypeError(`AUTH_BUDGET_ACL: entry ${index} must be an array of non-empty strings (got an array with a ${jsonTypeOf(id)} element${order})`);
+            }
+            if (id.length === 0) {
+                throw new TypeError(`AUTH_BUDGET_ACL: entry ${index} must be an array of non-empty strings (got an array with an empty string${order})`);
+            }
+        }
+        map[key] = [...value];
+        index++;
+    }
+    return map;
+}

package/dist/src/auth/budget-acl.js

@@ -9,13 +9,21 @@
 //   { "<principal>": ["<syncId1>", "<syncId2>"] }
 //
 //   Principal keys:
-//     "alice@example.com"  — matched against token email claim
-//     "some-sub-uuid"      — matched against token sub claim
-//     "group:admin"        — matched against token groups/roles array
+//     "alice@example.com"  matched against the token email claim
+//     "some-sub-uuid"      matched against the token sub claim
+//     "group:admin"        matched against the token groups/roles array
 //
 //   Value ["*"] grants access to all budgets (admin shorthand).
 //
-// When AUTH_BUDGET_ACL is unset, all authenticated users are allowed ("*").
+// Three states, classified once from the raw value and cached (#551):
+//   open  (AUTH_BUDGET_ACL unset, '' or '{}'): every authenticated user is
+//         allowed ("*"), as documented.
+//   map   (a valid non-empty object): the per-principal lookup below.
+//   deny  (a value that does not parse): every principal gets [] and a 403.
+//         config.ts refuses startup on such a value, so this state is a
+//         defence in depth for any caller that reaches the parser another way.
+//         Before #551 a parse failure degraded to an EMPTY map, which read as
+//         "open": a typo in the ACL granted every budget to every user.
 //
 // Usage in httpServer.ts:
 //   app.use(httpPath, budgetAclMiddleware);   // after bearerAuth()
@@ -24,31 +32,36 @@
 // to filter results by permitted sync IDs (forward-looking multi-budget support).
 import config from '../config.js';
 import logger from '../logger.js';
+import { parseBudgetAcl } from './budget-acl-parse.js';
 import { resolveAllowedBudgetsFromActual, resolvePrincipalAsync } from './budget-acl-dynamic.js';
-// ---------------------------------------------------------------------------
-// ACL map (parsed once from env, cached)
-// ---------------------------------------------------------------------------
-let _aclMap = null;
-function getAclMap() {
-    if (_aclMap !== null)
-        return _aclMap;
-    if (!config.AUTH_BUDGET_ACL) {
-        _aclMap = {};
-        return _aclMap;
-    }
+let _aclState = null;
+// Test seam (#551): when set, classify this raw value instead of config.AUTH_BUDGET_ACL.
+let _rawOverride = null;
+function classify(raw) {
+    if (raw === undefined || raw === '')
+        return { kind: 'open' };
+    let map;
     try {
-        const parsed = JSON.parse(config.AUTH_BUDGET_ACL);
-        if (typeof parsed !== 'object' || Array.isArray(parsed)) {
-            throw new TypeError('AUTH_BUDGET_ACL must be a JSON object');
-        }
-        _aclMap = parsed;
-        logger.info(`[ACL] Budget ACL loaded: ${Object.keys(_aclMap).length} principal(s)`);
+        map = parseBudgetAcl(raw);
     }
     catch (err) {
-        logger.error('[ACL] Invalid AUTH_BUDGET_ACL JSON — treating as empty (no budget restrictions):', err);
-        _aclMap = {};
+        // Only the parser's message, which is safe by contract (it never names a key
+        // or a value); never the raw error object, whose cause or stack could.
+        const reason = err instanceof Error ? err.message : 'AUTH_BUDGET_ACL: unparseable';
+        logger.error(`[ACL] Invalid AUTH_BUDGET_ACL: access denied to every principal until it is fixed (${reason})`);
+        return { kind: 'deny' };
     }
-    return _aclMap;
+    const count = Object.keys(map).length;
+    if (count === 0)
+        return { kind: 'open' };
+    logger.info(`[ACL] Budget ACL loaded: ${count} principal(s)`);
+    return { kind: 'map', map };
+}
+function getAclState() {
+    if (_aclState === null) {
+        _aclState = classify(_rawOverride !== null ? _rawOverride.raw : config.AUTH_BUDGET_ACL);
+    }
+    return _aclState;
 }
 // ---------------------------------------------------------------------------
 // Public helpers
@@ -57,15 +70,23 @@ function getAclMap() {
  * Returns the list of allowed budget sync-IDs for the currently authenticated
  * request principal.
  *
- * - Returns `['*']` when ACL is empty / unset (no restrictions).
+ * - Returns `['*']` in the open state (ACL unset, empty, or `{}`).
  * - Returns `['*']` when any matched principal has wildcard access.
  * - Returns `[]` when the user is authenticated but not in the ACL at all.
+ * - Returns `[]` for every principal in the deny state (the ACL value does not
+ *   parse), never `['*']`.
+ *
+ * Lookups use Object.hasOwn so a principal named like an Object.prototype member
+ * (`constructor`, `toString`) is simply absent instead of matching the inherited
+ * function (which used to throw and surface as a 500).
  */
 export function getAllowedBudgets(req) {
-    const acl = getAclMap();
-    // No ACL configured → allow everything
-    if (Object.keys(acl).length === 0)
+    const state = getAclState();
+    if (state.kind === 'open')
         return ['*'];
+    if (state.kind === 'deny')
+        return [];
+    const acl = state.map;
     const auth = req.auth;
     if (!auth)
         return [];
@@ -84,13 +105,15 @@ export function getAllowedBudgets(req) {
         principals.push(`group:${g}`);
     // Check for wildcard admin access first
     for (const p of principals) {
-        if (acl[p]?.includes('*'))
+        if (Object.hasOwn(acl, p) && acl[p].includes('*'))
             return ['*'];
     }
     // Collect all permitted sync-IDs
     const permitted = new Set();
     for (const p of principals) {
-        for (const id of acl[p] ?? [])
+        if (!Object.hasOwn(acl, p))
+            continue;
+        for (const id of acl[p])
             permitted.add(id);
     }
     return [...permitted];
@@ -108,8 +131,8 @@ export function canAccessBudget(req, budgetSyncId) {
 /**
  * Express middleware that enforces the budget ACL when OIDC auth is active.
  *
- * - Falls through immediately when AUTH_PROVIDER !== 'oidc' or AUTH_BUDGET_ACL
- *   is unset (no-op — keeps backward compatibility).
+ * - Falls through immediately when AUTH_PROVIDER !== 'oidc' (no-op, keeps
+ *   backward compatibility). With OIDC and the ACL unset it attaches `['*']`.
  * - Attaches `req.allowedBudgets` for downstream use (multi-budget tools).
  * - Returns HTTP 403 if the authenticated user has no permitted budgets.
  *
@@ -178,11 +201,23 @@ async function resolveDynamicAcl(req, res, next) {
         res.status(403).json({ error: 'Forbidden: budget access could not be determined' });
     }
 }
-/** Reset cached state (test helper). */
+/** Reset cached state and the raw override (test helper). */
 export function _resetAclForTests() {
-    _aclMap = null;
+    _aclState = null;
+    _rawOverride = null;
 }
-/** Directly set the ACL map (test helper — bypasses config/env). */
+/**
+ * Directly set the ACL map (test helper; bypasses config/env). `{}` is the open
+ * state, exactly as an unset variable is.
+ */
 export function _setAclForTests(aclMap) {
-    _aclMap = aclMap;
+    _aclState = Object.keys(aclMap).length === 0 ? { kind: 'open' } : { kind: 'map', map: aclMap };
+}
+/**
+ * #551 test seam: classify `raw` as if it were the AUTH_BUDGET_ACL value, through
+ * the same parser and logging as the real path. Cleared by _resetAclForTests.
+ */
+export function _setRawAclForTests(raw) {
+    _rawOverride = { raw };
+    _aclState = null;
 }

package/dist/src/config.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { parseIdentityMap } from './auth/identity-map.js';
+import { parseBudgetAcl } from './auth/budget-acl-parse.js';
 // #466: the byte count body-parser will ACTUALLY enforce for MCP_HTTP_BODY_LIMIT, or
 // null when the value must be refused. Mirrors `bytes.parse` (what body-parser uses)
 // without importing that transitive package: floor(number * unit), units b and kb
@@ -192,7 +193,34 @@ export const configSchema = z.object({
     // Keys: email, sub, or "group:<name>". Values: array of sync IDs or ["*"] for all.
     // Example: {"alice@example.com":["budget-1"],"group:admin":["*"]}
     // Leave unset to allow all authenticated users to access all budgets.
-    AUTH_BUDGET_ACL: z.string().optional(),
+    // #551: a SET value must parse, whatever AUTH_PROVIDER and AUTH_BUDGET_ACL_SOURCE
+    // are. Unset and '' mean "no restrictions" and are not validated. Before this
+    // refine an invalid value was parsed lazily at runtime and degraded to an empty
+    // map, which the ACL read as "open": a typo granted every budget to every user.
+    // The parser is a zero-import leaf so this file can call it (see its header).
+    AUTH_BUDGET_ACL: z
+        .string()
+        .optional()
+        .superRefine((v, ctx) => {
+        if (v === undefined || v === '')
+            return;
+        try {
+            parseBudgetAcl(v);
+        }
+        catch (err) {
+            // The parser's message is safe by contract (variable name, problem class,
+            // entry index and JSON type only; never a key, a value or JSON.parse's
+            // echo of the input). Its own "AUTH_BUDGET_ACL: " prefix is dropped here
+            // because the sentence already names the variable.
+            const reason = (err instanceof Error ? err.message : String(err)).replace(/^AUTH_BUDGET_ACL: /, '');
+            ctx.addIssue({
+                code: 'custom',
+                message: `AUTH_BUDGET_ACL is malformed (${reason}). ` +
+                    'Expected a JSON object mapping each principal to an array of budget sync ids, for example ' +
+                    '{"<email or sub>":["<sync id>"],"group:<name>":["*"]}. See docs/CONFIGURATION.md.',
+            });
+        }
+    }),
     // #338: where the budget ACL comes from.
     //   'static' (default) = AUTH_BUDGET_ACL above, exactly as before.
     //   'actual'           = derived from the Actual server's own per-file access

package/dist/src/lib/ActualConnectionPool.js

@@ -36,6 +36,22 @@ class ActualConnectionPool {
     // a lazily-cleaned table would leak transport objects for sessions a client
     // abandons without reconnecting.
     evictionCallbacks = [];
+    // #530: every HTTP session the transport layer registered, with the time it was last
+    // served. An entry in `connections` is not the only thing that must expire: an
+    // infra-error drop (or `switchBudget`'s slow path) removes the pool entry WITHOUT
+    // evicting the transport, and before #530 a client that then went away left its
+    // transport, owner record and init promise behind forever, because nothing timed an
+    // entry-less session. The sweep reaps a registered id that has no entry and was not
+    // served for one idle window ("orphaned"). `touch()` stamps it, so a served request
+    // keeps the session alive whether or not the entry is back.
+    registered = new Map();
+    // #530 (review M1): requests currently being served per session. The orphan sweep skips a
+    // session with a request in flight: an entry-less session running a long operation (an
+    // import past the idle window, or a request queued behind another session's drain) has
+    // stamped its registration only at the START of the request, so without this the sweep
+    // would close its transport mid-operation. Entries have the #392 lock re-check and the
+    // #378 in-drain touch for the same hazard; registrations have neither.
+    inFlight = new Map();
     constructor() {
         // Read from environment variable or default to 15
         // @actual-app/api is a singleton, so concurrent sessions cause conflicts
@@ -116,7 +132,24 @@ class ActualConnectionPool {
      * sweep so the two can never disagree about where the boundary is (#167).
      */
     isExpired(conn) {
-        return (Date.now() - conn.lastActivity) > this.IDLE_TIMEOUT;
+        // #530: a registered session's clock is the later of the entry's lastActivity and its
+        // last served request, so a recycled entry cannot make a session look idle.
+        return this.isPastIdle(Math.max(conn.lastActivity, this.registered.get(conn.sessionId) ?? 0));
+    }
+    /** The one boundary for entries and registrations alike (#167, #530). */
+    isPastIdle(lastActivity) {
+        return (Date.now() - lastActivity) > this.IDLE_TIMEOUT;
+    }
+    /**
+     * #530: the transport layer registers each HTTP session when it registers the transport,
+     * so the pool can time it even while it has no entry. Idempotent; stamps "now".
+     */
+    registerSession(sessionId) {
+        this.registered.set(sessionId, Date.now());
+    }
+    /** #530: drop a registration (idempotent). Every eviction path calls this itself. */
+    forgetSession(sessionId) {
+        this.registered.delete(sessionId);
     }
     /**
      * Refresh a session's activity timestamp. Called by the transport layer on
@@ -124,28 +157,61 @@ class ActualConnectionPool {
      * this, the pool only stamped lastActivity at init/switch, so an actively
      * used session's pool clock never advanced; httpServer kept a parallel
      * activity map to compensate, which is the drift this consolidation removes.
-     * No-op for unknown sessions (does NOT create an entry).
+     * No-op for unknown sessions (does NOT create an entry). #530: also stamps the session's
+     * registration when it has one, so a session whose entry was dropped stays alive while
+     * it is being served (the #378 in-drain touch feeds the same clock). Never registers.
      */
     touch(sessionId) {
+        const now = Date.now();
         const conn = this.connections.get(sessionId);
         if (conn) {
-            conn.lastActivity = Date.now();
+            conn.lastActivity = now;
+        }
+        if (this.registered.has(sessionId)) {
+            this.registered.set(sessionId, now);
         }
     }
+    /**
+     * #530: mark a request as in flight for the session (and touch it). While the count is
+     * above zero the orphan sweep leaves the session alone. httpServer calls this on POST only:
+     * an open GET event stream is idle by nature and must not pin an orphan.
+     */
+    beginRequest(sessionId) {
+        this.touch(sessionId);
+        this.inFlight.set(sessionId, (this.inFlight.get(sessionId) ?? 0) + 1);
+    }
+    /**
+     * #530: the request has ended (response finished or the client went away). Drops the
+     * in-flight count and touches, so the idle window starts from the END of a long request,
+     * not its start. Idempotent for an unknown or already-evicted session.
+     */
+    endRequest(sessionId) {
+        const n = this.inFlight.get(sessionId);
+        if (n !== undefined) {
+            if (n <= 1)
+                this.inFlight.delete(sessionId);
+            else
+                this.inFlight.set(sessionId, n - 1);
+        }
+        this.touch(sessionId);
+    }
     /**
      * Register a listener invoked when the pool removes a session (idle sweep or
      * explicit close). httpServer registers one that closes the transport and
      * drops its table entries, keeping both tables consistent (#167). Listeners
      * must not throw; any error is logged and swallowed so one bad listener
-     * cannot abort the removal of others.
+     * cannot abort the removal of others. #530: the listener also receives the reason
+     * (`evicted` for the #167 paths, `orphaned` for the entry-less sweep).
      */
     onSessionEvicted(cb) {
         this.evictionCallbacks.push(cb);
     }
-    fireEviction(sessionId) {
+    fireEviction(sessionId, reason = 'evicted') {
+        this.registered.delete(sessionId); // #530: whatever the path, the session is gone
+        this.inFlight.delete(sessionId); // #530: a late endRequest finds nothing to decrement
         for (const cb of this.evictionCallbacks) {
             try {
-                cb(sessionId);
+                cb(sessionId, reason);
             }
             catch (err) {
                 logger.error(`[ConnectionPool] Eviction listener threw for session ${sessionId} (ignoring):`, err);
@@ -632,6 +698,23 @@ class ActualConnectionPool {
                 await this.shutdownConnection(sessionId, { evict: true, onlyIfExpired: true });
             }
         }
+        // #530: registered sessions with no entry. Walked AFTER the entry evictions (each of
+        // which already dropped its registration) and synchronously: there is no api call to
+        // make, only the transport layer's tables to clear, so the lock is not involved and a
+        // request served in the meantime has already stamped the registration. A session with
+        // a request still in flight is never an orphan, however long that request runs.
+        const orphans = [];
+        for (const [sessionId, lastServed] of this.registered.entries()) {
+            if (!this.connections.has(sessionId) && !this.inFlight.has(sessionId) && this.isPastIdle(lastServed)) {
+                orphans.push(sessionId);
+            }
+        }
+        if (orphans.length > 0) {
+            logger.info(`[ConnectionPool] Reaping ${orphans.length} orphaned sessions (no pool entry, idle for one window)`);
+            for (const sessionId of orphans) {
+                this.fireEviction(sessionId, 'orphaned');
+            }
+        }
     }
     /**
      * Shutdown all connections and stop cleanup timer
@@ -680,6 +763,8 @@ class ActualConnectionPool {
             // otherwise fire once per session at the exact moment the code chose not to take it.
             await teardown(true).catch(() => { });
         });
+        this.registered.clear(); // #530: the transport layer is going down with the pool
+        this.inFlight.clear();
         logger.info('[ConnectionPool] All connections shut down');
     }
     /**

package/dist/src/lib/actual-adapter.js

@@ -2794,19 +2794,116 @@ export async function getSchedules() {
         return Array.isArray(raw) ? raw : [];
     });
 }
+/**
+ * #547: upstream builds a schedule's rule with one `is` condition per field and STRINGIFIES the
+ * value on create (`scheduleModel.fromExternal` in loot-core/src/server/api-models.ts), so an
+ * OMITTED payee or account becomes the literal string "undefined". On update
+ * (`api/schedule-update`) an EXISTING condition takes the raw value and only a MISSING one is
+ * pushed as String(value); the server read back the literal "null" after a clear all the same,
+ * and the layer that stringifies it was not identified, so the strip treats raw null, "null"
+ * and "undefined" alike. None of them can ever equal an id, so the rule never links a
+ * transaction: the schedule shows in the UI and in actual_schedules_get but is inert. Reproduced through the server on 2026-10-13 with
+ * @actual-app/api 26.10.0 on every shape (no payee, no account, neither, payee cleared, account
+ * cleared); the control with both fields linked its import.
+ *
+ * The repair drops the dead condition from the schedule's rule inside the SAME drain as the
+ * schedule write, so the rule is right before the drain's api.sync() and no later reader sees
+ * the inert shape. Only a condition whose value is nullish or one of those two literals is
+ * dropped: if upstream stops emitting it there is nothing to strip and no rule write happens.
+ * A schedule without a payee or an account is a legitimate shape (the UI builds it and the tool
+ * description promises it), so it is repaired rather than refused.
+ *
+ * The rule is read back inside the drain, straight after a raw write (the #493 measurement:
+ * upstream can resolve before the row lands), so the read is a bounded poll with the #489 shape.
+ *
+ * A RAW null value is treated as dead too. Upstream's rule engine would match it ("transactions
+ * with no payee"), but the only way it reaches a schedule rule is through a field the caller sent
+ * as null, and the tool contract says null CLEARS the link. Stripping it enforces that contract;
+ * it never deletes a user-authored condition.
+ */
+const DEAD_SCHEDULE_CONDITION_VALUES = new Set(['undefined', 'null']);
+function isDeadScheduleCondition(cond, fields) {
+    if (!fields.includes(cond?.field))
+        return false;
+    const v = cond.value;
+    return v == null || (typeof v === 'string' && DEAD_SCHEDULE_CONDITION_VALUES.has(v));
+}
+/** Which of the two linkable fields the caller left unset (create) or set to null (update). */
+function unsetScheduleLinkFields(input, mode) {
+    const unset = (field) => (mode === 'create' ? input[field] == null : input[field] === null);
+    return ['payee', 'account'].filter(unset);
+}
+async function stripDeadScheduleConditions(scheduleId, fields, opStartedAt, mode) {
+    if (fields.length === 0)
+        return;
+    const repair = fields.map((f) => `actual_schedules_update { ${f}: null }`).join(' or ');
+    // Every message below avoids the TRANSIENT_ERROR_PATTERNS substrings ("timed out" included):
+    // _shouldDropPoolOnError would otherwise drop the session's connection. Upstream causes stay
+    // in `cause`, never in the text, for the same reason.
+    const tail = mode === 'create'
+        ? `The schedule EXISTS, so do not create it again: repair it with ${repair}, or delete it with actual_schedules_delete.`
+        : `The schedule was updated; retrying ${repair} is safe.`;
+    const failed = (what, err) => new Error(`Schedule "${scheduleId}" was saved, but ${what}, so the ${fields.join(' and ')} condition may not be cleared and the schedule may not link any transaction. ${tail}`, { cause: err });
+    // #494: same cap as the split poll, measured from the start of the operation.
+    const T = config.ACTUAL_OP_TIMEOUT_MS;
+    const deadline = T > 0
+        ? Math.min(Date.now() + SPLIT_VERIFY_TIMEOUT_MS, opStartedAt + Math.floor(T / 2))
+        : Date.now() + SPLIT_VERIFY_TIMEOUT_MS;
+    const boundMs = T > 0 ? Math.min(SPLIT_VERIFY_TIMEOUT_MS, Math.floor(T / 2)) : SPLIT_VERIFY_TIMEOUT_MS;
+    let rule;
+    for (;;) {
+        let rules;
+        try {
+            rules = await withConcurrency(() => retry(() => rawGetRules(), { retries: 2, backoffMs: 200 }));
+        }
+        catch (err) {
+            throw failed('its rule could not be read back', err);
+        }
+        rule = (Array.isArray(rules) ? rules : []).find((r) => (Array.isArray(r?.actions) ? r.actions : []).some((a) => a?.op === 'link-schedule' && a?.value === scheduleId));
+        if (rule)
+            break;
+        if (Date.now() >= deadline) {
+            // Thrown from the callback so the caller sees it (the drain's closing api.sync() still
+            // saves the schedule).
+            throw new Error(`Schedule "${scheduleId}" was saved, but its rule was not visible within ${boundMs}ms, so the ${fields.join(' and ')} ` +
+                `condition could not be cleared and the schedule will not link any transaction. ${tail}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, SPLIT_VERIFY_INTERVAL_MS));
+    }
+    const conditions = Array.isArray(rule.conditions) ? rule.conditions : [];
+    // Review round 1: the rule is in hand, so drop EVERY dead link condition, not only the fields
+    // this call unset. A schedule created before this fix with a payee and no account carries a
+    // dead account condition; the prescribed repair `{ payee: null }` must clear it too, or the
+    // call reports success and the schedule still never links. `fields` only decides whether the
+    // strip runs at all (a name-only update does not reach here) and words the error.
+    const kept = conditions.filter((c) => !isDeadScheduleCondition(c, ['payee', 'account']));
+    if (kept.length === conditions.length)
+        return;
+    try {
+        await withConcurrency(() => retry(() => rawUpdateRule({ ...rule, conditions: kept }), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
+    }
+    catch (err) {
+        throw failed('its rule could not be rewritten', err);
+    }
+}
 export async function createSchedule(schedule) {
     observability.incrementToolCall('actual.schedules.create').catch(() => { });
     return queueWriteOperation(async () => {
+        const opStartedAt = Date.now();
+        const input = (schedule ?? {});
         // Note: rawCreateSchedule(schedule) passes the external schedule object directly.
-        // Do NOT wrap in { schedule: ... } — that would double-nest and break date parsing.
-        const raw = await withConcurrency(() => retry(() => rawCreateSchedule(schedule), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
+        // Do NOT wrap in { schedule: ... }: that would double-nest and break date parsing.
+        const raw = await withConcurrency(() => retry(() => rawCreateSchedule(input), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
         const id = normalizeToId(raw);
+        // #547: an omitted payee or account is stored as a condition that can never match.
+        await stripDeadScheduleConditions(id, unsetScheduleLinkFields(input, 'create'), opStartedAt, 'create');
         return id;
     }, { preservesListings: PRESERVES_ALL_ENTITY_LISTINGS });
 }
 export async function updateSchedule(id, fields, resetNextDate) {
     observability.incrementToolCall('actual.schedules.update').catch(() => { });
     return queueWriteOperation(async () => {
+        const opStartedAt = Date.now();
         // #527: upstream MERGES a partial update, so `amountOp` alone keeps the stored amount and
         // `amount` alone keeps the stored op. Whether the pair fits ('isbetween' takes a
         // { num1, num2 } range, every other op a number) therefore depends on the stored row when
@@ -2829,6 +2926,8 @@ export async function updateSchedule(id, fields, resetNextDate) {
             }
         }
         await withConcurrency(() => retry(() => rawUpdateSchedule(id, patch, resetNextDate), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
+        // #547: a payee or account cleared with null is stored as the literal string "null".
+        await stripDeadScheduleConditions(id, unsetScheduleLinkFields(patch, 'update'), opStartedAt, 'update');
     }, { preservesListings: PRESERVES_ALL_ENTITY_LISTINGS });
 }
 /**

package/dist/src/lib/transportErrorLogger.js

@@ -12,6 +12,7 @@
  * Volume is bounded by ONE per-process window limiter.
  */
 import { createModuleLogger } from './loggerFactory.js';
+import { requestContext } from './requestContext.js';
 const MAX_DETAIL_CODE_POINTS = 200;
 const CUT_CHARS = /[{["'`]/;
 // Control (C0, C1), line/paragraph separators, bidi format characters, and (#535) the
@@ -47,12 +48,42 @@ export function sanitizeTransportErrorDetail(value) {
         s = s ? `${s} ${OMITTED}` : OMITTED;
     return s === '' ? '[no message]' : s;
 }
-/** Fixed-window limiter: first `max` calls per window pass, the rest are counted. */
+function defaultSchedule(fn, delayMs) {
+    setTimeout(fn, delayMs).unref();
+}
+/**
+ * Fixed-window limiter: first `max` calls per window pass, the rest are counted.
+ *
+ * The count is reported by whichever comes first: the next allowed call (it carries
+ * `suppressed` on its own record) or, when `onWindowEnd` is set, a flush scheduled on
+ * the FIRST suppressed call of the window for the window's end (#536: before that a
+ * burst that was the last error ever lost its count). Each path zeroes the count, so
+ * the other finds 0 and reports nothing: never twice. A late flush (busy event loop)
+ * reports whatever accumulated by then, and the next suppression after a flush
+ * schedules a fresh one, so while the process runs a count is delayed at worst. The
+ * default timer is unref'd by design (it must not hold a stdio process open), so a
+ * shutdown inside the window drops the pending count.
+ */
 export function createWindowLimiter(opts) {
     let windowStart = 0;
     let count = 0;
     let suppressed = 0;
     let started = false;
+    let flushPending = false;
+    const schedule = opts.schedule ?? defaultSchedule;
+    const flush = () => {
+        flushPending = false;
+        if (suppressed <= 0)
+            return;
+        const reported = suppressed;
+        suppressed = 0;
+        try {
+            opts.onWindowEnd?.(reported);
+        }
+        catch {
+            // a throwing reporter must not escape the timer callback
+        }
+    };
     return {
         take() {
             const t = opts.now();
@@ -68,12 +99,48 @@ export function createWindowLimiter(opts) {
                 return { allowed: true, suppressed: reported };
             }
             suppressed++;
+            if (opts.onWindowEnd && !flushPending) {
+                flushPending = true;
+                try {
+                    // Clamp to [0, windowMs]: a backward clock step would otherwise grow the
+                    // delay past the window (and past Node's 2^31 ms timer limit, which fires
+                    // after 1 ms and turns the summary into one line per error).
+                    schedule(flush, Math.min(opts.windowMs, Math.max(0, windowStart + opts.windowMs - t)));
+                }
+                catch {
+                    flushPending = false; // a failed schedule must not escape take(); the next suppression retries
+                }
+            }
             return { allowed: false, suppressed: 0 };
         },
     };
 }
+let summaryLog;
+/**
+ * #536: the window-end summary. One constant message, one number, never stdout.
+ * Logged inside `requestContext.exit`: the flush timer inherits the AsyncLocalStorage
+ * store of the request that first hit the limit (ALS propagates through setTimeout),
+ * and `addCorrelation` in src/logger.ts would stamp that one session's ids on an
+ * aggregate that counts errors from every session. Never throws.
+ */
+export function reportSuppressedTransportErrors(suppressed, logger) {
+    try {
+        const log = logger ?? (summaryLog = summaryLog ?? createModuleLogger('TRANSPORT'));
+        requestContext.exit(() => {
+            log.warn('MCP transport errors suppressed', { suppressed });
+        });
+    }
+    catch {
+        // never throw into a timer callback
+    }
+}
 // ONE limiter per process so many HTTP sessions cannot multiply the budget.
-const moduleLimiter = createWindowLimiter({ max: 50, windowMs: 60_000, now: Date.now });
+const moduleLimiter = createWindowLimiter({
+    max: 50,
+    windowMs: 60_000,
+    now: Date.now,
+    onWindowEnd: (n) => reportSuppressedTransportErrors(n),
+});
 function safeErrorName(error) {
     try {
         const name = error?.name;

package/dist/src/server/httpServer.js

@@ -7,7 +7,7 @@ import logger, { resolveRequestId } from '../logger.js';
 import { attachTransportErrorLogger } from '../lib/transportErrorLogger.js';
 import { getLocalIp } from '../utils.js';
 import actualToolsManager from '../actualToolsManager.js';
-import { getConnectionState, connectToActualForSession, shutdownActualForSession, shutdownActual, canAcceptNewSession } from '../actualConnection.js';
+import { getConnectionState, connectToActualForSession, shutdownActualForSession, shutdownActual, canAcceptNewSession, isConnectionPoolEnabled } from '../actualConnection.js';
 import { connectionPool } from '../lib/ActualConnectionPool.js';
 import observability from '../observability.js';
 import config from '../config.js';
@@ -23,6 +23,7 @@ import { parseScopeList } from '../lib/oidc-scopes.js';
 import { budgetAclMiddleware } from '../auth/budget-acl.js';
 import { runAclPreflight } from '../auth/budget-acl-dynamic.js';
 import * as https from 'node:https';
+import { finished } from 'node:stream';
 import * as fs from 'node:fs';
 // AsyncLocalStorage for request context: moved to src/lib/requestContext.ts
 // so adapter code can import it without a circular dependency on httpServer.
@@ -235,8 +236,15 @@ advertisedUrl) {
     // loser would silently get the generic 404, restoring this bug at random.
     const INIT_FAILURE_TTL_MS = 60_000;
     const INIT_FAILURE_MAX = 1000;
+    // #550: the record carries the principal that initiated the session (the same value
+    // recordSessionOwner stores on success) and is served only to that principal. A failed
+    // init records no owner in session-owners.ts, and the POST cause branch runs before the
+    // ownership guard, so without this ANY authenticated principal presenting the id got
+    // the cause reply for 60 s, which contradicts the unknown-id equivalence #529 gives
+    // initialized sessions. Under a static bearer or no auth every caller is the same
+    // principal, so those deployments keep the #438 behaviour unchanged.
     const sessionInitFailures = new Map();
-    const rememberInitFailure = (sid, err) => {
+    const rememberInitFailure = (sid, err, owner) => {
         const now = Date.now();
         for (const [k, v] of sessionInitFailures) {
             if (now - v.at > INIT_FAILURE_TTL_MS)
@@ -250,15 +258,22 @@ advertisedUrl) {
                 break;
             sessionInitFailures.delete(oldest);
         }
-        sessionInitFailures.set(sid, { ...classifyInitFailure(err), at: now });
+        sessionInitFailures.set(sid, { ...classifyInitFailure(err), at: now, owner });
     };
-    /** Peek. Never deletes. Returns undefined once the TTL has elapsed. */
-    const peekInitFailure = (sid) => {
+    /**
+     * Peek. Never deletes. Returns undefined once the TTL has elapsed, and (#550) for a
+     * principal other than the one that initiated the session: the caller then falls
+     * through to the reply an unknown id gets, and the record is neither consumed nor
+     * extended. Strict equality, like sessionOwnerMatches.
+     */
+    const peekInitFailure = (sid, principal) => {
         const rec = sessionInitFailures.get(sid);
         if (!rec)
             return undefined;
         if (Date.now() - rec.at > INIT_FAILURE_TTL_MS)
             return undefined;
+        if (rec.owner !== principal)
+            return undefined;
         return { cause: rec.cause, sentence: rec.sentence };
     };
     // safe fallback if index didn't provide implementedTools
@@ -279,21 +294,27 @@ advertisedUrl) {
     // the matching transport in the same window. This is what keeps the two
     // tables from drifting: no "alive in httpServer, dead in the pool" state, and
     // no transport object left behind for a session the client abandoned.
-    connectionPool.onSessionEvicted((sessionId) => {
+    // #530: the pool also reaps a session it has no entry for (an infra-error drop
+    // recycles the entry without evicting the transport) once it goes one idle
+    // window without a served request, with reason `orphaned`; same teardown. The
+    // body is synchronous on purpose: the pool walks its registrations in one pass.
+    connectionPool.onSessionEvicted(teardownSession);
+    function teardownSession(sessionId, reason) {
         const transport = transports.get(sessionId);
         if (transport) {
             try {
                 transport.close?.();
             }
             catch (err) {
-                logger.debug(`[SESSION] Error closing transport for evicted session ${sessionId} (ignoring): ${err}`);
+                logger.debug(`[SESSION] Error closing transport for ${reason} session ${sessionId} (ignoring): ${err}`);
             }
         }
         transports.delete(sessionId);
         sessionInitPromises.delete(sessionId);
         forgetSessionOwner(sessionId);
-        logger.info(`[SESSION] Transport torn down for evicted session: ${sessionId}`);
-    });
+        connectionPool.forgetSession(sessionId);
+        logger.info(`[SESSION] Transport torn down for ${reason} session: ${sessionId}`);
+    }
     // Authentication middleware
     const authenticateRequest = (req, res) => {
         // OIDC mode: verify the request principal directly rather than inferring auth
@@ -511,6 +532,10 @@ advertisedUrl) {
                             // is already the source of truth for this session's idle clock.
                             recordSessionOwner(sid, sessionOwner);
                             transports.set(sid, transport);
+                            // #530: let the pool time this session even after its entry is recycled.
+                            // Pooling off (USE_CONNECTION_POOL=false) has no sweep, so nothing to register.
+                            if (isConnectionPoolEnabled())
+                                connectionPool.registerSession(sid);
                             logger.info(`[SESSION] Actual connection initialized for session: ${sid}`);
                             resolveInit?.();
                         }
@@ -523,7 +548,7 @@ advertisedUrl) {
                             // cause is known here and discarded, and the client's next request gets
                             // a bare "Session not found" that says nothing about a schema mismatch,
                             // a bad password or an unreachable server.
-                            rememberInitFailure(sid, err);
+                            rememberInitFailure(sid, err, sessionOwner);
                             rejectInit?.(err);
                         }
                         finally {
@@ -595,7 +620,7 @@ advertisedUrl) {
                     // enum-only contract through the very hole left open there.
                     let knownFailure;
                     try {
-                        knownFailure = peekInitFailure(sessionId);
+                        knownFailure = peekInitFailure(sessionId, resolvePrincipal(req));
                     }
                     catch {
                         knownFailure = undefined;
@@ -676,8 +701,18 @@ advertisedUrl) {
                 });
                 return;
             }
-            // Refresh the pool's idle clock for this session (single source of truth, #167).
-            connectionPool.touch(sessionId);
+            // Refresh the pool's idle clock for this session (single source of truth, #167) and
+            // count the request in flight (#530): the orphan sweep must not reap a session whose
+            // own request is still running. The END marker is the response's completion, not a
+            // finally block: with enableJsonResponse `handleRequest` can resolve before the body
+            // is written. `stream.finished` rather than `res.once('close')`: a client that gave
+            // up during the init wait above has ALREADY closed the response, its `close` event
+            // fired before this line ran, and a listener attached now would never run, leaving
+            // the count at one for good (review round 2). `finished` calls back for an
+            // already-closed response too, and once, whether the response completed, errored
+            // or the client went away.
+            connectionPool.beginRequest(sessionId);
+            finished(res, () => connectionPool.endRequest(sessionId));
             // Run in AsyncLocalStorage context so tools and the adapter can access
             // sessionId (pool branch, #134) and allowedBudgets (ACL enforcement, #156).
             const allowedBudgets = req.allowedBudgets;
@@ -734,15 +769,17 @@ advertisedUrl) {
             res.status(400).json({ jsonrpc: '2.0', error: { code: -32000, message: 'No session id' }, id: null });
             return;
         }
-        // Same ownership rule as the POST route, checked before the idle clock is
-        // touched so another principal cannot keep a session alive either. A refusal
-        // reads like an unknown session.
+        // Same ownership rule as the POST route. A refusal reads like an unknown
+        // session. The `transports.has` guard is load bearing: a session whose init
+        // FAILED never had an owner recorded, and under OIDC or a static bearer every
+        // caller has a principal, so without it that session would be refused here
+        // instead of reaching the #438 cause report below. That report is owner-bound
+        // on its own since #550 (the peek takes the principal).
         if (transports.has(sessionId) && !sessionOwnerMatches(sessionId, resolvePrincipal(req))) {
             logger.warn(`[SESSION] Refused a GET for session ${sessionId} from a principal that does not own it`);
             res.status(400).json({ jsonrpc: '2.0', error: { code: -32000, message: 'Transport not ready' }, id: null });
             return;
         }
-        connectionPool.touch(sessionId); // Refresh the pool's idle clock (#167)
         const transport = transports.get(sessionId);
         if (!transport) {
             // #438: same cause, this route's own status and code. The classifier owns no
@@ -763,7 +800,7 @@ advertisedUrl) {
             // NODE_ENV is not production.
             let knownFailure;
             try {
-                knownFailure = peekInitFailure(sessionId);
+                knownFailure = peekInitFailure(sessionId, resolvePrincipal(req));
             }
             catch {
                 knownFailure = undefined;
@@ -780,6 +817,12 @@ advertisedUrl) {
             });
             return;
         }
+        // #529: the idle clock is refreshed only for a session this route will serve,
+        // after the ownership check and the transport lookup, in the same order as
+        // POST. Touching before the lookup let a request that was about to be
+        // answered "Transport not ready" (a pool entry whose transport is gone, or
+        // one still initializing) keep that session alive.
+        connectionPool.touch(sessionId); // Refresh the pool's idle clock (#167)
         await transport.handleRequest(req, res);
     });
     // Quick GET server-info probe used by our test harness (testMcpClient.ts, the

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "actual-mcp-server",
   "displayName": "Actual MCP Server",
-  "version": "0.22.31",
+  "version": "0.22.37",
   "engines": {
     "node": ">=22.0.0",
     "npm": ">=10.0.0"
@@ -30,7 +30,7 @@
     "verify-tools": "npm run build && node scripts/verify-tools.js",
     "check:coverage": "node scripts/list-actual-api-methods.mjs",
     "direct-sync": "node scripts/direct-sync/bank-sync-direct.mjs",
-    "test:unit-js": "node tests/unit/transactions_create.test.js && node tests/unit/transactions_aggregate.test.js && node tests/unit/account_flow_summary.test.js && node tests/unit/recurring_expenses_summary.test.js && node tests/unit/generated_tools.smoke.test.js &&node tests/unit/schema_validation.test.js && node tests/unit/schema_json_openai_compat.test.js && node tests/unit/config_https_validation.test.js && node tests/unit/config_data_dir.test.js && node tests/unit/config_drift.test.js && node tests/unit/port_alignment.test.js && node tests/unit/dockerfile_data_dir_alignment.test.js && node tests/unit/unraid_template_alignment.test.js && node tests/unit/entrypoint_invariants.test.js && node tests/unit/e2e_spec_collection.test.js && node tests/unit/compose_profile_sync.test.js && node tests/unit/advertised_tools_sync.test.js && node tests/unit/new_tool_completeness.test.js && node tests/unit/knip_config.test.js && node tests/unit/readme_stats_sync.test.js && node tests/unit/config_insecure_upstream.test.js && node tests/unit/workflow_release_guards.test.js && node tests/unit/report_train_failure.test.js && node tests/unit/unit_chain_membership.test.js && node tests/unit/api_surface_drift.test.js && node tests/unit/write_effect_audit_staleness.test.js && node tests/unit/write_effect_audit_membership.test.js && node tests/unit/tool_annotations.test.js && node tests/unit/tool_id_schema_drift.test.js && node tests/unit/filter_id_resolution.test.js && node tests/unit/filter_id_tool_wiring.test.js && node tests/unit/api_coverage_baseline.test.js && node tests/unit/train_preflight.test.js && node tests/unit/verify_published_artifacts.test.js && node tests/unit/report_train_stale.test.js && node tests/unit/stdio_framing_check.test.js && node tests/unit/server_info.test.js && node tests/unit/transfers_create.test.js && node tests/unit/bot_target_branch.test.js && node tests/unit/auth_posture.test.js && node tests/unit/auth_posture_wiring.test.js && node tests/unit/auth-acl.test.js && node tests/unit/bug76.test.js && node tests/unit/budgets_setAmount.test.js && node tests/unit/adapter_set_budget_batch.test.js && node tests/unit/budget_updates_batch.test.js && node tests/unit/rules_create.test.js && node tests/unit/adapter_rule_reference_guard.test.js && node tests/unit/rules_create_batch.test.js && node tests/unit/budgets_hold_for_next_month.test.js && node tests/unit/budgets_transfer.test.js && node tests/unit/transactions_uncategorized.test.js && node tests/unit/httpServer_session_init.test.js && node tests/unit/httpServer_session_not_found.test.js && node tests/unit/httpServer_init_failure_report.test.js && node tests/unit/stdio_init_failure_report.test.js && node tests/unit/manual_mcp_client_retry.test.js && node tests/unit/manual_mcp_client_session.test.js && node tests/unit/manual_mcp_client_circuit.test.js && node tests/unit/manual_runner_killswitch.test.js && node tests/unit/adapter_auth_rate_limit.test.js && node tests/unit/adapter_session_reuse.test.js && node tests/unit/retry_classifier.test.js && node tests/unit/adapter_module_surface.test.js && node tests/unit/adapter_nonidempotent_no_retry.test.js && node tests/unit/pool_liveness.test.js && node tests/unit/pool_shutdown_all.test.js && node tests/unit/query_where_operators.test.js && node tests/unit/query_run_validation.test.js && node tests/unit/adapter_with_write_session.test.js && node tests/unit/category_groups_delete.test.js && node tests/unit/rules_delete.test.js && node tests/unit/schedules_delete.test.js && node tests/unit/accounts_delete.test.js && node tests/unit/update_tools_not_found.test.js && node tests/unit/accounts_close.test.js && node tests/unit/accounts_reopen.test.js && node tests/unit/payees_delete.test.js && node tests/unit/payees_merge.test.js && node tests/unit/rules_create_or_update.test.js && node tests/unit/unhandled-rejection.test.js && node tests/unit/rejection-allowlist-purity.test.js && node tests/unit/httpServer_bearer_auth.test.js && node tests/unit/session_ownership.test.js && node tests/unit/httpServer_oidc_audience.test.js && node tests/unit/httpServer_oidc_auth_verification.test.js && node tests/unit/httpServer_oidc_jwks_discovery.test.js && node tests/unit/oidc_resource_identifier.test.js && node tests/unit/httpServer_oidc_resource_metadata.test.js && node tests/unit/oidc_error_cause.test.js && node tests/unit/httpServer_oidc_error_body.test.js && node tests/unit/oidc_token_source.test.js && node tests/unit/config_oidc_assertion_refines.test.js && node tests/unit/httpServer_oidc_assertion_mode.test.js && node tests/unit/httpServer_body_limit.test.js && node tests/unit/httpErrorHandler.test.js && node tests/unit/httpServer_error_handler_wiring.test.js && node tests/unit/httpServer_trust_proxy.test.js && node tests/unit/httpServer_batch_cap.test.js && node tests/unit/dotenv_stdout_quiet.test.js && node tests/unit/httpServer_bind_host.test.js && node tests/unit/adapter_write_pool_cooperation.test.js && node tests/unit/adapter_drain_listing_cache.test.js && node tests/unit/budget_acl_enforcement.test.js && node tests/unit/budget_selection_precondition.test.js && node tests/unit/budget_load_abandonment.test.js && node tests/unit/budget_loader_postcondition.test.js && node tests/unit/budget_loader_import_allowlist.test.js && node tests/unit/budget_import_tracking.test.js && node tests/unit/pool_shutdown_under_lock.test.js && node tests/unit/api_lock_affinity.test.js && node tests/unit/commit_message_closing_keyword.test.js && node tests/unit/write_queue_stranding.test.js && node tests/unit/write_queue_stranded_bound.test.js && node tests/unit/budget_preference_store.test.js && node tests/unit/budget_preference_restore.test.js && node tests/unit/tags_list.test.js && node tests/unit/tags_create.test.js && node tests/unit/tags_update.test.js && node tests/unit/tags_delete.test.js && node tests/unit/notes_get.test.js && node tests/unit/notes_update.test.js && node tests/unit/payees_common_list.test.js && node tests/unit/transactions_update_guard.test.js && node tests/unit/transactions_update_splits.test.js && node tests/unit/transactions_update_split_convert.test.js && node tests/unit/entities_search.test.js && node tests/unit/transactions_import_schema.test.js && node tests/unit/tool_schema_shape.test.js && node tests/unit/zod_error_format.test.js && node tests/unit/transactions_update_batch.test.js && node tests/unit/tool_count_sync.test.js && node tests/unit/stdio_transport.test.js && node tests/unit/stdio_budget_switch.test.js && node tests/unit/logger_structured.test.js && node tests/unit/logger_redaction.test.js && node tests/unit/logger_correlation.test.js && node tests/unit/check_coverage.test.js && node tests/unit/adapter_op_timeout.test.js && node tests/unit/adapter_write_queue_wakeup.test.js && node tests/unit/ci_workflow_guards.test.js && node tests/unit/node_version_guard.test.js && node tests/unit/node_version_drift.test.js && node tests/unit/playwright_version_drift.test.js && node tests/unit/observability_smoke.test.js && node tests/unit/residue_pattern.test.js && node tests/unit/batch_uncategorized_cleanup.test.js && node tests/unit/dual_transport_gate.test.js && node tests/unit/manual_assertions_use_helper.test.js && node tests/unit/server_version_guard.test.js && node tests/unit/server_version_probe_outside_op_timeout.test.js && node tests/unit/payee_rules_reference_filter.test.js && node tests/unit/oidc_metadata_discovery.test.js && node tests/unit/httpServer_oauth_metadata_route.test.js && node tests/unit/httpServer_mcp_info_route.test.js && node tests/unit/residue_sweep_balance_account.test.js && node tests/unit/tool_factory.test.js && node tests/unit/budget_registry_parse.test.js && node tests/unit/preferences_get.test.js && node tests/unit/budgets_export.test.js && node tests/unit/budgets_import.test.js && node tests/unit/budgets_import_syncid.test.js && node tests/unit/budget_acl_dynamic.test.js && node tests/unit/budget_acl_identity_map.test.js && node tests/unit/budget_acl_userinfo.test.js && node tests/unit/acl_e2e_fixture_contract.test.js && node tests/unit/budget_acl_middleware.test.js && node tests/unit/rules_stage.test.js && node tests/unit/oidc_scope_list.test.js && node tests/unit/get_context.test.js && node tests/unit/contributor_docs.test.js && node tests/unit/toolsets.test.js && node tests/unit/toolsets_entrypoint.test.js && node tests/unit/tools_list_size_budget.test.js && node tests/unit/rules_update_schedules_schema.test.js && node tests/unit/schedules_update_amount_guard.test.js && node tests/unit/source_text_helper.test.js && node tests/unit/transport_onerror.test.js && node tests/unit/adapter_transaction_batch_abort.test.js && node tests/unit/transactions_merge_adapter.test.js",
+    "test:unit-js": "node tests/unit/transactions_create.test.js && node tests/unit/transactions_aggregate.test.js && node tests/unit/account_flow_summary.test.js && node tests/unit/recurring_expenses_summary.test.js && node tests/unit/generated_tools.smoke.test.js &&node tests/unit/schema_validation.test.js && node tests/unit/schema_json_openai_compat.test.js && node tests/unit/config_https_validation.test.js && node tests/unit/config_data_dir.test.js && node tests/unit/config_drift.test.js && node tests/unit/port_alignment.test.js && node tests/unit/dockerfile_data_dir_alignment.test.js && node tests/unit/unraid_template_alignment.test.js && node tests/unit/entrypoint_invariants.test.js && node tests/unit/e2e_spec_collection.test.js && node tests/unit/compose_profile_sync.test.js && node tests/unit/advertised_tools_sync.test.js && node tests/unit/new_tool_completeness.test.js && node tests/unit/knip_config.test.js && node tests/unit/readme_stats_sync.test.js && node tests/unit/config_insecure_upstream.test.js && node tests/unit/workflow_release_guards.test.js && node tests/unit/report_train_failure.test.js && node tests/unit/unit_chain_membership.test.js && node tests/unit/api_surface_drift.test.js && node tests/unit/write_effect_audit_staleness.test.js && node tests/unit/write_effect_audit_membership.test.js && node tests/unit/tool_annotations.test.js && node tests/unit/tool_id_schema_drift.test.js && node tests/unit/filter_id_resolution.test.js && node tests/unit/filter_id_tool_wiring.test.js && node tests/unit/api_coverage_baseline.test.js && node tests/unit/train_preflight.test.js && node tests/unit/verify_published_artifacts.test.js && node tests/unit/report_train_stale.test.js && node tests/unit/stdio_framing_check.test.js && node tests/unit/server_info.test.js && node tests/unit/transfers_create.test.js && node tests/unit/bot_target_branch.test.js && node tests/unit/auth_posture.test.js && node tests/unit/auth_posture_wiring.test.js && node tests/unit/auth-acl.test.js && node tests/unit/bug76.test.js && node tests/unit/budgets_setAmount.test.js && node tests/unit/adapter_set_budget_batch.test.js && node tests/unit/budget_updates_batch.test.js && node tests/unit/rules_create.test.js && node tests/unit/adapter_rule_reference_guard.test.js && node tests/unit/rules_create_batch.test.js && node tests/unit/budgets_hold_for_next_month.test.js && node tests/unit/budgets_transfer.test.js && node tests/unit/transactions_uncategorized.test.js && node tests/unit/httpServer_session_init.test.js && node tests/unit/httpServer_session_not_found.test.js && node tests/unit/httpServer_init_failure_report.test.js && node tests/unit/stdio_init_failure_report.test.js && node tests/unit/manual_mcp_client_retry.test.js && node tests/unit/manual_mcp_client_session.test.js && node tests/unit/manual_mcp_client_circuit.test.js && node tests/unit/manual_runner_killswitch.test.js && node tests/unit/adapter_auth_rate_limit.test.js && node tests/unit/adapter_session_reuse.test.js && node tests/unit/retry_classifier.test.js && node tests/unit/adapter_module_surface.test.js && node tests/unit/adapter_nonidempotent_no_retry.test.js && node tests/unit/pool_liveness.test.js && node tests/unit/pool_shutdown_all.test.js && node tests/unit/query_where_operators.test.js && node tests/unit/query_run_validation.test.js && node tests/unit/adapter_with_write_session.test.js && node tests/unit/category_groups_delete.test.js && node tests/unit/rules_delete.test.js && node tests/unit/schedules_delete.test.js && node tests/unit/accounts_delete.test.js && node tests/unit/update_tools_not_found.test.js && node tests/unit/accounts_close.test.js && node tests/unit/accounts_reopen.test.js && node tests/unit/payees_delete.test.js && node tests/unit/payees_merge.test.js && node tests/unit/rules_create_or_update.test.js && node tests/unit/unhandled-rejection.test.js && node tests/unit/rejection-allowlist-purity.test.js && node tests/unit/httpServer_bearer_auth.test.js && node tests/unit/session_ownership.test.js && node tests/unit/httpServer_oidc_audience.test.js && node tests/unit/httpServer_oidc_auth_verification.test.js && node tests/unit/httpServer_oidc_jwks_discovery.test.js && node tests/unit/oidc_resource_identifier.test.js && node tests/unit/httpServer_oidc_resource_metadata.test.js && node tests/unit/oidc_error_cause.test.js && node tests/unit/httpServer_oidc_error_body.test.js && node tests/unit/oidc_token_source.test.js && node tests/unit/config_oidc_assertion_refines.test.js && node tests/unit/httpServer_oidc_assertion_mode.test.js && node tests/unit/httpServer_body_limit.test.js && node tests/unit/httpErrorHandler.test.js && node tests/unit/httpServer_error_handler_wiring.test.js && node tests/unit/httpServer_trust_proxy.test.js && node tests/unit/httpServer_batch_cap.test.js && node tests/unit/dotenv_stdout_quiet.test.js && node tests/unit/httpServer_bind_host.test.js && node tests/unit/adapter_write_pool_cooperation.test.js && node tests/unit/adapter_drain_listing_cache.test.js && node tests/unit/budget_acl_enforcement.test.js && node tests/unit/budget_selection_precondition.test.js && node tests/unit/budget_load_abandonment.test.js && node tests/unit/budget_loader_postcondition.test.js && node tests/unit/budget_loader_import_allowlist.test.js && node tests/unit/budget_import_tracking.test.js && node tests/unit/pool_shutdown_under_lock.test.js && node tests/unit/api_lock_affinity.test.js && node tests/unit/commit_message_closing_keyword.test.js && node tests/unit/write_queue_stranding.test.js && node tests/unit/write_queue_stranded_bound.test.js && node tests/unit/budget_preference_store.test.js && node tests/unit/budget_preference_restore.test.js && node tests/unit/tags_list.test.js && node tests/unit/tags_create.test.js && node tests/unit/tags_update.test.js && node tests/unit/tags_delete.test.js && node tests/unit/notes_get.test.js && node tests/unit/notes_update.test.js && node tests/unit/payees_common_list.test.js && node tests/unit/transactions_update_guard.test.js && node tests/unit/transactions_update_splits.test.js && node tests/unit/transactions_update_split_convert.test.js && node tests/unit/entities_search.test.js && node tests/unit/transactions_import_schema.test.js && node tests/unit/tool_schema_shape.test.js && node tests/unit/zod_error_format.test.js && node tests/unit/transactions_update_batch.test.js && node tests/unit/tool_count_sync.test.js && node tests/unit/stdio_transport.test.js && node tests/unit/stdio_budget_switch.test.js && node tests/unit/logger_structured.test.js && node tests/unit/logger_redaction.test.js && node tests/unit/logger_correlation.test.js && node tests/unit/check_coverage.test.js && node tests/unit/adapter_op_timeout.test.js && node tests/unit/adapter_write_queue_wakeup.test.js && node tests/unit/ci_workflow_guards.test.js && node tests/unit/node_version_guard.test.js && node tests/unit/node_version_drift.test.js && node tests/unit/playwright_version_drift.test.js && node tests/unit/observability_smoke.test.js && node tests/unit/residue_pattern.test.js && node tests/unit/batch_uncategorized_cleanup.test.js && node tests/unit/dual_transport_gate.test.js && node tests/unit/manual_assertions_use_helper.test.js && node tests/unit/server_version_guard.test.js && node tests/unit/server_version_probe_outside_op_timeout.test.js && node tests/unit/payee_rules_reference_filter.test.js && node tests/unit/oidc_metadata_discovery.test.js && node tests/unit/httpServer_oauth_metadata_route.test.js && node tests/unit/httpServer_mcp_info_route.test.js && node tests/unit/residue_sweep_balance_account.test.js && node tests/unit/tool_factory.test.js && node tests/unit/budget_registry_parse.test.js && node tests/unit/preferences_get.test.js && node tests/unit/budgets_export.test.js && node tests/unit/budgets_import.test.js && node tests/unit/budgets_import_syncid.test.js && node tests/unit/budget_acl_dynamic.test.js && node tests/unit/budget_acl_identity_map.test.js && node tests/unit/budget_acl_userinfo.test.js && node tests/unit/acl_e2e_fixture_contract.test.js && node tests/unit/budget_acl_middleware.test.js && node tests/unit/rules_stage.test.js && node tests/unit/oidc_scope_list.test.js && node tests/unit/get_context.test.js && node tests/unit/contributor_docs.test.js && node tests/unit/toolsets.test.js && node tests/unit/toolsets_entrypoint.test.js && node tests/unit/tools_list_size_budget.test.js && node tests/unit/rules_update_schedules_schema.test.js && node tests/unit/schedules_update_amount_guard.test.js && node tests/unit/source_text_helper.test.js && node tests/unit/transport_onerror.test.js && node tests/unit/adapter_transaction_batch_abort.test.js && node tests/unit/transactions_merge_adapter.test.js && node tests/unit/schedules_dead_conditions.test.js && node tests/unit/session_ownership_express.test.js && node tests/unit/pool_orphan_sweep.test.js && node tests/unit/budget_acl_parse.test.js",
     "test:adapter": "npm run build && node dist/src/tests_adapter_runner.js",
     "test:e2e": "npx playwright test",
     "test:e2e:docker": "./tests/e2e/run-docker-e2e.sh",