@diy-accounting-uk/diya-gl 1.2.46 → 1.2.48

package/README.md

@@ -38,12 +38,15 @@ diya-gl recalc --package bst --data my-book --years se-2025-2026 --output-dir ou
 diya-gl read-workbook --file my-workbook.xlsx --output-dir out
 diya-gl write-workbook --data my-book --output-dir out
 diya-gl link my-book
+diya-gl new-book --product se --name "Lark Lane" --year-end 2027-04-05 --output-dir lark-lane
+diya-gl roll-forward --data my-book --output-dir next-year
 diya-gl view my-book
 diya-gl mcp
 ```
 
 Each subcommand is also its own command, if you only want one on your `PATH`:
-`diya-gl-recalc`, `diya-gl-read-workbook`, `diya-gl-write-workbook`, `diya-gl-link`, `diya-gl-view`, `diya-gl-mcp`.
+`diya-gl-recalc`, `diya-gl-read-workbook`, `diya-gl-write-workbook`, `diya-gl-link`, `diya-gl-new-book`,
+`diya-gl-roll-forward`, `diya-gl-view`, `diya-gl-mcp`.
 
 - **recalc** takes a diya-gl book (`--data`) or a populated workbook (`--source-dir`,
   `--mode saved|recalculate`) and writes `report.json`: every figure, report section and
@@ -58,6 +61,22 @@ Each subcommand is also its own command, if you only want one on your `PATH`:
   opens it, the whole book carried in the fragment so nothing is uploaded. `--base <url>`
   replaces the origin. The fragment length goes to stderr, with a warning past 64 KB (about
   2,000 lines), where chat, email and QR codes start to cut links off.
+- **new-book** starts an empty book for a new business: `--product` (`bst`, `se`, `taxi` or
+  `ltd`), `--name` and `--year-end` (YYYY-MM-DD), plus `--vat` for a VAT-registered Self
+  Employed or Company book. It writes `book.toml` (the product's starting chart of accounts,
+  the twelve months to the year end and that tax year's rates), an empty `lines.jsonl`,
+  `report.json` and `bookchecks.json` into `--output-dir`, the current directory by default.
+  It answers: how do I start books for a new business, what accounts does a new sole trader
+  or company book start with, and which tax rates apply to the first year?
+- **roll-forward** takes a book (`--data`, the same sources as **link**) and writes the next
+  year's into `--output-dir`: the year end a year on with that year's tax rates, the closing
+  balances as opening ones, and lines holding only the opening entries (a Company's opening
+  journal and one brought-forward line per bank account; a Self Employed book's bank lines).
+  Beside `book.toml`, `lines.jsonl`, `report.json` and `bookchecks.json` it writes
+  `rollchecks.json`, each opening figure the new year prints against the closing figure the old
+  year printed, and exits 1 when one disagrees. It answers: how do I start next year's books,
+  what do I bring forward from last year, and does my opening balance sheet agree with last
+  year's closing one?
 - **view** takes the same book sources as **link**, serves the full diya-gl pages on
   `127.0.0.1` (`--port <number>`, default a free port) and opens the book in your default
   browser (`--no-open` prints the address only). The pages are not in this package: the local
@@ -67,8 +86,9 @@ Each subcommand is also its own command, if you only want one on your `PATH`:
   another site. The book stays in the browser (the part of the address after `#` is never sent
   anywhere). The server stays up until Ctrl-C. The workbook templates come from
   spreadsheets.diyaccounting.co.uk the first time a page action needs one.
