earnrate 0.2.15 → 0.2.17

package/dist/mcp/tools/wallet.js

@@ -57,14 +57,206 @@ function changes(catalog, args) {
             : `enrolled in: ${args.enrolled.join(', ')}`);
     for (const [id, used] of Object.entries(args.creditUsed ?? {}))
         out.push(`${money(used)} of the ${id} credit used this period`);
+    if (args.skippedCredits !== undefined)
+        out.push(args.skippedCredits.length === 0
+            ? 'every credit counted'
+            : `credits not used: ${args.skippedCredits.join(', ')}`);
     if (args.bonus === null)
         out.push('welcome bonus no longer tracked');
     else if (args.bonus !== undefined)
         out.push(`welcome bonus tracked from ${args.bonus.opened}, ${money(args.bonus.spent ?? 0)} spent so far`);
     return out;
 }
-export function registerWalletTools(server, deps, ctx, inputs) {
+// The saved wallet with its summary and to-do list, as list_wallet shows it.
+export async function walletListing(deps, ctx) {
+    const read = await ctx.readableWallet();
+    if (typeof read === 'string')
+        return read;
+    const started = deps.savedWallets === 'account' ? await deps.store.started() : null;
+    const base = walletSummary(deps.catalog, read.wallet, deps.today());
+    const summary = {
+        ...base,
+        started,
+        checklist: checklist(deps.catalog, read.wallet, deps.today(), base, cardText(deps.catalog).shortName),
+    };
+    return { ...read, summary };
+}
+export function walletHandlers(deps, ctx, inputs) {
     const { catalog, store } = deps;
+    const listWallet = {
+        input: z.object({}),
+        run: async () => {
+            const found = await walletListing(deps, ctx);
+            if (typeof found === 'string')
+                return fail(found);
+            const { start, summary } = found;
+            const when = summary.started === null
+                ? `This is ${ctx.walletName}.\n`
+                : `This is ${ctx.walletName}. ${startedText(summary.started, Date.now())}\n`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${when}${start === null ? '' : `${start}\n`}${formatChecklist(summary.checklist)}${formatWalletSummary(summary)}`,
+                    },
+                ],
+                structuredContent: summary,
+            };
+        },
+    };
+    const RecordInput = z.object({
+        cardId: z
+            .string()
+            .min(1)
+            .describe('The card used, as a cardId from list_wallet or best_card_for_purchase.'),
+        merchant: Merchant,
+        amount: z.number().positive().describe('Amount spent in US dollars.'),
+        channel: ChannelInput,
+        date: DateInput,
+        category: inputs.RecordCategoryInput,
+    });
+    const recordPurchase = {
+        input: RecordInput,
+        run: async ({ cardId, merchant, amount, channel, date, category }) => {
+            const w = await ctx.wallet();
+            if (typeof w === 'string')
+                return fail(w);
+            if (!w.cards.some((c) => c.id === cardId))
+                return fail(`"${cardId}" isn't in the wallet. Cards: ${w.cards.map((c) => c.id).join(', ')}.`);
+            const purchase = {
+                cardId,
+                merchant,
+                amount,
+                channel: channel ?? null,
+                date: date ?? deps.today(),
+            };
+            const resolved = await ctx.resolve(merchant, purchase.channel, category ?? null);
+            if (resolved.merchant.source === 'none')
+                return fail(`earnrate doesn't recognize "${merchant}", so it can't tell which caps this purchase counts toward. Nothing was recorded. Call record_purchase again with category if you can tell what kind of business it is (a restaurant, a grocery store, a gas station), or ask the user. If nobody knows, category "other" records it toward a welcome bonus without touching any cap.`);
+            const result = await store.record(purchase, resolved.merchant);
+            if (!result.ok)
+                return fail(`Couldn't record it: ${result.error}`);
+            const { cap: booking, bonus, milestones, credit } = result;
+            const capLabel = booking
+                ? (walletSummary(catalog, w, purchase.date)
+                    .cards.find((c) => c.cardId === cardId)
+                    ?.caps.find((c) => c.key === booking.capKey)?.label ?? null)
+                : null;
+            const output = booking || bonus || milestones.length > 0 || credit
+                ? {
+                    recorded: true,
+                    booking,
+                    bonus,
+                    milestones,
+                    credit,
+                    message: `${formatBooking(amount, cardText(catalog).shortName(cardId), booking, bonus, milestones, credit, capLabel)} Saved in ${ctx.walletName}.`,
+                }
+                : {
+                    recorded: false,
+                    booking: null,
+                    bonus: null,
+                    milestones: [],
+                    credit: null,
+                    message: `Nothing to track: ${cardText(catalog).shortName(cardId)} has no spending cap, open welcome bonus, spend bonus or enrolled statement credit for this purchase, so the wallet wasn't changed.`,
+                };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: [output.message, ...resolved.notices].join('\n'),
+                    },
+                ],
+                structuredContent: output,
+            };
+        },
+    };
+    const addCard = {
+        input: CardChange,
+        run: async (args) => {
+            const result = await store.addCard(cardInput(args), deps.today());
+            const started = !result.ok || !result.created
+                ? ''
+                : deps.savedWallets === 'account'
+                    ? ', the first card in your saved wallet'
+                    : `, starting a new wallet at ${store.where}`;
+            return ctx.changed(result, `Added ${ctx.cardName(args.cardId)} (${args.cardId})${started}.`);
+        },
+    };
+    const updateCard = {
+        input: CardChange,
+        run: async (args) => {
+            const what = changes(catalog, args);
+            const card = catalog.cards.find((c) => c.id === args.cardId);
+            const unused = args.anniversary !== undefined && card && !needsAnniversary(card)
+                ? " None of its caps reset on the account anniversary, so earnrate doesn't use it."
+                : '';
+            return ctx.changed(await store.updateCard(cardInput(args), deps.today()), `Updated ${ctx.cardName(args.cardId)} (${args.cardId})${what.length > 0 ? `: ${what.join('; ')}` : ''}.${unused}`);
+        },
+    };
+    const RemoveInput = z.object({ cardId: CardId });
+    const removeCard = {
+        input: RemoveInput,
+        run: async ({ cardId }) => ctx.changed(await store.removeCard(cardId), `Removed ${ctx.cardName(cardId)} (${cardId}).`, { notes: false }),
+    };
+    const MembershipsInput = z.object({ memberships: inputs.AllMemberships });
+    const setMemberships = {
+        input: MembershipsInput,
+        run: async ({ memberships }) => {
+            const result = await store.setMemberships(memberships);
+            const used = new Set((result.ok ? result.wallet.cards : []).flatMap((held) => {
+                const card = catalog.cards.find((c) => c.id === held.id);
+                return card ? membershipsFor(card) : [];
+            }));
+            const unused = memberships.filter((m) => !used.has(m));
+            return ctx.changed(result, `${memberships.length > 0
+                ? `Memberships set to ${memberships.map((m) => `${membershipName(catalog, m)} (${m})`).join(', ')}.`
+                : 'Memberships cleared.'}${unused.length > 0 ? ` ${listed(unused.map((m) => membershipName(catalog, m)))} ${unused.length === 1 ? "doesn't" : "don't"} change any saved card's rates yet; kept for cards that use ${unused.length === 1 ? 'it' : 'them'}.` : ''}`, { notes: false });
+        },
+    };
+    const PointValuesInput = z.object({
+        values: z
+            .record(z.string(), z.number().nullable())
+            .optional()
+            .describe('Cents per point by currency id, e.g. {"UR": 1.5, "MR": 1.6}. null goes back to the default.'),
+        profile: z
+            .enum(['flat', 'points-heavy'])
+            .optional()
+            .describe(`A preset: flat (${profileText('flat')}) or points-heavy (${profileText('points-heavy')}). Values given too win over it.`),
+    });
+    const setPointValues = {
+        input: PointValuesInput,
+        run: async ({ values, profile }) => {
+            const given = currencyChanges(catalog, values ?? {});
+            if (!given.ok)
+                return fail(given.error);
+            const changes = {
+                ...(profile ? VALUATION_PROFILES[profile] : {}),
+                ...given.changes,
+            };
+            if (Object.keys(changes).length === 0)
+                return fail('Give values (cents per point by currency) or a profile.');
+            const result = await store.setValuations(changes);
+            const set = Object.entries(changes).map(([id, cents]) => cents === null
+                ? `${currencyLabel(catalog, id)} back to the default`
+                : `${currencyLabel(catalog, id)} at ${String(cents)}¢`);
+            return ctx.changed(result, `Point values: ${set.join(', ')}.`, {
+                notes: false,
+            });
+        },
+    };
+    return {
+        list_wallet: listWallet,
+        record_purchase: recordPurchase,
+        add_card: addCard,
+        update_card: updateCard,
+        remove_card: removeCard,
+        set_memberships: setMemberships,
+        set_point_values: setPointValues,
+    };
+}
+export function registerWalletTools(server, deps, ctx, inputs) {
+    const { catalog } = deps;
+    const tools = walletHandlers(deps, ctx, inputs);
     server.registerTool('list_wallet', {
         title: 'List wallet',
         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, yearly spend bonuses at least 75% of the way, statement credits to enroll in or use before they reset); 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, progress toward yearly spend bonuses, statement credits (enrolled or not, and what's left this period), 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}`,
@@ -75,44 +267,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: false,
             openWorldHint: false,
         },
-    }, async () => {
-        const read = await ctx.readableWallet();
-        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 = {
-            ...base,
-            started,
-            checklist: checklist(catalog, read.wallet, deps.today(), base, cardText(catalog).shortName),
-        };
-        const when = started === null
-            ? `This is ${ctx.walletName}.\n`
-            : `This is ${ctx.walletName}. ${startedText(started, Date.now())}\n`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `${when}${read.start === null ? '' : `${read.start}\n`}${formatChecklist(summary.checklist)}${formatWalletSummary(summary)}`,
-                },
-            ],
-            structuredContent: summary,
-        };
-    });
+    }, () => tools.list_wallet.run());
     server.registerTool('record_purchase', {
         title: 'Record a purchase',
         description: `Records a purchase the user has already made, so spending caps, welcome-bonus progress, yearly spend bonuses and statement credits used stay accurate for future recommendations. It updates the user's saved wallet. Only call it after the purchase has happened, and only once per purchase: calling it twice counts the spend twice. Purchases with no cap, no open welcome bonus, no spend bonus and no enrolled statement credit are acknowledged and nothing is written. For a merchant earnrate doesn't recognize it asks for category first, so caps aren't missed. ${ctx.walletUse}`,
-        inputSchema: z.object({
-            cardId: z
-                .string()
-                .min(1)
-                .describe('The card used, as a cardId from list_wallet or best_card_for_purchase.'),
-            merchant: Merchant,
-            amount: z.number().positive().describe('Amount spent in US dollars.'),
-            channel: ChannelInput,
-            date: DateInput,
-            category: inputs.RecordCategoryInput,
-        }),
+        inputSchema: tools.record_purchase.input,
         outputSchema: RecordResultSchema,
         annotations: {
             title: 'Record a purchase',
@@ -121,62 +280,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             idempotentHint: false,
             openWorldHint: deps.llm !== null,
         },
-    }, async ({ cardId, merchant, amount, channel, date, category }) => {
-        const w = await ctx.wallet();
-        if (typeof w === 'string')
-            return fail(w);
-        if (!w.cards.some((c) => c.id === cardId))
-            return fail(`"${cardId}" isn't in the wallet. Cards: ${w.cards.map((c) => c.id).join(', ')}.`);
-        const purchase = {
-            cardId,
-            merchant,
-            amount,
-            channel: channel ?? null,
-            date: date ?? deps.today(),
-        };
-        const resolved = await ctx.resolve(merchant, purchase.channel, category ?? null);
-        if (resolved.merchant.source === 'none')
-            return fail(`earnrate doesn't recognize "${merchant}", so it can't tell which caps this purchase counts toward. Nothing was recorded. Call record_purchase again with category if you can tell what kind of business it is (a restaurant, a grocery store, a gas station), or ask the user. If nobody knows, category "other" records it toward a welcome bonus without touching any cap.`);
-        const result = await store.record(purchase, resolved.merchant);
-        if (!result.ok)
-            return fail(`Couldn't record it: ${result.error}`);
-        const { cap: booking, bonus, milestones, credit } = result;
-        const capLabel = booking
-            ? (walletSummary(catalog, w, purchase.date)
-                .cards.find((c) => c.cardId === cardId)
-                ?.caps.find((c) => c.key === booking.capKey)?.label ?? null)
-            : null;
-        const output = booking || bonus || milestones.length > 0 || credit
-            ? {
-                recorded: true,
-                booking,
-                bonus,
-                milestones,
-                credit,
-                message: `${formatBooking(amount, cardText(catalog).shortName(cardId), booking, bonus, milestones, credit, capLabel)} Saved in ${ctx.walletName}.`,
-            }
-            : {
-                recorded: false,
-                booking: null,
-                bonus: null,
-                milestones: [],
-                credit: null,
-                message: `Nothing to track: ${cardText(catalog).shortName(cardId)} has no spending cap, open welcome bonus, spend bonus or enrolled statement credit for this purchase, so the wallet wasn't changed.`,
-            };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [output.message, ...resolved.notices].join('\n'),
-                },
-            ],
-            structuredContent: output,
-        };
-    });
+    }, (args) => tools.record_purchase.run(args));
     server.registerTool('add_card', {
         title: 'Add a card',
         description: `Adds a card the user holds to their wallet by its id from search_cards, creating the wallet if there isn't one. The reply says what the card still needs (category picks, memberships, activations); ask the user about those. Stores only the card's product id and settings, never card numbers. ${ctx.walletUse}`,
-        inputSchema: CardChange,
+        inputSchema: tools.add_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Add a card',
@@ -184,19 +292,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async (args) => {
-        const result = await store.addCard(cardInput(args), deps.today());
-        const started = !result.ok || !result.created
-            ? ''
-            : deps.savedWallets === 'account'
-                ? ', the first card in your saved wallet'
-                : `, starting a new wallet at ${store.where}`;
-        return ctx.changed(result, `Added ${ctx.cardName(args.cardId)} (${args.cardId})${started}.`);
-    });
+    }, (args) => tools.add_card.run(args));
     server.registerTool('update_card', {
         title: 'Update a card',
-        description: `Changes settings on a card already in the wallet: its category picks for this period, checkout label, anniversary, opening date (optional; for first-year rates), activated categories, cap spending so far (capSpent), spending this year toward its spend bonuses (milestoneSpent), statement credits enrolled in (enrolled) and used this period (creditUsed), or a welcome bonus to track. Picks replace the saved ones in each choice group you set (other groups are kept) for the current period. Use it when the user picks new categories, such as each quarter on U.S. Bank Cash+. ${ctx.walletUse}`,
-        inputSchema: CardChange,
+        description: `Changes settings on a card already in the wallet: its category picks for this period, checkout label, anniversary, opening date (optional; for first-year rates), activated categories, cap spending so far (capSpent), spending this year toward its spend bonuses (milestoneSpent), statement credits enrolled in (enrolled), used this period (creditUsed) or not used at all (skippedCredits), or a welcome bonus to track. Picks replace the saved ones in each choice group you set (other groups are kept) for the current period. Use it when the user picks new categories, such as each quarter on U.S. Bank Cash+. ${ctx.walletUse}`,
+        inputSchema: tools.update_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Update a card',
@@ -204,18 +304,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async (args) => {
-        const what = changes(catalog, args);
-        const card = catalog.cards.find((c) => c.id === args.cardId);
-        const unused = args.anniversary !== undefined && card && !needsAnniversary(card)
-            ? " None of its caps reset on the account anniversary, so earnrate doesn't use it."
-            : '';
-        return ctx.changed(await store.updateCard(cardInput(args), deps.today()), `Updated ${ctx.cardName(args.cardId)} (${args.cardId})${what.length > 0 ? `: ${what.join('; ')}` : ''}.${unused}`);
-    });
+    }, (args) => tools.update_card.run(args));
     server.registerTool('remove_card', {
         title: 'Remove a card',
         description: `Removes a card from the wallet, with its tracked cap usage, bonus progress and yearly spending. Memberships and point values stay, even when the last card goes. Only when the user says they no longer have it or don't want it considered. ${ctx.walletUse}`,
-        inputSchema: z.object({ cardId: CardId }),
+        inputSchema: tools.remove_card.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Remove a card',
@@ -223,11 +316,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ cardId }) => ctx.changed(await store.removeCard(cardId), `Removed ${ctx.cardName(cardId)} (${cardId}).`, { notes: false }));
+    }, (args) => tools.remove_card.run(args));
     server.registerTool('set_memberships', {
         title: 'Set memberships',
         description: `Sets the memberships that unlock some cards' rates, such as amazon-prime for Prime Visa's 5% or a Bank of America Preferred Rewards tier, and costco for a Costco membership (so spending answers don't count its cost against Costco Anywhere). Replaces the whole list, so include the ones to keep. It saves them even with no cards saved, and every answer then uses them. ${ctx.walletUse}`,
-        inputSchema: z.object({ memberships: inputs.AllMemberships }),
+        inputSchema: tools.set_memberships.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Set memberships',
@@ -235,30 +328,11 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ memberships }) => {
-        const result = await store.setMemberships(memberships);
-        const used = new Set((result.ok ? result.wallet.cards : []).flatMap((held) => {
-            const card = catalog.cards.find((c) => c.id === held.id);
-            return card ? membershipsFor(card) : [];
-        }));
-        const unused = memberships.filter((m) => !used.has(m));
-        return ctx.changed(result, `${memberships.length > 0
-            ? `Memberships set to ${memberships.map((m) => `${membershipName(catalog, m)} (${m})`).join(', ')}.`
-            : 'Memberships cleared.'}${unused.length > 0 ? ` ${listed(unused.map((m) => membershipName(catalog, m)))} ${unused.length === 1 ? "doesn't" : "don't"} change any saved card's rates yet; kept for cards that use ${unused.length === 1 ? 'it' : 'them'}.` : ''}`, { notes: false });
-    });
+    }, (args) => tools.set_memberships.run(args));
     server.registerTool('set_point_values', {
         title: 'Set point values',
         description: `Saves what the user's points are worth to them, in cents per point, in their saved wallet; every answer then compares cards at those values unless a valuation profile is asked for. No saved cards are needed. Use it when the user says what their points are worth ("I value Chase points at 1.5¢") or that they transfer points to airlines and hotels (profile points-heavy). Values change only the currencies given; null goes back to earnrate's default. Currencies by id: ${catalog.currencies.map((c) => `${c.id} (${c.name})`).join(', ')}. ${ctx.walletUse}`,
-        inputSchema: z.object({
-            values: z
-                .record(z.string(), z.number().nullable())
-                .optional()
-                .describe('Cents per point by currency id, e.g. {"UR": 1.5, "MR": 1.6}. null goes back to the default.'),
-            profile: z
-                .enum(['flat', 'points-heavy'])
-                .optional()
-                .describe(`A preset: flat (${profileText('flat')}) or points-heavy (${profileText('points-heavy')}). Values given too win over it.`),
-        }),
+        inputSchema: tools.set_point_values.input,
         outputSchema: WalletChangeSchema,
         annotations: {
             title: 'Set point values',
@@ -266,22 +340,5 @@ export function registerWalletTools(server, deps, ctx, inputs) {
             destructiveHint: true,
             idempotentHint: true,
         },
-    }, async ({ values, profile }) => {
-        const given = currencyChanges(catalog, values ?? {});
-        if (!given.ok)
-            return fail(given.error);
-        const changes = {
-            ...(profile ? VALUATION_PROFILES[profile] : {}),
-            ...given.changes,
-        };
-        if (Object.keys(changes).length === 0)
-            return fail('Give values (cents per point by currency) or a profile.');
-        const result = await store.setValuations(changes);
-        const set = Object.entries(changes).map(([id, cents]) => cents === null
-            ? `${currencyLabel(catalog, id)} back to the default`
-            : `${currencyLabel(catalog, id)} at ${String(cents)}¢`);
-        return ctx.changed(result, `Point values: ${set.join(', ')}.`, {
-            notes: false,
-        });
-    });
+    }, (args) => tools.set_point_values.run(args));
 }

