@fin.cx/skr 3.1.0 → 3.3.0

package/ts/core/core.datev.ts

@@ -7,13 +7,20 @@
  * STRING with CRLF; persisting it as CP1252 is the IO layer's job.
  * One manual import into real DATEV per release candidate remains the final
  * conformance gate (readme.plan.md, M0).
+ *
+ * A DATEV row is one Buchungssatz: the amount is booked on Konto with the
+ * Soll/Haben mark and on Gegenkonto with the opposite side. A journal draft
+ * is a balanced set of lines, so it is consolidated into bookings before it
+ * is written (see journalDraftsToDatevRows); writing one row per line would
+ * book every draft twice on import.
  */
 import * as plugins from './core.plugins.js';
-import type { IJournalDraft, TBuKey, TCents } from './core.types.js';
+import type { IJournalDraft, IJournalLineDraft, TBuKey, TCents, TLineSide } from './core.types.js';
+import { getDefaultPolicy, isAutomatikAccount, type IAccountPolicy } from './core.accountpolicy.js';
 import { DATEV_COLUMN_CAPTIONS } from './core.datev.captions.js';
 import { DATEV_MAX_BELEGFELD, DATEV_MAX_BUCHUNGSTEXT } from './core.validate.js';
 
-const { centsToString } = plugins.calculation;
+const { allocateCents, centsToString } = plugins.calculation;
 
 export const DATEV_COLUMN_COUNT = 125;
 export const DATEV_HEADER_FIELD_COUNT = 31;