-- **mcp** runs a stdio [MCP](https://modelcontextprotocol.io) server with eight tools:
-  `extract_book`, `report`, `edit_lines`, `save_workbook`, and four that read every detail of
+- **mcp** runs a stdio [MCP](https://modelcontextprotocol.io) server with ten tools:
+  `extract_book`, `new_book` (the empty book **new-book** writes), `roll_forward` (the next
+  year **roll-forward** writes), `report`, `edit_lines`, `save_workbook`, and four that read every detail of
   the loaded book: `lines` (filter and group every transaction, e.g. best customer or spend on
   fuel in June), `chart` (the accounts and the report rows each feeds), `book` (the business,
   period, tax settings and registers) and `checks` (every book check with the entryNumbers
@@ -176,9 +196,10 @@ format text is CC BY 4.0, so you can implement the format in anything with attri
 The workbook templates are not part of this package. `write-workbook` and the MCP `save_workbook`
 tool fetch the template they need from
 [spreadsheets.diyaccounting.co.uk](https://spreadsheets.diyaccounting.co.uk) the first time they run,
-print the terms, and cache it for later runs. The templates are the company's own work, under the
-PolyForm Internal Use License 1.0.0 with an additional grant: use them for your own accounts, or for
-your clients' accounts if you are an accountant or a bookkeeper, and do not redistribute them.
+print the terms, and cache it for later runs of the same version. The templates are the company's
+own work, under the PolyForm Internal Use License 1.0.0 with an additional grant: use them for your
+own accounts, or for your clients' accounts if you are an accountant or a bookkeeper, and do not
+redistribute them.
 
 This repository does not accept contributions.
 

package/bin/diya-gl-new-book.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+//
+// diya-gl-new-book.js — start an empty book for a new business.
+
+import { runDistBin } from "./run-dist-bin.js";
+runDistBin("app/bin/new-book.js", process.argv.slice(2));

package/bin/diya-gl-roll-forward.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+//
+// diya-gl-roll-forward.js — start the next year of a book.
+
+import { runDistBin } from "./run-dist-bin.js";
+runDistBin("app/bin/roll-forward.js", process.argv.slice(2));

package/bin/diya-gl.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (C) 2006-2026 DIY Accounting Limited
 //
-// diya-gl.js — the dispatcher: diya-gl <recalc|read-workbook|write-workbook|link|view|mcp> [args].
+// diya-gl.js — the dispatcher: diya-gl <recalc|read-workbook|write-workbook|link|new-book|roll-forward|view|mcp> [args].
 // Each subcommand is also its own bin (diya-gl-recalc, and so on), for a
 // caller that wants one command on its PATH without the others.
 
@@ -17,6 +17,8 @@ const SUBCOMMANDS = {
   "read-workbook": "app/bin/export.js",
   "write-workbook": "app/bin/write-workbook.js",
   "link": "app/bin/link.js",
+  "new-book": "app/bin/new-book.js",
+  "roll-forward": "app/bin/roll-forward.js",
   "view": "app/bin/view.js",
   "mcp": "app/bin/diya-gl-mcp.js",
 };

package/dist/app/bin/export.js

@@ -253,6 +253,21 @@ function writeDiyaGlData(outputDir, book, lines) {
   console.log(`  book.toml: ${Object.keys(stamped).length} tables`);
 }
 
+/**
+ * A whole book directory from a (book, lines) pair already in hand: book.toml,
+ * lines.jsonl, report.json and bookchecks.json, written the way --file writes
+ * them. The new-book and roll-forward commands write their output through it.
+ * @param {string} outputDir
+ * @param {Object} book
+ * @param {Array} lines
+ */
+export async function writeBookDirectory(outputDir, book, lines) {
+  const product = productOf(book);
+  writeDiyaGlData(outputDir, book, lines);
+  writeReportJson(outputDir, buildFileReportDocument(book, lines, product, PRODUCTS[product]));
+  await writeBookChecksJson(outputDir, book, lines);
+}
+
 async function runFileMode(filePath, outputDirArg, packageName) {
   const resolvedFile = resolve(filePath);
   const resolvedOutput = resolve(outputDirArg || dirname(resolvedFile));

package/dist/app/bin/new-book.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+//
+// new-book.js — start an empty book for a new business: the product's
+// starting chart of accounts, the twelve months to the year end and that tax
+// year's rates, with no lines yet.
+//
+// Usage:
+//   node app/bin/new-book.js --product se --name "Lark Lane" --year-end 2027-04-05
+//   node app/bin/new-book.js --product ltd --name "Lark Lane Ltd" --year-end 2027-03-31 --vat --output-dir lark-lane
+//
+// Writes book.toml, lines.jsonl, report.json and bookchecks.json into
+// --output-dir, the current directory when none is given. It runs the MCP
+// server's new_book tool, so the command and the tool build the same book.
+
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { TOOLS, createSession } from "../lib/mcp/diya-gl-tools.js";
+import { writeBookDirectory } from "./export.js";
+
+const USAGE = [
+  "Usage: diya-gl new-book --product <bst|se|taxi|ltd> --name <business> --year-end <YYYY-MM-DD> [--vat] [--output-dir <dir>]",
+  "Answers: How do I start books for a new business? What accounts does a new sole trader or company book start with? Which tax rates apply to my first year?",
+].join("\n");
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const options = { vatRegistered: false, outputDir: "." };
+  const valueOf = (flag, index) => {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) throw new Error(`${flag} needs a value. ${USAGE}`);
+    return value;
+  };
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--product") options.product = valueOf(flag, i++);
+    else if (flag === "--name") options.businessName = valueOf(flag, i++);
+    else if (flag === "--year-end") options.yearEnd = valueOf(flag, i++);
+    else if (flag === "--output-dir") options.outputDir = valueOf(flag, i++);
+    else if (flag === "--vat") options.vatRegistered = true;
+    else throw new Error(`Unknown argument ${flag}. ${USAGE}`);
+  }
+  if (!options.product || !options.businessName || !options.yearEnd) throw new Error(USAGE);
+  return options;
+}
+
+async function main() {
+  const { outputDir, ...params } = parseArgs(process.argv);
+  const { book, lines, bookChecks } = await TOOLS.new_book.handler(createSession(), params);
+  const resolvedOutput = resolve(outputDir);
+  await writeBookDirectory(resolvedOutput, book, lines);
+  const { pass, warn, fail } = bookChecks.summary;
+  console.log(
+    `New ${params.product} book for ${book.entityInformation.organizationIdentifier}, ${book.documentInfo.periodCoveredStart} to ${book.documentInfo.periodCoveredEnd}, in ${resolvedOutput}: ${pass} checks pass, ${warn} warn, ${fail} fail`,
+  );
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}

package/dist/app/bin/roll-forward.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+//
+// roll-forward.js — start the next year of a book: the year end moves on a
+// year, the closing balances become the opening ones, and the lines hold only
+// the opening entries.
+//
+// Usage:
+//   node app/bin/roll-forward.js --data examples/brickwork-pro/ltd-nonvat --output-dir next-year
+//   node app/bin/roll-forward.js --data my-book-diya-gl.zip --output-dir next-year
+//
+// --data is a directory holding book.toml and lines.jsonl, or any diya-gl zip
+// or JSON file diya-gl-interchange.js reads. Writes book.toml, lines.jsonl,
+// report.json, bookchecks.json and rollchecks.json (each opening figure the
+// new year prints against the closing figure the old year printed for it)
+// into --output-dir. It runs the MCP server's roll_forward tool, so the
+// command and the tool roll the same book. Exits 1 when a roll check fails.
+
+import { existsSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { parseDiyaGlData } from "../lib/diya-gl-loader.js";
+import { readBookSource } from "../lib/diya-gl-interchange.js";
+import { PRODUCTS } from "../lib/products.js";
+import { TOOLS, createSession } from "../lib/mcp/diya-gl-tools.js";
+import { writeBookDirectory } from "./export.js";
+
+const USAGE = [
+  "Usage: diya-gl roll-forward --data <book directory | diya-gl zip | diya-gl JSON file> --output-dir <dir>",
+  "Answers: How do I start next year's books? What do I bring forward from last year? Does my opening balance sheet agree with last year's closing one?",
+].join("\n");
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i];
+    const value = args[i + 1];
+    if (flag !== "--data" && flag !== "--output-dir") throw new Error(`Unknown argument ${flag}. ${USAGE}`);
+    if (value === undefined || value.startsWith("--")) throw new Error(`${flag} needs a value. ${USAGE}`);
+    options[flag === "--data" ? "data" : "outputDir"] = value;
+    i++;
+  }
+  if (!options.data || !options.outputDir) throw new Error(USAGE);
+  return options;
+}
+
+async function readBook(source) {
+  const path = resolve(source);
+  if (!existsSync(path)) throw new Error(`${source} does not exist.`);
+  if (statSync(path).isDirectory()) {
+    return parseDiyaGlData(readFileSync(join(path, "book.toml"), "utf8"), readFileSync(join(path, "lines.jsonl"), "utf8"));
+  }
+  const { book, lines } = await readBookSource(readFileSync(path), source, { products: PRODUCTS });
+  return { book, lines };
+}
+
+async function main() {
+  const { data, outputDir } = parseArgs(process.argv);
+  const prior = await readBook(data);
+  const { book, lines, bookChecks, rollChecks } = await TOOLS.roll_forward.handler(createSession(), prior);
+  const resolvedOutput = resolve(outputDir);
+  await writeBookDirectory(resolvedOutput, book, lines);
+  writeFileSync(join(resolvedOutput, "rollchecks.json"), `${JSON.stringify(rollChecks, null, 2)}\n`);
+  const failing = rollChecks.filter((check) => check.result === "fail");
+  console.log(
+    `Rolled forward to ${book.documentInfo.periodCoveredStart} to ${book.documentInfo.periodCoveredEnd} in ${resolvedOutput}: ${lines.length} opening lines, ${bookChecks.summary.fail} book checks failing, ${failing.length} of ${rollChecks.length} roll checks failing`,
+  );
+  for (const check of failing) console.error(`  ${check.key}: expected ${check.expected}, the new year opens on ${check.actual}`);
+  if (failing.length > 0) process.exitCode = 1;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}

