已删除的清单照样被物化 + 容量/空闲口径读错，而自述报告/健康检查/退出码全绿（Python 集合运算漏减移除项 · 契约口径 vs 本地默认值 · 空判据表假绿）

SCHED_ENABLED_MANIFEST=/srv/conf/enabled.txt
SCHED_MATERIALIZE_ROOT=/srv/work
SCHED_MATERIALIZE_IDLE_EXIT_S=300      # 空闲多久就退出（不是占用过期）
SCHED_MAX_INFLIGHT=11                  # 一套集合可容纳的份数上限
SCHED_HOLD_MAX_S=3600                  # 一份占用的持有时长上限
SCHED_DISABLED_POLICY=block            # stale 必须先挡住

启用清单：m-alpha / m-beta / m-removed
本轮动作：{"op":"add","name":"m-gamma"}、{"op":"remove","name":"m-removed"}
本轮占用：{"manifest":"m-beta","release_after_s":3600,"generation":41}

集合 = 启用清单 ∪ 本次新增 − 本次移除     （被移除的清单不再属于集合）

$ bash ops/repro.sh
{"counts": {"block": 0, "materialize": 4, "total": 4}, "inflight": 1,
 "lease_s": 180, "max": 2, "ok": true, "root": "/srv/state/work"}
scheduler rc=0
健康检查：{"degraded": false, "engine": "materialize-scheduler", "issues": []}   health rc=0

不一致：集合构成：期望 ['m-alpha', 'm-beta', 'm-gamma'] 实际 ['m-alpha', 'm-beta', 'm-removed', 'm-gamma']
不一致：m-beta：期望占用代数 41 实际 1
不一致：root：期望 '/srv/work' 实际 '/srv/state/work'
不一致：lease_s：期望 300 实际 180
不一致：max：期望 11 实际 2
不一致：汇总 counts.total：期望 3 实际 4
不一致：汇总 counts.materialize：期望 3 实际 4
RESULT: BAD（不一致 7 条）     rc=1

"lease_matches_contract": short["idle_s"] == conf.get("SCHED_HOLD_MAX_S")

cd scenario/2026-10-14-1600
docker compose up -d --build
docker compose exec -T scheduler bash

cd /srv
bash ops/repro.sh ; echo "rc=$?"     # -> RESULT: BAD（不一致 7 条），rc=1（预期的复现信号）
bash ops/verify.sh ; echo "rc=$?"    # -> PASS=6 FAIL=19 / RESULT: BAD
python3 client/scheduler_probe.py    # -> RESULT: BAD，rc=1

== A 组：根目录 / 空闲退出必须逐字等于契约（不许本地兜底） ==
  [FAIL] A1 root：期望 /srv/work 实际 /srv/state/work
  [FAIL] A2 lease_s：期望 300 实际 180
== B 组：容量口径是「一套集合的上限」，不是逐个清单的并行度 ==
  [FAIL] B1 max：期望 11 实际 2
== C 组：集合构成 = 启用清单 ∪ 新增 − 移除（题眼） ==
  [FAIL] C1 集合构成：期望 m-alpha,m-beta,m-gamma 实际 m-alpha,m-beta,m-removed,m-gamma
== D 组：stale 必须按禁用策略挡住（题眼） ==
  [FAIL] D1 m-removed 不在计划里：期望 <missing> 实际 materialize
== E 组：占用代数必须与持有者登记的一致（题眼） ==
  [FAIL] E2 m-beta 占用代数：期望 41 实际 1
== G 组：健康检查必须有牙（判不了 != 没问题） ==
  [FAIL] G2 契约不可用 health 退出码：期望 3 实际 0
  [FAIL] G3 拿不到报告 health 退出码：期望 2 实际 0
PASS=6 FAIL=19

# 问题态
for name in list(self.enabled) + list(self.added) + list(self.removed):

# 问题态
def normalize(hold):
    return {"release_after_s": int(hold["release_after_s"]),
            "generation": _next_generation()}      # 自增计数器

