jaz-cli 2.6.0 → 2.8.0

package/dist/__tests__/fixed-deposit.test.js

@@ -0,0 +1,214 @@
+import { describe, it, expect } from 'vitest';
+import { calculateFixedDeposit } from '../calc/fixed-deposit.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateFixedDeposit (simple interest)', () => {
+    const base = { principal: 100000, annualRate: 3.5, termMonths: 12 };
+    it('maturity = principal + simple interest', () => {
+        const r = calculateFixedDeposit(base);
+        // 100000 * 3.5% * 12/12 = 3500
+        expect(r.maturityValue).toBe(103500);
+    });
+    it('totalInterest = maturity - principal', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.totalInterest).toBe(3500);
+    });
+    it('schedule has termMonths periods', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule).toHaveLength(12);
+    });
+    it('equal monthly accrual (except final rounding)', () => {
+        const r = calculateFixedDeposit(base);
+        const monthlyAccrual = Math.round(3500 / 12 * 100) / 100; // 291.67
+        for (let i = 0; i < 11; i++) {
+            expect(r.schedule[i].interest).toBe(monthlyAccrual);
+        }
+    });
+    it('total accrued interest = totalInterest exactly', () => {
+        const r = calculateFixedDeposit(base);
+        const totalAccrued = r.schedule.reduce((s, row) => s + row.interest, 0);
+        expect(Math.round(totalAccrued * 100) / 100).toBe(3500);
+    });
+    it('opening balance stays at principal (simple interest)', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            expect(row.openingBalance).toBe(100000);
+        }
+    });
+    it('every journal entry is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+    it('accrual journals use Accrued Interest / Interest Income', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule[0].journal.lines[0].account).toBe('Accrued Interest Receivable');
+        expect(r.schedule[0].journal.lines[1].account).toBe('Interest Income');
+    });
+});
+describe('calculateFixedDeposit (compound quarterly)', () => {
+    const base = { principal: 100000, annualRate: 4, termMonths: 12, compounding: 'quarterly' };
+    it('schedule has 4 periods (quarterly)', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule).toHaveLength(4);
+    });
+    it('maturity > simple interest equivalent', () => {
+        const simple = calculateFixedDeposit({ principal: 100000, annualRate: 4, termMonths: 12 });
+        const compound = calculateFixedDeposit(base);
+        expect(compound.maturityValue).toBeGreaterThan(simple.maturityValue);
+    });
+    it('final closing balance = maturity value', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(r.maturityValue);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateFixedDeposit(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('total accrued = totalInterest', () => {
+        const r = calculateFixedDeposit(base);
+        const totalAccrued = r.schedule.reduce((s, row) => s + row.interest, 0);
+        expect(Math.round(totalAccrued * 100) / 100).toBe(r.totalInterest);
+    });
+    it('every journal entry is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+});
+describe('calculateFixedDeposit (compound monthly)', () => {
+    it('monthly compound: 12 periods', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12, compounding: 'monthly',
+        });
+        expect(r.schedule).toHaveLength(12);
+    });
+});
+describe('calculateFixedDeposit (compound annually)', () => {
+    it('annual compound: 1 period for 12 months', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12, compounding: 'annually',
+        });
+        expect(r.schedule).toHaveLength(1);
+        expect(r.maturityValue).toBe(104000); // 100000 * 1.04
+    });
+});
+describe('calculateFixedDeposit (placement/maturity journals)', () => {
+    const base = { principal: 100000, annualRate: 3.5, termMonths: 12 };
+    it('placement journal: debit Fixed Deposit, credit Cash', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.placementJournal.lines[0].account).toBe('Fixed Deposit');
+        expect(r.placementJournal.lines[0].debit).toBe(100000);
+        expect(r.placementJournal.lines[1].account).toBe('Cash / Bank Account');
+        expect(r.placementJournal.lines[1].credit).toBe(100000);
+    });
+    it('maturity journal: debit Cash, credit FD + Accrued Interest', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.maturityJournal.lines[0].account).toBe('Cash / Bank Account');
+        expect(r.maturityJournal.lines[0].debit).toBe(103500);
+        expect(r.maturityJournal.lines[1].account).toBe('Fixed Deposit');
+        expect(r.maturityJournal.lines[1].credit).toBe(100000);
+        expect(r.maturityJournal.lines[2].account).toBe('Accrued Interest Receivable');
+        expect(r.maturityJournal.lines[2].credit).toBe(3500);
+    });
+    it('placement journal is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        const debits = r.placementJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.placementJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('maturity journal is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        const debits = r.maturityJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.maturityJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+});
+describe('calculateFixedDeposit (blueprint)', () => {
+    it('blueprint present when startDate given', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint null without startDate', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12 });
+        expect(r.blueprint).toBeNull();
+    });
+    it('step 1 = cash-out (placement)', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('cash-out');
+    });
+    it('last step = cash-in (maturity)', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        expect(lastStep.action).toBe('cash-in');
+    });
+    it('step count = 1 placement + N accruals + 1 maturity', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(14); // 1 + 12 + 1
+    });
+    it('compound quarterly: step count uses compound periods', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12,
+            compounding: 'quarterly', startDate: '2025-01-01',
+        });
+        expect(r.blueprint.steps).toHaveLength(6); // 1 + 4 + 1
+    });
+    it('capsuleType is Fixed Deposit', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleType).toBe('Fixed Deposit');
+    });
+    it('capsuleDescription contains IFRS 9', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleDescription).toContain('IFRS 9');
+    });
+});
+describe('calculateFixedDeposit (currency)', () => {
+    it('currency passes through', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12 });
+        expect(r.currency).toBeNull();
+    });
+});
+describe('calculateFixedDeposit (validation)', () => {
+    it('rejects zero principal', () => {
+        expect(() => calculateFixedDeposit({ principal: 0, annualRate: 3.5, termMonths: 12 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative rate', () => {
+        expect(() => calculateFixedDeposit({ principal: 100000, annualRate: -1, termMonths: 12 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects non-multiple term for quarterly compounding', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 7, compounding: 'quarterly',
+        })).toThrow(CalcValidationError);
+    });
+    it('rejects non-multiple term for annual compounding', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 18, compounding: 'annually',
+        })).toThrow(CalcValidationError);
+    });
+    it('allows any term for monthly compounding', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 7, compounding: 'monthly',
+        });
+        expect(r.schedule).toHaveLength(7);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '01-01-2025',
+        })).toThrow(CalcValidationError);
+    });
+});

