bingo-light 2.1.3 → 2.2.0

package/README.en.md

@@ -69,11 +69,15 @@ That's it. Three commands and your fork stays in sync forever.
 
 > The AI calls `conflict-analyze --json`, reads the structured ours/theirs data, writes the merged file, and the rebase continues. No human needed.
 
-During a rebase, `conflict-analyze` also returns:
-- **`patch_intent`** — patch name, subject, full commit message, original SHA, original diff, metadata (reason/tags/upstream_pr/status/owner), and position in the patch stack.
-- **`verify`** — configured `test.command` plus per-file syntax/parse commands by extension (`.py/.json/.yml/.yaml/.toml/.sh`).
-
-`conflict-resolve --verify` (CLI) or `verify: true` (MCP) runs `test.command` after the final `git rebase --continue`; the result is attached as `verify_result`.
+During a rebase, `conflict-analyze` returns a full situational briefing:
+- **`patch_intent`** — patch name, subject, full commit message, original SHA, original diff, metadata, stack position.
+- **`verify`** — configured `test.command` + per-file syntax/parse hints by extension (`.py/.json/.yml/.yaml/.toml/.sh`).
+- **`upstream_context`** — upstream commits touching conflicts, with author, subject, and extracted PR numbers.
+- **`patch_dependencies`** — later patches in your stack that modify overlapping files (cascade risk).
+- **`decision_memory`** — prior resolutions for this patch from `.bingo/decisions/`, ranked by relevance.
+- Each `conflicts[]` entry carries **`semantic_class`**: `whitespace` / `import_reorder` / `signature_change` / `logic`.
+
+`conflict-resolve --verify` (CLI) or `verify: true` (MCP) runs `test.command` after the final `git rebase --continue`; the result is attached as `verify_result`. `conflict-resolve` also auto-records the decision (file, semantic class, strategy) to decision memory.
 
 ---
 

package/README.md

