@antprofuse/saddle-skill 0.2.0 → 0.3.0-alpha.1

package/SKILL.md

@@ -1,73 +1,54 @@
 ---
-name: saddle-service-0-2
-description: 使用 Saddle 0.2 冻结候选声明生成和审查受管 Rust 业务应用。仅在任务明确针对已发布且身份匹配的 Saddle 0.2 Rust 制品时使用，覆盖唯一 application bootstrap、静态 Service/route/内部调用图、query_optional、standalone write、单层 transaction commit/业务 rollback，以及禁止 V1、裸 I/O、普通容器和第二执行面的 Gate。
+name: saddle-service-0-3
+description: 使用正式 Saddle 0.3.0-alpha.1 开发或审查带 profusegw 固定入口和 profusecontract 强类型外部函数调用的 Rust 业务应用。用于根据纯业务 spec 定义共同 protobuf 契约、编写固定 ProfuseGwContext handler、穷举技术失败，或运行正式业务门禁。
 ---
 
-# Saddle 0.2 真实 Facade 研发契约候选
+# Saddle 0.3.0-alpha.1 业务研发契约
 
-先核对 Rust Facade、Skill package、[公开 API snapshot](references/public-api.snapshot)
-与 machine schema 的版本身份。开发候选必须精确匹配 manifest 中的 source commit；
-正式使用必须匹配已发布 Rust 制品。任一身份不一致时停止生成，不用其他 workspace
-path、设计目标或相邻版本替代。
+业务 Agent 的直接输入只有业务 spec 与本 Skill。不要要求用户阅读 Saddle 仓库、审计报告、组件提交或内部实现。
 
-## 执行顺序
+## 必须按顺序执行
 
-1. 阅读 [声明语法](references/declaration-schema.md)，只编写一个
-   `saddle::application!` 声明。
-2. 阅读 [公开 API 边界](references/api-boundary.md)，区分稳定源码契约与
-   build-internal 类型。
-3. 涉及旧应用升级时阅读 [迁移规则](references/migration.md)。
-4. 交付前按 [machine schema](references/machine-schema.md) 生成并核对构建输入。
-5. 以 `assets/registry-consumer` 为可编译基准生成私有
-   `GeneratedApplicationOwner`。application marker 必须公开一个 provider-generic、
-   consuming 的 `run<B: ApprovedExternalBundle>(bundle, config)`；函数体只能在私有
-   generated module 内移动一次 owner 到
-   `ProductionLauncher::verify(bundle)?.run(config, GeneratedOwner)`。不得生成 bundle、
-   credential、raw constructor，也不得公开 owner。
-6. 运行 `scripts/validate-contract.sh <application.rs>` 与
-   `scripts/validate-generated-project.sh <project-root>`；核对 public API snapshot、
-   approved locks、package allowlist、同源 managed-object peak 与 machine
-   fingerprint，再运行正式 Rust package 提供的 Gate，不自行实现替代 Gate。生成工程
-   验证必须设置 `CARGO_NET_OFFLINE=true`，并通过已批准的 entry-local runner 创建
-   canonical `/tmp` 直属临时根；入口只接受其中独立的 `cargo-home`、`target` 与 `work`，
-   覆盖继承的 `CARGO_HOME`，在成功、STOP 和其他失败退出后删除整个临时根，并输出由
-   toolchain、target、features、lock、source 与 build contract 共同派生的 cache key。
+1. 阅读 [消费者起手式](references/consumer-start.md)，只从业务 spec 提取接口、业务类型、业务规则、业务结果和外部业务能力。
+2. 每个外部能力先按 [外部函数协议](references/external-function-contracts.md) 定义双方共同的 `.proto`。冻结文件原始 bytes 与 SHA-256 后，才并行交给 Saddle 后端和 profusecontract 实现。
+3. 按 [编程模型](references/programming-model.md) 声明应用、固定 profusegw operation、应用级强类型外部函数能力和唯一 handler。
+4. 对八类技术失败与三种执行确定性逐项给出业务 spec 明确允许的处理。禁止 wildcard/default、自动重试、默认业务成功或空结果。
+5. 按 [正式 Gate](references/validation.md) 生成 lock，并在交付前运行：
 
