earnrate 0.2.6 → 0.2.8

package/dist/engine/evaluate.js

@@ -147,14 +147,14 @@ function capState(rule, card, held, date) {
     const { period, spent } = capUsed(cap, key, held, date);
     return { key, cap, period, remaining: Math.max(0, cap.amount - spent) };
 }
-function rateAfterCap(rate, cap, amount) {
+function rateAfterCap(rate, cap, afterCap, amount) {
     if (!cap)
         return rate;
     if (amount !== null && amount > 0) {
         const inCap = Math.min(amount, cap.remaining);
-        return (inCap * rate + (amount - inCap) * cap.cap.then_rate) / amount;
+        return (inCap * rate + (amount - inCap) * afterCap) / amount;
     }
-    return cap.remaining > 0 ? rate : cap.cap.then_rate;
+    return cap.remaining > 0 ? rate : afterCap;
 }
 // On equal rates an uncapped rule wins, so spend that can earn the same
 // without a cap doesn't use one up. Otherwise the earlier rule stays.
@@ -170,24 +170,31 @@ export function evaluateCard(card, held, ctx) {
         nominalRate: card.base_rate,
         rate: card.base_rate,
         cap: null,
+        afterCap: null,
     };
     let best = base;
     let nominal = base;
     const blocked = [];
+    const applying = [];
     for (const rule of card.rules) {
         const status = applicability(card, rule, ctx, held, picked);
         if (status === 'no')
             continue;
-        if (status === 'needs-activation') {
+        if (status === 'needs-activation')
             blocked.push(rule);
-            continue;
-        }
+        else
+            applying.push(rule);
+    }
+    const uncapped = Math.max(card.base_rate, ...applying.filter((r) => r.cap === undefined).map((r) => r.rate));
+    for (const rule of applying) {
         const cap = capState(rule, card, held, ctx.date);
+        const afterCap = cap ? Math.max(cap.cap.then_rate, uncapped) : null;
         const earning = {
             rule,
             nominalRate: rule.rate,
-            rate: rateAfterCap(rule.rate, cap, ctx.amount),
+            rate: rateAfterCap(rule.rate, cap, afterCap ?? rule.rate, ctx.amount),
             cap,
+            afterCap,
         };
         if (beats(earning, earning.rate, best, best.rate))
             best = earning;

package/dist/engine/explore.js

@@ -5,7 +5,7 @@ import { choicePeriod, periodKey } from "./periods.js";
 import { recommend } from "./recommend.js";
 import { rotationGap } from "./rotation.js";
 import { membershipsUsed } from "./setup.js";
-import { optionName } from "./wallet-summary.js";
+import { optionName } from "./rule-text.js";
 import { CAP_PERIODS, categoryPhrase, choiceName, codesAs, earnText, listed, money, PICK_PERIODS, pointValuesText, } from "./text.js";
 import { cardValuation } from "./valuation.js";
 import { EPSILON } from "./compare.js";
@@ -99,7 +99,7 @@ function requirementsFor(catalog, card, held, wallet, merchant, purchase) {
             ? {
                 amount: cap.amount,
                 period: cap.period,
-                thenRate: cap.then_rate,
+                thenRate: best.afterCap ?? cap.then_rate,
                 currency: cardValuation(catalog, wallet, card).currency,
             }
             : null,

package/dist/engine/recommend.js

@@ -1,7 +1,9 @@
 import { findMerchant, resolveMerchant, resolveMerchantById, } from "../merchants/resolve.js";
 import { bonusStatus } from "./bonus.js";
 import { evaluateCard, purchaseContext, usableAt, } from "./evaluate.js";
+import { membershipName } from "./memberships.js";
 import { daysBetween } from "./periods.js";
+import { ruleWhat } from "./rule-text.js";
 import { rotationGap } from "./rotation.js";
 import { EPSILON, isClose } from "./compare.js";
 import { CAP_ADJECTIVES, categoryPhrase, codesAs, currencyLabel, currencyName, earnText, money, NETWORK_NAMES, num, pct, pointValuesText, roundCents, shortDate, wholeDollars, } from "./text.js";
@@ -84,7 +86,7 @@ function reasoningFor(catalog, wallet, entry, amount) {
     const currency = valuation.currency;
     if (best.rule) {
         const note = best.rule.note ? ` ${best.rule.note}` : '';
-        lines.push(`${earnText(catalog, best.nominalRate, currency)} from its "${best.rule.id}" rule.${note}`);
+        lines.push(`${earnText(catalog, best.nominalRate, currency)} on ${ruleWhat(catalog, best.rule)}${best.rule.requires?.membership === undefined ? '' : `, with ${membershipName(catalog, best.rule.requires.membership)}`}.${note}`);
     }
     else {
         lines.push(`${earnText(catalog, card.base_rate, currency)}, its base rate. No bonus category applies here.`);
@@ -92,7 +94,7 @@ function reasoningFor(catalog, wallet, entry, amount) {
     const cap = best.cap;
     if (cap && amount !== null && amount > cap.remaining) {
         const over = amount - cap.remaining;
-        lines.push(`${money(cap.remaining)} earns ${earnText(catalog, best.nominalRate, currency)} before the cap, then ${money(over)} earns ${earnText(catalog, cap.cap.then_rate, currency)}: ${num(best.rate)} per dollar overall.`);
+        lines.push(`${money(cap.remaining)} earns ${earnText(catalog, best.nominalRate, currency)} before the cap, then ${money(over)} earns ${earnText(catalog, best.afterCap ?? cap.cap.then_rate, currency)}: ${num(best.rate)} per dollar overall.`);
     }
     if (valuation.pooledFrom !== null) {
         const partners = card.pools_into?.when_wallet_has ?? [];
@@ -121,17 +123,17 @@ function warningsFor(catalog, entry, purchase) {
             warnings.push(`Add this card's anniversary (MM-DD) to your wallet so its ${capLabel(best)} can be tracked.`);
         }
         else if (purchase.amount !== null && purchase.amount > remaining) {
-            warnings.push(`This purchase crosses the ${capLabel(best)} on "${best.rule.id}": only ${money(remaining)} is left for ${period}.`);
+            warnings.push(`This purchase crosses the ${capLabel(best)} on ${ruleWhat(catalog, best.rule)}: only ${money(remaining)} is left for ${period}.`);
         }
         else if (remaining < cap.amount * NEAR_CAP_SHARE) {
-            warnings.push(`Only ${money(remaining)} left of the ${capLabel(best)} on "${best.rule.id}" for ${period}.`);
+            warnings.push(`Only ${money(remaining)} left of the ${capLabel(best)} on ${ruleWhat(catalog, best.rule)} for ${period}.`);
         }
     }
     if (nominal.rule &&
         nominal.cap &&
         nominal !== best &&
         nominal.cap.remaining === 0) {
-        warnings.push(`The ${capLabel(nominal)} on "${nominal.rule.id}" is used up for ${nominal.cap.period ?? 'this period'}, so it earns ${earnText(catalog, nominal.cap.cap.then_rate, valuation.currency)} until it resets.`);
+        warnings.push(`The ${capLabel(nominal)} on ${ruleWhat(catalog, nominal.rule)} is used up for ${nominal.cap.period ?? 'this period'}, so it earns ${earnText(catalog, nominal.afterCap ?? nominal.cap.cap.then_rate, valuation.currency)} until it resets.`);
     }
     if (best.rule?.unverified !== undefined) {
         warnings.push(`This rate isn't confirmed against the issuer's terms yet: ${best.rule.unverified}`);
@@ -144,6 +146,10 @@ function warningsFor(catalog, entry, purchase) {
         warnings.push(`Your chosen categories are set for ${evaluation.staleChoice}, not the current period, so chosen-category bonuses don't apply until you update them.`);
     }
     for (const rule of evaluation.needsActivation) {
+        if (rule.activate_by !== undefined && rule.activate_by < purchase.date) {
+            warnings.push(`The bonus here (${earnText(catalog, rule.rate, valuation.currency)}) needed activating by ${shortDate(rule.activate_by)}.`);
+            continue;
+        }
         warnings.push(`Activate this bonus with the issuer (it's free)${rule.activate_by === undefined ? '' : ` by ${shortDate(rule.activate_by)}`} to earn ${earnText(catalog, rule.rate, valuation.currency)} here${rule.valid_to === undefined ? '' : ` through ${shortDate(rule.valid_to)}`}.`);
     }
     return warnings;

package/dist/engine/rule-text.js

@@ -0,0 +1,47 @@
+import { findMerchant } from "../merchants/resolve.js";
+import { categoryPhrase, choiceName, listed, words } from "./text.js";
+// What a rule or a pick covers, in words, for answers and wallet lists.
+// Travel-site bookings ("Flight through Amex Travel") read mid-sentence in
+// lower case and plural; brand names ("Airbnb through Amex Travel") keep theirs.
+const BOOKING = /^(Attraction|Car rental|Cruise|Flight|Hotel|Vacation rental)\b/;
+function merchantName(catalog, id) {
+    const merchant = findMerchant(catalog, id);
+    const name = merchant?.name ?? words(id);
+    return merchant?.kind === 'booking'
+        ? name.replace(BOOKING, (kind) => `${kind.toLowerCase()}s`)
+        : name;
+}
+export function optionName(catalog, card, choiceId, option) {
+    const o = card.choices.find((c) => c.id === choiceId)?.options[option];
+    if (!o)
+        return words(option);
+    const parts = [
+        ...o.categories.map((c) => categoryPhrase(catalog, c)),
+        ...o.merchants.map((m) => merchantName(catalog, m)),
+    ];
+    if (o.online)
+        parts.push('online shopping');
+    return parts.length > 0 ? listed(parts) : words(option);
+}
+// What a rule covers, as a list of phrases.
+export function ruleParts(catalog, rule) {
+    if (rule.match.any)
+        return ['everything else'];
+    if (rule.match.choice !== undefined)
+        return [`your ${choiceName(rule.match.choice)} picks`];
+    const merchants = rule.match.merchants ?? [];
+    // A long list of one kind of store reads as "select streaming services".
+    const kinds = new Set(merchants.map((m) => findMerchant(catalog, m)?.category));
+    const [kind] = kinds;
+    const merchantParts = merchants.length > 4 && kinds.size === 1 && kind !== undefined
+        ? [`select ${categoryPhrase(catalog, kind)}`]
+        : merchants.map((m) => merchantName(catalog, m));
+    const parts = [
+        ...(rule.match.categories ?? []).map((c) => categoryPhrase(catalog, c)),
+        ...merchantParts,
+    ];
+    return parts.length > 0 ? parts : [words(rule.id)];
+}
+export function ruleWhat(catalog, rule) {
+    return listed(ruleParts(catalog, rule));
+}

package/dist/engine/setup.js

@@ -45,6 +45,7 @@ export function activationRules(card, today) {
     return card.rules
         .filter((r) => r.requires?.activation === true &&
         (r.valid_to === undefined || r.valid_to >= today) &&
+        (r.activate_by === undefined || r.activate_by >= today) &&
         (r.valid_from === undefined ||
             daysBetween(today, r.valid_from) <= ACTIVATION_LOOKAHEAD_DAYS))
         .map((r) => r.id);

package/dist/engine/wallet-change.js

@@ -1,3 +1,4 @@
+import { CARD_NUMBER_LABEL, labelHasCardNumber } from "../schema/card-number.js";
 import { WALLET_VERSION, } from "../schema/wallet.js";
 import { addMonths } from "./bonus.js";
 import { capByKey } from "./evaluate.js";
@@ -33,9 +34,8 @@ export function cardFields(card, held, input, today) {
     else if (input.checkoutLabel !== undefined) {
         if (input.checkoutLabel.trim() === '')
             problems.push('The checkout label is empty.');
-        // earnrate never stores card numbers; a last four is fine.
-        if (/\d{8,}/.test(input.checkoutLabel.replace(/[\s-]/g, '')))
-            problems.push('The checkout label looks like it has a card number in it. earnrate never stores card numbers; use a name like "Amex Gold".');
+        if (labelHasCardNumber(input.checkoutLabel))
+            problems.push(CARD_NUMBER_LABEL);
         fields.checkout_label = input.checkoutLabel.trim();
     }
     if (input.anniversary !== undefined) {

package/dist/engine/wallet-summary.js

@@ -1,66 +1,19 @@
-import { findMerchant } from "../merchants/resolve.js";
 import { bonusStatus } from "./bonus.js";
 import { activationGroup, capUsed, isActivated, pickedCategories, } from "./evaluate.js";
 import { membershipName } from "./memberships.js";
+import { optionName, ruleParts, ruleWhat } from "./rule-text.js";
 import { daysBetween, inEffect, periodEnd } from "./periods.js";
 import { STALE_AFTER_DAYS } from "./recommend.js";
 import { rotationGap } from "./rotation.js";
 import { activationRules } from "./setup.js";
-import { CAP_PERIODS, categoryPhrase, choiceName, currencyLabel, earnText, listed, shortDate, wholeDollars, words, } from "./text.js";
+import { CAP_PERIODS, choiceName, currencyLabel, earnText, listed, shortDate, wholeDollars, words, } from "./text.js";
 import { cardValuation, currencyValuation } from "./valuation.js";
-// Travel-site bookings ("Flight through Amex Travel") read mid-sentence in
-// lower case and plural; brand names ("Airbnb through Amex Travel") keep theirs.
-const BOOKING = /^(Attraction|Car rental|Cruise|Flight|Hotel|Vacation rental)\b/;
-function merchantName(catalog, id) {
-    const merchant = findMerchant(catalog, id);
-    const name = merchant?.name ?? words(id);
-    return merchant?.kind === 'booking'
-        ? name.replace(BOOKING, (kind) => `${kind.toLowerCase()}s`)
-        : name;
-}
-export function optionName(catalog, card, choiceId, option) {
-    const o = card.choices.find((c) => c.id === choiceId)?.options[option];
-    if (!o)
-        return words(option);
-    const parts = [
-        ...o.categories.map((c) => categoryPhrase(catalog, c)),
-        ...o.merchants.map((m) => merchantName(catalog, m)),
-    ];
-    if (o.online)
-        parts.push('online shopping');
-    return parts.length > 0 ? listed(parts) : words(option);
-}
-// What a rule covers, as a list of phrases.
-function ruleParts(catalog, rule) {
-    if (rule.match.choice !== undefined)
-        return [`your ${choiceName(rule.match.choice)} picks`];
-    const merchants = rule.match.merchants ?? [];
-    // A long list of one kind of store reads as "select streaming services".
-    const kinds = new Set(merchants.map((m) => findMerchant(catalog, m)?.category));
-    const [kind] = kinds;
-    const merchantParts = merchants.length > 4 && kinds.size === 1 && kind !== undefined
-        ? [`select ${categoryPhrase(catalog, kind)}`]
-        : merchants.map((m) => merchantName(catalog, m));
-    const parts = [
-        ...(rule.match.categories ?? []).map((c) => categoryPhrase(catalog, c)),
-        ...merchantParts,
-    ];
-    return parts.length > 0 ? parts : [words(rule.id)];
-}
-function ruleWhat(catalog, rule) {
-    return listed(ruleParts(catalog, rule));
-}
 const matchKeys = (rule) => rule.match.choice !== undefined
     ? []
     : [
         ...(rule.match.categories ?? []).map((c) => `category:${c}`),
         ...(rule.match.merchants ?? []).map((m) => `merchant:${m}`),
     ];
-// Every bonus rate the cardholder gets now, best first, so none reads as the
-// base rate. Rates behind a membership the wallet lacks are left out, and so
-// is a lower tier that an uncapped, always-on higher rate fully covers (Prime
-// Visa's 3% without Prime, once Prime is held). Rules at the same rate share
-// a line.
 // "first $1,500 a quarter, combined": how much of a rate's spending earns it.
 function capLimit(card, shown, rule) {
     if (rule.cap === undefined)
@@ -74,6 +27,11 @@ function capLimit(card, shown, rule) {
         shown.filter((r) => r.cap === rule.cap).length > 1;
     return `first ${wholeDollars(cap.amount)} ${CAP_PERIODS[cap.period]}${shared ? ', combined' : ''}`;
 }
+// Every bonus rate the cardholder gets now, best first, so none reads as the
+// base rate. Rates behind a membership the wallet lacks are left out, and so
+// is a lower tier that an uncapped, always-on higher rate fully covers (Prime
+// Visa's 3% without Prime, once Prime is held). Rules at the same rate share
+// a line.
 function headlineRates(catalog, wallet, card, held, currency, today) {
     const shown = card.rules
         .filter((r) => inEffect(r, today) &&
@@ -91,6 +49,16 @@ function headlineRates(catalog, wallet, card, held, currency, today) {
             .flatMap(matchKeys);
         if (keys.length > 0 && keys.every((k) => higher.includes(k)))
             continue;
+        // A membership tier's higher rate on the same purchases replaces the
+        // card's own (BofA Rewards tiers), cap or not.
+        const replaced = shown.some((h) => h !== r &&
+            h.rate > r.rate &&
+            h.requires?.membership !== undefined &&
+            r.requires?.membership === undefined &&
+            JSON.stringify(h.match) === JSON.stringify(r.match) &&
+            JSON.stringify(h.exclude) === JSON.stringify(r.exclude));
+        if (replaced)
+            continue;
         const pending = r.requires?.activation && !isActivated(card, held, r.id);
         const key = [
             `${earnText(catalog, r.rate, currency)} on`,
@@ -109,10 +77,14 @@ function headlineRates(catalog, wallet, card, held, currency, today) {
             const after = `${limit}${activate}`;
             return `${head} ${listed(whats)}${after === '' ? '' : ` (${after.replace(/^, /, '')})`}`;
         }),
-        `${earnText(catalog, card.base_rate, currency)} on everything else`,
+        ...(shown.some((r) => r.match.any && r.rate > card.base_rate)
+            ? []
+            : [`${earnText(catalog, card.base_rate, currency)} on everything else`]),
     ];
 }
-function toActivate(catalog, card, held, today) {
+// Bonuses current or starting soon that the card hasn't activated, one per
+// activation group (one activation covers a quarter's categories).
+export function activationsDue(catalog, card, held, today) {
     const seen = new Set();
     const out = [];
     for (const id of activationRules(card, today)) {
@@ -123,18 +95,25 @@ function toActivate(catalog, card, held, today) {
             seen.add(g);
         const rules = card.rules.filter((r) => group.includes(r.id));
         const first = rules[0];
-        const deadline = first?.activate_by === undefined
-            ? ''
-            : `, activate by ${shortDate(first.activate_by)}`;
-        const when = first?.valid_from !== undefined && first.valid_to !== undefined
-            ? ` (${shortDate(first.valid_from)} to ${shortDate(first.valid_to)}${deadline})`
-            : deadline === ''
-                ? ''
-                : ` (${deadline.slice(2)})`;
-        out.push(`${rules.map((r) => ruleWhat(catalog, r)).join(', ')}${when}`);
+        out.push({
+            what: rules.map((r) => ruleWhat(catalog, r)).join(', '),
+            from: first?.valid_from ?? null,
+            to: first?.valid_to ?? null,
+            activateBy: first?.activate_by ?? null,
+        });
     }
     return out;
 }
+function toActivate(catalog, card, held, today) {
+    return activationsDue(catalog, card, held, today).map((a) => {
+        const deadline = a.activateBy === null ? '' : `activate by ${shortDate(a.activateBy)}`;
+        const dates = a.from !== null && a.to !== null
+            ? `${shortDate(a.from)} to ${shortDate(a.to)}`
+            : '';
+        const when = [dates, deadline].filter((x) => x !== '').join(', ');
+        return `${a.what}${when === '' ? '' : ` (${when})`}`;
+    });
+}
 function capSummaries(catalog, card, held, today) {
     const caps = new Map();
     for (const shared of card.caps)

package/dist/format/wallet-yaml.js

@@ -1,5 +1,6 @@
 import { Document, parse, visit } from 'yaml';
 import { walletProblems } from "../data/integrity.js";
+import { CARD_NUMBER_LABEL, CARD_NUMBER_REDEMPTION, } from "../schema/card-number.js";
 import { WALLET_VERSION, WalletSchema } from "../schema/wallet.js";
 // A wallet as the YAML file the CLI reads, for moving it between the
 // website, the remote server and the command line. Node-free.
@@ -54,7 +55,10 @@ export function parseWalletYaml(text, catalog) {
     }
     const result = WalletSchema.safeParse(raw);
     if (!result.success)
-        return "That isn't an earnrate wallet.";
+        return (result.error.issues
+            .map((i) => i.message)
+            .find((m) => m === CARD_NUMBER_LABEL || m === CARD_NUMBER_REDEMPTION) ??
+            "That isn't an earnrate wallet.");
     const problems = walletProblems(result.data, catalog);
     return problems.length > 0 ? problems.join(' ') : result.data;
 }

package/dist/format/wallet.js

@@ -1,4 +1,10 @@
 import { money, NETWORK_NAMES, shortDate } from "../engine/text.js";
+// "To do now", above the card details; nothing when all's done.
+export function formatChecklist(items) {
+    return items.length === 0
+        ? ''
+        : `To do now:\n${items.map((i) => `- ${i.text}`).join('\n')}\n\n`;
+}
 export function formatWalletSummary(summary) {
     const cards = summary.cards.map((c) => {
         const label = c.checkoutLabel

package/dist/mcp/context.js

@@ -61,10 +61,14 @@ export function makeContext(deps) {
     // neither ever overrides a merchant earnrate already knows.
     async function resolve(merchant, channel, category) {
         const known = resolvePlace(catalog, merchant, channel);
-        if (known.source !== 'none' || category !== null || !deps.llm) {
-            return { merchant: withCallerCategory(known, category), notices: [] };
-        }
-        return deps.llm.resolve(catalog, merchant, channel);
+        const resolved = known.source !== 'none' || category !== null || !deps.llm
+            ? { merchant: withCallerCategory(known, category), notices: [] }
+            : await deps.llm.resolve(catalog, merchant, channel);
+        const source = resolved.merchant.source;
+        if (deps.missed &&
+            (source === 'none' || source === 'caller' || source === 'llm'))
+            await deps.missed.note(merchant, source === 'none' ? null : resolved.merchant.category, deps.today());
+        return resolved;
     }
     // Cards named in the conversation come first, then the saved wallet; with
     // neither (null), answers cover every card earnrate knows.

package/dist/mcp/schemas.js

@@ -86,6 +86,14 @@ export const WalletSummarySchema = z.object({
         redemption: z.string().nullable(),
     })),
     started: z.string().nullable(),
+    checklist: z
+        .array(z.object({
+        kind: z.enum(['activate', 'pick', 'cap', 'bonus', 'rotation']),
+        cardId: z.string(),
+        text: z.string(),
+        due: z.string().nullable(),
+    }))
+        .optional(),
     cards: z.array(z.object({
         cardId: z.string(),
         cardName: z.string(),

package/dist/mcp/serve.js

@@ -3,12 +3,15 @@ import { FileWalletStore } from "../data/file-store.js";
 import { loadCatalog, walletPath } from "../data/load.js";
 import { localToday as today } from "../engine/periods.js";
 import { llmEnabled, openLlmSession } from "../merchants/from-env.js";
+import { missedPath, missLogAt } from "../merchants/missed.js";
 import { packageVersion } from "../version.js";
 import { createEarnrateServer } from "./server.js";
 // stdout carries the protocol, so diagnostics go to stderr only.
 export async function serveMcp(env) {
     const version = await packageVersion();
     const catalog = await loadCatalog();
+    const missedFile = missedPath(env);
+    const missed = missedFile === null ? null : missLogAt(missedFile);
     let llm = null;
     if (llmEnabled(env)) {
         const opened = await openLlmSession({ env, today });
@@ -26,6 +29,7 @@ export async function serveMcp(env) {
         savedWallets: 'file',
         today,
         llm,
+        missed,
         version,
     }));
 }

package/dist/mcp/server.js

@@ -39,7 +39,7 @@ const WHICH_WALLET = {
 };
 const instructions = (savedWallets) => `earnrate answers which credit card earns the most for a purchase, from each issuer's own terms. Anyone can use it without entering anything: with no cards given, best_card_for_purchase, best_cards_for, cheat_sheet, simulate_spending and compare_welcome_offers answer from every card earnrate knows, and that's a complete answer. Never require the user's cards, and don't ask what they spend unless the answer depends on it; simulate_spending assumes typical amounts when none are given and says so.
 
-Personalizing is optional. If the user names their cards, pass them as \`cards\` (ids from search_cards) for that answer; nothing is saved. After answering, offer once to save those cards so earnrate remembers them, and save them with add_card only if the user says yes. ${SAVING[savedWallets]} When a card needs category picks, memberships like Amazon Prime, or activations, ask the user rather than guessing.
+Personalizing is optional. If the user names their cards, pass them as \`cards\` (ids from search_cards) for that answer; nothing is saved. After answering, offer once to save those cards so earnrate remembers them, and save them with add_card only if the user says yes. ${SAVING[savedWallets]} When a card needs category picks, memberships like Amazon Prime, or activations, ask the user rather than guessing. When the user asks what to do with their cards (this quarter, or what they're forgetting), call list_wallet: it starts with a to-do list.
 
 The wallet lists cards by product id, never card numbers; never ask for card numbers, expiry dates or security codes.
 

package/dist/mcp/tools/wallet.js

@@ -3,8 +3,11 @@ import { membershipsFor, needsAnniversary } from "../../engine/setup.js";
 import { choiceName, currencyLabel, listed, money, shortDate, words, } from "../../engine/text.js";
 import { membershipName } from "../../engine/memberships.js";
 import { profileText, VALUATION_PROFILES } from "../../engine/profiles.js";
-import { optionName, walletSummary } from "../../engine/wallet-summary.js";
-import { formatBooking, formatWalletSummary } from "../../format/wallet.js";
+import { optionName } from "../../engine/rule-text.js";
+import { walletSummary } from "../../engine/wallet-summary.js";
+import { checklist } from "../../engine/checklist.js";
+import { cardText } from "../../format/card-text.js";
+import { formatBooking, formatChecklist, formatWalletSummary, } from "../../format/wallet.js";
 import { fail } from "../context.js";
 import { CardChange, CardId, cardInput, ChannelInput, DateInput, Merchant, } from "../inputs.js";
 import { RecordResultSchema, WalletChangeSchema, WalletSummarySchema, } from "../schemas.js";
@@ -52,7 +55,7 @@ export function registerWalletTools(server, deps, ctx, inputs) {
     const { catalog, store } = deps;
     server.registerTool('list_wallet', {
         title: 'List wallet',
-        description: `Lists the user's cards: checkout label, network, rewards currency and its value, spending caps with how much is left this period, chosen bonus categories (and whether they're current), welcome-bonus progress, which stores a store card works at, when each card's data was last verified, the point values the user saved, and (for the hosted wallet) when it was started. ${ctx.walletUse}`,
+        description: `Starts with a to-do list for the user's cards right now (bonuses to activate and their deadlines, categories to pick or confirm, caps nearly used up, welcome bonuses to finish and the weekly pace); use it when the user asks what to do with their cards this quarter or what they're forgetting. Then lists the user's cards: checkout label, network, rewards currency and its value, spending caps with how much is left this period, chosen bonus categories (and whether they're current), welcome-bonus progress, which stores a store card works at, when each card's data was last verified, the point values the user saved, and (for the hosted wallet) when it was started. ${ctx.walletUse}`,
         outputSchema: WalletSummarySchema,
         annotations: {
             title: 'List wallet',
@@ -64,9 +67,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
         if (typeof read === 'string')
             return fail(read);
         const started = deps.savedWallets === 'account' ? await deps.store.started() : null;
+        const base = walletSummary(catalog, read.wallet, deps.today());
         const summary = {
-            ...walletSummary(catalog, read.wallet, deps.today()),
+            ...base,
             started,
+            checklist: checklist(catalog, read.wallet, deps.today(), base, cardText(catalog).shortName),
         };
         const when = started === null
             ? `This is ${ctx.walletName}.\n`
@@ -75,7 +80,7 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             content: [
                 {
                     type: 'text',
-                    text: `${when}${read.start === null ? '' : `${read.start}\n`}${formatWalletSummary(summary)}`,
+                    text: `${when}${read.start === null ? '' : `${read.start}\n`}${formatChecklist(summary.checklist)}${formatWalletSummary(summary)}`,
                 },
             ],
             structuredContent: summary,

package/dist/merchants/cache.js

@@ -1,4 +1,5 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { writeFileAtomic } from "../data/atomic-write.js";
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { z } from 'zod';
@@ -71,10 +72,7 @@ export async function openMerchantCache(file) {
                 merchants = { ...merchants, [key]: toEntry(value) };
                 if (!writable)
                     return;
-                await mkdir(path.dirname(file), { recursive: true });
-                const tmp = `${file}.${String(process.pid)}.tmp`;
-                await writeFile(tmp, `${JSON.stringify({ version: 1, merchants }, null, 2)}\n`);
-                await rename(tmp, file);
+                await writeFileAtomic(file, `${JSON.stringify({ version: 1, merchants }, null, 2)}\n`);
             },
         },
     };

package/dist/merchants/fallback.js

@@ -1,4 +1,5 @@
 import { LLM_MAX_CALLS_ENV_VAR } from "../brand.js";
+import { hasCardNumber } from "../schema/card-number.js";
 import { describeClassifierError } from "./anthropic.js";
 import { normalizeMerchantName, resolveMerchant } from "./resolve.js";
 export const DEFAULT_MAX_CALLS = 20;
@@ -42,6 +43,13 @@ export function createLlmSession(options) {
             const known = resolveMerchant(catalog, input, channel);
             if (known.source !== 'none')
                 return { merchant: known, notices: [] };
+            if (hasCardNumber(input))
+                return {
+                    merchant: known,
+                    notices: [
+                        'Skipped the Claude lookup: that looks like a card number, and earnrate never sends one anywhere.',
+                    ],
+                };
             const key = normalizeMerchantName(input);
             const saved = options.cache.get(key);
             if (saved && usable(catalog, saved)) {

package/dist/merchants/missed.js

@@ -0,0 +1,77 @@
+import { readFile } from 'node:fs/promises';
+import { writeFileAtomic } from "../data/atomic-write.js";
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { CONFIG_DIR, MISSED_ENV_VAR } from "../brand.js";
+import { hasCardNumber } from "../schema/card-number.js";
+import { normalizeMerchantName } from "./resolve.js";
+const MissedFileSchema = z.object({
+    version: z.literal(1),
+    merchants: z.record(z.string(), z.object({
+        name: z.string(),
+        count: z.number().int().positive(),
+        last_seen: z.string(),
+        categories: z.array(z.string()).default([]),
+    })),
+});
+const MAX = 500;
+// $EARNRATE_MISSED_MERCHANTS names another file, or "off" keeps no log.
+export function missedPath(env = process.env) {
+    const given = env[MISSED_ENV_VAR]?.trim();
+    if (given === 'off')
+        return null;
+    return given || path.join(homedir(), CONFIG_DIR, 'missed-merchants.json');
+}
+export async function readMissed(file) {
+    try {
+        const parsed = MissedFileSchema.safeParse(JSON.parse(await readFile(file, 'utf8')));
+        return parsed.success ? Object.values(parsed.data.merchants) : [];
+    }
+    catch {
+        return [];
+    }
+}
+// Writes are queued, so concurrent tool calls never lose a count. A file that
+// can't be read as a log is left alone.
+export function missLogAt(file) {
+    let queue = Promise.resolve();
+    return {
+        note(name, category, today) {
+            const key = normalizeMerchantName(name);
+            if (key === '' || hasCardNumber(name))
+                return Promise.resolve();
+            const run = queue.then(async () => {
+                let merchants = {};
+                try {
+                    const parsed = MissedFileSchema.safeParse(JSON.parse(await readFile(file, 'utf8')));
+                    if (!parsed.success)
+                        return;
+                    merchants = parsed.data.merchants;
+                }
+                catch (e) {
+                    if (!(e instanceof Error && 'code' in e && e.code === 'ENOENT'))
+                        return;
+                }
+                const seen = merchants[key];
+                merchants[key] = {
+                    name: name.trim(),
+                    count: (seen?.count ?? 0) + 1,
+                    last_seen: today,
+                    categories: [
+                        ...new Set([
+                            ...(seen?.categories ?? []),
+                            ...(category === null ? [] : [category]),
+                        ]),
+                    ],
+                };
+                const kept = Object.entries(merchants)
+                    .sort(([, a], [, b]) => b.last_seen.localeCompare(a.last_seen))
+                    .slice(0, MAX);
+                await writeFileAtomic(file, `${JSON.stringify({ version: 1, merchants: Object.fromEntries(kept) }, null, 2)}\n`);
+            });
+            queue = run.catch(() => undefined);
+            return run.catch(() => undefined);
+        },
+    };
+}