shopping-cli 3.2.0__tar.gz → 3.2.1__tar.gz

{shopping_cli-3.2.0/shopping_cli.egg-info → shopping_cli-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shopping-cli
-Version: 3.2.0
+Version: 3.2.1
 Summary: Standalone local-commerce AI consultation marketplace runtime
 License:                                  Apache License
                                    Version 2.0, January 2004

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "shopping-cli"
-version = "3.2.0"
+version = "3.2.1"
 description = "Standalone local-commerce AI consultation marketplace runtime"
 readme = "README.md"
 requires-python = ">=3.11"

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/__init__.py

@@ -1,3 +1,3 @@
 """Standalone shopping-cli consultation runtime."""
 
-VERSION = "3.2.0"
+VERSION = "3.2.1"

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/api/handlers/negotiation.py

@@ -20,9 +20,13 @@ from shopping_cli.db.session import db_session
 from shopping_cli.services import negotiation as negotiation_service
 
 # 审查 S-M2：merchant/agent/negotiation/human-review 端点此前均无限流——已泄露/
-# 低熵 token 的滥用无节流。对磋商决策提交（写路径，追加磋商消息）加 per-owner
-# 固定窗口限流：进程内（单进程部署前提，与 ERP sync 限流同款）。env 可覆盖
-# （调用时读取，便于测试注入）。
+# 低熵 token 的滥用无节流。对磋商决策提交（写路径，追加磋商消息）加固定窗口
+# 限流：进程内（单进程部署前提，与 ERP sync 限流同款）。env 可覆盖（调用时
+# 读取，便于测试注入）。
+# 审查 S-M2 补强：限流键从 per-owner（buyer 的 owner_id 客户端声明，轮换
+# buyer_id 即绕过）改为 per-token（token_hash，服务端派生）——同凭证无论声明
+# 什么 buyer_id 都共享一个桶；轮换新 token 受 S-M1 bootstrap 全局桶（铸造速率）
+# 封顶。merchant/agent 单 token 部署下语义不变。
 _NEGOTIATION_DECISION_WINDOW_SECONDS = 60
 _DECISION_RATE_LIMIT_DEFAULT_PER_MINUTE = 600
 _decision_buckets: dict[str, tuple[float, int]] = {}
@@ -38,18 +42,18 @@ def _decision_rate_limit_per_minute() -> int:
     return value if value > 0 else _DECISION_RATE_LIMIT_DEFAULT_PER_MINUTE
 
 
-def _enforce_decision_rate_limit(owner_id: str) -> None:
+def _enforce_decision_rate_limit(credential_key: str) -> None:
     limit = _decision_rate_limit_per_minute()
     now = time.monotonic()
     with _decision_buckets_lock:
-        window_start, count = _decision_buckets.get(owner_id, (0.0, 0))
+        window_start, count = _decision_buckets.get(credential_key, (0.0, 0))
         if now - window_start >= _NEGOTIATION_DECISION_WINDOW_SECONDS:
             window_start, count = now, 0
         if count >= limit:
             raise RateLimitError(
                 f"negotiation decision rate limit exceeded ({limit}/minute)"
             )
-        _decision_buckets[owner_id] = (window_start, count + 1)
+        _decision_buckets[credential_key] = (window_start, count + 1)
 
 
 def _actor(conn: Any, payload: dict[str, Any]) -> negotiation_service.NegotiationActor:
@@ -96,8 +100,9 @@ def get_snapshot(db_path: str | Path, payload: dict[str, Any], query: dict[str,
 def submit_decision(db_path: str | Path, payload: dict[str, Any]) -> dict[str, Any]:
     with db_session(db_path) as conn:
         actor = _actor(conn, payload)
-        # 审查 S-M2：per-owner 固定窗口限流（决策提交=磋商消息追加，滥用最直接）。
-        _enforce_decision_rate_limit(actor.owner_id)
+        # 审查 S-M2：固定窗口限流（决策提交=磋商消息追加，滥用最直接）。键用
+        # 服务端派生的 token_hash（per-token），空值兜底 owner_id。
+        _enforce_decision_rate_limit(actor.token_hash or actor.owner_id)
         policy_result = negotiation_service.submit_decision(
             conn,
             actor,

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/contracts/kiwi-contracts.lock.json

@@ -2,6 +2,6 @@
   "lock_version": 1,
   "source_repository": "harrylabsj/kiwi",
   "source_commit": "009bc25cdae2668c8fd19ccedcc4e0c64a34f6be",
-  "bundle_sha256": "2dbbc52a1113dc5c05dc544802571ee188b44e1567d6bfb0cd8ccd87ea7f4998",
+  "bundle_sha256": "2350ecaacebb791cd980cc2886511359e356378a6f18cdecc1ac6331c31b0e70",
   "contracts_manifest": "contracts/manifest.json"
 }

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/core/channels.py

@@ -168,7 +168,7 @@ def _begin_channel_ingress(
             return _existing_ingress_response(conn, row, buyer_id, channel)
         # stale_at 非空 → 落 INSERT ON CONFLICT 覆盖旧行（重处理幂等）
     try:
-        conn.execute(
+        cursor = conn.execute(
             """
             insert into channel_message_ingresses(
                 channel, external_user_id, external_message_id, status,
@@ -181,6 +181,7 @@ def _begin_channel_ingress(
                 message_id = excluded.message_id,
                 stale_at = excluded.stale_at,
                 updated_at = excluded.updated_at
+            where channel_message_ingresses.stale_at != ''
             """,
             (channel, external_user_id, external_message_id, PROCESSING_STATUS, now, now),
         )
@@ -195,6 +196,19 @@ def _begin_channel_ingress(
         if row is not None:
             return _existing_ingress_response(conn, row, buyer_id, channel)
         raise
+    if cursor.rowcount == 0:
+        # 并发重复：另一请求已先落 fresh processing 行（stale_at 为空），DO UPDATE
+        # 被 WHERE 跳过、rowcount=0 → 我们未抢到写权，回查走冲突/幂等分支。
+        row = conn.execute(
+            """
+            select * from channel_message_ingresses
+            where channel = ? and external_user_id = ? and external_message_id = ?
+            """,
+            (channel, external_user_id, external_message_id),
+        ).fetchone()
+        if row is not None:
+            return _existing_ingress_response(conn, row, buyer_id, channel)
+        raise
     return None
 
 

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/data_sources/csv_excel_source.py

@@ -23,7 +23,7 @@ import math
 import sqlite3
 import zipfile
 import xml.etree.ElementTree as ET
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal, InvalidOperation
 from pathlib import Path
@@ -45,6 +45,17 @@ SOURCE_CSV_EXCEL = "csv_excel"
 
 _XLSX_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 
+# Import limits are deliberately conservative: CSV/XLSX are operator-supplied
+# files, so parsing must not turn an accidental or malicious workbook into an
+# unbounded memory/CPU allocation (zip bombs, giant shared strings, or millions
+# of rows).  These are wire/data-source limits, not database limits.
+MAX_IMPORT_FILE_BYTES = 10 * 1024 * 1024
+MAX_IMPORT_ROWS = 100_000
+MAX_IMPORT_COLUMNS = 256
+MAX_IMPORT_CELL_CHARS = 16_384
+MAX_XLSX_ENTRIES = 256
+MAX_XLSX_UNCOMPRESSED_BYTES = 50 * 1024 * 1024
+
 
 @dataclass(frozen=True)
 class CsvExcelSyncConfig:
@@ -75,6 +86,12 @@ def read_rows(path: str) -> list[dict[str, str]]:
     p = Path(path)
     if not p.is_file():
         raise AdapterError(f"file not found: {path}")
+    try:
+        size = p.stat().st_size
+    except OSError as exc:
+        raise AdapterError(f"cannot stat import file: {path}") from exc
+    if size > MAX_IMPORT_FILE_BYTES:
+        raise AdapterError(f"import file exceeds {MAX_IMPORT_FILE_BYTES} bytes")
     if p.suffix.lower() == ".xlsx":
         return _read_xlsx_rows(p)
     if p.suffix.lower() in {".csv", ".tsv", ""}:
@@ -85,33 +102,97 @@ def read_rows(path: str) -> list[dict[str, str]]:
 def _read_csv_rows(path: Path) -> list[dict[str, str]]:
     try:
         with path.open("r", encoding="utf-8-sig", newline="") as f:
+            # csv's parser otherwise accepts arbitrarily large individual fields.
+            csv.field_size_limit(MAX_IMPORT_CELL_CHARS)
             reader = csv.DictReader(f)
-            rows = [dict(r) for r in reader]
+            header = reader.fieldnames
+            if header is None:
+                return []
+            if len(header) > MAX_IMPORT_COLUMNS:
+                raise AdapterError(f"CSV has more than {MAX_IMPORT_COLUMNS} columns")
+            if any(len(str(name or "")) > MAX_IMPORT_CELL_CHARS for name in header):
+                raise AdapterError(f"CSV header exceeds {MAX_IMPORT_CELL_CHARS} characters")
+            rows: list[dict[str, str]] = []
+            for index, row in enumerate(reader, start=1):
+                if index > MAX_IMPORT_ROWS:
+                    raise AdapterError(f"CSV exceeds {MAX_IMPORT_ROWS} data rows")
+                if len(row) > MAX_IMPORT_COLUMNS:
+                    raise AdapterError(f"CSV row {index} has more than {MAX_IMPORT_COLUMNS} columns")
+                normalized: dict[str, str] = {}
+                for key, value in row.items():
+                    if key is None:
+                        raise AdapterError(f"CSV row {index} has too many columns")
+                    text = str(value or "")
+                    if len(text) > MAX_IMPORT_CELL_CHARS:
+                        raise AdapterError(f"CSV row {index} contains a cell over {MAX_IMPORT_CELL_CHARS} characters")
+                    normalized[str(key)] = text
+                rows.append(normalized)
     except (UnicodeDecodeError, csv.Error) as exc:
         raise AdapterError(f"invalid CSV: {exc}") from exc
     return rows
 
 
+def _xlsx_cell_column(ref: str | None, row_index: int, cell_pos: int) -> int:
+    """解析单元格 ``r`` 属性（如 ``C2``）→ 0 基列号。
+
+    Excel 常省略空单元格（留白/样式单元格/合并后空列），按文档顺序对齐会让
+    后续有值单元格左移、静默写坏 price/stock（审查 S-M5）。因此以 ``r`` 属性
+    的列字母定位（A=0 … ZZ=701），缺列由调用方补 ``""``。无 ``r`` 属性
+    （少见）回退文档顺序位置。
+    """
+    if ref:
+        letters = "".join(ch for ch in ref if ch.isalpha()).upper()
+        if letters:
+            col = 0
+            for ch in letters:
+                col = col * 26 + (ord(ch) - ord("A") + 1)
+            if col >= 1:
+                return col - 1
+    # 无 r / 纯数字引用：回退文档顺序位置（保持既有行为）。
+    return cell_pos - 1
+
+
 def _xlsx_read_sheet(zf: zipfile.ZipFile, sheet_path: str, shared: list[str]) -> list[list[str]]:
     root = ET.fromstring(zf.read(sheet_path))
     ns = _XLSX_NS
     rows: list[list[str]] = []
-    for row in root.iter(f"{{{ns}}}row"):
+    for row_index, row in enumerate(root.iter(f"{{{ns}}}row"), start=1):
+        if row_index > MAX_IMPORT_ROWS:
+            raise AdapterError(f"xlsx exceeds {MAX_IMPORT_ROWS} data rows")
         cells: list[str] = []
-        for cell in row:
+        for cell_pos, cell in enumerate(row, start=1):
+            if cell_pos > MAX_IMPORT_COLUMNS:
+                raise AdapterError(f"xlsx row {row_index} has more than {MAX_IMPORT_COLUMNS} columns")
+            col = _xlsx_cell_column(cell.get("r"), row_index, cell_pos)
+            if col >= MAX_IMPORT_COLUMNS:
+                raise AdapterError(f"xlsx row {row_index} column {col + 1} exceeds {MAX_IMPORT_COLUMNS} columns")
+            # 按 r 属性定位列，跳过的空列补 ""（S-M5：空单元格不得左移错位）。
+            if col >= len(cells):
+                cells.extend("" for _ in range(col + 1 - len(cells)))
             t = cell.get("t", "n")
             v = cell.find(f"{{{ns}}}v")
+            value = ""
             if t == "s" and v is not None:
-                idx = int(v.text or "0")
-                cells.append(shared[idx] if idx < len(shared) else "")
+                try:
+                    idx = int(v.text or "0")
+                except ValueError as exc:
+                    raise AdapterError(
+                        f"xlsx row {row_index} has invalid shared string index {v.text!r}"
+                    ) from exc
+                if idx < 0 or idx >= len(shared):
+                    raise AdapterError(
+                        f"xlsx row {row_index} shared string index {idx} out of range"
+                    )
+                value = shared[idx]
             elif t == "inlineStr":
                 is_el = cell.find(f"{{{ns}}}is")
-                text = ""
                 if is_el is not None:
-                    text = "".join(tt.text or "" for tt in is_el.iter(f"{{{ns}}}t"))
-                cells.append(text)
+                    value = "".join(tt.text or "" for tt in is_el.iter(f"{{{ns}}}t"))
             elif v is not None:
-                cells.append(str(v.text or ""))
+                value = str(v.text or "")
+            if len(value) > MAX_IMPORT_CELL_CHARS:
+                raise AdapterError(f"xlsx row {row_index} contains a cell over {MAX_IMPORT_CELL_CHARS} characters")
+            cells[col] = value
         rows.append(cells)
     return rows
 
@@ -119,11 +200,22 @@ def _xlsx_read_sheet(zf: zipfile.ZipFile, sheet_path: str, shared: list[str]) ->
 def _read_xlsx_rows(path: Path) -> list[dict[str, str]]:
     try:
         with zipfile.ZipFile(path) as zf:
+            infos = zf.infolist()
+            if len(infos) > MAX_XLSX_ENTRIES:
+                raise AdapterError(f"xlsx has more than {MAX_XLSX_ENTRIES} zip entries")
+            uncompressed = sum(info.file_size for info in infos)
+            if uncompressed > MAX_XLSX_UNCOMPRESSED_BYTES:
+                raise AdapterError(f"xlsx uncompressed content exceeds {MAX_XLSX_UNCOMPRESSED_BYTES} bytes")
             shared: list[str] = []
             if "xl/sharedStrings.xml" in zf.namelist():
                 root = ET.fromstring(zf.read("xl/sharedStrings.xml"))
                 for si in root.iter(f"{{{_XLSX_NS}}}si"):
-                    shared.append("".join(t.text or "" for t in si.iter(f"{{{_XLSX_NS}}}t")))
+                    if len(shared) >= MAX_IMPORT_ROWS * MAX_IMPORT_COLUMNS:
+                        raise AdapterError("xlsx shared strings exceed the supported cell count")
+                    value = "".join(t.text or "" for t in si.iter(f"{{{_XLSX_NS}}}t"))
+                    if len(value) > MAX_IMPORT_CELL_CHARS:
+                        raise AdapterError(f"xlsx shared string exceeds {MAX_IMPORT_CELL_CHARS} characters")
+                    shared.append(value)
             sheet_path = None
             for name in ("xl/worksheets/sheet1.xml", "xl/worksheets/sheet.xml"):
                 if name in zf.namelist():
@@ -150,6 +242,21 @@ def _read_xlsx_rows(path: Path) -> list[dict[str, str]]:
 # ---------------------------------------------------------------------------
 
 
+_FORMULA_INJECTION_PREFIXES = ("=", "+", "-", "@", "\t", "\r")
+
+
+def _neutralize_formula(value: str) -> str:
+    """防 CSV/Excel 公式注入：以 = + - @ \\t \\r 开头的文本前缀单引号。
+
+    审查 L1：导入的文本字段若被下游重新导出为 CSV/Excel 并打开，公式前缀会被
+    执行（=cmd|... / @SUM(...) 等）。前缀 ' 让 Excel 把单元格视为文本，不破坏
+    合法数据（如 "-5% off"）。
+    """
+    if value.startswith(_FORMULA_INJECTION_PREFIXES):
+        return "'" + value
+    return value
+
+
 def _parse_product(raw: dict[str, str], index: int) -> dict[str, Any]:
     """CSV/Excel 行 → 本地 products 行（sku/title/price/stock 校验，fail-closed）。"""
     sku = (raw.get("sku") or "").strip()
@@ -180,12 +287,12 @@ def _parse_product(raw: dict[str, str], index: int) -> dict[str, Any]:
         raise AdapterError(f"row {index}: invalid stock {stock_raw!r}")
     return {
         "sku": sku,
-        "title": title,
+        "title": _neutralize_formula(title),
         "price": price,
         "stock": stock,
         "currency": (raw.get("currency") or "").strip() or "CNY",
-        "category": (raw.get("category") or "").strip(),
-        "description": (raw.get("description") or "").strip(),
+        "category": _neutralize_formula((raw.get("category") or "").strip()),
+        "description": _neutralize_formula((raw.get("description") or "").strip()),
         "merchant_id": (raw.get("merchant_id") or "").strip(),
     }
 

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/db/migrations.py

@@ -10,7 +10,7 @@ from typing import Callable
 
 from shopping_cli.core.tokens import is_sha256_digest, token_digest, token_prefix, token_suffix
 
-CURRENT_SCHEMA_VERSION = 24
+CURRENT_SCHEMA_VERSION = 25
 
 
 @dataclass(frozen=True)
@@ -506,6 +506,29 @@ def migration_023_remove_scheme_a_stub_merchants(conn: sqlite3.Connection) -> No
         conn.execute("delete from merchants where id = ?", (merchant_id,))
 
 
+def migration_025_negotiation_decision_idempotency(conn: sqlite3.Connection) -> None:
+    """协商决策幂等账本（审查 H2 2026-08-16）。
+
+    ``submit_decision`` 此前靠"先扫描 messages 再 append"判断幂等，并发相同
+    idempotency_key 的两个请求都能通过预读并各自写入决策消息（违反冻结协议
+    "同 key 重放绝不重复"）。新增 (conversation_id, agent_id, idempotency_key)
+    唯一表，claim 时由唯一约束兜底并发——与 buyer_request_idempotency 同模式。
+    """
+    conn.execute(
+        """
+        create table if not exists negotiation_decision_idempotency (
+            conversation_id text not null,
+            agent_id text not null,
+            idempotency_key text not null,
+            message_id integer not null default 0,
+            decision_json text not null default '{}',
+            created_at text not null,
+            primary key (conversation_id, agent_id, idempotency_key)
+        )
+        """
+    )
+
+
 MIGRATIONS: tuple[Migration, ...] = (
     Migration(1, "conversation_next_actor", migration_001_conversation_next_actor),
     Migration(2, "agent_runtime_columns", migration_002_agent_runtime_columns),
@@ -524,6 +547,7 @@ MIGRATIONS: tuple[Migration, ...] = (
     Migration(22, "product_handoff_destination", migration_022_product_handoff_destination),
     Migration(23, "remove_scheme_a_stub_merchants", migration_023_remove_scheme_a_stub_merchants),
     Migration(24, "product_source_csv_excel", migration_024_product_source_csv_excel),
+    Migration(25, "negotiation_decision_idempotency", migration_025_negotiation_decision_idempotency),
 )
 
 

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/db/models.py

@@ -233,6 +233,17 @@ SCHEMA = [
         primary key (admin_token_hash, idempotency_key)
     )
     """,
+    """
+    create table if not exists negotiation_decision_idempotency (
+        conversation_id text not null,
+        agent_id text not null,
+        idempotency_key text not null,
+        message_id integer not null default 0,
+        decision_json text not null default '{}',
+        created_at text not null,
+        primary key (conversation_id, agent_id, idempotency_key)
+    )
+    """,
 
 ]
 

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/services/negotiation.py

@@ -92,10 +92,14 @@ class NegotiationActor:
     owner_id: str  # buyer_id or merchant_id bound to the token
     agent_id: str  # claim identity used in agent_message_processes
     conversation_id: str = ""  # buyer tokens are bound to one conversation
+    token_hash: str = ""  # 审查 S-M2 补强：token 摘要（服务端派生）——决策限流按
+    # 凭证（token）键控而非客户端声明的 owner_id，buyer 轮换 buyer_id 无法用
+    # 同一 token 重置限流桶。
 
 
 def require_negotiation_actor(conn: sqlite3.Connection, token: Any) -> NegotiationActor:
     row = token_service.require_api_token(conn, token, "negotiation token required")
+    token_hash = str(row["token_hash"] or "")
     role = str(row["role"] or "")
     if role == "buyer":
         buyer_id = str(row["buyer_id"] or "")
@@ -107,6 +111,7 @@ def require_negotiation_actor(conn: sqlite3.Connection, token: Any) -> Negotiati
             owner_id=buyer_id,
             agent_id=protocol.buyer_agent_identity(buyer_id),
             conversation_id=conversation_id,
+            token_hash=token_hash,
         )
     if role == "merchant":
         merchant_id = str(row["merchant_id"] or "")
@@ -116,13 +121,14 @@ def require_negotiation_actor(conn: sqlite3.Connection, token: Any) -> Negotiati
             role="merchant",
             owner_id=merchant_id,
             agent_id=token_service.default_merchant_agent_id(merchant_id),
+            token_hash=token_hash,
         )
     if role == "agent":
         merchant_id = str(row["merchant_id"] or "")
         agent_id = str(row["agent_id"] or "")
         if not merchant_id or agent_id != token_service.default_merchant_agent_id(merchant_id):
             raise AuthError("agent token cannot act as a negotiation merchant agent")
-        return NegotiationActor(role="merchant", owner_id=merchant_id, agent_id=agent_id)
+        return NegotiationActor(role="merchant", owner_id=merchant_id, agent_id=agent_id, token_hash=token_hash)
     raise AuthError("token role cannot negotiate")
 
 
@@ -504,7 +510,10 @@ def _merchant_gate(
     proposal = decision.get("proposal")
     if decision["action"] in {"propose", "counter"} and proposal is None:
         return _reject("missing_proposal", "propose/counter 必须携带结构化 proposal。")
-    product = product_summary(conn, str(conversation["sku"]))
+    # 审查 M7：此前直接 product_summary(sku) 取地板价，未校验商品归属本会话商家——
+    # SKU 复用/重建时会对错误商家的 automation_boundaries 做 floor/折扣判断。
+    # 换用 _load_conversation_product（带归属校验，fail-closed）。
+    product = _load_conversation_product(conn, conversation)
     floor_str = merchant_agent._authorized_bargain_amount(product)
     # 泄漏守卫对每个 merchant 决策运行——ask/decline 等无 proposal 的决策
     # 也可能携带泄露底价的 public_message（此前该分支直接放行）。
@@ -697,6 +706,38 @@ def submit_decision(
     sender = _decision_sender(actor.role)
     status = _decision_status(actor.role, decision["action"])
     structured_payload = _decision_structured_payload(actor.agent_id, actor.role, decision, idempotency_key)
+    # 幂等 claim：DB 唯一约束兜底并发（审查 H2）。两个并发相同 key 的请求只
+    # 有一个能插入成功；另一个在此拿到 IntegrityError，此时对方已提交，回查
+    # messages 走重放/冲突。与顶部 _find_decision_replay（服务"丢响应后回合已
+    # 推进再重试"的串行幂等）互补，共同覆盖并发 + 串行两条重试路径。
+    try:
+        conn.execute(
+            """
+            insert into negotiation_decision_idempotency(
+                conversation_id, agent_id, idempotency_key, created_at
+            )
+            values (?, ?, ?, ?)
+            """,
+            (conversation_id, actor.agent_id, idempotency_key, now_iso()),
+        )
+    except sqlite3.IntegrityError:
+        replay = _find_decision_replay(conn, actor, conversation_id, idempotency_key)
+        if replay is not None:
+            if protocol.canonical_json(replay["decision"]) != protocol.canonical_json(decision):
+                raise IdempotencyConflict(
+                    f"idempotency key {idempotency_key} was already used with a different decision"
+                )
+            refreshed = require_conversation(conn, conversation_id)
+            return _policy_result(
+                conversation_id,
+                "accepted",
+                protocol.snapshot_next_actor(str(refreshed["next_actor"] or "")),
+                list(decision["reason_codes"]),
+                "决策已接受并写入会话（幂等重放，未重复写入）。",
+                0,
+                message_id=int(replay["message_id"]),
+            )
+        raise IdempotencyConflict(f"idempotency key {idempotency_key} was already used")
     message = append_message(
         conn,
         conversation_id,
@@ -706,6 +747,20 @@ def submit_decision(
         structured_payload=structured_payload,
         status=status,
     )
+    conn.execute(
+        """
+        update negotiation_decision_idempotency
+        set message_id = ?, decision_json = ?
+        where conversation_id = ? and agent_id = ? and idempotency_key = ?
+        """,
+        (
+            int(message["id"]),
+            protocol.canonical_json(decision),
+            conversation_id,
+            actor.agent_id,
+            idempotency_key,
+        ),
+    )
     if status == "closed":
         append_conversation_closed_audit(conn, conversation_id, sender, "")
     append_audit_event(

{shopping_cli-3.2.0 → shopping_cli-3.2.1}/shopping_cli/services/tokens.py

@@ -112,7 +112,7 @@ def require_api_token(conn: Any, token: Any, missing_error: str = "authorization
     digest = token_digest(raw_token)
     row = conn.execute(
         """
-        select role, merchant_id, buyer_id, agent_id, conversation_id, revoked_at, expires_at
+        select role, merchant_id, buyer_id, agent_id, conversation_id, revoked_at, expires_at, token_hash
         from api_tokens
         where token_hash = ?
         """,

{shopping_cli-3.2.0 → shopping_cli-3.2.1/shopping_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shopping-cli
-Version: 3.2.0
+Version: 3.2.1
 Summary: Standalone local-commerce AI consultation marketplace runtime
 License:                                  Apache License
                                    Version 2.0, January 2004