actual-mcp-server 0.22.18 → 0.22.20

package/README.md

@@ -835,7 +835,7 @@ The software is provided **as-is**, without warranty of any kind. The author acc
 
 ---
 
-**Version:** 0.22.18 | **Tool Count:** 83 (verified LibreChat-compatible)
+**Version:** 0.22.20 | **Tool Count:** 83 (verified LibreChat-compatible)
 
 ## Sponsor
 

package/dist/src/actualToolsManager.js

@@ -185,9 +185,6 @@ class ActualToolsManager {
     getPublishedToolNames() {
         return [...this.requirePolicy().published];
     }
-    isPublished(name) {
-        return !this.requirePolicy().hidden.has(name) && this.tools.has(name);
-    }
     /** The resolved MCP_TOOLSETS / MCP_TOOLS / MCP_READ_ONLY, for server_info. */
     getToolPolicy() {
         const { toolsets, tools, readOnly } = this.requirePolicy().settings;

package/dist/src/index.js

@@ -9,6 +9,7 @@ import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { isKnownBenignRejection } from './lib/rejection-allowlist.js';
+import { format } from 'node:util';
 /**
  * #277: the single version reader for this module.
  *
@@ -89,6 +90,26 @@ const argsEarly = process.argv.slice(2);
 if (argsEarly.includes('--stdio')) {
     process.env.MCP_STDIO_MODE = 'true';
 }
+// #502: the pre-logger stdio chokepoint. Under --stdio, stdout is the JSON-RPC channel, but
+// anything that calls console.log before src/logger.ts loads reaches the real stdout:
+// @dabh/diagnostics (during winston.createLogger, when DEBUG/DIAGNOSTICS is set and NODE_ENV
+// is not production) and potentially dotenv. src/logger.ts wireConsoleAndDebug() replaces
+// these methods once the logger loads, exactly as before. This is installed under --stdio
+// only, so HTTP stdout behaviour is unchanged. It writes straight to process.stderr, so
+// there is no recursion risk. Output in this window bypasses the #220 redaction (as it
+// already did), which is acceptable only because everything printed here is static (the
+// debug notice, winston level names; dotenv is pinned quiet and debug false). A future
+// pre-logger print of dynamic data is a redaction concern.
+function installPreLoggerStderrConsole() {
+    const toStderr = (...args) => {
+        process.stderr.write(format(...args) + '\n');
+    };
+    console.log = toStderr;
+    console.info = toStderr;
+    console.debug = toStderr;
+    console.warn = toStderr;
+    console.error = toStderr;
+}
 // Only load dotenv if we're not just showing help
 // dotenv will be loaded inside the async IIFE below via dynamic import
 // to avoid using require() in ESM and to keep the early --help fast exit.
@@ -141,6 +162,8 @@ Docs & source: https://github.com/agigante80/actual-mcp-server`);
     process.exit(0);
 }
 (async () => {
+    if (argsEarly.includes('--stdio'))
+        installPreLoggerStderrConsole();
     // Load dotenv here (dynamic import) only when not running with --help
     if (!argsEarly.includes('--help')) {
         const dotenv = await import('dotenv');
@@ -171,7 +194,7 @@ Docs & source: https://github.com/agigante80/actual-mcp-server`);
         process.env.LOG_LEVEL = process.env.LOG_LEVEL || 'debug';
         // optional flag your code can check for even more verbose transport logging
         process.env.MCP_BRIDGE_DEBUG_TRANSPORT = 'true';
-        console.log('Debug mode enabled: DEBUG=* LOG_LEVEL=debug');
+        process.stderr.write('Debug mode enabled: DEBUG=* LOG_LEVEL=debug\n');
     }
     // dynamic imports to avoid running side effects on module import
     const [{ connectToActual }, { ActualMCPConnection }] = await Promise.all([

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

@@ -307,6 +307,32 @@ export function _shouldKeepSingletonAlive(activeSessions, forceFullShutdown) {
 function _shouldDropPoolOnError(err) {
     return isRetryableError(err) && !isRateLimitError(err);
 }
+/**
+ * The ONE rule for batch paths that catch per item (updateTransactionBatch, createRulesBatch,
+ * setBudgetBatch). INFRASTRUCTURE ERRORS STOP THE BATCH: when `_shouldDropPoolOnError` matches,
+ * this throws and the remaining items are never sent; otherwise it returns and the caller
+ * records the per-item failure and continues. Rate limits are not pool-drop errors, so they
+ * stay per item.
+ *
+ * The original error text is kept inside the message so `isRetryableError` (message-only) still
+ * classifies the wrapper, and `{ cause }` keeps the original error. The throw surfaces as a
+ * whole-call failure out of queueWriteOperation, which on the LEGACY path sets
+ * drainForceFullShutdown (full teardown). On the POOLED path the entry is dropped only if the
+ * drain's following `api.sync()` also fails with a pool-drop error. The trailing sync still runs
+ * on both paths and pushes the applied items, which is why the message tells the caller to read
+ * back instead of claiming a committed state.
+ *
+ * Per item this is realistically reached only by `out of memory` / `ENOMEM`: the raw update
+ * calls are LOCAL writes and the upstream sync is debounced, so a network error surfaces at the
+ * trailing sync rather than here (#521 premise). Do not re-litigate that; the guard is a
+ * defensive consistency rule shared by all three batch paths.
+ */
+function abortBatchOnInfrastructureError(error, ctx) {
+    if (!_shouldDropPoolOnError(error))
+        return;
+    throw new Error(`${ctx.label} batch aborted after ${ctx.appliedCount} of ${ctx.total} items (applied: ${ctx.applied || 'none'}${ctx.extra ? '; ' + ctx.extra : ''}): ${ctx.message}. ` +
+        `Read back with ${ctx.readBackTool} before retrying.`, { cause: error });
+}
 /**
  * Enforce per-request budget ACL before any pool branching or lock acquisition.
  *
@@ -1842,6 +1868,28 @@ export async function setBudgetAmount(month, categoryId, amount) {
         return result;
     }, { preservesListings: ['accounts', 'categories', 'categoryGroups', 'payees'] });
 }
+/**
+ * Budget transfer between two categories within a single month.
+ *
+ * Reads the current budget amounts, validates source-side sufficient funds,
+ * and writes both adjustments inside ONE `queueWriteOperation` cycle. This
+ * is the structural fix for issue #141: the previous tool body did three
+ * separate lock cycles (read + write + write) which could hang for the
+ * full Playwright timeout when the upstream server's mutator queue stalled
+ * between cycles. The month read and the funds check run before either write.
+ *
+ * NOT atomic and no rollback (#518). Both writes run inside
+ * `rawBatchBudgetUpdates`, upstream's `batch-budget-start` /
+ * `batch-budget-end` bracket around `batchMessages`, which batches sync
+ * messages; it is not a database transaction. If the second write fails, the
+ * first stays applied, so a partial transfer is possible. A returned result
+ * means both writes were queued, not that both landed: `batch-budget-start`
+ * runs `batchMessages` un-awaited and `batch-budget-end` returns before the
+ * queued messages are applied, so a later apply failure is a detached
+ * rejection that is never returned to the caller (#539). The upstream trace is the
+ * `actual_budget_updates_batch` row of `docs/audit/write-effect-audit.md`,
+ * which shares this bracket (#516).
+ */
 export async function transferBudgetAmount(month, fromCategoryId, toCategoryId, amount) {
     observability.incrementToolCall('actual.budgets.transfer').catch(() => { });
     return queueWriteOperation(async () => {
@@ -2064,7 +2112,7 @@ export async function updateTransactionBatch(updates) {
         }, { retries: 2, backoffMs: 200 }));
         const succeeded = [];
         const failed = [];
-        for (const { id, fields } of updates) {
+        for (const [position, { id, fields }] of updates.entries()) {
             if (!existing.has(id)) {
                 failed.push({ id, error: `Transaction "${id}" not found. Use actual_transactions_get to list transactions.` });
                 continue;
@@ -2075,6 +2123,18 @@ export async function updateTransactionBatch(updates) {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
+                // Infrastructure errors stop the batch (see abortBatchOnInfrastructureError). The
+                // failing item's state is UNKNOWN (an ENOMEM can land after the local write ran);
+                // items after it were never sent.
+                abortBatchOnInfrastructureError(err, {
+                    label: 'Transaction',
+                    appliedCount: succeeded.length,
+                    total: updates.length,
+                    applied: succeeded.map((x) => x.id).join(', '),
+                    extra: `failed before the abort: ${failed.map((x) => x.id).join(', ') || 'none'}; outcome unknown: ${id}; not attempted: ${updates.length - position - 1}`,
+                    message,
+                    readBackTool: 'actual_transactions_get',
+                });
                 failed.push({ id, error: message });
             }
         }
@@ -2168,6 +2228,14 @@ export async function updatePayee(id, fields) {
             const { category: _stripped, ...rest } = fieldsObj;
             directFields = rest;
         }
+        // #522: an explicitly set category is checked BEFORE the direct-field write, so a refused
+        // category writes nothing at all (not even the name). null clears the rule and an absent key
+        // skips this. A hidden category passes (the listing includes it); a category GROUP id is
+        // refused as a missing Category. Same pipeline as the rule writes.
+        if (typeof categoryValue === 'string') {
+            const categoryRefs = [{ side: 'action', field: 'category', id: categoryValue }];
+            assertRuleReferencesExist(categoryRefs, await loadRuleReferenceListings(categoryRefs), RULE_REFUSAL_CHANGED);
+        }
         // Update the payee's direct fields (name, transfer_acct, etc.)
         if (Object.keys(directFields).length > 0) {
             await withConcurrency(() => retry(() => rawUpdatePayee(id, directFields), { retries: 2, backoffMs: 200, isRetryable: isRetryableError }));
@@ -2250,43 +2318,74 @@ const RULE_REFERENCE_FIELDS = {
     payee: { entity: 'Payee', listTool: 'actual_payees_get' },
     account: { entity: 'Account', listTool: 'actual_accounts_get' },
 };
-/** Every (field, id) pair a rule points at. Null, undefined and non-string values are skipped (a null `set category` clears it). */
+/**
+ * Condition operators whose value is an entity id (or an array of ids). `and` is upstream's
+ * INTERNAL op for `category` and `category_group` (shared/rules.ts `internalOps`), parsed like
+ * `oneOf`, so leaving it out would narrow what #485 already guarded. The text ops (`contains`,
+ * `matches`, `doesNotContain`) compare text and `onBudget` / `offBudget` carry no id: they are
+ * skipped and must never be refused.
+ */
+const RULE_ID_CONDITION_OPS = new Set(['is', 'isNot', 'oneOf', 'notOneOf', 'and']);
+/** Refusal suffixes, one per write path, so no call site can inherit text that is false for it (#524 item 6). */
+const RULE_REFUSAL_CREATED = 'Nothing was created.';
+const RULE_REFUSAL_CHANGED = 'Nothing was changed.';
+const RULE_REFUSAL_BATCH_ITEM = 'This rule was not created.';
+/**
+ * Every id a rule points at. Null, undefined and non-string values are skipped (a null
+ * `set category` clears it). Conditions count only for an id operator (RULE_ID_CONDITION_OPS).
+ * Actions count only for `set`, and not when `options.template` is TRUTHY: upstream compiles a
+ * truthy template as Handlebars and does not use the value as an id (server/rules/action.ts,
+ * `if (options?.template)`), while an empty or absent template applies the plain value as the
+ * id. Do NOT test with `!== undefined` or `'template' in options`.
+ * The field filter uses `Object.hasOwn`, not `in`: a field named `toString` is on the prototype.
+ */
 function ruleReferences(rule) {
     const out = [];
     const r = (rule ?? {});
-    const add = (field, value) => {
-        if (typeof field !== 'string' || !(field in RULE_REFERENCE_FIELDS))
+    const add = (side, field, value) => {
+        if (typeof field !== 'string' || !Object.hasOwn(RULE_REFERENCE_FIELDS, field))
             return;
         const values = Array.isArray(value) ? value : [value];
         for (const v of values)
             if (typeof v === 'string')
-                out.push({ field: field, id: v });
+                out.push({ side, field: field, id: v });
     };
     if (Array.isArray(r.conditions)) {
-        for (const c of r.conditions)
-            add(c?.field, c?.value);
+        for (const c of r.conditions) {
+            if (typeof c?.op === 'string' && RULE_ID_CONDITION_OPS.has(c.op))
+                add('condition', c?.field, c?.value);
+        }
     }
     if (Array.isArray(r.actions)) {
         for (const a of r.actions) {
-            if (a?.op === 'set')
-                add(a?.field, a?.value);
+            if (a?.op === 'set' && !a?.options?.template)
+                add('action', a?.field, a?.value);
         }
     }
     return out;
 }
+const ruleRefKey = (ref) => `${ref.side}|${ref.field}|${ref.id}`;
 /**
- * #485: read the listings the given rules need, once per kind, through the drain cache. Call
- * INSIDE a queued op and BEFORE the first raw create. Only kinds that some rule references
- * are read. The three listings are what upstream shows a user: categories (hidden included,
+ * Only the references `next` ADDS over `stored`. A dangling id already in the stored rule must
+ * not make an unrelated edit fail. The key includes the side: the same id newly added on the
+ * other side (condition to action) counts as new.
+ */
+function newRuleReferences(next, stored) {
+    const had = new Set(ruleReferences(stored).map(ruleRefKey));
+    return ruleReferences(next).filter((ref) => !had.has(ruleRefKey(ref)));
+}
+/**
+ * #485: read the listings the given references need, once per kind, through the drain cache.
+ * Call INSIDE a queued op and BEFORE the first raw write. Only kinds that some reference needs
+ * are read, so an edit introducing no new reference reads no listing. The three listings are what upstream shows a user: categories (hidden included,
  * group ids are not in it), payees (transfer payees included, tombstoned ones excluded here
  * even if the listing returns them) and accounts (closed and off-budget accounts included, and
  * both count as existing: a closed account is not a missing reference).
  */
-async function loadRuleReferenceListings(rules) {
+async function loadRuleReferenceListings(refs) {
     const need = new Set();
-    for (const rule of rules)
-        for (const ref of ruleReferences(rule))
-            need.add(ref.field);
+    for (const ref of refs)
+        need.add(ref.field);
     const listings = {};
     if (need.has('category')) {
         const rows = await withConcurrency(() => retry(() => readDrainListing('categories', () => rawGetCategories()), { retries: 2, backoffMs: 200 }));
@@ -2306,19 +2405,22 @@ async function loadRuleReferenceListings(rules) {
  * #485: refuse a rule that points at a category, payee or account that does not exist.
  * Upstream `createRule` checks field, operator and nullability only, with no existence lookup
  * of id values, so it stores a rule pointing at nothing. NOT exported: tests drive it through
- * `createRule` and `createRulesBatch`, and it lives in the adapter so neither call site can
- * skip it.
- *
- * KNOWN GAPS, accepted and tracked in #522: the other rule writes (`upsertRule`, `updateRule`
- * and `updatePayee`'s default-category rule) are NOT guarded, and `link-schedule` action
- * values are not checked.
+ * the adapter methods, and it lives in the adapter so no call site can skip it. `suffix` is
+ * REQUIRED (no default) so a new call site cannot inherit text that is false for it.
+ *
+ * The guard now covers every rule write: `createRule`, `createRulesBatch`, `updateRule`,
+ * `upsertRule` and `updatePayee`'s category. KNOWN GAPS that remain: `link-schedule` action
+ * values; `category_group` condition values (upstream `FIELD_INFO` types it `id`, but its value
+ * is a group id that appears in none of the three listings, #524 item 5); and, deliberately,
+ * text-pattern ops (`contains`, `matches`, `doesNotContain`) and actions with a truthy
+ * `options.template`.
  */
-function assertRuleReferencesExist(rule, listings) {
-    for (const ref of ruleReferences(rule)) {
+function assertRuleReferencesExist(refs, listings, suffix) {
+    for (const ref of refs) {
         const known = listings[ref.field];
         if (known && !known.has(ref.id)) {
             const meta = RULE_REFERENCE_FIELDS[ref.field];
-            throw new NotFoundRefusal(meta.entity, ref.id, meta.listTool, 'Nothing was created.');
+            throw new NotFoundRefusal(meta.entity, ref.id, meta.listTool, suffix);
         }
     }
 }
@@ -2356,12 +2458,8 @@ function ruleCreateErrorText(error) {
  *     the same rule twice if the first attempt landed), each caught per item. Only raw calls
  *     run here: an `adapter.*` call would nest the api lock and deadlock.
  *
- * INFRASTRUCTURE ERRORS STOP THE BATCH. When `_shouldDropPoolOnError` matches, the loop stops
- * and the error is rethrown with the original text kept (so the classification still matches)
- * and the indices already created. The rethrow surfaces as a whole-call failure; on the legacy
- * path of queueWriteOperation it also forces a full shutdown. (In pooled mode the pooled entry
- * is dropped only if the following sync fails.) Rate limits and upstream rejections are per
- * item and the loop continues.
+ * INFRASTRUCTURE ERRORS STOP THE BATCH: see `abortBatchOnInfrastructureError`. Rate limits and
+ * upstream rejections are per item and the loop continues.
  *
  * COOPERATIVE DEADLINE: same 0.75 fraction of ACTUAL_OP_TIMEOUT_MS as `setBudgetBatch`,
  * because `withOpTimeout` cannot cancel this callback. Items not reached go to `failed` with
@@ -2373,11 +2471,12 @@ export async function createRulesBatch(items, total) {
         const startedAt = Date.now();
         const succeeded = [];
         const failed = [];
-        const listings = await loadRuleReferenceListings(items.map((i) => i.rule));
+        const listings = await loadRuleReferenceListings(items.flatMap((i) => ruleReferences(i.rule)));
         const toWrite = [];
         for (const item of items) {
             try {
-                assertRuleReferencesExist(item.rule, listings);
+                // The other items may well be created, so the single-rule suffix would be false here.
+                assertRuleReferencesExist(ruleReferences(item.rule), listings, RULE_REFUSAL_BATCH_ITEM);
                 toWrite.push(item);
             }
             catch (error) {
@@ -2396,11 +2495,14 @@ export async function createRulesBatch(items, total) {
             }
             catch (error) {
                 const msg = ruleCreateErrorText(error);
-                if (_shouldDropPoolOnError(error)) {
-                    const applied = succeeded.map((x) => x.index).join(', ') || 'none';
-                    throw new Error(`Rules batch aborted after ${succeeded.length} of ${total} items (applied: ${applied}): ${msg}. ` +
-                        'Read back with actual_rules_get before retrying.', { cause: error });
-                }
+                abortBatchOnInfrastructureError(error, {
+                    label: 'Rules',
+                    appliedCount: succeeded.length,
+                    total,
+                    applied: succeeded.map((x) => x.index).join(', '),
+                    message: msg,
+                    readBackTool: 'actual_rules_get',
+                });
                 failed.push({ index, error: msg });
             }
         }
@@ -2413,8 +2515,10 @@ export async function createRule(rule) {
     observability.incrementToolCall('actual.rules.create').catch(() => { });
     return queueWriteOperation(async () => {
         // #485: the reference guard shares this drain's cached listings with the write.
-        assertRuleReferencesExist(rule, await loadRuleReferenceListings([rule]));
-        const raw = await withConcurrency(() => retry(() => rawCreateRule(rule), { retries: 2, backoffMs: 200, isRetryable: isRetryableError }));
+        const refs = ruleReferences(rule);
+        assertRuleReferencesExist(refs, await loadRuleReferenceListings(refs), RULE_REFUSAL_CREATED);
+        // retries 0: a slow first attempt that lands followed by a retry stores a duplicate rule.
+        const raw = await withConcurrency(() => retry(() => rawCreateRule(rule), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
         const id = normalizeToId(raw);
         return id;
     }, { preservesListings: PRESERVES_ALL_ENTITY_LISTINGS });
@@ -2427,7 +2531,7 @@ export async function updateRule(id, fields) {
         const rules = await withConcurrency(() => retry(() => rawGetRules(), { retries: 2, backoffMs: 200 }));
         const existingRule = rules.find((r) => r.id === id);
         if (!existingRule) {
-            throw new Error(`Rule with id ${id} not found`);
+            throw new NotFoundRefusal('Rule', id, 'actual_rules_get');
         }
         const fieldsObj = fields;
         const rule = {
@@ -2450,6 +2554,11 @@ export async function updateRule(id, fields) {
             conditions: fieldsObj.conditions ?? existingRule.conditions ?? [],
             actions: fieldsObj.actions ?? existingRule.actions ?? [],
         };
+        // Only references this update ADDS are checked: a dangling id already stored does not make
+        // an unrelated edit fail. Diffing the merged rule equals diffing the payload, because an
+        // 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)}`);
         await withConcurrency(() => retry(() => rawUpdateRule(rule), { retries: 0, backoffMs: 200, isRetryable: isRetryableError }));
         logger.debug(`[UPDATE RULE] Update completed for rule ${id}`);
@@ -2502,6 +2611,8 @@ export async function upsertRule(input, stageWasSupplied) {
                 conditions: ruleData.conditions ?? matchedRule.conditions ?? [],
                 actions: ruleData.actions ?? matchedRule.actions ?? [],
             };
+            const addedRefs = newRuleReferences(merged, matchedRule);
+            assertRuleReferencesExist(addedRefs, await loadRuleReferenceListings(addedRefs), RULE_REFUSAL_CHANGED);
             // Non-idempotent from upstream's point of view: do not retry the write.
             await withConcurrency(() => retry(() => rawUpdateRule(merged), { retries: 0, backoffMs: 200 }));
             return { id: matchedRule.id, created: false };
@@ -2512,6 +2623,8 @@ export async function upsertRule(input, stageWasSupplied) {
         // value: Actual's default stage.
         if (ruleData.stage === undefined)
             ruleData.stage = null;
+        const createRefs = ruleReferences(ruleData);
+        assertRuleReferencesExist(createRefs, await loadRuleReferenceListings(createRefs), RULE_REFUSAL_CREATED);
         const rawId = await withConcurrency(() => retry(() => rawCreateRule(ruleData), { retries: 0, backoffMs: 200 }));
         return { id: normalizeToId(rawId), created: true };
     }, { preservesListings: PRESERVES_ALL_ENTITY_LISTINGS });
@@ -2995,18 +3108,16 @@ export async function setBudgetBatch(items) {
                     }
                     catch (error) {
                         const msg = error instanceof Error ? error.message : String(error);
-                        // INFRASTRUCTURE ERRORS ARE NOT PER-ITEM FAILURES. queueWriteOperation sets
-                        // drainForceFullShutdown only when _shouldDropPoolOnError sees the error reach
-                        // it. Swallowing a dropped connection into `failed` would leave the dead pooled
-                        // connection in place for the next caller, so stop the loop and rethrow out of
-                        // the bracket (upstream closes it in a `finally`). The original message text is
-                        // kept so the pattern classification still matches. Rate-limit errors are not
-                        // pool-drop errors (see _shouldDropPoolOnError), so they stay per-item failures.
-                        if (_shouldDropPoolOnError(error)) {
-                            const applied = succeeded.map((x) => x.index).join(', ') || 'none';
-                            throw new Error(`Budget batch aborted after ${succeeded.length} of ${items.length} items (applied: ${applied}): ${msg}. ` +
-                                'Read back with actual_budgets_getMonth before retrying.');
-                        }
+                        // Infrastructure errors stop the batch (see abortBatchOnInfrastructureError);
+                        // the throw leaves the bracket and upstream closes it in a `finally`.
+                        abortBatchOnInfrastructureError(error, {
+                            label: 'Budget',
+                            appliedCount: succeeded.length,
+                            total: items.length,
+                            applied: succeeded.map((x) => x.index).join(', '),
+                            message: msg,
+                            readBackTool: 'actual_budgets_getMonth',
+                        });
                         failed.push({ ...ref, error: amountWritten ? `amount was applied, then the carryover failed: ${msg}` : msg });
                     }
                 }

package/dist/src/lib/config-registry.js

@@ -86,8 +86,8 @@ export function canonicalConfigVars(schemaKeys) {
 /**
  * The subset of canonical vars that MUST appear in the user-facing docs
  * (.env.example and the README env table): every schema key, plus every allowlist
- * entry not flagged `documented: false`. Internal vars (build arg, dotenv flag,
- * CLI-flag mirror) are accounted for by the enumeration but exempt from the docs.
+ * entry not flagged `documented: false`. Internal vars (build arg, CLI-flag mirror)
+ * are accounted for by the enumeration but exempt from the docs.
  */
 export function documentedConfigVars(schemaKeys) {
     return new Set([

package/dist/src/lib/schemas/rules.js

@@ -106,7 +106,7 @@ export function validateRuleInput(input) {
     }
     // Validate field usage to guide users toward correct field selection
     for (const condition of input.conditions) {
-        const fieldInfo = FIELD_OPERATORS[condition.field];
+        const fieldInfo = Object.hasOwn(FIELD_OPERATORS, condition.field) ? FIELD_OPERATORS[condition.field] : undefined;
         // Validate operator is compatible with field type
         if (fieldInfo && !fieldInfo.operators.includes(condition.op)) {
             throw new Error(`Invalid operator "${condition.op}" for field "${condition.field}". ` +

package/dist/src/lib/toolsets.js

@@ -12,9 +12,10 @@
  *
  * Design rules, each the answer to a way this can go wrong:
  *   - ONE source. resolvePublishedToolNames is pure and runs once, in
- *     actualToolsManager.initialize(), from the validated config. It returns an immutable
- *     policy (the published set plus a per-tool hide reason). Nothing reads process.env
- *     at dispatch time.
+ *     actualToolsManager.initialize(), from the validated config. It returns a frozen
+ *     policy (the published set plus a per-tool hide reason; the hide map is a ReadonlyMap
+ *     by type only, since Object.freeze does not reach Map contents). Nothing reads
+ *     process.env at dispatch time.
  *   - Hide AND refuse. Omitting a tool from tools/list is not access control, so callTool
  *     refuses an unpublished tool with ToolUnavailableError.
  *   - Fail loud. An unknown toolset, preset or tool name throws, and so does a
@@ -272,13 +273,19 @@ export function resolvePublishedToolNames(registeredNames, settings) {
     const published = [];
     const hidden = new Map();
     for (const name of registeredNames) {
-        if (!selected.has(name))
-            hidden.set(name, 'MCP_TOOLSETS');
-        else if (settings.readOnly && WRITE_CAPABLE.has(name))
+        // Read-only is checked FIRST: while it is on, adding a writer to MCP_TOOLSETS or MCP_TOOLS
+        // cannot publish it, so MCP_READ_ONLY is the setting to change first when both hide a tool.
+        if (settings.readOnly && WRITE_CAPABLE.has(name))
             hidden.set(name, 'MCP_READ_ONLY');
+        else if (!selected.has(name))
+            hidden.set(name, 'MCP_TOOLSETS');
         else
             published.push(name);
     }
+    // Partition invariant: every registered name is exactly one of published or hidden.
+    if (published.length + hidden.size !== registeredNames.length || published.some((n) => hidden.has(n))) {
+        throw new Error('toolsets: published and hidden must partition the registry');
+    }
     if (published.length === 0) {
         throw new Error(`No tools would be published: MCP_TOOLSETS="${settings.toolsets}", MCP_TOOLS="${settings.tools}" and ` +
             `MCP_READ_ONLY=${settings.readOnly} resolve to 0 tools. For example, a toolset made only of writers ` +
@@ -295,8 +302,13 @@ export function resolvePublishedToolNames(registeredNames, settings) {
         }),
     });
 }
-/** The typed refusal for a registered but unpublished tool, built from the stored reason. */
+/**
+ * The typed refusal for a registered but unpublished tool. Fails CLOSED: the decision is the
+ * frozen `published` list; `hidden` only supplies the reason. The fallback reason is
+ * unreachable in production because the resolver enforces the partition invariant.
+ */
 export function unavailableError(policy, tool) {
-    const setting = policy.hidden.get(tool);
-    return setting ? new ToolUnavailableError(tool, setting) : undefined;
+    if (policy.published.includes(tool))
+        return undefined;
+    return new ToolUnavailableError(tool, policy.hidden.get(tool) ?? 'MCP_TOOLSETS');
 }

package/dist/src/lib/transportErrorLogger.js

@@ -0,0 +1,116 @@
+/**
+ * Transport-level error logging (#504).
+ *
+ * `@modelcontextprotocol/sdk` reports transport and protocol errors through
+ * `transport.onerror`, which `Protocol.connect` chains into the Server's `onerror`.
+ * Nothing set it, so refusals (batch cap, parse errors, unknown ids) were invisible.
+ *
+ * The error text can echo CLIENT content (payloads, headers), so it is sanitized before
+ * it is logged, the log message is a CONSTANT (the logger runs winston splat(), which
+ * interpolates `%o`/`%s` in the message), and the Error object, stack and cause are never
+ * passed to the logger (format.errors({ stack: true }) would re-emit the raw message).
+ * Volume is bounded by ONE per-process window limiter.
+ */
+import { createModuleLogger } from './loggerFactory.js';
+const MAX_DETAIL_CODE_POINTS = 200;
+const CUT_CHARS = /[{["'`]/;
+// Control (C0, C1), line/paragraph separators and bidi format characters. Written with
+// escapes, as src/logger.ts does: a raw U+2028 in source would terminate the literal.
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
+const OMITTED = '[payload omitted]';
+/** Pure: turn an arbitrary thrown value into a bounded, payload-free, single-line string. */
+export function sanitizeTransportErrorDetail(value) {
+    let raw = '';
+    try {
+        if (value === null || value === undefined)
+            raw = '';
+        else if (value instanceof Error)
+            raw = String(value.message);
+        else
+            raw = String(value);
+    }
+    catch {
+        raw = '';
+    }
+    let cut = false;
+    const cutAt = raw.search(CUT_CHARS);
+    if (cutAt >= 0) {
+        raw = raw.slice(0, cutAt);
+        cut = true;
+    }
+    let s = raw.replace(/%/g, ' ').replace(CONTROL_CHARS, ' ').replace(/\s+/g, ' ').trim();
+    s = Array.from(s).slice(0, MAX_DETAIL_CODE_POINTS).join('');
+    if (cut)
+        s = s ? `${s} ${OMITTED}` : OMITTED;
+    return s === '' ? '[no message]' : s;
+}
+/** Fixed-window limiter: first `max` calls per window pass, the rest are counted. */
+export function createWindowLimiter(opts) {
+    let windowStart = 0;
+    let count = 0;
+    let suppressed = 0;
+    let started = false;
+    return {
+        take() {
+            const t = opts.now();
+            if (!started || t - windowStart >= opts.windowMs) {
+                started = true;
+                windowStart = t;
+                count = 0;
+            }
+            if (count < opts.max) {
+                count++;
+                const reported = suppressed;
+                suppressed = 0;
+                return { allowed: true, suppressed: reported };
+            }
+            suppressed++;
+            return { allowed: false, suppressed: 0 };
+        },
+    };
+}
+// ONE limiter per process so many HTTP sessions cannot multiply the budget.
+const moduleLimiter = createWindowLimiter({ max: 50, windowMs: 60_000, now: Date.now });
+function safeErrorName(error) {
+    try {
+        const name = error?.name;
+        return typeof name === 'string' && /^[A-Za-z]{1,40}$/.test(name) ? name : 'Error';
+    }
+    catch {
+        return 'Error';
+    }
+}
+/**
+ * Install a server.onerror that logs a sanitized, rate-limited record. Chains any prior
+ * handler. The handler never throws (stdio invokes it inside a stdin data handler).
+ */
+export function attachTransportErrorLogger(server, transport, deps = {}) {
+    const prev = server.onerror;
+    const limiter = deps.limiter ?? moduleLimiter;
+    let log = deps.logger;
+    server.onerror = (error) => {
+        try {
+            if (typeof prev === 'function')
+                prev(error);
+        }
+        catch {
+            // a broken prior handler must not stop ours or escape into the SDK
+        }
+        try {
+            const { allowed, suppressed } = limiter.take();
+            if (!allowed)
+                return;
+            log = log ?? createModuleLogger('TRANSPORT');
+            log.warn('MCP transport error', {
+                transport,
+                errorName: safeErrorName(error),
+                detail: sanitizeTransportErrorDetail(error),
+                ...(suppressed > 0 ? { suppressed } : {}),
+            });
+        }
+        catch {
+            // never throw into the SDK
+        }
+    };
+}

package/dist/src/server/httpServer.js

@@ -4,6 +4,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 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';
@@ -360,6 +361,7 @@ advertisedUrl) {
             name: serverDescription || "actual-mcp-server",
             version: version || "0.1.0",
         }, serverOptions);
+        attachTransportErrorLogger(server, 'http');
         // List tools handler
         server.setRequestHandler(ListToolsRequestSchema, async () => {
             logger.debug('[TOOLS LIST] Listing available tools');

package/dist/src/server/stdioServer.js

@@ -4,6 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'node:crypto';
 import logger from '../logger.js';
+import { attachTransportErrorLogger } from '../lib/transportErrorLogger.js';
 import actualToolsManager from '../actualToolsManager.js';
 import { requestContext } from '../lib/requestContext.js';
 import { buildToolListEntries } from '../lib/tool-list-entry.js';
@@ -108,6 +109,7 @@ export async function startStdioServer(mcp, capabilities, implementedTools, serv
     const stdioSessionId = `stdio-${randomUUID()}`;
     logger.debug(`[STDIO] session id ${stdioSessionId}`);
     const server = new Server({ name: serverDescription || 'actual-mcp-server', version: version || '0.1.0' }, { capabilities, instructions: serverInstructions });
+    attachTransportErrorLogger(server, 'stdio');
     // List tools handler — mirrors createServerInstance() in httpServer.ts
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         // #379: the SAME builder the HTTP paths use. stdio is the transport Claude Desktop

package/dist/src/tools/budget_updates_batch.js

@@ -41,14 +41,16 @@ Example: Set health insurance budget for 2 months:
         // timeout) must reach actualToolsManager.callTool and surface as a tool error.
         const input = InputSchema.parse(args || {});
         const { succeeded, failed } = await adapter.setBudgetBatch(input.operations);
-        // Counts, plus index/month/categoryId per failure. Never amounts.
+        // Counts and failed indices only. Never amounts, months or category ids.
         log.info('Budget batch finished', {
             total: input.operations.length,
             successCount: succeeded.length,
             failureCount: failed.length,
         });
-        for (const f of failed) {
-            log.warn('Budget batch item failed', { index: f.index, month: f.month, categoryId: f.categoryId });
+        if (failed.length > 0) {
+            // setBudgetBatch returns `failed` already sorted ascending by index, so no re-sort here.
+            const failedIndices = failed.map((f) => f.index);
+            log.warn('Budget batch items failed', { failureCount: failed.length, failedIndices });
         }
         const result = {
             succeeded,

package/dist/src/tools/query_run.js

@@ -13,7 +13,7 @@ Example: "SELECT id, date, amount, payee.name FROM transactions WHERE amount < 0
 
 WHERE supports: =, !=, >, >=, <, <=; IN (v1, v2); LIKE / NOT LIKE (case and accent-insensitive, % wildcard, e.g. imported_payee LIKE '%amazon%'); IS NULL / IS NOT NULL; boolean columns as true / false (cleared = false, category.hidden = true); conditions joined with AND. OR, REGEXP, NOT IN and parenthesised groups are not supported and return an error (a query is never silently run unfiltered). Transactions come back in split-INLINE mode: "is_parent = true" returns nothing, use "is_parent = false" to exclude split children.
 
-Joins use dot notation: payee.name, category.name, account.name (NOT payee_name). Amounts are in cents: $100.00 = 10000.
+Joins use dot notation: payee.name, category.name, account.name (NOT payee_name). Amounts are in cents: $100.00 = 10000. Dates are quoted YYYY-MM-DD strings: date >= '2025-01-01'.
 
 Tables:
 - transactions: id, date, amount, notes, cleared, account, payee, category
@@ -49,7 +49,7 @@ Tables:
                 throw 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 tool description for more examples.`);
+                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.`);
             }
             else {
                 throw new Error(`Query execution failed: ${errorMessage}`);

package/dist/src/tools/rules_create_batch.js

@@ -41,7 +41,7 @@ Returns: { succeeded: [{index, id}], failed: [{index, error}], total, successCou
             failed.push(...res.failed);
         }
         failed.sort((a, b) => a.index - b.index);
-        succeeded.sort((a, b) => a.index - b.index);
+        // succeeded comes back sorted by index from adapter.createRulesBatch, which owns that order (#524).
         return { succeeded, failed, total, successCount: succeeded.length, failureCount: failed.length };
     },
 });

package/dist/src/tools/rules_create_or_update.js

@@ -75,7 +75,7 @@ Returns: { id, created: boolean }, created=true for a new rule, false for an upd
         const input = InputSchema.parse(args || {});
         // ── Validate conditions ──
         for (const condition of input.conditions) {
-            const fieldInfo = FIELD_OPERATORS[condition.field];
+            const fieldInfo = Object.hasOwn(FIELD_OPERATORS, condition.field) ? FIELD_OPERATORS[condition.field] : undefined;
             if (fieldInfo && !fieldInfo.operators.includes(condition.op)) {
                 throw new Error(`Invalid operator "${condition.op}" for field "${condition.field}". ` +
                     `Field "${condition.field}" is a ${fieldInfo.type} field and only supports: ${fieldInfo.operators.join(', ')}.`);

package/dist/src/tools/rules_update.js

@@ -83,7 +83,7 @@ Stage: omit it to leave the rule where it is, pass null for the normal stage, or
         // Validate field usage to guide users toward correct field selection
         if (input.fields.conditions) {
             for (const condition of input.fields.conditions) {
-                const fieldInfo = FIELD_OPERATORS[condition.field];
+                const fieldInfo = Object.hasOwn(FIELD_OPERATORS, condition.field) ? FIELD_OPERATORS[condition.field] : undefined;
                 // Validate operator is compatible with field type
                 if (fieldInfo && !fieldInfo.operators.includes(condition.op)) {
                     throw new Error(`Invalid operator "${condition.op}" for field "${condition.field}". ` +

package/dist/src/tools/transactions_update_batch.js

@@ -37,7 +37,7 @@ const InputSchema = z.object({
 });
 const tool = {
     name: 'actual_transactions_update_batch',
-    description: `Update multiple transactions in a single call. Accepts up to 50 {id, fields} pairs. Each update is applied independently: partial failures are reported per-item so you know exactly which succeeded and which failed. Splits are not supported here: a subtransactions field is ignored in batch. Use actual_transactions_update to edit an existing split's children.
+    description: `Update multiple transactions in a single call. Accepts up to 50 {id, fields} pairs. Each update is applied independently and NOT atomically: items applied before a failure stay applied. A missing id or an update Actual rejects is reported per item in failed, and the rest continue. If the call itself fails (lost connection, out of memory, timeout), the error names the ids already applied; read the transactions back with actual_transactions_get BEFORE retrying. Splits are not supported here: a subtransactions field is ignored in batch. Use actual_transactions_update to edit an existing split's children.
 
 Returns: { succeeded: [{id}], failed: [{id, error}], total, successCount, failureCount }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "actual-mcp-server",
   "displayName": "Actual MCP Server",
-  "version": "0.22.18",
+  "version": "0.22.20",
   "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/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/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",
+    "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/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/source_text_helper.test.js && node tests/unit/transport_onerror.test.js && node tests/unit/adapter_transaction_batch_abort.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",