lambda-erp 0.8.20__tar.gz → 0.8.21__tar.gz

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.8.20
+Version: 0.8.21
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -92,7 +92,7 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
                                                ▼
                            ┌──────────────────────────────────────────┐
                            │  LLM orchestrator                        │
-                           │  - GPT-5.4 drives the reasoning loop     │
+                           │  - GPT-5.6 drives the reasoning loop     │
                            │  - Tool-use: document CRUD, search,      │
                            │    reports, aggregations, analytics      │
                            │  - Delegates JS generation to Anthropic  │
@@ -449,9 +449,9 @@ replacement file.
 Both the backend seams (document classes, lifecycle hooks, converters, plugin
 loading) and the frontend seams (doctype/route/nav/component registries,
 branding, configurable API base, Tailwind preset) are implemented. The backend
-also builds a clean pip wheel and the frontend a `@lambda-development/erp-core` npm library
-— see [`docs/packaging-distribution-plan.md`](docs/packaging-distribution-plan.md)
-for the publish path.
+ships as a pip package and the frontend as the
+`@lambda-development/erp-core` npm package. See
+[`docs/releasing.md`](docs/releasing.md) for the release process.
 
 ---
 

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/README.md

@@ -64,7 +64,7 @@ Each of those is hours of skilled work today. With a capable LLM in the loop, th
                                                ▼
                            ┌──────────────────────────────────────────┐
                            │  LLM orchestrator                        │
-                           │  - GPT-5.4 drives the reasoning loop     │
+                           │  - GPT-5.6 drives the reasoning loop     │
                            │  - Tool-use: document CRUD, search,      │
                            │    reports, aggregations, analytics      │
                            │  - Delegates JS generation to Anthropic  │
@@ -421,9 +421,9 @@ replacement file.
 Both the backend seams (document classes, lifecycle hooks, converters, plugin
 loading) and the frontend seams (doctype/route/nav/component registries,
 branding, configurable API base, Tailwind preset) are implemented. The backend
-also builds a clean pip wheel and the frontend a `@lambda-development/erp-core` npm library
-— see [`docs/packaging-distribution-plan.md`](docs/packaging-distribution-plan.md)
-for the publish path.
+ships as a pip package and the frontend as the
+`@lambda-development/erp-core` npm package. See
+[`docs/releasing.md`](docs/releasing.md) for the release process.
 
 ---
 

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/auth.py

@@ -612,7 +612,7 @@ DEFAULTS = {
     "allow_public_signup": "0",
     # When "1", the programmatic chat API (POST /api/v1/chat, Bearer API keys) is
     # active. Default off — an admin turns it on and issues keys. See
-    # docs/chat-api-plan.md.
+    # docs/chat-api.md.
     "chat_api_enabled": "0",
     # When "1", the same Bearer API keys authenticate the regular REST API
     # (/api/documents, /api/masters, /api/reports, …) in addition to the session

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/chat.py

@@ -478,6 +478,20 @@ TOOLS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_document_fields",
+            "description": "List the available columns of a document type and identify which are text fields. Call this before building list_documents filters when you are unsure of a field name or whether it supports the case-insensitive contains operator. Also returns the default fields used by free-text search.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "doctype": {"type": "string", "enum": DOCUMENT_SLUGS},
+                },
+                "required": ["doctype"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -627,7 +641,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "search_masters",
-            "description": "Search master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). Case-insensitive, with fuzzy fallback for misspellings. By default matches across standard text fields (name, display name, address/city/zip); large free-text columns like description/templates are skipped unless named in `fields`. PREFER passing `fields` whenever you know which attribute you're matching on (e.g. a city, an email, a tax id) — it's faster, more precise, and avoids false hits from other columns. Returns ALL matching records by default (no cap); pass `limit` only to bound a large list.",
+            "description": "Search and filter master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). `query` is a case-insensitive free-text lookup with fuzzy fallback for simple misspellings. Use `filters` for deterministic field-aware queries and for combining different values across fields. Returns ALL matching records by default (no cap); pass `limit` only to bound a large list.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -638,7 +652,20 @@ TOOLS = [
                         "items": {"type": "string"},
                         "description": "Recommended: the column(s) to search, e.g. [\"city\"] or [\"customer_name\"]. Narrowing here is faster and avoids matching unrelated columns. Omit only when you genuinely don't know which field holds the value, to search all standard text fields.",
                     },
