sycommon-python-lib 0.2.7a55__py3-none-any.whl → 0.2.8__py3-none-any.whl

sycli/cli.py

@@ -173,6 +173,11 @@ def _create_parser() -> argparse.ArgumentParser:
     p_acp.add_argument("--config", "-c", help="Path to ACP config file (default: .sycli/acp.yaml)")
     p_acp.add_argument("--project-root", "-r", default=".", help="Project root directory")
 
+    # ── acp-serve ──
+    p_acp_serve = sub.add_parser(
+        "acp-serve", help="Serve a DeepAgent as Zed ACP agent over stdio (LLM-backed)")
+    p_acp_serve.add_argument("--project-root", "-r", default=".", help="Project root directory")
+
     # ── version ──
     sub.add_parser("version", help="Show version")
 
@@ -243,6 +248,10 @@ def main() -> None:
         from sycli.commands.acp_cmd import handle_acp
         sys.exit(handle_acp(args))
 
+    elif args.command == "acp-serve":
+        from sycli.commands.acp_serve_cmd import handle_acp_serve
+        sys.exit(handle_acp_serve(args))
+
 
 def _handle_status(args) -> None:
     """Show current RL state."""

sycli/commands/acp_serve_cmd.py

@@ -0,0 +1,113 @@
+"""sycli acp-serve command — 把 DeepAgent 起成 Zed ACP agent（stdio）。
+
+与 `sycli acp` 的区别：
+- acp：把 .sycli/acp.yaml 里的静态 CLI 工具暴露成 ACP agent（无 LLM，纯命令路由）。
+- acp-serve：把一个真的 DeepAgent（LLM + 本地 shell 后端）暴露成 ACP agent，
+  Zed/其它 ACP client 连上后即可对话式驱动它干活。
+
+stdio 约定：stdout 是 JSON-RPC 通道，一切诊断输出走 stderr。
+"""
+
+from __future__ import annotations
+
+import signal
+import sys
+from pathlib import Path
+
+
+def _e(msg: str) -> None:
+    """stderr 诊断输出（stdout 留给 JSON-RPC）。"""
+    print(f"  {msg}", file=sys.stderr)
+
+
+def handle_acp_serve(args) -> int:
+    """Handle `sycli acp-serve` command.
+
+    Flow:
+        1. Resolve project root, load sycli.json（LLM 配置）
+        2. Build DeepAgent graph（LLM + LocalShellBackend）
+        3. Serve over stdio as Zed ACP agent (blocking)
+
+    Args:
+        args: Parsed argparse namespace with project_root.
+
+    Returns:
+        Exit code (0 for success, 1 for error).
+    """
+    project_root = Path(args.project_root or ".").resolve()
+    config_path = project_root / ".sycli" / "sycli.json"
+
+    from sycli.models.config_models import SycliConfig
+
+    config = SycliConfig.load(config_path)
+    issues = config.validate_config()
+    fatal = [i for i in issues if "base_url" in i or "api_key" in i]
+    if fatal:
+        for i in fatal:
+            _e(f"✘ Config: {i}")
+        _e("✘ LLM 未配置，无法启动 DeepAgent。先运行 `sycli init` 或检查 sycli.json。")
+        return 1
+
+    # Print summary to stderr（stdout 留给 stdio JSON-RPC）
+    _e("═" * 60)
+    _e("Zed ACP DeepAgent Server")
+    _e(f"  Project:  {project_root}")
+    _e(f"  Config:   {config_path if config_path.exists() else '(defaults)'}")
+    _e(f"  Model:    {config.llm.model} @ {config.llm.resolved_base_url()}")
+    _e("  Transport: stdio (JSON-RPC)")
+    _e("─" * 60)
+
+    # Build DeepAgent graph（延迟导入：出错时不污染 stdout）
+    def _build_graph():
+        from deepagents import create_deep_agent
+        from sycli.agents.factory import build_subagents
+        from sycli.core.backend import create_backend
+        from sycli.core.llm import create_llm
+
+        llm = create_llm(config.llm, streaming=True)
+        backend = create_backend(project_root)
+        subagents = build_subagents(config, llm, backend, project_name=project_root.name, mode="serve", project_root=str(project_root))
+        return create_deep_agent(
+            model=llm,
+            backend=backend,
+            system_prompt=(
+                "你是 sycli DeepAgent，正通过 ACP 协议被远程 client 驱动。"
+                "在项目根目录内完成任务；需要拆解任务时用 write_todos 维护计划。"
+            ),
+            subagents=subagents,
+            checkpointer=None,  # langchain-acp 适配层自动挂进程内 checkpointer
+            debug=False,
+            name="sycli-acp-serve",
+        )
+
+    from sycommon.agent.acp.server_adapter import serve_graph
+
+    _shutdown = False
+
+    def _signal_handler(sig, frame):
+        nonlocal _shutdown
+        if _shutdown:
+            sys.exit(1)
+        _shutdown = True
+        _e("⚠ Shutting down ACP DeepAgent...")
+
+    signal.signal(signal.SIGINT, _signal_handler)
+
+    try:
+        serve_graph(
+            graph_factory=_build_graph,
+            agent_name="sycli-deepagent",
+            agent_title="sycli DeepAgent",
+        )
+    except KeyboardInterrupt:
+        _e("⚠ ACP DeepAgent stopped.")
+        return 0
+    except Exception as e:
+        _e(f"✘ ACP server failed: {e}")
+        import traceback
+
+        traceback.print_exc(file=sys.stderr)
+        return 1
+
+    return 0
+

