"""模块依赖行为验证。

保护：安装产物边界与依赖方向——业务只经公共接口、Skill 不携带实现、
接入不直写表、共享基础不反向依赖业务、装配层不承载创作规则。

已实现子集：
- 安装包在任意 cwd 可导入且导入不产生外部连接（含旧树同名包遮挡守卫）；
- 技能目录不注入 sys.path、不携带实现脚本；
- src/muse 活跃运行代码不依赖外部专有 CLI；
- 共享基础类型不导入业务模块；__main__ 只是薄命令入口。

依赖后续扩展的用例（宿主适配、协议、角色路由、旧库参数守卫、
技能目录合同）落地后逐例实现，不以形状检查代替。
"""

from __future__ import annotations

import ast
import json
import re
import shlex
import subprocess
import sys
from importlib.util import resolve_name
from pathlib import Path

import pytest
import yaml

import muse

仓库根 = Path(__file__).resolve().parents[2]
源码根 = 仓库根 / "src" / "muse"


def _遍历py(根: Path) -> list[Path]:
    return sorted(p for p in 根.rglob("*.py") if "__pycache__" not in p.parts)


def _导入名(文件: Path) -> set[str]:
    """AST 提取文件内全部 import 的顶层模块名。"""
    树 = ast.parse(文件.read_text(encoding="utf-8"))
    名单: set[str] = set()
    for 节点 in ast.walk(树):
        if isinstance(节点, ast.Import):
            for 别名 in 节点.names:
                名单.add(别名.name.split(".")[0])
        elif isinstance(节点, ast.ImportFrom) and 节点.module and 节点.level == 0:
            名单.add(节点.module.split(".")[0])
    return 名单