+                    "filters": {
+                        "type": "object",
+                        "description": "Optional deterministic filters on any real column, ANDed together and with `query`. Scalar values are exact: {\"disabled\": 0}. Text substring: {\"legal_form\": [\"contains\", \"AG\"]}. Comparisons and NULL checks use the same forms as list_documents. `contains` is only valid for schema-confirmed text fields.",
+                        "default": {},
+                    },
+                    "order_by": {"type": "string", "description": "Optional real column to sort by. Defaults to name."},
+                    "order": {"type": "string", "enum": ["asc", "desc"], "description": "Sort direction (default asc).", "default": "asc"},
                     "limit": {"type": "integer", "description": "Optional max number of results. OMIT for no cap — returns ALL matches (e.g. to see the entire chart of accounts). Pass a number only to bound a large list."},
+                    "offset": {"type": "integer", "description": "Skip this many matching rows. Use with limit for pagination.", "default": 0},
+                    "result_fields": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Optional result projection. Returns only these real columns plus name. This is separate from `fields`, which selects columns searched by `query`.",
+                    },
                     "include_disabled": {"type": "boolean", "description": "Default false (active records only). Set true to ALSO return disabled/archived records — needed to find a record you must inspect, re-enable, or reference, or to answer 'what's disabled'. Retry with this if a lookup for a record you know exists comes back empty."},
                 },
                 "required": ["master_type"],
@@ -649,7 +676,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "get_master_fields",
-            "description": "List the available columns of a master type (customer, supplier, item, ...). Call this WHENEVER you're unsure which columns exist: before passing `fields` to search_masters, and before building a `data` payload for create_master/update_master when you're not certain a field exists or where a value belongs (e.g. a contact person, a tax id, a payment term). It lets you target real fields instead of guessing — or wrongly concluding a value can't be stored. Returns: `fields` (all columns), `default_search_fields` (what search_masters searches when `fields` is omitted), and `bulk_text_fields` (large text columns searched only when named in `fields`).",
+            "description": "List the available columns of a master type (customer, supplier, item, ...). Call this WHENEVER you're unsure which columns exist: before passing `fields` or `filters` to search_masters, and before building a create/update payload. Returns all fields, text fields (the columns that support `contains`), default free-text search fields, and bulk text fields that are searched only when explicitly named.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -1326,18 +1353,6 @@ def _handle_list_documents(args):
     # within the tool-result budget. Use get_document to drill into one doc.
     doctype = args["doctype"]
     filters = args.get("filters") or {}
-    # Chat callers routinely pass `search` but omit `search_fields`; with no fields
-    # the free-text search silently no-ops and returns the newest N by creation
-    # (2026-08-13: tag lookups on leads "found nothing"). Default the columns to the
-    # doctype's registered chat fields so document search matches a record the way
-    # search_masters already does for masters. The frontend never hits this — its
-    # UI config always sends search_fields.
-    if filters.get("search") and not filters.get("search_fields"):
-        registered = (services.CHAT_DOCTYPES.get(doctype) or {}).get("fields") or []
-        valid = set(services.document_columns(doctype) or [])
-        default_fields = [f for f in registered if f in valid]
-        if default_fields:
-            filters = {**filters, "search_fields": default_fields}
     err = _validate_filter_columns(doctype, filters)
     if err:
         return {"error": err}
@@ -1369,6 +1384,23 @@ def _handle_list_documents(args):
     return rows
 
 