package/dist/mcp/wallet-api.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { makeContext } from "./context.js";
+import { makeInputs } from "./inputs.js";
+import { importHandler } from "./tools/account.js";
+import { walletHandlers, walletListing } from "./tools/wallet.js";
+// The changes earnrate.dev can make to a synced wallet, by MCP tool name.
+// import_wallet replaces it all, with the tool's own confirmation.
+export const WALLET_CHANGES = [
+    'add_card',
+    'update_card',
+    'remove_card',
+    'set_memberships',
+    'set_point_values',
+    'record_purchase',
+    'import_wallet',
+];
+const ChangeRequest = z.object({
+    tool: z.enum(WALLET_CHANGES),
+    input: z.record(z.string(), z.unknown()).optional(),
+});
+// The hosted wallet over plain HTTP: reads give what list_wallet gives, and
+// each change runs the MCP tool's own handler, so the rules and refusals
+// can't drift between earnrate.dev and Claude.
+export function walletApi(deps) {
+    const server = {
+        ...deps,
+        savedWallets: 'account',
+        llm: null,
+        version: '',
+    };
+    const ctx = makeContext(server);
+    const handlers = {
+        ...walletHandlers(server, ctx, makeInputs(deps.catalog)),
+        import_wallet: importHandler(deps.catalog, deps.store, ctx),
+    };
+    async function read() {
+        const found = await walletListing(server, ctx);
+        if (typeof found === 'string')
+            return { status: 422, body: { error: found } };
+        return {
+            status: 200,
+            body: { wallet: found.wallet, summary: found.summary },
+        };
+    }
+    // `body` is the request's parsed JSON: {"tool": "add_card", "input": {...}}.
+    async function change(body) {
+        const request = ChangeRequest.safeParse(body);
+        if (!request.success)
+            return {
+                status: 400,
+                body: {
+                    error: `Send one change as {"tool": ..., "input": {...}}, where tool is one of ${WALLET_CHANGES.join(', ')}.`,
+                },
+            };
+        const { tool, input } = request.data;
+        const handler = handlers[tool];
+        const args = handler.input.safeParse(input ?? {});
+        if (!args.success)
+            return {
+                status: 400,
+                tool,
+                body: {
+                    error: `Invalid input for ${tool}: ${z.prettifyError(args.error)}`,
+                },
+            };
+        const result = await handler.run(args.data);
+        const text = result.content.map((c) => c.text).join('\n');
+        if (result.isError)
+            return { status: 422, tool, body: { error: text } };
+        const after = await read();
+        return {
+            status: after.status,
+            tool,
+            body: after.status === 200 ? { message: text, ...after.body } : after.body,
+        };
+    }
+    return { read, change };
+}