sycommon/agent/acp/server_adapter.py

@@ -0,0 +1,99 @@
+"""ACP server 适配器——把 LangGraph/DeepAgent graph 暴露成 ACP agent（stdio）。
+
+与 client.py 相反的方向：client.py 让我们的 agent 通过 ACP 调远程 agent（如 Codex）；
+本模块让我们的 agent（DeepAgent compiled graph）反过来被 ACP client（Zed 编辑器、
+其它主控 agent）驱动，基于 langchain-acp 的 LangChainAcpAgent 适配层。
+
+对外暴露：
+- serve_graph：把 compiled graph 包成 ACP agent 并阻塞跑 stdio JSON-RPC 循环。
+- build_acp_server_agent：只构建 LangChainAcpAgent（不进 IO 循环，测试/嵌入用）。
+
+会话与状态：
+- 每 ACP session 对应 graph 一个 thread_id（session_id），多轮上下文由
+  langgraph checkpointer 维持；无 checkpointer 的 graph 会被适配层自动挂
+  MemorySaver（进程内，进程退出即失）。
+- deepagents 的 write_todos 计划事件经 DeepAgentsCompatibilityBridge 投影成
+  ACP AgentPlanUpdate，client（如 Zed）能实时看到计划进度。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Optional
+
+from langchain_acp import create_acp_agent, run_acp
+from langchain_acp.runtime.adapter import LangChainAcpAgent
+
+logger = logging.getLogger(__name__)
+
+# graph 工厂类型：langchain-acp 以 FactoryGraphSource 调用工厂，签名是
+# factory(session: AcpSessionContext) -> compiled graph（session 可忽略）。
+# 声明成可选参以兼容「无参工厂」——我们只透传给 langchain-acp。
+GraphFactory = Callable[..., Any]
+
+
+def _adapt_factory(factory: GraphFactory) -> GraphFactory:
+    """把任意零参工厂包成 langchain-acp 要求的 (session) -> graph 签名。"""
+    def _wrapped(session: Any = None) -> Any:  # noqa: ARG001
+        return factory()
+    return _wrapped
+
+
+def build_acp_server_agent(
+    graph: Any = None,
+    *,
+    graph_factory: Optional[GraphFactory] = None,
+    agent_name: str = "sycommon-deepagent",
+    agent_title: str = "sycommon DeepAgent",
+) -> LangChainAcpAgent:
+    """构建 ACP 化的 agent（不进 IO 循环）。
+
+    Args:
+        graph: 已编译的 LangGraph/DeepAgent graph（与 graph_factory 二选一）。
+        graph_factory: 返回 compiled graph 的零参工厂（优先级低于 graph）。
+        agent_name: ACP agentInfo.name（client 侧展示用）。
+        agent_title: ACP agentInfo.title。
+
+    Returns:
+        LangChainAcpAgent，可直接传给 acp.run_agent 或自托管事件循环。
+    """
+    if graph is None and graph_factory is None:
+        raise ValueError("graph 与 graph_factory 至少提供一个")
+    agent = create_acp_agent(
+        graph=graph,
+        graph_factory=_adapt_factory(graph_factory) if graph_factory else None,
+        config=_make_config(agent_name, agent_title),
+    )
+    logger.info("[acp_server] agent 就绪 name=%s（等待 stdio client 连接）", agent_name)
+    return agent
+
+
+def serve_graph(
+    graph: Any = None,
+    *,
+    graph_factory: Optional[GraphFactory] = None,
+    agent_name: str = "sycommon-deepagent",
+    agent_title: str = "sycommon DeepAgent",
+) -> None:
+    """把 graph 包成 ACP agent 并阻塞运行 stdio JSON-RPC 循环。
+
+    stdout 是 JSON-RPC 通道，任何日志必须走 stderr（上层负责 logging 配置）。
+    client 断开 stdin 或进程被 kill 时返回。
+    """
+    agent = build_acp_server_agent(
+        graph, graph_factory=graph_factory,
+        agent_name=agent_name, agent_title=agent_title,
+    )
+    run_acp(graph_source=agent._graph_source, config=agent._config)
+
+
+def _make_config(agent_name: str, agent_title: str) -> Any:
+    """构造 AdapterConfig（agent 标识 + deepagents 兼容桥）。"""
+    from langchain_acp import AdapterConfig
+    from langchain_acp.bridges import DeepAgentsCompatibilityBridge
+
+    return AdapterConfig(
+        agent_name=agent_name,
+        agent_title=agent_title,
+        capability_bridges=(DeepAgentsCompatibilityBridge(),),
+    )

sycommon/agent/deep_agent.py

@@ -76,16 +76,67 @@ _STREAM_DEBUG = check_env_flag(['DEEP_AGENT_STREAM_DEBUG'], default='false')
 # 无上限可涨到几十 MB。超限停止追加（只影响前端 tool_call 进度展示，工具实际执行不受影响）。
 MAX_ARGS_BUFFER_BYTES = int(os.environ.get("DEEP_AGENT_MAX_ARGS_BUFFER", 1024 * 1024))
 
+# Defense 4 流式缓冲的判定阈值（字符）：累积到该长度做一次备忘复述前缀判定。
+# 需 >= _match_summary_prefix_overlap 的 min_overlap(20) 且覆盖典型复述开头。
+_DEFENSE4_PROBE_CHARS = int(os.environ.get("DEEP_AGENT_DEFENSE4_PROBE", 120))
+
 if TYPE_CHECKING:
     from deepagents.graph import CompiledStateGraph
     from langchain.agents.middleware.types import AgentState, ContextT, ModelRequest, ModelResponse, ResponseT
     from langgraph.runtime import Runtime
 
+
+def _match_summary_prefix_overlap(text: str, summary: str,
+                                  min_overlap: int = 20) -> int:
+    """检测回答开头对备忘原文的逐字复述，返回需剥除的字符数（0=无复述）。
+
+    Defense 4 的核心判定：模型复述备忘时几乎总是从备忘某行的开头逐字照抄
+    （实测样本：「用户的整体目标是深入学习...」= 备忘第一句原文）。这里对
+    备忘的每一条目（按行取正文）做前缀匹配：text 开头是某条目的开头片段
+    （且 >= min_overlap 字符）即命中，返回重叠长度。
+
+    只查开头（前缀），不做全文搜索 —— 备忘要素"融入回答"是期望行为，
+    只有开头照抄才是复述泄漏。正常回答恰好以备忘某条目前 20 字开头且
+    语义独立的概率可忽略；误剥时也只影响首个 chunk 的前缀。
+
+    Args:
+        text: AI 回答的首个非空文本 chunk。
+        summary: 注入 system 的备忘原文（电报式条目，逐行比对）。
+        min_overlap: 判定为复述的最小连续重叠字符数。
+
+    Returns:
+        text 开头与备忘条目重叠的字符数；无重叠返回 0。
+    """
+    if not text or not summary:
+        return 0
+    probe = text[:120]  # 复述只发生在开头，截断降低比对开销
+    for line in summary.splitlines():
+        line = line.strip()
+        if len(line) < min_overlap:
+            continue
+        # 条目锚点：行首（条目化后「目标:」等标签开头）+ 去掉标签后的正文开头
+        for anchor in (line, line.split(":", 1)[-1].lstrip()):
+            anchor = anchor.strip()
+            if len(anchor) < min_overlap:
+                continue
+            # 前缀重叠：probe 与 anchor 的最长公共前缀
+            n = min(len(probe), len(anchor))
+            common = 0
+            for i in range(n):
+                if probe[i] == anchor[i]:
+                    common += 1
+                else:
+                    break
+            if common >= min_overlap:
+                return common
+    return 0
+
+
 @tool
 def get_current_date() -> str:
-    """获取当前日期时间"""
-    from datetime import datetime
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    """获取当前日期时间（北京时间）"""
+    from sycommon.tools.time_utils import now_bj
+    return now_bj().strftime("%Y-%m-%d %H:%M:%S")
 
 
 # 默认系统提示词
@@ -160,6 +211,10 @@ class AgentConfig(BaseModel):
     # (scoped 由服务端路由硬编码,user 由 MinIO 按 user 灌入)。
     system_skills_allow: Optional[set[str]] = None
     memory_dir: Optional[str] = None
+    # 额外 middleware（应用层注入，如技能使用上报、自定义拦截）：
+    # 数字员工等项目自定义 AgentMiddleware 实例列表，create_deep_agent 会
+    # 追加到内置 middleware_list 之后执行。类型用 list 而非具体类避免循环依赖。
+    extra_middleware: list = []
 
     @property
     def skills_dir(self) -> Optional[str]:
@@ -228,6 +283,8 @@ class DeepAgent:
         rubric_eval_collector: Optional[_RubricEvalCollector] = None,
         sensitive_guard: Optional[SensitiveGuardMiddleware] = None,
         raw_model: Any = None,
+        request_prep: Optional[ModelRequestPrepMiddleware] = None,
+        summarization_mw: Any = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -236,6 +293,12 @@ class DeepAgent:
         self.recovery_manager = recovery_manager
         self.rubric_eval_collector = rubric_eval_collector
         self.sensitive_guard = sensitive_guard
+        # 🔑 ModelRequestPrepMiddleware 实例引用：chat() 时读取其
+        # last_summary_text 做备忘复述兜底（Defense 4）。
+        self.request_prep = request_prep
+        # 🔑 SummarizationToolMiddleware 内部 middleware 引用：resume_compactor
+        # 恢复前分段压缩复用其 _acreate_summary/_partition_messages 等压缩链。
+        self.summarization_mw = summarization_mw
         # 🔑 存 raw_model 引用，供 cleanup 关 LLM client（root_async_client）。
         # model 被埋进 graph 内部节点闭包，表层拿不到，必须 create 时显式传入。
         self._raw_model = raw_model
@@ -286,6 +349,13 @@ class DeepAgent:
         ai_text_content = ""
         seen_tool_call_ids = set()
         stream_step = 0
+        # Defense 4（备忘复述兜底）状态：对每「版」备忘各判定一次。
+        # 比对文本取 ModelRequestPrepMiddleware.last_summary_text —— 压缩可发生
+        # 在本轮任意一次模型调用（不只在首轮）。流式下逐 token chunk 太小，
+        # 用缓冲累积到 ~120 字符再做一次判定（见流循环内 Defense 4 注释）。
+        _defense4_seen_summary = None
+        _defense4_buffer = ""
+        _defense4_done = True  # 无备忘时默认已完成（跳过判定）
         # 兜底：累积流式 chunk 中的 usage_metadata（middleware 在流式场景可能拿不到）
         total_input_tokens = 0
         total_output_tokens = 0
@@ -401,6 +471,14 @@ class DeepAgent:
 
                 stream_step += 1
 
+                # 🔑 跳过 middleware 内部模型调用的输出（lc_internal_call）。
+                # langchain 1.3.15 起 SummarizationMiddleware 的摘要生成调用带
+                # internal_call_metadata() 标记（进程内随机 token 防伪造），
+                # langgraph 会把它透传到流事件 metadata。压缩轮的「摘要本体」
+                # （目标:/事实: 等条目）曾因此被当回答发给用户 —— 根治点。
+                if isinstance(metadata, dict) and "lc_internal_call" in metadata:
+                    continue
+
                 # ===== 逐 chunk 诊断日志：默认关闭，DEEP_AGENT_STREAM_DEBUG=true 时开启 =====
                 if _STREAM_DEBUG:
                     _chunk_type = type(chunk).__name__
@@ -565,6 +643,46 @@ class DeepAgent:
                     if _cleaned:
                         content = content.strip()
 
+                # 🔑 Defense 4（输出兜底）：开头与注入备忘的复述检测。
+                # 前三层防线（备忘条目化 / 正向契约 / 标签清理）失效时，模型会把
+                # 备忘开头当回答开头逐字复述（实测"用户的整体目标是..."）。这里
+                # 对本条 agent 回答的开头做一次重叠判定：开头与备忘原文出现连续
+                # 长重叠（>= 20 字符）即剥掉重叠前缀。
+                # 🔑 流式适配：逐 token 流式下首 chunk 仅 1-2 字符，单个 chunk
+                # 永远达不到 20 字符判定阈值。因此用「先缓冲后放行」：本条回答的
+                # 前 _DEFENSE4_PROBE_CHARS 字符先累积到 _defense4_buffer（不
+                # yield），凑满后做一次判定——命中复述剥除前缀、未命中原样，
+                # 然后一次性 flush 发出；此后所有 chunk 直通。回答总长不足阈值
+                # 时由流末 flush（见 FOR 循环结束处）兜底。代价是回答开头延迟
+                # 若干 token 到达，换取首句复述的可靠拦截。
+                if (msg_type in ("AIMessage", "AIMessageChunk")
+                        and content.strip()):
+                    _summary_ref = getattr(
+                        getattr(self, 'request_prep', None),
+                        'last_summary_text', None)
+                    # 新一版备忘 → 重置缓冲与完成标记（压缩可发生在本轮任意一次模型调用后）
+                    if _summary_ref and _summary_ref is not _defense4_seen_summary:
+                        _defense4_seen_summary = _summary_ref
+                        _defense4_buffer = ""
+                        _defense4_done = False
+                    if _summary_ref and not _defense4_done:
+                        _defense4_buffer += content
+                        if len(_defense4_buffer) >= _DEFENSE4_PROBE_CHARS:
+                            _defense4_done = True
+                            _strip = _match_summary_prefix_overlap(
+                                _defense4_buffer, _summary_ref)
+                            if _strip:
+                                SYLogger.warning(
+                                    f"[DeepAgent] 回答开头复述备忘（重叠 {_strip} 字符），已剥除")
+                                _defense4_buffer = _defense4_buffer[_strip:].lstrip()
+                        # 缓冲未满或刚好判定完：本 chunk 已并入缓冲，不单独发出。
+                        # 判定完成时下方统一 flush；未满时置空等待后续。
+                        content = ""
+                    # 判定完成后：缓冲里剩余的内容一次性放到本 chunk 发出
+                    if _defense4_done and _defense4_buffer:
+                        content = _defense4_buffer + (content or "")
+                        _defense4_buffer = ""
+
                 if msg_type in ("AIMessage", "AIMessageChunk"):
                     # 🔑 提取 reasoning_content（思考/推理内容）
                     # 模型在 thinking 模式下会将推理过程放在 reasoning_content 字段，
@@ -777,6 +895,28 @@ class DeepAgent:
                 print(
                     f"[DeepAgent] FOR LOOP ENDED. stream_step={stream_step}, ai_text_content={repr(ai_text_content[:100])}, tool_calls={len(current_tool_calls)}", flush=True)
 
+            # 🔑 Defense 4 流末 flush：回答总长不足判定阈值时缓冲里还压着内容
+            # （正常路径在缓冲满 _DEFENSE4_PROBE_CHARS 时已 flush）。这里做
+            # 最后一次判定并发出，避免短回答被缓冲吞掉。
+            if _defense4_buffer:
+                if not _defense4_done and _defense4_seen_summary:
+                    _strip = _match_summary_prefix_overlap(
+                        _defense4_buffer, _defense4_seen_summary)
+                    if _strip:
+                        SYLogger.warning(
+                            f"[DeepAgent] 回答开头复述备忘（流末判定，重叠 {_strip} 字符），已剥除")
+                        _defense4_buffer = _defense4_buffer[_strip:].lstrip()
+                if _defense4_buffer:
+                    flushed = _defense4_buffer
+                    _defense4_buffer = ""
+                    ai_text_content += flushed
+                    event = ChatEventBuilder.ai_chunk(
+                        flushed, id=None, agent=DEFAULT_AGENT_NAME)
+                    if on_event:
+                        await on_event(event)
+                    yield event
+                _defense4_done = True
+
             SYLogger.warning(
                 f"[STREAM-DEBUG] FOR LOOP ENDED | _astream_chunk_count={_astream_chunk_count} | "
                 f"stream_step={stream_step} | ai_text_len={len(ai_text_content)} | "
@@ -1111,13 +1251,17 @@ async def create_deep_agent(
 
     middleware_list = [
         guard,
-        ToolResultTruncationMiddleware(),
+        # 截断上限从 nacos maxTokens 推导(×0.04,下限2000);读不到配置兜底 8192
+        ToolResultTruncationMiddleware(model_name=config.model_name),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
         ModelRequestPrepMiddleware(),     # 紧跟 summarization：摘要重定位 + 动态压 max_tokens
         SkillWriteGuardMiddleware(),          # 系统 /skills/system 只读守卫(先于白名单)
         SandboxPathGuardMiddleware(user_id),  # 宿主绝对路径规范化/拦截(防越权读他人沙箱文件)
     ]
+    # 应用层注入的额外 middleware（如技能使用上报），排在内置之后
+    if config.extra_middleware:
+        middleware_list.extend(config.extra_middleware)
 
     # RubricMiddleware：复用 FilesystemMiddleware 的工具（底层走 HTTPSandboxBackend HTTP 远程调用）
     if config.rubric_max_iterations > 0 and sandbox_backend:
@@ -1130,17 +1274,6 @@ async def create_deep_agent(
             on_evaluation=rubric_eval_collector.on_evaluation,
         ))
 
-    # SkillApiWhitelistMiddleware：按子技能注入接口白名单（拦 execute 工具，
-    # export SKILL_API_WHITELIST + 推送 sitecustomize 到沙箱做 path 级校验）
-    if sandbox_backend:
-        try:
-            from sycommon.agent.middleware.skill_api_whitelist import (
-                SkillApiWhitelistMiddleware)
-            middleware_list.append(
-                SkillApiWhitelistMiddleware(sandbox_backend))
-        except Exception as _wl_err:
-            SYLogger.warning(f"[DeepAgent] 技能接口白名单中间件加载失败(忽略): {_wl_err}")
-
     agent_kwargs = {
         "model": raw_model,
         "tools": config.tools or [get_current_date],
@@ -1204,6 +1337,15 @@ async def create_deep_agent(
         rubric_eval_collector=rubric_eval_collector,
         sensitive_guard=guard,
         raw_model=raw_model,
+        request_prep=next(
+            (m for m in middleware_list
+             if type(m).__name__ == "ModelRequestPrepMiddleware"), None),
+        # SummarizationToolMiddleware 实例引用:resume_compactor 分段压缩复用
+        # 其内部 _DeepAgentsSummarizationMiddleware(_acreate_summary 等)。
+        # graph 内部探测(deepagents 未暴露 middleware 列表)不可靠,创建时显式传入。
+        summarization_mw=next(
+            (getattr(m, "_summarization", None) for m in middleware_list
+             if type(m).__name__ == "SummarizationToolMiddleware"), None),
     )
 
 
@@ -1429,6 +1571,8 @@ async def _sync_skills_to_sandbox(
 
         skill_count = 0
         skip_count = 0
+        # 收集需要重传的技能（版本不一致 / 无版本 / 正文校验失败）
+        pending = []  # [(skill_name, local_version, src, remote_version)]
         for skill_name, local_version, src in local_skills:
             remote_version = remote_version_map.get(skill_name, "")
 
@@ -1437,19 +1581,27 @@ async def _sync_skills_to_sandbox(
                 # （历史上出现过沙箱 SKILL.md 版本号新、正文旧的脏数据，导致 agent
                 # 永远读不到新版指令）。校验失败则强制走删除+重传。
                 # fresh_map 在进入循环前已并发预取，这里只查表不再 await。
-                if not fresh_map.get(skill_name, False):
-                    SYLogger.warning(
-                        f"[DeepAgent] 技能版本一致但正文不一致，强制重传: {skill_name} "
-                        f"v{local_version}")
-                    # 落到下方的删除+重传分支
-                else:
+                if fresh_map.get(skill_name, False):
                     SYLogger.debug(
                         f"[DeepAgent] 技能版本一致,跳过: {skill_name} v{local_version}")
                     backend._synced_skills.add(skill_name)
                     skip_count += 1
                     continue
-
-            # 版本不一致或无版本（或正文校验失败），删除旧目录(走 /delete,跳过懒同步,毫秒级)
+                SYLogger.warning(
+                    f"[DeepAgent] 技能版本一致但正文不一致，强制重传: {skill_name} "
+                    f"v{local_version}")
+            pending.append((skill_name, local_version, src, remote_version))
+
+        # 并发删除 + 全量上传：信号量限流，把「N 次串行 HTTP 上传」压成「N/并发 批」。
+        # 单个技能上传失败仅记 warning、不拖垮其余（原串行版会让一个失败中断后续所有技能）。
+        # 内存安全：技能库总量 ~2.9MB / 最大单文件 ~608KB，base64 编码瞬时膨胀 ~3x，
+        # 6 路并发最坏额外内存峰值 ~10MB 量级，对服务进程可忽略；若未来技能塞入大资源文件，
+        # 可调低此值或改走 aupload_stream_from_disk 流式上传。
+        _SKILL_SYNC_CONCURRENCY = 6
+        _sync_sem = asyncio.Semaphore(_SKILL_SYNC_CONCURRENCY)
+
+        async def _sync_one(skill_name, local_version, src, remote_version):
+            # 删除旧目录(走 /delete,跳过懒同步,毫秒级)
             if skill_name in existing_dirs:
                 deleted_ok = False
                 for _attempt in range(2):  # 最多重试一次，确保旧内容真删掉
@@ -1473,11 +1625,21 @@ async def _sync_skills_to_sandbox(
                         f"[DeepAgent] 删除旧版技能彻底失败，本次跳过: {skill_name}")
 
             # 全量上传整个技能目录到沙箱(batch_upload 服务端无条件覆盖)
-            await backend.async_sync_dirs([(src, f"{sandbox_dest}/{skill_name}")])
+            try:
+                async with _sync_sem:
+                    await backend.async_sync_dirs([(src, f"{sandbox_dest}/{skill_name}")])
+            except Exception as e:
+                SYLogger.warning(
+                    f"[DeepAgent] 技能上传失败: {skill_name}, {e}")
+                return 0
             backend._synced_skills.add(skill_name)
-            skill_count += 1
             SYLogger.info(
                 f"[DeepAgent] 全量同步技能到沙箱: {skill_name} v{local_version}")
+            return 1
+
+        if pending:
+            results = await asyncio.gather(*[_sync_one(*p) for p in pending])
+            skill_count = sum(r for r in results if r)
 
         if chmod_readonly:
             try:

sycommon/agent/middleware/model_request_prep.py

@@ -45,8 +45,16 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
     通过 ``awrap_model_call`` 在调用 handler 前改造 request。与
     ``TokenTrackingMiddleware`` / ``SensitiveGuardMiddleware`` 同一套写法，
     需排在 ``SummarizationMiddleware`` 之后（摘要 HumanMessage 由后者产生）。
+
+    另持有 ``last_summary_text``（最近一次注入 system 的备忘原文），
+    供 deep_agent 的输出兜底（首句与备忘重叠检测）使用。同一 agent 实例
+    串行会话下读取方在流式消费阶段访问，与写入（模型调用前）天然错开，
+    无并发竞争；多轮压缩时被新摘要覆盖，兜底始终比对最新一版。
     """
 