-## 生成约束
+   ```bash
+   npx --no-install saddle-03-gate --manifest-path Cargo.toml
+   ```
 
-- 生成唯一 bootstrap、registry seal、dispatcher、classified adapter 和 startup
-  assembly。
-- generated module 和 owner 必须保持私有；业务声明只能命名 application marker，
-  不能命名、构造、Clone、提取或重放 owner/token/proof。
-- Test/部署控制面从外部注入合法 `ApprovedExternalBundle` 与 `SaddleConfig`；Skill 只生成
-  可被该控制面调用的 business consumer，不生成或保存生产凭据与部署实例。
-- route、Service、内部调用边、DB operation 与 transaction decision 必须全部来自
-  同一声明。
-- query、write、transaction 只使用静态 SQL 与固定受管参数/结果 shape。
-- transaction 仅允许一个 write step，显式 `commit` 或 `business_rollback`。
-- handler 保持 async 源码体验，但不得出现 boxed/dyn Future 或业务自建 executor。
-- generated artifact 只携 route/framing、DB work、具体静态 layout、每 route
-  commitment/managed-object/DB credit 与 build/artifact/route-set identity。
-- capacity、deadline、task bytes、StartupPlan 与 deployment calibration 由 Gate/Runtime
-  从已验证资源产生；generated/业务不得填写、枚举、观察或依赖这些值。
-- Service capacity、termination、continuation 与 runtime layout proof 必须由同一次
-  registry freeze 的整包进入 Facade 后在组件内部签发并消费。generated crate 不得实现
-  proof trait、声明 proof associated type、拆分 capacity leaf，或复制任何 identity。
-- 私有 generated owner 只能把同次 freeze 的不可 `Clone` 整包移动进
-  `generated_bootstrap`，再把得到的 opaque bootstrap 作为 `seal.bind(bootstrap)` 的唯一
-  输入；业务/provider 不得观察、构造或传入 layout、size、route identity 或 proof。
+6. Gate 或编译失败时停止，保留最小业务 consumer 复现；不得复制或修改 Saddle 中间件绕过。
 
-## 停止条件
+## 正式版本身份
 
-- Rust/Skill/schema 版本或摘要不匹配；
-- 只有源码候选、没有身份匹配的已发布 Rust Facade，却要求按正式制品使用；
-- 需要动态 SQL、多 step/嵌套事务、后台任务、第三方 I/O 或未交付能力；
-- 需要 V1 `ServiceHandler`、`Statement`、普通 serde、`String`、`Vec`、raw sqlx、
-  第二 Runtime/task/dispatcher/assembly；
-- signed production bundle、final calibration 或 release profile 尚未由正式制品冻结。
+业务 crate 必须精确依赖：
 
-上述最后一项只禁止 Skill 伪造具体部署实例，不阻止生成 provider-generic consumer。
-若任务要求由 Skill 自造 bundle/credential，必须停止；若外部 Test provider 可用，则继续
-生成并验证 consumer。
+```toml
+[dependencies]
+saddle-framework = "=0.3.0-alpha.1"
+```
 
-停止时提交最小可复现案例，不读取或复制中间件实现。
+`saddle-framework` 是唯一业务 facade。业务不得直接依赖 `saddle-core`、`saddle-admission`、`saddle-boundary`、`saddle-db`、`saddle-macros`、`saddle-observability`、`saddle-runtime` 或 `saddle-service`。
+
+## 固定边界
+
+- Saddle 编译进业务应用，不是独立服务、进程或控制面。
+- profusegw 唯一入口是 `POST /saddle/v1/ingress/profusegw/invoke`；不得手写 listener、HTTP handler 或第二路由。
+- 所有 handler 使用 `saddle::ingress::ProfuseGwContext`；alpha.1 只读取只读、有界的 `user_id`，不得读取 Header、Cookie、原始 JSON 或任意上下文 Map。
+- 外部函数由共同 `.proto` 的 `(business_unit, function)` 精确定位。中文 `function` 逐字保留，不翻译、不 alias、不 fallback、不动态选择。
+- 业务只使用生成的应用级强类型 capability，不接触 channel、stub、裸 protobuf bytes、动态函数名或通用依赖容器。
+- 不支持 contract 多版本路由、`Any`、开放 Map、任意 JSON、streaming、cancel 或框架自动业务重试。
+- 不创建线程、第二 Runtime、后台 task、裸 DB/网络 I/O、日志 subscriber 或第二执行面。
+
+## 立即停止
+
+- 双方没有同一份已冻结 `.proto`，或 descriptor 摘要不同；
+- method option 缺少逐字 `business_unit + function`；
+- 请求、结果、字符串、bytes、集合或嵌套对象没有业务静态上限；
+- 需要动态 function/descriptor、raw invoke、裸 gRPC、原始网络上下文或未声明外部 I/O；
+- 八类技术失败或三种执行确定性未显式处理；
+- Cargo 不是精确 alpha.1 facade、缺 lock，或正式 Gate 不通过。
+
+停止时只交最小复现和期望业务表达，由 Saddle 修复公共能力缺口。

