foxclaw 0.1.0 → 0.1.3

package/python/tests/test_skills_fetch.py

@@ -0,0 +1,282 @@
+"""`foxclaw skills install` 的来源解析与落地。
+
+全部离线:远端用 monkeypatch 替掉 `_http_get`,不打真网 —— 否则 CI 会因 ClawHub
+抖动而红,这类测试一旦不稳就会被跳过,等于没测。
+"""
+from __future__ import annotations
+
+import io
+import json
+import tarfile
+import zipfile
+
+import pytest
+
+from foxclaw.skills import fetch as fetch_mod
+from foxclaw.skills.archive import PackageError, has_code, read_package
+
+MD = "---\nname: Demo Skill\ndescription: 演示用技能\nversion: 1.2.3\n---\n\n正文指示"
+
+
+def _zip(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        for name, body in files.items():
+            z.writestr(name, body)
+    return buf.getvalue()
+
+
+def _tgz(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as t:
+        for name, text in files.items():
+            raw = text.encode("utf-8")
+            info = tarfile.TarInfo(name)
+            info.size = len(raw)
+            t.addfile(info, io.BytesIO(raw))
+    return buf.getvalue()
+
+
+def _mock_http(monkeypatch, routes: dict) -> None:
+    def fake(url: str, timeout: float = 25.0, max_bytes: int = 10 * 1024 * 1024):
+        for key, val in routes.items():
+            if key in url:
+                return val
+        raise PackageError(f"测试未配置这条路由: {url}")
+
+    monkeypatch.setattr(fetch_mod, "_http_get", fake)
+
+
+def test_read_zip_root_skill_md():
+    pkg = read_package(_zip({"SKILL.md": MD, "_meta.json": '{"slug": "demo"}'}))
+    assert pkg["skill_md"] == MD
+    assert pkg["meta"]["slug"] == "demo"
+
+
+def test_read_targz_picks_shallowest():
+    pkg = read_package(_tgz({
+        "repo-abc/SKILL.md": MD,
+        "repo-abc/docs/SKILL.md": "更深的同名副本应被忽略",
+    }))
+    assert pkg["skill_md"] == MD
+
+
+def test_read_package_rejects_traversal():
+    with pytest.raises(PackageError):
+        read_package(_zip({"../evil/SKILL.md": MD}))
+
+
+def test_read_package_without_skill_md():
+    with pytest.raises(PackageError, match="未找到 SKILL.md"):
+        read_package(_zip({"README.md": "nothing here"}))
+
+
+def test_subpath_narrows_search():
+    with pytest.raises(PackageError):
+        read_package(_tgz({"repo/a/SKILL.md": MD}), subpath="other")
+
+
+def test_has_code_detects_scripts():
+    assert has_code(["SKILL.md", "scripts/run.py"])
+    assert has_code(["SKILL.md", "tool.sh"])
+    assert not has_code(["SKILL.md", "skill-card.md"])
+
+
+def test_ref_routes_scoped_name_to_clawhub(monkeypatch):
+    seen: dict = {}
+
+    def fake(owner, slug, timeout):
+        seen["id"] = (owner, slug)
+        return fetch_mod.SkillPackage(skill_md=MD, source="clawhub", origin="x")
+
+    monkeypatch.setattr(fetch_mod, "_from_clawhub", fake)
+    assert fetch_mod.fetch("@snowfox/demo").origin == "x"
+    assert seen["id"] == ("snowfox", "demo")
+    fetch_mod.fetch("snowfox/demo")
+    assert seen["id"] == ("snowfox", "demo")
+
+
+def test_unknown_ref_rejected():
+    with pytest.raises(PackageError, match="无法识别"):
+        fetch_mod.fetch("no-such-thing-xyz")
+
+
+def test_local_dir_reads_skill_md(tmp_path):
+    (tmp_path / "SKILL.md").write_text(MD, encoding="utf-8")
+    pkg = fetch_mod.fetch(str(tmp_path))
+    assert pkg.source == "local"
+    assert "演示用技能" in pkg.skill_md
+
+
+def test_local_dir_without_skill_md(tmp_path):
+    with pytest.raises(PackageError):
+        fetch_mod.fetch(str(tmp_path))
+
+
+def test_clawhub_blocks_malware(monkeypatch):
+    _mock_http(monkeypatch, {
+        "/api/v1/skills/": (json.dumps({
+            "moderation": {"isMalwareBlocked": True, "summary": "窃取密钥"},
+            "latestVersion": {"version": "1.0.0"},
+        }).encode(), "application/json"),
+    })
+    with pytest.raises(fetch_mod.MalwareBlocked):
+        fetch_mod.fetch("@bad/skill")
+
+
+def test_clawhub_github_handoff(monkeypatch):
+    """download 返回 JSON 交接(GitHub 托底)时要改下 archiveUrl,而不是当 zip 解。"""
+    _mock_http(monkeypatch, {
+        "/api/v1/skills/": (json.dumps({
+            "moderation": {"isSuspicious": True},
+            "latestVersion": {"version": "2.0.0"},
+        }).encode(), "application/json"),
+        "/api/v1/download": (json.dumps({
+            "archiveUrl": "https://codeload.example/archive.tar.gz",
+        }).encode(), "application/json"),
+        "archive.tar.gz": (_tgz({"repo-main/SKILL.md": MD}), "application/gzip"),
+    })
+    pkg = fetch_mod.fetch("@snowfox/demo")
+    assert pkg.version == "2.0.0"
+    assert pkg.suspicious is True
+    assert "repo-main/SKILL.md" in pkg.files
+
+
+def test_clawhub_not_found(monkeypatch):
+    def boom(url, timeout=25.0, max_bytes=10 * 1024 * 1024):
+        raise fetch_mod.HttpError(404, url, "Not found")
+
+    monkeypatch.setattr(fetch_mod, "_http_get", boom)
+    with pytest.raises(PackageError, match="找不到"):
+        fetch_mod.fetch("@ghost/missing")
+
+
+def test_github_subpath(monkeypatch):
+    _mock_http(monkeypatch, {
+        "codeload.github.com": (_tgz({
+            "repo-main/skills/demo/SKILL.md": MD,
+            "repo-main/skills/other/SKILL.md": "x",
+        }), "application/gzip"),
+    })
+    pkg = fetch_mod.fetch("github:snowfox/repo/skills/demo@main")
+    assert pkg.source == "github"
+    assert pkg.skill_md == MD
+    assert pkg.origin == "github:snowfox/repo/skills/demo@main"
+
+
+def _src(tmp_path):
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "SKILL.md").write_text(MD, encoding="utf-8")
+    return src
+
+
+def test_cli_install_writes_file_when_service_down(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert [s["id"] for s in saved["skills"]] == ["demo_skill"]
+    assert saved["skills"][0]["version"] == "1.2.3"
+
+
+def test_cli_install_respects_explicit_id(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes",
+                     "--id", "my_demo"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert saved["skills"][0]["id"] == "my_demo"
+
+
+def test_cli_install_refuses_without_confirmation(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    monkeypatch.setattr(install_cmd, "_confirm", lambda: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path))]) == 1
+    assert not (tmp_path / "data" / "markdown_skills.json").exists()
+
+
+def test_cli_list_reads_file_when_service_down(tmp_path, monkeypatch, capsys):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    cli.main(["skills", "install", str(_src(tmp_path)), "--yes"])
+    capsys.readouterr()
+
+    assert cli.main(["skills", "list", "--json"]) == 0
+    got = json.loads(capsys.readouterr().out)
+    assert got["source"] == "file"
+    assert got["skills"][0]["id"] == "demo_skill"
+
+
+def test_cli_remove_deletes_skill(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    cli.main(["skills", "install", str(_src(tmp_path)), "--yes"])
+
+    assert cli.main(["skills", "remove", "demo_skill"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert saved["skills"] == []
+
+
+def test_cli_remove_unknown_id_fails(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    assert cli.main(["skills", "remove", "nope"]) == 1
+
+
+def test_cli_install_uses_api_when_service_alive(tmp_path, monkeypatch):
+    """服务在跑时必须打 API:直接改 json 会被运行中注册表的下次 save 整份覆盖。"""
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: True)
+    calls: list = []
+
+    def fake_json(base, method, path, payload=None):
+        calls.append((method, path, payload))
+        return {"created": True}
+
+    monkeypatch.setattr(install_cmd, "_api_json", fake_json)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes"]) == 0
+    method, path, payload = calls[0]
+    assert (method, path) == ("POST", "/api/ahs/md-skills")
+    assert payload["acknowledged"] is True
+    assert payload["id"] == "demo_skill"
+    assert "正文指示" in payload["content"]
+    assert not (tmp_path / "data" / "markdown_skills.json").exists()
+
+
+def test_local_zip_package(tmp_path):
+    p = tmp_path / "demo.zip"
+    p.write_bytes(_zip({"SKILL.md": MD, "_meta.json": '{"slug": "pack"}'}))
+    pkg = fetch_mod.fetch(str(p))
+    assert pkg.source == "local"
+    assert pkg.meta["slug"] == "pack"

package/python/tests/test_stats_and_events.py

@@ -0,0 +1,162 @@
+"""
+记忆统计 + 活动事件 回归测试(全离线)。
+
+覆盖两个实锤 bug 的修复:
+  1. hmr.stats() 从 vector_store 探测 count/size/memories 取 total —— 但真实记忆在 memory_fs,
+     vector_store 只存嵌入且无这些属性 → total 恒为 0(而 relations 却有值,自相矛盾)。
+     修复:改为数 memory_fs.list_memories();by_agent 从 tags 里的 "agent:<id>" 解析。
+  2. 对话路径(stream_reply)此前不发任何事件 → /bus/history 恒空、前端"活动"页永远没内容。
+     修复:对话完成后 publish 一条 chat.completed。
+"""
+import os, sys, types, threading
+from pathlib import Path
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
+os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from foxclaw.core.memory_adapter import HMRAdapter
+from foxclaw.agents.base import CognitiveAgent
+
+
+def _mem(tags):
+    return types.SimpleNamespace(tags=list(tags))
+
+
+def _adapter_with(hmr_obj):
+    """构造最小 self 调用 HMRAdapter.stats(不加载真实 HMR)。"""
+    s = types.SimpleNamespace()
+    s._lock = threading.RLock()
+    s._hmr = hmr_obj
+    s.version = "2.0.0"
+    s.backend = "HMR"
+    return s
+
+
+def test_stats_counts_from_memory_fs_not_vector_store():
+    """核心回归:记忆在 memory_fs;vector_store 没有 count/size/memories 也不能让 total 归零。"""
+    mems = [_mem(["agent:supervisor"]), _mem(["agent:supervisor"]),
+            _mem(["agent:finance", "shared"]), _mem(["agent:office"])]
+    hmr = types.SimpleNamespace(
+        memory_fs=types.SimpleNamespace(list_memories=lambda: mems),
+        vector_store=types.SimpleNamespace(),
+        memory_graph=None)
+    out = HMRAdapter.stats(_adapter_with(hmr))
+    assert out["total_memories"] == 4, "必须从 memory_fs 数出真实记忆数"
+    assert out["by_agent"] == {"supervisor": 2, "finance": 1, "office": 1}
+    assert out["shared"] == 1 and out["private"] == 3
+
+
+def test_stats_falls_back_to_vector_store_vectors():
+    """memory_fs 不可用时,兜底数 vector_store.vectors(dict)。"""
+    hmr = types.SimpleNamespace(
+        memory_fs=None,
+        vector_store=types.SimpleNamespace(vectors={"a": 1, "b": 2, "c": 3}),
+        memory_graph=None)
+    out = HMRAdapter.stats(_adapter_with(hmr))
+    assert out["total_memories"] == 3
+
+
+def test_stats_relations_from_graph_unchanged():
+    """relations 仍来自 memory_graph.edges(这条原本就是对的,不能改坏)。"""
+    hmr = types.SimpleNamespace(
+        memory_fs=types.SimpleNamespace(list_memories=lambda: []),
+        vector_store=None,
+        memory_graph=types.SimpleNamespace(edges=[1, 2, 3, 4, 5]))
+    out = HMRAdapter.stats(_adapter_with(hmr))
+    assert out["relations"] == 5
+
+
+def test_stats_survives_broken_hmr():
+    """HMR 结构异常时不抛,返回零值(fail-safe,前端不白屏)。"""
+    hmr = types.SimpleNamespace(memory_fs=None, vector_store=None, memory_graph=None)
+    out = HMRAdapter.stats(_adapter_with(hmr))
+    assert out["total_memories"] == 0 and out["relations"] == 0
+
+
+def test_derive_title_from_content():
+    d = HMRAdapter._derive_title
+    assert d("对话:你好 → 你好呀！周五中午,正是一周里…") == "你好"
+    assert d("用户偏好:我喜欢简洁的回答") == "我喜欢简洁的回答"
+    assert d("把这份报告存入HMR → 好的,我现在") == "把这份报告存入HMR"
+    assert d("") == ""
+    assert len(d("很长" * 50)) <= 24
+
+
+def test_recent_replaces_timestamp_titles():
+    """HMR 默认标题是 "Concept 03:11"(纯时间戳)→ 展示时必须现推可读标题(老数据也要好看)。"""
+    m = types.SimpleNamespace(id="m1", type="concept", title="Concept 03:11",
+                              semantic_summary="", content="对话:今天是几号 → 今天是 7 月 24 日",
+                              tags=["agent:supervisor"], created_at=None)
+    s = HMRAdapter.__new__(HMRAdapter)
+    s._lock = threading.RLock(); s.version = "2.0.0"; s.backend = "HMR"
+    s._hmr = types.SimpleNamespace(memory_fs=types.SimpleNamespace(list_memories=lambda: [m]))
+    out = s.recent(5)
+    assert out[0]["title"] == "今天是几号", "时间戳标题必须被替换成可读标题"
+    assert out[0]["agent"] == "supervisor"
+
+
+def test_recent_keeps_meaningful_title():
+    """已有可读标题的不许被覆盖。"""
+    m = types.SimpleNamespace(id="m2", type="concept", title="季度财务复盘",
+                              semantic_summary="", content="随便什么内容",
+                              tags=[], created_at=None)
+    s = HMRAdapter.__new__(HMRAdapter)
+    s._lock = threading.RLock(); s.version = "2.0.0"; s.backend = "HMR"
+    s._hmr = types.SimpleNamespace(memory_fs=types.SimpleNamespace(list_memories=lambda: [m]))
+    assert s.recent(5)[0]["title"] == "季度财务复盘"
+
+
+def test_chat_publishes_activity_event(monkeypatch):
+    """核心回归:对话完成后必须往事件脊柱发 chat.completed,否则"活动"页永远空。"""
+    monkeypatch.setenv("FOXCLAW_TOOL_USE", "1")
+    published = []
+    spine = types.SimpleNamespace(
+        publish=lambda topic, payload, source="": published.append((topic, payload, source)))
+
+    fake = types.SimpleNamespace()
+    fake._caps = {"event_spine": spine}
+    fake._sanitize_history = lambda h, max_turns=12: []
+    fake.router = types.SimpleNamespace(supports_tools=lambda: True)
+    fake.AGENT_ID = "assistant"
+    fake._ability_augment = lambda t, m: m
+    fake._skill_augment = lambda t, m: m
+    fake._pref_augment = lambda m: m
+    fake._reply_with_tools = lambda task, messages, stop_event=None: "这是回复内容。"
+    fake._think = lambda **k: None
+    fake._store_memory = lambda *a, **k: None
+    fake._maybe_store_preference = lambda t: None
+
+    out = "".join(CognitiveAgent.stream_reply(fake, "帮我看看这个"))
+    assert "回复内容" in out
+    topics = [t for t, _, _ in published]
+    assert "chat.completed" in topics, "对话路径必须发 chat.completed 事件"
+    payload = [p for t, p, _ in published if t == "chat.completed"][0]
+    assert payload["agent_id"] == "assistant"
+    assert payload["reply_chars"] > 0
+    assert payload["task"].startswith("帮我看看")
+
+
+def test_chat_event_absent_without_spine():
+    """无事件脊柱(standalone/治理场景)时静默跳过,不得抛错。"""
+    fake = types.SimpleNamespace()
+    fake._caps = None
+    fake._sanitize_history = lambda h, max_turns=12: []
+    fake.router = types.SimpleNamespace(supports_tools=lambda: False)
+    fake.AGENT_ID = "assistant"
+    fake._web_augment = lambda t, m: m
+    fake._ability_augment = lambda t, m: m
+    fake._skill_augment = lambda t, m: m
+    fake._pref_augment = lambda m: m
+    fake.system_prompt = "sys"
+    fake.router.stream = lambda *a, **k: iter(["好", "的"])
+    fake._think = lambda **k: None
+    fake._store_memory = lambda *a, **k: None
+    fake._maybe_store_preference = lambda t: None
+    out = "".join(CognitiveAgent.stream_reply(fake, "你好"))
+    assert out == "好的"
+
+
+if __name__ == "__main__":
+    import pytest
+    pytest.main([__file__, "-v"])

package/python/tests/test_streaming.py

@@ -0,0 +1,55 @@
+"""LLM 流式输出(方案A)验证:router.stream 分块 + /api/chat/stream SSE 逐字返回。"""
+import os, sys, tempfile, json
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+import pytest
+
+
+def test_streaming():
+    if "foxclaw.api" in sys.modules:
+        pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
+    os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
+    os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
+    os.environ["FOXCLAW_STREAM_RATE"] = "1"
+    os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_stream_")
+
+    print("=" * 60); print("LLM 流式输出验证"); print("=" * 60)
+
+    from foxclaw.core.model_router import ModelRouter
+    r = ModelRouter()
+    chunks = list(r.stream("sys", [{"role": "user", "content": "你好世界这是一段用于测试流式分块的文本"}]))
+    assert len(chunks) > 1, f"应多块: {len(chunks)}"
+    assert "".join(chunks), "拼接应非空"
+    print(f"[1] router.stream stub 分块(chunk={len(chunks)}) OK")
+
+    from fastapi.testclient import TestClient
+    from foxclaw.api import app
+    with TestClient(app) as c:
+        with c.stream("POST", "/api/chat/stream",
+                      json={"task": "简单介绍一下你自己", "agent_id": "supervisor"}) as resp:
+            assert resp.status_code == 200, resp.status_code
+            deltas, done = [], False
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                ev = json.loads(line[6:])
+                if "delta" in ev:
+                    deltas.append(ev["delta"])
+                if ev.get("done"):
+                    done = True
+            assert len(deltas) > 0, "应有 delta 事件"
+            assert done, "应以 done 收尾"
+            assert "".join(deltas), "拼接应非空"
+        print(f"[2] /api/chat/stream SSE(delta={len(deltas)}, done) OK")
+
+        with c.stream("POST", "/api/chat/stream",
+                      json={"task": "再来一次", "agent_id": "supervisor"}) as resp:
+            txt = "".join(resp.iter_text())
+            assert "rate limited" in txt, f"限流未生效: {txt[:120]}"
+        print("[3] /api/chat/stream 令牌桶限流 OK")
+
+    print("\nLLM 流式输出验证全部通过")
+
+
+if __name__ == "__main__":
+    test_streaming()

package/python/tests/test_supervisor_pipeline.py

@@ -0,0 +1,176 @@
+"""P1-1 · 主管 pipeline 化回归。
+
+主管不再重写 run_task,路由分发拆成 8 个 pipeline stage
+(recall→meta_check→schedule→route→plan→dispatch→replan→aggregate),走 base 统一模板
+`_run_task_core`。本文件锁定:
+
+  [1] 结构:SupervisorAgent.run_task 即基类模板;主管 pipeline 是 SUPERVISOR_STAGES;
+  [2] 元问题短路:meta_check 自答,后续 stage 跳过,内部标记不外泄;
+  [3] 单 Agent 分发:返回体顶层键与旧实现逐字一致(result/schedule/plan/process_id);
+  [4] stub 兜底:无关键词命中 + stub → 兜底派发 assistant(不经自答);
+  [5] 统一 execution.completed:多步并行任务也只发**一条**任务级事件、
+      agent_id=supervisor(文稿 Step 4:删手动 bus.publish);blocked 子任务 →
+      顶层 status=blocked 且执行事件 blocked=True(未完成不沉淀真值);
+  [6] 流式:run_task_stream 逐 stage 出 8 个进度事件;子 Agent 的 act token 随
+      contextvar 传播流出(delta 非空);stop_event 预置 → interrupted;
+  [7] 恢复记账:经 base 生命周期钩子,started/finished 配对、异常路径记 failed。
+
+全离线:ws.needs_search 关掉联网;router 强制 stub(共享实例,五个 Agent 同源)。
+"""
+import asyncio
+import sys
+import tempfile
+import threading
+import types
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws
+ws.needs_search = lambda q: False
+
+from foxclaw import Foxclaw
+from foxclaw.agents.base import CognitiveAgent, HarnessBlockedError
+from foxclaw.agents.agents import SupervisorAgent
+from foxclaw.pipeline import SUPERVISOR_STAGES
+
+EXPECTED_STAGES = ["recall", "meta_check", "schedule", "route", "plan", "dispatch", "replan", "aggregate"]
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+def _names():
+    return [getattr(s, "stage_name", getattr(s, "__name__", "?")) for s in SUPERVISOR_STAGES]
+
+
+def main():
+    print("=" * 60)
+    print("P1-1 · 主管 pipeline 化回归")
+    print("=" * 60)
+
+    print("\n【1】结构:主管走统一模板,不再重写 run_task")
+    check(SupervisorAgent.run_task is CognitiveAgent.run_task,
+          "SupervisorAgent.run_task 即基类模板(P1-1 达成)")
+    check(SupervisorAgent._cognitive_pipeline is not CognitiveAgent._cognitive_pipeline,
+          "主管覆盖 _cognitive_pipeline(路由分发走 SUPERVISOR_STAGES)")
+    check(_names() == EXPECTED_STAGES, f"主管 stage 序列={EXPECTED_STAGES}(实为 {_names()})")
+
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp(prefix="foxclaw_svpipe_"))
+    os_.router.provider = "stub"
+    os_.router._client = None
+    sup = os_.supervisor
+
+    print("\n【2】元问题短路:meta_check 自答,内部标记不外泄")
+    r = asyncio.run(sup.run_task("你是谁,能做什么"))
+    res = r["result"]
+    check(res.get("dispatched_to") == "supervisor" and res.get("self_answered") is True,
+          "元问题 → 主管自答(dispatched_to=supervisor, self_answered=True)")
+    check("_meta_answered" not in r and "_self_answer" not in r,
+          "内部短路标记不外泄到返回体")
+    check(r.get("agent") == "supervisor" and "session_id" in r and "thought_summary" in r,
+          "返回体由 base 模板统一组装(agent/session_id/thought_summary)")
+
+    print("\n【3】单 Agent 分发:返回体顶层键与旧实现逐字一致")
+    r = asyncio.run(sup.run_task("帮我做个预算分析"))
+    res = r["result"]
+    check(res.get("dispatched_to") == "finance", f"关键词命中 → finance(实为 {res.get('dispatched_to')})")
+    for k in ("schedule", "plan", "process_id"):
+        check(k in r, f"顶层键 {k} 保留(与旧主管返回体一致)")
+    check(r["plan"].get("multi_step") is False, "单步任务 plan.multi_step=False")
+    check(res.get("blocked") is False, "正常分发 blocked=False")
+
+    print("\n【4】stub 兜底:无关键词命中 + stub → 主管自处理(助手已下放为技能)")
+    r = asyncio.run(sup.run_task("解释一下什么是航天器"))
+    res = r["result"]
+    check(res.get("dispatched_to") == "supervisor" and not res.get("self_answered"),
+          f"stub 下未命中 → 主管自身处理(实为 {res.get('dispatched_to')})")
+
+    print("\n【5】统一 execution.completed(文稿 Step 4)")
+    spine = os_.event_spine
+    before = len(spine.history("execution.completed"))
+    asyncio.run(sup.run_task("同时查今天的日程、分析本月理财、总结这篇论文"))
+    evts = spine.history("execution.completed")
+    new_evts = evts[before:]
+    check(len(new_evts) == 1,
+          f"并行 3 子任务只发 1 条任务级 execution.completed(实为 {len(new_evts)} 条)"
+          "——逐子任务手动 publish 已删")
+    check(new_evts and new_evts[0]["payload"].get("agent_id") == "supervisor",
+          "任务级事件归因 supervisor(子 Agent 带 _no_emit 不双发)")
+
+    print("\n【5b】blocked 子任务 → 顶层 status=blocked + 事件 blocked=True(不沉淀真值)")
+    async def _boom(self, task, context, session_id, memories):
+        raise HarnessBlockedError(types.SimpleNamespace(reason="模拟越界"), None)
+    os_.finance._execute = types.MethodType(_boom, os_.finance)
+    before = len(spine.history("execution.completed"))
+    r = asyncio.run(sup.run_task("帮我做个预算分析"))
+    check(r["result"].get("blocked") is True, "子 Agent 被拦 → result.blocked=True")
+    check(r.get("status") == "blocked",
+          "被拦提升为顶层 status=blocked(与 base 模板 skill_status 机制一致)")
+    new_evts = spine.history("execution.completed")[before:]
+    check(len(new_evts) == 1 and new_evts[0]["payload"].get("blocked") is True,
+          "被拦任务的执行事件 blocked=True → 真值链不沉淀")
+    del os_.finance._execute
+
+    print("\n【6】流式:run_task_stream 八 stage + 子 Agent token 传播 + 中断")
+    events = list(sup.run_task_stream("帮我做个预算分析"))
+    stages = [e["stage"] for e in events if "stage" in e]
+    deltas = [e["delta"] for e in events if "delta" in e]
+    results = [e["result"] for e in events if "result" in e]
+    check(stages == EXPECTED_STAGES, f"流式逐 stage 进度=主管八 stage(实为 {stages})")
+    check(len(results) == 1 and results[0].get("agent") == "supervisor",
+          "恰一个最终 result,agent=supervisor")
+    check(results[0]["result"].get("dispatched_to") == "finance", "流式与非流式路由结论一致")
+    check(len(deltas) > 0,
+          "delta 非空:子 Agent 的 act token 随 _act_stream contextvar 传播流出(文稿坑5实测反转)")
+    check("".join(deltas) == str(results[0]["result"].get("sub_result")),
+          "流式 token 拼接 == 子 Agent 最终结果(透传忠实)")
+
+    ev = threading.Event(); ev.set()
+    ev_events = list(sup.run_task_stream("这个任务会被中断", stop_event=ev))
+    ev_results = [e["result"] for e in ev_events if "result" in e]
+    check(ev_results and ev_results[0].get("interrupted") is True,
+          "stop_event 预置 → result.interrupted=True(stage 边界优雅停)")
+    check(not [e for e in ev_events if "stage" in e], "起步即停:无 stage 进度事件")
+
+    print("\n【7】恢复记账:base 生命周期钩子,started/finished 配对")
+    calls = []
+
+    class _Spy:
+        def task_started(self, task_id, description, session_id, channel=""):
+            calls.append(("started", task_id))
+        def task_finished(self, sid, status="done"):
+            calls.append(("finished", sid, status))
+
+    sup._recovery = _Spy()
+    asyncio.run(sup.run_task("帮我做个预算分析", context={"channel": "test"}))
+    check(calls[0][0] == "started" and calls[1][0] == "finished" and calls[1][2] == "done",
+          f"正常任务:started→finished(done) 配对(实为 {calls})")
+    check(calls[0][1] == calls[1][1], "started/finished 同一 task_id(可配对)")
+
+    calls.clear()
+    async def _raise(self, task, context=None, **kw):
+        raise RuntimeError("子 Agent 崩溃")
+    sup._subagents["finance"].run_task = _raise
+    try:
+        asyncio.run(sup.run_task("帮我做个预算分析"))
+        raised = False
+    except RuntimeError:
+        raised = True
+    check(raised, "子 Agent 未兜底异常向上传播(不吞)")
+    check(calls[0][0] == "started" and calls[1] == ("finished", calls[0][1], "failed"),
+          f"异常任务记 failed(区别于正常完成)(实为 {calls})")
+
+    print("\n" + "=" * 60)
+    print("P1-1 主管 pipeline 化回归通过")
+    print("=" * 60)
+
+
+def test_supervisor_pipeline():
+    main()
+
+
+if __name__ == "__main__":
+    main()