continentept-mcp 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -6,6 +6,32 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-10-15
+
+### Fixed
+
+- The first request after the browser started could fail with "The order history page was not recognised", or a search error, while the website was still setting up its session. A page that does not show what it should is now loaded once more.
+- Order dates with abbreviated months, as the website now shows them ("01 Set 26"), are read. They were all `null`.
+- `get_product` reports a product the website no longer sells as `not_found`, instead of `invalid_data`.
+- After an upgrade, the update check no longer reports an older version as the latest one.
+
+## [0.6.0] - 2026-10-15
+
+### Changed
+
+- **Breaking:** `get_cart` returns `totals` instead of `total`: `products`, `bags`, `deposit`, `delivery`, `discounts` and `grandTotal`, the amount to pay. The old `total` left out the bags, so it was less than the amount to pay.
+- **Breaking:** cart line prices are `{ amount, per }` price tags, like catalogue prices, plus a `lineTotal`. Products sold by the piece but priced by weight were shown as a price "each" when it was the price per kg.
+
+### Added
+
+- Cart lines have a `kind`, `bag` for the shopping bags the website adds by itself and `product` for everything else.
+- `search_products` and `get_product` return `recommendedPrice`, the recommended retail price (PVPR) the website shows beside the price on many promotions, so assistants can compare it with the selling price. ([#4](https://github.com/andredelgado/continente-mcp/pull/4), thanks [@Lozano-Miguel](https://github.com/Lozano-Miguel))
+
+### Fixed
+
+- Products sold by the piece but priced per kilogram (fruit, vegetables, meat, fish, counter cheese and ham) had no sale rules, so they could not be added to the cart. Their maximum is now read in kilograms, like the minimum and step, and converted to whole pieces.
+- Cart quantities now have a unit. They were all reported as `unknown`; each line's unit now comes from its own sale rules, so a weighted line reads as pieces. A cart change is no longer confirmed by a line that reports another unit.
+
 ## [0.5.0] - 2026-10-15
 
 ### Fixed
@@ -71,7 +97,9 @@ All notable changes to this project are documented here. The format follows
 - Automatic sign-in from environment variables or a private credentials file, and a `login` command.
 - The `basket-planner` skill for planning a shopping list and updating the basket.
 
-[Unreleased]: https://github.com/andredelgado/continente-mcp/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/andredelgado/continente-mcp/compare/v0.6.1...HEAD
+[0.6.1]: https://github.com/andredelgado/continente-mcp/compare/v0.6.0...v0.6.1
+[0.6.0]: https://github.com/andredelgado/continente-mcp/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/andredelgado/continente-mcp/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/andredelgado/continente-mcp/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/andredelgado/continente-mcp/compare/v0.3.0...v0.3.1

package/README.md

@@ -119,7 +119,7 @@ Continente cart"* or *"What do I usually buy? Build me a list for this week."*
 | `search_products` | Search the catalogue; favorites rank first |
 | `get_product` | Price, availability and sale rules for one product |
 | `list_favorites` | Your saved favorites (`refresh: true` fetches the latest) |
-| `get_cart` | Cart lines, quantities and total |
+| `get_cart` | Cart lines, quantities, bags and totals |
 | `add_cart_item` | Add an amount on top of what is in the cart |
 | `set_cart_item_quantity` | Make the cart hold exactly a quantity; zero removes |
 | `remove_cart_item` | Remove a line from the cart |

package/dist/clients/storefront.d.ts

@@ -7,6 +7,16 @@ export declare class StorefrontClient {
     constructor(session: StorefrontSession);
     io<T>(lease: BrowserLease, operation: () => Promise<T>): Promise<T>;
     navigateToStorefrontPage(path: string): Promise<Result<BrowserLease, ToolError>>;
+    /**
+     * Load a page and wait for a marker only the expected page has. A fresh browser's first visit can
+     * land on an interim page while the website sets up its session, so a page without the marker is
+     * loaded once more; `ready` says whether the marker appeared. `landed` rejects a final URL early.
+     */
+    readPage(path: string, marker: string, landed?: (url: URL) => ToolError | null): Promise<Result<{
+        html: string;
+        url: string;
+        ready: boolean;
+    }, ToolError>>;
     html(path: string, marker?: string): Promise<Result<string, ToolError>>;
 }
 export declare class CatalogClient implements CatalogGateway {

package/dist/clients/storefront.js

@@ -40,20 +40,36 @@ export class StorefrontClient {
             return browserFailure(error);
         }
     }
-    async html(path, marker = 'main, [role="main"], .product-line, a[href*="/produto/"]') {
-        const response = await this.navigateToStorefrontPage(path);
-        if (!response.ok)
-            return response;
-        try {
-            await this.io(response.value, () => response.value.page.waitForSelector(marker, { state: 'attached', timeout: requestTimeout(10000) }));
-            return success(await this.io(response.value, () => response.value.page.content()));
-        }
-        catch (error) {
-            if (error instanceof RequestStopped)
-                throw error;
-            return failure('upstream_unavailable', 'Page readiness marker was not found');
+    /**
+     * Load a page and wait for a marker only the expected page has. A fresh browser's first visit can
+     * land on an interim page while the website sets up its session, so a page without the marker is
+     * loaded once more; `ready` says whether the marker appeared. `landed` rejects a final URL early.
+     */
+    async readPage(path, marker, landed) {
+        for (let attempt = 1;; attempt++) {
+            const response = await this.navigateToStorefrontPage(path);
+            if (!response.ok)
+                return response;
+            const lease = response.value;
+            const rejected = landed?.(new URL(lease.page.url()));
+            if (rejected)
+                return { ok: false, error: rejected };
+            try {
+                const ready = await this.io(lease, () => lease.page.waitForSelector(marker, { state: 'attached', timeout: requestTimeout(10000) }).then(() => true, () => false));
+                if (ready || attempt === 2)
+                    return success({ html: await this.io(lease, () => lease.page.content()), url: lease.page.url(), ready });
+            }
+            catch (error) {
+                return browserFailure(error);
+            }
         }
     }
+    async html(path, marker = 'main, [role="main"], .product-line, a[href*="/produto/"]') {
+        const page = await this.readPage(path, marker);
+        if (!page.ok)
+            return page;
+        return page.value.ready ? success(page.value.html) : failure('upstream_unavailable', 'Page readiness marker was not found');
+    }
 }
 export class CatalogClient {
     site;
@@ -61,18 +77,11 @@ export class CatalogClient {
         this.site = site;
     }
     async fetchProductDetails(reference) {
-        const result = await this.site.navigateToStorefrontPage(productPath(reference));
-        if (!result.ok)
-            return result;
-        try {
-            await this.site.io(result.value, () => result.value.page.waitForSelector('h1.product-name, main', { state: 'attached', timeout: requestTimeout(10000) }));
-            return success({ html: await this.site.io(result.value, () => result.value.page.content()), url: result.value.page.url() });
-        }
-        catch (error) {
-            if (error instanceof RequestStopped)
-                throw error;
-            return failure('invalid_data', 'Product detail content is unavailable');
-        }
+        // The website redirects a product it no longer sells to its home page.
+        const page = await this.site.readPage(productPath(reference), 'h1.product-name, .ct-pdp--prices', url => url.pathname.startsWith('/produto/') ? null : failure('not_found', 'This product is no longer sold on the website').error);
+        if (!page.ok)
+            return page;
+        return page.value.ready ? success({ html: page.value.html, url: page.value.url }) : failure('invalid_data', 'Product detail content is unavailable');
     }
     async searchProducts(query, limit) {
         const first = await this.site.html(`/pesquisa/?q=${encodeURIComponent(query)}`, '.ct-inner-tile-wrap, .search-noresults-wrapper, .search-no-results, [data-search-empty]');
@@ -280,17 +289,9 @@ export class OrdersClient {
         const path = cursor === undefined ? '/conta/encomendas/' : orderHistoryUrl(cursor);
         if (!path)
             return failure('invalid_input', 'Invalid order history cursor');
-        const response = await this.site.navigateToStorefrontPage(path);
-        if (!response.ok)
-            return response;
-        const { page } = response.value;
-        try {
-            await this.site.io(response.value, () => page.waitForSelector('main, [role="main"], a[href*="detalhe-encomenda"]', { state: 'attached', timeout: requestTimeout(10000) }));
-            return success(await this.site.io(response.value, () => page.content()));
-        }
-        catch (error) {
-            return browserFailure(error);
-        }
+        // Without the marker the page is still handed to the parser, which says what it does not recognise.
+        const page = await this.site.readPage(path, '.ct-order-history--landing-container, .ct-order-history--order-preview-item');
+        return page.ok ? success(page.value.html) : page;
     }
     async fetchOrderLines(url) {
         const href = storefrontUrl(url);

package/dist/domain/models.d.ts

@@ -48,6 +48,18 @@ export declare const ProductSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>>;
     packageText: z.ZodNullable<z.ZodString>;
+    recommendedPrice: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>;
+        per: z.ZodEnum<{
+            item: "item";
+            kg: "kg";
+            l: "l";
+            piece: "piece";
+        }>;
+    }, z.core.$strict>>;
     minimumText: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type Product = z.infer<typeof ProductSchema>;
@@ -55,6 +67,10 @@ export declare const CartItemSchema: z.ZodObject<{
     productId: z.core.$ZodBranded<z.ZodString, "ProductId", "out">;
     cartItemId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CartItemId", "out">>;
     name: z.ZodString;
+    kind: z.ZodEnum<{
+        bag: "bag";
+        product: "product";
+    }>;
     quantity: z.ZodDiscriminatedUnion<[z.ZodObject<{
         status: z.ZodLiteral<"known">;
         quantity: z.ZodObject<{
@@ -78,25 +94,62 @@ export declare const CartItemSchema: z.ZodObject<{
             unsupported_unit: "unsupported_unit";
         }>>;
     }, z.core.$strict>], "status">;
-    price: z.ZodObject<{
-        amount: z.ZodNullable<z.ZodObject<{
+    price: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodObject<{
             currency: z.ZodLiteral<"EUR">;
             minorUnits: z.ZodNumber;
-        }, z.core.$strict>>;
-        basis: z.ZodEnum<{
-            line: "line";
-            unit: "unit";
-            unknown: "unknown";
+        }, z.core.$strict>;
+        per: z.ZodEnum<{
+            item: "item";
+            kg: "kg";
+            l: "l";
+            piece: "piece";
         }>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
+    lineTotal: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type CartItem = z.infer<typeof CartItemSchema>;
+/** Each amount as the website reports it, or null when it reports none. */
+export declare const CartTotalsSchema: z.ZodObject<{
+    products: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+    bags: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+    deposit: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+    delivery: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+    discounts: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+    grandTotal: z.ZodNullable<z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        minorUnits: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CartTotals = z.infer<typeof CartTotalsSchema>;
 export declare const CartSchema: z.ZodObject<{
     customerAuthenticated: z.ZodBoolean;
     items: z.ZodArray<z.ZodObject<{
         productId: z.core.$ZodBranded<z.ZodString, "ProductId", "out">;
         cartItemId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CartItemId", "out">>;
         name: z.ZodString;
+        kind: z.ZodEnum<{
+            bag: "bag";
+            product: "product";
+        }>;
         quantity: z.ZodDiscriminatedUnion<[z.ZodObject<{
             status: z.ZodLiteral<"known">;
             quantity: z.ZodObject<{
@@ -120,22 +173,49 @@ export declare const CartSchema: z.ZodObject<{
                 unsupported_unit: "unsupported_unit";
             }>>;
         }, z.core.$strict>], "status">;
-        price: z.ZodObject<{
-            amount: z.ZodNullable<z.ZodObject<{
+        price: z.ZodNullable<z.ZodObject<{
+            amount: z.ZodObject<{
                 currency: z.ZodLiteral<"EUR">;
                 minorUnits: z.ZodNumber;
-            }, z.core.$strict>>;
-            basis: z.ZodEnum<{
-                line: "line";
-                unit: "unit";
-                unknown: "unknown";
+            }, z.core.$strict>;
+            per: z.ZodEnum<{
+                item: "item";
+                kg: "kg";
+                l: "l";
+                piece: "piece";
             }>;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-    total: z.ZodNullable<z.ZodObject<{
-        currency: z.ZodLiteral<"EUR">;
-        minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        lineTotal: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
+    totals: z.ZodObject<{
+        products: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        bags: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        deposit: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        delivery: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        discounts: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+        grandTotal: z.ZodNullable<z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
 export type Cart = z.infer<typeof CartSchema>;
 export declare const OrderLineSchema: z.ZodObject<{
@@ -308,6 +388,18 @@ export declare const ProductDetailsSchema: z.ZodObject<{
             piece: "piece";
         }>;
     }, z.core.$strict>>;
+    recommendedPrice: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            minorUnits: z.ZodNumber;
+        }, z.core.$strict>;
+        per: z.ZodEnum<{
+            item: "item";
+            kg: "kg";
+            l: "l";
+            piece: "piece";
+        }>;
+    }, z.core.$strict>>;
     availability: z.ZodEnum<{
         available: "available";
         unavailable: "unavailable";

package/dist/domain/models.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { ToolErrorSchema } from './errors.js';
 import { CartItemIdSchema, OrderIdSchema, OrderNumberSchema, ProductIdSchema, ProductReferenceSchema } from './identity.js';
-import { MoneySchema, PriceTagSchema, QuotedMoneySchema } from './money.js';
+import { MoneySchema, PriceTagSchema } from './money.js';
 import { ObservedQuantitySchema, QuantitySchema, ProductSaleRulesSchema } from './quantity.js';
 const productDetails = {
     name: z.string().trim().min(1).max(250),
@@ -15,19 +15,40 @@ export const ProductSchema = FavoriteProductSchema.safeExtend({
     secondaryPrice: PriceTagSchema.nullable(),
     /** Pack size as displayed, such as `940 gr`, `2 x 52 gr` or `1,2 kg (aprox.)`. */
     packageText: z.string().nullable(),
+    /** The recommended retail price (PVPR) shown beside a promotional price; null when the website shows none. */
+    recommendedPrice: PriceTagSchema.nullable(),
     minimumText: z.string().nullable(),
 });
 export const CartItemSchema = z.strictObject({
     productId: ProductIdSchema,
     cartItemId: CartItemIdSchema.nullable(),
     name: z.string().trim().min(1),
+    /** `bag` for the shopping bags the website adds to the cart on its own; `product` for everything else. */
+    kind: z.enum(['product', 'bag']),
     quantity: ObservedQuantitySchema,
-    price: QuotedMoneySchema,
+    /** Unit price with what it is for: per item, or per kg for products sold by the piece but priced by weight. */
+    price: PriceTagSchema.nullable(),
+    /** The line's total as the website reports it. */
+    lineTotal: MoneySchema.nullable(),
+});
+/** Each amount as the website reports it, or null when it reports none. */
+export const CartTotalsSchema = z.strictObject({
+    /** Product lines only, without bags or deposit. */
+    products: MoneySchema.nullable(),
+    /** The bag lines. */
+    bags: MoneySchema.nullable(),
+    /** Bottle and can deposit (SDR). */
+    deposit: MoneySchema.nullable(),
+    delivery: MoneySchema.nullable(),
+    /** Amount taken off by order and delivery discounts. */
+    discounts: MoneySchema.nullable(),
+    /** The amount to pay as the website shows it; it includes the bags. */
+    grandTotal: MoneySchema.nullable(),
 });
 export const CartSchema = z.strictObject({
     customerAuthenticated: z.boolean(),
     items: z.array(CartItemSchema),
-    total: MoneySchema.nullable(),
+    totals: CartTotalsSchema,
 });
 export const OrderLineSchema = z.strictObject({
     productId: ProductIdSchema.nullable(),
@@ -63,7 +84,7 @@ export const FavoritesCacheSchema = z.strictObject({
 });
 export const ProductDetailsSchema = ProductReferenceSchema.safeExtend({
     name: productDetails.name, url: productDetails.url, price: PriceTagSchema.nullable(),
-    secondaryPrice: PriceTagSchema.nullable(), availability: z.enum(['available', 'unavailable', 'unknown']),
+    secondaryPrice: PriceTagSchema.nullable(), recommendedPrice: PriceTagSchema.nullable(), availability: z.enum(['available', 'unavailable', 'unknown']),
     saleRules: z.discriminatedUnion('status', [
         z.strictObject({ status: z.literal('available'), rules: ProductSaleRulesSchema }),
         z.strictObject({ status: z.literal('unavailable'), error: ToolErrorSchema }),

package/dist/domain/money.d.ts

@@ -6,19 +6,6 @@ export declare const MoneySchema: z.ZodObject<{
     minorUnits: z.ZodNumber;
 }, z.core.$strict>;
 export type Money = z.infer<typeof MoneySchema>;
-/** The source of a price determines its basis; a line total is not a unit price. */
-export declare const QuotedMoneySchema: z.ZodObject<{
-    amount: z.ZodNullable<z.ZodObject<{
-        currency: z.ZodLiteral<"EUR">;
-        minorUnits: z.ZodNumber;
-    }, z.core.$strict>>;
-    basis: z.ZodEnum<{
-        line: "line";
-        unit: "unit";
-        unknown: "unknown";
-    }>;
-}, z.core.$strict>;
-export type QuotedMoney = z.infer<typeof QuotedMoneySchema>;
 /** Convert decimal text through integer arithmetic; never round an unrecognized precision. */
 export declare function parseMoneyAmount(input: unknown): Result<Money | null, ToolError>;
 /**

package/dist/domain/money.js

@@ -4,11 +4,6 @@ export const MoneySchema = z.strictObject({
     currency: z.literal('EUR'),
     minorUnits: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
-/** The source of a price determines its basis; a line total is not a unit price. */
-export const QuotedMoneySchema = z.strictObject({
-    amount: MoneySchema.nullable(),
-    basis: z.enum(['unit', 'line', 'unknown']),
-});
 /** Convert decimal text through integer arithmetic; never round an unrecognized precision. */
 export function parseMoneyAmount(input) {
     if (input === null || input === undefined || input === '')

package/dist/mcp/contracts.d.ts

@@ -230,6 +230,18 @@ export declare const SearchData: z.ZodObject<{
             }>;
         }, z.core.$strict>>;
         packageText: z.ZodNullable<z.ZodString>;
+        recommendedPrice: z.ZodNullable<z.ZodObject<{
+            amount: z.ZodObject<{
+                currency: z.ZodLiteral<"EUR">;
+                minorUnits: z.ZodNumber;
+            }, z.core.$strict>;
+            per: z.ZodEnum<{
+                item: "item";
+                kg: "kg";
+                l: "l";
+                piece: "piece";
+            }>;
+        }, z.core.$strict>>;
         minimumText: z.ZodNullable<z.ZodString>;
         favorite: z.ZodBoolean;
     }, z.core.$strict>>;
@@ -550,6 +562,18 @@ export declare const SearchOutput: z.ZodObject<{
                     }>;
                 }, z.core.$strict>>;
                 packageText: z.ZodNullable<z.ZodString>;
+                recommendedPrice: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodObject<{
+                        currency: z.ZodLiteral<"EUR">;
+                        minorUnits: z.ZodNumber;
+                    }, z.core.$strict>;
+                    per: z.ZodEnum<{
+                        item: "item";
+                        kg: "kg";
+                        l: "l";
+                        piece: "piece";
+                    }>;
+                }, z.core.$strict>>;
                 minimumText: z.ZodNullable<z.ZodString>;
                 favorite: z.ZodBoolean;
             }, z.core.$strict>>;
@@ -731,6 +755,10 @@ export declare const CartOutput: z.ZodObject<{
                 productId: z.core.$ZodBranded<z.ZodString, "ProductId", "out">;
                 cartItemId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "CartItemId", "out">>;
                 name: z.ZodString;
+                kind: z.ZodEnum<{
+                    bag: "bag";
+                    product: "product";
+                }>;
                 quantity: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     status: z.ZodLiteral<"known">;
                     quantity: z.ZodObject<{
@@ -754,22 +782,49 @@ export declare const CartOutput: z.ZodObject<{
                         unsupported_unit: "unsupported_unit";
                     }>>;
                 }, z.core.$strict>], "status">;
-                price: z.ZodObject<{
-                    amount: z.ZodNullable<z.ZodObject<{
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodObject<{
                         currency: z.ZodLiteral<"EUR">;
                         minorUnits: z.ZodNumber;
-                    }, z.core.$strict>>;
-                    basis: z.ZodEnum<{
-                        line: "line";
-                        unit: "unit";
-                        unknown: "unknown";
+                    }, z.core.$strict>;
+                    per: z.ZodEnum<{
+                        item: "item";
+                        kg: "kg";
+                        l: "l";
+                        piece: "piece";
                     }>;
-                }, z.core.$strict>;
-            }, z.core.$strict>>;
-            total: z.ZodNullable<z.ZodObject<{
-                currency: z.ZodLiteral<"EUR">;
-                minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                lineTotal: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
+            totals: z.ZodObject<{
+                products: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                bags: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                deposit: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                delivery: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                discounts: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+                grandTotal: z.ZodNullable<z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         status: z.ZodLiteral<"error">;
@@ -1442,6 +1497,18 @@ export declare const ProductDetailsOutput: z.ZodObject<{
                     piece: "piece";
                 }>;
             }, z.core.$strict>>;
+            recommendedPrice: z.ZodNullable<z.ZodObject<{
+                amount: z.ZodObject<{
+                    currency: z.ZodLiteral<"EUR">;
+                    minorUnits: z.ZodNumber;
+                }, z.core.$strict>;
+                per: z.ZodEnum<{
+                    item: "item";
+                    kg: "kg";
+                    l: "l";
+                    piece: "piece";
+                }>;
+            }, z.core.$strict>>;
             availability: z.ZodEnum<{
                 available: "available";
                 unavailable: "unavailable";

package/dist/mcp/guide.d.ts

@@ -1,5 +1,5 @@
 import type { PromptHandler } from './server.js';
-export declare const BASKET_PLANNER_GUIDE = "# Basket planner\n\nTurn the user's shopping intent into a product list or a verified basket using the **continentept-mcp** tools. A request for a plan authorizes research only; a request to add, remove or set items authorizes those basket changes. Keep the user's existing choices and constraints. Ask only about choices that change the result, such as an unspecified substitute or whether a quantity means \"more\" or \"in total\".\n\n## Choose products and quantities\n\n1. Use `search_products` with `query` (and `limit` when useful). Treat results as candidates: match size, brand, dietary constraints and intended use before choosing. Keep `productId` as a string, including leading zeros.\n2. Use `get_product` when price, availability or sale rules matter. Quantities are in the returned sale unit. Respect minimum, maximum and step; never assume a weighted product is sold by the kilogram and never silently round a requested amount.\n3. Before changing the basket, read `get_cart` for current quantities and line identities. If several lines share a product ID, use the intended line's `cartItemId`, or ask the user which line they mean.\n4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer `minorUnits` (129 means \u20AC1.29). Keep product prices, basket totals and estimated list costs distinct.\n\nSearches read a bounded number of result pages; respect `completeness` and `failures` and do not claim a search was exhaustive.\n\n## Change the basket\n\n- `set_cart_item_quantity({ productId, quantity, cartItemId? })` makes the basket hold exactly `quantity`, adding the product if needed. Zero removes it. Prefer this whenever the user states a desired total; repeating it is safe.\n- `add_cart_item({ productId, quantity, cartItemId? })` adds `quantity` on top of what is already there (default one sale unit). Use it only for \"add more\".\n- `remove_cart_item({ productId, cartItemId? })` removes a line. An already absent item is confirmed without a write.\n\nIf the basket holds two units, \"add two more\" is `add_cart_item` with 2, while \"I need two\" is `set_cart_item_quantity` with 2 (which changes nothing). Process a list one item at a time and read each result before continuing. There is no batch, checkout or payment tool; checkout happens on the website.\n\n## Read outcomes before reporting success\n\nRead `structuredContent.result` rather than inferring success from prose.\n\n- `status: success`, `empty` or `partial` carries `data`. Report partial-result warnings and unavailable data.\n- A confirmed change has `data.outcome: \"confirmed\"` and `confirmedQuantity`, the quantity now in the basket. Report that observed quantity.\n- `status: error` carries `error`. For basket changes also read `mutation`: `not_applied` means nothing was submitted or the change was rejected; fix the reported cause before trying again.\n- `mutation.outcome: \"unknown\"` means the change may have happened. Stop dependent basket changes, call `get_cart`, and compare with the state before the change. Never repeat the original request just because the response was lost. If the basket state cannot settle the intent, explain the uncertainty and ask the user.\n\nA timeout, cancellation or lost connection during a change is not evidence that the basket stayed the same. Apply the same reconciliation when no structured result arrives.\n\n## Use account context when it helps\n\nFor \"my usual items\", `list_favorites` and `list_frequently_bought_products` can inform a proposed list. Past purchases are evidence, not permission to buy them again.\n\n`list_favorites` returns a local snapshot with `source` and `freshness`; pass `refresh: true` when the user wants the current website list or the snapshot is stale. An empty list is a valid result, and a failed refresh does not mean favorites disappeared.\n\n`list_orders` supports `limit`, `includeLines`, `detailLimit` and `cursor` (the returned `nextCursor`). Use the internal `orderId` with `get_order`, not the displayed order number. `list_frequently_bought_products` has separate `orderLimit` and `limit`; its scan counts and failures show how representative the ranking is. Never add quantities expressed in different units.\n\n`get_session_status` reports local state only; it does not verify that the login still works. Do not include credentials or account details in summaries.\n\nFinish with the chosen or changed items, confirmed quantities and units, and any unresolved choices or failures. Keep planned items separate from changes the server confirmed.\n\nFor exact schemas and limits, see the [tool reference](https://github.com/andredelgado/continente-mcp/blob/main/docs/tools.md).";
+export declare const BASKET_PLANNER_GUIDE = "# Basket planner\n\nTurn the user's shopping intent into a product list or a verified basket using the **continentept-mcp** tools. A request for a plan authorizes research only; a request to add, remove or set items authorizes those basket changes. Keep the user's existing choices and constraints. Ask only about choices that change the result, such as an unspecified substitute or whether a quantity means \"more\" or \"in total\".\n\n## Choose products and quantities\n\n1. Use `search_products` with `query` (and `limit` when useful). Treat results as candidates: match size, brand, dietary constraints and intended use before choosing. Keep `productId` as a string, including leading zeros.\n2. Use `get_product` when price, availability or sale rules matter. Quantities are in the returned sale unit. Respect minimum, maximum and step; never assume a weighted product is sold by the kilogram and never silently round a requested amount.\n3. Before changing the basket, read `get_cart` for current quantities and line identities. If several lines share a product ID, use the intended line's `cartItemId`, or ask the user which line they mean.\n4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer `minorUnits` (129 means \u20AC1.29). Keep product prices, basket totals and estimated list costs distinct. The amount to pay is `get_cart`'s `totals.grandTotal`, which includes the bags the website adds.\n\nSearches read a bounded number of result pages; respect `completeness` and `failures` and do not claim a search was exhaustive.\n\n## Change the basket\n\n- `set_cart_item_quantity({ productId, quantity, cartItemId? })` makes the basket hold exactly `quantity`, adding the product if needed. Zero removes it. Prefer this whenever the user states a desired total; repeating it is safe.\n- `add_cart_item({ productId, quantity, cartItemId? })` adds `quantity` on top of what is already there (default one sale unit). Use it only for \"add more\".\n- `remove_cart_item({ productId, cartItemId? })` removes a line. An already absent item is confirmed without a write.\n\nIf the basket holds two units, \"add two more\" is `add_cart_item` with 2, while \"I need two\" is `set_cart_item_quantity` with 2 (which changes nothing). Process a list one item at a time and read each result before continuing. There is no batch, checkout or payment tool; checkout happens on the website.\n\n## Read outcomes before reporting success\n\nRead `structuredContent.result` rather than inferring success from prose.\n\n- `status: success`, `empty` or `partial` carries `data`. Report partial-result warnings and unavailable data.\n- A confirmed change has `data.outcome: \"confirmed\"` and `confirmedQuantity`, the quantity now in the basket. Report that observed quantity.\n- `status: error` carries `error`. For basket changes also read `mutation`: `not_applied` means nothing was submitted or the change was rejected; fix the reported cause before trying again.\n- `mutation.outcome: \"unknown\"` means the change may have happened. Stop dependent basket changes, call `get_cart`, and compare with the state before the change. Never repeat the original request just because the response was lost. If the basket state cannot settle the intent, explain the uncertainty and ask the user.\n\nA timeout, cancellation or lost connection during a change is not evidence that the basket stayed the same. Apply the same reconciliation when no structured result arrives.\n\n## Use account context when it helps\n\nFor \"my usual items\", `list_favorites` and `list_frequently_bought_products` can inform a proposed list. Past purchases are evidence, not permission to buy them again.\n\n`list_favorites` returns a local snapshot with `source` and `freshness`; pass `refresh: true` when the user wants the current website list or the snapshot is stale. An empty list is a valid result, and a failed refresh does not mean favorites disappeared.\n\n`list_orders` supports `limit`, `includeLines`, `detailLimit` and `cursor` (the returned `nextCursor`). Use the internal `orderId` with `get_order`, not the displayed order number. `list_frequently_bought_products` has separate `orderLimit` and `limit`; its scan counts and failures show how representative the ranking is. Never add quantities expressed in different units.\n\n`get_session_status` reports local state only; it does not verify that the login still works. Do not include credentials or account details in summaries.\n\nFinish with the chosen or changed items, confirmed quantities and units, and any unresolved choices or failures. Keep planned items separate from changes the server confirmed.\n\nFor exact schemas and limits, see the [tool reference](https://github.com/andredelgado/continente-mcp/blob/main/docs/tools.md).";
 /** Sent to every client on connect; the essential rules for working with the cart safely. */
 export declare const SERVER_INSTRUCTIONS = "Continente MCP shops at Continente.pt for one account. Checkout and payment always happen on the website.\n\n- Quantities are in the product's sale unit. Call get_product before choosing a quantity for weighted or bulk products, and respect its minimum, maximum and step.\n- set_cart_item_quantity sets an exact total (adding the product if needed; 0 removes it). add_cart_item adds on top of what is already there. When the user says how many they need, use set_cart_item_quantity.\n- Change the cart one item at a time and read structuredContent.result before reporting success. confirmedQuantity is what the cart now holds.\n- If a cart change returns mutation.outcome \"unknown\", the cart may have changed. Call get_cart and decide from its contents. Never repeat the change automatically.\n- Money is EUR in integer minorUnits (129 means \u20AC1.29). Each price says what it is for: per item, per piece, per kg or per l. A price per kg or per l is not the price of one pack; check packageText and secondaryPrice before comparing. Missing prices, quantities or completeness stay unknown; do not guess them.\n- If your client supports MCP prompts, the basket-planner prompt has the full workflow for planning a shopping list or basket.";
 export declare const basketPlannerPrompt: PromptHandler;

package/dist/mcp/guide.js

@@ -9,7 +9,7 @@ Turn the user's shopping intent into a product list or a verified basket using t
 1. Use \`search_products\` with \`query\` (and \`limit\` when useful). Treat results as candidates: match size, brand, dietary constraints and intended use before choosing. Keep \`productId\` as a string, including leading zeros.
 2. Use \`get_product\` when price, availability or sale rules matter. Quantities are in the returned sale unit. Respect minimum, maximum and step; never assume a weighted product is sold by the kilogram and never silently round a requested amount.
 3. Before changing the basket, read \`get_cart\` for current quantities and line identities. If several lines share a product ID, use the intended line's \`cartItemId\`, or ask the user which line they mean.
-4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer \`minorUnits\` (129 means €1.29). Keep product prices, basket totals and estimated list costs distinct.
+4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer \`minorUnits\` (129 means €1.29). Keep product prices, basket totals and estimated list costs distinct. The amount to pay is \`get_cart\`'s \`totals.grandTotal\`, which includes the bags the website adds.
 
 Searches read a bounded number of result pages; respect \`completeness\` and \`failures\` and do not claim a search was exhaustive.
 

package/dist/mcp/shopping.js

@@ -23,8 +23,6 @@ const observed = (quantity) => quantity.status === 'known' ? amount(quantity.qua
     : quantity.value === null ? 'quantity unknown' : `${quantity.value} (unit unknown)`;
 const PER = { item: '', piece: ' per piece', kg: '/kg', l: '/l' };
 const priced = (price) => price === null ? 'price unknown' : `${euros(price.amount)}${PER[price.per]}`;
-const quoted = (price) => price.amount === null ? 'price unavailable'
-    : `${euros(price.amount)}${price.basis === 'unit' ? ' each' : price.basis === 'line' ? ' line total' : ''}`;
 const numbered = (lines) => lines.map((line, index) => `${index + 1}. ${line}`).join('\n');
 function response(data, text, status = 'success') {
     return { structuredContent: { result: { status, data } }, content: [{ type: 'text', text }] };
@@ -39,7 +37,8 @@ function errorResult(error, mutation) {
 }
 export function formatProductSearchResults(products) {
     return numbered(products.map(product => `${product.name}${product.favorite ? ' ⭐ favorite' : ''} — ${priced(product.price)}` +
-        `${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}${product.packageText ? `, pack ${product.packageText}` : ''}` +
+        `${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}${product.recommendedPrice ? `, PVPR ${priced(product.recommendedPrice)}` : ''}` +
+        `${product.packageText ? `, pack ${product.packageText}` : ''}` +
         `${product.minimumText ? `, minimum ${product.minimumText}` : ''}\n   productId: ${product.productId}`));
 }
 function formatSaleRules(rules) {
@@ -49,7 +48,8 @@ function formatSaleRules(rules) {
 }
 function formatProduct(product) {
     return [`${product.name}`, `productId: ${product.productId}`,
-        `Price: ${priced(product.price)}${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}`,
+        `Price: ${priced(product.price)}${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}` +
+            `${product.recommendedPrice ? `, PVPR ${priced(product.recommendedPrice)}` : ''}`,
         `Availability: ${product.availability}`,
         product.saleRules.status === 'available' ? `Sale rules: ${formatSaleRules(product.saleRules.rules)}`
             : `Sale rules unavailable: ${product.saleRules.error.message}`, `URL: ${product.url}`].join('\n');
@@ -135,10 +135,16 @@ export class ShoppingHandlers {
         const cart = result.value;
         if (!cart.items.length)
             return response(cart, 'The cart is empty.', 'empty');
-        const list = numbered(cart.items.map(item => `${item.name} — ${observed(item.quantity)} × ${quoted(item.price)}` +
+        const list = numbered(cart.items.map(item => `${item.name}${item.kind === 'bag' ? ' (bag)' : ''} — ${observed(item.quantity)} × ${priced(item.price)}` +
+            `${item.lineTotal ? `, line ${euros(item.lineTotal)}` : ''}` +
             `\n   productId: ${item.productId}${item.cartItemId ? `, cartItemId: ${item.cartItemId}` : ''}`));
-        return response(cart, `Cart (${cart.items.length} lines):\n\n${list}\n\nTotal: ${cart.total === null ? 'unavailable' : euros(cart.total)}` +
-            `\nCheckout happens on the website: ${CHECKOUT_URL}`);
+        const { totals } = cart;
+        const optional = [['Deposit', totals.deposit], ['Delivery', totals.delivery], ['Discounts', totals.discounts]]
+            .filter(([, value]) => value !== null && value.minorUnits > 0).map(([label, value]) => `${label}: ${euros(value)}`);
+        const summary = [`Products: ${totals.products === null ? 'unavailable' : euros(totals.products)}`,
+            ...(totals.bags !== null && totals.bags.minorUnits > 0 ? [`Bags: ${euros(totals.bags)}`] : []), ...optional,
+            `Total to pay: ${totals.grandTotal === null ? 'unavailable' : euros(totals.grandTotal)}`].join('\n');
+        return response(cart, `Cart (${cart.items.length} lines):\n\n${list}\n\n${summary}\nCheckout happens on the website: ${CHECKOUT_URL}`);
     }
     async mutation(result, operation) {
         if (!result.ok)
@@ -225,7 +231,9 @@ export function registerShoppingTools(services, update = NO_UPDATE_INFO) {
             'Check this before choosing a quantity for weighted or bulk products. No login needed.', contracts.GetProductInput, contracts.ProductDetailsOutput, READ, args => handlers.getProduct(args.productId)),
         tool('list_favorites', 'List favorites', 'List the products saved as favorites on the account. Uses a local snapshot that is refreshed automatically when missing; ' +
             'snapshots older than 24 hours are marked stale. Pass refresh: true to fetch the current list from the website.', contracts.FavoritesInput, contracts.FavoritesOutput, READ, args => handlers.listFavorites(args.refresh)),
-        tool('get_cart', 'Get cart', 'Read the shopping cart: each line with productId, cartItemId, quantity and price, plus the total. ' +
+        tool('get_cart', 'Get cart', 'Read the shopping cart: each line with productId, cartItemId, kind (product or bag), quantity, unit price (per item or per kg) ' +
+            'and lineTotal, plus the totals ' +
+            '(products, bags, deposit, delivery, discounts and grandTotal, the amount to pay). ' +
             'Use it to check current quantities before changing them and to verify any uncertain change.', contracts.EmptyInput, contracts.CartOutput, READ, () => handlers.getCart()),
         tool('add_cart_item', 'Add to cart', 'Add an amount of a product to the cart, on top of any quantity already there. quantity is in the product sale unit (default 1). ' +
             `Use set_cart_item_quantity instead when the user wants a specific total. ${UNCERTAIN_WRITE}`, contracts.AddCartItemInput, contracts.MutationOutput, ADD, args => handlers.addCartItem(args.productId, args.quantity, args.cartItemId), true),

package/dist/parsers/cart.js

@@ -1,6 +1,6 @@
 import { load } from 'cheerio';
 import { z } from 'zod';
-import { CartSchema, ProductSaleRulesSchema, failure, parseMoneyAmount, parseProductReference, parseValue, success } from '../domain/index.js';
+import { CartSchema, ProductSaleRulesSchema, QuantityUnitSchema, failure, parseMoneyAmount, parseProductReference, parseValue, success } from '../domain/index.js';
 import { field, record } from './records.js';
 import { storefrontUrl } from './catalog.js';
 const unrecognizedCart = () => failure('invalid_data', 'The cart response was not recognised');
@@ -20,31 +20,76 @@ function cartLines(input) {
     const basket = record(field(input, 'basket'));
     return field(input, 'action') === 'Cart-MiniCartShow' && basket && Object.keys(basket).length === 0 ? [] : null;
 }
-function cartLine(line) {
+const PRICE_PER = { kg: 'kg', l: 'l', lt: 'l' };
+/**
+ * A line's units, from its own sale rules. Products sold by the piece but priced per kg count pieces
+ * and quote a price per kg; everything else counts and prices units. The line's `selectedunit` and
+ * `selectedDimension` do not follow the quantity, so they are not used.
+ */
+function lineUnits(line) {
+    const rates = record(field(line, 'measurementInfo', 'quantityConversionRates'));
+    if (!rates)
+        return undefined;
+    if (rates.hasAlternativeSaleUnit !== true && rates.hasConversionRate !== true) {
+        return rates.primaryunit === 'un' ? { quantity: 'un', price: 'item' } : { quantity: null, price: null };
+    }
+    const unit = QuantityUnitSchema.safeParse(rates.secondaryunit);
+    return { quantity: unit.success ? unit.data : null, price: PRICE_PER[String(rates.primaryunit)] ?? null };
+}
+function cartLine(line, bag) {
     const reference = parseProductReference(field(line, 'id'));
-    // Weighted lines report the amount in the displayed sale unit as secondaryQuantity.
     const reported = field(line, 'secondaryQuantity') ?? field(line, 'quantity');
     const rawQuantity = typeof reported === 'string' && reported.trim() !== '' ? Number(reported) : reported;
-    const unitPrice = field(line, 'price', 'sales', 'value');
-    const lineTotal = field(line, 'priceTotal', 'basePriceValue');
-    const price = parseMoneyAmount(unitPrice ?? lineTotal);
-    if (!reference.ok || typeof rawQuantity !== 'number' || !Number.isFinite(rawQuantity) || rawQuantity < 0 || !price.ok)
+    const unitPrice = parseMoneyAmount(field(line, 'price', 'sales', 'value'));
+    const lineTotal = parseMoneyAmount(field(line, 'priceTotal', 'value'));
+    if (!reference.ok || typeof rawQuantity !== 'number' || !Number.isFinite(rawQuantity) || rawQuantity < 0 || !unitPrice.ok || !lineTotal.ok)
         return unrecognizedCart();
+    const units = lineUnits(line);
     return parseValue(CartSchema.shape.items.element, {
         productId: reference.value.productId,
         cartItemId: field(line, 'UUID') ?? field(line, 'uuid') ?? null,
         name: field(line, 'productName'),
-        quantity: { status: 'unknown', value: rawQuantity, rawText: null },
-        price: { amount: price.value, basis: unitPrice != null ? 'unit' : lineTotal != null ? 'line' : 'unknown' },
+        kind: bag !== null && reference.value.productId === bag ? 'bag' : 'product',
+        quantity: units?.quantity ? { status: 'known', quantity: { value: rawQuantity, unit: units.quantity } }
+            : { status: 'unknown', value: rawQuantity, rawText: null, ...(units ? { reason: 'unsupported_unit' } : {}) },
+        price: unitPrice.value && units?.price ? { amount: unitPrice.value, per: units.price } : null,
+        lineTotal: lineTotal.value,
     }, 'cart line');
 }
+const money = (value) => { const parsed = parseMoneyAmount(value); return parsed.ok ? parsed.value : null; };
+const euro = (minorUnits) => ({ currency: 'EUR', minorUnits });
+/** Mini-cart totals. An amount the website does not report, or reports unreadably, stays null. */
+function cartTotals(input, lines, bag) {
+    const totals = field(input, 'basket', 'totals');
+    if (lines.length === 0 && field(input, 'action') === 'Cart-MiniCartShow' && !record(totals)) {
+        return { products: euro(0), bags: euro(0), deposit: euro(0), delivery: null, discounts: euro(0), grandTotal: euro(0) };
+    }
+    const products = money(field(input, 'cart', 'totalProductsValueNumber') ?? field(totals, 'productsTotalPriceOnly'));
+    const withDeposit = money(field(totals, 'productsTotalPriceOnlyWithSDR'));
+    const bagLines = bag === null ? null : lines.filter(line => { const reference = parseProductReference(field(line, 'id')); return reference.ok && reference.value.productId === bag; })
+        .map(line => money(field(line, 'priceTotal', 'value')));
+    const discountParts = [field(totals, 'orderLevelDiscountTotal', 'value'), field(totals, 'shippingLevelDiscountTotal', 'value')]
+        .filter(value => value != null).map(value => typeof value === 'number' ? money(Math.abs(value)) : null);
+    const sum = (amounts) => amounts && amounts.every(amount => amount !== null)
+        ? euro(amounts.reduce((total, amount) => total + amount.minorUnits, 0)) : null;
+    return {
+        products,
+        bags: sum(bagLines),
+        deposit: products && withDeposit && withDeposit.minorUnits >= products.minorUnits ? euro(withDeposit.minorUnits - products.minorUnits) : null,
+        delivery: money(field(totals, 'totalShippingCostNumber')),
+        discounts: discountParts.length ? sum(discountParts) : null,
+        grandTotal: money(field(totals, 'grandTotalNumber')),
+    };
+}
 export function parseCartResponse(input) {
     const lines = cartLines(input);
     if (!lines)
         return unrecognizedCart();
+    const bagReference = parseProductReference(field(input, 'basket', 'resources', 'plasticBagID'));
+    const bag = bagReference.ok ? bagReference.value.productId : null;
     const items = [];
     for (const line of lines) {
-        const item = cartLine(line);
+        const item = cartLine(line, bag);
         if (!item.ok)
             return item;
         items.push(item.value);
@@ -53,11 +98,7 @@ export function parseCartResponse(input) {
     if (new Set(lineIds).size !== lineIds.length)
         return failure('invalid_data', 'The cart contains duplicate line identifiers');
     const customerAuthenticated = field(input, 'resources', 'customerAuthenticated') === true;
-    const total = lines.length === 0 && field(input, 'action') === 'Cart-MiniCartShow'
-        ? success({ currency: 'EUR', minorUnits: 0 })
-        : parseMoneyAmount(field(input, 'cart', 'totalProductsValueNumber') ?? field(input, 'basket', 'totals', 'productsTotalPriceOnly') ??
-            field(input, 'basket', 'totals', 'productsTotalPriceOnlyWithSDR'));
-    return total.ok ? success({ customerAuthenticated, items, total: total.value }) : total;
+    return success({ customerAuthenticated, items, totals: cartTotals(input, lines, bag) });
 }
 const amount = z.union([z.number(), z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)]).pipe(z.number().finite().nonnegative());
 const MeasureOptionsSchema = z.object({
@@ -77,6 +118,9 @@ const MEASURES = {
     l: { dimension: 'volume', grams: 1000 }, ml: { dimension: 'volume', grams: 1 },
 };
 const unknownRules = (message) => failure('sale_rules_unknown', message);
+/** Storefront amount converted to sale units, without binary noise such as 98.99999999999999. */
+const inSaleUnits = (value, factor) => Number((value / factor).toPrecision(12));
+const isWholeMultiple = (value, step) => { const ratio = value / step; return Math.abs(ratio - Math.round(ratio)) < 1e-6; };
 /** Interpret the storefront's `data-measure-options`. Anything ambiguous is rejected rather than guessed. */
 export function parseSaleRules(input) {
     let raw = input;
@@ -106,21 +150,25 @@ export function parseSaleRules(input) {
         if (sale && storefront && (sale.dimension !== storefront.dimension || Math.abs(factor - sale.grams / storefront.grams) > 1e-12)) {
             return unknownRules('The unit conversion contradicts the declared units');
         }
-        // The maximum's unit is not stated for alternative-unit products, so it cannot be applied safely.
-        if (options.maxNumberOfUnitsPerSale != null)
-            return unknownRules('The maximum quantity has no established unit for this product');
     }
     else if (options.primaryunit !== 'un' || (options.selectedunit != null && options.selectedunit !== 'primary')) {
         return unknownRules('Only unit sales and declared alternative units are supported');
     }
     const step = options.stepQuantity ?? (saleUnit === 'un' ? factor : null);
+    const max = options.maxNumberOfUnitsPerSale;
+    // Minimum, step and maximum are all in the storefront unit (kg for weighted products): the site's
+    // own quantity control compares one quantity against all three and snaps the maximum to the step.
+    // A maximum that is not a whole number of steps is not a shape we have seen, so refuse it.
+    if (alternativeUnit && max != null && step && !isWholeMultiple(max, step)) {
+        return unknownRules('The maximum quantity is not a whole number of steps');
+    }
     if (!step || !milliquantity(step).ok)
         return unknownRules('A positive step with at most three decimals is required');
     const unit = saleUnit;
-    const minimum = options.minOrderQuantity ? { value: options.minOrderQuantity / factor, unit } : null;
-    const maximum = options.maxNumberOfUnitsPerSale != null ? { value: options.maxNumberOfUnitsPerSale, unit } : null;
+    const minimum = options.minOrderQuantity ? { value: inSaleUnits(options.minOrderQuantity, factor), unit } : null;
+    const maximum = max != null ? { value: inSaleUnits(max, factor), unit } : null;
     const rules = ProductSaleRulesSchema.safeParse({ saleUnit, storefrontUnit: alternativeUnit ? options.primaryunit : 'un',
-        storefrontUnitsPerSaleUnit: factor, minimum, maximum, step: { value: step / factor, unit } });
+        storefrontUnitsPerSaleUnit: factor, minimum, maximum, step: { value: inSaleUnits(step, factor), unit } });
     if (!rules.success)
         return unknownRules('Sale rules use an unsupported unit or contradictory bounds');
     return success({ rules: rules.data, alternativeUnit, storefrontStep: String(step), updateDimension: options.secondaryunit || options.primaryunit });

package/dist/parsers/catalog.d.ts

@@ -13,6 +13,8 @@ export declare function productReferenceFromUrl(href: string): Result<{
         code: string;
     }[] | undefined;
 }>;
+/** The amount in a "PVPR 6,00€" label, the recommended retail price shown beside a promotional price. */
+export declare function recommendedPriceLabel(label: string): string;
 export interface SearchPage {
     products: Product[];
     /** One entry per result that was skipped or kept with missing data. */

package/dist/parsers/catalog.js

@@ -31,6 +31,10 @@ function minimumLabel(label) {
 function packageLabel(label) {
     return text(/^emb\.\s*(.+)$/i.exec(text(label))?.[1] ?? '') || null;
 }
+/** The amount in a "PVPR 6,00€" label, the recommended retail price shown beside a promotional price. */
+export function recommendedPriceLabel(label) {
+    return text(label).replace(/^PVPR\s*/i, '');
+}
 /** An unrecognised price is reported, not fatal: the product stays usable with an unknown price. */
 function priceOrNull(label) {
     const parsed = parsePriceTag(label);
@@ -60,11 +64,15 @@ export function parseProductSearchPage(html) {
         }
         const main = priceOrNull(text(card.find('.pwc-tile--price-primary').first().text()));
         const secondary = priceOrNull(text(card.find('.pwc-tile--price-secondary').first().text()));
+        const recommended = priceOrNull(recommendedPriceLabel(card.find('.pvpr-info').first().parent().text()));
         if (!main.recognised)
             problem(`${position} (product ${reference.value.productId}) has a price in an unrecognised format; its price is unknown.`);
+        if (!recommended.recognised)
+            problem(`${position} (product ${reference.value.productId}) has a recommended price (PVPR) in an unrecognised format; it is unknown.`);
         const quantity = card.find('.pwc-tile--quantity').first().text();
         const product = parseValue(ProductSchema, { ...reference.value, name, url: storefrontUrl(href), price: main.price,
-            secondaryPrice: secondary.price, packageText: packageLabel(quantity), minimumText: minimumLabel(quantity) }, 'product');
+            secondaryPrice: secondary.price, packageText: packageLabel(quantity), minimumText: minimumLabel(quantity),
+            recommendedPrice: recommended.price }, 'product');
         if (product.ok)
             products.push(product.value);
         else

package/dist/parsers/orders.d.ts

@@ -13,6 +13,8 @@ export interface OrderHistory {
     totalCount: number | null;
 }
 export declare function orderHistoryUrl(value: string): string | null;
+/** "2 outubro 2026", "2 de outubro de 2026" or the abbreviated "01 Set 26"; anything else stays unparsed. */
+export declare function normalizedDate(raw: string): string | null;
 export declare function parseOrderHistory(html: string): Result<OrderHistory, ToolError>;
 export declare function parseOrderDetail(html: string, expected: Order): Result<OrderLine[], ToolError>;
 export declare function parseSingleOrder(html: string, orderId: Order['orderId']): Result<Order, ToolError>;

package/dist/parsers/orders.js

@@ -51,13 +51,16 @@ export function orderHistoryUrl(value) {
     const href = storefrontUrl(value);
     return href && new URL(href).pathname === '/conta/encomendas/' ? href : null;
 }
-function normalizedDate(raw) {
-    const match = raw.trim().toLowerCase().match(/^(\d{1,2})\s+(?:de\s+)?([a-zç]+)\s+(?:de\s+)?(\d{4})$/);
+const MONTHS = ['janeiro', 'fevereiro', 'março', 'abril', 'maio', 'junho', 'julho', 'agosto', 'setembro', 'outubro', 'novembro', 'dezembro'];
+/** "2 outubro 2026", "2 de outubro de 2026" or the abbreviated "01 Set 26"; anything else stays unparsed. */
+export function normalizedDate(raw) {
+    const match = raw.trim().toLowerCase().match(/^(\d{1,2})\s+(?:de\s+)?([a-zç]+)\.?\s+(?:de\s+)?(\d{4}|\d{2})$/);
     if (!match)
         return null;
-    const month = ['janeiro', 'fevereiro', 'março', 'abril', 'maio', 'junho', 'julho', 'agosto', 'setembro', 'outubro', 'novembro', 'dezembro'].indexOf(match[2]);
+    const name = match[2];
+    const month = MONTHS.findIndex(full => full === name || (name.length === 3 && full.startsWith(name)));
     const day = Number(match[1]);
-    const year = Number(match[3]);
+    const year = match[3].length === 2 ? 2000 + Number(match[3]) : Number(match[3]);
     const date = new Date(Date.UTC(year, month, day));
     return month >= 0 && date.getUTCFullYear() === year && date.getUTCMonth() === month && date.getUTCDate() === day ? date.toISOString().slice(0, 10) : null;
 }

package/dist/parsers/product.js

@@ -2,7 +2,7 @@ import { load } from 'cheerio';
 import { ProductDetailsSchema, parsePriceTag, parseProductReference, parseValue } from '../domain/index.js';
 import { success, failure } from '../domain/index.js';
 import { parseSaleRules } from './cart.js';
-import { productReferenceFromUrl, storefrontUrl } from './catalog.js';
+import { productReferenceFromUrl, recommendedPriceLabel, storefrontUrl } from './catalog.js';
 import { record } from './records.js';
 /** Scope every source to the requested product; recommendations cannot supply missing facts. */
 export function parseProductDetails(html, sourceUrl, expectedId) {
@@ -34,10 +34,13 @@ export function parseProductDetails(html, sourceUrl, expectedId) {
         const parsed = parsePriceTag($(`.ct-pdp--prices ${selector}`).first().text());
         return parsed.ok ? parsed.value : null;
     };
+    // Only the product's own price block: recommendation tiles on the page carry their own PVPR.
+    const recommended = parsePriceTag(recommendedPriceLabel($('.ct-pdp--prices .pvpr-info').first().parent().text()));
     const product = {
         ...reference.value, name, url,
         price: priceTag('.pwc-tile--price-primary'),
         secondaryPrice: priceTag('.pwc-tile--price-secondary'),
+        recommendedPrice: recommended.ok ? recommended.value : null,
         availability: availability === 'https://schema.org/InStock' ? 'available' : ['https://schema.org/OutOfStock', 'https://schema.org/Discontinued'].includes(availability) ? 'unavailable' : 'unknown',
         saleRules: rules.ok ? { status: 'available', rules: rules.value.rules } : { status: 'unavailable', error: rules.error },
     };

package/dist/services/cart.js

@@ -63,7 +63,10 @@ export class CartService {
         const cart = await this.getCart();
         const actual = cart.ok ? observedCartQuantity(cart.value, productId, cartItemId) : null;
         const selected = cart.ok ? selectCartItem(cart.value, productId, cartItemId) : null;
-        if (!cart.ok || actual === null || Math.abs(actual - expected) > 0.0005 || (requireAbsence && (!selected?.ok || selected.value !== null))) {
+        // A line that reports its unit must report the requested one; an amount in another unit is not a confirmation.
+        const line = selected?.ok ? selected.value : null;
+        const otherUnit = line?.quantity.status === 'known' && line.quantity.quantity.unit !== requested.unit;
+        if (!cart.ok || actual === null || otherUnit || Math.abs(actual - expected) > 0.0005 || (requireAbsence && (!selected?.ok || selected.value !== null))) {
             return this.unknown(productId, requested, failure('cart_change_unconfirmed').error);
         }
         const confirmed = { outcome: 'confirmed', productId, requested,

package/dist/services/catalog.d.ts

@@ -50,6 +50,13 @@ export declare class CatalogService {
             };
             per: "item" | "kg" | "l" | "piece";
         } | null;
+        recommendedPrice: {
+            amount: {
+                currency: "EUR";
+                minorUnits: number;
+            };
+            per: "item" | "kg" | "l" | "piece";
+        } | null;
         availability: "available" | "unavailable" | "unknown";
         saleRules: {
             status: "available";

package/dist/services/updates.js

@@ -50,15 +50,19 @@ export async function checkForUpdate(options) {
         cached = CacheSchema.parse(JSON.parse(await readFile(file, 'utf8')));
     }
     catch { /* no usable cache */ }
-    let latest = cached?.latestVersion ?? null;
+    // An answer older than the running version predates an upgrade, so it is checked again.
+    const outdated = cached !== null && isNewerRelease(options.currentVersion, cached.latestVersion);
+    let latest = cached && !outdated ? cached.latestVersion : null;
     const age = cached ? now.getTime() - Date.parse(cached.checkedAt) : Infinity;
-    if (!(age >= 0 && age < UPDATE_CHECK_INTERVAL_MS)) {
+    if (outdated || !(age >= 0 && age < UPDATE_CHECK_INTERVAL_MS)) {
         try {
             latest = await withTimeout(signal => (options.fetchLatest ?? registryLatest)(options.packageName, signal), options.timeoutMs ?? 1500);
             await writePrivateJson(file, { checkedAt: now.toISOString(), latestVersion: latest }).catch(() => { });
         }
         catch { /* offline or slow: keep the last known answer */ }
     }
+    if (latest !== null && isNewerRelease(options.currentVersion, latest))
+        latest = null;
     return { currentVersion: options.currentVersion, latestVersion: latest, available: latest !== null && isNewerRelease(latest, options.currentVersion) };
 }
 /** A line for the assistant's instructions, or null when there is nothing to say. */

package/docs/tools.md

@@ -57,8 +57,8 @@ calls, for clients that do not pass structured content to the model.
   per-piece `secondaryPrice`; packaged goods show the pack price with a per-kg or per-litre
   `secondaryPrice`. A price per kg or per litre is not the price of one pack. An unknown or
   unrecognised price is `null`.
-- **Cart prices** are `{ amount, basis }`, where `basis` is `unit`, `line` (a line total) or
-  `unknown`.
+- **Cart prices** use the same `{ amount, per }` price tags: `per` is `item`, or `kg` for
+  products sold by the piece but priced by weight. Each cart line also has `lineTotal`.
 - **Quantities** are `{ value, unit }` with unit `un`, `kg`, `g`, `l` or `ml`. Quantities read
   from the website are either `{ status: "known", quantity }` or
   `{ status: "unknown", value, rawText, reason }`; an unknown unit is never guessed.
@@ -76,8 +76,13 @@ Search uses the local favorites snapshot and never signs in to refresh it.
 
 Each product has `productId`, `productSlug`, `name`, `url`, `price`, `secondaryPrice`,
 `packageText` (the pack size as shown, such as `940 gr`, `2 x 52 gr` or
-`400 gr (peso escorrido 260 gr)`), `minimumText` (a minimum purchase such as `600 gr (3 un)`)
-and `favorite`.
+`400 gr (peso escorrido 260 gr)`), `minimumText` (a minimum purchase such as `600 gr (3 un)`),
+`recommendedPrice` and `favorite`.
+
+`recommendedPrice` is the recommended retail price (PVPR) the website shows beside the price
+on many promotions, or `null` when it shows none. Promotions such as multi-buy offers have no
+PVPR, so it is not a complete list of promotions. Compare it with `price` rather than treating
+its presence as a discount.
 
 A result the server cannot read does not fail the search. It is skipped, or kept with an
 unknown price when only the price is unreadable, and described in `failures`; the result is
@@ -88,7 +93,8 @@ then `partial`.
 
 ### `get_product`
 
-Returns `productId`, `productSlug`, `name`, `url`, `price`, `secondaryPrice`, `availability`
+Returns `productId`, `productSlug`, `name`, `url`, `price`, `secondaryPrice`, `recommendedPrice`
+(as in `search_products`), `availability`
 (`available`, `unavailable` or `unknown`) and `saleRules`:
 
 ```json
@@ -96,9 +102,13 @@ Returns `productId`, `productSlug`, `name`, `url`, `price`, `secondaryPrice`, `a
   "minimum": { "value": 1, "unit": "un" }, "maximum": { "value": 10, "unit": "un" }, "step": { "value": 1, "unit": "un" } } }
 ```
 
-Cart quantities are always in `saleUnit`. If the website's rules cannot be interpreted
-safely, `saleRules` is `{ "status": "unavailable", "error": ... }` and the result is
-`partial`. Availability reflects the product page, not delivery-slot stock.
+Cart quantities are always in `saleUnit`. Products priced per kilogram but sold by the piece
+(fruit, meat, fish) have `saleUnit: "un"` and `storefrontUnit: "kg"`: their minimum, maximum and
+step are whole pieces, and `storefrontUnitsPerSaleUnit` is the approximate weight of one piece.
+If the website's rules cannot be interpreted safely, `saleRules` is
+`{ "status": "unavailable", "error": ... }` and the result is `partial`. Availability reflects
+the product page, not delivery-slot stock. A product the website no longer sells returns
+`not_found`.
 
 ## Favorites
 
@@ -111,12 +121,36 @@ automatically when missing, is marked `stale` after 24 hours, and is replaced wh
 `data`: `favorites`, `fetchedAt`, `expiresAt`, `source` (`cache` or `website`), `freshness`
 (`fresh` or `stale`), `cacheState` (`empty` or `populated`), `completeness`.
 
+Favorites can include products the website no longer sells, still with their last price. Check
+with `get_product` before adding one to the cart; it returns `not_found` for those.
+
 ## Cart
 
 ### `get_cart`
 
-`data`: `customerAuthenticated`, `items` (each with `productId`, `cartItemId`, `name`,
-`quantity`, `price`) and `total`.
+`data`: `customerAuthenticated`, `items` (each with `productId`, `cartItemId`, `name`, `kind`,
+`quantity`, `price`, `lineTotal`) and `totals`.
+
+- `kind` is `bag` for the shopping bags the website adds to the cart by itself, and `product`
+  for everything else.
+- `quantity` is in the line's sale unit, read from the line's own sale rules: pieces (`un`) for
+  products sold by the piece but priced per kg, `un` for everything else. A line without
+  recognisable sale rules keeps its amount with an unknown unit.
+- `price` is the unit price with what it is for: per item, or per kg for products sold by the
+  piece (2 apples at €2.99/kg cost less than €5.98). `null` when the line does not say what its
+  price is for. `lineTotal` is the line's total as the website reports it.
+- `totals` holds each amount as the website reports it, or `null` when it reports none:
+
+  | Field | Meaning |
+  | --- | --- |
+  | `products` | Product lines only, without bags or deposit |
+  | `bags` | The bag lines |
+  | `deposit` | Bottle and can deposit (SDR) |
+  | `delivery` | Delivery cost, once the website has one |
+  | `discounts` | Amount taken off by order and delivery discounts |
+  | `grandTotal` | The amount to pay as the website shows it. It includes the bags. |
+
+  Report `grandTotal` as the amount to pay, and don't add the other fields to it yourself.
 
 ### Changing the cart
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "continentept-mcp",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "mcpName": "io.github.andredelgado/continente-mcp",
   "description": "MCP server for Continente.pt: search products, check sale rules, read favorites and orders, and make verified cart changes.",
   "keywords": [
@@ -64,7 +64,8 @@
     "test:browser": "npm run build && tsc -p tsconfig.tests.json && node build/tools/run-tests.js --browser",
     "test:package": "npm run build:tools && node build/tools/package-smoke.js",
     "prepack": "npm run build",
-    "build:bundle": "npm run build && node build/tools/build-bundle.js"
+    "build:bundle": "npm run build && node build/tools/build-bundle.js",
+    "check:site": "npm run build && node build/tools/site-check.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",

package/skills/basket-planner/SKILL.md

@@ -12,7 +12,7 @@ Turn the user's shopping intent into a product list or a verified basket using t
 1. Use `search_products` with `query` (and `limit` when useful). Treat results as candidates: match size, brand, dietary constraints and intended use before choosing. Keep `productId` as a string, including leading zeros.
 2. Use `get_product` when price, availability or sale rules matter. Quantities are in the returned sale unit. Respect minimum, maximum and step; never assume a weighted product is sold by the kilogram and never silently round a requested amount.
 3. Before changing the basket, read `get_cart` for current quantities and line identities. If several lines share a product ID, use the intended line's `cartItemId`, or ask the user which line they mean.
-4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer `minorUnits` (129 means €1.29). Keep product prices, basket totals and estimated list costs distinct.
+4. Show unresolved choices. Missing prices, availability, quantities or sale rules stay unknown. Money is EUR in integer `minorUnits` (129 means €1.29). Keep product prices, basket totals and estimated list costs distinct. The amount to pay is `get_cart`'s `totals.grandTotal`, which includes the bags the website adds.
 
 Searches read a bounded number of result pages; respect `completeness` and `failures` and do not claim a search was exhaustive.