+def _handle_get_document_fields(args):
+    doctype = args["doctype"]
+    table = services.SLUG_TO_DOCTYPE.get(doctype)
+    if not table:
+        return {"error": f"Unknown document type: {doctype}"}
+    db = get_db()
+    cls = services.DOCUMENT_CLASSES.get(table)
+    return {
+        "doctype": doctype,
+        "fields": sorted(db._get_table_columns(table)),
+        "text_fields": sorted(db._get_text_columns(table)),
+        "default_search_fields": services.document_search_columns(db, doctype),
+        "child_tables": sorted((cls.CHILD_TABLES or {}).keys()) if cls else [],
+        "link_fields": dict(getattr(cls, "LINK_FIELDS", None) or {}) if cls else {},
+    }
+
+
 def _handle_get_document(args):
     return services.load_document(args["doctype"], args["name"])
 
@@ -1407,22 +1439,6 @@ def _handle_convert_document(args):
     return services.convert_document(args["doctype"], args["name"], args["target_doctype"])
 
 
-# Columns that are technically text but are noise for free-text master search.
-_MASTER_SEARCH_SKIP_COLUMNS = {
-    "naming_series",
-    "owner",
-    "modified_by",
-    "creation",
-    "modified",
-    "created_at",
-    "updated_at",
-}
-
-# Large free-text columns excluded from the DEFAULT search: scanning/fuzzing a
-# big blob (e.g. an item description or an HTML template) is costly and rarely
-# how you identify a record. Still searchable on demand via the `fields` arg.
-_MASTER_BULK_TEXT_COLUMNS = {"description", "notes", "remarks", "terms", "comments"}
-
 # Minimum difflib similarity for a fuzzy (misspelled) match to be returned.
 _MASTER_FUZZY_THRESHOLD = 0.6
 # Bounds for the fuzzy scorer so a single large value can't blow up cost:
@@ -1431,18 +1447,9 @@ _FUZZY_MAX_VALUE_LEN = 200
 _FUZZY_MAX_TOKENS = 16
 
 
-def _is_bulk_text_column(col):
-    return (col in _MASTER_BULK_TEXT_COLUMNS
-            or col.endswith("_template") or col.endswith("_html"))
-
-
 def _master_search_columns(db, doctype):
-    """Text columns worth matching a query against by default. Discovered from
-    the live schema (new text fields become searchable automatically), minus
-    audit noise and large free-text/template columns."""
-    cols = db._get_text_columns(doctype) - _MASTER_SEARCH_SKIP_COLUMNS
-    # Deterministic order keeps generated SQL and fuzzy scoring stable.
-    return sorted(c for c in cols if not _is_bulk_text_column(c))
+    """Compatibility wrapper for the shared REST/MCP field policy."""
+    return services.master_search_columns(db, doctype)
 
 
 def _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit):
@@ -1485,10 +1492,11 @@ def _handle_get_master_fields(args):
         return {"error": f"Unknown master type: {master_type}"}
     doctype, _ = entry
     default_search = _master_search_columns(db, doctype)