package/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
-  display_name: "Saddle 0.2 研发契约"
-  short_description: "生成并验证受管 Service、数据库与单层事务应用"
-  default_prompt: "使用 $saddle-service-0-2 按真实 Facade 契约生成并验证 Saddle 0.2 应用。"
+  display_name: "Saddle 0.3 业务应用"
+  short_description: "使用 Saddle 0.3 开发受控边界的 Rust 业务应用"
+  default_prompt: "请安装 Saddle 0.3.0-alpha.1 Skill（npm install --save-exact --ignore-scripts --no-audit --no-fund @antprofuse/saddle-skill@0.3.0-alpha.1），结合业务 spec 开始研发。"

package/package.json

@@ -1,19 +1,9 @@
 {
   "name": "@antprofuse/saddle-skill",
-  "version": "0.2.0",
-  "description": "Unpublished immutable Saddle 0.2 Skill candidate.",
+  "version": "0.3.0-alpha.1",
+  "description": "Saddle 0.3.0-alpha.1 中文 AI Coding 研发契约与业务门禁。",
   "license": "MIT OR Apache-2.0",
-  "files": [
-    "SKILL.md",
-    "agents",
-    "references",
-    "assets",
-    "scripts",
-    "package-files.txt",
-    "package-manifest.json"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  }
+  "files": ["SKILL.md", "agents", "references", "scripts"],
+  "bin": {"saddle-03-gate": "scripts/saddle-03-gate.js"},
+  "publishConfig": {"access": "public", "registry": "https://registry.npmjs.org/"}
 }

package/references/consumer-start.md

@@ -0,0 +1,60 @@
+# Saddle 0.3 消费者起手式
+
+## 目标
+
+从纯业务 spec 形成可供 Saddle 后端与 profusecontract 并行消费的同一份外部函数契约和可编译业务 consumer。
+
+## 阶段 0：核对输入
+
+只接受以下业务输入：接口与数据、业务规则、业务成功/拒绝/错误、业务状态，以及所需外部业务能力。若输入要求 HTTP/gRPC 细节、动态函数、框架重试、容量默认值或用户文案，先把这些技术决策从业务 spec 移出。
+
+列出每个外部能力的：
+
+- 业务用途；
+- 具名 request/result；
+- 字符串、bytes、集合与嵌套对象的业务静态上限；
+- 是否有副作用；
+- 八类技术失败与执行确定性下的显式业务决策。
+
+任一项缺失时停止，不进入实现。
+
+## 阶段 1：先冻结共同 `.proto`
+
+按 [外部函数契约](external-function-contracts.md) 为每个能力定义 rpc 与 method option。`function` 必须保留业务契约中的中文原名，例如：
+
+```protobuf
+option (saddle.profusecontract.external_function) = {
+  business_unit: "puc"
+  function: "查询用户绑定户号"
+};
+```
+
+冻结一个 canonical 文件，记录其原始 bytes SHA-256。Saddle 后端与 profusecontract 必须消费同一路径或同摘要副本；不得维护两份“等价”定义。
+
+必须 import `saddle/profusecontract/external_function.proto` 并使用其 `external_function` method option；不得自建同名 extension。
+
+## 阶段 2：同源并行交接
+
+共同 `.proto` 冻结后才创建两个互不改写契约的工作项：
+
+1. **Saddle 后端**：准备 operation、contract、允许函数、固定 `ProfuseGwContext` handler 和技术失败决策；只有阶段 3 身份门禁通过后才写真实 Rust 实现。
+2. **profusecontract**：按同一 `(business_unit, function)` 实现 Java/SOFA 防腐与同 descriptor conformance。
+
+两项交接必须携带相同的 proto bytes SHA-256。任何契约变化先合回 canonical `.proto`，重新冻结后同时通知两侧。
+
+## 阶段 3：Rust 实现
+
+业务 crate 精确使用 `saddle-framework = "=0.3.0-alpha.1"`，然后按 [最小编程模型](programming-model.md) 编写声明和 handler。不得直接依赖任何 Saddle 中间件 crate。
+
+## 阶段 4：闭合前停止条件
+
+以下任一情况立即 STOP：
+
+- 两侧 proto bytes 或 `(business_unit, function)` 不同；
+- 中文 `function` 被翻译、alias、fallback 或动态选择；
+- handler 不使用唯一固定 `ProfuseGwContext`，或读取原始网络上下文；
+- 技术失败码或执行确定性存在 catch-all/default；
+- 需要裸 gRPC/channel/bytes、第二入口、动态 descriptor 或未声明外部 I/O；
+- `saddle-framework` 不是精确 `=0.3.0-alpha.1`，或 [正式 Gate](validation.md) 失败。
+
+停止产物只包含最小复现、缺失身份和期望业务表达，不包含中间件替代实现。

