Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
180a111799 | ||
|
|
a3948dbe0d | ||
|
|
24959a0ba8 | ||
|
|
afbb9f191c | ||
|
|
8db699191e | ||
|
|
e5580d9640 | ||
|
|
9ce2ae1037 | ||
|
|
166b01c86b | ||
|
|
87cfe05095 | ||
|
|
b37387e6da | ||
|
|
895752a1fd | ||
|
|
38c07d9a0e | ||
|
|
8e437e2cd3 | ||
|
|
23229a6ac9 | ||
|
|
58b65215a1 | ||
|
|
92c3f80055 | ||
|
|
8a66f803cb | ||
|
|
3ce59a4da8 | ||
|
|
90688741c5 | ||
|
|
70b88b3767 | ||
|
|
f859e6eeea | ||
|
|
6705e2e6b7 | ||
|
|
6e8a62928b | ||
|
|
398a0b7222 | ||
|
|
e8f1a3e126 | ||
|
|
8ea56cbe30 | ||
|
|
8085d06124 | ||
|
|
6f929dc2da | ||
|
|
dd22180269 | ||
|
|
cc48bf6d05 | ||
|
|
19f986953a | ||
|
|
770dee5199 | ||
|
|
f6612813e3 | ||
|
|
643ea06340 | ||
|
|
0cd64a7450 | ||
|
|
981faac022 | ||
|
|
f818834ec1 | ||
|
|
8d47507d15 | ||
|
|
1e1f05c087 | ||
|
|
06e61efc51 | ||
|
|
2dfa0b2a5b | ||
|
|
629ad8ed39 | ||
|
|
ee677478be | ||
|
|
edbf241d99 | ||
|
|
add6a7d32c | ||
|
|
c64ec99115 | ||
|
|
60a3b84a84 | ||
|
|
02a4f2d20d | ||
|
|
88490e3092 | ||
|
|
9031c106a1 | ||
|
|
633436e40f | ||
|
|
cf73fcf1ef | ||
|
|
e48fd5b0f4 | ||
|
|
b2f97e72c3 | ||
|
|
c7c0f66d1f | ||
|
|
d5ab9daebb | ||
|
|
5795236d1f | ||
|
|
e8d6dc92fc | ||
|
|
afe31cb2a8 | ||
|
|
905a67df32 | ||
|
|
f63b7ef48d | ||
|
|
393558ca97 | ||
|
|
0d9bd99fc0 | ||
|
|
a0c779e022 | ||
|
|
a82b6fdde1 | ||
|
|
3613ed7c4e | ||
|
|
9564dff777 | ||
|
|
f56deffefe | ||
|
|
bdedf3ecd8 | ||
|
|
b0ee958fcf | ||
|
|
e64f6b23b4 | ||
|
|
eed4f05ea4 | ||
|
|
d88ed274ed | ||
|
|
7fdd97f675 | ||
|
|
c299efe589 | ||
|
|
b3867c46db | ||
|
|
1a39a53d93 |
No files matched your search
@@ -15,6 +15,22 @@ jobs:
|
||||
run: |
|
||||
cargo build -p marqdo_plugin_agent --locked
|
||||
cargo build -p marqdo_plugin_llm --locked
|
||||
- name: Native agent choice and bounded recovery unit tests
|
||||
run: cargo test -p marqdo_plugin_agent --locked
|
||||
- name: Check short AI flow documents
|
||||
run: |
|
||||
cargo run --locked -- check ext/ai/flow.mq.md
|
||||
cargo run --locked -- check ext/ai/recovery.mq.md
|
||||
cargo run --locked -- check ext/ai/context.mq.md
|
||||
cargo run --locked -- check tests/ext/ai-native-flow.mq.md
|
||||
cargo run --locked -- check ext/ai/workflow.mq.md
|
||||
cargo run --locked -- check tests/ext/ai-native-workflow.mq.md
|
||||
- name: Native AI flow interpreter smoke (offline)
|
||||
env:
|
||||
MARQDO_AGENT_PLUGIN: ${{ github.workspace }}/target/debug/libagent.so
|
||||
run: |
|
||||
cargo run --locked -- run tests/ext/ai-native-flow.mq.md
|
||||
cargo run --locked -- run tests/ext/ai-native-workflow.mq.md
|
||||
- name: Workbench contracts (M00–M06 / F-subset)
|
||||
run: cargo test --test workbench_contracts --locked
|
||||
- name: Offline executable-knowledge gate
|
||||
|
||||
@@ -32,11 +32,15 @@ jobs:
|
||||
cargo build --release -p marqdo -p marqdo_plugin_agent -p marqdo_plugin_quantum -p marqdo_plugin_linalg -p marqdo_plugin_llm -p marqdo_plugin_engineering
|
||||
bash scripts/build-web-plugin.sh
|
||||
- name: Build and validate the runner's exact pack bytes
|
||||
shell: pwsh
|
||||
run: ./target/release/marqdo.exe call skills/marqdo-release/packs.mq.md ci --effects plugin,fs.write,environment.read --fs-root . --require-ok --json
|
||||
shell: bash
|
||||
run: |
|
||||
set -euo pipefail
|
||||
./target/release/marqdo.exe call skills/marqdo-release/packs.mq.md ci --effects plugin,fs.read,fs.write,environment.read --fs-root . --require-ok --json
|
||||
- name: Attach source and Windows native packs without replacement
|
||||
shell: pwsh
|
||||
run: ./target/release/marqdo.exe call skills/marqdo-release/packs.mq.md attach_ci --effects plugin,fs.read,environment.read --fs-root . --require-ok --json
|
||||
shell: bash
|
||||
run: |
|
||||
set -euo pipefail
|
||||
./target/release/marqdo.exe call skills/marqdo-release/packs.mq.md attach_ci --effects plugin,fs.read,environment.read --fs-root . --require-ok --json
|
||||
|
||||
linux:
|
||||
runs-on: ubuntu-latest
|
||||
@@ -59,6 +63,6 @@ jobs:
|
||||
cargo build --release -p marqdo -p marqdo_plugin_agent -p marqdo_plugin_quantum -p marqdo_plugin_linalg -p marqdo_plugin_llm -p marqdo_plugin_engineering
|
||||
bash scripts/build-web-plugin.sh
|
||||
- name: Build and validate the runner's exact pack bytes
|
||||
run: target/release/marqdo call skills/marqdo-release/packs.mq.md ci --effects plugin,fs.write,environment.read --fs-root . --require-ok --json
|
||||
run: target/release/marqdo call skills/marqdo-release/packs.mq.md ci --effects plugin,fs.read,fs.write,environment.read --fs-root . --require-ok --json
|
||||
- name: Attach Linux native pack without replacement
|
||||
run: target/release/marqdo call skills/marqdo-release/packs.mq.md attach_ci --effects plugin,fs.read,environment.read --fs-root . --require-ok --json
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,40 @@
|
||||
name: native-ai-flow
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- feat/native-ai-flow-recovery-20261118
|
||||
pull_request:
|
||||
paths:
|
||||
- 'plugins/agent/**'
|
||||
- 'ext/ai/flow.mq.md'
|
||||
- 'ext/ai/context.mq.md'
|
||||
- 'ext/ai/recovery.mq.md'
|
||||
- 'ext/ai/workflow.mq.md'
|
||||
- 'tests/ext/ai-native-*.mq.md'
|
||||
- '.github/workflows/native-ai-flow.yml'
|
||||
|
||||
jobs:
|
||||
agent:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- name: Build the agent plugin
|
||||
run: cargo build -p marqdo_plugin_agent --locked
|
||||
- name: Run native agent and workflow tests
|
||||
run: cargo test -p marqdo_plugin_agent --locked
|
||||
- name: Check the public Marqdo ABI libraries
|
||||
run: |
|
||||
cargo run --locked -- check ext/ai/flow.mq.md
|
||||
cargo run --locked -- check ext/ai/context.mq.md
|
||||
cargo run --locked -- check ext/ai/recovery.mq.md
|
||||
cargo run --locked -- check ext/ai/workflow.mq.md
|
||||
cargo run --locked -- check tests/ext/ai-native-flow.mq.md
|
||||
cargo run --locked -- check tests/ext/ai-native-workflow.mq.md
|
||||
- name: Exercise offline integration through Marqdo
|
||||
env:
|
||||
MARQDO_AGENT_PLUGIN: ${{ github.workspace }}/target/debug/libagent.so
|
||||
run: |
|
||||
cargo run --locked -- run tests/ext/ai-native-flow.mq.md
|
||||
cargo run --locked -- run tests/ext/ai-native-workflow.mq.md
|
||||
Executable → Regular
File mode changed.
@@ -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"
|
||||
Executable → Regular
+2
@@ -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
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
/target/
|
||||
/dist/
|
||||
# Plugin unit tests use package-relative scratch checkpoints.
|
||||
/plugins/agent/target/
|
||||
|
||||
# Copied by gold harness for ABI plugins
|
||||
/tests/lib/demo.dll
|
||||
|
||||
@@ -2,6 +2,63 @@
|
||||
|
||||
## 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
|
||||
|
||||
**AI native durable workflow(CLI 仍为 v2.8.0)**:`ext/ai` 以插件侧步骤机交付持久化
|
||||
工作流(`workflow`/`flow`/`context`/`recovery`),含有界模型选择、作用域上下文、
|
||||
只读失败恢复、`inspect`/`list` 与可隔离 `resume_dir`。Windows 打包使用 `path.join`
|
||||
根路径与 `System32\tar.exe`。详见 [双语发布说明](doc/releases/ext-2.8.1.md)。
|
||||
|
||||
```bash
|
||||
marqdo ext add agent # CDN latest → 2.8.1
|
||||
# 或:MARQDO_EXT_VERSION=2.8.1 marqdo ext add agent
|
||||
```
|
||||
|
||||
**核心表面 Δ(Core surface Δ)**:**无增删**——仅 Extension / Agent Runtime。
|
||||
|
||||
### Added
|
||||
|
||||
- `ext/ai/workflow`:`open/next/commit/cancel/tick/retry_*`,以及只读 `inspect`/`list`
|
||||
与各操作的 host-relative `resume_dir`。
|
||||
- `ext/ai/flow` · `context` · `recovery`:ask/choose、作用域打包、CheckpointV2 恢复面。
|
||||
- Agent ABI:`agent_workflow_*`、`agent_choice_parse`、`agent_context_scope`、
|
||||
`agent_input_*`、`agent_parallel_report`。
|
||||
- Offline fixtures:`tests/ext/ai-native-flow.mq.md`、`tests/ext/ai-native-workflow.mq.md`;
|
||||
CI:`.github/workflows/native-ai-flow.yml`。
|
||||
|
||||
### Fixed
|
||||
|
||||
- `flow.choose` no longer leaks a branch-local `parsed` value into the function
|
||||
contract; the repaired-choice path is fully scoped.
|
||||
- CI builds the agent cdylib and runs offline integration without the removed
|
||||
`run --effects` flag, using `MARQDO_AGENT_PLUGIN` instead.
|
||||
- Atomic checkpoint/effect temp names no longer collide under parallel writes;
|
||||
resume tests no longer race on process-wide cwd.
|
||||
- Windows `extension-release`:engineering root 使用 `path.join` / cwd 回退;
|
||||
ZIP 显式调用 `System32\tar.exe`(bsdtar);`packs.ci` 授予 `fs.read`。
|
||||
|
||||
### Changed
|
||||
|
||||
- 扩展包 SemVer **2.8.1**(`ext/VERSION`);与 CLI **v2.8.0** 可独立安装。
|
||||
- 分支已合并 v2.8.0 依赖锁后的 AI 工作流增量,不再从 2.7.1 基线分叉。
|
||||
|
||||
## v2.8.0 — 2026-11-17
|
||||
|
||||
`marqdo prove` 正式发布:定理表 → Lean 4 证明 → 自动判定。离线符号执行(F1–F5)无工具链可用,`checked` 永远弱于 `proved`;单调性护栏让判定器缺陷显式失败;假定理给出反例见证;证书缓存与目录模式面向智能体批量出证。
|
||||
|
||||
+3
-2
@@ -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",
|
||||
@@ -668,6 +668,7 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"marqdo-plugin-sdk",
|
||||
"pulldown-cmark",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
|
||||
Executable → Regular
+1
-1
@@ -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"
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
<p align="center"><em>让 SKILL 真正成为工具:文档即知识,知识即可执行。</em></p>
|
||||
|
||||
<p align="center">
|
||||
<a href="https://github.com/cflmy/marqdo/releases/tag/v2.7.1"><img alt="release" src="https://img.shields.io/badge/release-v2.7.1-DDBA86?style=flat-square"></a>
|
||||
<a href="https://github.com/cflmy/marqdo/releases/tag/v2.9.0"><img alt="release" src="https://img.shields.io/badge/release-v2.9.0-DDBA86?style=flat-square"></a>
|
||||
<a href="LICENSE"><img alt="Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-blue?style=flat-square"></a>
|
||||
<img alt="Rust runtime" src="https://img.shields.io/badge/runtime-Rust-B38E68?style=flat-square">
|
||||
<img alt="Pure by default" src="https://img.shields.io/badge/call-pure_by_default-467C83?style=flat-square">
|
||||
@@ -21,9 +21,13 @@
|
||||
<a href="#explore-the-view">View</a> ·
|
||||
<a href="doc/library-development.mq.md">Guide</a> ·
|
||||
<a href="https://www.marqdo.com/">Website</a> ·
|
||||
<a href="doc/releases/v2.7.1.md">Release notes</a>
|
||||
<a href="doc/releases/v2.9.0.md">Release notes</a>
|
||||
</p>
|
||||
|
||||
## 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
|
||||
@@ -117,7 +121,7 @@ marqdo view examples/procurement --no-open
|
||||
|
||||
Agent Skills already support scripts; Marqdo's claim is **one document-native language surface** for authoring, inspecting, executing and reusing functions. This is **not** a claim of full formal verification, zero-delay execution, or OS-level isolation of all plugin/process behavior.
|
||||
|
||||
**Resources:** [Release v2.8.0](https://github.com/cflmy/marqdo/releases/tag/v2.8.0) · [Procurement example](examples/procurement/index.mq.md) · [Executable library authoring](doc/library-development.mq.md) · [Function calling](public/features/22-函数调用.mq.md) · [Link syntax](doc/design/link-syntax.md) · [Website](https://www.marqdo.com/)
|
||||
**Resources:** [Release v2.8.0](https://github.com/cflmy/marqdo/releases/tag/v2.8.0) · [Ext pack 2.8.1](https://github.com/cflmy/marqdo/releases/tag/ext-v2.8.1) · [Procurement example](examples/procurement/index.mq.md) · [Executable library authoring](doc/library-development.mq.md) · [Function calling](public/features/22-函数调用.mq.md) · [Link syntax](doc/design/link-syntax.md) · [Website](https://www.marqdo.com/)
|
||||
|
||||
---
|
||||
|
||||
@@ -128,8 +132,12 @@ Agent Skills already support scripts; Marqdo's claim is **one document-native la
|
||||
|
||||
当前 CLI **2.8.0** 新增 `marqdo prove`:知识文件的定理表编译为 Lean 4 并自动判定真假——没有 Lean 工具链也能离线符号执行(诚实降级,绝不冒充证明),有 Lean 时全链路证明并给出反例见证。参见[发布说明](doc/releases/v2.8.0.md)。
|
||||
|
||||
独立拓展包 **2.8.1**(CLI 仍为 2.8.0):`ext/ai` 插件侧持久化工作流(选择 / 作用域上下文 / 只读失败恢复 / `inspect`)。`marqdo ext add agent` → CDN latest。参见[拓展包说明](doc/releases/ext-2.8.1.md)。
|
||||
|
||||
CLI **2.8.0** adds `marqdo prove`: theorem tables in knowledge files compile to Lean 4 and are judged automatically — offline symbolic execution without a toolchain (honest degradation, never impersonating a proof), full proofs with counterexample witnesses when Lean is available.
|
||||
|
||||
Ext pack **2.8.1** (CLI remains 2.8.0): plugin-only durable AI workflows with bounded choice, scoped context, failed-only read-only recovery and `inspect`.
|
||||
|
||||
## 核心优势:可执行知识(Executable Knowledge)
|
||||
|
||||
> **Knowledge That Can Run —— 知识即可执行。**
|
||||
|
||||
Executable → Regular
+1
-1
@@ -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)"
|
||||
|
||||
@@ -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-<sha256>)`。后者应从编译生成的 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,未达到完整通用模块化证明标准。
|
||||
@@ -0,0 +1,140 @@
|
||||
# Marqdo native agent flow — implementation contract
|
||||
|
||||
Status: **incremental, draft**. The core orchestration now has a plugin-only
|
||||
alternative to interpreter-stack suspension: a durable finite step state machine
|
||||
with explicit safe commit boundaries. Do not claim arbitrary stack-level
|
||||
continuation or exactly-once external writes based on a checkpoint file.
|
||||
|
||||
## Author surface (implemented in this branch)
|
||||
|
||||
| Module | Function | Contract |
|
||||
|---|---|---|
|
||||
| ext/ai/context.mq.md | scope | Select a bounded source excerpt using parsed Markdown headings; ambiguous names fail closed |
|
||||
| ext/ai/context.mq.md | pack | Compact caller-provided file/class/function text via ContextPackV2 |
|
||||
| ext/ai/flow.mq.md | ask/choose/parse_choice | One short decision, allowed-choice verification, at most one format repair |
|
||||
| ext/ai/flow.mq.md | input/reply | Durable step-boundary user-input gate keyed by id + source revision and scope |
|
||||
| ext/ai/flow.mq.md | start/wait/parallel | Existing Marqdo subtask scheduler, failure-preserving parallel result aggregation |
|
||||
| ext/ai/flow.mq.md | enter | Resolve only author-supplied registered skill name, run via standard subtask path |
|
||||
| ext/ai/recovery.mq.md | decide/save/load | Native error policy and CheckpointV2; no implicit unsafe re-execution |
|
||||
| ext/ai/workflow.mq.md | open/next/commit/cancel | Durable forward-only step machine with per-step commit boundaries |
|
||||
| ext/ai/workflow.mq.md | inspect/list | Read-only progress summary and checkpoint discovery scoped by session/principal |
|
||||
| ext/ai/workflow.mq.md | tick/retry_plan/retry_commit/retry_failed | One-step execution and failed-only read-only recovery |
|
||||
|
||||
The native agent plugin provides `agent_choice_parse`, `agent_context_scope`,
|
||||
`agent_input_open`, `agent_input_resume`, `agent_parallel_report`, and the
|
||||
`agent_workflow_*` primitives including `inspect` and `list`.
|
||||
Plugin errors must be visible, never converted into a fabricated successful answer.
|
||||
All workflow wrappers accept a host-relative `resume_dir`, so tests and callers
|
||||
can isolate checkpoints instead of sharing the default `.marqdo/agent-resume`.
|
||||
|
||||
## Invariants
|
||||
|
||||
- A model choice is untrusted data until verified against an explicit option list.
|
||||
- An imported module is **not** automatically part of a model prompt.
|
||||
- The requested heading scope, not the entire source file, is the prompt source.
|
||||
- A pending user-input gate owns a persistent checkpoint, not a blocked interpreter thread.
|
||||
- The same answer may be returned repeatedly; a competing answer or stale revision conflicts.
|
||||
- A completed subtask wait is distinct from a successful child exit.
|
||||
- Existing successful siblings remain visible when one subtask fails.
|
||||
- Writes, executable effects and external writes remain under ToolSpec permissions,
|
||||
the EffectLedger and source-version checks.
|
||||
- No component may silently broaden a tool's authorization on failure.
|
||||
|
||||
## Important limitations in this branch
|
||||
|
||||
The input/reply gate stores an explicit **step boundary**. It does not yet persist
|
||||
an arbitrary bytecode interpreter frame. Applications must choose and re-enter
|
||||
their next Marqdo function explicitly after receiving a verified input answer.
|
||||
The current source selector relies on a Markdown parser plus Marqdo heading
|
||||
conventions, not on the compiler's resolved module/class/function AST and symbols.
|
||||
Host identity inputs are supplied by the caller; production applications must
|
||||
attest them from their authenticated session, never use model-generated identity.
|
||||
The parallel wrapper reuses `subtask.run_many` and does not add durable child
|
||||
lease orchestration. Live provider tests and real 1B-model benchmarking remain open.
|
||||
|
||||
## Required VM/runtime completion: suspended execution
|
||||
|
||||
1. Introduce `WaitingInput` as a scheduler state, distinct from terminal failure.
|
||||
Save the logical run, program counter at a safe suspension boundary, bound
|
||||
inputs, variable snapshot, module and tool digests, and effect watermark.
|
||||
2. Resume via a new attempt linked to the original logical run, but never
|
||||
automatically repeat committed effects. Preserve cancellation and budget.
|
||||
3. The resume endpoint must be atomic (revision CAS), authenticate principal
|
||||
and workspace, verify source and tool schema revisions, and deduplicate
|
||||
repeated reply requests. Do not trust IDs inside model text.
|
||||
4. Handle interrupted worker, partial snapshot, stale input, invalid choice and
|
||||
unknown external write as separate outcomes. Treat unknown writes as
|
||||
reconciliation-required; do not invent exactly-once guarantees.
|
||||
5. Persist only serializable language values at declared safe points. If a
|
||||
foreign kernel, socket or native handle is live, explicitly refuse
|
||||
transparent frame recovery and preserve a safe step-level restart option.
|
||||
|
||||
## Required durable parallel execution
|
||||
|
||||
A parent dispatches child `.mq.md` functions using registered paths, grants
|
||||
minimal capabilities, shares budget and rate limits, and persists a child task
|
||||
manifest. Child completion records a status, value ref, output digest and ledger
|
||||
watermark before the parent merges results. For same-resource writes, use
|
||||
serialized revisions and explicit commit order. On parent cancellation, stop
|
||||
new children and request child cancellation; do not assume remote writes rolled
|
||||
back. On recovery, reconcile child attempts and reuse successful results.
|
||||
|
||||
## Release gates
|
||||
|
||||
| Test | Required observation |
|
||||
|---|---|
|
||||
| compiler/import check | All new `.mq.md` functions pass contract checks and execute via ABI |
|
||||
| small model outputs | Exact, labeled, fenced and numeric options normalize; mixed options fail |
|
||||
| input gate crash | After checkpoint, reply is committed once; alternate reply conflicts |
|
||||
| source drift | Original gate cannot resume against changed source revision |
|
||||
| context isolation | Class/function selectors reject ambiguity and ignore fenced headings |
|
||||
| concurrent partial | Failed/uncertain child never discards successful siblings |
|
||||
| unknown write | Neither retry nor recovered child duplicates an unconfirmed effect |
|
||||
| long-run cancellation | Worker/child task termination preserves usable artifacts and receipts |
|
||||
| compatibility | Existing `agent.step/plan/run` and workbooks remain callable |
|
||||
| model evaluation | Tokens/decision, semantic validity, end-to-end completion, recovery overhead |
|
||||
|
||||
Do not merge the branch as a completed runtime refactor until the relevant
|
||||
runtime gates, including crash injection and multi-worker concurrency, pass.
|
||||
|
||||
|
||||
## Plugin-only workflow (November 18 revision)
|
||||
|
||||
The Agent ABI plugin implements
|
||||
`agent_workflow_open/next/inspect/list/commit/cancel` plus the failed-only
|
||||
retry primitives. The small `ext/ai/workflow.mq.md` library wraps these
|
||||
primitives and provides `tick` to execute exactly one safe decision or document
|
||||
task per call. `inspect` and `list` are strictly read-only: they report progress
|
||||
or discover checkpoints without advancing a cursor or running a step.
|
||||
Source definitions have only five step kinds: `model`, `input`, `skill`,
|
||||
`parallel` and `return`. Model text is verified against declared options.
|
||||
`input` intentionally returns a waiting status; the UI supplies an answer
|
||||
through `commit` on a later invocation. There is no interpreter thread to
|
||||
hold and no need for a separate qdagent orchestration server.
|
||||
|
||||
The checkpoint records the source revision, caller-provided session and
|
||||
principal scope, next step index and the completed outputs. The same step
|
||||
cannot be silently committed twice. Mixed child outcomes preserve completed
|
||||
siblings in the checkpoint and **block** further automatic execution until
|
||||
the unknown/failed child operations are reconciled.
|
||||
|
||||
The state engine does not execute arbitrary unregistered tools directly:
|
||||
`tick` delegates to existing Marqdo ABI-backed SKILL/subtask functions.
|
||||
This is an implementation of **durable step-state recovery**, not a claim
|
||||
of transparent recovery for a suspended foreign function or native call.
|
||||
It provides the practical workflow needed for short qdagent SKILLs without
|
||||
altering the Marqdo interpreter.
|
||||
|
||||
### Security/reliability boundary still required for production
|
||||
|
||||
- The host must attest source digest, principal, session, permissions and
|
||||
registry, rather than accepting values copied from an LLM response.
|
||||
- Effectful child tools must use the existing EffectLedger and external
|
||||
receipt reconciliation; no automatic re-dispatch after an uncertain write.
|
||||
- Cancelling a workflow checkpoint does not automatically cancel previously
|
||||
spawned external children; the supervisor must propagate cancellation.
|
||||
- The current task runner is step-atomic, not a durable parallel child lease
|
||||
scheduler. A future plugin-only child manifest may use the host's existing
|
||||
`runtime` query API, but must not bypass process.exec or file-root grants.
|
||||
- Cross-process locks need a lease/owner-aware stale-lock recovery path;
|
||||
a stale lock currently fails closed and requires operator review.
|
||||
@@ -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 <generated-certificate> --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(可验证知识编译器)**:
|
||||
|
||||
> 能证明的知识生成可复用的形式证明;不能证明的知识保留明确证据与假设;所有知识均可统一寻址、依赖追踪、组合与执行,永不把未证明的内容伪装成已证明。
|
||||
|
||||
证明的是**明确作用域中的性质**,可信性依靠**证据分级、语义对应、来源追踪与受控执行**共同建立。这个目标可验收、可维护,也适合智能体与量子科研应用的发展方向。
|
||||
+575
@@ -0,0 +1,575 @@
|
||||
我会在后续继续完成开发,接下来我比较关心marqdo的知识编译的问题,你认为我将marqdo的函数内的语句成为锚点,或者说带标记的内容都成为锚点,方便使用[]()引用,成为知识编译的一种可行吗?
|
||||
|
||||
**我认为完全可行,而且这可能是 Marqdo 实现“知识编译”最有价值的方向之一。**
|
||||
|
||||
但我建议对你的设想做一个关键调整:
|
||||
|
||||
> **所有可执行语句都成为编译器内部可定位的节点;所有具有明确标记的内容,都可以提升为稳定、可引用的知识锚点。**
|
||||
>
|
||||
> 锚点不仅用于跳转,还应该具备语义身份、依赖关系、执行能力、版本和验证状态。
|
||||
|
||||
这样,Marqdo 的函数就不再是一个只能整体调用的黑盒,而是一组能够逐层寻址、复用、验证和追溯的知识节点。
|
||||
|
||||
## **一、你的设想实际上已经有实现基础**
|
||||
|
||||
我重新查看了 Marqdo `main` 分支的代码,发现你的想法与仓库已有设计高度一致,并不需要从零开始。
|
||||
|
||||
在 [可执行知识系统设计](https://github.com/cflmy/marqdo/blob/main/doc/design/executable-knowledge-system.md?utm_source=chatgpt.com) 中,你已经提出:
|
||||
|
||||
- `#`:知识命名空间、类或知识实体。
|
||||
- `##`:具备参数和返回契约的可复用函数。
|
||||
- `[]()`:为函数内部的知识步骤命名,并保留原有执行语义。
|
||||
- 编译器将命名步骤转化为 `KnowledgeStep`,关联依赖、类型、来源和效果。
|
||||
|
||||
更重要的是,这不只是文档构想。目前 `src/sema/ir.rs` 已经实现了 `KnowledgeRef`、`KnowledgeStep` 和 `collect_named_steps`,并且能够识别部分遮蔽表达式、函数调用、循环和正文知识引用。
|
||||
|
||||
不过,现在的内部步骤 ID 采用类似 `#step-1`、`#step-2` 的序号形式。这种身份适合单次编译,却不适合长期知识引用:在函数前面插入一条新步骤,就可能改变后面所有步骤的编号。
|
||||
|
||||
因此,我认为下一阶段的重点不是“再增加一种锚点语法”,而是:
|
||||
|
||||
**将已有的 KnowledgeStep 从编译期记录,升级为具备稳定身份的知识制品。**
|
||||
|
||||
## **二、建议采用“两级锚点体系”**
|
||||
|
||||
这比“把每一条语句都暴露为知识”更合理。
|
||||
|
||||
| 层级 | 生成规则 | 作用 |
|
||||
| ------ | -------------------------- | ------------------ |
|
||||
| 内部锚点 | 所有可执行 AST 语句自动生成 | 调试、数据流、执行追踪、增量编译 |
|
||||
| 公共知识锚点 | `#`、`##`、带标记的表达式、显式标记的知识内容 | 跨函数引用、搜索、依赖分析、知识复用 |
|
||||
|
||||
例如:
|
||||
|
||||
```
|
||||
|
||||
# 订单定价
|
||||
|
||||
## 计算税额
|
||||
|
||||
根据订单地区查询税率,再计算应缴税额。
|
||||
|
||||
**税率 = [查询适用税率](税率库.查询(地区))**
|
||||
|
||||
**税额 = [计算应缴税额](金额 * 税率)**
|
||||
|
||||
*税额*
|
||||
|
||||
```
|
||||
|
||||
编译器可以从这段普通 Marqdo 文档中建立以下结构:
|
||||
|
||||
**订单定价**
|
||||
|
||||
Class · 知识命名空间
|
||||
|
||||
**计算税额**
|
||||
|
||||
Function · 公开可调用知识单元
|
||||
|
||||
**查询适用税率**
|
||||
|
||||
Observe / Reuse
|
||||
|
||||
**计算应缴税额**
|
||||
|
||||
Derive
|
||||
|
||||
数据依赖:税率 → 税额
|
||||
|
||||
**返回税额**
|
||||
|
||||
Return · 函数结果
|
||||
|
||||
在这个结构中,两个标记步骤各有自己的地址,并且可以独立被查询、检查来源、进行影响分析。
|
||||
|
||||
这和普通代码索引有根本区别:它不仅知道“这个函数在哪里”,还知道**函数为什么得到这个结果,以及结果依赖哪些知识**。
|
||||
|
||||
## **三、最关键的语义区分:可引用不等于可执行**
|
||||
|
||||
我认为这里必须制定严格的语义规范。
|
||||
|
||||
假设一个函数内部存在名为“查询适用税率”的锚点。
|
||||
|
||||
那么,其他文档引用它时,实际上存在三种不同需求:
|
||||
|
||||
| 操作 | 期望行为 |
|
||||
| ---- | --------------------- |
|
||||
| 引用知识 | 找到该步骤,读取说明、实现和出处 |
|
||||
| 获取结果 | 在已知输入和执行环境中取得该步骤的计算结果 |
|
||||
| 复用执行 | 重新执行该步骤,产生新的计算结果 |
|
||||
|
||||
**不能因为一个锚点存在,就允许它在任何地方被直接执行。**
|
||||
|
||||
例如,函数内部的“计算应缴税额”依赖局部变量 `金额` 和 `税率`。假如其他函数直接引用这个步骤,编译器必须确认它需要哪些输入。
|
||||
|
||||
有两种合理的处理方式:
|
||||
|
||||
- 默认只允许引用它的定义、来源和契约。
|
||||
- 需要独立执行时,必须拥有完整输入绑定;否则将它提取为独立 `##` 函数。
|
||||
|
||||
后续可以考虑由编译器自动将满足纯度、闭包与输入条件的知识步骤提升为可调用能力。但这应是第二阶段,不能在最初就隐式执行任何锚点。
|
||||
|
||||
### **不必重新设计 **`[]()`** 的基本语法**
|
||||
|
||||
可以继续保留现有语义:
|
||||
|
||||
```
|
||||
**税额 = [计算应缴税额](金额 * 税率)**
|
||||
```
|
||||
|
||||
这里 `[]` 提供知识描述,`()` 保留表达式的执行含义。
|
||||
|
||||
另外,知识定位可以使用编译后的稳定地址,例如以下**拟议形式**:
|
||||
|
||||
```
|
||||
[查看税率依据](mq://pricing/订单定价/计算税额#查询适用税率)
|
||||
```
|
||||
|
||||
这应当被解释为知识引用,而不是自动重新执行“查询适用税率”。这里的 `mq://` 是建议的地址表示,不是说当前版本已经支持这样的写法。
|
||||
|
||||
我建议将 `KnowledgeRef` 按所在上下文分为:
|
||||
|
||||
- 正文:解析目标和展示证据,不产生副作用。
|
||||
- 可执行表达式:按原有求值语义执行,并附带引用元数据。
|
||||
- 工具或智能体调用:额外要求可调用契约、输入闭合与权限验证。
|
||||
|
||||
这样 `[]()` 就能成为统一引用形式,同时不破坏现有 Markdown 的可读性。
|
||||
|
||||
## **四、怎样让锚点稳定**
|
||||
|
||||
这是整个方案技术上最难、也最重要的地方。
|
||||
|
||||
**知识锚点不能用行号或内容哈希直接作为永久身份。**
|
||||
|
||||
因为代码修改时:
|
||||
|
||||
- 插入语句会改变行号。
|
||||
- 修改公式会改变哈希,但可能仍是同一个知识概念。
|
||||
- 修改描述名称不一定意味着知识实体改变。
|
||||
- 两个函数可能有相同的步骤名称。
|
||||
|
||||
因此,建议将三个概念拆开:
|
||||
|
||||
| 概念 | 意义 | 变化规则 |
|
||||
| ---------------- | --------- | --------- |
|
||||
| `AnchorId` | 知识单元的稳定身份 | 尽量跨版本保持 |
|
||||
| `ContentDigest` | 当前定义与实现 | 实现发生变化就更新 |
|
||||
| `EvidenceDigest` | 来源与验证证据 | 证据变化时更新 |
|
||||
|
||||
对于自动生成的锚点,可以先根据模块身份、所属函数、局部名称和结构位置确定候选身份,再通过上一版编译产物中的映射记录保持身份连续。
|
||||
|
||||
对于需要长期跨文档引用的公共知识锚点,可以允许显式稳定 ID,或者由编译器自动登记到知识索引中。**显式 ID 不必强制写在每个 **`[]()`** 中**,这样才能保持 Marqdo 的简洁性。
|
||||
|
||||
如果两个同级锚点都叫“查询适用税率”,编译器必须报告歧义,要求进一步限定,不能按出现顺序选择。
|
||||
|
||||
## **五、知识编译的最终产物应该是什么**
|
||||
|
||||
我认为一个知识锚点至少需要这些字段:
|
||||
|
||||
```
|
||||
|
||||
{
|
||||
"anchor_id": "pricing.tax.lookup",
|
||||
"owner": "订单定价.计算税额",
|
||||
"label": "查询适用税率",
|
||||
"kind": "observe",
|
||||
"inputs": ["地区"],
|
||||
"outputs": ["税率"],
|
||||
"dependencies": ["税率库.查询"],
|
||||
"effects": ["read"],
|
||||
"source_span": {
|
||||
"file": "pricing.mq.md",
|
||||
"line": 8
|
||||
},
|
||||
"content_digest": "...",
|
||||
"evidence": [],
|
||||
"verification": {
|
||||
"resolved": true,
|
||||
"tested": false,
|
||||
"source_verified": false
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
这是一份拟议的数据结构,`anchor_id` 仅为示例。
|
||||
|
||||
这里还有一项值得强调的区别:**知识可以编译成功,但并不代表知识在事实上正确。**
|
||||
|
||||
例如读取“某地区税率”,编译器可以验证依赖、参数、数据类型、调用目标,却无法仅凭这些信息证明外部税率数据仍然有效。
|
||||
|
||||
所以应当把编译状态、测试状态、来源验证状态和领域正确性分别记录,而不能用一个 `verified=true` 概括所有问题。
|
||||
|
||||
### **推荐的编译流水线**
|
||||
|
||||
1\. Parse
|
||||
|
||||
读取 Markdown 与 Marqdo AST
|
||||
|
||||
2\. Anchor
|
||||
|
||||
为语句与标记内容建立地址和身份
|
||||
|
||||
3\. Resolve
|
||||
|
||||
绑定函数、变量、知识引用和依赖
|
||||
|
||||
4\. Verify
|
||||
|
||||
检查类型、契约、权限、来源和版本
|
||||
|
||||
5\. Emit
|
||||
|
||||
生成知识图、锚点索引、引用锁与执行制品
|
||||
|
||||
这基本可以落在当前 `src/sema/` 和 `src/knowledge/` 的基础上,不需要开发第二套语言执行器。特别是现有 `SemanticProject` 已能导出 `steps.json`、`refs.json` 和 `artifacts`;真正需要扩展的是步骤的稳定身份、数据依赖、引用绑定以及验证信息。
|
||||
|
||||
## **六、我建议下一步怎么实现**
|
||||
|
||||
优先做三个阶段,而不是一下将所有 Markdown 内容变成公开知识。
|
||||
|
||||
| 阶段 | 主要工作 | 验收 |
|
||||
| ------- | ---------------------------------------- | ------------------ |
|
||||
| M1:锚点身份 | 扩展 `KnowledgeStep`,建立稳定 `AnchorId` 和增量映射 | 插入其他语句后,原引用不漂移 |
|
||||
| M2:锚点引用 | 扩展 `KnowledgeRef` 和语义解析,支持跨函数、跨文档的知识定位 | 能解析、检测歧义、建立反向依赖 |
|
||||
| M3:知识制品 | 生成可查询的知识图、版本锁、验证与影响分析 | 改一条规则,可定位受影响的结果与叙述 |
|
||||
|
||||
之后再增加局部知识步骤的独立执行、缓存、自动提取为函数,以及智能体按需发现知识的能力。
|
||||
|
||||
## **七、这对 Marqdo 的真正价值**
|
||||
|
||||
我觉得这一方向比单纯强调“Markdown 可以执行”更有研究价值。
|
||||
|
||||
传统函数提供的是函数级抽象。你现在提出的机制则能够把抽象进一步下沉:
|
||||
|
||||
**文档 → 类 → 函数 → 知识步骤 → 依赖与证据。**
|
||||
|
||||
当智能体发现某个已有知识满足任务需求时,不需要再次生成代码,也不需要复制一段函数实现。它能够先定位知识节点,查询其契约与依据,再决定是引用现有结果、调用已有函数,还是创建新的知识。
|
||||
|
||||
但需要避免一个研究上的陷阱:**把语句赋予 ID 本身,不足以构成有说服力的知识编译创新。** 它仍可能被认为只是代码索引或细粒度程序分析。
|
||||
|
||||
真正值得验证的主张是:
|
||||
|
||||
> **Marqdo 能否把自然语言标记与可执行语义编译为统一、稳定、可验证的知识节点,并在知识发生改变时,自动维护其引用、依赖和可信状态?**
|
||||
|
||||
如果能够证明这件事,就形成了一条从可读 Markdown 到可执行知识库的清晰技术路径。
|
||||
|
||||
因此,我最推荐你的方案是:**函数内所有语句可定位,带标记的内容可公开引用,经过契约验证的知识节点才可独立复用执行。**
|
||||
|
||||
这比让所有语句无差别地成为公共锚点更严谨,也更符合 Marqdo“代码即文档,文档即知识库,知识即可执行”的设计理念。
|
||||
|
||||
现在的marqdo更新到了2.8.0,我觉得自动证明和上面的知识编译有关系,你怎么看,可以给我什么建议?
|
||||
|
||||
我认为 **Marqdo 2.8.0 的自动证明,与我们此前讨论的知识锚点和知识编译,实际上是同一技术体系中缺失的两块拼图**。
|
||||
|
||||
而且在重新阅读 2.8.0 的实现之后,我认为可以提出比“把代码变成知识图,再给函数附加证明”更进一步的目标:
|
||||
|
||||
> **将 **`.mq.md`** 编译为可寻址、可执行、可组合,并携带机器可核验证据的知识制品。**
|
||||
|
||||
这与 Marqdo 原来的“代码即文档,文档即知识库,知识即可执行”并不矛盾,而是让“知识”拥有了可以接受形式化检查的语义。
|
||||
|
||||
不过,我不建议把它直接表述为“Marqdo 自动证明知识正确”。当前 2.8.0 证明的是限定语义模型下的程序性质,而不是自然语言知识的全部真实性。
|
||||
|
||||
## **一、2.8.0 已经完成了哪些关键基础**
|
||||
|
||||
我检查了 [2.8.0 发布说明](https://github.com/cflmy/marqdo/blob/main/doc/releases/v2.8.0.md?utm_source=chatgpt.com)、`src/prove/`、`src/sema/ir.rs` 和相关测试。
|
||||
|
||||
| 能力 | 2.8.0 的实际情况 | 与知识编译的关系 |
|
||||
| ---- | ---------------------------------------------- | ----------------- |
|
||||
| 语义编译 | 已有 SemanticArtifact、KnowledgeRef、KnowledgeStep | 知识的身份与结构 |
|
||||
| 自动证明 | `marqdo prove` 将定理表及函数降级为 Lean 4 | 知识的形式化约束 |
|
||||
| 离线判定 | F1–F5 符号执行;`checked` 不等于 `proved` | 快速、低成本检查 |
|
||||
| 证明证书 | 记录证明状态、源码与工具链哈希 | 知识的可核验证据 |
|
||||
| 反例 | 部分假命题能得到路径或区间见证 | 知识修复依据 |
|
||||
| 组合证明 | 同模块简单纯函数有限内联 | 已有基础,但尚未形成模块化证明体系 |
|
||||
|
||||
当前最值得注意的是:**语义编译器与证明编译器还没有围绕知识锚点形成完整的统一体系。**
|
||||
|
||||
知识编译能够生成步骤和依赖,证明编译能够生成定理和证书,但尚不能自然地表达:
|
||||
|
||||
“这个知识步骤依赖哪些已经证明的知识?证明依赖的知识修改后,哪些证书需要失效?调用者能否直接复用被调用知识的证明,而不必重新展开整个函数?”
|
||||
|
||||
我认为,这就是 Marqdo 2.9 最值得解决的问题。
|
||||
|
||||
## **二、从知识锚点到可证明知识图**
|
||||
|
||||
我建议让知识编译和证明编译共享同一套稳定的语义身份。
|
||||
|
||||
**Marqdo **`.mq.md`
|
||||
|
||||
叙述、类、函数、`[]()`、定理表
|
||||
|
||||
**统一知识语义 IR**
|
||||
|
||||
稳定身份 · 知识锚点 · 数据依赖 · 效果 · 契约
|
||||
|
||||
**知识编译**
|
||||
|
||||
知识图、引用解析、影响分析、执行绑定
|
||||
|
||||
**证明编译**
|
||||
|
||||
Proof IR、Lean、反例、证书
|
||||
|
||||
**可验证知识制品**
|
||||
|
||||
Artifact + Contract + Proof Certificate + Dependencies
|
||||
|
||||
关键变化不是简单地增加几条图上的 `proved_by` 边,而是让编译器能够基于同一份语义结构,分别生成执行内容、知识引用和证明义务。
|
||||
|
||||
我建议采用这样的分工:
|
||||
|
||||
- `#`、`##` 为知识提供作用域和可调用边界。
|
||||
- `[]()` 为内部知识步骤提供可读名称和可寻址身份。
|
||||
- 现有契约表定义输入、输出及其他约束。
|
||||
- 现有定理表表达需要成立的命题。
|
||||
- `prove` 为满足证明条件的命题生成证书。
|
||||
- 知识编译器关联上述信息,生成统一知识制品。
|
||||
|
||||
**不需要为知识证明额外发明一套 Markdown 标记。**
|
||||
|
||||
## **三、最值得实现的功能:证明能够沿知识引用传播**
|
||||
|
||||
假设有三个知识单元:
|
||||
|
||||
**A · 查询适用税率**
|
||||
|
||||
契约:根据地区和时间,返回适用税率
|
||||
|
||||
证明:在已声明的数据有效性条件下,返回值满足范围约束
|
||||
|
||||
**B · 计算税额**
|
||||
|
||||
依赖 A,并根据金额和税率进行计算
|
||||
|
||||
证明:假设 A 的契约成立,B 满足自己的计算性质
|
||||
|
||||
**C · 订单结算**
|
||||
|
||||
依赖 B,并生成最终金额
|
||||
|
||||
证明:在 B 的前提与其他结算条件成立时,满足结算约束
|
||||
|
||||
现在修改 A 的内部实现。
|
||||
|
||||
传统方式下,B、C 可能要重新进行大量测试,或者依赖开发者人工检查。
|
||||
|
||||
我希望 Marqdo 能够做到:
|
||||
|
||||
1. 重新编译 A,确认其契约与实现发生了哪些变化。
|
||||
2. 如果 A 的实现改变,但原契约仍被新证明支持,B 可以在依赖和证明上下文未变时继续复用已有证明。
|
||||
3. 如果 A 的契约不再得到支持,则 B 的相关证明变成 `stale` 或 `unverified`,并进一步影响 C。
|
||||
4. 只对受影响的证明义务重新运行 Lean,而不是重新证明所有知识。
|
||||
|
||||
**这就让知识图成为证明依赖图,同时使证明能够参与增量知识编译。**
|
||||
|
||||
它与 2.8.0 当前的证书缓存有明显区别。当前缓存主要根据源码、Proof IR、库和工具链版本等生成复合键;未来应该进一步细化为:
|
||||
|
||||
- 某个知识锚点的实现指纹。
|
||||
- 该锚点的公开契约。
|
||||
- 证明依赖的其他知识及其契约指纹。
|
||||
- 使用的假设和证明规则。
|
||||
- Lean 内核接受的证明及其环境身份。
|
||||
|
||||
这样才能精确控制哪些结果可以复用。
|
||||
|
||||
## **四、证明不一定只属于函数,也可以属于知识步骤**
|
||||
|
||||
这是我认为你原先“所有带标记的内容成为锚点”构想最有价值的延伸。
|
||||
|
||||
2.8.0 的定理表目前属于函数级声明,位于函数首条可执行语句之前。这很合理,也应该保留为默认的公开契约。
|
||||
|
||||
例如:
|
||||
|
||||
```
|
||||
# 审批
|
||||
|
||||
## 审批订单
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||||
|
||||
1. `金额` > 10000
|
||||
**回执 = [提交人工审核](人工审核(金额=`金额`))**
|
||||
2. *
|
||||
**回执 = [小额自动处理](自动处理(金额=`金额`))**
|
||||
|
||||
*回执*
|
||||
```
|
||||
|
||||
这个示例主要展示已有的定理表与遮蔽表达式如何结合,具体调用仍需要项目中的函数定义和类型契约。
|
||||
|
||||
现在证明的对象主要是 `## 审批订单` 的行为性质。
|
||||
|
||||
我认为将来可以增加一步:
|
||||
|
||||
**把函数证明所涉及的知识步骤,映射到相应的锚点与依赖边。**
|
||||
|
||||
例如,“大额必经人工”定理可以关联到“提交人工审核”知识锚点,同时记录证明是在什么输入条件和语义模型下成立的。
|
||||
|
||||
但是这里必须非常严格:
|
||||
|
||||
- 证明整个函数满足某个性质,不意味着函数内部每个步骤都被单独证明正确。
|
||||
- `[提交人工审核]` 这个自然语言标签,不能自动当成形式化命题。
|
||||
- 证明轨迹包含“人工审核”,也不能证明外部审核服务真的完成了审核。
|
||||
|
||||
因此,**先做函数级证明向锚点的精确关联,再考虑锚点级局部证明**,会更稳妥。
|
||||
|
||||
## **五、建议的统一知识制品结构**
|
||||
|
||||
我建议在现有 `SemanticArtifact`、`KnowledgeStep`、`KnowledgeRef` 之上增加证明关联层,而不是让 `src/prove` 生成第二套互不相认的知识身份。
|
||||
|
||||
下面是建议结构,并非 2.8.0 已有的完整 Schema。
|
||||
|
||||
```
|
||||
|
||||
{
|
||||
"anchor_id": "pricing.tax.calculate",
|
||||
"symbol_id": "mq://project/pricing/function/calculate",
|
||||
"kind": "derive",
|
||||
"contract": {
|
||||
"inputs": ["amount", "rate"],
|
||||
"outputs": ["tax"]
|
||||
},
|
||||
"dependencies": [
|
||||
"pricing.tax.lookup"
|
||||
],
|
||||
"verification": {
|
||||
"parse": "valid",
|
||||
"resolve": "valid",
|
||||
"proof": {
|
||||
"status": "proved",
|
||||
"claims": ["tax_formula"],
|
||||
"certificate": "sha256:...",
|
||||
"assumptions": [],
|
||||
"scope": "function"
|
||||
},
|
||||
"source": "unverified"
|
||||
},
|
||||
"hashes": {
|
||||
"interface": "...",
|
||||
"implementation": "...",
|
||||
"proof_dependencies": "..."
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
一个很重要的设计是:`proof`** 不应该只是一个全局布尔值**。
|
||||
|
||||
不同知识锚点可能有不同性质:某个命题已经证明,另一个命题尚未证明,还有一个证明依赖不可靠的外部假设。
|
||||
|
||||
因此最小证明单元应当是:
|
||||
|
||||
`(AnchorId, ClaimId, Assumptions, SemanticDigest, ProofCertificate)`
|
||||
|
||||
而不是:
|
||||
|
||||
`AnchorId → proved: true`
|
||||
|
||||
这样调用者才能明确知道自己究竟复用了什么保证。
|
||||
|
||||
## **六、2.9 最应该优先实现的四项工作**
|
||||
|
||||
| 优先级 | 工作 | 为什么重要 |
|
||||
| --- | ----------------------------------------- | -------------- |
|
||||
| P0 | 统一 `SymbolId`、`AnchorId`、定理身份 | 解决知识与证明的长期稳定绑定 |
|
||||
| P1 | 将证明证书关联到 SemanticArtifact / KnowledgeStep | 建立知识与证明的直接关系 |
|
||||
| P2 | 跨模块 assume-guarantee 证明组合 | 使证明可以跨知识引用传播 |
|
||||
| P3 | 证明依赖图与增量失效分析 | 使大型知识库不必每次全量重证 |
|
||||
|
||||
我尤其强调 P2。
|
||||
|
||||
因为从 2.8.0 发布说明可以看到,**跨模块调用目前仍视为不透明操作,而 assume-guarantee 后置条件复用明确延期到 2.9**。
|
||||
|
||||
这恰好是知识编译与自动证明结合的突破点。
|
||||
|
||||
假设 Marqdo 有两个函数:
|
||||
|
||||
- `A` 已经证明后置条件 \\(Q_A\\)。
|
||||
- `B` 调用 `A`,希望证明自己的后置条件 \\(Q_B\\)。
|
||||
|
||||
那么 B 不必知道 A 的完整实现,只需要建立调用点的输入满足 A 前置条件,并利用 A 已经证明的后置条件完成自己的证明。
|
||||
|
||||
这正是契约组合推理的基本思路。
|
||||
|
||||
但证明必须明确依赖:A 的证书、其适用条件、A 与 B 的语义模型是否一致,以及任何外部假设。不能把未经验证的函数描述当作公理。
|
||||
|
||||
### **还需要优先修复两个证明语义边界**
|
||||
|
||||
2.8.0 有两项已记录的差异,我建议不要在强化知识证明时忽略:
|
||||
|
||||
- **i64 溢出**:解释器按有界整数处理并可能报错,而当前 Lean 模型使用无界 `Int`。
|
||||
- **除零/模零**:解释器产生运行时错误,Lean 底座目前存在返回 `.int 0` 的建模差异。
|
||||
|
||||
这意味着证明证书必须记录实际覆盖的数值范围和语义前提。未修复或没有证明等价的部分,不能被上层知识引用当成无条件可信的计算保证。
|
||||
|
||||
## **七、与智能体结合后,会产生什么变化?**
|
||||
|
||||
这部分可能最符合你未来做科研智能体的方向。
|
||||
|
||||
过去智能体调用知识库时,主要依据名字、描述、检索相似度来选择已有能力。
|
||||
|
||||
未来可以让它先查询知识图,获得知识制品的:
|
||||
|
||||
- 可执行入口与输入契约。
|
||||
- 形式化证明过的性质。
|
||||
- 来源与版本。
|
||||
- 未证明的假设和适用边界。
|
||||
- 是否受到近期源码或依赖修改的影响。
|
||||
|
||||
于是智能体不再只是“找到一个看起来相关的 SKILL”,而是可以选择一个**在当前任务条件下,拥有足够验证依据的知识能力**。
|
||||
|
||||
例如,量子科研智能体在寻找电路优化方法时,可以优先寻找具有等价性证明的电路变换,而不是每次重新生成并尝试未经验证的优化。
|
||||
|
||||
当然,这需要专门定义量子电路语义、等价关系和可信的验证过程;现有 2.8.0 的控制流证明还不能直接证明任意量子电路等价。
|
||||
|
||||
## **八、研究上怎样证明这条路线有价值?**
|
||||
|
||||
我建议至少设计三个实验,不要只展示“Lean 可以证明 Marqdo”。
|
||||
|
||||
**实验 E1:知识修改与证明增量失效**
|
||||
|
||||
在拥有大量相互引用的知识函数的项目中,修改其中某个函数,对比全量重新证明和基于锚点依赖的增量重新证明。
|
||||
|
||||
指标:重新证明的命题数、证明耗时、失效检测准确率,以及错误复用证书的次数(目标为零)。
|
||||
|
||||
**实验 E2:跨函数与跨文档证明复用**
|
||||
|
||||
与 2.8.0 通过内联或不透明调用处理函数的方案相比,验证契约组合是否显著提升可证覆盖率。
|
||||
|
||||
指标:proved 比例、unverified/rejected 比例、证明时间、需要人工声明的假设数量。
|
||||
|
||||
**实验 E3:证明感知的智能体知识复用**
|
||||
|
||||
让相同模型完成知识检索、函数复用与程序修改任务,对比普通语义检索、只使用知识图、知识图加证明证书三种方案。
|
||||
|
||||
指标:错误知识复用率、任务成功率、人工审核量、输入 Token 和总执行成本。
|
||||
|
||||
这三个实验分别验证“知识编译”、“证明组合”和“智能体使用价值”,能够避免把三个研究主张混成一个难以检验的宏大叙事。
|
||||
|
||||
## **我的总体判断**
|
||||
|
||||
如果按照技术潜力排序,我会这样看:
|
||||
|
||||
| 方向 | 评价 |
|
||||
| ----------------- | ---------------- |
|
||||
| 给所有语句生成锚点 | 必要的基础设施,但单独创新性有限 |
|
||||
| 让 `[]()` 成为稳定知识引用 | 很有价值,能形成统一知识身份 |
|
||||
| 让知识锚点携带可验证契约和证书 | 更有研究深度 |
|
||||
| 让证明沿知识依赖传播并支持增量复用 | 我认为是最值得集中攻关的核心 |
|
||||
|
||||
而且现在你拥有了一个很好的技术条件:**2.8.0 已经实现了真正的 Lean 证明路径,不再只是设计中的设想。**
|
||||
|
||||
我建议将 Marqdo 2.9 的主线收敛成:
|
||||
|
||||
**Proof-Carrying Executable Knowledge(携带证明的可执行知识)**
|
||||
|
||||
但需要注意,Proof-Carrying Code、契约式程序验证和模块化证明本身都是已有研究。Marqdo 真正需要体现的区别,是它如何把 Markdown 原生描述、稳定知识锚点、可执行语义、证明义务与增量知识依赖统一编译为同一个制品体系,而非仅仅给代码加上证明。
|
||||
|
||||
一句话总结我的建议:
|
||||
|
||||
**2.8.0 实现了“文档中的程序可以被证明”;2.9 应当实现“证明可以成为知识的一部分,并随着知识被引用、组合、验证和复用”。**
|
||||
|
||||
我认为,这比单纯继续扩展 `marqdo prove` 可支持的表达式范围,更符合 Marqdo 的长期方向。
|
||||
@@ -0,0 +1,64 @@
|
||||
# Ext pack v2.8.1 发布说明 · Release Notes(AI native flow)
|
||||
|
||||
## 1. 一句话
|
||||
|
||||
独立拓展包 **2.8.1**(CLI 仍为 **2.8.0**):`ext/ai` 交付插件侧持久化工作流——显式
|
||||
`open/next/commit/cancel`、有界模型选择、作用域上下文、只读失败恢复,以及
|
||||
`inspect/list` 与可隔离的 `resume_dir`。Windows `extension-release` 使用原生
|
||||
`path.join` 根路径与 `C:\Windows\System32\tar.exe`(bsdtar)打包。不改解释器栈
|
||||
挂起语义,也不宣称外部写的 exactly-once。
|
||||
|
||||
Independent extension pack **2.8.1** (CLI remains **2.8.0**): `ext/ai` ships a
|
||||
plugin-only durable workflow — explicit `open/next/commit/cancel`, bounded model
|
||||
choice, scoped context packing, failed-only read-only recovery, plus
|
||||
`inspect/list` and isolatable `resume_dir`. Windows `extension-release` packs
|
||||
with native `path.join` roots and `C:\Windows\System32\tar.exe` (bsdtar). No
|
||||
interpreter-stack suspension and no exactly-once external-write claim.
|
||||
|
||||
## 2. 亮点(Highlights)
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 持久步骤机 | `plugins/agent` `workflow`:`open/next/commit/cancel/retry_*`,CheckpointV2,逐步提交边界 |
|
||||
| 作者面 | `ext/ai/workflow` · `flow` · `context` · `recovery`;`tick` 单步执行,等待输入不阻塞解释器线程 |
|
||||
| 选择解析 | 精确 / 编号 / 标签 / 短中英句 / JSON 信封;歧义与未知路径失败关闭 |
|
||||
| 作用域上下文 | Markdown 感知的 file/class/function 摘录;歧义拒绝;不把整库 import 塞进提示 |
|
||||
| 安全并行恢复 | 保留成功兄弟结果;仅重试已分类为只读的失败子任务;写/未知效应不自动派发 |
|
||||
| 可观测性 | `inspect`/`list` 只读进度;测试与调用方可传入 host-relative `resume_dir` |
|
||||
| Windows CI | engineering root 用 `path.join`;ZIP 用 `System32\tar.exe --format=zip` |
|
||||
|
||||
设计契约:[native-agent-flow-v3.md](../design/native-agent-flow-v3.md)。
|
||||
|
||||
## 3. 安装(Install)
|
||||
|
||||
```bash
|
||||
marqdo ext add agent # CDN / Releases → 2.8.1
|
||||
# 或:MARQDO_EXT_VERSION=2.8.1 marqdo ext add agent
|
||||
marqdo ext add llm
|
||||
```
|
||||
|
||||
产物:`marqdo-2.8.1-ext.zip` 与双平台 native ZIP(含 agent / llm 等既有原生库)。
|
||||
|
||||
## 4. 验证(Validation)
|
||||
|
||||
```bash
|
||||
cargo test -p marqdo_plugin_agent --locked
|
||||
cargo run --locked -- check ext/ai/flow.mq.md
|
||||
cargo run --locked -- check ext/ai/context.mq.md
|
||||
cargo run --locked -- check ext/ai/recovery.mq.md
|
||||
cargo run --locked -- check ext/ai/workflow.mq.md
|
||||
cargo run --locked -- run tests/ext/ai-native-flow.mq.md
|
||||
cargo run --locked -- run tests/ext/ai-native-workflow.mq.md
|
||||
```
|
||||
|
||||
CI:`.github/workflows/native-ai-flow.yml` 与 `extension-release.yml`(`ext-v2.8.1`)。
|
||||
|
||||
## 5. 已知限制(Known limitations)
|
||||
|
||||
- 输入闸门保存的是**步骤边界**,不是任意字节码解释器帧;回复后须显式进入下一 Marqdo 函数。
|
||||
- 作用域选择依赖 Markdown 标题约定,不是编译器已解析的 AST 符号表。
|
||||
- 调用方提供的 principal/session/source revision 须由已认证宿主证明,不能来自模型文本。
|
||||
- 并行复用 `subtask.run_many`;跨进程子任务租约与已在跑外部进程的取消传播仍待专项注入验证。
|
||||
- 实时大模型与目标 1B 本地模型评测仍开放;写效应自动重试仍被拒绝,直至 EffectLedger 对账完成。
|
||||
|
||||
**核心表面 Δ**:无增删——19 个核心构造不变;本包为 Extension / Agent Runtime。
|
||||
@@ -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 <path/to/composition-certificate.json> --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.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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-...` 地址,不要猜测哈希。两个同名标记不共享地址,会被标记为无公共锚点。
|
||||
@@ -0,0 +1,19 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: 可寻址、可验证的知识步骤
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## 计算
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 无外部操作 | 长度(轨迹) = 0 | | auto |
|
||||
|
||||
这里的 [计算知识节点](#@计算结果) 和 [定理声明](#@无外部操作) 都是可解析的知识引用;
|
||||
它不会再次执行运算,也不会自动继承函数的形式化证明。
|
||||
|
||||
**答案 = [计算结果](2 * 3)**
|
||||
|
||||
*答案*
|
||||
Executable → Regular
+1
-1
@@ -1 +1 @@
|
||||
2.7.0
|
||||
2.9.0
|
||||
@@ -0,0 +1,113 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: AI context — short, explicit source scopes
|
||||
description: Pack user input and caller-provided file/class/function excerpts.
|
||||
import:
|
||||
agent: ext/ai/agent.mq.md
|
||||
plugin: lib/plugin.mq.md
|
||||
json: lib/json.mq.md
|
||||
---
|
||||
|
||||
Pass only the documentation that the next model decision needs. The supplied
|
||||
file/class/function snippets are data; they do not execute as Marqdo source.
|
||||
A future compiler-backed selector can supply these arguments from AST spans.
|
||||
This helper does not yet infer class/function scopes automatically.
|
||||
|
||||
## pack
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| user | text | required | Latest user input |
|
||||
| file | text | "" | File-level description excerpt |
|
||||
| class | text | "" | Current class excerpt |
|
||||
| function | text | "" | Current function excerpt |
|
||||
| budget_tokens | number | 2048 | Small-model context budget |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Bounded ContextPackV2 and compaction evidence |
|
||||
|
||||
Use `user`, `file`="", `class`="", `function`="", `budget_tokens`=2048 as the inputs for this operation.
|
||||
|
||||
Keep the latest request and current function first. Low-priority file context
|
||||
may be dropped under pressure; any important constraint must be in a retained
|
||||
field, not in a discardable tool transcript.
|
||||
|
||||
`items` =
|
||||
|
||||
| @ | origin | trust | priority | text | retain |
|
||||
|---|---|---|---|---|---|
|
||||
| 1 | user | user | 0 | `user` | True |
|
||||
| 2 | function | unknown | 1 | `function` | True |
|
||||
| 3 | class | unknown | 2 | `class` | False |
|
||||
| 4 | file | unknown | 3 | `file` | False |
|
||||
|
||||
Return *[Pack the supplied scopes and compact redundant context](agent.context_pack_compact(items=`items`, budget_tokens=`budget_tokens`, goal=`user`))*.
|
||||
|
||||
|
||||
## scope
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| scope | text | "function" | file / class / function / tool |
|
||||
| class | text | None | Class heading for disambiguation |
|
||||
| function | text | None | Function/tool heading |
|
||||
| source | text | None | Source override; otherwise current entry module |
|
||||
| max_chars | number | 1600 | Maximum Unicode characters |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Exact source excerpt, line range, or explicit ambiguity |
|
||||
|
||||
Use `scope`="function", `class`=None, `function`=None, `source`=None, `max_chars`=1600 as the inputs for this operation.
|
||||
|
||||
The native selector respects Markdown headings and ignores fenced-code heading
|
||||
lookalikes. Repeated function names require a class; missing/ambiguous scopes
|
||||
return an error value, never an unrelated or whole-file fallback.
|
||||
|
||||
We retain **p = [Locate native agent plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load native agent plugin](plugin.load(path=`p`))**.
|
||||
2. *
|
||||
Return *[No native parser available](json.parse(text="{\"ok\":false,\"status\":\"unavailable\",\"text\":null}"))*.
|
||||
|
||||
Return *[Project the requested document scope](agent_context_scope(source=`source`, scope=`scope`, class=`class`, function=`function`, max_chars=`max_chars`))*.
|
||||
|
||||
|
||||
## compose
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| user | text | required | Latest user input |
|
||||
| class | text | required | Current class name |
|
||||
| function | text | required | Current function name |
|
||||
| source | text | None | Override current entry source |
|
||||
| budget_tokens | number | 2048 | Small-model context budget |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | ContextPackV2 or an explicit failed selector |
|
||||
|
||||
Use `user`, `class`, `function`, `source`=None, `budget_tokens`=2048 as the inputs for this operation.
|
||||
|
||||
Project file, class and function scopes independently. Refuse ambiguous names
|
||||
rather than silently importing an unrelated class or the entire source. The
|
||||
latest user input stays in the retained portion of the resulting context pack.
|
||||
|
||||
We retain **f = [Select file preface](scope(scope="file", source=`source`, max_chars=500))**.
|
||||
We retain **c = [Select current class](scope(scope="class", class=`class`, source=`source`, max_chars=800))**.
|
||||
We retain **n = [Select current function](scope(scope="function", class=`class`, function=`function`, source=`source`, max_chars=1500))**.
|
||||
We retain **f_ok = [Check file selection](json.get(value=`f`, key="ok"))**.
|
||||
We retain **c_ok = [Check class selection](json.get(value=`c`, key="ok"))**.
|
||||
We retain **n_ok = [Check function selection](json.get(value=`n`, key="ok"))**.
|
||||
1. not `f_ok`
|
||||
Return *f*.
|
||||
2. not `c_ok`
|
||||
Return *c*.
|
||||
3. not `n_ok`
|
||||
Return *n*.
|
||||
4. *
|
||||
We retain **ft = [Read file preface](json.get(value=`f`, key="text"))**.
|
||||
We retain **ct = [Read class explanation](json.get(value=`c`, key="text"))**.
|
||||
We retain **nt = [Read function explanation](json.get(value=`n`, key="text"))**.
|
||||
Return *[Compact only the selected scopes](pack(user=`user`, file=`ft`, class=`ct`, function=`nt`, budget_tokens=`budget_tokens`))*.
|
||||
@@ -0,0 +1,246 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: AI flow — small-model choices and bounded subtasks
|
||||
description: Short model decisions, verified options and concurrent Marqdo documents.
|
||||
import:
|
||||
llm: ext/ai/llm.mq.md
|
||||
json: lib/json.mq.md
|
||||
plugin: lib/plugin.mq.md
|
||||
subtask: lib/subtask.mq.md
|
||||
---
|
||||
|
||||
This is the thin author-facing layer. A model returns a candidate; Marqdo checks
|
||||
it before routing. Invalid choices are not SKILL paths and never execute.
|
||||
Only the requested function and its inputs need to be in the model prompt.
|
||||
|
||||
## parse_choice
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| reply | text | required | Raw model reply, treated as data |
|
||||
| options | list | required | Allowed names, not paths or commands |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | {ok,value,status} or {ok:false,error} |
|
||||
|
||||
Use `reply`, `options` as the inputs for this operation.
|
||||
|
||||
Parsing accepts one exact name, a labeled name, a fenced name or a 1-based
|
||||
index. Ambiguous prose fails closed. Parsing never runs a tool or SKILL.
|
||||
|
||||
We retain **p = [Locate the installed agent plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load the agent plugin](plugin.load(path=`p`))**.
|
||||
2. *
|
||||
Return *[Missing native parser](json.parse(text="{\"ok\":false,\"status\":\"unavailable\",\"value\":null}"))*.
|
||||
|
||||
Return *[Parse and verify the choice](agent_choice_parse(reply=`reply`, options=`options`))*.
|
||||
|
||||
## choose
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| input | text | required | Current user request or local decision |
|
||||
| options | list | required | Small list of registered option names |
|
||||
| model | any | None | Existing provider model identifier |
|
||||
| repair | bool | True | Allow one format-only repair attempt |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Verified choice result, or explicit failure |
|
||||
|
||||
Use `input`, `options`, `model`=None, `repair`=True as the inputs for this operation.
|
||||
|
||||
Only ask for the option name. A failed first parse can receive one short
|
||||
format correction; never silently select the nearest-looking option.
|
||||
|
||||
We retain **opts = [Encode allowed values](json.stringify(value=`options`))**.
|
||||
We retain **prompt = "Choose exactly one of these options. Return its name only, no explanation:\n" + opts + "\nInput:\n" + input**.
|
||||
We retain **m = [Build one model handle](llm.create(model=`model`))**.
|
||||
We retain **turn = [Ask the model once](m.ask(prompt=`prompt`))**.
|
||||
We retain **err = [Check model transport error](json.get(value=`turn`, key="error"))**.
|
||||
1. `err`
|
||||
Return *turn*.
|
||||
2. *
|
||||
We retain **reply = [Read model answer](json.get(value=`turn`, key="text"))**.
|
||||
We retain **parsed = [Validate the model reply](parse_choice(reply=`reply`, options=`options`))**.
|
||||
We retain **ok = [Read validation status](json.get(value=`parsed`, key="ok"))**.
|
||||
1. `ok`
|
||||
Return *parsed*.
|
||||
2. `repair`
|
||||
We retain **fix = "Your answer was not an exact allowed option. Return only ONE option name from:\n" + opts**.
|
||||
We retain **fixed = [Retry the format only once](m.ask(prompt=`fix`))**.
|
||||
We retain **repair_error = [Read transport error](json.get(value=`fixed`, key="error"))**.
|
||||
1. `repair_error`
|
||||
Return *fixed*.
|
||||
2. *
|
||||
We retain **again = [Read corrected answer](json.get(value=`fixed`, key="text"))**.
|
||||
Return *[Validate the repaired reply](parse_choice(reply=`again`, options=`options`))*.
|
||||
3. *
|
||||
Return *parsed*.
|
||||
|
||||
## parallel
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| tasks | list | required | Existing .mq.md file tasks with arguments |
|
||||
| limit | number | 2 | Maximum simultaneously running tasks |
|
||||
| timeout_ms | number | 30000 | Execution timeout in milliseconds |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Succeeded, partial, failed or uncertain child outcomes |
|
||||
|
||||
Use `tasks`, `limit`=2, `timeout_ms`=30000 as the inputs for this operation.
|
||||
|
||||
Reuse the built-in subtask scheduler. Each child document returns via its
|
||||
`# main`, and successful siblings remain visible if another child fails.
|
||||
|
||||
We retain **results = [Run bounded Marqdo document tasks](subtask.run_many(tasks=`tasks`, limit=`limit`, timeout_ms=`timeout_ms`))**.
|
||||
We retain **p = [Locate native agent plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load native agent plugin](plugin.load(path=`p`))**.
|
||||
Return *[Preserve success, failure and uncertain child outcomes](agent_parallel_report(results=`results`))*.
|
||||
2. *
|
||||
Return *[Native result classifier unavailable](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
|
||||
## input
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable step ID |
|
||||
| question | text | required | User-visible question |
|
||||
| options | list | required | User-visible choices |
|
||||
| source_revision | text | required | Pinned Marqdo source revision |
|
||||
| session_id | text | None | Host-attested session |
|
||||
| principal_ref | text | None | Host-attested user scope |
|
||||
| freeform | bool | True | Allow custom user reply |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | waiting_input or previously committed reply |
|
||||
|
||||
Use `id`, `question`, `options`, `source_revision`, `session_id`=None, `principal_ref`=None, `freeform`=True as the inputs for this operation.
|
||||
|
||||
This does not park an interpreter stack. The caller persists a step-boundary
|
||||
checkpoint, displays the question, and on a new turn uses reply to continue.
|
||||
The host, not the LLM, must attest session and principal IDs.
|
||||
|
||||
We retain **p = [Locate native agent plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load native agent plugin](plugin.load(path=`p`))**.
|
||||
2. *
|
||||
Return *[No native gate available](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
Return *[Persist one waiting input gate](agent_input_open(id=`id`, question=`question`, options=`options`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, freeform=`freeform`))*.
|
||||
|
||||
## reply
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Existing waiting step |
|
||||
| reply | text | required | New user response |
|
||||
| source_revision | text | required | Current pinned source revision |
|
||||
| session_id | text | None | Host-attested session |
|
||||
| principal_ref | text | None | Host-attested user scope |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Resolved answer, invalid reply or explicit conflict |
|
||||
|
||||
Use `id`, `reply`, `source_revision`, `session_id`=None, `principal_ref`=None as the inputs for this operation.
|
||||
|
||||
Matching repeated replies are idempotent. A conflicting reply, changed document
|
||||
or changed session fails without executing any SKILL or side effect.
|
||||
|
||||
We retain **p = [Locate native agent plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load native agent plugin](plugin.load(path=`p`))**.
|
||||
2. *
|
||||
Return *[No native gate available](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
Return *[Commit the verified user reply](agent_input_resume(id=`id`, reply=`reply`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`))*.
|
||||
|
||||
|
||||
## enter
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| skill | text | required | Model-selected registered name |
|
||||
| registry | map | required | Trusted name → path mapping |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Subtask result, or blocked unknown skill |
|
||||
|
||||
Use `skill`, `registry` as the inputs for this operation.
|
||||
|
||||
Never execute a raw model-generated path. Resolve a registered skill name to
|
||||
an author-controlled document, then call its `# main` through the normal Marqdo
|
||||
subtask and effect permissions. The caller must provide a trusted registry.
|
||||
|
||||
We retain **path = [Resolve registered SKILL](json.get(value=`registry`, key=`skill`))**.
|
||||
1. not `path`
|
||||
Return *[Unknown skill is blocked](json.parse(text="{\"ok\":false,\"status\":\"unsupported_skill\"}"))*.
|
||||
2. *
|
||||
We retain **task = [Spawn registered Marqdo document](subtask.spawn(path=`path`))**.
|
||||
Return *[Await the subtask result](subtask.wait(id=`task`))*.
|
||||
|
||||
|
||||
## ask
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| prompt | text | required | Short local prompt |
|
||||
| model | any | None | Configured model selection |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | text | Model reply (not yet a verified tool call) |
|
||||
|
||||
Use `prompt`, `model`=None as the inputs for this operation.
|
||||
|
||||
Ask only what the current function needs. The reply remains data until an
|
||||
explicit verifier accepts it. The LLM adapter owns provider configuration.
|
||||
|
||||
Return *[Ask the configured model](llm.ask(prompt=`prompt`, model=`model`))*.
|
||||
|
||||
## start
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| path | text | required | Trusted registered Marqdo document |
|
||||
| args | list | None | Optional child CLI arguments |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | number | Child task handle |
|
||||
|
||||
Use `path`, `args`=None as the inputs for this operation.
|
||||
|
||||
Start an isolated SKILL document asynchronously, after the calling host has
|
||||
validated its path and required process.exec permission. No model-generated
|
||||
raw path is a valid grant.
|
||||
|
||||
Return *[Start one Marqdo document](subtask.spawn(path=`path`, args=`args`))*.
|
||||
|
||||
## wait
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | number | required | Child task handle |
|
||||
| timeout_ms | number | 30000 | Maximum wait time |
|
||||
| cancel | bool | False | Cancel on timeout |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Child result, timeout or cancellation |
|
||||
|
||||
Use `id`, `timeout_ms`=30000, `cancel`=False as the inputs for this operation.
|
||||
|
||||
A successful wait protocol is not proof of a successful child execution:
|
||||
inspect the child exit code before using its result.
|
||||
|
||||
Return *[Wait for the child](subtask.wait_timeout(id=`id`, timeout_ms=`timeout_ms`, cancel=`cancel`))*.
|
||||
+7
-1
@@ -9,7 +9,13 @@ Start here to choose an AI task. [Model calls](llm.mq.md) own prompts, model con
|
||||
stream collection and usage; [provider adapters](llm/index.mq.md) describe OpenAI-compatible
|
||||
and Ollama requests. [Agents](agent.mq.md) own call-site context, the explicit tool registry,
|
||||
policy routing, observations, workbook planning and continuation. [CoW trials](sandbox.mq.md)
|
||||
own isolated file changes and promotion. [Step routing](policies/step-route.mq.md) is readable
|
||||
own isolated file changes and promotion. [Native flow](flow.mq.md) provides short, verified model choices and bounded document
|
||||
concurrency; [workflow](workflow.mq.md) drives a durable forward-only step plan with
|
||||
`inspect`/`list` progress queries and failed-only read recovery; [context](context.mq.md)
|
||||
packs explicit source scopes; [recovery](recovery.mq.md)
|
||||
uses the native error policy and versioned checkpoints. These are lightweight
|
||||
interfaces, not a second agent runtime.
|
||||
[Step routing](policies/step-route.mq.md) is readable
|
||||
policy data, not a second agent language. Chinese users can start at [索引](索引.mq.md).
|
||||
|
||||
Begin with this offline stream example; it does not request credentials, install a plugin or
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: AI recovery — safe defaults for short SKILL functions
|
||||
description: Reuse the native error policy, durable checkpoints and effect ledger.
|
||||
import:
|
||||
agent: ext/ai/agent.mq.md
|
||||
---
|
||||
|
||||
Error handling belongs to Marqdo, not the model's prompt. The native policy
|
||||
never blindly repeats uncertain writes. Every resume must revalidate the
|
||||
current permission and source revision; a saved checkpoint is not authorization.
|
||||
|
||||
## decide
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| error | map | required | Structured AgentErrorV1 |
|
||||
| attempts | number | 0 | Number of attempts already made |
|
||||
| effect_class | text | "read" | Declared tool effect |
|
||||
| cancelled | bool | False | Parent cancellation status |
|
||||
| fingerprint_repeats | number | 0 | Identical failures without new evidence |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Safe recovery action with budget |
|
||||
|
||||
Use `error`, `attempts`=0, `effect_class`="read", `cancelled`=False, `fingerprint_repeats`=0 as the inputs for this operation.
|
||||
|
||||
This returns an action, not an automatic retry or permission to execute. For
|
||||
write or unknown effect, consult the effect ledger before taking another step.
|
||||
|
||||
Return *[Select a bounded recovery action](agent.error_decide_retry(error=`error`, attempts=`attempts`, effect_class=`effect_class`, cancelled=`cancelled`, fingerprint_repeats=`fingerprint_repeats`))*.
|
||||
|
||||
## save
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable logical run ID |
|
||||
| task | any | None | Current task or user request |
|
||||
| status | text | "waiting_input" | Current run status |
|
||||
| effect_ledger_watermark | any | None | Durable ledger boundary if available |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | CheckpointV2 write result |
|
||||
|
||||
Use `id`, `task`=None, `status`="waiting_input", `effect_ledger_watermark`=None as the inputs for this operation.
|
||||
|
||||
Use the existing atomic checkpoint writer. When ledger evidence is absent,
|
||||
a resumed writer requires manual review rather than automatic repetition.
|
||||
This function saves metadata; it does not suspend a Rust execution frame.
|
||||
|
||||
Return *[Save a versioned checkpoint](agent.resume_save(id=`id`, task=`task`, status=`status`, checkpoint_v2=True, effect_ledger_watermark=`effect_ledger_watermark`))*.
|
||||
|
||||
## load
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Previously saved logical run ID |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Checkpoint or missing/unsafe recovery status |
|
||||
|
||||
Use `id` as the inputs for this operation.
|
||||
|
||||
Loading a checkpoint does not execute any saved step. The caller must inspect
|
||||
recovery_mode and write_auto_resume before dispatching any effectful operation.
|
||||
|
||||
Return *[Inspect the saved checkpoint](agent.resume_load(id=`id`))*.
|
||||
@@ -0,0 +1,330 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: Native AI workflow — durable, short, one-step-at-a-time execution
|
||||
description: Plugin-managed checkpointed decision flow without an external agent runtime.
|
||||
import:
|
||||
plugin: lib/plugin.mq.md
|
||||
json: lib/json.mq.md
|
||||
flow: ext/ai/flow.mq.md
|
||||
subtask: lib/subtask.mq.md
|
||||
---
|
||||
|
||||
Every step is an explicit commit boundary. The plugin stores accepted outputs,
|
||||
refuses stale documents and conflicting decisions, and exposes the next action.
|
||||
The caller must supply trusted session, principal and source revision fields;
|
||||
model text is never an identity or permission token. `resume_dir` is a
|
||||
host-relative checkpoint directory, never an absolute client path.
|
||||
|
||||
## open
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable run ID |
|
||||
| steps | list | required | 1–128 ordered step records |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Created, resumed, or explicit conflict |
|
||||
|
||||
Use `id`, `steps`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Opening the same ID with the same steps, source revision, session and principal
|
||||
returns the current action instead of resetting progress. Reusing an ID with a
|
||||
different plan or identity fails closed.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Open durable workflow](agent_workflow_open(id=`id`, steps=`steps`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## next
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable run ID |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Current action or terminal state |
|
||||
|
||||
Use `id`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
`next` is read-only: it does not call a model, run a child document or consume
|
||||
the current step. Stopped states (`blocked`, `uncertain`, `cancelled`) and
|
||||
unclassified child effects are reported explicitly.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Find the next committed boundary](agent_workflow_next(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## inspect
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable run ID |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Progress summary with cursor, step and partial results |
|
||||
|
||||
Use `id`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Use inspect for a UI progress panel or an operator audit. It returns the
|
||||
durable checkpoint `status`, the next `action` (for example `waiting_model`),
|
||||
cursor, total and completed step counts, the current step, and retained partial
|
||||
child results without advancing the workflow.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Read workflow progress](agent_workflow_inspect(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## list
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| session_id | text | None | Trusted session filter |
|
||||
| principal_ref | text | None | Trusted principal filter |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Workflow summaries, newest metadata included separately |
|
||||
|
||||
Use `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Only native workflow checkpoints are listed; unrelated resume records and
|
||||
corrupt files are omitted. Pass host-attested filters to keep one session or
|
||||
principal from seeing another's run identifiers.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[List workflow checkpoints](agent_workflow_list(session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## commit
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable run ID |
|
||||
| step_id | text | required | Exact current step |
|
||||
| response | any | required | Completed step output |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Committed next step or explicit failure |
|
||||
|
||||
Use `id`, `step_id`, `response`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
A completed step cannot be committed twice. Replaying the same value returns
|
||||
the already-committed result; a different value for the same step conflicts.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Validate and commit one step](agent_workflow_commit(id=`id`, step_id=`step_id`, response=`response`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## cancel
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Stable run ID |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Cancelled checkpoint status |
|
||||
|
||||
Use `id`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Cancelling prevents future commits. It does not claim that children already
|
||||
started by the supervisor were rolled back.
|
||||
|
||||
We retain **p = [Locate the Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Commit cancellation](agent_workflow_cancel(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Missing ABI plugin](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
|
||||
## tick
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Running workflow |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| registry | map | None | Trusted SKILL registry |
|
||||
| model | any | None | Configured LLM |
|
||||
| session_id | text | None | Host-attested session |
|
||||
| principal_ref | text | None | Host-attested principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | New checkpoint state, or waiting_input for the UI |
|
||||
|
||||
Use `id`, `source_revision`, `registry`=None, `model`=None, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Advance at most one step. Model text is a candidate, never direct
|
||||
execution. Waiting for a user returns immediately without holding a thread.
|
||||
A caller repeats tick after verified completion; UI replies use commit.
|
||||
|
||||
`tick` is the only wrapper that may execute a document child, and it only does
|
||||
so after the checkpoint reports a read-only `ready_tool` step. When the action
|
||||
is `waiting_input`, return the state unchanged so the host can display the
|
||||
question and commit the attested answer on a later call. A blocked, uncertain
|
||||
or cancelled checkpoint is returned as-is; recovery must use `retry_plan` or an
|
||||
operator decision instead of silently ticking again. The returned state always
|
||||
describes the committed boundary, not an optimistic guess about a running
|
||||
child.
|
||||
|
||||
We retain **state = [Load the next action](next(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))**.
|
||||
We retain **status = [Read action status](json.get(value=`state`, key="status"))**.
|
||||
1. `status` == "waiting_model"
|
||||
We retain **step = [Read model step](json.get(value=`state`, key="step"))**.
|
||||
We retain **step_id = [Read step identifier](json.get(value=`step`, key="id"))**.
|
||||
We retain **prompt = [Read local prompt](json.get(value=`step`, key="prompt"))**.
|
||||
We retain **options = [Read allowed decisions](json.get(value=`step`, key="options"))**.
|
||||
We retain **answer = [Make a bounded choice](flow.choose(input=`prompt`, options=`options`, model=`model`))**.
|
||||
We retain **valid = [Check model decision](json.get(value=`answer`, key="ok"))**.
|
||||
1. `valid`
|
||||
We retain **chosen = [Read verified model answer](json.get(value=`answer`, key="value"))**.
|
||||
Return *[Commit the model choice](commit(id=`id`, step_id=`step_id`, response=`chosen`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *answer*.
|
||||
2. `status` == "ready_tool"
|
||||
We retain **step = [Read tool step](json.get(value=`state`, key="step"))**.
|
||||
We retain **kind = [Read operation kind](json.get(value=`step`, key="kind"))**.
|
||||
We retain **step_id = [Read step identifier](json.get(value=`step`, key="id"))**.
|
||||
1. `kind` == "parallel"
|
||||
We retain **tasks = [Read child tasks](json.get(value=`step`, key="tasks"))**.
|
||||
We retain **report = [Run bounded parallel documents](flow.parallel(tasks=`tasks`))**.
|
||||
Return *[Commit all child outcomes](commit(id=`id`, step_id=`step_id`, response=`report`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. `kind` == "skill"
|
||||
We retain **name = [Read registered skill name](json.get(value=`step`, key="skill"))**.
|
||||
We retain **out = [Run registered SKILL only](flow.enter(skill=`name`, registry=`registry`))**.
|
||||
Return *[Commit verified child result](commit(id=`id`, step_id=`step_id`, response=`out`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
3. *
|
||||
Return *state*.
|
||||
3. `status` == "ready_return"
|
||||
We retain **step = [Read return step](json.get(value=`state`, key="step"))**.
|
||||
We retain **step_id = [Read step identifier](json.get(value=`step`, key="id"))**.
|
||||
We retain **value = [Read final value](json.get(value=`step`, key="value"))**.
|
||||
Return *[Commit the completed workflow](commit(id=`id`, step_id=`step_id`, response=`value`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
4. *
|
||||
Return *state*.
|
||||
|
||||
|
||||
## retry_plan
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Blocked workflow ID |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Failed-only read-task list or manual_review |
|
||||
|
||||
Use `id`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Only a parallel step explicitly declared read-only and with no uncertain
|
||||
effects may return a retry plan. Completed siblings are not included.
|
||||
|
||||
We retain **p = [Locate Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Select failed read-only children](agent_workflow_retry_plan(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Native plugin unavailable](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## retry_commit
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Blocked workflow ID |
|
||||
| results | list | required | New outcomes for failed children only |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Merged persistent report, or still blocked |
|
||||
|
||||
Use `id`, `results`, `source_revision`, `session_id`=None, `principal_ref`=None, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Re-use successful child results from the checkpoint. New results fill failed
|
||||
slots only, in original order; a newly uncertain outcome blocks further work.
|
||||
|
||||
We retain **p = [Locate Agent ABI plugin](plugin.native_path(name="agent"))**.
|
||||
1. `p`
|
||||
We **[Load Agent ABI plugin](plugin.load(path=`p`))**.
|
||||
Return *[Merge verified read-only retries](agent_workflow_retry_commit(id=`id`, results=`results`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *[Native plugin unavailable](json.parse(text="{\"ok\":false,\"status\":\"unavailable\"}"))*.
|
||||
|
||||
## retry_failed
|
||||
|
||||
| 参数 | 类型 | 默认 | 说明 |
|
||||
|---|---|---|---|
|
||||
| id | text | required | Blocked workflow ID |
|
||||
| source_revision | text | required | Pinned source revision |
|
||||
| session_id | text | None | Trusted session |
|
||||
| principal_ref | text | None | Trusted principal |
|
||||
| limit | number | 2 | Max concurrent failed children |
|
||||
| timeout_ms | number | 30000 | Child timeout |
|
||||
| resume_dir | text | ".marqdo/agent-resume" | Host-relative checkpoint directory |
|
||||
|
||||
| 返回 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| result | map | Recovered workflow, partial results or manual review |
|
||||
|
||||
Use `id`, `source_revision`, `session_id`=None, `principal_ref`=None, `limit`=2, `timeout_ms`=30000, `resume_dir`=".marqdo/agent-resume" as the inputs for this operation.
|
||||
|
||||
Run only the failed read-only tasks returned by the native checkpoint checker.
|
||||
Unknown external writes never reach this path.
|
||||
|
||||
We retain **plan = [Inspect safe retry manifest](retry_plan(id=`id`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))**.
|
||||
We retain **can_retry = [Check permitted recovery](json.get(value=`plan`, key="ok"))**.
|
||||
1. `can_retry`
|
||||
We retain **tasks = [Read failed-only children](json.get(value=`plan`, key="tasks"))**.
|
||||
We retain **outcomes = [Execute failed read-only children only](subtask.run_many(tasks=`tasks`, limit=`limit`, timeout_ms=`timeout_ms`))**.
|
||||
Return *[Merge with preserved completed children](retry_commit(id=`id`, results=`outcomes`, source_revision=`source_revision`, session_id=`session_id`, principal_ref=`principal_ref`, resume_dir=`resume_dir`))*.
|
||||
2. *
|
||||
Return *plan*.
|
||||
@@ -71,7 +71,7 @@ authentication is resolved inside the plugin from existing stores.
|
||||
We **loaded = [Load this package's native boundary](_load())** and
|
||||
**base = [Read the granted runtime working root](sys.cwd())** and **resolved_root = root**.
|
||||
1. not [The requested root is already absolute](paths.is_absolute(path=`root`))
|
||||
We **resolved_root = base + "/" + root** so process and native filesystem locations agree.
|
||||
We **resolved_root = [Join the runtime cwd with the relative grant](paths.join(a=`base`, b=`root`))** so Windows and Unix separators stay native.
|
||||
|
||||
`request_data` =
|
||||
|
||||
|
||||
@@ -13,4 +13,5 @@ crate-type = ["cdylib"]
|
||||
[dependencies]
|
||||
marqdo-plugin-sdk = { path = "../../crates/marqdo-plugin-sdk" }
|
||||
serde_json = "1"
|
||||
pulldown-cmark = "0.12"
|
||||
chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
|
||||
@@ -0,0 +1,197 @@
|
||||
//! Fail-closed choice parsing for small-model routing.
|
||||
//! This module only extracts a value; it never resolves or executes a SKILL.
|
||||
|
||||
use serde_json::{json, Value};
|
||||
|
||||
fn canonical(s: &str) -> String {
|
||||
s.trim()
|
||||
.trim_matches(|c: char| matches!(c, '"' | '\'' | '`' | '“' | '”' | '‘' | '’'))
|
||||
.trim()
|
||||
.to_lowercase()
|
||||
}
|
||||
|
||||
fn strip_fence(s: &str) -> &str {
|
||||
let s = s.trim();
|
||||
if !s.starts_with("```") {
|
||||
return s;
|
||||
}
|
||||
let Some(start) = s.find('\n') else {
|
||||
return s;
|
||||
};
|
||||
let body = &s[start + 1..];
|
||||
let Some(end) = body.find("```") else {
|
||||
return s;
|
||||
};
|
||||
if !body[end + 3..].trim().is_empty() {
|
||||
return s;
|
||||
}
|
||||
body[..end].trim()
|
||||
}
|
||||
|
||||
fn strip_label(s: &str) -> &str {
|
||||
let s = s.trim();
|
||||
let Some((head, tail)) = s.split_once([':', ':']) else {
|
||||
return s;
|
||||
};
|
||||
if matches!(
|
||||
head.trim().to_lowercase().as_str(),
|
||||
"choice" | "option" | "selected" | "选择" | "选项" | "答案"
|
||||
) {
|
||||
tail.trim()
|
||||
} else {
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
fn structured_reply(raw: &str) -> Option<String> {
|
||||
let parsed: Value = serde_json::from_str(raw).ok()?;
|
||||
if let Some(s) = parsed.as_str() {
|
||||
return Some(s.to_string());
|
||||
}
|
||||
if let Some(list) = parsed.as_array() {
|
||||
if list.len() == 1 {
|
||||
return list[0].as_str().map(str::to_string);
|
||||
}
|
||||
return None;
|
||||
}
|
||||
let map = parsed.as_object()?;
|
||||
// Refuse conflicting structured decisions instead of choosing first.
|
||||
let values: Vec<&str> = ["choice", "selected", "option", "选择"]
|
||||
.iter()
|
||||
.filter_map(|key| map.get(*key).and_then(Value::as_str))
|
||||
.collect();
|
||||
if values.is_empty() || values.iter().any(|s| *s != values[0]) {
|
||||
return None;
|
||||
}
|
||||
Some(values[0].to_string())
|
||||
}
|
||||
|
||||
fn single_choice(options: &[String], reply: &str) -> Option<String> {
|
||||
let raw = strip_label(strip_fence(reply));
|
||||
// Structured single-choice replies are accepted only through known fields,
|
||||
// and then still validated against the caller's exact allowlist.
|
||||
let decoded = structured_reply(raw);
|
||||
let raw = decoded.as_deref().unwrap_or(raw);
|
||||
// Small models often prepend a short selection verb. Accept only the
|
||||
// verb followed by a complete allowed value; explanations stay invalid.
|
||||
let raw = raw.trim();
|
||||
let raw = ["我选择", "我选", "I choose ", "I pick ", "选中"].iter()
|
||||
.find_map(|p| raw.strip_prefix(p).map(str::trim))
|
||||
.unwrap_or(raw);
|
||||
let value = canonical(raw);
|
||||
// Never infer a routing decision from arbitrary prose.
|
||||
let matches: Vec<&String> = options
|
||||
.iter()
|
||||
.filter(|opt| canonical(opt) == value)
|
||||
.collect();
|
||||
if matches.len() == 1 {
|
||||
return Some(matches[0].clone());
|
||||
}
|
||||
// A bare number denotes a 1-based index into the allowed list.
|
||||
if let Ok(index) = value.parse::<usize>() {
|
||||
if index > 0 && index <= options.len() {
|
||||
return Some(options[index - 1].clone());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Parse one permitted option from a small model response.
|
||||
/// Returns a status rather than treating arbitrary prose as a tool target.
|
||||
pub fn parse_choice(args: &Value) -> Result<Value, String> {
|
||||
let reply = args
|
||||
.get("reply")
|
||||
.and_then(Value::as_str)
|
||||
.ok_or_else(|| "missing text `reply`".to_string())?;
|
||||
let options = args
|
||||
.get("options")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or_else(|| "options must be an array of strings".to_string())?;
|
||||
if options.is_empty() || options.len() > 64 {
|
||||
return Err("options must contain 1..=64 entries".to_string());
|
||||
}
|
||||
let mut allowed = Vec::with_capacity(options.len());
|
||||
for option in options {
|
||||
let name = option
|
||||
.as_str()
|
||||
.ok_or_else(|| "each option must be a string".to_string())?;
|
||||
if name.trim().is_empty() || name.len() > 128 {
|
||||
return Err("each option must contain 1..=128 UTF-8 bytes".to_string());
|
||||
}
|
||||
if allowed.iter().any(|p: &String| canonical(p) == canonical(name)) {
|
||||
return Err("options must be unique after normalization".to_string());
|
||||
}
|
||||
allowed.push(name.to_string());
|
||||
}
|
||||
if let Some(value) = single_choice(&allowed, reply) {
|
||||
Ok(json!({"ok": true, "value": value, "status": "accepted"}))
|
||||
} else {
|
||||
Ok(json!({
|
||||
"ok": false,
|
||||
"value": null,
|
||||
"status": "invalid",
|
||||
"error": {
|
||||
"code": "model.invalid_choice",
|
||||
"category": "invalid_output",
|
||||
"retryable": false,
|
||||
"recovery_action": "repair_output"
|
||||
}
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn check(reply: &str) -> Value {
|
||||
parse_choice(&json!({"options": ["chat", "office"], "reply": reply})).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_exact_label_fence_and_number() {
|
||||
assert_eq!(check("chat")["value"], "chat");
|
||||
assert_eq!(check(" CHAT ")["value"], "chat");
|
||||
assert_eq!(check("选择:office")["value"], "office");
|
||||
assert_eq!(check("```text\nchat\n```")["value"], "chat");
|
||||
assert_eq!(check("2")["value"], "office");
|
||||
assert_eq!(check("我选择 chat")["value"], "chat");
|
||||
assert_eq!(check("I choose office")["value"], "office");
|
||||
assert_eq!(check(r#"{"choice":"chat"}"#)["value"], "chat");
|
||||
assert_eq!(check("[\"office\"]")["value"], "office");
|
||||
assert_eq!(check("```json\n{\"selected\":\"office\"}\n```")["value"], "office");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_prose_conflicts_and_out_of_range() {
|
||||
for reply in ["请选择 chat", "chat 或 office", "choice: chat,因为更合适", "3", ""] {
|
||||
let result = check(reply);
|
||||
assert_eq!(result["ok"], false, "accepted {reply:?}");
|
||||
assert_eq!(result["value"], Value::Null);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_conflicting_structured_decisions() {
|
||||
assert_eq!(check(r#"{"choice":"chat","option":"office"}"#)["ok"], false);
|
||||
assert_eq!(check(r#"{"choice":"../private.mq.md"}"#)["ok"], false);
|
||||
assert_eq!(check(r#"["chat","office"]"#)["ok"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_options_before_parsing() {
|
||||
for options in [
|
||||
json!([]),
|
||||
json!(["chat", "CHAT"]),
|
||||
json!(["chat", 10]),
|
||||
json!([""]),
|
||||
] {
|
||||
assert!(parse_choice(&json!({"options": options, "reply": "chat"})).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn never_extracts_arbitrary_skill_path() {
|
||||
assert_eq!(check("../../private.mq.md")["ok"], false);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
//! Markdown-heading-backed, bounded context projection for Marqdo SKILLs.
|
||||
//! This is source selection, not execution: quoted text never becomes tool authority.
|
||||
//! Markdown events ignore fenced-code headings; ambiguous functions fail closed.
|
||||
|
||||
use pulldown_cmark::{Event, HeadingLevel, Parser, Tag, TagEnd};
|
||||
use serde_json::{json, Value};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Section {
|
||||
level: u8,
|
||||
title: String,
|
||||
start: usize,
|
||||
}
|
||||
|
||||
fn level_num(h: HeadingLevel) -> u8 {
|
||||
match h {
|
||||
HeadingLevel::H1 => 1,
|
||||
HeadingLevel::H2 => 2,
|
||||
HeadingLevel::H3 => 3,
|
||||
HeadingLevel::H4 => 4,
|
||||
HeadingLevel::H5 => 5,
|
||||
HeadingLevel::H6 => 6,
|
||||
}
|
||||
}
|
||||
|
||||
fn headings(source: &str) -> Vec<Section> {
|
||||
let mut out = Vec::new();
|
||||
let mut pending: Option<Section> = None;
|
||||
for (event, range) in Parser::new(source).into_offset_iter() {
|
||||
match event {
|
||||
Event::Start(Tag::Heading { level, .. }) => {
|
||||
pending = Some(Section {
|
||||
level: level_num(level),
|
||||
title: String::new(),
|
||||
start: range.start,
|
||||
});
|
||||
}
|
||||
Event::Text(text) | Event::Code(text) => {
|
||||
if let Some(section) = pending.as_mut() {
|
||||
section.title.push_str(&text);
|
||||
}
|
||||
}
|
||||
Event::End(TagEnd::Heading(_)) => {
|
||||
if let Some(mut section) = pending.take() {
|
||||
section.title = section.title.trim().to_string();
|
||||
out.push(section);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn class_for(headings: &[Section], index: usize) -> Option<&str> {
|
||||
headings[..index]
|
||||
.iter()
|
||||
.rev()
|
||||
.find(|h| h.level == 1)
|
||||
.map(|h| h.title.as_str())
|
||||
}
|
||||
|
||||
fn frontmatter_end(source: &str) -> usize {
|
||||
if !source.starts_with("---\n") {
|
||||
return 0;
|
||||
}
|
||||
let mut pos = 4;
|
||||
for line in source[4..].split_inclusive('\n') {
|
||||
pos += line.len();
|
||||
if line.trim() == "---" {
|
||||
return pos;
|
||||
}
|
||||
}
|
||||
0
|
||||
}
|
||||
|
||||
fn truncate_chars(text: &str, max_chars: usize) -> (&str, bool) {
|
||||
let Some((end, _)) = text.char_indices().nth(max_chars) else {
|
||||
return (text, false);
|
||||
};
|
||||
(&text[..end], true)
|
||||
}
|
||||
|
||||
pub fn project(args: &Value) -> Result<Value, String> {
|
||||
let source = match args.get("source").and_then(Value::as_str) {
|
||||
Some(s) => s.to_string(),
|
||||
None => crate::host_query_json("module_source")?
|
||||
.as_str()
|
||||
.ok_or_else(|| "module_source unavailable".to_string())?
|
||||
.to_string(),
|
||||
};
|
||||
let scope = args.get("scope").and_then(Value::as_str).unwrap_or("function");
|
||||
let class = args.get("class").and_then(Value::as_str);
|
||||
let function = args.get("function").and_then(Value::as_str);
|
||||
let maximum = args
|
||||
.get("max_chars")
|
||||
.and_then(Value::as_u64)
|
||||
.unwrap_or(1600)
|
||||
.clamp(32, 16000) as usize;
|
||||
// YAML frontmatter may look like a setext Markdown heading; never treat it
|
||||
// as a Marqdo class or function boundary.
|
||||
let front_end = frontmatter_end(&source);
|
||||
let marks: Vec<Section> = headings(&source)
|
||||
.into_iter()
|
||||
.filter(|heading| heading.start >= front_end)
|
||||
.collect();
|
||||
let results: Vec<(usize, usize)> = match scope {
|
||||
"file" => {
|
||||
let end = marks.first().map_or(source.len(), |h| h.start);
|
||||
let start = frontmatter_end(&source).min(end);
|
||||
vec![(start, end)]
|
||||
}
|
||||
"class" | "function" | "tool" => {
|
||||
let level = match scope {
|
||||
"class" => 1,
|
||||
"function" => 2,
|
||||
_ => 3,
|
||||
};
|
||||
let target = if level == 1 { class } else { function };
|
||||
let wanted = target.ok_or_else(|| format!("{scope} selector required"))?;
|
||||
marks
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(i, h)| {
|
||||
h.level == level
|
||||
&& h.title == wanted
|
||||
&& (level == 1 || class.is_none() || class_for(&marks, *i) == class)
|
||||
})
|
||||
.map(|(i, h)| {
|
||||
let end = marks[i + 1..]
|
||||
.iter()
|
||||
.find(|next| next.level <= level)
|
||||
.map_or(source.len(), |next| next.start);
|
||||
let end = if level == 1 {
|
||||
marks[i + 1..]
|
||||
.iter()
|
||||
.find(|next| next.level <= 2)
|
||||
.map_or(end, |next| next.start)
|
||||
} else {
|
||||
end
|
||||
};
|
||||
(h.start, end)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
_ => return Err("scope must be file, class, function or tool".to_string()),
|
||||
};
|
||||
if results.len() != 1 {
|
||||
return Ok(json!({
|
||||
"ok": false,
|
||||
"status": if results.is_empty() { "not_found" } else { "ambiguous" },
|
||||
"scope": scope,
|
||||
"matches": results.len(),
|
||||
"text": null
|
||||
}));
|
||||
}
|
||||
let (start, end) = results[0];
|
||||
let (slice, truncated) = truncate_chars(source[start..end].trim(), maximum);
|
||||
let line_start = source[..start].bytes().filter(|c| *c == b'\n').count() + 1;
|
||||
Ok(json!({
|
||||
"ok": true, "status": "accepted", "scope": scope,
|
||||
"text": slice, "truncated": truncated,
|
||||
"start_byte": start, "end_byte": end,
|
||||
"start_line": line_start,
|
||||
"source_kind": "markdown_headings"
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const DOC: &str = "---\ntitle: example\n---\nEntry instructions.\n\n# main\nClass instructions.\n\n## route\nReal body.\n```md\n## route\nfake\n```\n\n## other\nOther body.\n\n# helper\nHelper prose.\n\n## route\nSecond body.\n";
|
||||
|
||||
#[test]
|
||||
fn scope_is_bounded_and_fenced_headings_ignored() {
|
||||
let v = project(&json!({"source": DOC, "scope": "function", "class": "main", "function": "route"})).unwrap();
|
||||
assert_eq!(v["ok"], true);
|
||||
assert!(v["text"].as_str().unwrap().contains("Real body."));
|
||||
assert!(v["text"].as_str().unwrap().contains("fake"));
|
||||
assert!(!v["text"].as_str().unwrap().contains("Other body."));
|
||||
assert!(!v["text"].as_str().unwrap().contains("Second body."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ambiguous_function_fails_closed() {
|
||||
let v = project(&json!({"source": DOC, "scope": "function", "function": "route"})).unwrap();
|
||||
assert_eq!(v["status"], "ambiguous");
|
||||
assert_eq!(v["text"], Value::Null);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn file_scope_removes_frontmatter_and_class_prose_excludes_functions() {
|
||||
let a = project(&json!({"source": DOC, "scope": "file"})).unwrap();
|
||||
assert_eq!(a["text"], "Entry instructions.");
|
||||
let b = project(&json!({"source": DOC, "scope": "class", "class": "main"})).unwrap();
|
||||
assert!(b["text"].as_str().unwrap().contains("Class instructions."));
|
||||
assert!(!b["text"].as_str().unwrap().contains("Real body."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_truncation_does_not_split_characters() {
|
||||
let v = project(&json!({"source": "汉".repeat(100), "scope": "file", "max_chars": 32})).unwrap();
|
||||
assert_eq!(v["text"].as_str().unwrap().chars().count(), 32);
|
||||
assert_eq!(v["truncated"], true);
|
||||
}
|
||||
}
|
||||
@@ -91,6 +91,8 @@ fn ensure_dir(root: &Path) -> Result<(), String> {
|
||||
fs::create_dir_all(root).map_err(|e| format!("effects mkdir: {e}"))
|
||||
}
|
||||
|
||||
static EFFECT_TEMP_SEQUENCE: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
|
||||
|
||||
fn atomic_write_json(path: &Path, doc: &Value) -> Result<(), String> {
|
||||
let parent = path
|
||||
.parent()
|
||||
@@ -102,7 +104,8 @@ fn atomic_write_json(path: &Path, doc: &Value) -> Result<(), String> {
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or("op.json"),
|
||||
std::process::id(),
|
||||
now_rfc3339().replace(':', "")
|
||||
format!("{}-{}", now_rfc3339().replace(':', ""),
|
||||
EFFECT_TEMP_SEQUENCE.fetch_add(1, std::sync::atomic::Ordering::Relaxed))
|
||||
);
|
||||
let tmp = parent.join(tmp_name);
|
||||
let text = serde_json::to_string_pretty(doc).map_err(|e| e.to_string())?;
|
||||
@@ -425,12 +428,16 @@ fn fnv64(s: &str) -> u64 {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// Avoid process-global set_current_dir: Rust executes tests concurrently.
|
||||
// Keep each ledger in its own repository-relative, unique directory.
|
||||
static SCRATCH_SEQ: std::sync::atomic::AtomicU64 =
|
||||
std::sync::atomic::AtomicU64::new(0);
|
||||
|
||||
fn scratch(tag: &str) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
let seq = SCRATCH_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let dir = PathBuf::from("target").join(format!(
|
||||
"mq-effects-{}-{}-{}",
|
||||
tag,
|
||||
std::process::id(),
|
||||
now_rfc3339().replace(':', "")
|
||||
tag, std::process::id(), seq
|
||||
));
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
@@ -440,14 +447,13 @@ mod tests {
|
||||
#[test]
|
||||
fn prepare_dedupe_and_collision() {
|
||||
let dir = scratch("prep");
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let ledger_dir = dir.join("led").to_string_lossy().to_string();
|
||||
let a = effects_prepare(&json!({
|
||||
"operation_id": "op1",
|
||||
"idempotency_key": "idem1",
|
||||
"args_digest": "sha256:a",
|
||||
"effect_class": "write",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run1",
|
||||
}))
|
||||
.unwrap();
|
||||
@@ -458,7 +464,7 @@ mod tests {
|
||||
"operation_id": "op1",
|
||||
"idempotency_key": "idem1",
|
||||
"args_digest": "sha256:a",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
assert_eq!(again["deduped"], true);
|
||||
@@ -467,43 +473,41 @@ mod tests {
|
||||
"operation_id": "op2",
|
||||
"idempotency_key": "idem1",
|
||||
"args_digest": "sha256:b",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}));
|
||||
assert!(clash.unwrap_err().contains("collision"));
|
||||
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transition_and_watermark_gates_write_resume() {
|
||||
let dir = scratch("wm");
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let ledger_dir = dir.join("led").to_string_lossy().to_string();
|
||||
effects_prepare(&json!({
|
||||
"operation_id": "op_w",
|
||||
"idempotency_key": "idem_w",
|
||||
"args_digest": "sha256:w",
|
||||
"effect_class": "write",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run1",
|
||||
}))
|
||||
.unwrap();
|
||||
effects_transition(&json!({
|
||||
"operation_id": "op_w",
|
||||
"state": "started",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
// Crash window: unknown — write auto-resume must stay closed.
|
||||
effects_transition(&json!({
|
||||
"operation_id": "op_w",
|
||||
"state": "unknown",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
let wm1 = effects_watermark(&json!({
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run1",
|
||||
}))
|
||||
.unwrap();
|
||||
@@ -513,12 +517,12 @@ mod tests {
|
||||
effects_reconcile(&json!({
|
||||
"operation_id": "op_w",
|
||||
"outcome": "committed",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"result_ref": "receipt:1",
|
||||
}))
|
||||
.unwrap();
|
||||
let wm2 = effects_watermark(&json!({
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run1",
|
||||
}))
|
||||
.unwrap();
|
||||
@@ -526,7 +530,6 @@ mod tests {
|
||||
assert_eq!(wm2["open_unknown"], 0);
|
||||
assert!(wm2["watermark"].as_str().unwrap().starts_with("sha256-lite:"));
|
||||
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
@@ -535,32 +538,31 @@ mod tests {
|
||||
// Write "succeeds" locally only after reconcile; retry while unknown must not
|
||||
// look write_auto_resume_safe (MA-T03 watermark gate).
|
||||
let dir = scratch("mat03");
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let ledger_dir = dir.join("led").to_string_lossy().to_string();
|
||||
effects_prepare(&json!({
|
||||
"operation_id": "op_kill",
|
||||
"idempotency_key": "run|s|write_probe|sha256-lite:1",
|
||||
"args_digest": "sha256-lite:1",
|
||||
"effect_class": "write",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run_kill",
|
||||
}))
|
||||
.unwrap();
|
||||
effects_transition(&json!({
|
||||
"operation_id": "op_kill",
|
||||
"state": "started",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
// Crash before commit:
|
||||
effects_transition(&json!({
|
||||
"operation_id": "op_kill",
|
||||
"state": "unknown",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
let wm = effects_watermark(&json!({
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run_kill",
|
||||
}))
|
||||
.unwrap();
|
||||
@@ -572,7 +574,7 @@ mod tests {
|
||||
"idempotency_key": "run|s|write_probe|sha256-lite:1",
|
||||
"args_digest": "sha256-lite:1",
|
||||
"effect_class": "write",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run_kill",
|
||||
}))
|
||||
.unwrap();
|
||||
@@ -582,42 +584,39 @@ mod tests {
|
||||
effects_reconcile(&json!({
|
||||
"operation_id": "op_kill",
|
||||
"outcome": "committed",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"result_ref": "effect:op_kill",
|
||||
}))
|
||||
.unwrap();
|
||||
let wm2 = effects_watermark(&json!({
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
"logical_run_id": "run_kill",
|
||||
}))
|
||||
.unwrap();
|
||||
assert_eq!(wm2["write_auto_resume_safe"], true);
|
||||
assert_eq!(wm2["pending_writes"], 0);
|
||||
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn illegal_skip_started() {
|
||||
let dir = scratch("bad");
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let ledger_dir = dir.join("led").to_string_lossy().to_string();
|
||||
effects_prepare(&json!({
|
||||
"operation_id": "op_x",
|
||||
"idempotency_key": "idem_x",
|
||||
"args_digest": "sha256:x",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
let err = effects_transition(&json!({
|
||||
"operation_id": "op_x",
|
||||
"state": "committed",
|
||||
"ledger_dir": "led",
|
||||
"ledger_dir": ledger_dir.clone(),
|
||||
}))
|
||||
.unwrap_err();
|
||||
assert!(err.contains("illegal transition"));
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
@@ -82,6 +82,10 @@ pub fn decide_retry(args: &Value) -> Result<Value, String> {
|
||||
.get("max_arg_repairs")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(1) as u32;
|
||||
let max_output_repair = args
|
||||
.get("max_output_repairs")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(1) as u32;
|
||||
let effect_class = args
|
||||
.get("effect_class")
|
||||
.and_then(|v| v.as_str())
|
||||
@@ -145,6 +149,12 @@ pub fn decide_retry(args: &Value) -> Result<Value, String> {
|
||||
"invalid_arguments" if recovery == "repair_args" && attempts < max_arg_repair => Ok(
|
||||
decision("repair_args", "one_arg_repair", attempts, max_arg_repair),
|
||||
),
|
||||
"invalid_output" if recovery == "repair_output" && attempts < max_output_repair => Ok(
|
||||
decision("repair_output", "one_format_repair", attempts, max_output_repair),
|
||||
),
|
||||
"context_overflow" if recovery == "compact_context" && attempts == 0 => Ok(
|
||||
decision("compact_context", "one_bounded_compaction", attempts, 1),
|
||||
),
|
||||
"auth" | "forbidden" | "policy_denied" => Ok(decision(
|
||||
"needs_input",
|
||||
category,
|
||||
@@ -172,13 +182,17 @@ fn decision(action: &str, reason: &str, attempts: u32, max_attempts: u32) -> Val
|
||||
"reason": reason,
|
||||
"attempts_used": attempts,
|
||||
"max_attempts": max_attempts,
|
||||
"auto": matches!(action, "retry_step" | "repair_args"),
|
||||
"auto": matches!(action, "retry_step" | "repair_args" | "repair_output" | "compact_context"),
|
||||
})
|
||||
}
|
||||
|
||||
fn infer_category(code: &str) -> &'static str {
|
||||
let c = code.to_ascii_lowercase();
|
||||
if c.contains("timeout") || c.contains("429") || c.contains("5xx") || c.contains("connect") {
|
||||
if c.contains("context_overflow") || c.contains("context_length") {
|
||||
"context_overflow"
|
||||
} else if c.contains("invalid_choice") || c.contains("invalid_output") {
|
||||
"invalid_output"
|
||||
} else if c.contains("timeout") || c.contains("429") || c.contains("5xx") || c.contains("connect") {
|
||||
"transient"
|
||||
} else if c.contains("schema") || c.contains("argument") {
|
||||
"invalid_arguments"
|
||||
@@ -212,6 +226,8 @@ fn default_recovery(category: &str, effect_state: &str) -> &'static str {
|
||||
match category {
|
||||
"transient" => "retry_step",
|
||||
"invalid_arguments" => "repair_args",
|
||||
"invalid_output" => "repair_output",
|
||||
"context_overflow" => "compact_context",
|
||||
"auth" | "forbidden" | "policy_denied" | "needs_input" => "needs_input",
|
||||
"budget_exhausted" => "return_partial",
|
||||
"cancelled" => "stop",
|
||||
@@ -259,6 +275,27 @@ mod tests {
|
||||
assert_eq!(d["auto"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_repair_is_bounded_and_read_only() {
|
||||
let err = make_error(&json!({"code": "model.invalid_choice"})).unwrap();
|
||||
assert_eq!(err["category"], "invalid_output");
|
||||
let first = decide_retry(&json!({"error": err, "attempts": 0})).unwrap();
|
||||
assert_eq!(first["action"], "repair_output");
|
||||
let next = decide_retry(&json!({"error": err, "attempts": 1})).unwrap();
|
||||
assert_eq!(next["action"], "stop");
|
||||
let write = decide_retry(&json!({
|
||||
"error": err, "attempts": 0, "effect_class": "write"
|
||||
})).unwrap();
|
||||
assert_eq!(write["action"], "manual_review");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn compaction_is_not_an_unbounded_model_loop() {
|
||||
let err = make_error(&json!({"code": "model.context_overflow"})).unwrap();
|
||||
assert_eq!(decide_retry(&json!({"error": err, "attempts": 0})).unwrap()["action"], "compact_context");
|
||||
assert_eq!(decide_retry(&json!({"error": err, "attempts": 1})).unwrap()["action"], "stop");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fingerprint_loop_stops() {
|
||||
let err = make_error(&json!({"code": "tool.timeout"})).unwrap();
|
||||
|
||||
@@ -0,0 +1,251 @@
|
||||
//! Durable input gates for document-native SKILLs.
|
||||
//! Pausing is a committed *step boundary*, not serialization of a Rust stack.
|
||||
//! The caller resumes the next documented step with the saved answer.
|
||||
|
||||
use std::fs::{self, OpenOptions};
|
||||
use std::path::PathBuf;
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use crate::resume;
|
||||
|
||||
struct GateLock(PathBuf);
|
||||
impl Drop for GateLock {
|
||||
fn drop(&mut self) {
|
||||
let _ = fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
fn text_arg<'a>(args: &'a Value, key: &str) -> Result<&'a str, String> {
|
||||
args.get(key)
|
||||
.and_then(Value::as_str)
|
||||
.filter(|s| !s.is_empty())
|
||||
.ok_or_else(|| format!("missing text `{key}`"))
|
||||
}
|
||||
|
||||
fn valid_id(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& s.len() <= 100
|
||||
&& s.bytes().all(|c| c.is_ascii_alphanumeric() || c == b'-' || c == b'_')
|
||||
}
|
||||
|
||||
fn root(args: &Value) -> Result<PathBuf, String> {
|
||||
let name = args
|
||||
.get("resume_dir")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or(".marqdo/agent-resume");
|
||||
let path = PathBuf::from(name);
|
||||
if path.is_absolute()
|
||||
|| path.components().any(|part| matches!(part, std::path::Component::ParentDir))
|
||||
{
|
||||
return Err("resume_dir must be a relative path without '..'".to_string());
|
||||
}
|
||||
fs::create_dir_all(&path).map_err(|e| format!("input gate mkdir: {e}"))?;
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn lock(args: &Value, id: &str) -> Result<GateLock, String> {
|
||||
if !valid_id(id) {
|
||||
return Err("input gate id must be 1..=100 ASCII letters, numbers, '_' or '-'".into());
|
||||
}
|
||||
let path = root(args)?.join(format!("{id}.input-lock"));
|
||||
OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.open(&path)
|
||||
.map_err(|e| format!("input gate is busy or needs reconciliation: {e}"))?;
|
||||
Ok(GateLock(path))
|
||||
}
|
||||
|
||||
fn options(args: &Value) -> Result<Value, String> {
|
||||
let choices = args.get("options").and_then(Value::as_array)
|
||||
.ok_or_else(|| "options must be a list of 1..=32 short labels".to_string())?;
|
||||
if choices.is_empty() || choices.len() > 32 {
|
||||
return Err("options must contain 1..=32 choices".into());
|
||||
}
|
||||
for v in choices {
|
||||
let Some(s) = v.as_str() else {
|
||||
return Err("every option must be text".into());
|
||||
};
|
||||
if s.is_empty() || s.len() > 256 {
|
||||
return Err("each option must contain 1..=256 bytes".into());
|
||||
}
|
||||
}
|
||||
let empty = crate::choice::parse_choice(&json!({
|
||||
"options": choices, "reply": "__invalid_choice_probe__"
|
||||
}))?;
|
||||
// The parser checks duplicates and option size; the probe must not be accepted.
|
||||
if empty["ok"] == true {
|
||||
return Err("invalid reserved choice option".into());
|
||||
}
|
||||
Ok(Value::Array(choices.to_vec()))
|
||||
}
|
||||
|
||||
/// Create a durable waiting-input checkpoint. Repeated open never resets a
|
||||
/// previously answered gate. No external effect is performed.
|
||||
pub fn input_open(args: &Value) -> Result<Value, String> {
|
||||
let id = text_arg(args, "id")?;
|
||||
let _lock = lock(args, id)?;
|
||||
let labels = options(args)?;
|
||||
let query = text_arg(args, "question")?;
|
||||
let version = text_arg(args, "source_revision")?;
|
||||
let read_args = json!({"id": id, "resume_dir": args.get("resume_dir")});
|
||||
let existing = resume::resume_load(&read_args)?;
|
||||
if existing["found"] == true {
|
||||
let meta = &existing["meta"];
|
||||
let same = meta["question"] == query
|
||||
&& meta["options"] == labels
|
||||
&& meta["source_revision"] == version
|
||||
&& meta["session_id"] == *args.get("session_id").unwrap_or(&Value::Null)
|
||||
&& meta["principal_ref"] == *args.get("principal_ref").unwrap_or(&Value::Null);
|
||||
if same && existing["ok"] == true {
|
||||
let status = existing["status"].as_str().unwrap_or("unknown");
|
||||
return Ok(json!({
|
||||
"ok": true, "id": id, "status": status,
|
||||
"value": existing["result"], "reused": true,
|
||||
"question": query, "options": labels
|
||||
}));
|
||||
}
|
||||
return Ok(json!({"ok":false,"id":id,"status":"conflict",
|
||||
"error":{"code":"input.stale_or_reused_gate"}}));
|
||||
}
|
||||
let saved = resume::resume_save(&json!({
|
||||
"id": id, "resume_dir": args.get("resume_dir"),
|
||||
"checkpoint_v2": true,
|
||||
"status": "waiting_input",
|
||||
"task": query,
|
||||
"meta": {
|
||||
"question": query,
|
||||
"options": labels,
|
||||
"source_revision": version,
|
||||
"session_id": args.get("session_id").unwrap_or(&Value::Null),
|
||||
"principal_ref": args.get("principal_ref").unwrap_or(&Value::Null),
|
||||
"freeform": args.get("freeform").and_then(Value::as_bool).unwrap_or(true)
|
||||
}
|
||||
}))?;
|
||||
if saved["ok"] != true {
|
||||
return Err("unable to save input checkpoint".into());
|
||||
}
|
||||
Ok(json!({"ok": true, "id":id, "status":"waiting_input", "value":null,
|
||||
"question":query,"options":labels,"reused":false}))
|
||||
}
|
||||
|
||||
/// Resume a specific gate with a user response. Only a committed answer can be
|
||||
/// replayed: different duplicate replies conflict instead of re-triggering work.
|
||||
pub fn input_resume(args: &Value) -> Result<Value, String> {
|
||||
let id = text_arg(args, "id")?;
|
||||
let _lock = lock(args, id)?;
|
||||
let reply = text_arg(args, "reply")?;
|
||||
if reply.len() > 4096 {
|
||||
return Err("input reply must not exceed 4096 bytes".into());
|
||||
}
|
||||
let version = text_arg(args, "source_revision")?;
|
||||
let read_args = json!({"id": id, "resume_dir": args.get("resume_dir")});
|
||||
let existing = resume::resume_load(&read_args)?;
|
||||
if existing["ok"] != true || existing["schema"] != "CheckpointV2" {
|
||||
return Ok(json!({"ok":false,"status":"not_found_or_corrupt","id":id}));
|
||||
}
|
||||
let meta = &existing["meta"];
|
||||
if meta["source_revision"] != version
|
||||
|| meta["session_id"] != *args.get("session_id").unwrap_or(&Value::Null)
|
||||
|| meta["principal_ref"] != *args.get("principal_ref").unwrap_or(&Value::Null)
|
||||
{
|
||||
return Ok(json!({"ok":false,"status":"conflict","id":id,
|
||||
"error":{"code":"input.scope_or_revision_changed"}}));
|
||||
}
|
||||
// Normalize the answer before duplicate detection: the index "2" and
|
||||
// the selected label "office" must be the same committed response.
|
||||
let allowed = crate::choice::parse_choice(&json!({
|
||||
"options": meta["options"], "reply": reply
|
||||
}))?;
|
||||
let normalized = if allowed["ok"] == true {
|
||||
allowed["value"].clone()
|
||||
} else if meta["freeform"] == true && !reply.trim().is_empty() {
|
||||
json!(reply.trim())
|
||||
} else {
|
||||
return Ok(json!({"ok":false,"status":"invalid","id":id,
|
||||
"error":{"code":"input.invalid_choice"}}));
|
||||
};
|
||||
if existing["status"] == "resumed" {
|
||||
if existing["result"] == normalized {
|
||||
return Ok(json!({"ok":true,"status":"resumed","id":id,
|
||||
"value":normalized,"reused":true}));
|
||||
}
|
||||
return Ok(json!({"ok":false,"status":"conflict","id":id,
|
||||
"error":{"code":"input.already_answered"}}));
|
||||
}
|
||||
if existing["status"] != "waiting_input" {
|
||||
return Ok(json!({"ok":false,"status":"conflict","id":id}));
|
||||
}
|
||||
let saved = resume::resume_save(&json!({
|
||||
"id": id, "resume_dir": args.get("resume_dir"),
|
||||
"checkpoint_v2": true,
|
||||
"status": "resumed",
|
||||
"task": existing["task"],
|
||||
"meta": meta,
|
||||
"result": normalized
|
||||
}))?;
|
||||
if saved["ok"] != true {
|
||||
return Err("unable to commit resumed input".into());
|
||||
}
|
||||
Ok(json!({"ok":true,"status":"resumed","id":id,
|
||||
"value":normalized,"reused":false}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
static SEQ: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
fn fixture() -> (String, String) {
|
||||
let id = format!("gate_{}_{}",std::process::id(),SEQ.fetch_add(1,Ordering::Relaxed));
|
||||
let dir = format!("target/mq-gate-test-{id}");
|
||||
(id, dir)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persists_answer_without_duplicate_side_effect_or_changed_reply() {
|
||||
let (id, dir) = fixture();
|
||||
let initial = json!({"id":id,"resume_dir":dir,"question":"Choose?",
|
||||
"options":["chat","office"],"source_revision":"v1",
|
||||
"session_id":"s1","principal_ref":"u1","freeform":false});
|
||||
assert_eq!(input_open(&initial).unwrap()["status"], "waiting_input");
|
||||
assert_eq!(input_open(&initial).unwrap()["reused"], true);
|
||||
let v = json!({"id":id,"resume_dir":dir,"reply":"2",
|
||||
"source_revision":"v1","session_id":"s1","principal_ref":"u1"});
|
||||
assert_eq!(input_resume(&v).unwrap()["value"], "office");
|
||||
assert_eq!(input_resume(&v).unwrap()["reused"], true);
|
||||
assert_eq!(input_resume(&json!({"id":id,"resume_dir":dir,
|
||||
"reply":"office","source_revision":"v1","session_id":"s1",
|
||||
"principal_ref":"u1"})).unwrap()["reused"], true);
|
||||
assert_eq!(input_resume(&json!({"id":id,"resume_dir":dir,
|
||||
"reply":"chat","source_revision":"v1","session_id":"s1",
|
||||
"principal_ref":"u1"})).unwrap()["status"], "conflict");
|
||||
assert_eq!(input_open(&initial).unwrap()["status"], "resumed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prevents_changed_source_or_unauthorized_session() {
|
||||
let (id, dir) = fixture();
|
||||
let initial = json!({"id":id,"resume_dir":dir,"question":"Proceed?",
|
||||
"options":["yes","no"],"source_revision":"v1",
|
||||
"session_id":"s1","principal_ref":"u1"});
|
||||
input_open(&initial).unwrap();
|
||||
for (rev,session) in [("v2","s1"),("v1","other")] {
|
||||
assert_eq!(input_resume(&json!({"id":id,"resume_dir":dir,"reply":"yes",
|
||||
"source_revision":rev,"session_id":session,
|
||||
"principal_ref":"u1"})).unwrap()["status"], "conflict");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_choice_keeps_gate_open_and_no_freeform_is_enforced() {
|
||||
let (id, dir) = fixture();
|
||||
input_open(&json!({"id":id,"resume_dir":dir,"question":"Pick",
|
||||
"options":["a","b"],"freeform":false,
|
||||
"source_revision":"v1"})).unwrap();
|
||||
assert_eq!(input_resume(&json!({"id":id,"resume_dir":dir,"reply":"??",
|
||||
"source_revision":"v1"})).unwrap()["status"], "invalid");
|
||||
assert_eq!(resume::resume_load(&json!({"id":id,"resume_dir":dir})).unwrap()["status"], "waiting_input");
|
||||
}
|
||||
}
|
||||
@@ -1,19 +1,24 @@
|
||||
//! Agent plugin (C ABI v2): layout helpers + session bag + context via host_query + agent-kb + v2 memory + adaptive route.
|
||||
|
||||
mod choice;
|
||||
mod context_pack;
|
||||
mod context_scope;
|
||||
mod corpus;
|
||||
mod effects;
|
||||
mod eng;
|
||||
mod error;
|
||||
mod input;
|
||||
mod kb;
|
||||
mod mcp_client;
|
||||
mod mcp_server;
|
||||
mod memory;
|
||||
mod output;
|
||||
mod parallel;
|
||||
mod resume;
|
||||
mod route;
|
||||
mod sandbox;
|
||||
mod tools;
|
||||
mod workflow;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::ffi::CString;
|
||||
@@ -834,6 +839,19 @@ kb_ffi!(agent_resume_save, resume::resume_save, "agent_resume_save");
|
||||
kb_ffi!(agent_resume_load, resume::resume_load, "agent_resume_load");
|
||||
kb_ffi!(agent_resume_clear, resume::resume_clear, "agent_resume_clear");
|
||||
kb_ffi!(agent_resume_list, resume::resume_list, "agent_resume_list");
|
||||
kb_ffi!(agent_choice_parse, choice::parse_choice, "agent_choice_parse");
|
||||
kb_ffi!(agent_context_scope, context_scope::project, "agent_context_scope");
|
||||
kb_ffi!(agent_input_open, input::input_open, "agent_input_open");
|
||||
kb_ffi!(agent_input_resume, input::input_resume, "agent_input_resume");
|
||||
kb_ffi!(agent_parallel_report, parallel::report, "agent_parallel_report");
|
||||
kb_ffi!(agent_workflow_open, workflow::open, "agent_workflow_open");
|
||||
kb_ffi!(agent_workflow_next, workflow::next, "agent_workflow_next");
|
||||
kb_ffi!(agent_workflow_inspect, workflow::inspect, "agent_workflow_inspect");
|
||||
kb_ffi!(agent_workflow_list, workflow::list, "agent_workflow_list");
|
||||
kb_ffi!(agent_workflow_commit, workflow::commit, "agent_workflow_commit");
|
||||
kb_ffi!(agent_workflow_cancel, workflow::cancel, "agent_workflow_cancel");
|
||||
kb_ffi!(agent_workflow_retry_plan, workflow::retry_plan, "agent_workflow_retry_plan");
|
||||
kb_ffi!(agent_workflow_retry_commit, workflow::retry_commit, "agent_workflow_retry_commit");
|
||||
kb_ffi!(agent_error_make, error::make_error, "agent_error_make");
|
||||
kb_ffi!(agent_error_decide_retry, error::decide_retry, "agent_error_decide_retry");
|
||||
kb_ffi!(agent_tools_register, tools::tools_register, "agent_tools_register");
|
||||
@@ -963,6 +981,19 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
|
||||
("agent_resume_load", "id,resume_dir", agent_resume_load),
|
||||
("agent_resume_clear", "id,resume_dir", agent_resume_clear),
|
||||
("agent_resume_list", "resume_dir", agent_resume_list),
|
||||
("agent_choice_parse", "reply,options", agent_choice_parse),
|
||||
("agent_context_scope", "source,scope,class,function", agent_context_scope),
|
||||
("agent_input_open", "id,question,options,source_revision", agent_input_open),
|
||||
("agent_input_resume", "id,reply,source_revision", agent_input_resume),
|
||||
("agent_parallel_report", "results", agent_parallel_report),
|
||||
("agent_workflow_open", "id,steps,source_revision,session_id,principal_ref,resume_dir", agent_workflow_open),
|
||||
("agent_workflow_next", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_next),
|
||||
("agent_workflow_inspect", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_inspect),
|
||||
("agent_workflow_list", "session_id,principal_ref,resume_dir", agent_workflow_list),
|
||||
("agent_workflow_commit", "id,step_id,response,source_revision,session_id,principal_ref,resume_dir", agent_workflow_commit),
|
||||
("agent_workflow_cancel", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_cancel),
|
||||
("agent_workflow_retry_plan", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_retry_plan),
|
||||
("agent_workflow_retry_commit", "id,results,source_revision,session_id,principal_ref,resume_dir", agent_workflow_retry_commit),
|
||||
("agent_error_make", "code,message,category", agent_error_make),
|
||||
("agent_error_decide_retry", "error,attempts,effect_class", agent_error_decide_retry),
|
||||
("agent_tools_register", "spec,specs", agent_tools_register),
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
//! Deterministic fan-out results: never discard a successful sibling and never
|
||||
//! infer success from a completed wait protocol alone.
|
||||
|
||||
use serde_json::{json, Value};
|
||||
|
||||
pub fn report(args: &Value) -> Result<Value, String> {
|
||||
let results = args
|
||||
.get("results")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or_else(|| "results must be ordered subtask result list".to_string())?;
|
||||
if results.len() > 10_000 {
|
||||
return Err("parallel result count exceeds scheduler limit".into());
|
||||
}
|
||||
let mut passed = 0usize;
|
||||
let mut failed = 0usize;
|
||||
let mut unknown = 0usize;
|
||||
let mut entries = Vec::with_capacity(results.len());
|
||||
for (index, child) in results.iter().enumerate() {
|
||||
let transport = child.get("ok").and_then(Value::as_bool);
|
||||
let body = child.get("value").unwrap_or(&Value::Null);
|
||||
let status = match (transport, body.get("code").and_then(Value::as_i64)) {
|
||||
(Some(true), Some(0)) => { passed += 1; "succeeded" }
|
||||
(Some(true), Some(_)) | (Some(false), _) => { failed += 1; "failed" }
|
||||
_ => { unknown += 1; "uncertain" }
|
||||
};
|
||||
// Raw child result is kept as data; the model sees only an optional
|
||||
// bounded summary. The host may store detailed output as an artifact.
|
||||
let detail = child.get("error")
|
||||
.and_then(Value::as_str)
|
||||
.or_else(|| body.get("stderr").and_then(Value::as_str))
|
||||
.unwrap_or("");
|
||||
let brief: String = detail.chars().take(280).collect();
|
||||
entries.push(json!({
|
||||
"index": index,
|
||||
"status": status,
|
||||
"summary": brief,
|
||||
"result": child
|
||||
}));
|
||||
}
|
||||
let status = if unknown != 0 {
|
||||
"uncertain"
|
||||
} else if failed == 0 {
|
||||
"succeeded"
|
||||
} else if passed > 0 {
|
||||
"partial"
|
||||
} else {
|
||||
"failed"
|
||||
};
|
||||
Ok(json!({
|
||||
"ok": failed == 0 && unknown == 0,
|
||||
"schema": "AgentParallelResultV1",
|
||||
"status": status,
|
||||
"succeeded": passed,
|
||||
"failed": failed,
|
||||
"uncertain": unknown,
|
||||
"items": entries
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn preserves_success_and_exposes_failed_child() {
|
||||
let result = report(&json!({"results":[
|
||||
{"ok":true,"value":{"code":0,"value":"good"}},
|
||||
{"ok":true,"value":{"code":2,"stderr":"failed"}},
|
||||
{"ok":false,"error":"timeout"}
|
||||
]})).unwrap();
|
||||
assert_eq!(result["status"], "partial");
|
||||
assert_eq!(result["succeeded"], 1);
|
||||
assert_eq!(result["failed"], 2);
|
||||
assert_eq!(result["items"][0]["status"], "succeeded");
|
||||
}
|
||||
#[test]
|
||||
fn unknown_child_cannot_be_mislabeled_successful() {
|
||||
let value = report(&json!({"results":[{"ok":true,"value":{"value":"no code"}}]})).unwrap();
|
||||
assert_eq!(value["status"], "uncertain");
|
||||
assert_eq!(value["ok"], false);
|
||||
}
|
||||
}
|
||||
+11
-13
@@ -85,6 +85,8 @@ fn ensure_dir(root: &Path) -> Result<(), String> {
|
||||
}
|
||||
|
||||
/// Atomic durable write: unique temp → write → flush/fsync → rename.
|
||||
static TEMP_SEQUENCE: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
|
||||
|
||||
fn atomic_write_json(path: &Path, doc: &Value) -> Result<(), String> {
|
||||
let parent = path
|
||||
.parent()
|
||||
@@ -96,7 +98,8 @@ fn atomic_write_json(path: &Path, doc: &Value) -> Result<(), String> {
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or("ckpt.json"),
|
||||
std::process::id(),
|
||||
now_rfc3339().replace(':', "")
|
||||
format!("{}-{}", now_rfc3339().replace(':', ""),
|
||||
TEMP_SEQUENCE.fetch_add(1, std::sync::atomic::Ordering::Relaxed))
|
||||
);
|
||||
let tmp = parent.join(tmp_name);
|
||||
let text = serde_json::to_string_pretty(doc).map_err(|e| e.to_string())?;
|
||||
@@ -396,7 +399,8 @@ mod tests {
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_nanos();
|
||||
let dir = std::env::temp_dir().join(format!("marqdo-resume-{label}-{nanos}"));
|
||||
// Do not mutate process-wide cwd from concurrent Rust unit tests.
|
||||
let dir = PathBuf::from("target").join(format!("marqdo-resume-{label}-{nanos}"));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
}
|
||||
@@ -410,10 +414,7 @@ mod tests {
|
||||
#[test]
|
||||
fn atomic_v2_roundtrip_and_legacy_manual_review() {
|
||||
let dir = scratch("v2");
|
||||
// Use relative path via env cwd — chdir into scratch for this test.
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let rel = "ckpts";
|
||||
let rel = dir.join("ckpts").to_string_lossy().to_string();
|
||||
let saved = resume_save(&json!({
|
||||
"id": "run1",
|
||||
"schema": "CheckpointV2",
|
||||
@@ -491,23 +492,20 @@ mod tests {
|
||||
assert_eq!(unsafe_ck["recovery_mode"], "checkpoint_v2_read_only");
|
||||
assert_eq!(unsafe_ck["write_auto_resume"], false);
|
||||
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corrupt_checkpoint_reports_error() {
|
||||
let dir = scratch("corrupt");
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
fs::create_dir_all("ckpts").unwrap();
|
||||
fs::write("ckpts/bad.json", "{not-json").unwrap();
|
||||
let loaded = resume_load(&json!({"id": "bad", "resume_dir": "ckpts"})).unwrap();
|
||||
let ckpts = dir.join("ckpts");
|
||||
fs::create_dir_all(&ckpts).unwrap();
|
||||
fs::write(ckpts.join("bad.json"), "{not-json").unwrap();
|
||||
let loaded = resume_load(&json!({"id": "bad", "resume_dir": ckpts.to_string_lossy()})).unwrap();
|
||||
assert_eq!(loaded["found"], true);
|
||||
assert_eq!(loaded["ok"], false);
|
||||
assert_eq!(loaded["error"]["code"], "checkpoint.corrupt");
|
||||
assert_eq!(loaded["recovery_mode"], "manual_review");
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,679 @@
|
||||
//! Plugin-only durable step workflow.
|
||||
//! No interpreter-frame serialization: every model/tool decision is a checkpointed
|
||||
//! transition. This state machine issues actions but never executes arbitrary code.
|
||||
|
||||
use std::fs::{self, OpenOptions};
|
||||
use std::path::PathBuf;
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use crate::{choice, parallel, resume};
|
||||
|
||||
const MAX_STEPS: usize = 128;
|
||||
|
||||
struct Guard(PathBuf);
|
||||
impl Drop for Guard {
|
||||
fn drop(&mut self) { let _ = fs::remove_file(&self.0); }
|
||||
}
|
||||
|
||||
fn field<'a>(v: &'a Value, key: &str) -> Result<&'a str, String> {
|
||||
v.get(key).and_then(Value::as_str).filter(|x| !x.is_empty())
|
||||
.ok_or_else(|| format!("workflow requires text {key}"))
|
||||
}
|
||||
|
||||
fn safe_key(s: &str) -> bool {
|
||||
!s.is_empty() && s.len() <= 100
|
||||
&& s.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
|
||||
}
|
||||
|
||||
fn storage(args: &Value) -> Result<PathBuf, String> {
|
||||
let rel = args.get("resume_dir").and_then(Value::as_str)
|
||||
.unwrap_or(".marqdo/agent-resume");
|
||||
let path = PathBuf::from(rel);
|
||||
if path.is_absolute() || path.components().any(|part|
|
||||
matches!(part, std::path::Component::ParentDir | std::path::Component::Prefix(_)))
|
||||
{
|
||||
return Err("resume_dir must be relative with no parent traversal".into());
|
||||
}
|
||||
let base = crate::host_query_json("cwd").ok()
|
||||
.and_then(|v| v.as_str().map(PathBuf::from))
|
||||
.unwrap_or(std::env::current_dir().map_err(|e| e.to_string())?);
|
||||
let dir = base.join(path);
|
||||
fs::create_dir_all(&dir).map_err(|e| format!("workflow mkdir: {e}"))?;
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
fn lock(args: &Value, id: &str) -> Result<Guard, String> {
|
||||
if !safe_key(id) {
|
||||
return Err("workflow id must be <=100 ASCII letters, numbers, - or _".into());
|
||||
}
|
||||
let path = storage(args)?.join(format!("{id}.flow-lock"));
|
||||
OpenOptions::new().write(true).create_new(true).open(&path)
|
||||
.map_err(|e| format!("workflow busy or stale lock; review before recovering: {e}"))?;
|
||||
Ok(Guard(path))
|
||||
}
|
||||
|
||||
fn checkpoint_args(args: &Value, id: &str) -> Value {
|
||||
json!({"id": id, "resume_dir": args.get("resume_dir")})
|
||||
}
|
||||
|
||||
fn read(args: &Value, id: &str) -> Result<Value, String> {
|
||||
resume::resume_load(&checkpoint_args(args,id))
|
||||
}
|
||||
|
||||
fn context(args: &Value) -> Value {
|
||||
json!({
|
||||
"source_revision": args.get("source_revision").cloned().unwrap_or(Value::Null),
|
||||
"session_id": args.get("session_id").cloned().unwrap_or(Value::Null),
|
||||
"principal_ref": args.get("principal_ref").cloned().unwrap_or(Value::Null)
|
||||
})
|
||||
}
|
||||
|
||||
fn check_context(args: &Value, ckpt: &Value) -> bool {
|
||||
ckpt["meta"]["identity"] == context(args)
|
||||
}
|
||||
|
||||
fn validate_steps(args: &Value) -> Result<Value, String> {
|
||||
let steps = args.get("steps").and_then(Value::as_array)
|
||||
.ok_or_else(|| "steps must be a list".to_string())?;
|
||||
if steps.is_empty() || steps.len() > MAX_STEPS {
|
||||
return Err("steps must contain 1..=128 items".into());
|
||||
}
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
for s in steps {
|
||||
let id = field(s, "id")?;
|
||||
if !safe_key(id) || !seen.insert(id) {
|
||||
return Err("step ids must be unique safe identifiers".into());
|
||||
}
|
||||
let kind = field(s, "kind")?;
|
||||
if !matches!(kind, "model" | "input" | "skill" | "parallel" | "return") {
|
||||
return Err(format!("unsupported step kind: {kind}"));
|
||||
}
|
||||
if matches!(kind, "model" | "input") {
|
||||
let options = s.get("options").and_then(Value::as_array)
|
||||
.ok_or_else(|| "choice step requires options list".to_string())?;
|
||||
let _ = choice::parse_choice(&json!({"reply":"","options":options}))?;
|
||||
if kind == "input" { let _ = field(s, "question")?; }
|
||||
if kind == "model" { let _ = field(s, "prompt")?; }
|
||||
}
|
||||
if kind == "skill" { let _ = field(s, "skill")?; }
|
||||
if kind == "parallel" && !s.get("tasks").is_some_and(Value::is_array) {
|
||||
return Err("parallel step requires tasks array".into());
|
||||
}
|
||||
}
|
||||
// Resolve all branch targets against frozen, forward-only step IDs.
|
||||
for (i, s) in steps.iter().enumerate() {
|
||||
let targets = s.get("next").and_then(Value::as_str).into_iter()
|
||||
.chain(s.get("routes").and_then(Value::as_object)
|
||||
.into_iter().flat_map(|m| m.values().filter_map(Value::as_str)));
|
||||
for target in targets {
|
||||
let position = steps.iter().position(|x|x["id"]==target)
|
||||
.ok_or_else(|| format!("unknown workflow target: {target}"))?;
|
||||
if position <= i {
|
||||
return Err("workflow routes must move forward to avoid loops".into());
|
||||
}
|
||||
}
|
||||
if let Some(routes)=s.get("routes").and_then(Value::as_object) {
|
||||
if !matches!(s["kind"].as_str(),Some("model"|"input")) {
|
||||
return Err("only choice steps may declare routes".into());
|
||||
}
|
||||
for key in routes.keys() {
|
||||
if !s["options"].as_array().is_some_and(|opts|
|
||||
opts.iter().any(|x|x.as_str()==Some(key.as_str()))) {
|
||||
return Err("route label is not a declared choice".into());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Value::Array(steps.clone()))
|
||||
}
|
||||
|
||||
fn advance_cursor(step:&Value, value:&Value, steps:&[Value], current:usize)->Result<usize,String> {
|
||||
let target=if let Some(routes)=step.get("routes").and_then(Value::as_object) {
|
||||
let label=value.as_str().ok_or("routed choice must return a text label")?;
|
||||
Some(routes.get(label).and_then(Value::as_str)
|
||||
.ok_or("chosen option is missing a declared route")?)
|
||||
} else {
|
||||
step.get("next").and_then(Value::as_str)
|
||||
};
|
||||
match target {
|
||||
None=>Ok(current+1),
|
||||
Some(name)=> {
|
||||
let n=steps.iter().position(|s|s["id"]==name)
|
||||
.ok_or("unknown target after checkpoint recovery")?;
|
||||
if n<=current {return Err("cyclic route refused".into())}
|
||||
Ok(n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn state(ckpt: &Value) -> Result<(&Value,usize),String> {
|
||||
let meta = ckpt.get("meta").ok_or("missing workflow metadata")?;
|
||||
if meta.get("kind").and_then(Value::as_str) != Some("MarqdoAgentFlowV1") {
|
||||
return Err("checkpoint is not a workflow".into());
|
||||
}
|
||||
let index = meta.get("cursor").and_then(Value::as_u64)
|
||||
.ok_or("missing workflow cursor")? as usize;
|
||||
Ok((meta,index))
|
||||
}
|
||||
|
||||
fn save(args: &Value, id: &str, meta: &Value, status: &str) -> Result<(),String> {
|
||||
let result = resume::resume_save(&json!({
|
||||
"id": id,
|
||||
"resume_dir": args.get("resume_dir"),
|
||||
"checkpoint_v2": true,
|
||||
"status": status,
|
||||
"meta": meta,
|
||||
"completed_steps": meta["completed"],
|
||||
"step_id": meta["steps"].get(meta["cursor"].as_u64().unwrap_or(0) as usize)
|
||||
.and_then(|x| x.get("id")).cloned().unwrap_or(Value::Null)
|
||||
}))?;
|
||||
if result["ok"] != true { return Err("workflow checkpoint write failed".into()); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Register a bounded, frozen plan. Re-opening never resets a progressed plan.
|
||||
pub fn open(args: &Value) -> Result<Value,String> {
|
||||
let id = field(args,"id")?;
|
||||
let _guard = lock(args,id)?;
|
||||
let revision = field(args,"source_revision")?;
|
||||
if revision.len()>256 { return Err("source_revision too long".into()); }
|
||||
let steps = validate_steps(args)?;
|
||||
let existing = read(args,id)?;
|
||||
let identity = context(args);
|
||||
if existing["found"] == true {
|
||||
if existing["ok"] == true
|
||||
&& existing["meta"]["identity"] == identity
|
||||
&& existing["meta"]["steps"] == steps
|
||||
{
|
||||
return next_doc(&existing,id,true);
|
||||
}
|
||||
return Ok(json!({"ok":false,"status":"conflict","error":"workflow.id_or_revision_reused"}));
|
||||
}
|
||||
let meta = json!({
|
||||
"kind":"MarqdoAgentFlowV1",
|
||||
"identity":identity,
|
||||
"steps":steps,
|
||||
"cursor":0,
|
||||
"completed":[],
|
||||
});
|
||||
save(args,id,&meta,"running")?;
|
||||
Ok(json!({"ok":true,"id":id,"status":"created","cursor":0}))
|
||||
}
|
||||
|
||||
fn next_doc(ckpt: &Value, id: &str, reused: bool) -> Result<Value,String> {
|
||||
let (meta,index)=state(ckpt)?;
|
||||
let steps = meta["steps"].as_array().ok_or("invalid steps")?;
|
||||
if index>=steps.len() {
|
||||
return Ok(json!({"ok":true,"id":id,"status":"succeeded",
|
||||
"cursor":index,"completed":meta["completed"],"reused":reused}));
|
||||
}
|
||||
let step=&steps[index];
|
||||
let status=ckpt["status"].as_str().unwrap_or("running");
|
||||
if status=="blocked" || status=="uncertain" || status=="cancelled" {
|
||||
return Ok(json!({"ok":false,"id":id,"status":status,
|
||||
"cursor":index,"step":step,"completed":meta["completed"],
|
||||
"partial": meta.get("partial").cloned().unwrap_or(Value::Null)}));
|
||||
}
|
||||
// Never auto-dispatch effectful or unclassified child documents.
|
||||
// Those must be executed using the existing EffectLedger policy and an
|
||||
// independently verified receipt, not an arbitrary model instruction.
|
||||
if (step["kind"]=="skill" || step["kind"]=="parallel")
|
||||
&& step["effect_class"]!="read"
|
||||
{
|
||||
return Ok(json!({"ok":false,"id":id,"status":"manual_review",
|
||||
"cursor":index,"step":step,
|
||||
"reason":"automatic child dispatch requires an explicit read-only effect class"}));
|
||||
}
|
||||
let waiting=match step["kind"].as_str().unwrap_or("") {
|
||||
"model"=>"waiting_model",
|
||||
"input"=>"waiting_input",
|
||||
"skill" | "parallel"=>"ready_tool",
|
||||
"return"=>"ready_return",
|
||||
_=>"blocked"
|
||||
};
|
||||
Ok(json!({"ok":true,"id":id,"status":waiting,
|
||||
"cursor":index,"step":step,"completed":meta["completed"],"reused":reused}))
|
||||
}
|
||||
|
||||
/// Query the durable next action. This is non-blocking and does not invoke LLM.
|
||||
pub fn next(args: &Value) -> Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"id":id,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
next_doc(&ckpt,id,false)
|
||||
}
|
||||
|
||||
/// Read a workflow summary without advancing it or running any step.
|
||||
/// The caller-supplied identity must match the checkpoint, exactly like next.
|
||||
pub fn inspect(args:&Value)->Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"id":id,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
let (meta,index)=state(&ckpt)?;
|
||||
let steps=meta["steps"].as_array().ok_or("invalid steps")?;
|
||||
let completed=meta["completed"].as_array().ok_or("invalid completed")?;
|
||||
// `status` is the durable checkpoint status; `action` is what tick would
|
||||
// observe next (waiting_model, waiting_input, ready_tool, ...).
|
||||
let action=next_doc(&ckpt,id,false)?.get("status").cloned().unwrap_or(Value::Null);
|
||||
Ok(json!({
|
||||
"ok":true,"id":id,
|
||||
"status":ckpt["status"].as_str().unwrap_or("running"),
|
||||
"action":action,
|
||||
"cursor":index,
|
||||
"total_steps":steps.len(),
|
||||
"completed_steps":completed.len(),
|
||||
"completed":meta["completed"],
|
||||
"step":steps.get(index).cloned().unwrap_or(Value::Null),
|
||||
"partial":meta.get("partial").cloned().unwrap_or(Value::Null),
|
||||
"identity":meta["identity"],
|
||||
"updated_at":ckpt.get("updated_at").cloned().unwrap_or(Value::Null)
|
||||
}))
|
||||
}
|
||||
|
||||
/// List workflow checkpoints in the (host-relative) resume directory.
|
||||
/// Non-workflow checkpoints and corrupt entries are omitted. When the caller
|
||||
/// supplies an attested session or principal, only matching runs are returned.
|
||||
pub fn list(args:&Value)->Result<Value,String> {
|
||||
let dir=storage(args)?;
|
||||
let session=args.get("session_id").and_then(Value::as_str);
|
||||
let principal=args.get("principal_ref").and_then(Value::as_str);
|
||||
let mut items=Vec::new();
|
||||
let rd=fs::read_dir(&dir).map_err(|e|format!("workflow list: {e}"))?;
|
||||
for ent in rd.flatten() {
|
||||
let path=ent.path();
|
||||
if path.extension().and_then(|x|x.to_str())!=Some("json") { continue; }
|
||||
if path.file_name().and_then(|x|x.to_str())
|
||||
.map(|x|x.starts_with('.')).unwrap_or(false) { continue; }
|
||||
let Ok(text)=fs::read_to_string(&path) else { continue };
|
||||
let Ok(doc)=serde_json::from_str::<Value>(&text) else { continue };
|
||||
let meta=&doc["meta"];
|
||||
if meta["kind"].as_str()!=Some("MarqdoAgentFlowV1") { continue; }
|
||||
if session.is_some() && meta["identity"]["session_id"].as_str()!=session { continue; }
|
||||
if principal.is_some() && meta["identity"]["principal_ref"].as_str()!=principal { continue; }
|
||||
let steps=meta["steps"].as_array().map(|x|x.len()).unwrap_or(0);
|
||||
let completed=meta["completed"].as_array().map(|x|x.len()).unwrap_or(0);
|
||||
items.push(json!({
|
||||
"id":doc.get("id").cloned().unwrap_or(Value::Null),
|
||||
"status":doc.get("status").cloned().unwrap_or(Value::Null),
|
||||
"cursor":meta.get("cursor").cloned().unwrap_or(Value::Null),
|
||||
"total_steps":steps,
|
||||
"completed_steps":completed,
|
||||
"source_revision":meta["identity"]["source_revision"],
|
||||
"updated_at":doc.get("updated_at").cloned().unwrap_or(Value::Null)
|
||||
}));
|
||||
}
|
||||
items.sort_by(|a,b| a["id"].as_str().cmp(&b["id"].as_str()));
|
||||
Ok(json!({"ok":true,"items":items,"resume_dir":dir.to_string_lossy()}))
|
||||
}
|
||||
|
||||
/// Commit a verified result for the exact current step. All mutations are
|
||||
/// serialized with a lock; a completed step cannot be committed a second time.
|
||||
pub fn commit(args: &Value) -> Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let _guard=lock(args,id)?;
|
||||
let step_id=field(args,"step_id")?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
let (meta,index)=state(&ckpt)?;
|
||||
let steps=meta["steps"].as_array().ok_or("invalid steps")?;
|
||||
let response=args.get("response").ok_or("missing response")?;
|
||||
if index>=steps.len() {
|
||||
let previous = meta["completed"].as_array().ok_or("invalid completed")?;
|
||||
if previous.iter().any(|x|x["step_id"]==step_id && x["value"]==*response) {
|
||||
return Ok(json!({"ok":true,"status":"succeeded","reused":true}));
|
||||
}
|
||||
return Ok(json!({"ok":false,"status":"already_finished"}));
|
||||
}
|
||||
let step=&steps[index];
|
||||
if step["id"]!=step_id {
|
||||
if meta["completed"].as_array().is_some_and(|list|
|
||||
list.iter().any(|x|x["step_id"]==step_id && x["value"]==*response))
|
||||
{
|
||||
return Ok(json!({"ok":true,"status":"already_committed","reused":true}));
|
||||
}
|
||||
return Ok(json!({"ok":false,"status":"step_conflict"}));
|
||||
}
|
||||
if ckpt["status"]!="running" {
|
||||
return Ok(json!({"ok":false,"status":"blocked","reason":ckpt["status"]}));
|
||||
}
|
||||
let kind=field(step,"kind")?;
|
||||
let value = match kind {
|
||||
"model" | "input" => {
|
||||
let reply = response.as_str().ok_or("model/input response must be text")?;
|
||||
let valid=choice::parse_choice(&json!({"options":step["options"],"reply":reply}))?;
|
||||
if valid["ok"]!=true {
|
||||
return Ok(json!({"ok":false,"status":"invalid_choice",
|
||||
"error":valid["error"]}));
|
||||
}
|
||||
valid["value"].clone()
|
||||
}
|
||||
"skill" => {
|
||||
// A completed wait is not equivalent to a successful child process.
|
||||
let exit = response.get("value").and_then(|v| v.get("code"))
|
||||
.or_else(|| response.get("code")).and_then(Value::as_i64);
|
||||
if response["ok"]==false || exit != Some(0) {
|
||||
return Ok(json!({"ok":false,
|
||||
"status":if exit.is_none() {"uncertain"} else {"failed"},
|
||||
"reason":"child process exit code zero is required before commit"}));
|
||||
}
|
||||
response.clone()
|
||||
}
|
||||
"parallel" => {
|
||||
let report=if response["schema"]=="AgentParallelResultV1" {
|
||||
response.clone()
|
||||
} else {
|
||||
parallel::report(&json!({"results":response}))?
|
||||
};
|
||||
if report["ok"]!=true {
|
||||
let status=if report["uncertain"].as_u64().unwrap_or(0)>0 {
|
||||
"uncertain"
|
||||
} else {"blocked"};
|
||||
// Save the full manifest of successful and failed siblings before
|
||||
// returning. Do not run failed/unknown children automatically.
|
||||
let mut frozen=meta.clone();
|
||||
frozen["partial"]=report.clone();
|
||||
save(args,id,&frozen,status)?;
|
||||
return Ok(json!({"ok":false,"status":status,
|
||||
"report":report,"reason":"child results retained for reconciliation"}));
|
||||
}
|
||||
report
|
||||
}
|
||||
"return" => response.clone(),
|
||||
_ => return Err("invalid step kind".into()),
|
||||
};
|
||||
let target=advance_cursor(step,&value,steps,index)?;
|
||||
let mut new_meta=meta.clone();
|
||||
new_meta["cursor"]=json!(target);
|
||||
new_meta["completed"].as_array_mut().ok_or("completed not array")?
|
||||
.push(json!({"step_id":step_id,"value":value}));
|
||||
let terminal=target==steps.len();
|
||||
save(args,id,&new_meta,if terminal {"succeeded"} else {"running"})?;
|
||||
Ok(json!({"ok":true,"id":id,
|
||||
"status":if terminal {"succeeded"} else {"advanced"},
|
||||
"cursor":target,"value":value,"reused":false}))
|
||||
}
|
||||
|
||||
/// Produce a plan containing only previously failed *read-only* child tasks.
|
||||
/// "uncertain" children and effectful plans cannot be blindly retried.
|
||||
pub fn retry_plan(args: &Value) -> Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
let (meta,index)=state(&ckpt)?;
|
||||
if ckpt["status"]!="blocked" {
|
||||
return Ok(json!({"ok":false,"status":"not_retryable"}));
|
||||
}
|
||||
let step=&meta["steps"][index];
|
||||
if step["kind"]!="parallel" || step["effect_class"]!="read"
|
||||
|| meta["partial"]["uncertain"].as_u64().unwrap_or(1)!=0
|
||||
{
|
||||
return Ok(json!({"ok":false,"status":"manual_reconciliation_required"}));
|
||||
}
|
||||
let Some(items)=meta["partial"]["items"].as_array() else {
|
||||
return Err("partial report has no items".into());
|
||||
};
|
||||
let Some(tasks)=step["tasks"].as_array() else {
|
||||
return Err("parallel plan has no tasks".into());
|
||||
};
|
||||
if items.len()!=tasks.len() {
|
||||
return Err("partial report task count mismatch".into());
|
||||
}
|
||||
let mut failed=Vec::new();
|
||||
let mut indices=Vec::new();
|
||||
for (i,item) in items.iter().enumerate() {
|
||||
if item["index"]!=i {
|
||||
return Err("out-of-order child result index".into());
|
||||
}
|
||||
if item["status"]=="failed" {
|
||||
failed.push(tasks[i].clone());
|
||||
indices.push(i);
|
||||
} else if item["status"]!="succeeded" {
|
||||
return Ok(json!({"ok":false,"status":"manual_reconciliation_required"}));
|
||||
}
|
||||
}
|
||||
Ok(json!({"ok":true,"status":"retry_read_only",
|
||||
"id":id,"step_id":step["id"],"tasks":failed,"indices":indices}))
|
||||
}
|
||||
|
||||
/// Merge only the failed child slots with verified new outcomes.
|
||||
/// Successful results and their order remain untouched.
|
||||
pub fn retry_commit(args: &Value) -> Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let _guard=lock(args,id)?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
let (meta,index)=state(&ckpt)?;
|
||||
if ckpt["status"]!="blocked" {
|
||||
return Ok(json!({"ok":false,"status":"not_retryable"}));
|
||||
}
|
||||
let step=&meta["steps"][index];
|
||||
if step["kind"]!="parallel" || step["effect_class"]!="read"
|
||||
|| meta["partial"]["uncertain"].as_u64().unwrap_or(1)!=0
|
||||
{
|
||||
return Ok(json!({"ok":false,"status":"manual_reconciliation_required"}));
|
||||
}
|
||||
let items=meta["partial"]["items"].as_array()
|
||||
.ok_or("invalid partial report")?;
|
||||
let incoming=args.get("results").and_then(Value::as_array)
|
||||
.ok_or("retry_commit requires results list")?;
|
||||
let expected=items.iter().filter(|it|it["status"]=="failed").count();
|
||||
if incoming.len()!=expected {
|
||||
return Err("retry result count differs from failed child count".into());
|
||||
}
|
||||
let mut next=Vec::with_capacity(items.len());
|
||||
let mut replacement=incoming.iter();
|
||||
for item in items {
|
||||
if item["status"]=="succeeded" {
|
||||
next.push(item["result"].clone());
|
||||
} else if item["status"]=="failed" {
|
||||
next.push(replacement.next().ok_or("missing retry result")?.clone());
|
||||
} else {
|
||||
return Ok(json!({"ok":false,"status":"manual_reconciliation_required"}));
|
||||
}
|
||||
}
|
||||
let report=parallel::report(&json!({"results":next}))?;
|
||||
let mut updated=meta.clone();
|
||||
if report["ok"]==true {
|
||||
let target=advance_cursor(step,&report,
|
||||
updated["steps"].as_array().ok_or("steps missing")?,index)?;
|
||||
updated["cursor"]=json!(target);
|
||||
updated["partial"]=Value::Null;
|
||||
updated["completed"].as_array_mut().ok_or("completed not list")?
|
||||
.push(json!({"step_id":step["id"],"value":report}));
|
||||
let finished=target==updated["steps"].as_array().ok_or("steps missing")?.len();
|
||||
save(args,id,&updated,if finished {"succeeded"} else {"running"})?;
|
||||
Ok(json!({"ok":true,"status":if finished {"succeeded"} else {"advanced"},
|
||||
"cursor":target,"result":report}))
|
||||
} else {
|
||||
updated["partial"]=report.clone();
|
||||
save(args,id,&updated,if report["uncertain"].as_u64().unwrap_or(0)>0 {
|
||||
"uncertain" } else {"blocked"})?;
|
||||
Ok(json!({"ok":false,"status":"blocked","report":report}))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cancel(args: &Value) -> Result<Value,String> {
|
||||
let id=field(args,"id")?;
|
||||
let _guard=lock(args,id)?;
|
||||
let ckpt=read(args,id)?;
|
||||
if ckpt["ok"]!=true || !check_context(args,&ckpt) {
|
||||
return Ok(json!({"ok":false,"status":"not_found_or_mismatched"}));
|
||||
}
|
||||
if ckpt["status"]=="succeeded" {
|
||||
return Ok(json!({"ok":false,"status":"already_finished"}));
|
||||
}
|
||||
let (meta,_)=state(&ckpt)?;
|
||||
save(args,id,meta,"cancelled")?;
|
||||
Ok(json!({"ok":true,"id":id,"status":"cancelled"}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::atomic::{AtomicU64,Ordering};
|
||||
static SEQ: AtomicU64=AtomicU64::new(0);
|
||||
fn fixture()->Value {
|
||||
let n=SEQ.fetch_add(1,Ordering::Relaxed);
|
||||
json!({"id":format!("wf-{}-{n}",std::process::id()),
|
||||
"resume_dir":format!("target/workflow-test-{}-{n}",std::process::id()),
|
||||
"source_revision":"v1",
|
||||
"steps":[
|
||||
{"id":"choose","kind":"model","prompt":"Choose a skill","options":["chat","office"]},
|
||||
{"id":"answer","kind":"input","question":"OK?","options":["yes","no"]},
|
||||
{"id":"end","kind":"return"}
|
||||
]})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nonblocking_model_then_input_then_terminal() {
|
||||
let a=fixture();
|
||||
assert_eq!(open(&a).unwrap()["status"],"created");
|
||||
assert_eq!(next(&a).unwrap()["status"],"waiting_model");
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("choose");
|
||||
c["response"]=json!("office");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"advanced");
|
||||
assert_eq!(next(&a).unwrap()["status"],"waiting_input");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"already_committed");
|
||||
c["step_id"]=json!("answer");
|
||||
c["response"]=json!("yes");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"advanced");
|
||||
c["step_id"]=json!("end");
|
||||
c["response"]=json!("ok");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"succeeded");
|
||||
assert_eq!(next(&a).unwrap()["status"],"succeeded");
|
||||
assert_eq!(open(&a).unwrap()["status"],"succeeded");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_and_write_effects_never_auto_dispatch() {
|
||||
let mut a=fixture();
|
||||
a["steps"]=json!([{"id":"publish","kind":"skill","skill":"office"}]);
|
||||
open(&a).unwrap();
|
||||
assert_eq!(next(&a).unwrap()["status"],"manual_review");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn routes_skip_unselected_skill_branches() {
|
||||
let mut a=fixture();
|
||||
a["steps"]=json!([
|
||||
{"id":"decide","kind":"model","prompt":"Pick","options":["chat","office"],
|
||||
"routes":{"chat":"chat_skill","office":"office_skill"}},
|
||||
{"id":"chat_skill","kind":"skill","skill":"chat","effect_class":"read","next":"done"},
|
||||
{"id":"office_skill","kind":"skill","skill":"office","effect_class":"read","next":"done"},
|
||||
{"id":"done","kind":"return"}
|
||||
]);
|
||||
open(&a).unwrap();
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("decide");
|
||||
c["response"]=json!("office");
|
||||
assert_eq!(commit(&c).unwrap()["cursor"],2);
|
||||
assert_eq!(next(&a).unwrap()["step"]["id"],"office_skill");
|
||||
c["step_id"]=json!("office_skill");
|
||||
c["response"]=json!({"ok":true,"value":{"code":0}});
|
||||
assert_eq!(commit(&c).unwrap()["cursor"],3);
|
||||
assert_eq!(next(&a).unwrap()["step"]["id"],"done");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn source_change_conflict_and_invalid_model_choice() {
|
||||
let a=fixture();
|
||||
open(&a).unwrap();
|
||||
let mut bad=a.clone();
|
||||
bad["source_revision"]=json!("v2");
|
||||
assert_eq!(next(&bad).unwrap()["status"],"not_found_or_mismatched");
|
||||
assert_eq!(open(&bad).unwrap()["status"],"conflict");
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("choose");
|
||||
c["response"]=json!("chat or office");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"invalid_choice");
|
||||
assert_eq!(next(&a).unwrap()["status"],"waiting_model");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_children_remain_durable_and_unknown_requires_reconciliation() {
|
||||
let mut a=fixture();
|
||||
a["steps"]=json!([{"id":"batch","kind":"parallel","tasks":[{"skill":"a"},{"skill":"b"}]}]);
|
||||
open(&a).unwrap();
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("batch");
|
||||
c["response"]=json!([
|
||||
{"ok":true,"value":{"code":0,"value":"useful"}},
|
||||
{"ok":false,"error":"connection lost"}
|
||||
]);
|
||||
assert_eq!(commit(&c).unwrap()["status"],"blocked");
|
||||
let after=next(&a).unwrap();
|
||||
assert_eq!(after["status"],"blocked");
|
||||
assert_eq!(after["partial"]["succeeded"],1);
|
||||
assert_eq!(after["partial"]["failed"],1);
|
||||
assert_eq!(commit(&c).unwrap()["status"],"blocked");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retries_only_failed_read_only_children_without_redoing_successes() {
|
||||
let mut a=fixture();
|
||||
a["steps"]=json!([{"id":"batch","kind":"parallel","effect_class":"read",
|
||||
"tasks":[{"path":"a.mq.md"},{"path":"b.mq.md"}]}]);
|
||||
open(&a).unwrap();
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("batch");
|
||||
c["response"]=json!([
|
||||
{"ok":true,"value":{"code":0,"value":"keep"}},
|
||||
{"ok":false,"error":"temporary timeout"}
|
||||
]);
|
||||
assert_eq!(commit(&c).unwrap()["status"],"blocked");
|
||||
let plan=retry_plan(&a).unwrap();
|
||||
assert_eq!(plan["indices"],json!([1]));
|
||||
assert_eq!(plan["tasks"].as_array().unwrap().len(),1);
|
||||
let mut retry=a.clone();
|
||||
retry["results"]=json!([{"ok":true,"value":{"code":0,"value":"fixed"}}]);
|
||||
assert_eq!(retry_commit(&retry).unwrap()["status"],"succeeded");
|
||||
let out=next(&a).unwrap();
|
||||
assert_eq!(out["completed"][0]["value"]["items"][0]["result"]["value"]["value"],"keep");
|
||||
assert_eq!(out["completed"][0]["value"]["items"][1]["result"]["value"]["value"],"fixed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inspect_and_list_are_read_only_and_session_scoped() {
|
||||
let mut a=fixture();
|
||||
a["session_id"]=json!("s1");
|
||||
a["principal_ref"]=json!("u1");
|
||||
open(&a).unwrap();
|
||||
let seen=inspect(&a).unwrap();
|
||||
assert_eq!(seen["status"],"running");
|
||||
assert_eq!(seen["action"],"waiting_model");
|
||||
assert_eq!(seen["total_steps"],3);
|
||||
assert_eq!(seen["completed_steps"],0);
|
||||
assert_eq!(seen["step"]["id"],"choose");
|
||||
// Inspection must not consume the current step.
|
||||
assert_eq!(next(&a).unwrap()["status"],"waiting_model");
|
||||
let listed=list(&a).unwrap();
|
||||
assert!(listed["items"].as_array().unwrap()
|
||||
.iter().any(|x|x["id"]==a["id"]));
|
||||
let mut other=a.clone();
|
||||
other["session_id"]=json!("s2");
|
||||
assert_eq!(inspect(&other).unwrap()["status"],"not_found_or_mismatched");
|
||||
assert!(list(&other).unwrap()["items"].as_array().unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_cancel_stops_future_commits() {
|
||||
let a=fixture();
|
||||
open(&a).unwrap();
|
||||
assert_eq!(cancel(&a).unwrap()["status"],"cancelled");
|
||||
let mut c=a.clone();
|
||||
c["step_id"]=json!("choose");
|
||||
c["response"]=json!("chat");
|
||||
assert_eq!(commit(&c).unwrap()["status"],"blocked");
|
||||
}
|
||||
}
|
||||
@@ -32,10 +32,16 @@ fn read_bounded(mut r: impl Read, max: u64) -> Result<Vec<u8>, String> {
|
||||
if b.len() as u64 > max { return Err("bounded input limit exceeded".into()); }
|
||||
Ok(b)
|
||||
}
|
||||
fn strip_verbatim(path: &Path) -> &Path {
|
||||
path.strip_prefix(r"\\?\").unwrap_or(path)
|
||||
}
|
||||
|
||||
fn scoped(root: &Path, relative: &str) -> Result<PathBuf, String> {
|
||||
let p = root.join(relative).canonicalize().map_err(|_| "path does not exist")?;
|
||||
if !p.starts_with(root) { return Err("artifact path escapes the selected root".into()); }
|
||||
Ok(p)
|
||||
if p.starts_with(root) || strip_verbatim(&p).starts_with(strip_verbatim(root)) {
|
||||
return Ok(p);
|
||||
}
|
||||
Err("artifact path escapes the selected root".into())
|
||||
}
|
||||
fn homes(root: &Path) -> Vec<PathBuf> {
|
||||
let mut out = Vec::new();
|
||||
@@ -498,8 +504,24 @@ fn gzip_text(p: &Value) -> Answer {
|
||||
Ok(json!(String::from_utf8(plain).map_err(|_| "gzip text is not UTF-8")?))
|
||||
}
|
||||
|
||||
fn resolve_root(request: &Value) -> Result<PathBuf, String> {
|
||||
let raw = request.get("root").and_then(Value::as_str).unwrap_or(".");
|
||||
let selected = PathBuf::from(raw);
|
||||
if let Ok(path) = selected.canonicalize() {
|
||||
return Ok(path);
|
||||
}
|
||||
// Relative grants must still resolve when the caller only passed "." and the
|
||||
// process cwd is the intended checkout (Windows runners are sensitive here).
|
||||
if raw == "." || raw.is_empty() {
|
||||
return std::env::current_dir()
|
||||
.and_then(|p| p.canonicalize())
|
||||
.map_err(|e| format!("root does not exist ({raw}: {e})"));
|
||||
}
|
||||
Err(format!("root does not exist ({raw})"))
|
||||
}
|
||||
|
||||
fn dispatch(request:&Value)->Answer {
|
||||
let root=PathBuf::from(request.get("root").and_then(Value::as_str).unwrap_or(".")).canonicalize().map_err(|_|"root does not exist")?;
|
||||
let root=resolve_root(request)?;
|
||||
let op=field(request,"operation")?;
|
||||
let empty=json!({});let p=request.get("payload").unwrap_or(&empty);
|
||||
match op {
|
||||
|
||||
@@ -15,7 +15,7 @@ import:
|
||||
|
||||
This leaf builds source and one platform's native extension archives for an authorized version. It does not publish, choose a version, create a tag or edit version files. The extension-release workflow runs the same tasks on Windows and Linux after local.tag pushes ext-vX.Y.Z. Its attach_ci task creates the exact tagged release through the native service boundary and attaches three assets with the existing gh upload tool; assets.publish subsequently verifies those exact bytes before R2 publication.
|
||||
|
||||
Build all six maintained native plugins first. The native_dir contract is a directory containing their platform library names, normally target/release. Source discovery and staging use native Marqdo filesystem operations. Only ZIP encoding uses the existing platform tool: Info-ZIP on Linux, the installed bsdtar on Windows. Compiler and format boundaries do not require Python or a generated shell program.
|
||||
Build all six maintained native plugins first. The native_dir contract is a directory containing their platform library names, normally target/release. Source discovery and staging use native Marqdo filesystem operations. Only ZIP encoding uses the existing platform tool: Info-ZIP on Linux, 7-Zip on Windows. Compiler and format boundaries do not require Python or a generated shell program.
|
||||
|
||||
## libraries
|
||||
|
||||
@@ -74,7 +74,7 @@ Return *[Reject an unsupported native target](result.error(code="packs.platform"
|
||||
|
||||
Use `stage`, `entry`, `output` and `platform` only after build preflight. Native resolution validates the stage and output paths first; the encoder receives individual arguments and one named staging subtree. It cannot expand a generated shell expression. A failed encoder can leave the selected incomplete archive for inspection; this task never reuses it as successful output or deletes unrelated files.
|
||||
|
||||
The Windows runner supplies bsdtar with ZIP format support; Linux supplies Info-ZIP. Format encoding is the only external operation here. Reads, directory creation, copies, hashes and final ZIP validation remain separate explicit native tasks. The caller removes only its owned temporary stage after the child exits. Existing archives require inspection or a different output directory, keeping reruns from silently replacing publication candidates.
|
||||
The Windows runner supplies 7-Zip with ZIP format support; Linux supplies Info-ZIP. Format encoding is the only external operation here. Reads, directory creation, copies, hashes and final ZIP validation remain separate explicit native tasks. The caller removes only its owned temporary stage after the child exits. Existing archives require inspection or a different output directory, keeping reruns from silently replacing publication candidates.
|
||||
|
||||
1. [This output already belongs to an earlier attempt](fs.exists(path=`output`))
|
||||
Return *[Preserve the existing archive](result.error(code="packs.output_exists", message=`output`, operation="_archive"))*.
|
||||
@@ -96,13 +96,14 @@ We **destination = [Resolve the new archive inside the granted root](fs.resolve(
|
||||
|
||||
| argument |
|
||||
|---|
|
||||
| tar |
|
||||
| "--format=zip" |
|
||||
| "-cf" |
|
||||
| "C:\\Program Files\\7-Zip\\7z.exe" |
|
||||
| a |
|
||||
| "-tzip" |
|
||||
| `destination` |
|
||||
| `entry` |
|
||||
|
||||
Return *[Encode only the explicitly staged format subtree](engineering.checked(argv=`argv`, cwd=`stage`, timeout_ms=300000, max_output=65536))*.
|
||||
We **checkout = [Use the absolute runtime checkout as the plugin root](sys.cwd())**.
|
||||
Return *[Encode only the explicitly staged format subtree](engineering.checked(argv=`argv`, cwd=`stage`, timeout_ms=300000, max_output=65536, root=`checkout`))*.
|
||||
|
||||
## _receipt
|
||||
|
||||
|
||||
+12
@@ -97,6 +97,18 @@ pub struct Function {
|
||||
pub var_contracts: HashMap<String, crate::contract::Contract>,
|
||||
/// 定理表(ADR 0010):函数级命题声明;首条可执行语句之前提取,不参与运行。
|
||||
pub claims: Vec<Claim>,
|
||||
/// Non-executable modular assumptions, never accepted as proven facts.
|
||||
pub assumptions: Vec<Assumption>,
|
||||
}
|
||||
|
||||
/// 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<String>,
|
||||
pub postcondition: String,
|
||||
pub line: u32,
|
||||
}
|
||||
|
||||
/// 一条定理声明(设计 §7.1):`| 定理 | 结论 | 前提 | 策略 |` 的一行。
|
||||
|
||||
@@ -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<std::result::Result<Vec<crate::ast::Assumption>,String>> {
|
||||
const OP: &[&str] = &["假设","assumption"];
|
||||
const PRE: &[&str] = &["前置","requires","precondition"];
|
||||
const POST: &[&str] = &["后置","ensures","postcondition"];
|
||||
let headers:Vec<String>=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 {
|
||||
|
||||
@@ -21,7 +21,8 @@ pub fn compile(opts: KnowledgeOptions) -> Result<KnowledgeGraph> {
|
||||
// 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()
|
||||
};
|
||||
|
||||
@@ -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<Function>{
|
||||
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::<Vec<_>>();
|
||||
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<i64>{
|
||||
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::<Option<Vec<_>>>()?.join(" ");
|
||||
let callee_binders=(0..es.params.len()).map(|i|format!("(v{i} : Int)"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
let caller_binders=(0..cs.params.len()).map(|i|format!("(v{i} : Int)"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
let callee_args=(0..es.params.len()).map(|i|format!("v{i}"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
let caller_args=(0..cs.params.len()).map(|i|format!("v{i}"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
// This callee theorem is verified from the translated source *inside its
|
||||
// own module*. The caller only imports its proved interface theorem.
|
||||
let callee_src=format!(
|
||||
"-- pure typed-int fragment of {}\n\
|
||||
def callee {callee_binders} : Int := ({n} : Int)\n\
|
||||
theorem callee_contract {callee_binders} : callee {callee_args} = ({n} : Int) := by rfl\n",
|
||||
ce.artifact_id.0);
|
||||
let caller_src=format!(
|
||||
"import CalleeModule\n\
|
||||
-- exact forwarded import call from {}\n\
|
||||
def caller {caller_binders} : Int := callee {arg_expr}\n\
|
||||
theorem caller_contract {caller_binders} : caller {caller_args} = ({n} : Int) := by\n\
|
||||
\x20\x20simpa [caller] using (callee_contract {arg_expr})\n",
|
||||
ca.artifact_id.0);
|
||||
Some((callee_src,caller_src,format!("{}#{}",ca.artifact_id.0,
|
||||
ce.artifact_id.0),n))
|
||||
}
|
||||
/// Explain why a caller cannot receive a scoped composition certificate.
|
||||
/// Missing evidence is reported, never fixed up by guessing call identities.
|
||||
fn rejection_diagnostics(c:&Compilation,call:&BoundCall)->Value{
|
||||
let caller=c.semantics.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.caller));
|
||||
let callee=c.semantics.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.target));
|
||||
let cf=caller.and_then(|a|function(c,a));
|
||||
let ef=callee.and_then(|a|function(c,a));
|
||||
let constant=ef.as_ref().and_then(constant_return);
|
||||
json!({
|
||||
"caller_semantics_resolved":caller.is_some(),
|
||||
"callee_semantics_resolved":callee.is_some(),
|
||||
"caller_effects":caller.map(|a|a.effects.values()),
|
||||
"callee_effects":callee.map(|a|a.effects.values()),
|
||||
"call_effects":call.required_effects.values(),
|
||||
"caller_forward_shape":cf.as_ref().and_then(forwarded).is_some(),
|
||||
"caller_ast_body":cf.as_ref().map(|f|format!("{:?}",f.body)),
|
||||
"callee_ast_body":ef.as_ref().map(|f|format!("{:?}",f.body)),
|
||||
"callee_constant_return":constant,
|
||||
"runtime_forward_name":cf.as_ref().and_then(forwarded)
|
||||
.and_then(|f|f.for_evaluation().ok())
|
||||
.map(|c|crate::sema::bind::call_display(&c)),
|
||||
"bound_call_name":call.call_site,
|
||||
"caller_bound_call_count":c.semantics.bound_calls.iter()
|
||||
.filter(|item|item.caller==call.caller).count(),
|
||||
"caller_has_expected_claim":caller.zip(constant).is_some_and(|(a,n)|
|
||||
claim_is_constant(c,a,n)),
|
||||
"callee_has_expected_claim":callee.zip(constant).is_some_and(|(a,n)|
|
||||
claim_is_constant(c,a,n)),
|
||||
"caller_signature":caller.and_then(|a|a.signature.as_ref())
|
||||
.map(|s|s.params.iter().map(|p|json!({"name":p.name,"type":p.ty,
|
||||
"required":p.required})).collect::<Vec<_>>()),
|
||||
"callee_signature":callee.and_then(|a|a.signature.as_ref())
|
||||
.map(|s|s.params.iter().map(|p|json!({"name":p.name,"type":p.ty,
|
||||
"required":p.required})).collect::<Vec<_>>()),
|
||||
"actual_arguments":call.args.iter().map(|a|json!({
|
||||
"name":a.name,"symbol":a.symbol,"integer":a.integer})).collect::<Vec<_>>(),
|
||||
"path_guards":call.path_guards,"control_blocker":call.control_blocker
|
||||
})
|
||||
}
|
||||
/// Emit one sealed bundle per eligible call. An unsuccessful Lean command
|
||||
/// never creates a certificate; the JSON report carries the failure.
|
||||
pub fn prove(compiled:&Compilation,out:&Path,toolchain:&Toolchain)->Result<Value>{
|
||||
let mut records=Vec::new();
|
||||
for call in &compiled.semantics.bound_calls{
|
||||
if super::unified::covers(compiled,&call.caller){continue}
|
||||
let Some((source,client,identity,n))=candidate(compiled,call) else {
|
||||
// Projection contracts have their own independently replayable
|
||||
// backend, and must not also appear as unsupported constant claims.
|
||||
if super::projection::eligible(compiled,call)
|
||||
||super::expression::eligible(compiled,call){continue}
|
||||
records.push(json!({"caller":call.caller.as_str(),
|
||||
"callee":call.target.as_str(),"status":"unsupported_fragment",
|
||||
"reason":"requires_pure_number_contract_int_model_forwarder_with_constant_claims",
|
||||
"diagnostics":rejection_diagnostics(compiled,call)}));
|
||||
continue;
|
||||
};
|
||||
let key=sha(format!("{}|{}|{}|{}",identity,
|
||||
compiled.semantics.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.caller))
|
||||
.map(|a|a.hashes.closure.0.as_str()).unwrap_or(""),
|
||||
compiled.semantics.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.target))
|
||||
.map(|a|a.hashes.closure.0.as_str()).unwrap_or(""),
|
||||
toolchain.version).as_bytes());
|
||||
let folder=out.join("composed").join(&key[7..23]);
|
||||
fs::create_dir_all(&folder)?;
|
||||
let callee=folder.join("CalleeModule.lean");
|
||||
let caller=folder.join("CallerModule.lean");
|
||||
let built=folder.join("CalleeModule.olean");
|
||||
fs::write(&callee,&source)?;
|
||||
fs::write(&caller,&client)?;
|
||||
let run=(|| ->Result<()>{
|
||||
compile_import_module(toolchain,&callee,&built,&folder,
|
||||
Duration::from_secs(120)).context("callee interface")?;
|
||||
let verified=folder.join("CallerModule.olean");
|
||||
compile_import_module(toolchain,&caller,&verified,&folder,
|
||||
Duration::from_secs(120)).context("caller composition")?;
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(e)=run{
|
||||
let _=fs::remove_file(folder.join("composition-certificate.json"));
|
||||
records.push(json!({"identity":identity,
|
||||
"status":"lean_rejected","error":format!("{e:#}")}));
|
||||
continue
|
||||
}
|
||||
let cert=json!({
|
||||
"schema_version":1,"kind":"marqdo_restricted_composition",
|
||||
"scope":"number_contract_int_model_pure_forwarder_constant_result",
|
||||
"status":"lean_kernel_proved_model",
|
||||
"identity":identity,"caller":call.caller.as_str(),
|
||||
"callee":call.target.as_str(),
|
||||
"claimed_result":n,
|
||||
"callee_source_sha256":sha(source.as_bytes()),
|
||||
"caller_source_sha256":sha(client.as_bytes()),
|
||||
"callee_compiled_sha256":sha(&fs::read(&built)?),
|
||||
"caller_compiled_sha256":sha(&fs::read(folder.join("CallerModule.olean"))?),
|
||||
"toolchain":toolchain.version,
|
||||
"source_closures":compiled.semantics.artifacts.iter()
|
||||
.filter(|a|a.symbol_id.as_ref()==Some(&call.caller)
|
||||
||a.symbol_id.as_ref()==Some(&call.target))
|
||||
.map(|a|json!({"id":a.artifact_id.0,
|
||||
"closure":a.hashes.closure.0})).collect::<Vec<_>>(),
|
||||
"independent_replay":"CalleeModule.lean then CallerModule.lean"
|
||||
});
|
||||
let receipt=folder.join("composition-certificate.json");
|
||||
fs::write(&receipt,serde_json::to_vec_pretty(&cert)?)?;
|
||||
records.push(json!({"identity":identity,
|
||||
"status":"lean_kernel_proved_model","artifact":receipt,
|
||||
"scope":"number_contract_int_model_pure_forwarder_constant_result"}));
|
||||
}
|
||||
records.extend(super::projection::prove(compiled,out,toolchain)?);
|
||||
records.extend(super::expression::prove(compiled,out,toolchain)?);
|
||||
records.extend(super::unified::prove(compiled,out,toolchain)?);
|
||||
for record in &mut records {
|
||||
if record["evidence"].is_null(){
|
||||
record["evidence"]=if record["status"]=="lean_kernel_proved_model"{
|
||||
super::evidence::model_proved()
|
||||
}else{super::evidence::unknown("unproved_or_unsupported_fragment")};
|
||||
}
|
||||
}
|
||||
Ok(json!({"schema_version":1,"role":"restricted_composed_lean_module",
|
||||
"results":records,
|
||||
"full_marqdo_runtime_semantics_proved":false}))
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// Strict receipt-to-source correspondence; any duplicate row is a hard failure.
|
||||
fn ensure_exact_closures(
|
||||
rows:usize,
|
||||
received:&std::collections::BTreeSet<(String,String)>,
|
||||
expected:&std::collections::BTreeSet<(String,String)>
|
||||
)->Result<()>{
|
||||
anyhow::ensure!(rows==expected.len() && received==expected,
|
||||
"proof.compose_stale_or_ambiguous_closure");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Replay a composition certificate *against the current project source*.
|
||||
/// The certificate never supplies Lean source code: it must byte-match source
|
||||
/// recompiled from the current Marqdo AST, and both Lean modules are rechecked.
|
||||
pub fn replay(compiled:&Compilation,certificate:&Path,lean:&Toolchain)->Result<Value>{
|
||||
let receipt:Value=serde_json::from_slice(&fs::read(certificate)?)?;
|
||||
if receipt["kind"]=="marqdo_parameter_projection_composition"{
|
||||
return super::projection::replay(compiled,certificate,lean)
|
||||
}
|
||||
if receipt["kind"]=="marqdo_pure_expression_composition"{
|
||||
return super::expression::replay(compiled,certificate,lean)
|
||||
}
|
||||
if receipt["kind"]=="marqdo_unified_modular_contract"{
|
||||
return super::unified::replay(compiled,certificate,lean)
|
||||
}
|
||||
anyhow::ensure!(receipt["schema_version"]==1
|
||||
&&receipt["kind"]=="marqdo_restricted_composition"
|
||||
&&receipt["scope"]=="number_contract_int_model_pure_forwarder_constant_result"
|
||||
&&receipt["status"]=="lean_kernel_proved_model",
|
||||
"proof.compose_invalid_certificate: unexpected status or scope");
|
||||
anyhow::ensure!(receipt["toolchain"]==lean.version,
|
||||
"proof.compose_stale_toolchain");
|
||||
let identity=receipt["identity"].as_str().context("missing identity")?;
|
||||
// A certificate identity is a unique proof subject, not a search hint.
|
||||
// Reject ambiguous candidates instead of silently selecting the first.
|
||||
let matching=compiled.semantics.bound_calls.iter()
|
||||
.filter_map(|call|{
|
||||
let (a,b,id,n)=candidate(compiled,call)?;
|
||||
(id==identity).then_some((a,b,id,n,call))
|
||||
}).collect::<Vec<_>>();
|
||||
anyhow::ensure!(matching.len()==1,
|
||||
"proof.compose_ambiguous_or_stale_source: expected exactly one callsite");
|
||||
let (callee,caller,_,n,call)=matching.into_iter().next()
|
||||
.context("proof.compose_missing_candidate")?;
|
||||
anyhow::ensure!(receipt["claimed_result"]==n,
|
||||
"proof.compose_claim_changed");
|
||||
anyhow::ensure!(receipt["caller"]==call.caller.as_str()
|
||||
&&receipt["callee"]==call.target.as_str(),
|
||||
"proof.compose_symbol_changed");
|
||||
// Exact-set comparison blocks duplicate, injected, and omitted dependency
|
||||
// rows. The receipt does not get to choose the dependency closure.
|
||||
let expected_closures=compiled.semantics.artifacts.iter()
|
||||
.filter(|a|a.symbol_id.as_ref()==Some(&call.caller)
|
||||
||a.symbol_id.as_ref()==Some(&call.target))
|
||||
.map(|a|(a.artifact_id.0.clone(),a.hashes.closure.0.clone()))
|
||||
.collect::<std::collections::BTreeSet<_>>();
|
||||
anyhow::ensure!(expected_closures.len()==2,
|
||||
"proof.compose_ambiguous_artifact");
|
||||
let received=receipt["source_closures"].as_array()
|
||||
.context("proof.compose_missing_source_closures")?;
|
||||
let actual_closures=received.iter().map(|r|{
|
||||
Ok((r["id"].as_str().context("proof.compose_invalid_closure_id")?.to_owned(),
|
||||
r["closure"].as_str().context("proof.compose_invalid_closure_hash")?.to_owned()))
|
||||
}).collect::<Result<std::collections::BTreeSet<_>>>()?;
|
||||
ensure_exact_closures(received.len(),&actual_closures,&expected_closures)?;
|
||||
let folder=certificate.parent().context("missing certificate parent")?;
|
||||
let callee_path=folder.join("CalleeModule.lean");
|
||||
let caller_path=folder.join("CallerModule.lean");
|
||||
anyhow::ensure!(fs::read_to_string(&callee_path)?==callee
|
||||
&&fs::read_to_string(&caller_path)?==caller,
|
||||
"proof.compose_generated_source_mismatch");
|
||||
anyhow::ensure!(receipt["callee_source_sha256"]==sha(callee.as_bytes())
|
||||
&&receipt["caller_source_sha256"]==sha(caller.as_bytes()),
|
||||
"proof.compose_hash_mismatch");
|
||||
let callee_obj=folder.join("CalleeModule.olean");
|
||||
let caller_obj=folder.join("CallerModule.olean");
|
||||
compile_import_module(lean,&callee_path,&callee_obj,folder,
|
||||
Duration::from_secs(120))?;
|
||||
compile_import_module(lean,&caller_path,&caller_obj,folder,
|
||||
Duration::from_secs(120))?;
|
||||
anyhow::ensure!(receipt["callee_compiled_sha256"]==sha(&fs::read(&callee_obj)?)
|
||||
&&receipt["caller_compiled_sha256"]==sha(&fs::read(&caller_obj)?),
|
||||
"proof.compose_replay_output_changed");
|
||||
Ok(json!({"schema_version":1,"kind":"independent_composition_replay",
|
||||
"status":"lean_kernel_replayed","scope":receipt["scope"],
|
||||
"identity":identity,"current_source_verified":true,
|
||||
"full_marqdo_runtime_semantics_proved":false}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn certificate_closures_must_be_exact_and_unique(){
|
||||
use std::collections::BTreeSet;
|
||||
let expected=BTreeSet::from([
|
||||
("caller".into(),"sha256:a".into()),
|
||||
("callee".into(),"sha256:b".into())
|
||||
]);
|
||||
assert!(ensure_exact_closures(2,&expected,&expected).is_ok());
|
||||
assert!(ensure_exact_closures(3,&expected,&expected).is_err());
|
||||
let missing=BTreeSet::from([("caller".into(),"sha256:a".into())]);
|
||||
assert!(ensure_exact_closures(1,&missing,&expected).is_err());
|
||||
let mut injected=expected.clone();
|
||||
injected.insert(("third".into(),"sha256:c".into()));
|
||||
assert!(ensure_exact_closures(3,&injected,&expected).is_err());
|
||||
let mut changed=expected.clone();
|
||||
changed.remove(&("callee".into(),"sha256:b".into()));
|
||||
changed.insert(("callee".into(),"sha256:wrong".into()));
|
||||
assert!(ensure_exact_closures(2,&changed,&expected).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn pure_forwarder_can_be_compiled_into_two_independent_lean_sources(){
|
||||
let root=std::env::temp_dir().join(
|
||||
format!("marqdo-compose-unit-{}",std::process::id()));
|
||||
let _=fs::remove_dir_all(&root);
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
fs::write(root.join("math.mq.md"),r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# math
|
||||
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| fixed | 结果 = 2 | auto |
|
||||
|
||||
*2*
|
||||
"#).unwrap();
|
||||
fs::write(root.join("main.mq.md"),r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## forward
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| same | 结果 = 2 | auto |
|
||||
|
||||
**v = [调用](math.math.exact(`n`))**
|
||||
*v*
|
||||
"#).unwrap();
|
||||
let c=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=c.semantics.bound_calls.iter().find(|x|
|
||||
x.call_site=="math.math.exact").unwrap();
|
||||
let (callee,caller,_,result)=candidate(&c,call)
|
||||
.unwrap_or_else(||panic!("composition candidate rejected: {}",
|
||||
rejection_diagnostics(&c,call)));
|
||||
assert_eq!(result,2);
|
||||
assert!(callee.contains("theorem callee_contract"));
|
||||
assert!(caller.starts_with("import CalleeModule"));
|
||||
assert!(caller.contains("using (callee_contract"));
|
||||
// Duplicate matching declarations must not be treated as a
|
||||
// unique contractual source of truth.
|
||||
let duplicate=std::fs::read_to_string(root.join("math.mq.md")).unwrap()
|
||||
.replace("| fixed | 结果 = 2 | auto |",
|
||||
"| fixed | 结果 = 2 | auto |\n| other | 结果 = 2 | auto |");
|
||||
std::fs::write(root.join("math.mq.md"),duplicate).unwrap();
|
||||
let ambiguous=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let ambiguous_call=ambiguous.semantics.bound_calls.iter().find(|x|
|
||||
x.call_site=="math.math.exact").unwrap();
|
||||
assert!(candidate(&ambiguous,ambiguous_call).is_none(),
|
||||
"duplicate constant claims must fail closed");
|
||||
std::fs::write(root.join("math.mq.md"),r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# math
|
||||
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| fixed | 结果 = 2 | auto |
|
||||
|
||||
*2*
|
||||
"#).unwrap();
|
||||
// Branching is explicitly outside the certificate scope.
|
||||
fs::write(root.join("main.mq.md"),r#"---
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## forward
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| same | 结果 = 2 | auto |
|
||||
|
||||
1. `n` > 0
|
||||
**v = [调用](math.math.exact(`n`))**
|
||||
2. *
|
||||
**v = 0**
|
||||
|
||||
*v*
|
||||
"#).unwrap();
|
||||
let changed=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let guarded=changed.semantics.bound_calls.iter().find(|x|
|
||||
x.call_site=="math.math.exact").unwrap();
|
||||
assert!(candidate(&changed,guarded).is_none());
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
//! Explicit evidence levels: a Lean proof of the mathematical model is
|
||||
//! categorically different from a proof about the dynamic Marqdo runtime.
|
||||
//! Neither source metadata nor an asserted plugin contract grants authority.
|
||||
use serde::{Serialize,Deserialize};
|
||||
use serde_json::{json,Value};
|
||||
|
||||
#[derive(Clone,Copy,Debug,PartialEq,Eq,Serialize,Deserialize)]
|
||||
#[serde(rename_all="snake_case")]
|
||||
pub enum EvidenceGrade{
|
||||
/// Only when correspondence to supported runtime semantics was proven.
|
||||
Proved,
|
||||
/// Kernel checked theorem over an explicitly identified abstract model.
|
||||
ModelProved,
|
||||
/// Observed by supplied tests/experiments. Not a mathematical proof.
|
||||
Tested,
|
||||
/// Trust or environmental assertion, not proven from source.
|
||||
Assumed,
|
||||
/// Insufficient evidence, timeout, unsupported language, or no proof.
|
||||
Unknown,
|
||||
/// An actual counterexample, never just a missing Lean derivation.
|
||||
Refuted,
|
||||
/// The source, contract, toolchain, or dependency changed.
|
||||
Stale
|
||||
}
|
||||
impl EvidenceGrade{
|
||||
pub fn as_str(self)->&'static str{
|
||||
match self{
|
||||
Self::Proved=>"proved",Self::ModelProved=>"model_proved",
|
||||
Self::Tested=>"tested",Self::Assumed=>"assumed",
|
||||
Self::Unknown=>"unknown",Self::Refuted=>"refuted",
|
||||
Self::Stale=>"stale"
|
||||
}
|
||||
}
|
||||
}
|
||||
fn record(grade:EvidenceGrade,basis:&str,kernel_replayed:bool,
|
||||
runtime_correspondence:bool)->Value{
|
||||
let effective=if grade==EvidenceGrade::Proved && !runtime_correspondence{
|
||||
EvidenceGrade::ModelProved
|
||||
}else{grade};
|
||||
json!({
|
||||
"schema_version":1,"grade":effective.as_str(),"basis":basis,
|
||||
"model":"lean_int_abstract",
|
||||
"kernel_replayed":kernel_replayed,
|
||||
"runtime_correspondence_verified":runtime_correspondence,
|
||||
"full_marqdo_runtime_semantics_proved":false,
|
||||
"not_execution_authority":true
|
||||
})
|
||||
}
|
||||
/// Kernel checked at issuance; no independent replay has happened yet.
|
||||
pub fn model_proved()->Value{
|
||||
record(EvidenceGrade::ModelProved,"source_regenerated_lean_kernel",
|
||||
false,false)
|
||||
}
|
||||
/// Source-regenerated modules were independently recompiled on replay.
|
||||
pub fn model_replayed()->Value{
|
||||
record(EvidenceGrade::ModelProved,"independently_replayed_lean_kernel",
|
||||
true,false)
|
||||
}
|
||||
pub fn unknown(reason:&str)->Value{
|
||||
record(EvidenceGrade::Unknown,reason,false,false)
|
||||
}
|
||||
pub fn assumed()->Value{
|
||||
record(EvidenceGrade::Assumed,"external_or_author_declaration",false,false)
|
||||
}
|
||||
pub fn for_receipt(status:&str,usable:bool,kernel_replayed:bool)->Value{
|
||||
if status=="stale"{
|
||||
return record(EvidenceGrade::Stale,"source_or_dependency_changed",
|
||||
false,false)
|
||||
}
|
||||
if !usable {
|
||||
return unknown(if status=="ambiguous"{"ambiguous_receipt"}
|
||||
else if status=="unproved"{"lean_not_proved"}
|
||||
else{"no_trusted_replayable_proof"})
|
||||
}
|
||||
if status=="proved"{
|
||||
return record(EvidenceGrade::ModelProved,
|
||||
"source_bound_lean_certificate",kernel_replayed,false)
|
||||
}
|
||||
unknown("unsupported_receipt_status")
|
||||
}
|
||||
pub fn with_grade(grade:EvidenceGrade,source:&str)->Value{
|
||||
// This constructor is for explicitly sourced tests/assumptions and is
|
||||
// intentionally never allowed to create runtime-level Proved by fiat.
|
||||
record(grade,source,false,false)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test]
|
||||
fn grades_do_not_promote_abstract_integer_proofs(){
|
||||
let fresh=model_proved();
|
||||
assert_eq!(fresh["kernel_replayed"],false);
|
||||
assert_eq!(fresh["grade"],"model_proved");
|
||||
let replayed=model_replayed();
|
||||
assert_eq!(replayed["kernel_replayed"],true);
|
||||
let proved=for_receipt("proved",true,true);
|
||||
assert_eq!(proved["grade"],"model_proved");
|
||||
assert_eq!(proved["full_marqdo_runtime_semantics_proved"],false);
|
||||
assert_eq!(with_grade(EvidenceGrade::Proved,"asserted")["grade"],
|
||||
"model_proved");
|
||||
assert_eq!(for_receipt("stale",false,false)["grade"],"stale");
|
||||
assert_eq!(for_receipt("unproved",false,false)["grade"],"unknown");
|
||||
assert_eq!(for_receipt("ambiguous",false,false)["grade"],"unknown");
|
||||
assert_eq!(with_grade(EvidenceGrade::Refuted,
|
||||
"actual_counterexample")["grade"],"refuted");
|
||||
assert_eq!(assumed()["grade"],"assumed");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,320 @@
|
||||
//! Independent assume/guarantee composition of source-backed pure arithmetic
|
||||
//! expressions. All results are **Lean Int-model** theorems, NOT dynamic
|
||||
//! Marqdo Number/i64 runtime equivalence. Every unsupported case fails closed.
|
||||
use std::{collections::BTreeSet,fs,path::Path,time::Duration};
|
||||
use anyhow::{Context,Result};
|
||||
use serde_json::{json,Value};
|
||||
use sha2::{Digest,Sha256};
|
||||
use crate::{
|
||||
ast::{BinaryOp,Expr,Function,Stmt,UnaryOp},
|
||||
prove::{driver::{Toolchain,compile_import_module},
|
||||
proof_check::{self,ClaimAst,CTok}},
|
||||
sema::ir::{BoundCall,Compilation,SemanticArtifact,CanonicalParam}
|
||||
};
|
||||
use super::projection::{load_function,forwarder,closures};
|
||||
|
||||
const KIND:&str="marqdo_pure_expression_composition";
|
||||
const SCOPE:&str="number_contract_int_model_pure_expression_forwarder";
|
||||
fn sha(s:&[u8])->String{format!("sha256:{:x}",Sha256::digest(s))}
|
||||
|
||||
#[derive(Clone,Debug,PartialEq,Eq)]
|
||||
enum Term{
|
||||
Number(i64), Param(usize), Neg(Box<Term>),
|
||||
Add(Box<Term>,Box<Term>),Sub(Box<Term>,Box<Term>),
|
||||
Mul(Box<Term>,Box<Term>)
|
||||
}
|
||||
impl Term{
|
||||
fn source(e:&Expr,params:&[CanonicalParam],depth:usize)->Option<Self>{
|
||||
if depth>=32{return None}
|
||||
match e{
|
||||
Expr::Literal(crate::ast::Literal::Int(n))=>Some(Self::Number(*n)),
|
||||
Expr::Var(s)=>Some(Self::Param(unique_param(params,s)?)),
|
||||
Expr::Occluded{payload:Some(inner),..}=>Self::source(inner,params,depth+1),
|
||||
Expr::Unary{op:UnaryOp::Neg,expr}=>
|
||||
Some(Self::Neg(Box::new(Self::source(expr,params,depth+1)?))),
|
||||
Expr::Binary{op,left,right}=>{
|
||||
let l=Box::new(Self::source(left,params,depth+1)?);
|
||||
let r=Box::new(Self::source(right,params,depth+1)?);
|
||||
match op{
|
||||
BinaryOp::Add=>Some(Self::Add(l,r)),
|
||||
BinaryOp::Sub=>Some(Self::Sub(l,r)),
|
||||
BinaryOp::Mul=>Some(Self::Mul(l,r)),
|
||||
_=>None
|
||||
}
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn claim(e:&ClaimAst,params:&[CanonicalParam],depth:usize)->Option<Self>{
|
||||
if depth>=32{return None}
|
||||
match e{
|
||||
ClaimAst::Lit(CTok::Int(n))=>Some(Self::Number(*n)),
|
||||
ClaimAst::Var(s)=>Some(Self::Param(unique_param(params,s)?)),
|
||||
ClaimAst::Un{op:"-",expr}=>Some(Self::Neg(Box::new(
|
||||
Self::claim(expr,params,depth+1)?))),
|
||||
ClaimAst::Bin{op,left,right}=>{
|
||||
let l=Box::new(Self::claim(left,params,depth+1)?);
|
||||
let r=Box::new(Self::claim(right,params,depth+1)?);
|
||||
match *op{
|
||||
"+"=>Some(Self::Add(l,r)),
|
||||
"-"=>Some(Self::Sub(l,r)),
|
||||
"*"=>Some(Self::Mul(l,r)),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn substitute(&self,args:&[Term],depth:usize)->Option<Self>{
|
||||
if depth>=64{return None}
|
||||
match self{
|
||||
Self::Number(n)=>Some(Self::Number(*n)),
|
||||
Self::Param(i)=>args.get(*i).cloned(),
|
||||
Self::Neg(a)=>Some(Self::Neg(Box::new(a.substitute(args,depth+1)?))),
|
||||
Self::Add(a,b)=>Some(Self::Add(Box::new(a.substitute(args,depth+1)?),
|
||||
Box::new(b.substitute(args,depth+1)?))),
|
||||
Self::Sub(a,b)=>Some(Self::Sub(Box::new(a.substitute(args,depth+1)?),
|
||||
Box::new(b.substitute(args,depth+1)?))),
|
||||
Self::Mul(a,b)=>Some(Self::Mul(Box::new(a.substitute(args,depth+1)?),
|
||||
Box::new(b.substitute(args,depth+1)?)))
|
||||
}
|
||||
}
|
||||
fn lean(&self)->String{
|
||||
match self{
|
||||
Self::Number(n)=>format!("({n} : Int)"),
|
||||
Self::Param(i)=>format!("v{i}"),
|
||||
Self::Neg(a)=>format!("(-{})",a.lean()),
|
||||
Self::Add(a,b)=>format!("({} + {})",a.lean(),b.lean()),
|
||||
Self::Sub(a,b)=>format!("({} - {})",a.lean(),b.lean()),
|
||||
Self::Mul(a,b)=>format!("({} * {})",a.lean(),b.lean())
|
||||
}
|
||||
}
|
||||
fn is_composite(&self)->bool{
|
||||
matches!(self,Self::Neg(..)|Self::Add(..)|Self::Sub(..)|Self::Mul(..))
|
||||
}
|
||||
}
|
||||
fn unique_param(params:&[CanonicalParam],name:&str)->Option<usize>{
|
||||
let i=params.iter().position(|p|p.name==name)?;
|
||||
(params.iter().filter(|p|p.name==name).count()==1).then_some(i)
|
||||
}
|
||||
fn claim_matches(compiled:&Compilation,artifact:&SemanticArtifact,
|
||||
params:&[CanonicalParam],want:&Term)->bool{
|
||||
let Some(owner)=artifact.symbol_id.as_ref() else{return false};
|
||||
// The declaration must unambiguously refer to the exact source equation.
|
||||
// Do not convert any arbitrary author-written proposition into an axiom.
|
||||
compiled.semantics.claims.iter().filter(|c|{
|
||||
if c.owner!=*owner||
|
||||
!c.premise.as_deref().map_or(true,|s|s.trim().is_empty()){
|
||||
return false
|
||||
}
|
||||
let Ok(tokens)=proof_check::tokenize_claim(&c.conclusion) else{return false};
|
||||
let Ok((_,tree))=proof_check::parse_claim_expr(&tokens) else{return false};
|
||||
match tree{
|
||||
ClaimAst::Bin{op:"=",left,right}
|
||||
if matches!(*left,ClaimAst::Var(ref v) if v=="结果")=>
|
||||
Term::claim(&right,params,0).as_ref()==Some(want),
|
||||
_=>false
|
||||
}
|
||||
}).count()==1
|
||||
}
|
||||
fn callee_expression(fun:&Function,params:&[CanonicalParam])->Option<Term>{
|
||||
match fun.body.as_slice(){
|
||||
[Stmt::Return{value,..}]=>Term::source(value,params,0),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
struct Prepared{
|
||||
identity:String,
|
||||
callee:String,
|
||||
caller:String
|
||||
}
|
||||
fn candidate(c:&Compilation,call:&BoundCall)->Option<Prepared>{
|
||||
let sem=&c.semantics;
|
||||
let ca=single_artifact(c,&call.caller)?;
|
||||
let ce=single_artifact(c,&call.target)?;
|
||||
if ca.source.file==ce.source.file||call.caller==call.target
|
||||
||!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}
|
||||
if sem.bound_calls.iter().filter(|x|x.caller==call.caller).count()!=1{
|
||||
return None
|
||||
}
|
||||
let cs=ca.signature.as_ref()?;
|
||||
let es=ce.signature.as_ref()?;
|
||||
let caller=load_function(c,ca)?;
|
||||
let callee=load_function(c,ce)?;
|
||||
if caller.is_object()||callee.is_object(){return None}
|
||||
if caller.params.len()!=cs.params.len()
|
||||
||callee.params.len()!=es.params.len()
|
||||
||call.args.len()!=es.params.len(){return None}
|
||||
if !caller.params.iter().zip(cs.params.iter()).all(|(a,b)|a.name==b.name)
|
||||
||!callee.params.iter().zip(es.params.iter()).all(|(a,b)|a.name==b.name){
|
||||
return None
|
||||
}
|
||||
if cs.params.iter().chain(es.params.iter())
|
||||
.any(|p|p.ty!="number"||!p.required||p.default_digest.is_some()){
|
||||
return None
|
||||
}
|
||||
let body=callee_expression(&callee,&es.params)?;
|
||||
if !body.is_composite(){return None}
|
||||
if !claim_matches(c,ce,&es.params,&body){return None}
|
||||
let forwarded=forwarder(&caller)?.for_evaluation().ok()?;
|
||||
if forwarded.path.is_none()||forwarded.receiver.is_some()
|
||||
||crate::sema::bind::call_display(&forwarded)!=call.call_site
|
||||
||forwarded.args.len()!=call.args.len(){return None}
|
||||
let args=call.args.iter().zip(es.params.iter()).map(|(a,p)|{
|
||||
if a.name.as_ref().is_some_and(|name|name!=&p.name){return None}
|
||||
if let Some(n)=a.integer{return Some(Term::Number(n))}
|
||||
let symbol=a.symbol.as_ref()?;
|
||||
Some(Term::Param(unique_param(&cs.params,symbol)?))
|
||||
}).collect::<Option<Vec<_>>>()?;
|
||||
let expected=body.substitute(&args,0)?;
|
||||
if !claim_matches(c,ca,&cs.params,&expected){return None}
|
||||
let callee_binders=binders(es.params.len());
|
||||
let caller_binders=binders(cs.params.len());
|
||||
let callee_vars=vars(es.params.len());
|
||||
let caller_vars=vars(cs.params.len());
|
||||
let call_args=args.iter().map(Term::lean).collect::<Vec<_>>().join(" ");
|
||||
let callee_src=format!(
|
||||
"-- Source-derived callee expression; Lean Int abstraction only.\n\
|
||||
def callee {callee_binders} : Int := {}\n\
|
||||
theorem callee_contract {callee_binders} : callee {callee_vars} = {} := by rfl\n",
|
||||
body.lean(),body.lean());
|
||||
let caller_src=format!(
|
||||
"import CalleeModule\n\
|
||||
-- The caller imports the callee's theorem, never its implementation body.\n\
|
||||
def caller {caller_binders} : Int := callee {call_args}\n\
|
||||
theorem caller_contract {caller_binders} : caller {caller_vars} = {} := by\n\
|
||||
\x20\x20simpa [caller] using (callee_contract {call_args})\n",
|
||||
expected.lean());
|
||||
Some(Prepared{
|
||||
identity:format!("{}#{}",ca.artifact_id.0,ce.artifact_id.0),
|
||||
callee:callee_src,caller:caller_src
|
||||
})
|
||||
}
|
||||
fn single_artifact<'a>(c:&'a Compilation,
|
||||
symbol:&crate::sema::SymbolId)->Option<&'a SemanticArtifact>{
|
||||
let mut found=c.semantics.artifacts.iter().filter(|a|
|
||||
a.kind=="function"&&a.symbol_id.as_ref()==Some(symbol));
|
||||
let item=found.next()?;
|
||||
found.next().is_none().then_some(item)
|
||||
}
|
||||
fn binders(n:usize)->String{
|
||||
(0..n).map(|i|format!("(v{i} : Int)")).collect::<Vec<_>>().join(" ")
|
||||
}
|
||||
fn vars(n:usize)->String{
|
||||
(0..n).map(|i|format!("v{i}")).collect::<Vec<_>>().join(" ")
|
||||
}
|
||||
pub(super) fn eligible(c:&Compilation,call:&BoundCall)->bool{
|
||||
candidate(c,call).is_some()
|
||||
}
|
||||
pub(super) fn prove(c:&Compilation,out:&Path,lean:&Toolchain)->Result<Vec<Value>>{
|
||||
let mut results=Vec::new();
|
||||
for call in &c.semantics.bound_calls{
|
||||
if super::unified::covers(c,&call.caller){continue}
|
||||
let Some(plan)=candidate(c,call) else{continue};
|
||||
let closure=closures(c,call)?;
|
||||
let key=sha(format!("{}|{:?}|{}",plan.identity,closure,lean.version).as_bytes());
|
||||
let dir=out.join("composed").join(format!("expr-{}",&key[7..23]));
|
||||
fs::create_dir_all(&dir)?;
|
||||
let callee_src=dir.join("CalleeModule.lean");
|
||||
let caller_src=dir.join("CallerModule.lean");
|
||||
let callee_obj=dir.join("CalleeModule.olean");
|
||||
let caller_obj=dir.join("CallerModule.olean");
|
||||
fs::write(&callee_src,&plan.callee)?;
|
||||
fs::write(&caller_src,&plan.caller)?;
|
||||
let checked=(||->Result<()>{
|
||||
compile_import_module(lean,&callee_src,&callee_obj,&dir,
|
||||
Duration::from_secs(120)).context("expression callee proof")?;
|
||||
compile_import_module(lean,&caller_src,&caller_obj,&dir,
|
||||
Duration::from_secs(120)).context("expression caller composition")?;
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(e)=checked{
|
||||
let _=fs::remove_file(dir.join("composition-certificate.json"));
|
||||
results.push(json!({"identity":plan.identity,"status":"lean_rejected",
|
||||
"scope":SCOPE,"error":format!("{e:#}")}));
|
||||
continue
|
||||
}
|
||||
let cert=json!({
|
||||
"schema_version":1,"kind":KIND,"scope":SCOPE,
|
||||
"status":"lean_kernel_proved_model",
|
||||
"caller":call.caller.as_str(),"callee":call.target.as_str(),
|
||||
"identity":plan.identity,"toolchain":lean.version,
|
||||
"source_closures":closure.iter().map(|(id,digest)|
|
||||
json!({"id":id,"closure":digest})).collect::<Vec<_>>(),
|
||||
"callee_source_sha256":sha(plan.callee.as_bytes()),
|
||||
"caller_source_sha256":sha(plan.caller.as_bytes()),
|
||||
"callee_compiled_sha256":sha(&fs::read(&callee_obj)?),
|
||||
"caller_compiled_sha256":sha(&fs::read(&caller_obj)?),
|
||||
"full_marqdo_runtime_semantics_proved":false,
|
||||
"independent_replay":"CalleeModule.lean then CallerModule.lean"
|
||||
});
|
||||
let receipt=dir.join("composition-certificate.json");
|
||||
fs::write(&receipt,serde_json::to_vec_pretty(&cert)?)?;
|
||||
results.push(json!({"identity":plan.identity,"status":"lean_kernel_proved_model",
|
||||
"scope":SCOPE,"artifact":receipt}));
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
pub(super) fn replay(c:&Compilation,certificate:&Path,lean:&Toolchain)
|
||||
->Result<Value>{
|
||||
let cert:Value=serde_json::from_slice(&fs::read(certificate)?)?;
|
||||
anyhow::ensure!(cert["schema_version"]==1&&cert["kind"]==KIND
|
||||
&&cert["scope"]==SCOPE&&cert["status"]=="lean_kernel_proved_model",
|
||||
"proof.expression_invalid_certificate");
|
||||
anyhow::ensure!(cert["toolchain"]==lean.version,"proof.expression_toolchain_mismatch");
|
||||
let identity=cert["identity"].as_str().context("proof.expression_missing_identity")?;
|
||||
let candidates=c.semantics.bound_calls.iter().filter_map(|call|
|
||||
candidate(c,call).and_then(|plan|(plan.identity==identity).then_some((call,plan))))
|
||||
.collect::<Vec<_>>();
|
||||
anyhow::ensure!(candidates.len()==1,"proof.expression_ambiguous_or_stale_source");
|
||||
let (call,plan)=&candidates[0];
|
||||
anyhow::ensure!(cert["caller"]==call.caller.as_str()
|
||||
&&cert["callee"]==call.target.as_str(),"proof.expression_changed_symbols");
|
||||
let expected=closures(c,call)?;
|
||||
let rows=cert["source_closures"].as_array().context("proof.expression_missing_closures")?;
|
||||
let actual=rows.iter().map(|r|Ok((
|
||||
r["id"].as_str().context("proof.expression_bad_id")?.to_owned(),
|
||||
r["closure"].as_str().context("proof.expression_bad_digest")?.to_owned()
|
||||
))).collect::<Result<BTreeSet<_>>>()?;
|
||||
anyhow::ensure!(rows.len()==expected.len()&&actual==expected,
|
||||
"proof.expression_stale_or_ambiguous_closure");
|
||||
let dir=certificate.parent().context("proof.expression_missing_parent")?;
|
||||
let callee_src=dir.join("CalleeModule.lean");
|
||||
let caller_src=dir.join("CallerModule.lean");
|
||||
anyhow::ensure!(fs::read_to_string(&callee_src)?==plan.callee
|
||||
&&fs::read_to_string(&caller_src)?==plan.caller
|
||||
&&cert["callee_source_sha256"]==sha(plan.callee.as_bytes())
|
||||
&&cert["caller_source_sha256"]==sha(plan.caller.as_bytes()),
|
||||
"proof.expression_source_mismatch");
|
||||
let callee_obj=dir.join("CalleeModule.olean");
|
||||
let caller_obj=dir.join("CallerModule.olean");
|
||||
compile_import_module(lean,&callee_src,&callee_obj,dir,Duration::from_secs(120))?;
|
||||
compile_import_module(lean,&caller_src,&caller_obj,dir,Duration::from_secs(120))?;
|
||||
anyhow::ensure!(cert["callee_compiled_sha256"]==sha(&fs::read(callee_obj)?)
|
||||
&&cert["caller_compiled_sha256"]==sha(&fs::read(caller_obj)?),
|
||||
"proof.expression_compiled_mismatch");
|
||||
Ok(json!({"schema_version":1,"kind":"independent_composition_replay",
|
||||
"status":"lean_kernel_replayed","scope":SCOPE,
|
||||
"identity":identity,"current_source_verified":true,
|
||||
"full_marqdo_runtime_semantics_proved":false}))
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test]
|
||||
fn arithmetic_contract_requires_exact_structural_match(){
|
||||
let params=vec![CanonicalParam{name:"n".into(),ty:"number".into(),
|
||||
required:true,default_digest:None,unit:None}];
|
||||
let lhs=crate::parse::parse_expr("`n` + 1").unwrap();
|
||||
let want=Term::source(&lhs,¶ms,0).unwrap();
|
||||
let good=proof_check::parse_claim_expr(
|
||||
&proof_check::tokenize_claim("n + 1").unwrap()).unwrap().1;
|
||||
assert_eq!(Term::claim(&good,¶ms,0),Some(want.clone()));
|
||||
let bad=proof_check::parse_claim_expr(
|
||||
&proof_check::tokenize_claim("n + 2").unwrap()).unwrap().1;
|
||||
assert_ne!(Term::claim(&bad,¶ms,0),Some(want));
|
||||
assert!(Term::source(&crate::parse::parse_expr("`n` / 2").unwrap(),¶ms,0).is_none());
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,7 @@ pub fn extract_graph(opts: &ExtractOptions) -> Result<KnowledgeGraph> {
|
||||
let root = if opts.path.is_file() {
|
||||
opts.path
|
||||
.parent()
|
||||
.filter(|p| !p.as_os_str().is_empty())
|
||||
.map(|p| p.to_path_buf())
|
||||
.unwrap_or_else(|| PathBuf::from("."))
|
||||
} else {
|
||||
|
||||
@@ -16,6 +16,15 @@ pub mod learn;
|
||||
pub mod lifecycle;
|
||||
pub mod metrics;
|
||||
pub mod policy;
|
||||
pub mod proof;
|
||||
pub mod modular;
|
||||
pub mod vc;
|
||||
pub mod symbolic;
|
||||
pub mod composition;
|
||||
pub mod projection;
|
||||
pub mod expression;
|
||||
pub mod unified;
|
||||
pub mod evidence;
|
||||
pub mod preflight;
|
||||
pub mod reuse;
|
||||
pub mod util;
|
||||
|
||||
@@ -0,0 +1,237 @@
|
||||
//! Conservative inter-module proof dependency planning.
|
||||
//!
|
||||
//! This is NOT a rule that a proved callee theorem magically proves its
|
||||
//! caller. It records which Lean-checked callee contracts a caller could rely
|
||||
//! on and refuses to discharge parameter-dependent preconditions by guesswork.
|
||||
//! The independently proved caller claim remains a separate obligation.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use serde_json::{json, Value};
|
||||
use crate::sema::ir::SemanticProject;
|
||||
|
||||
fn linked_claims<'a>(proofs:&'a Value, symbol:&str)->Vec<&'a Value>{
|
||||
proofs["claims"].as_array().into_iter()
|
||||
.flat_map(|rows|rows.iter())
|
||||
.filter(|r|r["owner_symbol_id"].as_str()==Some(symbol))
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn analyze(semantic:&SemanticProject, proof_index:&Value)->Value{
|
||||
analyze_with_verified(semantic,proof_index,&BTreeSet::new())
|
||||
}
|
||||
|
||||
/// The accepted set must come from the real Lean kernel, never from the host
|
||||
/// calculator or an untrusted JSON status.
|
||||
pub fn analyze_with_verified(semantic:&SemanticProject, proof_index:&Value,
|
||||
kernel_verified:&BTreeSet<String>)->Value{
|
||||
let known:BTreeSet<&str>=semantic.artifacts.iter()
|
||||
.filter_map(|a|a.symbol_id.as_ref().map(|id|id.as_str())).collect();
|
||||
let mut obligations=Vec::new();
|
||||
let mut links:BTreeMap<String,Vec<String>>=BTreeMap::new();
|
||||
for call in &semantic.bound_calls {
|
||||
let callee=call.target.as_str();
|
||||
let caller_id=call.caller.as_str();
|
||||
let caller=Some(caller_id);
|
||||
let assumption=semantic.assumptions.iter()
|
||||
.find(|a|a.owner.as_str()==caller_id &&
|
||||
(a.operation==call.call_site || a.operation==callee));
|
||||
let id=format!("{}:{}:{}",call.source.file,call.source.line,callee);
|
||||
let exported=semantic.claims.iter().any(|c|c.owner.as_str()==callee);
|
||||
let receipts=linked_claims(proof_index,callee);
|
||||
let contracts:Vec<Value>=semantic.claims.iter()
|
||||
.filter(|c|c.owner.as_str()==callee)
|
||||
.map(|c|{
|
||||
let matched=receipts.iter().find(|r|
|
||||
r["claim_anchor_id"]==c.anchor_id
|
||||
&& r["conclusion"]==c.conclusion
|
||||
&& r["premise"]==json!(c.premise));
|
||||
let verified=matched.is_some_and(|r|r["status"]=="proved"
|
||||
&& r["usable"]==true);
|
||||
let unconditional=c.premise.as_deref()
|
||||
.map_or(true,|s|s.trim().is_empty());
|
||||
let goal=if unconditional {None} else {
|
||||
c.premise.as_deref().and_then(|pre|
|
||||
super::vc::instantiate(semantic,call,pre))
|
||||
};
|
||||
let symbolic=if unconditional {None} else {
|
||||
c.premise.as_deref().and_then(|pre|
|
||||
super::symbolic::plan(semantic,call,pre))
|
||||
};
|
||||
let key=format!("{}#{}",id,c.anchor_id);
|
||||
let kernel_passed=goal.as_ref().is_some_and(|g|
|
||||
g.holds && kernel_verified.contains(&key));
|
||||
json!({
|
||||
"claim_anchor_id":c.anchor_id,
|
||||
"premise":c.premise,
|
||||
"conclusion":c.conclusion,
|
||||
"callee_certificate_valid":verified,
|
||||
"callee_evidence":super::evidence::for_receipt(
|
||||
if verified {"proved"}else{"unverified"},verified,false),
|
||||
// An unbound premise is a caller-side proof obligation;
|
||||
// it is never discharged merely because callee was proved.
|
||||
"precondition_goal_key":if unconditional {None} else {Some(key)},
|
||||
"lean_proposition":goal.as_ref().map(|g|g.proposition.as_str()),
|
||||
"closed_host_check":goal.as_ref().map(|g|g.holds),
|
||||
"symbolic_model_proposition":symbolic.as_ref().map(|g|g.proposition.as_str()),
|
||||
"symbolic_model_guard_count":symbolic.as_ref().map(|g|g.guard_propositions.len()),
|
||||
"symbolic_model_runtime_domain_verified":symbolic.as_ref().map(|g|g.runtime_domain_verified),
|
||||
"symbolic_int_abstract_supported":symbolic.as_ref().map(|g|g.abstract_integer_model_supported),
|
||||
"path_guards":call.path_guards,
|
||||
"control_blocker":call.control_blocker,
|
||||
"call_precondition_status":if unconditional {"none"}
|
||||
else if kernel_passed {"lean_kernel_verified"}
|
||||
else if goal.as_ref().is_some_and(|g|!g.holds) {"refuted_closed_precondition"}
|
||||
else if goal.is_some() {"requires_lean_kernel"}
|
||||
else if symbolic.is_some() {"symbolic_path_lean_model_pending"}
|
||||
else {"requires_symbolic_callsite_proof"},
|
||||
"status":if !verified {"missing_verified_callee_claim"}
|
||||
else if unconditional || kernel_passed {"available_as_contract"}
|
||||
else if goal.as_ref().is_some_and(|g|!g.holds) {"precondition_refuted"}
|
||||
else {"precondition_pending"}
|
||||
})
|
||||
}).collect();
|
||||
let controls_sufficient=call.control_blocker.is_none()
|
||||
&& call.required_effects.is_pure();
|
||||
let all_available=controls_sufficient && exported && !contracts.is_empty()
|
||||
&& contracts.iter().all(|x|x["status"]=="available_as_contract");
|
||||
let status=if !known.contains(callee) {
|
||||
"external_without_semantic_definition"
|
||||
} else if !controls_sufficient {
|
||||
"unmodeled_control_or_effect"
|
||||
} else if !exported {
|
||||
"callee_without_declared_contract"
|
||||
} else if all_available {
|
||||
"callee_contracts_verified"
|
||||
} else {
|
||||
"proof_obligations_pending"
|
||||
};
|
||||
obligations.push(json!({
|
||||
"id":id,"caller":caller,"callee":callee,
|
||||
"call_site":call.call_site,
|
||||
"source":{"file":call.source.file,"line":call.source.line},
|
||||
"status":status,"contracts":contracts,
|
||||
"caller_proof_required":true,
|
||||
"evidence":super::evidence::unknown("dependency_audit_is_not_caller_proof"),
|
||||
"runtime_link_required":true,
|
||||
"path_guards":call.path_guards,
|
||||
"control_blocker":call.control_blocker,
|
||||
"effects":call.required_effects.values(),
|
||||
"runtime_effect_model":"not_established_by_knowledge_audit",
|
||||
"caller_assumption":assumption.map(|a|json!({
|
||||
"id":a.id,"premise":a.premise,
|
||||
"postcondition":a.postcondition,
|
||||
"verified":false,
|
||||
"evidence":super::evidence::assumed(),
|
||||
"status":"requires_lean_callsite_derivation"
|
||||
})),
|
||||
"caller_assumption_binding":if assumption.is_some(){"declared_unproved"}
|
||||
else {"absent"}
|
||||
}));
|
||||
if let Some(caller)=caller {
|
||||
links.entry(caller.to_string()).or_default().push(callee.into());
|
||||
}
|
||||
}
|
||||
for call in &semantic.dynamic_calls {
|
||||
obligations.push(json!({
|
||||
"id":format!("{}:{}:dynamic",call.source.file,call.source.line),
|
||||
"source":{"file":call.source.file,"line":call.source.line},
|
||||
"status":"dynamic_or_unresolved_no_modular_proof",
|
||||
"reason":call.reason,"caller_proof_required":true
|
||||
}));
|
||||
}
|
||||
obligations.sort_by(|a,b|a["id"].as_str().cmp(&b["id"].as_str()));
|
||||
let cycles=find_cycles(&links);
|
||||
let verified_claims:Vec<Value>=semantic.claims.iter().map(|c|{
|
||||
let found=linked_claims(proof_index,c.owner.as_str()).iter().any(|r|
|
||||
r["claim_anchor_id"]==c.anchor_id &&
|
||||
r["conclusion"]==c.conclusion &&
|
||||
r["premise"]==json!(c.premise) &&
|
||||
r["status"]=="proved" && r["usable"]==true);
|
||||
json!({"claim_anchor_id":c.anchor_id,"owner":c.owner.as_str(),
|
||||
"status":if found {"proved_with_local_lean_receipt"} else {"unverified"}})
|
||||
}).collect();
|
||||
let linked=obligations.iter().all(|o|o["status"]=="callee_contracts_verified")
|
||||
&& cycles.is_empty();
|
||||
let declarations_proved=!verified_claims.is_empty()
|
||||
&& verified_claims.iter().all(|c|c["status"]=="proved_with_local_lean_receipt");
|
||||
let audit_passes=linked && declarations_proved;
|
||||
json!({
|
||||
"schema_version":1,
|
||||
"kind":"modular_proof_obligations",
|
||||
"status":if audit_passes {"dependency_receipts_valid"}
|
||||
else {"open_obligations"},
|
||||
"audit_passes":audit_passes,
|
||||
"verified_claims":verified_claims,
|
||||
// Even a successful audit is NOT a modular Lean theorem:
|
||||
// the runtime-link and caller entailment obligations remain.
|
||||
"proof_completion":"not_established_by_dependency_analysis",
|
||||
"obligations":obligations,
|
||||
"cycles":cycles
|
||||
})
|
||||
}
|
||||
|
||||
fn find_cycles(graph:&BTreeMap<String,Vec<String>>)->Vec<Vec<String>>{
|
||||
fn visit<'a>(node:&'a str,g:&'a BTreeMap<String,Vec<String>>,
|
||||
visiting:&mut BTreeSet<String>,done:&mut BTreeSet<String>,
|
||||
stack:&mut Vec<String>,cycles:&mut Vec<Vec<String>>){
|
||||
if done.contains(node){return}
|
||||
if !visiting.insert(node.to_string()){
|
||||
if let Some(start)=stack.iter().position(|x|x==node){
|
||||
let mut cycle=stack[start..].to_vec();
|
||||
cycle.push(node.to_string());
|
||||
cycles.push(cycle);
|
||||
}
|
||||
return
|
||||
}
|
||||
stack.push(node.to_string());
|
||||
if let Some(next)=g.get(node){
|
||||
for target in next {visit(target,g,visiting,done,stack,cycles)}
|
||||
}
|
||||
stack.pop();visiting.remove(node);done.insert(node.to_string());
|
||||
}
|
||||
let mut visiting=BTreeSet::new();
|
||||
let mut done=BTreeSet::new();
|
||||
let mut cycles=Vec::new();
|
||||
for key in graph.keys(){visit(key,graph,&mut visiting,&mut done,&mut Vec::new(),&mut cycles)}
|
||||
cycles
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn contracts_never_discharge_callsite_preconditions_implicitly(){
|
||||
let source=std::env::temp_dir().join(format!("marqdo-modular-{}",std::process::id()));
|
||||
let _=std::fs::remove_dir_all(&source);
|
||||
std::fs::create_dir_all(&source).unwrap();
|
||||
std::fs::write(source.join("callee.mq.md"),
|
||||
"# callee\n\n## f\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| c | 结果 = 2 | x > 0 | auto |\n\n*2*\n").unwrap();
|
||||
std::fs::write(source.join("main.mq.md"),
|
||||
"---\nimport:\n callee: callee.mq.md\n---\n# main\n\n## call\n\n**x = [外部调用](callee.callee.f())**\n*x*\n").unwrap();
|
||||
let compilation=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&source).unwrap()).unwrap();
|
||||
let report=analyze(&compilation.semantics,&json!({"claims":[]}));
|
||||
let obligations=report["obligations"].as_array().unwrap();
|
||||
assert!(!obligations.is_empty());
|
||||
assert!(obligations.iter().all(|x|x["status"]!="proved"));
|
||||
assert_eq!(report["proof_completion"],"not_established_by_dependency_analysis");
|
||||
// Even a caller-supplied "valid" callee receipt cannot discharge the
|
||||
// actual-argument bridge for a conditional requires clause.
|
||||
let callee=compilation.semantics.claims.iter().find(|c|c.label=="c").unwrap();
|
||||
let forged=json!({"claims":[{
|
||||
"owner_symbol_id":callee.owner.as_str(),
|
||||
"claim_anchor_id":callee.anchor_id,
|
||||
"conclusion":callee.conclusion,
|
||||
"premise":callee.premise,
|
||||
"status":"proved","usable":true
|
||||
}]});
|
||||
let conditional=analyze(&compilation.semantics,&forged);
|
||||
let first=conditional["obligations"].as_array().unwrap()
|
||||
.iter().find(|x|x["callee"]==callee.owner.as_str()).unwrap();
|
||||
assert_eq!(first["contracts"][0]["status"],"precondition_pending");
|
||||
assert_eq!(first["contracts"][0]["call_precondition_status"],
|
||||
"requires_symbolic_callsite_proof");
|
||||
assert_eq!(conditional["audit_passes"],false);
|
||||
std::fs::remove_dir_all(source).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,372 @@
|
||||
//! Cross-module projection contracts for the *abstract* Lean Int model.
|
||||
//!
|
||||
//! This is a source-regenerated, kernel-replayed proof: the callee returns
|
||||
//! exactly one of its own arguments and the caller forwards one static import.
|
||||
//! No arithmetic, dynamic dispatch, effects, exceptions or runtime Number
|
||||
//! equivalence is inferred. Unmodeled programs never get a certificate.
|
||||
use std::{collections::BTreeSet,fs,path::Path,time::Duration};
|
||||
use anyhow::{Context,Result};
|
||||
use serde_json::{json,Value};
|
||||
use sha2::{Digest,Sha256};
|
||||
use crate::{
|
||||
ast::{CallExpr,Expr,Function,Stmt},
|
||||
prove::driver::{Toolchain,compile_import_module},
|
||||
sema::ir::{BoundCall,Compilation,SemanticArtifact}
|
||||
};
|
||||
|
||||
const SCOPE:&str="number_contract_int_model_pure_forwarder_parameter_projection";
|
||||
const KIND:&str="marqdo_parameter_projection_composition";
|
||||
fn sha(bytes:&[u8])->String{format!("sha256:{:x}",Sha256::digest(bytes))}
|
||||
|
||||
struct Prepared {
|
||||
callee_source:String,
|
||||
caller_source:String,
|
||||
identity:String,
|
||||
result_label:String,
|
||||
parameter_index:usize,
|
||||
}
|
||||
fn lookup<'a>(functions:&'a [Function],segments:&[&str])->Option<&'a Function>{
|
||||
let (head,tail)=segments.split_first()?;
|
||||
let mut candidates=functions.iter().filter(|f|f.name==*head);
|
||||
let found=candidates.next()?;
|
||||
if candidates.next().is_some(){return None}
|
||||
if tail.is_empty(){Some(found)}else{lookup(&found.children,tail)}
|
||||
}
|
||||
pub(super) fn load_function(compiled:&Compilation,artifact:&SemanticArtifact)->Option<Function>{
|
||||
let text=fs::read_to_string(compiled.semantics.root.join(&artifact.source.file)).ok()?;
|
||||
let parsed=crate::parse::parse_source(&text).ok()?;
|
||||
lookup(&parsed.functions,&artifact.display_name.split('.').collect::<Vec<_>>()).cloned()
|
||||
}
|
||||
fn unwrap_var(expr:&Expr)->Option<&str>{
|
||||
match expr{
|
||||
Expr::Var(v)=>Some(v.as_str()),
|
||||
Expr::Occluded{payload:Some(inner),..}=>unwrap_var(inner),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn unwrap_call(expr:&Expr)->Option<&CallExpr>{
|
||||
match expr{
|
||||
Expr::Call(c)=>Some(c),
|
||||
Expr::Occluded{payload:Some(inner),..}=>unwrap_call(inner),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn projection(fun:&Function)->Option<&str>{
|
||||
match fun.body.as_slice(){
|
||||
[Stmt::Return{value,..}]=>unwrap_var(value),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
pub(super) fn forwarder(fun:&Function)->Option<&CallExpr>{
|
||||
match fun.body.as_slice(){
|
||||
[Stmt::Return{value,..}]=>unwrap_call(value),
|
||||
[Stmt::Assign{name,value,..},Stmt::Return{value:Expr::Var(result),..}]
|
||||
if name==result=>unwrap_call(value),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn exact_unconditional_claim(compiled:&Compilation,artifact:&SemanticArtifact,
|
||||
expected:&str)->bool{
|
||||
artifact.symbol_id.as_ref().is_some_and(|owner|
|
||||
compiled.semantics.claims.iter().filter(|c|
|
||||
c.owner==*owner &&
|
||||
c.premise.as_deref().map_or(true,|p|p.trim().is_empty()) &&
|
||||
c.conclusion.trim()==expected
|
||||
).count()==1)
|
||||
}
|
||||
fn candidate(compiled:&Compilation,call:&BoundCall)->Option<Prepared>{
|
||||
let sem=&compiled.semantics;
|
||||
let mut caller_artifacts=sem.artifacts.iter().filter(|a|
|
||||
a.kind=="function"&&a.symbol_id.as_ref()==Some(&call.caller));
|
||||
let ca=caller_artifacts.next()?;
|
||||
if caller_artifacts.next().is_some(){return None}
|
||||
let mut callee_artifacts=sem.artifacts.iter().filter(|a|
|
||||
a.kind=="function"&&a.symbol_id.as_ref()==Some(&call.target));
|
||||
let ce=callee_artifacts.next()?;
|
||||
if callee_artifacts.next().is_some(){return None}
|
||||
if ca.source.file==ce.source.file||call.caller==call.target||
|
||||
!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=load_function(compiled,ca)?;
|
||||
let callee=load_function(compiled,ce)?;
|
||||
if caller.is_object()||callee.is_object(){return None}
|
||||
let return_parameter=projection(&callee)?;
|
||||
let forwarded=forwarder(&caller)?.for_evaluation().ok()?;
|
||||
if forwarded.path.is_none()||forwarded.receiver.is_some()||
|
||||
crate::sema::bind::call_display(&forwarded)!=call.call_site ||
|
||||
sem.bound_calls.iter().filter(|c|c.caller==call.caller).count()!=1{
|
||||
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()||
|
||||
forwarded.args.len()!=call.args.len(){return None}
|
||||
// Canonical "number" includes non-integer variants at runtime.
|
||||
// Our result is exclusively about the mathematical Int abstraction.
|
||||
if cs.params.iter().chain(es.params.iter())
|
||||
.any(|p|!p.ty.eq_ignore_ascii_case("number")||!p.required||
|
||||
p.default_digest.is_some()){return None}
|
||||
if !cs.params.iter().zip(caller.params.iter())
|
||||
.all(|(a,b)|a.name==b.name) ||
|
||||
!es.params.iter().zip(callee.params.iter())
|
||||
.all(|(a,b)|a.name==b.name){return None}
|
||||
let k=es.params.iter().position(|p|p.name==return_parameter)?;
|
||||
if es.params.iter().filter(|p|p.name==return_parameter).count()!=1{
|
||||
return None
|
||||
}
|
||||
if !exact_unconditional_claim(compiled,ce,
|
||||
&format!("结果 = {return_parameter}")){return None}
|
||||
let mut args=Vec::new();
|
||||
let mut caller_result=None;
|
||||
for (i,(formal,arg)) in es.params.iter().zip(call.args.iter()).enumerate(){
|
||||
if arg.name.as_ref().is_some_and(|name|name!=&formal.name){return None}
|
||||
let (term,label)=if let Some(value)=arg.integer{
|
||||
(format!("({value} : Int)"),value.to_string())
|
||||
}else{
|
||||
let symbol=arg.symbol.as_ref()?;
|
||||
let index=cs.params.iter().position(|p|p.name==*symbol)?;
|
||||
if cs.params.iter().filter(|p|p.name==*symbol).count()!=1{return None}
|
||||
(format!("v{index}"),symbol.clone())
|
||||
};
|
||||
args.push(term);
|
||||
if i==k{caller_result=Some(label)}
|
||||
}
|
||||
let result_label=caller_result?;
|
||||
if !exact_unconditional_claim(compiled,ca,
|
||||
&format!("结果 = {result_label}")){return None}
|
||||
let callee_binders=(0..es.params.len())
|
||||
.map(|i|format!("(v{i} : Int)")).collect::<Vec<_>>().join(" ");
|
||||
let caller_binders=(0..cs.params.len())
|
||||
.map(|i|format!("(v{i} : Int)")).collect::<Vec<_>>().join(" ");
|
||||
let callee_vars=(0..es.params.len())
|
||||
.map(|i|format!("v{i}")).collect::<Vec<_>>().join(" ");
|
||||
let caller_vars=(0..cs.params.len())
|
||||
.map(|i|format!("v{i}")).collect::<Vec<_>>().join(" ");
|
||||
let call_terms=args.join(" ");
|
||||
let projected_term=&args[k];
|
||||
// No author-controlled identifiers appear in generated Lean code.
|
||||
let callee_source=format!(
|
||||
"def callee {callee_binders} : Int := v{k}\n\
|
||||
theorem callee_contract {callee_binders} : callee {callee_vars} = v{k} := by rfl\n");
|
||||
let caller_source=format!(
|
||||
"import CalleeModule\n\
|
||||
def caller {caller_binders} : Int := callee {call_terms}\n\
|
||||
theorem caller_contract {caller_binders} : caller {caller_vars} = {projected_term} := by\n\
|
||||
\x20\x20simpa [caller] using (callee_contract {call_terms})\n");
|
||||
Some(Prepared{
|
||||
callee_source,caller_source,
|
||||
identity:format!("{}#{}",ca.artifact_id.0,ce.artifact_id.0),
|
||||
result_label,parameter_index:k
|
||||
})
|
||||
}
|
||||
pub(super) fn eligible(compiled:&Compilation,call:&BoundCall)->bool{
|
||||
candidate(compiled,call).is_some()
|
||||
}
|
||||
pub(super) fn closures(compiled:&Compilation,call:&BoundCall)->Result<BTreeSet<(String,String)>>{
|
||||
let set=compiled.semantics.artifacts.iter()
|
||||
.filter(|a|a.symbol_id.as_ref()==Some(&call.caller)||
|
||||
a.symbol_id.as_ref()==Some(&call.target))
|
||||
.map(|a|(a.artifact_id.0.clone(),a.hashes.closure.0.clone()))
|
||||
.collect::<BTreeSet<_>>();
|
||||
anyhow::ensure!(set.len()==2,"proof.projection_ambiguous_dependency");
|
||||
Ok(set)
|
||||
}
|
||||
pub(super) fn prove(compiled:&Compilation,out:&Path,lean:&Toolchain)->Result<Vec<Value>>{
|
||||
let mut rows=Vec::new();
|
||||
for call in &compiled.semantics.bound_calls{
|
||||
if super::unified::covers(compiled,&call.caller){continue}
|
||||
let Some(plan)=candidate(compiled,call) else{continue};
|
||||
let dependencies=closures(compiled,call)?;
|
||||
let key=sha(format!("{}|{:?}|{}",plan.identity,dependencies,lean.version).as_bytes());
|
||||
let dir=out.join("composed").join(format!("projection-{}",&key[7..23]));
|
||||
fs::create_dir_all(&dir)?;
|
||||
let callee=dir.join("CalleeModule.lean");
|
||||
let caller=dir.join("CallerModule.lean");
|
||||
let callee_obj=dir.join("CalleeModule.olean");
|
||||
let caller_obj=dir.join("CallerModule.olean");
|
||||
fs::write(&callee,&plan.callee_source)?;
|
||||
fs::write(&caller,&plan.caller_source)?;
|
||||
let checked=(||->Result<()>{
|
||||
compile_import_module(lean,&callee,&callee_obj,&dir,
|
||||
Duration::from_secs(120)).context("projection callee")?;
|
||||
compile_import_module(lean,&caller,&caller_obj,&dir,
|
||||
Duration::from_secs(120)).context("projection caller")?;
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(e)=checked{
|
||||
let _=fs::remove_file(dir.join("composition-certificate.json"));
|
||||
rows.push(json!({"identity":plan.identity,"status":"lean_rejected",
|
||||
"scope":SCOPE,"error":format!("{e:#}")}));
|
||||
continue
|
||||
}
|
||||
let cert=json!({
|
||||
"schema_version":1,"kind":KIND,"scope":SCOPE,
|
||||
"status":"lean_kernel_proved_model",
|
||||
"identity":plan.identity,
|
||||
"caller":call.caller.as_str(),"callee":call.target.as_str(),
|
||||
"result_label":plan.result_label,
|
||||
"parameter_index":plan.parameter_index,
|
||||
"callee_source_sha256":sha(plan.callee_source.as_bytes()),
|
||||
"caller_source_sha256":sha(plan.caller_source.as_bytes()),
|
||||
"callee_compiled_sha256":sha(&fs::read(&callee_obj)?),
|
||||
"caller_compiled_sha256":sha(&fs::read(&caller_obj)?),
|
||||
"toolchain":lean.version,
|
||||
"source_closures":dependencies.iter().map(|(id,closure)|
|
||||
json!({"id":id,"closure":closure})).collect::<Vec<_>>(),
|
||||
"runtime_domain_verified":false,
|
||||
"independent_replay":"CalleeModule.lean then CallerModule.lean"
|
||||
});
|
||||
let receipt=dir.join("composition-certificate.json");
|
||||
fs::write(&receipt,serde_json::to_vec_pretty(&cert)?)?;
|
||||
rows.push(json!({"identity":plan.identity,"status":"lean_kernel_proved_model",
|
||||
"artifact":receipt,"scope":SCOPE}));
|
||||
}
|
||||
Ok(rows)
|
||||
}
|
||||
pub(super) fn replay(compiled:&Compilation,certificate:&Path,lean:&Toolchain)
|
||||
->Result<Value>{
|
||||
let cert:Value=serde_json::from_slice(&fs::read(certificate)?)?;
|
||||
anyhow::ensure!(cert["schema_version"]==1&&cert["kind"]==KIND&&
|
||||
cert["scope"]==SCOPE&&cert["status"]=="lean_kernel_proved_model",
|
||||
"proof.projection_invalid_certificate");
|
||||
anyhow::ensure!(cert["toolchain"]==lean.version,
|
||||
"proof.projection_stale_toolchain");
|
||||
let identity=cert["identity"].as_str().context("missing identity")?;
|
||||
let matches=compiled.semantics.bound_calls.iter().filter_map(|call|
|
||||
candidate(compiled,call).and_then(|p|
|
||||
(p.identity==identity).then_some((call,p)))).collect::<Vec<_>>();
|
||||
anyhow::ensure!(matches.len()==1,
|
||||
"proof.projection_ambiguous_or_stale_source");
|
||||
let (call,plan)=&matches[0];
|
||||
anyhow::ensure!(cert["caller"]==call.caller.as_str()&&
|
||||
cert["callee"]==call.target.as_str()&&
|
||||
cert["parameter_index"]==plan.parameter_index&&
|
||||
cert["result_label"]==plan.result_label,
|
||||
"proof.projection_changed_proof_subject");
|
||||
let expected=closures(compiled,call)?;
|
||||
let rows=cert["source_closures"].as_array()
|
||||
.context("proof.projection_missing_closures")?;
|
||||
let actual=rows.iter().map(|r|Ok((
|
||||
r["id"].as_str().context("proof.projection_bad_id")?.to_string(),
|
||||
r["closure"].as_str().context("proof.projection_bad_closure")?.to_string()
|
||||
))).collect::<Result<BTreeSet<_>>>()?;
|
||||
anyhow::ensure!(rows.len()==expected.len()&&actual==expected,
|
||||
"proof.projection_stale_or_ambiguous_closure");
|
||||
let dir=certificate.parent().context("missing certificate parent")?;
|
||||
let callee=dir.join("CalleeModule.lean");
|
||||
let caller=dir.join("CallerModule.lean");
|
||||
anyhow::ensure!(fs::read_to_string(&callee)?==plan.callee_source&&
|
||||
fs::read_to_string(&caller)?==plan.caller_source&&
|
||||
cert["callee_source_sha256"]==sha(plan.callee_source.as_bytes())&&
|
||||
cert["caller_source_sha256"]==sha(plan.caller_source.as_bytes()),
|
||||
"proof.projection_generated_source_mismatch");
|
||||
let callee_obj=dir.join("CalleeModule.olean");
|
||||
let caller_obj=dir.join("CallerModule.olean");
|
||||
compile_import_module(lean,&callee,&callee_obj,dir,
|
||||
Duration::from_secs(120))?;
|
||||
compile_import_module(lean,&caller,&caller_obj,dir,
|
||||
Duration::from_secs(120))?;
|
||||
anyhow::ensure!(cert["callee_compiled_sha256"]==sha(&fs::read(callee_obj)?)&&
|
||||
cert["caller_compiled_sha256"]==sha(&fs::read(caller_obj)?),
|
||||
"proof.projection_replay_output_changed");
|
||||
Ok(json!({"schema_version":1,"kind":"independent_composition_replay",
|
||||
"status":"lean_kernel_replayed","scope":SCOPE,"identity":identity,
|
||||
"current_source_verified":true,
|
||||
"full_marqdo_runtime_semantics_proved":false}))
|
||||
}
|
||||
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test]
|
||||
fn symbolic_projection_uses_only_the_selected_actual(){
|
||||
let root=std::env::temp_dir().join(format!(
|
||||
"marqdo-projection-unit-{}",std::process::id()));
|
||||
let _=fs::remove_dir_all(&root);
|
||||
fs::create_dir_all(&root).unwrap();
|
||||
let callee=r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
# math
|
||||
## select
|
||||
+ `first`
|
||||
+ `second`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| first | int | integer |
|
||||
| second | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| proj | 结果 = second | auto |
|
||||
|
||||
*`second`*
|
||||
"#;
|
||||
let caller=r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
# main
|
||||
## use
|
||||
+ `x`
|
||||
+ `y`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| x | int | integer |
|
||||
| y | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| forwarded | 结果 = x | auto |
|
||||
|
||||
**v = [选择](math.math.select(`y`, `x`))**
|
||||
*v*
|
||||
"#;
|
||||
fs::write(root.join("math.mq.md"),callee).unwrap();
|
||||
fs::write(root.join("main.mq.md"),caller).unwrap();
|
||||
let project=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=project.semantics.bound_calls.iter().find(|c|
|
||||
c.call_site=="math.math.select").expect("static call");
|
||||
let proof=candidate(&project,call).expect("symbolic projection");
|
||||
assert_eq!(proof.parameter_index,1);
|
||||
assert_eq!(proof.result_label,"x");
|
||||
assert!(proof.callee_source.contains(":= v1"));
|
||||
assert!(proof.caller_source.contains("callee v1 v0"));
|
||||
assert!(proof.caller_source.contains("= v0"));
|
||||
assert!(!proof.caller_source.contains("sorry"));
|
||||
|
||||
// Reordering the actuals without changing the asserted result must
|
||||
// invalidate the caller contract; source is the authority.
|
||||
let incorrect=caller.replace(
|
||||
"math.math.select(`y`, `x`)",
|
||||
"math.math.select(`x`, `y`)");
|
||||
fs::write(root.join("main.mq.md"),incorrect).unwrap();
|
||||
let changed=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=changed.semantics.bound_calls.iter().find(|c|
|
||||
c.call_site=="math.math.select").unwrap();
|
||||
assert!(candidate(&changed,call).is_none());
|
||||
|
||||
// A declaration with an unsatisfied precondition is NOT a proof.
|
||||
fs::write(root.join("main.mq.md"),caller).unwrap();
|
||||
fs::write(root.join("math.mq.md"),
|
||||
callee.replace("| proj | 结果 = second | auto |",
|
||||
"| proj | 结果 = second | auto |\n| other | 结果 = second | auto |")).unwrap();
|
||||
let ambiguous=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=ambiguous.semantics.bound_calls.iter().find(|c|
|
||||
c.call_site=="math.math.select").unwrap();
|
||||
assert!(candidate(&ambiguous,call).is_none());
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,336 @@
|
||||
//! Bind a proved function claim to one semantic symbol, never to every
|
||||
//! marked step. Unmatched identities and stale evidence fail closed.
|
||||
|
||||
use std::{collections::BTreeMap, fs, path::Path};
|
||||
use anyhow::{Context, Result};
|
||||
use serde_json::{json, Value};
|
||||
use sha2::{Digest, Sha256};
|
||||
use crate::{prove::{Report, Verdict}, sema::ir::{Compilation, SemanticArtifact, SemanticProject}};
|
||||
|
||||
fn sha(bytes: &[u8]) -> String {
|
||||
format!("sha256:{:x}", Sha256::digest(bytes))
|
||||
}
|
||||
fn generated_module_valid(folder:&Path,expected:&Value)->bool {
|
||||
let source_dir=folder.join("Generated");
|
||||
let Ok(files)=fs::read_dir(&source_dir) else {return false};
|
||||
let mut candidates=files.flatten().filter(|f|
|
||||
f.path().extension().is_some_and(|ext|ext=="lean")).collect::<Vec<_>>();
|
||||
if candidates.len()!=1{return false}
|
||||
let Some(generated)=candidates.pop() else{return false};
|
||||
let Ok(source)=fs::read(generated.path()) else{return false};
|
||||
sha(&source).trim_start_matches("sha256:")==expected.as_str().unwrap_or("")
|
||||
}
|
||||
/// Never accept a mutable cached Lean source as proof authority. Rebuild the
|
||||
/// expected module and plan from the current Marqdo source with the same
|
||||
/// compiler pipeline used by prove_path; a forged axiom/sorry in the cached
|
||||
/// Lean file will not match the deterministic generated source.
|
||||
fn cached_translation_matches_current(
|
||||
folder:&Path, entry:&Value,semantic:&SemanticProject
|
||||
)->bool {
|
||||
let Some(rel)=entry["source_file"].as_str() else{return false};
|
||||
let Some(display)=entry["proof_module_display"].as_str() else{return false};
|
||||
let abs=semantic.root.join(rel);
|
||||
let Ok(module)=crate::load::load_module(&abs) else{return false};
|
||||
let Some(source_sha)=module.source.sha256.as_deref() else{return false};
|
||||
if entry["source_sha256"]!=source_sha{return false}
|
||||
let effects=crate::prove::lower::effect_map(&abs);
|
||||
let Ok((plan,_))=crate::prove::lower::build_plan(
|
||||
&module,source_sha,display,effects,&[]) else{return false};
|
||||
if fs::read(folder.join("plan.json")).ok().as_deref()
|
||||
!=Some(plan.to_stable_json().as_bytes()) {
|
||||
return false;
|
||||
}
|
||||
let (generated_name,expected)=crate::prove::emit::emit_module(
|
||||
&plan,&crate::prove::emit::stem_of(display));
|
||||
let generated=folder.join("Generated").join(generated_name);
|
||||
if fs::read(generated).ok().as_deref()!=Some(expected.as_bytes()) {
|
||||
return false;
|
||||
}
|
||||
sha(expected.as_bytes()).trim_start_matches("sha256:")
|
||||
==entry["module_sha256"].as_str().unwrap_or("")
|
||||
}
|
||||
|
||||
fn certificate_identity_valid(folder:&Path,cert:&Value)->bool {
|
||||
let Ok(plan)=fs::read(folder.join("plan.json")) else {return false};
|
||||
let source=cert["source_sha256"].as_str().unwrap_or("");
|
||||
let library=cert["library_sha256"].as_str().unwrap_or("");
|
||||
let toolchain=cert["toolchain"].as_str().unwrap_or("");
|
||||
let actual_library=crate::prove::cache::sha256_hex(
|
||||
crate::prove::driver::LIBRARY_SRC.as_bytes());
|
||||
let expected_key=crate::prove::cache::cache_key(
|
||||
source,&crate::prove::cache::sha256_hex(&plan),
|
||||
library,toolchain,env!("CARGO_PKG_VERSION"));
|
||||
library==actual_library
|
||||
&& cert["marqdo"]==env!("CARGO_PKG_VERSION")
|
||||
&& cert["key"]==expected_key
|
||||
&& generated_module_valid(folder,&cert["module_sha256"])
|
||||
}
|
||||
|
||||
fn certificate(dir: &Path, report: &Report) -> Option<(Value, String)> {
|
||||
let bytes = fs::read(dir.join("certificate.json")).ok()?;
|
||||
let cert: Value = serde_json::from_slice(&bytes).ok()?;
|
||||
let lean = report.lean.as_ref()?;
|
||||
if cert["schema"] != 1 || cert["source_sha256"] != report.source_sha256
|
||||
|| cert["tier"] != "lean" || cert["library_sha256"] != lean.library_sha256
|
||||
|| cert["toolchain"] != lean.toolchain || cert["module_sha256"] != lean.module_sha256 {
|
||||
return None;
|
||||
}
|
||||
Some((cert, sha(&bytes)))
|
||||
}
|
||||
|
||||
fn matching<'a>(compiled: &'a Compilation, path: &Path, name: &str)
|
||||
-> Option<&'a SemanticArtifact> {
|
||||
let file=path.canonicalize().ok()?;
|
||||
let mut all=compiled.semantics.artifacts.iter()
|
||||
.filter(|a|a.kind=="function" && a.display_name==name)
|
||||
.filter(|a|compiled.semantics.root.join(&a.source.file)
|
||||
.canonicalize().ok().as_deref()==Some(file.as_path()));
|
||||
let first=all.next()?;
|
||||
all.next().is_none().then_some(first)
|
||||
}
|
||||
|
||||
/// Exact owner binding; related step anchors are navigation only, not proved.
|
||||
pub fn link_report(compiled: &Compilation, file: &Path, report: &Report, dir: &Path) -> Value {
|
||||
let cert=certificate(dir,report);
|
||||
let mut claims=Vec::new();
|
||||
let mut unresolved=Vec::new();
|
||||
for f in &report.functions {
|
||||
let Some(owner)=matching(compiled,file,&f.name) else {
|
||||
unresolved.push(json!({"function":f.name,"reason":"unbound_or_ambiguous"}));
|
||||
continue;
|
||||
};
|
||||
let Some(symbol)=owner.symbol_id.as_ref() else {
|
||||
unresolved.push(json!({"function":f.name,"reason":"missing_symbol_id"}));
|
||||
continue;
|
||||
};
|
||||
let steps:Vec<&str>=compiled.semantics.steps.iter()
|
||||
.filter(|s|s.id.0.starts_with(&format!("{}#step-",symbol.as_str())))
|
||||
.filter_map(|s|s.anchor_id.as_deref()).collect();
|
||||
for claim in &f.claims {
|
||||
// A proof receipt must be bound to the exact theorem declaration
|
||||
// present in the same AST, not merely to a similarly named function.
|
||||
let mut matching_claims=compiled.semantics.claims.iter().filter(|decl|
|
||||
decl.owner==*symbol && decl.label==claim.id
|
||||
&& decl.conclusion==claim.conclusion
|
||||
&& decl.premise==claim.premise);
|
||||
let Some(declared)=matching_claims.next() else {
|
||||
unresolved.push(json!({"function":f.name,"claim":claim.id,
|
||||
"reason":"theorem_declaration_missing_or_changed"}));
|
||||
continue;
|
||||
};
|
||||
if matching_claims.next().is_some() {
|
||||
unresolved.push(json!({"function":f.name,"claim":claim.id,
|
||||
"reason":"ambiguous_theorem_declaration"}));
|
||||
continue;
|
||||
}
|
||||
let cert_ok=cert.as_ref().is_some_and(|(v,_)|
|
||||
v["claims"].as_array().is_some_and(|records|
|
||||
records.iter().any(|r|
|
||||
r["id"]==claim.id && r["function"]==f.name
|
||||
&& r["status"]=="proved")));
|
||||
let proved=claim.status==Verdict::Proved && claim.decided_by=="lean" && cert_ok;
|
||||
let status=if claim.status==Verdict::Proved && !proved {
|
||||
"unverified"
|
||||
} else { claim.status.as_str() };
|
||||
claims.push(json!({
|
||||
"claim_anchor_id":declared.anchor_id,
|
||||
"owner_symbol_id":symbol.as_str(),
|
||||
"function":f.name,"claim_id":claim.id,
|
||||
"premise":claim.premise,"conclusion":claim.conclusion,
|
||||
"source_line":claim.source_line,
|
||||
"status":status,
|
||||
"decided_by":if proved {"lean"} else if status=="checked" {"offline"} else {"none"},
|
||||
"certificate_digest":if proved {cert.as_ref().map(|(_,h)|h.as_str())} else {None},
|
||||
"proof_scope":"function",
|
||||
"evidence":super::evidence::for_receipt(
|
||||
status,proved,false),
|
||||
"related_anchor_ids":steps,
|
||||
"related_anchor_relation":"defined_in_same_function_not_individually_proved",
|
||||
"semantic_hashes":{"interface":owner.hashes.interface.0,
|
||||
"implementation":owner.hashes.implementation.0,
|
||||
"closure":owner.hashes.closure.0},
|
||||
"source_file":owner.source.file,
|
||||
"source_sha256":report.source_sha256,
|
||||
"library_sha256":report.lean.as_ref().map(|l|l.library_sha256.as_str()),
|
||||
"toolchain":report.lean.as_ref().map(|l|l.toolchain.as_str()),
|
||||
"module_sha256":report.lean.as_ref().map(|l|l.module_sha256.as_str()),
|
||||
"proof_module_display":report.file
|
||||
}));
|
||||
}
|
||||
}
|
||||
claims.sort_by(|a,b|a["claim_anchor_id"].as_str().cmp(&b["claim_anchor_id"].as_str()));
|
||||
let assumptions:Vec<Value>=compiled.semantics.assumptions.iter()
|
||||
.filter(|a|compiled.semantics.root.join(&a.source.file)
|
||||
.canonicalize().ok().as_deref()==file.canonicalize().ok().as_deref())
|
||||
.map(|a|json!({"id":a.id,"owner":a.owner.as_str(),
|
||||
"operation":a.operation,"premise":a.premise,
|
||||
"postcondition":a.postcondition,
|
||||
"status":"declared_not_disclosed_as_proved"}))
|
||||
.collect();
|
||||
json!({"schema_version":1,"kind":"knowledge_proof_linkage",
|
||||
"source_sha256":report.source_sha256,"file":report.file,
|
||||
"claims":claims,"assumptions":assumptions,"unresolved":unresolved})
|
||||
}
|
||||
|
||||
pub fn emit_links(file: &Path, report: &Report, dir: &Path) -> Result<()> {
|
||||
let result=match crate::sema::ir::compile_file_closure(file) {
|
||||
Ok(compiled)=>link_report(&compiled,file,report,dir),
|
||||
Err(err)=>json!({"schema_version":1,"kind":"knowledge_proof_linkage",
|
||||
"status":"unbound","source_sha256":report.source_sha256,"claims":[],
|
||||
"unresolved":[{"reason":"semantic_compile_failed","detail":format!("{err:#}")}]}),
|
||||
};
|
||||
let path=dir.join("knowledge-links.json");
|
||||
fs::write(&path,serde_json::to_vec_pretty(&result)?)
|
||||
.with_context(||format!("write {}",path.display()))
|
||||
}
|
||||
|
||||
/// Invalidate proof links against both semantic owner hashes and source bytes.
|
||||
/// Certificate integrity is rechecked; duplicate claim identities are refused.
|
||||
pub fn index_links(prove_dir:&Path, semantic:&SemanticProject)->Value {
|
||||
let owners:BTreeMap<_,_>=semantic.artifacts.iter()
|
||||
.filter_map(|a|a.symbol_id.as_ref().map(|id|(id.as_str().to_string(),a)))
|
||||
.collect();
|
||||
let mut entries=Vec::new();
|
||||
if let Ok(folders)=fs::read_dir(prove_dir) {
|
||||
for folder in folders.flatten().filter(|f|f.path().is_dir()) {
|
||||
let Ok(bytes)=fs::read(folder.path().join("knowledge-links.json")) else {continue};
|
||||
let Ok(link) = serde_json::from_slice::<Value>(&bytes) else {continue};
|
||||
let Some(claims)=link["claims"].as_array() else {continue};
|
||||
for claim in claims {
|
||||
let mut entry=claim.clone();
|
||||
entry["receipt_artifact"]=json!(folder.file_name().to_string_lossy().to_string());
|
||||
let owner=claim["owner_symbol_id"].as_str().and_then(|id|owners.get(id));
|
||||
let theorem_present=claim["owner_symbol_id"].as_str().is_some_and(|id|
|
||||
semantic.claims.iter().any(|c|
|
||||
c.owner.as_str()==id
|
||||
&& claim["claim_anchor_id"]==c.anchor_id
|
||||
&& claim["claim_id"]==c.label
|
||||
&& claim["conclusion"]==c.conclusion
|
||||
&& claim["premise"]==json!(c.premise)));
|
||||
let fresh=theorem_present && owner.is_some_and(|a| {
|
||||
claim["source_file"]==a.source.file
|
||||
&& claim["semantic_hashes"]["interface"]==a.hashes.interface.0
|
||||
&& claim["semantic_hashes"]["implementation"]==a.hashes.implementation.0
|
||||
&& claim["semantic_hashes"]["closure"]==a.hashes.closure.0
|
||||
&& fs::read(semantic.root.join(&a.source.file)).ok().is_some_and(
|
||||
|raw|sha(&raw).trim_start_matches("sha256:")==claim["source_sha256"])
|
||||
});
|
||||
let certified=cached_translation_matches_current(
|
||||
&folder.path(),&entry,semantic)
|
||||
&& entry["status"]=="proved" && entry["decided_by"]=="lean"
|
||||
&& entry["certificate_digest"].as_str().is_some_and(|digest|
|
||||
fs::read(folder.path().join("certificate.json")).ok().is_some_and(|bytes| {
|
||||
if sha(&bytes)!=digest { return false; }
|
||||
let Ok(cert)=serde_json::from_slice::<Value>(&bytes) else {
|
||||
return false
|
||||
};
|
||||
cert["schema"]==1 && cert["tier"]=="lean"
|
||||
&& certificate_identity_valid(&folder.path(),&cert)
|
||||
&& cert["source_sha256"]==entry["source_sha256"]
|
||||
&& cert["library_sha256"]==entry["library_sha256"]
|
||||
&& cert["toolchain"]==entry["toolchain"]
|
||||
&& cert["module_sha256"]==entry["module_sha256"]
|
||||
&& cert["claims"].as_array().is_some_and(|records|
|
||||
records.iter().any(|r|
|
||||
r["id"]==entry["claim_id"]
|
||||
&& r["function"]==entry["function"]
|
||||
&& r["status"]=="proved"))
|
||||
}));
|
||||
if !fresh {
|
||||
entry["status"]=json!("stale");
|
||||
entry["stale_reason"]=json!("source_or_semantic_dependency_changed");
|
||||
} else if entry["status"]=="proved" && !certified {
|
||||
entry["status"]=json!("unverified");
|
||||
entry["stale_reason"]=json!("missing_or_changed_lean_certificate");
|
||||
}
|
||||
entry["usable"]=json!(fresh && certified);
|
||||
entries.push(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
entries.sort_by(|a,b|a["claim_anchor_id"].as_str().cmp(&b["claim_anchor_id"].as_str()));
|
||||
let mut freq=BTreeMap::new();
|
||||
for e in &entries {
|
||||
if let Some(id)=e["claim_anchor_id"].as_str() {
|
||||
*freq.entry(id.to_string()).or_insert(0usize)+=1;
|
||||
}
|
||||
}
|
||||
for e in &mut entries {
|
||||
if e["claim_anchor_id"].as_str().and_then(|id|freq.get(id))
|
||||
.is_some_and(|n|*n>1) {
|
||||
e["status"]=json!("ambiguous");
|
||||
e["stale_reason"]=json!("multiple_proof_link_records");
|
||||
e["usable"]=json!(false);
|
||||
}
|
||||
}
|
||||
// Evidence is orthogonal to legacy `status`: a verified Lean receipt
|
||||
// means model_proved, NOT unrestricted Marqdo runtime correctness.
|
||||
for e in &mut entries {
|
||||
e["evidence"]=super::evidence::for_receipt(
|
||||
e["status"].as_str().unwrap_or("unknown"),
|
||||
e["usable"]==true,e["kernel_replayed"]==true);
|
||||
}
|
||||
json!({"schema_version":1,"role":"proof_receipts_not_execution_authority",
|
||||
"claims":entries})
|
||||
}
|
||||
|
||||
|
||||
/// Recheck every locally cached *usable* Lean receipt with an actual Lean
|
||||
/// invocation. Hash-only certificates are not trusted for --verify. An error
|
||||
/// at one folder revokes all its receipts; no JSON proof flag can override it.
|
||||
pub fn replay_index(
|
||||
prove_dir:&Path, index:&mut Value,
|
||||
toolchain:&crate::prove::driver::Toolchain,
|
||||
timeout:std::time::Duration
|
||||
)->Result<()> {
|
||||
let (libdir,_)=crate::prove::driver::ensure_library(prove_dir,toolchain)?;
|
||||
let mut replayed:BTreeMap<String,Vec<(String,String)>>=BTreeMap::new();
|
||||
let mut rejected:std::collections::BTreeSet<String>=std::collections::BTreeSet::new();
|
||||
let Some(entries)=index["claims"].as_array_mut() else {return Ok(())};
|
||||
let artifacts:std::collections::BTreeSet<_>=entries.iter()
|
||||
.filter(|e|e["usable"]==true)
|
||||
.filter_map(|e|e["receipt_artifact"].as_str().map(str::to_owned))
|
||||
.collect();
|
||||
for id in artifacts {
|
||||
if id=="." || id==".." || id.contains('/') || id.contains('\\'){
|
||||
rejected.insert(id);
|
||||
continue;
|
||||
}
|
||||
let src_dir=prove_dir.join(&id).join("Generated");
|
||||
let files=fs::read_dir(&src_dir).ok().into_iter()
|
||||
.flat_map(|items|items.flatten())
|
||||
.filter(|f|f.path().extension().is_some_and(|ext|ext=="lean"))
|
||||
.map(|f|f.path()).collect::<Vec<_>>();
|
||||
if files.len()!=1 {rejected.insert(id);continue;}
|
||||
let path=&files[0];
|
||||
let Ok(source)=fs::read_to_string(path) else {rejected.insert(id);continue};
|
||||
let Ok(outcome)=crate::prove::driver::check_module(
|
||||
toolchain,&libdir,path,&source,timeout,None) else {
|
||||
rejected.insert(id);continue;
|
||||
};
|
||||
if outcome.status!=Verdict::Proved ||
|
||||
fs::read_to_string(path).ok().as_deref()!=Some(source.as_str()) {
|
||||
rejected.insert(id);continue;
|
||||
}
|
||||
replayed.insert(id,outcome.claims.into_iter()
|
||||
.filter(|c|c.status==Verdict::Proved)
|
||||
.map(|c|(c.function,c.claim)).collect());
|
||||
}
|
||||
for entry in entries {
|
||||
if entry["usable"]!=true {continue;}
|
||||
let id=entry["receipt_artifact"].as_str().unwrap_or("");
|
||||
let found=replayed.get(id).is_some_and(|claims|claims.iter().any(|(fun,claim)|
|
||||
entry["function"]==fun.as_str() && entry["claim_id"]==claim.as_str()));
|
||||
if !found || rejected.contains(id) {
|
||||
entry["usable"]=json!(false);
|
||||
entry["status"]=json!("unverified");
|
||||
entry["stale_reason"]=json!("lean_kernel_replay_failed");
|
||||
} else {
|
||||
entry["kernel_replayed"]=json!(true);
|
||||
}
|
||||
entry["evidence"]=super::evidence::for_receipt(
|
||||
entry["status"].as_str().unwrap_or("unknown"),
|
||||
entry["usable"]==true,entry["kernel_replayed"]==true);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
//! Symbolic branch VCs for a deliberately restricted, pure integer fragment.
|
||||
//! A proved proposition in the Int abstraction is NOT by itself a proof of
|
||||
//! Marqdo runtime semantics (i64, dynamic values and exceptions).
|
||||
use std::collections::BTreeMap;
|
||||
use crate::prove::proof_check::{self,ClaimAst as A,CTok as T};
|
||||
use crate::sema::ir::{BoundCall,SemanticProject};
|
||||
|
||||
#[derive(Debug,Clone)]
|
||||
pub struct SymbolicGoal{
|
||||
pub proposition:String,
|
||||
pub guard_propositions:Vec<String>,
|
||||
pub guard_index:Option<usize>,
|
||||
pub binders:Vec<String>,
|
||||
pub runtime_domain_verified:bool,
|
||||
pub abstract_integer_model_supported:bool,
|
||||
}
|
||||
fn identifier(s:&str)->bool {
|
||||
!s.is_empty()&&s.chars().all(|c|c.is_alphanumeric()||c=='_')
|
||||
}
|
||||
fn term(expr:&A,bindings:&BTreeMap<String,String>)->Option<(String,bool)>{
|
||||
match expr {
|
||||
A::Lit(T::Int(n))=>Some((format!("({n} : Int)"),false)),
|
||||
A::Lit(T::Bool(b))=>Some((if *b{"True"}else{"False"}.into(),true)),
|
||||
A::Var(v)=>Some((bindings.get(v)?.clone(),false)),
|
||||
A::Bin{op,left,right}=>{
|
||||
let (l,lb)=term(left,bindings)?;
|
||||
let (r,rb)=term(right,bindings)?;
|
||||
match *op{
|
||||
"+" | "-" if !lb && !rb=>Some((format!("({l} {op} {r})"),false)),
|
||||
// omega only reasons about *linear* arithmetic. A variable
|
||||
// multiplied by another variable is never assumed linear.
|
||||
"*" if !lb && !rb
|
||||
&& (matches!(left.as_ref(),A::Lit(T::Int(_)))
|
||||
||matches!(right.as_ref(),A::Lit(T::Int(_))))=>
|
||||
Some((format!("({l} * {r})"),false)),
|
||||
"=" | "≠" | "<" | "≤" | ">" | "≥" if !lb && !rb=>
|
||||
Some((format!("({l} {op} {r})"),true)),
|
||||
"且" if lb && rb=>Some((format!("({l} ∧ {r})"),true)),
|
||||
"或" if lb && rb=>Some((format!("({l} ∨ {r})"),true)),
|
||||
_=>None
|
||||
}
|
||||
},
|
||||
A::Un{op:"非",expr}=>{
|
||||
let (inner,boolean)=term(expr,bindings)?;
|
||||
boolean.then(||(format!("(¬ {inner})"),true))
|
||||
},
|
||||
A::Un{op:"-",expr}=>{
|
||||
let (inner,boolean)=term(expr,bindings)?;
|
||||
(!boolean).then(||(format!("(-{inner})"),false))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn proposition(source:&str,bindings:&BTreeMap<String,String>)->Option<String>{
|
||||
let tokens=proof_check::tokenize_claim(source).ok()?;
|
||||
let (_,expr)=proof_check::parse_claim_expr(&tokens).ok()?;
|
||||
let (text,boolean)=term(&expr,bindings)?;
|
||||
boolean.then_some(text)
|
||||
}
|
||||
/// Source-backed branch facts are the only assumptions accepted; no theorem
|
||||
/// premise provided by a model/user is silently promoted to an axiom.
|
||||
pub fn plan(semantic:&SemanticProject,call:&BoundCall,premise:&str)->Option<SymbolicGoal>{
|
||||
if call.control_blocker.is_some()||call.path_guards.is_empty(){return None}
|
||||
let callee=semantic.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.target))?.signature.as_ref()?;
|
||||
let caller=semantic.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.caller))?.signature.as_ref()?;
|
||||
if callee.params.len()!=call.args.len(){return None}
|
||||
let mut caller_bind=BTreeMap::new();
|
||||
let mut binders=Vec::new();
|
||||
for (i,param) in caller.params.iter().enumerate(){
|
||||
if !identifier(¶m.name){return None}
|
||||
let variable=format!("v{i}");
|
||||
caller_bind.insert(param.name.clone(),format!("({variable} : Int)"));
|
||||
binders.push(variable);
|
||||
}
|
||||
// Marqdo canonical Number may include Int, Num and Formula.
|
||||
// Proof is over Int only; never claim a runtime type proof here.
|
||||
let model_supported=caller.params.iter()
|
||||
.all(|p|p.ty.eq_ignore_ascii_case("number"));
|
||||
if !model_supported {return None}
|
||||
let mut callee_bind=BTreeMap::new();
|
||||
for (formal,arg) in callee.params.iter().zip(call.args.iter()){
|
||||
if arg.name.as_ref().is_some_and(|s|s!=&formal.name){return None}
|
||||
let actual=if let Some(n)=arg.integer {
|
||||
format!("({n} : Int)")
|
||||
}else{
|
||||
caller_bind.get(arg.symbol.as_ref()?)?.clone()
|
||||
};
|
||||
if !identifier(&formal.name){return None}
|
||||
callee_bind.insert(formal.name.clone(),actual);
|
||||
}
|
||||
let wanted=proposition(premise,&callee_bind)?;
|
||||
let all=call.path_guards.iter().map(|guard|proposition(guard,&caller_bind))
|
||||
.collect::<Option<Vec<_>>>()?;
|
||||
let idx=all.iter().position(|guard|guard==&wanted);
|
||||
Some(SymbolicGoal {
|
||||
proposition:wanted,guard_propositions:all,guard_index:idx,
|
||||
binders,runtime_domain_verified:false,
|
||||
abstract_integer_model_supported:model_supported
|
||||
})
|
||||
}
|
||||
pub fn emit_lean(goals:&[(String,SymbolicGoal)])->String{
|
||||
let mut text=String::from("-- Symbolic path theorem over Int model; not runtime equivalence.\nnamespace MarqdoSymbolic\n");
|
||||
for (i,(_,g)) in goals.iter().enumerate(){
|
||||
let vars=g.binders.iter().map(|x|format!("({x} : Int)"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
let hypotheses=g.guard_propositions.iter().enumerate()
|
||||
.map(|(n,p)|format!("(h{n} : {p})"))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
let tactic=if let Some(n)=g.guard_index {
|
||||
format!(" exact h{n}")
|
||||
} else {
|
||||
" omega".to_string()
|
||||
};
|
||||
text.push_str(&format!("theorem path_vc_{i} {vars} {hypotheses} : {} := by\n{tactic}\n",
|
||||
g.proposition));
|
||||
}
|
||||
text.push_str("end MarqdoSymbolic\n");
|
||||
text
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test]
|
||||
fn branch_condition_generates_symbolic_lean_obligation() {
|
||||
let root=std::env::temp_dir().join(format!(
|
||||
"marqdo-symbolic-branch-{}",std::process::id()));
|
||||
let _=std::fs::remove_dir_all(&root);
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::write(root.join("math.mq.md"),
|
||||
"# math\n\n## exact\n+ `n`\n\n| 参数 | 类型 | 说明 |\n|---|---|---|\n| n | int | integer |\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| c | 结果 = 2 | n > 0 | auto |\n\n*2*\n").unwrap();
|
||||
std::fs::write(root.join("main.mq.md"),
|
||||
"---\nimport:\n math: math.mq.md\n---\n# main\n\n## f\n+ `n`\n\n| 参数 | 类型 | 说明 |\n|---|---|---|\n| n | int | integer |\n\n1. `n` > 0\n **v = [调用](math.math.exact(`n`))**\n2. *\n **v = 0**\n\n*v*\n").unwrap();
|
||||
let c=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=c.semantics.bound_calls.iter().find(|x|
|
||||
x.call_site=="math.math.exact").expect("import binding");
|
||||
assert_eq!(call.path_guards.len(),1);
|
||||
assert!(call.control_blocker.is_none());
|
||||
let goal=plan(&c.semantics,call,"n > 0")
|
||||
.expect("path condition should imply imported precondition");
|
||||
assert!(!goal.runtime_domain_verified);
|
||||
assert!(goal.abstract_integer_model_supported);
|
||||
assert_eq!(goal.guard_index,Some(0));
|
||||
let source=emit_lean(&[("branch-call".into(),goal)]);
|
||||
assert!(source.contains("theorem path_vc_0"));
|
||||
assert!(source.contains("exact h0"));
|
||||
assert!(!source.contains("sorry"));
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn linear_arithmetic_path_goals_are_supported_but_nonlinear_goals_fail_closed(){
|
||||
let params=BTreeMap::from([("n".into(),"(v0 : Int)".into()),
|
||||
("m".into(),"(v1 : Int)".into())]);
|
||||
let stronger=proposition("n + 5 > 10",¶ms)
|
||||
.expect("linear path condition");
|
||||
let weaker=proposition("n > 0",¶ms)
|
||||
.expect("linear callee precondition");
|
||||
let goal=SymbolicGoal{
|
||||
proposition:weaker,guard_propositions:vec![stronger],
|
||||
guard_index:None,binders:vec!["v0".into(),"v1".into()],
|
||||
runtime_domain_verified:false,abstract_integer_model_supported:true
|
||||
};
|
||||
let generated=emit_lean(&[("linear".into(),goal)]);
|
||||
assert!(generated.contains("omega"));
|
||||
assert!(generated.contains("+"));
|
||||
assert!(proposition("n * m > 0",¶ms).is_none(),
|
||||
"nonlinear multiplication cannot silently enter omega fragment");
|
||||
assert!(proposition("n * 3 > 0",¶ms).is_some());
|
||||
assert!(proposition("-n < 0",¶ms).is_some());
|
||||
assert!(proposition("n / 2 > 0",¶ms).is_none());
|
||||
}
|
||||
#[test]
|
||||
fn symbolic_guards_cannot_be_invented_from_unsupported_calls(){
|
||||
assert!(proposition("lib.fetch(x) > 0",&BTreeMap::new()).is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,498 @@
|
||||
//! Unified source-derived, kernel-checked modular contracts over the Lean Int
|
||||
//! abstraction. NOT an unrestricted Marqdo runtime correctness theorem.
|
||||
//!
|
||||
//! Each function is translated ONCE from its current AST into a separate Lean
|
||||
//! module. Contracts are proved from that source; callers use only imported
|
||||
//! contracts, never synthetic axioms or inlined callee implementations.
|
||||
//! Supported: pure, statically bound positional calls; integer linear terms,
|
||||
//! immutable expressions, sequential local assignments and total if/else
|
||||
//! branches; arbitrarily nested acyclic cross-file dependencies (depth capped).
|
||||
//! Unsupported: missing/multiple contracts, loops, recursive calls, plugins,
|
||||
//! effects, dynamic dispatch, defaults, conditional contracts, non-total branches,
|
||||
//! runtime Number/i64/Formula equivalence. Every such case fails closed.
|
||||
use std::{collections::{BTreeMap,BTreeSet},fs,path::Path,time::Duration};
|
||||
use anyhow::{Context,Result};
|
||||
use serde_json::{json,Value};
|
||||
use sha2::{Digest,Sha256};
|
||||
use crate::{
|
||||
ast::{Arg,BinaryOp,CallExpr,Expr,Function,Literal,Stmt,UnaryOp},
|
||||
prove::{driver::{Toolchain,compile_import_module},
|
||||
proof_check::{self,ClaimAst,CTok}},
|
||||
sema::{SymbolId,ir::{BoundCall,CanonicalParam,Compilation,SemanticArtifact}}
|
||||
};
|
||||
use super::projection::load_function;
|
||||
|
||||
const KIND:&str="marqdo_unified_modular_contract";
|
||||
const SCOPE:&str="pure_number_int_model_sequential_branch_dag";
|
||||
fn sha(bytes:&[u8])->String{format!("sha256:{:x}",Sha256::digest(bytes))}
|
||||
fn id_for(symbol:&str)->String{
|
||||
let value=sha(symbol.as_bytes());
|
||||
format!("f_{}",&value[7..31])
|
||||
}
|
||||
fn module_for(symbol:&str)->String{
|
||||
let value=sha(symbol.as_bytes());
|
||||
format!("M{}",&value[7..31])
|
||||
}
|
||||
fn args_text(args:&[String])->String{
|
||||
if args.is_empty(){String::new()}else{format!(" {}",args.join(" "))}
|
||||
}
|
||||
fn variables(count:usize)->Vec<String>{
|
||||
(0..count).map(|i|format!("v{i}")).collect()
|
||||
}
|
||||
fn binders(count:usize)->String{
|
||||
variables(count).iter().map(|v|format!(" ({v} : Int)")).collect()
|
||||
}
|
||||
fn unique_artifact<'a>(compiled:&'a Compilation,id:&str)
|
||||
->Option<&'a SemanticArtifact>{
|
||||
let mut found=compiled.semantics.artifacts.iter().filter(|a|
|
||||
a.kind=="function" && a.symbol_id.as_ref().is_some_and(|s|s.as_str()==id));
|
||||
let one=found.next()?;
|
||||
found.next().is_none().then_some(one)
|
||||
}
|
||||
fn basic_signature(params:&[CanonicalParam])->bool{
|
||||
params.iter().all(|p|p.ty.eq_ignore_ascii_case("number")
|
||||
&&p.required&&p.default_digest.is_none())
|
||||
&¶ms.iter().map(|p|&p.name).collect::<BTreeSet<_>>().len()==params.len()
|
||||
}
|
||||
fn claim_term(ast:&ClaimAst,params:&BTreeMap<String,String>,depth:usize)
|
||||
->Option<String>{
|
||||
if depth>=32{return None}
|
||||
match ast{
|
||||
ClaimAst::Lit(CTok::Int(n))=>Some(format!("({n} : Int)")),
|
||||
ClaimAst::Var(v)=>params.get(v).cloned(),
|
||||
ClaimAst::Un{op:"-",expr}=>Some(format!("(-{})",
|
||||
claim_term(expr,params,depth+1)?)),
|
||||
ClaimAst::Bin{op,left,right}=>{
|
||||
let symbol=match *op{"+"|"-"|"*"=>*op,_=>return None};
|
||||
// Multiplication between symbolic terms is outside the omega
|
||||
// fragment. Only multiplication by a literal is admitted.
|
||||
if symbol=="*" && !matches!(left.as_ref(),ClaimAst::Lit(CTok::Int(_)))
|
||||
&&!matches!(right.as_ref(),ClaimAst::Lit(CTok::Int(_))){return None}
|
||||
Some(format!("({} {symbol} {})",
|
||||
claim_term(left,params,depth+1)?,
|
||||
claim_term(right,params,depth+1)?))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn result_claim(compiled:&Compilation,artifact:&SemanticArtifact,
|
||||
params:&BTreeMap<String,String>)->Option<String>{
|
||||
let owner=artifact.symbol_id.as_ref()?;
|
||||
let mut matches=compiled.semantics.claims.iter().filter(|c|
|
||||
c.owner==*owner&&c.premise.as_deref()
|
||||
.map_or(true,|p|p.trim().is_empty())).filter_map(|c|{
|
||||
let tokens=proof_check::tokenize_claim(&c.conclusion).ok()?;
|
||||
let (_,ast)=proof_check::parse_claim_expr(&tokens).ok()?;
|
||||
match ast{
|
||||
ClaimAst::Bin{op,left,right}
|
||||
if matches!(*left,ClaimAst::Var(ref n) if n=="结果")=>{
|
||||
let operator=match op{
|
||||
"="=>"=", ">"=>">", "<"=>"<", "≥"=>">=", "≤"=>"<=", "≠"=>"!=",
|
||||
_=>return None
|
||||
};
|
||||
Some(format!("{operator} {}",claim_term(&right,params,0)?))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
});
|
||||
let first=matches.next()?;
|
||||
// One exported claim per function is an explicit, auditable boundary;
|
||||
// other statements are never silently promoted into assumptions.
|
||||
matches.next().is_none().then_some(first)
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct CallUse{
|
||||
callee:String,args:Vec<String>
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct Built{
|
||||
symbol:String,artifact:String,closure:String,module:String,lean:String,
|
||||
file:String,dep_symbols:BTreeSet<String>,result_operator:String
|
||||
}
|
||||
struct Builder<'a>{
|
||||
compilation:&'a Compilation,
|
||||
active:BTreeSet<String>,
|
||||
built:BTreeMap<String,Built>,
|
||||
order:Vec<String>
|
||||
}
|
||||
impl<'a> Builder<'a>{
|
||||
fn new(c:&'a Compilation)->Self{
|
||||
Self{compilation:c,active:BTreeSet::new(),
|
||||
built:BTreeMap::new(),order:Vec::new()}
|
||||
}
|
||||
fn number(&mut self,expr:&Expr,env:&BTreeMap<String,String>,owner:&str,
|
||||
line:u32,uses:&mut Vec<CallUse>,depth:usize)->Option<String>{
|
||||
if depth>=32{return None}
|
||||
match expr{
|
||||
Expr::Literal(Literal::Int(n))=>Some(format!("({n} : Int)")),
|
||||
Expr::Var(v)=>env.get(v).cloned(),
|
||||
Expr::Occluded{payload:Some(inner),..}=>
|
||||
self.number(inner,env,owner,line,uses,depth+1),
|
||||
Expr::Unary{op:UnaryOp::Neg,expr}=>Some(format!("(-{})",
|
||||
self.number(expr,env,owner,line,uses,depth+1)?)),
|
||||
Expr::Binary{op,left,right}=>{
|
||||
let symbol=match op{
|
||||
BinaryOp::Add=>"+",BinaryOp::Sub=>"-",
|
||||
BinaryOp::Mul=>"*",_=>return None
|
||||
};
|
||||
if symbol=="*" && !matches!(left.as_ref(),Expr::Literal(Literal::Int(_)))
|
||||
&&!matches!(right.as_ref(),Expr::Literal(Literal::Int(_))){
|
||||
return None
|
||||
}
|
||||
let a=self.number(left,env,owner,line,uses,depth+1)?;
|
||||
let b=self.number(right,env,owner,line,uses,depth+1)?;
|
||||
Some(format!("({a} {symbol} {b})"))
|
||||
},
|
||||
Expr::Call(call)=>self.call(call,env,owner,line,uses,depth+1),
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn condition(&mut self,expr:&Expr,env:&BTreeMap<String,String>,
|
||||
owner:&str,line:u32,uses:&mut Vec<CallUse>,depth:usize)->Option<String>{
|
||||
if depth>=32{return None}
|
||||
match expr{
|
||||
Expr::Literal(Literal::Bool(b))=>Some(if *b{"True"}else{"False"}.into()),
|
||||
Expr::Occluded{payload:Some(inner),..}=>
|
||||
self.condition(inner,env,owner,line,uses,depth+1),
|
||||
Expr::Unary{op:UnaryOp::Not,expr}=>Some(format!("(¬ {})",
|
||||
self.condition(expr,env,owner,line,uses,depth+1)?)),
|
||||
Expr::Binary{op,left,right}=>{
|
||||
let relation=match op{
|
||||
BinaryOp::Eq=>Some("="),BinaryOp::Ne=>Some("≠"),
|
||||
BinaryOp::Lt=>Some("<"),BinaryOp::Le=>Some("≤"),
|
||||
BinaryOp::Gt=>Some(">"),BinaryOp::Ge=>Some("≥"),
|
||||
_=>None
|
||||
};
|
||||
if let Some(rel)=relation{
|
||||
let a=self.number(left,env,owner,line,uses,depth+1)?;
|
||||
let b=self.number(right,env,owner,line,uses,depth+1)?;
|
||||
return Some(format!("({a} {rel} {b})"))
|
||||
}
|
||||
let relation=match op{BinaryOp::And=>"∧",
|
||||
BinaryOp::Or=>"∨",_=>return None};
|
||||
let a=self.condition(left,env,owner,line,uses,depth+1)?;
|
||||
let b=self.condition(right,env,owner,line,uses,depth+1)?;
|
||||
Some(format!("({a} {relation} {b})"))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn call(&mut self,call:&CallExpr,env:&BTreeMap<String,String>,
|
||||
owner:&str,line:u32,uses:&mut Vec<CallUse>,depth:usize)->Option<String>{
|
||||
if depth>=32 ||call.path.is_none()||call.receiver.is_some()
|
||||
||!call.pre_modifiers.is_empty(){return None}
|
||||
let normalized=call.for_evaluation().ok()?;
|
||||
let display=crate::sema::bind::call_display(&normalized);
|
||||
let mut matches=self.compilation.semantics.bound_calls.iter().filter(|bc|
|
||||
bc.caller.as_str()==owner &&bc.source.line==line&&
|
||||
bc.call_site==display);
|
||||
let bound=matches.next()?.clone();
|
||||
if matches.next().is_some()||bound.control_blocker.is_some()
|
||||
||!bound.required_effects.is_pure()||bound.args.len()!=call.args.len(){
|
||||
return None
|
||||
}
|
||||
let callee=bound.target.as_str();
|
||||
if callee==owner{return None}
|
||||
let artifact=unique_artifact(self.compilation,callee)?;
|
||||
if !artifact.effects.is_pure(){return None}
|
||||
let signature=artifact.signature.as_ref()?;
|
||||
if !basic_signature(&signature.params)||
|
||||
signature.params.len()!=call.args.len(){return None}
|
||||
// Only positional arguments, in executable order, are trusted here.
|
||||
// Named/default/variadic semantics require their own binding proof.
|
||||
let mut args=Vec::new();
|
||||
for (actual,static_arg) in call.args.iter().zip(&bound.args){
|
||||
if static_arg.name.is_some(){return None}
|
||||
let Arg::Positional(value)=actual else{return None};
|
||||
args.push(self.number(value,env,owner,line,uses,depth+1)?);
|
||||
}
|
||||
self.visit(callee)?;
|
||||
uses.push(CallUse{callee:callee.to_owned(),args:args.clone()});
|
||||
Some(format!("({}{})",id_for(callee),args_text(&args)))
|
||||
}
|
||||
fn block(&mut self,items:&[Stmt],mut env:BTreeMap<String,String>,
|
||||
owner:&str,uses:&mut Vec<CallUse>,conditions:&mut Vec<String>,depth:usize)->Option<String>{
|
||||
if depth>=32{return None}
|
||||
for (index,st) in items.iter().enumerate(){
|
||||
match st{
|
||||
Stmt::Assign{name,value,span,..}=>{
|
||||
let rhs=self.number(value,&env,owner,span.line,uses,0)?;
|
||||
env.insert(name.clone(),rhs);
|
||||
},
|
||||
Stmt::Return{value,span} if index+1==items.len()=>{
|
||||
return self.number(value,&env,owner,span.line,uses,0)
|
||||
},
|
||||
Stmt::Branch{arms,span} if index+1==items.len()=>{
|
||||
// A branch must explicitly cover all outcomes, including
|
||||
// its else arm. No unproved fallthrough is accepted.
|
||||
let mut otherwise=None;
|
||||
for arm in arms.iter().rev(){
|
||||
let expression=self.block(&arm.body,env.clone(),
|
||||
owner,uses,conditions,depth+1)?;
|
||||
otherwise=Some(if let Some(condition)=&arm.condition{
|
||||
let cond=self.condition(condition,&env,owner,
|
||||
span.line,uses,0)?;
|
||||
if !conditions.contains(&cond){conditions.push(cond.clone())}
|
||||
let rest=otherwise?;
|
||||
format!("(if {cond} then {expression} else {rest})")
|
||||
}else{
|
||||
if otherwise.is_some(){return None}
|
||||
expression
|
||||
});
|
||||
}
|
||||
return otherwise
|
||||
},
|
||||
_=>return None
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
fn visit(&mut self,symbol:&str)->Option<()>{
|
||||
if self.built.contains_key(symbol){return Some(())}
|
||||
if self.active.len()>=24||!self.active.insert(symbol.to_owned()){
|
||||
return None
|
||||
}
|
||||
let result=(||->Option<Built>{
|
||||
let a=unique_artifact(self.compilation,symbol)?.clone();
|
||||
if !a.effects.is_pure(){return None}
|
||||
let sig=a.signature.as_ref()?;
|
||||
if !basic_signature(&sig.params){return None}
|
||||
let fun:Function=load_function(self.compilation,&a)?;
|
||||
if fun.is_object()||fun.params.len()!=sig.params.len()
|
||||
||!fun.params.iter().zip(&sig.params)
|
||||
.all(|(f,p)|f.name==p.name){return None}
|
||||
let env=sig.params.iter().enumerate().map(|(i,p)|
|
||||
(p.name.clone(),format!("v{i}"))).collect::<BTreeMap<_,_>>();
|
||||
let contract=result_claim(self.compilation,&a,&env)?;
|
||||
let mut call_uses=Vec::new();
|
||||
let mut conditions=Vec::new();
|
||||
let body=self.block(&fun.body,env,symbol,&mut call_uses,
|
||||
&mut conditions,0)?;
|
||||
// No semantically relevant BoundCall may remain unmodeled:
|
||||
// every source call requires a unique static binding.
|
||||
let source_count=self.compilation.semantics.bound_calls.iter()
|
||||
.filter(|c|c.caller.as_str()==symbol).count();
|
||||
if call_uses.len()!=source_count{return None}
|
||||
let deps=call_uses.iter().map(|use_|use_.callee.clone())
|
||||
.collect::<BTreeSet<_>>();
|
||||
if deps.contains(symbol){return None}
|
||||
let fname=id_for(symbol);
|
||||
let args=variables(sig.params.len());
|
||||
let bind=binders(sig.params.len());
|
||||
let invocation=format!("{fname}{}",args_text(&args));
|
||||
let mut source=String::new();
|
||||
for dep in &deps{
|
||||
source.push_str(&format!("import {}\n",module_for(dep)));
|
||||
}
|
||||
source.push_str(&format!(
|
||||
"-- Generated from a pure Marqdo AST. Int abstraction only.\n\
|
||||
def {fname}{bind} : Int := {body}\n\
|
||||
theorem {fname}_contract{bind} : {invocation} {contract} := by\n"));
|
||||
for (i,use_) in call_uses.iter().enumerate(){
|
||||
let callee_contract=format!("{}_contract",id_for(&use_.callee));
|
||||
source.push_str(&format!(
|
||||
" have hc{i} := {callee_contract}{}\n",args_text(&use_.args)));
|
||||
}
|
||||
// `split_ifs` is a Mathlib tactic, unavailable under the
|
||||
// pinned core Lean toolchain. Case-split on source-derived
|
||||
// conditions using core `by_cases`, then simplify each case.
|
||||
let mut tactic=format!(" simp only [{fname}] at *");
|
||||
for (i,condition) in conditions.iter().enumerate(){
|
||||
tactic.push_str(&format!(" <;> by_cases h{i} : {condition}"));
|
||||
}
|
||||
if conditions.is_empty(){
|
||||
tactic.push_str(" <;> omega\n");
|
||||
}else{
|
||||
tactic.push_str(" <;> simp_all <;> omega\n");
|
||||
}
|
||||
source.push_str(&tactic);
|
||||
let operator=contract.split_whitespace().next()?.to_string();
|
||||
Some(Built{
|
||||
symbol:symbol.to_owned(),artifact:a.artifact_id.0.clone(),
|
||||
closure:a.hashes.closure.0.clone(),module:module_for(symbol),
|
||||
lean:source,file:a.source.file.clone(),dep_symbols:deps,
|
||||
result_operator:operator
|
||||
})
|
||||
})();
|
||||
self.active.remove(symbol);
|
||||
if let Some(built)=result{
|
||||
self.order.push(symbol.to_owned());
|
||||
self.built.insert(symbol.to_owned(),built);
|
||||
Some(())
|
||||
}else{None}
|
||||
}
|
||||
fn plan(mut self,root:&str)->Option<Plan>{
|
||||
self.visit(root)?;
|
||||
if self.built.len()<2{return None}
|
||||
let nodes=self.order.iter().map(|id|self.built.get(id).cloned())
|
||||
.collect::<Option<Vec<_>>>()?;
|
||||
// Actually prove a caller that uses imported source definitions.
|
||||
if nodes.last()?.dep_symbols.is_empty(){return None}
|
||||
Some(Plan{root:root.into(),nodes})
|
||||
}
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct Plan{root:String,nodes:Vec<Built>}
|
||||
impl Plan{
|
||||
fn identities(&self)->BTreeSet<(String,String)>{
|
||||
self.nodes.iter().map(|n|(n.artifact.clone(),n.closure.clone()))
|
||||
.collect()
|
||||
}
|
||||
fn key(&self,version:&str)->String{
|
||||
sha(format!("{}|{:?}|{}",self.root,self.identities(),version).as_bytes())
|
||||
}
|
||||
}
|
||||
fn candidate(c:&Compilation,root:&str)->Option<Plan>{
|
||||
Builder::new(c).plan(root)
|
||||
}
|
||||
/// Retain the stable legacy certificate format for simple one-call
|
||||
/// forwarders. Use the unified engine for actual sequential, branched or
|
||||
/// transitive contracts, where the legacy shape cannot represent the proof.
|
||||
fn advanced(c:&Compilation,plan:&Plan)->bool{
|
||||
if plan.nodes.len()>2{return true}
|
||||
if c.semantics.bound_calls.iter()
|
||||
.filter(|call|call.caller.as_str()==plan.root).count()>1{return true}
|
||||
let Some(artifact)=unique_artifact(c,&plan.root) else{return false};
|
||||
let Some(function)=load_function(c,artifact) else{return false};
|
||||
function.body.iter().any(|stmt|matches!(stmt,Stmt::Branch{..}))
|
||||
}
|
||||
pub(super) fn covers(c:&Compilation,root:&SymbolId)->bool{
|
||||
candidate(c,root.as_str()).is_some_and(|plan|advanced(c,&plan))
|
||||
}
|
||||
pub(super) fn prove(c:&Compilation,out:&Path,lean:&Toolchain)->Result<Vec<Value>>{
|
||||
let roots=c.semantics.bound_calls.iter().map(|call|call.caller.as_str())
|
||||
.collect::<BTreeSet<_>>();
|
||||
let mut results=Vec::new();
|
||||
for root in roots{
|
||||
let Some(plan)=candidate(c,root)else{continue};
|
||||
if !advanced(c,&plan){continue}
|
||||
let key=plan.key(&lean.version);
|
||||
let dir=out.join("composed").join(format!("unified-{}",&key[7..23]));
|
||||
fs::create_dir_all(&dir)?;
|
||||
let checked=(||->Result<Vec<Value>>{
|
||||
let mut files=Vec::new();
|
||||
for node in &plan.nodes{
|
||||
let src=dir.join(format!("{}.lean",node.module));
|
||||
let obj=dir.join(format!("{}.olean",node.module));
|
||||
fs::write(&src,&node.lean)?;
|
||||
compile_import_module(lean,&src,&obj,&dir,Duration::from_secs(120))
|
||||
.with_context(||format!("module {}",node.module))?;
|
||||
files.push(json!({
|
||||
"symbol":node.symbol,"artifact":node.artifact,
|
||||
"module":node.module,"source_sha256":sha(node.lean.as_bytes()),
|
||||
"compiled_sha256":sha(&fs::read(obj)?),
|
||||
"dependencies":node.dep_symbols,"result_operator":node.result_operator,
|
||||
"source_file":node.file
|
||||
}));
|
||||
}
|
||||
Ok(files)
|
||||
})();
|
||||
match checked{
|
||||
Ok(files)=>{
|
||||
let certificate=json!({
|
||||
"schema_version":1,"kind":KIND,"scope":SCOPE,
|
||||
"status":"lean_kernel_proved_model",
|
||||
"evidence_grade":"model_proved",
|
||||
"full_marqdo_runtime_semantics_proved":false,
|
||||
"identity":plan.root,"toolchain":lean.version,
|
||||
"source_closures":plan.identities().iter().map(|(id,h)|
|
||||
json!({"id":id,"closure":h})).collect::<Vec<_>>(),
|
||||
"modules":files,
|
||||
"independent_replay":"topological module recompilation from current source"
|
||||
});
|
||||
let certificate_path=dir.join("composition-certificate.json");
|
||||
fs::write(&certificate_path,serde_json::to_vec_pretty(&certificate)?)?;
|
||||
results.push(json!({"identity":plan.root,
|
||||
"status":"lean_kernel_proved_model",
|
||||
"scope":SCOPE,"artifact":certificate_path,
|
||||
"evidence":super::evidence::model_proved()}));
|
||||
},
|
||||
Err(e)=>{
|
||||
let _=fs::remove_file(dir.join("composition-certificate.json"));
|
||||
results.push(json!({"identity":plan.root,"status":"lean_rejected",
|
||||
"scope":SCOPE,"error":format!("{e:#}"),
|
||||
"evidence":super::evidence::unknown("lean_rejected")}));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
pub(super) fn replay(c:&Compilation,certificate:&Path,lean:&Toolchain)->Result<Value>{
|
||||
let cert:Value=serde_json::from_slice(&fs::read(certificate)?)?;
|
||||
anyhow::ensure!(cert["schema_version"]==1&&cert["kind"]==KIND
|
||||
&&cert["scope"]==SCOPE&&cert["status"]=="lean_kernel_proved_model"
|
||||
&&cert["evidence_grade"]=="model_proved"
|
||||
&&cert["full_marqdo_runtime_semantics_proved"]==false,
|
||||
"proof.unified_invalid_certificate");
|
||||
anyhow::ensure!(cert["toolchain"]==lean.version,
|
||||
"proof.unified_stale_toolchain");
|
||||
let root=cert["identity"].as_str().context("proof.unified_missing_identity")?;
|
||||
let plan=candidate(c,root).context("proof.unified_stale_or_unsupported_source")?;
|
||||
let expected=plan.identities();
|
||||
let items=cert["source_closures"].as_array()
|
||||
.context("proof.unified_missing_source_closures")?;
|
||||
let actual=items.iter().map(|r|Ok((
|
||||
r["id"].as_str().context("proof.unified_invalid_id")?.to_string(),
|
||||
r["closure"].as_str().context("proof.unified_invalid_hash")?.to_string()
|
||||
))).collect::<Result<BTreeSet<_>>>()?;
|
||||
anyhow::ensure!(items.len()==expected.len()&&actual==expected,
|
||||
"proof.unified_stale_or_ambiguous_source_closure");
|
||||
let rows=cert["modules"].as_array().context("proof.unified_missing_modules")?;
|
||||
anyhow::ensure!(rows.len()==plan.nodes.len(),
|
||||
"proof.unified_module_count_changed");
|
||||
let dir=certificate.parent().context("proof.unified_missing_parent")?;
|
||||
for (node,row) in plan.nodes.iter().zip(rows){
|
||||
anyhow::ensure!(row["symbol"]==node.symbol&&row["artifact"]==node.artifact
|
||||
&&row["module"]==node.module
|
||||
&&row["dependencies"]==json!(node.dep_symbols)
|
||||
&&row["result_operator"]==node.result_operator
|
||||
&&row["source_file"]==node.file,
|
||||
"proof.unified_module_identity_changed");
|
||||
let src=dir.join(format!("{}.lean",node.module));
|
||||
let obj=dir.join(format!("{}.olean",node.module));
|
||||
anyhow::ensure!(fs::read_to_string(&src)?==node.lean
|
||||
&&row["source_sha256"]==sha(node.lean.as_bytes()),
|
||||
"proof.unified_generated_source_changed");
|
||||
compile_import_module(lean,&src,&obj,dir,Duration::from_secs(120))?;
|
||||
anyhow::ensure!(row["compiled_sha256"]==sha(&fs::read(&obj)?),
|
||||
"proof.unified_compiled_module_changed");
|
||||
}
|
||||
Ok(json!({"schema_version":1,"kind":"independent_composition_replay",
|
||||
"status":"lean_kernel_replayed","scope":SCOPE,"identity":root,
|
||||
"evidence":super::evidence::model_replayed(),
|
||||
"current_source_verified":true,
|
||||
"full_marqdo_runtime_semantics_proved":false}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test]
|
||||
fn simple_source_contracts_must_not_be_promoted_without_unique_claim(){
|
||||
let c=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(
|
||||
Path::new("doc/verification/skill-proof")).unwrap());
|
||||
if let Ok(project)=c{
|
||||
for artifact in project.semantics.artifacts.iter()
|
||||
.filter(|a|a.kind=="function"){
|
||||
assert!(!project.semantics.claims.iter()
|
||||
.any(|r|r.owner.as_str()=="__invented_symbol__"));
|
||||
let _=artifact;
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn claim_language_refuses_nonlinear_and_unknown_values(){
|
||||
let bind=BTreeMap::from([("n".into(),"v0".into()),
|
||||
("m".into(),"v1".into())]);
|
||||
let parse=|s:&str|{
|
||||
let toks=proof_check::tokenize_claim(s).unwrap();
|
||||
proof_check::parse_claim_expr(&toks).unwrap().1
|
||||
};
|
||||
assert_eq!(claim_term(&parse("n + 2"),&bind,0),
|
||||
Some("(v0 + (2 : Int))".into()));
|
||||
assert!(claim_term(&parse("n * m"),&bind,0).is_none());
|
||||
assert!(claim_term(&parse("n / 2"),&bind,0).is_none());
|
||||
assert!(claim_term(&parse("secret"),&bind,0).is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
//! Closed, overflow-safe callsite verification conditions. A generated
|
||||
//! formula is a Lean *goal*, not evidence. Only a subsequent kernel invocation
|
||||
//! can discharge it. Unknown/symbolic arguments always remain open.
|
||||
use std::collections::BTreeMap;
|
||||
use crate::prove::proof_check::{self,ClaimAst as A,CTok as T};
|
||||
use crate::sema::ir::{BoundCall, SemanticProject};
|
||||
|
||||
#[derive(Debug,Clone,PartialEq,Eq)]
|
||||
pub struct Goal {
|
||||
/// Exact statement of the instantiated proposition.
|
||||
pub proposition: String,
|
||||
/// Conservative host-side check for early rejection only; not a proof.
|
||||
pub holds: bool,
|
||||
}
|
||||
enum Term {
|
||||
Int(i64,String),
|
||||
Bool(bool,String),
|
||||
}
|
||||
fn calc(ast:&A, actuals:&BTreeMap<String,i64>)->Option<Term>{
|
||||
match ast {
|
||||
A::Lit(T::Int(n))=>Some(Term::Int(*n,format!("({n} : Int)"))),
|
||||
A::Lit(T::Bool(b))=>Some(Term::Bool(*b,
|
||||
if *b{"True"}else{"False"}.into())),
|
||||
A::Var(v)=>actuals.get(v).map(|n|Term::Int(*n,format!("({n} : Int)"))),
|
||||
A::Un{op,expr}=>match (*op,calc(expr,actuals)?) {
|
||||
("-",Term::Int(n,code))=>Some(Term::Int(n.checked_neg()?,format!("(-{code})"))),
|
||||
("非",Term::Bool(b,code))=>Some(Term::Bool(!b,format!("(¬ {code})"))),
|
||||
_=>None
|
||||
},
|
||||
A::Bin{op,left,right}=>{
|
||||
let l=calc(left,actuals)?;
|
||||
let r=calc(right,actuals)?;
|
||||
match (l,r) {
|
||||
(Term::Int(x,a),Term::Int(y,b))=>{
|
||||
let pair=match *op {
|
||||
"+"=>Some((x.checked_add(y)?,format!("({a} + {b})"))),
|
||||
"-"=>Some((x.checked_sub(y)?,format!("({a} - {b})"))),
|
||||
"*"=>Some((x.checked_mul(y)?,format!("({a} * {b})"))),
|
||||
_=>None
|
||||
};
|
||||
if let Some((n,code))=pair {return Some(Term::Int(n,code))}
|
||||
let (truth,rel)=match *op {
|
||||
"="=>(x==y,"="),"≠"=>(x!=y,"≠"),
|
||||
"<"=>(x<y,"<"),"≤"=>(x<=y,"≤"),
|
||||
">"=>(x>y,">"),"≥"=>(x>=y,"≥"),_=>return None
|
||||
};
|
||||
Some(Term::Bool(truth,format!("({a} {rel} {b})")))
|
||||
},
|
||||
(Term::Bool(x,a),Term::Bool(y,b))=>{
|
||||
let (truth,code)=match *op {
|
||||
"且"=>(x&&y,format!("({a} ∧ {b})")),
|
||||
"或"=>(x||y,format!("({a} ∨ {b})")),
|
||||
"="=>(x==y,format!("({a} ↔ {b})")),
|
||||
"≠"=>(x!=y,format!("(¬ ({a} ↔ {b}))")),
|
||||
_=>return None
|
||||
};
|
||||
Some(Term::Bool(truth,code))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
pub fn instantiate(semantic:&SemanticProject,call:&BoundCall,premise:&str)->Option<Goal>{
|
||||
let owner=semantic.artifacts.iter().find(|a|
|
||||
a.symbol_id.as_ref()==Some(&call.target))?;
|
||||
let signature=owner.signature.as_ref()?;
|
||||
if signature.params.len()!=call.args.len(){return None}
|
||||
// No implicit defaults, no mixed positional/named ambiguity. Explicitly
|
||||
// require that the exact ordered actuals match the callee signature.
|
||||
let mut bindings=BTreeMap::new();
|
||||
for (formal,actual) in signature.params.iter().zip(call.args.iter()){
|
||||
if actual.name.as_ref().is_some_and(|name|name!=&formal.name){
|
||||
return None
|
||||
}
|
||||
bindings.insert(formal.name.clone(),actual.integer?);
|
||||
}
|
||||
let tokens=proof_check::tokenize_claim(premise).ok()?;
|
||||
let (_,expr)=proof_check::parse_claim_expr(&tokens).ok()?;
|
||||
match calc(&expr,&bindings)? {
|
||||
Term::Bool(holds,proposition)=>Some(Goal{holds,proposition}),
|
||||
Term::Int(..)=>None
|
||||
}
|
||||
}
|
||||
pub fn emit_lean(goals:&[(String,Goal)])->String{
|
||||
let mut out=String::from(
|
||||
"-- Generated closed obligations. These are not accepted until Lean checks them.\n");
|
||||
out.push_str("namespace MarqdoClosedCallsite\n");
|
||||
for (i,(_,goal)) in goals.iter().enumerate(){
|
||||
out.push_str(&format!(
|
||||
"theorem vc_{i} : {} := by decide\n",goal.proposition));
|
||||
}
|
||||
out.push_str("end MarqdoClosedCallsite\n");
|
||||
out
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn bool_and_arithmetic_propositions_are_kernel_goals_not_certs(){
|
||||
let ast=proof_check::parse_claim_expr(
|
||||
&proof_check::tokenize_claim("金额 > 0 且 金额 < 10").unwrap()).unwrap().1;
|
||||
let args=BTreeMap::from([("金额".into(),3)]);
|
||||
let Term::Bool(holds,prop)=calc(&ast,&args).unwrap() else {panic!("not boolean")};
|
||||
assert!(holds);
|
||||
assert!(prop.contains("∧")&&prop.contains("(3 : Int)"));
|
||||
let lean=emit_lean(&[("test".into(),Goal{proposition:prop,holds})]);
|
||||
assert!(lean.contains("theorem vc_0"));
|
||||
assert!(!lean.contains("sorry"));
|
||||
}
|
||||
#[test]
|
||||
fn real_project_call_actuals_generate_closed_goal_without_claiming_proof(){
|
||||
let root=std::env::temp_dir().join(
|
||||
format!("marqdo-closed-vc-{}",std::process::id()));
|
||||
let _=std::fs::remove_dir_all(&root);
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
std::fs::write(root.join("math.mq.md"),
|
||||
"# math\n\n## exact\n+ `n`\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| c | 结果 = 2 | n > 0 | auto |\n\n*2*\n").unwrap();
|
||||
std::fs::write(root.join("main.mq.md"),
|
||||
"---\nimport:\n math: math.mq.md\n---\n# main\n\n## f\n\n**v = [调用](math.math.exact(3))**\n*v*\n").unwrap();
|
||||
let compiled=crate::sema::ir::compile_project(
|
||||
&crate::sema::ir::CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let call=compiled.semantics.bound_calls.iter().find(
|
||||
|c|c.call_site=="math.math.exact").expect("real imported bound call");
|
||||
assert_eq!(call.args.len(),1);
|
||||
assert_eq!(call.args[0].integer,Some(3));
|
||||
let goal=instantiate(&compiled.semantics,call,"n > 0").unwrap();
|
||||
assert!(goal.holds);
|
||||
assert!(goal.proposition.contains("(3 : Int)"));
|
||||
assert!(instantiate(&compiled.semantics,call,"n > 10")
|
||||
.is_some_and(|goal|!goal.holds));
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overflowing_i64_expression_is_not_silently_lean_unbounded(){
|
||||
let ast=proof_check::parse_claim_expr(
|
||||
&proof_check::tokenize_claim("x + 1 > 0").unwrap()).unwrap().1;
|
||||
assert!(calc(&ast,&BTreeMap::from([("x".into(),i64::MAX)])).is_none());
|
||||
}
|
||||
}
|
||||
+170
@@ -609,6 +609,29 @@ enum ProveAction {
|
||||
enum KnowledgeAction {
|
||||
/// Compile L0–L4 projections (default)
|
||||
Compile,
|
||||
/// Inspect verified theorem receipts and inter-module proof obligations.
|
||||
ProofDeps {
|
||||
/// Fail if the receipt/contract graph contains unresolved obligations.
|
||||
#[arg(long)]
|
||||
strict: bool,
|
||||
/// Actually discharge closed callsite preconditions in Lean; without
|
||||
/// this switch the command only emits pending proof obligations.
|
||||
#[arg(long)]
|
||||
verify: bool,
|
||||
},
|
||||
/// Emit independent Lean callee+caller proofs for restricted pure forwarders.
|
||||
/// Unsupported constructs are rejected and never receive certificates.
|
||||
Compose {
|
||||
/// Exit nonzero if any call is unsupported or Lean rejects it.
|
||||
#[arg(long)]
|
||||
strict: bool,
|
||||
},
|
||||
/// Independently replay a previously issued composition certificate
|
||||
/// against current source, Lean modules and toolchain.
|
||||
Replay {
|
||||
#[arg(value_name = "CERTIFICATE")]
|
||||
certificate: PathBuf,
|
||||
},
|
||||
/// Inspect stable project symbols by exact URI or display name
|
||||
Inspect {
|
||||
/// Symbol URI (`mq://…`) or declaration name
|
||||
@@ -1769,6 +1792,153 @@ fn try_main(cli: Cli) -> Result<i32> {
|
||||
write_knowledge(KnowledgeOptions { path, out_dir: out })?;
|
||||
Ok(0)
|
||||
}
|
||||
KnowledgeAction::Replay { certificate } => {
|
||||
let root=if path.is_file(){
|
||||
path.parent().filter(|p|!p.as_os_str().is_empty())
|
||||
.unwrap_or_else(||std::path::Path::new(".")).to_path_buf()
|
||||
}else{path.clone()};
|
||||
let compiled=marqdo::sema::ir::compile_project(
|
||||
&marqdo::sema::ir::CompileOptions{
|
||||
project_root:root,
|
||||
entry:path.is_file().then_some(path),
|
||||
lock_mode:marqdo::sema::ir::LockMode::Off
|
||||
})?;
|
||||
let lean=marqdo::prove::driver::Toolchain::discover(None)?
|
||||
.ok_or_else(||anyhow::anyhow!("proof.compose_lean_missing"))?;
|
||||
let proof=marqdo::knowledge::composition::replay(
|
||||
&compiled,&certificate,&lean)?;
|
||||
if json{println!("{proof}");}else{
|
||||
println!("{}",serde_json::to_string_pretty(&proof)?);
|
||||
}
|
||||
Ok(0)
|
||||
}
|
||||
KnowledgeAction::Compose { strict } => {
|
||||
let root=if path.is_file(){
|
||||
path.parent().filter(|p|!p.as_os_str().is_empty())
|
||||
.unwrap_or_else(||std::path::Path::new(".")).to_path_buf()
|
||||
}else{path.clone()};
|
||||
let compiled=marqdo::sema::ir::compile_project(
|
||||
&marqdo::sema::ir::CompileOptions{
|
||||
project_root:root,
|
||||
entry:path.is_file().then_some(path),
|
||||
lock_mode:marqdo::sema::ir::LockMode::Off
|
||||
})?;
|
||||
let lean=marqdo::prove::driver::Toolchain::discover(None)?
|
||||
.ok_or_else(||anyhow::anyhow!(
|
||||
"proof.compose_lean_missing: Lean required"))?;
|
||||
let result=marqdo::knowledge::composition::prove(
|
||||
&compiled,&out.join("modular"),&lean)?;
|
||||
let failures=result["results"].as_array().map_or(true,|entries|
|
||||
entries.is_empty()||entries.iter().any(|e|
|
||||
e["status"]!="lean_kernel_proved_model"));
|
||||
if json {println!("{result}");} else {
|
||||
println!("{}",serde_json::to_string_pretty(&result)?);
|
||||
}
|
||||
Ok(if strict && failures {2} else {0})
|
||||
}
|
||||
KnowledgeAction::ProofDeps { strict,verify } => {
|
||||
let semantic_root=if path.is_file() {
|
||||
path.parent().filter(|p|!p.as_os_str().is_empty())
|
||||
.unwrap_or_else(||std::path::Path::new(".")).to_path_buf()
|
||||
} else {path.clone()};
|
||||
let compiled=marqdo::sema::ir::compile_project(
|
||||
&marqdo::sema::ir::CompileOptions {
|
||||
project_root:semantic_root,
|
||||
entry:path.is_file().then_some(path),
|
||||
lock_mode:marqdo::sema::ir::LockMode::Off,
|
||||
})?;
|
||||
let mut receipts=marqdo::knowledge::proof::index_links(
|
||||
&out.join("prove"),&compiled.semantics);
|
||||
let toolchain=if verify {
|
||||
Some(marqdo::prove::driver::Toolchain::discover(None)?
|
||||
.ok_or_else(||anyhow::anyhow!(
|
||||
"proof.modular_lean_missing: Lean is required for --verify"))?)
|
||||
} else {None};
|
||||
if let Some(lean)=toolchain.as_ref(){
|
||||
marqdo::knowledge::proof::replay_index(
|
||||
&out.join("prove"),&mut receipts,lean,
|
||||
std::time::Duration::from_secs(120))?;
|
||||
}
|
||||
let replayed=receipts["claims"].as_array().map_or(0,|records|
|
||||
records.iter().filter(|c|c["kernel_replayed"]==true).count());
|
||||
let draft=marqdo::knowledge::modular::analyze(
|
||||
&compiled.semantics,&receipts);
|
||||
let mut accepted=std::collections::BTreeSet::new();
|
||||
let verified_toolchain=toolchain.as_ref().map(|t|t.version.clone());
|
||||
if verify {
|
||||
let goals:Vec<(String,marqdo::knowledge::vc::Goal)>=draft["obligations"]
|
||||
.as_array().into_iter().flat_map(|rows|rows.iter())
|
||||
.flat_map(|row|row["contracts"].as_array().into_iter()
|
||||
.flat_map(|contracts|contracts.iter()))
|
||||
.filter_map(|c|{
|
||||
if c["callee_certificate_valid"]!=true
|
||||
|| c["closed_host_check"]!=true {return None}
|
||||
Some((
|
||||
c["precondition_goal_key"].as_str()?.to_string(),
|
||||
marqdo::knowledge::vc::Goal{
|
||||
holds:true,
|
||||
proposition:c["lean_proposition"].as_str()?.to_string()
|
||||
}
|
||||
))
|
||||
}).collect();
|
||||
if !goals.is_empty(){
|
||||
let toolchain=toolchain.as_ref().expect("verify implies Lean");
|
||||
let target=out.join("modular");
|
||||
std::fs::create_dir_all(&target)?;
|
||||
let lean_file=target.join("closed-goals.lean");
|
||||
let content=marqdo::knowledge::vc::emit_lean(&goals);
|
||||
std::fs::write(&lean_file,content)?;
|
||||
marqdo::prove::driver::check_closed_goals(
|
||||
&toolchain,&lean_file,std::time::Duration::from_secs(120))?;
|
||||
accepted.extend(goals.into_iter().map(|(id,_)|id));
|
||||
}
|
||||
}
|
||||
let mut symbolic_checked=0usize;
|
||||
if let Some(lean)=toolchain.as_ref(){
|
||||
let symbolic:Vec<(String,marqdo::knowledge::symbolic::SymbolicGoal)>=
|
||||
compiled.semantics.bound_calls.iter().flat_map(|call|{
|
||||
compiled.semantics.claims.iter()
|
||||
.filter(|c|c.owner==call.target)
|
||||
.filter(|c|receipts["claims"].as_array().is_some_and(|rows|
|
||||
rows.iter().any(|r|
|
||||
r["claim_anchor_id"]==c.anchor_id
|
||||
&& r["status"]=="proved"
|
||||
&& r["usable"]==true)))
|
||||
.filter_map(|c|Some((
|
||||
c.anchor_id.clone(),
|
||||
marqdo::knowledge::symbolic::plan(
|
||||
&compiled.semantics,call,c.premise.as_deref()?)?
|
||||
)))
|
||||
.filter(|(_,g)|g.abstract_integer_model_supported)
|
||||
.collect::<Vec<_>>()
|
||||
}).collect();
|
||||
if !symbolic.is_empty(){
|
||||
let target=out.join("modular");
|
||||
std::fs::create_dir_all(&target)?;
|
||||
let path=target.join("symbolic-path-goals.lean");
|
||||
std::fs::write(&path,
|
||||
marqdo::knowledge::symbolic::emit_lean(&symbolic))?;
|
||||
marqdo::prove::driver::check_closed_goals(lean,&path,
|
||||
std::time::Duration::from_secs(120))?;
|
||||
symbolic_checked=symbolic.len();
|
||||
}
|
||||
}
|
||||
let mut report=marqdo::knowledge::modular::analyze_with_verified(
|
||||
&compiled.semantics,&receipts,&accepted);
|
||||
report["symbolic_path_lean_model_proved"]=
|
||||
serde_json::json!(symbolic_checked);
|
||||
report["symbolic_proof_scope"]=
|
||||
serde_json::json!("integer_path_model_not_runtime_equivalence");
|
||||
report["lean_preconditions_verified"]=serde_json::json!(accepted.len());
|
||||
report["lean_toolchain"]=serde_json::json!(verified_toolchain);
|
||||
report["lean_receipts_replayed"]=serde_json::json!(replayed);
|
||||
if json {
|
||||
println!("{report}");
|
||||
} else {
|
||||
println!("{}",serde_json::to_string_pretty(&report)?);
|
||||
}
|
||||
Ok(if strict && report["audit_passes"]!=true {2} else {0})
|
||||
}
|
||||
KnowledgeAction::Inspect { symbol } => {
|
||||
// A supplied directory is an explicit compilation scope;
|
||||
// a supplied file inherits the nearest project boundary.
|
||||
|
||||
@@ -320,6 +320,7 @@ impl<'a> Cursor<'a> {
|
||||
contract: None,
|
||||
var_contracts: std::collections::HashMap::new(),
|
||||
claims: Vec::new(),
|
||||
assumptions: Vec::new(),
|
||||
};
|
||||
// Prose decls pending promotion (name → optional default text).
|
||||
let mut prose_decls: Vec<(String, Option<String>, u32)> = Vec::new();
|
||||
@@ -2080,6 +2081,14 @@ fn extract_function_contract(fun: &mut Function, lines: &[ClassifiedLine]) -> Re
|
||||
let Some(parsed) = crate::contract::parse_contract_table(pairs, span.line, end_line, quote)
|
||||
else {
|
||||
// 非契约形状:先试定理表(ADR 0010),再按普通表保留。
|
||||
if let Some(parsed) = crate::contract::parse_assumption_table(pairs, span.line) {
|
||||
if prefix_zone {
|
||||
fun.assumptions.extend(parsed.map_err(|msg|
|
||||
bail_at(None, span, format!("proof.assumption_malformed: {msg}")))?);
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
match crate::contract::parse_claim_table(pairs, span.line) {
|
||||
// 合法定理表:只在「首个可执行行之前」生效;提取后从 body 移除。
|
||||
// 其余位置仍是普通表,由 `check --proof` 报 proof.claim_misplaced。
|
||||
@@ -2550,6 +2559,31 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::ast::Stmt;
|
||||
|
||||
#[test]
|
||||
fn assumption_tables_are_metadata_and_never_runtime_steps() {
|
||||
let src=r#"# main
|
||||
|
||||
## guarded
|
||||
|
||||
| 假设 | 前置 | 后置 |
|
||||
|---|---|---|
|
||||
| backend.fetch | 金额 > 0 | 返回.ok = True |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 安全 | 长度(轨迹) = 0 | | auto |
|
||||
|
||||
*1*
|
||||
"#;
|
||||
let m=parse_source(src).unwrap();
|
||||
let f=&m.functions[0].children[0];
|
||||
assert_eq!(f.assumptions.len(),1);
|
||||
assert_eq!(f.assumptions[0].op,"backend.fetch");
|
||||
assert_eq!(f.assumptions[0].premise.as_deref(),Some("金额 > 0"));
|
||||
assert_eq!(f.claims.len(),1);
|
||||
assert_eq!(f.body.len(),1,"assumption and theorem tables must not execute");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_formula_meta_var_standalone() {
|
||||
let src = "# main\n\n$$\n% marqdo: var=f\nx^2 - 2\n$$\n";
|
||||
|
||||
@@ -57,6 +57,11 @@ pub struct NarrativeLink {
|
||||
/// Classify a link target without parsing it as an expression.
|
||||
pub fn classify_narrative_target(target: &str) -> NarrativeLinkKind {
|
||||
let t = target.trim();
|
||||
// Compiler-owned mq:// anchor addresses are inert knowledge references,
|
||||
// never external URLs or auto-executable code.
|
||||
if t.starts_with("mq://") && (t.contains("#anchor-") || t.contains("#claim-")) {
|
||||
return NarrativeLinkKind::Narrate;
|
||||
}
|
||||
if t.starts_with("http://")
|
||||
|| t.starts_with("https://")
|
||||
|| t.starts_with("mailto:")
|
||||
|
||||
@@ -121,6 +121,41 @@ pub fn ensure_library(cache_root: &Path, lean: &Toolchain) -> Result<(PathBuf, S
|
||||
}
|
||||
|
||||
/// 判定一个生成的 Lean 模块。
|
||||
/// Compile a self-contained Lean module for a reusable, independent caller
|
||||
/// proof. Source and output must both be inside the immutable build directory.
|
||||
pub fn compile_import_module(lean:&Toolchain,src:&Path,olean:&Path,
|
||||
import_root:&Path,timeout:Duration)->Result<()> {
|
||||
let original=std::fs::read(src)?;
|
||||
let mut command=Command::new(&lean.lean);
|
||||
command.env("LEAN_PATH",import_root)
|
||||
.arg("-o").arg(olean).arg(src);
|
||||
let (log,status,timed_out)=run_with_timeout(&mut command,timeout)?;
|
||||
anyhow::ensure!(!timed_out,"proof.compose_timeout: {}",src.display());
|
||||
anyhow::ensure!(status==Some(0)&&olean.is_file(),
|
||||
"proof.compose_lean_failed: {log}");
|
||||
anyhow::ensure!(std::fs::read(src)?==original,
|
||||
"proof.compose_source_race: generated Lean changed during verification");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Re-check a generated, closed proof-obligation module with the Lean kernel.
|
||||
/// No local JSON certificate or Rust-side decision may replace this check.
|
||||
pub fn check_closed_goals(
|
||||
toolchain:&Toolchain, source:&Path, timeout:Duration
|
||||
)->Result<()>{
|
||||
let source_before=std::fs::read(source)?;
|
||||
let mut command=Command::new(&toolchain.lean);
|
||||
command.arg(source);
|
||||
let (log,code,timed_out)=run_with_timeout(&mut command,timeout)?;
|
||||
anyhow::ensure!(std::fs::read(source)?==source_before,
|
||||
"proof.modular_source_race: Lean goal module changed during verification");
|
||||
anyhow::ensure!(!timed_out,
|
||||
"proof.modular_timeout: Lean did not finish within {}s",timeout.as_secs());
|
||||
anyhow::ensure!(code==Some(0),
|
||||
"proof.modular_unproved: Lean rejected callsite goals: {log}");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn check_module(
|
||||
lean: &Toolchain,
|
||||
lib_dir: &Path,
|
||||
|
||||
@@ -139,6 +139,7 @@ fn emit_theorems(out: &mut String, fun: &FnPlan) {
|
||||
out,
|
||||
" all_goals
|
||||
simp_all [mqTruth, Op.name, mqAccess, mqResultOk, mqResultError, mqValueOr, mqAnd, mqOr, mqNot, mqEq]
|
||||
try simp_all [mqAdd, mqSub, mqMul, mqNeg]
|
||||
try
|
||||
first
|
||||
| exact (mqGt_mqLe_false ‹mqGt _ (Val.int _) = true› ‹mqLe _ (Val.int _) = true›).elim
|
||||
|
||||
+108
-2
@@ -13,7 +13,7 @@ use anyhow::Result;
|
||||
use crate::ast::{self, Arg, BinaryOp, CallExpr, Expr, Function, Module, Stmt};
|
||||
use crate::diagnostics::{Diagnostic, Severity, Span};
|
||||
use crate::prove::ir::{
|
||||
BinOp, ClaimPlan, Expr as IrExpr, FnPlan, InterpPart, OpDecl, ParamPlan, Plan, PlanTy,
|
||||
AssumptionPlan, BinOp, ClaimPlan, Expr as IrExpr, FnPlan, InterpPart, OpDecl, ParamPlan, Plan, PlanTy,
|
||||
PureExpr, Step, UnOp, SCHEMA,
|
||||
};
|
||||
use crate::sema::bind::{call_display, resolve_for_exec};
|
||||
@@ -148,7 +148,10 @@ impl<'m> Lowerer<'m> {
|
||||
line: c.line,
|
||||
})
|
||||
.collect(),
|
||||
assumptions: Vec::new(),
|
||||
assumptions: fun.assumptions.iter().map(|a|AssumptionPlan{
|
||||
op:a.op.clone(), premise:a.premise.clone(),
|
||||
postcondition:a.postcondition.clone()
|
||||
}).collect(),
|
||||
};
|
||||
Lowered {
|
||||
display: display.to_string(),
|
||||
@@ -599,6 +602,21 @@ impl<'m> Lowerer<'m> {
|
||||
}
|
||||
}
|
||||
Target::Import { bind, lib, fun: target, .. } => {
|
||||
// Source-level verification of a tightly restricted imported
|
||||
// pure leaf: one return expression, only literal/parameter
|
||||
// arithmetic, exact positional args. This is NOT abstract
|
||||
// contract reuse; Lean verifies the actual substituted body.
|
||||
if body.inline_depth < 4
|
||||
&& imported_pure_leaf(target)
|
||||
&& imported_leaf_arithmetic_safe(target,call)
|
||||
&& call.args.len()==target.params.len()
|
||||
&& call.args.iter().all(|a|matches!(a,Arg::Positional(_)))
|
||||
{
|
||||
body.inline_depth+=1;
|
||||
let lowered=self.inline_body(target,&args,body);
|
||||
body.inline_depth-=1;
|
||||
return lowered;
|
||||
}
|
||||
// lib/result 的构造器内联为结构(§4.5;真实库名是 ok/error/value_or)。
|
||||
if bind == "result" && matches!(target.name.as_str(), "ok" | "error" | "value_or") {
|
||||
return IrExpr::Pure(PureExpr::Ctor {
|
||||
@@ -906,6 +924,94 @@ fn effect_label_of_host(host: HostFn) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Imported source transparency is enabled only for a pure expression
|
||||
/// fragment that cannot inspect module globals or call external operations.
|
||||
fn imported_pure_leaf(fun:&Function)->bool {
|
||||
fn closed(expr:&Expr,params:&std::collections::BTreeSet<&str>)->bool {
|
||||
match expr {
|
||||
Expr::Literal(_)=>true,
|
||||
Expr::Var(v)=>params.contains(v.as_str()),
|
||||
Expr::Occluded {payload:Some(inner),..}=>closed(inner,params),
|
||||
Expr::Unary {expr,..}=>closed(expr,params),
|
||||
Expr::Binary {left,right,..}=>closed(left,params)&&closed(right,params),
|
||||
_=>false,
|
||||
}
|
||||
}
|
||||
if fun.is_object() || fun.body.len()!=1{return false}
|
||||
let params:std::collections::BTreeSet<&str>=fun.params.iter()
|
||||
.map(|p|p.name.as_str()).collect();
|
||||
match &fun.body[0]{
|
||||
Stmt::Return {value,..}=>closed(value,¶ms),
|
||||
_=>false,
|
||||
}
|
||||
}
|
||||
|
||||
/// The interpreter uses bounded i64 while Lean's arithmetic is unbounded.
|
||||
/// Therefore imported source expansion of arithmetic is allowed only if all
|
||||
/// arithmetic subexpressions close to checked i64 constants after applying
|
||||
/// the *actual* call arguments. Unknown/overflow/div-zero stays opaque.
|
||||
fn imported_leaf_arithmetic_safe(target:&Function, call:&CallExpr)->bool {
|
||||
let Some(Stmt::Return {value,..})=target.body.first() else {return false};
|
||||
if target.params.len()!=call.args.len(){return false}
|
||||
let bindings:Vec<(&str,&Expr)>=target.params.iter().zip(call.args.iter())
|
||||
.filter_map(|(p,a)|match a {
|
||||
Arg::Positional(expr)=>Some((p.name.as_str(),expr)),
|
||||
_=>None
|
||||
}).collect();
|
||||
if bindings.len()!=call.args.len(){return false}
|
||||
fn int_value(expr:&Expr,bindings:&[(&str,&Expr)],depth:usize)->Option<i64>{
|
||||
if depth>24 {return None}
|
||||
match expr{
|
||||
Expr::Literal(ast::Literal::Int(n))=>Some(*n),
|
||||
Expr::Var(v)=> {
|
||||
let bound=bindings.iter().find(|(key,_)|*key==v.as_str())?.1;
|
||||
// A bound argument must be self-contained to avoid recursion
|
||||
int_value(bound,&[],depth+1)
|
||||
}
|
||||
Expr::Occluded {payload:Some(inner),..}=>
|
||||
int_value(inner,bindings,depth+1),
|
||||
Expr::Unary {op:ast::UnaryOp::Neg,expr}=>
|
||||
int_value(expr,bindings,depth+1)?.checked_neg(),
|
||||
Expr::Binary {op,left,right}=>{
|
||||
let x=int_value(left,bindings,depth+1)?;
|
||||
let y=int_value(right,bindings,depth+1)?;
|
||||
match op{
|
||||
BinaryOp::Add=>x.checked_add(y),
|
||||
BinaryOp::Sub=>x.checked_sub(y),
|
||||
BinaryOp::Mul=>x.checked_mul(y),
|
||||
// Division semantics (integer rounding/Num coercion)
|
||||
// require a differential proof before source transparency.
|
||||
BinaryOp::Div=>None,
|
||||
_=>None,
|
||||
}
|
||||
}
|
||||
_=>None,
|
||||
}
|
||||
}
|
||||
fn safe(expr:&Expr,bindings:&[(&str,&Expr)])->bool{
|
||||
match expr{
|
||||
Expr::Literal(_)=>true,
|
||||
Expr::Var(v)=>bindings.iter().any(|(key,_)|*key==v.as_str()),
|
||||
Expr::Occluded{payload:Some(inner),..}=>safe(inner,bindings),
|
||||
Expr::Unary {op,expr}=>match op {
|
||||
ast::UnaryOp::Neg=>int_value(
|
||||
&Expr::Unary{op:*op,expr:expr.clone()},bindings,0).is_some(),
|
||||
ast::UnaryOp::Not=>safe(expr,bindings),
|
||||
},
|
||||
Expr::Binary {op,left,right}=>{
|
||||
match op {
|
||||
BinaryOp::Add|BinaryOp::Sub|BinaryOp::Mul|BinaryOp::Div=>
|
||||
int_value(expr,bindings,0).is_some(),
|
||||
_=>safe(left,bindings)&&safe(right,bindings),
|
||||
}
|
||||
}
|
||||
_=>false,
|
||||
}
|
||||
}
|
||||
safe(value,&bindings)
|
||||
&& bindings.iter().all(|(_,argument)|safe(argument,&[]))
|
||||
}
|
||||
|
||||
/// 无 sema 效应表时的库函数效应回退(与 sema 的 imported_effects 同思路的保守版)。
|
||||
fn imported_effect_label(lib: &Module, fun: &Function) -> String {
|
||||
let mut visiting = std::collections::HashSet::new();
|
||||
|
||||
+11
-2
@@ -434,7 +434,7 @@ pub fn prove_path(path: &Path, opts: &ProveOptions) -> Result<Report> {
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Report {
|
||||
let report = Report {
|
||||
file: file_display,
|
||||
source_sha256,
|
||||
artifact_id: artifact_dir
|
||||
@@ -447,7 +447,16 @@ pub fn prove_path(path: &Path, opts: &ProveOptions) -> Result<Report> {
|
||||
emitted,
|
||||
lean: lean_info,
|
||||
duration_ms: started.elapsed().as_millis(),
|
||||
})
|
||||
};
|
||||
// Knowledge linkage is advisory. Failing to bind must not invent a proof
|
||||
// or change the judgment of the underlying v2.8.0 prover.
|
||||
#[cfg(feature = "cli")]
|
||||
if let Some(dir) = artifact_dir.as_deref() {
|
||||
if let Err(err) = crate::knowledge::proof::emit_links(path, &report, dir) {
|
||||
eprintln!("warning[knowledge.proof_linkage]: {err:#}");
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
/// 离线判定(§5):checked/反例贴回定理,绝不冒充 proved。
|
||||
|
||||
@@ -170,6 +170,16 @@ fn check_misplaced_and_malformed(
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if let Some(assumption)=contract::parse_assumption_table(pairs,span.line){
|
||||
let (code,msg)=match assumption {
|
||||
Ok(_)=>("proof.assumption_misplaced",
|
||||
"假设表必须在第一条可执行语句之前;此处不会自动生效".to_string()),
|
||||
Err(err)=>("proof.assumption_malformed",err)
|
||||
};
|
||||
out.push(proof_diag(module,path,span,code,msg,
|
||||
"移动并修正 | 假设 | 前置 | 后置 | 表到函数开头".into()));
|
||||
continue;
|
||||
}
|
||||
match contract::parse_claim_table(pairs, span.line) {
|
||||
Some(Ok(_rows)) => {
|
||||
// 合法定理形却还在 body:一定是位置不对(prefix zone 内会被提取)。
|
||||
|
||||
+550
-7
@@ -183,6 +183,14 @@ pub struct SemanticArtifact {
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KnowledgeRef {
|
||||
pub id: String,
|
||||
/// Stable public address of the marked step, absent for ambiguous labels.
|
||||
pub anchor_id: Option<String>,
|
||||
/// Original Markdown target when this reference occurs in prose.
|
||||
pub link_target: Option<String>,
|
||||
/// Resolved stable anchor target; never an executable call.
|
||||
pub target_anchor: Option<String>,
|
||||
/// Reference to a theorem declaration, not a proof certificate.
|
||||
pub target_claim: Option<String>,
|
||||
pub label: String,
|
||||
pub context: String,
|
||||
pub source: SourceLocation,
|
||||
@@ -190,9 +198,36 @@ pub struct KnowledgeRef {
|
||||
pub target: Option<SymbolId>,
|
||||
}
|
||||
|
||||
/// Stable identity and unproved declaration of a v2.8.0 function theorem.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KnowledgeClaim {
|
||||
pub anchor_id: String,
|
||||
pub owner: SymbolId,
|
||||
pub label: String,
|
||||
pub conclusion: String,
|
||||
pub premise: Option<String>,
|
||||
pub line: u32,
|
||||
pub source: SourceLocation,
|
||||
}
|
||||
|
||||
/// Declared operation assumption, not an accepted proof or runtime binding.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KnowledgeAssumption {
|
||||
pub id: String,
|
||||
pub owner: SymbolId,
|
||||
pub operation: String,
|
||||
pub premise: Option<String>,
|
||||
pub postcondition: String,
|
||||
pub source: SourceLocation,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KnowledgeStep {
|
||||
pub id: ArtifactId,
|
||||
/// Stable public anchor; legacy #step-N is kept as an internal step identity.
|
||||
pub anchor_id: Option<String>,
|
||||
/// Hash of the authored source line (or fallback label when line unavailable).
|
||||
pub definition_digest: Digest,
|
||||
pub reference: String,
|
||||
pub kind: String,
|
||||
pub calls: Vec<SymbolId>,
|
||||
@@ -200,12 +235,73 @@ pub struct KnowledgeStep {
|
||||
pub source: SourceLocation,
|
||||
}
|
||||
|
||||
/// Fully static i64 call-site argument. Non-constant expressions are kept
|
||||
/// as unresolved proof obligations rather than guessed values.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct StaticCallArg {
|
||||
pub name: Option<String>,
|
||||
pub integer: Option<i64>,
|
||||
pub expression_digest: Digest,
|
||||
/// Only a direct identifier; arbitrary expressions do not become symbolic identities.
|
||||
pub symbol: Option<String>,
|
||||
}
|
||||
|
||||
fn checked_constant_int(expr: &Expr, depth: usize) -> Option<i64> {
|
||||
if depth > 32 { return None; }
|
||||
match expr {
|
||||
Expr::Literal(crate::ast::Literal::Int(n)) => Some(*n),
|
||||
Expr::Occluded { payload: Some(inner), .. } =>
|
||||
checked_constant_int(inner, depth+1),
|
||||
Expr::Unary {op: crate::ast::UnaryOp::Neg, expr} =>
|
||||
checked_constant_int(expr,depth+1)?.checked_neg(),
|
||||
Expr::Binary {op,left,right} => {
|
||||
let a=checked_constant_int(left,depth+1)?;
|
||||
let b=checked_constant_int(right,depth+1)?;
|
||||
match op {
|
||||
crate::ast::BinaryOp::Add=>a.checked_add(b),
|
||||
crate::ast::BinaryOp::Sub=>a.checked_sub(b),
|
||||
crate::ast::BinaryOp::Mul=>a.checked_mul(b),
|
||||
// Division and its rounding/coercion are not yet proven
|
||||
// equivalent to the Lean abstract numeric model.
|
||||
_=>None
|
||||
}
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
|
||||
fn static_call_args(call:&CallExpr)->Vec<StaticCallArg>{
|
||||
// The exact same alias/modifier expansion used by runtime resolution
|
||||
// must determine the proof's argument list. An invalid normalization
|
||||
// must never yield a recoverable proof argument.
|
||||
let Ok(normalized)=call.for_evaluation() else {return Vec::new()};
|
||||
normalized.args.iter().map(|a|{
|
||||
let (name,expr)=match a {
|
||||
crate::ast::Arg::Positional(expr)=>(None,expr),
|
||||
crate::ast::Arg::Named{name,value}=>(Some(name.clone()),value)
|
||||
};
|
||||
StaticCallArg {
|
||||
name, integer:checked_constant_int(expr,0),
|
||||
expression_digest:digest(format!("{expr:?}")),
|
||||
symbol:match expr {Expr::Var(v)=>Some(v.clone()),_=>None}
|
||||
}
|
||||
}).collect()
|
||||
}
|
||||
|
||||
/// Static call site bound to a SymbolId (G02).
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct BoundCall {
|
||||
/// Exact owning function symbol at the AST callsite.
|
||||
pub caller: SymbolId,
|
||||
pub target: SymbolId,
|
||||
pub call_site: String,
|
||||
pub source: SourceLocation,
|
||||
/// Exact, ordered actual arguments with conservative closed-int decoding.
|
||||
pub args: Vec<StaticCallArg>,
|
||||
/// Guard predicates are source-derived and never independently trusted.
|
||||
pub path_guards: Vec<String>,
|
||||
/// Loop, unknown guard, etc: no modular proof may pass this callsite.
|
||||
pub control_blocker: Option<String>,
|
||||
pub required_effects: EffectSet,
|
||||
}
|
||||
|
||||
@@ -225,6 +321,8 @@ pub struct SemanticProject {
|
||||
pub artifacts: Vec<SemanticArtifact>,
|
||||
pub refs: Vec<KnowledgeRef>,
|
||||
pub steps: Vec<KnowledgeStep>,
|
||||
pub claims: Vec<KnowledgeClaim>,
|
||||
pub assumptions: Vec<KnowledgeAssumption>,
|
||||
pub bound_calls: Vec<BoundCall>,
|
||||
pub dynamic_calls: Vec<DynamicCall>,
|
||||
}
|
||||
@@ -275,6 +373,8 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
let mut artifacts = Vec::new();
|
||||
let mut refs = Vec::new();
|
||||
let mut steps = Vec::new();
|
||||
let mut claims = Vec::new();
|
||||
let mut assumptions = Vec::new();
|
||||
let mut bound_calls = Vec::new();
|
||||
let mut dynamic_calls = Vec::new();
|
||||
let mut local_by_name: BTreeMap<(ModuleId, String), SymbolId> = BTreeMap::new();
|
||||
@@ -291,6 +391,53 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
let module_symbols = index.symbols_in_module(module_id);
|
||||
for symbol in index.symbols_in_module(module_id) {
|
||||
let function = by_path.get(&symbol.declaration_path).expect("symbol collected from module");
|
||||
let mut claim_counts=BTreeMap::new();
|
||||
for claim in &function.claims {
|
||||
*claim_counts.entry(claim.id.as_str()).or_insert(0usize)+=1;
|
||||
}
|
||||
for claim in &function.claims {
|
||||
if claim_counts.get(claim.id.as_str())!=Some(&1) {
|
||||
diagnostics.push(Diagnostic::new(Some(path.as_path()),
|
||||
Span::new(claim.line,1),
|
||||
format!("ambiguous theorem declaration: {}",claim.id))
|
||||
.with_code("knowledge.claim_duplicate")
|
||||
.with_severity(Severity::Warning));
|
||||
continue;
|
||||
}
|
||||
claims.push(KnowledgeClaim {
|
||||
anchor_id: format!("{}#claim-{}",symbol.id.as_str(),
|
||||
digest(claim.id.as_bytes()).0.trim_start_matches("sha256:")),
|
||||
owner:symbol.id.clone(),
|
||||
label:claim.id.clone(),
|
||||
conclusion:claim.conclusion.clone(),
|
||||
premise:claim.premise.clone(),
|
||||
line:claim.line,
|
||||
source:source_location(index.root().path(),path,claim.line,claim.line),
|
||||
});
|
||||
}
|
||||
let mut assumption_counts=BTreeMap::new();
|
||||
for assumption in &function.assumptions {
|
||||
*assumption_counts.entry(assumption.op.as_str()).or_insert(0usize)+=1;
|
||||
}
|
||||
for assumption in &function.assumptions {
|
||||
if assumption_counts.get(assumption.op.as_str())!=Some(&1) {
|
||||
diagnostics.push(Diagnostic::new(Some(path.as_path()),
|
||||
Span::new(assumption.line,1),
|
||||
format!("ambiguous assumption operation: {}",assumption.op))
|
||||
.with_code("proof.assumption_duplicate")
|
||||
.with_severity(Severity::Warning));
|
||||
continue;
|
||||
}
|
||||
assumptions.push(KnowledgeAssumption{
|
||||
id:format!("{}#assumption-{}",symbol.id.as_str(),
|
||||
digest(assumption.op.as_bytes()).0.trim_start_matches("sha256:")),
|
||||
owner:symbol.id.clone(),
|
||||
operation:assumption.op.clone(),
|
||||
premise:assumption.premise.clone(),
|
||||
postcondition:assumption.postcondition.clone(),
|
||||
source:source_location(index.root().path(),path,assumption.line,assumption.line)
|
||||
});
|
||||
}
|
||||
let owned_links: Vec<_> = narrative_links
|
||||
.iter()
|
||||
.filter(|link| enclosing_symbol(&module_symbols, link.line).is_some_and(|s| s.id == symbol.id))
|
||||
@@ -304,6 +451,7 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
path,
|
||||
function,
|
||||
symbol,
|
||||
text,
|
||||
&local_by_name,
|
||||
&owned_links,
|
||||
&module_prov,
|
||||
@@ -323,6 +471,20 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
}
|
||||
}
|
||||
close_effect_dependencies(&mut artifacts);
|
||||
resolve_anchor_references(&mut refs, &claims);
|
||||
for reference in refs.iter().filter(|r|
|
||||
r.resolution=="unresolved_anchor" || r.resolution=="ambiguous_anchor") {
|
||||
let source_path=root.path().join(&reference.source.file);
|
||||
diagnostics.push(Diagnostic::new(
|
||||
Some(source_path.as_path()),
|
||||
Span::new(reference.source.line, 1),
|
||||
format!("knowledge target cannot be uniquely resolved: {}",
|
||||
reference.link_target.as_deref().unwrap_or("<missing>")))
|
||||
.with_code(if reference.resolution=="ambiguous_anchor" {
|
||||
"knowledge.anchor_ambiguous"
|
||||
} else {"knowledge.anchor_unresolved"})
|
||||
.with_severity(Severity::Warning));
|
||||
}
|
||||
let resolved_effects: BTreeMap<_,_> = artifacts.iter()
|
||||
.map(|artifact|(artifact.artifact_id.clone(),artifact.effects.clone())).collect();
|
||||
for bound in &mut bound_calls {
|
||||
@@ -345,6 +507,8 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
artifacts.sort_by(|a, b| a.artifact_id.0.cmp(&b.artifact_id.0));
|
||||
refs.sort_by(|a, b| a.id.cmp(&b.id));
|
||||
steps.sort_by(|a, b| a.id.0.cmp(&b.id.0));
|
||||
claims.sort_by(|a,b| a.anchor_id.cmp(&b.anchor_id));
|
||||
assumptions.sort_by(|a,b|a.id.cmp(&b.id));
|
||||
bound_calls.sort_by(|a, b| {
|
||||
a.source
|
||||
.file
|
||||
@@ -368,6 +532,8 @@ fn compile_index(index: ProjectIndex) -> Result<Compilation> {
|
||||
artifacts,
|
||||
refs,
|
||||
steps,
|
||||
claims,
|
||||
assumptions,
|
||||
bound_calls,
|
||||
dynamic_calls,
|
||||
},
|
||||
@@ -514,6 +680,168 @@ fn resolve_narrative_target(
|
||||
})
|
||||
}
|
||||
|
||||
/// The label is a human-facing name, not an execution permission.
|
||||
fn normalize_anchor_label(label: &str) -> String {
|
||||
label.split_whitespace().collect::<Vec<_>>().join(" ")
|
||||
}
|
||||
|
||||
fn public_anchor(owner: &SymbolId, label: &str, counts: &BTreeMap<String, usize>) -> Option<String> {
|
||||
let normalized = normalize_anchor_label(label);
|
||||
if normalized.is_empty() || counts.get(&normalized) != Some(&1) {
|
||||
return None;
|
||||
}
|
||||
// Full SHA-256 avoids truncation collisions; unrelated step insertions
|
||||
// do not change the address, while changing the label intentionally does.
|
||||
Some(format!("{}#anchor-{}", owner.as_str(), digest(normalized.as_bytes()).0.trim_start_matches("sha256:")))
|
||||
}
|
||||
|
||||
fn anchor_definition_digest(source: &str, line: u32, label: &str, kind: &str) -> Digest {
|
||||
let body = if line > 0 { source.lines().nth(line as usize - 1) } else { None };
|
||||
digest(format!("{kind}\0{label}\0{}", body.unwrap_or("<unknown-source-line>")))
|
||||
}
|
||||
|
||||
/// Explicit knowledge references are inert: resolving a link never invokes a
|
||||
/// function. Short #@label binds ONLY inside the current function. Full
|
||||
/// mq://...#anchor-<sha256> targets support cross-module references.
|
||||
fn resolve_anchor_references(refs: &mut [KnowledgeRef], claims: &[KnowledgeClaim]) {
|
||||
let declared: BTreeSet<String> = refs.iter()
|
||||
.filter_map(|r| r.anchor_id.clone()).collect();
|
||||
let theorem_ids: BTreeSet<String> = claims.iter().map(|c|c.anchor_id.clone()).collect();
|
||||
for reference in refs {
|
||||
let Some(raw) = reference.link_target.as_deref() else {continue};
|
||||
let sought = if let Some(label) = raw.trim().strip_prefix("#@") {
|
||||
let Some(owner) = reference.id.split("#ref-").next() else {continue};
|
||||
if label.is_empty() {continue}
|
||||
Some((format!("{}#anchor-{}", owner,
|
||||
digest(normalize_anchor_label(label).as_bytes()).0.trim_start_matches("sha256:")),
|
||||
format!("{}#claim-{}", owner,
|
||||
digest(label.as_bytes()).0.trim_start_matches("sha256:"))))
|
||||
} else if raw.starts_with("mq://")
|
||||
&& (raw.contains("#anchor-") || raw.contains("#claim-")) {
|
||||
Some((raw.trim().to_string(), raw.trim().to_string()))
|
||||
} else { None };
|
||||
if let Some((anchor, claim)) = sought {
|
||||
let step_match=declared.contains(&anchor);
|
||||
let theorem_match=theorem_ids.contains(&claim);
|
||||
match (step_match,theorem_match) {
|
||||
(true,false)=>{
|
||||
reference.target_anchor=Some(anchor);
|
||||
reference.resolution="anchor".into();
|
||||
}
|
||||
(false,true)=>{
|
||||
reference.target_claim=Some(claim);
|
||||
reference.resolution="claim".into();
|
||||
}
|
||||
(true,true)=>reference.resolution="ambiguous_anchor".into(),
|
||||
_=>reference.resolution="unresolved_anchor".into()
|
||||
}
|
||||
reference.target=None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone,Default)]
|
||||
struct CallsiteControl {
|
||||
guards: Vec<String>,
|
||||
blocker: Option<String>,
|
||||
}
|
||||
|
||||
/// Only side-effect-free boolean and integer-comparison guards are projected.
|
||||
/// Unknown guards and any loops remain explicit unresolved obligations.
|
||||
fn guard_text(expr:&Expr)->Option<String>{
|
||||
match expr {
|
||||
Expr::Var(v)=>Some(v.clone()),
|
||||
Expr::Literal(crate::ast::Literal::Int(n))=>Some(n.to_string()),
|
||||
Expr::Literal(crate::ast::Literal::Bool(v))=>Some(
|
||||
if *v {"真"}else{"假"}.into()),
|
||||
Expr::Occluded {payload:Some(e),..}=>guard_text(e),
|
||||
Expr::Unary {op:crate::ast::UnaryOp::Not,expr}=>
|
||||
Some(format!("非 ({})",guard_text(expr)?)),
|
||||
Expr::Unary {op:crate::ast::UnaryOp::Neg,expr}=>
|
||||
Some(format!("-({})",guard_text(expr)?)),
|
||||
Expr::Binary {op,left,right}=>{
|
||||
let symbol=match op {
|
||||
crate::ast::BinaryOp::Eq=>"=",
|
||||
crate::ast::BinaryOp::Ne=>"≠",
|
||||
crate::ast::BinaryOp::Lt=>"<",
|
||||
crate::ast::BinaryOp::Le=>"≤",
|
||||
crate::ast::BinaryOp::Gt=>">",
|
||||
crate::ast::BinaryOp::Ge=>"≥",
|
||||
crate::ast::BinaryOp::And=>"且",
|
||||
crate::ast::BinaryOp::Or=>"或",
|
||||
// Preserve source arithmetic in *guard obligations* only.
|
||||
// This does not certify i64 overflow or dynamic Number
|
||||
// behavior; the symbolic Lean Int backend checks linearity.
|
||||
crate::ast::BinaryOp::Add=>"+",
|
||||
crate::ast::BinaryOp::Sub=>"-",
|
||||
crate::ast::BinaryOp::Mul=>"*",
|
||||
_=>return None
|
||||
};
|
||||
Some(format!("({} {} {})",
|
||||
guard_text(left)?,symbol,guard_text(right)?))
|
||||
},
|
||||
_=>None
|
||||
}
|
||||
}
|
||||
fn callsite_control(fun:&Function)->BTreeMap<u32,CallsiteControl>{
|
||||
fn walk(items:&[Stmt],conditions:&[String],block:Option<String>,
|
||||
output:&mut BTreeMap<u32,CallsiteControl>){
|
||||
for stmt in items{
|
||||
match stmt {
|
||||
Stmt::Branch{arms,span}=>{
|
||||
// Calls within branch test expressions require separate
|
||||
// evaluation-order reasoning and must not borrow arm facts.
|
||||
output.entry(span.line).or_insert_with(||CallsiteControl{
|
||||
guards:conditions.to_vec(),
|
||||
blocker:Some("call_in_condition_not_modeled".into())
|
||||
});
|
||||
let mut negated=Vec::new();
|
||||
let mut prior_unknown_condition=false;
|
||||
for arm in arms{
|
||||
let mut path=conditions.to_vec();
|
||||
path.extend(negated.iter().cloned());
|
||||
// A previous unmodelled if/elif test also controls the
|
||||
// reachability of all later arms, including else.
|
||||
let mut arm_block=if prior_unknown_condition {
|
||||
Some("prior_non_pure_branch_guard".into())
|
||||
} else {block.clone()};
|
||||
if let Some(cond)=&arm.condition{
|
||||
match guard_text(cond){
|
||||
Some(guard)=>{
|
||||
path.push(guard.clone());
|
||||
negated.push(format!("非 ({guard})"));
|
||||
},
|
||||
None=>{
|
||||
arm_block=Some("non_pure_branch_guard".into());
|
||||
prior_unknown_condition=true;
|
||||
}
|
||||
}
|
||||
}
|
||||
walk(&arm.body,&path,arm_block,output);
|
||||
}
|
||||
},
|
||||
Stmt::While{body,span,..}|Stmt::ForEach{body,span,..}=>{
|
||||
output.insert(span.line,CallsiteControl{
|
||||
guards:conditions.to_vec(),
|
||||
blocker:Some("loop_or_iterator_requires_invariant".into())
|
||||
});
|
||||
walk(body,conditions,
|
||||
Some("loop_or_iterator_requires_invariant".into()),output);
|
||||
},
|
||||
_=>{
|
||||
let line=crate::ast::stmt_line(stmt);
|
||||
output.insert(line,CallsiteControl{
|
||||
guards:conditions.to_vec(),blocker:block.clone()
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut found=BTreeMap::new();
|
||||
walk(&fun.body,&[],None,&mut found);
|
||||
found
|
||||
}
|
||||
|
||||
fn artifact_for_function(
|
||||
index: &ProjectIndex,
|
||||
module_id: &ModuleId,
|
||||
@@ -521,6 +849,7 @@ fn artifact_for_function(
|
||||
path: &Path,
|
||||
function: &Function,
|
||||
symbol: &SymbolDecl,
|
||||
source_text: &str,
|
||||
local_by_name: &BTreeMap<(ModuleId, String), SymbolId>,
|
||||
narrative_links: &[crate::parse::NarrativeLink],
|
||||
module_prov: &super::provenance::ModuleProvenance,
|
||||
@@ -533,6 +862,7 @@ fn artifact_for_function(
|
||||
Vec<super::provenance::ProvenanceDiag>,
|
||||
) {
|
||||
let calls = collect_call_sites(function);
|
||||
let controls=callsite_control(function);
|
||||
let mut effects = direct_effects(index, ast_module, function, &calls);
|
||||
let mut dependencies = Vec::new();
|
||||
let mut bound_calls = Vec::new();
|
||||
@@ -543,9 +873,13 @@ fn artifact_for_function(
|
||||
CallClass::Bound { target, effects: call_effects } => {
|
||||
dependencies.push(ArtifactId(target.as_str().to_string()));
|
||||
bound_calls.push(BoundCall {
|
||||
caller:symbol.id.clone(),
|
||||
target,
|
||||
call_site: call_display(call),
|
||||
source,
|
||||
args:static_call_args(call),
|
||||
path_guards:controls.get(line).map(|c|c.guards.clone()).unwrap_or_default(),
|
||||
control_blocker:controls.get(line).and_then(|c|c.blocker.clone()),
|
||||
required_effects: call_effects,
|
||||
});
|
||||
}
|
||||
@@ -560,6 +894,12 @@ fn artifact_for_function(
|
||||
}
|
||||
}
|
||||
let named = collect_named_steps(function);
|
||||
// Only a unique author-visible label in this function receives a public
|
||||
// address. Duplicate names are deliberately not resolved by source order.
|
||||
let mut label_counts = BTreeMap::new();
|
||||
for site in &named {
|
||||
*label_counts.entry(normalize_anchor_label(&site.label)).or_insert(0usize) += 1;
|
||||
}
|
||||
let mut refs = Vec::new();
|
||||
let mut steps = Vec::new();
|
||||
let mut step_n = 0u32;
|
||||
@@ -572,7 +912,13 @@ fn artifact_for_function(
|
||||
}
|
||||
});
|
||||
let ref_id = format!("{}#ref-{}", symbol.id.as_str(), step_n);
|
||||
let anchor = public_anchor(&symbol.id, &named.label, &label_counts);
|
||||
let definition_digest = anchor_definition_digest(source_text, named.line, &named.label, &named.kind);
|
||||
refs.push(KnowledgeRef {
|
||||
anchor_id: anchor.clone(),
|
||||
link_target: None,
|
||||
target_anchor: None,
|
||||
target_claim: None,
|
||||
id: ref_id.clone(),
|
||||
label: named.label.clone(),
|
||||
context: named.context.clone(),
|
||||
@@ -589,6 +935,8 @@ fn artifact_for_function(
|
||||
}
|
||||
steps.push(KnowledgeStep {
|
||||
id: ArtifactId(format!("{}#step-{}", symbol.id.as_str(), step_n)),
|
||||
anchor_id: anchor,
|
||||
definition_digest,
|
||||
reference: ref_id,
|
||||
kind: named.kind.clone(),
|
||||
calls: target.into_iter().collect(),
|
||||
@@ -606,7 +954,13 @@ fn artifact_for_function(
|
||||
crate::parse::NarrativeLinkKind::Navigation => None,
|
||||
};
|
||||
let ref_id = format!("{}#ref-{}", symbol.id.as_str(), step_n);
|
||||
// A narrative link is a reference, not a definition. It never creates
|
||||
// a public executable anchor of its own.
|
||||
refs.push(KnowledgeRef {
|
||||
anchor_id: None,
|
||||
link_target: Some(link.target.clone()),
|
||||
target_anchor: None,
|
||||
target_claim: None,
|
||||
id: ref_id.clone(),
|
||||
label: link.label.clone(),
|
||||
context: "narrative".into(),
|
||||
@@ -620,6 +974,8 @@ fn artifact_for_function(
|
||||
});
|
||||
steps.push(KnowledgeStep {
|
||||
id: ArtifactId(format!("{}#step-{}", symbol.id.as_str(), step_n)),
|
||||
anchor_id: None,
|
||||
definition_digest: anchor_definition_digest(source_text, link.line, &link.label, link.kind.as_str()),
|
||||
reference: ref_id,
|
||||
kind: link.kind.as_str().into(),
|
||||
calls: target.into_iter().collect(),
|
||||
@@ -763,10 +1119,14 @@ fn classify_call(
|
||||
}) else {
|
||||
return CallClass::Other;
|
||||
};
|
||||
let decl = if path.len() >= 2 {
|
||||
path[1..].to_vec()
|
||||
} else if let Some(d) = declaration_path_of(lib, fun) {
|
||||
// Resolve the *declaration* path in the imported module, not
|
||||
// the syntactic call path: `rates.lookup()` may refer to a
|
||||
// nested `# rates / ## lookup` function. Losing the parent
|
||||
// would silently break transitive proof invalidation.
|
||||
let decl = if let Some(d) = declaration_path_of(lib, fun) {
|
||||
d
|
||||
} else if path.len() >= 2 {
|
||||
path[1..].to_vec()
|
||||
} else {
|
||||
return CallClass::Other;
|
||||
};
|
||||
@@ -1315,6 +1675,8 @@ impl SemanticProject {
|
||||
"artifacts": self.artifacts.iter().map(artifact_json).collect::<Vec<_>>(),
|
||||
"refs": self.refs.iter().map(ref_json).collect::<Vec<_>>(),
|
||||
"steps": self.steps.iter().map(step_json).collect::<Vec<_>>(),
|
||||
"claims": self.claims.iter().map(claim_json).collect::<Vec<_>>(),
|
||||
"assumptions": self.assumptions.iter().map(assumption_json).collect::<Vec<_>>(),
|
||||
"bound_calls": self.bound_calls.iter().map(bound_call_json).collect::<Vec<_>>(),
|
||||
"dynamic_calls": self.dynamic_calls.iter().map(dynamic_call_json).collect::<Vec<_>>(),
|
||||
})
|
||||
@@ -1324,12 +1686,31 @@ impl SemanticProject {
|
||||
pub fn artifact_json(artifact: &SemanticArtifact) -> Value {
|
||||
json!({"schema_version": SCHEMA_VERSION, "artifact_id": artifact.artifact_id.0, "symbol_id": artifact.symbol_id.as_ref().map(SymbolId::as_str), "display_name": artifact.display_name, "kind": artifact.kind, "callable": artifact.callable, "source": {"file": artifact.source.file, "line": artifact.source.line, "end_line": artifact.source.end_line}, "signature": artifact.signature.as_ref().map(|s| json!({"receiver":s.receiver,"params":s.params.iter().map(|p|json!({"name":p.name,"type":p.ty,"required":p.required,"default_digest":p.default_digest.as_ref().map(|d|&d.0),"unit":p.unit})).collect::<Vec<_>>(),"returns":s.returns,"effects":s.effects.values()})), "contract":{"params":artifact.contract.params,"returns":artifact.contract.returns,"fields":artifact.contract.fields}, "effects":artifact.effects.values(), "dependencies":artifact.dependencies.iter().map(|d|&d.0).collect::<Vec<_>>(), "provenance":artifact.provenance.iter().map(|p|json!({"uri":p.uri,"locator":p.locator,"content_digest":p.content_digest.as_ref().map(|d|&d.0),"relation":p.relation})).collect::<Vec<_>>(), "applicability":artifact.applicability, "hashes":{"interface":artifact.hashes.interface.0,"implementation":artifact.hashes.implementation.0,"evidence":artifact.hashes.evidence.0,"artifact":artifact.hashes.artifact.0,"closure":artifact.hashes.closure.0}, "verification":{"parse":artifact.verification.parse,"resolve":artifact.verification.resolve,"contract":artifact.verification.contract,"execution":artifact.verification.execution,"tests":artifact.verification.tests,"evidence":artifact.verification.evidence,"domain":artifact.verification.domain,"methods":artifact.verification.methods}, "lifecycle":artifact.lifecycle})
|
||||
}
|
||||
fn ref_json(reference: &KnowledgeRef) -> Value { json!({"id":reference.id,"label":reference.label,"context":reference.context,"source":{"file":reference.source.file,"line":reference.source.line,"end_line":reference.source.end_line},"resolution":reference.resolution,"target":reference.target.as_ref().map(SymbolId::as_str)}) }
|
||||
fn step_json(step: &KnowledgeStep) -> Value { json!({"id":step.id.0,"reference":step.reference,"kind":step.kind,"calls":step.calls.iter().map(SymbolId::as_str).collect::<Vec<_>>(),"effects":step.effects.values(),"source":{"file":step.source.file,"line":step.source.line,"end_line":step.source.end_line}}) }
|
||||
fn ref_json(reference: &KnowledgeRef) -> Value { json!({"id":reference.id,"anchor_id":reference.anchor_id,"link_target":reference.link_target,"target_anchor":reference.target_anchor,"target_claim":reference.target_claim,"label":reference.label,"context":reference.context,"source":{"file":reference.source.file,"line":reference.source.line,"end_line":reference.source.end_line},"resolution":reference.resolution,"target":reference.target.as_ref().map(SymbolId::as_str)}) }
|
||||
fn assumption_json(a:&KnowledgeAssumption)->Value{
|
||||
json!({"id":a.id,"owner":a.owner.as_str(),"operation":a.operation,
|
||||
"premise":a.premise,"postcondition":a.postcondition,
|
||||
"verification":"declared_not_proved",
|
||||
"source":{"file":a.source.file,"line":a.source.line}})
|
||||
}
|
||||
fn claim_json(claim: &KnowledgeClaim) -> Value {
|
||||
json!({"anchor_id":claim.anchor_id,"owner":claim.owner.as_str(),
|
||||
"label":claim.label,"conclusion":claim.conclusion,"premise":claim.premise,
|
||||
"verification":"declared_unverified",
|
||||
"source":{"file":claim.source.file,"line":claim.line}})
|
||||
}
|
||||
fn step_json(step: &KnowledgeStep) -> Value { json!({"id":step.id.0,"anchor_id":step.anchor_id,"definition_digest":step.definition_digest.0,"reference":step.reference,"kind":step.kind,"calls":step.calls.iter().map(SymbolId::as_str).collect::<Vec<_>>(),"effects":step.effects.values(),"source":{"file":step.source.file,"line":step.source.line,"end_line":step.source.end_line}}) }
|
||||
fn bound_call_json(call: &BoundCall) -> Value {
|
||||
json!({
|
||||
"caller":call.caller.as_str(),
|
||||
"target": call.target.as_str(),
|
||||
"call_site": call.call_site,
|
||||
"args":call.args.iter().map(|a|json!({
|
||||
"name":a.name,"integer":a.integer,"symbol":a.symbol,
|
||||
"expression_digest":a.expression_digest.0
|
||||
})).collect::<Vec<_>>(),
|
||||
"path_guards":call.path_guards,
|
||||
"control_blocker":call.control_blocker,
|
||||
"source": {"file": call.source.file, "line": call.source.line, "end_line": call.source.end_line},
|
||||
"required_effects": call.required_effects.values(),
|
||||
"binding": "BoundCall",
|
||||
@@ -1349,6 +1730,11 @@ const SEMANTIC_NAMES: &[&str] = &[
|
||||
"symbols.json",
|
||||
"refs.json",
|
||||
"steps.json",
|
||||
"anchors.json",
|
||||
"claims.json",
|
||||
"assumptions.json",
|
||||
"proof-index.json",
|
||||
"proof-obligations.json",
|
||||
"bound_calls.json",
|
||||
"dynamic_calls.json",
|
||||
"artifacts",
|
||||
@@ -1400,7 +1786,7 @@ pub fn write_semantic_projections(out_dir: &Path, compilation: &Compilation) ->
|
||||
fs::create_dir_all(gen_dir.join("artifacts"))?;
|
||||
fs::create_dir_all(gen_dir.join("graph"))?;
|
||||
fs::create_dir_all(gen_dir.join("verification"))?;
|
||||
write_generation_tree(&gen_dir, compilation)?;
|
||||
write_generation_tree(&gen_dir, compilation, &out_dir.join("prove"))?;
|
||||
|
||||
// Publish journal + CAS (M-R6): record expected CURRENT before switching.
|
||||
let expected = fs::read_to_string(out_dir.join("CURRENT"))
|
||||
@@ -1463,7 +1849,7 @@ pub fn write_semantic_projections(out_dir: &Path, compilation: &Compilation) ->
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_generation_tree(stage: &Path, compilation: &Compilation) -> Result<()> {
|
||||
fn write_generation_tree(stage: &Path, compilation: &Compilation, prove_root: &Path) -> Result<()> {
|
||||
let project = compilation.semantics.to_json();
|
||||
write_json(
|
||||
&stage.join("project.json"),
|
||||
@@ -1477,6 +1863,37 @@ fn write_generation_tree(stage: &Path, compilation: &Compilation) -> Result<()>
|
||||
write_json(&stage.join("symbols.json"), &json!({"schema_version":SCHEMA_VERSION,"symbols":compilation.index.symbols().iter().map(|s|json!({"id":s.id.as_str(),"module":s.module.as_str(),"kind":s.kind.as_str(),"callable":s.callable.map(|c|c.as_str()),"name":s.name,"declaration_path":s.declaration_path,"source":{"file":rel_uri(compilation.index.root().path(),&s.source),"line":s.line}})).collect::<Vec<_>>() }))?;
|
||||
write_json(&stage.join("refs.json"), &json!({"schema_version":SCHEMA_VERSION,"refs":project["refs"]}))?;
|
||||
write_json(&stage.join("steps.json"), &json!({"schema_version":SCHEMA_VERSION,"steps":project["steps"]}))?;
|
||||
write_json(&stage.join("claims.json"), &json!({
|
||||
"schema_version":SCHEMA_VERSION,
|
||||
"role":"theorem_declarations_not_proof_results",
|
||||
"claims":project["claims"]
|
||||
}))?;
|
||||
let proofs=crate::knowledge::proof::index_links(prove_root, &compilation.semantics);
|
||||
write_json(&stage.join("assumptions.json"), &json!({
|
||||
"schema_version":SCHEMA_VERSION,
|
||||
"role":"declared_modular_contracts_require_callsite_proof",
|
||||
"assumptions":project["assumptions"]
|
||||
}))?;
|
||||
write_json(&stage.join("proof-index.json"), &proofs)?;
|
||||
write_json(&stage.join("proof-obligations.json"),
|
||||
&crate::knowledge::modular::analyze(&compilation.semantics, &proofs))?;
|
||||
write_json(&stage.join("anchors.json"), &json!({
|
||||
"schema_version":SCHEMA_VERSION,
|
||||
"role":"stable_public_knowledge_addresses",
|
||||
"anchors": compilation.semantics.steps.iter()
|
||||
.filter(|step| step.anchor_id.is_some())
|
||||
.map(|step| json!({
|
||||
"anchor_id":step.anchor_id,
|
||||
"owner":step.id.0.split('#').next(),
|
||||
"label":compilation.semantics.refs.iter()
|
||||
.find(|r| r.id == step.reference).map(|r| r.label.as_str()),
|
||||
"step_id":step.id.0,
|
||||
"kind":step.kind,
|
||||
"source":step_json(step)["source"],
|
||||
"definition_digest":step.definition_digest.0,
|
||||
"effects":step.effects.values(),
|
||||
})).collect::<Vec<_>>()
|
||||
}))?;
|
||||
write_json(&stage.join("bound_calls.json"), &json!({"schema_version":SCHEMA_VERSION,"bound_calls":project["bound_calls"]}))?;
|
||||
write_json(&stage.join("dynamic_calls.json"), &json!({"schema_version":SCHEMA_VERSION,"dynamic_calls":project["dynamic_calls"]}))?;
|
||||
write_json(&stage.join("graph/nodes.json"), &json!({"schema_version":SCHEMA_VERSION,"nodes":project["artifacts"]}))?;
|
||||
@@ -1490,7 +1907,33 @@ fn write_generation_tree(stage: &Path, compilation: &Compilation) -> Result<()>
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
for assumption in &compilation.semantics.assumptions {
|
||||
edges.push(json!({"from":assumption.owner.as_str(),
|
||||
"to":assumption.id,"kind":"declares_assumption"}));
|
||||
}
|
||||
for claim in &compilation.semantics.claims {
|
||||
edges.push(json!({"from":claim.owner.as_str(),
|
||||
"to":claim.anchor_id,"kind":"declares_claim"}));
|
||||
}
|
||||
for reference in &compilation.semantics.refs {
|
||||
if let Some(claim) = &reference.target_claim {
|
||||
let owner=reference.id.split("#ref-").next().unwrap_or("");
|
||||
edges.push(json!({"from":owner,"to":claim,"kind":"references_claim"}));
|
||||
}
|
||||
if let Some(target) = &reference.target_anchor {
|
||||
let owner = reference.id.split("#ref-").next().unwrap_or("");
|
||||
edges.push(json!({"from":owner,"to":target,"kind":"references_anchor"}));
|
||||
}
|
||||
}
|
||||
for step in &compilation.semantics.steps {
|
||||
if let Some(anchor) = &step.anchor_id {
|
||||
if let Some(owner) = step.id.0.split('#').next() {
|
||||
edges.push(json!({"from":owner,"to":anchor,"kind":"defines_anchor"}));
|
||||
}
|
||||
for target in &step.calls {
|
||||
edges.push(json!({"from":anchor,"to":target.as_str(),"kind":"calls"}));
|
||||
}
|
||||
}
|
||||
if step.kind == "narrate" {
|
||||
for target in &step.calls {
|
||||
edges.push(json!({
|
||||
@@ -1651,6 +2094,106 @@ import:
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn public_anchors_survive_unrelated_insertions_and_track_definition_changes() {
|
||||
let root = root();
|
||||
let file = root.join("main.mq.md");
|
||||
let source = |prefix: &str, amount: i32| format!(
|
||||
"# main\n\n## calculate\n\n{prefix}**x = [计算税额]({amount} * 2)**\n*x*\n"
|
||||
);
|
||||
fs::write(&file, source("", 3)).unwrap();
|
||||
let one = compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let anchor1 = one.semantics.steps.iter().find(|s| s.anchor_id.is_some()).unwrap();
|
||||
let identity = anchor1.anchor_id.clone();
|
||||
let digest1 = anchor1.definition_digest.clone();
|
||||
fs::write(&file, source("**other = [准备参数](1)**\n", 3)).unwrap();
|
||||
let two = compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let anchor2 = two.semantics.steps.iter()
|
||||
.find(|s| s.anchor_id == identity).unwrap();
|
||||
assert_eq!(anchor1.anchor_id, anchor2.anchor_id);
|
||||
assert_eq!(digest1, anchor2.definition_digest);
|
||||
assert_ne!(anchor1.id, anchor2.id, "legacy ordinal step id may move");
|
||||
fs::write(&file, source("**other = [准备参数](1)**\n", 4)).unwrap();
|
||||
let three = compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let anchor3 = three.semantics.steps.iter()
|
||||
.find(|s| s.anchor_id == identity).unwrap();
|
||||
assert_ne!(digest1, anchor3.definition_digest);
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn markdown_knowledge_links_bind_only_to_registered_anchors() {
|
||||
let root=root();
|
||||
fs::write(root.join("main.mq.md"),
|
||||
"# main\n\n## f\n\n[说明](#@演算)\n[不存在](#@没有)\n**x = [演算](2 * 3)**\n*x*\n"
|
||||
).unwrap();
|
||||
let c=compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let target=c.semantics.steps.iter().find_map(|s|s.anchor_id.as_deref()).unwrap();
|
||||
let link=c.semantics.refs.iter().find(|r|r.label=="说明").unwrap();
|
||||
assert_eq!(link.target_anchor.as_deref(),Some(target));
|
||||
assert_eq!(link.resolution,"anchor");
|
||||
assert!(link.target.is_none(),"narrative links must never become executable calls");
|
||||
let bad=c.semantics.refs.iter().find(|r|r.label=="不存在").unwrap();
|
||||
assert_eq!(bad.resolution,"unresolved_anchor");
|
||||
assert!(bad.target_anchor.is_none());
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn canonical_mq_uri_resolves_across_functions_without_calling_knowledge() {
|
||||
let root=root();
|
||||
let src=root.join("main.mq.md");
|
||||
fs::write(&src,"# main\n\n## source\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let initial=compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let anchor=initial.semantics.steps.iter().find_map(|s|s.anchor_id.clone()).unwrap();
|
||||
let updated=format!(
|
||||
"# main\n\n## source\n\n**x = [演算](2 * 3)**\n*x*\n\n## consumer\n\n[阅读计算知识]({anchor})\n*None*\n"
|
||||
);
|
||||
fs::write(&src,updated).unwrap();
|
||||
let parsed=compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let read=parsed.semantics.refs.iter().find(|r|r.label=="阅读计算知识").unwrap();
|
||||
assert_eq!(read.target_anchor.as_deref(),Some(anchor.as_str()));
|
||||
assert_eq!(read.resolution,"anchor");
|
||||
assert!(read.target.is_none());
|
||||
assert!(parsed.semantics.bound_calls.iter().all(|c|c.call_site!="阅读计算知识"));
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn theorem_claims_are_addressable_but_never_implicitly_proved() {
|
||||
let root=root();
|
||||
fs::write(root.join("main.mq.md"),
|
||||
"# main\n\n## f\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| 安全性质 | 长度(轨迹) = 0 | | auto |\n\n[阅读定理](#@安全性质)\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let c=compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
assert_eq!(c.semantics.claims.len(),1);
|
||||
let claim=&c.semantics.claims[0];
|
||||
let link=c.semantics.refs.iter().find(|r|r.label=="阅读定理").unwrap();
|
||||
assert_eq!(link.target_claim.as_deref(),Some(claim.anchor_id.as_str()));
|
||||
assert_eq!(link.resolution,"claim");
|
||||
assert!(link.target.is_none());
|
||||
let serialized=c.semantics.to_json();
|
||||
assert_eq!(serialized["claims"][0]["verification"],"declared_unverified");
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_labels_fail_closed_in_public_anchor_projection() {
|
||||
let root = root();
|
||||
fs::write(root.join("main.mq.md"),
|
||||
"# main\n\n## f\n\n**x = [重复](1)**\n**y = [重复](2)**\n*y*\n").unwrap();
|
||||
let compilation = compile_project(&CompileOptions::for_path(&root).unwrap()).unwrap();
|
||||
let duplicated: Vec<_> = compilation.semantics.refs.iter()
|
||||
.filter(|r| r.label == "重复").collect();
|
||||
assert_eq!(duplicated.len(), 2);
|
||||
assert!(duplicated.iter().all(|r| r.anchor_id.is_none()));
|
||||
let out = root.join(".marqdo");
|
||||
write_semantic_projections(&out, &compilation).unwrap();
|
||||
let anchors: Value = serde_json::from_str(
|
||||
&fs::read_to_string(out.join("anchors.json")).unwrap()).unwrap();
|
||||
assert!(anchors["anchors"].as_array().unwrap().is_empty());
|
||||
fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn named_steps_classify_observe_derive_iterate_call() {
|
||||
let root = root();
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: AI native flow offline smoke
|
||||
import:
|
||||
flow: ext/ai/flow.mq.md
|
||||
context: ext/ai/context.mq.md
|
||||
json: lib/json.mq.md
|
||||
sys: lib/sys.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
This fixture tests the real Marqdo interface without a model provider.
|
||||
It refuses an invalid choice and retrieves only the designated function
|
||||
rather than guessing another SKILL or importing the full document.
|
||||
|
||||
**opts = > json.parse text=["chat","office"]**
|
||||
**pick = > flow.parse_choice reply="选择:office" options=`opts`**
|
||||
**value = > json.get value=`pick` key="value"**
|
||||
1. `value` == "office"
|
||||
**_ = 1**
|
||||
2. *
|
||||
**debug_pick = > json.stringify value=`pick`**
|
||||
> print text=`debug_pick`
|
||||
> sys.exit code=11
|
||||
|
||||
**structured = > flow.parse_choice reply="{\"choice\":\"chat\"}" options=`opts`**
|
||||
**structure_value = > json.get value=`structured` key="value"**
|
||||
1. `structure_value` == "chat"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=16
|
||||
|
||||
**invalid = > flow.parse_choice reply="chat 或 office" options=`opts`**
|
||||
**not_ok = > json.get value=`invalid` key="ok"**
|
||||
1. `not_ok`
|
||||
> sys.exit code=12
|
||||
2. *
|
||||
**_ = 1**
|
||||
|
||||
**ctx = > context.scope scope="function" class="main" function="probe" max_chars=200**
|
||||
**ok = > json.get value=`ctx` key="ok"**
|
||||
1. `ok`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=13
|
||||
|
||||
**packed = > context.compose user="Test the route" class="main" function="probe" budget_tokens=2048**
|
||||
**pack_schema = > json.get value=`packed` key="schema"**
|
||||
1. `pack_schema` == "ContextPackV2"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=15
|
||||
|
||||
**gate = > flow.input id="ai_native_flow_ci_gate" question="Continue?" options=`opts` source_revision="fixture-v1" freeform=False**
|
||||
**answered = > flow.reply id="ai_native_flow_ci_gate" reply="office" source_revision="fixture-v1"**
|
||||
**answer = > json.get value=`answered` key="value"**
|
||||
1. `answer` == "office"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=14
|
||||
|
||||
Return *"ai-flow-native-ok"*.
|
||||
|
||||
## probe
|
||||
|
||||
This private helper's narrative should be extracted by the scoped selector
|
||||
without including the root SKILL or neighboring function definitions.
|
||||
|
||||
Return *"probe"*.
|
||||
@@ -0,0 +1,124 @@
|
||||
---
|
||||
markup: occlusion
|
||||
title: ABI-native durable agent workflow test
|
||||
import:
|
||||
workflow: ext/ai/workflow.mq.md
|
||||
json: lib/json.mq.md
|
||||
sys: lib/sys.mq.md
|
||||
time: lib/time.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
Offline test: the same Marqdo program advances through model choice, user
|
||||
input and terminal state with plugin-owned durable checkpoints. The run ID and
|
||||
checkpoint directory include the current millisecond so repeated local runs
|
||||
start clean instead of reopening yesterday's completed workflow.
|
||||
|
||||
**now = > time.now_ms**
|
||||
**stamp = > json.stringify value=`now`**
|
||||
**rid = "abi_flow_ci_" + stamp**
|
||||
**dir = ".marqdo/ai-native-workflow-" + stamp**
|
||||
|
||||
**steps = > json.parse text=[{"id":"intent","kind":"model","prompt":"Choose next skill","options":["chat","office"]},{"id":"confirm","kind":"input","question":"Continue?","options":["yes","no"]},{"id":"end","kind":"return"}]**
|
||||
**opened = > workflow.open id=`rid` steps=`steps` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**o = > json.get value=`opened` key="ok"**
|
||||
1. `o`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=21
|
||||
|
||||
**seen = > workflow.inspect id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**seen_status = > json.get value=`seen` key="action"**
|
||||
**seen_total = > json.get value=`seen` key="total_steps"**
|
||||
1. `seen_status` == "waiting_model"
|
||||
1. `seen_total` == 3
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=30
|
||||
2. *
|
||||
> sys.exit code=31
|
||||
|
||||
**listed = > workflow.list session_id="ci-session" resume_dir=`dir`**
|
||||
**listed_ok = > json.get value=`listed` key="ok"**
|
||||
**listed_items = > json.get value=`listed` key="items"**
|
||||
**listed_n = > len value=`listed_items`**
|
||||
1. `listed_ok`
|
||||
1. `listed_n` > 0
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=32
|
||||
2. *
|
||||
> sys.exit code=33
|
||||
|
||||
**first = > workflow.next id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**first_state = > json.get value=`first` key="status"**
|
||||
1. `first_state` == "waiting_model"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=22
|
||||
|
||||
**c1 = > workflow.commit id=`rid` step_id="intent" response="chat" source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**done1 = > json.get value=`c1` key="ok"**
|
||||
1. `done1`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=23
|
||||
|
||||
**progress = > workflow.inspect id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**progress_done = > json.get value=`progress` key="completed_steps"**
|
||||
1. `progress_done` == 1
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=34
|
||||
|
||||
**second = > workflow.tick id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**second_state = > json.get value=`second` key="status"**
|
||||
1. `second_state` == "waiting_input"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=24
|
||||
|
||||
**c2 = > workflow.commit id=`rid` step_id="confirm" response="yes" source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**done2 = > json.get value=`c2` key="ok"**
|
||||
1. `done2`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=25
|
||||
|
||||
**c3 = > workflow.tick id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**complete = > workflow.next id=`rid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**status = > json.get value=`complete` key="status"**
|
||||
1. `status` == "succeeded"
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=26
|
||||
|
||||
**partial_steps = > json.parse text=[{"id":"children","kind":"parallel","effect_class":"read","tasks":[{"path":"worker-a.mq.md"},{"path":"worker-b.mq.md"}]}]**
|
||||
**prid = "abi_flow_partial_ci_" + stamp**
|
||||
**new_batch = > workflow.open id=`prid` steps=`partial_steps` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**parts = > json.parse text=[{"ok":true,"value":{"code":0,"value":"useful"}},{"ok":false,"error":"timeout"}]**
|
||||
**stopped = > workflow.commit id=`prid` step_id="children" response=`parts` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**reloaded = > workflow.next id=`prid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**partial = > json.get value=`reloaded` key="partial"**
|
||||
**survivors = > json.get value=`partial` key="succeeded"**
|
||||
1. `survivors` == 1
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=27
|
||||
|
||||
**retry_plan = > workflow.retry_plan id=`prid` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**allowed = > json.get value=`retry_plan` key="ok"**
|
||||
1. `allowed`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=28
|
||||
**repaired = > json.parse text=[{"ok":true,"value":{"code":0,"value":"repaired"}}]**
|
||||
**merged = > workflow.retry_commit id=`prid` results=`repaired` source_revision="flow-v1" session_id="ci-session" resume_dir=`dir`**
|
||||
**merged_ok = > json.get value=`merged` key="ok"**
|
||||
1. `merged_ok`
|
||||
**_ = 1**
|
||||
2. *
|
||||
> sys.exit code=29
|
||||
|
||||
Return *"durable-agent-flow-ok"*.
|
||||
@@ -0,0 +1,434 @@
|
||||
//! Knowledge-anchored proof receipts are a *narrow* verified linkage layer.
|
||||
//! No synthetic test here is evidence that Lean proved a statement.
|
||||
|
||||
use std::{fs, path::PathBuf};
|
||||
use marqdo::knowledge::proof::{link_report, index_links};
|
||||
use marqdo::prove::{ClaimReport, FunctionReport, LeanInfo, Report, Tier, Verdict};
|
||||
use marqdo::sema::ir::{compile_project, CompileOptions};
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
fn root(label: &str) -> PathBuf {
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
static SEQ: AtomicU64=AtomicU64::new(0);
|
||||
let dir=std::env::temp_dir().join(format!("mq-proof-links-{}-{}-{}",
|
||||
label,std::process::id(),SEQ.fetch_add(1,Ordering::Relaxed)));
|
||||
fs::create_dir_all(&dir).unwrap();dir
|
||||
}
|
||||
fn sha(bytes:&[u8])->String {format!("{:x}",Sha256::digest(bytes))}
|
||||
fn report(file:&PathBuf, status:Verdict, decided_by:&str, lean:Option<LeanInfo>)->Report {
|
||||
Report {
|
||||
file:"main.mq.md".into(),source_sha256:sha(&fs::read(file).unwrap()),
|
||||
artifact_id:None,status,
|
||||
functions:vec![FunctionReport{
|
||||
name:"main.compute".into(),verdict:status,
|
||||
tier:if lean.is_some(){Tier::Lean}else{Tier::Offline},
|
||||
ops:vec![],rejected:vec![],
|
||||
claims:vec![ClaimReport{
|
||||
id:"rule".into(),premise:None,conclusion:"结果 = 6".into(),
|
||||
tactic:None,status,decided_by:decided_by.into(),
|
||||
source_line:Some(5),evidence:None,
|
||||
}]
|
||||
}],
|
||||
diagnostics:vec![],emitted:vec![],lean,duration_ms:0
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn links_bind_to_exact_owner_and_stale_after_source_change() {
|
||||
let dir=root("stale");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let compiled=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let receipt=link_report(&compiled,&file,&report(&file,Verdict::Checked,"trace",None),&dir);
|
||||
assert_eq!(receipt["claims"][0]["status"],"checked");
|
||||
assert_eq!(receipt["claims"][0]["proof_scope"],"function");
|
||||
assert!(receipt["claims"][0]["owner_symbol_id"].as_str().unwrap().len()>10);
|
||||
assert_eq!(receipt["claims"][0]["certificate_digest"],serde_json::Value::Null);
|
||||
assert_eq!(receipt["claims"][0]["related_anchor_ids"].as_array().unwrap().len(),1);
|
||||
let sidecar=dir.join(".marqdo/prove/one");
|
||||
fs::create_dir_all(&sidecar).unwrap();
|
||||
fs::write(sidecar.join("knowledge-links.json"),serde_json::to_vec(&receipt).unwrap()).unwrap();
|
||||
let current=index_links(&dir.join(".marqdo/prove"),&compiled.semantics);
|
||||
assert_eq!(current["claims"][0]["status"],"checked");
|
||||
assert_eq!(current["claims"][0]["usable"],false);
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n**x = [演算](2 * 4)**\n*x*\n").unwrap();
|
||||
let changed=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let stale=index_links(&dir.join(".marqdo/prove"),&changed.semantics);
|
||||
assert_eq!(stale["claims"][0]["status"],"stale");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overflowing_actual_argument_cannot_be_source_inlined_to_lean_int() {
|
||||
let dir=root("overflow-actual-arg");
|
||||
fs::write(dir.join("numbers.mq.md"),r#"# numbers
|
||||
|
||||
## identity
|
||||
+ `n`
|
||||
|
||||
*`n`*
|
||||
"#).unwrap();
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,r#"---
|
||||
import:
|
||||
numbers: numbers.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| bad | 结果 = 0 | auto |
|
||||
|
||||
**value = [溢出](numbers.numbers.identity(9223372036854775807 + 1))**
|
||||
*value*
|
||||
"#).unwrap();
|
||||
let out=dir.join("prove");
|
||||
let _=marqdo::prove::prove_path(&file,&marqdo::prove::ProveOptions{
|
||||
emit_dir:Some(out.clone()),judge:false,..Default::default()
|
||||
}).unwrap();
|
||||
let plan:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("plan.json")).unwrap()).unwrap();
|
||||
let f=plan["functions"].as_array().unwrap().iter()
|
||||
.find(|x|x["name"]=="main.compute").unwrap();
|
||||
assert!(!f["ops"].as_array().unwrap().is_empty(),
|
||||
"an overflowing actual argument must not be silently turned into Lean Int");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overflowing_imported_arithmetic_cannot_be_source_inlined_to_lean_int() {
|
||||
let dir=root("overflow-import");
|
||||
fs::write(dir.join("numbers.mq.md"),r#"# numbers
|
||||
|
||||
## increment
|
||||
+ `n`
|
||||
|
||||
*`n` + 1*
|
||||
"#).unwrap();
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,r#"---
|
||||
import:
|
||||
numbers: numbers.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| bad | 结果 = 0 | auto |
|
||||
|
||||
**value = [溢出](numbers.numbers.increment(9223372036854775807))**
|
||||
*value*
|
||||
"#).unwrap();
|
||||
let out=dir.join("prove");
|
||||
let _=marqdo::prove::prove_path(&file,&marqdo::prove::ProveOptions{
|
||||
emit_dir:Some(out.clone()),judge:false,..Default::default()
|
||||
}).unwrap();
|
||||
let plan:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("plan.json")).unwrap()).unwrap();
|
||||
let f=plan["functions"].as_array().unwrap().iter()
|
||||
.find(|x|x["name"]=="main.compute").unwrap();
|
||||
assert!(!f["ops"].as_array().unwrap().is_empty(),
|
||||
"i64 overflow must never silently become total unbounded Lean arithmetic");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effectful_import_stays_opaque_in_proof_plan() {
|
||||
let dir=root("effectful-import");
|
||||
fs::write(dir.join("lib.mq.md"),r#"# external
|
||||
|
||||
## lookup
|
||||
|
||||
> print text="side effect"
|
||||
*2*
|
||||
"#).unwrap();
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,r#"---
|
||||
import:
|
||||
lib: lib.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| invariant | 长度(轨迹) = 0 | auto |
|
||||
|
||||
**value = [读取](lib.external.lookup())**
|
||||
*value*
|
||||
"#).unwrap();
|
||||
let out=dir.join("prove");
|
||||
let _=marqdo::prove::prove_path(&file,&marqdo::prove::ProveOptions{
|
||||
emit_dir:Some(out.clone()),judge:false,..Default::default()
|
||||
}).unwrap();
|
||||
let plan:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("plan.json")).unwrap()).unwrap();
|
||||
let f=plan["functions"].as_array().unwrap().iter()
|
||||
.find(|x|x["name"]=="main.compute").unwrap();
|
||||
assert!(!f["ops"].as_array().unwrap().is_empty(),
|
||||
"effectful import must remain an opaque operation and never be source-inlined");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assumption_table_is_in_proof_ir_but_cannot_grant_proved_status() {
|
||||
let dir=root("assumptions");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## call
|
||||
|
||||
| 假设 | 前置 | 后置 |
|
||||
|---|---|---|
|
||||
| provider.lookup | 金额 > 0 | 返回 = 2 |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| no_effect | 长度(轨迹) = 0 | | auto |
|
||||
|
||||
*1*
|
||||
"#).unwrap();
|
||||
let out=dir.join("prove");
|
||||
let report=marqdo::prove::prove_path(&file,
|
||||
&marqdo::prove::ProveOptions{
|
||||
emit_dir:Some(out.clone()),judge:false,..Default::default()
|
||||
}).unwrap();
|
||||
let plan:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("plan.json")).unwrap()).unwrap();
|
||||
let f=plan["functions"].as_array().unwrap().iter()
|
||||
.find(|x|x["name"]=="main.call").unwrap();
|
||||
assert_eq!(f["assumptions"][0]["op"],"provider.lookup");
|
||||
assert_eq!(f["assumptions"][0]["premise"],"金额 > 0");
|
||||
assert_ne!(report.status,Verdict::Proved);
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn modular_assumption_projection_is_never_self_certifying() {
|
||||
let dir=root("assumption-projection");
|
||||
let src=dir.join("main.mq.md");
|
||||
fs::write(&src,r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 假设 | 前置 | 后置 |
|
||||
|---|---|---|
|
||||
| rates.lookup | 金额 > 0 | 返回 = 2 |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| has_result | 结果 = 2 | | auto |
|
||||
|
||||
*2*
|
||||
"#).unwrap();
|
||||
let out=dir.join(".marqdo");
|
||||
marqdo::knowledge::write_knowledge(marqdo::knowledge::KnowledgeOptions{
|
||||
path:dir.clone(),out_dir:out.clone()
|
||||
}).unwrap();
|
||||
let a:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("assumptions.json")).unwrap()).unwrap();
|
||||
assert_eq!(a["assumptions"][0]["operation"],"rates.lookup");
|
||||
assert_eq!(a["assumptions"][0]["verification"],"declared_not_proved");
|
||||
let plan:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("proof-obligations.json")).unwrap()).unwrap();
|
||||
assert_ne!(plan["status"],"proved");
|
||||
assert_eq!(plan["proof_completion"],"not_established_by_dependency_analysis");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strict_modular_cli_exposes_unproved_conditions_as_nonzero_exit() {
|
||||
let dir=root("strict-modular");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| obligation | 结果 = 6 | | auto |\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let output=std::process::Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
||||
.arg("knowledge").arg("proof-deps")
|
||||
.arg(&dir).arg("--json").arg("--strict")
|
||||
.arg("--out").arg(dir.join(".marqdo"))
|
||||
.output().expect("run knowledge proof-deps");
|
||||
assert_eq!(output.status.code(),Some(2),
|
||||
"unproven claims must fail strict audit: stdout={} stderr={}",
|
||||
String::from_utf8_lossy(&output.stdout),
|
||||
String::from_utf8_lossy(&output.stderr));
|
||||
let report:serde_json::Value=serde_json::from_slice(&output.stdout).unwrap();
|
||||
assert_eq!(report["audit_passes"],false);
|
||||
assert_eq!(report["verified_claims"][0]["status"],"unverified");
|
||||
assert_eq!(report["proof_completion"],"not_established_by_dependency_analysis");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn altered_theorem_conclusion_cannot_reuse_a_matching_function_name() {
|
||||
let dir=root("altered-claim");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let c=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let mut fake=report(&file,Verdict::Proved,"lean",None);
|
||||
fake.functions[0].claims[0].conclusion="结果 = 999".into();
|
||||
let linkage=link_report(&c,&file,&fake,&dir);
|
||||
assert!(linkage["claims"].as_array().unwrap().is_empty());
|
||||
assert_eq!(linkage["unresolved"][0]["reason"],"theorem_declaration_missing_or_changed");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dependency_change_invalidates_caller_proof_even_if_caller_source_is_unchanged() {
|
||||
let dir=root("transitive");
|
||||
let lib=dir.join("rates.mq.md");
|
||||
let app=dir.join("main.mq.md");
|
||||
fs::write(&lib,"# rates\n\n## lookup\n\n*2*\n").unwrap();
|
||||
fs::write(&app,r#"---
|
||||
import:
|
||||
rates: rates.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| rule | 结果 = 6 | | auto |
|
||||
|
||||
**tax = [计算税额](rates.rates.lookup())**
|
||||
*tax*
|
||||
"#).unwrap();
|
||||
let before=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let owner=before.semantics.artifacts.iter()
|
||||
.find(|a|a.display_name=="main.compute").unwrap();
|
||||
assert!(!owner.dependencies.is_empty(),
|
||||
"imported call must be a bound dependency; check full class path");
|
||||
let old_closure=owner.hashes.closure.clone();
|
||||
let receipt=link_report(&before,&app,&report(&app,Verdict::Checked,"trace",None),&dir);
|
||||
assert_eq!(receipt["claims"].as_array().unwrap().len(),1,
|
||||
"function identity must resolve exactly");
|
||||
let proof=dir.join(".marqdo/prove/first");
|
||||
fs::create_dir_all(&proof).unwrap();
|
||||
fs::write(proof.join("knowledge-links.json"),
|
||||
serde_json::to_vec(&receipt).unwrap()).unwrap();
|
||||
fs::write(&lib,"# rates\n\n## lookup\n\n*3*\n").unwrap();
|
||||
let after=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let revised=after.semantics.artifacts.iter()
|
||||
.find(|a|a.display_name=="main.compute").unwrap();
|
||||
assert_ne!(old_closure,revised.hashes.closure,
|
||||
"callee implementation changes must invalidate caller closure");
|
||||
let index=index_links(&dir.join(".marqdo/prove"),&after.semantics);
|
||||
assert_eq!(index["claims"][0]["status"],"stale");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn complete_knowledge_publish_contains_anchors_refs_and_proof_receipts() {
|
||||
let dir=root("publish");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n[查看知识](#@演算)\n[查看定理](#@rule)\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let out=dir.join(".marqdo");
|
||||
marqdo::knowledge::write_knowledge(marqdo::knowledge::KnowledgeOptions{
|
||||
path:dir.clone(),out_dir:out.clone()
|
||||
}).unwrap();
|
||||
let anchors:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("anchors.json")).unwrap()).unwrap();
|
||||
assert_eq!(anchors["anchors"].as_array().unwrap().len(),1);
|
||||
let refs:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("refs.json")).unwrap()).unwrap();
|
||||
assert!(refs["refs"].as_array().unwrap().iter()
|
||||
.any(|r|r["label"]=="查看知识" && r["resolution"]=="anchor"));
|
||||
let claims:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("claims.json")).unwrap()).unwrap();
|
||||
assert_eq!(claims["claims"].as_array().unwrap().len(),1);
|
||||
assert_eq!(claims["claims"][0]["verification"],"declared_unverified");
|
||||
assert!(refs["refs"].as_array().unwrap().iter()
|
||||
.any(|r|r["label"]=="查看定理" && r["resolution"]=="claim"));
|
||||
let index:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("proof-index.json")).unwrap()).unwrap();
|
||||
assert_eq!(index["claims"].as_array().unwrap().len(),0);
|
||||
let generated=fs::read_to_string(out.join("CURRENT")).unwrap();
|
||||
assert!(out.join("generations").join(generated.trim())
|
||||
.join("anchors.json").is_file());
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fake_lean_status_with_no_matching_certificate_cannot_be_proved() {
|
||||
let dir=root("forge");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let compiled=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let lean=LeanInfo{
|
||||
toolchain:"Lean 4.35".into(),library_sha256:"lib".into(),
|
||||
module_sha256:"module".into(),cache:"miss"
|
||||
};
|
||||
let receipt=link_report(&compiled,&file,
|
||||
&report(&file,Verdict::Proved,"lean",Some(lean)),&dir);
|
||||
assert_eq!(receipt["claims"][0]["status"],"unverified");
|
||||
assert_eq!(receipt["claims"][0]["certificate_digest"],serde_json::Value::Null);
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real_prove_pipeline_emits_function_bound_knowledge_sidecar_without_lean() {
|
||||
let dir=root("pipeline");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| 无外部操作 | 长度(轨迹) = 0 | | auto |
|
||||
|
||||
**x = [演算](2 * 3)**
|
||||
*x*
|
||||
"#).unwrap();
|
||||
let out=dir.join(".marqdo/prove/manual");
|
||||
let opts=marqdo::prove::ProveOptions {
|
||||
emit_dir:Some(out.clone()),judge:false,..Default::default()
|
||||
};
|
||||
let report=marqdo::prove::prove_path(&file,&opts).unwrap();
|
||||
assert!(report.functions.iter().any(|f|!f.claims.is_empty()));
|
||||
let linkage:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(out.join("knowledge-links.json")).unwrap()).unwrap();
|
||||
assert_eq!(linkage["schema_version"],1);
|
||||
assert_eq!(linkage["claims"][0]["claim_id"],"无外部操作");
|
||||
assert_eq!(linkage["claims"][0]["proof_scope"],"function");
|
||||
assert_ne!(linkage["claims"][0]["status"],"proved");
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stale_duplicate_claims_are_never_selected_by_position() {
|
||||
let dir=root("duplicate");
|
||||
let file=dir.join("main.mq.md");
|
||||
fs::write(&file,"# main\n\n## compute\n\n| 定理 | 结论 | 前提 | 策略 |\n|---|---|---|---|\n| rule | 结果 = 6 | | auto |\n\n**x = [演算](2 * 3)**\n*x*\n").unwrap();
|
||||
let compiled=compile_project(&CompileOptions::for_path(&dir).unwrap()).unwrap();
|
||||
let receipt=link_report(&compiled,&file,&report(&file,Verdict::Checked,"trace",None),&dir);
|
||||
for name in ["a","b"] {
|
||||
let out=dir.join(".marqdo/prove").join(name);
|
||||
fs::create_dir_all(&out).unwrap();
|
||||
fs::write(out.join("knowledge-links.json"),serde_json::to_vec(&receipt).unwrap()).unwrap();
|
||||
}
|
||||
let index=index_links(&dir.join(".marqdo/prove"),&compiled.semantics);
|
||||
assert_eq!(index["claims"][0]["status"],"ambiguous");
|
||||
assert_eq!(index["claims"][1]["status"],"ambiguous");
|
||||
assert_eq!(index["claims"][0]["usable"],false);
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
@@ -226,6 +226,712 @@ fn g1_cache_hit_skips_judging() {
|
||||
let _ = fs::remove_file(&log);
|
||||
}
|
||||
|
||||
/// Source-transparent, leaf-pure imported call is verified with real Lean.
|
||||
#[test]
|
||||
fn modular_pure_leaf_import_proved_by_real_lean() {
|
||||
if !toolchain_available() {
|
||||
skip_or_fail("modular_pure_leaf_import_proved_by_real_lean");
|
||||
return;
|
||||
}
|
||||
let scratch=Scratch::new("modular-pure-import");
|
||||
scratch.write("rates.mq.md",r#"# rates
|
||||
|
||||
## lookup
|
||||
|
||||
*2*
|
||||
"#);
|
||||
scratch.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
rates: rates.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| 返回值正确 | 结果 = 2 | auto |
|
||||
|
||||
**tax = [查询](rates.rates.lookup())**
|
||||
*tax*
|
||||
"#);
|
||||
let out=scratch.marqdo().args(["prove","main.mq.md","--json"]).output()
|
||||
.expect("prove pure imported leaf");
|
||||
let result:serde_json::Value=serde_json::from_slice(&out.stdout)
|
||||
.unwrap_or_else(|_| panic!("stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
String::from_utf8_lossy(&out.stdout)));
|
||||
assert_eq!(result["status"],"proved",
|
||||
"imported pure leaf must be proved by real Lean: {result}");
|
||||
let ops=&result["functions"][0]["ops"];
|
||||
assert!(ops.as_array().is_some_and(|a|a.is_empty()),
|
||||
"pure leaf import cannot be treated as an opaque environment op: {ops}");
|
||||
}
|
||||
|
||||
/// Pure cross-module parameter substitution is checked by real Lean, not JSON status.
|
||||
#[test]
|
||||
fn modular_pure_leaf_import_with_argument_proved_by_real_lean(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("modular_pure_leaf_import_with_argument_proved_by_real_lean");
|
||||
return;
|
||||
}
|
||||
let scratch=Scratch::new("modular-parameterized");
|
||||
scratch.write("numbers.mq.md",r#"# numbers
|
||||
|
||||
## increment
|
||||
+ `n`
|
||||
|
||||
*`n` + 1*
|
||||
"#);
|
||||
scratch.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
numbers: numbers.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## compute
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| 参数绑定正确 | 结果 = 4 | auto |
|
||||
|
||||
**value = [加一](numbers.numbers.increment(3))**
|
||||
*value*
|
||||
"#);
|
||||
let out=scratch.marqdo().args(["prove","main.mq.md","--json"])
|
||||
.output().expect("prove imported parameterized leaf");
|
||||
let json:serde_json::Value=serde_json::from_slice(&out.stdout)
|
||||
.unwrap_or_else(|_|panic!("stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
String::from_utf8_lossy(&out.stdout)));
|
||||
assert_eq!(json["status"],"proved",
|
||||
"parameter substitution across file boundary must be Lean proved: {json}");
|
||||
}
|
||||
|
||||
/// Real inter-module certificate + closed actual-argument bridge, checked by
|
||||
/// a second Lean invocation. Graph status is not itself a caller theorem.
|
||||
#[test]
|
||||
fn modular_closed_callsite_proof_uses_real_lean_kernel(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("modular_closed_callsite_proof_uses_real_lean_kernel");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("modular-closed-vc");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# math
|
||||
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| constant | 结果 = 2 | n > 0 | auto |
|
||||
|
||||
*2*
|
||||
"#);
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## caller
|
||||
|
||||
**x = [获得数字](math.math.exact(3))**
|
||||
*x*
|
||||
"#);
|
||||
let proof=s.marqdo().args(["prove","math.mq.md","--json"])
|
||||
.output().expect("prove imported contract");
|
||||
assert!(proof.status.success(),
|
||||
"callee proof failed: {}",String::from_utf8_lossy(&proof.stdout));
|
||||
let result=s.marqdo().args([
|
||||
"knowledge","proof-deps","--verify","--json","."
|
||||
]).output().expect("verify modular goals");
|
||||
let json:serde_json::Value=serde_json::from_slice(&result.stdout)
|
||||
.unwrap_or_else(|_|panic!("{}",
|
||||
String::from_utf8_lossy(&result.stderr)));
|
||||
assert_eq!(json["lean_preconditions_verified"],1,
|
||||
"no kernel checked callsite: {json}");
|
||||
assert!(json["lean_receipts_replayed"].as_u64().unwrap_or(0)>=1,
|
||||
"callee theorem must be replayed by Lean, not trusted from JSON: {json}");
|
||||
let call=json["obligations"].as_array().unwrap().iter()
|
||||
.find(|o|o["call_site"]=="math.math.exact").unwrap();
|
||||
assert_eq!(call["contracts"][0]["call_precondition_status"],"lean_kernel_verified");
|
||||
assert_eq!(call["contracts"][0]["status"],"available_as_contract");
|
||||
assert_eq!(json["proof_completion"],"not_established_by_dependency_analysis");
|
||||
assert!(s.dir.join(".marqdo/modular/closed-goals.lean").exists());
|
||||
// A proved callee cannot authorize a call with an invalid actual.
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## caller
|
||||
|
||||
**x = [无效调用](math.math.exact(0))**
|
||||
*x*
|
||||
"#);
|
||||
let invalid=s.marqdo().args([
|
||||
"knowledge","proof-deps","--verify","--json","--strict","."
|
||||
]).output().expect("reject false contract premise");
|
||||
assert_eq!(invalid.status.code(),Some(2),
|
||||
"false instantiated precondition must fail closed");
|
||||
let denied:serde_json::Value=serde_json::from_slice(&invalid.stdout).unwrap();
|
||||
assert_eq!(denied["lean_preconditions_verified"],0);
|
||||
assert!(denied["obligations"].as_array().unwrap().iter()
|
||||
.any(|o|o["contracts"].as_array().is_some_and(|contracts|
|
||||
contracts.iter().any(|c|
|
||||
c["call_precondition_status"]=="refuted_closed_precondition"))));
|
||||
}
|
||||
|
||||
/// Two independent Lean modules: the caller imports only the proved callee
|
||||
/// theorem. The certificate explicitly limits its scope to pure Int forwarders.
|
||||
#[test]
|
||||
fn composition_emits_independently_replayable_caller_certificate(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("composition_emits_independently_replayable_caller_certificate");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("composed-replay-int");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# math
|
||||
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| fixed | 结果 = 2 | auto |
|
||||
|
||||
*2*
|
||||
"#);
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## forward
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| same | 结果 = 2 | auto |
|
||||
|
||||
**v = [调用](math.math.exact(`n`))**
|
||||
*v*
|
||||
"#);
|
||||
let result=s.marqdo().args([
|
||||
"knowledge","compose","--strict","--json","."
|
||||
]).output().expect("compose independent theorem");
|
||||
assert_eq!(result.status.code(),Some(0),
|
||||
"stderr={} stdout={}",String::from_utf8_lossy(&result.stderr),
|
||||
String::from_utf8_lossy(&result.stdout));
|
||||
let json:serde_json::Value=serde_json::from_slice(&result.stdout).unwrap();
|
||||
let successful=json["results"].as_array().unwrap().iter()
|
||||
.find(|row|row["status"]=="lean_kernel_proved_model")
|
||||
.expect("independent callee+caller proof");
|
||||
let file=std::path::PathBuf::from(successful["artifact"].as_str().unwrap());
|
||||
let receipt:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(s.dir.join(file)).unwrap()).unwrap();
|
||||
assert_eq!(receipt["scope"],
|
||||
"number_contract_int_model_pure_forwarder_constant_result");
|
||||
assert_eq!(receipt["full_marqdo_runtime_semantics_proved"],
|
||||
serde_json::Value::Null);
|
||||
let folder=s.dir.join(successful["artifact"].as_str().unwrap())
|
||||
.parent().unwrap().to_path_buf();
|
||||
let caller=fs::read_to_string(folder.join("CallerModule.lean")).unwrap();
|
||||
assert!(caller.contains("import CalleeModule"));
|
||||
assert!(caller.contains("using (callee_contract"));
|
||||
assert!(!caller.contains("sorry"));
|
||||
// Replay is tied to currently compiled Marqdo source, not just a copied
|
||||
// certificate or an arbitrary Lean theorem with the same display name.
|
||||
let cert=successful["artifact"].as_str().unwrap();
|
||||
let replay=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("independent proof replay");
|
||||
assert!(replay.status.success(),
|
||||
"replay stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&replay.stderr),
|
||||
String::from_utf8_lossy(&replay.stdout));
|
||||
let verified:serde_json::Value=serde_json::from_slice(&replay.stdout).unwrap();
|
||||
assert_eq!(verified["status"],"lean_kernel_replayed");
|
||||
assert_eq!(verified["full_marqdo_runtime_semantics_proved"],false);
|
||||
|
||||
let original=fs::read_to_string(s.dir.join("math.mq.md")).unwrap();
|
||||
fs::write(s.dir.join("math.mq.md"),original.replace("*2*","*3*")).unwrap();
|
||||
let changed=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("reject stale source");
|
||||
assert!(!changed.status.success(),
|
||||
"old composed proof must not survive callee source change");
|
||||
}
|
||||
|
||||
/// Projection of an imported symbolic parameter is proved in two distinct
|
||||
/// Lean modules. The caller imports ONLY the callee theorem and its interface.
|
||||
#[test]
|
||||
fn projection_composition_proves_symbolic_caller_and_replays_from_source(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("projection_composition_proves_symbolic_caller_and_replays_from_source");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("composed-replay-projection");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
# math
|
||||
|
||||
## identity
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| exact | 结果 = n | auto |
|
||||
|
||||
*`n`*
|
||||
"#);
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
# main
|
||||
|
||||
## forward
|
||||
+ `input`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| input | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| forwarded | 结果 = input | auto |
|
||||
|
||||
**value = [调用](math.math.identity(`input`))**
|
||||
*value*
|
||||
"#);
|
||||
let out=s.marqdo().args(["knowledge","compose","--strict","--json","."])
|
||||
.output().expect("compose symbolic projection");
|
||||
assert!(out.status.success(),"stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
String::from_utf8_lossy(&out.stdout));
|
||||
let json:serde_json::Value=serde_json::from_slice(&out.stdout).unwrap();
|
||||
let proved=json["results"].as_array().unwrap().iter()
|
||||
.find(|r|r["status"]=="lean_kernel_proved_model"&&
|
||||
r["scope"]=="number_contract_int_model_pure_forwarder_parameter_projection")
|
||||
.unwrap_or_else(||panic!("missing parameterized caller theorem: {json}"));
|
||||
let cert=proved["artifact"].as_str().unwrap();
|
||||
let dir=s.dir.join(cert).parent().unwrap().to_path_buf();
|
||||
let caller=fs::read_to_string(dir.join("CallerModule.lean")).unwrap();
|
||||
let callee=fs::read_to_string(dir.join("CalleeModule.lean")).unwrap();
|
||||
assert!(callee.contains("callee_contract"));
|
||||
assert!(caller.contains("import CalleeModule"));
|
||||
assert!(caller.contains("using (callee_contract"));
|
||||
assert!(caller.contains("= v0"),"caller conclusion must be symbolic");
|
||||
assert!(!caller.contains("sorry"));
|
||||
let replay=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("replay parameterized theorem");
|
||||
assert!(replay.status.success(),"{} {}",
|
||||
String::from_utf8_lossy(&replay.stdout),
|
||||
String::from_utf8_lossy(&replay.stderr));
|
||||
let report:serde_json::Value=serde_json::from_slice(&replay.stdout).unwrap();
|
||||
assert_eq!(report["status"],"lean_kernel_replayed");
|
||||
assert_eq!(report["full_marqdo_runtime_semantics_proved"],false);
|
||||
let original=fs::read_to_string(s.dir.join("math.mq.md")).unwrap();
|
||||
fs::write(s.dir.join("math.mq.md"),original.replace("*`n`*","*0*")).unwrap();
|
||||
let stale=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("replay changed projection");
|
||||
assert!(!stale.status.success(),"modified callee cannot retain proof");
|
||||
fs::write(s.dir.join("math.mq.md"),original).unwrap();
|
||||
let main=fs::read_to_string(s.dir.join("main.mq.md")).unwrap();
|
||||
fs::write(s.dir.join("main.mq.md"),
|
||||
main.replace("结果 = input","结果 = 999")).unwrap();
|
||||
let invalid=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("replay changed caller claim");
|
||||
assert!(!invalid.status.success(),"unsupported caller conclusion cannot inherit proof");
|
||||
}
|
||||
|
||||
/// A source-derived arithmetic theorem is imported by a caller without
|
||||
/// inlining the callee body. False or stale contracts never become axioms.
|
||||
#[test]
|
||||
fn pure_expression_composition_proves_and_replays_real_lean(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("pure_expression_composition_proves_and_replays_real_lean");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("composed-pure-expr");
|
||||
let callee=r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
# math
|
||||
## increment
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| plus | 结果 = n + 1 | auto |
|
||||
|
||||
*`n` + 1*
|
||||
"#;
|
||||
s.write("math.mq.md",callee);
|
||||
let caller=r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
# main
|
||||
## forward
|
||||
+ `input`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| input | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| inc | 结果 = input + 1 | auto |
|
||||
|
||||
**v = [递增](math.math.increment(`input`))**
|
||||
*v*
|
||||
"#;
|
||||
s.write("main.mq.md",caller);
|
||||
let out=s.marqdo().args(["knowledge","compose","--strict","--json","."])
|
||||
.output().expect("compose pure expression");
|
||||
assert!(out.status.success(),"{} {}",
|
||||
String::from_utf8_lossy(&out.stdout),
|
||||
String::from_utf8_lossy(&out.stderr));
|
||||
let report:serde_json::Value=serde_json::from_slice(&out.stdout).unwrap();
|
||||
let proved=report["results"].as_array().unwrap().iter().find(|r|
|
||||
r["scope"]=="number_contract_int_model_pure_expression_forwarder"
|
||||
&&r["status"]=="lean_kernel_proved_model")
|
||||
.unwrap_or_else(||panic!("no checked arithmetic composition: {report}"));
|
||||
let cert=proved["artifact"].as_str().unwrap();
|
||||
let dir=s.dir.join(cert).parent().unwrap().to_path_buf();
|
||||
let callee_lean=fs::read_to_string(dir.join("CalleeModule.lean")).unwrap();
|
||||
let caller_lean=fs::read_to_string(dir.join("CallerModule.lean")).unwrap();
|
||||
assert!(callee_lean.contains("(v0 + (1 : Int))"));
|
||||
assert!(caller_lean.starts_with("import CalleeModule"));
|
||||
assert!(caller_lean.contains("using (callee_contract"));
|
||||
assert!(!caller_lean.contains("sorry"));
|
||||
let replay=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("replay arithmetic certificate");
|
||||
assert!(replay.status.success(),"{} {}",
|
||||
String::from_utf8_lossy(&replay.stdout),
|
||||
String::from_utf8_lossy(&replay.stderr));
|
||||
let record:serde_json::Value=serde_json::from_slice(&replay.stdout).unwrap();
|
||||
assert_eq!(record["status"],"lean_kernel_replayed");
|
||||
assert_eq!(record["full_marqdo_runtime_semantics_proved"],false);
|
||||
s.write("math.mq.md",&callee.replace("结果 = n + 1","结果 = n + 2"));
|
||||
let stale=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("reject forged arithmetic contract");
|
||||
assert!(!stale.status.success(),"changed theorem declaration cannot be replayed");
|
||||
s.write("math.mq.md",callee);
|
||||
s.write("main.mq.md",&caller.replace("结果 = input + 1",
|
||||
"结果 = input + 2"));
|
||||
let false_caller=s.marqdo().args(["knowledge","replay",cert,"--json","."])
|
||||
.output().expect("reject false caller claim");
|
||||
assert!(!false_caller.status.success(),"caller mismatch cannot inherit callee proof");
|
||||
}
|
||||
|
||||
/// A stronger symbolic branch guard implies the callee requires clause in
|
||||
/// the Lean Int model. It does NOT prove dynamic Marqdo Number semantics.
|
||||
#[test]
|
||||
fn symbolic_path_implication_uses_real_lean_without_runtime_promotion() {
|
||||
if !toolchain_available() {
|
||||
skip_or_fail("symbolic_path_implication_uses_real_lean_without_runtime_promotion");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("modular-symbolic-omega");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
|
||||
# math
|
||||
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| constant | 结果 = 2 | n > 0 | auto |
|
||||
|
||||
*2*
|
||||
"#);
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
## guarded
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
1. `n` > 10
|
||||
**x = [带条件调用](math.math.exact(`n`))**
|
||||
2. *
|
||||
**x = 0**
|
||||
|
||||
*x*
|
||||
"#);
|
||||
let proof=s.marqdo().args(["prove","math.mq.md","--json"])
|
||||
.output().expect("prove callee first");
|
||||
assert!(proof.status.success(),
|
||||
"callee must be proved: {}",String::from_utf8_lossy(&proof.stdout));
|
||||
let out=s.marqdo().args([
|
||||
"knowledge","proof-deps","--verify","--json","."
|
||||
]).output().expect("prove conditional Int path");
|
||||
let json:serde_json::Value=serde_json::from_slice(&out.stdout)
|
||||
.unwrap_or_else(|_|panic!("stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&out.stderr),
|
||||
String::from_utf8_lossy(&out.stdout)));
|
||||
assert!(json["symbolic_path_lean_model_proved"].as_u64().unwrap_or(0)>=1,
|
||||
"Lean must discharge n > 10 entails n > 0: {json}");
|
||||
assert_eq!(json["symbolic_proof_scope"],
|
||||
"integer_path_model_not_runtime_equivalence");
|
||||
assert_eq!(json["proof_completion"],
|
||||
"not_established_by_dependency_analysis");
|
||||
}
|
||||
|
||||
/// An arithmetic source guard is instantiated at a symbolic call site,
|
||||
/// then Lean proves the linear implication (never runtime Number equivalence).
|
||||
#[test]
|
||||
fn arithmetic_symbolic_path_implication_uses_real_lean(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("arithmetic_symbolic_path_implication_uses_real_lean");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("symbolic-linear-path");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
# math
|
||||
## exact
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 前提 | 策略 |
|
||||
|---|---|---|---|
|
||||
| constant | 结果 = 2 | n > 0 | auto |
|
||||
|
||||
*2*
|
||||
"#);
|
||||
s.write("main.mq.md",r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
# main
|
||||
## guarded
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
1. `n` + 5 > 10
|
||||
**x = [条件调用](math.math.exact(`n`))**
|
||||
2. *
|
||||
**x = 0**
|
||||
|
||||
*x*
|
||||
"#);
|
||||
let callee=s.marqdo().args(["prove","math.mq.md","--json"])
|
||||
.output().expect("verify source callee");
|
||||
assert!(callee.status.success(),
|
||||
"callee proof must precede callsite discharge: {}",
|
||||
String::from_utf8_lossy(&callee.stdout));
|
||||
let audit=s.marqdo().args(["knowledge","proof-deps","--verify","--json","."])
|
||||
.output().expect("verify symbolic linear path");
|
||||
let json:serde_json::Value=serde_json::from_slice(&audit.stdout)
|
||||
.unwrap_or_else(|_|panic!("stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&audit.stderr),
|
||||
String::from_utf8_lossy(&audit.stdout)));
|
||||
assert!(json["symbolic_path_lean_model_proved"].as_u64().unwrap_or(0)>=1,
|
||||
"n + 5 > 10 must imply n > 0 in kernel-checked Int model: {json}");
|
||||
assert_eq!(json["symbolic_proof_scope"],
|
||||
"integer_path_model_not_runtime_equivalence");
|
||||
assert_eq!(json["proof_completion"],
|
||||
"not_established_by_dependency_analysis");
|
||||
}
|
||||
|
||||
/// One proof pipeline for three transitive modules, two sequential calls,
|
||||
/// an exhaustive branch, and a caller inequality claim. No callee source is
|
||||
/// inlined into the importing Lean module; every module has its own theorem.
|
||||
#[test]
|
||||
fn unified_modular_contract_proves_multicall_branch_and_transitive_dag(){
|
||||
if !toolchain_available(){
|
||||
skip_or_fail("unified_modular_contract_proves_multicall_branch_and_transitive_dag");
|
||||
return;
|
||||
}
|
||||
let s=Scratch::new("unified-contract-three-module");
|
||||
s.write("math.mq.md",r#"---
|
||||
markup: occlusion
|
||||
---
|
||||
# math
|
||||
|
||||
## increment
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| increment_post | 结果 = n + 1 | auto |
|
||||
|
||||
*`n` + 1*
|
||||
"#);
|
||||
let ops=r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
---
|
||||
# ops
|
||||
|
||||
## twice
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| twice_post | 结果 = n + 2 | auto |
|
||||
|
||||
**a = [第一次](math.math.increment(`n`))**
|
||||
**b = [第二次](math.math.increment(`a`))**
|
||||
*b*
|
||||
"#;
|
||||
s.write("ops.mq.md",ops);
|
||||
let main=r#"---
|
||||
markup: occlusion
|
||||
import:
|
||||
math: math.mq.md
|
||||
ops: ops.mq.md
|
||||
---
|
||||
# main
|
||||
|
||||
## guarded
|
||||
+ `n`
|
||||
|
||||
| 参数 | 类型 | 说明 |
|
||||
|---|---|---|
|
||||
| n | int | integer |
|
||||
|
||||
| 定理 | 结论 | 策略 |
|
||||
|---|---|---|
|
||||
| result_floor | 结果 ≥ 1 | auto |
|
||||
|
||||
1. `n` > 0
|
||||
**x = [调用复合模块](ops.ops.twice(`n`))**
|
||||
*x*
|
||||
2. *
|
||||
**y = [调用叶模块](math.math.increment(0))**
|
||||
*y*
|
||||
"#;
|
||||
s.write("main.mq.md",main);
|
||||
let output=s.marqdo().args(["knowledge","compose","--strict","--json","."])
|
||||
.output().expect("compose uniform DAG");
|
||||
assert!(output.status.success(),"stderr={} stdout={}",
|
||||
String::from_utf8_lossy(&output.stderr),
|
||||
String::from_utf8_lossy(&output.stdout));
|
||||
let report:serde_json::Value=serde_json::from_slice(&output.stdout).unwrap();
|
||||
let record=report["results"].as_array().unwrap().iter().find(|row|
|
||||
row["scope"]=="pure_number_int_model_sequential_branch_dag"
|
||||
&&row["status"]=="lean_kernel_proved_model"
|
||||
&&row["evidence"]["grade"]=="model_proved"
|
||||
&&row["artifact"].as_str().is_some_and(|p|{
|
||||
let path=s.dir.join(p);
|
||||
let cert:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(path).unwrap_or_default()).unwrap_or_default();
|
||||
cert["modules"].as_array().is_some_and(|nodes|nodes.len()==3)
|
||||
})).unwrap_or_else(||panic!("three-module caller theorem not proved: {report}"));
|
||||
let certificate=record["artifact"].as_str().unwrap();
|
||||
let folder=s.dir.join(certificate).parent().unwrap().to_path_buf();
|
||||
let receipt:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(s.dir.join(certificate)).unwrap()).unwrap();
|
||||
let modules=receipt["modules"].as_array().unwrap();
|
||||
assert_eq!(modules.len(),3);
|
||||
let caller_name=modules[2]["module"].as_str().unwrap();
|
||||
let caller=fs::read_to_string(folder.join(format!("{caller_name}.lean"))).unwrap();
|
||||
assert!(caller.contains("import M"));
|
||||
assert!(caller.contains("have hc"));
|
||||
assert!(caller.contains("by_cases"));
|
||||
assert!(!caller.contains("sorry"));
|
||||
assert_eq!(receipt["full_marqdo_runtime_semantics_proved"],false);
|
||||
let replay=s.marqdo().args(["knowledge","replay",certificate,"--json","."])
|
||||
.output().expect("replay unified proof");
|
||||
assert!(replay.status.success(),"stdout={} stderr={}",
|
||||
String::from_utf8_lossy(&replay.stdout),
|
||||
String::from_utf8_lossy(&replay.stderr));
|
||||
let replayed:serde_json::Value=serde_json::from_slice(&replay.stdout).unwrap();
|
||||
assert_eq!(replayed["status"],"lean_kernel_replayed");
|
||||
assert_eq!(replayed["evidence"]["grade"],"model_proved");
|
||||
|
||||
s.write("ops.mq.md",&ops.replace("结果 = n + 2","结果 = n + 3"));
|
||||
let stale=s.marqdo().args(["knowledge","replay",certificate,"--json","."])
|
||||
.output().expect("reject changed intermediate proof contract");
|
||||
assert!(!stale.status.success(),"stale transitive dependency must fail");
|
||||
|
||||
s.write("ops.mq.md",ops);
|
||||
s.write("main.mq.md",&main.replace("结果 ≥ 1","结果 ≥ 100"));
|
||||
let wrong=s.marqdo().args(["knowledge","compose","--strict","--json","."])
|
||||
.output().expect("reject invalid caller theorem");
|
||||
let output_json:serde_json::Value=serde_json::from_slice(&wrong.stdout)
|
||||
.unwrap_or_default();
|
||||
assert!(!output_json["results"].as_array().into_iter().flat_map(|a|a.iter())
|
||||
.any(|r|r["scope"]=="pure_number_int_model_sequential_branch_dag"
|
||||
&&r["status"]=="lean_kernel_proved_model"
|
||||
&&r["identity"]==receipt["identity"]));
|
||||
}
|
||||
|
||||
/// G2:真证书命中(用真 lean 跑一次后,证书生效;第二次 cache: hit 且快)。
|
||||
#[test]
|
||||
fn g2_certificate_hit_after_real_run() {
|
||||
@@ -241,6 +947,24 @@ fn g2_certificate_hit_after_real_run() {
|
||||
let json: serde_json::Value = serde_json::from_slice(&out.stdout).expect("json");
|
||||
assert_eq!(json["status"], "proved", "真定理必须 proved:{json}");
|
||||
assert_eq!(json["lean"]["cache"], "miss");
|
||||
let proof_id = json["artifact_id"].as_str().unwrap().rsplit('/').next().unwrap();
|
||||
let link_path = s.dir.join(".marqdo/prove").join(proof_id).join("knowledge-links.json");
|
||||
let linkage: serde_json::Value = serde_json::from_slice(
|
||||
&fs::read(&link_path).expect("real Lean proof must emit a knowledge linkage"))
|
||||
.expect("knowledge linkage JSON");
|
||||
assert_eq!(linkage["claims"][0]["status"], "proved",
|
||||
"only verified Lean receipts should carry proved: {linkage}");
|
||||
assert_eq!(linkage["claims"][0]["proof_scope"], "function");
|
||||
assert!(linkage["claims"][0]["certificate_digest"].as_str().is_some());
|
||||
let publish=s.marqdo().args([
|
||||
"knowledge","台账.mq.md","--out",".marqdo"
|
||||
]).output().expect("publish verified knowledge");
|
||||
assert!(publish.status.success(),"knowledge compile failed: {}",
|
||||
String::from_utf8_lossy(&publish.stderr));
|
||||
let proof_index: serde_json::Value = serde_json::from_slice(
|
||||
&fs::read(s.dir.join(".marqdo/proof-index.json")).unwrap()).unwrap();
|
||||
assert_eq!(proof_index["claims"][0]["status"],"proved");
|
||||
assert_eq!(proof_index["claims"][0]["usable"],true);
|
||||
|
||||
// 第二次:命中证书。
|
||||
let out2 = s.marqdo().arg("prove").arg("台账.mq.md").arg("--json").output().expect("second prove");
|
||||
@@ -248,6 +972,23 @@ fn g2_certificate_hit_after_real_run() {
|
||||
assert_eq!(json2["status"], "proved");
|
||||
assert_eq!(json2["lean"]["cache"], "hit", "第二次必须命中证书缓存");
|
||||
assert!(json2["duration_ms"].as_u64().unwrap() < 5000, "命中后必须快");
|
||||
|
||||
// Even a genuine local certificate ceases to be usable if the generated
|
||||
// Lean source has been edited; a matching JSON hash is not enough.
|
||||
let generated=s.dir.join(".marqdo/prove").join(proof_id).join("Generated");
|
||||
let lean_file=fs::read_dir(&generated).unwrap().map(|e|e.unwrap().path())
|
||||
.find(|p|p.extension().is_some_and(|ext|ext=="lean")).unwrap();
|
||||
let mut modified=fs::read_to_string(&lean_file).unwrap();
|
||||
modified.push_str("\n-- local tampering\n");
|
||||
fs::write(&lean_file,modified).unwrap();
|
||||
let republish=s.marqdo().args([
|
||||
"knowledge","台账.mq.md","--out",".marqdo"
|
||||
]).output().unwrap();
|
||||
assert!(republish.status.success(),"{}",String::from_utf8_lossy(&republish.stderr));
|
||||
let stale:serde_json::Value=serde_json::from_slice(
|
||||
&fs::read(s.dir.join(".marqdo/proof-index.json")).unwrap()).unwrap();
|
||||
assert_eq!(stale["claims"][0]["usable"],false,
|
||||
"modified generated module cannot reuse genuine Lean receipt: {stale}");
|
||||
}
|
||||
|
||||
/// G2b:--no-cache 绕过证书。
|
||||
|
||||
Reference in new issue
Block a user