package/dist/schema/card.js

@@ -23,6 +23,9 @@ export const MilestoneSchema = z
     period: z.enum(['calendar_year', 'cardmember_year']),
     points: z.number().positive().optional(), // in the card's currency
     rewards: z.array(z.string().min(1)).min(1).optional(),
+    // The day the issuer starts it, for one announced ahead: spending counts
+    // from then.
+    valid_from: IsoDate.optional(),
     note: z.string().optional(),
 })
     .refine((m) => m.points !== undefined || m.rewards !== undefined, 'a milestone needs points, rewards or both');
@@ -76,6 +79,9 @@ export const RuleSchema = z
     geography: z
         .enum(['us_only', 'foreign_only', 'worldwide'])
         .default('worldwide'),
+    // Only a purchase of at least this many dollars. Unknown without an
+    // amount, so then it never applies by assumption.
+    min_amount: z.number().positive().optional(),
     // Inline cap, or the id of a shared cap in the card's `caps`.
     cap: z.union([CapSchema, KebabId]).optional(),
     requires: z
@@ -186,6 +192,11 @@ export const CreditSchema = z.strictObject({
     period: CreditPeriod,
     // The cardholder must enroll with the issuer before it pays.
     enroll: z.literal(true).optional(),
+    // It pays only on a purchase of at least this many dollars.
+    min_amount: z.number().positive().optional(),
+    // The issuer's last day for it. Past it the credit counts nowhere, and a
+    // year's worth counts only the periods that start by then.
+    valid_to: IsoDate.optional(),
     note: z.string().optional(),
 });
 const HexColor = z.string().regex(/^#[0-9a-f]{6}$/);

package/dist/schema/wallet.js

@@ -46,10 +46,14 @@ export const WalletCardSchema = z.strictObject({
     activated: z.array(KebabId).default([]),
     // Keyed by milestone id: every purchase on the card this period.
     milestone_usage: z.record(KebabId, CapUsage).optional(),
-    // Merchant credits (the card's `credits`) the cardholder has enrolled in,
-    // by credit id, and the dollars of each credit already received this period.
+    // Merchant credits (the card's `credits`) the cardholder has enrolled in
+    // or, for ones that need no enrolling, says they use, by credit id; and
+    // the dollars of each credit already received this period.
     enrolled: z.array(KebabId).optional(),
     credit_usage: z.record(KebabId, CreditUsage).optional(),
+    // Credits the cardholder doesn't use: left out of the pick, the to-do
+    // list and the fee math, even if enrolled.
+    skipped_credits: z.array(KebabId).optional(),
     // A welcome bonus in progress. Terms default to the card's published
     // offer; set spend, by, points or dollars when yours was different.
     bonus: z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "earnrate",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Which credit card earns the most at a merchant, from your cards or every card, and why",
   "keywords": [
     "credit cards",