@huicai/cli 2026.814.0 → 2026.1019.0

package/skills/report-craft/scripts/fin_model.py

@@ -0,0 +1,602 @@
+#!/usr/bin/env python3
+# 财务测算引擎：假设（JSON）→ 投资估算表 / 项目投资现金流量表 / 财务评价指标（NPV·IRR·回收期·总投资收益率）/
+# 情景分析 / 敏感性分析（含临界点）/ 结论句 / 可直接交给 render_chart 的图表 spec。只用标准库。
+#
+# ── 为什么要有它 ──
+# 可研报告最常见的硬伤是「数字对不上、口径不对」，而这恰恰是模型心算最容易错的地方。实测（HuiCai 可研基线）：
+#   · 静态回收期拿「收入」去除总投资——没扣经营成本，回收期被严重低估；
+#   · 「内部模型调用节约 60 万元/年」，而整个项目的模型调用预算才 22 万元——节约额比被节约的支出还大；
+#   · 模板要求的净现值、内部收益率、敏感性分析一个都没有。
+# 这些不是文笔问题，是计算问题。计算交给引擎：模型只给假设和依据，数字由这里算、表由这里排，
+# 全文引用的每个数都来自同一次计算，前后不可能矛盾。
+#
+# ── 口径（按《建设项目经济评价方法与参数》（第三版）融资前分析；notes 里原样写给评审）──
+#   · 计算期 = 建设期 m 年 + 运营期 n 年，年序 1..m+n；现金流按年末发生（年末习惯法），折现到第 1 年初；
+#   · 所得税前净现金流量 = 营业收入 + 成本节约 + 回收余值 − 建设投资 − 经营成本；
+#   · 调整所得税 = 息税前利润 × 税率，息税前利润 = 收入 + 节约 − 经营成本 − 折旧摊销（建设投资按直线法摊销），
+#     亏损向后结转 5 年弥补；所得税后净现金流量 = 税前 − 调整所得税；
+#   · 成本节约 = 被节约的那项支出 × 节约比例——**节约额永远不会超过被节约的支出本身**；
+#   · 投资回收期含建设期：T − 1 + |第 T−1 年累计净现金流量| ÷ 第 T 年净现金流量；
+#   · 敏感性：各因素单独 ±10%/±20%（折现率 ±2 个百分点），临界点 = 使 NPV 恰为 0 的变动幅度（即 IRR = 基准收益率）。
+#
+# 用法：python fin_model.py <assumptions.json | JSON 文本>     最后一行输出 JSON。
+
+import json
+import math
+import re
+import sys
+
+
+class ModelError(ValueError):
+    """假设写错了：信息要能直接照着改。"""
+
+
+def _num(x, where):
+    try:
+        v = float(x)
+    except (TypeError, ValueError):
+        raise ModelError(f'{where} 不是数字：{x!r}')
+    if math.isnan(v) or math.isinf(v):
+        raise ModelError(f'{where} 不是有限数字：{x!r}')
+    return v
+
+
+def fmt(v, d=2):
+    return '—' if v is None else f'{v:,.{d}f}'
+
+
+def pct(v, d=1):
+    return '—' if v is None else f'{v * 100:.{d}f}%'
+
+
+def yrs(v):
+    return '超出计算期' if v is None else f'{v:.2f} 年'
+
+
+def md(headers, rows):
+    out = ['| ' + ' | '.join(headers) + ' |', '|' + '|'.join(['---'] * len(headers)) + '|']
+    out += ['| ' + ' | '.join(str(c) for c in r) + ' |' for r in rows]
+    return '\n'.join(out)
+
+
+# ── 读假设 ──────────────────────────────────────────────────────────────────
+def _len_hint(got, n, m):
+    """逐年数组长度不对时，猜最常见的原因：把建设期那几年也写进去了。"""
+    if got == n + m:
+        return f'——看起来把建设期 {m} 年也算进去了：逐年数组只写运营期，去掉开头建设期的 {m} 个数'
+    return ''
+
+
+def series_of(item, n, where, is_cost=False, m=1):
+    """一行收入/成本 → 运营期 n 年的逐年数组。支持 values / price×volume / per_year(+growth)。"""
+    if 'values' in item:
+        vals = item['values']
+        if not isinstance(vals, list) or len(vals) != n:
+            got = len(vals) if isinstance(vals, list) else 0
+            raise ModelError(f'{where}.values 要有 {n} 个数（运营期 {n} 年逐年），实际 {got} 个' + _len_hint(got, n, m))
+        return [_num(v, f'{where}.values[{i}]') for i, v in enumerate(vals)]
+    if 'price' in item and 'volume' in item:
+        price = _num(item['price'], f'{where}.price')
+        vol = item['volume']
+        if not isinstance(vol, list) or len(vol) != n:
+            got = len(vol) if isinstance(vol, list) else 0
+            raise ModelError(f'{where}.volume 要有 {n} 个数（运营期逐年销量/客户数），实际 {got} 个' + _len_hint(got, n, m))
+        return [price * _num(v, f'{where}.volume[{i}]') for i, v in enumerate(vol)]
+    if 'per_year' in item:
+        base = _num(item['per_year'], f'{where}.per_year')
+        g = _num(item.get('growth', 0), f'{where}.growth')
+        return [base * (1 + g) ** i for i in range(n)]
+    raise ModelError(f'{where} 要给 values，或 price+volume，或 per_year(+growth)'
+                     + ('，或 pct_of_revenue' if is_cost else ''))
+
+
+def load(spec):
+    if not isinstance(spec, dict):
+        raise ModelError('假设要是一个 JSON 对象')
+    n = int(_num(spec.get('years', 5), 'years'))
+    m = int(_num(spec.get('construction_years', 1), 'construction_years'))
+    if not 1 <= n <= 30:
+        raise ModelError('years（运营期年数）要在 1~30 之间')
+    if not 1 <= m <= 5:
+        raise ModelError('construction_years（建设期年数）要在 1~5 之间')
+    r = _num(spec.get('discount_rate', 0.08), 'discount_rate')
+    if not 0 <= r < 1:
+        raise ModelError('discount_rate 写成小数（8% 写 0.08）')
+    tax = _num(spec.get('tax_rate', 0), 'tax_rate')
+    if not 0 <= tax < 1:
+        raise ModelError('tax_rate 写成小数（高新技术企业 15% 写 0.15；0 = 只做所得税前分析）')
+    dep_years = int(_num(spec.get('depreciation_years', n), 'depreciation_years'))
+    if dep_years < 1:
+        raise ModelError('depreciation_years 至少 1 年')
+
+    inv = spec.get('investment') or []
+    if not inv:
+        raise ModelError('缺 investment（建设投资明细）：[{"name":"研发人员人工","amount":480,"basis":"12人×12月×3.3万元"}]')
+    investment = []
+    for i, it in enumerate(inv):
+        amt = _num(it.get('amount'), f'investment[{i}].amount')
+        if amt < 0:
+            raise ModelError(f'investment[{i}].amount 不能为负')
+        sch = it.get('schedule')
+        if sch is None:
+            sch = [1.0 / m] * m                              # 没写分年计划：建设期内平均投入
+        if not isinstance(sch, list) or len(sch) != m:
+            raise ModelError(f'investment[{i}].schedule 要有 {m} 个比例（建设期逐年投入占比）')
+        sch = [_num(x, f'investment[{i}].schedule') for x in sch]
+        if abs(sum(sch) - 1) > 1e-6:
+            raise ModelError(f'investment[{i}].schedule 各年比例之和要等于 1（现在是 {sum(sch):g}）')
+        investment.append({'name': str(it.get('name') or f'投资项{i + 1}'), 'amount': amt, 'schedule': sch,
+                           'basis': str(it.get('basis', '') or '')})
+
+    revenue = []
+    for i, it in enumerate(spec.get('revenue') or []):
+        revenue.append({'name': str(it.get('name') or f'收入{i + 1}'), 'values': series_of(it, n, f'revenue[{i}]', m=m),
+                        'basis': str(it.get('basis', '') or '')})
+    savings = []
+    for i, it in enumerate(spec.get('savings') or []):
+        base = it.get('base_values')
+        if not isinstance(base, list) or len(base) != n:
+            got = len(base) if isinstance(base, list) else 0
+            raise ModelError(f'savings[{i}] 要给 base_values（被节约的那项支出，运营期逐年 {n} 个数，实际 {got} 个）和 rate——'
+                             '节约额 = 支出 × 比例，没有支出就谈不上节约' + _len_hint(got, n, m))
+        rate = _num(it.get('rate'), f'savings[{i}].rate')
+        if not 0 <= rate <= 1:
+            raise ModelError(f'savings[{i}].rate 要在 0~1 之间（节约 30% 写 0.3）')
+        bv = [_num(v, f'savings[{i}].base_values[{t}]') for t, v in enumerate(base)]
+        savings.append({'name': str(it.get('name') or f'成本节约{i + 1}'), 'base': bv, 'rate': rate,
+                        'values': [b * rate for b in bv], 'basis': str(it.get('basis', '') or '')})
+    if not revenue and not savings:
+        raise ModelError('revenue（营业收入）与 savings（成本节约）至少给一项。'
+                         '既无收入也无可量化节约的公益/内部项目，应改做费用效果分析，不要硬编收入')
+    costs = []
+    for i, it in enumerate(spec.get('costs') or []):
+        p = it.get('pct_of_revenue')
+        if p is not None:
+            p = _num(p, f'costs[{i}].pct_of_revenue')
+            if not 0 <= p <= 1:
+                raise ModelError(f'costs[{i}].pct_of_revenue 要在 0~1 之间（收入的 20% 写 0.2）')
+        costs.append({'name': str(it.get('name') or f'成本{i + 1}'), 'pct': p,
+                      'values': series_of(it, n, f'costs[{i}]', is_cost=True, m=m) if p is None else None,
+                      'basis': str(it.get('basis', '') or '')})
+    scen = spec.get('scenarios') or {}
+    if not isinstance(scen, dict):
+        raise ModelError('scenarios 写成对象：{"乐观":{"revenue":1.2},"悲观":{"revenue":0.7,"costs":1.1}}')
+    for k, v in scen.items():
+        if not isinstance(v, dict) or not set(v) <= {'revenue', 'costs', 'investment', 'savings'}:
+            raise ModelError(f'情景「{k}」只能调 revenue/costs/investment/savings 四个乘数')
+        for kk, vv in v.items():
+            _num(vv, f'scenarios.{k}.{kk}')
+    start = spec.get('start_year')
+    return {
+        'unit': str(spec.get('unit', '万元')), 'n': n, 'm': m, 'r': r, 'tax': tax, 'dep_years': dep_years,
+        'start_year': int(_num(start, 'start_year')) if start is not None else None,
+        'investment': investment, 'revenue': revenue, 'costs': costs, 'savings': savings,
+        'residual': _num(spec.get('residual_value', 0), 'residual_value'), 'scenarios': scen,
+        'decimals': max(0, min(4, int(_num(spec.get('decimals', 2), 'decimals')))),
+    }
+
+
+# ── 计算 ────────────────────────────────────────────────────────────────────
+def cashflows(M, k_rev=1.0, k_cost=1.0, k_inv=1.0, k_sav=1.0, rev_line=None):
+    """按乘数重算一遍现金流。基准、情景、敏感性、临界点全走这一个函数，口径不会分叉。"""
+    m, n = M['m'], M['n']
+    rev_lines = [[v * (k_rev if rev_line in (None, x['name']) else 1.0) for v in x['values']] for x in M['revenue']]
+    rev = [sum(l[j] for l in rev_lines) for j in range(n)]
+    cost_lines = [[(c['pct'] * rev[j] if c['pct'] is not None else c['values'][j]) * k_cost for j in range(n)]
+                  for c in M['costs']]
+    cost = [sum(l[j] for l in cost_lines) for j in range(n)]
+    sav_lines = [[v * k_sav for v in s['values']] for s in M['savings']]
+    sav = [sum(l[j] for l in sav_lines) for j in range(n)]
+    inv_year = [sum(x['amount'] * x['schedule'][k] for x in M['investment']) * k_inv for k in range(m)]
+    inv = sum(inv_year)
+    dep = [inv / M['dep_years'] if j < M['dep_years'] else 0.0 for j in range(n)]
+    ebit = [rev[j] + sav[j] - cost[j] - dep[j] for j in range(n)]
+    tax, pool = [], []                                     # 亏损向后结转 5 年
+    for j, e in enumerate(ebit):
+        if e <= 0:
+            if e < 0:
+                pool.append([j, -e])
+            tax.append(0.0)
+            continue
+        taxable = e
+        for p in pool:
+            if j - p[0] > 5 or p[1] <= 0:
+                continue
+            use = min(p[1], taxable)
+            p[1] -= use
+            taxable -= use
+            if taxable <= 0:
+                break
+        tax.append(taxable * M['tax'])
+    resid = [M['residual'] if j == n - 1 else 0.0 for j in range(n)]
+    pre = [-v for v in inv_year] + [rev[j] + sav[j] + resid[j] - cost[j] for j in range(n)]
+    post = pre[:m] + [pre[m + j] - tax[j] for j in range(n)]
+    return {'rev': rev, 'rev_lines': rev_lines, 'cost': cost, 'cost_lines': cost_lines, 'sav': sav,
+            'sav_lines': sav_lines, 'inv_year': inv_year, 'inv': inv, 'dep': dep, 'ebit': ebit, 'tax': tax,
+            'resid': resid, 'pre': pre, 'post': post}
+
+
+def npv(ncf, r):
+    """年末习惯法：第 t 年（t 从 1 起）的现金流折现 t 年。"""
+    return sum(v / (1 + r) ** (t + 1) for t, v in enumerate(ncf))
+
+
+def irr(ncf):
+    """二分法求 NPV=0 的折现率；无根（如累计始终为负）返回 None——如实说「不存在」，不编数。"""
+    lo, hi = -0.99, 10.0
+    f_lo, f_hi = npv(ncf, lo), npv(ncf, hi)
+    if f_lo == 0:
+        return lo
+    if f_lo * f_hi > 0:
+        return None
+    for _ in range(300):
+        mid = (lo + hi) / 2
+        fm = npv(ncf, mid)
+        if abs(fm) < 1e-10 or hi - lo < 1e-12:
+            return mid
+        if (f_lo < 0) == (fm < 0):
+            lo, f_lo = mid, fm
+        else:
+            hi = mid
+    return (lo + hi) / 2
+
+
+def payback(ncf, r=None):
+    """含建设期的投资回收期：T − 1 + |第 T−1 年累计| ÷ 第 T 年净现金流（T 为累计首次 ≥0 的年序）。收不回返回 None。"""
+    cum = 0.0
+    for t, v in enumerate(ncf):
+        dv = v if r is None else v / (1 + r) ** (t + 1)
+        prev, cum = cum, cum + dv
+        if t > 0 and prev < 0 <= cum:
+            return t + (-prev) / dv
+    return None
+
+
+def indicators(ncf, r):
+    return {'npv': npv(ncf, r), 'irr': irr(ncf), 'payback': payback(ncf), 'payback_dynamic': payback(ncf, r)}
+
+
+def main_ncf(M, cf):
+    return cf['post'] if M['tax'] > 0 else cf['pre']
+
+
+def switching(M, key):
+    """临界点：使主口径 NPV 恰为 0 的因素变动幅度，在 [-99%, +300%] 内二分；找不到返回 None。"""
+    def f(k):
+        kw = {'k_rev': 1.0, 'k_cost': 1.0, 'k_inv': 1.0, 'k_sav': 1.0}
+        if key.startswith('rev:'):
+            kw['k_rev'] = 1 + k
+            return npv(main_ncf(M, cashflows(M, rev_line=key[4:], **kw)), M['r'])
+        kw[key] = 1 + k
+        return npv(main_ncf(M, cashflows(M, **kw)), M['r'])
+    if f(0.0) == 0:
+        return 0.0
+    for a, b in ((-0.99, 0.0), (0.0, 3.0)):
+        fa, fb = f(a), f(b)
+        if fa * fb < 0:
+            for _ in range(100):
+                mid = (a + b) / 2
+                fm = f(mid)
+                if (fm < 0) == (fa < 0):
+                    a, fa = mid, fm
+                else:
+                    b = mid
+            return (a + b) / 2
+    return None
+
+
+def run(spec):
+    M = load(spec)
+    n, m, u, r, d = M['n'], M['m'], M['unit'], M['r'], M['decimals']
+    T = m + n
+    has_tax = M['tax'] > 0
+    basis = '所得税后' if has_tax else '所得税前'
+    base = cashflows(M)
+    ind_pre = indicators(base['pre'], r)
+    ind_post = indicators(base['post'], r) if has_tax else None
+    ind = ind_post or ind_pre
+    avg_ebit = sum(base['ebit']) / n
+    roi = avg_ebit / base['inv'] if base['inv'] else None
+
+    def f(v):
+        return fmt(v, d)
+
+    years = [str(M['start_year'] + t) if M['start_year'] else f'第{t + 1}年' for t in range(T)]
+
+    # ── 预警：不改数，只提醒哪里评审会追问 ──
+    warnings = []
+    if not M['costs']:
+        warnings.append('没有列经营成本：回收期与 NPV 会按「收入全是净收益」算，严重高估——至少列人员、云资源/算力、模型调用、运维与销售')
+    elif sum(base['rev']) > 0 and sum(base['cost']) < 0.15 * sum(base['rev']):
+        warnings.append(f'经营成本只占营业收入的 {pct(sum(base["cost"]) / sum(base["rev"]))}，偏低——'
+                        'AI 类产品的模型调用、算力、运维人员、销售与服务费用要逐项列全')
+    if ind['npv'] < 0:
+        warnings.append(f'{basis} NPV 为 {f(ind["npv"])} {u} < 0：按当前假设财务上不可行——结论写「不可行」或'
+                        '「有条件可行」并写清条件，不要为了结论去改假设')
+    if ind['irr'] is None:
+        warnings.append('内部收益率不存在（累计净现金流始终为负）：如实写「IRR 不存在」，不要编一个数')
+    elif ind['irr'] > 1:
+        warnings.append(f'IRR 高达 {pct(ind["irr"])}：通常是投资漏列或收入假设过于乐观，评审一定会追问依据')
+    if ind['payback'] is None:
+        warnings.append(f'计算期 {T} 年内收不回投资：回收期写「超出计算期」')
+    for s in M['savings']:
+        if s['rate'] > 0.5:
+            warnings.append(f'「{s["name"]}」节约比例 {pct(s["rate"], 0)}，超过一半——要有实测或试点数据支撑，否则评审不会采信')
+    for x in M['revenue']:
+        v = x['values']
+        for j in range(1, n):
+            if v[j - 1] > 0 and v[j] / v[j - 1] > 3:
+                warnings.append(f'收入「{x["name"]}」运营第 {j + 1} 年是上一年的 {v[j] / v[j - 1]:.1f} 倍：要写清增长依据（渠道、签约、试点转化）')
+                break
+    if sum(base['sav']) > sum(base['rev']) > 0:
+        warnings.append('成本节约合计大于营业收入合计：效益主要靠「省钱」，文中要写清节约的来源与测量方法')
+    # 情景方向要自洽。实测模型不知道「按收入比例的成本会自动随收入变」，为了让上游成本跟着收入降，
+    # 给悲观情景设了 costs ×0.8——得到一个「收入降 40%、成本降 20%」的悲观情景，写进报告就是笑话。
+    has_pct = any(c['pct'] is not None for c in M['costs'])
+    for name, mult in M['scenarios'].items():
+        kr, kc = float(mult.get('revenue', 1)), float(mult.get('costs', 1))
+        bad = re.search(r'悲观|保守|下行|不利|压力', name)
+        good = re.search(r'乐观|上行|有利', name)
+        if bad and (kc < 1 or kr > 1):
+            warnings.append(f'「{name}」情景的方向不对（收入×{kr:g}、经营成本×{kc:g}）：悲观情景应是收入 ≤1、成本 ≥1。'
+                            + ('按收入比例列的成本（pct_of_revenue）已经随收入自动下降，不用再把 costs 调低来「跟随」——' if has_pct and kc < 1 else '')
+                            + '改完重算，别把方向相反的情景写进报告')
+        if good and (kc > 1 or kr < 1):
+            warnings.append(f'「{name}」情景的方向不对（收入×{kr:g}、经营成本×{kc:g}）：乐观情景应是收入 ≥1、成本 ≤1'
+                            + ('（按收入比例的成本会随收入自动上升，不必再调高 costs）' if has_pct and kc > 1 else '') + '，改完重算')
+
+    # ── 1) 投资估算表 ──
+    inv_total = base['inv']
+    head = ['序号', '工程或费用名称', f'金额（{u}）', '占比']
+    if m > 1:
+        head += [years[k] for k in range(m)]
+    head.append('估算依据')
+    rows = []
+    for i, x in enumerate(M['investment']):
+        row = [str(i + 1), x['name'], f(x['amount']), pct(x['amount'] / inv_total if inv_total else 0)]
+        if m > 1:
+            row += [f(x['amount'] * s) for s in x['schedule']]
+        rows.append(row + [x['basis'] or '—'])
+    tot = ['', '合计', f(inv_total), '100.0%']
+    if m > 1:
+        tot += [f(v) for v in base['inv_year']]
+    rows.append(tot + [''])
+    t_inv = md(head, rows)
+
+    # ── 2) 项目投资现金流量表（序号/项目/合计/逐年）──
+    def line(no, name, vals_full):
+        return [no, name, f(sum(vals_full))] + [f(v) if v != 0 else '—' for v in vals_full]
+
+    def ops(vals):                                         # 运营期数组 → 计算期数组（建设期补 0）
+        return [0.0] * m + list(vals)
+
+    def cumsum(vals):
+        out, acc = [], 0.0
+        for v in vals:
+            acc += v
+            out.append(acc)
+        return out
+
+    rows = []
+    cin = [0.0] * m + [base['rev'][j] + base['sav'][j] + base['resid'][j] for j in range(n)]
+    rows.append(line('1', '现金流入', cin))
+    k = 1
+    for x, l in zip(M['revenue'], base['rev_lines']):
+        rows.append(line(f'1.{k}', f'营业收入：{x["name"]}', ops(l)))
+        k += 1
+    for s, l in zip(M['savings'], base['sav_lines']):
+        rows.append(line(f'1.{k}', f'成本节约：{s["name"]}', ops(l)))
+        k += 1
+    if M['residual']:
+        rows.append(line(f'1.{k}', '回收资产余值', ops(base['resid'])))
+    cout = [base['inv_year'][t] if t < m else base['cost'][t - m] for t in range(T)]
+    rows.append(line('2', '现金流出', cout))
+    rows.append(line('2.1', '建设投资', base['inv_year'] + [0.0] * n))
+    for i, (c, l) in enumerate(zip(M['costs'], base['cost_lines'])):
+        rows.append(line(f'2.{i + 2}', f'经营成本：{c["name"]}', ops(l)))
+    cum_pre = cumsum(base['pre'])
+    rows.append(line('3', '所得税前净现金流量（1−2）', base['pre']))
+    rows.append(['4', '累计所得税前净现金流量', '—'] + [f(v) for v in cum_pre])
+    cum_main = cum_pre
+    if has_tax:
+        cum_post = cumsum(base['post'])
+        rows.append(line('5', f'调整所得税（{pct(M["tax"], 0)}）', ops(base['tax'])))
+        rows.append(line('6', '所得税后净现金流量（3−5）', base['post']))
+        rows.append(['7', '累计所得税后净现金流量', '—'] + [f(v) for v in cum_post])
+        cum_main = cum_post
+    main = main_ncf(M, base)
+    disc = [v / (1 + r) ** (t + 1) for t, v in enumerate(main)]
+    cum_disc = cumsum(disc)
+    no = 8 if has_tax else 5
+    rows.append([str(no), f'折现系数（i={pct(r, 0)}）', '—'] + [f'{1 / (1 + r) ** (t + 1):.4f}' for t in range(T)])
+    rows.append([str(no + 1), f'{basis}折现净现金流量', f(sum(disc))] + [f(v) for v in disc])
+    rows.append([str(no + 2), f'累计{basis}折现净现金流量', '—'] + [f(v) for v in cum_disc])
+    t_cf = md(['序号', '项目', '合计'] + years, rows)
+
+    # ── 3) 财务评价指标表 ──
+    def ind_rows(tag, ii):
+        return [
+            [f'项目投资财务净现值（{tag}，i={pct(r, 0)}）', f'{f(ii["npv"])} {u}', 'FNPV ≥ 0 可行'],
+            [f'项目投资财务内部收益率（{tag}）', pct(ii['irr'], 2) if ii['irr'] is not None else '不存在',
+             f'FIRR ≥ 基准收益率 {pct(r, 0)} 可行'],
+            [f'静态投资回收期（{tag}，含建设期）', yrs(ii['payback']), f'计算期 {T} 年'],
+            [f'动态投资回收期（{tag}，含建设期）', yrs(ii['payback_dynamic']), '按折现后的累计净现金流量'],
+        ]
+    rows = ind_rows('所得税前', ind_pre)
+    if has_tax:
+        rows += ind_rows('所得税后', ind_post)
+    rows.append(['总投资收益率（运营期年均息税前利润 ÷ 总投资）', pct(roi), '与行业参考值比较'])
+    t_ind = md(['指标', '数值', '判据'], rows)
+
+    # ── 4) 情景分析 ──
+    scen_def = {'基准': {}}
+    scen_def.update(M['scenarios'])
+    rows, scen_out, scen_desc = [], {}, {}
+    labels = (('revenue', '收入'), ('costs', '经营成本'), ('investment', '投资'), ('savings', '节约'))
+    for name, mult in scen_def.items():
+        kw = {'k_rev': float(mult.get('revenue', 1)), 'k_cost': float(mult.get('costs', 1)),
+              'k_inv': float(mult.get('investment', 1)), 'k_sav': float(mult.get('savings', 1))}
+        ii = indicators(main_ncf(M, cashflows(M, **kw)), r)
+        scen_out[name] = ii
+        desc = '、'.join(f'{lab}{(float(mult[key]) - 1) * 100:+.0f}%' for key, lab in labels
+                        if key in mult and float(mult[key]) != 1) or '全部按基准假设'
+        scen_desc[name] = desc
+        rows.append([name, desc, f(ii['npv']), pct(ii['irr'], 2) if ii['irr'] is not None else '不存在',
+                     yrs(ii['payback'])])
+    t_scen = md(['情景', '假设调整', f'NPV（{basis}，{u}）', f'FIRR（{basis}）', '静态回收期'], rows)
+
+    # ── 5) 敏感性分析 ──
+    factors = []
+    if M['revenue']:
+        factors.append(('k_rev', '营业收入'))
+    if M['costs']:
+        factors.append(('k_cost', '经营成本'))
+    factors.append(('k_inv', '建设投资'))
+    if M['savings']:
+        factors.append(('k_sav', '成本节约'))
+    if len(M['revenue']) > 1:
+        factors += [(f'rev:{x["name"]}', f'其中：{x["name"]}') for x in M['revenue']]
+    steps = [-0.2, -0.1, 0.1, 0.2]
+    rows, tornado, sens = [], [], []
+    for key, lab in factors:
+        vals = []
+        for st in steps:
+            kw = {'k_rev': 1.0, 'k_cost': 1.0, 'k_inv': 1.0, 'k_sav': 1.0}
+            if key.startswith('rev:'):
+                kw['k_rev'] = 1 + st
+                cf = cashflows(M, rev_line=key[4:], **kw)
+            else:
+                kw[key] = 1 + st
+                cf = cashflows(M, **kw)
+            vals.append(npv(main_ncf(M, cf), r))
+        coef = ((vals[2] - vals[1]) / 0.2) / ind['npv'] if ind['npv'] else None
+        sw = switching(M, key)
+        sens.append({'factor': lab, 'coef': coef, 'switch': sw})
+        if sw is not None:
+            sw_txt = f'{sw * 100:+.1f}%'
+        elif (coef or 0) >= 0:                             # 正向因素：往下压到头 NPV 仍不变号
+            sw_txt = '减少 99% 仍不转负' if ind['npv'] >= 0 else '增加 300% 仍为负'
+        else:
+            sw_txt = '增加 300% 仍不转负' if ind['npv'] >= 0 else '减少 99% 仍为负'
+        rows.append([lab] + [f(v) for v in vals] + [f'{coef:.2f}' if coef is not None else '—', sw_txt])
+        if not key.startswith('rev:'):                     # 龙卷风只画总因素，分项留在表里
+            tornado.append({'name': lab, 'low': round(vals[0], d), 'high': round(vals[3], d),
+                            'low_label': '-20%', 'high_label': '+20%'})
+    lo_r, hi_r = max(r - 0.02, 0.0), r + 0.02
+    dr_lo, dr_hi = npv(main, lo_r), npv(main, hi_r)
+    tornado.append({'name': '基准收益率', 'low': round(dr_lo, d), 'high': round(dr_hi, d),
+                    'low_label': pct(lo_r, 0), 'high_label': pct(hi_r, 0)})
+    t_sens = md(['因素', '-20%', '-10%', '+10%', '+20%', '敏感度系数', '临界点（NPV=0）'], rows)
+    # 折现率不是「±10%」那种变动，单独一句，免得挤进同一列被误读
+    t_sens += (f'\n\n表中数值为{basis}财务净现值（{u}），基准情景 {f(ind["npv"])} {u}。基准收益率取 {pct(lo_r, 0)} / {pct(hi_r, 0)} 时，'
+               f'NPV 分别为 {f(dr_lo)} / {f(dr_hi)} {u}'
+               + (f'；折现率升至 {pct(ind["irr"], 2)}（即 FIRR）时 NPV 为 0。' if ind['irr'] is not None else '。'))
+
+    # ── 图表 spec（原样交给 render_chart）──
+    charts = {
+        'investment_composition': {'type': 'pie', 'unit': u, 'categories': [x['name'] for x in M['investment']],
+                                   'series': [{'name': '建设投资', 'values': [round(x['amount'], d) for x in M['investment']]}]},
+        'investment_waterfall': {'type': 'waterfall', 'unit': u, 'total_label': '总投资',
+                                 'items': [{'name': x['name'], 'value': round(x['amount'], d)} for x in M['investment']]},
+        'cumulative_cashflow': {'type': 'line', 'unit': u, 'categories': years,
+                                'series': [{'name': f'累计{basis}净现金流量', 'values': [round(v, d) for v in cum_main]},
+                                           {'name': f'累计{basis}折现净现金流量', 'values': [round(v, d) for v in cum_disc]}]},
+        'sensitivity_tornado': {'type': 'tornado', 'metric': f'{basis}NPV', 'unit': u, 'base': round(ind['npv'], d),
+                                'items': tornado},
+    }
+    if M['revenue']:
+        op_years = years[m:]
+        if len(M['revenue']) > 1:
+            charts['revenue_by_line'] = {'type': 'stacked', 'unit': u, 'categories': op_years,
+                                         'series': [{'name': x['name'], 'values': [round(v, d) for v in l]}
+                                                    for x, l in zip(M['revenue'], base['rev_lines'])]}
+        if M['costs']:
+            charts['revenue_vs_cost'] = {'type': 'bar', 'unit': u, 'categories': op_years,
+                                         'series': [{'name': '营业收入', 'values': [round(v, d) for v in base['rev']]},
+                                                    {'name': '经营成本', 'values': [round(v, d) for v in base['cost']]}]}
+
+    # ── 口径说明（原样写进报告，评审能照着复核）──
+    notes = [
+        f'计算期 {T} 年：建设期 {m} 年（{years[0]}{"–" + years[m - 1] if m > 1 else ""}），运营期 {n} 年'
+        f'（{years[m]}{"–" + years[-1] if n > 1 else ""}）；金额单位 {u}；现金流按年末发生，折现到计算期第 1 年初；'
+        f'基准收益率 {pct(r, 1)}。',
+        '所得税前净现金流量 = 营业收入 + 成本节约 + 回收资产余值 − 建设投资 − 经营成本。',
+    ]
+    if has_tax:
+        notes.append(f'调整所得税 = 息税前利润 × {pct(M["tax"], 0)}；息税前利润 = 营业收入 + 成本节约 − 经营成本 − 摊销，'
+                     f'建设投资按 {M["dep_years"]} 年直线法摊销、残值为 0，亏损向后结转 5 年弥补。')
+    else:
+        notes.append('未计所得税（所得税前分析）；如需所得税后指标，给出适用税率后重算。')
+    for x in M['revenue']:
+        if x['basis']:
+            notes.append(f'营业收入「{x["name"]}」：{x["basis"]}。')
+    for c in M['costs']:
+        if c['pct'] is not None:
+            notes.append(f'经营成本「{c["name"]}」按营业收入的 {pct(c["pct"], 0)} 计' + (f'：{c["basis"]}' if c['basis'] else '') + '。')
+        elif c['basis']:
+            notes.append(f'经营成本「{c["name"]}」：{c["basis"]}。')
+    for s in M['savings']:
+        notes.append(f'成本节约「{s["name"]}」= 被节约的支出 × {pct(s["rate"], 0)}' + (f'（{s["basis"]}）' if s['basis'] else '')
+                     + f'；被节约支出逐年为 {"、".join(f(v) for v in s["base"])} {u}，节约额不超过支出本身。')
+    if any(c['pct'] is not None for c in M['costs']):
+        notes.append('按营业收入比例计的经营成本，在情景分析与敏感性分析中随营业收入同步变动；'
+                     '「经营成本」因素的调整乘在全部经营成本之上。')
+    notes.append('敏感性分析每次只变动一个因素、其余保持基准；临界点为使 NPV 恰为 0 的变动幅度。')
+
+    # ── 结论句（正文直接引用，保证与表一致）──
+    top = max(sens, key=lambda s: abs(s['coef'] or 0)) if sens else None
+    feasible = ind['npv'] >= 0 and ind['irr'] is not None and ind['irr'] >= r
+    concl = (f'按基准假设，项目总投资 {f(inv_total)} {u}，{basis}财务净现值 {f(ind["npv"])} {u}'
+             f'（i={pct(r, 0)}），财务内部收益率 {pct(ind["irr"], 2) if ind["irr"] is not None else "不存在"}，'
+             f'静态投资回收期 {yrs(ind["payback"])}（含建设期 {m} 年），动态投资回收期 {yrs(ind["payback_dynamic"])}；')
+    concl += '财务上可行。' if feasible else '按当前假设财务上不可行。'
+    if top and top['switch'] is not None and top['coef']:
+        concl += (f'{top["factor"]}是最敏感的因素（敏感度系数 {top["coef"]:.2f}），'
+                  f'{"下降" if top["switch"] < 0 else "上升"} {abs(top["switch"]) * 100:.1f}% 时 NPV 降为 0。')
+
+    bad = [(k, v) for k, v in scen_out.items() if k != '基准' and v['npv'] < 0]
+    if bad and feasible:                                   # 结论「可行」不能盖住下行情景转负
+        concl += '；'.join(f'在「{k}」情景（{scen_desc[k]}）下 NPV 为 {f(v["npv"])} {u}，转为不可行' for k, v in bad) \
+            + '，需在风险分析中给出应对措施。'
+
+    def rnd(ii):
+        return {kk: (round(v, 6) if isinstance(v, float) else v) for kk, v in ii.items()}
+
+    return {
+        'ok': True, 'unit': u, 'basis': basis,
+        'indicators': {'pre_tax': rnd(ind_pre), 'post_tax': rnd(ind_post) if ind_post else None,
+                       'roi': round(roi, 6) if roi is not None else None, 'total_investment': round(inv_total, 6)},
+        'conclusion': concl,
+        'scenarios': {kk: rnd(v) for kk, v in scen_out.items()},
+        'sensitivity': [{'factor': s['factor'], 'coef': round(s['coef'], 4) if s['coef'] is not None else None,
+                         'switch': round(s['switch'], 4) if s['switch'] is not None else None} for s in sens],
+        'tables': {'投资估算表': t_inv, '项目投资现金流量表': t_cf, '财务评价指标表': t_ind,
+                   '情景分析表': t_scen, '敏感性分析表': t_sens},
+        'notes': notes, 'charts': charts, 'warnings': warnings,
+    }
+
+
+def main(argv):
+    if len(argv) < 2:
+        print(json.dumps({'ok': False, 'error': '用法：fin_model.py <assumptions.json>'}, ensure_ascii=False))
+        return 2
+    try:
+        src = argv[1]
+        if src.lstrip().startswith('{'):                   # 直接传 JSON（只读工具不往工作区写临时文件）
+            spec = json.loads(src)
+        else:
+            with open(src, encoding='utf-8') as fh:
+                spec = json.load(fh)
+        res = run(spec)
+    except ModelError as e:
+        res = {'ok': False, 'error': str(e)}
+    except json.JSONDecodeError as e:
+        res = {'ok': False, 'error': f'假设文件不是合法 JSON：{e}'}
+    except Exception as e:                                 # 引擎自身出错：如实上报
+        res = {'ok': False, 'error': f'测算引擎出错：{type(e).__name__}: {e}'}
+    print(json.dumps(res, ensure_ascii=False))
+    return 0 if res.get('ok') else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))