package/dist/app/bin/view.js

@@ -15,30 +15,16 @@
 // one directory per package version and origin host.
 
 import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
 import { tmpdir } from "os";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
+import { join, resolve } from "path";
 import { readBookFragment } from "./link.js";
 import { FRAGMENT_KEY } from "../lib/diya-gl-link.js";
 import { DEFAULT_ORIGIN, startViewServer } from "../lib/diya-gl-view-server.js";
+import { packageVersion } from "../lib/package-version.js";
 
 const USAGE =
   "Usage: diya-gl view <book directory | diya-gl zip | diya-gl JSON file | workbook> [--port <number>] [--origin <url>] [--no-open]";
 
-// The nearest package.json above this file: the package's own in dist/, the
-// repository's in a checkout. Both carry the version the cache is keyed on.
-function packageVersion() {
-  let directory = dirname(fileURLToPath(import.meta.url));
-  for (;;) {
-    const candidate = join(directory, "package.json");
-    if (existsSync(candidate)) return JSON.parse(readFileSync(candidate, "utf8")).version;
-    const parent = dirname(directory);
-    if (parent === directory) throw new Error("No package.json found above " + import.meta.url);
-    directory = parent;
-  }
-}
-
 function parseArgs(argv) {
   const args = argv.slice(2);
   let port = 0;
@@ -86,7 +72,7 @@ function openInBrowser(url) {
 async function main() {
   const { source, port, origin, open } = parseArgs(process.argv);
   const { product, fragment, length, warning } = await readBookFragment(source);
-  const cacheDir = join(tmpdir(), "diya-gl-view", packageVersion(), new URL(origin).host.replace(/[^A-Za-z0-9.-]/g, "_"));
+  const cacheDir = join(tmpdir(), "diya-gl-view", await packageVersion(), new URL(origin).host.replace(/[^A-Za-z0-9.-]/g, "_"));
   const running = await startViewServer({ cacheDir, origin, port });
   const url = `http://${running.host}:${running.port}/${product}.html#${FRAGMENT_KEY}=${fragment}`;
   console.log(url);

package/dist/app/data/filing/ct-computation-v1.1.toml

@@ -167,7 +167,7 @@ section = 1
 part = 2
 partName = "Section 1 Part 2: Accounting Non-Taxable Income Deducted"
 label = "Non-trading loan relationship credit"
-xbrl = "AdjustmentsNon-tradingLoanRelationshipsCreditsPerAccounts"
+xbrl = "AdjustmentsNon-tradingLoanRelationshipCreditsPerAccounts"
 sheetCell = "Financialaccounts.xlsx!CorporationTax!K24"
 note = "Bank interest: the plan's Ltd view moves this to CT600 box 170 rather than adding it back in the trading computation."
 
@@ -432,7 +432,7 @@ section = 1
 part = 3
 partName = "Section 1 Part 3: Accounting Disallowable Expenditure Addback"
 label = "Non-trading loan relationship debit"
-xbrl = "AdjustmentsNon-tradingLoanRelationshipsDebitsPerAccounts"
+xbrl = "AdjustmentsNon-tradingLoanRelationshipDebitsPerAccounts"
 
 [[line]]
 section = 1

package/dist/app/data/filing/ct600-v3.toml

@@ -1283,6 +1283,8 @@ label = "Tax already paid (and not already repaid)"
 section = "Tax reconciliation"
 format = "pounds-and-pence"
 element = "TaxAlreadyPaid"
+status = "entry-on-this-template"
+statusNote = "CT600!AJ163 is an entry cell with no formula: the company types what it has paid, and no book figure feeds it"
 xmlPath = "/IRenvelope/CompanyTaxReturn/TaxReconciliation/TaxAlreadyPaid"
 sheetCell = "Financialaccounts.xlsx!CT600!AJ163"
 

package/dist/app/data/releases.json

@@ -1429,6 +1429,58 @@
           "scorecard": "101605 passed, 0 warnings, 0 failed"
         }
       }
+    },
+    {
+      "tag": "diya-gl-v1.2.46",
+      "date": "2026-10-05",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.46+f38ebcb4",
+      "taxDataHash": "89424bd36c0d",
+      "reconciledCommit": "54e8731a91279975e61b1a232fbb67fda89515f0",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "700 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "064605ae76ed",
+          "scorecard": "8015 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "ab3dc062e15f",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
+    },
+    {
+      "tag": "diya-gl-v1.2.47",
+      "date": "2026-10-05",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.47+26b9e6ec",
+      "taxDataHash": "51bdff60e993",
+      "reconciledCommit": "54e8731a91279975e61b1a232fbb67fda89515f0",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "700 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "064605ae76ed",
+          "scorecard": "8015 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "a65ab09cf35c",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
     }
   ]
 }