package/references/external-function-contracts.md

@@ -0,0 +1,82 @@
+# profusecontract 外部函数契约
+
+## 目的
+
+把业务应用需要的外部能力定义为 Saddle 后端与 profusecontract 的共同技术边界。先冻结契约，再分别实现业务编排和 SOFA RPC 防腐。
+
+## 唯一身份
+
+外部函数只由以下二元组定位：
+
+```text
+(businessUnit, function)
+```
+
+- `businessUnit` 是业务单元，例如 `puc`。
+- `function` 是契约原始函数名，允许中文，例如 `查询用户绑定户号`。
+- protobuf method、Rust 方法和 Java 方法使用各语言合法的本地标识符；它们不是跨系统身份。
+- 0.3.0 不定义 contract version、多版本路由、翻译表、alias 或 fallback。
+
+## 定义步骤
+
+1. 从业务 spec 识别外部业务能力，不复制 SOFA service、method 或传输模型。
+2. 为每个能力定义具名 protobuf request 和 result。
+3. 使用 Saddle 提供的 `google.protobuf.MethodOptions` extension，把 rpc 方法绑定到 `businessUnit + function`。
+4. 把同一份 `.proto` 交给 Saddle 业务 Agent 和 profusecontract Agent。
+5. Saddle 侧显式引用契约并登记允许调用的函数；profusecontract 侧实现对应函数和防腐映射。
+6. 双方以同一 descriptor 运行 conformance fixture 后再联调。
+
+第 4 步是并行研发的起点，不是第 1 步。交接时至少记录 `.proto` 相对路径、原始 bytes SHA-256、package、service、rpc、`business_unit` 和中文 `function`。任一方改动契约都必须回到共同冻结步骤，不能在各自分支继续演化。
+
+## 模板
+
+```protobuf
+syntax = "proto3";
+
+package puc;
+
+import "saddle/profusecontract/external_function.proto";
+
+service PucExternalFunctions {
+  rpc QueryBoundAccounts(
+    QueryBoundAccountsRequest
+  ) returns (
+    QueryBoundAccountsResult
+  ) {
+    option (saddle.profusecontract.external_function) = {
+      business_unit: "puc"
+      function: "查询用户绑定户号"
+    };
+  }
+}
+
+message QueryBoundAccountsRequest {
+  string user_id = 1;
+}
+
+message QueryBoundAccountsResult {
+  repeated BoundAccount accounts = 1;
+}
+
+message BoundAccount {
+  string account_id = 1;
+}
+```
+
+这里的跨系统正式身份是 `("puc", "查询用户绑定户号")`。`QueryBoundAccounts`、未来生成的 Rust 方法名和 Java 方法名都只是本地代码标识符，不能替换、翻译或推导中文 `function`。
+
+该 import 与 method option 属于 Saddle `0.3.0-alpha.1` 固定协议。不得自行创建同名 extension，也不得复制为另一份协议。
+
+实际线上网络仍只调用 Saddle 固定 `ProfuseContractBoundary/Invoke` unary。契约中的 service/rpc 用于绑定身份、request 和 result，不要求 profusecontract 暴露同名网络方法。
+
+## 数据约束
+
+- request/result 必须具名、封闭且可有界。
+- 禁止 `google.protobuf.Any`、开放 Map、任意 JSON 和承载业务对象的裸 bytes。
+- 字符串、bytes、集合和嵌套对象必须由业务实现明确静态上限；Saddle 验证，不替业务决定数值。
+- result 表达函数契约业务结果；框架 `TechnicalFailure` 不进入 result message。
+- `.proto` 不包含 SOFA service/method、外部 Java 类型、重试、降级、用户文案或容量默认值。
+
+## 变更规则
+
+先修改共同 `.proto` 并重新通过双方 conformance，再修改两侧实现。禁止两侧各自维护近似定义后人工对齐；0.3.0 遇到不兼容变化时停止并共同升级，不在运行时并存或猜测版本。

