Merge pull request #56882 from frappe/fix/pos-invoice-reset-mop-attributeerror

fix: reset_mode_of_payments raises AttributeError on a POS Invoice

erpnext/accounts/doctype/account/chart_of_accounts/verified/in_standard_chart_of_accounts.json

@@ -37,6 +37,10 @@
                         "account_type": "Stock",
                         "account_category": "Stock Assets"
                     },
+                    "Stock Delivered But Not Billed": {
+                        "account_type": "Stock Delivered But Not Billed",
+                        "account_category": "Stock Assets"
+                    },
                     "account_type": "Stock",
                     "account_category": "Stock Assets"
                 },
@@ -223,10 +227,6 @@
                     "Stock Received But Not Billed": {
                         "account_type": "Stock Received But Not Billed",
                         "account_category": "Trade Payables"
-                    },
-                    "Stock Delivered But Not Billed": {
-                        "account_type": "Stock Delivered But Not Billed",
-                        "account_category": "Trade Payables"
                     }
                 },
                 "Duties and Taxes": {

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.py

@@ -1,10 +1,59 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-
+from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
+	aggregate_with_last_account_closing_balance,
+	generate_key,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
 
+def entry(**overrides):
+	row = {"debit": 0, "credit": 0, "debit_in_account_currency": 0, "credit_in_account_currency": 0}
+	row.update(overrides)
+	return row
+
+
 class TestAccountClosingBalance(ERPNextTestSuite):
-	pass
+	"""The closing-balance snapshot is built by merging this period's entries with the
+	previous period's. These lock the merge/key logic that drives that carry-forward."""
+
+	def test_matching_entries_are_summed(self):
+		# this is how a prior-period balance carries forward into the current one
+		merged = aggregate_with_last_account_closing_balance(
+			[
+				entry(account="Cash - _TC", debit=100, debit_in_account_currency=100),
+				entry(
+					account="Cash - _TC",
+					debit=50,
+					credit=20,
+					debit_in_account_currency=50,
+					credit_in_account_currency=20,
+				),
+			],
+			[],
+		)
+		self.assertEqual(len(merged), 1)
+		row = next(iter(merged.values()))
+		self.assertEqual(row["debit"], 150)
+		self.assertEqual(row["credit"], 20)
+		# the account-currency columns are accumulated in the same pass
+		self.assertEqual(row["debit_in_account_currency"], 150)
+		self.assertEqual(row["credit_in_account_currency"], 20)
+
+	def test_entries_are_kept_separate_per_dimension(self):
+		merged = aggregate_with_last_account_closing_balance(
+			[
+				entry(account="Cash - _TC", cost_center="CC1", debit=100, debit_in_account_currency=100),
+				entry(account="Cash - _TC", cost_center="CC2", debit=40, debit_in_account_currency=40),
+			],
+			[],
+		)
+		self.assertEqual(len(merged), 2)
+
+	def test_period_closing_flag_is_part_of_the_key(self):
+		# a P&L reversal (flag 0) and a closing-account entry (flag 1) for the same
+		# account must not merge, so the flag has to distinguish their keys
+		key_reversal, _ = generate_key(entry(account="Sales - _TC", is_period_closing_voucher_entry=0), [])
+		key_closing, _ = generate_key(entry(account="Sales - _TC", is_period_closing_voucher_entry=1), [])
+		self.assertNotEqual(key_reversal, key_closing)

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.js

@@ -6,7 +6,7 @@ frappe.ui.form.on("Accounting Dimension Filter", {
 		let help_content = `<table class="table table-bordered" style="background-color: var(--scrollbar-track-color);">
 				<tr><td>
 					<p>
-						<i class="fa fa-hand-right"></i>
+						<svg class="icon icon-sm"><use href="#icon-info"></use></svg>
 						{{__('Note: On checking Is Mandatory the accounting dimension will become mandatory against that specific account for all accounting transactions')}}
 					</p>
 				</td></tr>

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -188,7 +188,7 @@ def get_closing_balance_as_per_statement(bank_account: str, date: str):
 	return {"balance": 0, "date": None}
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def set_closing_balance_as_per_statement(bank_account: str, date: str | datetime.date, balance: float):
 	"""
 	Set the closing balance as per statement for a bank account and date

erpnext/accounts/doctype/bank_guarantee/test_bank_guarantee.py

@@ -1,8 +1,76 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+from frappe.utils import flt
+
+from erpnext.accounts.doctype.bank_guarantee.bank_guarantee import get_voucher_details
+from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.tests.utils import ERPNextTestSuite
 
+BANK = "_Test BG Bank"
+
 
 class TestBankGuarantee(ERPNextTestSuite):
-	pass
+	"""Bank Guarantee records a guarantee issued/received against a customer or
+	supplier. validate() needs a party; on_submit() needs the bank details filled in."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		if not frappe.db.exists("Bank", BANK):
+			frappe.get_doc({"doctype": "Bank", "bank_name": BANK}).insert()
+
+	def make_bg(self, **args):
+		args = frappe._dict(args)
+		doc = frappe.new_doc("Bank Guarantee")
+		doc.bg_type = args.bg_type or "Receiving"
+		doc.amount = args.amount if args.amount is not None else 1000
+		doc.start_date = args.start_date or "2026-06-01"
+		if args.end_date:
+			doc.end_date = args.end_date
+		doc.customer = args.get("customer", "_Test Customer")
+		doc.supplier = args.get("supplier")
+		# fields on_submit requires — present by default, cleared per-test to assert the guard
+		doc.bank_guarantee_number = args.get("bank_guarantee_number", "BG-001")
+		doc.name_of_beneficiary = args.get("name_of_beneficiary", "Test Beneficiary")
+		doc.bank = args.get("bank", BANK)
+		return doc
+
+	def test_validate_requires_customer_or_supplier(self):
+		doc = self.make_bg(customer=None)
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_submit_requires_guarantee_number(self):
+		doc = self.make_bg(bank_guarantee_number="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_submit_requires_beneficiary_name(self):
+		doc = self.make_bg(name_of_beneficiary="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_submit_requires_bank(self):
+		doc = self.make_bg(bank="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_valid_guarantee_submits(self):
+		doc = self.make_bg()
+		doc.insert()
+		doc.submit()
+		self.assertEqual(frappe.db.get_value("Bank Guarantee", doc.name, "docstatus"), 1)
+
+	def test_get_voucher_details_for_receiving(self):
+		so = make_sales_order()
+		details = get_voucher_details("Receiving", so.name)
+		self.assertEqual(details.customer, so.customer)
+		self.assertEqual(flt(details.grand_total), flt(so.grand_total))
+
+	def test_end_date_before_start_date_is_not_validated(self):
+		# SUSPECTED BUG: validate() never checks that end_date >= start_date, so a
+		# guarantee that expires before it starts saves cleanly. Locking the current
+		# (wrong) behaviour so a future fix that adds the check trips this test.
+		doc = self.make_bg(start_date="2026-06-30", end_date="2026-06-01")
+		doc.insert()
+		self.assertTrue(frappe.db.exists("Bank Guarantee", doc.name))

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -116,7 +116,7 @@ def get_account_balance(bank_account: str, till_date: str | date, company: str):
 	return flt(balance_as_per_system) - flt(total_debit) + flt(total_credit) + amounts_not_reflected_in_system
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def update_bank_transaction(
 	bank_transaction_name: str, reference_number: str, party_type: str | None = None, party: str | None = None
 ):
@@ -146,7 +146,7 @@ def update_bank_transaction(
 	)[0]
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_journal_entry_bts(
 	bank_transaction_name: str,
 	reference_number: str | None = None,
@@ -305,7 +305,7 @@ def create_journal_entry_bts(
 	return reconcile_vouchers(bank_transaction_name, vouchers, is_new_voucher=True)
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_payment_entry_bts(
 	bank_transaction_name: str,
 	reference_number: str | None = None,
@@ -500,7 +500,7 @@ def create_bulk_internal_transfer(bank_transaction_names: list[str | int], bank_
 	return output
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_internal_transfer(
 	bank_transaction_name: str | int,
 	posting_date: str | date,
@@ -1057,7 +1057,7 @@ def get_auto_reconcile_message(partially_reconciled, reconciled):
 	return alert_message, indicator
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str | list, is_new_voucher: bool = False):
 	# updated clear date of all the vouchers based on the bank transaction
 	vouchers = frappe.parse_json(vouchers)

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -8,6 +8,7 @@ from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
 	auto_reconcile_vouchers,
+	get_auto_reconcile_message,
 	get_bank_transactions,
 )
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
@@ -97,3 +98,40 @@ class TestBankReconciliationTool(ERPNextTestSuite, AccountsTestMixin):
 		# assert API output post reconciliation
 		transactions = get_bank_transactions(self.bank_account, from_date, to_date)
 		self.assertEqual(len(transactions), 0)
+
+	def make_bank_transaction(self, date, deposit=100):
+		return (
+			frappe.get_doc(
+				{
+					"doctype": "Bank Transaction",
+					"date": date,
+					"deposit": deposit,
+					"bank_account": self.bank_account,
+					"currency": "INR",
+				}
+			)
+			.save()
+			.submit()
+		)
+
+	def test_get_bank_transactions_excludes_dates_after_to_date(self):
+		self.make_bank_transaction(date=today())
+		names = [t.name for t in get_bank_transactions(self.bank_account, to_date=add_days(today(), -1))]
+		self.assertEqual(names, [])
+
+	def test_auto_reconcile_message_for_no_matches(self):
+		message, indicator = get_auto_reconcile_message([], [])
+		self.assertEqual(indicator, "blue")
+		self.assertIn("No matches", message)
+
+	def test_auto_reconcile_message_counts_and_pluralizes(self):
+		# reconciled count is reported and the indicator turns green
+		message, indicator = get_auto_reconcile_message([], ["t1", "t2"])
+		self.assertEqual(indicator, "green")
+		self.assertIn("2 Transaction(s) Reconciled", message)
+
+		# partially-reconciled label is singular for one, plural for many
+		singular, _ = get_auto_reconcile_message(["p1"], [])
+		self.assertIn("1 Transaction Partially Reconciled", singular)
+		plural, _ = get_auto_reconcile_message(["p1", "p2"], [])
+		self.assertIn("2 Transactions Partially Reconciled", plural)

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -397,7 +397,7 @@ def unreconcile_transaction(transaction_name: str | int):
 		frappe.get_doc(voucher["doctype"], voucher["name"]).cancel()
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def unreconcile_transaction_entry(bank_transaction_id: str | int, voucher_type: str, voucher_id: str | int):
 	"""
 	Removes a single payment entry from a bank transaction - for example only undoing one voucher instead of undoing the entire transaction

erpnext/accounts/doctype/bank_transaction/bank_transaction_upload.py

@@ -34,7 +34,7 @@ def upload_bank_statement():
 	return {"columns": columns, "data": data}
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_bank_entries(columns: str, data: str | list, bank_account: str):
 	header_map = get_header_mapping(columns, bank_account)
 

erpnext/accounts/doctype/bisect_accounting_statements/bisect_accounting_statements.py

@@ -184,7 +184,7 @@ class BisectAccountingStatements(Document):
 			self.get_report_summary()
 			self.update_node()
 
-	@frappe.whitelist()
+	@frappe.whitelist(methods=["POST"])
 	def bisect_left(self):
 		if self.current_node is not None:
 			cur_node = frappe.get_doc("Bisect Nodes", self.current_node)
@@ -198,7 +198,7 @@ class BisectAccountingStatements(Document):
 			else:
 				frappe.msgprint(_("No more children on Left"))
 
-	@frappe.whitelist()
+	@frappe.whitelist(methods=["POST"])
 	def bisect_right(self):
 		if self.current_node is not None:
 			cur_node = frappe.get_doc("Bisect Nodes", self.current_node)
@@ -212,7 +212,7 @@ class BisectAccountingStatements(Document):
 			else:
 				frappe.msgprint(_("No more children on Right"))
 
-	@frappe.whitelist()
+	@frappe.whitelist(methods=["POST"])
 	def move_up(self):
 		if self.current_node is not None:
 			cur_node = frappe.get_doc("Bisect Nodes", self.current_node)

erpnext/accounts/doctype/bisect_accounting_statements/test_bisect_accounting_statements.py

@@ -1,11 +1,47 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
+import datetime
 
+import frappe
+from frappe.utils import getdate
 
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestBisectAccountingStatements(ERPNextTestSuite):
-	pass
+	"""The tool bisects a date range into a tree of Bisect Nodes down to single days.
+	These cover the date validation and that the bisection cleanly partitions the range."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		frappe.db.delete("Bisect Nodes")
+
+	def _leaf_days(self):
+		leaves = frappe.get_all(
+			"Bisect Nodes",
+			filters={"left_child": ["is", "not set"]},
+			fields=["period_from_date", "period_to_date"],
+		)
+		# every leaf spans a single day
+		for leaf in leaves:
+			self.assertEqual(getdate(leaf.period_from_date), getdate(leaf.period_to_date))
+		return sorted(getdate(leaf.period_from_date) for leaf in leaves)
+
+	def test_validate_dates_rejects_reversed_range(self):
+		doc = frappe.new_doc("Bisect Accounting Statements")
+		doc.from_date = "2026-01-08"
+		doc.to_date = "2026-01-01"
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_bfs_partitions_range_into_single_days(self):
+		doc = frappe.new_doc("Bisect Accounting Statements")
+		doc.bfs(datetime.datetime(2026, 1, 1), datetime.datetime(2026, 1, 8))
+
+		# the 8-day span Jan 1..Jan 8 becomes exactly 8 contiguous single-day leaves
+		self.assertEqual(self._leaf_days(), [getdate(f"2026-01-0{n}") for n in range(1, 9)])
+
+	def test_dfs_produces_the_same_partition_as_bfs(self):
+		doc = frappe.new_doc("Bisect Accounting Statements")
+		doc.dfs(datetime.datetime(2026, 1, 1), datetime.datetime(2026, 1, 8))
+		self.assertEqual(self._leaf_days(), [getdate(f"2026-01-0{n}") for n in range(1, 9)])

erpnext/accounts/doctype/budget/budget.py

@@ -878,7 +878,7 @@ def get_fiscal_year_date_range(from_fiscal_year, to_fiscal_year):
 	return from_year.year_start_date, to_year.year_end_date
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def revise_budget(budget_name: str):
 	old_budget = frappe.get_doc("Budget", budget_name)
 

erpnext/accounts/doctype/cashier_closing/test_cashier_closing.py

@@ -1,8 +1,67 @@
-# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.tests.utils import ERPNextTestSuite
 
+DATE = "2026-06-15"
+
 
 class TestCashierClosing(ERPNextTestSuite):
-	pass
+	"""Cashier Closing reconciles a shift: it pulls outstanding invoices in a
+	date/time window and rolls payments, expense, custody and returns into net_amount."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_invoice_in_window(self, rate=100):
+		si = create_sales_invoice(rate=rate, qty=1, posting_date=DATE, do_not_submit=True)
+		si.posting_time = "10:30:00"
+		si.submit()
+		si.reload()  # read outstanding_amount as persisted after submit
+		return si
+
+	def make_closing(self, user="Administrator", payments=None, **args):
+		doc = frappe.new_doc("Cashier Closing")
+		doc.user = user
+		doc.date = args.get("date", DATE)
+		doc.from_time = args.get("from_time", "09:00:00")
+		doc.time = args.get("time", "18:00:00")
+		for amount in payments or []:
+			doc.append("payments", {"mode_of_payment": "Cash", "amount": amount})
+		doc.expense = args.get("expense", 0)
+		doc.custody = args.get("custody", 0)
+		doc.returns = args.get("returns", 0)
+		return doc
+
+	def test_from_time_must_be_before_to_time(self):
+		doc = self.make_closing(from_time="18:00:00", time="09:00:00")
+		self.assertRaises(frappe.ValidationError, doc.save)
+
+	def test_equal_from_and_to_time_is_rejected(self):
+		# validate_time uses >=, so a zero-length window is also blocked
+		doc = self.make_closing(from_time="09:00:00", time="09:00:00")
+		self.assertRaises(frappe.ValidationError, doc.save)
+
+	def test_net_amount_rolls_up_outstanding_and_adjustments(self):
+		si = self.make_invoice_in_window(rate=100)
+		doc = self.make_closing(payments=[500], expense=50, custody=30, returns=20)
+		doc.save()
+
+		# the in-window invoice is picked up as outstanding
+		self.assertEqual(doc.outstanding_amount, si.outstanding_amount)
+		# net = payments + outstanding + expense - custody + returns
+		self.assertEqual(doc.net_amount, 500 + si.outstanding_amount + 50 - 30 + 20)
+
+	def test_outstanding_is_scoped_to_the_invoice_owner(self):
+		# The invoice is created by Administrator; a closing for a different user does
+		# not see it. NOTE: get_outstanding keys on Sales Invoice.owner (the document
+		# creator) rather than an explicit cashier/POS-user field, which is fragile when
+		# invoices are created by a shared or system user.
+		self.make_invoice_in_window(rate=100)
+		doc = self.make_closing(user="Guest", payments=[500])
+		doc.save()
+		self.assertEqual(doc.outstanding_amount, 0)
+		self.assertEqual(doc.net_amount, 500)

erpnext/accounts/doctype/chart_of_accounts_importer/test_chart_of_accounts_importer.py

@@ -1,8 +1,54 @@
-# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.accounts.doctype.chart_of_accounts_importer.chart_of_accounts_importer import (
+	build_forest,
+	validate_columns,
+	validate_missing_roots,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
+# columns: account_name, parent_account, account_number, parent_account_number,
+#          is_group, account_type, root_type, account_currency
+ROOT = ["Assets", "Assets", "", "", 1, "", "Asset", "INR"]
+CHILD = ["Cash", "Assets", "", "", 0, "Cash", "Asset", "INR"]
+
 
 class TestChartofAccountsImporter(ERPNextTestSuite):
-	pass
+	"""The importer parses an uploaded CoA into a nested tree and validates its
+	shape. These cover the parsing/validation helpers without a file upload."""
+
+	def test_validate_columns_rejects_blank_file(self):
+		self.assertRaises(frappe.ValidationError, validate_columns, [])
+
+	def test_validate_columns_requires_eight_columns(self):
+		self.assertRaises(frappe.ValidationError, validate_columns, [["a", "b", "c"]])
+		# the standard template width passes
+		validate_columns([ROOT])
+
+	def test_build_forest_nests_child_under_parent(self):
+		forest = build_forest([ROOT, CHILD])
+		self.assertIn("Assets", forest)
+		self.assertIn("Cash", forest["Assets"])
+
+	def test_build_forest_rejects_unknown_parent(self):
+		orphan = ["Cash", "Missing Parent", "", "", 0, "Cash", "Asset", "INR"]
+		self.assertRaises(frappe.ValidationError, build_forest, [orphan])
+
+	def test_build_forest_requires_account_name(self):
+		nameless = ["", "Assets", "", "", 0, "Cash", "Asset", "INR"]
+		self.assertRaises(frappe.ValidationError, build_forest, [ROOT, nameless])
+
+	def test_validate_missing_roots_requires_all_root_types(self):
+		present = ("Asset", "Liability", "Expense", "Income")  # Equity missing
+		self.assertRaises(
+			frappe.ValidationError,
+			validate_missing_roots,
+			[{"root_type": rt} for rt in present],
+		)
+		# all five root types present -> no error
+		validate_missing_roots(
+			[{"root_type": rt} for rt in ("Asset", "Liability", "Expense", "Income", "Equity")]
+		)

erpnext/accounts/doctype/cheque_print_template/cheque_print_template.py

@@ -46,7 +46,7 @@ class ChequePrintTemplate(Document):
 	pass
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_or_update_cheque_print_format(template_name: str):
 	frappe.only_for("System Manager")
 

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -298,3 +298,65 @@ class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 
 		for key, _val in expected_data.items():
 			self.assertEqual(expected_data.get(key), account_details.get(key))
+
+
+class TestExchangeRateRevaluationValidation(ERPNextTestSuite):
+	"""Validation and gain/loss calculation paths, exercised on the document directly
+	so they don't need the multi-currency GL setup the integration tests above build."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.company = "_Test Company"
+
+	def _revaluation_with_rows(self, rows, rounding_loss_allowance=0.05):
+		doc = frappe.new_doc("Exchange Rate Revaluation")
+		doc.company = self.company
+		doc.posting_date = today()
+		doc.rounding_loss_allowance = rounding_loss_allowance
+		for row in rows:
+			doc.append("accounts", row)
+		return doc
+
+	def test_rounding_loss_allowance_must_be_between_0_and_1(self):
+		for bad in (-0.1, 1, 1.5):
+			doc = self._revaluation_with_rows([], rounding_loss_allowance=bad)
+			self.assertRaises(frappe.ValidationError, doc.validate)
+		# values inside [0, 1) are accepted, at the lower bound and mid-range
+		for good in (0.0, 0.5):
+			self._revaluation_with_rows([], rounding_loss_allowance=good).validate()
+
+	def test_gain_loss_computed_and_split_by_zero_balance(self):
+		doc = self._revaluation_with_rows(
+			[
+				# open (unbooked) row: base balance moved 1000 -> 1100, a 100 gain
+				{"zero_balance": 0, "balance_in_base_currency": 1000, "new_balance_in_base_currency": 1100},
+				# already-settled (zero_balance) row carries a booked loss of 40
+				{"zero_balance": 1, "gain_loss": -40},
+			]
+		)
+		doc.validate()
+
+		# gain_loss is derived only for open rows; the zero-balance row keeps its value
+		self.assertEqual(doc.accounts[0].gain_loss, 100)
+		self.assertEqual(doc.gain_loss_unbooked, 100)
+		self.assertEqual(doc.gain_loss_booked, -40)
+		self.assertEqual(doc.total_gain_loss, 60)
+
+	def test_before_submit_drops_rows_without_gain_loss(self):
+		doc = self._revaluation_with_rows(
+			[
+				{"zero_balance": 0, "balance_in_base_currency": 1000, "new_balance_in_base_currency": 1100},
+				{"zero_balance": 0, "balance_in_base_currency": 500, "new_balance_in_base_currency": 500},
+			]
+		)
+		doc.validate()  # second row nets to a 0 gain_loss
+		doc.remove_accounts_without_gain_loss()
+		self.assertEqual(len(doc.accounts), 1)
+		self.assertEqual(doc.accounts[0].gain_loss, 100)
+
+	def test_before_submit_requires_at_least_one_gain_loss_row(self):
+		doc = self._revaluation_with_rows(
+			[{"zero_balance": 0, "balance_in_base_currency": 500, "new_balance_in_base_currency": 500}]
+		)
+		doc.validate()
+		self.assertRaises(frappe.ValidationError, doc.remove_accounts_without_gain_loss)

erpnext/accounts/doctype/item_tax_template/test_item_tax_template.py

@@ -1,8 +1,62 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+TAX_ACCOUNT = "_Test Account VAT - _TC"
+RECEIVABLE_ACCOUNT = "Debtors - _TC"
+
 
 class TestItemTaxTemplate(ERPNextTestSuite):
-	pass
+	"""Item Tax Template validates its tax rows: each account must belong to the
+	company, be a tax-like account type, and appear only once."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_template(self, rows, title="_Test ITT"):
+		doc = frappe.new_doc("Item Tax Template")
+		doc.title = f"{title} {frappe.generate_hash(length=6)}"
+		doc.company = COMPANY
+		for account, rate, not_applicable in rows:
+			doc.append(
+				"taxes",
+				{"tax_type": account, "tax_rate": rate, "not_applicable": not_applicable},
+			)
+		return doc
+
+	def test_valid_template_saves_and_is_named_with_abbr(self):
+		doc = self.make_template([(TAX_ACCOUNT, 9, 0)])
+		doc.insert()
+		self.assertTrue(doc.name.endswith(" - _TC"))
+		self.assertTrue(doc.name.startswith(doc.title))
+
+	def test_duplicate_tax_type_throws(self):
+		doc = self.make_template([(TAX_ACCOUNT, 9, 0), (TAX_ACCOUNT, 5, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_account_of_wrong_company_throws(self):
+		other_account = frappe.db.get_value("Account", {"company": "_Test Company 1", "is_group": 0}, "name")
+		self.assertTrue(other_account, "need a non-group account in _Test Company 1")
+		doc = self.make_template([(other_account, 9, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_disallowed_account_type_throws(self):
+		# a Receivable account is not Tax/Chargeable/Income/Expense
+		doc = self.make_template([(RECEIVABLE_ACCOUNT, 9, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_not_applicable_row_has_rate_zeroed(self):
+		doc = self.make_template([(TAX_ACCOUNT, 18, 1)])
+		doc.insert()
+		self.assertEqual(doc.taxes[0].tax_rate, 0)
+
+	def test_negative_tax_rate_is_accepted(self):
+		# SUSPECTED BUG: validate never bounds tax_rate, so a negative (or >100) rate
+		# saves silently. Locking the current (wrong) behaviour.
+		doc = self.make_template([(TAX_ACCOUNT, -5, 0)])
+		doc.insert()
+		self.assertEqual(doc.taxes[0].tax_rate, -5)

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -29,7 +29,7 @@ frappe.ui.form.on("Journal Entry", {
 
 	refresh(frm) {
 		if (frm.doc.reversal_of && (frm.is_new() || frm.doc.docstatus == 0)) {
-			frm.set_read_only();
+			erpnext.journal_entry.lock_reversal_entry(frm);
 		}
 
 		erpnext.toggle_naming_series();
@@ -232,6 +232,13 @@ Object.assign(erpnext.journal_entry, {
 		}
 	},
 
+	lock_reversal_entry(frm) {
+		frm.fields
+			.filter((field) => field.has_input)
+			.forEach((field) => frm.set_df_property(field.df.fieldname, "read_only", 1));
+		frm.set_df_property("accounts", "read_only", 1);
+	},
+
 	add_custom_buttons(frm) {
 		if (frm.doc.docstatus > 0) {
 			frm.add_custom_button(

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.py

@@ -45,6 +45,20 @@ class JournalEntryTemplate(Document):
 
 	def validate(self):
 		self.validate_party()
+		self.validate_account_company()
+
+	def validate_account_company(self):
+		"""Each row's account must belong to the template's company."""
+		for account in self.accounts:
+			if (
+				account.account
+				and frappe.get_cached_value("Account", account.account, "company") != self.company
+			):
+				frappe.throw(
+					_("Row {0}: Account {1} does not belong to company {2}").format(
+						account.idx, account.account, self.company
+					)
+				)
 
 	def validate_party(self):
 		"""

erpnext/accounts/doctype/journal_entry_template/test_journal_entry_template.py

@@ -1,9 +1,45 @@
-# Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-# import frappe
+
+import frappe
 
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestJournalEntryTemplate(ERPNextTestSuite):
-	pass
+	"""Journal Entry Template's only real rule is validate_party: party_type is
+	allowed only on Receivable/Payable accounts, and a party needs a party_type."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_template(self, rows, company=COMPANY):
+		doc = frappe.new_doc("Journal Entry Template")
+		doc.template_title = f"_Test JET {frappe.generate_hash(length=6)}"
+		doc.company = company
+		doc.voucher_type = "Journal Entry"
+		doc.naming_series = frappe.get_meta("Journal Entry").get_field("naming_series").options.split("\n")[0]
+		for row in rows:
+			doc.append("accounts", row)
+		return doc
+
+	def test_party_type_only_on_receivable_or_payable_account(self):
+		# Cash is neither Receivable nor Payable, so a party_type here is invalid
+		doc = self.make_template([{"account": "Cash - _TC", "party_type": "Customer"}])
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_party_requires_party_type(self):
+		doc = self.make_template([{"account": "Debtors - _TC", "party": "_Test Customer"}])
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_account_from_other_company_is_rejected(self):
+		other_receivable = frappe.db.get_value(
+			"Account", {"company": "_Test Company 1", "account_type": "Receivable", "is_group": 0}, "name"
+		)
+		self.assertTrue(other_receivable, "need a receivable account in _Test Company 1")
+		doc = self.make_template(
+			[{"account": other_receivable, "party_type": "Customer", "party": "_Test Customer"}]
+		)
+		self.assertRaises(frappe.ValidationError, doc.insert)

erpnext/accounts/doctype/loyalty_program/loyalty_program.js

@@ -8,7 +8,7 @@ frappe.ui.form.on("Loyalty Program", {
 		var help_content = `<table class="table table-bordered" style="background-color: var(--scrollbar-track-color);">
 				<tr><td>
 					<h4>
-						<i class="fa fa-hand-right"></i>
+						<svg class="icon icon-sm"><use href="#icon-info"></use></svg>
 						${__("Notes")}
 					</h4>
 					<ul>

erpnext/accounts/doctype/mode_of_payment/test_mode_of_payment.py

@@ -5,9 +5,59 @@ import frappe
 
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestModeofPayment(ERPNextTestSuite):
-	pass
+	"""Mode of Payment validates its per-company default accounts (account company
+	must match the row, no company twice) and blocks disabling while a POS Profile
+	still references it."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_mop(self, accounts=None, enabled=1):
+		doc = frappe.new_doc("Mode of Payment")
+		doc.mode_of_payment = f"_Test MoP {frappe.generate_hash(length=6)}"
+		doc.type = "General"
+		doc.enabled = enabled
+		for company, account in accounts or []:
+			doc.append("accounts", {"company": company, "default_account": account})
+		return doc
+
+	def test_valid_mode_of_payment_saves(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC")])
+		doc.insert()
+		self.assertTrue(doc.name)
+
+	def test_account_of_wrong_company_throws(self):
+		other_account = frappe.db.get_value("Account", {"company": "_Test Company 1", "is_group": 0}, "name")
+		self.assertTrue(other_account, "need a non-group account in _Test Company 1")
+		doc = self.make_mop(accounts=[(COMPANY, other_account)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_repeating_company_throws(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC"), (COMPANY, "Debtors - _TC")])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_disabling_mode_referenced_by_pos_profile_is_not_blocked(self):
+		# SUSPECTED BUG: validate_pos_mode_of_payment queries "Sales Invoice Payment"
+		# rows with parenttype "POS Profile", but a POS Profile's payments are stored
+		# as "POS Payment Method" rows. The filter never matches, so the guard is dead
+		# and a mode still referenced by a POS Profile disables without complaint.
+		# Locking the current (wrong) behaviour so a fix to the guard trips this test.
+		from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
+
+		make_pos_profile()  # its payments row references the "Cash" mode of payment
+		cash = frappe.get_doc("Mode of Payment", "Cash")
+		cash.enabled = 0
+		cash.save()
+		self.assertEqual(frappe.db.get_value("Mode of Payment", "Cash", "enabled"), 0)
+
+	def test_disabling_unreferenced_mode_succeeds(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC")], enabled=0)
+		doc.insert()
+		self.assertEqual(doc.enabled, 0)
 
 
 def set_default_account_for_mode_of_payment(mode_of_payment, company, account):

erpnext/accounts/doctype/monthly_distribution/test_monthly_distribution.py

@@ -1,8 +1,67 @@
-# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+from frappe.utils import getdate
+
+from erpnext.accounts.doctype.monthly_distribution.monthly_distribution import (
+	get_percentage,
+	get_periodwise_distribution_data,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestMonthlyDistribution(ERPNextTestSuite):
-	pass
+	"""Monthly Distribution spreads an amount across months. validate() enforces a
+	100% total; get_percentage() sums the months that fall inside a period window."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_distribution(self, allocations):
+		doc = frappe.new_doc("Monthly Distribution")
+		doc.distribution_id = f"_Test MD {frappe.generate_hash(length=6)}"
+		for month, pct in allocations:
+			doc.append("percentages", {"month": month, "percentage_allocation": pct})
+		return doc
+
+	def test_get_months_populates_twelve_even_rows(self):
+		doc = frappe.new_doc("Monthly Distribution")
+		doc.distribution_id = "_Test MD Even"
+		doc.get_months()
+
+		self.assertEqual(len(doc.percentages), 12)
+		self.assertEqual(doc.percentages[0].month, "January")
+		self.assertEqual(doc.percentages[-1].month, "December")
+		self.assertEqual([d.idx for d in doc.percentages], list(range(1, 13)))
+		for d in doc.percentages:
+			self.assertAlmostEqual(d.percentage_allocation, 100.0 / 12, places=4)
+		# the auto-populated rows round to exactly 100 and pass validation
+		doc.validate()
+
+	def test_validate_rejects_total_other_than_100(self):
+		doc = self.make_distribution([("January", 50), ("February", 30)])  # sums to 80
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_get_percentage_sums_period_window(self):
+		doc = self.make_distribution([("January", 50), ("February", 30), ("March", 20)])
+		doc.insert()  # total is 100, so validate passes
+
+		# a quarter starting in January covers Jan+Feb+Mar
+		self.assertEqual(get_percentage(doc, getdate("2026-01-01"), 3), 100)
+		# a single month picks up only that month
+		self.assertEqual(get_percentage(doc, getdate("2026-02-01"), 1), 30)
+		# months with no row simply contribute 0 (there is no guard that all 12 exist)
+		self.assertEqual(get_percentage(doc, getdate("2026-04-01"), 1), 0)
+
+	def test_periodwise_distribution_maps_each_period(self):
+		doc = self.make_distribution([("January", 50), ("February", 30), ("March", 20)])
+		doc.insert()
+
+		period_list = [
+			frappe._dict(key="q1", from_date=getdate("2026-01-01")),
+			frappe._dict(key="q2", from_date=getdate("2026-04-01")),
+		]
+		data = get_periodwise_distribution_data(doc.name, period_list, "Quarterly")
+		self.assertEqual(data["q1"], 100)  # Jan+Feb+Mar
+		self.assertEqual(data["q2"], 0)  # Apr+May+Jun carry no allocation

erpnext/accounts/doctype/party_link/test_party_link.py

@@ -1,9 +1,67 @@
-# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-# import frappe
 
+import frappe
+
+from erpnext.accounts.doctype.party_link.party_link import create_party_link
 from erpnext.tests.utils import ERPNextTestSuite
 
+CUSTOMER = "_Test Customer"
+SUPPLIER = "_Test Supplier"
+SUPPLIER_2 = "_Test Supplier 1"
+
 
 class TestPartyLink(ERPNextTestSuite):
-	pass
+	"""Party Link ties a Customer and a Supplier together as one underlying party.
+	validate() constrains the primary role and blocks duplicate links."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def test_create_party_link_with_customer_primary(self):
+		link = create_party_link("Customer", CUSTOMER, SUPPLIER)
+		self.assertEqual(link.primary_role, "Customer")
+		self.assertEqual(link.secondary_role, "Supplier")
+		self.assertEqual(link.primary_party, CUSTOMER)
+		self.assertEqual(link.secondary_party, SUPPLIER)
+		self.assertTrue(frappe.db.exists("Party Link", link.name))
+
+	def test_create_party_link_with_supplier_primary(self):
+		link = create_party_link("Supplier", SUPPLIER, CUSTOMER)
+		self.assertEqual(link.primary_role, "Supplier")
+		self.assertEqual(link.secondary_role, "Customer")
+		self.assertEqual(link.primary_party, SUPPLIER)
+		self.assertEqual(link.secondary_party, CUSTOMER)
+		self.assertTrue(frappe.db.exists("Party Link", link.name))
+
+	def test_primary_role_must_be_customer_or_supplier(self):
+		doc = frappe.new_doc("Party Link")
+		doc.primary_role = "Employee"
+		doc.primary_party = CUSTOMER
+		doc.secondary_role = "Supplier"
+		doc.secondary_party = SUPPLIER
+		# validate() alone isolates the role rule from the dynamic-link checks
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_duplicate_link_throws(self):
+		create_party_link("Customer", CUSTOMER, SUPPLIER)
+		dup = frappe.new_doc("Party Link")
+		dup.primary_role = "Customer"
+		dup.primary_party = CUSTOMER
+		dup.secondary_role = "Supplier"
+		dup.secondary_party = SUPPLIER
+		self.assertRaises(frappe.ValidationError, dup.insert)
+
+	def test_party_can_wrongly_be_primary_in_two_links(self):
+		# SUSPECTED BUG: the uniqueness checks are asymmetric - a party already a
+		# *primary* in another link isn't blocked, so one customer can be linked to two
+		# different suppliers, breaking the 1:1 mapping. Locking the current (wrong)
+		# behaviour so a fix that blocks primary reuse trips this test.
+		create_party_link("Customer", CUSTOMER, SUPPLIER)
+		link2 = frappe.new_doc("Party Link")
+		link2.primary_role = "Customer"
+		link2.primary_party = CUSTOMER
+		link2.secondary_role = "Supplier"
+		link2.secondary_party = SUPPLIER_2
+		link2.insert()
+		self.assertTrue(frappe.db.exists("Party Link", link2.name))

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -414,21 +414,17 @@ frappe.ui.form.on("Payment Entry", {
 
 	show_general_ledger: function (frm) {
 		if (frm.doc.docstatus > 0) {
-			frm.add_custom_button(
-				__("Ledger"),
-				function () {
-					frappe.route_options = {
-						voucher_no: frm.doc.name,
-						from_date: frm.doc.posting_date,
-						to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
-						company: frm.doc.company,
-						categorize_by: "",
-						show_cancelled_entries: frm.doc.docstatus === 2,
-					};
-					frappe.set_route("query-report", "General Ledger");
-				},
-				"fa fa-table"
-			);
+			frm.add_custom_button(__("Ledger"), function () {
+				frappe.route_options = {
+					voucher_no: frm.doc.name,
+					from_date: frm.doc.posting_date,
+					to_date: moment(frm.doc.modified).format("YYYY-MM-DD"),
+					company: frm.doc.company,
+					categorize_by: "",
+					show_cancelled_entries: frm.doc.docstatus === 2,
+				};
+				frappe.set_route("query-report", "General Ledger");
+			});
 		}
 	},
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -2317,3 +2317,65 @@ def create_customer(name="_Test Customer 2 USD", currency="USD"):
 		customer.save()
 		customer = customer.name
 	return customer
+
+
+class TestPaymentEntryValidation(ERPNextTestSuite):
+	"""Field-level validations invoked on the document directly, covering branches the
+	integration suite above doesn't reach (no GL / reconciliation setup needed)."""
+
+	def make_pe(self, **fields):
+		doc = frappe.new_doc("Payment Entry")
+		doc.update(fields)
+		return doc
+
+	def test_payment_type_must_be_a_known_value(self):
+		self.assertRaises(frappe.ValidationError, self.make_pe(payment_type="Foo").validate_payment_type)
+		self.make_pe(payment_type="Receive").validate_payment_type()  # valid value passes
+
+	def test_nonexistent_party_is_rejected(self):
+		doc = self.make_pe(party_type="Customer", party="__No Such Customer__")
+		self.assertRaises(frappe.ValidationError, doc.validate_party_details)
+
+	def test_amount_and_exchange_rate_fields_are_mandatory(self):
+		# every field but target_exchange_rate is set, so that missing one raises
+		doc = self.make_pe(
+			paid_amount=100, received_amount=100, source_exchange_rate=1, target_exchange_rate=0
+		)
+		self.assertRaises(frappe.ValidationError, doc.validate_mandatory)
+
+	def test_received_amount_cannot_exceed_paid_in_same_currency(self):
+		doc = self.make_pe(
+			paid_from_account_currency="INR",
+			paid_to_account_currency="INR",
+			paid_amount=100,
+			received_amount=150,
+		)
+		self.assertRaises(frappe.ValidationError, doc.validate_received_amount)
+		# received <= paid is fine
+		doc.received_amount = 50
+		doc.validate_received_amount()
+
+	def test_duplicate_reference_rows_are_rejected(self):
+		doc = self.make_pe()
+		for _ in range(2):
+			doc.append(
+				"references",
+				{"reference_doctype": "Sales Invoice", "reference_name": "SI-X", "allocated_amount": 100},
+			)
+		self.assertRaises(frappe.ValidationError, doc.validate_duplicate_entry)
+
+	def test_receive_from_customer_against_negative_outstanding_is_rejected(self):
+		doc = self.make_pe(party_type="Customer", payment_type="Receive")
+		doc.append(
+			"references",
+			{"reference_doctype": "Sales Invoice", "reference_name": "SI-Y", "allocated_amount": -100},
+		)
+		self.assertRaises(frappe.ValidationError, doc.validate_payment_type_with_outstanding)
+
+	def test_bank_transaction_requires_a_reference_number(self):
+		doc = self.make_pe(payment_type="Pay", paid_from="_Test Bank - _TC")
+		self.assertRaises(frappe.ValidationError, doc.validate_transaction_reference)
+		# supplying the reference details clears the requirement
+		doc.reference_no = "TXN-1"
+		doc.reference_date = "2026-06-15"
+		doc.validate_transaction_reference()

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -718,7 +718,7 @@ class PaymentRequest(Document):
 				row_number += TO_SKIP_NEW_ROW
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def make_payment_request(**args):
 	"""Make payment request"""
 

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.js

@@ -41,21 +41,17 @@ frappe.ui.form.on("Period Closing Voucher", {
 
 	refresh: function (frm) {
 		if (frm.doc.docstatus > 0) {
-			frm.add_custom_button(
-				__("Ledger"),
-				function () {
-					frappe.route_options = {
-						voucher_no: frm.doc.name,
-						from_date: frm.doc.period_start_date,
-						to_date: frm.doc.period_end_date,
-						company: frm.doc.company,
-						categorize_by: "",
-						show_cancelled_entries: frm.doc.docstatus === 2,
-					};
-					frappe.set_route("query-report", "General Ledger");
-				},
-				"fa fa-table"
-			);
+			frm.add_custom_button(__("Ledger"), function () {
+				frappe.route_options = {
+					voucher_no: frm.doc.name,
+					from_date: frm.doc.period_start_date,
+					to_date: frm.doc.period_end_date,
+					company: frm.doc.company,
+					categorize_by: "",
+					show_cancelled_entries: frm.doc.docstatus === 2,
+				};
+				frappe.set_route("query-report", "General Ledger");
+			});
 		}
 	},
 });

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -360,12 +360,15 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
 
-		# Passed posting_date is after PCV end date, so cancellation should not fail.
-		make_reverse_gl_entries(
-			voucher_type="Journal Entry",
-			voucher_no=jv.name,
-			posting_date="2022-01-01",
-		)
+		frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", "2021-12-31")
+
+		try:
+			make_reverse_gl_entries(
+				voucher_type="Journal Entry",
+				voucher_no=jv.name,
+			)
+		finally:
+			frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", None)
 
 		totals_after_cancel = frappe.get_all(
 			"GL Entry",

erpnext/accounts/doctype/pos_invoice/test_pos_invoice_reset_mop.py

@@ -0,0 +1,34 @@
+# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+# Regression test for https://github.com/frappe/erpnext/issues/56501
+# AttributeError: 'POSInvoice' object has no attribute 'is_created_using_pos'
+# when calling reset_mode_of_payments on a draft POS Invoice.
+
+from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import (
+	POSInvoiceTestMixin,
+	create_pos_invoice,
+)
+from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
+
+
+class TestPOSInvoiceResetModeOfPayments(POSInvoiceTestMixin):
+	def setUp(self):
+		super().setUp()
+		create_opening_entry(self.pos_profile, self.test_user.name)
+
+	def test_reset_mode_of_payments_does_not_raise_attribute_error(self):
+		"""Calling reset_mode_of_payments on a draft POS Invoice must not raise
+		AttributeError for the missing is_created_using_pos attribute.
+
+		update_multi_mode_option accesses doc.is_created_using_pos, which is a
+		field on SalesInvoice but does not exist on POSInvoice, causing the error
+		reported in #56501 when a user tries to edit a saved draft order.
+		"""
+		inv = create_pos_invoice(do_not_submit=True)
+
+		# This call must not raise AttributeError on the missing field.
+		inv.reset_mode_of_payments()
+
+		# Payments should have been repopulated from the POS profile.
+		self.assertTrue(len(inv.payments) > 0, "Payments should be populated after reset")

erpnext/accounts/doctype/pricing_rule/pricing_rule.js

@@ -40,7 +40,7 @@ frappe.ui.form.on("Pricing Rule", {
 		var help_content = `<table class="table table-bordered" style="background-color: var(--scrollbar-track-color);">
 				<tr><td>
 					<h4>
-						<i class="fa fa-hand-right"></i>
+						<svg class="icon icon-sm"><use href="#icon-info"></use></svg>
 						${__("Notes")}
 					</h4>
 					<ul>
@@ -63,7 +63,7 @@ frappe.ui.form.on("Pricing Rule", {
 					</ul>
 				</td></tr>
 				<tr><td>
-					<h4><i class="fa fa-question-sign"></i>
+					<h4><svg class="icon icon-sm"><use href="#icon-circle-question-mark"></use></svg>
 						${__("How Pricing Rule is applied?")}
 					</h4>
 					<ol>

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -106,6 +106,8 @@ def get_pr_instance(doc: str):
 		"party",
 		"receivable_payable_account",
 		"default_advance_account",
+		"bank_cash_account",
+		"cost_center",
 		"from_invoice_date",
 		"to_invoice_date",
 		"from_payment_date",

erpnext/accounts/doctype/process_payment_reconciliation/test_process_payment_reconciliation.py

@@ -1,11 +1,73 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-
+import frappe
 
+from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation import (
+	get_pr_instance,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestProcessPaymentReconciliation(ERPNextTestSuite):
-	pass
+	"""Process Payment Reconciliation validates its accounts against the company,
+	moves to Queued on submit, and hands its filters to a Payment Reconciliation run."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_ppr(self, **args):
+		args = frappe._dict(args)
+		doc = frappe.new_doc("Process Payment Reconciliation")
+		doc.company = COMPANY
+		doc.party_type = "Customer"
+		doc.party = "_Test Customer"
+		doc.receivable_payable_account = args.get("receivable_payable_account", "Debtors - _TC")
+		doc.bank_cash_account = args.get("bank_cash_account")
+		doc.from_invoice_date = args.get("from_invoice_date")
+		doc.to_invoice_date = args.get("to_invoice_date")
+		return doc
+
+	def other_company_account(self, **extra):
+		filters = {"company": "_Test Company 1", "is_group": 0, **extra}
+		account = frappe.db.get_value("Account", filters, "name")
+		self.assertTrue(account, "need a matching account in _Test Company 1")
+		return account
+
+	def test_receivable_account_must_belong_to_company(self):
+		doc = self.make_ppr(receivable_payable_account=self.other_company_account(account_type="Receivable"))
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_bank_cash_account_must_belong_to_company(self):
+		doc = self.make_ppr(bank_cash_account=self.other_company_account())
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_submit_sets_status_to_queued(self):
+		doc = self.make_ppr()
+		doc.insert()
+		doc.submit()
+		self.assertEqual(doc.status, "Queued")
+
+	def test_get_pr_instance_copies_filters_and_caps_limits(self):
+		doc = self.make_ppr(from_invoice_date="2026-01-01", to_invoice_date="2026-06-30")
+		doc.insert()
+
+		pr = get_pr_instance(doc.name)
+		self.assertEqual(pr.company, COMPANY)
+		self.assertEqual(pr.party, "_Test Customer")
+		self.assertEqual(pr.receivable_payable_account, "Debtors - _TC")
+		self.assertEqual(str(pr.from_invoice_date), "2026-01-01")
+		# the tool run is capped so a single process can't fetch unbounded rows
+		self.assertEqual(pr.invoice_limit, 1000)
+		self.assertEqual(pr.payment_limit, 1000)
+
+	def test_get_pr_instance_copies_bank_cash_and_cost_center(self):
+		doc = self.make_ppr(bank_cash_account="Cash - _TC")
+		doc.cost_center = "_Test Cost Center - _TC"
+		doc.insert()
+
+		pr = get_pr_instance(doc.name)
+		self.assertEqual(pr.bank_cash_account, "Cash - _TC")
+		self.assertEqual(pr.cost_center, "_Test Cost Center - _TC")

erpnext/accounts/doctype/process_period_closing_voucher/process_period_closing_voucher.py

@@ -89,50 +89,55 @@ class ProcessPeriodClosingVoucher(Document):
 		cancel_pcv_processing(self.name)
 
 
+def initialize_parallel_threads(docname: str):
+	threads = 4
+	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
+	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
+	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
+
+	if normal_balances := (
+		qb.from_(ppcvd)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
+		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
+		.limit(threads)
+		.for_update(skip_locked=True)
+		.run(as_dict=True)
+	):
+		if not is_scheduler_inactive():
+			for x in normal_balances:
+				frappe.db.set_value(
+					"Process Period Closing Voucher Detail",
+					x.name,
+					"status",
+					"Running",
+				)
+				frappe.enqueue(
+					method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
+					queue="long",
+					timeout=timeout,
+					is_async=True,
+					enqueue_after_commit=True,
+					docname=docname,
+					row_name=x.name,
+					date=x.processing_date,
+					report_type=x.report_type,
+					parentfield=x.parentfield,
+				)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.in_test:
+				frappe.db.commit()  # nosemgrep
+	else:
+		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+
+
 @frappe.whitelist()
 def start_pcv_processing(docname: str):
 	if frappe.db.get_value("Process Period Closing Voucher", docname, "status") in ["Queued", "Running"]:
 		frappe.has_permission("Process Period Closing Voucher", "write", doc=docname, throw=True)
-		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
-
-		timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
-		ppcvd = qb.DocType("Process Period Closing Voucher Detail")
-		if normal_balances := (
-			qb.from_(ppcvd)
-			.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
-			.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
-			.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
-			.limit(4)
-			.for_update(skip_locked=True)
-			.run(as_dict=True)
-		):
-			if not is_scheduler_inactive():
-				for x in normal_balances:
-					frappe.db.set_value(
-						"Process Period Closing Voucher Detail",
-						{
-							"processing_date": x.processing_date,
-							"parent": docname,
-							"report_type": x.report_type,
-							"parentfield": x.parentfield,
-						},
-						"status",
-						"Running",
-					)
-					frappe.enqueue(
-						method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
-						queue="long",
-						timeout=timeout,
-						is_async=True,
-						enqueue_after_commit=True,
-						docname=docname,
-						date=x.processing_date,
-						report_type=x.report_type,
-						parentfield=x.parentfield,
-					)
-		else:
-			frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+		initialize_parallel_threads(docname)
 
 
 @frappe.whitelist()
@@ -250,11 +255,11 @@ def get_gle_for_closing_account(pcv, dimension_balance, dimensions):
 @frappe.whitelist()
 def schedule_next_date(docname: str):
 	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
 	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
 	if to_process := (
 		qb.from_(ppcvd)
-		.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
 		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
 		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
 		.limit(1)
@@ -264,15 +269,15 @@ def schedule_next_date(docname: str):
 		if not is_scheduler_inactive():
 			frappe.db.set_value(
 				"Process Period Closing Voucher Detail",
-				{
-					"processing_date": to_process[0].processing_date,
-					"parent": docname,
-					"report_type": to_process[0].report_type,
-					"parentfield": to_process[0].parentfield,
-				},
+				to_process[0].name,
 				"status",
 				"Running",
 			)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.in_test:
+				frappe.db.commit()  # nosemgrep
+
 			frappe.enqueue(
 				method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
 				queue="long",
@@ -280,6 +285,7 @@ def schedule_next_date(docname: str):
 				is_async=True,
 				enqueue_after_commit=True,
 				docname=docname,
+				row_name=to_process[0].name,
 				date=to_process[0].processing_date,
 				report_type=to_process[0].report_type,
 				parentfield=to_process[0].parentfield,
@@ -444,6 +450,11 @@ def summarize_and_post_ledger_entries(docname):
 
 	make_closing_entries(closing_entries, pcv.name, pcv.company, pcv.period_end_date)
 
+	# keep transaction on PPCV and PPCVD short
+	# prevents concurrency errors - REPEATABLE READ
+	if not frappe.in_test:
+		frappe.db.commit()  # nosemgrep
+
 	frappe.db.set_value("Period Closing Voucher", pcv.name, "gle_processing_status", "Completed")
 	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
 
@@ -529,10 +540,10 @@ def build_dimension_wise_balance_dict(gl_entries):
 	return dimension_balances
 
 
-def process_individual_date(docname: str, date, report_type, parentfield):
+def process_individual_date(docname: str, row_name, date, report_type, parentfield):
 	current_date_status = frappe.db.get_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 	)
 	if current_date_status != "Running":
@@ -580,17 +591,20 @@ def process_individual_date(docname: str, date, report_type, parentfield):
 	# save results
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"closing_balance",
 		frappe.json.dumps(res),
 	)
 
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 		"Completed",
 	)
+	# commit heavy computation before touching PPCV or PPCVD
+	if not frappe.in_test:
+		frappe.db.commit()  # nosemgrep
 
 	# chain call
 	schedule_next_date(docname)

erpnext/accounts/doctype/process_period_closing_voucher/test_process_period_closing_voucher.py

@@ -48,18 +48,27 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		ppcv.save()
 		return ppcv
 
-	def set_processing_date_status(self, date, ppcv, rpt_type, parentfield, status):
+	def set_processing_date_status(self, row_name, status):
 		frappe.db.set_value(
 			"Process Period Closing Voucher Detail",
-			{"processing_date": date, "parent": ppcv, "report_type": rpt_type, "parentfield": parentfield},
+			row_name,
 			"status",
 			status,
 		)
 
-	def get_processing_date_closing_balance(self, date, ppcv, rpt_type, parentfield):
+	def get_row_name(self, ppcv_name, rpt_type, parentfield):
+		return frappe.db.get_all(
+			"Process Period Closing Voucher Detail",
+			filters={"parent": ppcv_name, "report_type": rpt_type, "parentfield": parentfield},
+			order_by="report_type, idx",
+			pluck="name",
+			limit=1,
+		)[0]
+
+	def get_processing_date_closing_balance(self, row_name):
 		return frappe.db.get_value(
 			"Process Period Closing Voucher Detail",
-			{"processing_date": date, "parent": ppcv, "report_type": rpt_type, "parentfield": parentfield},
+			row_name,
 			"closing_balance",
 		)
 
@@ -97,11 +106,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		parentfield = "normal_balances"
 		rpt_type = "Profit and Loss"
 		# status has to be set to 'Running' for logic to run
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 1)
 		expected_pl = {
 			"account": "Sales - _TC",
@@ -117,11 +125,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 
 		# Balance sheet balance
 		rpt_type = "Balance Sheet"
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 1)
 		expected_bs = {
 			"account": "Debtors - _TC",
@@ -138,11 +145,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		# Opening balance
 		parentfield = "z_opening_balances"
 		rpt_type = "Balance Sheet"
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 2)
 		opening_cash = next(x for x in bal if x["account"] == "Cash - _TC")
 		expected_opening_cash = {

erpnext/accounts/doctype/process_period_closing_voucher_detail/process_period_closing_voucher_detail.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
-# import frappe
+import frappe
 from frappe.model.document import Document
 
 
@@ -24,3 +24,10 @@ class ProcessPeriodClosingVoucherDetail(Document):
 	# end: auto-generated types
 
 	pass
+
+
+def on_doctype_update():
+	frappe.db.add_index(
+		"Process Period Closing Voucher Detail",
+		["parent", "status", "parentfield", "idx", "processing_date"],
+	)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

@@ -13,7 +13,7 @@
 		</div>
 		{% endif %}
 	</div>
-	<h2 class="text-center">{{ _("GENERAL LEDGER") }}</h2>
+	<h2 class="text-center">{{ _("STATEMENT OF ACCOUNTS") }}</h2>
 	<div>
 		{% if filters.party[0] == filters.party_name[0] %}
 			<h5 style="float: left;">{{ _("Customer: ") }} <b>{{ filters.party_name[0] }}</b></h5>

erpnext/accounts/doctype/process_statement_of_accounts/test_process_statement_of_accounts.py

@@ -113,3 +113,38 @@ def create_process_soa(**args):
 	process_soa.update(soa_dict)
 	process_soa.save()
 	return process_soa
+
+
+class TestProcessStatementOfAccountsValidation(ERPNextTestSuite):
+	"""validate() fills in default subject/body/pdf templates and enforces the
+	basic constraints. Exercised on the document directly (no email/PDF flow)."""
+
+	def make_soa(self, report="Accounts Receivable", with_customer=True, **overrides):
+		doc = frappe.new_doc("Process Statement Of Accounts")
+		doc.report = report
+		doc.company = "_Test Company"
+		if with_customer:
+			doc.append("customers", {"customer": "_Test Customer"})
+		doc.update(overrides)
+		return doc
+
+	def test_customers_are_required(self):
+		self.assertRaises(frappe.ValidationError, self.make_soa(with_customer=False).validate)
+
+	def test_general_ledger_body_uses_a_date_range(self):
+		doc = self.make_soa(report="General Ledger")
+		doc.validate()
+		self.assertIn("from {{ doc.from_date }} to {{ doc.to_date }}", doc.body)
+		# subject and pdf name are also defaulted
+		self.assertTrue(doc.subject)
+		self.assertTrue(doc.pdf_name)
+
+	def test_receivable_body_uses_the_posting_date(self):
+		doc = self.make_soa(report="Accounts Receivable")
+		doc.validate()
+		self.assertIn("until {{ doc.posting_date }}", doc.body)
+
+	def test_account_must_belong_to_company(self):
+		other = frappe.db.get_value("Account", {"company": "_Test Company 1", "is_group": 0}, "name")
+		self.assertTrue(other, "need an account in _Test Company 1")
+		self.assertRaises(frappe.ValidationError, self.make_soa(account=other).validate)

erpnext/accounts/doctype/process_subscription/test_process_subscription.py

@@ -1,11 +1,56 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
+from unittest.mock import patch
 
+import frappe
 
+from erpnext.accounts.doctype.process_subscription.process_subscription import (
+	create_subscription_process,
+)
+from erpnext.accounts.doctype.subscription.test_subscription import (
+	create_parties,
+	create_subscription,
+	make_plans,
+	reset_settings,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestProcessSubscription(ERPNextTestSuite):
-	pass
+	"""Process Subscription is a batch driver: on submit it enqueues subscription.process_all
+	for every non-cancelled Subscription (or just one when a subscription is named)."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		# mirror TestSubscription setup so subscriptions build against known settings
+		make_plans()
+		create_parties()
+		reset_settings()
+		frappe.db.set_value("Company", "_Test Company", "accounts_frozen_till_date", None)
+
+	def enqueued_subscriptions(self, subscription=None):
+		"""Submit a Process Subscription while capturing what gets enqueued."""
+		calls = []
+
+		def capture(*args, **kwargs):
+			calls.append(kwargs)
+
+		with patch("frappe.enqueue", side_effect=capture):
+			create_subscription_process(subscription=subscription, posting_date="2026-06-15")
+
+		# each enqueue is handed a batch (list) of subscription names
+		return [name for call in calls for name in call.get("subscription", [])]
+
+	def test_named_subscription_is_the_only_one_enqueued(self):
+		sub = create_subscription(start_date="2026-01-01")
+		self.assertEqual(self.enqueued_subscriptions(subscription=sub.name), [sub.name])
+
+	def test_cancelled_subscriptions_are_skipped(self):
+		active = create_subscription(start_date="2026-01-01")
+		cancelled = create_subscription(start_date="2026-01-01")
+		cancelled.cancel_subscription()
+
+		enqueued = self.enqueued_subscriptions()
+		self.assertIn(active.name, enqueued)
+		self.assertNotIn(cancelled.name, enqueued)

erpnext/accounts/doctype/purchase_invoice/services/gl_composer.py

@@ -3,7 +3,6 @@
 
 import frappe
 from frappe import _
-from frappe.query_builder.functions import Sum
 from frappe.utils import cint, flt, get_link_to_form
 
 import erpnext
@@ -131,7 +130,6 @@ class PurchaseInvoiceGLComposer(BaseGLComposer):
 		from erpnext.accounts.doctype.purchase_invoice.purchase_invoice import (
 			get_purchase_document_details,
 		)
-		from erpnext.stock.utils import get_valuation_method
 
 		doc = self.doc
 		tax_service = TaxService(doc)
@@ -331,33 +329,25 @@ class PurchaseInvoiceGLComposer(BaseGLComposer):
 						self.make_provisional_gl_entry(gl_entries, item)
 
 					if not doc.is_internal_transfer():
-						handled = False
-						if (
-							item.item_code
-							and item.item_code in stock_items
-							and item.get("purchase_receipt")
-							and not doc.is_return
-							and get_valuation_method(item.item_code, doc.company) == "Standard Cost"
-						):
-							handled = self.make_standard_cost_srbnb_split(
-								gl_entries, item, expense_account, account_currency, base_amount
-							)
-
-						if not handled:
-							gl_entries.append(
-								self.get_gl_dict(
-									{
-										"account": expense_account,
-										"against": doc.supplier,
-										"debit": base_amount,
-										"debit_in_transaction_currency": amount,
-										"cost_center": item.cost_center,
-										"project": item.project or doc.project,
-									},
-									account_currency,
-									item=item,
-								)
+						# When Update Stock is disabled, this invoice has no stock impact: the linked
+						# Purchase Receipt already booked the stock (at standard) and the Purchase Price
+						# Variance. Here we only clear "Stock Received But Not Billed" at the full billed
+						# amount against the supplier - booking PPV again would double count it and leave
+						# SRBNB partially uncleared.
+						gl_entries.append(
+							self.get_gl_dict(
+								{
+									"account": expense_account,
+									"against": doc.supplier,
+									"debit": base_amount,
+									"debit_in_transaction_currency": amount,
+									"cost_center": item.cost_center,
+									"project": item.project or doc.project,
+								},
+								account_currency,
+								item=item,
 							)
+						)
 
 						# check if the exchange rate has changed
 						if (
@@ -530,95 +520,6 @@ class PurchaseInvoiceGLComposer(BaseGLComposer):
 				},
 			)
 
-	def make_standard_cost_srbnb_split(
-		self, gl_entries, item, expense_account, account_currency, base_amount
-	):
-		"""For a Standard Cost item billed against a Purchase Receipt, clear SRBNB at the standard
-		value the receipt actually booked and post the (Net Amount - standard) difference to the
-		Purchase Price Variance account. Returns False (caller falls back) if the receipt value
-		can't be resolved."""
-		from erpnext.stock.doctype.item_standard_cost.item_standard_cost import (
-			get_purchase_price_variance_account,
-		)
-
-		doc = self.doc
-		precision = item.precision("base_net_amount")
-		standard_value = flt(self.get_pr_stock_value(item), precision)
-		if not standard_value:
-			return False
-
-		gl_entries.append(
-			self.get_gl_dict(
-				{
-					"account": expense_account,
-					"against": doc.supplier,
-					"debit": standard_value,
-					"debit_in_transaction_currency": flt(standard_value / doc.conversion_rate, precision),
-					"remarks": doc.get("remarks") or _("Accounting Entry for Stock"),
-					"cost_center": item.cost_center,
-					"project": item.project or doc.project,
-				},
-				account_currency,
-				item=item,
-			)
-		)
-
-		variance = flt(base_amount - standard_value, precision)
-		if variance:
-			gl_entries.append(
-				self.get_gl_dict(
-					{
-						"account": get_purchase_price_variance_account(item.item_code, doc.company),
-						"against": doc.supplier,
-						"debit": variance,
-						"debit_in_transaction_currency": flt(variance / doc.conversion_rate, precision),
-						"remarks": doc.get("remarks") or _("Purchase Price Variance"),
-						"cost_center": item.cost_center,
-						"project": item.project or doc.project,
-					},
-					item=item,
-				)
-			)
-
-		return True
-
-	def get_pr_stock_value(self, item):
-		"""Stock value (at standard) the linked Purchase Receipt booked for the quantity this invoice
-		row is billing.
-
-		Accepted and rejected stock for the same receipt row share `voucher_detail_no`, so the
-		warehouse filter is required: without it the accepted warehouse's SRBNB would be cleared at
-		accepted + rejected value and post the wrong Purchase Price Variance amount. The accepted
-		warehouse is read from the receipt row itself (not the invoice row, which may be unset on a
-		non-stock invoice).
-
-		The receipt's full accepted value is pro-rated to the invoiced quantity, so a partial bill
-		clears SRBNB (and posts PPV) for only the units it covers, not the whole receipt row."""
-		pr_detail = frappe.db.get_value(
-			"Purchase Receipt Item", item.pr_detail, ["warehouse", "stock_qty"], as_dict=True
-		)
-		if not pr_detail or not pr_detail.warehouse:
-			return 0.0
-
-		sle = frappe.qb.DocType("Stock Ledger Entry")
-		result = (
-			frappe.qb.from_(sle)
-			.select(Sum(sle.stock_value_difference))
-			.where(
-				(sle.voucher_type == "Purchase Receipt")
-				& (sle.voucher_no == item.purchase_receipt)
-				& (sle.voucher_detail_no == item.pr_detail)
-				& (sle.warehouse == pr_detail.warehouse)
-				& (sle.is_cancelled == 0)
-			)
-		).run()
-		accepted_value = flt(result[0][0]) if result and result[0][0] else 0.0
-		if not accepted_value or not flt(pr_detail.stock_qty):
-			return accepted_value
-
-		# Pro-rate to the quantity being billed by this invoice row (handles partial billing).
-		return accepted_value * flt(item.stock_qty) / flt(pr_detail.stock_qty)
-
 	def get_stock_variance_account(self, item):
 		"""For Standard Cost items the purchase-price-vs-standard difference is a Purchase Price
 		Variance; for all other items it keeps the existing behaviour (default expense account)."""

erpnext/accounts/doctype/repost_payment_ledger/test_repost_payment_ledger.py

@@ -1,11 +1,55 @@
-# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-
+import frappe
 
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestRepostPaymentLedger(ERPNextTestSuite):
-	pass
+	"""Repost Payment Ledger auto-selects submitted vouchers on/after a cutoff date
+	(unless rows are added manually) and queues them for a ledger rebuild."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_repost(self, **args):
+		args = frappe._dict(args)
+		doc = frappe.new_doc("Repost Payment Ledger")
+		doc.company = COMPANY
+		doc.posting_date = args.get("posting_date", "2026-06-01")
+		doc.voucher_type = args.get("voucher_type", "Sales Invoice")
+		doc.add_manually = args.get("add_manually", 0)
+		return doc
+
+	def test_loads_submitted_vouchers_on_or_after_cutoff(self):
+		after_cutoff = create_sales_invoice(company=COMPANY, posting_date="2026-06-15", rate=100, qty=1)
+		on_cutoff = create_sales_invoice(company=COMPANY, posting_date="2026-06-01", rate=100, qty=1)
+		before_cutoff = create_sales_invoice(company=COMPANY, posting_date="2026-01-15", rate=100, qty=1)
+
+		doc = self.make_repost(posting_date="2026-06-01", voucher_type="Sales Invoice")
+		doc.save()  # before_validate loads the vouchers and sets status
+
+		loaded = {v.voucher_no for v in doc.repost_vouchers}
+		self.assertIn(after_cutoff.name, loaded)
+		# the filter is >= so an invoice posted exactly on the cutoff is included
+		self.assertIn(on_cutoff.name, loaded)
+		self.assertNotIn(before_cutoff.name, loaded)
+		self.assertEqual(doc.repost_status, "Queued")
+
+	def test_add_manually_preserves_user_rows(self):
+		# manually add a BEFORE-cutoff invoice (which the filter would never load) while a
+		# matching after-cutoff invoice also exists. If auto-loading wrongly ran it would
+		# drop the manual row and pull the after-cutoff one, so this distinguishes the modes.
+		manual_si = create_sales_invoice(company=COMPANY, posting_date="2026-01-15", rate=100, qty=1)
+		create_sales_invoice(company=COMPANY, posting_date="2026-06-15", rate=100, qty=1)
+
+		doc = self.make_repost(add_manually=1, posting_date="2026-06-01")
+		doc.append("repost_vouchers", {"voucher_type": "Sales Invoice", "voucher_no": manual_si.name})
+		doc.save()
+
+		rows = [(v.voucher_type, v.voucher_no) for v in doc.repost_vouchers]
+		self.assertEqual(rows, [("Sales Invoice", manual_si.name)])

erpnext/accounts/doctype/sales_invoice/services/gl_composer.py

@@ -33,9 +33,11 @@ class SalesInvoiceGLComposer(BaseGLComposer):
 
 		self.make_item_gl_entries(gl_entries)
 
-		disable_sdbnb_in_sr = frappe.get_cached_value("Company", doc.company, "disable_sdbnb_in_sr")
+		disable_sdbnb_in_sr, is_sdbnb_enabled = frappe.get_cached_value(
+			"Company", doc.company, ["disable_sdbnb_in_sr", "enable_stock_delivered_but_not_billed"]
+		)
 
-		if not (doc.is_return and disable_sdbnb_in_sr):
+		if is_sdbnb_enabled and not (doc.is_return and disable_sdbnb_in_sr):
 			self.stock_delivered_but_not_billed_gl_entries(gl_entries)
 
 		self.make_precision_loss_gl_entry(gl_entries)

erpnext/accounts/doctype/sales_invoice/services/pos.py

@@ -344,7 +344,9 @@ def update_multi_mode_option(doc, pos_profile) -> None:
 		payment.account = payment_mode.default_account
 		payment.type = payment_mode.type
 
-	mop_refetched = bool(doc.payments) and not doc.is_created_using_pos
+	# is_created_using_pos exists on Sales Invoice but not POS Invoice; use get() so this
+	# shared helper doesn't raise AttributeError when called on a POS Invoice
+	mop_refetched = bool(doc.payments) and not doc.get("is_created_using_pos")
 
 	doc.set("payments", [])
 	invalid_modes = []

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -1576,14 +1576,14 @@ class TestSalesInvoice(ERPNextTestSuite):
 		frappe.db.set_single_value("POS Settings", "post_change_gl_entries", 1)
 
 	def test_stock_delivered_but_not_billed_gl_on_invoice(self):
-		company = "_Test Company with perpetual inventory"
+		company = "_Test SDBNB Company"
 		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
 
 		make_purchase_receipt(
 			company=company,
 			item_code="_Test FG Item",
-			warehouse="Stores - TCP1",
-			cost_center="Main - TCP1",
+			warehouse="Stores - _TSDBNB",
+			cost_center="Main - _TSDBNB",
 			qty=5,
 			rate=100,
 		)
@@ -1591,13 +1591,13 @@ class TestSalesInvoice(ERPNextTestSuite):
 		dn = create_delivery_note(
 			company=company,
 			item_code="_Test FG Item",
-			warehouse="Stores - TCP1",
-			cost_center="Main - TCP1",
+			warehouse="Stores - _TSDBNB",
+			cost_center="Main - _TSDBNB",
 			qty=2,
 			rate=300,
 		)
 		# A perpetual-inventory Delivery Note books the cost to the SDBNB account
-		self.assertEqual(dn.items[0].expense_account, "Stock Delivered But Not Billed - TCP1")
+		self.assertEqual(dn.items[0].expense_account, "Stock Delivered But Not Billed - _TSDBNB")
 
 		si = make_sales_invoice(dn.name)
 		si.insert()
@@ -1609,9 +1609,9 @@ class TestSalesInvoice(ERPNextTestSuite):
 			fields=["account", "debit", "credit"],
 		)
 		sdbnb_credit = sum(
-			row.credit for row in gl_entries if row.account == "Stock Delivered But Not Billed - TCP1"
+			row.credit for row in gl_entries if row.account == "Stock Delivered But Not Billed - _TSDBNB"
 		)
-		cogs_debit = sum(row.debit for row in gl_entries if row.account == "Cost of Goods Sold - TCP1")
+		cogs_debit = sum(row.debit for row in gl_entries if row.account == "Cost of Goods Sold - _TSDBNB")
 
 		# Billing reverses SDBNB and recognises the cost in COGS for an equal amount
 		self.assertTrue(sdbnb_credit > 0)

erpnext/accounts/doctype/share_transfer/test_share_transfer.py

@@ -121,3 +121,65 @@ class TestShareTransfer(ERPNextTestSuite):
 			}
 		)
 		self.assertRaises(ShareDontExists, doc.insert)
+
+
+class TestShareTransferValidation(ERPNextTestSuite):
+	"""basic_validations() enforces the transfer's internal consistency. Exercised
+	directly (to_folio_no set to skip folio auto-naming) so no shareholder fixtures
+	are needed - it only reasons about the document's own fields."""
+
+	def make_transfer(self, **overrides):
+		doc = frappe.new_doc("Share Transfer")
+		doc.update(
+			{
+				"transfer_type": "Transfer",
+				"date": "2026-01-01",
+				"from_shareholder": "SH-A",
+				"to_shareholder": "SH-B",
+				"to_folio_no": "1",
+				"share_type": "Equity",
+				"from_no": 1,
+				"to_no": 100,
+				"no_of_shares": 100,
+				"rate": 10,
+				"amount": 1000,
+				"company": "_Test Company",
+				"equity_or_liability_account": "Creditors - _TC",
+			}
+		)
+		doc.update(overrides)
+		return doc
+
+	def test_baseline_transfer_is_consistent(self):
+		# the helper's defaults must pass, otherwise the negative cases prove nothing
+		self.make_transfer().basic_validations()
+
+	def test_seller_and_buyer_must_differ(self):
+		doc = self.make_transfer(to_shareholder="SH-A")
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)
+
+	def test_share_count_must_match_the_number_range(self):
+		# 1..100 is 100 shares, not 50
+		doc = self.make_transfer(no_of_shares=50)
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)
+
+	def test_amount_must_equal_rate_times_shares(self):
+		doc = self.make_transfer(amount=999)  # 10 * 100 = 1000
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)
+
+	def test_amount_is_derived_when_left_blank(self):
+		doc = self.make_transfer(amount=0)
+		doc.basic_validations()
+		self.assertEqual(doc.amount, 1000)
+
+	def test_equity_or_liability_account_is_required(self):
+		doc = self.make_transfer(equity_or_liability_account=None)
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)
+
+	def test_issue_requires_a_to_shareholder(self):
+		doc = self.make_transfer(transfer_type="Issue", to_shareholder="", asset_account="Cash - _TC")
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)
+
+	def test_purchase_requires_a_from_shareholder(self):
+		doc = self.make_transfer(transfer_type="Purchase", from_shareholder="", asset_account="Cash - _TC")
+		self.assertRaises(frappe.ValidationError, doc.basic_validations)

erpnext/accounts/doctype/subscription_plan/subscription_plan.py

@@ -79,7 +79,9 @@ def get_plan_rate(
 		start_date = getdate(start_date)
 		end_date = getdate(end_date)
 
-		no_of_months = relativedelta.relativedelta(end_date, start_date).months + 1
+		delta = relativedelta.relativedelta(end_date, start_date)
+		# include the years component so cross-year spans aren't under-counted
+		no_of_months = delta.years * 12 + delta.months + 1
 		cost = plan.cost * no_of_months
 
 		# Adjust cost if start or end date is not month start or end

erpnext/accounts/doctype/subscription_plan/test_subscription_plan.py

@@ -1,8 +1,54 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestSubscriptionPlan(ERPNextTestSuite):
-	pass
+	"""Subscription Plan validates its interval and computes a rate. The Monthly
+	Rate branch multiplies cost by the number of months in the billing window."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_plan(self, **args):
+		args = frappe._dict(args)
+		plan = frappe.new_doc("Subscription Plan")
+		plan.plan_name = f"_Test Plan {frappe.generate_hash(length=6)}"
+		plan.item = args.item or "_Test Item"
+		plan.currency = args.currency or "INR"
+		plan.price_determination = args.price_determination
+		plan.cost = args.cost or 0
+		plan.billing_interval = args.billing_interval or "Month"
+		plan.billing_interval_count = (
+			args.billing_interval_count if args.billing_interval_count is not None else 1
+		)
+		return plan
+
+	def test_billing_interval_count_must_be_positive(self):
+		plan = self.make_plan(price_determination="Fixed Rate", cost=100, billing_interval_count=0)
+		self.assertRaises(frappe.ValidationError, plan.insert)
+
+	def test_fixed_rate_applies_prorate_factor(self):
+		plan = self.make_plan(price_determination="Fixed Rate", cost=100)
+		plan.insert()
+		self.assertEqual(get_plan_rate(plan.name), 100)
+		self.assertEqual(get_plan_rate(plan.name, prorate_factor=0.5), 50)
+
+	def test_monthly_rate_within_year(self):
+		plan = self.make_plan(price_determination="Monthly Rate", cost=100)
+		plan.insert()
+		# Jan 1 - Mar 31 is 3 whole months; month-aligned so proration is 0
+		rate = get_plan_rate(plan.name, start_date="2026-01-01", end_date="2026-03-31")
+		self.assertEqual(rate, 300)
+
+	def test_monthly_rate_across_year_boundary(self):
+		# a 14-month span (Jan 2026 to Feb 2027) bills all 14 months, not just the
+		# 2-month remainder that relativedelta.months alone would give
+		plan = self.make_plan(price_determination="Monthly Rate", cost=100)
+		plan.insert()
+		rate = get_plan_rate(plan.name, start_date="2026-01-01", end_date="2027-02-28")
+		self.assertEqual(rate, 1400)

erpnext/accounts/general_ledger.py

@@ -640,13 +640,15 @@ def make_reverse_gl_entries(
 			partial_cancel=partial_cancel,
 		)
 		validate_accounting_period(gl_entries)
-		check_freezing_date(gl_entries[0]["posting_date"], gl_entries[0]["company"], adv_adj)
 
 		is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
 
-		# For reverse entries, use the posting_date parameter if provided and valid
-		# Otherwise fall back to original posting_date
-		validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+		if immutable_ledger_enabled:
+			validation_date = posting_date or frappe.form_dict.get("posting_date") or getdate()
+		else:
+			validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+
+		check_freezing_date(validation_date, gl_entries[0]["company"], adv_adj)
 		validate_against_pcv(is_opening, validation_date, gl_entries[0]["company"])
 
 		if partial_cancel:
@@ -715,7 +717,7 @@ def make_reverse_gl_entries(
 
 			if immutable_ledger_enabled:
 				new_gle["is_cancelled"] = 0
-				new_gle["posting_date"] = frappe.form_dict.get("posting_date") or getdate()
+				new_gle["posting_date"] = posting_date or frappe.form_dict.get("posting_date") or getdate()
 			elif posting_date:
 				new_gle["posting_date"] = posting_date
 

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -174,7 +174,17 @@ frappe.query_reports["Accounts Payable"] = {
 	},
 
 	get_datatable_options(options) {
-		return Object.assign(options, { checkboxColumn: true });
+		return Object.assign(options, {
+			checkboxColumn: true,
+			events: {
+				onCheckRow: () => erpnext.accounts.toggle_create_pe_primary_action(frappe.query_report),
+			},
+		});
+	},
+
+	after_refresh: function (report) {
+		report.datatable?.rowmanager?.checkAll(false);
+		report.page.clear_primary_action();
 	},
 
 	onload: function (report) {
@@ -186,20 +196,27 @@ frappe.query_reports["Accounts Payable"] = {
 		if (frappe.boot.sysdefaults.default_ageing_range) {
 			report.set_filter_value("range", frappe.boot.sysdefaults.default_ageing_range);
 		}
-
-		if (frappe.model.can_create("Payment Entry")) {
-			report.page.add_inner_button(
-				__("Create Payment Entries"),
-				function () {
-					erpnext.accounts.create_payment_entries_from_payable_report(report);
-				},
-				__("Actions")
-			);
-		}
 	},
 };
 
 frappe.provide("erpnext.accounts");
+
+erpnext.accounts.toggle_create_pe_primary_action = function (report) {
+	if (!report || !report.datatable || !frappe.model.can_create("Payment Entry")) return;
+
+	const has_purchase_invoice = report.datatable.rowmanager
+		.getCheckedRows()
+		.some((i) => report.datatable.datamanager.data[i]?.voucher_type === "Purchase Invoice");
+
+	if (has_purchase_invoice) {
+		report.page.set_primary_action(__("Create Payment Entries"), () =>
+			erpnext.accounts.create_payment_entries_from_payable_report(report)
+		);
+	} else {
+		report.page.clear_primary_action();
+	}
+};
+
 erpnext.accounts.create_payment_entries_from_payable_report = function (report) {
 	const datatable = report.datatable;
 	if (!datatable) return;

erpnext/accounts/report/accounts_payable_summary/test_accounts_payable_summary.py

@@ -0,0 +1,144 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import today
+
+from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.report.accounts_payable_summary.accounts_payable_summary import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestAccountsPayableSummary(ERPNextTestSuite):
+	"""Payable Summary is a thin wrapper over AccountsReceivableSummary with
+	account_type=Payable; these tests lock the supplier-side output: invoiced,
+	advance, paid, outstanding, ageing buckets and the optional GL-balance /
+	future-payment columns."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.maxDiff = None
+		self.company = "_Test Company"
+		self.supplier = "_Test Supplier"
+
+	def _filters(self, **overrides):
+		filters = {
+			"company": self.company,
+			"supplier": self.supplier,
+			"posting_date": today(),
+			"range": "30, 60, 90, 120",
+		}
+		filters.update(overrides)
+		return filters
+
+	def _make_invoice(self, rate=200):
+		return make_purchase_invoice(
+			company=self.company,
+			supplier=self.supplier,
+			qty=1,
+			rate=rate,
+			price_list_rate=rate,
+			posting_date=today(),
+		)
+
+	def _expected_row(self, pi, **overrides):
+		supplier_group = frappe.db.get_value("Supplier", self.supplier, "supplier_group")
+		row = {
+			"party_type": "Supplier",
+			"advance": 0,
+			"party": self.supplier,
+			"invoiced": 200.0,
+			"paid": 0.0,
+			"credit_note": 0.0,
+			"outstanding": 200.0,
+			"range1": 200.0,
+			"range2": 0.0,
+			"range3": 0.0,
+			"range4": 0.0,
+			"range5": 0.0,
+			"total_due": 200.0,
+			"future_amount": 0.0,
+			"sales_person": [],
+			"currency": pi.currency,
+			"supplier_group": supplier_group,
+		}
+		row.update(overrides)
+		return row
+
+	def test_01_payable_summary_output(self):
+		"""Invoiced -> advance -> partial payment progression for a single supplier."""
+		filters = self._filters()
+		pi = self._make_invoice()
+
+		expected = self._expected_row(pi)
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+		# advance payment: pay 50 but allocate nothing against the invoice
+		pe = get_payment_entry(pi.doctype, pi.name)
+		pe.paid_amount = 50
+		pe.references[0].allocated_amount = 0
+		pe.save().submit()
+
+		expected.update({"advance": 50.0, "outstanding": 150.0, "range1": 150.0, "total_due": 150.0})
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+		# partial payment allocated against the invoice
+		pe = get_payment_entry(pi.doctype, pi.name)
+		pe.paid_amount = 125
+		pe.references[0].allocated_amount = 125
+		pe.save().submit()
+
+		expected.update(
+			{"advance": 50.0, "paid": 125.0, "outstanding": 25.0, "range1": 25.0, "total_due": 25.0}
+		)
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+	@ERPNextTestSuite.change_settings("Buying Settings", {"supp_master_name": "Naming Series"})
+	def test_02_gl_balance_and_future_payment_columns(self):
+		"""Naming-series naming adds party_name; show_gl_balance / show_future_payments
+		add their columns; a fully-paid invoice drops out of the report."""
+		filters = self._filters()
+		pi = self._make_invoice()
+
+		pe = get_payment_entry(pi.doctype, pi.name)
+		pe.paid_amount = 150
+		pe.references[0].allocated_amount = 150
+		pe.save().submit()
+
+		expected = self._expected_row(
+			pi,
+			party_name=frappe.db.get_value("Supplier", self.supplier, "supplier_name"),
+			paid=150.0,
+			outstanding=50.0,
+			range1=50.0,
+			total_due=50.0,
+		)
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+		# GL balance reconciliation columns
+		filters.update({"show_gl_balance": True})
+		expected.update({"gl_balance": 50.0, "diff": 0.0})
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+		# future payment columns
+		filters.update({"show_future_payments": True})
+		expected.update({"remaining_balance": 50.0})
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 1)
+		self.assertDictEqual(rows[0], expected)
+
+		# clear the remaining balance -> supplier drops out of the summary entirely
+		get_payment_entry(pi.doctype, pi.name).save().submit()
+		rows = execute(filters)[1]
+		self.assertEqual(len(rows), 0)

erpnext/accounts/report/bank_clearance_summary/test_bank_clearance_summary.py

@@ -0,0 +1,64 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+
+from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.accounts.report.bank_clearance_summary.bank_clearance_summary import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+BANK_ACCOUNT = "_Test Bank - _TC"
+
+
+class TestBankClearanceSummary(ERPNextTestSuite):
+	def run_report(self, **extra):
+		filters = frappe._dict(
+			{
+				"account": BANK_ACCOUNT,
+				"company": "_Test Company",
+				"from_date": "2026-01-01",
+				"to_date": "2026-12-31",
+			}
+		)
+		filters.update(extra)
+		return execute(filters)[1]
+
+	def find_row(self, data, payment_entry):
+		for row in data:
+			if row[1] == payment_entry:
+				return row
+		return None
+
+	def test_uncleared_then_cleared_journal_entry(self):
+		je = make_journal_entry(BANK_ACCOUNT, "Sales - _TC", 5000, submit=True, posting_date="2026-06-01")
+
+		# Uncleared: the bank row appears with the debit amount and no clearance date
+		row = self.find_row(self.run_report(), je.name)
+		self.assertIsNotNone(row, "Journal Entry not listed in Bank Clearance Summary")
+		self.assertEqual(row[0], "Journal Entry")
+		self.assertEqual(frappe.utils.getdate(row[2]), frappe.utils.getdate("2026-06-01"))
+		self.assertIsNone(row[4])  # clearance_date empty -> uncleared
+		self.assertEqual(row[5], "Sales - _TC")  # against account
+		self.assertEqual(row[6], 5000)  # debit - credit on the bank account
+
+		# Cleared: set the clearance date on the Journal Entry and re-run
+		frappe.db.set_value("Journal Entry", je.name, "clearance_date", "2026-06-05")
+
+		row = self.find_row(self.run_report(), je.name)
+		self.assertIsNotNone(row)
+		self.assertEqual(frappe.utils.getdate(row[4]), frappe.utils.getdate("2026-06-05"))
+		self.assertEqual(row[6], 5000)
+
+	def test_date_filter_excludes_out_of_range_entries(self):
+		je = make_journal_entry(BANK_ACCOUNT, "Sales - _TC", 3000, submit=True, posting_date="2026-06-10")
+
+		# Within range: present
+		self.assertIsNotNone(self.find_row(self.run_report(), je.name))
+
+		# Window entirely after the posting date (from_date lower bound): excluded
+		after = self.run_report(from_date="2026-07-01", to_date="2026-12-31")
+		self.assertIsNone(self.find_row(after, je.name))
+
+		# Window ending before the posting date (to_date upper bound): excluded
+		before = self.run_report(from_date="2026-01-01", to_date="2026-06-09")
+		self.assertIsNone(self.find_row(before, je.name))

erpnext/accounts/report/billed_items_to_be_received/billed_items_to_be_received.py

@@ -31,7 +31,7 @@ def get_report_filters(report_filters):
 	]
 
 	if report_filters.get("purchase_invoice"):
-		filters.append(["Purchase Invoice", "per_received", "in", [report_filters.get("purchase_invoice")]])
+		filters.append(["Purchase Invoice", "name", "=", report_filters.get("purchase_invoice")])
 
 	return filters
 

erpnext/accounts/report/billed_items_to_be_received/test_billed_items_to_be_received.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import today
+
+from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.accounts.report.billed_items_to_be_received.billed_items_to_be_received import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestBilledItemsToBeReceived(ERPNextTestSuite):
+	def run_report(self, **extra):
+		filters = frappe._dict(
+			{
+				"company": "_Test Company",
+				"posting_date": today(),
+			}
+		)
+		filters.update(extra)
+		return execute(filters)[1]
+
+	def get_rows_for(self, data, pi_name):
+		return [row for row in data if row.get("name") == pi_name]
+
+	def test_billed_but_not_received_item_appears(self):
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier",
+			item_code="_Test Item",
+			qty=5,
+			rate=200,
+			update_stock=0,
+		)
+
+		rows = self.get_rows_for(self.run_report(), pi.name)
+		self.assertEqual(len(rows), 1)
+
+		row = rows[0]
+		self.assertEqual(row.get("supplier"), "_Test Supplier")
+		self.assertEqual(row.get("company"), "_Test Company")
+		self.assertEqual(row.get("item_code"), "_Test Item")
+		self.assertEqual(row.get("qty"), 5)
+		self.assertEqual(row.get("received_qty"), 0)
+		self.assertEqual(row.get("rate"), 200)
+		self.assertEqual(row.get("amount"), 1000)
+
+	def test_stock_updating_invoice_is_excluded(self):
+		"""update_stock=1 means the item is already received; it must not appear."""
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier",
+			item_code="_Test Item",
+			qty=5,
+			rate=200,
+			update_stock=1,
+		)
+
+		rows = self.get_rows_for(self.run_report(), pi.name)
+		self.assertEqual(len(rows), 0)
+
+	def test_fully_received_invoice_drops_off(self):
+		"""When per_received reaches 100 the invoice is fully received and drops off."""
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier",
+			item_code="_Test Item",
+			qty=5,
+			rate=200,
+			update_stock=0,
+		)
+
+		# Present while nothing has been received.
+		self.assertEqual(len(self.get_rows_for(self.run_report(), pi.name)), 1)
+
+		frappe.db.set_value("Purchase Invoice", pi.name, "per_received", 100)
+
+		# Absent once fully received.
+		self.assertEqual(len(self.get_rows_for(self.run_report(), pi.name)), 0)
+
+	def test_posting_date_upper_bound_filter(self):
+		"""A PI posted after the filter's posting_date must be excluded."""
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier",
+			item_code="_Test Item",
+			qty=5,
+			rate=200,
+			update_stock=0,
+		)
+
+		rows = self.get_rows_for(self.run_report(posting_date="2000-01-01"), pi.name)
+		self.assertEqual(len(rows), 0)
+
+	def test_purchase_invoice_filter_scopes_to_that_invoice(self):
+		"""The optional purchase_invoice filter must narrow to that invoice only."""
+		pi = make_purchase_invoice(
+			supplier="_Test Supplier", item_code="_Test Item", qty=5, rate=200, update_stock=0
+		)
+		other = make_purchase_invoice(
+			supplier="_Test Supplier", item_code="_Test Item", qty=3, rate=200, update_stock=0
+		)
+
+		names = {row.get("name") for row in self.run_report(purchase_invoice=pi.name)}
+		self.assertEqual(names, {pi.name})
+		self.assertNotIn(other.name, names)

erpnext/accounts/report/budget_variance_report/test_budget_variance_report.py

@@ -4,7 +4,7 @@
 import frappe
 from frappe.utils import nowdate
 
-from erpnext.accounts.doctype.budget.test_budget import make_budget
+from erpnext.accounts.doctype.budget.test_budget import make_budget, set_total_expense_zero
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.report.budget_variance_report.budget_variance_report import execute
 from erpnext.accounts.utils import get_fiscal_year
@@ -33,7 +33,12 @@ class TestBudgetVarianceReport(ERPNextTestSuite):
 		return execute(filters)[1]
 
 	def report_row(self, data, dimension, account=ACCOUNT):
-		return next(row for row in data if row["budget_against"] == dimension and row["account"] == account)
+		row = next(
+			(r for r in data if r["budget_against"] == dimension and r["account"] == account),
+			None,
+		)
+		self.assertIsNotNone(row, f"No report row for {dimension} / {account}")
+		return row
 
 	def field(self, label):
 		return frappe.scrub(f"{label} {self.fy}")
@@ -55,6 +60,8 @@ class TestBudgetVarianceReport(ERPNextTestSuite):
 		self.assertTrue(columns)
 
 	def test_budget_amount_shown_with_zero_actual(self):
+		# neutralise any committed actuals so the exact Actual/Variance assertions hold
+		set_total_expense_zero(nowdate(), "cost_center")
 		make_budget(
 			budget_against="Cost Center", cost_center=COST_CENTER, budget_amount=120000, submit_budget=1
 		)
@@ -65,6 +72,9 @@ class TestBudgetVarianceReport(ERPNextTestSuite):
 		self.assertEqual(row[self.field("Variance")], 120000)
 
 	def test_actual_expense_updates_actual_and_variance(self):
+		# zero out pre-committed actuals: keeps Actual exact and avoids the budget's
+		# "Stop" action rejecting the journal entry when prior actuals already exist
+		set_total_expense_zero(nowdate(), "cost_center")
 		make_budget(
 			budget_against="Cost Center", cost_center=COST_CENTER, budget_amount=120000, submit_budget=1
 		)
@@ -88,6 +98,8 @@ class TestBudgetVarianceReport(ERPNextTestSuite):
 		self.assertEqual(dimensions, {COST_CENTER})
 
 	def test_monthly_period_totals(self):
+		# zero out pre-committed actuals so total_actual reflects only this test's entry
+		set_total_expense_zero(nowdate(), "cost_center")
 		make_budget(
 			budget_against="Cost Center", cost_center=COST_CENTER, budget_amount=120000, submit_budget=1
 		)

erpnext/accounts/report/calculated_discount_mismatch/test_calculated_discount_mismatch.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import json
+
+import frappe
+from frappe.utils.formatters import format_value
+
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.report.calculated_discount_mismatch.calculated_discount_mismatch import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestCalculatedDiscountMismatch(ERPNextTestSuite):
+	"""Integrity detector: flag transactions whose stored ``discount_amount`` was tampered
+	after the fact (a Version records the change) while ``additional_discount_percentage``
+	stayed the same, so the stored amount no longer matches the percentage-derived value.
+	"""
+
+	def run_report(self, docname: str) -> dict | None:
+		"""Run the (filter-less) report and return the row for ``docname``, if any."""
+		_columns, data = execute(frappe._dict({}))
+		return next((row for row in data if row["docname"] == docname), None)
+
+	def create_discounted_invoice(self) -> "frappe.Document":
+		"""Draft Sales Invoice (rate 1000) with a 10% additional discount.
+
+		The controller derives ``discount_amount`` = 10% of the grand total = 100.00,
+		so the stored amount is consistent with the percentage.
+		"""
+		invoice = create_sales_invoice(rate=1000, qty=1, do_not_submit=1)
+		invoice.additional_discount_percentage = 10
+		invoice.save()
+		invoice.reload()
+		return invoice
+
+	def test_consistent_discount_is_not_flagged(self):
+		"""A submitted invoice whose discount_amount matches its percentage is not reported."""
+		invoice = self.create_discounted_invoice()
+		invoice.submit()
+		invoice.reload()
+
+		self.assertEqual(invoice.discount_amount, 100.0)
+		self.assertIsNone(self.run_report(invoice.name))
+
+	def test_tampered_discount_is_flagged(self):
+		"""Directly overwriting discount_amount (leaving the percentage intact) is reported.
+
+		This reproduces the real-world integrity breach: a Version records the
+		``discount_amount`` change, its ``new`` value equals the current stored amount, and
+		``additional_discount_percentage`` was not touched -- exactly the shape the report
+		queries for.
+		"""
+		invoice = self.create_discounted_invoice()
+		consistent_amount = invoice.discount_amount  # 100.00, matches the 10% percentage
+		tampered_amount = 250.0
+
+		discount_field = frappe.get_meta("Sales Invoice").get_field("discount_amount")
+		# Format exactly as the report does so version.new == format_value(current amount).
+		suspected = format_value(consistent_amount, df=discount_field, currency=invoice.currency)
+		actual = format_value(tampered_amount, df=discount_field, currency=invoice.currency)
+
+		# Tamper the stored amount directly, bypassing the controller that would recompute it.
+		frappe.db.set_value("Sales Invoice", invoice.name, "discount_amount", tampered_amount)
+		self.record_discount_change(invoice.name, suspected, actual)
+
+		row = self.run_report(invoice.name)
+
+		self.assertIsNotNone(row)
+		self.assertEqual(row["doctype"], "Sales Invoice")
+		self.assertEqual(row["actual_discount_percentage"], 10.0)
+		self.assertEqual(row["actual_discount_amount"], actual)
+		self.assertEqual(row["suspected_discount_amount"], suspected)
+
+	def record_discount_change(self, docname: str, old: str, new: str) -> None:
+		"""Insert the Version audit row a direct discount_amount edit would have produced."""
+		version = frappe.new_doc("Version")
+		version.ref_doctype = "Sales Invoice"
+		version.docname = docname
+		version.data = json.dumps({"changed": [["discount_amount", old, new]]}, separators=(",", ":"))
+		version.flags.ignore_version = True
+		version.insert(ignore_permissions=True)

erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py

@@ -582,7 +582,12 @@ def prepare_data(accounts, start_date, end_date, balance_must_be, companies, com
 				total += flt(row[company])
 
 		row["has_value"] = has_value
-		row["total"] = total
+		# when accumulating into the group company, that company's column already consolidates its
+		# descendants, so summing every company column would double-count; use the group total directly.
+		if filters.get("accumulated_in_group_company"):
+			row["total"] = flt(row.get(filters.company, 0.0), 3)
+		else:
+			row["total"] = total
 
 		data.append(row)
 

erpnext/accounts/report/consolidated_financial_statement/test_consolidated_financial_statement.py

@@ -0,0 +1,129 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import flt, today
+
+from erpnext.accounts.report.consolidated_financial_statement.consolidated_financial_statement import (
+	execute,
+)
+from erpnext.accounts.utils import get_fiscal_year
+from erpnext.tests.utils import ERPNextTestSuite
+
+PARENT_COMPANY = "Parent Group Company India"
+CHILD_COMPANY = "Child Company India"
+
+
+class TestConsolidatedFinancialStatement(ERPNextTestSuite):
+	"""Consolidation is exercised via the bootstrap group of companies
+	(`Parent Group Company India` with child `Child Company India`). Income and
+	expense posted in the child company must surface in the report that is run
+	for the parent (group) company."""
+
+	def setUp(self):
+		self.fiscal_year = get_fiscal_year(today(), company=PARENT_COMPANY)[0]
+
+	def run_report(self, **extra):
+		filters = frappe._dict(
+			{
+				"company": PARENT_COMPANY,
+				"filter_based_on": "Fiscal Year",
+				"from_fiscal_year": self.fiscal_year,
+				"to_fiscal_year": self.fiscal_year,
+				"periodicity": "Yearly",
+				"include_default_book_entries": 1,
+			}
+		)
+		filters.update(extra)
+		return execute(filters)[1]
+
+	def post_journal_entry(self, debit_account, credit_account, amount):
+		je = frappe.new_doc("Journal Entry")
+		je.posting_date = today()
+		je.company = CHILD_COMPANY
+		je.set(
+			"accounts",
+			[
+				{"account": debit_account, "debit_in_account_currency": amount},
+				{"account": credit_account, "credit_in_account_currency": amount},
+			],
+		)
+		je.save()
+		je.submit()
+		return je
+
+	def get_row(self, data, account_name_fragment, last_match=False):
+		"""Return the first (or last) row whose account_name contains the fragment.
+
+		Pass ``last_match=True`` to get the leaf/most-specific match when the fragment
+		is also a prefix of a parent group account (parents precede children in tree order).
+		"""
+		found = None
+		for row in data:
+			if account_name_fragment in str(row.get("account_name") or ""):
+				if not last_match:
+					return row
+				found = row
+		return found
+
+	def test_profit_and_loss_reflects_child_company_income(self):
+		amount = 7000
+		self.post_journal_entry("Cash - CCI", "Sales - CCI", amount)
+
+		data = self.run_report(report="Profit and Loss Statement", accumulated_in_group_company=0)
+
+		self.assertTrue(data, "Report returned no rows")
+
+		# child's Sales account is mapped onto the parent chart (Sales - PGCI)
+		sales_row = self.get_row(data, "Sales", last_match=True)
+		self.assertIsNotNone(sales_row, "Sales row missing from consolidated P&L")
+		# >= so a pre-existing Sales balance in the fiscal year doesn't make this brittle
+		self.assertGreaterEqual(flt(sales_row.get(CHILD_COMPANY)), amount)
+
+		total_income_row = self.get_row(data, "Total Income (Credit)")
+		self.assertIsNotNone(total_income_row, "Total Income row missing")
+		self.assertGreaterEqual(flt(total_income_row.get("total")), amount)
+
+	def test_profit_and_loss_reflects_child_company_expense(self):
+		amount = 3000
+		self.post_journal_entry("Marketing Expenses - CCI", "Cash - CCI", amount)
+
+		data = self.run_report(report="Profit and Loss Statement", accumulated_in_group_company=0)
+
+		expense_row = self.get_row(data, "Marketing Expenses", last_match=True)
+		self.assertIsNotNone(expense_row, "Marketing Expenses row missing from consolidated P&L")
+		self.assertGreaterEqual(flt(expense_row.get(CHILD_COMPANY)), amount)
+
+		total_expense_row = self.get_row(data, "Total Expense (Debit)")
+		self.assertIsNotNone(total_expense_row, "Total Expense row missing")
+		self.assertGreaterEqual(flt(total_expense_row.get("total")), amount)
+
+	def test_accumulated_in_group_company_rolls_up_to_parent(self):
+		"""With `accumulated_in_group_company`, the child's amount is also
+		accumulated into the parent company column."""
+		amount = 5000
+		self.post_journal_entry("Cash - CCI", "Sales - CCI", amount)
+
+		data = self.run_report(report="Profit and Loss Statement", accumulated_in_group_company=1)
+
+		sales_row = self.get_row(data, "Sales", last_match=True)
+		self.assertIsNotNone(sales_row)
+		child_value = flt(sales_row.get(CHILD_COMPANY))
+		self.assertGreaterEqual(child_value, amount)
+		# parent column picks up the child value when accumulated
+		self.assertEqual(flt(sales_row.get(PARENT_COMPANY)), child_value)
+		# the total equals the consolidated (group) value, not the sum of parent + child
+		# columns -- this is the regression guard for the double-count fix
+		self.assertEqual(flt(sales_row.get("total")), child_value)
+
+	def test_balance_sheet_executes_and_returns_rows(self):
+		# posting income leaves a balancing entry in the child's Cash (Asset) account
+		amount = 4000
+		self.post_journal_entry("Cash - CCI", "Sales - CCI", amount)
+
+		data = self.run_report(report="Balance Sheet", accumulated_in_group_company=0)
+
+		self.assertTrue(data, "Balance Sheet returned no rows")
+		cash_row = self.get_row(data, "Cash")
+		self.assertIsNotNone(cash_row, "Cash asset row missing from consolidated Balance Sheet")
+		self.assertGreaterEqual(flt(cash_row.get(CHILD_COMPANY)), amount)

erpnext/accounts/report/custom_financial_statement/test_custom_financial_statement.py

@@ -0,0 +1,94 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import flt
+
+from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.accounts.report.custom_financial_statement.custom_financial_statement import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestCustomFinancialStatement(ERPNextTestSuite):
+	"""The report renders a Financial Report Template through FinancialReportEngine.
+	These tests exercise its own entry point: a template with an account-data row
+	and a calculated row, and the guard that returns nothing without a template."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.company = "_Test Company"
+		self.expense_account = "_Test Account Cost for Goods Sold - _TC"
+		self.cash_account = "Cash - _TC"
+
+	def _make_template(self):
+		# rows filter by exact account name so the value is isolated from other data
+		template_name = f"Test Custom FS {frappe.generate_hash()[:8]}"
+		return frappe.get_doc(
+			{
+				"doctype": "Financial Report Template",
+				"template_name": template_name,
+				"report_type": "Profit and Loss Statement",
+				"rows": [
+					{
+						"reference_code": "EXP",
+						"display_name": "Test Expense",
+						"indentation_level": 0,
+						"data_source": "Account Data",
+						"balance_type": "Closing Balance",
+						"calculation_formula": f'["name", "=", "{self.expense_account}"]',
+					},
+					{
+						"reference_code": "EXP_X2",
+						"display_name": "Expense Doubled",
+						"indentation_level": 0,
+						"data_source": "Calculated Amount",
+						"calculation_formula": "EXP * 2",
+					},
+				],
+			}
+		).insert()
+
+	def _filters(self, template_name):
+		return frappe._dict(
+			{
+				"company": self.company,
+				"report_template": template_name,
+				"from_fiscal_year": "2024",
+				"to_fiscal_year": "2024",
+				"period_start_date": "2024-01-01",
+				"period_end_date": "2024-12-31",
+				"filter_based_on": "Date Range",
+				"periodicity": "Yearly",
+				"accumulated_values": 0,
+			}
+		)
+
+	def test_account_and_calculated_rows(self):
+		make_journal_entry(
+			self.expense_account,
+			self.cash_account,
+			2000,
+			posting_date="2024-06-15",
+			company=self.company,
+			submit=True,
+		)
+		template = self._make_template()
+
+		columns, data = execute(self._filters(template.template_name))[:2]
+		self.assertTrue(columns)
+
+		rows = {row.get("account_name"): row for row in data}
+		self.assertIn("Test Expense", rows)
+		self.assertIn("Expense Doubled", rows)
+
+		period_keys = rows["Test Expense"].get("_segment_info", {}).get("period_keys", [])
+		self.assertTrue(period_keys, "expected at least one period key in _segment_info")
+		period_key = period_keys[0]
+
+		# the account-data row picks up the posted expense; the calculated row doubles it
+		self.assertEqual(flt(rows["Test Expense"][period_key]), 2000.0)
+		self.assertEqual(flt(rows["Expense Doubled"][period_key]), 4000.0)
+
+	def test_no_template_returns_nothing(self):
+		"""Without a report_template the report short-circuits and returns None."""
+		self.assertIsNone(execute(frappe._dict({"company": self.company})))

erpnext/accounts/report/dimension_wise_accounts_balance_report/test_dimension_wise_accounts_balance_report.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import today
+
+from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.accounts.report.dimension_wise_accounts_balance_report.dimension_wise_accounts_balance_report import (
+	execute,
+)
+from erpnext.accounts.utils import get_fiscal_year
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestDimensionWiseAccountsBalance(ERPNextTestSuite):
+	"""Balances accounts one column per value of an accounting dimension (here
+	Cost Center). Locks the two behaviours that matter: an entry lands in its
+	own dimension column as debit - credit, and children roll up into parents."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.company = "_Test Company"
+		self.expense_account = "_Test Account Cost for Goods Sold - _TC"
+		self.cash_account = "Cash - _TC"
+
+	def _make_cost_center(self, name):
+		full_name = f"{name} - _TC"
+		if not frappe.db.exists("Cost Center", full_name):
+			frappe.get_doc(
+				{
+					"doctype": "Cost Center",
+					"cost_center_name": name,
+					"parent_cost_center": "_Test Company - _TC",
+					"company": self.company,
+					"is_group": 0,
+				}
+			).insert()
+		return full_name
+
+	def _filters(self, **overrides):
+		filters = frappe._dict(
+			{
+				"company": self.company,
+				"dimension": "Cost Center",
+				"fiscal_year": get_fiscal_year(today(), company=self.company)[0],
+			}
+		)
+		filters.update(overrides)
+		return filters
+
+	def test_dimension_column_and_rollup(self):
+		# a dedicated cost center isolates our column from any other posted data
+		cost_center = self._make_cost_center("Test Dimension CC")
+		make_journal_entry(
+			self.expense_account,
+			self.cash_account,
+			300,
+			cost_center=cost_center,
+			posting_date=today(),
+			submit=True,
+		)
+
+		columns, data = execute(self._filters())
+		column = frappe.scrub(cost_center)
+		self.assertIn(column, [c["fieldname"] for c in columns])
+
+		rows = {row["account"]: row for row in data}
+
+		# the entry shows as debit - credit under its own dimension column
+		self.assertEqual(rows[self.expense_account][column], 300.0)
+		self.assertEqual(rows[self.cash_account][column], -300.0)
+
+		# and rolls up into each account's parent (isolated to our cost center)
+		expense_parent = frappe.db.get_value("Account", self.expense_account, "parent_account")
+		cash_parent = frappe.db.get_value("Account", self.cash_account, "parent_account")
+		self.assertEqual(rows[expense_parent][column], 300.0)
+		self.assertEqual(rows[cash_parent][column], -300.0)
+
+	def test_requires_fiscal_year(self):
+		filters = self._filters()
+		filters.pop("fiscal_year")
+		self.assertRaises(frappe.ValidationError, execute, filters)

erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py

@@ -21,7 +21,12 @@ def execute(filters=None):
 	entries = get_entries(filters)
 	invoice_details = get_invoice_posting_date_map(filters)
 
-	report = ReceivablePayableReport(filters)
+	# Only four range columns are defined (range1-range4, the last being "90 Above").
+	# Three thresholds yield exactly four buckets, so payments more than 90 days after
+	# the invoice land in range4 instead of an unread range5.
+	report_filters = frappe._dict(filters)
+	report_filters.range = "30, 60, 90"
+	report = ReceivablePayableReport(report_filters)
 
 	data = []
 	for d in entries:

erpnext/accounts/report/payment_period_based_on_invoice_date/test_payment_period_based_on_invoice_date.py

@@ -32,15 +32,15 @@ class TestPaymentPeriodBasedOnInvoiceDate(ERPNextTestSuite):
 			}
 		)
 		filters.update(extra)
-		return execute(filters)
+		columns, data = execute(filters)
+		fieldnames = [c["fieldname"] for c in columns]
+		# Map each positional row to a dict keyed by column fieldname so assertions
+		# stay correct even if a column is inserted or reordered.
+		return columns, [dict(zip(fieldnames, row, strict=False)) for row in data]
 
 	def find_payment_row(self, data, payment_name):
-		# Row shape (positional): payment_document, payment_entry(voucher_no),
-		# party_type, party, posting_date, invoice(against_voucher_no),
-		# invoice_posting_date, due_date, amount, remarks, age,
-		# range1, range2, range3, range4, [delay_in_payment]
 		for row in data:
-			if row[1] == payment_name:
+			if row["payment_entry"] == payment_name:
 				return row
 		return None
 
@@ -57,42 +57,60 @@ class TestPaymentPeriodBasedOnInvoiceDate(ERPNextTestSuite):
 		invoice = create_sales_invoice(customer="_Test Customer", rate=1000, posting_date="2026-06-01")
 		payment = self.pay_invoice(invoice, "2026-06-20")
 
-		columns, data = self.run_report()
+		_columns, data = self.run_report()
 
 		row = self.find_payment_row(data, payment.name)
 		self.assertIsNotNone(row, "Payment row not found in report output")
 
-		# Positional assertions on the row shape.
-		self.assertEqual(row[2], "Customer")
-		self.assertEqual(row[4], getdate("2026-06-20"))  # payment posting date
-		self.assertEqual(row[5], invoice.name)  # against invoice
-		self.assertEqual(row[6], getdate("2026-06-01"))  # invoice posting date
-		self.assertEqual(row[8], 1000)  # amount
-		self.assertEqual(row[10], 19)  # age = payment date - invoice date
+		self.assertEqual(row["party_type"], "Customer")
+		self.assertEqual(row["posting_date"], getdate("2026-06-20"))
+		self.assertEqual(row["invoice"], invoice.name)
+		self.assertEqual(row["invoice_posting_date"], getdate("2026-06-01"))
+		self.assertEqual(row["amount"], 1000)
+		self.assertEqual(row["age"], 19)  # age = payment date - invoice date
 
 		# Buckets: 0-30 filled, others empty.
-		self.assertEqual(row[11], 1000)  # range1 (0-30)
-		self.assertEqual(row[12], 0)  # range2 (30-60)
-		self.assertEqual(row[13], 0)  # range3 (60-90)
-		self.assertEqual(row[14], 0)  # range4 (90 Above)
+		self.assertEqual(row["range1"], 1000)  # 0-30
+		self.assertEqual(row["range2"], 0)  # 30-60
+		self.assertEqual(row["range3"], 0)  # 60-90
+		self.assertEqual(row["range4"], 0)  # 90 Above
 
 	def test_paid_amount_lands_in_30_60_bucket(self):
 		# invoice 2026-06-01, paid 2026-07-16 -> 45 days after -> 30-60 bucket
 		invoice = create_sales_invoice(customer="_Test Customer 1", rate=1000, posting_date="2026-06-01")
 		payment = self.pay_invoice(invoice, "2026-07-16")
 
-		columns, data = self.run_report()
+		_columns, data = self.run_report()
 
 		row = self.find_payment_row(data, payment.name)
 		self.assertIsNotNone(row, "Payment row not found in report output")
 
-		self.assertEqual(row[8], 1000)  # amount
-		self.assertEqual(row[10], 45)  # age = payment date - invoice date
+		self.assertEqual(row["amount"], 1000)
+		self.assertEqual(row["age"], 45)
 		# Buckets: 30-60 filled, others empty.
-		self.assertEqual(row[11], 0)  # range1 (0-30)
-		self.assertEqual(row[12], 1000)  # range2 (30-60)
-		self.assertEqual(row[13], 0)  # range3 (60-90)
-		self.assertEqual(row[14], 0)  # range4 (90 Above)
+		self.assertEqual(row["range1"], 0)
+		self.assertEqual(row["range2"], 1000)
+		self.assertEqual(row["range3"], 0)
+		self.assertEqual(row["range4"], 0)
+
+	def test_payment_over_90_days_lands_in_90_above_bucket(self):
+		# invoice 2026-01-01, paid 2026-06-01 -> 151 days after -> "90 Above" bucket.
+		# Regression guard: with four range columns, a payment older than the last
+		# threshold must fall into range4 rather than an unread range5 (showing 0).
+		invoice = create_sales_invoice(customer="_Test Customer 2", rate=1000, posting_date="2026-01-01")
+		payment = self.pay_invoice(invoice, "2026-06-01")
+
+		_columns, data = self.run_report()
+
+		row = self.find_payment_row(data, payment.name)
+		self.assertIsNotNone(row, "Payment row not found in report output")
+
+		self.assertEqual(row["amount"], 1000)
+		self.assertEqual(row["age"], 151)
+		self.assertEqual(row["range1"], 0)
+		self.assertEqual(row["range2"], 0)
+		self.assertEqual(row["range3"], 0)
+		self.assertEqual(row["range4"], 1000)  # 90 Above captures the full amount
 
 	def test_columns_expose_expected_age_buckets(self):
 		columns, _data = self.run_report()

erpnext/accounts/report/profitability_analysis/test_profitability_analysis.py

@@ -46,8 +46,9 @@ class TestProfitabilityAnalysis(ERPNextTestSuite):
 		)
 
 	def test_income_expense_and_gross_profit(self):
-		# bootstrap leaf cost center; clean of committed GL so exact assertions hold
-		cc = "_Test Cost Center - _TC"
+		# a dedicated leaf cost center keeps these exact assertions free of GL that
+		# other tests may book against a shared cost center in the same fiscal year
+		cc = self.make_cc("_Test PA Income Expense")
 		self.book_income(cc, 10000)
 		self.book_expense(cc, 4000)
 
@@ -74,7 +75,7 @@ class TestProfitabilityAnalysis(ERPNextTestSuite):
 		self.assertEqual(parent_row["gross_profit_loss"], 7000)
 
 	def test_date_range_excludes_out_of_period_entries(self):
-		cc = "_Test Cost Center 2 - _TC"
+		cc = self.make_cc("_Test PA Date Range")
 		self.book_income(cc, 10000, posting_date="2025-06-01")
 
 		# the 2025 income must not appear in a 2026 report (zero-value rows are dropped)
@@ -97,7 +98,8 @@ class TestProfitabilityAnalysis(ERPNextTestSuite):
 		data = self.run_report()
 		# the report appends a blank separator row and a totals row at the end
 		total_row = data[-1]
-		self.assertEqual(total_row["account"], "'Total'")
+		# the report wraps the (possibly translated) "Total" label in single quotes
+		self.assertEqual(total_row["account"], "'" + frappe._("Total") + "'")
 		# total is built from direct (non-accumulated) values, so it stays internally consistent
 		self.assertEqual(total_row["gross_profit_loss"], total_row["income"] - total_row["expense"])
 		# and it includes this test's bookings

erpnext/accounts/report/share_balance/share_balance.py

@@ -22,7 +22,7 @@ def execute(filters=None):
 	else:
 		share_type, no_of_shares, rate, amount = 1, 2, 3, 4
 
-		all_shares = get_all_shares(filters.get("shareholder"), filters.get("date"))
+		all_shares = get_all_shares(filters.get("shareholder"), filters.get("date"), filters.get("company"))
 		for share_entry in all_shares:
 			row = False
 			for datum in data:
@@ -61,16 +61,35 @@ def get_columns(filters):
 	return columns
 
 
-def get_all_shares(shareholder, date):
+def get_all_shares(shareholder, date, company=None):
 	"""Share movements for the shareholder up to (and including) `date`, signed by direction:
-	shares received are positive, shares transferred/sold out are negative."""
-	transfers = frappe.get_all(
-		"Share Transfer",
-		filters={"docstatus": 1, "date": ("<=", date)},
-		fields=["share_type", "no_of_shares", "rate", "amount", "from_shareholder", "to_shareholder"],
-		order_by="date",
+	shares received are positive, shares transferred/sold out are negative.
+
+	The shareholder and company predicates are pushed into the query so only the
+	relevant transfers are fetched instead of scanning the whole table."""
+	share_transfer = frappe.qb.DocType("Share Transfer")
+	query = (
+		frappe.qb.from_(share_transfer)
+		.select(
+			share_transfer.share_type,
+			share_transfer.no_of_shares,
+			share_transfer.rate,
+			share_transfer.amount,
+			share_transfer.from_shareholder,
+			share_transfer.to_shareholder,
+		)
+		.where((share_transfer.docstatus == 1) & (share_transfer.date <= date))
+		.where(
+			(share_transfer.to_shareholder == shareholder) | (share_transfer.from_shareholder == shareholder)
+		)
+		.orderby(share_transfer.date)
 	)
 
+	if company:
+		query = query.where(share_transfer.company == company)
+
+	transfers = query.run(as_dict=True)
+
 	shares = []
 	for transfer in transfers:
 		if transfer.to_shareholder == shareholder:

erpnext/accounts/report/share_balance/test_share_balance.py

@@ -42,6 +42,30 @@ class TestShareBalanceReport(ERPNextTestSuite):
 		self.assertEqual(row[3], 10)  # average rate
 		self.assertEqual(row[4], 1000)  # amount = 100 * 10
 
+	def test_company_filter_scopes_transfers(self):
+		# the transfer is booked under `_Test Company`
+		create_share_transfer(
+			transfer_type="Issue",
+			to_shareholder=self.shareholder,
+			share_type=self.share_type,
+			from_no=1,
+			to_no=100,
+			no_of_shares=100,
+			rate=10,
+			date="2026-06-01",
+		)
+
+		# matching company: the holding shows up
+		self.assertEqual(self.get_row(date="2026-06-05")[2], 100)
+
+		# a different company must not surface this shareholder's transfer
+		other_company_data = execute(
+			frappe._dict(
+				{"date": "2026-06-05", "company": "_Test Company 1", "shareholder": self.shareholder}
+			)
+		)[1]
+		self.assertEqual(other_company_data, [])
+
 	def test_balance_increases_on_second_issue(self):
 		create_share_transfer(
 			transfer_type="Issue",

erpnext/accounts/report/share_ledger/test_share_ledger.py

@@ -0,0 +1,171 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+
+from erpnext.accounts.report.share_ledger.share_ledger import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+COMPANY = "_Test Company"
+
+# The report returns legacy positional columns (no fieldnames); name the indices once
+# here so a column reorder needs a single edit instead of silently shifting assertions.
+COL_SHAREHOLDER = 0
+COL_DATE = 1
+COL_TRANSFER_TYPE = 2
+COL_SHARE_TYPE = 3
+COL_NO_OF_SHARES = 4
+COL_RATE = 5
+COL_AMOUNT = 6
+COL_COMPANY = 7
+COL_SHARE_TRANSFER = 8
+
+
+class TestShareLedger(ERPNextTestSuite):
+	def setUp(self):
+		self.shareholder = self.create_shareholder("_Test Share Ledger Holder")
+		# Issue 100 shares on 2026-06-01, then another 50 on 2026-06-10.
+		self.first = self.issue_shares(date="2026-06-01", from_no=1, to_no=100, rate=10)
+		self.second = self.issue_shares(date="2026-06-10", from_no=101, to_no=150, rate=12)
+
+	def test_ledger_lists_all_transfers_upto_date(self):
+		data = self.run_report(shareholder=self.shareholder, date="2026-06-30")
+
+		self.assertEqual(len(data), 2)
+
+		first_row, second_row = data
+		self.assertEqual(first_row[COL_SHAREHOLDER], self.shareholder)
+		self.assertEqual(first_row[COL_DATE], frappe.utils.getdate("2026-06-01"))
+		self.assertEqual(first_row[COL_TRANSFER_TYPE], "Issue")
+		self.assertEqual(first_row[COL_SHARE_TYPE], "Equity")
+		self.assertEqual(first_row[COL_NO_OF_SHARES], 100)
+		self.assertEqual(first_row[COL_RATE], 10)
+		self.assertEqual(first_row[COL_AMOUNT], 1000)
+		self.assertEqual(first_row[COL_COMPANY], COMPANY)
+		self.assertEqual(first_row[COL_SHARE_TRANSFER], self.first)
+
+		self.assertEqual(second_row[COL_DATE], frappe.utils.getdate("2026-06-10"))
+		self.assertEqual(second_row[COL_NO_OF_SHARES], 50)
+		self.assertEqual(second_row[COL_RATE], 12)
+		self.assertEqual(second_row[COL_AMOUNT], 600)
+		self.assertEqual(second_row[COL_SHARE_TRANSFER], self.second)
+
+	def test_running_balance_of_shares(self):
+		data = self.run_report(shareholder=self.shareholder, date="2026-06-30")
+
+		# The ledger records each transfer's raw no_of_shares (always positive); it does
+		# not sign by direction. With only incoming "Issue" rows here, summing them is a
+		# valid running total. (Directional balances are the Share Balance report's job.)
+		running = 0
+		balances = []
+		for row in data:
+			running += row[COL_NO_OF_SHARES]
+			balances.append(running)
+
+		self.assertEqual(balances, [100, 150])
+
+	def test_as_on_date_between_transfers_shows_only_first(self):
+		data = self.run_report(shareholder=self.shareholder, date="2026-06-05")
+
+		self.assertEqual(len(data), 1)
+		self.assertEqual(data[0][COL_SHARE_TRANSFER], self.first)
+		self.assertEqual(data[0][COL_NO_OF_SHARES], 100)
+
+	def test_transfer_type_label_when_shareholder_is_seller(self):
+		buyer = self.create_shareholder("_Test Share Ledger Buyer")
+		transfer = self.make_transfer(
+			from_shareholder=self.shareholder,
+			to_shareholder=buyer,
+			date="2026-06-15",
+			from_no=1,
+			to_no=40,
+			rate=10,
+		)
+
+		row = self.transfer_row(self.run_report(shareholder=self.shareholder, date="2026-06-30"), transfer)
+		# seller side: the label names the counterparty it went "to"
+		self.assertEqual(row[COL_TRANSFER_TYPE], f"Transfer to {buyer}")
+
+	def test_transfer_type_label_when_shareholder_is_buyer(self):
+		seller = self.create_shareholder("_Test Share Ledger Seller")
+		# the seller must own shares before it can transfer them
+		self.issue_shares(date="2026-06-12", from_no=201, to_no=300, rate=10, shareholder=seller)
+		transfer = self.make_transfer(
+			from_shareholder=seller,
+			to_shareholder=self.shareholder,
+			date="2026-06-15",
+			from_no=201,
+			to_no=240,
+			rate=10,
+		)
+
+		row = self.transfer_row(self.run_report(shareholder=self.shareholder, date="2026-06-30"), transfer)
+		# buyer side: the label names the counterparty it came "from"
+		self.assertEqual(row[COL_TRANSFER_TYPE], f"Transfer from {seller}")
+
+	def test_missing_date_throws(self):
+		self.assertRaises(frappe.ValidationError, execute, frappe._dict(shareholder=self.shareholder))
+
+	def test_missing_shareholder_returns_no_rows(self):
+		data = self.run_report(date="2026-06-30")
+		self.assertEqual(data, [])
+
+	def run_report(self, **extra):
+		filters = frappe._dict({"company": COMPANY, **extra})
+		return execute(filters)[1]
+
+	def transfer_row(self, data, transfer_name):
+		row = next((r for r in data if r[COL_SHARE_TRANSFER] == transfer_name), None)
+		self.assertIsNotNone(row, f"Share Transfer {transfer_name} missing from ledger")
+		return row
+
+	def create_shareholder(self, title):
+		doc = frappe.get_doc(
+			{
+				"doctype": "Shareholder",
+				"title": title,
+				"company": COMPANY,
+			}
+		).insert()
+		return doc.name
+
+	def issue_shares(self, date, from_no, to_no, rate, shareholder=None):
+		doc = frappe.get_doc(
+			{
+				"doctype": "Share Transfer",
+				"transfer_type": "Issue",
+				"date": date,
+				"to_shareholder": shareholder or self.shareholder,
+				"share_type": "Equity",
+				"from_no": from_no,
+				"to_no": to_no,
+				"no_of_shares": to_no - from_no + 1,
+				"rate": rate,
+				"company": COMPANY,
+				"asset_account": "Cash - _TC",
+				"equity_or_liability_account": "Creditors - _TC",
+			}
+		)
+		doc.submit()
+		return doc.name
+
+	def make_transfer(self, from_shareholder, to_shareholder, date, from_no, to_no, rate):
+		doc = frappe.get_doc(
+			{
+				"doctype": "Share Transfer",
+				"transfer_type": "Transfer",
+				"date": date,
+				"from_shareholder": from_shareholder,
+				"to_shareholder": to_shareholder,
+				"share_type": "Equity",
+				"from_no": from_no,
+				"to_no": to_no,
+				"no_of_shares": to_no - from_no + 1,
+				"rate": rate,
+				"company": COMPANY,
+				"asset_account": "Cash - _TC",
+				"equity_or_liability_account": "Creditors - _TC",
+			}
+		)
+		doc.submit()
+		return doc.name

erpnext/accounts/workspace/accounts_setup/accounts_setup.json

@@ -0,0 +1,329 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-14 12:44:31.994274",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "database",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Accounts Setup",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-06-14 13:43:50.138704",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "module_onboarding": "Accounting Onboarding",
+ "name": "Accounts Setup",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 55.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Chart of Accounts",
+   "link_to": "Account",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Chart of Cost Centers",
+   "link_to": "Cost Center",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Account Category",
+   "link_to": "Account Category",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounting Dimension",
+   "link_to": "Accounting Dimension",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Currency",
+   "link_to": "Currency",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Currency Exchange",
+   "link_to": "Currency Exchange",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Finance Book",
+   "link_to": "Finance Book",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Mode of Payment",
+   "link_to": "Mode of Payment",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Term",
+   "link_to": "Payment Term",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Journal Entry Template",
+   "link_to": "Journal Entry Template",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Terms and Conditions",
+   "link_to": "Terms and Conditions",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Company",
+   "link_to": "Company",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Fiscal Year",
+   "link_to": "Fiscal Year",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Taxes",
+   "link_to": "Sales Taxes and Charges Template",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "lock-keyhole-open",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Opening & Closing",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "COA Importer",
+   "link_to": "Chart of Accounts Importer",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Opening Invoice Tool",
+   "link_to": "Opening Invoice Creation Tool",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounting Period",
+   "link_to": "Accounting Period",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "FX Revaluation",
+   "link_to": "Exchange Rate Revaluation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Period Closing Voucher",
+   "link_to": "Period Closing Voucher",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "settings",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Settings",
+   "link_to": "Accounts Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Currency Exchange Settings",
+   "link_to": "Currency Exchange Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Accounts Setup",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/banking/banking.json

@@ -0,0 +1,222 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-11 11:51:22.767176",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "circle-dollar-sign",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Banking",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 13:43:50.924019",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Banking",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 49.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "book-open-check",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Clearance",
+   "link_to": "Bank Clearance",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "wrench",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Reconciliation",
+   "link_to": "Bank Reconciliation Tool",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "clipboard-check",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Reconciliation Statement",
+   "link_to": "Bank Reconciliation Statement",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "split",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Unreconcile Payment",
+   "link_to": "Unreconcile Payment",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "link",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Process Payment Reconciliation",
+   "link_to": "Process Payment Reconciliation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank",
+   "link_to": "Bank",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Account",
+   "link_to": "Bank Account",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Account Type",
+   "link_to": "Bank Account Type",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Account Subtype",
+   "link_to": "Bank Account Subtype",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Bank Guarantee",
+   "link_to": "Bank Guarantee",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Plaid Settings",
+   "link_to": "Plaid Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "scroll-text",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Dunning",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dunning",
+   "link_to": "Dunning",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dunning Type",
+   "link_to": "Dunning Type",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Banking",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/budgeting/budgeting.json

@@ -0,0 +1,104 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-14 14:38:20.315394",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "wallet",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Budgeting",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 04:24:48.116724",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Budgeting",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 57.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "default_workspace": 0,
+   "icon": "briefcase-business",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Budget",
+   "link_to": "Budget",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "default_workspace": 0,
+   "icon": "badge-cent",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Cost Center",
+   "link_to": "Cost Center",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "default_workspace": 0,
+   "icon": "wallet",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounting Dimension",
+   "link_to": "Accounting Dimension",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "default_workspace": 0,
+   "icon": "notepad-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Cost Center Allocation",
+   "link_to": "Cost Center Allocation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "default_workspace": 0,
+   "icon": "sheet",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Budget Variance",
+   "link_to": "Budget Variance Report",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Budgeting",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/financial_reports/financial_reports.json

@@ -13,7 +13,7 @@
  "doctype": "Workspace",
  "for_user": "",
  "hide_custom": 0,
- "icon": "table",
+ "icon": "sheet",
  "idx": 1,
  "indicator_color": "",
  "is_hidden": 0,
@@ -266,9 +266,10 @@
    "type": "Link"
   }
  ],
- "modified": "2026-05-18 09:49:45.138296",
+ "modified": "2026-07-03 13:44:08.095321",
  "modified_by": "Administrator",
  "module": "Accounts",
+ "module_onboarding": "Accounting Onboarding",
  "name": "Financial Reports",
  "number_cards": [],
  "owner": "Administrator",
@@ -279,6 +280,417 @@
  "roles": [],
  "sequence_id": 5.0,
  "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "wallet",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Financial Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Balance Sheet",
+   "link_to": "Balance Sheet",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Profit and Loss",
+   "link_to": "Profit and Loss Statement",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Cash Flow",
+   "link_to": "Cash Flow",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Trial Balance",
+   "link_to": "Trial Balance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Consolidated Report",
+   "link_to": "Consolidated Financial Statement",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Custom Financial Statement",
+   "link_to": "Custom Financial Statement",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Financial Report Template",
+   "link_to": "Financial Report Template",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "book-text",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Ledgers",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "General Ledger",
+   "link_to": "General Ledger",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Customer Ledger",
+   "link_to": "Customer Ledger Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Ledger",
+   "link_to": "Supplier Ledger Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Registers",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Receivable",
+   "link_to": "Accounts Receivable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Payable",
+   "link_to": "Accounts Payable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "AR Summary",
+   "link_to": "Accounts Receivable Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "AP Summary",
+   "link_to": "Accounts Payable Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Register",
+   "link_to": "Sales Register",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Register",
+   "link_to": "Purchase Register",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item-wise sales Register",
+   "link_to": "Item-wise Sales Register",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item-wise Purchase Register",
+   "link_to": "Item-wise Purchase Register",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "dollar-sign",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Profitability",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Gross Profit",
+   "link_to": "Gross Profit",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Profitability Analysis",
+   "link_to": "Profitability Analysis",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Invoice Trends",
+   "link_to": "Sales Invoice Trends",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Invoice Trends",
+   "link_to": "Purchase Invoice Trends",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "scroll-text",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Other Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Trial Balance for Party",
+   "link_to": "Trial Balance for Party",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Period Based On Invoice Date",
+   "link_to": "Payment Period Based On Invoice Date",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Partners Commission",
+   "link_to": "Sales Partners Commission",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Customer Credit Balance",
+   "link_to": "Customer Credit Balance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Payment Summary",
+   "link_to": "Sales Payment Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Address And Contacts",
+   "link_to": "Address And Contacts",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "UAE VAT 201",
+   "link_to": "UAE VAT 201",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
  "title": "Financial Reports",
  "type": "Workspace"
 }

erpnext/accounts/workspace/invoicing/invoicing.json

@@ -13,7 +13,7 @@
  "doctype": "Workspace",
  "for_user": "",
  "hide_custom": 0,
- "icon": "accounting",
+ "icon": "wallet",
  "idx": 4,
  "indicator_color": "",
  "is_hidden": 0,
@@ -587,9 +587,10 @@
    "type": "Link"
   }
  ],
- "modified": "2026-01-23 11:05:47.246213",
+ "modified": "2026-07-03 13:44:08.471142",
  "modified_by": "Administrator",
  "module": "Accounts",
+ "module_onboarding": "Accounting Onboarding",
  "name": "Invoicing",
  "number_cards": [
   {
@@ -617,6 +618,354 @@
  "roles": [],
  "sequence_id": 2.0,
  "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "house",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Home",
+   "link_to": "Invoicing",
+   "link_type": "Workspace",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "chart-column",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dashboard",
+   "link_to": "Accounts",
+   "link_type": "Dashboard",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "list-tree",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Chart of Accounts",
+   "link_to": "Account",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "arrow-left-to-line",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Receivables",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Customer",
+   "link_to": "Customer",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Invoice",
+   "link_to": "Sales Invoice",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Credit Note",
+   "link_to": "Sales Invoice",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "route_options": "{\"is_return\": 1}",
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Receivable",
+   "link_to": "Accounts Receivable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "arrow-right-from-line",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Payables",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier",
+   "link_to": "Supplier",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Invoice",
+   "link_to": "Purchase Invoice",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Debit Note",
+   "link_to": "Purchase Invoice",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "route_options": "{\"is_return\": 1}",
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Payable",
+   "link_to": "Accounts Payable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "coins",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Payments",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Entry",
+   "link_to": "Payment Entry",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Journal Entry",
+   "link_to": "Journal Entry",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Request",
+   "link_to": "Payment Request",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Order",
+   "link_to": "Payment Order",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Reconciliation",
+   "link_to": "Payment Reconciliation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Unreconcile Payment",
+   "link_to": "Unreconcile Payment",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Process Payment Reconciliation",
+   "link_to": "Process Payment Reconciliation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Repost Accounting Ledger",
+   "link_to": "Repost Accounting Ledger",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Repost Payment Ledger",
+   "link_to": "Repost Payment Ledger",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sheet",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "General Ledger",
+   "link_to": "General Ledger",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Trial Balance",
+   "link_to": "Trial Balance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Financial Reports",
+   "link_to": "Financial Reports",
+   "link_type": "Workspace",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "settings",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Settings",
+   "link_to": "Accounts Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
  "title": "Invoicing",
  "type": "Workspace"
 }

erpnext/accounts/workspace/payments/payments.json

@@ -0,0 +1,240 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-11 11:51:21.886461",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "receipt-text",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Payments",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 13:43:50.184761",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "module_onboarding": "Accounting Onboarding",
+ "name": "Payments",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 47.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "chart-column",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dashboard",
+   "link_to": "Payments",
+   "link_type": "Dashboard",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "coins",
+   "indent": 1,
+   "keep_closed": 0,
+   "label": "Payments",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Entry",
+   "link_to": "Payment Entry",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Journal Entry",
+   "link_to": "Journal Entry",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Request",
+   "link_to": "Payment Request",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Order",
+   "link_to": "Payment Order",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Payment Reconciliation",
+   "link_to": "Payment Reconciliation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Unreconcile Payment",
+   "link_to": "Unreconcile Payment",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Process Payment Reconciliation",
+   "link_to": "Process Payment Reconciliation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Repost Accounting Ledger",
+   "link_to": "Repost Accounting Ledger",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Repost Payment Ledger",
+   "link_to": "Repost Payment Ledger",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sheet",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Receivable",
+   "link_to": "Accounts Receivable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Accounts Payable",
+   "link_to": "Accounts Payable",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "General Ledger",
+   "link_to": "General Ledger",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Trial Balance",
+   "link_to": "Trial Balance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Financial Reports",
+   "link_to": "Financial Reports",
+   "link_type": "Workspace",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Payments",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/share_management/share_management.json

@@ -0,0 +1,86 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-11 11:51:22.831729",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "coins",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Share Management",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 13:43:51.040978",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Share Management",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 50.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "user",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Shareholder",
+   "link_to": "Shareholder",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "move-horizontal",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Share Transfer",
+   "link_to": "Share Transfer",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "list",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Share Ledger",
+   "link_to": "Share Ledger",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "notepad-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Share Balance",
+   "link_to": "Share Balance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Share Management",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/subscriptions/subscriptions.json

@@ -0,0 +1,121 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-14 14:08:36.817393",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "wallet",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Subscriptions",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 14:08:36.999272",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Subscriptions",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 56.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "circle-dollar-sign",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Subscription",
+   "link_to": "Subscription",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "receipt-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Subscription Plan",
+   "link_to": "Subscription Plan",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "settings",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Subscription Settings",
+   "link_to": "Subscription Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Customer",
+   "link_to": "Customer",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier",
+   "link_to": "Supplier",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item",
+   "link_to": "Item",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Subscriptions",
+ "type": "Workspace"
+}

erpnext/accounts/workspace/taxes/taxes.json

@@ -0,0 +1,188 @@
+{
+ "app": "erpnext",
+ "charts": [],
+ "content": "[]",
+ "creation": "2026-06-11 11:51:22.649582",
+ "custom_blocks": [],
+ "docstatus": 0,
+ "doctype": "Workspace",
+ "for_user": "",
+ "hide_custom": 0,
+ "icon": "coins",
+ "idx": 0,
+ "indicator_color": "green",
+ "is_hidden": 0,
+ "label": "Taxes",
+ "link_type": "DocType",
+ "links": [],
+ "modified": "2026-07-03 13:43:50.894825",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "module_onboarding": "Accounting Onboarding",
+ "name": "Taxes",
+ "number_cards": [],
+ "owner": "Administrator",
+ "public": 1,
+ "quick_lists": [],
+ "roles": [],
+ "sequence_id": 48.0,
+ "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "panel-bottom-close",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Sales Tax Template",
+   "link_to": "Sales Taxes and Charges Template",
+   "link_type": "DocType",
+   "navigate_to_tab": "",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "panel-top-close",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Tax Template",
+   "link_to": "Purchase Taxes and Charges Template",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "package",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item Tax Template",
+   "link_to": "Item Tax Template",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "triangle",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Tax Category",
+   "link_to": "Tax Category",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "book-open-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Tax Rule",
+   "link_to": "Tax Rule",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "book-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Tax Withholding Category",
+   "link_to": "Tax Withholding Category",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Tax Withholding Group",
+   "link_to": "Tax Withholding Group",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "notebook-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Deduction Certificate",
+   "link_to": "Lower Deduction Certificate",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sheet",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Reports",
+   "link_to": "",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "TDS Computation Summary",
+   "link_to": "TDS Computation Summary",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Tax Withholding Details",
+   "link_to": "Tax Withholding Details",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
+ "title": "Taxes",
+ "type": "Workspace"
+}

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -587,3 +587,47 @@ def get_actual_sle_dict(name):
 		}
 
 	return sle_dict
+
+
+class TestAssetCapitalizationValidation(ERPNextTestSuite):
+	"""Row-level validations for the consumed/target items. Exercised on the document
+	directly (the integration tests above cover the full capitalization posting)."""
+
+	def make_capitalization(self, **fields):
+		doc = frappe.new_doc("Asset Capitalization")
+		doc.company = "_Test Company"
+		doc.update(fields)
+		return doc
+
+	def test_source_items_are_mandatory(self):
+		doc = self.make_capitalization()
+		self.assertRaises(frappe.ValidationError, doc.validate_source_mandatory)
+
+	def test_target_item_must_be_a_fixed_asset(self):
+		# _Test Item is a stock item, not a fixed asset
+		doc = self.make_capitalization(target_item_code="_Test Item")
+		self.assertRaises(frappe.ValidationError, doc.validate_target_item)
+
+	def test_consumed_stock_row_rejects_a_non_stock_item(self):
+		doc = self.make_capitalization()
+		doc.append("stock_items", {"item_code": "_Test Non Stock Item", "stock_qty": 1})
+		self.assertRaises(frappe.ValidationError, doc.validate_consumed_stock_item)
+
+	def test_consumed_stock_row_requires_positive_qty(self):
+		doc = self.make_capitalization()
+		doc.append("stock_items", {"item_code": "_Test Item", "stock_qty": 0})
+		self.assertRaises(frappe.ValidationError, doc.validate_consumed_stock_item)
+
+	def test_service_row_rejects_a_stock_item(self):
+		doc = self.make_capitalization()
+		doc.append("service_items", {"item_code": "_Test Item", "qty": 1, "rate": 100})
+		self.assertRaises(frappe.ValidationError, doc.validate_service_item)
+
+	def test_service_row_requires_positive_qty_and_rate(self):
+		zero_qty = self.make_capitalization()
+		zero_qty.append("service_items", {"item_code": "_Test Non Stock Item", "qty": 0, "rate": 100})
+		self.assertRaises(frappe.ValidationError, zero_qty.validate_service_item)
+
+		zero_rate = self.make_capitalization()
+		zero_rate.append("service_items", {"item_code": "_Test Non Stock Item", "qty": 1, "rate": 0})
+		self.assertRaises(frappe.ValidationError, zero_rate.validate_service_item)

erpnext/assets/doctype/location/location.py

@@ -224,7 +224,7 @@ def get_children(doctype: str, parent: str | None = None, location: str | None =
 	)
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def add_node():
 	from frappe.desk.treeview import make_tree_args
 

erpnext/assets/workspace/assets/assets.json

@@ -13,7 +13,7 @@
  "doctype": "Workspace",
  "for_user": "",
  "hide_custom": 0,
- "icon": "assets",
+ "icon": "archive",
  "idx": 0,
  "is_hidden": 0,
  "label": "Assets",
@@ -199,9 +199,10 @@
    "type": "Link"
   }
  ],
- "modified": "2025-12-31 16:22:38.132729",
+ "modified": "2026-07-03 13:44:08.417956",
  "modified_by": "Administrator",
  "module": "Assets",
+ "module_onboarding": "Asset Onboarding",
  "name": "Assets",
  "number_cards": [],
  "owner": "Administrator",
@@ -212,6 +213,294 @@
  "roles": [],
  "sequence_id": 7.0,
  "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "house",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Home",
+   "link_to": "Assets",
+   "link_type": "Workspace",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "chart-column",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dashboard",
+   "link_to": "Asset",
+   "link_type": "Dashboard",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "laptop",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset",
+   "link_to": "Asset",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "trending-down",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Depreciation Schedule",
+   "link_to": "Asset Depreciation Schedule",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sprout",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Capitalization",
+   "link_to": "Asset Capitalization",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "move-horizontal",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Movement",
+   "link_to": "Asset Movement",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "rocket",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Maintenance",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Maintenance Team",
+   "link_to": "Asset Maintenance Team",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Maintenance",
+   "link_to": "Asset Maintenance",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Maintenance Log",
+   "link_to": "Asset Maintenance Log",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Value Adjustment",
+   "link_to": "Asset Value Adjustment",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Repair",
+   "link_to": "Asset Repair",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sheet",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Fixed Asset Register",
+   "link_to": "Fixed Asset Register",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Depreciation Ledger",
+   "link_to": "Asset Depreciation Ledger",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Depreciations and Balances",
+   "link_to": "Asset Depreciations and Balances",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Maintenance",
+   "link_to": "Asset Maintenance",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Activity",
+   "link_to": "Asset Activity",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item",
+   "link_to": "Item",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Asset Category",
+   "link_to": "Asset Category",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Location",
+   "link_to": "Location",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "settings",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Settings",
+   "link_to": "Accounts Settings",
+   "link_type": "DocType",
+   "navigate_to_tab": "assets_tab",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link",
+   "url": ""
+  }
+ ],
+ "standard": 1,
  "title": "Assets",
  "type": "Workspace"
 }

erpnext/buying/doctype/request_for_quotation/mapper.py

@@ -55,7 +55,7 @@ def make_supplier_quotation_from_rfq(
 
 
 # This method is used to make supplier quotation from supplier's portal.
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def create_supplier_quotation(doc: str | Document | dict):
 	doc = frappe.parse_json(doc)
 

erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py

@@ -185,7 +185,7 @@ def refresh_scorecards():
 			frappe.get_doc("Supplier Scorecard", sc_name).save()
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def make_all_scorecards(docname: str):
 	sc = frappe.get_doc("Supplier Scorecard", docname)
 	supplier = frappe.get_doc("Supplier", sc.supplier)

erpnext/buying/report/purchase_analytics/test_purchase_analytics.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import flt
+
+from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
+from erpnext.buying.report.purchase_analytics.purchase_analytics import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+COMPANY = "_Test Company"
+SUPPLIER = "_Test Supplier"
+SUPPLIER_GROUP = "_Test Supplier Group"
+# A historical window that ordinary test fixtures don't post into.
+FROM_DATE = "2019-04-01"
+TO_DATE = "2019-06-30"
+
+
+class TestPurchaseAnalytics(ERPNextTestSuite):
+	"""purchase_analytics reuses the shared Analytics engine; these tests lock its
+	wiring (doc_type=Purchase Order) across the Supplier Group / Item Group trees."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def _filters(self, **overrides):
+		filters = {
+			"doc_type": "Purchase Order",
+			"value_quantity": "Value",
+			"range": "Monthly",
+			"company": COMPANY,
+			"from_date": FROM_DATE,
+			"to_date": TO_DATE,
+		}
+		filters.update(overrides)
+		return frappe._dict(filters)
+
+	def _rows(self, filters):
+		return {row["entity"]: row for row in execute(filters)[1]}
+
+	def make_po(self, qty=4, rate=250):
+		return create_purchase_order(
+			company=COMPANY, supplier=SUPPLIER, qty=qty, rate=rate, transaction_date="2019-04-10"
+		)
+
+	def test_supplier_group_tree_rolls_up_to_root(self):
+		filters = self._filters(tree_type="Supplier Group")
+		base = self._rows(filters)
+		base_group = flt(base.get(SUPPLIER_GROUP, {}).get("total", 0.0))
+
+		po = self.make_po(qty=4, rate=250)
+		rows = self._rows(filters)
+
+		# supplier is remapped to its group; the root sits at indent 0
+		self.assertIn(SUPPLIER_GROUP, rows)
+		self.assertIn("All Supplier Groups", rows)
+		self.assertNotIn(SUPPLIER, rows)
+		self.assertEqual(rows["All Supplier Groups"]["indent"], 0)
+
+		self.assertAlmostEqual(rows[SUPPLIER_GROUP]["total"] - base_group, flt(po.base_net_total), places=2)
+		self.assertGreaterEqual(flt(rows["All Supplier Groups"]["total"]), flt(po.base_net_total))
+
+	def test_item_group_tree_rolls_up_to_root(self):
+		item_group = frappe.db.get_value("Item", "_Test Item", "item_group")
+		filters = self._filters(tree_type="Item Group")
+		base = self._rows(filters)
+		base_group = flt(base.get(item_group, {}).get("total", 0.0))
+
+		po = self.make_po(qty=4, rate=250)
+		rows = self._rows(filters)
+
+		self.assertIn(item_group, rows)
+		self.assertIn("All Item Groups", rows)
+		# the raw item code must not leak as its own entity; the root sits at indent 0
+		self.assertNotIn("_Test Item", rows)
+		self.assertEqual(rows["All Item Groups"]["indent"], 0)
+		self.assertAlmostEqual(rows[item_group]["total"] - base_group, flt(po.base_net_total), places=2)
+		self.assertGreaterEqual(flt(rows["All Item Groups"]["total"]), flt(po.base_net_total))
+
+	def test_supplier_group_by_quantity(self):
+		filters = self._filters(tree_type="Supplier Group", value_quantity="Quantity")
+		base = self._rows(filters)
+		base_qty = flt(base.get(SUPPLIER_GROUP, {}).get("total", 0.0))
+		base_root_qty = flt(base.get("All Supplier Groups", {}).get("total", 0.0))
+
+		po = self.make_po(qty=7, rate=100)
+		rows = self._rows(filters)
+
+		self.assertAlmostEqual(rows[SUPPLIER_GROUP]["total"] - base_qty, flt(po.total_qty), places=2)
+		# the quantity must roll up to the root too, not just the leaf group
+		self.assertAlmostEqual(
+			rows["All Supplier Groups"]["total"] - base_root_qty, flt(po.total_qty), places=2
+		)

erpnext/buying/report/subcontract_order_summary/test_subcontract_order_summary.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+from frappe.utils import add_days, today
+
+from erpnext.buying.report.subcontract_order_summary.subcontract_order_summary import execute
+from erpnext.controllers.tests.test_subcontracting_controller import (
+	get_subcontracting_order,
+	make_bom_for_subcontracted_items,
+	make_raw_materials,
+	make_service_items,
+	make_subcontracted_items,
+)
+from erpnext.tests.utils import ERPNextTestSuite
+
+FG_ITEM = "Subcontracted Item SA7"
+
+
+class TestSubcontractOrderSummary(ERPNextTestSuite):
+	"""The report lists Subcontracting Order finished items with their ordered and
+	received quantities within the transaction-date window."""
+
+	def setUp(self):
+		make_subcontracted_items()
+		make_raw_materials()
+		make_service_items()
+		make_bom_for_subcontracted_items()
+
+	def run_report(self, **extra):
+		filters = frappe._dict(
+			{"company": "_Test Company", "from_date": add_days(today(), -1), "to_date": add_days(today(), 1)}
+		)
+		filters.update(extra)
+		return execute(filters)[1]
+
+	def test_subcontracting_order_is_listed(self):
+		sco = get_subcontracting_order()
+
+		rows = [r for r in self.run_report(name=sco.name) if r.get("item_code") == FG_ITEM]
+		self.assertTrue(rows, "Subcontracting Order finished item missing from report")
+		self.assertEqual(rows[0]["qty"], 10)
+		self.assertEqual(rows[0]["received_qty"], 0)  # nothing received yet
+
+	def test_out_of_range_date_excludes_order(self):
+		sco = get_subcontracting_order()
+
+		data = self.run_report(name=sco.name, from_date="2019-01-01", to_date="2019-01-31")
+		self.assertEqual(data, [])

erpnext/buying/report/supplier_quotation_comparison/test_supplier_quotation_comparison.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+
+from erpnext.buying.report.supplier_quotation_comparison.supplier_quotation_comparison import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+COMPANY = "_Test Company"
+ITEM = "_Test Item"
+
+
+class TestSupplierQuotationComparison(ERPNextTestSuite):
+	"""The report lists Supplier Quotation item lines so quotes for the same item can
+	be compared across suppliers."""
+
+	def make_quotation(self, supplier, qty, rate, uom=None):
+		item = {"item_code": ITEM, "qty": qty, "rate": rate, "warehouse": "_Test Warehouse - _TC"}
+		if uom:
+			item["uom"] = uom
+		sq = frappe.get_doc(
+			{
+				"doctype": "Supplier Quotation",
+				"supplier": supplier,
+				"company": COMPANY,
+				"currency": "INR",
+				"transaction_date": "2026-06-01",
+				"items": [item],
+			}
+		)
+		sq.insert()
+		sq.submit()
+		return sq
+
+	def run_report(self, **extra):
+		filters = frappe._dict({"company": COMPANY, "from_date": "2026-01-01", "to_date": "2026-12-31"})
+		filters.update(extra)
+		return execute(filters)[1]
+
+	def test_no_filters_returns_empty(self):
+		self.assertEqual(execute(None)[1], [])
+
+	def test_quotation_line_listed_with_price(self):
+		# _Test UOM 1 converts at 10 stock units per qty, so price_per_unit
+		# (amount / stock_qty) diverges from base_rate and the division path is tested
+		sq = self.make_quotation("_Test Supplier", qty=10, rate=100, uom="_Test UOM 1")
+
+		rows = [r for r in self.run_report(item_code=ITEM) if r.get("quotation") == sq.name]
+		self.assertTrue(rows, "Supplier Quotation line missing from report")
+		row = rows[0]
+		self.assertEqual(row["supplier_name"], "_Test Supplier")
+		self.assertEqual(row["qty"], 10)
+		self.assertEqual(row["base_rate"], 100)
+		self.assertEqual(row["base_amount"], 1000)
+		# 1000 amount / (10 qty * 10 conversion) = 10, distinct from the 100 base_rate
+		self.assertEqual(row["price_per_unit"], 10)
+
+	def test_compares_multiple_suppliers_for_item(self):
+		sq1 = self.make_quotation("_Test Supplier", qty=10, rate=100)
+		sq2 = self.make_quotation("_Test Supplier 1", qty=10, rate=120)
+
+		quotes = {r["quotation"]: r for r in self.run_report(item_code=ITEM)}
+		self.assertIn(sq1.name, quotes)
+		self.assertIn(sq2.name, quotes)
+		self.assertEqual(quotes[sq1.name]["base_rate"], 100)
+		self.assertEqual(quotes[sq2.name]["base_rate"], 120)

erpnext/buying/workspace/buying/buying.json

@@ -13,7 +13,7 @@
  "doctype": "Workspace",
  "for_user": "",
  "hide_custom": 0,
- "icon": "buying",
+ "icon": "shopping-cart",
  "idx": 0,
  "is_hidden": 0,
  "label": "Buying",
@@ -341,17 +341,6 @@
    "onboard": 1,
    "type": "Link"
   },
-  {
-   "dependencies": "",
-   "hidden": 0,
-   "is_query_report": 1,
-   "label": "Item Wise Consumption",
-   "link_count": 0,
-   "link_to": "Item Wise Consumption",
-   "link_type": "Report",
-   "onboard": 1,
-   "type": "Link"
-  },
   {
    "dependencies": "",
    "hidden": 0,
@@ -512,9 +501,10 @@
    "type": "Link"
   }
  ],
- "modified": "2026-01-02 14:55:59.078773",
+ "modified": "2026-07-03 13:43:50.509039",
  "modified_by": "Administrator",
  "module": "Buying",
+ "module_onboarding": "Buying Onboarding",
  "name": "Buying",
  "number_cards": [
   {
@@ -538,6 +528,403 @@
  "roles": [],
  "sequence_id": 5.0,
  "shortcuts": [],
+ "sidebar_items": [
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "house",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Home",
+   "link_to": "Buying",
+   "link_type": "Workspace",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "chart-column",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Dashboard",
+   "link_to": "Buying",
+   "link_type": "Dashboard",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "notepad-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Material Request",
+   "link_to": "Material Request",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "git-pull-request-arrow",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Request for Quotation",
+   "link_to": "Request for Quotation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "book-open-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Quotation",
+   "link_to": "Supplier Quotation",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "receipt-text",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Order",
+   "link_to": "Purchase Order",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "scale",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Invoice",
+   "link_to": "Purchase Invoice",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "database",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Setup",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier",
+   "link_to": "Supplier",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Group",
+   "link_to": "Supplier Group",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "icon": "",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item",
+   "link_to": "Item",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Price List",
+   "link_to": "Price List",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Address",
+   "link_to": "Address",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Contacts",
+   "link_to": "Contact",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Scorecard",
+   "link_to": "Supplier Scorecard",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Scorecard Criteria",
+   "link_to": "Supplier Scorecard Criteria",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Scorecard Variable",
+   "link_to": "Supplier Scorecard Variable",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Scorecard Standing",
+   "link_to": "Supplier Scorecard Standing",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "sheet",
+   "indent": 1,
+   "keep_closed": 1,
+   "label": "Reports",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Section Break"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Analytics",
+   "link_to": "Purchase Analytics",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Order Analysis",
+   "link_to": "Purchase Order Analysis",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Requested Items to Order and Receive",
+   "link_to": "Requested Items to Order and Receive",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Items To Be Requested",
+   "link_to": "Items To Be Requested",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item-wise Purchase History",
+   "link_to": "Item-wise Purchase History",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Receipt Trends ",
+   "link_to": "Purchase Receipt Trends",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Invoice Trends",
+   "link_to": "Purchase Invoice Trends",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Purchase Order Trends",
+   "link_to": "Purchase Order Trends",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Procurement Tracker",
+   "link_to": "Procurement Tracker",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Item Wise Consumption",
+   "link_to": "Item Wise Consumption",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Quotation Comparison",
+   "link_to": "Supplier Quotation Comparison",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 1,
+   "collapsible": 1,
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Supplier Addresses And Contacts",
+   "link_to": "Address And Contacts",
+   "link_type": "Report",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  },
+  {
+   "child": 0,
+   "collapsible": 1,
+   "icon": "settings",
+   "indent": 0,
+   "keep_closed": 0,
+   "label": "Settings",
+   "link_to": "Buying Settings",
+   "link_type": "DocType",
+   "open_in_new_tab": 0,
+   "show_arrow": 0,
+   "type": "Link"
+  }
+ ],
+ "standard": 1,
  "title": "Buying",
  "type": "Workspace"
 }

erpnext/controllers/accounts_controller.py

@@ -1724,7 +1724,7 @@ def get_missing_company_details(doctype: str, docname: str):
 	}
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def update_company_master_and_address(current_doctype: str, name: str, company: str, details: dict | str):
 	from frappe.utils import validate_email_address
 

erpnext/controllers/queries.py

@@ -20,7 +20,7 @@ from frappe.query_builder.functions import (
 	Substring,
 	Sum,
 )
-from frappe.utils import nowdate, today, unique
+from frappe.utils import cint, nowdate, today, unique
 from pypika import Order
 
 import erpnext
@@ -808,7 +808,11 @@ def get_filtered_dimensions(
 		query_filters.append(["company", "=", filters.get("company")])
 
 	for field in searchfields:
-		or_filters.append([field, "LIKE", "%%%s%%" % txt])
+		df = meta.get_field(field)
+		if df and df.fieldtype != "Check":
+			or_filters.append([field, "LIKE", "%%%s%%" % txt])
+		else:
+			or_filters.append([field, "=", cint(txt)])
 		fields.append(field)
 
 	if dimension_filters:

erpnext/controllers/stock_controller.py

@@ -653,7 +653,7 @@ def check_item_quality_inspection(doctype: str, docstatus: str | int, items: str
 	return [item for item in items if item.get("item_code") in inspection_required_items]
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def make_quality_inspections(
 	company: str, doctype: str, docname: str, items: str | list, inspection_type: str
 ):

erpnext/crm/doctype/campaign/campaign.js

@@ -17,7 +17,7 @@ frappe.ui.form.on("Campaign", {
 					frappe.route_options = { utm_source: "Campaign", utm_campaign: frm.doc.name };
 					frappe.set_route("List", "Lead");
 				},
-				"fa fa-list",
+				null,
 				true
 			);
 		}

erpnext/crm/doctype/contract_template/test_contract_template.py

@@ -1,8 +1,43 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.crm.doctype.contract_template.contract_template import get_contract_template
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestContractTemplate(ERPNextTestSuite):
-	pass
+	"""Contract Template validates its Jinja terms and renders them against a doc."""
+
+	def test_malformed_contract_terms_are_rejected(self):
+		doc = frappe.new_doc("Contract Template")
+		doc.contract_terms = "{% for x in %}"  # invalid Jinja
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+		# a valid template, and no template at all, both pass
+		doc.contract_terms = "Party: {{ party_name }}"
+		doc.validate()
+		doc.contract_terms = None
+		doc.validate()
+
+	def test_get_contract_template_renders_terms(self):
+		template = frappe.get_doc(
+			{
+				"doctype": "Contract Template",
+				"title": "_Test Contract Template",
+				"contract_terms": "Party: {{ party_name }}",
+			}
+		).insert()
+
+		result = get_contract_template(template.name, {"party_name": "Acme"})
+		self.assertEqual(result["contract_terms"], "Party: Acme")
+		self.assertEqual(result["contract_template"].name, template.name)
+
+	def test_get_contract_template_without_terms_returns_none(self):
+		template = frappe.get_doc(
+			{"doctype": "Contract Template", "title": "_Test Empty Contract Template"}
+		).insert()
+
+		result = get_contract_template(template.name, {})
+		self.assertIsNone(result["contract_terms"])

erpnext/crm/doctype/crm_settings/test_crm_settings.py

@@ -1,9 +1,39 @@
-# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-# import frappe
+
+import frappe
 
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestCRMSettings(ERPNextTestSuite):
-	pass
+	"""CRM Settings guards its Frappe-CRM sync and Contact-Us opportunity toggles."""
+
+	def make_settings(self, **fields):
+		doc = frappe.new_doc("CRM Settings")
+		doc.update(fields)
+		return doc
+
+	def test_data_sync_requires_at_least_one_allowed_user(self):
+		doc = self.make_settings(enable_frappe_crm_data_synchronization=1)
+		self.assertRaises(frappe.ValidationError, doc.validate_allowed_users)
+		# adding a user satisfies the check
+		doc.append("allowed_users", {"user": "Administrator"})
+		doc.validate_allowed_users()
+
+	def test_disabling_sync_clears_allowed_users(self):
+		doc = self.make_settings(enable_frappe_crm_data_synchronization=0)
+		doc.append("allowed_users", {"user": "Administrator"})
+		doc.clear_allowed_users()
+		self.assertEqual(doc.allowed_users, [])
+
+		# while sync is on, the rows are kept
+		enabled = self.make_settings(enable_frappe_crm_data_synchronization=1)
+		enabled.append("allowed_users", {"user": "Administrator"})
+		enabled.clear_allowed_users()
+		self.assertEqual(len(enabled.allowed_users), 1)
+
+	@ERPNextTestSuite.change_settings("Contact Us Settings", {"is_disabled": 1})
+	def test_opportunity_from_contact_us_needs_the_form_enabled(self):
+		doc = self.make_settings(enable_opportunity_creation_from_contact_us=1)
+		self.assertRaises(frappe.ValidationError, doc.validate_enable_opportunity_creation_from_contact_us)

erpnext/crm/doctype/lead/lead.py

@@ -380,7 +380,7 @@ def get_lead_with_phone_number(number):
 	return lead
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def add_lead_to_prospect(lead: str, prospect: str):
 	prospect = frappe.get_doc("Prospect", prospect)
 	prospect.append("leads", {"lead": lead})

erpnext/crm/doctype/lead/mapper.py

@@ -110,7 +110,7 @@ def make_quotation(source_name: str, target_doc: str | Document | None = None):
 	return target_doc
 
 
-@frappe.whitelist()
+@frappe.whitelist(methods=["POST"])
 def make_lead_from_communication(communication: str, ignore_communication_links: bool = False):
 	"""raise a issue from email"""