package/dist/__tests__/fx-reval.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { calculateFxReval } from '../calc/fx-reval.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateFxReval (gain)', () => {
+    const base = { amount: 50000, bookRate: 1.35, closingRate: 1.38 };
+    it('bookValue = amount * bookRate', () => {
+        const r = calculateFxReval(base);
+        expect(r.bookValue).toBe(67500); // 50000 * 1.35
+    });
+    it('closingValue = amount * closingRate', () => {
+        const r = calculateFxReval(base);
+        expect(r.closingValue).toBe(69000); // 50000 * 1.38
+    });
+    it('gain = closingValue - bookValue', () => {
+        const r = calculateFxReval(base);
+        expect(r.gainOrLoss).toBe(1500);
+        expect(r.isGain).toBe(true);
+    });
+    it('journal debits Monetary Item, credits FX Unrealized Gain', () => {
+        const r = calculateFxReval(base);
+        expect(r.journal.lines[0].account).toContain('Monetary Item');
+        expect(r.journal.lines[0].debit).toBe(1500);
+        expect(r.journal.lines[1].account).toBe('FX Unrealized Gain');
+        expect(r.journal.lines[1].credit).toBe(1500);
+    });
+    it('journal is balanced', () => {
+        const r = calculateFxReval(base);
+        const debits = r.journal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.journal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('reversal is exact negative of revaluation', () => {
+        const r = calculateFxReval(base);
+        for (let i = 0; i < r.journal.lines.length; i++) {
+            expect(r.reversalJournal.lines[i].debit).toBe(r.journal.lines[i].credit);
+            expect(r.reversalJournal.lines[i].credit).toBe(r.journal.lines[i].debit);
+        }
+    });
+    it('reversal journal is balanced', () => {
+        const r = calculateFxReval(base);
+        const debits = r.reversalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.reversalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+});
+describe('calculateFxReval (loss)', () => {
+    const base = { amount: 50000, bookRate: 1.38, closingRate: 1.35 };
+    it('loss is negative gainOrLoss', () => {
+        const r = calculateFxReval(base);
+        expect(r.gainOrLoss).toBe(-1500);
+        expect(r.isGain).toBe(false);
+    });
+    it('journal debits FX Unrealized Loss, credits Monetary Item', () => {
+        const r = calculateFxReval(base);
+        expect(r.journal.lines[0].account).toBe('FX Unrealized Loss');
+        expect(r.journal.lines[0].debit).toBe(1500);
+        expect(r.journal.lines[1].account).toContain('Monetary Item');
+        expect(r.journal.lines[1].credit).toBe(1500);
+    });
+});
+describe('calculateFxReval (zero movement)', () => {
+    it('zero gain/loss when rates equal', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.35 });
+        expect(r.gainOrLoss).toBe(0);
+        expect(r.isGain).toBe(true); // >= 0 treated as gain
+    });
+});
+describe('calculateFxReval (blueprint)', () => {
+    it('blueprint always present (no startDate needed)', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint has 2 steps (reval + reversal)', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.steps).toHaveLength(2);
+    });
+    it('both steps are journal type', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        for (const step of r.blueprint.steps) {
+            expect(step.action).toBe('journal');
+        }
+    });
+    it('capsuleType is FX Revaluation', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.capsuleType).toBe('FX Revaluation');
+    });
+    it('capsuleDescription contains IAS 21', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.capsuleDescription).toContain('IAS 21');
+    });
+});
+describe('calculateFxReval (defaults + passthrough)', () => {
+    it('defaults to USD/SGD', () => {
+        const r = calculateFxReval({ amount: 1000, bookRate: 1.3, closingRate: 1.4 });
+        expect(r.currency).toBe('USD');
+        expect(r.inputs.baseCurrency).toBe('SGD');
+    });
+    it('custom currency passes through', () => {
+        const r = calculateFxReval({ amount: 1000, bookRate: 1.3, closingRate: 1.4, currency: 'EUR', baseCurrency: 'PHP' });
+        expect(r.currency).toBe('EUR');
+        expect(r.inputs.baseCurrency).toBe('PHP');
+    });
+});
+describe('calculateFxReval (validation)', () => {
+    it('rejects zero amount', () => {
+        expect(() => calculateFxReval({ amount: 0, bookRate: 1.35, closingRate: 1.38 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative bookRate', () => {
+        expect(() => calculateFxReval({ amount: 50000, bookRate: -1, closingRate: 1.38 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero closingRate', () => {
+        expect(() => calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 0 })).toThrow(CalcValidationError);
+    });
+});

package/dist/__tests__/jobs-audit-prep.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { generateAuditPrepBlueprint } from '../jobs/audit-prep.js';
+import { JobValidationError } from '../jobs/validate.js';
+describe('generateAuditPrepBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.jobType).toBe('audit-prep');
+    });
+    it('has 4 phases and 14 total steps', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(14);
+    });
+    it('phase names are correct', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Financial Statements',
+            'Supporting Schedules',
+            'Reconciliations',
+            'Export & Compile Audit Pack',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — trial balance
+            'report', // 2 — balance sheet
+            'report', // 3 — P&L
+            'report', // 4 — cash flow
+            'report', // 5 — equity movement
+            'report', // 6 — AR aging
+            'report', // 7 — AP aging
+            'report', // 8 — fixed assets
+            'report', // 9 — tax ledger
+            'verify', // 10 — bank reconciliation
+            'verify', // 11 — intercompany
+            'verify', // 12 — loan schedule
+            'export', // 13 — export data
+            'report', // 14 — compile audit pack
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateAuditPrepBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.currency).toBe('SGD');
+    });
+});
+describe('generateAuditPrepBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025', currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('full year period produces FY label', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.period).toBe('FY2025');
+    });
+    it('full year period uses Jan 1 to Dec 31', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-01-01');
+        expect(body.endDate).toBe('2025-12-31');
+    });
+    it('quarter period produces Q label', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025-Q3' });
+        expect(bp.period).toBe('Q3 2025');
+    });
+    it('quarter period uses correct date range', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025-Q3' });
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-07-01');
+        expect(body.endDate).toBe('2025-09-30');
+    });
+});
+describe('generateAuditPrepBlueprint (validation)', () => {
+    it('invalid period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '2025-06' }))
+            .toThrow(JobValidationError);
+    });
+    it('invalid quarter throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '2025-Q5' }))
+            .toThrow(JobValidationError);
+    });
+    it('malformed period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: 'FY2025' }))
+            .toThrow(JobValidationError);
+    });
+    it('empty period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '' }))
+            .toThrow(JobValidationError);
+    });
+});
+describe('generateAuditPrepBlueprint (summary)', () => {
+    it('recipeReferences include bank-reconciliation', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.recipeReferences).toContain('bank-reconciliation');
+    });
+    it('calcReferences include jaz calc loan', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.calcReferences).toContain('jaz calc loan');
+    });
+    it('apiCalls include key report endpoints', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/trial-balance');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/balance-sheet');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/profit-and-loss');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/cashflow');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/equity-movement');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ar-aging');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ap-aging');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/fixed-assets');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/vat-ledger');
+    });
+});

