actual-mcp-server 0.22.31 → 0.22.40

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.40 | **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/actualToolsManager.js

@@ -1,6 +1,7 @@
 // src/actualToolsManager.ts
 import logger from './logger.js';
 import { formatZodError } from './lib/zod-error-format.js';
+import { errorLogFields } from './lib/errors.js';
 import config from './config.js';
 import { createModuleLogger } from './lib/loggerFactory.js';
 import { resolvePublishedToolNames, unavailableError } from './lib/toolsets.js';
@@ -211,26 +212,39 @@ class ActualToolsManager {
             toolsetLog.warn('Refused a call to an unpublished tool', { tool: name, setting: unavailable.setting });
             throw unavailable;
         }
+        const startTime = Date.now();
         try {
             const result = await tool.call(args);
             // Force-serialize/deserialize to ensure result is JSON-safe (no circular refs,
             // Buffers, class instances, etc). Convert undefined -> null so callers always
             // receive a valid JSON value.
-            const safe = result === undefined ? null : JSON.parse(JSON.stringify(result));
-            logger.info(`[TOOL RESULT] ${name}: ${JSON.stringify(safe)}`);
+            const json = JSON.stringify(result === undefined ? null : result);
+            const safe = JSON.parse(json);
+            // Content-free by design (#556): tool arguments and results are the user's budget
+            // data and never reach the logs. This record is the one place content COULD be
+            // logged, so an opt-in for debugging (#557) belongs here and nowhere else.
+            // `durationMs`, not `ms`: the logger reserves a top-level `ms` key (src/logger.ts).
+            logger.info('[TOOL RESULT]', { tool: name, durationMs: Date.now() - startTime, outcome: 'ok', bytes: Buffer.byteLength(json, 'utf8') });
             return safe;
         }
         catch (err) {
             // Format Zod validation errors into one actionable, consistent message (#206).
             // Duck-type on `.issues` so any structurally-compatible ZodError is handled.
+            // The failure record mirrors the success one (#556): tool, duration and outcome,
+            // never the arguments. It never carries the error MESSAGE either (#559): that text
+            // is for the client and can quote input or upstream content. errorLogFields gives
+            // the class, a refusal's kind, and the throw site's withLogMessage text if any.
+            const failure = { tool: name, durationMs: Date.now() - startTime, outcome: 'error' };
             if (err && typeof err === 'object' && 'issues' in err) {
                 const formattedMsg = formatZodError(err, tool.inputSchema);
-                logger.error(`[TOOL ERROR] ${name}: ${formattedMsg}`);
+                // The #206 text is for the client only: a schema's custom refine message can quote
+                // input (transactions_create echoes the split amounts), so the log gets the issue
+                // codes, which come from Zod and never from the arguments.
+                const issueCodes = [...new Set((err.issues ?? []).map((i) => String(i?.code)))];
+                logger.error(`[TOOL ERROR] ${name}`, { ...failure, errorClass: 'ZodError', issueCodes });
                 throw new Error(formattedMsg);
             }
-            const e = err;
-            const msg = e && typeof e.message === 'string' ? e.message : String(err);
-            logger.error(`[TOOL ERROR] ${name}: ${msg}`);
+            logger.error(`[TOOL ERROR] ${name}`, { ...failure, ...errorLogFields(err) });
             throw err;
         }
     }

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

@@ -13,7 +13,7 @@ import observability from '../observability.js';
 import { retry, isRetryableError, isRateLimitError } from './retry.js';
 import { withOpTimeout } from './opTimeout.js';
 import { markInitFailure } from './init-failure.js';
-import { NotFoundRefusal, OutOfRangeRefusal, constraintErrorMsg } from './errors.js';
+import { NotFoundRefusal, OutOfRangeRefusal, constraintErrorMsg, errorLogFields } from './errors.js';
 import { amountOpMismatch } from './schemas/schedule-amount.js';
 import { findMatchingRule } from './rule-matching.js';
 import logger from '../logger.js';