-    bulk = sorted(c for c in db._get_text_columns(doctype) if _is_bulk_text_column(c))
+    bulk = services.master_bulk_text_columns(db, doctype)
     return {
         "master_type": master_type,
         "fields": sorted(db._get_table_columns(doctype)),
+        "text_fields": sorted(db._get_text_columns(doctype)),
         # What search_masters searches when `fields` is omitted.
         "default_search_fields": default_search,
         # Large text fields searched ONLY when named in search_masters `fields`.
@@ -1517,23 +1525,20 @@ def _handle_search_masters(args):
         return {"error": f"Unknown master type: {master_type}"}
 
     doctype, _name_field = entry
-    has_disabled = "disabled" in db._get_table_columns(doctype)
+    columns = set(db._get_table_columns(doctype))
+    has_disabled = "disabled" in columns
     # Active-only by default (retired/archived records are hidden — you shouldn't
     # book to them or wade through them). Set include_disabled to reach a disabled
     # record you need to inspect, re-enable, or reference. Only meaningful when the
     # table has a `disabled` column.
     filter_disabled = has_disabled and not bool(args.get("include_disabled"))
 
-    if not query:
-        filters = {"disabled": 0} if filter_disabled else None
-        return db.get_all(doctype, filters=filters, fields=["*"], limit=limit)
-
     # Optional `fields` narrows the search to specific columns — cheaper, more
     # precise, and the only way to reach bulk columns (description, templates)
     # that the default search skips. Unknown names are ignored.
     requested = args.get("fields") or []
     if requested:
-        valid = set(db._get_table_columns(doctype))
+        valid = columns
         # The identity alias (e.g. "item_code") is what the model calls the code
         # everywhere else — create_master, document lines, the asset/reservation
         # prompt — so it naturally passes fields=["item_code"]. But the real
@@ -1556,22 +1561,36 @@ def _handle_search_masters(args):
     else:
         search_cols = _master_search_columns(db, doctype)
 
-    active_prefix = "disabled = 0 AND " if filter_disabled else ""
-
-    # Case-insensitive substring match. lower() on both sides is portable (bare
-    # LIKE is case-insensitive on SQLite but case-sensitive on Postgres, which
-    # silently broke prod search); CAST lets targeted non-text columns match too.
-    where = " OR ".join(f'lower(CAST("{col}" AS TEXT)) LIKE ?' for col in search_cols)
-    pattern = f"%{query.lower()}%"
-    limit_sql = f" LIMIT {limit}" if limit else ""
-    rows = db.sql(
-        f'SELECT * FROM "{doctype}" WHERE {active_prefix}({where}){limit_sql}',
-        [pattern] * len(search_cols),
-    )
-    if rows:
-        return [dict(r) for r in rows]
-
-    # Nothing matched literally — try fuzzy matching to catch misspellings.
+    filters = args.get("filters") or {}
+    result_fields = args.get("result_fields") or None
+    offset = args.get("offset", 0) or 0
+    order_by = args.get("order_by")
+    order = args.get("order", "asc")
+    try:
+        result = services.list_master_records(
+            master_type,
+            filters=filters,
+            search=query or None,
+            search_fields=search_cols if query else None,
+            include_disabled=bool(args.get("include_disabled")),
+            order_by=order_by,
+            order=order,
+            limit=limit,
+            offset=offset,
+            fields=result_fields,
+            with_total=False,
+        )
+    except (TypeError, ValueError) as exc:
+        return {"error": str(exc)}
+    rows = [dict(row) for row in result["rows"]]
+    if rows or not query:
+        return rows
+
+    # Preserve the established fuzzy fallback for a simple lookup. A
+    # deterministic field-filter query must return exactly its literal result;
+    # relaxing only the free-text part could otherwise select the wrong record.
+    if filters or offset or order_by or result_fields:
+        return []
     return _fuzzy_master_search(db, doctype, search_cols, query, filter_disabled, limit=limit)
 
 
@@ -1932,6 +1951,7 @@ def _handle_apply_company_setup(args):
 
 TOOL_HANDLERS = {
     "list_documents": _handle_list_documents,
+    "get_document_fields": _handle_get_document_fields,
     "get_document": _handle_get_document,
     "create_document": _handle_create_document,
     "update_document": _handle_update_document,
@@ -2405,10 +2425,10 @@ Every master record has a primary key (the `name` column) and a human-readable d
 When you fill in `item_code`, `customer`, `supplier`, `warehouse`, `company`, etc. in a document or child-table row, you MUST use the **primary key**, never the display name. `"item_code": "Project Management"` is ALWAYS wrong — it's a name, not a code.
 
 If the user refers to something by its human name ("bill them 8 hours of project mgmt", "add Redstone to the quote"), resolve the key first:
-- `search_masters(master_type="item", q="project management")` → returns `[{{name: "SVC-005", item_name: "Project Management"}}]`. Use `name` as `item_code`.
+- `search_masters(master_type="item", query="project management")` → returns `[{{name: "SVC-005", item_name: "Project Management"}}]`. Use `name` as `item_code`.
 - Same for customers, suppliers, warehouses, etc. — `search_masters` is **case-insensitive** and falls back to **fuzzy matching for misspellings**, so a typo'd name ("Meynex") still resolves. Trust its results instead of concluding "not found" after one narrow try.
 - **Prefer narrowing with `fields`** whenever you know the attribute: search a customer by city with `fields=["city"]`, by email with `fields=["contact_email"]`, etc. It's faster and avoids false matches from unrelated columns. Omitting `fields` searches all standard text fields (a good fallback when you're unsure where the value lives), but large free-text columns (e.g. item `description`) are only searched when you name them explicitly in `fields`.
-- **Don't guess column names** — call `get_master_fields(master_type=...)` first to see the real columns (and which are searched by default), then pass the exact names to `search_masters` `fields`. This also tells you which large text fields (like `description`) you must name explicitly to search.
+- **Don't guess column names** — call `get_master_fields(master_type=...)` first to see the real columns, which support `contains`, and which are searched by default. Use `query` + `fields` for a fuzzy lookup; use `filters` for exact, combined field conditions. For documents, use `get_document_fields` before constructing unfamiliar `list_documents` filters.
 - **When unsure where a value belongs, discover the schema — don't guess or give up.** Before a `create_master`/`update_master` where you're not certain a field exists or which column fits (the user gives a contact person, a VAT/tax id, a payment term, an IBAN, …), call `get_master_fields(master_type=...)` and map the value onto the real column. Never tell the user you can't store something without checking the fields first — the master usually has a column for it (e.g. a customer's contact person goes in `contact_person`/`contact_phone`/`contact_email`, not the company-level `phone`/`email`).
 
 When you list masters back to the user (items on an invoice, customers on a report), include the key in parentheses so follow-ups are unambiguous. Example: "Project Management (SVC-005) — 16 Hour".

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/routers/availability.py