+    #: 最近一次注入 system_message 的备忘原文（无摘要时为 None）
+    last_summary_text: Optional[str] = None
+
     @property
     def name(self) -> str:
         return "ModelRequestPrepMiddleware"
@@ -77,13 +85,20 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
             return request
 
         from deepagents.middleware._utils import append_to_system_message
+        # 🔑 注入形态 = 备忘在前、行为契约在后（recency：靠近对话末端的指令
+        # 遵循度最高），且用正向指令替代"不要复述"禁令 —— 负向禁令对
+        # glm/DeepSeek 系模型有反向唤起效果（提到"复述"反而引导复述）。
         _summary_directive = (
             "\n\n<system_context>\n"
-            "以下是之前对话历史的压缩摘要，作为你的内部记忆使用。"
-            "把它当作你自己的回忆，绝对不要在回复中重复、复述或引用此内容的任何部分。\n"
+            "以下是之前对话历史的压缩备忘（内部笔记，仅供你参考，不属于对话内容）。\n"
             f"{_summary_text}\n"
+            "\n回复规范：直接以对新问题的回答开头。"
+            "备忘中的相关要素直接融入回答本身；"
+            "不要先盘点、复述或引用备忘内容，也不要提及备忘的存在。\n"
             "</system_context>"
         )