package/references/programming-model.md

@@ -0,0 +1,84 @@
+# Saddle 0.3 最小编程模型
+
+## 应用显式声明
+
+业务应用使用 `saddle-framework = "=0.3.0-alpha.1"` 的公开编程面：
+
+```rust
+saddle::application! {
+    schema "saddle-application/2";
+    application PucBackend;
+
+    profusecontract {
+        contract "contracts/puc-external-functions.proto";
+        capability PucProfuseContract;
+        functions {
+            QueryBoundAccounts => query_bound_accounts {
+                business_unit "puc";
+                function "查询用户绑定户号";
+            } (
+                QueryBoundAccountsRequest
+            ) -> QueryBoundAccountsResult;
+        }
+    }
+
+    service QueryMyBoundAccounts {
+        ingress profusegw;
+        operation_type "alipay.profuse.industry.puc.queryMyBoundAccounts";
+        request QueryMyBoundAccountsRequest;
+        response QueryMyBoundAccountsResult;
+        handler query_my_bound_accounts;
+        uses QueryBoundAccounts;
+    }
+}
+```
+
+这是业务实现显式写出的静态事实。Saddle 不从 spec 自动选择 contract、function 或调用边，也不允许运行时动态修改。
+
+## Handler
+
+所有 profusegw handler 使用同一固定签名形状：
+
+```rust
+async fn query_my_bound_accounts(
+    request: QueryMyBoundAccountsRequest,
+    context: saddle::ingress::ProfuseGwContext,
+    contract: PucProfuseContract,
+) -> QueryMyBoundAccountsResult;
+```
+
+- `request`：纯业务接口输入。
+- `context`：固定 profusegw 框架上下文；所有接口共用同一类型，0.3.0 只有 `user_id`。
+- `contract`：应用级强类型 profusecontract 调用能力，只包含应用显式登记的函数；不是通用依赖注入容器。
+
+所有 profusegw operation 必须使用同一个固定 `ProfuseGwContext`。业务只能读取其只读 `user_id`；禁止用自建 context、Header/JSON Map 或通用依赖容器补位。
+
+生成的强类型 async 调用必须等待结果，并分别处理完成结果与技术失败：
+
+```rust
+match contract.query_bound_accounts(input).await {
+    ExternalFunctionResult::Completed(result) => handle_result(result),
+    ExternalFunctionResult::TechnicalFailure(failure) => match failure.code() {
+        // 穷举固定技术失败，不允许 wildcard/default。
+    },
+}
+```
+
+`Completed` 只表示函数形成确定的契约 result，不等于函数业务成功。`TechnicalFailure` 不携带业务 result，并带 `NOT_EXECUTED`、`EXECUTED` 或 `MAY_HAVE_EXECUTED` 执行确定性。
+
+在实现前先为以下八项各写一条显式业务决策；正式 Rust 枚举名必须从身份匹配的 API 读取，不得根据本表猜模块或类型：
+
+| 技术失败码 | 必须显式决定 |
+| --- | --- |
+| `FUNCTION_NOT_FOUND` | 停止、传播或映射到业务已定义结果 |
+| `FUNCTION_REQUEST_INVALID` | 停止、传播或映射到业务已定义结果 |
+| `CAPACITY_REJECTED` | 停止、传播或执行业务已定义且无自动重试的路径 |
+| `DEADLINE_EXCEEDED` | 停止、传播或执行业务已定义且无自动重试的路径 |
+| `DEPENDENCY_UNAVAILABLE` | 停止、传播或执行业务已定义且无自动重试的路径 |
+| `CONTRACT_RESULT_INVALID` | 停止或传播，不得伪造空结果 |
+| `INTERNAL_FAILURE` | 停止或传播，不得伪造业务结果 |
+| `TRANSPORT_FAILURE` | 按执行确定性停止或传播，不得自动重试 |
+
+每个分支还必须显式考虑正式 API 允许的执行确定性。不得使用 `_`、`default`、`UNKNOWN` 或 catch-all；新增技术码必须让旧消费者编译或 Gate 失败，而不是静默进入通用失败。
+
+正式枚举名是 `TechnicalFailureCode::{FunctionNotFound, FunctionRequestInvalid, CapacityRejected, DeadlineExceeded, DependencyUnavailable, ContractResultInvalid, InternalFailure, TransportFailure}` 与 `ExecutionCertainty::{NotExecuted, Executed, MayHaveExecuted}`。对二者做笛卡尔积 match，每个技术码在三种 certainty 下均须出现于具名 arm；可用 `|` 合并业务决策相同的 arm，但不能省略任一组合。

