continentept-mcp 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-15
+
+### Fixed
+
+- Searching for produce, meat and other products priced per kilogram failed with "Invalid money amount". Prices now record what they are for: per item, per piece, per kg or per litre.
+- One unreadable search result no longer fails the whole search; the other results are returned as a partial result, and the unreadable one is described.
+- Search results keep the website's relevance order. Products whose names merely resembled a favorite no longer jump ahead of better matches; exact favorites still come first.
+- Favorites priced per kilogram are read correctly, and an unrecognised favorite price is reported as unknown instead of failing the refresh.
+
+### Changed
+
+- **Breaking:** catalogue prices (`price` in search, favorites and `get_product`) are now `{ amount, per }`. `unitPriceText` is replaced by `secondaryPrice`, and the search field `similarity` is removed. Saved favorites are fetched again once after updating.
+- Search results include `packageText`, the pack size as shown on the website.
+- Sign-in errors say whether no credentials are configured or Continente did not accept them, with the next step for each case. The instructions present the `basket-planner` prompt as optional, for clients that support prompts.
+- Browser engine updated to Playwright 1.64 (Chrome 156). After updating, the new Chromium downloads automatically on first use (about 150 MB, once).
+
 ## [0.4.0] - 2026-10-15
 
 ### Added
@@ -55,7 +71,8 @@ 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.4.0...HEAD
+[Unreleased]: https://github.com/andredelgado/continente-mcp/compare/v0.5.0...HEAD
+[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
 [0.3.0]: https://github.com/andredelgado/continente-mcp/compare/v0.2.0...v0.3.0

package/dist/clients/storefront.js

@@ -93,7 +93,7 @@ export class CatalogClient {
                 break;
             }
             const previousCount = ids.size;
-            parsed.value.forEach(product => ids.add(product.productId));
+            parsed.value.products.forEach(product => ids.add(product.productId));
             pages.push(html);
             reportProgress(pages.length, 5, 'Reading catalogue pages');
             const continuation = parseSearchPagination(html);

package/dist/domain/models.d.ts

@@ -4,8 +4,16 @@ export declare const FavoriteProductSchema: z.ZodObject<{
     productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
     name: z.ZodString;
     price: z.ZodNullable<z.ZodObject<{
-        currency: z.ZodLiteral<"EUR">;
-        minorUnits: z.ZodNumber;
+        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>>;
     url: z.ZodURL;
 }, z.core.$strict>;
@@ -15,11 +23,31 @@ export declare const ProductSchema: z.ZodObject<{
     productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
     name: z.ZodString;
     price: z.ZodNullable<z.ZodObject<{
-        currency: z.ZodLiteral<"EUR">;
-        minorUnits: z.ZodNumber;
+        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>>;
     url: z.ZodURL;
-    unitPriceText: z.ZodNullable<z.ZodString>;
+    secondaryPrice: 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>>;
+    packageText: z.ZodNullable<z.ZodString>;
     minimumText: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
 export type Product = z.infer<typeof ProductSchema>;
@@ -227,7 +255,7 @@ export declare const PurchaseFrequencySchema: z.ZodObject<{
 }, z.core.$strict>;
 export type PurchaseFrequency = z.infer<typeof PurchaseFrequencySchema>;
 export declare const FavoritesCacheSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     accountScope: z.ZodString;
     fetchedAt: z.ZodISODateTime;
     favorites: z.ZodArray<z.ZodObject<{
@@ -235,8 +263,16 @@ export declare const FavoritesCacheSchema: z.ZodObject<{
         productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
         name: z.ZodString;
         price: z.ZodNullable<z.ZodObject<{
-            currency: z.ZodLiteral<"EUR">;
-            minorUnits: z.ZodNumber;
+            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>>;
         url: z.ZodURL;
     }, z.core.$strict>>;
@@ -248,18 +284,30 @@ export declare const ProductDetailsSchema: z.ZodObject<{
     productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
     name: z.ZodString;
     url: z.ZodURL;
-    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>;
-    unitPriceText: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    secondaryPrice: 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,16 +1,20 @@
 import { z } from 'zod';
 import { ToolErrorSchema } from './errors.js';
 import { CartItemIdSchema, OrderIdSchema, OrderNumberSchema, ProductIdSchema, ProductReferenceSchema } from './identity.js';
-import { MoneySchema, QuotedMoneySchema } from './money.js';
+import { MoneySchema, PriceTagSchema, QuotedMoneySchema } from './money.js';
 import { ObservedQuantitySchema, QuantitySchema, ProductSaleRulesSchema } from './quantity.js';
 const productDetails = {
     name: z.string().trim().min(1).max(250),
-    price: MoneySchema.nullable(),
+    /** The main price as displayed; null when absent or unrecognised. */
+    price: PriceTagSchema.nullable(),
     url: z.url(),
 };
 export const FavoriteProductSchema = ProductReferenceSchema.safeExtend(productDetails);
 export const ProductSchema = FavoriteProductSchema.safeExtend({
-    unitPriceText: z.string().nullable(),
+    /** The comparison price shown next to the main one, such as per kg or per piece. */
+    secondaryPrice: PriceTagSchema.nullable(),
+    /** Pack size as displayed, such as `940 gr`, `2 x 52 gr` or `1,2 kg (aprox.)`. */
+    packageText: z.string().nullable(),
     minimumText: z.string().nullable(),
 });
 export const CartItemSchema = z.strictObject({
@@ -51,15 +55,15 @@ export const PurchaseFrequencySchema = z.strictObject({
 }).refine(frequency => (frequency.identityBasis === 'product') === (frequency.productId !== null), { message: 'Identity basis must agree with the available product ID' })
     .refine(frequency => new Set(frequency.quantities.map(quantity => quantity.unit)).size === frequency.quantities.length, { message: 'Purchase totals must contain each unit only once' });
 export const FavoritesCacheSchema = z.strictObject({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     accountScope: z.string().trim().min(1).max(128),
     fetchedAt: z.iso.datetime({ offset: true }),
     favorites: z.array(FavoriteProductSchema),
     completeness: z.literal('complete').optional(),
 });
 export const ProductDetailsSchema = ProductReferenceSchema.safeExtend({
-    name: productDetails.name, url: productDetails.url, price: QuotedMoneySchema,
-    unitPriceText: z.string().nullable(), availability: z.enum(['available', 'unavailable', 'unknown']),
+    name: productDetails.name, url: productDetails.url, price: PriceTagSchema.nullable(),
+    secondaryPrice: 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

@@ -21,3 +21,22 @@ export declare const QuotedMoneySchema: z.ZodObject<{
 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>;
+/**
+ * What a displayed price is for. The storefront shows packaged goods per `item` (one pack or
+ * article), produce and meat per `kg`, drinks per `l`, and an approximate price per `piece`.
+ */
+export declare const PriceTagSchema: 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>;
+export type PriceTag = z.infer<typeof PriceTagSchema>;
+/** Parse labels such as `1,29€`, `1,19€/kg` or `0,24€/un`. An empty label is an unknown price. */
+export declare function parsePriceTag(input: unknown): Result<PriceTag | null, ToolError>;

package/dist/domain/money.js

@@ -28,3 +28,28 @@ export function parseMoneyAmount(input) {
     }
     return { ok: true, value: { currency: 'EUR', minorUnits: Number(minorUnits) } };
 }
+/**
+ * What a displayed price is for. The storefront shows packaged goods per `item` (one pack or
+ * article), produce and meat per `kg`, drinks per `l`, and an approximate price per `piece`.
+ */
+export const PriceTagSchema = z.strictObject({
+    amount: MoneySchema,
+    per: z.enum(['item', 'piece', 'kg', 'l']),
+});
+const PRICE_UNITS = { kg: 'kg', l: 'l', lt: 'l', un: 'piece' };
+/** Parse labels such as `1,29€`, `1,19€/kg` or `0,24€/un`. An empty label is an unknown price. */
+export function parsePriceTag(input) {
+    if (input === null || input === undefined)
+        return { ok: true, value: null };
+    if (typeof input !== 'string')
+        return { ok: false, error: invalidData('price') };
+    const text = input.replace(/\s+/g, '');
+    if (!text)
+        return { ok: true, value: null };
+    const match = /^(\d+(?:[.,]\d{1,2})?)€(?:\/([a-z]+))?$/i.exec(text);
+    const per = match ? PRICE_UNITS[(match[2] ?? '').toLowerCase()] ?? (match[2] === undefined ? 'item' : undefined) : undefined;
+    const amount = match && per ? parseMoneyAmount(match[1]) : null;
+    if (!amount?.ok || !amount.value || !per)
+        return { ok: false, error: { ...invalidData('price'), message: 'Unrecognised price format' } };
+    return { ok: true, value: { amount: amount.value, per } };
+}

package/dist/mcp/contracts.d.ts

@@ -205,14 +205,33 @@ export declare const SearchData: z.ZodObject<{
         productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
         name: z.ZodString;
         price: z.ZodNullable<z.ZodObject<{
-            currency: z.ZodLiteral<"EUR">;
-            minorUnits: z.ZodNumber;
+            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>>;
         url: z.ZodURL;
-        unitPriceText: z.ZodNullable<z.ZodString>;
+        secondaryPrice: 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>>;
+        packageText: z.ZodNullable<z.ZodString>;
         minimumText: z.ZodNullable<z.ZodString>;
         favorite: z.ZodBoolean;
-        similarity: z.ZodNumber;
     }, z.core.$strict>>;
     scanned: z.ZodNumber;
     returned: z.ZodNumber;
@@ -256,8 +275,16 @@ export declare const FavoritesData: z.ZodObject<{
         productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
         name: z.ZodString;
         price: z.ZodNullable<z.ZodObject<{
-            currency: z.ZodLiteral<"EUR">;
-            minorUnits: z.ZodNumber;
+            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>>;
         url: z.ZodURL;
     }, z.core.$strict>>;
@@ -498,14 +525,33 @@ export declare const SearchOutput: z.ZodObject<{
                 productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
                 name: z.ZodString;
                 price: z.ZodNullable<z.ZodObject<{
-                    currency: z.ZodLiteral<"EUR">;
-                    minorUnits: z.ZodNumber;
+                    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>>;
                 url: z.ZodURL;
-                unitPriceText: z.ZodNullable<z.ZodString>;
+                secondaryPrice: 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>>;
+                packageText: z.ZodNullable<z.ZodString>;
                 minimumText: z.ZodNullable<z.ZodString>;
                 favorite: z.ZodBoolean;
-                similarity: z.ZodNumber;
             }, z.core.$strict>>;
             scanned: z.ZodNumber;
             returned: z.ZodNumber;
@@ -598,8 +644,16 @@ export declare const FavoritesOutput: z.ZodObject<{
                 productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
                 name: z.ZodString;
                 price: z.ZodNullable<z.ZodObject<{
-                    currency: z.ZodLiteral<"EUR">;
-                    minorUnits: z.ZodNumber;
+                    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>>;
                 url: z.ZodURL;
             }, z.core.$strict>>;
@@ -1364,18 +1418,30 @@ export declare const ProductDetailsOutput: z.ZodObject<{
             productSlug: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ProductSlug", "out">>;
             name: z.ZodString;
             url: z.ZodURL;
-            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>;
-            unitPriceText: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            secondaryPrice: 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/contracts.js

@@ -42,7 +42,7 @@ export function outputSchema(data, extra = {}) {
         ]), ...extra });
 }
 const integer = z.number().int().nonnegative();
-export const SearchData = z.strictObject({ products: z.array(ProductSchema.safeExtend({ favorite: z.boolean(), similarity: z.number().min(0).max(1) })),
+export const SearchData = z.strictObject({ products: z.array(ProductSchema.safeExtend({ favorite: z.boolean() })),
     scanned: integer, returned: integer, favoritesLoaded: integer, completeness: z.enum(['complete', 'partial', 'unknown']),
     failures: z.array(ToolErrorSchema), nextCursor: z.string().nullable() });
 export const FavoritesData = z.strictObject({ favorites: z.array(FavoriteProductSchema), fetchedAt: z.iso.datetime({ offset: true }), completeness: z.enum(['complete', 'unknown']),

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).";
 /** 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). Missing prices, quantities or completeness stay unknown; do not guess them.\n- For planning a shopping list or basket, use the basket-planner prompt for the full workflow.";
+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

@@ -52,8 +52,8 @@ export const SERVER_INSTRUCTIONS = `Continente MCP shops at Continente.pt for on
 - 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.
 - Change the cart one item at a time and read structuredContent.result before reporting success. confirmedQuantity is what the cart now holds.
 - 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.
-- Money is EUR in integer minorUnits (129 means €1.29). Missing prices, quantities or completeness stay unknown; do not guess them.
-- For planning a shopping list or basket, use the basket-planner prompt for the full workflow.`;
+- Money is EUR in integer minorUnits (129 means €1.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.
+- If your client supports MCP prompts, the basket-planner prompt has the full workflow for planning a shopping list or basket.`;
 export const basketPlannerPrompt = {
     name: 'basket-planner',
     title: 'Plan a Continente basket',

package/dist/mcp/shopping.d.ts

@@ -13,11 +13,15 @@ export interface ShoppingServices {
     history: PurchaseHistoryService;
     session: SessionService;
 }
+/** What to do about a sign-in failure, depending on whether credentials are configured at all. */
+export declare function signInHelp(credentialsConfigured: boolean | null): string;
 export declare function formatProductSearchResults(products: SearchResult['page']['items']): string;
 export declare class ShoppingHandlers {
     private readonly services;
     private readonly update;
     constructor(services: ShoppingServices, update: UpdateStatus);
+    /** An error result; sign-in failures before any cart write get guidance for fixing them. */
+    private failed;
     private recover;
     searchProducts(query: string, limit: number): Promise<CallToolResult>;
     getProduct(reference: string): Promise<CallToolResult>;

package/dist/mcp/shopping.js

@@ -1,7 +1,19 @@
 import { failure } from '../domain/index.js';
 import * as contracts from './contracts.js';
 import { withAuthenticationRecovery } from '../services/recovery.js';
-const NOT_LOGGED_IN = 'Sign-in required. Configure CONTINENTE_EMAIL and CONTINENTE_PASSWORD (see the configuration guide) or run `continentept-mcp login`.';
+const CONFIGURATION_GUIDE = 'https://github.com/andredelgado/continente-mcp/blob/main/docs/configuration.md';
+const PUBLIC_TOOLS = 'Searching and product details work without signing in.';
+/** What to do about a sign-in failure, depending on whether credentials are configured at all. */
+export function signInHelp(credentialsConfigured) {
+    if (credentialsConfigured === false) {
+        return 'Sign-in required: no Continente email and password are configured. In the Claude Desktop extension, enter them in the '
+            + `extension's settings; in other setups, set CONTINENTE_EMAIL and CONTINENTE_PASSWORD (see ${CONFIGURATION_GUIDE}). ${PUBLIC_TOOLS}`;
+    }
+    const cause = credentialsConfigured ? 'Continente did not accept the configured email and password, or asked for extra verification'
+        : 'Continente did not accept the sign-in, or no credentials are configured';
+    return `Sign-in failed: ${cause}. Check the credentials, or run \`continentept-mcp login --show-browser\` in a terminal `
+        + `to sign in and complete any verification (see ${CONFIGURATION_GUIDE}). ${PUBLIC_TOOLS}`;
+}
 const CHECKOUT_URL = 'https://www.continente.pt/checkout/carrinho/';
 // Text content mirrors the structured result for clients that only show text to the model,
 // so it always includes the identifiers needed for follow-up calls.
@@ -9,6 +21,8 @@ const euros = (money) => money === null ? 'price unavailable' : `€${(money.min
 const amount = (quantity) => `${Number(quantity.value.toPrecision(12))} ${quantity.unit}`;
 const observed = (quantity) => quantity.status === 'known' ? amount(quantity.quantity)
     : 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');
@@ -17,17 +31,16 @@ function response(data, text, status = 'success') {
 }
 function errorResult(error, mutation) {
     const unknown = mutation?.outcome === 'unknown';
-    const publicError = { ...error, message: error.code === 'not_authenticated' && !unknown ? NOT_LOGGED_IN : error.message,
-        ...(unknown ? { retryable: false } : {}) };
+    const publicError = { ...error, ...(unknown ? { retryable: false } : {}) };
     const note = unknown ? '\nThe cart may have changed. Call get_cart before making another change; do not repeat this request automatically.'
         : mutation ? '\nThe cart was not changed.' : '';
     return { isError: true, content: [{ type: 'text', text: `Error (${publicError.code}): ${publicError.message}${note}` }],
         structuredContent: { result: { status: 'error', error: publicError, ...(mutation ? { mutation } : {}) } } };
 }
 export function formatProductSearchResults(products) {
-    return numbered(products.map(product => `${product.name}${product.favorite ? ' ⭐ favorite' : ''} — ${euros(product.price)}` +
-        `${product.unitPriceText ? ` (${product.unitPriceText})` : ''}${product.minimumText ? `, minimum ${product.minimumText}` : ''}` +
-        `\n   productId: ${product.productId}`));
+    return numbered(products.map(product => `${product.name}${product.favorite ? ' ⭐ favorite' : ''} — ${priced(product.price)}` +
+        `${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}${product.packageText ? `, pack ${product.packageText}` : ''}` +
+        `${product.minimumText ? `, minimum ${product.minimumText}` : ''}\n   productId: ${product.productId}`));
 }
 function formatSaleRules(rules) {
     const bounds = [rules.minimum && `minimum ${amount(rules.minimum)}`, rules.maximum && `maximum ${amount(rules.maximum)}`,
@@ -36,7 +49,7 @@ function formatSaleRules(rules) {
 }
 function formatProduct(product) {
     return [`${product.name}`, `productId: ${product.productId}`,
-        `Price: ${quoted(product.price)}${product.unitPriceText ? ` (${product.unitPriceText})` : ''}`,
+        `Price: ${priced(product.price)}${product.secondaryPrice ? ` (${priced(product.secondaryPrice)})` : ''}`,
         `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');
@@ -74,43 +87,51 @@ export class ShoppingHandlers {
         this.services = services;
         this.update = update;
     }
+    /** An error result; sign-in failures before any cart write get guidance for fixing them. */
+    async failed(error, mutation) {
+        if (error.code !== 'not_authenticated' || mutation?.outcome === 'unknown')
+            return errorResult(error, mutation);
+        const status = await this.services.session.getStatus?.().catch(() => undefined);
+        const configured = status ? status.credentials.hasEmail === true && status.credentials.hasPassword === true : null;
+        return errorResult({ ...error, message: signInHelp(status?.credentials.hasEmail === null ? null : configured) }, mutation);
+    }
     recover(operation) {
         return withAuthenticationRecovery(operation, () => this.services.session.refreshAuthentication());
     }
     async searchProducts(query, limit) {
         const result = await this.services.catalog.searchProducts(query, limit);
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const { page, scanned, favorites } = result.value;
         const partial = page.completeness === 'partial';
         const text = page.items.length
             ? `${page.items.length} of ${scanned} scanned products for "${query}":\n\n${formatProductSearchResults(page.items)}`
             : `No products found for "${query}".`;
         return response({ products: page.items, scanned, returned: page.items.length, favoritesLoaded: favorites.length, completeness: page.completeness,
-            failures: page.failures, nextCursor: page.nextCursor }, text + (partial ? '\n\nPartial results: some result pages could not be read.' : ''), partial ? 'partial' : page.items.length ? 'success' : 'empty');
+            failures: page.failures, nextCursor: page.nextCursor }, text + (partial ? `\n\nPartial results: ${page.failures.length} problem(s) reading results; see failures.` : ''), partial ? 'partial' : page.items.length ? 'success' : 'empty');
     }
     async getProduct(reference) {
         const result = await this.services.catalog.getProduct(reference);
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const product = result.value;
-        const partial = product.saleRules.status === 'unavailable' || product.price.amount === null || product.availability === 'unknown';
+        const partial = product.saleRules.status === 'unavailable' || product.price === null || product.availability === 'unknown';
         return response(product, formatProduct(product), partial ? 'partial' : 'success');
     }
     async listFavorites(refresh) {
         const result = await this.recover(() => refresh ? this.services.favorites.refreshFavorites() : this.services.favorites.listFavorites());
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const { favorites, source, freshness } = result.value;
         const header = `${favorites.length} favorites (${source === 'website' ? 'fetched from the website' : `cached ${result.value.fetchedAt}`}):`;
-        const list = numbered(favorites.map(item => `${item.name} — ${euros(item.price)}\n   productId: ${item.productId}`));
+        const list = numbered(favorites.map(item => `${item.name} — ${priced(item.price)}\n   productId: ${item.productId}`));
         return response(favoritesData(result.value), (favorites.length ? `${header}\n\n${list}` : 'No favorites saved.') +
             (freshness === 'stale' ? '\n\nThis snapshot is more than 24 hours old. Call list_favorites with refresh: true to update it.' : ''), favorites.length ? 'success' : 'empty');
     }
     async getCart() {
         const result = await this.recover(() => this.services.cart.getCart());
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const cart = result.value;
         if (!cart.items.length)
             return response(cart, 'The cart is empty.', 'empty');
@@ -119,13 +140,13 @@ export class ShoppingHandlers {
         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}`);
     }
-    mutation(result, operation) {
+    async mutation(result, operation) {
         if (!result.ok)
-            return errorResult(result.error, { outcome: 'not_applied' });
+            return this.failed(result.error, { outcome: 'not_applied' });
         const value = result.value;
         if (value.outcome === 'confirmed')
             return response(value, mutationText(value, operation));
-        return errorResult(value.error, value.outcome === 'unknown' ? { outcome: 'unknown', recovery: value.recovery } : { outcome: 'not_applied' });
+        return this.failed(value.error, value.outcome === 'unknown' ? { outcome: 'unknown', recovery: value.recovery } : { outcome: 'not_applied' });
     }
     async addCartItem(reference, quantity, cartItemId) {
         return this.mutation(await this.recover(() => this.services.cart.addCartItem(reference, quantity, cartItemId)), 'add');
@@ -139,7 +160,7 @@ export class ShoppingHandlers {
     async listOrders(limit, options) {
         const result = await this.recover(() => this.services.orders.listOrders(limit, options));
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const page = result.value;
         const partial = page.completeness === 'partial';
         const list = numbered(page.items.map(order => `${orderHeading(order)}\n${formatOrderLines(order)}`));
@@ -151,7 +172,7 @@ export class ShoppingHandlers {
     async getOrder(orderId) {
         const result = await this.recover(() => this.services.orders.getOrder(orderId));
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const order = result.value;
         const lines = order.lines.status === 'available' ? order.lines.items : [];
         const unknownQuantityLines = lines.filter(line => line.quantity.status === 'unknown').length;
@@ -161,7 +182,7 @@ export class ShoppingHandlers {
     async listFrequentlyBoughtProducts(orderLimit, limit) {
         const result = await this.recover(() => this.services.history.listFrequentlyBoughtProducts(orderLimit));
         if (!result.ok)
-            return errorResult(result.error);
+            return this.failed(result.error);
         const scan = result.value;
         if (!scan.succeeded && (scan.failed || scan.unscanned)) {
             const unavailable = errorResult(failure('order_details_unavailable', 'No order details could be read. See scan.failures.').error);
@@ -198,8 +219,8 @@ export function registerShoppingTools(services, update = NO_UPDATE_INFO) {
             execute: raw => services.session.run(() => execute(raw)) };
     }
     return [
-        tool('search_products', 'Search products', 'Search the Continente.pt catalogue. No login needed. Results show price, unit price and productId; products in your saved favorites rank first. ' +
-            'Reads at most five result pages, so completeness may be "unknown" for broad queries.', contracts.SearchInput, contracts.SearchOutput, READ, args => handlers.searchProducts(args.query, args.limit)),
+        tool('search_products', 'Search products', 'Search the Continente.pt catalogue. No login needed. Results keep the website\'s relevance order, with products from your saved favorites first, and show ' +
+            'each price with what it is for (per item, piece, kg or litre), the pack size and productId. Reads at most five result pages, so completeness may be "unknown" for broad queries.', contracts.SearchInput, contracts.SearchOutput, READ, args => handlers.searchProducts(args.query, args.limit)),
         tool('get_product', 'Get product', 'Get one product by productId: price, availability and sale rules (sale unit, minimum, maximum and step). ' +
             '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; ' +

package/dist/parsers/catalog.d.ts

@@ -13,7 +13,13 @@ export declare function productReferenceFromUrl(href: string): Result<{
         code: string;
     }[] | undefined;
 }>;
-export declare function parseProductSearchPage(html: string): Result<Product[], ToolError>;
+export interface SearchPage {
+    products: Product[];
+    /** One entry per result that was skipped or kept with missing data. */
+    problems: ToolError[];
+}
+/** Parse one results page. A bad card is reported in `problems` instead of failing the page. */
+export declare function parseProductSearchPage(html: string): Result<SearchPage, ToolError>;
 export declare function parseFavoritesPageData(html: string): Result<{
     items: FavoriteProduct[];
     expectedIds: string[];
@@ -23,12 +29,14 @@ export declare function parseFavoritesContinuation(html: string): Result<string
 export declare function parseFavoritesPages(pages: string[]): Result<FavoriteProduct[], ToolError>;
 export declare function uniqueProducts<T extends FavoriteProduct>(products: T[]): T[];
 export interface RankedProduct extends Product {
-    /** The exact product is in the saved favorites. */
+    /** This exact product is in the saved favorites. */
     favorite: boolean;
-    /** Highest word overlap (0–1) between this name and a favorite's name. */
-    similarity: number;
 }
-/** Favorites first, then names most similar to a favorite; otherwise keep the site's order. */
+/**
+ * The website orders results by relevance to the query; keep that order and only move exact
+ * favorites to the front. Name similarity to favorites is not used: shared words such as a
+ * brand name would pull unrelated products above real matches.
+ */
 export declare function rankProductsByFavorites(products: Product[], favorites: FavoriteProduct[]): RankedProduct[];
 export declare function parseSearchPagination(html: string): Result<{
     url: string;

package/dist/parsers/catalog.js

@@ -1,5 +1,5 @@
 import { load } from 'cheerio';
-import { FavoriteProductSchema, ProductSchema, parseMoneyAmount, parseProductReference, parseValue } from '../domain/index.js';
+import { FavoriteProductSchema, ProductSchema, parsePriceTag, parseProductReference, parseValue } from '../domain/index.js';
 import { failure, success } from '../domain/index.js';
 export const STOREFRONT_ORIGIN = 'https://www.continente.pt';
 export function storefrontUrl(value) {
@@ -19,6 +19,7 @@ export function productReferenceFromUrl(href) {
     // Slugs can contain encoded punctuation that tool inputs do not accept; fall back to the numeric ID.
     return parsed.ok ? parsed : parseProductReference(slug?.match(/-(\d+)(?:-master)?$/)?.[1]);
 }
+const PRICE_IN_LABEL = /\d+[,.]\d+\s*€(?:\s*\/\s*[a-z]+)?/gi;
 const SEARCH_EMPTY = '.search-noresults-wrapper, .search-no-results, [data-search-empty]';
 const PRODUCT_LINK = 'a[href*="/produto/"]';
 /** Text after "=" in labels such as "Quant. Mínima = 600 gr (3 un)". */
@@ -26,35 +27,52 @@ function minimumLabel(label) {
     const [caption, ...rest] = label.split('=');
     return /m[ií]nim/i.test(caption ?? '') && rest.length ? text(rest.join('=')) || null : null;
 }
+/** Pack size from labels such as "emb. 940 gr" or "emb. 2 x 52 gr". */
+function packageLabel(label) {
+    return text(/^emb\.\s*(.+)$/i.exec(text(label))?.[1] ?? '') || null;
+}
+/** An unrecognised price is reported, not fatal: the product stays usable with an unknown price. */
+function priceOrNull(label) {
+    const parsed = parsePriceTag(label);
+    return parsed.ok ? { price: parsed.value, recognised: true } : { price: null, recognised: false };
+}
+/** Parse one results page. A bad card is reported in `problems` instead of failing the page. */
 export function parseProductSearchPage(html) {
     const $ = load(html);
     if ($(SEARCH_EMPTY).length)
-        return success([]);
+        return success({ products: [], problems: [] });
     const tiles = $($('.search-results-grid').length ? '.search-results-grid .ct-inner-tile-wrap' : '.ct-inner-tile-wrap').toArray();
     if (!tiles.length)
         return failure('invalid_data', 'The search results page was not recognised');
     const products = [];
-    for (const tile of tiles) {
+    const problems = [];
+    const problem = (message) => problems.push(failure('invalid_data', message).error);
+    tiles.forEach((tile, index) => {
         const card = $(tile);
+        const position = `Search result ${index + 1}`;
         const links = card.find(PRODUCT_LINK).toArray().map(link => ({ href: $(link).attr('href'), label: text($(link).text()) }));
         const href = links[0]?.href;
         const name = links.map(link => link.label).find(Boolean);
-        if (!href || !name)
-            return failure('invalid_data', 'A search result was not recognised');
-        const reference = productReferenceFromUrl(href);
-        if (!reference.ok)
-            return reference;
-        const price = parseMoneyAmount(text(card.find('.pwc-tile--price-primary').first().text()) || null);
-        if (!price.ok)
-            return price;
-        const product = parseValue(ProductSchema, { ...reference.value, name, price: price.value, url: storefrontUrl(href),
-            unitPriceText: text(card.find('.pwc-tile--price-secondary').first().text()) || null,
-            minimumText: minimumLabel(card.find('.pwc-tile--quantity').first().text()) }, 'product');
-        if (!product.ok)
-            return product;
-        products.push(product.value);
-    }
-    return success(uniqueProducts(products));
+        const reference = href ? productReferenceFromUrl(href) : null;
+        if (!href || !name || !reference?.ok) {
+            problem(`${position} was not recognised and was skipped.`);
+            return;
+        }
+        const main = priceOrNull(text(card.find('.pwc-tile--price-primary').first().text()));
+        const secondary = priceOrNull(text(card.find('.pwc-tile--price-secondary').first().text()));
+        if (!main.recognised)
+            problem(`${position} (product ${reference.value.productId}) has a price in an unrecognised format; its price 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');
+        if (product.ok)
+            products.push(product.value);
+        else
+            problem(`${position} (product ${reference.value.productId}) was not recognised and was skipped.`);
+    });
+    if (!products.length && problems.length)
+        return failure('invalid_data', 'No search result on the page could be recognised');
+    return success({ products: uniqueProducts(products), problems });
 }
 export function parseFavoritesPageData(html) {
     const $ = load(html);
@@ -82,23 +100,19 @@ export function parseFavoritesPageData(html) {
         const anchor = card.find('a[href*="/produto/"]').filter((_, element) => text($(element).text()).length > 0).first();
         const label = text(anchor.text());
         const href = anchor.attr('href') ?? '';
-        const name = label.replace(/\d+[,.]\d+\s*€/g, '').trim();
+        const name = label.replace(PRICE_IN_LABEL, '').trim();
         if (!name) {
             error = failure('invalid_data', 'A favorite product was not recognised').error;
             return;
         }
         const ref = productReferenceFromUrl(href);
-        const rawPrice = text(card.find('.pwc-tile--price-primary').first().text()) || label.match(/(\d+[,.]\d+\s*€)/)?.[1];
-        const price = parseMoneyAmount(rawPrice);
+        const rawPrice = text(card.find('.pwc-tile--price-primary').first().text()) || label.match(PRICE_IN_LABEL)?.[0] || '';
         if (!ref.ok) {
             error = ref.error;
             return;
         }
-        if (!price.ok) {
-            error = price.error;
-            return;
-        }
-        const result = parseValue(FavoriteProductSchema, { ...ref.value, name, price: price.value, url: storefrontUrl(href) }, 'favorite');
+        // Favorites must be complete, but an unrecognised price only makes that price unknown.
+        const result = parseValue(FavoriteProductSchema, { ...ref.value, name, price: priceOrNull(rawPrice).price, url: storefrontUrl(href) }, 'favorite');
         if (result.ok)
             products.push(result.value);
         else
@@ -151,26 +165,15 @@ export function uniqueProducts(products) {
     return products.filter(product => { if (seen.has(product.productId))
         return false; seen.add(product.productId); return true; });
 }
-const words = (name) => new Set(name.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
-    .split(/[^a-z0-9]+/).filter(word => word.length > 1));
-function overlap(a, b) {
-    let shared = 0;
-    for (const word of a)
-        if (b.has(word))
-            shared++;
-    const union = a.size + b.size - shared;
-    return union ? shared / union : 0;
-}
-/** Favorites first, then names most similar to a favorite; otherwise keep the site's order. */
+/**
+ * The website orders results by relevance to the query; keep that order and only move exact
+ * favorites to the front. Name similarity to favorites is not used: shared words such as a
+ * brand name would pull unrelated products above real matches.
+ */
 export function rankProductsByFavorites(products, favorites) {
     const favoriteIds = new Set(favorites.map(product => product.productId));
-    const favoriteNames = favorites.map(product => words(product.name));
-    return products.map((product, position) => {
-        const name = words(product.name);
-        const similarity = Math.round(Math.max(0, ...favoriteNames.map(favorite => overlap(name, favorite))) * 100) / 100;
-        return { product: { ...product, favorite: favoriteIds.has(product.productId), similarity }, position };
-    }).sort((a, b) => Number(b.product.favorite) - Number(a.product.favorite) || b.product.similarity - a.product.similarity || a.position - b.position)
-        .map(entry => entry.product);
+    const ranked = products.map(product => ({ ...product, favorite: favoriteIds.has(product.productId) }));
+    return [...ranked.filter(product => product.favorite), ...ranked.filter(product => !product.favorite)];
 }
 export function parseSearchPagination(html) {
     const actions = load(html)('[data-url*="Search-UpdateGrid"]');

package/dist/parsers/product.js

@@ -1,5 +1,5 @@
 import { load } from 'cheerio';
-import { ProductDetailsSchema, parseMoneyAmount, parseProductReference, parseValue } from '../domain/index.js';
+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';
@@ -30,12 +30,14 @@ export function parseProductDetails(html, sourceUrl, expectedId) {
     });
     const offer = products.length === 1 ? record(products[0].offers) : null;
     const availability = typeof offer?.availability === 'string' ? offer.availability.replace(/^http:\/\//, 'https://') : '';
-    const priceText = $('.ct-pdp--prices .pwc-tile--price-primary').first().text().replace(/\s+/g, '').trim();
-    const amount = parseMoneyAmount(priceText);
+    const priceTag = (selector) => {
+        const parsed = parsePriceTag($(`.ct-pdp--prices ${selector}`).first().text());
+        return parsed.ok ? parsed.value : null;
+    };
     const product = {
         ...reference.value, name, url,
-        price: { amount: amount.ok ? amount.value : null, basis: rules.ok && rules.value.rules.saleUnit === 'un' && amount.ok && amount.value ? 'unit' : 'unknown' },
-        unitPriceText: $('.ct-pdp--prices .pwc-tile--price-secondary').first().text().replace(/\s+/g, ' ').trim() || null,
+        price: priceTag('.pwc-tile--price-primary'),
+        secondaryPrice: priceTag('.pwc-tile--price-secondary'),
         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/catalog.d.ts

@@ -40,10 +40,16 @@ export declare class CatalogService {
             amount: {
                 currency: "EUR";
                 minorUnits: number;
-            } | null;
-            basis: "line" | "unit" | "unknown";
-        };
-        unitPriceText: string | null;
+            };
+            per: "item" | "kg" | "l" | "piece";
+        } | null;
+        secondaryPrice: {
+            amount: {
+                currency: "EUR";
+                minorUnits: number;
+            };
+            per: "item" | "kg" | "l" | "piece";
+        } | null;
         availability: "available" | "unavailable" | "unknown";
         saleRules: {
             status: "available";

package/dist/services/catalog.js

@@ -68,7 +68,7 @@ export class FavoritesService {
             return products;
         if (scope !== this.scope())
             return failure('cache_unavailable', 'Favorites account/session changed during refresh');
-        const cache = { schemaVersion: 1, accountScope: scope,
+        const cache = { schemaVersion: 2, accountScope: scope,
             fetchedAt: this.clock.now().toISOString(), favorites: products.value, completeness: 'complete' };
         const saved = await requestIO(() => this.store.save(cache));
         return saved.ok ? success(this.snapshot(cache, 'website')) : saved;
@@ -106,7 +106,8 @@ export class CatalogService {
                 failures.push(parsed.error);
                 break;
             }
-            products.push(...parsed.value);
+            products.push(...parsed.value.products);
+            failures.push(...parsed.value.problems);
         }
         const unique = uniqueProducts(products);
         const favorites = cache?.favorites ?? [];

package/docs/tools.md

@@ -50,9 +50,15 @@ calls, for clients that do not pass structured content to the model.
 
 ### Values
 
-- **Money** is `{ "currency": "EUR", "minorUnits": 129 }` (€1.29). An unknown price is `null`.
-  Cart and product prices are `{ amount, basis }`, where `basis` is `unit`, `line` (a line
-  total) or `unknown`.
+- **Money** is `{ "currency": "EUR", "minorUnits": 129 }` (€1.29).
+- **Catalogue prices** (search, favorites, `get_product`) are `{ amount, per }`, saying what the
+  price is for: `item` (one pack or article), `piece` (one unit, often approximate for
+  produce), `kg` or `l`. Produce and meat show their main `price` per kg, with an approximate
+  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`.
 - **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.
@@ -64,17 +70,25 @@ calls, for clients that do not pass structured content to the model.
 
 ### `search_products`
 
-Searches the public catalogue. Products in your saved favorites rank first (`favorite: true`),
-then products whose names share the most words with a favorite (`similarity`, 0–1); ties
-keep the website's order. Search uses the local favorites snapshot and never signs in to
-refresh it.
+Searches the public catalogue. Results keep the website's order, which reflects relevance to
+the query, except that products in your saved favorites move to the front (`favorite: true`).
+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`.
+
+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
+then `partial`.
 
 `data`: `products`, `scanned`, `returned`, `favoritesLoaded`, `completeness`, `failures`,
 `nextCursor`.
 
 ### `get_product`
 
-Returns `productId`, `productSlug`, `name`, `url`, `price`, `unitPriceText`, `availability`
+Returns `productId`, `productSlug`, `name`, `url`, `price`, `secondaryPrice`, `availability`
 (`available`, `unavailable` or `unknown`) and `saleRules`:
 
 ```json
@@ -189,7 +203,7 @@ credentials, cookies or file paths.
 | `quantity_below_minimum` | The resulting quantity is below the product minimum. |
 | `sale_rules_unknown` | The product's sale rules could not be interpreted safely. |
 | `not_found` | The product, cart line or order does not exist. |
-| `not_authenticated` | Sign-in is required and automatic sign-in failed or is not configured. |
+| `not_authenticated` | Sign-in is required and automatic sign-in failed or is not configured. The message says which, and what to do. |
 | `upstream_unavailable` | The website could not be reached or returned an error. |
 | `invalid_data` | The website returned something the server does not recognise. |
 | `order_details_unavailable` | Order details could not be read. |

package/docs/troubleshooting.md

@@ -7,7 +7,7 @@ without contacting the website.
 | --- | --- |
 | `browser_unavailable`: Chromium is being downloaded | The first use downloads Chromium (about 150 MB). Wait a minute and try again. |
 | `browser_unavailable`: Chromium could not be downloaded | Check the internet connection, then run `npx -y continentept-mcp install-browser` to see the download output. On Linux, add `--with-deps` to install system libraries. |
-| `not_authenticated` | Check that `get_session_status` reports credentials as configured, then run `continentept-mcp login` to test them. See [configuration](configuration.md). |
+| `not_authenticated` | The message says whether no credentials are configured or Continente did not accept them. Check them in the extension's settings or your configuration, or run `continentept-mcp login --show-browser` to sign in and complete any extra verification. See [configuration](configuration.md). |
 | Sign-in keeps failing | Run `continentept-mcp login --show-browser` to watch the browser and complete any extra verification the website asks for. |
 | Status shows `authentication: unknown` | Nothing has been observed since the server started or since the saved session changed. Any account tool will establish it. |
 | Favorites are stale or missing from search ranking | Call `list_favorites` with `refresh: true`, then search again. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "continentept-mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "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": [
@@ -69,12 +69,15 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
     "cheerio": "1.2.0",
-    "playwright": "1.59.1",
+    "playwright": "1.64.0",
     "zod": "4.6.7"
   },
   "devDependencies": {
     "@anthropic-ai/mcpb": "2.1.2",
     "@types/node": "^22.18.0",
     "typescript": "^7.0.2"
+  },
+  "overrides": {
+    "tmp": "^0.2.7"
   }
 }