@@ -187,7 +187,16 @@ cd bingo-light && make install && bingo-light setup
 }
 ```
 
-`conflict-analyze` 在 rebase 中额外附带 `patch_intent`（补丁意图：原始 commit、diff、metadata、栈位置）与 `verify`（配置的 `test.command` + 按扩展名的逐文件校验命令）。`conflict-resolve --verify` 在最终 `git rebase --continue` 完成后自动跑 `test.command`，结果挂在 `verify_result` 字段。
+`conflict-analyze` 在 rebase 中返回完整态势简报：
+
+- **`patch_intent`**：补丁意图（原始 commit、diff、metadata、栈位置）
+- **`verify`**：配置的 `test.command` + 按扩展名的逐文件校验命令
+- **`upstream_context`**：触发冲突的上游 commits（作者、主题、自动抽取的 PR 号）
+- **`patch_dependencies`**：栈中后续补丁是否触及相同文件（cascade 风险）
+- **`decision_memory`**：该补丁的历史解决方案（`.bingo/decisions/`）
+- 每条 `conflicts[]` 都带 **`semantic_class`**：`whitespace` / `import_reorder` / `signature_change` / `logic`
+
+`conflict-resolve --verify` 在最终 `git rebase --continue` 完成后自动跑 `test.command`，结果挂在 `verify_result` 字段；`conflict-resolve` 还会自动把本次决策（file, semantic class, strategy）写入 decision memory。
 
 </details>
 

package/bingo-light

@@ -269,6 +269,58 @@ def _format_conflict_analyze(result: dict) -> str:
         for h in verify.get("file_hints", []):
             lines.append(f"  [{h['kind']}] {h['command']}")
 
+    deps = result.get("patch_dependencies")
+    if deps and deps.get("dependents"):
+        lines.append("")
+        dlist = deps["dependents"]
+        lines.append(
+            f"{_c(BOLD, 'Cascade risk:')} "
+            f"{len(dlist)} later patch(es) touch overlapping files"
+        )
+        for d in dlist[:5]:
+            files = ", ".join(d.get("overlapping_files", []))
+            lines.append(
+                f"  #{d['position']} {d['name']}: {d.get('subject', '')} "
+                f"\u2014 {_c(YELLOW, files)}"
+            )
+        if len(dlist) > 5:
+            lines.append(f"  {_c(DIM, f'... {len(dlist) - 5} more')}")
+
+    dm = result.get("decision_memory")
+    if dm and dm.get("entries"):
+        lines.append("")
+        lines.append(f"{_c(BOLD, 'Decision memory:')} prior resolutions for this patch")
+        for e in dm["entries"]:
+            lines.append(f"  {_c(CYAN, e['file'])} ({e['semantic_class']}):")
+            for prev in e.get("previous_decisions", [])[:3]:
+                strat = prev.get("resolution_strategy", "?")
+                subj = prev.get("upstream_subject") or "(no subject)"
+                ts = prev.get("timestamp", "")
+                rel = prev.get("relevance", "")
+                lines.append(
+                    f"    [{strat}] {subj} {_c(DIM, f'({rel}, {ts})')}"
+                )
+
+    uc = result.get("upstream_context")
+    if uc:
+        lines.append("")
+        total = uc.get("total_commits", 0)
+        touching = uc.get("commits_touching_conflicts", [])
+        lines.append(
+            f"{_c(BOLD, 'Upstream context:')} "
+            f"{uc.get('range', '?')} "
+            f"({total} commits, {len(touching)} touching conflicts)"
+        )
+        for commit in touching[:5]:
+            short = commit.get("short_sha", "?")
+            subj = commit.get("subject", "")
+            author = commit.get("author", "")
+            pr = commit.get("pr")
+            pr_tag = f" #{pr}" if pr else ""
+            lines.append(f"  {_c(DIM, short)} {subj}{pr_tag} \u2014 {author}")
+        if len(touching) > 5:
+            lines.append(f"  {_c(DIM, f'... {len(touching) - 5} more')}")
+
     return "\n".join(lines)
 
 

package/bingo_core/__init__.py

@@ -14,7 +14,7 @@ import re
 
 # --- Constants ---
 
-VERSION = "2.1.3"
+VERSION = "2.2.0"
 PATCH_PREFIX = "[bl]"
 CONFIG_FILE = ".bingolight"
 BINGO_DIR = ".bingo"
@@ -39,6 +39,8 @@ from bingo_core.exceptions import (  # noqa: E402
     DirtyTreeError,
 )
 from bingo_core.models import PatchInfo, ConflictInfo  # noqa: E402
+from bingo_core.semantic import classify_conflict  # noqa: E402
+from bingo_core.decisions import DecisionMemory, detect_resolution_strategy  # noqa: E402
 from bingo_core.git import Git  # noqa: E402
 from bingo_core.config import Config  # noqa: E402
 from bingo_core.state import State  # noqa: E402
@@ -70,7 +72,11 @@ __all__ = [
     # Data classes
     "PatchInfo",
     "ConflictInfo",
+    # Functions
+    "classify_conflict",
+    "detect_resolution_strategy",
     # Classes
+    "DecisionMemory",
     "Git",
     "Config",
     "State",

package/bingo_core/decisions.py

@@ -0,0 +1,167 @@
+"""
+bingo_core.decisions — per-patch conflict-resolution memory.
+
+Complements git rerere (which keys by literal conflict text) with a
+pattern-level memory: records how patch X was resolved against upstream
+commit Y, keyed by (patch_name, file, semantic_class). When the same
+patch conflicts again in a similar pattern, previous decisions are
+surfaced to the AI during conflict-analyze so it can consider the
+prior choice.
+
+Storage: .bingo/decisions/<patch-name>.json, one file per patch.
+This avoids hot contention and keeps each patch's history isolated.
+
+Python 3.8+ stdlib only. No external dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from typing import List, Optional
+
+# Patch name constraint mirrors PATCH_NAME_RE to keep filenames safe.
+_SAFE_PATCH_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+MAX_DECISIONS_PER_PATCH = 50
+
+
+class DecisionMemory:
+    """Per-patch decision log stored under .bingo/decisions/."""
+
+    def __init__(self, repo_path: str):
+        self.repo_path = repo_path
+        self.dir = os.path.join(repo_path, ".bingo", "decisions")
+
+    def _path_for(self, patch_name: str) -> Optional[str]:
+        if not patch_name or not _SAFE_PATCH_NAME.match(patch_name):
+            return None
+        return os.path.join(self.dir, f"{patch_name}.json")
+
+    def _load_all(self, patch_name: str) -> List[dict]:
+        path = self._path_for(patch_name)
+        if not path or not os.path.isfile(path):
+            return []
+        try:
+            with open(path) as f:
+                data = json.load(f)
+        except (IOError, OSError, json.JSONDecodeError):
+            return []
+        decisions = data.get("decisions", [])
+        return decisions if isinstance(decisions, list) else []
+
+    def _save_all(self, patch_name: str, decisions: List[dict]) -> None:
+        path = self._path_for(patch_name)
+        if not path:
+            return
+        os.makedirs(self.dir, exist_ok=True)
+        tmp = path + ".tmp"
+        try:
+            with open(tmp, "w") as f:
+                json.dump(
+                    {"patch": patch_name, "decisions": decisions},
+                    f, indent=2,
+                )
+            os.replace(tmp, path)
+        except (IOError, OSError):
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+
+    def record(
+        self,
+        patch_name: str,
+        file: str,
+        semantic_class: str,
+        resolution_strategy: str,
+        upstream_sha: Optional[str] = None,
+        upstream_subject: Optional[str] = None,
+        notes: str = "",
+    ) -> None:
+        """Append one decision for a patch.
+
+        Silently no-ops if patch_name is empty or invalid. The newest
+        MAX_DECISIONS_PER_PATCH entries are retained; older entries are
+        dropped FIFO to keep files bounded.
+        """
+        if not patch_name or not _SAFE_PATCH_NAME.match(patch_name):
+            return
+        entry = {
+            "timestamp": datetime.now(timezone.utc).strftime(
+                "%Y-%m-%dT%H:%M:%SZ"
+            ),
+            "file": file,
+            "semantic_class": semantic_class,
+            "resolution_strategy": resolution_strategy,
+            "upstream_sha": upstream_sha,
+            "upstream_subject": upstream_subject,
+            "notes": notes,
+        }
+        decisions = self._load_all(patch_name)
+        decisions.append(entry)
+        if len(decisions) > MAX_DECISIONS_PER_PATCH:
+            decisions = decisions[-MAX_DECISIONS_PER_PATCH:]
+        self._save_all(patch_name, decisions)
+
+    def lookup(
+        self,
+        patch_name: str,
+        file: Optional[str] = None,
+        semantic_class: Optional[str] = None,
+        limit: int = 5,
+    ) -> List[dict]:
+        """Return up to `limit` previous decisions, most-recent first,
+        ranked by relevance to the given file/semantic_class.
+
+        Ranking: +2 if file matches, +1 if semantic_class matches.
+        Ties broken by recency.
+        """
+        decisions = self._load_all(patch_name)
+        if not decisions:
+            return []
+
+        def score(d: dict) -> tuple:
+            relevance = 0
+            if file and d.get("file") == file:
+                relevance += 2
+            if semantic_class and d.get("semantic_class") == semantic_class:
+                relevance += 1
+            return (relevance, d.get("timestamp", ""))
+
+        ranked = sorted(decisions, key=score, reverse=True)
+        result = []
+        for d in ranked[:limit]:
+            # Add a human-readable relevance tag
+            tag = []
+            if file and d.get("file") == file:
+                tag.append("same_file")
+            if semantic_class and d.get("semantic_class") == semantic_class:
+                tag.append("same_class")
+            entry = dict(d)
+            entry["relevance"] = "+".join(tag) if tag else "recent"
+            result.append(entry)
+        return result
+
+
+def detect_resolution_strategy(
+    resolved_content: str, ours: str, theirs: str
+) -> str:
+    """Classify how a resolution was produced by comparing bytes.
+
+    Returns "keep_ours" / "keep_theirs" / "manual". Exact-match required
+    because partial merges still count as manual. Empty `resolved_content`
+    returns "manual" (caller didn't tell us what was written).
+    """
+    if not resolved_content:
+        return "manual"
+    # Strip trailing whitespace on both sides to be forgiving of newline diffs.
+    r = resolved_content.rstrip()
+    o = (ours or "").rstrip()
+    t = (theirs or "").rstrip()
+    if r == o:
+        return "keep_ours"
+    if r == t:
+        return "keep_theirs"
+    return "manual"

package/bingo_core/models.py

@@ -32,6 +32,7 @@ class ConflictInfo:
     theirs: str = ""
     conflict_count: int = 0
     merge_hint: str = ""
+    semantic_class: str = "logic"
 
     def to_dict(self) -> dict:
         return asdict(self)

package/bingo_core/repo.py

@@ -31,6 +31,8 @@ from bingo_core.exceptions import (
     DirtyTreeError,
 )
 from bingo_core.models import ConflictInfo
+from bingo_core.semantic import classify_conflict
+from bingo_core.decisions import DecisionMemory, detect_resolution_strategy
 from bingo_core.git import Git
 from bingo_core.config import Config
 from bingo_core.state import State
@@ -46,6 +48,7 @@ class Repo:
         self.config = Config(self.path)
         self.state = State(self.path)
         self.team = TeamState(self.path, git=self.git)
+        self.decisions = DecisionMemory(self.path)
 
     # -- Internal helpers --
 
@@ -359,6 +362,167 @@ class Repo:
         ".sh": ("bash -n {path}", "syntax"),
     }
 
+    _PR_NUMBER_RE = re.compile(r"(?:#|pull request #)(\d+)")
+
+    def _build_patch_dependencies(self, current_name: str) -> Optional[dict]:
+        """Find later patches in the stack that touch the same files as current.
+
+        Useful for detecting cascade risk: if we're resolving a conflict in
+        patch A, and patches B/C/D build on A's changes to the same files,
+        the AI should consider whether its merge choice will cascade.
+
+        Returns {current_patch, dependents: [{name, subject, position,
+        overlapping_files}]} or None if no stack info available.
+        """
+        if not current_name:
+            return None
+        try:
+            c = self._load()
+            base = self._patches_base(c)
+            if not base:
+                return None
+            try:
+                log_output = self.git.run(
+                    "rev-list", "--reverse",
+                    f"{base}..{c['patches_branch']}"
+                )
+            except GitError:
+                return None
+            shas = log_output.splitlines()
+            if not shas:
+                return None
+
+            # Collect (index, name, subject, sha, files) for each patch.
+            patches_info = []
+            for idx, sha in enumerate(shas, start=1):
+                try:
+                    subj = self.git.run("log", "-1", "--format=%s", sha).strip()
+                except GitError:
+                    continue
+                m = self._PATCH_SUBJECT_RE.match(subj)
+                if not m:
+                    continue
+                try:
+                    files_out = self.git.run(
+                        "show", "--format=", "--name-only", sha
+                    )
+                except GitError:
+                    files_out = ""
+                files = [ln for ln in files_out.splitlines() if ln]
+                patches_info.append({
+                    "index": idx,
+                    "name": m.group(1),
+                    "subject": m.group(2).strip(),
+                    "files": set(files),
+                })
+
+            # Find current patch and its files.
+            cur = next(
+                (p for p in patches_info if p["name"] == current_name), None
+            )
+            if cur is None:
+                return None
+
+            # Later patches that overlap.
+            dependents = []
+            for p in patches_info:
+                if p["index"] <= cur["index"]:
+                    continue
+                overlap = cur["files"] & p["files"]
+                if overlap:
+                    dependents.append({
+                        "name": p["name"],
+                        "subject": p["subject"],
+                        "position": p["index"],
+                        "overlapping_files": sorted(overlap),
+                    })
+            return {
+                "current_patch": current_name,
+                "dependents": dependents,
+            }
+        except Exception:
+            return None
+
+    def _build_upstream_context(self, conflicted_files: List[str]) -> Optional[dict]:
+        """Find upstream commits that modified the conflicting files.
+
+        Uses .bingo/.undo-tracking (pre-sync upstream position) as the
+        baseline and the current tracking branch as the target. For each
+        conflicted file, lists upstream commits between those two points.
+
+        Returns a dict {range, total_commits, commits_touching_conflicts}
+        or None if the comparison range cannot be established.
+        """
+        try:
+            _head, old_tracking = self.state.load_undo()
+        except Exception:
+            return None
+        if not old_tracking:
+            return None
+
+        try:
+            c = self._load()
+        except Exception:
+            return None
+        # During a conflict, _sync_locked rolls back the tracking branch,
+        # so we use the remote-tracking ref (upstream/<branch>) which
+        # reflects the fetched target position.
+        new_tracking = (
+            self.git.rev_parse(f"upstream/{c['upstream_branch']}")
+            or self.git.rev_parse(c["tracking_branch"])
+        )
+        if not new_tracking or new_tracking == old_tracking:
+            return None
+
+        commit_map: dict = {}
+        FMT = "%H%x1f%h%x1f%an%x1f%at%x1f%s"
+        for f in conflicted_files:
+            try:
+                out = self.git.run(
+                    "log",
+                    f"--format={FMT}",
+                    f"{old_tracking}..{new_tracking}",
+                    "--",
+                    f,
+                )
+            except GitError:
+                continue
+            for line in out.splitlines():
+                parts = line.split("\x1f")
+                if len(parts) != 5:
+                    continue
+                sha, short, author, ts, subject = parts
+                entry = commit_map.setdefault(sha, {
+                    "sha": sha,
+                    "short_sha": short,
+                    "author": author,
+                    "timestamp": int(ts) if ts.isdigit() else 0,
+                    "subject": subject,
+                    "files": [],
+                    "pr": None,
+                })
+                if f not in entry["files"]:
+                    entry["files"].append(f)
+                if entry["pr"] is None:
+                    m = self._PR_NUMBER_RE.search(subject)
+                    if m:
+                        entry["pr"] = m.group(1)
+
+        total = 0
+        try:
+            total = self.git.rev_list_count(f"{old_tracking}..{new_tracking}")
+        except Exception:
+            pass
+
+        commits = sorted(
+            commit_map.values(), key=lambda x: x["timestamp"], reverse=True
+        )
+        return {
+            "range": f"{old_tracking[:7]}..{new_tracking[:7]}",
+            "total_commits": total,
+            "commits_touching_conflicts": commits,
+        }
+
     def _verify_hints_for(self, files: List[str]) -> List[dict]:
         """Generate per-file verification commands by extension.
 
@@ -525,6 +689,7 @@ class Repo:
             theirs=theirs,
             conflict_count=conflict_count,
             merge_hint=merge_hint,
+            semantic_class=classify_conflict(ours, theirs, filepath),
         )
 
     def _record_sync(self, c: dict, behind: int, saved_tracking: str) -> None:
@@ -1138,8 +1303,12 @@ class Repo:
             "test_command": self.config.get("test.command") or None,
             "file_hints": self._verify_hints_for(conflicted),
         }
+        upstream_context = self._build_upstream_context(conflicted)
+        patch_dependencies = self._build_patch_dependencies(
+            patch_intent.get("name", "") if patch_intent else ""
+        )
 
-        return {
+        result = {
             "ok": True,
             "in_rebase": True,
             "current_patch": current_patch,
@@ -1155,6 +1324,34 @@ class Repo:
                 "6. To abort instead: git rebase --abort",
             ],
         }
+        if upstream_context is not None:
+            result["upstream_context"] = upstream_context
+        if patch_dependencies is not None:
+            result["patch_dependencies"] = patch_dependencies
+
+        # Decision memory: look up previous resolutions for this patch.
+        patch_name = patch_intent.get("name", "") if patch_intent else ""
+        if patch_name:
+            memory_entries = []
+            for conflict in conflicts:
+                prior = self.decisions.lookup(
+                    patch_name,
+                    file=conflict.file,
+                    semantic_class=conflict.semantic_class,
+                    limit=3,
+                )
+                if prior:
+                    memory_entries.append({
+                        "file": conflict.file,
+                        "semantic_class": conflict.semantic_class,
+                        "previous_decisions": prior,
+                    })
+            if memory_entries:
+                result["decision_memory"] = {
+                    "patch": patch_name,
+                    "entries": memory_entries,
+                }
+        return result
 
     def conflict_resolve(
         self, file_path: str, content: str = "", verify: bool = False
@@ -1197,6 +1394,9 @@ class Repo:
                 f"Unmerged files: {', '.join(unmerged) if unmerged else '(none)'}"
             )
 
+        # Capture pre-resolve conflict snapshot (for decision memory).
+        pre_conflict = self._extract_conflict(rel_path)
+
         # Write content if provided
         if content:
             full_path = str(resolved)
@@ -1210,6 +1410,41 @@ class Repo:
         if not self.git.run_ok("add", rel_path):
             raise BingoError(f"Failed to stage file: {rel_path}")
 
+        # Record decision memory (best-effort; silent on failure).
+        try:
+            intent = self._build_patch_intent()
+            patch_name = intent.get("name", "") if intent else ""
+            if patch_name:
+                resolved_content = content
+                if not resolved_content:
+                    try:
+                        with open(str(resolved)) as f:
+                            resolved_content = f.read()
+                    except (IOError, OSError):
+                        resolved_content = ""
+                strategy = detect_resolution_strategy(
+                    resolved_content, pre_conflict.ours, pre_conflict.theirs
+                )
+                # Pick the first upstream commit touching this file as the
+                # "triggering" upstream change (best-effort context).
+                uc = self._build_upstream_context([rel_path])
+                upstream_sha = None
+                upstream_subject = None
+                if uc and uc.get("commits_touching_conflicts"):
+                    top = uc["commits_touching_conflicts"][0]
+                    upstream_sha = top.get("sha")
+                    upstream_subject = top.get("subject")
+                self.decisions.record(
+                    patch_name,
+                    file=rel_path,
+                    semantic_class=pre_conflict.semantic_class,
+                    resolution_strategy=strategy,
+                    upstream_sha=upstream_sha,
+                    upstream_subject=upstream_subject,
+                )
+        except Exception:
+            pass  # memory is best-effort; never block rebase on it
+
         # Check remaining unmerged files
         remaining = self.git.ls_files_unmerged()
         if remaining:

package/bingo_core/semantic.py

@@ -0,0 +1,85 @@
+"""
+bingo_core.semantic — semantic classification of conflict regions.
+
+Given ours/theirs text for a single conflict region, return one of:
+    "whitespace"       — regions differ only in whitespace
+    "import_reorder"   — both regions are only import statements,
+                         same set of imports, just reordered
+    "signature_change" — function/method signature changed (params
+                         added, removed, or renamed) but name same
+    "logic"            — default; real logic change requiring human
+                         or AI reasoning
+
+The classifier is intentionally conservative: when unsure, return
+"logic" so callers treat it as a real conflict.
+
+Python 3.8+ stdlib only.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Matches Python "import X" or "from X import Y" lines.
+_IMPORT_RE_PY = re.compile(r"^\s*(?:import|from)\s+\S")
+# Matches JS/TS imports and CommonJS require.
+_IMPORT_RE_JS = re.compile(r"^\s*(?:import\s|const\s+\w+\s*=\s*require\()")
+
+# Function signature captures: (name, params) for Python def and JS function.
+_FN_SIG_PY = re.compile(r"^\s*(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)")
+_FN_SIG_JS = re.compile(r"^\s*(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)")
+
+
+def classify_conflict(ours: str, theirs: str, file: str = "") -> str:
+    """Classify a conflict region as whitespace / import_reorder /
+    signature_change / logic.
+
+    `file` is accepted for future extension (language-specific rules)
+    but not currently used.
+    """
+    if _is_whitespace_only(ours, theirs):
+        return "whitespace"
+    if _is_import_reorder(ours, theirs):
+        return "import_reorder"
+    if _is_signature_change(ours, theirs):
+        return "signature_change"
+    return "logic"
+
+
+def _is_whitespace_only(a: str, b: str) -> bool:
+    """True if the only difference is whitespace (tabs, spaces, newlines).
+
+    All whitespace is removed for comparison — matching git's
+    `diff --ignore-all-space` semantics.
+    """
+    na = "".join(a.split())
+    nb = "".join(b.split())
+    return na == nb and na != ""
+
+
+def _is_import_reorder(a: str, b: str) -> bool:
+    """True if both sides contain only import statements, with the same
+    set of imports (just reordered)."""
+    a_lines = [ln for ln in a.splitlines() if ln.strip()]
+    b_lines = [ln for ln in b.splitlines() if ln.strip()]
+    if not a_lines or not b_lines:
+        return False
+    for line in a_lines + b_lines:
+        if not (_IMPORT_RE_PY.match(line) or _IMPORT_RE_JS.match(line)):
+            return False
+    # Compare as sorted sets: order-insensitive match.
+    return sorted(a_lines) == sorted(b_lines)
+
+
+def _is_signature_change(a: str, b: str) -> bool:
+    """True if both sides contain a function definition for the same
+    name but with different parameter lists."""
+    for pattern in (_FN_SIG_PY, _FN_SIG_JS):
+        a_match = pattern.search(a)
+        b_match = pattern.search(b)
+        if a_match and b_match:
+            same_name = a_match.group(1) == b_match.group(1)
+            different_params = a_match.group(2).strip() != b_match.group(2).strip()
+            if same_name and different_params:
+                return True
+    return False

package/mcp-server.py

@@ -288,10 +288,13 @@ TOOLS = [
         "name": "bingo_conflict_analyze",
         "description": (
             "Analyze current rebase conflicts. Returns structured info about each conflicted file "
-            "(ours/theirs, conflict count, hints) plus patch_intent (name, subject, full commit "
-            "message, original_sha, original_diff, meta, stack_position) and verify "
-            "(test_command + per-file syntax/parse commands). "
-            "Call this when bingo_sync reports a conflict to understand what needs fixing."
+            "(ours/theirs, conflict count, hints, semantic_class: whitespace/import_reorder/"
+            "signature_change/logic) plus: patch_intent (name, subject, full commit message, "
+            "original_sha, original_diff, meta, stack_position), verify (test_command + per-file "
+            "syntax/parse commands), upstream_context (upstream commits touching conflicts with "
+            "author/PR), patch_dependencies (later patches touching same files — cascade risk), "
+            "and decision_memory (prior resolutions for this patch from .bingo/decisions/). "
+            "Call this when bingo_sync reports a conflict."
         ),
         "inputSchema": {
             "type": "object",
@@ -1094,7 +1097,7 @@ def main():
                 "capabilities": {"tools": {}},
                 "serverInfo": {
                     "name": "bingo-light",
-                    "version": "2.1.3",
+                    "version": "2.2.0",
                 },
             }))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingo-light",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "AI-native fork maintenance — manage customizations as a clean patch stack on top of upstream",
   "keywords": ["git", "fork", "patch", "mcp", "ai", "maintenance", "upstream", "rebase"],
   "homepage": "https://github.com/DanOps-1/bingo-light",