package/dist/app/data/se-2027-2028.toml

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2006-2026 DIY Accounting Limited
+# UK self-employment tax rates and thresholds for the 2027-28 tax year
+# Period: 6 April 2027 – 5 April 2028
+# Source: HMRC. Class 2 weekly rate and small profits threshold carried forward from 2026-27 (not yet published)
+
+[tax_year]
+label = "2027-28"
+next_label = "2028-29"
+start = 2027-04-06
+end = 2028-04-05
+
+[income_tax]
+personal_allowance = 12570
+starting_rate = 0.00
+basic_rate = 0.20
+higher_rate = 0.40
+starter_band_end = 0
+basic_band_end = 37700
+higher_band_start = 37701
+higher_band_end = 125140
+additional_rate = 0.45
+personal_allowance_taper_threshold = 100000
+
+[national_insurance]
+class2_rate = 3.65
+class4_lower_rate = 0.06
+class4_lower_limit = 12570
+class4_upper_rate = 0.02
+class4_upper_limit = 50270
+class2_weekly_rate = 3.65
+class2_small_profits_threshold = 7105
+
+[capital_allowances]
+annual_investment_allowance = 1.00
+writing_down_allowance = 0.14
+writing_down_allowance_special = 0.06
+structures_and_buildings_allowance = 0.03
+structures_and_buildings_allowance_enhanced = 0.10
+
+[depreciation]
+land_and_property = 0.00
+plant_and_machinery = 0.10
+fixtures_and_fittings = 0.20
+computer_equipment = 0.33
+motor_vehicles = 0.25
+
+# Approved mileage rates: gov.uk "Travel - mileage and fuel rates and allowances", cars and vans, tax year 2026 to 2027, unchanged for 2027-28: 55p first 10,000 miles, 25p after.
+[mileage]
+higher_rate_limit = 10000
+higher_rate_pence = 0.55
+lower_rate_start = 10001
+lower_rate_pence = 0.25
+
+[vat]
+registration_threshold = 90000
+standard_rate = 0.20