_counter = {"n": 0}
def _next_generation():
    _counter["n"] += 1
    return _counter["n"]

# 问题态
LOCAL_DEFAULTS = {"output_root": "/srv/state/work", "lease_seconds": 180,
                  "max_parallel": 2, "disabled_policy": "keep"}

def load_config():
    return dict(LOCAL_DEFAULTS)      # 不接收契约、不校验、不覆盖

# 问题态
if local["disabled_policy"] == "block":     # local 来自写死的 "keep"

# 问题态
BAD_FIELDS = ()        # 空元组

for key in BAD_FIELDS:              # 一次都不循环
    if not report.get(key):
        issues.append(...)

except (OSError, json.JSONDecodeError):
    print(...); return EXIT_OK       # 读不到报告也算健康

return EXIT_OK                      # 无条件

def all(self):
    removed = set(self.removed)
    out = []
    for name in list(self.enabled) + list(self.added):
        if name in removed:
            continue
        if name not in out:
            out.append(name)
    return out

def normalize(hold):
    if not hold:
        return None
    return {"release_after_s": int(hold["release_after_s"]),
            "generation": int(hold["generation"])}     # 原样登记

def load_config(conf):
    if not conf.get("contract_available"):
        raise RuntimeError("契约不可用：拒绝在猜出来的口径下物化")
    return {
        "output_root": conf["materialize_root"],
        "idle_exit_s": conf["materialize_idle_exit_s"],   # 空闲退出
        "max_per_set": conf["max_inflight"],              # 一套集合的上限
        "disabled_policy": conf["disabled_policy"],
    }

local = config.load_config(conf)
names = mset.all()
over_capacity = len(names) > local["max_per_set"]
...
if name in mset.stale_removed() and local["disabled_policy"] == "block":
    row.update(verdict="block", reason="disabled_stale"); rows.append(row); continue
...
if over_capacity:                       # 容量是「一套集合」的上限 → 整轮失败
    for row in rows:
        row.update(verdict="block", reason="inflight_over_capacity")

local = config.load_config(conf)        # 契约不可用 → RuntimeError
...
"lease_matches_contract": short["idle_s"] == conf["materialize_idle_exit_s"],   # 不是 hold_max_s
...
def main():
    try:
        report = run()
    except RuntimeError as exc:
        print(json.dumps({"contract_available": False, "ok": False, "error": str(exc)},
                         ensure_ascii=False, sort_keys=True))
        return EXIT_CONTRACT            # 3

docker compose exec -T scheduler bash -c 'cd /srv && bash ops/repro.sh; echo "rc=$?"'

{"counts": {"block": 0, "materialize": 3, "total": 3}, "inflight": 1,
 "lease_s": 300, "max": 11, "ok": true, "root": "/srv/work"}
scheduler rc=0
健康检查：{"block": 0, "contract_available": true, "degraded": false, "issues": [],
           "lease_s": 300, "max_inflight": 11, "root": "/srv/work", "set_size": 3,
           "stale": ["m-removed"], "total": 3}
health rc=0
清单集合（按契约）：['m-alpha', 'm-beta', 'm-gamma']
RESULT: OK
probe rc=0
repro rc=0

PASS=25 FAIL=0
RESULT: OK

docker compose exec -T scheduler bash -c 'cd /srv && bash ops/negative.sh'

== N1：被移除的重新留在集合里 → 探针 rc=1（转红）、health rc=2
== N2：占用代数改成自编号     → 探针 rc=1（转红）
== N3：容量按「集合 × 并行度」 → 探针 rc=1（转红）
== N4：root 回退本地默认值     → 探针 rc=1（转红）
== N5：自述被篡改 counts.total=999 → health rc=2（有牙）
== N6：判据表挖空 + 退出码恒 0 → 对坏数据仍 rc=0（实证假绿）
== N7：契约不可用 → health rc=3、scheduler rc=3
== N8：契约口径非法（loose）  → health rc=3
负向验证：13 PASS / 0 FAIL
RESULT: OK（闸门有牙）