guarantee-based-coding 0.2.2__tar.gz → 0.2.3__tar.gz

{guarantee_based_coding-0.2.2/guarantee_based_coding.egg-info → guarantee_based_coding-0.2.3}/PKG-INFO

@@ -1,108 +1,108 @@
-Metadata-Version: 2.4
-Name: guarantee-based-coding
-Version: 0.2.2
-Summary: Make code safely modifiable even when not fully understood — turn implicit inter-module dependencies into explicit, executable, verifiable guarantees.
-Author: Jesse-x86
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/Jesse-x86/guarantee-based-coding
-Project-URL: Repository, https://github.com/Jesse-x86/guarantee-based-coding
-Keywords: guarantee,testing,ai-coding,mcp,code-safety
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typer[all]
-Requires-Dist: pydantic
-Requires-Dist: mcp<2.0,>=1.0
-Dynamic: license-file
-
-# Guarantee-Based Coding (GBC)
-
-**与其指望 AI 更聪明，不如让再笨的 agent 也改不坏你的代码。**
-
-**English version: [docs/en/README.md](docs/en/README.md)**
-
-GBC 把「这次改动会不会悄悄碰坏别处」从一种担心，变成可以当场验证的事实：你在意的行为被登记成
-一条条带测试的**保证（guarantee）**，每次改完一跑——全绿就安心，有红就精确告诉你碰坏了谁、谁在
-依赖它。
-
----
-
-## 🚀 快速开始
-
-```bash
-pipx install guarantee-based-coding
-gbc setup        # 打印本地化接线指南：怎么把 MCP / skills 接入你的 agent
-```
-
-装好后 `gbc` 命令即在 PATH 上。完整上手（安装 → 接入 agent → 冒烟验证）见
-**[docs/zh/quick-start.md](./docs/zh/quick-start.md)**。
-
-想让 agent 替你接入？把 **[docs/zh/onboarding-agent.md](./docs/zh/onboarding-agent.md)** 交给它。
-
----
-
-> 🚧 **交互式 demo 施工中**：旧的演示套件已废弃，新的交互式演示正在筹备。目前请直接读文档上手。
-
----
-
-## 📚 文档
-
-| 你想 | 看这里 |
-|------|--------|
-| 装好并跑起来 | [快速开始](./docs/zh/quick-start.md) |
-| 懂 GBC 在保护什么 | [核心概念](./docs/zh/concepts.md) |
-| 在 GBC 下安全改代码 | [工作流](./docs/zh/workflow.md) |
-| 查命令 / 工具 / executor | [参考手册](./docs/zh/reference.md) |
-| 你是 agent，被要求接入 GBC | [Agent 上手](./docs/zh/onboarding-agent.md) |
-
-English docs: [docs/en/](./docs/en/)。
-
----
-
-## 核心想法
-
-代码之间的依赖本质上是一组**保证**。模块 A 依赖模块 B，不是依赖它的实现细节，而是依赖它的某些
-行为承诺——返回值的类型、格式、语义。把这些保证从隐含变成**显式、可执行、可验证**，正确性的判定
-就从「AI 觉得自己改对了」变成「所有被依赖的保证仍通过」——一个可机械验证的布尔条件。
-
-![无 GBC vs 有 GBC](docs/assets/workflow-comparison.svg)
-
-GBC **不是**另一个要挑战 Cursor / Aider 的 AI 编程助手，而是填补它们在大型项目里缺的一环：
-**机器可判定的变更边界**。它与那些 agent 配合——改前查依赖树，改后必须跑通所有相关保证；也区别
-于 CI——CI 是事后的，GBC 是准入制的门禁，错误在落地前就被拦在 agent 的上下文里。
-
-完整概念、架构图、与已有概念（Design by Contract / 测试）的区别，见
-[核心概念](./docs/zh/concepts.md)。
-
----
-
-## 当前状态
-
-GBC 目前是一个可用的 Python 分发包（`pipx install guarantee-based-coding`），自身用 GBC 管理自己的
-`.gbc/`（dogfooding）：
-
-- ✅ 核心保证机制（具名 id、多对一、出生即绿、退休保护、反查）
-- ✅ 多语言 executor 配置
-- ✅ CLI + MCP 双接口（含意图文档 `gbc doc` 全进 MCP）
-- ✅ 意图文档子系统（`gbc doc` / web 编辑器）
-- ✅ 随包分发的接线指南（`gbc setup`）与 CLI-only agent 的 skill 包
-- ✅ 原子文件写入 + 备份
-
-
-**诚实的局限**：保护能力上限 = 测试质量（测试只走 happy path 就是虚假安全感）；依赖需主动登记，
-覆盖率随项目增长需持续投入；每次验证真实跑测试，有一定延迟。详见
-[核心概念 · 局限性](./docs/zh/concepts.md#局限性诚实地说)。
-
----
-
-## 许可
-
-本项目采用 [Apache-2.0](./LICENSE) 许可证。
-
-## 联系
-
-如果你对这个方向感兴趣，欢迎 star、issue 或者直接联系我。
+Metadata-Version: 2.4
+Name: guarantee-based-coding
+Version: 0.2.3
+Summary: Make code safely modifiable even when not fully understood — turn implicit inter-module dependencies into explicit, executable, verifiable guarantees.
+Author: Jesse-x86
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Jesse-x86/guarantee-based-coding
+Project-URL: Repository, https://github.com/Jesse-x86/guarantee-based-coding
+Keywords: guarantee,testing,ai-coding,mcp,code-safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: pydantic
+Requires-Dist: mcp<2.0,>=1.0
+Dynamic: license-file
+
+# Guarantee-Based Coding (GBC)
+
+**与其指望 AI 更聪明，不如让再笨的 agent 也改不坏你的代码。**
+
+**English version: [docs/en/README.md](docs/en/README.md)**
+
+GBC 把「这次改动会不会悄悄碰坏别处」从一种担心，变成可以当场验证的事实：你在意的行为被登记成
+一条条带测试的**保证（guarantee）**，每次改完一跑——全绿就安心，有红就精确告诉你碰坏了谁、谁在
+依赖它。
+
+---
+
+## 🚀 快速开始
+
+```bash
+pipx install guarantee-based-coding
+gbc setup        # 打印本地化接线指南：怎么把 MCP / skills 接入你的 agent
+```
+
+装好后 `gbc` 命令即在 PATH 上。完整上手（安装 → 接入 agent → 冒烟验证）见
+**[docs/zh/quick-start.md](./docs/zh/quick-start.md)**。
+
+想让 agent 替你接入？把 **[docs/zh/onboarding-agent.md](./docs/zh/onboarding-agent.md)** 交给它。
+
+---
+
+> 🚧 **交互式 demo 施工中**：旧的演示套件已废弃，新的交互式演示正在筹备。目前请直接读文档上手。
+
+---
+
+## 📚 文档
+
+| 你想 | 看这里 |
+|------|--------|
+| 装好并跑起来 | [快速开始](./docs/zh/quick-start.md) |
+| 懂 GBC 在保护什么 | [核心概念](./docs/zh/concepts.md) |
+| 在 GBC 下安全改代码 | [工作流](./docs/zh/workflow.md) |
+| 查命令 / 工具 / executor | [参考手册](./docs/zh/reference.md) |
+| 你是 agent，被要求接入 GBC | [Agent 上手](./docs/zh/onboarding-agent.md) |
+
+English docs: [docs/en/](./docs/en/)。
+
+---
+
+## 核心想法
+
+代码之间的依赖本质上是一组**保证**。模块 A 依赖模块 B，不是依赖它的实现细节，而是依赖它的某些
+行为承诺——返回值的类型、格式、语义。把这些保证从隐含变成**显式、可执行、可验证**，正确性的判定
+就从「AI 觉得自己改对了」变成「所有被依赖的保证仍通过」——一个可机械验证的布尔条件。
+
+![无 GBC vs 有 GBC](docs/assets/workflow-comparison.svg)
+
+GBC **不是**另一个要挑战 Cursor / Aider 的 AI 编程助手，而是填补它们在大型项目里缺的一环：
+**机器可判定的变更边界**。它与那些 agent 配合——改前查依赖树，改后必须跑通所有相关保证；也区别
+于 CI——CI 是事后的，GBC 是准入制的门禁，错误在落地前就被拦在 agent 的上下文里。
+
+完整概念、架构图、与已有概念（Design by Contract / 测试）的区别，见
+[核心概念](./docs/zh/concepts.md)。
+
+---
+
+## 当前状态
+
+GBC 目前是一个可用的 Python 分发包（`pipx install guarantee-based-coding`），自身用 GBC 管理自己的
+`.gbc/`（dogfooding）：
+
+- ✅ 核心保证机制（具名 id、多对一、出生即绿、退休保护、反查）
+- ✅ 多语言 executor 配置
+- ✅ CLI + MCP 双接口（含意图文档 `gbc doc` 全进 MCP）
+- ✅ 意图文档子系统（`gbc doc` / web 编辑器）
+- ✅ 随包分发的接线指南（`gbc setup`）与 CLI-only agent 的 skill 包
+- ✅ 原子文件写入 + 备份
+
+
+**诚实的局限**：保护能力上限 = 测试质量（测试只走 happy path 就是虚假安全感）；依赖需主动登记，
+覆盖率随项目增长需持续投入；每次验证真实跑测试，有一定延迟。详见
+[核心概念 · 局限性](./docs/zh/concepts.md#局限性诚实地说)。
+
+---
+
+## 许可
+
+本项目采用 [Apache-2.0](./LICENSE) 许可证。
+
+## 联系
+
+如果你对这个方向感兴趣，欢迎 star、issue 或者直接联系我。

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/gbc/__init__.py

@@ -18,4 +18,4 @@
 显式、可执行、可验证的保证。本包是该方法的实现，也是它的第一个使用者。
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/gbc/app/core/guarantee.py

@@ -241,9 +241,10 @@ def remove_dependency(
 ) -> None:
     """撤销一条依赖（add_dependency 的逆操作，同样维护双向一致）。
 
-    - gid 非 None：只摘掉这一个保证依赖（consumer 边去掉 gid，provider 反向边去掉 consumer），
-      symbol 边若还挂着别的保证则保留。
-    - gid 为 None：整条 symbol 边连同它挂的所有保证一起撤销，并从各保证的 dependents 摘除 consumer。
+    - gid 非 None：只摘掉这一个保证依赖，保留 symbol 边（可退为免费依赖）。
+    - gid 为 None：整条 symbol 边连同它挂的所有保证一起撤销。
+    两种撤销都仅在 consumer 不再通过任何 symbol 依赖同一 provider 的同一保证时，
+    才从该保证的 dependents 摘除 consumer。
     """
     symbol = f"{provider}:{symbol_name}"
     dep = _find_dependency(consumer_meta, symbol)
@@ -251,19 +252,25 @@ def remove_dependency(
         raise GuaranteeNotFoundError(target_file=consumer, guarantee_path=symbol)
 
     def _detach(target_gid: str) -> None:
+        if any(
+            remaining.symbol.startswith(f"{provider}:")
+            and target_gid in remaining.guarantees
+            for remaining in consumer_meta.depends_on
+        ):
+            return
         guarantee = provider_meta.provides.get(target_gid)
         if guarantee and consumer in guarantee.dependents:
             guarantee.dependents.remove(consumer)
 
     if gid is None:
+        consumer_meta.depends_on.remove(dep)
         for g in list(dep.guarantees):
             _detach(g)
-        consumer_meta.depends_on.remove(dep)
         return
 
     if gid in dep.guarantees:
         dep.guarantees.remove(gid)
-    _detach(gid)
+        _detach(gid)
     # symbol 边变空（无保证）后是否保留：保留——它仍是一条有效的免费 symbol 依赖。
 
 

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/gbc/app/interface/cli.py

@@ -443,6 +443,8 @@ def verify_provider(
             console.print(f"[magenta]{len(disabled)} DISABLED (born-green suspended):[/magenta] {tags}")
     except Exception as e:
         raise handle_error(e)
+    if not s.green:
+        raise typer.Exit(code=1)
 
 
 @verify_app.command("single")
@@ -467,6 +469,8 @@ def verify_single(
                 console.print(f"[dim]── stderr ──[/dim]\n{result.stderr.rstrip()}")
     except Exception as e:
         raise handle_error(e)
+    if not passed:
+        raise typer.Exit(code=1)
 
 
 # ======== Refactor ========
@@ -579,6 +583,8 @@ def doctor_check(
             console.print_json(json.dumps(notices, ensure_ascii=False))
     except Exception as e:
         raise handle_error(e)
+    if errors:
+        raise typer.Exit(code=1)
 
 
 # ======== Executor Commands ========

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3/guarantee_based_coding.egg-info}/PKG-INFO

@@ -1,108 +1,108 @@
-Metadata-Version: 2.4
-Name: guarantee-based-coding
-Version: 0.2.2
-Summary: Make code safely modifiable even when not fully understood — turn implicit inter-module dependencies into explicit, executable, verifiable guarantees.
-Author: Jesse-x86
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/Jesse-x86/guarantee-based-coding
-Project-URL: Repository, https://github.com/Jesse-x86/guarantee-based-coding
-Keywords: guarantee,testing,ai-coding,mcp,code-safety
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typer[all]
-Requires-Dist: pydantic
-Requires-Dist: mcp<2.0,>=1.0
-Dynamic: license-file
-
-# Guarantee-Based Coding (GBC)
-
-**与其指望 AI 更聪明，不如让再笨的 agent 也改不坏你的代码。**
-
-**English version: [docs/en/README.md](docs/en/README.md)**
-
-GBC 把「这次改动会不会悄悄碰坏别处」从一种担心，变成可以当场验证的事实：你在意的行为被登记成
-一条条带测试的**保证（guarantee）**，每次改完一跑——全绿就安心，有红就精确告诉你碰坏了谁、谁在
-依赖它。
-
----
-
-## 🚀 快速开始
-
-```bash
-pipx install guarantee-based-coding
-gbc setup        # 打印本地化接线指南：怎么把 MCP / skills 接入你的 agent
-```
-
-装好后 `gbc` 命令即在 PATH 上。完整上手（安装 → 接入 agent → 冒烟验证）见
-**[docs/zh/quick-start.md](./docs/zh/quick-start.md)**。
-
-想让 agent 替你接入？把 **[docs/zh/onboarding-agent.md](./docs/zh/onboarding-agent.md)** 交给它。
-
----
-
-> 🚧 **交互式 demo 施工中**：旧的演示套件已废弃，新的交互式演示正在筹备。目前请直接读文档上手。
-
----
-
-## 📚 文档
-
-| 你想 | 看这里 |
-|------|--------|
-| 装好并跑起来 | [快速开始](./docs/zh/quick-start.md) |
-| 懂 GBC 在保护什么 | [核心概念](./docs/zh/concepts.md) |
-| 在 GBC 下安全改代码 | [工作流](./docs/zh/workflow.md) |
-| 查命令 / 工具 / executor | [参考手册](./docs/zh/reference.md) |
-| 你是 agent，被要求接入 GBC | [Agent 上手](./docs/zh/onboarding-agent.md) |
-
-English docs: [docs/en/](./docs/en/)。
-
----
-
-## 核心想法
-
-代码之间的依赖本质上是一组**保证**。模块 A 依赖模块 B，不是依赖它的实现细节，而是依赖它的某些
-行为承诺——返回值的类型、格式、语义。把这些保证从隐含变成**显式、可执行、可验证**，正确性的判定
-就从「AI 觉得自己改对了」变成「所有被依赖的保证仍通过」——一个可机械验证的布尔条件。
-
-![无 GBC vs 有 GBC](docs/assets/workflow-comparison.svg)
-
-GBC **不是**另一个要挑战 Cursor / Aider 的 AI 编程助手，而是填补它们在大型项目里缺的一环：
-**机器可判定的变更边界**。它与那些 agent 配合——改前查依赖树，改后必须跑通所有相关保证；也区别
-于 CI——CI 是事后的，GBC 是准入制的门禁，错误在落地前就被拦在 agent 的上下文里。
-
-完整概念、架构图、与已有概念（Design by Contract / 测试）的区别，见
-[核心概念](./docs/zh/concepts.md)。
-
----
-
-## 当前状态
-
-GBC 目前是一个可用的 Python 分发包（`pipx install guarantee-based-coding`），自身用 GBC 管理自己的
-`.gbc/`（dogfooding）：
-
-- ✅ 核心保证机制（具名 id、多对一、出生即绿、退休保护、反查）
-- ✅ 多语言 executor 配置
-- ✅ CLI + MCP 双接口（含意图文档 `gbc doc` 全进 MCP）
-- ✅ 意图文档子系统（`gbc doc` / web 编辑器）
-- ✅ 随包分发的接线指南（`gbc setup`）与 CLI-only agent 的 skill 包
-- ✅ 原子文件写入 + 备份
-
-
-**诚实的局限**：保护能力上限 = 测试质量（测试只走 happy path 就是虚假安全感）；依赖需主动登记，
-覆盖率随项目增长需持续投入；每次验证真实跑测试，有一定延迟。详见
-[核心概念 · 局限性](./docs/zh/concepts.md#局限性诚实地说)。
-
----
-
-## 许可
-
-本项目采用 [Apache-2.0](./LICENSE) 许可证。
-
-## 联系
-
-如果你对这个方向感兴趣，欢迎 star、issue 或者直接联系我。
+Metadata-Version: 2.4
+Name: guarantee-based-coding
+Version: 0.2.3
+Summary: Make code safely modifiable even when not fully understood — turn implicit inter-module dependencies into explicit, executable, verifiable guarantees.
+Author: Jesse-x86
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Jesse-x86/guarantee-based-coding
+Project-URL: Repository, https://github.com/Jesse-x86/guarantee-based-coding
+Keywords: guarantee,testing,ai-coding,mcp,code-safety
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: pydantic
+Requires-Dist: mcp<2.0,>=1.0
+Dynamic: license-file
+
+# Guarantee-Based Coding (GBC)
+
+**与其指望 AI 更聪明，不如让再笨的 agent 也改不坏你的代码。**
+
+**English version: [docs/en/README.md](docs/en/README.md)**
+
+GBC 把「这次改动会不会悄悄碰坏别处」从一种担心，变成可以当场验证的事实：你在意的行为被登记成
+一条条带测试的**保证（guarantee）**，每次改完一跑——全绿就安心，有红就精确告诉你碰坏了谁、谁在
+依赖它。
+
+---
+
+## 🚀 快速开始
+
+```bash
+pipx install guarantee-based-coding
+gbc setup        # 打印本地化接线指南：怎么把 MCP / skills 接入你的 agent
+```
+
+装好后 `gbc` 命令即在 PATH 上。完整上手（安装 → 接入 agent → 冒烟验证）见
+**[docs/zh/quick-start.md](./docs/zh/quick-start.md)**。
+
+想让 agent 替你接入？把 **[docs/zh/onboarding-agent.md](./docs/zh/onboarding-agent.md)** 交给它。
+
+---
+
+> 🚧 **交互式 demo 施工中**：旧的演示套件已废弃，新的交互式演示正在筹备。目前请直接读文档上手。
+
+---
+
+## 📚 文档
+
+| 你想 | 看这里 |
+|------|--------|
+| 装好并跑起来 | [快速开始](./docs/zh/quick-start.md) |
+| 懂 GBC 在保护什么 | [核心概念](./docs/zh/concepts.md) |
+| 在 GBC 下安全改代码 | [工作流](./docs/zh/workflow.md) |
+| 查命令 / 工具 / executor | [参考手册](./docs/zh/reference.md) |
+| 你是 agent，被要求接入 GBC | [Agent 上手](./docs/zh/onboarding-agent.md) |
+
+English docs: [docs/en/](./docs/en/)。
+
+---
+
+## 核心想法
+
+代码之间的依赖本质上是一组**保证**。模块 A 依赖模块 B，不是依赖它的实现细节，而是依赖它的某些
+行为承诺——返回值的类型、格式、语义。把这些保证从隐含变成**显式、可执行、可验证**，正确性的判定
+就从「AI 觉得自己改对了」变成「所有被依赖的保证仍通过」——一个可机械验证的布尔条件。
+
+![无 GBC vs 有 GBC](docs/assets/workflow-comparison.svg)
+
+GBC **不是**另一个要挑战 Cursor / Aider 的 AI 编程助手，而是填补它们在大型项目里缺的一环：
+**机器可判定的变更边界**。它与那些 agent 配合——改前查依赖树，改后必须跑通所有相关保证；也区别
+于 CI——CI 是事后的，GBC 是准入制的门禁，错误在落地前就被拦在 agent 的上下文里。
+
+完整概念、架构图、与已有概念（Design by Contract / 测试）的区别，见
+[核心概念](./docs/zh/concepts.md)。
+
+---
+
+## 当前状态
+
+GBC 目前是一个可用的 Python 分发包（`pipx install guarantee-based-coding`），自身用 GBC 管理自己的
+`.gbc/`（dogfooding）：
+
+- ✅ 核心保证机制（具名 id、多对一、出生即绿、退休保护、反查）
+- ✅ 多语言 executor 配置
+- ✅ CLI + MCP 双接口（含意图文档 `gbc doc` 全进 MCP）
+- ✅ 意图文档子系统（`gbc doc` / web 编辑器）
+- ✅ 随包分发的接线指南（`gbc setup`）与 CLI-only agent 的 skill 包
+- ✅ 原子文件写入 + 备份
+
+
+**诚实的局限**：保护能力上限 = 测试质量（测试只走 happy path 就是虚假安全感）；依赖需主动登记，
+覆盖率随项目增长需持续投入；每次验证真实跑测试，有一定延迟。详见
+[核心概念 · 局限性](./docs/zh/concepts.md#局限性诚实地说)。
+
+---
+
+## 许可
+
+本项目采用 [Apache-2.0](./LICENSE) 许可证。
+
+## 联系
+
+如果你对这个方向感兴趣，欢迎 star、issue 或者直接联系我。

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/tests/test_cli_commands.py

@@ -12,6 +12,7 @@
 - 根 --help 根据 --lang / GBC_LANG 输出对应语言文本。
 """
 import importlib
+import json
 import os
 from pathlib import Path
 import subprocess
@@ -420,6 +421,109 @@ def _gbc(*args, env=None):
     )
 
 
+@pytest.fixture
+def gate_project(tmp_path):
+    """A real temporary GBC project whose executor runs a controllable script."""
+    project = tmp_path / "gate-project"
+    project.mkdir()
+    (project / "provider.py").write_text("def behavior(): pass\n", encoding="utf-8")
+    script = project / "check.py"
+    script.write_text("print('gate-check'); raise SystemExit(0)\n", encoding="utf-8")
+
+    def invoke(*args):
+        return _gbc("--lang", "en", *args, "-C", str(project))
+
+    config = {"command": [sys.executable, "{file}"], "cwd": str(project)}
+    result = invoke("executor", "upsert", "gate-script", "--json", json.dumps(config))
+    assert result.returncode == 0, result.stdout + result.stderr
+    result = invoke(
+        "guarantee", "create", "provider.py", "behavior.gate", "check.py",
+        "gate-script", "CLI gate regression",
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    return project, script, invoke
+
+
+class TestGateExitCodes:
+    """Real entry-point processes must expose gate outcomes to shell callers."""
+
+    @pytest.mark.parametrize("command", ["single", "provider"])
+    @pytest.mark.parametrize("fails", [False, True])
+    def test_verify_exit_matches_executed_result(self, gate_project, command, fails):
+        _, script, invoke = gate_project
+        script.write_text(
+            f"print('gate-check'); raise SystemExit({7 if fails else 0})\n",
+            encoding="utf-8",
+        )
+        args = ["verify", command, "provider.py"]
+        if command == "single":
+            args.append("behavior.gate")
+        result = invoke(*args)
+        output = result.stdout + result.stderr
+        status = ("FAIL" if fails else "PASS") if command == "single" else (
+            "RED" if fails else "GREEN"
+        )
+        assert status in output
+        assert (result.returncode != 0) is fails, output
+        assert "unexpected" not in output.lower()
+        assert "Traceback" not in output
+        if command == "single" and fails:
+            assert "gate-check" in output
+
+    @pytest.mark.parametrize("skip", ["heavy", "disabled"])
+    def test_provider_only_skips_are_success(self, gate_project, skip):
+        _, script, invoke = gate_project
+        if skip == "heavy":
+            update = invoke("guarantee", "update", "provider.py", "behavior.gate", "--heavy", "1")
+        else:
+            update = invoke("guarantee", "disable", "provider.py", "behavior.gate")
+        assert update.returncode == 0, update.stdout + update.stderr
+        script.write_text("raise SystemExit(7)\n", encoding="utf-8")
+        result = invoke("verify", "provider", "provider.py")
+        assert result.returncode == 0, result.stdout + result.stderr
+        assert "GREEN" in result.stdout
+        assert "skipped=1" in result.stdout
+        assert ("heavy skipped" if skip == "heavy" else "DISABLED") in result.stdout
+
+    @pytest.mark.parametrize("broken", [False, True])
+    @pytest.mark.parametrize("disabled", [False, True])
+    def test_doctor_errors_fail_but_disabled_notices_do_not(self, gate_project, broken, disabled):
+        project, _, invoke = gate_project
+        (project / "consumer.py").write_text("# consumer\n", encoding="utf-8")
+        result = invoke("dep", "add", "consumer.py", "provider.py", "behavior", "-g", "behavior.gate")
+        assert result.returncode == 0, result.stdout + result.stderr
+        if disabled:
+            result = invoke("guarantee", "disable", "provider.py", "behavior.gate")
+            assert result.returncode == 0, result.stdout + result.stderr
+        if broken:
+            # Simulate lost consumer metadata, leaving a real dangling reverse edge.
+            (project / ".gbc" / "gbc.consumer.py.json").unlink()
+        result = invoke("doctor", "check")
+        output = result.stdout + result.stderr
+        if broken:
+            assert "missing_forward" in output
+        elif not disabled:
+            assert "consistent" in output
+        if disabled:
+            assert "disabled notice" in output
+        assert (result.returncode != 0) is broken, output
+        assert "unexpected" not in output.lower()
+        assert "Traceback" not in output
+
+    def test_born_green_failure_stays_nonzero(self, gate_project):
+        _, script, invoke = gate_project
+        script.write_text("raise SystemExit(7)\n", encoding="utf-8")
+        result = invoke(
+            "guarantee", "create", "provider.py", "behavior.rejected", "check.py",
+            "gate-script", "Must refuse failing birth",
+        )
+        assert result.returncode != 0, result.stdout + result.stderr
+        assert "behavior.rejected" in result.stdout
+        listed = invoke("guarantee", "list", "provider.py")
+        assert listed.returncode == 0, listed.stdout + listed.stderr
+        assert "behavior.rejected" not in listed.stdout
+
+
 def test_e2e_doctor_missing_gbc_propagates_nonzero_exit(tmp_path):
     """承诺:python -m 将 doctor 的失败返回码传播给真实子进程。"""
     missing = tmp_path / "missing"

{guarantee_based_coding-0.2.2 → guarantee_based_coding-0.2.3}/tests/test_guarantee_deps.py

@@ -2,10 +2,11 @@
 
 import pytest
 from gbc.app.models.meta import FileMeta, Guarantee, Dependency
-from gbc.app.models.errors import GuaranteeNotFoundError
+from gbc.app.models.errors import GuaranteeNotFoundError, GuaranteeHasDependentsError
 from gbc.app.core.guarantee import (
     add_dependency,
     remove_dependency,
+    retire_guarantee,
     list_provides,
     list_depends_on,
     dependents_of,
@@ -151,6 +152,88 @@ class TestRemoveDependency:
 
 # ======================== list_provides / list_depends_on ========================
 
+@pytest.mark.parametrize("whole_symbol", [False, True])
+def test_shared_guarantee_keeps_retirement_guard_until_last_symbol_removed(whole_symbol):
+    consumer_meta = FileMeta()
+    provider_meta = make_provider_meta()
+    for name in (SYMBOL_NAME, "other_helper"):
+        add_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, name, GID)
+
+    gid = None if whole_symbol else GID
+    remove_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, SYMBOL_NAME, gid)
+
+    assert dependents_of(provider_meta, GID) == [CONSUMER_PATH]
+    assert any(dep.symbol == f"{PROVIDER_PATH}:other_helper" and GID in dep.guarantees
+               for dep in consumer_meta.depends_on)
+    with pytest.raises(GuaranteeHasDependentsError):
+        retire_guarantee(provider_meta, PROVIDER_PATH, GID)
+
+    remove_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, "other_helper", gid)
+
+    assert dependents_of(provider_meta, GID) == []
+    if whole_symbol:
+        assert consumer_meta.depends_on == []
+    else:
+        assert len(consumer_meta.depends_on) == 2
+        assert all(dep.guarantees == [] for dep in consumer_meta.depends_on)
+    retire_guarantee(provider_meta, PROVIDER_PATH, GID)
+    assert GID not in provider_meta.provides
+
+
+@pytest.mark.parametrize("whole_symbol", [False, True])
+def test_removing_dependency_preserves_other_consumer(whole_symbol):
+    consumer_meta = FileMeta()
+    other_consumer = FileMeta()
+    other_path = "app/core/other_consumer.py"
+    provider_meta = make_provider_meta()
+    for meta, path in ((consumer_meta, CONSUMER_PATH), (other_consumer, other_path)):
+        add_dependency(meta, path, provider_meta, PROVIDER_PATH, SYMBOL_NAME, GID)
+
+    remove_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH,
+                      SYMBOL_NAME, None if whole_symbol else GID)
+
+    assert dependents_of(provider_meta, GID) == [other_path]
+    assert other_consumer.depends_on[0].guarantees == [GID]
+    with pytest.raises(GuaranteeHasDependentsError):
+        retire_guarantee(provider_meta, PROVIDER_PATH, GID)
+
+
+@pytest.mark.parametrize("whole_symbol", [False, True])
+def test_same_guarantee_id_on_other_provider_does_not_keep_removed_reverse_edge(whole_symbol):
+    consumer_meta = FileMeta()
+    provider_meta = make_provider_meta()
+    other_provider = make_provider_meta()
+    other_path = "app/core/provider.py.extra"
+    for meta, path in ((provider_meta, PROVIDER_PATH), (other_provider, other_path)):
+        add_dependency(consumer_meta, CONSUMER_PATH, meta, path, SYMBOL_NAME, GID)
+
+    remove_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH,
+                      SYMBOL_NAME, None if whole_symbol else GID)
+
+    assert dependents_of(provider_meta, GID) == []
+    assert dependents_of(other_provider, GID) == [CONSUMER_PATH]
+    assert any(dep.symbol == f"{other_path}:{SYMBOL_NAME}" and GID in dep.guarantees
+               for dep in consumer_meta.depends_on)
+    retire_guarantee(provider_meta, PROVIDER_PATH, GID)
+    with pytest.raises(GuaranteeHasDependentsError):
+        retire_guarantee(other_provider, other_path, GID)
+
+
+def test_removing_gid_not_attached_to_target_symbol_preserves_valid_dependency():
+    consumer_meta = FileMeta()
+    provider_meta = make_provider_meta()
+    add_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, SYMBOL_NAME)
+    add_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, "other_helper", GID)
+    before_consumer = consumer_meta.model_dump()
+    before_provider = provider_meta.model_dump()
+
+    remove_dependency(consumer_meta, CONSUMER_PATH, provider_meta, PROVIDER_PATH, SYMBOL_NAME, GID)
+
+    assert consumer_meta.model_dump() == before_consumer
+    assert provider_meta.model_dump() == before_provider
+    with pytest.raises(GuaranteeHasDependentsError):
+        retire_guarantee(provider_meta, PROVIDER_PATH, GID)
+
 class TestListFunctions:
     def test_list_provides_returns_provides_copy(self):
         meta = make_provider_meta()