package/dist/app/lib/app-resources.js

@@ -19,6 +19,8 @@
 // Node's own modules load on the first read rather than with this file, so a
 // bundle whose caller supplies a loader never pulls them in.
 
+import { packageVersion } from "./package-version.js";
+
 // The resource space is app/ with one named exception. The two v2 schemas are
 // published by the site, not carried in app/, and the site serves them at
 // /schema/ — so "schema/" is a root of its own rather than a directory under
@@ -31,7 +33,10 @@ const SCHEMA_ROOT_FROM_APP = ["..", "web", "spreadsheets.diyaccounting.co.uk", "
 // checkout has app/templates and reads it straight off disk. A packaged install
 // has not, so the loader takes the same file from the site, which already
 // serves the templates the DIYA-GL pages use, and keeps it in a user cache so
-// every later run works with no network.
+// every later run of the same version works with no network. The cache is keyed
+// on the package version and the source host, because the anchors the reader
+// checks a package against move with the version: a template cached by an
+// older version writes a package the newer reader refuses.
 //
 // Both the current /diya-gl/ and legacy /books/ paths resolve — the old one
 // through a redirect — so published versions built before the path moved keep
@@ -71,11 +76,12 @@ async function fetchTemplate(path) {
   const { dirname, resolve } = await import("path");
   const { homedir } = await import("os");
 
+  const source = templateSource();
   const cacheRoot = process.env.XDG_CACHE_HOME || resolve(homedir(), ".cache");
-  const cached = resolve(cacheRoot, "diya-gl", path);
+  const sourceHost = new URL(source).host.replace(/[^A-Za-z0-9.-]/g, "_");
+  const cached = resolve(cacheRoot, "diya-gl", await packageVersion(), sourceHost, path);
   if (existsSync(cached)) return readFileSync(cached);
 
-  const source = templateSource();
   announceTemplateTerms(source);
 
   const url = `${source}/${path}`;

package/dist/app/lib/calculators/bst.js

@@ -13,7 +13,7 @@ import { calculateIncomeTax } from "../tax/income-tax.js";
 import { calculateNIClass4 } from "../tax/national-insurance.js";
 import { calculateMileageAllowance, scenarioBusinessMiles } from "../tax/mileage.js";
 import { aggregateByCode } from "./shared.js";
-import { attributionWriter, entriesOf } from "../entry-attribution.js";
+import { attributionWriter, entriesOf, entryOf } from "../entry-attribution.js";
 
 const BST_MONTH_COLS = {
   apr: "D",
@@ -87,6 +87,22 @@ function outstandingTotal(transactions) {
  * @param {Object} [attribution] - filled in place with the entryNumbers behind each cell (entry-attribution.js)
  * @returns {Object} { "SheetName": { "CellRef": value } }
  */
+/**
+ * Each fixed asset bought in the year beside the tax written-down value the
+ * Fixed Assets sheet carries forward for it: the pool a book rolled forward
+ * brings into its next year.
+ * @param {Object} scenario - diyaGlToScenario's output
+ * @param {Object} taxData
+ * @returns {Array<{entryNumber: string, cost: number, writtenDownValue: number}>}
+ */
+export function bstAdditionsWrittenDown(scenario, taxData) {
+  return fixedAssetAdditions(scenario, "f").map((asset) => ({
+    entryNumber: entryOf(asset),
+    cost: asset.cost,
+    writtenDownValue: calculateFixedAssetSchedule([asset], taxData).M1,
+  }));
+}
+
 export function calculateBstResults(book, lines, taxData, scenario, attribution) {
   // A book's own declared chart can number its purchase accounts under a
   // scheme other than the Basic Sole Trader master's own (see

package/dist/app/lib/calculators/ltd.js

@@ -508,6 +508,7 @@ function buildSchedule(scenario, rate, depreciationRates, investmentAllowancePer
       assetClass: asset.category,
       row,
       acquiredInYear: false,
+      openingAsset: asset,
       cost: asset.cost,
       depreciationBroughtForward: asset.acc_dep || 0,
       taxWrittenDownValue: asset.tax_wdv || 0,
@@ -525,6 +526,7 @@ function buildSchedule(scenario, rate, depreciationRates, investmentAllowancePer
         assetClass: SCHEDULE_NEW_ASSET_CLASS,
         row,
         acquiredInYear: true,
+        entryNumber: entryOf(transaction),
         purchasedOn: serialOf(parseDate(transaction.date)),
         description: transaction.supplier,
         cost: writerNet(transaction.amount, rate),
@@ -767,13 +769,7 @@ function computeLtd(book, lines, taxData, scenario, attribution) {
     results[`${fileName}!${tabs[11]}`] = { A1: openingOfLastMonth, A2: balance };
   }
 
-  const depreciationRates = {
-    land: taxData.depreciation?.land_and_property ?? 0,
-    plant: taxData.depreciation?.plant_and_machinery ?? 0,
-    fixtures: taxData.depreciation?.fixtures_and_fittings ?? 0,
-    computer: taxData.depreciation?.computer_equipment ?? 0,
-    motor: taxData.depreciation?.motor_vehicles ?? 0,
-  };
+  const depreciationRates = depreciationRatesOf(taxData);
   const openingBalance = scenario.opening_balance || {};
   const scheduleRowEntries = attribution ? new Map() : null;
   const scheduleRows = buildSchedule(scenario, rate, depreciationRates, admin.G5, admin.G6, scheduleRowEntries);
@@ -961,6 +957,33 @@ function computeLtd(book, lines, taxData, scenario, attribution) {
  * @param {Object} [attribution] - filled in place with the entryNumbers behind each cell (entry-attribution.js)
  * @returns {Object} { "SheetName": { "CellRef": value } }
  */
+function depreciationRatesOf(taxData) {
+  return {
+    land: taxData.depreciation?.land_and_property ?? 0,
+    plant: taxData.depreciation?.plant_and_machinery ?? 0,
+    fixtures: taxData.depreciation?.fixtures_and_fittings ?? 0,
+    computer: taxData.depreciation?.computer_equipment ?? 0,
+    motor: taxData.depreciation?.motor_vehicles ?? 0,
+  };
+}
+
+/**
+ * Each Schedule row's own figures, beside the asset it holds: an asset
+ * brought forward (openingAsset, one of scenario.opening_fixed_assets) or the
+ * purchase line that bought it in the year (entryNumber). Rolling a book
+ * forward reads its carried forward cost, depreciation and tax written-down
+ * value from here.
+ * @param {Object} book
+ * @param {Object} taxData
+ * @param {Object} scenario - diyaGlToScenario's output
+ * @returns {Array<Object>} the rows buildSchedule computes
+ */
+export function ltdScheduleRows(book, taxData, scenario) {
+  const rate = scenario?.metadata?.vat_registered === false ? 0 : VAT_RATE;
+  const admin = buildAdmin(taxData, periodFrom(book), scenario.business?.associated_companies ?? 0);
+  return buildSchedule(scenario, rate, depreciationRatesOf(taxData), admin.G5, admin.G6);
+}
+
 export function calculateLtdResults(book, lines, taxData, scenario, attribution) {
   return computeLtd(book, lines, taxData, scenario, attribution).results;
 }
@@ -1996,8 +2019,11 @@ function buildCt600(corporationTax, pl, admin) {
   if (corporationTax.K26 > 0) sheet.Z72 = corporationTax.K26;
   if (corporationTax.K24 > 0) sheet.AJ76 = corporationTax.K24;
   sheet.AJ74 = (sheet.Z70 || 0) - (sheet.Z72 || 0);
-  sheet.AJ92 = sheet.AJ74 > 0 ? sheet.AJ74 + (sheet.AJ76 || 0) : 0;
-  sheet.AJ110 = sheet.AJ92;
+  sheet.AJ92 = Math.max(sheet.AJ74, 0) + (sheet.AJ76 || 0);
+  // A trading loss of the year meets the interest it can reach, as the working
+  // sheet's chargeable profit nets them, so box 30 carries what was set off.
+  if (corporationTax.K22 < 0 && corporationTax.K24 > 0) sheet.Z98 = Math.min(-corporationTax.K22, corporationTax.K24);
+  sheet.AJ110 = sheet.AJ92 - (sheet.Z98 || 0);
   sheet.AJ131 = sheet.AJ126 + sheet.AJ128;
   sheet.Y133 = corporationTax.marginalRelief;
   sheet.Y135 = corporationTax.K35;
@@ -2511,7 +2537,8 @@ function attributeLtdResults(attribution, context) {
   a.set(CT600, "AJ76", a.get(CT, "K24"));
   a.set(CT600, "AJ74", a.cells(CT600, "Z70", "Z72"));
   a.set(CT600, "AJ92", a.cells(CT600, "AJ74", "AJ76"));
-  a.set(CT600, "AJ110", a.get(CT600, "AJ92"));
+  a.set(CT600, "Z98", unionOf(a.get(CT, "K22"), a.get(CT, "K24")));
+  a.set(CT600, "AJ110", a.cells(CT600, "AJ92", "Z98"));
   a.set(CT600, "AJ131", a.cells(CT600, "AJ126", "AJ128"));
   a.set(CT600, "Y133", charged);
   a.set(CT600, "Y135", a.get(CT, "K35"));

package/dist/app/lib/calculators/se.js

@@ -660,6 +660,7 @@ function buildSchedule(scenario, taxData, rate, entries) {
   });
 
   const existingRows = [];
+  const existingAssets = [];
   const existingRowEntries = [];
   // The motor rows' own single asset pool cells, keyed by cell reference:
   // the private use share the writer puts in M, the marker in AD, and the
@@ -681,6 +682,7 @@ function buildSchedule(scenario, taxData, rate, entries) {
         disposal: disposalByAsset.get(asset),
       });
       existingRows.push(row);
+      existingAssets.push(asset);
       existingRowEntries.push({ asset: new Set(), disposal: disposalEntries.get(disposalByAsset.get(asset)) ?? new Set() });
       if (category === "motor") {
         const rowNumber = block.rows[index];
@@ -706,7 +708,24 @@ function buildSchedule(scenario, taxData, rate, entries) {
       SCHEDULE_TOTAL_COLUMNS.map((column) => [column, unionOf(entries.existing[column], entries.additions[column])]),
     );
   }
-  return { existing, additions, totals: addScheduleTotals(existing, additions), motorRowCells };
+  const register = [
+    ...existingRows.map((row, index) => ({ openingAsset: existingAssets[index], row })),
+    ...newRows.map((row, index) => ({ entryNumber: entryOf(capitalPurchases[index]), row })),
+  ];
+  return { existing, additions, totals: addScheduleTotals(existing, additions), motorRowCells, register };
+}
+
+/**
+ * Each Schedule row's own figures, beside the asset it holds: an asset
+ * brought forward (one of scenario.opening_fixed_assets) or the purchase line
+ * that bought it in the year. Rolling a book forward reads its carried
+ * forward cost, depreciation and tax written-down value from here.
+ * @param {Object} scenario - diyaGlToScenario's output
+ * @param {Object} taxData
+ * @returns {Array<{openingAsset?: Object, entryNumber?: string, row: Object}>}
+ */
+export function seScheduleRegister(scenario, taxData) {
+  return buildSchedule(scenario, taxData, vatRateFor(scenario)).register;
 }
 
 // ── Structures and Buildings Allowance (SA103F boxes 53 and 53.1) ──────────