jaz-cli 2.7.0 → 2.9.0

package/dist/tax/sg/form-cs.js

@@ -0,0 +1,349 @@
+/**
+ * Singapore Form C-S / C-S Lite corporate income tax computation engine.
+ *
+ * Implements the full IRAS tax computation pipeline:
+ *   accounting profit → add-backs → deductions → adjusted profit →
+ *   capital allowances → enhanced deductions → loss relief → donation relief →
+ *   chargeable income → exemption → 17% → CIT rebate → net tax payable
+ *
+ * Set-off order follows IRAS rules (current CA → enhanced → unabsorbed CA →
+ * losses → donations, each capped at available chargeable income).
+ */
+import { round2 } from '../types.js';
+import { validateFormCsInput } from '../validate.js';
+import { SG_CIT_RATE, FORM_CS_REVENUE_LIMIT, FORM_CS_LITE_REVENUE_LIMIT, DONATION_MULTIPLIER, MONTH_NAMES, } from './constants.js';
+import { computeExemption, computeCitRebate } from './exemptions.js';
+// ── Helpers ──────────────────────────────────────────────────────
+function formatBasisPeriod(start, end) {
+    const s = new Date(start + 'T00:00:00Z');
+    const e = new Date(end + 'T00:00:00Z');
+    const fmt = (d) => `${String(d.getUTCDate()).padStart(2, '0')} ${MONTH_NAMES[d.getUTCMonth()]} ${d.getUTCFullYear()}`;
+    return `${fmt(s)} to ${fmt(e)}`;
+}
+function line(label, amount, ref, indent) {
+    return { label, amount: round2(amount), reference: ref, indent: indent ?? 0 };
+}
+// ── Main computation ──────────────────────────────────────────────
+export function computeFormCs(input) {
+    validateFormCsInput(input);
+    const currency = input.currency ?? 'SGD';
+    const ya = input.ya;
+    const basisPeriod = formatBasisPeriod(input.basisPeriodStart, input.basisPeriodEnd);
+    // ── Form type determination ──
+    const eligible = input.revenue <= FORM_CS_REVENUE_LIMIT;
+    const formType = input.revenue <= FORM_CS_LITE_REVENUE_LIMIT ? 'C-S Lite' : 'C-S';
+    const schedule = [];
+    // ── Step 1: Accounting profit ──
+    const accountingProfit = round2(input.accountingProfit);
+    schedule.push(line('Net profit/(loss) per accounts', accountingProfit, 'P&L'));
+    // ── Step 2: Add-backs ──
+    const ab = input.addBacks;
+    const addBackItems = [
+        { label: 'Depreciation', amount: ab.depreciation, ref: 'S19 — accounting depr always added back' },
+        { label: 'Amortization', amount: ab.amortization, ref: 'Intangible amortization' },
+        { label: 'ROU depreciation (IFRS 16)', amount: ab.rouDepreciation, ref: 'IFRS 16 ROU' },
+        { label: 'Lease interest (IFRS 16)', amount: ab.leaseInterest, ref: 'IFRS 16 lease liability' },
+        { label: 'General provisions', amount: ab.generalProvisions, ref: 'ECL, warranty, restructuring' },
+        { label: 'Donations', amount: ab.donations, ref: 'IPC — claim 250% separately' },
+        { label: 'Entertainment', amount: ab.entertainment, ref: 'Non-deductible portion' },
+        { label: 'Penalties & fines', amount: ab.penalties, ref: 'Not deductible' },
+        { label: 'Private car expenses', amount: ab.privateCar, ref: 'S-plated vehicles' },
+        { label: 'Capital expenditure on P&L', amount: ab.capitalExpOnPnl, ref: 'Capital items expensed' },
+        { label: 'Unrealized FX losses', amount: ab.unrealizedFxLoss, ref: 'Not crystallized' },
+        { label: 'Other non-deductible', amount: ab.otherNonDeductible, ref: ab.otherDescription },
+    ];
+    const totalAddBacks = round2(addBackItems.reduce((s, i) => s + i.amount, 0));
+    schedule.push(line('Add: Non-deductible / non-taxable items', totalAddBacks));
+    for (const item of addBackItems) {
+        if (item.amount > 0) {
+            schedule.push(line(item.label, item.amount, item.ref, 1));
+        }
+    }
+    // ── Step 3: Deductions ──
+    const ded = input.deductions;
+    const deductionItems = [
+        { label: 'Actual lease payments (IFRS 16 reversal)', amount: ded.actualLeasePayments, ref: 'Operating lease payments' },
+        { label: 'Unrealized FX gains', amount: ded.unrealizedFxGain, ref: 'Not crystallized' },
+        { label: 'Exempt dividends', amount: ded.exemptDividends, ref: 'SG one-tier' },
+        { label: 'Exempt income', amount: ded.exemptIncome, ref: 'Not taxable' },
+        { label: 'Other deductions', amount: ded.otherDeductions, ref: ded.otherDescription },
+    ];
+    const totalDeductions = round2(deductionItems.reduce((s, i) => s + i.amount, 0));
+    schedule.push(line('Less: Further deductions', totalDeductions));
+    for (const item of deductionItems) {
+        if (item.amount > 0) {
+            schedule.push(line(item.label, item.amount, item.ref, 1));
+        }
+    }
+    // ── Step 4: Adjusted profit ──
+    const adjustedProfit = round2(accountingProfit + totalAddBacks - totalDeductions);
+    schedule.push(line('Adjusted profit/(loss)', adjustedProfit, 'Box 1'));
+    // ── Step 5: Capital allowances (IRAS set-off order) ──
+    // Current year CA first, then unabsorbed brought forward
+    const ca = input.capitalAllowances;
+    // If adjusted profit is negative, CA cannot reduce it further — carry all forward
+    let remainingCI = adjustedProfit;
+    // Current year CA
+    const currentCaClaim = remainingCI > 0
+        ? round2(Math.min(ca.currentYearClaim, remainingCI))
+        : 0;
+    const currentCaExcess = round2(ca.currentYearClaim - currentCaClaim);
+    if (currentCaClaim > 0) {
+        schedule.push(line('Less: Current year capital allowances', currentCaClaim, 'S19/S19A'));
+    }
+    remainingCI = round2(remainingCI - currentCaClaim);
+    // ── Step 6: Enhanced deductions ──
+    const ed = input.enhancedDeductions;
+    // R&D: qualifying expenditure × (multiplier - 1) = the enhanced portion
+    // (The base 100% is already in the P&L as an expense)
+    const rdEnhanced = round2(ed.rdExpenditure * Math.max(0, ed.rdMultiplier - 1));
+    const ipEnhanced = round2(ed.ipRegistration * Math.max(0, ed.ipMultiplier - 1));
+    const donationEnhanced = round2(ed.donations250Base * (DONATION_MULTIPLIER - 1));
+    // S14Q: net uplift only (base already claimed via CA)
+    const s14qEnhanced = ed.s14qRenovation;
+    const enhancedTotal = round2(rdEnhanced + ipEnhanced + donationEnhanced + s14qEnhanced);
+    const enhancedClaim = remainingCI > 0
+        ? round2(Math.min(enhancedTotal, remainingCI))
+        : 0;
+    const enhancedExcess = round2(enhancedTotal - enhancedClaim);
+    if (enhancedClaim > 0) {
+        schedule.push(line('Less: Enhanced deductions', enhancedClaim));
+        if (rdEnhanced > 0)
+            schedule.push(line(`R&D (${ed.rdMultiplier * 100}% − 100% base)`, rdEnhanced, 'S14C/14E', 1));
+        if (ipEnhanced > 0)
+            schedule.push(line(`IP registration (${ed.ipMultiplier * 100}% − 100% base)`, ipEnhanced, 'S14A', 1));
+        if (donationEnhanced > 0)
+            schedule.push(line(`Donations (${DONATION_MULTIPLIER * 100}% − 100% base)`, donationEnhanced, 'S37', 1));
+        if (s14qEnhanced > 0)
+            schedule.push(line('S14Q renovation (net uplift)', s14qEnhanced, 'S14Q', 1));
+    }
+    remainingCI = round2(remainingCI - enhancedClaim);
+    // Unabsorbed CA from prior years
+    const priorCaClaim = remainingCI > 0
+        ? round2(Math.min(ca.balanceBroughtForward, remainingCI))
+        : 0;
+    const priorCaExcess = round2(ca.balanceBroughtForward - priorCaClaim);
+    if (priorCaClaim > 0) {
+        schedule.push(line('Less: Unabsorbed CA brought forward', priorCaClaim, 'Prior YA CA'));
+    }
+    remainingCI = round2(remainingCI - priorCaClaim);
+    const capitalAllowanceClaim = round2(currentCaClaim + priorCaClaim);
+    const chargeableIncomeBeforeLosses = round2(Math.max(0, remainingCI));
+    schedule.push(line('Chargeable income before loss relief', chargeableIncomeBeforeLosses));
+    // ── Step 7: Loss relief ──
+    const lossRelief = chargeableIncomeBeforeLosses > 0
+        ? round2(Math.min(input.losses.broughtForward, chargeableIncomeBeforeLosses))
+        : 0;
+    const unabsorbedLossesAfter = round2(input.losses.broughtForward - lossRelief);
+    if (lossRelief > 0) {
+        schedule.push(line('Less: Unabsorbed trade losses', lossRelief, 'Prior YA losses'));
+    }
+    let ciAfterLosses = round2(chargeableIncomeBeforeLosses - lossRelief);
+    // ── Step 8: Donation relief ──
+    // Current year donations at 250%
+    const currentDonation250 = round2(ed.donations250Base * DONATION_MULTIPLIER);
+    const totalDonationAvailable = round2(currentDonation250 + input.donationsCarryForward.broughtForward);
+    const donationRelief = ciAfterLosses > 0
+        ? round2(Math.min(totalDonationAvailable, ciAfterLosses))
+        : 0;
+    // Determine how much came from current year vs brought forward
+    const currentDonationUsed = round2(Math.min(currentDonation250, donationRelief));
+    const priorDonationUsed = round2(donationRelief - currentDonationUsed);
+    const unabsorbedDonations = round2(input.donationsCarryForward.broughtForward - priorDonationUsed);
+    if (donationRelief > 0) {
+        schedule.push(line('Less: Donation deductions', donationRelief));
+        if (currentDonationUsed > 0)
+            schedule.push(line(`Current year (${DONATION_MULTIPLIER * 100}%)`, currentDonationUsed, 'S37', 1));
+        if (priorDonationUsed > 0)
+            schedule.push(line('Brought forward', priorDonationUsed, 'Prior YA', 1));
+    }
+    // ── Step 9: Chargeable income ──
+    const chargeableIncome = round2(Math.max(0, ciAfterLosses - donationRelief));
+    schedule.push(line('Chargeable income', chargeableIncome, 'Box 2'));
+    // ── Step 10: Tax exemption ──
+    const exemption = computeExemption(chargeableIncome, input.exemptionType);
+    const exemptAmount = exemption.exemptAmount;
+    const taxableIncome = exemption.taxableIncome;
+    if (exemptAmount > 0) {
+        const exemptionLabel = input.exemptionType === 'sute'
+            ? 'Start-Up Tax Exemption (SUTE)'
+            : 'Partial Tax Exemption (PTE)';
+        schedule.push(line(`Less: ${exemptionLabel}`, exemptAmount));
+    }
+    schedule.push(line('Taxable income', taxableIncome));
+    // ── Step 11: Gross tax ──
+    const grossTax = round2(taxableIncome * SG_CIT_RATE);
+    schedule.push(line(`Tax @ ${SG_CIT_RATE * 100}%`, grossTax, 'Box 6'));
+    // ── Step 12: CIT rebate ──
+    const citRebate = computeCitRebate(grossTax, ya);
+    if (citRebate > 0) {
+        schedule.push(line('Less: CIT rebate', citRebate, `YA ${ya} rebate`));
+    }
+    // ── Step 13: Net tax payable ──
+    const netTaxPayable = round2(Math.max(0, grossTax - citRebate));
+    schedule.push(line('Net tax payable', netTaxPayable, 'Box 7'));
+    // ── Carry-forwards ──
+    // Unabsorbed CA = excess from current year + excess from prior + enhanced excess
+    const unabsorbedCapitalAllowances = round2(currentCaExcess + priorCaExcess);
+    // If adjusted profit was negative, the loss is a current-year loss that adds to carry-forward
+    const currentYearLoss = adjustedProfit < 0 ? round2(Math.abs(adjustedProfit)) : 0;
+    const unabsorbedLosses = round2(unabsorbedLossesAfter + currentYearLoss);
+    // ── Form C-S field mapping ──
+    const formFields = buildFormFields(input, {
+        adjustedProfit,
+        chargeableIncome,
+        capitalAllowanceClaim,
+        enhancedDeductionTotal: enhancedClaim,
+        lossRelief,
+        donationRelief,
+        grossTax,
+        citRebate,
+        netTaxPayable,
+        formType,
+        basisPeriod,
+        exemptAmount,
+        taxableIncome,
+        currentYearLoss,
+        unabsorbedLosses,
+        unabsorbedCapitalAllowances,
+        unabsorbedDonations,
+    });
+    // ── Workings text ──
+    const workings = buildWorkings({
+        ya, currency, basisPeriod, formType, eligible,
+        accountingProfit, totalAddBacks, totalDeductions, adjustedProfit,
+        capitalAllowanceClaim, currentCaClaim, priorCaClaim,
+        enhancedDeductionTotal: enhancedClaim,
+        chargeableIncomeBeforeLosses, lossRelief, donationRelief,
+        chargeableIncome, exemptAmount, taxableIncome,
+        grossTax, citRebate, netTaxPayable,
+        exemptionType: input.exemptionType,
+        unabsorbedLosses, unabsorbedCapitalAllowances, unabsorbedDonations,
+    });
+    return {
+        type: 'sg-form-cs',
+        ya,
+        currency,
+        basisPeriod,
+        formType,
+        eligible,
+        schedule,
+        accountingProfit,
+        totalAddBacks,
+        totalDeductions,
+        adjustedProfit,
+        capitalAllowanceClaim,
+        enhancedDeductionTotal: enhancedClaim,
+        chargeableIncomeBeforeLosses,
+        lossRelief,
+        donationRelief,
+        chargeableIncome,
+        exemptAmount,
+        taxableIncome,
+        grossTax,
+        citRebate,
+        netTaxPayable,
+        unabsorbedLosses,
+        unabsorbedCapitalAllowances,
+        unabsorbedDonations,
+        formFields,
+        workings,
+    };
+}
+/**
+ * Build Form C-S (18 boxes) or C-S Lite (6 boxes) field mapping
+ * per IRAS specification. Box numbers match the actual IRAS form.
+ */
+function buildFormFields(input, f) {
+    if (f.formType === 'C-S Lite') {
+        // C-S Lite: 6 fields only
+        return [
+            { box: 1, label: 'Total Revenue', value: input.revenue, source: 'P&L total revenue' },
+            { box: 2, label: 'Adjusted Profit / Loss', value: f.adjustedProfit, source: 'Accounting profit + add-backs − deductions' },
+            { box: 3, label: 'Chargeable Income', value: f.chargeableIncome, source: 'After all reliefs' },
+            { box: 4, label: 'Exempt Amount', value: f.exemptAmount, source: `${input.exemptionType.toUpperCase()} exemption` },
+            { box: 5, label: 'Tax Payable', value: f.grossTax, source: `Taxable income × ${SG_CIT_RATE * 100}%` },
+            { box: 6, label: 'Net Tax Payable', value: f.netTaxPayable, source: 'Gross tax − CIT rebate' },
+        ];
+    }
+    // Form C-S: 18 fields matching IRAS layout
+    return [
+        // Section A: Revenue and Adjusted Profit
+        { box: 1, label: 'Adjusted Profit / Loss', value: f.adjustedProfit, source: 'Accounting profit + add-backs − deductions' },
+        { box: 2, label: 'Total Revenue', value: input.revenue, source: 'P&L total revenue' },
+        // Section B: Capital Allowances
+        { box: 3, label: 'Capital Allowances Claimed', value: f.capitalAllowanceClaim, source: 'Current + prior YA CA' },
+        { box: 4, label: 'Unabsorbed CA b/f', value: input.capitalAllowances.balanceBroughtForward, source: 'Prior YA carry-forward' },
+        { box: 5, label: 'Unabsorbed CA c/f', value: f.unabsorbedCapitalAllowances, source: 'b/f + current available − utilized' },
+        // Section C: Losses
+        { box: 6, label: 'Current Year Unabsorbed Losses', value: f.currentYearLoss, source: 'Only if Box 1 is a loss' },
+        { box: 7, label: 'Unabsorbed Losses b/f', value: input.losses.broughtForward, source: 'Prior YA carry-forward' },
+        { box: 8, label: 'Unabsorbed Losses c/f', value: f.unabsorbedLosses, source: 'b/f + current year loss − utilized' },
+        // Section D: Donations
+        { box: 9, label: 'Qualifying Donations (250%)', value: f.donationRelief, source: 'IPC donations at 250%' },
+        { box: 10, label: 'Unabsorbed Donations b/f', value: input.donationsCarryForward.broughtForward, source: 'Prior YA carry-forward (max 5 years)' },
+        { box: 11, label: 'Unabsorbed Donations c/f', value: f.unabsorbedDonations, source: 'b/f + current qualifying − utilized' },
+        // Section E: Chargeable Income and Tax
+        { box: 12, label: 'Chargeable Income', value: f.chargeableIncome, source: 'After all reliefs, floored at 0' },
+        { box: 13, label: 'Exempt Amount', value: f.exemptAmount, source: `${input.exemptionType.toUpperCase()} exemption` },
+        { box: 14, label: 'Taxable Income', value: f.taxableIncome, source: 'Chargeable income − exempt amount' },
+        { box: 15, label: 'Gross Tax', value: f.grossTax, source: `Taxable income × ${SG_CIT_RATE * 100}%` },
+        { box: 16, label: 'CIT Rebate', value: f.citRebate, source: `YA ${input.ya} rebate schedule` },
+        { box: 17, label: 'Net Tax Payable', value: f.netTaxPayable, source: 'Gross tax − CIT rebate' },
+        { box: 18, label: 'Claiming SUTE?', value: input.exemptionType === 'sute', source: 'Exemption election' },
+    ];
+}
+function fmtAmt(n, ccy) {
+    return `${ccy} ${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function buildWorkings(w) {
+    const lines = [
+        `TAX COMPUTATION — YA ${w.ya}`,
+        `${w.formType} | Basis period: ${w.basisPeriod}`,
+        `${w.eligible ? '✓ Eligible for Form C-S filing' : '✗ Exceeds C-S revenue threshold'}`,
+        '',
+        `Net profit per accounts:              ${fmtAmt(w.accountingProfit, w.currency)}`,
+        `Add: Non-deductible items:            ${fmtAmt(w.totalAddBacks, w.currency)}`,
+        `Less: Further deductions:            (${fmtAmt(w.totalDeductions, w.currency)})`,
+        `                                     ─────────────────`,
+        `Adjusted profit/(loss):               ${fmtAmt(w.adjustedProfit, w.currency)}`,
+        '',
+        `Less: Capital allowances:            (${fmtAmt(w.capitalAllowanceClaim, w.currency)})`,
+    ];
+    if (w.currentCaClaim > 0)
+        lines.push(`  Current year CA:                    (${fmtAmt(w.currentCaClaim, w.currency)})`);
+    if (w.priorCaClaim > 0)
+        lines.push(`  Unabsorbed CA b/f:                  (${fmtAmt(w.priorCaClaim, w.currency)})`);
+    if (w.enhancedDeductionTotal > 0) {
+        lines.push(`Less: Enhanced deductions:            (${fmtAmt(w.enhancedDeductionTotal, w.currency)})`);
+    }
+    lines.push(`                                     ─────────────────`);
+    lines.push(`Chargeable income before losses:      ${fmtAmt(w.chargeableIncomeBeforeLosses, w.currency)}`);
+    if (w.lossRelief > 0)
+        lines.push(`Less: Trade loss relief:             (${fmtAmt(w.lossRelief, w.currency)})`);
+    if (w.donationRelief > 0)
+        lines.push(`Less: Donation relief:               (${fmtAmt(w.donationRelief, w.currency)})`);
+    lines.push(`                                     ─────────────────`);
+    lines.push(`Chargeable income:                    ${fmtAmt(w.chargeableIncome, w.currency)}`);
+    if (w.exemptAmount > 0) {
+        lines.push(`Less: ${w.exemptionType.toUpperCase()} exemption:              (${fmtAmt(w.exemptAmount, w.currency)})`);
+        lines.push(`Taxable income:                       ${fmtAmt(w.taxableIncome, w.currency)}`);
+    }
+    lines.push('');
+    lines.push(`Tax @ 17%:                            ${fmtAmt(w.grossTax, w.currency)}`);
+    if (w.citRebate > 0)
+        lines.push(`Less: CIT rebate (YA ${w.ya}):           (${fmtAmt(w.citRebate, w.currency)})`);
+    lines.push(`                                     ═════════════════`);
+    lines.push(`NET TAX PAYABLE:                      ${fmtAmt(w.netTaxPayable, w.currency)}`);
+    if (w.unabsorbedLosses > 0 || w.unabsorbedCapitalAllowances > 0 || w.unabsorbedDonations > 0) {
+        lines.push('');
+        lines.push('Carry-forwards to next YA:');
+        if (w.unabsorbedLosses > 0)
+            lines.push(`  Unabsorbed trade losses:            ${fmtAmt(w.unabsorbedLosses, w.currency)}`);
+        if (w.unabsorbedCapitalAllowances > 0)
+            lines.push(`  Unabsorbed capital allowances:      ${fmtAmt(w.unabsorbedCapitalAllowances, w.currency)}`);
+        if (w.unabsorbedDonations > 0)
+            lines.push(`  Unabsorbed donations:               ${fmtAmt(w.unabsorbedDonations, w.currency)}`);
+    }
+    return lines.join('\n');
+}

package/dist/tax/sg/format-sg.js

@@ -0,0 +1,134 @@
+/**
+ * Singapore tax result formatters.
+ * Professional-grade tax computation schedule and CA schedule output.
+ */
+import chalk from 'chalk';
+const fmt = (n) => n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+const fmtR = (n) => fmt(Math.abs(n)).padStart(16);
+const line = (w) => chalk.dim('─'.repeat(w));
+const dline = (w) => chalk.dim('═'.repeat(w));
+// ── Form C-S / C-S Lite ──────────────────────────────────────────
+export function printFormCsResult(result) {
+    const W = 80;
+    const ccy = result.currency;
+    console.log();
+    console.log(chalk.bold(`SINGAPORE CORPORATE INCOME TAX COMPUTATION — YA ${result.ya}`));
+    console.log(line(W));
+    console.log(`  Form type:      ${chalk.bold(result.formType)}${result.eligible ? chalk.green(' ✓ Eligible') : chalk.red(' ✗ Not eligible')}`);
+    console.log(`  Basis period:   ${result.basisPeriod}`);
+    console.log(`  Currency:       ${ccy}`);
+    console.log(line(W));
+    // Tax computation schedule
+    console.log();
+    console.log(chalk.bold('TAX COMPUTATION SCHEDULE'));
+    console.log(line(W));
+    for (const entry of result.schedule) {
+        printScheduleLine(entry, ccy, W);
+    }
+    console.log(dline(W));
+    // Carry-forwards
+    if (result.unabsorbedLosses > 0 || result.unabsorbedCapitalAllowances > 0 || result.unabsorbedDonations > 0) {
+        console.log();
+        console.log(chalk.bold('CARRY-FORWARDS TO NEXT YA'));
+        console.log(line(W));
+        if (result.unabsorbedLosses > 0) {
+            console.log(`  Unabsorbed trade losses:          ${ccy} ${fmtR(result.unabsorbedLosses)}`);
+        }
+        if (result.unabsorbedCapitalAllowances > 0) {
+            console.log(`  Unabsorbed capital allowances:    ${ccy} ${fmtR(result.unabsorbedCapitalAllowances)}`);
+        }
+        if (result.unabsorbedDonations > 0) {
+            console.log(`  Unabsorbed donations:             ${ccy} ${fmtR(result.unabsorbedDonations)}`);
+        }
+    }
+    // Form C-S field mapping
+    console.log();
+    console.log(chalk.bold(`FORM ${result.formType} FIELD MAPPING`));
+    console.log(line(W));
+    for (const f of result.formFields) {
+        const val = typeof f.value === 'number' ? `${ccy} ${fmt(f.value)}` : String(f.value);
+        console.log(`  Box ${String(f.box).padStart(2)}: ${f.label.padEnd(35)} ${val}`);
+        console.log(chalk.dim(`         ${f.source}`));
+    }
+    // Workings
+    console.log();
+    console.log(chalk.bold('WORKINGS'));
+    console.log(line(W));
+    for (const l of result.workings.split('\n')) {
+        console.log(`  ${l}`);
+    }
+    console.log();
+}
+function printScheduleLine(entry, ccy, _w) {
+    const indent = entry.indent ?? 0;
+    const prefix = '  '.repeat(indent + 1);
+    const label = entry.label;
+    const ref = entry.reference ? chalk.dim(` (${entry.reference})`) : '';
+    // Main lines are bold, sub-items are dim
+    if (indent === 0) {
+        const isSubtotal = label.includes('Adjusted profit') || label.includes('Chargeable income') ||
+            label.includes('Taxable income') || label.includes('Net tax payable') ||
+            label.includes('Tax @');
+        const formatted = `${prefix}${label.padEnd(45 - indent * 2)}${ccy} ${fmtR(entry.amount)}${ref}`;
+        if (isSubtotal) {
+            console.log(chalk.bold(formatted));
+        }
+        else {
+            console.log(formatted);
+        }
+    }
+    else {
+        console.log(chalk.dim(`${prefix}${label.padEnd(43 - indent * 2)}${ccy} ${fmtR(entry.amount)}${ref}`));
+    }
+}
+// ── Capital Allowance Schedule ────────────────────────────────────
+export function printCaResult(result) {
+    const W = 110;
+    const ccy = result.currency;
+    console.log();
+    console.log(chalk.bold(`CAPITAL ALLOWANCE SCHEDULE — YA ${result.ya}`));
+    console.log(line(W));
+    // Header row
+    const header = [
+        'Description'.padEnd(25),
+        'Section'.padEnd(10),
+        'Cost'.padStart(14),
+        'Prior Claimed'.padStart(14),
+        'Current YA'.padStart(14),
+        'Total Claimed'.padStart(14),
+        'Remaining'.padStart(14),
+    ].join('  ');
+    console.log(chalk.dim(header));
+    console.log(line(W));
+    for (const row of result.assets) {
+        const cols = [
+            row.description.slice(0, 25).padEnd(25),
+            row.section.padEnd(10),
+            fmt(row.cost).padStart(14),
+            fmt(row.totalClaimedPrior).padStart(14),
+            fmt(row.currentYearClaim).padStart(14),
+            fmt(row.totalClaimedToDate).padStart(14),
+            fmt(row.remainingUnabsorbed).padStart(14),
+        ].join('  ');
+        console.log(cols);
+    }
+    console.log(line(W));
+    // Totals
+    console.log();
+    console.log(`  Current year CA:             ${ccy} ${fmt(result.totalCurrentYearClaim)}`);
+    console.log(`  Unabsorbed CA b/f:           ${ccy} ${fmt(result.unabsorbedBroughtForward)}`);
+    console.log(chalk.bold(`  Total CA available:          ${ccy} ${fmt(result.totalAvailable)}`));
+    if (result.lowValueCapped) {
+        console.log();
+        console.log(chalk.yellow(`  Note: Low-value asset claims capped at ${ccy} 30,000.00 per YA`));
+        console.log(chalk.yellow(`  (${result.lowValueCount} low-value assets, total ${ccy} ${fmt(result.lowValueTotal)} claimed)`));
+    }
+    // Workings
+    console.log();
+    console.log(chalk.bold('WORKINGS'));
+    console.log(line(W));
+    for (const l of result.workings.split('\n')) {
+        console.log(`  ${l}`);
+    }
+    console.log();
+}

package/dist/tax/types.js

@@ -0,0 +1,9 @@
+/**
+ * Types for jaz tax — Singapore Form C-S corporate income tax computation.
+ */
+import { round2 } from '../calc/types.js';
+export { round2 };
+export const ASSET_CATEGORIES = [
+    'computer', 'automation', 'low-value', 'general', 'ip', 'renovation',
+];
+export const EXEMPTION_TYPES = ['sute', 'pte', 'none'];

package/dist/tax/validate.js

@@ -0,0 +1,124 @@
+/**
+ * Input validation for jaz tax computations.
+ * Throws TaxValidationError with user-friendly messages.
+ */
+import { EXEMPTION_TYPES, ASSET_CATEGORIES } from './types.js';
+export class TaxValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TaxValidationError';
+    }
+}
+export function validateYa(ya) {
+    if (!Number.isFinite(ya) || !Number.isInteger(ya)) {
+        throw new TaxValidationError(`Year of Assessment must be an integer (got ${ya})`);
+    }
+    if (ya < 2020 || ya > 2100) {
+        throw new TaxValidationError(`Year of Assessment must be between 2020 and 2100 (got ${ya})`);
+    }
+}
+export function validateNonNegative(value, name) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TaxValidationError(`${name} must be zero or positive (got ${value})`);
+    }
+}
+export function validatePositive(value, name) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new TaxValidationError(`${name} must be a positive number (got ${value})`);
+    }
+}
+export function validateExemptionType(type) {
+    if (!EXEMPTION_TYPES.includes(type)) {
+        throw new TaxValidationError(`Invalid exemption type: "${type}". Must be one of: ${EXEMPTION_TYPES.join(', ')}`);
+    }
+}
+export function validateAssetCategory(cat) {
+    if (!ASSET_CATEGORIES.includes(cat)) {
+        throw new TaxValidationError(`Invalid asset category: "${cat}". Must be one of: ${ASSET_CATEGORIES.join(', ')}`);
+    }
+}
+export function validateDateFormat(date, name) {
+    const m = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!m) {
+        throw new TaxValidationError(`${name} must be YYYY-MM-DD format (got "${date}")`);
+    }
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    const da = Number(m[3]);
+    const d = new Date(Date.UTC(y, mo - 1, da));
+    if (d.getUTCFullYear() !== y || d.getUTCMonth() !== mo - 1 || d.getUTCDate() !== da) {
+        throw new TaxValidationError(`Invalid ${name}: "${date}"`);
+    }
+}
+/** Validate the full SgFormCsInput structure. */
+export function validateFormCsInput(input) {
+    validateYa(input.ya);
+    validateDateFormat(input.basisPeriodStart, 'basisPeriodStart');
+    validateDateFormat(input.basisPeriodEnd, 'basisPeriodEnd');
+    if (input.basisPeriodStart > input.basisPeriodEnd) {
+        throw new TaxValidationError(`basisPeriodStart (${input.basisPeriodStart}) must be on or before basisPeriodEnd (${input.basisPeriodEnd})`);
+    }
+    validateNonNegative(input.revenue, 'revenue');
+    // accountingProfit can be negative (loss)
+    // Add-backs — all must be non-negative
+    const ab = input.addBacks;
+    validateNonNegative(ab.depreciation, 'addBacks.depreciation');
+    validateNonNegative(ab.amortization, 'addBacks.amortization');
+    validateNonNegative(ab.rouDepreciation, 'addBacks.rouDepreciation');
+    validateNonNegative(ab.leaseInterest, 'addBacks.leaseInterest');
+    validateNonNegative(ab.generalProvisions, 'addBacks.generalProvisions');
+    validateNonNegative(ab.donations, 'addBacks.donations');
+    validateNonNegative(ab.entertainment, 'addBacks.entertainment');
+    validateNonNegative(ab.penalties, 'addBacks.penalties');
+    validateNonNegative(ab.privateCar, 'addBacks.privateCar');
+    validateNonNegative(ab.capitalExpOnPnl, 'addBacks.capitalExpOnPnl');
+    validateNonNegative(ab.unrealizedFxLoss, 'addBacks.unrealizedFxLoss');
+    validateNonNegative(ab.otherNonDeductible, 'addBacks.otherNonDeductible');
+    // Deductions — all must be non-negative
+    const ded = input.deductions;
+    validateNonNegative(ded.actualLeasePayments, 'deductions.actualLeasePayments');
+    validateNonNegative(ded.unrealizedFxGain, 'deductions.unrealizedFxGain');
+    validateNonNegative(ded.exemptDividends, 'deductions.exemptDividends');
+    validateNonNegative(ded.exemptIncome, 'deductions.exemptIncome');
+    validateNonNegative(ded.otherDeductions, 'deductions.otherDeductions');
+    // Capital allowances
+    validateNonNegative(input.capitalAllowances.currentYearClaim, 'capitalAllowances.currentYearClaim');
+    validateNonNegative(input.capitalAllowances.balanceBroughtForward, 'capitalAllowances.balanceBroughtForward');
+    // Enhanced deductions
+    const ed = input.enhancedDeductions;
+    validateNonNegative(ed.rdExpenditure, 'enhancedDeductions.rdExpenditure');
+    validateNonNegative(ed.ipRegistration, 'enhancedDeductions.ipRegistration');
+    validateNonNegative(ed.donations250Base, 'enhancedDeductions.donations250Base');
+    validateNonNegative(ed.s14qRenovation, 'enhancedDeductions.s14qRenovation');
+    // Carry-forwards
+    validateNonNegative(input.losses.broughtForward, 'losses.broughtForward');
+    validateNonNegative(input.donationsCarryForward.broughtForward, 'donationsCarryForward.broughtForward');
+    validateExemptionType(input.exemptionType);
+}
+/** Validate the SgCapitalAllowanceInput structure. */
+export function validateCaInput(input) {
+    validateYa(input.ya);
+    validateNonNegative(input.unabsorbedBroughtForward, 'unabsorbedBroughtForward');
+    if (!Array.isArray(input.assets) || input.assets.length === 0) {
+        throw new TaxValidationError('At least one asset is required');
+    }
+    for (let i = 0; i < input.assets.length; i++) {
+        const asset = input.assets[i];
+        validatePositive(asset.cost, `assets[${i}].cost`);
+        validateDateFormat(asset.acquisitionDate, `assets[${i}].acquisitionDate`);
+        validateAssetCategory(asset.category);
+        validateNonNegative(asset.priorYearsClaimed, `assets[${i}].priorYearsClaimed`);
+        if (asset.priorYearsClaimed > asset.cost) {
+            throw new TaxValidationError(`assets[${i}].priorYearsClaimed (${asset.priorYearsClaimed}) exceeds cost (${asset.cost})`);
+        }
+        if (asset.category === 'ip' && asset.ipWriteOffYears != null) {
+            const valid = [5, 10, 15];
+            if (!valid.includes(asset.ipWriteOffYears)) {
+                throw new TaxValidationError(`assets[${i}].ipWriteOffYears must be 5, 10, or 15 (got ${asset.ipWriteOffYears})`);
+            }
+        }
+        if (asset.category === 'low-value' && asset.cost > 5000) {
+            throw new TaxValidationError(`assets[${i}] is 'low-value' but cost (${asset.cost}) exceeds $5,000 threshold`);
+        }
+    }
+}

package/dist/types/index.js

@@ -1,6 +1,7 @@
-export const SKILL_TYPES = ['api', 'conversion', 'transaction-recipes', 'all'];
+export const SKILL_TYPES = ['api', 'conversion', 'transaction-recipes', 'jobs', 'all'];
 export const SKILL_DESCRIPTIONS = {
     api: 'Jaz/Juan REST API reference — 55 rules, endpoint catalog, error catalog, field mapping',
     conversion: 'Data conversion pipeline — Xero, QuickBooks, Sage, Excel migration to Jaz',
     'transaction-recipes': 'Complex accounting recipes — prepaid, deferred revenue, loans, IFRS 16, depreciation',
+    jobs: 'Accounting job blueprints — month/quarter/year-end close + 7 ad-hoc operational workflows',
 };

package/dist/utils/template.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // From dist/utils/template.js -> ../../assets (two levels up to cli/, then assets/)
 const ASSETS_DIR = join(__dirname, '..', '..', 'assets');
-const SKILLS = ['api', 'conversion', 'transaction-recipes'];
+const SKILLS = ['api', 'conversion', 'transaction-recipes', 'jobs'];
 async function exists(path) {
     try {
         await access(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaz-cli",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "CLI to install Jaz AI skills for Claude Code",
   "type": "module",
   "bin": {