package/references/validation.md

@@ -0,0 +1,36 @@
+# Saddle 0.3.0-alpha.1 正式业务 Gate
+
+## 依赖与锁
+
+业务 crate 只通过 facade 使用 Saddle：
+
+```toml
+[package]
+name = "my-saddle-app"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+
+[dependencies]
+saddle-framework = "=0.3.0-alpha.1"
+```
+
+在允许访问正式 registry 的依赖准备阶段生成并提交 `Cargo.lock`。禁止 `path`、`git`、`[patch]`、source replacement 或宽松 Saddle 版本。
+
+## 唯一命令
+
+在业务 crate 根目录执行：
+
+```bash
+npx --no-install saddle-03-gate --manifest-path Cargo.toml
+```
+
+命令由已安装的 `@antprofuse/saddle-skill@0.3.0-alpha.1` 提供，不需要 Saddle 源码仓库。它会检查：
+
+- facade 精确版本、禁止直接中间件依赖和 Cargo source 旁路；
+- `Cargo.lock` 同版映射；
+- 固定 `ProfuseGwContext`、应用声明、八类技术失败与三种 certainty 均被显式引用；
+- 无 wildcard/default、第二 listener/Runtime、裸 gRPC/HTTP、动态函数或 raw invoke；
+- Rust 1.85 下 `cargo check --locked --offline`。
+
+Gate 使用临时 target 并在成功、失败和信号退出时清理。任何失败均为 STOP；不得加跳过参数或改 Gate 脚本。