+        # 记录备忘原文，供 deep_agent 输出兜底（首句重叠检测）比对
+        self.last_summary_text = _summary_text
         _new_sys = append_to_system_message(
             request.system_message, _summary_directive)
         return request.override(messages=_filtered, system_message=_new_sys)

sycommon/agent/middleware/sensitive_guard.py

@@ -14,6 +14,7 @@ agent 本就是内部模型（model_tier="internal"）时短路放行，不检
 """
 import asyncio
 import os
+import time
 from typing import Any, Awaitable, Callable, List, Optional
 
 from langchain.agents.middleware.types import (
@@ -458,10 +459,13 @@ class SensitiveGuardMiddleware(AgentMiddleware):
             # 恢复，让检测器在干净的上下文里跑（非流式、不进用户事件流）。
             from langchain_core.runnables.config import var_child_runnable_config
             _ctx_token = var_child_runnable_config.set({})
+            _t0 = time.perf_counter()
             try:
                 raw = await detector.ainvoke(prompt)
             finally:
                 var_child_runnable_config.reset(_ctx_token)
+            _dt = time.perf_counter() - _t0
+            SYLogger.info(f"[Perf] sensitive_detect: {_dt:.3f}s")
             text = raw.content if isinstance(raw, BaseMessage) else str(raw)
             check = _parse_detect_json(text)
             if check is None: