lambda-erp 1.0.0__tar.gz → 1.0.2__tar.gz

{lambda_erp-1.0.0 → lambda_erp-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 1.0.0
+Version: 1.0.2
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0
@@ -303,6 +303,9 @@ docs/agents/        # Invariants, gotchas, design decisions (LLM-readable)
 
 `docs/agents/` is worth a read if you're going to contribute - it captures the invariants the code assumes but doesn't always enforce, plus the landmines that have bitten us.
 
+[Recent changes and outreach](docs/time-filters.md): shared time filters for REST,
+chat and MCP lists, with exact windows, pagination and timestamp-quality metadata.
+
 ---
 
 ## Building a customer deployment on top of the core

{lambda_erp-1.0.0 → lambda_erp-1.0.2}/README.md

@@ -275,6 +275,9 @@ docs/agents/        # Invariants, gotchas, design decisions (LLM-readable)
 
 `docs/agents/` is worth a read if you're going to contribute - it captures the invariants the code assumes but doesn't always enforce, plus the landmines that have bitten us.
 
+[Recent changes and outreach](docs/time-filters.md): shared time filters for REST,
+chat and MCP lists, with exact windows, pagination and timestamp-quality metadata.
+
 ---
 
 ## Building a customer deployment on top of the core

{lambda_erp-1.0.0 → lambda_erp-1.0.2}/api/chat.py

@@ -26,6 +26,7 @@ from dotenv import load_dotenv
 from fastapi import APIRouter, Depends as _Depends, HTTPException, WebSocket, WebSocketDisconnect
 from openai import OpenAI
 
+from api.time_filters import TIME_FILTER_SCHEMA, time_filter_fields
 from api import services
 from api.tool_permissions import tool_allowed, tool_permission_error
 from api.demo_limits import (
@@ -474,13 +475,16 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "list_documents",
-            "description": "List or search documents of a given type. Returns an array of document summaries (header fields only — child tables like 'items' and 'taxes' are NOT included to keep results compact). Use get_document to drill into a single document's line items. Results are ordered by creation DESC (newest first). Page past `limit` with `offset`; trim the payload to only the columns you need with `fields`.",
+            "description": "List or search documents of a given type. With time_filter or include_meta=true returns {rows,total,has_more,next_offset,time_filter,coverage,warnings}; otherwise returns an array of document summaries (header fields only — child tables like 'items' and 'taxes' are NOT included to keep results compact). Use get_document to drill into a single document's line items. Results default to creation DESC, or the parsed time_filter field DESC when supplied. Page past `limit` with `offset`; trim the payload to only the columns you need with `fields`.",
             "parameters": {
                 "type": "object",
                 "properties": {
+                    "time_filter": TIME_FILTER_SCHEMA,
+                    "include_meta": {"type": "boolean", "description": "Use true for complete lists or overviews: returns exact total and pagination/coverage metadata."},
+                    "include_discarded": {"type": "boolean", "description": "Include discarded drafts when checking recent changes; default false."},
                     "doctype": {"type": "string", "enum": DOCUMENT_SLUGS, "description": "Document type slug"},
-                    "filters": {"type": "object", "description": "Optional filters on any column. Equality: {\"status\": \"Draft\", \"customer\": \"CUST-001\"}. Comparison (value = a 2-item array [op, value]): {\"grand_total\": [\">\", 100]}, {\"fit\": [\"!=\", \"A\"]}. Case-insensitive text substring: {\"customer_name\": [\"contains\", \"acme\"]}. NULL checks (1-item array): {\"fit\": [\"is null\"]}, {\"main_email\": [\"is not null\"]}. Allowed ops: =, !=, >, <, >=, <=, contains, like, not like, is null, is not null. Free-text search: {\"search\": \"acme\"} matches the doctype's default text columns; narrow it with {\"search\": \"acme\", \"search_fields\": [\"company_name\", \"tags\"]}.", "default": {}},
-                    "order_by": {"type": "string", "description": "Optional column to sort by (e.g. \"occurred_at\" for a timeline). Defaults to creation."},
+                    "filters": {"type": "object", "description": "Optional filters on any column. Equality: {\"status\": \"Draft\", \"customer\": \"CUST-001\"}. Comparison (value = a 2-item array [op, value]): {\"grand_total\": [\">\", 100]}, {\"fit\": [\"!=\", \"A\"]}. Case-insensitive text substring: {\"customer_name\": [\"contains\", \"acme\"]}. NULL checks (1-item array): {\"fit\": [\"is null\"]}, {\"main_email\": [\"is not null\"]}. Allowed ops: =, !=, >, <, >=, <=, in, not in, contains, like, not like, is null, is not null. IN example: {\"type\": [\"in\", [\"call\", \"email\", \"note\"]]}. Free-text search: {\"search\": \"acme\"} matches the doctype's default text columns; narrow it with {\"search\": \"acme\", \"search_fields\": [\"company_name\", \"tags\"]}.", "default": {}},
+                    "order_by": {"type": "string", "description": "Optional column to sort by. Defaults to the time_filter field when supplied, otherwise creation."},
                     "order": {"type": "string", "enum": ["asc", "desc"], "description": "Sort direction (default desc)", "default": "desc"},
                     "limit": {"type": "integer", "description": "Max results (default 20, max 500)", "default": 20},
                     "offset": {"type": "integer", "description": "Skip this many rows before returning — for paging past `limit`. Default 0.", "default": 0},
@@ -494,7 +498,7 @@ 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 required fields, conditional business rules, child requirements, dynamic links and supported transient inputs. Check these before creating or updating a document; unknown fields are rejected.",
+            "description": "List available columns, text fields and supported time_filter_fields of a document type. 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 required fields, conditional business rules, child requirements, dynamic links and supported transient inputs. Check these before creating or updating a document; unknown fields are rejected.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -663,10 +667,12 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "search_masters",
-            "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.",
+            "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. With time_filter or include_meta=true returns a page object with rows, total, pagination and coverage (default limit 50, max 500; no fuzzy fallback). Legacy simple lookups return all matches as an array unless limit is supplied.",
             "parameters": {
                 "type": "object",
                 "properties": {
+                    "time_filter": TIME_FILTER_SCHEMA,
+                    "include_meta": {"type": "boolean", "description": "Use true for overviews: returns rows, exact total, pagination and coverage. Automatically enabled with time_filter."},
                     "master_type": {"type": "string", "enum": MASTER_TYPES},
                     "query": {"type": "string", "description": "Search term (empty string returns all)", "default": ""},
                     "fields": {
@@ -679,9 +685,9 @@ TOOLS = [
                         "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_by": {"type": "string", "description": "Optional real column to sort by. Defaults to the time_filter field when supplied, otherwise 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."},
+                    "limit": {"type": "integer", "description": "Maximum results. With time_filter/include_meta: default 50, range 1–500. Legacy simple lookups have no cap when omitted."},
                     "offset": {"type": "integer", "description": "Skip this many matching rows. Use with limit for pagination.", "default": 0},
                     "result_fields": {
                         "type": "array",
@@ -1454,39 +1460,28 @@ def _validate_filter_columns(doctype_slug, filters) -> str | None:
 
 
 def _handle_list_documents(args):
-    # List views don't need child tables — strip them so the LLM can see more rows
-    # within the tool-result budget. Use get_document to drill into one doc.
     doctype = args["doctype"]
-    filters = args.get("filters") or {}
-    err = _validate_filter_columns(doctype, filters)
-    if err:
-        return {"error": err}
-    order_by = args.get("order_by")
-    cols = services.document_columns(doctype)
-    if order_by and cols and order_by not in cols:
-        return {"error": f"Unknown order_by column for {doctype}: {order_by}"}
-
-    cls_entry = services.DOCUMENT_CLASSES.get(services.SLUG_TO_DOCTYPE.get(doctype, ""))
-    child_keys = list(cls_entry.CHILD_TABLES.keys()) if cls_entry and cls_entry.CHILD_TABLES else []
-
-    fields = args.get("fields")
     try:
-        rows = services.list_documents(
-            doctype,
-            filters=filters,
-            limit=args.get("limit", 20),
-            offset=args.get("offset", 0) or 0,
-            order_by=order_by,
-            order=args.get("order", "desc"),
-            fields=fields,
+        kwargs = dict(
+            filters=args.get("filters") or {}, limit=args.get("limit", 20),
+            offset=args.get("offset", 0) or 0, order_by=args.get("order_by"),
+            order=args.get("order", "desc"), fields=args.get("fields"),
+            include_discarded=bool(args.get("include_discarded")),
         )
-    except ValueError as e:  # bad filter operator / malformed operator list
-        return {"error": str(e)}
-    if not fields:  # projection already excludes child tables
+        if isinstance(kwargs["limit"], bool) or not isinstance(kwargs["limit"], int) or not 1 <= kwargs["limit"] <= 500:
+            raise ValueError("limit must be an integer between 1 and 500")
+        if not isinstance(kwargs["offset"], int) or isinstance(kwargs["offset"], bool) or kwargs["offset"] < 0:
+            raise ValueError("offset must be a non-negative integer")
+        meta = args.get("include_meta") or args.get("time_filter") is not None
+        result = services.list_document_page(doctype, time_filter=args.get("time_filter"), **kwargs) if meta else services.list_documents(doctype, **kwargs)
+        rows = result["rows"] if meta else result
+        cls = services.DOCUMENT_CLASSES.get(services.SLUG_TO_DOCTYPE.get(doctype, ""))
         for row in rows:
-            for key in child_keys:
+            for key in (cls.CHILD_TABLES if cls else {}):
                 row.pop(key, None)
-    return rows
+        return result
+    except (TypeError, ValueError) as exc:
+        return {"error": str(exc)}
 
 
 def _handle_generate_document_pdf(args, user=None):
@@ -1598,6 +1593,7 @@ def _handle_get_master_fields(args):
     cls = services.DOCUMENT_CLASSES.get(doctype)
     return {
         "master_type": master_type,
+        "time_filter_fields": time_filter_fields(db, doctype),
         "fields": sorted(db._get_table_columns(doctype)),
         "text_fields": sorted(db._get_text_columns(doctype)),
         # What search_masters searches when `fields` is omitted.
@@ -1613,6 +1609,7 @@ def _handle_get_master_fields(args):
 
 def _handle_search_masters(args):
     db = get_db()
+    meta = bool(args.get("include_meta")) or args.get("time_filter") is not None
     master_type = args["master_type"]
     query = (args.get("query") or "").strip()
 
@@ -1626,6 +1623,13 @@ def _handle_search_masters(args):
             limit = max(1, int(_raw_limit))
         except (TypeError, ValueError):
             limit = None
+    if meta:
+        limit = args.get("limit", 50)
+        offset = args.get("offset", 0)
+        if isinstance(limit, bool) or not isinstance(limit, int) or not 1 <= limit <= 500:
+            return {"error": "limit must be an integer between 1 and 500"}
+        if isinstance(offset, bool) or not isinstance(offset, int) or offset < 0:
+            return {"error": "offset must be a non-negative integer"}
 
     entry = services.MASTER_TABLES.get(master_type)
     if not entry:
@@ -1685,11 +1689,14 @@ def _handle_search_masters(args):
             limit=limit,
             offset=offset,
             fields=result_fields,
-            with_total=False,
+            with_total=meta,
+            time_filter=args.get("time_filter"),
         )
     except (TypeError, ValueError) as exc:
         return {"error": str(exc)}
     rows = [dict(row) for row in result["rows"]]
+    if meta:
+        return result
     if rows or not query:
         return rows
 
@@ -2516,6 +2523,34 @@ Only state that something was done — created, changed, enabled/disabled, booke
 
 **Path 1: single-record lookup → `list_documents` / `get_document`.** For "is SINV-0042 paid", "what did customer X order last", "show me the latest 5 purchase orders" — fetch the rows directly. Don't try to aggregate in your head unless there are only a handful of rows in front of you.
 
+**Recent changes and outreach:** For "last N hours" use `list_documents` or
+`search_masters` with `time_filter={{"field":"modified","last_hours":24}}`
+(or the requested hours), so the server resolves the exact window. Use `creation`
+for newly created records, `modified` for changed records, `occurred_at` for CRM
+interactions. Never substitute yesterday at midnight for the last 24 hours. Reuse
+returned `time_filter` since/until for subsequent pages and other types; for today
+or yesterday resolve local calendar boundaries using the user's known timezone
+(and get_current_time), asking if the timezone is unknown and affects the answer.
+For "what happened in this ERP", cover relevant documents, masters and registered
+CRM activities; query changes as well as creations. Do not claim no changes from
+a creation-only search. Describe which areas were checked; this is a current-record
+overview, not a complete audit trail of deletions, old field values or every edit.
+For outreach include relevant `note` entries describing draft preparation and
+scheduled sends, as well as calls/emails/meetings; a call/email-only filter misses
+planned outreach. Preserve distinctions between prepared, scheduled, sent and
+replied, and between interaction time and planned future send time. Load linked
+leads only to enrich the matching activities; unfiltered old lead state is not
+proof of activity during the period. Use supported IN filters to select multiple
+types; if a filter fails, fix it without silently dropping its restriction.
+For overviews use time_filter or include_meta=true, inspect total/has_more, and
+page when exhaustive detail is requested. Never count only the first page as the
+total. Mention coverage warnings: missing/invalid timestamps mean unknown history,
+not no activity. Unsupported fields/query errors are not empty results. Do not
+infer who changed what from modified alone; current fields are not before/after
+history. For core masters predating timestamp capture, creation can be unknown. Include
+disabled/discarded records when the overview requires them. Low-level SQL and some
+indirect document updates may not maintain modified; do not promise all changes.
+
 **Path 2: aggregated facts → `query_dataset`.** For "who is our top customer by revenue", "total sales this month", "outstanding AR by customer", "average invoice size", "count of POs per supplier" — anything that requires summing, counting, ranking, or grouping across many rows — call `query_dataset`. It runs a deterministic SQL aggregation server-side and returns the actual aggregated numbers you can cite in chat. NEVER try to compute a top-N or sum by eyeballing a `list_documents` sample — it defaults to 20 rows and will give a wrong answer on any meaningful dataset.
 
 **Path 3: charts / complex reports → `create_custom_analytics_report`.** Only call this when the user **explicitly asks for** a chart, graph, visualization, dashboard, trend, pivot, breakdown, or saved report — or when the analysis genuinely needs a reusable report. Do **not** invoke it for a factual question `query_dataset` could answer in one call.

{lambda_erp-1.0.0 → lambda_erp-1.0.2}/api/routers/documents.py

@@ -11,6 +11,7 @@ from api.services import (
     discard_document,
     convert_document,
     list_documents,
+    list_document_page,
     count_documents,
     document_columns,
     adjacent_documents,
@@ -21,6 +22,7 @@ from api.pdf import generate_pdf
 from api.pdf_exports import create_pdf_export, get_pdf_export, pdf_content_disposition
 from api.auth import require_role
 from api.list_values import distinct_list_values
+from api.time_filters import request_time_filter
 from lambda_erp.database import get_db
 
 router = APIRouter(prefix="/documents", tags=["documents"])
@@ -34,7 +36,7 @@ _manager = Depends(require_role("manager"))
 _LIST_RESERVED = {
     "status", "party", "from_date", "to_date", "docstatus",
     "include_discarded", "limit", "offset", "order_by", "order",
-    "date_field", "search", "search_fields", "fields",
+    "date_field", "search", "search_fields", "fields", "time_filter",
 }
 
 
@@ -60,7 +62,8 @@ def list_docs(
     search: str | None = None,
     search_fields: str | None = None,
     fields: str | None = None,
-    limit: int = Query(default=50, le=500),
+    time_filter: str | None = None,
+    limit: int = Query(default=50, ge=1, le=500),
     offset: int = Query(default=0, ge=0),
     _user: dict = _viewer,
 ):
@@ -130,17 +133,15 @@ def list_docs(
     if fields:
         projection = [f.strip() for f in fields.split(",") if f.strip() and f.strip() in columns]
 
-    rows = list_documents(doctype_slug, filters=filters, limit=limit, offset=offset,
-                          include_discarded=include_discarded, order_by=order_by, order=order,
-                          fields=projection)
-    total = count_documents(doctype_slug, filters=filters, include_discarded=include_discarded)
-    return {
-        "rows": rows,
-        "total": total,
-        "limit": limit,
-        "offset": offset,
-        "text_fields": sorted(get_db()._get_text_columns(doctype)),
-    }
+    try:
+        result = list_document_page(
+            doctype_slug, filters=filters, limit=limit, offset=offset,
+            include_discarded=include_discarded, order_by=order_by, order=order,
+            fields=projection, time_filter=request_time_filter(request),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {**result, "text_fields": sorted(get_db()._get_text_columns(doctype))}
 
 
 @router.get("/{doctype_slug}/{name}/adjacent")
@@ -204,8 +205,12 @@ def adjacent_doc(
         raise HTTPException(status_code=400, detail=f"Unknown order_by field: {order_by}")
     if order.lower() not in ("asc", "desc"):
         raise HTTPException(status_code=400, detail="order must be 'asc' or 'desc'")
-    return adjacent_documents(doctype_slug, name, filters=filters,
-                              include_discarded=include_discarded, order_by=order_by, order=order)
+    try:
+        return adjacent_documents(doctype_slug, name, filters=filters,
+                                  include_discarded=include_discarded, order_by=order_by, order=order,
+                                  time_filter=request_time_filter(request))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
 
 
 @router.get("/{doctype_slug}/search")

{lambda_erp-1.0.0 → lambda_erp-1.0.2}/api/routers/masters.py

@@ -18,6 +18,7 @@ from api.services import (
 )
 from api.auth import require_role, require_non_public_manager
 from api.list_values import distinct_list_values
+from api.time_filters import request_time_filter, resolve_time_filter, time_predicate
 from lambda_erp.exceptions import ValidationError
 from lambda_erp.validation import missing
 
@@ -275,6 +276,20 @@ def _validate_master_input(master_type, doctype, data, name=None):
     for field, table in MASTER_LINK_FIELDS.get(master_type, {}).items():
         if merged.get(field) and not db.exists(table, merged[field]):
             raise ValidationError(f'{doctype}: {field} must reference an existing {table}')
+    if master_type == 'company' and data.get('default_sales_tax_template'):
+        template = db.get_value('Tax Template', data['default_sales_tax_template'], ['company', 'tax_type'])
+        if not template or template['company'] != (name or data.get('name')) or template['tax_type'] != 'Sales':
+            raise ValidationError('Default sales tax template must be a Sales template belonging to this Company')
+
+
+@router.get('/company/{name}/sales-tax-templates')
+def company_sales_tax_templates(name: str, _user: dict = _viewer):
+    """Choices for the company default, using existing tax templates only."""
+    db = get_db()
+    if not db.exists('Company', name):
+        raise HTTPException(status_code=404, detail='Company not found')
+    return db.get_all('Tax Template', filters={'company': name, 'tax_type': 'Sales'},
+                      fields=['name', 'title'], order_by='title, name')
 
 
 def create_master_record(master_type: str, data: dict) -> dict:
@@ -289,6 +304,8 @@ def _create_master_record(master_type: str, data: dict) -> dict:
 
     db = get_db()
     doc = _normalize_master_data(data)
+    doc.pop("creation", None)
+    doc.pop("modified", None)
 
     # Let callers set the code under its intuitive alias (item_code -> name).
     # An explicit `name` still wins; the alias key is consumed either way so it
@@ -358,6 +375,8 @@ def _update_master_record(master_type: str, name: str, data: dict) -> dict:
 
     db = get_db()
     normalized = _normalize_master_data(data)
+    normalized.pop("creation", None)
+    normalized.pop("modified", None)
 
     # The alias (item_code) is the identity, not a mutable column. Allow it as a
     # no-op when it matches the record being updated, but reject a rename — the
@@ -408,7 +427,7 @@ def _update_master_record(master_type: str, name: str, data: dict) -> dict:
 # suffix used by Smart Search.
 _MASTER_LIST_RESERVED = {
     "limit", "offset", "include_disabled", "search", "search_fields", "fields",
-    "order_by", "order",
+    "order_by", "order", "time_filter",
 }
 
 
@@ -457,6 +476,16 @@ def _master_list_where(db, doctype: str, master_type: str, request: Request,
             where_parts.append(clause)
             params += sp
 
+    try:
+        window = resolve_time_filter(db, doctype, request_time_filter(request))
+        if window:
+            if window["field"] in _master_request_filters(db, doctype, request):
+                raise ValueError("Do not combine time_filter with a filter on the same timestamp field")
+            clause, bounds = time_predicate(window)
+            where_parts.append(clause)
+            params.extend(bounds)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
     return where_parts, params, columns
 
 
@@ -489,14 +518,15 @@ def _master_order(columns: set, order_by: str | None, order: str) -> tuple[str,
     return order_by or "name", direction if order_by else "asc"
 
 
-def _master_order_sql(column: str, direction: str, *, reverse: bool = False) -> str:
+def _master_order_sql(column: str, direction: str, *, reverse: bool = False, expression: str | None = None) -> str:
     """Deterministic master ordering with NULL values consistently at the end."""
     effective = direction
     nulls = "LAST"
     if reverse:
         effective = "desc" if direction == "asc" else "asc"
         nulls = "FIRST"
-    sql = f'"{column}" {effective.upper()}'
+    expression = expression or f'"{column}"'
+    sql = f'{expression} {effective.upper()}'
     if column != "name":
         sql += f" NULLS {nulls}, name {effective.upper()}"
     return sql
@@ -527,12 +557,13 @@ def master_filter_values(
 def list_masters(
     master_type: str,
     request: Request,
-    limit: int = Query(default=50, le=1000),
+    limit: int = Query(default=50, ge=1, le=1000),
     offset: int = Query(default=0, ge=0),
     include_disabled: bool = False,
     search: str | None = None,
     search_fields: str | None = None,
     fields: str | None = None,
+    time_filter: str | None = None,
     order_by: str | None = None,
     order: str = "asc",
     _user: dict = _viewer,
@@ -558,6 +589,7 @@ def list_masters(
             limit=limit,
             offset=offset,
             fields=requested_fields or None,
+            time_filter=request_time_filter(request),
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc))
@@ -609,10 +641,14 @@ def adjacent_master(
     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)
+    window = resolve_time_filter(db, doctype, request_time_filter(request))
+    sort_column, sort_direction = _master_order(columns, order_by or (window["field"] if window else None), order)
+    sort_expression = f'"{sort_column}"'
+    if window and sort_column == window["field"]:
+        sort_expression = f'erp_timestamp_epoch({sort_expression})'
     base_where = (" AND ".join(where_parts)) if where_parts else "1 = 1"
     current_rows = db.sql(
-        f'SELECT "{sort_column}" AS sort_value FROM "{doctype}" '
+        f'SELECT {sort_expression} AS sort_value FROM "{doctype}" '
         f"WHERE {base_where} AND name = ? LIMIT 1",
         [*params, name],
     )
@@ -633,26 +669,26 @@ def adjacent_master(
             key_params = [name]
         elif current_value is None:
             if after:
-                keyset = f'"{sort_column}" IS NULL AND name {same_cmp} ?'
+                keyset = f'{sort_expression} IS NULL AND name {same_cmp} ?'
             else:
                 keyset = (
-                    f'("{sort_column}" IS NOT NULL OR '
-                    f'("{sort_column}" IS NULL AND name {same_cmp} ?))'
+                    f'({sort_expression} IS NOT NULL OR '
+                    f'({sort_expression} IS NULL AND name {same_cmp} ?))'
                 )
             key_params = [name]
         else:
             keyset = (
-                f'("{sort_column}" {primary_cmp} ? OR '
-                f'("{sort_column}" = ? AND name {same_cmp} ?)'
+                f'({sort_expression} {primary_cmp} ? OR '
+                f'({sort_expression} = ? AND name {same_cmp} ?)'
             )
             key_params = [current_value, current_value, name]
             if after:
-                keyset += f' OR "{sort_column}" IS NULL'
+                keyset += f' OR {sort_expression} IS NULL'
             keyset += ")"
 
         rows = db.sql(
             f'SELECT name FROM "{doctype}" WHERE {base_where} AND {keyset} '
-            f'ORDER BY {_master_order_sql(sort_column, sort_direction, reverse=not after)} LIMIT 1',
+            f'ORDER BY {_master_order_sql(sort_column, sort_direction, reverse=not after, expression=sort_expression)} LIMIT 1',
             [*params, *key_params],
         )
         return rows[0]["name"] if rows else None