feihong-code 8.0.0 → 8.0.2

package/agent-team/llm/doubao_llm.py

@@ -0,0 +1,52 @@
+"""豆包大模型适配器（火山方舟 OpenAI 兼容接口）。
+
+零第三方依赖：使用标准库 urllib 发起请求。
+配置：DOUBAO_API_KEY / DOUBAO_MODEL / DOUBAO_BASE_URL（见 config.py）。
+"""
+import json
+import urllib.request
+import urllib.error
+from typing import Any, Dict, List
+
+from llm.base import LLMClient
+
+
+class DoubaoLLM(LLMClient):
+    provider = "doubao"
+
+    def __init__(self, api_key: str, model: str, base_url: str):
+        if not api_key:
+            raise ValueError("DOUBAO_API_KEY 未配置：请在 .env 中填写后设置 LLM_PROVIDER=doubao")
+        self.api_key = api_key
+        self.model = model
+        self.base_url = base_url.rstrip("/")
+
+    def chat(self, messages: List[Dict[str, str]], **kwargs: Any) -> str:
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", 0.7),
+            "max_tokens": kwargs.get("max_tokens", 2048),
+        }
+        req = urllib.request.Request(
+            f"{self.base_url}/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=kwargs.get("timeout", 60)) as resp:
+                body = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            detail = e.read().decode("utf-8", errors="ignore")
+            raise RuntimeError(f"豆包 API 调用失败 HTTP {e.code}: {detail[:300]}") from e
+        except urllib.error.URLError as e:
+            raise RuntimeError(f"豆包 API 网络错误: {e.reason}") from e
+
+        try:
+            return body["choices"][0]["message"]["content"].strip()
+        except (KeyError, IndexError, TypeError) as e:
+            raise RuntimeError(f"豆包 API 返回结构异常: {str(body)[:300]}") from e

package/agent-team/llm/mock_llm.py

@@ -0,0 +1,42 @@
+"""本地 Mock LLM：无 API Key 时提供确定性输出，用于跑通全链路与测试。
+
+真实接入：设置 LLM_PROVIDER=doubao 后由 DoubaoLLM 接管。
+"""
+from typing import Any, Dict, List
+
+from llm.base import LLMClient
+
+_KEYWORDS: Dict[str, str] = {
+    "线索": "【Mock】已扫描目标渠道，发现 3 条高意向线索：A 公司（制造业，意向 A）、B 公司（贸易，意向 B）、C 公司（服务商，意向 B）。",
+    "跟进": "【Mock】已按话术模板发起首轮触达：问候 + 价值主张 + 邀约。客户 B 已读待回复，建议 24h 内二次跟进。",
+    "成交": "【Mock】聊天记录诊断：卡点在价格疑虑（出现 2 次）。建议话术：先量化 ROI，再用限时政策促单。",
+    "分层": "【Mock】客户分层完成：A 类 1 家（高频互动）、B 类 2 家（有意向待跟进）、C 类 3 家（冷启动）。",
+    "选题": "【Mock】今日选题 3 条：①AI 如何帮工厂老板获客；②一人公司如何养 17 个 AI 员工；③评论区商机怎么挖。",
+    "脚本": "【Mock】短视频脚本已生成：黄金 3 秒钩子 + 痛点场景 + 方案演示 + 行动号召，时长约 45 秒。",
+    "爆款": "【Mock】同行爆款雷达：近 7 天 3 条 10w+ 内容，共性 = 强反差标题 + 数字钩子 + 案例收尾。",
+    "拆解": "【Mock】对标账号拆解完成：定位（工厂老板 IP）、选题结构（3 段式）、转化路径（评论区引流）。",
+    "剪辑": "【Mock】已合成成片 1 条：3 段素材拼接 + 字幕 + 片尾 CTA，分辨率 1080p，时长 45 秒。",
+    "公众号": "【Mock】公众号文章已生成并排期：标题 + 三段式正文 + 文末引流钩子，明日 08:00 发布。",
+    "行业": "【Mock】行业分析要点：市场规模 120 亿，年增速 18%，竞争格局分散，头部集中度提升中。",
+    "投资": "【Mock】投研要点：项目商业模式成立，核心风险 = 获客成本与复购率，建议关注现金流。",
+    "GEO": "【Mock】GEO 商机诊断：目标区域 3 个高潜商圈，人口密度与消费力匹配，建议优先覆盖。",
+    "外贸": "【Mock】外贸开发信已生成：针对目标市场买家，突出产能与交期优势，附 3 家候选客户。",
+    "小红书": "【Mock】小红书笔记已生成：种草型标题 + 场景化正文 + 评论区引导话术，配图 4 张。",
+    "评论区": "【Mock】评论区扫描完成：识别 2 条求购意向，来源可回溯，已转线索。",
+    "调度": "【Mock】调度计划已生成：按优先级排列 5 个任务，预估总耗时 12 分钟。",
+}
+
+
+class MockLLM(LLMClient):
+    provider = "mock"
+
+    def chat(self, messages: List[Dict[str, str]], **kwargs: Any) -> str:
+        last = ""
+        for m in reversed(messages):
+            if m.get("role") == "user":
+                last = m.get("content", "")
+                break
+        for kw, out in _KEYWORDS.items():
+            if kw in last:
+                return out
+        return "【Mock】已收到任务，按规则完成处理。"

package/agent-team/main.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""飞虹智 · AI 员工军团系统 — 命令行入口。
+
+命令：
+    init-db          初始化数据库
+    list-agents      查看 17 个 AI 员工清单
+    submit           提交单个任务（--module 编号 --type 类型 --input JSON）
+    run-once         执行一轮 pending 任务
+    run-loop         持续执行（--times N）
+    approve          人工确认任务（--task-id --no 表示驳回）
+    stats            任务统计
+    demo-pipeline    M1 销售闭环演示（01→02→04→09）
+    export-skills    导出 17 个 Skill 包到 skills/
+    install-skills   安装 Skill 包到指定 Skill 根目录
+"""
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+
+from config import BASE_DIR
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+
+def _get_llm():
+    from llm import get_llm
+    return get_llm()
+
+
+def _get_scheduler():
+    from core import models
+    from core.scheduler import Scheduler
+    from agents.registry import instantiate_all
+    llm = _get_llm()
+    agents = instantiate_all(llm)
+    return Scheduler(agents)
+
+
+def cmd_init_db(args):
+    from core import models
+    import config as cfg
+    models.init_db()
+    print("数据库已初始化:", cfg.DB_PATH)
+
+
+def cmd_list_agents(args):
+    from agents.registry import list_meta
+    metas = list_meta()
+    print(f"{'编号':<4}{'模块':<22}{'层级':<5}{'优先级':<5}说明")
+    print("-" * 90)
+    for m in metas:
+        print(f"{m['module_id']:<4}{m['name']:<22}{m['layer']:<5}{m['priority']:<5}{m['description']}")
+    print(f"\n共 {len(metas)} 个 AI 员工")
+
+
+def cmd_submit(args):
+    sched = _get_scheduler()
+    data = json.loads(args.input) if args.input else {}
+    task = sched.submit(module_id=args.module, task_type=args.type,
+                        input_data=data, priority=args.priority,
+                        need_human=None if args.no_human_gate is False else None)
+    print(json.dumps({"ok": True, "task_id": task.task_id, "status": task.status.value,
+                      "need_human": task.need_human}, ensure_ascii=False))
+
+
+def cmd_run_once(args):
+    sched = _get_scheduler()
+    results = sched.run_once(limit=args.limit)
+    for r in results:
+        print(json.dumps(r, ensure_ascii=False))
+    print(f"\n共执行 {len(results)} 个任务")
+
+
+def cmd_run_loop(args):
+    sched = _get_scheduler()
+    for i in range(args.times):
+        n = len(sched.run_once(limit=args.limit))
+        print(f"第 {i + 1} 轮执行 {n} 个任务")
+        if n == 0:
+            break
+
+
+def cmd_approve(args):
+    sched = _get_scheduler()
+    result = sched.approve(args.task_id, approved=not args.no)
+    print(json.dumps(result, ensure_ascii=False))
+
+
+def cmd_stats(args):
+    from core import models
+    sched = _get_scheduler()
+    st = sched.stats()
+    print("任务状态分布:", json.dumps(st["task_counts"], ensure_ascii=False))
+    print("各模块任务数:", json.dumps(st["by_module"], ensure_ascii=False))
+    print(f"在线模块数: {st['agents_online']}，失败重试上限: {st['max_retry']}")
+    print(f"线索数: {len(models.list_leads())}，客户数: {len(models.list_customers())}")
+
+
+def cmd_demo_pipeline(args):
+    """M1 销售闭环演示：01 线索雷达 → 02 跟进销冠(人工闸) → 04 成交分析 → 09 私域分层。"""
+    sched = _get_scheduler()
+    steps = [
+        {"module_id": "01", "task_type": "lead_scan",
+         "input": {"channels": ["评论区", "小红书", "公众号"], "keywords": "AI 获客"}, "priority": "P0"},
+        {"module_id": "02", "task_type": "follow_up",
+         "input": {"customer": {"company_name": "示例制造公司", "contact_name": "王总"},
+                   "strategy": "标准 3 触达"}, "priority": "P0"},
+        {"module_id": "04", "task_type": "chat_analysis",
+         "input": {"transcript": "客户：价格有点高；销售：可以谈；客户：我再想想。"}, "priority": "P0"},
+        {"module_id": "09", "task_type": "tiering",
+         "input": {"customers": [
+             {"customer_id": "C1", "company_name": "示例制造公司", "contact_name": "王总", "contact_phone": "13800000001"},
+             {"customer_id": "C2", "company_name": "示例贸易公司", "contact_name": "李总", "contact_phone": "13800000002"},
+         ]}, "priority": "P0"},
+    ]
+    ids = sched.create_pipeline(steps)
+    print("已提交销售闭环链路:", ids)
+    sched.run_once(limit=10)
+    # 02 任务进入人工确认，演示人工闸
+    for tid in ids:
+        t = _task(tid)
+        if t and t["status"] == "awaiting_human":
+            print(f"任务 {tid} 等待人工确认 -> 自动批准")
+            sched.approve(tid, approved=True)
+    sched.run_once(limit=10)
+    _print_pipeline_summary(ids)
+
+
+def _task(task_id):
+    from core import models
+    return models.get_task(task_id)
+
+
+def _print_pipeline_summary(ids):
+    from core import models
+    print("\n===== 销售闭环执行结果 =====")
+    for tid in ids:
+        t = models.get_task(tid)
+        out = t.get("output_json", {})
+        brief = ""
+        if "leads" in out:
+            brief = f"线索 {out['total']} 条"
+        elif "follow_up" in out:
+            brief = f"跟进对象 {out['follow_up'].get('target', '')}"
+        elif "diagnosis" in out:
+            brief = "卡点: " + "、".join(out["diagnosis"].get("blockers", []))
+        elif "tiers" in out:
+            brief = f"分层 {len(out['tiers'])} 个客户"
+        print(f"  {t['module_id']} {t['task_type']:<16} -> {t['status']:<16} {brief}")
+    print(f"\n线索库: {len(models.list_leads())} 条；客户库: {len(models.list_customers())} 条")
+
+
+def cmd_export_skills(args):
+    from skill_packager import export_skills
+    outdir = Path(args.outdir)
+    exported = export_skills(outdir)
+    print(f"已导出 {len(exported)} 个 Skill 包到 {outdir.resolve()}/")
+    for e in exported:
+        print(f"  [{e['module_id']}] {e['name']} -> {e['path']}")
+
+
+def cmd_install_skills(args):
+    from skill_packager import install_skills
+    source = Path(args.source)
+    target = Path(args.target)
+    installed = install_skills(source, target)
+    print(f"已安装 {len(installed)} 个 Skill 到 {target.resolve()}/")
+    for i in installed:
+        print(f"  {i['name']} -> {i['path']}")
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="feihongzhi", description="飞虹智 · AI 员工军团系统")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("init-db", help="初始化数据库")
+    sub.add_parser("list-agents", help="查看 AI 员工清单")
+
+    sp = sub.add_parser("submit", help="提交任务")
+    sp.add_argument("--module", required=True, help="模块编号 01-17")
+    sp.add_argument("--type", default="manual", help="任务类型")
+    sp.add_argument("--input", default="", help="输入 JSON")
+    sp.add_argument("--priority", default="P1", choices=["P0", "P1", "P2", "P3"])
+    sp.add_argument("--no-human-gate", action="store_true", help="关闭人工确认闸（测试用）")
+
+    rp = sub.add_parser("run-once", help="执行一轮 pending 任务")
+    rp.add_argument("--limit", type=int, default=10)
+
+    lp = sub.add_parser("run-loop", help="持续执行")
+    lp.add_argument("--times", type=int, default=3)
+    lp.add_argument("--limit", type=int, default=10)
+
+    ap = sub.add_parser("approve", help="人工确认任务")
+    ap.add_argument("--task-id", required=True)
+    ap.add_argument("--no", action="store_true", help="驳回")
+
+    sub.add_parser("stats", help="统计")
+    sub.add_parser("demo-pipeline", help="M1 销售闭环演示")
+
+    ep = sub.add_parser("export-skills", help="导出 Skill 包")
+    ep.add_argument("--outdir", default=str(BASE_DIR / "skills"))
+
+    ip = sub.add_parser("install-skills", help="安装 Skill 包")
+    ip.add_argument("--source", default=str(BASE_DIR / "skills"))
+    ip.add_argument("--target", default=str(Path.home() / ".doubao/agent_mode/workspace/.user_skills"))
+    return p
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    dispatch = {
+        "init-db": cmd_init_db,
+        "list-agents": cmd_list_agents,
+        "submit": cmd_submit,
+        "run-once": cmd_run_once,
+        "run-loop": cmd_run_loop,
+        "approve": cmd_approve,
+        "stats": cmd_stats,
+        "demo-pipeline": cmd_demo_pipeline,
+        "export-skills": cmd_export_skills,
+        "install-skills": cmd_install_skills,
+    }
+    try:
+        dispatch[args.command](args)
+    except Exception as e:  # noqa: BLE001
+        print(f"错误: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/agent-team/requirements.txt

@@ -0,0 +1,2 @@
+# 运行期零硬依赖（标准库即可）。接入豆包 API 时安装：
+# pip install requests

package/agent-team/skill_packager.py

@@ -0,0 +1,248 @@
+"""Skill 打包分发器：将 17 个 AI 员工模块导出为可独立安装/调用的 Skill 包。
+
+每个 Skill 包结构（对齐本环境 Skill 规范）：
+    skills/<module_id>_<模块名>/
+        SKILL.md   供智能体发现与调用（frontmatter name/description + 使用说明）
+        run.py     自包含运行器：内嵌该模块核心逻辑，仅依赖标准库
+
+命令：
+    python3 main.py export-skills            # 导出全部模块到 skills/
+    python3 main.py install-skills           # 安装到默认 Skill 根目录（.user_skills）
+    python3 main.py install-skills --target /path/to/skill_root
+"""
+import ast
+import inspect
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from agents.registry import get_agent_classes
+from config import BASE_DIR
+
+RUN_PY_TEMPLATE = '''#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""{name}（{module_id}）独立运行器。
+
+由 feihongzhi_agents 导出：自包含、仅标准库，可被其他智能体直接调用或安装为 Skill。
+用法：
+    python3 run.py --input '{{"field": "value"}}'
+    echo '{{"field": "value"}}' | python3 run.py
+可选接入真实大模型（设置环境变量后加 --llm）：
+    LLM_API_KEY=xxx LLM_MODEL=xxx LLM_BASE_URL=https://ark.cn-beijing.volces.com/api/v3
+    python3 run.py --llm --input '...'
+"""
+import argparse
+import json
+import sys
+import time
+import urllib.request
+import urllib.error
+from datetime import datetime
+
+# ------------------------- 内嵌核心逻辑（自动生成） -------------------------
+{body}
+# ------------------------- 极简 LLM 客户端（可选） -------------------------
+class _MiniLLM:
+    provider = "doubao"
+    def __init__(self):
+        import os
+        self.key = os.environ.get("LLM_API_KEY", "")
+        self.model = os.environ.get("LLM_MODEL", "")
+        self.base = os.environ.get("LLM_BASE_URL", "https://ark.cn-beijing.volces.com/api/v3").rstrip("/")
+        if not self.key or not self.model:
+            raise RuntimeError("缺少 LLM_API_KEY / LLM_MODEL 环境变量")
+    def complete(self, prompt, system=""):
+        msgs = []
+        if system:
+            msgs.append({{"role": "system", "content": system}})
+        msgs.append({{"role": "user", "content": prompt}})
+        payload = {{"model": self.model, "messages": msgs, "temperature": 0.7, "max_tokens": 1024}}
+        req = urllib.request.Request(
+            self.base + "/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={{"Content-Type": "application/json", "Authorization": "Bearer " + self.key}},
+            method="POST")
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                body = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            raise RuntimeError("LLM 调用失败 HTTP %s: %s" % (e.code, e.read().decode("utf-8", errors="ignore")[:200]))
+        return body["choices"][0]["message"]["content"].strip()
+
+def _load_input(args):
+    if args.input:
+        return json.loads(args.input)
+    if not sys.stdin.isatty():
+        raw = sys.stdin.read()
+        if raw.strip():
+            return json.loads(raw)
+    return {{}}
+
+def main():
+    ap = argparse.ArgumentParser(description="{name}（{module_id}）")
+    ap.add_argument("--input", help="JSON 输入，如 '{{\\"topic\\": \\"AI获客\\"}}'；或经 stdin 传入")
+    ap.add_argument("--llm", action="store_true", help="启用真实大模型（需 LLM_API_KEY/LLM_MODEL 环境变量）")
+    args = ap.parse_args()
+    data = _load_input(args)
+    llm = None
+    if args.llm:
+        try:
+            llm = _MiniLLM()
+        except Exception as e:
+            print(json.dumps({{"ok": False, "error": "LLM 初始化失败: " + str(e)}}, ensure_ascii=False))
+            sys.exit(1)
+    try:
+        out = {entry_func}(data, llm)
+    except Exception as e:
+        print(json.dumps({{"ok": False, "error": str(e)}}, ensure_ascii=False))
+        sys.exit(1)
+    print(json.dumps({{"ok": True, "output": out}}, ensure_ascii=False))
+
+if __name__ == "__main__":
+    main()
+'''
+
+SKILL_MD_TEMPLATE = """---
+name: {name}
+description: {description}。属于{layer}层，优先级{priority}。触发场景：用户需要{trigger}、或涉及{inputs}相关任务时调用。输出：{outputs}。
+---
+
+# {name}（{module_id}）
+
+{description}
+
+- **所属层级**：{layer}（优先级 {priority}）
+
+## 使用方式
+
+```bash
+# 方式一：命令行参数
+python3 run.py --input '{{"{ex_field}": "{ex_value}"}}'
+
+# 方式二：标准输入
+echo '{{"{ex_field}": "{ex_value}"}}' | python3 run.py
+
+# 接入真实大模型（可选）
+LLM_API_KEY=xxx LLM_MODEL=xxx python3 run.py --llm --input '{{"{ex_field}": "{ex_value}"}}'
+```
+
+## 输入字段
+
+| 字段 | 说明 |
+|---|---|
+{table_rows}
+
+## 输出字段
+
+{output_rows}
+
+## 安装为 Skill
+
+将本目录（含 SKILL.md 与 run.py）复制到目标 Skill 根目录即可被智能体发现调用。
+"""
+
+
+def _collect_dependencies(func) -> Dict[str, object]:
+    """收集函数引用的同模块顶层函数（如 _ts），供内嵌。"""
+    try:
+        tree = ast.parse(inspect.getsource(func))
+    except (OSError, TypeError):
+        return {}
+    used: set = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            used.add(node.func.id)
+        elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+            used.add(node.id)
+    mod = inspect.getmodule(func)
+    deps: Dict[str, object] = {}
+    for name in used:
+        obj = getattr(mod, name, None)
+        if obj is not None and inspect.isfunction(obj) and getattr(obj, "__module__", None) == mod.__name__:
+            if name != func.__name__:
+                deps[name] = obj
+    return deps
+
+
+def _body_source(cls) -> tuple:
+    """收集 run_logic 及其依赖函数源码，保证独立 run.py 自包含。返回 (源码, 入口函数名)。"""
+    func = cls.run_logic.__func__ if isinstance(cls.run_logic, staticmethod) else cls.run_logic
+    chunks: List[str] = []
+    seen: set = set()
+
+    def add(f):
+        if id(f) in seen:
+            return
+        seen.add(id(f))
+        for dep in _collect_dependencies(f).values():
+            add(dep)
+        chunks.append(inspect.getsource(f))
+
+    add(func)
+    return "\n\n".join(chunks), func.__name__
+
+
+def _first_key(schema: Dict[str, str]) -> tuple:
+    if not schema:
+        return ("data", "{}")
+    k = next(iter(schema))
+    if k == "customers":
+        return (k, '[{"customer_id":"C1","company_name":"客户A","contact_name":"李总"}]')
+    if k in ("channels", "target_accounts", "competitor_accounts", "hot_topics", "selling_points", "clips", "tasks"):
+        return (k, '["示例A","示例B"]')
+    if k == "transcript":
+        return (k, "客户：价格有点高；销售：可以谈。")
+    return (k, "示例输入")
+
+
+def export_skills(outdir: Path) -> List[Dict[str, str]]:
+    outdir = Path(outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+    exported: List[Dict[str, str]] = []
+    for cls in get_agent_classes():
+        agent = cls(llm=None)
+        meta = agent.meta()
+        slug = f"{meta['module_id']}_{meta['name']}"
+        pkg = outdir / slug
+        pkg.mkdir(parents=True, exist_ok=True)
+
+        body, entry_func = _body_source(cls)
+        run_py = RUN_PY_TEMPLATE.format(name=meta["name"], module_id=meta["module_id"],
+                                        body=body, entry_func=entry_func)
+        (pkg / "run.py").write_text(run_py, encoding="utf-8")
+
+        ex_field, ex_value = _first_key(meta["input_schema"])
+        table_rows = "\n".join(f"| {k} | {v} |" for k, v in meta["input_schema"].items()) or "| （无必填） | 可传任意 JSON |"
+        output_rows = "\n".join(f"- **{k}**：{v}" for k, v in meta["output_keys"].items()) or "- **result**：处理结果"
+        trigger = meta["name"]
+        md = SKILL_MD_TEMPLATE.format(
+            name=slug, module_id=meta["module_id"], description=meta["description"],
+            layer=meta["layer"], priority=meta["priority"], trigger=trigger,
+            inputs="、".join(meta["input_schema"].keys()) or "任意 JSON",
+            outputs="、".join(meta["output_keys"].keys()) or "result",
+            ex_field=ex_field, ex_value=ex_value,
+            table_rows=table_rows, output_rows=output_rows,
+        )
+        (pkg / "SKILL.md").write_text(md, encoding="utf-8")
+        exported.append({"module_id": meta["module_id"], "name": meta["name"], "path": str(pkg)})
+    return exported
+
+
+def install_skills(source: Path, target: Path) -> List[Dict[str, str]]:
+    source = Path(source)
+    target = Path(target)
+    target.mkdir(parents=True, exist_ok=True)
+    installed: List[Dict[str, str]] = []
+    for pkg in sorted(source.iterdir()):
+        if not pkg.is_dir():
+            continue
+        if not (pkg / "SKILL.md").exists():
+            continue
+        dest = target / pkg.name
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(pkg, dest)
+        installed.append({"name": pkg.name, "path": str(dest)})
+    return installed

package/agent-team/skills/01_AI/350/216/267/345/256/242/347/272/277/347/264/242/351/233/267/350/276/276/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: 01_AI获客线索雷达
+description: 全域线索发现、清洗与入库，构建线索池。属于L1层，优先级P0。触发场景：用户需要AI获客线索雷达、或涉及channels、keywords相关任务时调用。输出：total、leads、dedup_rule。
+---
+
+# 01_AI获客线索雷达（01）
+
+全域线索发现、清洗与入库，构建线索池
+
+- **所属层级**：L1（优先级 P0）
+
+## 使用方式
+
+```bash
+# 方式一：命令行参数
+python3 run.py --input '{"channels": "["示例A","示例B"]"}'
+
+# 方式二：标准输入
+echo '{"channels": "["示例A","示例B"]"}' | python3 run.py
+
+# 接入真实大模型（可选）
+LLM_API_KEY=xxx LLM_MODEL=xxx python3 run.py --llm --input '{"channels": "["示例A","示例B"]"}'
+```
+
+## 输入字段
+
+| 字段 | 说明 |
+|---|---|
+| channels | 线索渠道列表，如 ["评论区","小红书","公众号"] |
+| keywords | 获客关键词 |
+
+## 输出字段
+
+- **total**：线索总数
+- **leads**：线索列表
+- **dedup_rule**：去重规则
+
+## 安装为 Skill
+
+将本目录（含 SKILL.md 与 run.py）复制到目标 Skill 根目录即可被智能体发现调用。