@@ -4,8 +4,9 @@ Exposes the Reservation availability engine (lambda_erp/assets/reservation.py)
 over REST so the booking form can check "is this free?" before saving and the
 fleet calendar can render free vs booked. Read-only — posts nothing.
 
-See docs/RENTAL_UI_PLAN.md (Phase 1). The overlap rule itself lives in one
-place (reservation.overlapping_reservations); this router only surfaces it.
+The overlap rule itself lives in one place
+(`reservation.overlapping_reservations`); this router only surfaces it. See
+`docs/adr-0002-asset-and-reservation.md` for the reservation semantics.
 """
 
 from fastapi import APIRouter, Depends, Query, HTTPException

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/routers/chat_api.py

@@ -6,7 +6,7 @@ default). Lets an external orchestrator (Lambda's own lambda-web infra, then the
 iPhone app) hold a conversation with an ERP instance the way a connector script
 talks to Dynamics NAV.
 
-Statefulness (see docs/chat-api-plan.md):
+Statefulness (see docs/chat-api.md):
   - no `session_id`  -> stateless reasoning: the agent answers using only the
     current message; the turn is still persisted to a rolling audit session for
     visibility, but prior turns are NOT replayed. This suits a caller (the

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/routers/masters.py

@@ -13,8 +13,8 @@ from api.services import (
     MASTER_TABLES, MASTER_NAME_PREFIXES, MASTER_NAME_DIGITS, MASTER_RANDOM_NAME_TYPES,
     MASTER_IDENTITY_ALIAS,
     MASTER_REFERENCE_CHECKS,
-    _filter_atom, _search_clause, _where_from_filters, count_query_cached,
-    master_search_columns, parse_list_filter,
+    _filter_atom, _search_clause, _where_from_filters,
+    list_master_records, master_search_columns, parse_list_filter,
 )
 from api.auth import require_role, require_non_public_manager
 from api.list_values import distinct_list_values
@@ -359,6 +359,25 @@ def _master_list_where(db, doctype: str, master_type: str, request: Request,
     return where_parts, params, columns
 
 
+def _master_request_filters(db, doctype: str, request: Request) -> dict:
+    """Parse the REST query-string field filters into the shared internal form."""
+    filters = {}
+    for key, value in request.query_params.items():
+        if key in _MASTER_LIST_RESERVED:
+            continue
+        try:
+            field, parsed_value = parse_list_filter(db, doctype, key, value)
+        except KeyError:
+            raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
+        except TypeError:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Contains filter is only supported for text fields: {key}",
+            )
+        filters[field] = parsed_value
+    return filters
+
+
 def _master_order(columns: set, order_by: str | None, order: str) -> tuple[str, str]:
     if order_by is not None and order_by not in columns:
         raise HTTPException(status_code=400, detail=f"Unknown order_by field: {order_by}")
@@ -421,39 +440,26 @@ def list_masters(
     if not doctype:
         return {"detail": f"Unknown master type: {master_type}"}
     db = get_db()
-    where_parts, params, columns = _master_list_where(
-        db, doctype, master_type, request, include_disabled, search, search_fields,
-    )
-    sort_column, sort_direction = _master_order(columns, order_by, order)
-
-    where = (" WHERE " + " AND ".join(where_parts)) if where_parts else ""
-    total = count_query_cached(f'SELECT COUNT(*) as c FROM "{doctype}"{where}', params)
-
-    requested_fields = [f.strip() for f in (fields or "").split(",") if f.strip()]
-    if requested_fields:
-        unknown = [f for f in requested_fields if f not in columns]
-        if unknown:
-            raise HTTPException(status_code=400, detail=f"Unknown list fields: {', '.join(unknown)}")
-        if "name" not in requested_fields:
-            requested_fields.insert(0, "name")
-        projection = ", ".join(f'"{f}"' for f in requested_fields)
-    else:
-        projection = "*"
-    query = (
-        f'SELECT {projection} FROM "{doctype}"{where} '
-        f'ORDER BY {_master_order_sql(sort_column, sort_direction)} LIMIT {int(limit)}'
-    )
-    if offset:
-        query += f" OFFSET {int(offset)}"
-    rows = db.sql(query, params)
-
-    return {
-        "rows": rows,
-        "total": total,
-        "limit": limit,
-        "offset": offset,
-        "text_fields": sorted(db._get_text_columns(doctype)),
-    }
+    field_filters = _master_request_filters(db, doctype, request)
+    requested_search_fields = [
+        field.strip() for field in (search_fields or "").split(",") if field.strip()
+    ]
+    requested_fields = [field.strip() for field in (fields or "").split(",") if field.strip()]
+    try:
+        return list_master_records(
+            master_type,
+            filters=field_filters,
+            search=search,
+            search_fields=requested_search_fields or None,
+            include_disabled=include_disabled,
+            order_by=order_by,
+            order=order,
+            limit=limit,
+            offset=offset,
+            fields=requested_fields or None,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
 
 
 @router.get("/{master_type}/search")

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/api/services.py

@@ -236,8 +236,9 @@ def register_master(slug: str, table: str, name_field: str, *,
     (`/api/masters/{slug}`) and the chat tools (search_masters,
     get_master_fields, create/update/delete_master — their schemas and the
     system prompt are built from the live registry per request). Fields are
-    never declared: they're introspected from the table at call time, so every
-    text column of `table` is immediately searchable.
+    never declared: they're introspected from the table at call time. Ordinary
+    text columns are searched by default; large blobs remain available when a
+    caller names them explicitly.
 
     `name_field` is the human display column (e.g. "company_name").
     `name_prefix` enables auto-generated ids (prefix "LEAD" -> LEAD-001) when a
@@ -634,6 +635,47 @@ def _resolve_date_field(db, doctype: str, override: str | None) -> str | None:
 
 _SEARCH_EXPANSIONS: dict[str, list] = {}  # slug -> [fn(query: str, db) -> Iterable[str]]
 
+# Audit/plumbing columns and large blobs are poor defaults for a free-text
+# lookup. Callers can still target every real column explicitly.
+_SEARCH_SKIP_COLUMNS = {
+    "creation", "modified", "created_at", "updated_at", "owner",
+    "modified_by", "idx", "parent", "parenttype", "parentfield",
+}
+_BULK_TEXT_COLUMNS = {"description", "notes", "remarks", "terms", "comments"}
+
+
+def is_bulk_text_column(column: str) -> bool:
+    return (
+        column in _BULK_TEXT_COLUMNS
+        or column.endswith("_template")
+        or column.endswith("_html")
+    )
+
+
+def _useful_text_columns(db, doctype: str) -> list[str]:
+    return sorted(
+        column for column in db._get_text_columns(doctype) - _SEARCH_SKIP_COLUMNS
+        if not is_bulk_text_column(column)
+    )
+
+
+def document_search_columns(db, doctype_slug: str) -> list[str]:
+    """Default free-text columns for a document REST/MCP list query.
+
+    A registered chat doctype may deliberately provide a smaller field set.
+    Otherwise use schema-discovered text columns, excluding audit noise and
+    large blobs. This prevents ``search`` without ``search_fields`` from
+    silently becoming an unfiltered list.
+    """
+    doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
+    if not doctype:
+        return []
+    columns = db._get_table_columns(doctype)
+    declared = (CHAT_DOCTYPES.get(doctype_slug) or {}).get("fields") or []
+    if declared:
+        return sorted({field for field in declared if field in columns})
+    return _useful_text_columns(db, doctype)
+
 
 def register_search_expansion(doctype_slug: str, fn) -> None:
     """Register a related-table search for a doctype's list. `fn(query, db)`