@@ -1198,7 +1198,9 @@ async function processWriteQueue() {
                             resolve(result);
                         }
                         catch (error) {
-                            logger.error('[WRITE QUEUE] Operation failed:', error);
+                            // Class and log-safe text only (#559): a refusal names the id the caller sent
+                            // (which can be a name, #388), and upstream text can quote the written values.
+                            logger.error('[WRITE QUEUE] Operation failed', errorLogFields(error));
                             // #419: remember an infrastructure-level failure so the batch-end
                             // shutdown self-heals (see drainForceFullShutdown above).
                             if (_shouldDropPoolOnError(error))
@@ -1656,7 +1658,8 @@ export async function createCategory(category) {
             return normalizeToId(raw);
         }
         catch (error) {
-            logger.error('[CREATE CATEGORY] Error creating category:', error);
+            // Upstream's message quotes the category name (#559), so the log gets the class only.
+            logger.error('[CREATE CATEGORY] Error creating category', errorLogFields(error));
             // Re-throw the error with proper context
             if (error instanceof Error) {
                 throw error;
@@ -2672,7 +2675,8 @@ export async function updateRule(id, fields) {
         // omitted conditions or actions takes the stored value, which contributes no new refs.
         const addedRefs = newRuleReferences(rule, existingRule);
         assertRuleReferencesExist(addedRefs, await loadRuleReferenceListings(addedRefs), RULE_REFUSAL_CHANGED);
-        logger.debug(`[UPDATE RULE] Updating rule ${id} with merged fields: ${JSON.stringify(rule)}`);
+        // Rule id only: conditions and actions carry payee ids, notes and amounts (#556).
+        logger.debug(`[UPDATE RULE] Updating rule ${id}`);
         await withConcurrency(() => retry(() => rawUpdateRule(rule), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
         logger.debug(`[UPDATE RULE] Update completed for rule ${id}`);
     }, { preservesListings: PRESERVES_ALL_ENTITY_LISTINGS });
@@ -2794,19 +2798,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 +2930,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 });
 }
 /**
@@ -3343,7 +3446,7 @@ export async function runQuery(queryString) {
                             catch (err) {
                                 // Catch errors from the query execution to prevent unhandled rejections
                                 const msg = err?.message || String(err);
-                                logger.error(`[ADAPTER] Query execution error: ${msg}`);
+                                logger.error('[ADAPTER] Query execution error', errorLogFields(err)); // #559: msg can quote the query
                                 if (msg.includes('does not exist in table') || msg.includes('Field') || msg.includes('does not exist')) {
                                     throw new Error(`Invalid field in query: ${msg}`);
                                 }
@@ -3451,7 +3554,7 @@ export async function runQuery(queryString) {
                         catch (err) {
                             // Catch errors from the query execution to prevent unhandled rejections
                             const msg = err?.message || String(err);
-                            logger.error(`[ADAPTER] Query execution error: ${msg}`);
+                            logger.error('[ADAPTER] Query execution error', errorLogFields(err)); // #559: msg can quote the query
                             if (msg.includes('does not exist in table') || msg.includes('Field') || msg.includes('does not exist')) {
                                 throw new Error(`Invalid field in query: ${msg}`);
                             }
@@ -3486,7 +3589,8 @@ export async function runQuery(queryString) {
     catch (error) {
         // Top-level catch to ensure no unhandled rejections escape
         const errorMsg = error?.message || String(error);
-        logger.error(`[ADAPTER] Query execution failed: ${errorMsg}`);
+        // The message can embed the whole query (#559); the client still receives it below.
+        logger.error('[ADAPTER] Query execution failed', errorLogFields(error));
         // If the error already contains formatted validation errors with suggestions, preserve them
         if (errorMsg.includes('Invalid SQL query:') && (errorMsg.includes('Available fields:') || errorMsg.includes('Available tables:'))) {
             throw error; // Re-throw the well-formatted validation error without wrapping

package/dist/src/lib/errors.js

@@ -148,3 +148,28 @@ export function constraintErrorMsg(entityType, id, listTool) {
     return `Failed to delete ${entityType.toLowerCase()} "${id}". ` +
         `It may be referenced by other records. Use ${listTool} to verify it exists.`;
 }
+/**
+ * Log-safe error text (#559). An error's MESSAGE is for the client and may quote what the
+ * caller sent: a category name, a query, a rule value, or upstream text we do not control.
+ * The server never logs it. `withLogMessage` attaches a separate, content-free sentence
+ * that the `[TOOL ERROR]` record may log instead; set it where the error is thrown, and
+ * keep anything the caller supplied out of it.
+ */
+const LOG_MESSAGE = Symbol.for('actual-mcp-server.logMessage');
+export function withLogMessage(error, logMessage) {
+    Object.defineProperty(error, LOG_MESSAGE, { value: logMessage, enumerable: false });
+    return error;
+}
+export function errorLogFields(error) {
+    const errorClass = error instanceof Error ? (Object.getPrototypeOf(error)?.constructor?.name || 'Error') : error === null ? 'null' : typeof error;
+    const fields = { errorClass };
+    if (isPreflightRefusal(error))
+        fields.refusalKind = error.refusalKind;
+    const code = typeof error === 'object' && error !== null ? error.code : undefined;
+    if (typeof code === 'string' && /^E[A-Z0-9_]{1,40}$/.test(code))
+        fields.code = code;
+    const logMessage = typeof error === 'object' && error !== null ? error[LOG_MESSAGE] : undefined;
+    if (typeof logMessage === 'string')
+        fields.logMessage = logMessage;
+    return fields;
+}

package/dist/src/lib/retry.js

@@ -1,5 +1,6 @@
 import { DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MS, MAX_RETRY_DELAY_MS } from './constants.js';
 import { ModuleLoggers } from './loggerFactory.js';
+import { errorLogFields } from './errors.js';
 const log = ModuleLoggers.RETRY;
 /**
  * Error-message fragments that mark a TRANSIENT / infrastructure-level failure:
@@ -92,16 +93,16 @@ export async function retry(fn, opts) {
             // (#177). With no classifier, behaviour is unchanged (retry until the
             // attempt budget is exhausted), preserving every existing call site.
             if (isRetryable && !isRetryable(err)) {
-                log.debug('Not retrying non-transient error', { error: err?.message });
+                log.debug('Not retrying non-transient error', errorLogFields(err));
                 throw err;
             }
             attempt++;
             if (attempt > retries) {
-                log.error(`All retry attempts exhausted after ${retries} tries`, err);
+                log.error(`All retry attempts exhausted after ${retries} tries`, undefined, errorLogFields(err));
                 throw err;
             }
             const delay = Math.min(backoffMs * Math.pow(2, attempt - 1), MAX_RETRY_DELAY_MS);
-            log.debug(`Retry attempt ${attempt}/${retries} after ${delay}ms`, { error: err.message });
+            log.debug(`Retry attempt ${attempt}/${retries} after ${delay}ms`, errorLogFields(err));
             await new Promise(r => setTimeout(r, delay));
         }
     }

package/dist/src/lib/toolFactory.js

@@ -14,6 +14,7 @@
  */
 import { createModuleLogger } from './loggerFactory.js';
 import observability from '../observability.js';
+import { errorLogFields } from './errors.js';
 const log = createModuleLogger('TOOLS');
 /**
  * Create a tool definition with automatic error handling and logging
@@ -54,23 +55,24 @@ export function createTool(config) {
         call: async (args, meta) => {
             const startTime = Date.now();
             try {
+                // No args, input or result in these records (#556): they are budget data.
                 // Validate input against schema
-                log.debug(`Validating input for ${name}`, { args });
+                log.debug(`Validating input for ${name}`);
                 const input = schema.parse(args || {});
                 // Execute handler
-                log.debug(`Executing ${name}`, { input });
+                log.debug(`Executing ${name}`);
                 const result = await handler(input, meta);
                 // Log success
                 const duration = Date.now() - startTime;
-                log.debug(`${name} completed in ${duration}ms`, { result });
+                log.debug(`${name} completed in ${duration}ms`);
                 // Track observability
                 await observability.incrementToolCall(name);
                 return { result };
             }
             catch (error) {
-                // Log error with details
+                // Class and log-safe text only (#559): the message and stack can quote input.
                 const duration = Date.now() - startTime;
-                log.error(`${name} failed after ${duration}ms`, error, { args });
+                log.error(`${name} failed after ${duration}ms`, undefined, { tool: name, durationMs: duration, outcome: 'error', ...errorLogFields(error) });
                 // Track observability (still increment even on failure)
                 await observability.incrementToolCall(name);
                 // Re-throw for MCP error handling

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
@@ -382,7 +403,8 @@ advertisedUrl) {
                 throw new Error('Tool name must be a string');
             }
             const name = rawName;
-            logger.debug(`[TOOL CALL] ${name} args=${JSON.stringify(args)}`);
+            // Tool name only: arguments are budget data and never reach the logs (#556).
+            logger.debug(`[TOOL CALL] ${name}`);
             // Prefer ActualMCPConnection executor if provided
             if (typeof mcp.executeTool === 'function') {
                 const result = await mcp.executeTool(name, args ?? {});
@@ -511,6 +533,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 +549,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 +621,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 +702,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 +770,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 +801,7 @@ advertisedUrl) {
             // NODE_ENV is not production.
             let knownFailure;
             try {
-                knownFailure = peekInitFailure(sessionId);
+                knownFailure = peekInitFailure(sessionId, resolvePrincipal(req));
             }
             catch {
                 knownFailure = undefined;
@@ -780,6 +818,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/dist/src/tools/categories_create.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import adapter from '../lib/actual-adapter.js';
 import { CommonSchemas } from '../lib/schemas/common.js';
+import { withLogMessage } from '../lib/errors.js';
 const InputSchema = z.object({
     name: CommonSchemas.name,
     group_id: CommonSchemas.categoryGroupId,
@@ -36,7 +37,8 @@ const tool = {
                 throw new Error(`Failed to create category: Invalid or missing group_id. Use actual_category_groups_get to get available category groups first.`);
             }
             if (errorMessage.includes('already exists') || errorMessage.includes('duplicate')) {
-                throw new Error(`Failed to create category: A category named "${input.name}" already exists in this group.`);
+                // The client needs the name; the log gets content-free text (#559).
+                throw withLogMessage(new Error(`Failed to create category: A category named "${input.name}" already exists in this group.`), 'category name already exists in this group');
             }
             throw new Error(`Failed to create category: ${errorMessage}`);
         }

package/dist/src/tools/query_run.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import adapter from '../lib/actual-adapter.js';
 import { validateQueryShape } from '../lib/query-validator.js';
+import { errorLogFields, withLogMessage } from '../lib/errors.js';
 const InputSchema = z.object({
     query: z.string().min(1).describe('ActualQL query string to execute'),
 });
@@ -27,7 +28,8 @@ Tables:
             const input = InputSchema.parse(args || {});
             // Detect and reject GraphQL-like syntax with nested objects
             if (input.query.trim().startsWith('query ') && input.query.includes('{') && input.query.includes('}')) {
-                throw new Error(`GraphQL syntax is not fully supported. Please use SQL instead.\n\nExample: SELECT id, date, amount, payee.name, category.name FROM transactions ORDER BY date DESC LIMIT 5\n\nYour query attempted: ${input.query.substring(0, 100)}...`);
+                // The client sees its own query echoed; the log gets content-free text (#559).
+                throw withLogMessage(new Error(`GraphQL syntax is not fully supported. Please use SQL instead.\n\nExample: SELECT id, date, amount, payee.name, category.name FROM transactions ORDER BY date DESC LIMIT 5\n\nYour query attempted: ${input.query.substring(0, 100)}...`), 'GraphQL-style query rejected');
             }
             // Read-only shape gate (#162): reject writes / schema changes / stacked
             // statements before the query reaches the q() builder. Throws on violation.
@@ -38,21 +40,24 @@ Tables:
         catch (error) {
             // Provide helpful error messages
             const errorMessage = error?.message || String(error);
+            // Each rewrap keeps the original's log-safe text (#559), e.g. the GraphQL rejection above.
+            const logSafe = errorLogFields(error).logMessage;
+            const carry = (e) => (logSafe ? withLogMessage(e, logSafe) : e);
             // Check if error is about payee_name, category_name, account_name
             if (errorMessage.includes('payee_name') || errorMessage.includes('category_name') || errorMessage.includes('account_name')) {
-                throw new Error(`Field name error: Use dot notation for joins.\n• Use payee.name (NOT payee_name)\n• Use category.name (NOT category_name)\n• Use account.name (NOT account_name)\n\nExample: SELECT id, date, amount, payee.name FROM transactions LIMIT 5\n\nOriginal error: ${errorMessage}`);
+                throw carry(new Error(`Field name error: Use dot notation for joins.\n• Use payee.name (NOT payee_name)\n• Use category.name (NOT category_name)\n• Use account.name (NOT account_name)\n\nExample: SELECT id, date, amount, payee.name FROM transactions LIMIT 5\n\nOriginal error: ${errorMessage}`));
             }
             if (errorMessage.includes('does not exist in the schema')) {
-                throw new Error(`Invalid table or field name. Available tables: transactions, accounts, categories, payees, category_groups, schedules, rules. Use dot notation for joins (e.g., category.name). Original error: ${errorMessage}`);
+                throw carry(new Error(`Invalid table or field name. Available tables: transactions, accounts, categories, payees, category_groups, schedules, rules. Use dot notation for joins (e.g., category.name). Original error: ${errorMessage}`));
             }
             else if (errorMessage.includes('ActualQL query builder not available')) {
-                throw new Error('ActualQL query builder is not available. The Actual Budget API may not be properly initialized.');
+                throw carry(new Error('ActualQL query builder is not available. The Actual Budget API may not be properly initialized.'));
             }
             else if (errorMessage.includes('parse') || errorMessage.includes('syntax')) {
-                throw new Error(`Query syntax error: ${errorMessage}\n\nRecommended: Use SQL syntax\nExample: SELECT * FROM transactions ORDER BY date DESC LIMIT 5\n\nSee the tool description for the supported WHERE operators and join syntax.`);
+                throw carry(new Error(`Query syntax error: ${errorMessage}\n\nRecommended: Use SQL syntax\nExample: SELECT * FROM transactions ORDER BY date DESC LIMIT 5\n\nSee the tool description for the supported WHERE operators and join syntax.`));
             }
             else {
-                throw new Error(`Query execution failed: ${errorMessage}`);
+                throw carry(new Error(`Query execution failed: ${errorMessage}`));
             }
         }
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "actual-mcp-server",
   "displayName": "Actual MCP Server",
-  "version": "0.22.31",
+  "version": "0.22.40",
   "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/tool_content_logging.test.js && node tests/unit/adapter_error_logging.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",