@@ -28,6 +35,7 @@ export interface IDatevBuchungsstapelRow {
   belegfeld1?: string;
   belegfeld2?: string;
   buchungstext: string;
+  /** document GUID; written as `BEDI "GUID"` (field 20) */
   belegLink?: string;
   kost1?: string;
   kost2?: string;
@@ -84,17 +92,189 @@ function quote(value: string, maxLength?: number): string {
   return `"${sanitized}"`;
 }
 
+export interface IDatevRowsOptions {
+  festschreibung?: boolean;
+  /**
+   * Recognises VAT lines and Automatikkonten while consolidating; defaults to
+   * the default policy of each draft's chart.
+   */
+  policy?: IAccountPolicy;
+}
+
+/** Domestic tax keys whose row carries the gross amount; DATEV computes the VAT. */
+const VAT_RATE_OF_KEY: Partial<Record<TBuKey, number>> = { '9': 19, '8': 7, '3': 19, '2': 7 };
+
+function isVatAccount(policy: IAccountPolicy, accountNumber: string): boolean {
+  return Object.values(policy.vat).includes(accountNumber);
+}
+
+/** Rate of a domestic VAT account; intra-EU and §13b accounts only ever appear as pairs. */
+function vatRateOfAccount(policy: IAccountPolicy, accountNumber: string): number | undefined {
+  const { vat } = policy;
+  if (accountNumber === vat.inputStandard || accountNumber === vat.outputStandard) return 19;
+  if (accountNumber === vat.inputReduced || accountNumber === vat.outputReduced) return 7;
+  return undefined;
+}
+
+function signedCents(line: IJournalLineDraft): TCents {
+  return line.side === 'debit' ? line.amountCents : -line.amountCents;
+}
+
+function mirrors(left: IJournalLineDraft, right: IJournalLineDraft): boolean {
+  return (
+    left.counterAccount === right.accountNumber &&
+    right.counterAccount === left.accountNumber &&
+    signedCents(left) + signedCents(right) === 0
+  );
+}
+
+/** Keys that make DATEV compute a self-assessed VAT pair (input against output VAT). */
+function selfAssessedKeysOf(policy: IAccountPolicy, accountA: string, accountB: string): TBuKey[] | undefined {
+  if (accountA === accountB) return undefined;
+  const reverseCharge = [policy.vat.reverseChargeInput, policy.vat.reverseChargeOutput];
+  const intraEu = [policy.vat.intraEuAcqInput, policy.vat.intraEuAcqOutput];
+  if (reverseCharge.includes(accountA) && reverseCharge.includes(accountB)) return ['94', '91'];
+  if (intraEu.includes(accountA) && intraEu.includes(accountB)) return ['19', '18'];
+  return undefined;
+}
+
+/**
+ * Consolidate one balanced draft into the lines that become DATEV bookings.
+ *
+ * 1. VAT lines. A §13b / intra-EU pair (input and output VAT booked against
+ *    each other) is dropped when a base line of the draft carries the key
+ *    that makes DATEV compute both sides (94/91, 19/18); without such a key
+ *    the pair stays and becomes one explicit booking. Domestic VAT lines are
+ *    folded, per Gegenkonto and side, into the base lines whose BU key
+ *    carries their rate (9/8, 3/2), sharing the VAT in proportion; a VAT
+ *    line without a keyed base is folded into an Automatikkonto base (key
+ *    40 becomes '') only when it is the single remaining VAT line and that
+ *    base is the single Automatikkonto candidate, because the policy does
+ *    not know the rate of an Automatikkonto. Everything else stays an
+ *    explicit booking on the tax account, next to a base that keeps key 40.
+ * 2. Mirror lines (A against B and B against A with the same amount) become
+ *    one booking, taken from the line with a BU key, else from the debit line.
+ * 3. Split lines against one aggregate line (their signed sum cancels the
+ *    aggregate) become one booking each; the aggregate line is dropped.
+ * Anything left over throws: writing it would double the booking on import.
+ */
+export function consolidateJournalDraftForDatev(
+  draft: IJournalDraft,
+  policy: IAccountPolicy,
+): IJournalLineDraft[] {
+  const lines: IJournalLineDraft[] = draft.lines
+    .map((line) =>
+      line.amountCents < 0
+        ? { ...line, amountCents: -line.amountCents, side: (line.side === 'debit' ? 'credit' : 'debit') as TLineSide }
+        : { ...line },
+    )
+    .filter((line) => line.amountCents !== 0);
+  const consumed = new Set<number>();
+  const open = (): number[] => lines.map((_, index) => index).filter((index) => !consumed.has(index));
+  const isVat = (index: number): boolean => isVatAccount(policy, lines[index].accountNumber);
+
+  // 1a self-assessed VAT pairs
+  for (const i of open()) {
+    if (consumed.has(i) || !isVat(i)) continue;
+    for (const j of open()) {
+      if (j <= i || !isVat(j) || !mirrors(lines[i], lines[j])) continue;
+      const keys = selfAssessedKeysOf(policy, lines[i].accountNumber, lines[j].accountNumber);
+      if (keys && open().some((k) => !isVat(k) && keys.includes(lines[k].buKey))) {
+        consumed.add(i);
+        consumed.add(j);
+      }
+      break;
+    }
+  }
+  // 1b domestic VAT lines folded into their base lines, per Gegenkonto and side
+  const fold = (vatIndex: number, bases: number[], clearKey: boolean): void => {
+    const shares = allocateCents(lines[vatIndex].amountCents, bases.map((j) => lines[j].amountCents));
+    bases.forEach((j, position) => {
+      lines[j] = { ...lines[j], amountCents: lines[j].amountCents + shares[position], buKey: clearKey ? '' : lines[j].buKey };
+    });
+    consumed.add(vatIndex);
+  };
+  const groups = new Map<string, number[]>();
+  for (const i of open()) {
+    if (!isVat(i) || vatRateOfAccount(policy, lines[i].accountNumber) === undefined) continue;
+    const key = `${lines[i].counterAccount}|${lines[i].side}`;
+    groups.set(key, [...(groups.get(key) ?? []), i]);
+  }
+  for (const [key, vatLines] of groups) {
+    const bases = open().filter((j) => !isVat(j) && `${lines[j].counterAccount}|${lines[j].side}` === key);
+    const remaining: number[] = [];
+    for (const i of vatLines) {
+      const rate = vatRateOfAccount(policy, lines[i].accountNumber);
+      const keyed = bases.filter((j) => VAT_RATE_OF_KEY[lines[j].buKey] === rate);
+      if (keyed.length === 0) {
+        remaining.push(i);
+        continue;
+      }
+      fold(i, keyed, false);
+    }
+    const automatik = bases.filter(
+      (j) => isAutomatikAccount(policy, lines[j].accountNumber) && (lines[j].buKey === '' || lines[j].buKey === '40'),
+    );
+    if (remaining.length === 1 && automatik.length === 1) {
+      fold(remaining[0], automatik, true);
+    }
+  }
+
+  const bookings: IJournalLineDraft[] = [];
+  // 2 mirror lines
+  for (const i of open()) {
+    if (consumed.has(i)) continue;
+    for (const j of open()) {
+      if (j <= i) continue;
+      if (mirrors(lines[i], lines[j])) {
+        const keep = lines[i].buKey !== '' ? i : lines[j].buKey !== '' ? j : lines[i].side === 'debit' ? i : j;
+        bookings.push(lines[keep]);
+        consumed.add(i);
+        consumed.add(j);
+        break;
+      }
+    }
+  }
+  // 3 split lines against their aggregate line
+  for (const aggregateIndex of open()) {
+    if (consumed.has(aggregateIndex)) continue;
+    const aggregate = lines[aggregateIndex];
+    const group = open().filter((index) => index !== aggregateIndex && lines[index].counterAccount === aggregate.accountNumber);
+    if (group.length === 0) continue;
+    if (signedCents(aggregate) + group.reduce((sum, index) => sum + signedCents(lines[index]), 0) !== 0) continue;
+    for (const index of group) {
+      bookings.push(lines[index]);
+      consumed.add(index);
+    }
+    consumed.add(aggregateIndex);
+  }
+
+  const leftover = open();
+  if (leftover.length > 0) {
+    const detail = leftover
+      .map((index) => `line ${index + 1} (${lines[index].accountNumber} ${lines[index].side} ${lines[index].amountCents} against ${lines[index].counterAccount})`)
+      .join(', ');
+    const when = draft.date instanceof Date && !Number.isNaN(draft.date.getTime()) ? draft.date.toISOString().slice(0, 10) : 'undated';
+    throw new Error(
+      `Journal draft "${draft.description}" (${when}${draft.reference ? `, ${draft.reference}` : ''}) cannot be written as DATEV bookings: ${detail} has no counter line`,
+    );
+  }
+  return bookings;
+}
+
 /**
- * Flatten journal drafts into DATEV rows — one row per line, with the line's
- * explicit counterAccount as Gegenkonto (no pair reconstruction).
+ * Convert journal drafts into DATEV rows: one row per booking after
+ * consolidateJournalDraftForDatev, with the line's counterAccount as
+ * Gegenkonto.
  */
 export function journalDraftsToDatevRows(
   drafts: IJournalDraft[],
-  options?: { festschreibung?: boolean },
+  options?: IDatevRowsOptions,
 ): IDatevBuchungsstapelRow[] {
   const rows: IDatevBuchungsstapelRow[] = [];
   for (const draft of drafts) {
-    for (const line of draft.lines) {
+    const policy = options?.policy ?? getDefaultPolicy(draft.skrType);
+    for (const line of consolidateJournalDraftForDatev(draft, policy)) {
       rows.push({
         umsatzCents: line.amountCents,
         sollHaben: line.side === 'debit' ? 'S' : 'H',
@@ -115,6 +295,16 @@ export function journalDraftsToDatevRows(
   return rows;
 }
 
+/** Field 20 links a document image: `BEDI "GUID"`, quotes doubled inside the CSV field. */
+function formatBelegLink(value: string): string {
+  const guid = value
+    .trim()
+    .replace(/^BEDI\s*/iu, '')
+    .replace(/^"+|"+$/gu, '')
+    .replace(/"/g, "'");
+  return `"BEDI ""${guid}"""`;
+}
+
 function rowToFields(row: IDatevBuchungsstapelRow): string[] {
   const fields = new Array<string>(DATEV_COLUMN_COUNT).fill('');
   fields[0] = formatAmount(row.umsatzCents); // 1 Umsatz
@@ -126,7 +316,7 @@ function rowToFields(row: IDatevBuchungsstapelRow): string[] {
   if (row.belegfeld1) fields[10] = quote(row.belegfeld1, DATEV_MAX_BELEGFELD); // 11
   if (row.belegfeld2) fields[11] = quote(row.belegfeld2, DATEV_MAX_BELEGFELD); // 12
   fields[13] = quote(row.buchungstext, DATEV_MAX_BUCHUNGSTEXT); // 14 Buchungstext
-  if (row.belegLink) fields[19] = quote(row.belegLink); // 20 Beleglink
+  if (row.belegLink) fields[19] = formatBelegLink(row.belegLink); // 20 Beleglink
   if (row.kost1) fields[36] = quote(row.kost1); // 37 KOST1
   if (row.kost2) fields[37] = quote(row.kost2); // 38 KOST2
   if (row.festschreibung !== undefined) fields[113] = row.festschreibung ? '1' : '0'; // 114

package/ts/index.ts

@@ -26,6 +26,12 @@ export {
   setOposMeta,
 } from './skr.opos.js';
 export type { IOpenItem, IAgingBucket, IControlTotals, TOposKind } from './skr.opos.js';
+export { getUstvaPeriodData } from './skr.ustva.js';
+export type {
+  IUstvaPeriodData,
+  IUstvaMovement,
+  IUstvaScenarioBases,
+} from './skr.ustva.js';
 export { verifyHashChain } from './skr.verify.js';
 export type { IChainVerificationResult } from './skr.verify.js';
 export { migrateToV2 } from './skr.migrate.js';

package/ts/skr.api.ts

@@ -1055,6 +1055,24 @@ export class SkrApi {
     return getControlTotals(this.currentSKRType!, this.getDefaultPolicy(), asOf);
   }
 
+  // ========== UStVA extraction ==========
+
+  /**
+   * One period's movements + exact igE/§13b scenario bases, shaped for
+   * @fin.cx/tax `computeUstva()`. Review `warnings` before filing.
+   */
+  public async getUstvaPeriodData(
+    dateFrom: Date,
+    dateTo: Date,
+  ): Promise<import('./skr.ustva.js').IUstvaPeriodData> {
+    this.ensureInitialized();
+    const { getUstvaPeriodData } = await import('./skr.ustva.js');
+    return getUstvaPeriodData(this.currentSKRType!, this.getDefaultPolicy(), {
+      dateFrom,
+      dateTo,
+    });
+  }
+
   public async setDunning(params: {
     accountNumber: string;
     reference: string;

package/ts/skr.ustva.ts

@@ -0,0 +1,151 @@
+/**
+ * UStVA period extraction: one period's account movements plus the EXACT
+ * scenario Bemessungsgrundlagen (igE / §13b) taken from taxScenario-tagged
+ * journal entries. The result feeds @fin.cx/tax `computeUstva()` directly —
+ * movements as `IAccountMovementInput[]`, scenarioBases as
+ * `IScenarioBaseInput`.
+ *
+ * Base extraction per tagged entry: sum of (debit - credit) over lines that
+ * sit neither on a policy VAT account nor on a personal account (>= 10000).
+ * For the recipe shapes that is exactly the net expense line; Stornos flip
+ * sides and cancel. Every extracted base is cross-checked against the
+ * entry's own input-VAT line — disagreement lands in `warnings`.
+ */
+import { vatFromNetCents } from '@fin.cx/calculation';
+import { getDbSync } from './skr.database.js';
+import { JOURNAL_ENTRY_COLLECTION } from './skr.period.js';
+import { aggregateTrialBalance } from './skr.balances.js';
+import type { IAccountPolicy } from './core/index.js';
+import type { TSKRType } from './skr.types.js';
+
+export interface IUstvaMovement {
+  accountNumber: string;
+  /** debitCents - creditCents over the period */
+  signedCents: number;
+}
+
+export interface IUstvaScenarioBases {
+  /** igE 19 % net bases (Kz 89) */
+  intraEuAcquisitionStandardCents: number;
+  /** igE 7 % net bases (Kz 93) */
+  intraEuAcquisitionReducedCents: number;
+  /**
+   * §13b bases (Kz 46). The scenario tag does not distinguish EU services
+   * from other §13b cases — everything lands here; reclassify to Kz 84
+   * manually if a non-EU-services §13b case ever occurs.
+   */
+  reverseChargeServicesEuCents: number;
+}
+
+export interface IUstvaPeriodData {
+  movements: IUstvaMovement[];
+  scenarioBases: IUstvaScenarioBases;
+  /** tagged igE/§13b entries examined */
+  taggedEntryCount: number;
+  /** extraction anomalies — review before filing */
+  warnings: string[];
+}
+
+interface IRawEntry {
+  sequenceNumber?: number;
+  journalNumber?: string;
+  taxScenario?: string;
+  lines: Array<{ accountNumber: string; side?: string; amountCents?: number }>;
+}
+
+function isPersonalAccount(accountNumber: string): boolean {
+  const numeric = Number.parseInt(accountNumber, 10);
+  return numeric >= 10000 && numeric <= 99999;
+}
+
+export async function getUstvaPeriodData(
+  skrType: TSKRType,
+  policy: IAccountPolicy,
+  options: { dateFrom: Date; dateTo: Date },
+): Promise<IUstvaPeriodData> {
+  const trialBalance = await aggregateTrialBalance(skrType, options);
+  const movements: IUstvaMovement[] = trialBalance.accounts
+    .filter((account) => account.balanceCents !== 0)
+    .map((account) => ({
+      accountNumber: account.accountNumber,
+      signedCents: account.balanceCents,
+    }));
+
+  const vatAccounts = new Set(Object.values(policy.vat));
+  const warnings: string[] = [];
+  const scenarioBases: IUstvaScenarioBases = {
+    intraEuAcquisitionStandardCents: 0,
+    intraEuAcquisitionReducedCents: 0,
+    reverseChargeServicesEuCents: 0,
+  };
+
+  const collection = getDbSync().mongoDb.collection(JOURNAL_ENTRY_COLLECTION);
+  const tagged = (await collection
+    .find(
+      {
+        schemaVersion: 2,
+        skrType,
+        status: { $in: ['posted', 'finalized'] },
+        taxScenario: { $in: ['intra_eu_acquisition', 'reverse_charge_13b'] },
+        date: { $gte: options.dateFrom, $lte: options.dateTo },
+      },
+      { projection: { sequenceNumber: 1, journalNumber: 1, taxScenario: 1, lines: 1 } },
+    )
+    .toArray()) as unknown as IRawEntry[];
+
+  for (const entry of tagged) {
+    const label = entry.journalNumber ?? `seq ${entry.sequenceNumber}`;
+    const inputVatAccount =
+      entry.taxScenario === 'intra_eu_acquisition'
+        ? policy.vat.intraEuAcqInput
+        : policy.vat.reverseChargeInput;
+
+    let baseCents = 0;
+    let inputVatCents = 0;
+    for (const line of entry.lines) {
+      const amount = line.amountCents ?? 0;
+      const signed = line.side === 'debit' ? amount : -amount;
+      if (line.accountNumber === inputVatAccount) {
+        inputVatCents += signed;
+        continue;
+      }
+      if (vatAccounts.has(line.accountNumber)) continue;
+      if (isPersonalAccount(line.accountNumber)) continue;
+      baseCents += signed;
+    }
+
+    if (baseCents === 0 && inputVatCents !== 0) {
+      warnings.push(
+        `entry ${label}: no base extractable (counterparty not a personal account?) — VAT line is ${inputVatCents} cents`,
+      );
+      continue;
+    }
+    if (baseCents === 0) continue;
+
+    // rate detection from the entry's own VAT line (19 % vs 7 %)
+    const absBase = Math.abs(baseCents);
+    const absVat = Math.abs(inputVatCents);
+    const reduced = Math.abs(absVat * 100 - 7 * absBase) < Math.abs(absVat * 100 - 19 * absBase);
+    const rate = reduced ? 7 : 19;
+    const expectedVat = vatFromNetCents(baseCents, rate);
+    if (Math.abs(inputVatCents - expectedVat) > 2) {
+      warnings.push(
+        `entry ${label}: base ${baseCents} cents at ${rate} % expects VAT ${expectedVat}, ledger line says ${inputVatCents}`,
+      );
+    }
+
+    if (entry.taxScenario === 'intra_eu_acquisition') {
+      if (reduced) scenarioBases.intraEuAcquisitionReducedCents += baseCents;
+      else scenarioBases.intraEuAcquisitionStandardCents += baseCents;
+    } else {
+      scenarioBases.reverseChargeServicesEuCents += baseCents;
+    }
+  }
+
+  return {
+    movements,
+    scenarioBases,
+    taggedEntryCount: tagged.length,
+    warnings,
+  };
+}

package/readme.hints.md

@@ -1,103 +0,0 @@
-# Project Readme Hints
-
-## Dev Environment (2026-07-09)
-
-- Local services are managed by `gitzone services` (@git.zone/cli >= 2.23.0); the old
-  `services.sh` was removed. `gitzone services start` creates MongoDB as a **single-node
-  replica set** (rs0, keyfile auth, mongod on the mapped port inside the container) —
-  required because skr v2 posting uses MongoDB transactions. Verify with
-  `.nogit/debug/check-replicaset.ts` (tsx).
-- Service selection lives in `.smartconfig.json` under `@git.zone/cli.services`;
-  runtime config in `.nogit/env.json`. Old standalone data was backed up to
-  `.nogit/mongodata.pre-replset.bak` (disposable test data).
-- Program plan for the accounting roadmap ("no external tax accountant") is in
-  `readme.plan.md`; M0 = skr v2 core hardening. @fin.cx/calculation ships the cents
-  module (TCents) that skr v2 money handling builds on.
-
-## Chart rebase (2026-07-09, v3)
-
-- The built-in SKR03/04 charts are now GENERATED from @fin.cx/chartdata >= 2.1.0
-  (`tsx tools/generate-chart-data.ts`) — the v1 hand-written charts were an
-  invented hybrid layout and are gone. Notable corrections: SKR03 revenue lives
-  in class 8 (8400/8300), expenses in class 4 (default 4900 — 4980 is
-  Mietleasing!), VSt/USt rate accounts fixed (1571/1771 = 7 %); SKR04 bank is
-  1800, Kasse 1600, controls 1200/3300, default expense 6300.
-- Account.isAutomaticAccount: SKR04 controls corrected to 1200/3300.
-
-## M0 Phase 2 — stateless core (2026-07-09)
-
-- `ts/core/` is the pure booking core (exported as `core` from the package index):
-  types, BU keys, tax-scenario cascade, account policies, recipes, validation,
-  DATEV EXTF writer, hash chain. Hard rule: core imports only @fin.cx/calculation
-  (+ smarthash for SHA-256) — no smartdata/fs/network.
-- **BU-key corrections vs v1/finance.plus** (cross-checked 2026-07-09): 18/19 =
-  steuerpflichtiger innergemeinschaftlicher Erwerb 7%/19% (§1a UStG); 91/94 =
-  Leistungsempfänger schuldet die Steuer 7%/19% (§13b UStG); 40 = Aufhebung der
-  Automatik. v1's `skr.postingkeys.ts` (numeric keys with partly different meanings)
-  is superseded by `ts/core/core.bukeys.ts`. Official DATEV table (Hilfe-Center doc
-  0904313) is portal-gated — final verification = manual DATEV import per RC.
-- **DATEV EXTF v13 facts** (verified against a DATEV-importable reference file):
-  125 data columns, 31 header fields, field 114 = Festschreibung, decimal-comma
-  amounts, Belegdatum TTMM, text fields quoted, CRLF; file encoding must be CP1252
-  (conversion happens at the IO layer, core emits a JS string).
-  `ts/core/core.datev.captions.ts` is generated from that reference — do not edit.
-- Automatik convention in recipes: a line on an Automatikkonto carries key '' when
-  the entry has no explicit VAT lines, and key '40' when explicit VAT lines exist
-  (automatism must be cancelled so DATEV import doesn't double the tax).
-- PROVISIONAL policy accounts (verify in M-A): reduced-rate Skonto accounts
-  (3731/8731, 5731/4731) and rounding-diff accounts (2700/2300, 4830/6300).
-
-## Current Status (2025-10-27)
-
-### Test Results
-✅ **ALL 65/65 TESTS PASSING** (100%)
-
-### Recent Fixes
-
-#### Fixed: SKR04 Bug (Account 3300 Misclassification)
-**Problem**: Account 3300 was incorrectly hardcoded as an automatic account for SKR04
-**Root Cause**: Bug in `ts/skr.classes.account.ts:192` - account 3300 is "Fahrzeugkosten" (vehicle costs), NOT an automatic account
-**Solution**:
-1. Removed 3300 from automatic accounts list in `isAutomaticAccount()` method
-2. Updated test.skr04.ts to use timestamped database names to avoid conflicts
-**Files Changed**:
-- `ts/skr.classes.account.ts` - Fixed automatic account detection
-- `test/test.skr04.ts` - Added timestamp to database name
-
-**Result**: ✅ All SKR04 tests now passing (jahresabschluss.skr04 + basic SKR04 tests)
-
-### Architecture Notes
-
-#### VAT Validation Logic (Recent Changes)
-- **skr.classes.journalentry.ts:224-273**: Detects VAT lines in entries to enable smart validation
-- **skr.postingkeys.ts:87-100**: Exempts VAT accounts and debtor/creditor accounts from VAT amount requirements
-- **Rationale**: VAT accounts ARE the VAT; settlement transactions don't need VAT details again
-
-#### Posting Key Usage Pattern
-- **Tax-free operations** (key 40): Internal adjustments, depreciation, closing entries
-- **VAT operations** (keys 3, 8, 9, 19, 94): Customer/supplier transactions
-- **Best practice**: Use posting key 40 for non-VAT lines in mixed entries
-
-#### Account Structure
-- **Automatic accounts**: Cannot be posted to directly (1400 Debtors, 1600 Creditors, 3300 Bank)
-- **Personal accounts**: Created in ranges 10000-69999 (debtors), 70000-99999 (creditors)
-- **System enforces**: Must use personal variants instead of automatic accounts
-
-### Validation Pipeline
-1. **Line-level**: Posting key required, account exists, VAT rules
-2. **Posting key level**: VAT amount requirements (with exemptions)
-3. **Consistency level**: No mixing tax-free and taxed (unless intentional)
-4. **Balance level**: Debits must equal credits (0.01 tolerance)
-
-### Test Coverage
-- 65 test cases covering full accounting cycle
-- Complete Jahresabschluss (annual closing) workflow in SKR03
-- Report generation (Trial Balance, Income Statement, Balance Sheet)
-- Transaction reversal and audit trails
-- DATEV posting key validation
-
-### Dependencies
-- MongoDB via @push.rocks/smartdata for persistence
-- TypeScript 5.8.3 with strict mode
-- @git.zone/tstest for testing framework
-- @push.rocks/smartexpect for assertions