@@ -149,6 +149,19 @@ hqbacktest/
 
 性能冒烟测试在 `tests/data/test_task15_performance.py`，50 symbols × 250 days 全量 `history(bar_count=20)` 在 15 秒阈值内完成。
 
+### 撮合与账本口径（任务 16）
+
+- **同日撮合顺序：** 单个 `OPEN_MATCH(today)` batch 内**所有 SELL 先撮合、再撮合 BUY**（A 股「卖出资金当日可用」），同侧内保持策略提交顺序。资金检查用**滚动现金**而非撮合前快照。
+- **整手取整：** 仅 BUY 按 100 股整手向下取整；SELL 允许任意正整数股（含零股），静默截到整手违反契约。`order_target(symbol, 0)` 必须能清仓含零股的持仓。
+- **T+1 可卖不足：** 整单拒绝（`INSUFFICIENT_SHARES`），不支持部分截断。
+- **`realized_pnl` 不含费用**：仅 `(sell_price - avg_cost) × quantity`；费用（commission / stamp_tax / other_fee）只走现金账。
+- **金额量化：** 全部 `ROUND_HALF_EVEN`（`quantize_cash` 0.01 元 / `quantize_price` 0.0001 元），与券商「四舍五入到分」存在 1 分级差异。
+- **`Fill.BUY` 不携带 `stamp_tax`：** 印花税仅在 SELL 收取；`Fill.__post_init__` 拒绝 BUY 携带非零 stamp_tax 以保证账本与 costs 表一致。
+- **`intents.target_quantity_for_value(0)` 返回 0**（flatten），与 docstring 一致。
+- **CLI `initial_cash` 拒绝 float**（TOML 字面 `100000.0` 报错），与 `BacktestConfig` 严格度对齐（contract rule 5）。
+
+完整口径见 `docs/design/mvp-contract.md` §3.4。手算回归测试在 `tests/engine/test_task16_matching.py`。
+
 ## Python 用法（已实现）
 
 > 下面的代码就是 `examples/moving_average.py` 的简化版，可直接 `python -m hqbacktest run` 跑通（见 §命令行）。完整示例见 `examples/`。
 
@@ -150,6 +150,22 @@
 | `Bar.volume` 单位 | **手**（1 手 = 100 股；与 Tushare `hqdata` 适配器口径一致）；调用方需要股数时应乘以 `LOT_SIZE`。 |
 | 双门户一致性 | `InMemoryDataPortal` 与 `HqDataCsvPortal` 行为完全一致（parity 测试覆盖）。 |
 
+### 3.4 撮合与账本口径（任务 16 固化）
+
+| 维度 | v0.1 默认决定 |
+| --- | --- |
+| 同日撮合顺序 | 单个 `OPEN_MATCH(today)` batch 内**所有 SELL 先撮合、再撮合 BUY**（A 股「卖出资金当日可用」），同侧内保持策略提交顺序。 |
+| 资金检查 | `InsufficientCashRule` 用**滚动现金**（running_cash）逐单检查：SELL 净回款增加、BUY 成本扣除，拒绝后不滚动。 |
+| 整手取整 | **仅 BUY** 按 100 股整手向下取整；SELL 允许任意正整数股（含零股），静默截到整手违反契约。 |
+| `order_target(symbol, 0)` | 必须能清仓含零股的持仓；`order(sym, -N)` 对任意正整数 N 提交原数量。 |
+| T+1 可卖不足 | **整单拒绝**（`RejectReason.INSUFFICIENT_SHARES`），不支持部分截断。 |
+| `realized_pnl` | **不含任何费用**（commission / stamp_tax / other_fee），仅 `(sell_price - avg_cost) × quantity`；费用只走现金账。 |
+| 金额量化 | 全部使用 `ROUND_HALF_EVEN`（`quantize_cash` 0.01 元 / `quantize_price` 0.0001 元），与券商「四舍五入到分」存在 1 分级差异。 |
+| 同日同价「先买后卖」与「先卖后买」 | 提交顺序决定成交时点；`realized_pnl` 在费用外对相同 `(price, avg_cost, quantity)` 相同，**不含费用的现金额**依提交顺序而不同。 |
+| BUY 成交 `stamp_tax` | 必须为 0（印花税仅在 SELL 收取），`Fill.__post_init__` 校验拒绝非零。 |
+| `target_quantity_for_value(0)` | 返回 `0`（flatten），与 docstring 一致。 |
+| CLI `initial_cash` | 拒绝 `float`（TOML 字面 `100000.0` 报错），与引擎层 `BacktestConfig` 严格度对齐。 |
+
 ## 6. 不可变规则
 
 以下 13 条规则在 v0.1 期间**不允许任何代码绕过**；新增能力时若必须突破某条，必须先在本文档登记例外并同步 README。