package/dist/__tests__/jobs-bank-recon.test.js

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { generateBankReconBlueprint } from '../jobs/bank-recon.js';
+describe('generateBankReconBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.jobType).toBe('bank-recon');
+    });
+    it('has 4 phases and 10 total steps', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(10);
+    });
+    it('phase names are correct', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Identify Bank Accounts',
+            'Pull Unreconciled Records',
+            'Resolve Unreconciled Items',
+            'Verification',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateBankReconBlueprint();
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'verify', // 1 — list bank accounts
+            'verify', // 2 — search unreconciled
+            'verify', // 3 — check duplicates
+            'resolve', // 4 — match bank records
+            'resolve', // 5 — create transactions (import)
+            'resolve', // 6 — create cash journals
+            'review', // 7 — flag remaining items
+            'verify', // 8 — re-check unreconciled count
+            'verify', // 9 — review bank balance
+            'report', // 10 — generate reconciliation report
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateBankReconBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.currency).toBe('SGD');
+    });
+    it('default period is current', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.period).toBe('current');
+    });
+});
+describe('generateBankReconBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateBankReconBlueprint({ currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('account filter is applied', () => {
+        const bp = generateBankReconBlueprint({ account: 'DBS Current' });
+        const step1 = bp.phases[0].steps[0];
+        expect(step1.apiBody).toBeDefined();
+        expect(step1.apiBody.filters).toHaveProperty('accountName', 'DBS Current');
+        expect(step1.notes).toContain('DBS Current');
+    });
+    it('account filter absent by default', () => {
+        const bp = generateBankReconBlueprint();
+        const step1 = bp.phases[0].steps[0];
+        const filters = step1.apiBody.filters;
+        expect(filters).not.toHaveProperty('accountName');
+    });
+    it('period filter is applied to unreconciled search with correct end-of-month', () => {
+        const bp = generateBankReconBlueprint({ period: '2025-06' });
+        expect(bp.period).toBe('2025-06');
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateFrom', '2025-06-01');
+        expect(filters).toHaveProperty('valueDateTo', '2025-06-30');
+    });
+    it('period filter handles February correctly', () => {
+        const bp = generateBankReconBlueprint({ period: '2025-02' });
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateTo', '2025-02-28');
+    });
+    it('period filter handles leap year February', () => {
+        const bp = generateBankReconBlueprint({ period: '2024-02' });
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateTo', '2024-02-29');
+    });
+});
+describe('generateBankReconBlueprint (summary)', () => {
+    it('recipeReferences include bank-reconciliation and cash-receipt', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.recipeReferences).toContain('bank-reconciliation');
+        expect(bp.summary.recipeReferences).toContain('cash-receipt');
+    });
+    it('apiCalls include key endpoints', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.apiCalls).toContain('POST /chart-of-accounts/search');
+        expect(bp.summary.apiCalls).toContain('POST /bank-records/search');
+        expect(bp.summary.apiCalls).toContain('POST /journals');
+    });
+});

