diff --git a/.github/workflows/knowledge-proof-full-gate.yml b/.github/workflows/knowledge-proof-full-gate.yml
new file mode 100644
index 0000000..a027d89
--- /dev/null
+++ b/.github/workflows/knowledge-proof-full-gate.yml
@@ -0,0 +1,50 @@
+name: knowledge-proof-full-gate
+
+on:
+ pull_request:
+ paths:
+ - "src/knowledge/**"
+ - "src/sema/**"
+ - "src/prove/**"
+ - "tests/**"
+ - "doc/verification/skill-proof/**"
+ - ".github/workflows/knowledge-proof-full-gate.yml"
+ workflow_dispatch:
+
+concurrency:
+ group: knowledge-proof-full-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ complete-proof-regression:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - name: Install pinned Lean kernel
+ run: |
+ curl -sSf https://elan.lean-lang.org/elan-init.sh | sh -s -- -y --default-toolchain leanprover/lean4:v4.35.0
+ echo "$HOME/.elan/bin" >> "$GITHUB_PATH"
+ - name: Validate Lean kernel and embedded proof library
+ run: |
+ lean --version
+ bash scripts/check-proof-library.sh
+ lean doc/verification/skill-proof/MarqdoModularProof.lean
+ lean doc/verification/skill-proof/MarqdoEffects.lean
+ - name: Build and run all knowledge unit tests
+ run: |
+ cargo build --locked
+ cargo test --locked --lib knowledge::
+ cargo test --locked --lib sema::ir::tests
+ - name: Knowledge and execution compatibility suites
+ run: |
+ cargo test --locked --test knowledge_proof
+ cargo test --locked --test executable_knowledge
+ cargo test --locked --test prove
+ - name: Full genuine Lean proof matrix
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: |
+ cargo test --locked --test prove_lean
+ cargo test --locked --test prove_corpus
+ cargo test --locked --test conformance
diff --git a/.github/workflows/modular-proof-smoke.yml b/.github/workflows/modular-proof-smoke.yml
new file mode 100644
index 0000000..af49e59
--- /dev/null
+++ b/.github/workflows/modular-proof-smoke.yml
@@ -0,0 +1,70 @@
+name: modular-proof-smoke
+on:
+ pull_request:
+ paths:
+ - "src/knowledge/**"
+ - "src/sema/ir.rs"
+ - "src/prove/**"
+ - "tests/prove_lean.rs"
+ - "doc/verification/skill-proof/**"
+ - ".github/workflows/modular-proof-smoke.yml"
+ workflow_dispatch:
+concurrency:
+ group: modular-proof-smoke-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+jobs:
+ modular:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - name: Compile isolated modular proof candidates
+ run: cargo test --locked --lib knowledge::composition::tests -- --nocapture
+ - name: Compile parameter-projection proof backend
+ run: cargo test --locked --lib knowledge::projection -- --nocapture
+ - name: Compile pure-expression VC backend
+ run: cargo test --locked --lib knowledge::expression::tests -- --nocapture
+ - name: Unified contract engine and evidence lattice unit tests
+ run: |
+ cargo test --locked --lib knowledge::unified::tests -- --nocapture
+ cargo test --locked --lib knowledge::evidence::tests -- --nocapture
+ - name: Compile path-sensitive VCs
+ run: cargo test --locked --lib knowledge::symbolic::tests -- --nocapture
+ - name: Compile closed-argument VCs
+ run: cargo test --locked --lib knowledge::vc::tests -- --nocapture
+ - name: Install Lean 4.35
+ run: |
+ curl -sSf https://elan.lean-lang.org/elan-init.sh | sh -s -- -y --default-toolchain leanprover/lean4:v4.35.0
+ echo "$HOME/.elan/bin" >> "$GITHUB_PATH"
+ - name: Lean proof of exception, ABI and fuel-bound models
+ run: |
+ lean doc/verification/skill-proof/MarqdoModularProof.lean
+ lean doc/verification/skill-proof/MarqdoEffects.lean
+ - name: Independently composed Lean modules
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean composition_emits_independently_replayable_caller_certificate -- --nocapture
+ - name: Symbolic parameter projection with independent Lean replay
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean projection_composition_proves_symbolic_caller_and_replays_from_source -- --nocapture
+ - name: Independent arithmetic contract composition with real Lean
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean pure_expression_composition_proves_and_replays_real_lean -- --nocapture
+ - name: Three module DAG and branching caller with independent Lean replay
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean unified_modular_contract_proves_multicall_branch_and_transitive_dag -- --nocapture
+ - name: Regenerated provenance for original Lean certificates
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean g2_certificate_hit_after_real_run -- --nocapture
+ - name: Linear symbolic arithmetic path implication with real Lean
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean arithmetic_symbolic_path_implication_uses_real_lean -- --nocapture
+ - name: Symbolic path implication with real Lean
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: cargo test --locked --test prove_lean symbolic_path_implication_uses_real_lean_without_runtime_promotion -- --nocapture
diff --git a/.github/workflows/proof.yml b/.github/workflows/proof.yml
old mode 100755
new mode 100644
diff --git a/.github/workflows/release-v2.9.yml b/.github/workflows/release-v2.9.yml
new file mode 100644
index 0000000..07a4ed4
--- /dev/null
+++ b/.github/workflows/release-v2.9.yml
@@ -0,0 +1,91 @@
+# One-time, fail-closed promotion from verified main to immutable v2.9.0.
+# GITHUB_TOKEN-created tag pushes do not recursively start tag workflows.
+# Explicit workflow_dispatch is used to run the existing multi-platform
+# Release workflow against the immutable tag itself.
+name: Release v2.9.0 promotion
+on:
+ push:
+ branches: [main]
+ paths:
+ - "Cargo.toml"
+ - "doc/releases/v2.9.0.md"
+ - ".github/workflows/release-v2.9.yml"
+ pull_request:
+ paths:
+ - "Cargo.toml"
+ - "Cargo.lock"
+ - "crates/marqdo-wasm/Cargo.toml"
+ - "ext/VERSION"
+ - "doc/releases/v2.9.0.md"
+ - ".github/workflows/release-v2.9.yml"
+ workflow_dispatch:
+permissions:
+ contents: write
+ actions: write
+concurrency:
+ group: release-v2.9-promotion
+ cancel-in-progress: false
+jobs:
+ verify-and-dispatch:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ persist-credentials: true
+ - uses: dtolnay/rust-toolchain@stable
+ - name: Verify complete, matching release metadata
+ run: |
+ set -euo pipefail
+ python3 - <<'PY'
+ import re, pathlib
+ want = '2.9.0'
+ for file in ['Cargo.toml', 'crates/marqdo-wasm/Cargo.toml']:
+ data = pathlib.Path(file).read_text()
+ assert re.search(r'^version\s*=\s*"2\.9\.0"\s*$', data, re.M), file
+ lock = pathlib.Path('Cargo.lock').read_text()
+ for name in ['marqdo', 'marqdo-wasm']:
+ assert re.search(r'\[\[package\]\]\nname = "'+name+r'"\nversion = "2\.9\.0"', lock), name
+ assert pathlib.Path('ext/VERSION').read_text().strip() == want
+ assert pathlib.Path('doc/releases/v2.9.0.md').exists()
+ PY
+ git diff --exit-code
+ - name: Install pinned Lean checker
+ run: |
+ curl -sSf https://elan.lean-lang.org/elan-init.sh | sh -s -- -y --default-toolchain leanprover/lean4:v4.35.0
+ echo "$HOME/.elan/bin" >> "$GITHUB_PATH"
+ - name: Validate Lean and source-derived proof library
+ run: |
+ lean --version
+ bash scripts/check-proof-library.sh
+ lean doc/verification/skill-proof/MarqdoModularProof.lean
+ lean doc/verification/skill-proof/MarqdoEffects.lean
+ - name: Build and gate source semantics, actual Lean and compatibility
+ env:
+ MARQDO_PROOF_REQUIRE_LEAN: "1"
+ run: |
+ cargo build --locked
+ cargo test --locked --lib knowledge::
+ cargo test --locked --test knowledge_proof
+ cargo test --locked --test prove_lean
+ cargo test --locked --test prove_corpus
+ cargo test --locked --test conformance
+ cargo test --locked --test executable_knowledge
+ cargo test --locked --test release_handbook
+ - name: Create v2.9.0 only once and dispatch full platform release
+ if: github.repository == 'cflmy/marqdo' && github.ref == 'refs/heads/main' && github.event_name != 'pull_request'
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ set -euo pipefail
+ if git ls-remote --exit-code --tags origin refs/tags/v2.9.0 >/dev/null 2>&1; then
+ echo "v2.9.0 already exists; refusing to replace or re-dispatch assets"
+ exit 1
+ fi
+ test "$(git rev-parse HEAD)" = "$GITHUB_SHA"
+ git config user.name "github-actions[bot]"
+ git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+ git tag -a v2.9.0 "$GITHUB_SHA" -m "Marqdo v2.9.0 full: Verified Knowledge Compiler"
+ git push origin refs/tags/v2.9.0
+ gh workflow run release.yml --ref v2.9.0
+ echo "Dispatched Release workflow for immutable tag v2.9.0"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
old mode 100755
new mode 100644
index dfd0735..1ddd5ff
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -5,6 +5,7 @@ on:
push:
tags:
- "v*"
+ workflow_dispatch:
permissions:
contents: write
@@ -51,6 +52,7 @@ jobs:
New-Item -ItemType Directory -Force -Path dist | Out-Null
Push-Location vscode-extension
npm ci
+ npm version "$ver" --no-git-tag-version --allow-same-version
npm run compile
npx @vscode/vsce package --no-dependencies -o "../dist/marqdo-$ver.vsix"
Pop-Location
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2867e8..a7e5988 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,21 @@
## Unreleased
+## v2.9.0 — 2026-11-18 · Full release / 正式完整版本
+
+Marqdo Verified Knowledge Compiler: source-addressable knowledge proof artifacts, bounded Lean 4 modular contract composition, precise evidence grades, independent replay, and fail-closed unsupported semantics.
+
+- Unified source-derived pure-function proof DAG with symbolic parameters, sequential calls, total conditional branches, multi-module imports, and kernel-checked caller contracts.
+- Stable statement and theorem anchors, dependency closure signatures, proof indexes and source-change invalidation.
+- `proved`, `model_proved`, `tested`, `assumed`, `unknown`, `refuted`, `stale` are distinct; Lean Int-model proofs **do not** prove the complete Marqdo `number` or i64 runtime.
+- Independent Lean replay and negative regression tests for changed source, missing preconditions, unsupported effects, and false caller conclusions.
+- Full CLI/WASM/ext version synchronization, Windows/Linux native archives and editor release packaging (completion requires actual release workflow and asset verification).
+- Existing `marqdo prove` behavior, classic knowledge references, and `marqdo call` remain supported. Unsupported loops, recursive functions, dynamic dispatch, plugins and unverified runtime behaviors never become auto-proved.
+
+Marqdo 2.9.0(full)发布可寻址知识制品、统一纯函数模块化契约组合、真实 Lean 证书独立重放与证据等级;保留旧证明证书重放。仅支持明确的纯整数抽象子集,不宣称完整运行时正确性或所有函数自动可证。
+
+详情 / Details: [2.9.0 release notes](doc/releases/v2.9.0.md) · [Trust boundaries](doc/design/verified-knowledge-compiler-boundaries.md).
+
## Ext pack v2.8.1 — 2026-11-18
### Highlights
diff --git a/Cargo.lock b/Cargo.lock
old mode 100755
new mode 100644
index 62a9995..297f151
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -615,7 +615,7 @@ checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
[[package]]
name = "marqdo"
-version = "2.8.0"
+version = "2.9.0"
dependencies = [
"anyhow",
"assert_cmd",
@@ -656,7 +656,7 @@ dependencies = [
[[package]]
name = "marqdo-wasm"
-version = "2.8.0"
+version = "2.9.0"
dependencies = [
"marqdo",
"serde_json",
diff --git a/Cargo.toml b/Cargo.toml
old mode 100755
new mode 100644
index ebb81c3..ac4661b
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "marqdo"
-version = "2.8.0"
+version = "2.9.0"
edition = "2021"
license = "Apache-2.0"
description = "Marqdo — Markdown markers as an interpreted programming language"
diff --git a/README.md b/README.md
old mode 100755
new mode 100644
index 5f92763..d1dfbd8
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
让 SKILL 真正成为工具:文档即知识,知识即可执行。
-
+
@@ -21,9 +21,13 @@
View ·
Guide ·
Website ·
-Release notes
+Release notes
+## Marqdo 2.9.0 — Verified Knowledge Compiler
+
+Knowledge statements and claims have stable addresses; verified pure contracts compose across static modules and produce independently replayable Lean certificates. Evidence distinguishes abstract `model_proved` from true runtime `proved`. Unsupported runtime effects and semantics are explicitly unverified. [Proof scope and acceptance](doc/design/verified-knowledge-compiler-boundaries.md) · [Release notes](doc/releases/v2.9.0.md).
+
## One Markdown file. Three views. Real execution.
[](assets/marketing/marqdo-2.7.1-markdown-to-execution.mp4)
@@ -47,7 +51,7 @@
## Quickstart — one function, one command
-Install the [2.7.1 CLI release for Windows or Linux](https://github.com/cflmy/marqdo/releases/tag/v2.7.1), then run from this repository's root:
+Install the [latest 2.9.0 CLI release for Windows or Linux](https://github.com/cflmy/marqdo/releases/tag/v2.9.0), then run from this repository's root:
```bash
marqdo call examples/calculator.mq.md 计算器.加法 a=2 b=3
diff --git a/crates/marqdo-wasm/Cargo.toml b/crates/marqdo-wasm/Cargo.toml
old mode 100755
new mode 100644
index 76ccc34..f41ca24
--- a/crates/marqdo-wasm/Cargo.toml
+++ b/crates/marqdo-wasm/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "marqdo-wasm"
-version = "2.8.0"
+version = "2.9.0"
edition = "2021"
license = "Apache-2.0"
description = "Marqdo interpreter as WebAssembly (browser host bridge)"
diff --git a/doc/design/knowledge-proof-2.9.md b/doc/design/knowledge-proof-2.9.md
new file mode 100644
index 0000000..13943c5
--- /dev/null
+++ b/doc/design/knowledge-proof-2.9.md
@@ -0,0 +1,260 @@
+# Marqdo 知识锚点与证明制品(2.8 → 2.9)
+
+> 实现状态:PR #2 第一阶段。保持解释器和原有 `[]()` 求值语义不变,复用 2.8.0 `prove` 与既有 SemanticProject。以下明确区分**已经写入分支的功能**和**尚未完成的跨模块证明**。
+
+## 核心语义
+
+- AST 内部步骤仍有原来的 `#step-N` 序号,供旧查询、调试与执行日志使用。
+- 在**同一个函数内名称唯一**的标记步骤,获得独立的 `anchor_id = SymbolId#anchor-sha256(normalized_label)`;在前面插入其他步骤不会改变地址。
+- 同函数重复的标记名称**不产生公共锚点**;必须重命名,不得静默采用首个。
+- `definition_digest` 来自该语句源码位置的内容,与稳定身份分开;语句内容更改时身份保留、定义指纹改变。
+- 两种文档引用不执行目标:同函数的 `[阅读依据](#@演算)` 和跨模块绝对地址 `[阅读依据](mq://...#anchor-)`。后者应从编译生成的 anchors.json 拿完整 ID,不应凭空手写。
+- 2.8.0 定理表每条唯一声明生成稳定 `ClaimId = SymbolId#claim-sha256(定理名称)`;正文 `[阅读定理](#@定理名称)` 可以定位**声明**,但不会读取或伪造证明状态;同一名称同时匹配知识步骤和定理声明时标记 `ambiguous_anchor`,不猜测。\n- 普通 `[说明](https://...)` 仍为导航,原来表达式位置的 `[描述](payload)` 仍依照原 Marqdo 执行规则求值。
+- **链接不意味着执行权**:解析到知识锚点只生成引用边,不自动调用函数、加载插件或赋予权限。
+
+## 制品
+
+`marqdo knowledge` 所用的 SemanticProject 原子生成目录下新增:
+
+| 路径 | 内容 |
+|---|---|
+| `steps.json` / `refs.json` | 增量字段 `anchor_id`、`definition_digest`、`link_target`、`target_anchor` |
+| `claims.json` | 定理声明索引,初始状态固定为 `declared_unverified`,不等同于证明通过 |\n| `anchors.json` | 稳定公共步骤索引,附所有者、标记文本、源码、效应、定义指纹 |
+| `graph/edges.json` | `defines_anchor`、`references_anchor`、知识步骤到已解析调用目标的 `calls` |
+| `proof-index.json` | 可用或过期的证明收据索引;它不是可执行授权,也不自动证明步骤 |
+
+`marqdo prove` 在原本的证明目录附带 `knowledge-links.json`:
+每个定理通过文件 + 函数全名唯一绑定到 `SymbolId`,稳定 `claim_anchor_id` 附带前提、结论、来源、函数的 interface/implementation/closure digest 与可用时的 Lean 证书摘要。
+无法安全绑定时输出 `unresolved`,不匹配别的同名函数。
+`related_anchor_ids` 仅是 **defined_in_same_function_not_individually_proved** 导航关系,绝不意味着 Lean 已分别证明这些内部锚点的性质。
+
+## 证据有效性
+
+1. 离线 `checked` 不能当作 `proved`。
+2. 只有 `ClaimReport` 显示真实 Lean 判定,且匹配当前报告的原始 `certificate.json`、命题、文件、Lean 工具链与证明库,才可输出 `proved` 关联。
+3. 在知识编译时复核文件源码 SHA、函数接口、实现指纹、传递依赖 closure 指纹及证书字节摘要;失败 => `stale` / `unverified`,`usable=false`。
+4. 同一个声明出现多份可见报告时 => `ambiguous`,不能随意取旧证书或新证书。
+5. 当前证明文件是**本地缓存收据**,不是经过签名的远程授权凭证。对抗性环境必须在可信 CI 中再次用 Lean 验证,不能仅相信 JSON 内的 `status`。
+
+## 下一阶段:跨模块 assume–guarantee
+
+这是比单纯增加更多 Lean tactic 更重要的方向,但 **本 PR 第一阶段尚未实现**:
+
+- 将函数可复用契约分成 `requires / ensures / effects`,全部有已解析 SymbolId 作为身份;
+- 在调用方生成 “调用前提满足” 的证明义务,并以被调者的已验证后置条件作为假设,**明确记录假设链**;
+- 若被调者实现改变、但同一契约被重新证明支持,允许复用不受影响的调用方证明;
+- 若契约失效、闭包改变或假设不能满足,所有受影响证明回退 `stale`,不能保持 `proved`;
+- 对外部 ABI 插件调用,必须给出明确 effect 契约、来源和可信主体,不能把不透明调用宣告为纯函数;
+- 保留 Lean 与解释器对 i64 溢出、除零/模零行为的差异护栏,在证明模型不等价时不给出无限定的成功保证。
+
+## 验收指标
+
+1. 在任意步骤前插入不相关语句,公共锚点地址不漂移;旧内部编号可以变化。
+2. 只修改锚点表达式,定义 digest 必须变化,锚点地址保持;同名重复拒绝公开。
+3. `#@标签` 与完整 `mq://...` 必须精确解析;不存在锚点报告 unresolved,且不能变成 BoundCall。
+4. `prove` 的函数证明只能关联函数知识,不能将所有带标记步骤标成 proved。
+5. 更改源码、契约、传递依赖或证书后,知识索引拒绝使用过期证明。
+6. 与 2.8.0 原有 CLI / SemanticProject / Lean 测试保持兼容。
+
+
+
+## M4:模块化证明内核与当前信任边界
+
+本工作在 `src/knowledge/modular.rs` 增加证明义务图,输出于
+`proof-obligations.json`;可通过命令:
+
+```sh
+marqdo knowledge proof-deps --json --strict .
+```
+
+`--strict` 在缺少来源校验、证明收据或契约时非零退出。这个
+`audit_passes` **不是**一个 Lean 证明的调用方定理,也不能发布
+`proved`。它只说明当前本地可见的证明收据与契约引用是否完整。
+
+T3 声明采用既有 GFM 表格(不增加解释器语法):
+
+| 假设 | 前置 | 后置 |
+|---|---|---|
+| rates.lookup | 金额 > 0 | 返回 = 2 |
+
+函数开头的此表现在被 parser 提取进 `Function.assumptions`,映射到
+`FnPlan.assumptions`,由 `SemanticProject` 生成 `assumptions.json`;
+不参与运行时执行、也不赋予事实可信度。重复、未找到、前置条件待验证
+均应 fail closed。
+
+`doc/verification/skill-proof/MarqdoModularProof.lean` 定义参数化的
+`Contract`、`Implements` 和 `compose_sound`:
+
+- 被调函数真正满足其前后置条件;
+- 调用方/前一个函数真正满足其前后置条件;
+- 显式桥接引理证明前一个函数的后置条件足以满足后一个函数的前置条件;
+
+Lean 才能得出组合契约成立。文件含一个缺少桥接前提时组合错误的反例,
+以防未来实现将“被调者 proved”直接等价于“调用者 proved”。
+
+### 尚未完成的关键项(不得标记 done)
+
+1. **参数绑定**:从真实 Marqdo `BoundCall` 的表达式实参生成
+ 调用点前置条件的 Lean 目标。不能直接复用未绑定实参的 `前置` 文本。
+2. **模块化执行语义**:在 Lean 中准确表示 import / 调用 / 返回 / 效应,
+ 并与原解释器的数值和异常行为建立等价性。
+3. **证明组合与导出**:仅在被调证明证书经过受信核验、桥接义务
+ 由 Lean 消除且调用方自己的 Lean 定理成立时,输出新的模块化证明证书。
+4. **可靠的跨实现复用**:不能因为后置条件文字未改变就绕过重新核验;
+ 必须要有新实现支持同一契约的证明,且证明/模块 ABI 版本匹配。
+5. **安全与正确性测试**:成功与失败调用、条件前置、不透明调用、效应、
+ 多版本证书、循环依赖、证书篡改、解释器/Lean 差分一致性与崩溃恢复。
+
+所以目前 **已经实现的是可寻址知识编译、证明绑定和保守的模块依赖审计**;
+**没有实现完整跨模块自动推理并生成 `proved` 的系统**,不应声称后者已完成。
+
+
+## M5:跨模块纯叶函数的受限源码透明证明
+
+`src/prove/lower.rs` 新增第一条**真实跨文件执行语义**通路。
+`Target::Import` 仅对以下情形将导入函数源码透明降级入调用方 Proof IR:
+
+- 被调函数体只有一个 `Return`;表达式由字面量、形参、无副作用一元/二元表达式和遮蔽表达式构成,不得依赖全局状态或其他函数;
+- 调用实参全部显式传入、位置匹配且与参数数目一致,不能通过默认参数或任意命名重排来隐式猜测绑定;
+- 展开深度有严格上界;不支持分支、循环、递归、动态分派、ABI 效应或未知调用;
+- 当导入表达式包含算术操作时,必须通过实际实参的静态整数求值确保 `i64` 不溢出、不除零。包含变量或非整数的未知算术保持不透明,绝不因 Lean 的无界 `Int` 语义而自动升级。
+
+这条通路设计的真实 Lean 正例分别是无参数的跨文件纯返回,以及带实际参数绑定的加一计算;`tests/knowledge_proof.rs` 包含导入文件产生副作用和 `i64` 溢出的反例。
+
+**该特性是源码透明的跨模块证明(有限展开),不是抽象契约复用。**
+只有独立证明调用点前置条件、将已证被调契约接入调用方而无需展开实现,并由 Lean 校验接口桥接,才算真正完成通用 assume–guarantee 模块化证明。
+
+
+## M6:真实 Lean 的封闭调用前置条件(2026-11-18)
+
+模块化校验现在有两种不同的操作:
+
+```sh
+# 纯分析:不会冒充 Lean 已检查
+marqdo knowledge proof-deps --json .
+
+# 要求真实 Lean:先重放被调函数证明,再检查可闭合的调用点前提
+marqdo knowledge proof-deps --verify --json .
+
+# 审计严格退出码;不是“整个程序的模块化定理已被证明”
+marqdo knowledge proof-deps --verify --strict --json .
+```
+
+工作过程:
+
+1. `BoundCall` 保留精确的 caller/target 知识身份,以及**按解释器执行约定归一化后的实参**(名称、顺序、保守静态整数值、源表达式摘要)。
+2. `knowledge/vc.rs` 用被调方函数签名,将受限前提(整数比较/加减乘/布尔连接)绑定到**真实实参**。拒绝除法、溢出、动态变量、不匹配的命名/顺序参数及无法解释的谓词。
+3. 先校验原 `certificate.json` 的复合缓存键、`plan.json`、嵌入证明库哈希、生成 Lean 文件 SHA、源码和语义闭包。
+4. `--verify` 额外使用现有 Lean 工具链**重新检查被调方生成的 Lean 定理**。仅当重放后的确具有精确匹配的 proved 定理时,才承认该条 callee 收据。
+5. 从验证过的收据与闭合前提生成 `closed-goals.lean`,对每个目标使用 `theorem vc_i : ... := by decide`;调用 Lean 4 核验。Rust 计算的布尔结果只能用于提前拒绝,不能独立充当证据。
+6. `proof-obligations.json` 与实时 JSON 审计报告分别记录 `precondition_pending` / `precondition_refuted` / `lean_kernel_verified` 等状态。无工具链、超时、证书篡改、Lean 不接受、源变更全部拒绝进入成功状态。
+
+两个严格区分的边界:
+
+- `lean_kernel_verified` 表示**当前闭合调用点的条件命题已被核验**,而非调用方的完整结论定理。
+- `proof_completion` 仍为 `not_established_by_dependency_analysis`。目前缺少通用符号实参、分支路径条件、任意效应 ABI 的正式组合证明与可重放的跨模块结论证明证书。**不得将依赖图审计通过升级为完整模块化 proved。**
+
+新增 `tests/prove_lean.rs` 场景验证被调定理与调用前置条件**双重重放**,且实参不满足前置条件时必然退出非零;新增单元测试覆盖实际工程导入、整数溢出和未绑定实参。此处描述的是提交的实现及其预期测试,最终验收仍以最新提交 CI 结果为准。
+
+
+## M7:路径敏感符号证明和独立组合证书(限定子集)
+
+### 路径条件
+
+`SemanticProject.BoundCall` 保存调用身份、归一化实参、直接变量、
+进入该调用点的分支条件(包括 else 否定条件)以及无法证明时的
+`control_blocker`。副作用条件、循环、迭代和未知运算不作为已证前提。
+
+`src/knowledge/symbolic.rs` 对纯整数比较和布尔条件产生带
+`(v0 : Int)` 等量词绑定与路径假设的 Lean 定理;调用 Lean 核验后仅为
+`symbolic_path_lean_model_proved`,不等于运行时契约通过。数学 Int 与
+Marqdo 动态值、有界 i64 语义对应仍需独立证明。
+
+### 独立 Lean 组合证明(首个真正闭环)
+
+```sh
+marqdo knowledge compose --json --strict .
+marqdo knowledge replay .marqdo/modular/composed/{proof-id}/composition-certificate.json --json .
+```
+
+`compose` 仅接受:不同文件间的唯一静态调用;纯整数函数;
+调用方直接返回或一次局部赋值再返回被调结果;被调方只有一条整数常量返回;
+参数均有明确 int 契约、无默认参数;实参仅为调用方参数或安全整数常量;
+双方具有相同的无条件结果定理;无分支、循环、递归、异常、ABI 效应。
+
+分别生成 `CalleeModule.lean` 和 `CallerModule.lean`:
+
+- 被调方源码生成定义,其契约由 Lean 证明。
+- 调用方 `import CalleeModule`,只使用被调方证明的契约,不展开其函数体。
+- 两模块独立生成 .olean 并通过真实 Lean 4 核验。
+- `composition-certificate.json` 绑定符号、源码闭包、Lean 版本、Lean 源文件
+ 和编译模块哈希,证明作用域限定为
+ `typed_int_pure_forwarder_constant_postcondition`。
+- `replay` 必须从**当前项目**重新编译出相同的 Lean 源,匹配依赖闭包,
+ 然后独立重新执行两个 Lean 模块并校验产物哈希;源码/证书有变即失效。
+
+此证书状态是 `lean_kernel_proved_model`,**不是** Marqdo 运行时全部语义已证。
+
+### 异常、循环、递归与 ABI 的保守边界
+
+`MarqdoModularProof.lean` 用 `Exit.ok / Exit.error / Exit.diverged`
+显式区分成功、异常、不终止;`total_sequence_sound` 证明包含异常和
+发散结果的总正确性契约只有在前置条件桥接被证明后才能组合。
+异常结果和发散结果不能等同于正常返回。
+
+这是经过 Lean 检查的**抽象组合规则**,并非已证明所有插件、循环与递归
+实现满足这一模型。遇到 ABI 不透明效应、无法验证的异常处理、缺失循环
+不变式/终止性或递归下降变元时,编译器保守拒绝组合。
+
+### 未达到完整通用系统的部分
+
+动态类型语义保持、复杂算术的安全条件、任意路径的 WP、
+循环不变式与终止性、递归归纳证明、插件状态转换可信契约、
+并发效应,以及一般性参数化后置条件的源码无关组合,目前仍不完整。
+不能将已完成的限定子集扩大宣传为完整的通用模块化证明系统。
+
+### 2026-11-18 类型安全修正
+
+目前类型表源文本中的 `int` 被契约解析器归一化为 `number`,它也允许 Num 和 Formula。因此**不能**把 `number` 的证明自动解释为任意 Marqdo 运行时输入均为 i64。组合证书作用域改为 `number_contract_int_model_pure_forwarder_constant_result`,且根报告固定标注 `full_marqdo_runtime_semantics_proved: false`。这仅证明整数抽象模型上的独立模块组合。完整运行时证明必须新增可执行类型收窄及类型保持定理。
+
+另新增 `MarqdoEffects.lean`:把状态、插件异常、未决结果和耗尽 fuel 的循环统一建模,证明异常与未决结果不能充当成功返回;该抽象 ABI 契约仍须具体插件的实现见证,不能由表格声明自动授予。
+
+
+## M8:组合证书闭包与调用身份加固(2026-11-18)
+
+`knowledge replay` 现在要求证明证书的 identity 在当前语义工程中**恰好对应一个**可组合的 BoundCall;禁止采用 `find first` 策略选择多个候选中的第一个。调用方与被调用方的 closure 收据必须与重编译得到的**两个精确身份与哈希**集合完全一致:重复、额外注入、缺失、替换记录均拒绝重放。
+
+`composition.rs` 新增单元回归测试 `certificate_closures_must_be_exact_and_unique`。这仅加固证书来源绑定,不扩大已证明的运行时语义范围。CI 需以分支最新 head 为准;不同提交上曾经成功的检查不等于本提交已验证。
+
+
+## M9:合约声明歧义与同模块伪组合防护
+
+组合候选现在要求被调函数和调用方各自恰好拥有 **一条** 符合目标常量结果的无条件定理声明。此前使用 `any` 的逻辑可能让两个不同名称、同一结论的声明被当成唯一证据;现在这种情况按歧义处理并拒绝出证。测试在真实的 `.mq.md` 表格中构造两个同结论声明。
+
+此外,当前受限组合证明只面向不同源文件的静态导入调用,显式拒绝同文件以及自调用,避免将本地调用伪装成可复用跨模块契约证书。此项是准入安全性改进,不表示抽象插件、分支、循环和递归已经实现具体语义证明。
+
+验证仍须以最终提交的 GitHub Actions 为准,尤其关注 `modular-proof-smoke`、`proof` 和 `knowledge-proof-integration`。工作流无作业失败不应解释为单元测试失败或测试成功,必须另行定位 YAML / GitHub Actions 工作流事件层面问题。
+
+
+## M10:带符号实参的独立模块组合证书(受限整数投影)
+
+`src/knowledge/projection.rs` 现实现一条**源码驱动、Lean 内核证明、证书可重放**的参数化调用路径:
+
+- 被调函数在单一返回语句中返回唯一的形参,且该函数必须是无副作用的静态目标;
+- 调用方仅直接返回被调调用结果,或将该调用赋给局部变量后立刻返回;
+- 支持多个形参及重排后的实参,实参只能是调用方形参或已通过安全静态求值的 i64 常量;
+- 被调方声明唯一无条件契约 `结果 = 被投影形参`,调用方声明唯一无条件契约 `结果 = 对应实际形参或常量`;
+- 正式构建 `CalleeModule.lean`,以真实返回源生成 `callee_contract`;`CallerModule.lean` 导入前者,经实际实参实例化、以 `simpa [caller]` 得出调用方定理,**不在调用方展开被调实现**;
+- `composition-certificate.json` 与源码的唯一符号、精确双依赖闭包、工具链版本、Lean 源和编译产物摘要绑定;重放时从当前 `.mq.md` 重新生成两份 Lean 源并重新执行 Lean;
+- 重复函数名、重复语义实体、重名合同结论、未知或不匹配实参、路径条件、控制阻碍、效应函数、同文件调用、动态调度、源码漂移全部拒绝出证或重放。
+
+使用既有接口:
+
+```sh
+marqdo knowledge compose --strict --json .
+marqdo knowledge replay .marqdo/modular/composed/projection-*/composition-certificate.json --json .
+```
+
+新增真实 Lean 测试 `projection_composition_proves_symbolic_caller_and_replays_from_source`,以及参数重排/错误结论/重复声明单元测试。专项 CI `modular-proof-smoke` 运行这条路径。
+
+**严守边界**:这里的后置条件组合是抽象 Lean `Int` 模型中的`返回等于某个形参`关系,而不是任意谓词、循环不变式、递归归纳或有状态插件契约。Marqdo 的 `int` 声明会归一化到可容纳非整数值的 `number`,故证书显式只给出 `lean_kernel_proved_model`,不能声称动态运行时完全对应。用户定义的插件效应、异常、循环和递归仅有抽象逻辑,不得提升为源码级已证明执行。实现仍处于实验性 Draft,未达到完整通用模块化证明标准。
diff --git a/doc/design/verified-knowledge-compiler-boundaries.md b/doc/design/verified-knowledge-compiler-boundaries.md
new file mode 100644
index 0000000..4bb6187
--- /dev/null
+++ b/doc/design/verified-knowledge-compiler-boundaries.md
@@ -0,0 +1,179 @@
+# Marqdo 可验证知识编译器:目标、可信边界与阶段性验收
+
+> 状态:设计决策 + 当前实现对应。形成于 2026-11-18 关于知识编译、Lean 自动证明边界、AI 智能体知识沉淀与模块化组合的讨论。
+>
+> 本文规定目标边界,不以“任意 Marqdo 程序都能被 Lean 证明”为目标。具体实现应以当前源代码、真实 Lean 证书与 CI 结果为准;不能通过修改文档把尚未验证的语义宣布为已证明。
+
+## 1. 问题与共同认识
+
+Marqdo 的核心目标不是取代 Lean,也不是成为全自动程序验证器:
+
+> 代码即文档,文档即知识库,知识即可执行。
+
+更严格的工程定位:
+
+> 将人类可读文档编译为**可寻址、可验证、可执行、可复用的知识制品**的语言与编译系统。
+
+其中,“可验证”不是“所有性质都能被形式化证明”;“知识即可执行”也不是“所有外部世界事实都有数学定理”。
+
+形式证明必然面临不可判定性、求解器资源上限、环境非确定性、外部依赖以及不完整的语义模型。即使 Lean 内核确认一个命题正确,它确认的也是**给定 Lean 定义及假设下的命题**。如果 Marqdo 源码到 Lean 定义的映射未建立可信性,该证明不能无条件提升为 Marqdo 运行时正确性。
+
+因此,整个设计遵守四条约束:
+
+1. **证明精确标注作用域**:明确对象、输入域、效应、数值模型及前提;不要将模型证明冒充完整运行时证明。
+2. **可证明则证明**:在受支持且能建立可信模型的子集内,由真实 Lean 内核验证;失败不得降级成虚假的 proved。
+3. **不能证明仍可成为知识**:保留测试、执行轨迹、实验数据、来源与未经验证的假设;这些证据不等价于逻辑证明。
+4. **不会静默取得执行权**:锚点引用、知识收据、定理声明或插件假设都不自动执行工具、授权访问环境或改变运行时行为。
+
+## 2. 三层可信性,不由一个 Lean 布尔值代替
+
+### L1:结构与来源验证——基础必需
+
+对象包括 Markdown/Marqdo AST、唯一锚点、符号和模块解析、精确调用绑定、源码与契约指纹、引用有效性、依赖闭包、过期证据识别。
+
+主要由解析器、SemanticProject、知识图谱、哈希与回放机制验证,无须假装数学证明。
+
+### L2:形式证明——限定作用域
+
+对象包括函数前/后置条件、调用前提、符号路径、算术结论、可组合的跨模块性质。
+
+Lean 执行核验;Rust 只能生成目标、提前拒绝以及绑定真实源码,不能凭主机端的计算结果自行宣称定理成立。
+
+### L3:执行和经验验证——不可省略
+
+对象包括插件和 API 调用、量子硬件实验、非确定性智能体决策、实际数据质量与第三方网络服务。
+
+应携带可复现测试、日志、测量、环境版本和来源,不应自动转化为 Lean proof。
+
+量子科研例子:门矩阵幺正性可以有形式证明,具体设备的实验保真度必须由观测数据和校准记录支持;两种证据可组合引用,但不能互相冒充。
+
+## 3. 证据等级(Proof is not a Boolean)
+
+知识制品采用与旧版 \`status\` **正交**的 \`evidence.grade\`。已在 \`src/knowledge/evidence.rs\` 建立类型化模型:
+
+| 证据等级 | 含义 | 禁止的推断 |
+|---|---|---|
+| \`proved\` | 目标语言、输入域及其运行时语义对应已得到可信证明 | 不覆盖未纳入证明的插件、浮点或硬件 |
+| \`model_proved\` | Lean 核验了明示抽象模型下的命题 | 不得称为全部 Marqdo 运行时正确 |
+| \`tested\` | 存在真实、可追溯的测试/实验结果 | 通过测试不等于数学证明 |
+| \`assumed\` | 明示的外部假设、作者/插件契约 | 不得自动变成 proved |
+| \`unknown\` | 未建立证据、超时、求解失败或超出可证子集 | 不等价于“命题错误” |
+| \`refuted\` | 已提供可信反例 | 单纯 Lean proof 失败不能判为 refuted |
+| \`stale\` | 当前源码、依赖或证明环境改变导致证据失效 | 不得复用旧证书 |
+
+**关键规则**:
+
+- \`proved\` 必须同时要求具体语义对应与内核证明,不能通过修改 JSON 证据字段获得。
+- 目前整数算术的 Lean \`Int\` 定理通常属于 \`model_proved\`。Marqdo 的 \`number\` 契约可能包含 \`Num\`、\`Formula\` 等,且 i64 溢出、动态类型转换与异常行为尚未普遍与 \`Int\` 对齐。
+- \`tested\`、\`assumed\`、\`refuted\` 的证据需要**相应来源**;不能因为某个测试通过、表格声明或求解失败就随意升级。
+- 证据等级用于解释保证性质;\`usable\`、\`kernel_replayed\` 和 \`current_source_verified\` 是独立的可用性/核验状态,不能混淆。
+- 知识检索、智能体与工具链看到 \`unknown\` 或 \`assumed\` 时,可以请求额外验证、执行测试、询问外部系统或拒绝高风险动作,但不能修改证明结论。
+
+## 4. 统一契约组合:通用的是机制,不是自动化证明能力
+
+函数契约规范化为 \`requires / ensures / effects / evidence\`,每个契约绑定明确的 \`SymbolId\`、源码来源和依赖身份。
+
+一般调用 \(g(x)=f(a(x))\) 的组合义务:
+
+1. **被调函数确实满足自己的已声明契约**:有可信的源码与证据绑定。
+2. **调用点满足前提**:从调用方条件和实参绑定证明 \`requires_f(a(x))\`;不得把任意声明当成假设。
+3. **组合后调用方结论成立**:使用被调函数的已证保证、调用方实际执行流和路径条件,向 Lean 提交调用方定理。
+4. **失效传播**:源码、签名、接口、契约或依赖证明改变,旧证书不可继续使用,除非新的实现已经重新满足相应保证。
+
+\`src/knowledge/unified.rs\` 是统一入口,逐个从当前 Marqdo AST 降级受支持的纯函数,按静态导入 DAG **自底向上**生成独立 Lean 模块。每个模块定义源派生函数并证明该函数自己的契约;调用方导入已经编译的下游模块,以其契约定理为假设链的可验证依据,既不添加 \`axiom\`,也不内联下游源码。生成的每个模块均单独通过 Lean 内核,证书绑定:
+
+- 精确的源语义身份与传递依赖闭包;
+- 受支持的源码表达式及控制结构;
+- 模块生成次序、导入关系、源码摘要和已编译 Lean 摘要;
+- 工具链版本及受限证明作用域。
+
+\`marqdo knowledge replay\` 必须重读当前源文件,重新生成这些模块与依赖,再独立编译并逐项比较,不能仅仅读取带有 \`proved\` 标记的本地 JSON。
+
+旧有常量、参数投影、表达式后端的证书仍可重放;新证明优先走统一管线,避免把多个实现拼成互相矛盾的证明状态。
+
+### 当前统一后端的精确定义
+
+当前实现接受:
+
+- 静态、无副作用、跨文件的纯函数调用与有限、无环调用图;
+- 参数完整、必要且无默认值;源代码参数、签名和调用点均匹配;
+- 整数字面量、形参/局部变量、加减、一元负号,以及在支持的片段内由常数参与的乘法;
+- 顺序局部赋值、直接返回、具有显式 \`else\` 且每条分支都返回结果的普通条件分支;
+- 每个函数一个可识别、无条件、以 \`结果\` 为左侧的受限数值比较契约(等于或简单大小比较);
+- 多次静态调用与递归依赖**图上的多层模块**,由证明模块的拓扑顺序组合。
+
+当前实现**不接受**:
+
+- 循环、递归、非终止、并发、隐式/动态分派、插件副作用、没有可信模型的异常;
+- 任意表达式值、除法/浮点/公式数值、未核验的运行时整数范围、缺省或非位置实参;
+- 需要证明前置条件却没有调用方路径桥接证据的**条件契约**(可先由 \`proof-deps --verify\` 生成/检验独立义务;不能直接用无条件契约代替);
+- 非穷尽分支、分支后复杂状态合并、无法静态绑定的调用、未覆盖的语句类型;
+- 任何企图把 \`model_proved\` 直接提升为全语言 \`proved\` 的操作。
+
+这个子集提供真正的**组合机制**,不宣称任意 WP 自动求解、全部 Marqdo 运行时对应、完整 Hoare Logic 或未限制的程序正确性。
+
+## 5. 还需要开发哪些内容、哪些明确不需要
+
+### 当前阶段必需(完成后可停止无界扩张)
+
+1. 所有源文件上的可寻址索引、定理证据与版本来源绑定有效。
+2. 一个可用的静态契约组合通路,而非恒定返回、形参返回、算术返回三套互不兼容的证明规则。
+3. 在明示纯函数子集中支持符号实参、顺序组合、基本条件分支、多层静态模块组合。
+4. 真 Lean 证书独立重放与完整负例护栏(假结论、来源变化、未解义务、插件、溢出风险)。
+5. 可查询的 \`evidence.grade\`,让智能体区分证明、模型证明、测试、外部假设、未知与过期。
+6. 编译、知识索引、原有运行命令和解释器不发生回归。
+
+### 扩展按需求逐步添加
+
+- 对实际量子算法或标准库有价值的归纳、循环不变式、递归终止、特殊数据类型、插件实现见证;
+- 更大范围的契约谓词、复杂路径 WP、数值类型收窄和溢出条件;
+- 与真实外部测量、实验数据和 agent 轨迹对接的可复现证据。
+
+### 当前明确不作为完成门槛
+
+- Lean 对所有 Marqdo 代码自动证明;
+- 为每个外部 API、未知插件、远程服务或量子硬件建立形式语义;
+- 完整并发语义、全部递归及任意循环的自动终止证明;
+- 把不可判定问题或自动证明超时当成系统故障;
+- 把抽象模型的可证明性与真实环境事实的真实性混为一谈。
+
+**阶段完成**指有明确的支持清单、严格的拒绝行为、自动 CI 与不夸大的证据等级,而不是新增语言特性就继续追逐无限泛化。
+
+## 6. 智能体视角:知识制品应怎样使用
+
+对 agent 的安全接口不应只返回 \`true/false\`,而应返回:
+
+- 地址:\`SymbolId\` / 锚点;
+- 执行接口:签名、前置条件、效应权限;
+- 逻辑保证:受支持契约及其 \`proof_scope\`;
+- 证据:\`grade\`、来源、版本、独立重放状态;
+- 未解决义务:待证谓词、未建模效应、需要测试/实验的事实;
+- 依赖闭包与失效原因。
+
+智能体可以优先选择 \`model_proved\` 且输入满足限制的算法片段;在真实科研设备/外部系统调用上,同时查询 \`tested\` 证据与 \`assumed\` 的安全边界。过期制品不得直接复用。
+
+这体现 Marqdo 的原创价值:**文档直接成为知识身份、工具接口、形式契约和执行证据的共同承载体**,而不是简单把 Markdown 文字翻译成另一种程序语言。
+
+## 7. 验收清单与真实 CI
+
+核心命令:
+
+\`\`\`bash
+marqdo knowledge compose --strict --json .
+marqdo knowledge replay --json .
+marqdo knowledge proof-deps --verify --json .
+\`\`\`
+
+\`.github/workflows/modular-proof-smoke.yml\` 用真实 Lean 核验统一契约的模块组合和独立重放;\`.github/workflows/knowledge-proof-full-gate.yml\` 跑旧版证明、知识关联、可执行知识和差分测试。
+
+正例至少包含:跨文件纯函数证明、符号参数、两次连续调用、三层静态模块导入、穷尽分支以及调用方不等式结论。反例至少包含:假契约、修改传递依赖、重放过期证明、模糊签名、未支持运算、动态/外部调用、非穷尽分支,以及错误的证据等级提升。
+
+任何失败、缺少 Lean、证书与源码不一致、依赖过期或不支持的语义都必须显式拒绝出证或返回未核验状态。运行中的 CI 和缓存报告不能代替最新提交的核验结果。
+
+## 8. 结论
+
+Marqdo 知识编译的合理完成形态是 **Verified Knowledge Compiler(可验证知识编译器)**:
+
+> 能证明的知识生成可复用的形式证明;不能证明的知识保留明确证据与假设;所有知识均可统一寻址、依赖追踪、组合与执行,永不把未证明的内容伪装成已证明。
+
+证明的是**明确作用域中的性质**,可信性依靠**证据分级、语义对应、来源追踪与受控执行**共同建立。这个目标可验收、可维护,也适合智能体与量子科研应用的发展方向。
diff --git a/doc/releases/v2.9.0.md b/doc/releases/v2.9.0.md
new file mode 100644
index 0000000..5a1ae7f
--- /dev/null
+++ b/doc/releases/v2.9.0.md
@@ -0,0 +1,51 @@
+# Marqdo v2.9.0 · Full Release / 正式完整版本
+
+## 核心更新 · Highlights
+
+Marqdo 2.9.0 将 Markdown 原生可执行知识库推进为 **可验证知识编译器(Verified Knowledge Compiler)**。这不是全语言自动证明工具:Lean 4 仅证明明确支持的逻辑模型,系统继续保存来源、信任边界与失效原因。
+
+- **统一模块契约**:`knowledge compose` 支持静态纯函数的形参、整数表达式、连续赋值、穷尽分支、多次函数调用和多级模块调用 DAG。
+- **独立 Lean 模块证明**:每个受支持函数由源码生成可检查模块;调用方导入被调方定理,而不是将定理声明自动当成公理。
+- **知识锚点**:带标记步骤和定理声明具有稳定身份;`[]()` 用于可寻址引用,绝不自动赋予执行权。
+- **可信证据**:`model_proved`、`proved`、`tested`、`assumed`、`unknown`、`refuted`、`stale` 严格区分;证明收据绑定源码与依赖闭包,支持失效检测和独立重放。
+- **兼容性**:旧版 `marqdo prove`、`marqdo call`、知识视图和旧式简单组合证书继续兼容,Rust 与 Lean 差分测试保护语义边界。
+
+**EN:** Marqdo 2.9.0 introduces a Verified Knowledge Compiler for native Markdown knowledge artifacts, stable anchors, source-derived bounded assume/guarantee composition, and independently replayable Lean 4 certificates. The implementation **does not** claim universal program correctness: supported Lean `Int` theorems are labeled `model_proved` until a runtime semantic correspondence is established.
+
+## 可信边界 · Verification boundaries
+
+Lean 自动组合仅适用于源码可精确翻译的无副作用、静态纯整数模型片段;有界整数溢出、动态 `number` / `Formula`、插件效应、未知异常、循环和递归不会自动升级为已证明。前置条件未证明、源码漂移、证书篡改、Lean 不可用或超出支持范围时,必须拒绝出证或明确返回未验证状态。
+
+Formal logic proves **properties of the declared model**, not empirical facts or the entire runtime. External API responses, quantum hardware measurements and agent behavior require explicit experiment/test/provenance evidence. See [design decision](../design/verified-knowledge-compiler-boundaries.md).
+
+## 使用 · Usage
+
+```sh
+marqdo knowledge .
+marqdo knowledge compose --strict --json .
+marqdo knowledge proof-deps --verify --json .
+marqdo knowledge replay --json .
+```
+
+A `model_proved` certificate is **not** an unconditional authorization to call plugins or execute side effects.
+
+## 完整发行产物 · Full distribution
+
+The `v2.9.0` full packaging workflow produces:
+- Windows x86_64 native CLI (standalone EXE and bundled ZIP);
+- Linux x86_64 CLI+libraries bundle;
+- standard library ZIP, source ZIP and static user-site ZIP;
+- editor `marqdo-2.9.0.vsix` from the independent editor branch;
+- both Windows and Linux official native plugin packs, plus the versioned extension source pack when `ext/VERSION` matches `2.9.0`.
+
+**Release completion is determined by actual CI artifacts and publication evidence, not by this note.** In addition to GitHub assets the repository's [release handbook](../../skills/marqdo-release/index.mq.md) requires CDN/R2 byte parity and Ubuntu PPA publication/apt verification. Missing credentials, failed cross-platform builds or unverified publication channels must be reported as incomplete; never invent hashes or success.
+
+## 质量验收 · Quality gates
+
+- `modular-proof-smoke` — actual Lean kernel-checkable intermodule source contracts, negative/stale replay tests.
+- `knowledge-proof-full-gate` — knowledge, semantic-IR, proof corpus and interpreter/Lean differential tests.
+- `executable-knowledge` — backward compatibility and knowledge execution tests.
+- `Release` — verify both platform assets were built from the exact immutable tag.
+- `release-v2.9` gate — verify metadata, build/test on main and create the immutable tag only when checks pass.
+
+Version 2.9.0 is a **scoped Verified Knowledge Compiler**, not a theorem that every program or scientific experiment is automatically correct.
diff --git a/doc/verification/skill-proof/MarqdoEffects.lean b/doc/verification/skill-proof/MarqdoEffects.lean
new file mode 100644
index 0000000..ff805f3
--- /dev/null
+++ b/doc/verification/skill-proof/MarqdoEffects.lean
@@ -0,0 +1,82 @@
+/- Abstract stateful ABI and bounded-loop semantics.
+ These are proof rules, not an axiom that an arbitrary ABI plugin
+ satisfies its declared contract. Implementation witnesses are required. -/
+namespace MarqdoEffects
+
+inductive Outcome (σ α ε : Type) where
+ | ok : α → σ → Outcome σ α ε
+ | error : ε → σ → Outcome σ α ε
+ | unknown : Outcome σ α ε
+
+def bind {σ α β ε : Type}
+ (first : Outcome σ α ε)
+ (next : α → σ → Outcome σ β ε) : Outcome σ β ε :=
+ match first with
+ | .ok value state => next value state
+ | .error e state => .error e state
+ | .unknown => .unknown
+
+structure AbiContract (σ α β : Type) where
+ requires : σ → α → Prop
+ ensures : σ → α → σ → β → Prop
+
+def Implements {σ α β ε : Type}
+ (run : σ → α → Outcome σ β ε)
+ (contract : AbiContract σ α β) : Prop :=
+ ∀ state arg, contract.requires state arg →
+ ∃ value updated, run state arg = .ok value updated ∧
+ contract.ensures state arg updated value
+
+theorem impl_requires_witness {σ α β ε : Type}
+ (run : σ → α → Outcome σ β ε) (contract : AbiContract σ α β)
+ (h : Implements run contract) (state : σ) (arg : α)
+ (pre : contract.requires state arg) :
+ ∃ value updated, run state arg = .ok value updated := by
+ obtain ⟨v, s, hr, _⟩ := h state arg pre
+ exact ⟨v, s, hr⟩
+
+-- The plugin's failure case remains observable. A declared contract alone
+-- never rules out this case, unless a concrete implementation proof exists.
+theorem error_not_abi_success {σ α ε : Type}
+ (reason : ε) (state : σ) :
+ ¬ (∃ v s, (Outcome.error reason state : Outcome σ α ε) =
+ Outcome.ok v s) := by
+ intro h
+ obtain ⟨v, s, hs⟩ := h
+ cases hs
+
+theorem unknown_not_abi_success {σ α ε : Type} :
+ ¬ (∃ v s, (Outcome.unknown : Outcome σ α ε) =
+ Outcome.ok v s) := by
+ intro h
+ obtain ⟨v, s, hs⟩ := h
+ cases hs
+
+theorem bind_preserves_error {σ α β ε : Type}
+ (next : α → σ → Outcome σ β ε) (reason : ε) (state : σ) :
+ bind (Outcome.error reason state) next = Outcome.error reason state := by
+ rfl
+
+theorem bind_preserves_unknown {σ α β ε : Type}
+ (next : α → σ → Outcome σ β ε) :
+ bind Outcome.unknown next = Outcome.unknown := by
+ rfl
+
+-- Running out of fuel is UNRESOLVED, not a proof of termination or divergence.
+def runFuel {σ ε : Type}
+ (step : σ → Outcome σ σ ε) : Nat → σ → Outcome σ σ ε
+ | 0, _ => .unknown
+ | n + 1, state =>
+ match step state with
+ | .ok _ updated => runFuel step n updated
+ | .error e updated => .error e updated
+ | .unknown => .unknown
+
+theorem fuel_zero_not_success {σ ε : Type}
+ (step : σ → Outcome σ σ ε) (state : σ) :
+ ¬ (∃ v s, runFuel step 0 state = Outcome.ok v s) := by
+ intro h
+ obtain ⟨v, s, hs⟩ := h
+ cases hs
+
+end MarqdoEffects
diff --git a/doc/verification/skill-proof/MarqdoModularProof.lean b/doc/verification/skill-proof/MarqdoModularProof.lean
new file mode 100644
index 0000000..cf80e9b
--- /dev/null
+++ b/doc/verification/skill-proof/MarqdoModularProof.lean
@@ -0,0 +1,128 @@
+/-
+ Core assume–guarantee composition lemma for Marqdo module contracts.
+
+ This checks the *logic* of composing contracts, NOT that a particular
+ Marqdo function implements one. The compiler must separately establish
+ implementation correspondence and the call-site bridge obligation.
+-/
+
+namespace MarqdoModularProof
+
+structure Contract (α β : Type) where
+ requires : α → Prop
+ ensures : α → β → Prop
+
+def Implements {α β : Type} (f : α → β) (c : Contract α β) : Prop :=
+ ∀ x, c.requires x → c.ensures x (f x)
+
+def composed {α β γ : Type}
+ (first : Contract α β) (second : Contract β γ) : Contract α γ where
+ requires := first.requires
+ ensures := fun x z =>
+ ∃ y, first.ensures x y ∧ second.ensures y z
+
+-- Caller obligation is explicit. In particular, callee contract validity
+-- alone does not establish the precondition of the following component.
+theorem compose_sound {α β γ : Type}
+ (f : α → β) (g : β → γ)
+ (first : Contract α β) (second : Contract β γ)
+ (hf : Implements f first)
+ (hg : Implements g second)
+ (bridge : ∀ x, first.requires x →
+ first.ensures x (f x) → second.requires (f x)) :
+ Implements (fun x => g (f x)) (composed first second) := by
+ intro x hx
+ have hfirst := hf x hx
+ have hnext := hg (f x) (bridge x hx hfirst)
+ exact ⟨f x, hfirst, hnext⟩
+
+-- Trust-boundary test: the bridge is genuinely needed. Without it,
+-- the conclusion would fail for suitable partial contracts.
+example :
+ ¬ (∀ (f : Nat → Nat) (g : Nat → Nat)
+ (first : Contract Nat Nat) (second : Contract Nat Nat),
+ Implements f first →
+ Implements g second →
+ Implements (fun x => g (f x)) (composed first second)) := by
+ intro h
+ let f : Nat → Nat := fun _ => 0
+ let g : Nat → Nat := fun y => y
+ let first : Contract Nat Nat := {
+ requires := fun _ => True
+ ensures := fun _ _ => True
+ }
+ let second : Contract Nat Nat := {
+ requires := fun y => y = 1
+ ensures := fun _ z => z = 1
+ }
+ have hf : Implements f first := by
+ intro _ _
+ trivial
+ have hg : Implements g second := by
+ intro y hy
+ simpa [second, g] using hy
+ have hcomp := h f g first second hf hg
+ have target := hcomp 0 True.intro
+ cases target with
+ | intro y hpair =>
+ have impossible : (0 : Nat) = 1 := by
+ simpa [second, g, f] using hpair.right
+ exact Nat.zero_ne_one impossible
+
+-- Execution is a *partial* result: host/plugin failures and divergence
+-- must remain visible. Loops/recursion can be reasoned about only after
+-- separate termination proofs, and ABI effects require a proven contract.
+inductive Exit (α ε : Type) where
+ | ok (value : α)
+ | error (reason : ε)
+ | diverged
+
+def sequence {α β ε : Type}
+ (first : Exit α ε) (next : α → Exit β ε) : Exit β ε :=
+ match first with
+ | .ok value => next value
+ | .error e => .error e
+ | .diverged => .diverged
+
+structure TotalContract (α β : Type) where
+ requires : α → Prop
+ ensures : α → β → Prop
+
+def Satisfies {α β ε : Type}
+ (run : α → Exit β ε) (c : TotalContract α β) : Prop :=
+ ∀ x, c.requires x → ∃ y, run x = .ok y ∧ c.ensures x y
+
+def combined {α β γ : Type}
+ (first : TotalContract α β)
+ (second : TotalContract β γ) : TotalContract α γ where
+ requires := first.requires
+ ensures := fun x z => ∃ y, first.ensures x y ∧ second.ensures y z
+
+theorem total_sequence_sound {α β γ ε : Type}
+ (f : α → Exit β ε) (g : β → Exit γ ε)
+ (cf : TotalContract α β) (cg : TotalContract β γ)
+ (hf : Satisfies f cf)
+ (hg : Satisfies g cg)
+ (bridge : ∀ x y, cf.requires x → cf.ensures x y →
+ cg.requires y) :
+ Satisfies (fun x => sequence (f x) g) (combined cf cg) := by
+ intro x hx
+ obtain ⟨y, hrunF, hpostF⟩ := hf x hx
+ obtain ⟨z, hrunG, hpostG⟩ := hg y (bridge x y hx hpostF)
+ refine ⟨z, ?_, ⟨y, hpostF, hpostG⟩⟩
+ simpa [sequence, hrunF] using hrunG
+
+-- A crashing plugin and a diverging loop cannot satisfy a total contract.
+theorem error_not_success {α ε : Type} (e : ε) :
+ ¬ (∃ v : α, Exit.error e = Exit.ok v) := by
+ intro h
+ obtain ⟨v, hv⟩ := h
+ cases hv
+
+theorem diverged_not_success {α ε : Type} :
+ ¬ (∃ v : α, (Exit.diverged : Exit α ε) = Exit.ok v) := by
+ intro h
+ obtain ⟨v, hv⟩ := h
+ cases hv
+
+end MarqdoModularProof
diff --git a/examples/knowledge-proof/README.md b/examples/knowledge-proof/README.md
new file mode 100644
index 0000000..8f750cf
--- /dev/null
+++ b/examples/knowledge-proof/README.md
@@ -0,0 +1,14 @@
+# Marqdo 知识锚点 + 自动证明示例
+
+面向 CLI 2.8.0,原 Markdown 语法不变:
+
+```sh
+marqdo knowledge examples/knowledge-proof/
+marqdo prove examples/knowledge-proof/main.mq.md --json
+marqdo knowledge examples/knowledge-proof/
+```
+
+知识编译后,查看 `.marqdo/anchors.json`、`.marqdo/claims.json`、`.marqdo/refs.json`、`.marqdo/graph/edges.json` 以及 `.marqdo/proof-index.json`(具体输出目录取决于 CLI --out)。
+证明调用另外生成其证明目录下的 `knowledge-links.json`。运行 CLI 时是否有 Lean 决定该定理能否获得真正的 `proved` 状态;没有 Lean 只能是 `checked` 或 `unverified`。在此案例中,`长度(轨迹)=0` 是函数级定理,并非内部的“计算结果”步骤已经独立证明正确。
+
+`[计算知识节点](#@计算结果)` 是**同函数内的静态知识引用**。跨文件引用请从 `anchors.json` 拿完整 `mq://...#anchor-...` 地址,不要猜测哈希。两个同名标记不共享地址,会被标记为无公共锚点。
diff --git a/examples/knowledge-proof/main.mq.md b/examples/knowledge-proof/main.mq.md
new file mode 100644
index 0000000..bfedb03
--- /dev/null
+++ b/examples/knowledge-proof/main.mq.md
@@ -0,0 +1,19 @@
+---
+markup: occlusion
+title: 可寻址、可验证的知识步骤
+---
+
+# main
+
+## 计算
+
+| 定理 | 结论 | 前提 | 策略 |
+|---|---|---|---|
+| 无外部操作 | 长度(轨迹) = 0 | | auto |
+
+这里的 [计算知识节点](#@计算结果) 和 [定理声明](#@无外部操作) 都是可解析的知识引用;
+它不会再次执行运算,也不会自动继承函数的形式化证明。
+
+**答案 = [计算结果](2 * 3)**
+
+*答案*
diff --git a/ext/VERSION b/ext/VERSION
old mode 100755
new mode 100644
index dbe5900..c8e38b6
--- a/ext/VERSION
+++ b/ext/VERSION
@@ -1 +1 @@
-2.8.1
+2.9.0
diff --git a/src/ast.rs b/src/ast.rs
index 364e7ea..d944c45 100755
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -97,6 +97,18 @@ pub struct Function {
pub var_contracts: HashMap,
/// 定理表(ADR 0010):函数级命题声明;首条可执行语句之前提取,不参与运行。
pub claims: Vec,
+ /// Non-executable modular assumptions, never accepted as proven facts.
+ pub assumptions: Vec,
+}
+
+/// Author-declared operation contract. Call-site obligations must still be
+/// proved and callee implementation identity checked before it can be reused.
+#[derive(Debug, Clone)]
+pub struct Assumption {
+ pub op: String,
+ pub premise: Option,
+ pub postcondition: String,
+ pub line: u32,
}
/// 一条定理声明(设计 §7.1):`| 定理 | 结论 | 前提 | 策略 |` 的一行。
diff --git a/src/contract.rs b/src/contract.rs
index cb958b3..b09bfd0 100755
--- a/src/contract.rs
+++ b/src/contract.rs
@@ -369,6 +369,43 @@ pub fn parse_claim_table(
Some(Ok(rows))
}
+/// Parse the v2.9 modular assumption table. An assumption is metadata,
+/// never a runtime statement or an independently verified theorem.
+pub fn parse_assumption_table(
+ pairs: &[(String, Expr)], line: u32,
+) -> Option,String>> {
+ const OP: &[&str] = &["假设","assumption"];
+ const PRE: &[&str] = &["前置","requires","precondition"];
+ const POST: &[&str] = &["后置","ensures","postcondition"];
+ let headers:Vec=pairs.iter().map(|(k,_)|k.clone()).collect();
+ let op=find_col(&headers,OP)?;
+ let post=match find_col(&headers,POST){
+ Some(i)=>i,
+ None=>return Some(Err("assumption table requires a 后置 / ensures column".into()))
+ };
+ let op_names=col_rows(&pairs[op].1).unwrap_or_default();
+ let posts=claim_col_rows(&pairs[post].1);
+ let pres=find_col(&headers,PRE).map(|i|claim_col_rows(&pairs[i].1));
+ if op_names.len()!=posts.len()
+ || pres.as_ref().is_some_and(|p|p.len()!=op_names.len()) {
+ return Some(Err("assumption table columns have different row counts".into()));
+ }
+ let mut results=Vec::new();
+ for (i,name) in op_names.into_iter().enumerate(){
+ if name.trim().is_empty() || posts[i].trim().is_empty() {
+ return Some(Err(format!("assumption row {} lacks operation or postcondition",i+1)));
+ }
+ results.push(crate::ast::Assumption{
+ op:name.trim().to_string(),
+ premise:pres.as_ref().and_then(|p|p.get(i))
+ .map(|s|s.trim().to_string()).filter(|s|!s.is_empty()),
+ postcondition:posts[i].trim().to_string(),
+ line,
+ });
+ }
+ Some(Ok(results))
+}
+
/// 定理表形状错误(`check --proof` 才报;默认关)。
#[derive(Debug, Clone)]
pub struct ClaimTableError {
diff --git a/src/knowledge/compile.rs b/src/knowledge/compile.rs
index 0899746..ef16591 100755
--- a/src/knowledge/compile.rs
+++ b/src/knowledge/compile.rs
@@ -21,7 +21,8 @@ pub fn compile(opts: KnowledgeOptions) -> Result {
// Legacy EKC retrieval catalog writes only under `ekc/` and must never
// overwrite `graph/edges.json` (G01).
let semantic_root = if opts.path.is_file() {
- opts.path.parent().unwrap_or_else(|| Path::new(".")).to_path_buf()
+ opts.path.parent().filter(|p| !p.as_os_str().is_empty())
+ .unwrap_or_else(|| Path::new(".")).to_path_buf()
} else {
opts.path.clone()
};
diff --git a/src/knowledge/composition.rs b/src/knowledge/composition.rs
new file mode 100644
index 0000000..301c513
--- /dev/null
+++ b/src/knowledge/composition.rs
@@ -0,0 +1,490 @@
+//! Reusable, independently replayable **restricted** module composition.
+//!
+//! Scope: pure typed-int forwarding caller and source-constant callee. Two
+//! independently compiled Lean modules: caller imports the callee's theorem,
+//! not its implementation. Every unmodeled construct fails closed.
+//! This is not a theorem about arbitrary Marqdo programs.
+use std::{fs,path::Path,time::Duration};
+use anyhow::{Context,Result};
+use serde_json::{json,Value};
+use sha2::{Digest,Sha256};
+use crate::{
+ ast::{CallExpr,Expr,Function,Literal,Stmt},
+ prove::driver::{Toolchain,compile_import_module},
+ sema::ir::{Compilation,SemanticArtifact,BoundCall}
+};
+fn sha(input:&[u8])->String{format!("sha256:{:x}",Sha256::digest(input))}
+fn lookup<'a>(items:&'a [Function],path:&[&str])->Option<&'a Function>{
+ let (first,rest)=path.split_first()?;
+ let fun=items.iter().find(|f|f.name==*first)?;
+ if rest.is_empty(){Some(fun)}else{lookup(&fun.children,rest)}
+}
+fn function(compiled:&Compilation,a:&SemanticArtifact)->Option{
+ let raw=fs::read_to_string(compiled.semantics.root.join(&a.source.file)).ok()?;
+ let doc=crate::parse::parse_source(&raw).ok()?;
+ let path=a.display_name.split('.').collect::>();
+ lookup(&doc.functions,&path).cloned()
+}
+fn call_inside(expr:&Expr)->Option<&CallExpr>{
+ match expr{
+ Expr::Call(c)=>Some(c),
+ Expr::Occluded{payload:Some(inner),..}=>call_inside(inner),
+ _=>None
+ }
+}
+fn forwarded(fun:&Function)->Option<&CallExpr>{
+ match fun.body.as_slice(){
+ [Stmt::Return{value,..}]=>call_inside(value),
+ [Stmt::Assign{name,value,..},Stmt::Return{value:Expr::Var(v),..}]
+ if name==v=>call_inside(value),
+ _=>None
+ }
+}
+fn constant_return(fun:&Function)->Option{
+ match fun.body.as_slice(){
+ [Stmt::Return{value:Expr::Literal(Literal::Int(n)),..}]=>Some(*n),
+ [Stmt::Return{value:Expr::Occluded{payload:Some(v),..},..}] =>
+ if let Expr::Literal(Literal::Int(n))=v.as_ref(){Some(*n)}else{None},
+ _=>None
+ }
+}
+fn claim_is_constant(compiled:&Compilation,owner:&SemanticArtifact,n:i64)->bool{
+ // Treat duplicate eligible claims as ambiguity, never as evidence.
+ // A single matching declaration is required at the exact owner SymbolId.
+ owner.symbol_id.as_ref().is_some_and(|id|
+ compiled.semantics.claims.iter().filter(|c|
+ c.owner==*id
+ && c.premise.as_deref().map_or(true,|p|p.trim().is_empty())
+ && c.conclusion.trim()==format!("结果 = {n}")).count()==1)
+}
+fn candidate(compiled:&Compilation,call:&BoundCall)
+ ->Option<(String,String,String,i64)>{
+ let ca=compiled.semantics.artifacts.iter().find(|a|
+ a.symbol_id.as_ref()==Some(&call.caller) && a.kind=="function")?;
+ let ce=compiled.semantics.artifacts.iter().find(|a|
+ a.symbol_id.as_ref()==Some(&call.target) && a.kind=="function")?;
+ // The contract is strictly inter-module: local recursion and aliases
+ // must not inherit an import-composition certificate.
+ if ca.source.file==ce.source.file || call.caller==call.target{return None}
+ if !ca.effects.is_pure()||!ce.effects.is_pure()
+ ||!call.required_effects.is_pure()
+ ||call.control_blocker.is_some()||!call.path_guards.is_empty(){return None}
+ let caller=function(compiled,ca)?;
+ let callee=function(compiled,ce)?;
+ let forwarded=forwarded(&caller)?;
+ let runtime=forwarded.for_evaluation().ok()?;
+ if crate::sema::bind::call_display(&runtime)!=call.call_site
+ ||compiled.semantics.bound_calls.iter().filter(|item|
+ item.caller==call.caller).count()!=1 {return None}
+ if runtime.path.as_ref().is_none()||runtime.receiver.is_some()
+ ||caller.is_object()||callee.is_object(){return None}
+ let n=constant_return(&callee)?;
+ if !claim_is_constant(compiled,ca,n)||!claim_is_constant(compiled,ce,n){
+ return None
+ }
+ let cs=ca.signature.as_ref()?;
+ let es=ce.signature.as_ref()?;
+ if cs.params.len()!=caller.params.len()
+ ||es.params.len()!=callee.params.len()
+ ||es.params.len()!=call.args.len()
+ ||call.args.len()!=runtime.args.len(){return None}
+ if cs.params.iter().chain(es.params.iter())
+ // Marqdo currently canonicalizes int/num/float to "number".
+ // This certificate is explicitly about the *Lean Int model*, NOT
+ // all runtime Number variants. Runtime-equivalence remains false.
+ .any(|p|!p.ty.eq_ignore_ascii_case("number")||!p.required){return None}
+ let arg_expr=call.args.iter().zip(es.params.iter()).map(|(a,p)|{
+ if a.name.as_ref().is_some_and(|x|x!=&p.name){return None}
+ if let Some(v)=a.integer {return Some(format!("({v} : Int)"))}
+ let symbol=a.symbol.as_ref()?;
+ let position=cs.params.iter().position(|x|x.name==*symbol)?;
+ Some(format!("v{position}"))
+ }).collect::