package/scripts/saddle-03-gate.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const cp = require("child_process");
+
+function stop(rule, detail) {
+  process.stderr.write(`SADDLE_03_GATE ${rule} ${detail}\n`);
+  process.exitCode = 1;
+}
+
+const args = process.argv.slice(2);
+if (args.length !== 2 || args[0] !== "--manifest-path") {
+  process.stderr.write("usage: saddle-03-gate --manifest-path Cargo.toml\n");
+  process.exit(2);
+}
+const manifest = path.resolve(args[1]);
+if (!fs.existsSync(manifest)) {
+  stop("MANIFEST", `${manifest}: 文件不存在`);
+  process.exit(process.exitCode);
+}
+const root = path.dirname(manifest);
+const cargo = fs.readFileSync(manifest, "utf8");
+const lockPath = path.join(root, "Cargo.lock");
+
+if (/^\s*\[(patch|replace)\b/m.test(cargo) || /\b(path|git|branch|tag)\s*=/.test(cargo)) {
+  stop("DEPENDENCY_SOURCE", "禁止 path/git/patch/replace 依赖旁路");
+}
+const facade = cargo.match(/^\s*saddle-framework\s*=\s*(.+)$/m);
+if (!facade || !/^"=0\.3\.0-alpha\.1"\s*(?:#.*)?$/.test(facade[1].trim())) {
+  stop("SADDLE_VERSION", '必须直接且精确依赖 saddle-framework = "=0.3.0-alpha.1"');
+}
+const internals = ["saddle-core","saddle-admission","saddle-boundary","saddle-db","saddle-macros","saddle-observability","saddle-runtime","saddle-service"];
+for (const name of internals) {
+  if (new RegExp(`^\\s*${name}\\s*=`, "m").test(cargo)) stop("FACADE", `禁止直接依赖 ${name}`);
+}
+if (!fs.existsSync(lockPath)) {
+  stop("LOCK", "缺少 Cargo.lock");
+} else {
+  const lock = fs.readFileSync(lockPath, "utf8");
+  if (!/name = "saddle-framework"\nversion = "0\.3\.0-alpha\.1"/.test(lock)) {
+    stop("LOCK", "Cargo.lock 未绑定 saddle-framework 0.3.0-alpha.1");
+  }
+}
+
+const sourceRoot = path.join(root, "src");
+const files = [];
+function visit(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const ent of fs.readdirSync(dir, {withFileTypes: true})) {
+    const p = path.join(dir, ent.name);
+    if (ent.isDirectory()) visit(p); else if (ent.isFile() && p.endsWith(".rs")) files.push(p);
+  }
+}
+visit(sourceRoot);
+const source = files.map(p => fs.readFileSync(p, "utf8")).join("\n");
+if (!source.includes("application!")) stop("APPLICATION", "缺少 Saddle application! 声明");
+if (!source.includes("ProfuseGwContext")) stop("CONTEXT", "handler 必须使用固定 ProfuseGwContext");
+for (const code of ["FunctionNotFound","FunctionRequestInvalid","CapacityRejected","DeadlineExceeded","DependencyUnavailable","ContractResultInvalid","InternalFailure","TransportFailure"]) {
+  if (!source.includes(code)) stop("TECHNICAL_FAILURE", `缺少显式分支 ${code}`);
+}
+for (const certainty of ["NotExecuted","Executed","MayHaveExecuted"]) {
+  if (!source.includes(certainty)) stop("EXECUTION_CERTAINTY", `缺少显式分支 ${certainty}`);
+}
+const forbidden = [
+  ["WILDCARD", /_\s*=>/], ["LISTENER", /\b(TcpListener|axum|hyper|actix_web|warp)\b/],
+  ["RUNTIME", /\b(tokio::runtime|Runtime::new|spawn\s*\()/], ["RAW_RPC", /\b(tonic|Channel|ProfuseContractBoundary|raw_invoke|invoke_raw)\b/],
+  ["DYNAMIC_FUNCTION", /\b(dynamic_function|call_dynamic|DynamicExternalFunction)\b/], ["UNSAFE", /\bunsafe\b/]
+];
+for (const [rule, pattern] of forbidden) if (pattern.test(source)) stop(rule, "命中禁止业务旁路");
+
+if (process.exitCode) process.exit(process.exitCode);
+const target = fs.mkdtempSync(path.join(os.tmpdir(), "saddle-03-gate-"));
+try {
+  const env = {...process.env, CARGO_TARGET_DIR: target, CARGO_NET_OFFLINE: "true"};
+  const result = cp.spawnSync("cargo", ["+1.85.0", "check", "--manifest-path", manifest, "--locked", "--offline"], {env, stdio: "inherit"});
+  if (result.error || result.status !== 0) stop("COMPILER", "Rust 1.85 locked/offline 编译失败");
+} finally {
+  fs.rmSync(target, {recursive: true, force: true});
+}
+if (process.exitCode) process.exit(process.exitCode);
+process.stdout.write("SADDLE_03_GATE PASS; VERSION=0.3.0-alpha.1; LOCKED_OFFLINE; BUSINESS_BOUNDARIES=CLOSED\n");