package/dist/__tests__/jobs-credit-control.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { generateCreditControlBlueprint } from '../jobs/credit-control.js';
+import { JobValidationError } from '../jobs/validate.js';
+describe('generateCreditControlBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.jobType).toBe('credit-control');
+    });
+    it('has 4 phases and 7 total steps', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(7);
+    });
+    it('phase names are correct', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'AR Analysis',
+            'Chase List',
+            'Bad Debt Assessment',
+            'Verification',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateCreditControlBlueprint();
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — AR aging report
+            'verify', // 2 — identify overdue invoices
+            'review', // 3 — group by customer priority
+            'report', // 4 — follow-up action list
+            'review', // 5 — identify doubtful debts
+            'value', // 6 — calculate ECL provision
+            'verify', // 7 — review AR aging after actions
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateCreditControlBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.currency).toBe('SGD');
+    });
+    it('default overdueDays is 30', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.period).toBe('Overdue > 30 days');
+    });
+});
+describe('generateCreditControlBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateCreditControlBlueprint({ currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('custom overdueDays works', () => {
+        const bp = generateCreditControlBlueprint({ overdueDays: 60 });
+        expect(bp.period).toBe('Overdue > 60 days');
+    });
+    it('overdueDays is reflected in step description', () => {
+        const bp = generateCreditControlBlueprint({ overdueDays: 90 });
+        const step2 = bp.phases[0].steps[1];
+        expect(step2.description).toContain('90');
+    });
+});
+describe('generateCreditControlBlueprint (validation)', () => {
+    it('zero overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: 0 }))
+            .toThrow(JobValidationError);
+    });
+    it('negative overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: -10 }))
+            .toThrow(JobValidationError);
+    });
+    it('fractional overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: 30.5 }))
+            .toThrow(JobValidationError);
+    });
+});
+describe('generateCreditControlBlueprint (summary)', () => {
+    it('recipeReferences include bad-debt-provision', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.recipeReferences).toContain('bad-debt-provision');
+    });
+    it('calcReferences include jaz calc ecl', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.calcReferences).toContain('jaz calc ecl');
+    });
+    it('apiCalls include key endpoints', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ar-aging');
+        expect(bp.summary.apiCalls).toContain('POST /invoices/search');
+    });
+});