@@ -199,4 +215,5 @@
 | 2026-08-17 | v0.1（已被后续修订取代） | 曾将 `source` 交给 `hqdata` 解析；该 API 驱动的数据边界已在 2026-08-23 被 CSV 快照契约取代 | hqbacktest 维护者 |
 | 2026-08-23 | v0.1 | 修正回测运行时数据边界：`hqbacktest` 直接只读 hqdata CLI 落盘 CSV；`data_root` 默认 `~/.hqdata`，不调用 `hqdata.api` 或网络数据源 | hqbacktest 维护者 |
 | 2026-08-23 | v0.1 | 重构数据门户：`HqDataPortal` 替换为 `HqDataCsvPortal`，固定布局 `{data_root}/{source}/calendar.csv` + `stock_list|stock_daily|stock_factor/{YYYYMMDD}.csv`；`source` 名称或绝对路径均可，`CacheKey` 加入 `data_root` 防跨目录污染 | hqbacktest 维护者 |
-| 2026-08-24 | v0.1 | 任务 14 数据层缺行/停牌/首日语义：钉死 `get_bars` 允许间隙、引入 `SnapshotFileMissingError` 区分整日文件缺失与个股缺行、`current_price` 回看 20 交易日最近有效收盘价、首日哨兵日期不抛异常、删除 `InMemoryDataPortal.get_universe` 向前回退、补双门户 parity 测试、缓存返回防御性拷贝、`.BJ` 股票默认过滤、`Bar.volume` 单位标注为「手」 | hqbacktest 维护者 |
+| 2026-08-24 | v0.1 | 任务 14 数据层缺行/停牌/首日语义：钉死 `get_bars` 允许间隙、引入 `SnapshotFileMissingError` 区分整日文件缺失与个股缺行、`current_price` 回看 20 交易日最近有效收盘价、首日哨兵日期不抛异常、删除 `InMemoryDataPortal.get_universe` 向前回退、补双门户 parity 测试、缓存返回防御性拷贝、`.BJ` 股票默认过滤、`Bar.volume` 单位标注为「手」 | hqbacktest 维护者 |
+| 2026-08-24 | v0.1 | 任务 16 撮合与账本语义：同批撮合 SELL 先于 BUY（滚动现金）、SELL 不整手取整（`order_target(0)` 可清零股）、`Fill.BUY` 携带非零 stamp_tax 报错、`Order.record_fill` 移除不可达 `ACCEPTED` 分支、`intents.target_quantity_for_value(0)` 按 docstring 返回 0、CLI `initial_cash` 拒绝 float 与引擎对齐、`realized_pnl` 不含费用修正旧注释；登记 §3.4 撮合口径表 | hqbacktest 维护者 |
@@ -237,7 +237,16 @@ def _require_decimal(
     value = section[key]
     if isinstance(value, bool):
         raise ConfigError(f"[{section_name}].{key} must be a number, not bool")
-    if isinstance(value, (int, float, str)):
+    # Task 16: float is forbidden at the CLI layer too, matching the
+    # engine's contract rule 5. Without this check a TOML like
+    # `initial_cash = 100000.0` would silently convert to a Decimal via
+    # `Decimal(str(float))`, masking the precision concern.
+    if isinstance(value, float):
+        raise ConfigError(
+            f"[{section_name}].{key} must be int/str/Decimal; float is "
+            "forbidden (contract rule 5)"
+        )
+    if isinstance(value, (int, str)):
         try:
             d = Decimal(str(value))
         except Exception as exc:
 
@@ -65,6 +65,13 @@ def __post_init__(self) -> None:
                 raise ValueError(f"{field_name} must be quantized to 2 decimal places")
         if len(self.filled_at) != 8 or not self.filled_at.isdigit():
             raise ValueError(f"filled_at must be YYYYMMDD, got {self.filled_at!r}")
+        # Task 16: 印花税 is charged only on SELL. A BUY fill carrying a
+        # non-zero stamp_tax would let the cash ledger drift from the
+        # costs table, so we reject it at construction time.
+        if self.side is Side.BUY and self.stamp_tax != 0:
+            raise ValueError(
+                f"stamp_tax on BUY must be 0 (印花税 only on SELL), got {self.stamp_tax}"
+            )
         gross = cash_for_trade(self.quantity, self.price)
         expected_amount = gross if self.side is Side.BUY else -gross
         if self.amount != expected_amount:
 
@@ -138,9 +138,13 @@ def record_fill(
         price: Decimal,
         at: str,
     ) -> None:
-        """Record a single fill and update running aggregates."""
+        """Record a single fill and update running aggregates.
+
+        v0.1 always moves orders through ACCEPTED → PENDING before any
+        fill arrives, so the ACCEPTED branch in the status guard was
+        unreachable in practice (task 16).
+        """
         if self.status not in (
-            OrderStatus.ACCEPTED,
             OrderStatus.PENDING,
             OrderStatus.PARTIALLY_FILLED,
         ):
 
@@ -1,11 +1,11 @@
 """SimulatedBroker: market-on-open matching with rule set and cost model.
 
-Rules (task 7 + task 8):
+Rules (task 7 + task 8 + task 16):
     * Only `OrderType.MARKET` orders are supported; any other type is
       rejected by `Context` before reaching the broker.
     * The bar for `today` is read first: `MissingDataError` (suspended /
       no bar) becomes `bar_available=False` for the rule set, while
-      `InvalidDataError` and I/O errors propagate and abort the run.
+      `InvalidDataError` / I/O errors propagate and abort the run.
     * Each order then goes through `TradingRuleSet.first_denial`; the
       first denial short-circuits with a typed `RejectReason`.
     * Fees come from `CostModel.compute(order, price, quantity)`; the
@@ -14,6 +14,17 @@
     * Ledger-side rejections (`InsufficientCashError`,
       `InsufficientSharesError`) are produced by `Portfolio.apply_fill`
       and converted by the engine into typed rejections.
+
+Task 16 batch-matching order (A-share convention):
+    * Within a single `OPEN_MATCH(today)` batch, SELL orders match
+      **before** BUY orders. This mirrors "卖出资金当日可用": the
+      proceeds of a SELL can fund a same-batch BUY, so a rotation
+      ("卖旧买新") is not falsely rejected for INSUFFICIENT_CASH.
+    * The rule set's `InsufficientCashRule` checks against a rolling
+      `running_cash` that starts at `portfolio_cash`, increases by each
+      successful SELL's net proceeds, and decreases by each successful
+      BUY's cost. The ordering within each side (SELL-only or BUY-only)
+      preserves the strategy's submission order.
 """
 
 from decimal import Decimal
@@ -27,7 +38,7 @@
 from ..domain.bar import Bar
 from ..domain.enums import EventType, OrderStatus, RejectReason, Side
 from ..domain.fill import Fill
-from ..domain.money import PRICE_QUANT
+from ..domain.money import PRICE_QUANT, quantize_cash
 from ..domain.order import Order
 from .cost_model import CostModel, DefaultCostModel
 from .rule_set import RuleCheckContext, TradingRuleSet
@@ -58,25 +69,50 @@ def match(
 
         `sellable_quantity_for(symbol)` is a callable returning the current
         T+1 sellable shares for the symbol (0 if no position). It mirrors
-        the engine's view of the portfolio so the rule set stays pure.
-
-        `portfolio_cash` is a snapshot taken before this batch: for later
-        orders in the same batch the rule-level cash check may be stale.
-        That is safe because `Portfolio.apply_fill` re-checks every fill
-        against the live ledger and is the final arbiter.
+        the engine's view of the portfolio so the rule set stays pure;
+        the value is captured **before** the batch runs (T+1 state from
+        the previous day's settlement), and is not re-checked after each
+        SELL because a SELL only reduces `sellable_quantity`, so stale
+        values only over-estimate availability (fail-safe for the rule).
+
+        Task 16: orders are partitioned into SELLs and BUYs. All SELLs
+        match first (in submission order) so that their proceeds are
+        available to fund the subsequent BUYs (rolling cash). The
+        partition is a stable sort: the relative order within each side
+        is preserved, but cross-side order is normalized to
+        [SELLs..., BUYs...] as required by A-share convention.
+
+        Results are returned in **matching order** ([SELLs..., BUYs...]),
+        NOT submission order: the engine applies fills in the returned
+        order, so a BUY must be applied only after its funding SELL has
+        already credited the portfolio's cash. Re-assembling into
+        submission order would break the rolling-cash guarantee (a BUY
+        submitted before its funding SELL would be applied first and
+        falsely rejected for INSUFFICIENT_CASH).
         """
+        sell_orders = [o for o in orders if o.side is Side.SELL]
+        buy_orders = [o for o in orders if o.side is Side.BUY]
+        # Stable partition: preserve relative submission order within each
+        # side (the original `orders` list is already insertion-ordered).
+        ordered = sell_orders + buy_orders
+        running_cash = quantize_cash(portfolio_cash)
         results: List[MatchResult] = []
-        for order in orders:
-            results.append(
-                self._match_one(
-                    order,
-                    portal,
-                    today,
-                    rule_set,
-                    portfolio_cash,
-                    sellable_quantity_for(order.symbol),
-                )
+        for order in ordered:
+            match_result = self._match_one(
+                order,
+                portal,
+                today,
+                rule_set,
+                running_cash,
+                sellable_quantity_for(order.symbol),
             )
+            results.append(match_result)
+            # Roll cash: only successful fills update the running balance.
+            # `net_amount()` is already signed (SELL proceeds positive,
+            # BUY costs negative), so a single addition covers both sides.
+            _, fill, _, _ = match_result
+            if fill is not None:
+                running_cash = quantize_cash(running_cash + fill.net_amount())
         return results
 
     # ------------------------------------------------------------------ #
 
@@ -440,18 +440,27 @@ def _create_order(
         validate_symbol(symbol)
         if not is_positive(Decimal(quantity)):
             raise StrategyLifecycleError(f"quantity must be positive, got {quantity}")
-        lot_aligned = round_lot(quantity, lot_size=LOT_SIZE)
-        if lot_aligned == 0:
-            raise StrategyLifecycleError(
-                f"quantity {quantity} is below one lot of {LOT_SIZE} shares"
-            )
+        # Task 16: lot-alignment applies to BUY only. A-share rules allow
+        # odd-lot SELLs so positions holding non-lot quantities can be
+        # fully closed; round_lot() on a SELL would silently shrink
+        # the order (e.g. 150 -> 100), violating the contract that the
+        # broker sees the exact share count the strategy submitted.
+        if side is Side.BUY:
+            lot_aligned = round_lot(quantity, lot_size=LOT_SIZE)
+            if lot_aligned == 0:
+                raise StrategyLifecycleError(
+                    f"quantity {quantity} is below one lot of {LOT_SIZE} shares"
+                )
+            final_quantity = lot_aligned
+        else:
+            final_quantity = quantity
         # Guaranteed by _require_orderable in every public order method.
         created_session = self._phase
         order = Order(
             order_id=self._next_order_id(),
             symbol=symbol,
             side=side,
-            quantity=lot_aligned,
+            quantity=final_quantity,
             order_type=order_type,
             created_at=self._current_date,
             created_session=created_session,
@@ -468,7 +477,7 @@ def _create_order(
                 phase=EventType.ORDER_CREATED,
                 order_id=order.order_id,
                 detail=(
-                    f"{side.name} {lot_aligned} {symbol} "
+                    f"{side.name} {final_quantity} {symbol} "
                     f"(session={created_session.name})"
                 ),
             )
 
@@ -51,26 +51,35 @@ def side_from_quantity(quantity: int) -> Optional[Side]:
 
 
 def signed_diff_to_lots(target: int, current: int, lot_size: int = 100) -> int:
-    """Compute the signed delta between `target` and `current`, lot-aligned.
+    """Compute the signed delta between `target` and `current`.
 
-    Used by `order_target*` helpers: the resulting value is the share count
+    BUY deltas (target > current) are floored to the nearest lot (100
+    shares). SELL deltas (target < current) preserve the requested
+    share count exactly — A-share rules allow odd-lot SELLs so a
+    position holding a non-lot multiple can still be flattened. Used
+    by `order_target*` helpers: the resulting value is the share count
     to send through the broker (positive => BUY, negative => SELL).
     """
     diff = target - current
     if diff == 0:
         return 0
-    sign = 1 if diff > 0 else -1
-    abs_diff = abs(diff)
-    lots = abs_diff // lot_size  # floor; contract: lot-aligned BUY/SELL
-    return sign * lots * lot_size
+    if diff < 0:
+        # SELL: any positive integer is legal; do NOT lot-round.
+        return diff
+    # BUY: floor to nearest lot to avoid requesting fractional shares.
+    lots = diff // lot_size
+    return lots * lot_size
 
 
 def target_quantity_for_value(
     target_value: Decimal, price: Decimal, current_quantity: int, lot_size: int = 100
 ) -> int:
     """Compute the desired `quantity` for a `target_value` position.
 
-    `target_value` may be `Decimal("0")` to flatten the position.
+    `target_value` may be `Decimal("0")` to flatten the position; in
+    that case the function returns `0` (the caller, e.g.
+    `Context.order_target_value`, will translate this into a full
+    flatten via `order_target(symbol, 0)`).
     """
     if price <= 0:
         raise StrategyLifecycleError(f"price must be positive, got {price}")
@@ -79,7 +88,7 @@ def target_quantity_for_value(
             f"target_value must be non-negative, got {target_value}"
         )
     if target_value == 0:
-        return current_quantity  # flat → no change
+        return 0  # flatten (per docstring)
     target_qty_signed = quantity_from_value(target_value, price, lot_size)
     # quantity_from_value already returns a lot-aligned signed count.
     # For a target_value (positive), the signed count is positive.
 
@@ -418,7 +418,10 @@ def on_bar(self, context, data):
     assert portfolio.cash + portfolio.market_value(
         {"600000.SH": Decimal("10.0000")}
     ) == Decimal("99984.00")
-    # Fees live in `realized_pnl` via the broker + portfolio.apply_fill path.
+    # Fees do NOT live in `realized_pnl`: per contract §3.1 / rule 8,
+    # realized_pnl is the gross (sell_price - avg_cost) * quantity and
+    # stays independent of commission / stamp_tax / other_fee. Fees flow
+    # through `cash` only.
     fills = [e for e in engine.event_log.all() if e.phase is EventType.ORDER_FILLED]
     assert len(fills) == 3
 
 
@@ -52,8 +52,10 @@ def test_signed_diff_to_lots_buy():
 
 
 def test_signed_diff_to_lots_sell():
-    # Need to go from 300 to 50; diff = -250, lot-rounded = -200.
-    assert signed_diff_to_lots(50, 300) == -200
+    # Need to go from 300 to 50; diff = -250. Task 16: SELL preserves
+    # the requested share count (odd-lot SELLs allowed per A-share rules),
+    # so the result is -250, not lot-rounded -200.
+    assert signed_diff_to_lots(50, 300) == -250
 
 
 def test_signed_diff_to_lots_no_change():
@@ -70,10 +72,12 @@ def test_target_quantity_for_value_positive():
     )
 
 
-def test_target_quantity_for_value_zero_returns_current():
+def test_target_quantity_for_value_zero_returns_zero_per_docstring():
+    # Task 16: per the function's docstring ("may be 0 to flatten"), a
+    # zero target returns 0 — the caller flattens via order_target().
     assert (
         target_quantity_for_value(Decimal("0"), Decimal("12.50"), current_quantity=300)
-        == 300
+        == 0
     )