@@ -652,6 +694,8 @@ def _search_clause(db, doctype: str, doctype_slug: str, search, search_fields):
     tracks the searched list exactly."""
     if not search:
         return None, []
+    if not search_fields:
+        search_fields = document_search_columns(db, doctype_slug)
     cols = db._get_table_columns(doctype)
     like = f"%{search}%"
     parts, params = [], []
@@ -942,18 +986,125 @@ def count_query_cached(query: str, params=None) -> int:
     return total
 
 
-# Audit / plumbing columns never worth matching a free-text list search against.
-_MASTER_SEARCH_SKIP = {
-    "name", "creation", "modified", "owner", "modified_by", "disabled",
-    "idx", "parent", "parenttype", "parentfield", "docstatus",
-}
-
-
 def master_search_columns(db, doctype: str) -> list:
     """Text columns a free-text master-list search matches by default — schema-
     discovered (a new text field becomes searchable automatically), minus audit
-    noise. Mirrors the chat search_masters default so both search the same set."""
-    return sorted(db._get_text_columns(doctype) - _MASTER_SEARCH_SKIP)
+    noise and large blobs. Shared by REST and chat/MCP."""
+    return _useful_text_columns(db, doctype)
+
+
+def master_bulk_text_columns(db, doctype: str) -> list[str]:
+    """Large text fields available for explicit search, but skipped by default."""
+    return sorted(
+        column for column in db._get_text_columns(doctype)
+        if is_bulk_text_column(column)
+    )
+
+
+def _master_sort_sql(column: str, direction: str) -> str:
+    sql = f'"{column}" {direction.upper()}'
+    if column != "name":
+        sql += f" NULLS LAST, name {direction.upper()}"
+    return sql
+
+
+def list_master_records(
+    master_type: str,
+    *,
+    filters: dict | None = None,
+    search: str | None = None,
+    search_fields: list[str] | None = None,
+    include_disabled: bool = False,
+    order_by: str | None = None,
+    order: str = "asc",
+    limit: int | None = 50,
+    offset: int = 0,
+    fields: list[str] | None = None,
+    with_total: bool = True,
+) -> dict:
+    """Deterministic master-list query shared by REST and chat/MCP.
+
+    Scalars are exact filters; the whitelisted operator forms accepted by
+    ``_filter_atom`` provide contains/comparison/NULL filtering. Free text is a
+    separate OR-group and is ANDed with those field filters.
+    """
+    entry = MASTER_TABLES.get(master_type)
+    if not entry:
+        raise ValueError(f"Unknown master type: {master_type}")
+    doctype, _ = entry
+    db = get_db()
+    columns = db._get_table_columns(doctype)
+    text_fields = sorted(db._get_text_columns(doctype))
+
+    db_filters = {
+        key: value for key, value in (filters or {}).items()
+        if value is not None and value != ""
+    }
+    unknown_filters = [key for key in db_filters if key not in columns]
+    if unknown_filters:
+        raise ValueError(
+            f"Unknown filter column(s) for {master_type}: {', '.join(unknown_filters)}"
+        )
+    _validate_typed_filters(db, doctype, db_filters)
+
+    where_parts, params = _where_from_filters(db_filters)
+    if not include_disabled and "disabled" in columns:
+        where_parts.insert(0, '"disabled" = ?')
+        params.insert(0, 0)
+
+    requested_search_fields = list(search_fields or [])
+    unknown_search = [field for field in requested_search_fields if field not in columns]
+    if unknown_search:
+        raise ValueError(f"Unknown search field(s): {', '.join(unknown_search)}")
+    effective_search_fields = requested_search_fields or master_search_columns(db, doctype)
+    search_where, search_params = _search_clause(
+        db, doctype, master_type, search, effective_search_fields,
+    )
+    if search_where:
+        where_parts.append(search_where)
+        params.extend(search_params)
+
+    sort_column = order_by or "name"
+    if sort_column not in columns:
+        raise ValueError(f"Unknown order_by column for {master_type}: {sort_column}")
+    direction = str(order).lower()
+    if direction not in ("asc", "desc"):
+        raise ValueError("order must be 'asc' or 'desc'")
+
+    requested_fields = list(fields or [])
+    unknown_fields = [field for field in requested_fields if field not in columns]
+    if unknown_fields:
+        raise ValueError(f"Unknown result field(s): {', '.join(unknown_fields)}")
+    if requested_fields:
+        if "name" not in requested_fields:
+            requested_fields.insert(0, "name")
+        projection = ", ".join(f'"{field}"' for field in requested_fields)
+    else:
+        projection = "*"
+
+    where = " WHERE " + " AND ".join(where_parts) if where_parts else ""
+    total = (
+        count_query_cached(f'SELECT COUNT(*) AS c FROM "{doctype}"{where}', params)
+        if with_total else None
+    )
+    query = (
+        f'SELECT {projection} FROM "{doctype}"{where} '
+        f'ORDER BY {_master_sort_sql(sort_column, direction)}'
+    )
+    if limit is not None:
+        query += f" LIMIT {max(1, int(limit))}"
+    elif offset and db.dialect == "sqlite":
+        query += " LIMIT -1"
+    if offset:
+        query += f" OFFSET {max(0, int(offset))}"
+
+    return {
+        "rows": db.sql(query, params),
+        "total": total,
+        "limit": limit,
+        "offset": max(0, int(offset)),
+        "text_fields": text_fields,
+    }
 
 
 def count_documents(doctype_slug: str, filters: dict = None, include_discarded: bool = False) -> int:

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/frontend/src/api/client.ts