@pytest.mark.case_id(
    "TC-f4e7a41421c5",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_skills_do_not_syspath_into_shared_implementations__f4e7a4() -> None:
    """技能目录支持自包含独立辅助脚本，禁止向 sys.path 注入或反向导入业务实现。"""
    技能根 = 仓库根 / ".agent" / "skills"
    for p in 技能根.rglob("*.py"):
        if "__pycache__" in p.parts:
            continue
        文本 = p.read_text(encoding="utf-8")
        assert "sys.path" not in 文本, f"技能脚本出现 sys.path 注入：{p.relative_to(仓库根)}"
        assert "import muse" not in 文本 and "from muse" not in 文本, (
            f"技能脚本反向依赖业务单体：{p.relative_to(仓库根)}"
        )
    for md in 技能根.rglob("*.md"):
        文本 = md.read_text(encoding="utf-8")
        assert "sys.path" not in 文本, f"技能文档出现 sys.path 注入：{md.relative_to(仓库根)}"


def _字符串常量(文件: Path) -> list[str]:
    """AST 提取全部字符串常量，排除模块/类/函数 docstring。"""
    树 = ast.parse(文件.read_text(encoding="utf-8"))
    文档: set[int] = set()
    for 节点 in ast.walk(树):
        if isinstance(节点, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
            主体 = 节点.body
            if 主体 and isinstance(主体[0], ast.Expr) and isinstance(主体[0].value, ast.Constant):
                文档.add(id(主体[0].value))
    return [
        节点.value
        for 节点 in ast.walk(树)
        if isinstance(节点, ast.Constant) and isinstance(节点.value, str) and id(节点) not in 文档
    ]


@pytest.mark.case_id(
    "TC-ba6ad5c41f3c",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_dashboard_does_not_import_skills__ba6ad5() -> None:
    """src/muse 不以代码依赖 .agent 技能目录（文档中的合同引用不算依赖）。"""
    for 文件 in _遍历py(源码根):
        for 值 in _字符串常量(文件):
            assert ".agent" not in 值, f"源码以路径方式引用 .agent：{文件.relative_to(仓库根)}"
            assert "skills/" not in 值, f"源码引用技能路径：{文件.relative_to(仓库根)}"


@pytest.mark.case_id(
    "TC-1ec1b5f35798",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_active_runtime_has_no_claude_cli_dependency__1ec1b5() -> None:
    """活跃运行代码不依赖专有外部 CLI（claude/dsh 等）；子进程只允许工程工具。"""
    for 文件 in _遍历py(源码根):
        assert not _子进程违规(文件.read_text()), str(文件.relative_to(仓库根))


def _导入全名(代码: str, 模块: str) -> list[tuple[int, str]]:
    包 = 模块.rsplit(".", 1)[0]
    结果 = []
    for 节点 in ast.walk(ast.parse(代码)):
        if isinstance(节点, ast.Import):
            结果.extend((节点.lineno, 别名.name) for 别名 in 节点.names)
        elif isinstance(节点, ast.ImportFrom):
            来源 = 节点.module or ""
            if 节点.level:
                来源 = resolve_name("." * 节点.level + 来源, 包)
            结果.extend((节点.lineno, f"{来源}.{别名.name}") for 别名 in 节点.names)
    return 结果


def _子进程违规(代码: str) -> list[str]:
    """识别子进程 API 的导入别名及静态命令；不会执行被扫描文件。"""
    树 = ast.parse(代码)
    别名, 赋值 = {}, {}
    for 节点 in ast.walk(树):
        if isinstance(节点, ast.Import):
            for 项 in 节点.names:
                别名[项.asname or 项.name.split(".")[0]] = (
                    项.name if 项.asname else 项.name.split(".")[0]
                )
        elif isinstance(节点, ast.ImportFrom):
            for 项 in 节点.names:
                别名[项.asname or 项.name] = f"{节点.module}.{项.name}"
        elif isinstance(节点, ast.Assign):
            for 目标 in 节点.targets:
                if isinstance(目标, ast.Name):
                    赋值[目标.id] = 节点.value

    def 全名(节点, 已见=frozenset()):
        if isinstance(节点, ast.Name):
            if 节点.id in 赋值 and 节点.id not in 已见:
                return 全名(赋值[节点.id], 已见 | {节点.id})
            return 别名.get(节点.id, 节点.id)
        if isinstance(节点, ast.Attribute):
            return 全名(节点.value, 已见) + "." + 节点.attr
        return ""

    def 首项(节点, 已见=frozenset()):
        if isinstance(节点, ast.Name) and 节点.id in 赋值 and 节点.id not in 已见:
            return 首项(赋值[节点.id], 已见 | {节点.id})
        if isinstance(节点, (ast.List, ast.Tuple)):
            return 首项(节点.elts[0], 已见) if 节点.elts else None
        if isinstance(节点, ast.Constant) and isinstance(节点.value, str):
            return 节点.value
        if isinstance(节点, ast.BinOp) and isinstance(节点.op, ast.Add):
            左, 右 = 首项(节点.left, 已见), 首项(节点.right, 已见)
            return 左 + 右 if 左 is not None and 右 is not None else None
        return None

    API = {f"subprocess.{名}" for 名 in ("run", "Popen", "call", "check_call", "check_output")}
    API |= {"asyncio.create_subprocess_exec", "asyncio.create_subprocess_shell"}
    错误 = []
    for 节点 in ast.walk(树):
        if not isinstance(节点, ast.Call) or 全名(节点.func) not in API:
            continue
        参数 = (
            节点.args[0]
            if 节点.args
            else next((k.value for k in 节点.keywords if k.arg in {"args", "program", "cmd"}), None)
        )
        命令 = 首项(参数)
        if 命令:
            单词 = shlex.split(命令)
            if 单词 and Path(单词[0]).name.startswith(("claude", "dsh")):
                错误.append(f"{节点.lineno}: 禁止专有CLI {Path(单词[0]).name}")
    return 错误


@pytest.mark.case_id(
    "NC-o04-subprocess-ast-forms",
    environment="离线，临时Python源文件",
    given="子进程run/Popen/异步创建及导入和赋值别名",
    when="静态检查禁止CLI的同一命令，不执行临时源",
    then=["直接调用、别名、异步及静态拼接均拒绝，合法工具不误报"],
)
@pytest.mark.parametrize(
    "代码",
    [
        "import subprocess; subprocess.run(['claude','-p'])",
        "import subprocess as p; p.Popen(('dsh','x'))",
        "from subprocess import run as launch; launch(args=['claude'])",
        "from subprocess import Popen as launch; launch(['/bin/claude'])",
        "import asyncio as a\nasync def f():\n await a.create_subprocess_exec('claude','-p')",
        "from asyncio import create_subprocess_exec as launch\n"
        "async def f():\n await launch('dsh')",
        "import subprocess as p; command=['clau'+'de']; launch=p.run; launch(command)",
    ],
    ids=[
        "run",
        "popen-alias",
        "run-import",
        "popen-import",
        "async-alias",
        "async-import",
        "assigned-command",
    ],
)
def test_子进程检查识别别名与异步(tmp_path, 代码):
    文件 = tmp_path / "反例.py"
    文件.write_text(代码)
    assert _子进程违规(文件.read_text())
    assert not _子进程违规("import subprocess; subprocess.run(['git', 'status'])")
    assert not _子进程违规("class X: pass\nx=X(); x.run(['claude'])")


@pytest.mark.case_id(
    "TC-5d7edda75476",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_runtime_does_not_import_muse_business__5d7edd() -> None:
    """共享纯基础不反向导入业务；启动装配可以绑定具体实现。"""
    业务模块 = {
        "作品规划",
        "故事世界",
        "资料研究",
        "知识方法",
        "正文写作",
        "审校修订",
        "作者经验",
        "交付连载",
        "上下文",
        "效果评测",
    }
    基础文件 = list((源码根 / "共享").glob("*.py")) + [
        源码根 / "配置.py",
        源码根 / "资源加载.py",
    ]
    assert 基础文件, "共享与装配文件缺失"
    for 文件 in 基础文件:
        模块 = "muse." + ".".join(文件.relative_to(源码根).with_suffix("").parts)
        for _, 导入 in _导入全名(文件.read_text(), 模块):
            部分 = 导入.split(".")
            assert not (len(部分) > 1 and 部分[0] == "muse" and 部分[1] in 业务模块), (
                f"基础层导入业务模块：{文件.relative_to(仓库根)} -> {导入}"
            )


@pytest.mark.case_id(
    "TC-b141f1313b72",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_dispatch_agent_task_is_thin_cli__b141f1() -> None:
    """python -m muse 是薄入口：只做参数解析与转交，无业务逻辑与连接。"""
    文件 = 源码根 / "__main__.py"
    文本 = 文件.read_text(encoding="utf-8")
    导入 = _导入名(文件)
    assert 导入 <= {"__future__", "argparse", "sys", "pathlib", "muse"}, 导入
    for 禁止 in ("socket", "psycopg", "http", "urllib", "subprocess"):
        assert 禁止 not in 文本, f"命令入口包含 {禁止}"


# ---------------------------------------------------------------------------
# 安装与导入边界
# ---------------------------------------------------------------------------


@pytest.mark.case_id(
    "NC-import-any-cwd-offline",
    environment="离线，安装包与子进程",
    given="已安装的 muse 包与任意非仓库工作目录",
    when="在 / 目录下用安装的解释器导入 muse 全部顶层模块",
    then=["导入成功且期间任何 socket 连接尝试都会失败", "版本号与包身份一致"],
    contract="docs/系统架构/新版设计/文件设计/工程配置与部署.md",
)
def test_import_from_any_cwd_without_external_connections__e0a1b2() -> None:
    """任意 cwd 导入 muse 全部顶层模块且不产生任何 socket 连接（安装验收）。"""
    代码 = (
        "import socket\n"
        "def _拒绝(self, 地址):\n"
        "    raise AssertionError(f'导入期间尝试连接 {地址}')\n"
        "socket.socket.connect = _拒绝\n"
        "import muse, muse.启动, muse.配置, muse.资源加载, muse.共享\n"
        "print(muse.__version__)\n"
    )
    进程 = subprocess.run(
        [sys.executable, "-c", 代码], cwd="/", capture_output=True, text=True, timeout=60
    )
    assert 进程.returncode == 0, 进程.stderr
    assert 进程.stdout.strip() == muse.__version__


@pytest.mark.case_id(
    "NC-import-not-shadowed",
    environment="离线，安装包与子进程",
    given="仓库根存在旧实现目录 muse/ 与已安装的 src 布局新包",
    when="在仓库根解释器导入 muse",
    then=["muse.__file__ 解析到 src/muse，不被旧树同名目录遮挡"],
    contract="docs/系统架构/新版设计/文件设计/工程配置与部署.md",
)
def test_import_resolves_to_new_package_not_old_tree__c1d2e3() -> None:
    """import muse 解析到 src/muse 安装包，不被旧树同名目录遮挡。"""
    代码 = "import muse\nprint(muse.__file__)\n"
    进程 = subprocess.run(
        [sys.executable, "-c", 代码],
        cwd=仓库根,
        capture_output=True,
        text=True,
        timeout=60,
    )
    assert 进程.returncode == 0, 进程.stderr
    assert "src/muse" in 进程.stdout, 进程.stdout


def _跨域导入(代码: str, 模块: str, 业务模块: set[str]) -> list[str]:
    """解析绝对/相对以及模块别名导入；装配入口由调用者单独排除。"""
    本域 = 模块.split(".")[1]
    错误 = []
    for 行, 导入 in _导入全名(代码, 模块):
        部分 = 导入.split(".")
        if len(部分) < 2 or 部分[0] != "muse" or 部分[1] == 本域:
            continue
        if 部分[1] in 业务模块 and (len(部分) < 3 or 部分[2] != "接口"):
            错误.append(f"{行}: {导入}")
        if 本域 in 业务模块 and 部分[1] in {"编排", "接入"}:
            错误.append(f"{行}: 业务反向依赖 {导入}")
    return 错误


@pytest.mark.case_id(
    "NC-w20-20d01a",
    environment="离线，真实源码与AST语法反例",
    given="实际源码树和各业务接口",
    when="扫描跨域依赖、存储导出及编排/接入游标调用",
    then=["跨模块只经公开接口，不反向依赖编排；不公开内部存储；编排和接入不操作私表"],
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_跨模块仅经公共用例且编排不操作私表__20d01a() -> None:
    """公共类型与用例可导出；存储不能伪装成公开用例，接入/编排不能直写表。"""
    业务模块 = {p.parent.name for p in 源码根.glob("*/接口.py")} - {"编排", "接入"}
    违规 = []
    for 文件 in _遍历py(源码根):
        相对 = 文件.relative_to(源码根)
        if len(相对.parts) < 2:
            continue  # 启动.py 负责选择具体实现，根部共享边界由独立规则保护。
        模块 = "muse." + ".".join(相对.with_suffix("").parts)
        代码 = 文件.read_text(encoding="utf-8")
        违规.extend(f"{相对}:{项}" for 项 in _跨域导入(代码, 模块, 业务模块))
        树 = ast.parse(代码)
        if 相对.parts[0] in {"编排", "接入"}:
            for 节点 in ast.walk(树):
                if isinstance(节点, ast.Call) and isinstance(节点.func, ast.Attribute):
                    if 节点.func.attr in {"execute", "executemany", "cursor"}:
                        违规.append(f"{相对}:{节点.lineno}: 接入/编排不能使用数据库游标")
        if 文件.name == "接口.py":
            存储符号 = {
                项.asname or 项.name
                for 节点 in ast.walk(树)
                if isinstance(节点, ast.ImportFrom) and (节点.module or "").endswith(".存储")
                for 项 in 节点.names
            }
            for 节点 in 树.body:
                if isinstance(节点, ast.Assign) and any(
                    isinstance(目标, ast.Name) and 目标.id == "__all__" for 目标 in 节点.targets
                ):
                    泄露 = 存储符号 & set(ast.literal_eval(节点.value))
                    if 泄露:
                        违规.append(f"{相对}: 不能公开内部存储 {sorted(泄露)}")
    assert not 违规, "\n".join(违规)


@pytest.mark.case_id(
    "NC-w20-20d02b",
    environment="离线，真实源码与AST语法反例",
    given="绝对、相对、模块别名和分层from导入变体",
    when="对合法公共用例和非法私有依赖进行同一检查",
    then=["私有依赖的变体一律拒绝，合法公开用例与本域内部导入不误报"],
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_公共边界检查识别别名和相对导入__20d02b() -> None:
    """同一非法依赖的语法变体必须一致拒绝，合法公开入口与本域内部导入不误报。"""
    业务 = {"正文写作", "任务运行"}
    for 代码 in (
        "from muse.任务运行.模型 import 任务请求",
        "import muse.任务运行.存储 as 别名",
        "from ..任务运行.存储 import 任务存储",
        "from muse.任务运行 import 存储",
        "from muse import 任务运行",
        "from muse.编排.生成正文 import 发起生成正文",
    ):
        assert _跨域导入(代码, "muse.正文写作.接口", 业务), 代码
    for 代码 in (
        "from muse.任务运行.接口 import 任务请求",
        "from ..任务运行.接口 import 任务请求",
        "from muse.任务运行 import 接口",
        "import muse.任务运行.接口 as 任务",
        "from .存储 import 正文存储",
    ):
        assert not _跨域导入(代码, "muse.正文写作.接口", 业务), 代码


@pytest.mark.case_id(
    "NC-o04-dependency-fullnames",
    environment="离线AST依赖合同",
    given="深层相对导入、import别名、基础设施依赖公共业务类型",
    when="按模块依赖规则解析完整来源；共享禁止反向，基础设施允许公共接口",
    then=["真实模块全名不因别名或相对层级丢失", "基础设施只禁私有依赖，不增加无依据禁区"],
)
def test_依赖解析保留全名与批准的基础设施边界():
    assert _导入全名("from ...任务运行 import 存储 as s", "muse.正文写作.子包.服务") == [
        (1, "muse.任务运行.存储")
    ]
    assert _导入全名("import muse.任务运行.接口 as task", "muse.共享.辅助") == [
        (1, "muse.任务运行.接口")
    ]
    业务 = {"任务运行", "资料研究"}
    for 代码 in ("from muse.任务运行.接口 import 模型请求", "from muse.资料研究 import 接口"):
        assert not _跨域导入(代码, "muse.基础设施.模型.客户端", 业务)
    assert _跨域导入("from muse.任务运行 import 存储", "muse.基础设施.模型.客户端", 业务)


# ---------------------------------------------------------------------------
# 作者自然语言入口与角色路由合同（原 AuthorInstructionContractTest）
# ---------------------------------------------------------------------------

作者根 = 仓库根 / ".agent" / "作者"
场景根 = 作者根 / "场景"
标准索引表头 = (
    "| 名称 | 相对地址 | 内容描述 | 使用场景 | 使用要求 |\n"
    "|------|----------|----------|----------|----------|"
)
场景清单 = ("定故事", "排故事", "塑人物", "写下一章", "改正文", "查作品")
技能链接 = re.compile(r"\[([^\]\n]+)\]\(([^)\n]+/SKILL\.md)\)")
frontmatter名称 = re.compile(r"^name:\s*(.+?)\s*$", re.MULTILINE)
# 已有新版实现并登记进运行资源包的技能：场景路由必须指向新版路径，不再回到旧 muse 树。
已替代技能 = {
    "完善故事基础设定": ".agent/skills/操作/完善故事基础设定/SKILL.md",
    "决定正文候选去留": ".agent/skills/操作/决定正文候选去留/SKILL.md",
    "确认规划候选": ".agent/skills/操作/确认规划候选/SKILL.md",
}
退役技能别名 = {
    "生成下一章",
    "局部重写",
    "场景扩写",
    "正文润色",
    "作品定盘",
    "全书规划",
    "章级细纲",
    "全书解析",
    "章后抽取",
    "一致性检测",
    "质量评分",
}


def _章节(文本: str, 标题: str) -> str:
    匹配 = re.search(
        rf"^## {re.escape(标题)}\s*$\n(?P<正文>.*?)(?=^## |\Z)",
        文本,
        flags=re.MULTILINE | re.DOTALL,
    )
    assert 匹配 is not None, f"缺少章节：## {标题}"
    return 匹配.group("正文")


@pytest.mark.case_id(
    "TC-41d4cbb084d0",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_author_layer_has_discoverable_structure__41d4cb() -> None:
    """作者层文件完整且各级索引可发现；路由不依赖技能自动发现。"""
    期望 = {
        作者根 / "目录.md",
        作者根 / "指令.md",
        作者根 / "原生中文写作.md",
        场景根 / "目录.md",
        *(场景根 / f"{名称}.md" for 名称 in 场景清单),
    }
    缺失 = sorted(str(p.relative_to(仓库根)) for p in 期望 if not p.is_file())
    assert 缺失 == [], "作者指令层文件不完整：\n" + "\n".join(缺失)

    根索引 = (仓库根 / ".agent" / "目录.md").read_text(encoding="utf-8")
    项目入口 = (仓库根 / "AGENTS.md").read_text(encoding="utf-8")
    作者索引 = (作者根 / "目录.md").read_text(encoding="utf-8")
    场景索引 = (场景根 / "目录.md").read_text(encoding="utf-8")
    # 目录文件可携带导航元信息注记(父级目录派生行所需),表头从注记之后起算。
    作者索引 = re.sub(r"\A(?:<!-- 导航元信息: .*? -->\n)+", "", 作者索引)
    场景索引 = re.sub(r"\A(?:<!-- 导航元信息: .*? -->\n)+", "", 场景索引)
    assert "作者/目录.md" in 根索引
    assert ".agent/作者/指令.md" in 项目入口
    assert 作者索引.startswith(标准索引表头)
    assert 场景索引.startswith(标准索引表头)
    assert "[指令.md](指令.md)" in 作者索引
    assert "[原生中文写作.md](原生中文写作.md)" in 作者索引
    assert "[目录.md](场景/目录.md)" in 作者索引
    for 场景 in 场景清单:
        assert f"[{场景}.md]({场景}.md)" in 场景索引


@pytest.mark.case_id(
    "TC-5e199d285247",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_scenes_route_only_to_registered_chinese_skills__5e199d() -> None:
    """场景路由只指向真实存在且 frontmatter 名称一致的技能；已替代技能不再路由旧实现。"""
    登记能力 = {
        Path(条目).as_posix()
        for 条目 in json.loads((仓库根 / "工具" / "资源登记.json").read_text(encoding="utf-8"))[
            "能力文件"
        ]
    }
    for 场景 in 场景清单:
        源 = 场景根 / f"{场景}.md"
        路由章节 = _章节(源.read_text(encoding="utf-8"), "正式技能")
        for 标签, 原目标 in 技能链接.findall(路由章节):
            目标 = (源.parent / 原目标).resolve()
            assert 目标.is_file(), f"{源}: 技能链接不存在：{原目标}"
            匹配 = frontmatter名称.search(目标.read_text(encoding="utf-8"))
            assert 匹配 is not None, f"{目标}: 缺少 frontmatter name"
            assert 标签 == 匹配.group(1).strip(), f"{源}: 链接文字必须使用正式技能名"
            相对 = 目标.relative_to(仓库根).as_posix()
            if 标签 in 已替代技能:
                assert 相对 == 已替代技能[标签], (
                    f"{源}: {标签} 已有新版实现，应路由 {已替代技能[标签]} 而不是 {相对}"
                )
            文本 = 目标.read_text(encoding="utf-8")
            声明 = yaml.safe_load(文本.split("---", 2)[1]) if 文本.startswith("---\n") else {}
            if 声明.get("category") == "operation":
                assert 相对 in 登记能力, f"{源}: 未登记的运行操作技能：{相对}"
            assert 标签 not in 退役技能别名
    # 作者层不是技能：不得出现作者入口冒充技能登记。
    assert all(Path(路径).name != "目录.md" for 路径 in 登记能力)


@pytest.mark.case_id(
    "TC-7239c72475e5",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_interaction_and_native_chinese_contracts_are_complete__7239c7() -> None:
    """交互边界与原生中文写作合同的关键短语在作者层保持完整。"""
    入口 = (作者根 / "指令.md").read_text(encoding="utf-8")
    for 必含 in (
        "一轮只问一个关键问题",
        "二至三个中文选项",
        "采用",
        "修改",
        "丢弃",
        "Shadow",
        "Canonical",
        "只给正文",
        "主会话不代替角色",
    ):
        assert 必含 in 入口, f"作者指令缺少交互合同短语：{必含}"

    写作 = (作者根 / "原生中文写作.md").read_text(encoding="utf-8")
    for 必含 in (
        "中文语序",
        "具体名词、动作和关系优先",
        "作者声音、叙述者声音和角色声音",
        "不得凭空增加",
        "润色不得偷改情节事实",
        "扩写不得新开场景或改变落点",
        "重写不得越过作者指定范围",
        "精确诊断",
    ):
        assert 必含 in 写作, f"原生中文写作合同缺少：{必含}"

    诊断场景 = (场景根 / "查作品.md").read_text(encoding="utf-8")
    修改场景 = (场景根 / "改正文.md").read_text(encoding="utf-8")
    assert "只查不改" in 诊断场景
    assert "作者指定范围" in 修改场景


@pytest.mark.case_id(
    "TC-4bead8f3ebfb",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_role_prompts_route_with_registered_skill_names__4bead8() -> None:
    """五个角色文件与角色合同一致并登记进运行资源包；角色层不使用退役技能别名。"""
    登记 = json.loads((仓库根 / "工具" / "资源登记.json").read_text(encoding="utf-8"))
    能力 = set(登记["能力文件"])
    角色合同 = {
        "writer": "写手",
        "planner": "规划员",
        "extractor": "知识抽取员",
        "detector": "检测员",
        "judge": "评委",
    }
    for 角色ID, 名称 in 角色合同.items():
        相对 = f".agent/角色/{名称}.md"
        assert 相对 in 能力, f"角色未登记进运行资源包：{相对}"
        文本 = (仓库根 / 相对).read_text(encoding="utf-8")
        头部 = 文本.split("---")[1]
        assert f"id: {角色ID}" in 头部
        assert f"name: {名称}" in 头部
        assert "contract_version:" in 头部
        for 别名 in 退役技能别名:
            assert f"`{别名}`" not in 文本, f"{相对}: 角色文件引用退役技能别名 {别名}"


@pytest.mark.case_id(
    "TC-9c16ccc98756",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
@pytest.mark.安装包
def test_装配与结构入口在任意cwd解析安装产物__9c16cc() -> None:
    """按新版装配与结构入口验证安装产物；不固定旧 framework/runtime 目录或仓根层数。

    旧三类 Studio 接入的可加载性由完整安装包业务入口验收承接；本用例只验证
    当期装配入口、结构入口与任意 cwd 的安装产物可解析，不宣称未实现的 owner 已接通。
    """
    代码 = (
        "import socket\n"
        "def _拒绝(self, 地址):\n"
        "    raise AssertionError(f'入口解析期间尝试连接 {地址}')\n"
        "socket.socket.connect = _拒绝\n"
        "from muse.启动 import 应用装配, 构建\n"
        "from muse.资源加载 import 加载清单, 核对资源\n"
        "清单 = 加载清单()\n"
        "assert 清单['发布身份'] and 清单['构建身份']\n"
        "assert 核对资源()['构建身份'] == 清单['构建身份']\n"
        "print(清单['发布身份'])\n"
    )
    进程 = subprocess.run(
        [sys.executable, "-c", 代码], cwd="/", capture_output=True, text=True, timeout=60
    )
    assert 进程.returncode == 0, 进程.stderr
    assert 进程.stdout.strip()


@pytest.mark.case_id(
    "TC-254d1ec59a42",
    environment="离线，安装包与导入图",
    when="在无旧源码路径的环境装配模块并核对依赖。",
    contract="docs/系统架构/新版设计/总体架构.md",
)
def test_声音归属不重复经B06合同拒绝__254d1e() -> None:
    """角色级“同时归属”不再由旧账本校验：B06 声音请求合同拒绝该输入。"""
    import pytest
    from pydantic import ValidationError

    from muse.审校修订.接口 import 声音提案请求, 声音样张引用

    样张 = 声音样张引用("document", "chapter-1", 1, "a" * 64, "main")
    with pytest.raises(ValidationError):
        声音提案请求(
            "synthetic:demo",
            0,
            "voice",
            1,
            {"叙事": "冷峻"},
            (样张,),
            characters={"甲": ["嗯"], "乙": ["嗯"]},
        )
    with pytest.raises(ValidationError):
        声音提案请求(
            "synthetic:demo",
            0,
            "voice",
            1,
            {"叙事": "冷峻"},
            (样张,),
            untouchable_verbal_tics={"甲": ["嗯"], "乙": ["嗯"]},
        )