@@ -324,7 +324,7 @@ export const api = {
   stockBalance: (params?: Record<string, string>) =>
     request<{ rows: any[] }>(`/reports/stock-balance${qs(params)}`),
 
-  // --- Rentals: availability + fleet calendar (docs/RENTAL_UI_PLAN.md) ---
+  // --- Rentals: availability + fleet calendar ---
   availability: (params: { item_code: string; from: string; to: string; warehouse?: string; exclude?: string }) =>
     request<AvailabilityResult>(`/availability${qs(params)}`),
 

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/lambda_erp/accounting/revaluation.py

@@ -5,7 +5,7 @@ historical rate(s) they were booked at. At period end their base value has
 drifted from today's rate; `run_period_revaluation` restates them to the
 closing rate and books the difference as **unrealized** FX gain/loss.
 
-Principles (see docs/multicurrency-phase-4c.md):
+Principles (see docs/foreign-currency-revaluation.md):
 - Never edit posted entries — revaluation posts new GL, and an auto-reversal
   dated the next day backs it out so it doesn't double-count once the balance
   settles (and realized FX is recognized then).

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/lambda_erp/database.py

@@ -1403,7 +1403,7 @@ class Database:
             # (sha256); `key_prefix` is a display-only fragment. `role` bounds the
             # agent's tool access; `session_owner` is the user_id the key's chat
             # sessions are owned under (isolated from human users). See
-            # docs/chat-api-plan.md.
+            # docs/chat-api.md.
             # Per-user API keys (v2): a key BELONGS to a User and can never act
             # above its owner — `role` is only a CAP; the effective role is
             # min(cap, owner's current role) resolved live at auth time, so a

{lambda_erp-0.8.20 → lambda_erp-0.8.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.8.20"
+version = "0.8.21"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"