devmate 2.5.0__tar.gz → 2.5.2__tar.gz

{devmate-2.5.0 → devmate-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devmate
-Version: 2.5.0
+Version: 2.5.2
 Summary: 程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定
 Author-email: DevMate Team <devmate@example.com>
 License: MIT

{devmate-2.5.0 → devmate-2.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devmate"
-version = "2.5.0"
+version = "2.5.2"
 description = "程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定"
 readme = "README.md"
 authors = [

{devmate-2.5.0 → devmate-2.5.2}/src/devmate/__init__.py

@@ -1,6 +1,6 @@
 """
 DevMate — 程序员终端瑞士军刀
 """
-__version__ = "2.5.0"
+__version__ = "2.5.2"
 __app_name__ = "DevMate"
 __description__ = "程序员终端瑞士军刀——替代 5 个独立工具，一个 CLI 搞定"

{devmate-2.5.0 → devmate-2.5.2}/src/devmate/agent/validators.py

@@ -195,3 +195,89 @@ def summarize_validation(results: list[ValidatorResult]) -> str:
         return "无适用校验器"
     ok_count = sum(1 for r in results if r.ok)
     return f"{ok_count}/{len(results)} 校验通过"
+
+
+# ═══════════════════════════════════════════════════
+# 自动修复闭环（P0-②）：校验失败 → 自动修复 → 重验
+# ═══════════════════════════════════════════════════
+
+def auto_fix(path: str, dry_run: bool = False) -> dict:
+    """校验失败时尝试自动修复
+
+    当前支持：
+      - python_style:  ruff check --fix（自动修风格问题）
+      - python_syntax: 无自动修复（需 Agent 介入）
+
+    Args:
+        path: 文件路径
+        dry_run: 仅预览修复（ruff --diff）
+
+    Returns:
+        {"fixed": bool, "before": str, "after": str, "details": [...]}
+    """
+    result = {"fixed": False, "before": "", "after": "", "details": []}
+    ext = Path(path).suffix.lower()
+
+    # ruff 自动修复（Python 风格问题）
+    if ext == ".py":
+        try:
+            cmd = ["ruff", "check", "--fix"]
+            if dry_run:
+                cmd = ["ruff", "check", "--diff"]
+            cmd.append(path)
+            r = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            if r.returncode in (0, 1):
+                # returncode 0 = 无问题；1 = 有问题但已修/有剩余
+                # 检测是否有修复
+                after = Path(path).read_text(errors="replace")
+                before = result["before"]  # noqa: F841
+                if dry_run:
+                    result["details"].append("dry-run: 预览修复差异")
+                    result["after"] = r.stdout[:500]
+                else:
+                    result["after"] = after[:200]
+                # 检查是否还有残留问题
+                remaining = validate_file_feedback(path)
+                if not remaining:
+                    result["fixed"] = True
+                    result["details"].append("ruff 自动修复完成，校验通过")
+                else:
+                    result["details"].append(f"ruff 修复后仍有问题: {remaining[:100]}")
+        except FileNotFoundError:
+            result["details"].append("ruff 不可用，跳过自动修复")
+
+    # 记录修复前状态（用于对比）
+    try:
+        result["before"] = Path(path).read_text(errors="replace")[:200]
+    except Exception:
+        pass
+
+    return result
+
+
+def validate_with_autofix(path: str) -> dict:
+    """校验 + 自动修复 + 重验 完整闭环
+
+    Returns:
+        {"feedback": str, "auto_fixed": bool, "results": [...]}
+    """
+    # 第一轮校验
+    feedback = validate_file_feedback(path)
+    auto_fixed = False
+    details = []
+
+    if feedback:
+        # 尝试自动修复
+        fix_result = auto_fix(path)
+        auto_fixed = fix_result["fixed"]
+        if fix_result["details"]:
+            details.extend(fix_result["details"])
+        # 重验
+        feedback = validate_file_feedback(path)
+
+    return {
+        "feedback": feedback,
+        "auto_fixed": auto_fixed,
+        "details": details,
+        "results": validate_file(path),
+    }

{devmate-2.5.0 → devmate-2.5.2}/src/devmate/app/cli.py

@@ -3524,20 +3524,29 @@ def wf_drift_check():
 
 
 @wf_group.command("daemon", help="调度守护进程")
-@click.argument("action", type=click.Choice(["start", "stop", "status"]))
+@click.argument("action", type=click.Choice(["start", "stop", "status", "autostart", "no-autostart"]))  # noqa: E501
 @click.option("--interval", default=30, type=int, help="检查间隔（秒）")
-def wf_daemon(action, interval):
+@click.option("--retries", default=0, type=int, help="失败自动重试次数")
+def wf_daemon(action, interval, retries):
     """调度守护进程：常驻自动执行 cron 到期的调度任务
 
     用法:
-      devmate wf daemon start [--interval 30]    # 启动（每 30s 检查）
-      devmate wf daemon status                   # 查询状态
-      devmate wf daemon stop                     # 停止
+      devmate wf daemon start [--interval 30] [--retries 2]  # 启动（重试 2 次）
+      devmate wf daemon status                    # 查询状态
+      devmate wf daemon stop                      # 停止
+      devmate wf daemon autostart                 # 安装 launchd 开机自启（macOS）
+      devmate wf daemon no-autostart              # 卸载开机自启
     """
-    from devmate.workflow import daemon_start, daemon_status, daemon_stop
+    from devmate.workflow import (
+        daemon_install_launchd,
+        daemon_start,
+        daemon_status,
+        daemon_stop,
+        daemon_uninstall_launchd,
+    )
 
     if action == "start":
-        result = daemon_start(interval=interval)
+        result = daemon_start(interval=interval, retries=retries)
         console.print(f"[green]{result.data['message']}[/green]" if result.success
                       else f"[red]❌ {result.error}[/red]")
         console.print(f"[dim]日志: {result.data.get('log', '')}[/dim]")
@@ -3552,6 +3561,14 @@ def wf_daemon(action, interval):
         result = daemon_stop()
         console.print(f"[green]{result.data['message']}[/green]" if result.success
                       else f"[yellow]❌ {result.error}[/yellow]")
+    elif action == "autostart":
+        result = daemon_install_launchd()
+        console.print(f"[green]{result.data['message']}[/green]" if result.success
+                      else f"[red]❌ {result.error}[/red]")
+    elif action == "no-autostart":
+        result = daemon_uninstall_launchd()
+        console.print(f"[green]{result.data['message']}[/green]" if result.success
+                      else f"[red]❌ {result.error}[/red]")
 
 
 @wf_group.command("rm-step", help="删除工作流的第 N 个步骤")

{devmate-2.5.0 → devmate-2.5.2}/src/devmate/app/web/__init__.py

@@ -781,6 +781,21 @@ async def ai_config_set(request: Request, _: str = Depends(require_auth)):
 
 # ── Skill 库页面 ─────────────────────────────────
 
+@app.get("/plugins", response_class=HTMLResponse)
+async def plugins_page(request: Request, _: str = Depends(require_auth),
+                       message: str = ""):
+    """已安装插件管理页面"""
+    from devmate.plugin import list_installed, registry
+    installed = list_installed()
+    discovered = [p for p in registry.discover() if "error" not in p]
+    return templates.TemplateResponse(
+        "plugins.html",
+        {"request": request, "modules": MODULES, "active_module": "",
+         "installed": installed, "discovered": discovered,
+         "version": __version__, "message": message},
+    )
+
+
 @app.get("/skill", response_class=HTMLResponse)
 async def skill_page(request: Request, _: str = Depends(require_auth),
                      message: str = ""):

devmate-2.5.2/src/devmate/sub_agent/__init__.py

@@ -0,0 +1,237 @@
+"""devmate.sub_agent — Sub-agent 隔离（P0-⑥ · Context Isolate）
+
+方法论：Context Engineering 五动作之一「隔离（Isolate）」
+  - 旁支任务委派给独立上下文的 Sub-agent
+  - 主 Agent 不承载子任务细节，只拿回结构化结果摘要
+  - 长任务 → 拆子任务 → 各子任务独立上下文 → 汇总
+  - 输出契约（多 Agent 工程三原则）：每个子任务声明期望输出格式
+    缺失字段 → 标记 schema_failed（关键节点校验）
+
+设计：
+  - Sub-agent 复用 AgentRuntime（独立 SessionMemory，互不污染）
+  - 结果自动截断/摘要，只回传关键信息给主上下文
+  - 支持并行执行多个子任务（ThreadPoolExecutor）
+  - 输出契约：expected_schema 声明字段名→类型，结果校验缺字段/类型错
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path  # noqa: F401
+
+from devmate.bus.command import CommandResult
+
+# 允许的 schema 类型
+_SCHEMA_TYPES = {"string": str, "int": int, "float": (int, float),
+                 "bool": bool, "list": list, "dict": dict, "any": object}
+
+
+@dataclass
+class SubTask:
+    """子任务定义"""
+    name: str                       # 子任务名
+    prompt: str                     # 子任务指令（独立上下文）
+    max_steps: int = 5              # 最大步数
+    tool_whitelist: list[str] = field(default_factory=list)  # 允许的工具白名单
+    expected_schema: dict | None = None  # 输出契约 {字段: 类型}（如 {"host": "string"})
+    schema_required: bool = True    # 契约校验失败是否算任务失败
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "prompt": self.prompt,
+                "max_steps": self.max_steps,
+                "tool_whitelist": self.tool_whitelist,
+                "expected_schema": self.expected_schema}
+
+
+def validate_schema(output: str, schema: dict) -> tuple[bool, list[str]]:
+    """校验输出是否符合契约
+
+    策略（宽容解析）：
+      1. 尝试 JSON 解析（输出可能是 JSON）
+      2. 否则尝试 key: value 逐行解析
+      3. 从文本中按字段名查找
+
+    Returns:
+        (是否通过, 缺失/错误字段列表)
+    """
+    if not schema:
+        return True, []
+
+    # 尝试 JSON 解析
+    obj = None
+    try:
+        obj = json.loads(output)
+    except Exception:
+        pass
+
+    issues = []
+    for field_name, field_type in schema.items():
+        # 定位值
+        value = None
+        if isinstance(obj, dict):
+            value = obj.get(field_name)
+        elif obj is not None:
+            continue  # JSON 数组等，无法按字段校验
+        else:
+            # 行解析：key: value
+            for line in output.splitlines():
+                line = line.strip().lstrip("-• ")
+                if ":" in line:
+                    k, _, v = line.partition(":")
+                    if k.strip().strip('"').strip("'") == field_name:
+                        value = v.strip()
+                        break
+            if value is None:
+                # 全文包含字段名
+                if field_name in output:
+                    continue  # 出现但无法解析值，视为通过
+
+        if value is None or value == "":
+            issues.append(f"{field_name} 缺失")
+            continue
+
+        # 类型校验（宽容：去掉逗号/百分号/中文单位后缀）
+        expected_type = _SCHEMA_TYPES.get(field_type, object)
+        try:
+            clean = str(value).replace(",", "").replace("%", "")
+            # 去常见中英文单位后缀（核/GB/MB/秒/ms/元/%）
+            for unit in ("核", "个", "台", "GB", "MB", "KB", "秒", "ms", "元",
+                         "字节", "张", "条"):
+                clean = clean.removesuffix(unit)
+            clean = clean.strip()
+            if field_type == "int":
+                int(clean)
+            elif field_type == "float":
+                float(clean)
+            elif field_type == "string":
+                str(value)
+            elif field_type in ("list", "dict"):
+                if not isinstance(value, expected_type):
+                    issues.append(f"{field_name} 类型错误(期望 {field_type})")
+            elif field_type == "bool":
+                if str(value).lower() not in ("true", "false", "1", "0", "是", "否"):
+                    issues.append(f"{field_name} 类型错误(期望 bool)")
+            elif field_type == "any":
+                pass
+            elif not isinstance(value, expected_type):
+                issues.append(f"{field_name} 类型错误(期望 {field_type})")
+        except (ValueError, TypeError):
+            issues.append(f"{field_name} 类型错误(期望 {field_type})")
+
+    return not issues, issues
+
+
+@dataclass
+class SubTaskResult:
+    """子任务结果"""
+    name: str
+    success: bool
+    summary: str = ""
+    duration_ms: float = 0.0
+    steps: int = 0
+    error: str = ""
+    schema_ok: bool = True         # 输出契约校验是否通过
+    schema_missing: list[str] = field(default_factory=list)  # 缺失/错误字段
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "success": self.success,
+                "summary": self.summary[:300],
+                "duration_ms": round(self.duration_ms, 1),
+                "steps": self.steps, "error": self.error[:200],
+                "schema_ok": self.schema_ok,
+                "schema_missing": self.schema_missing}
+
+
+def run_subtask(task: SubTask, workdir: str = ".") -> SubTaskResult:
+    """执行单个子任务（独立上下文）
+
+    用 AgentRuntime 跑，但：
+      - 独立 SessionMemory（不污染主 Agent）
+      - 独立工具环境（tool_whitelist 过滤）
+      - 结果只回传摘要 + 输出契约校验（expected_schema）
+    """
+    start = time.time()
+    try:
+        from devmate_agent import AgentRuntime
+
+        runtime = AgentRuntime()
+
+        # 工具白名单过滤（隔离：子任务只看到允许的工具）
+        if task.tool_whitelist:
+            allowed = set(task.tool_whitelist)
+            for tname in list(runtime.tools.list_names()):
+                if tname not in allowed:
+                    runtime.tools.unregister(tname)
+
+        # 运行子任务（dry_run=False 真实执行）
+        result = runtime.run(task.prompt, max_steps=task.max_steps)
+
+        if result.success:
+            data = result.data
+            summary = str(data.get("final_output", data.get("output", "")))[:300]
+            # 输出契约校验（关键节点校验：缺失字段标记失败）
+            schema_ok, missing = True, []
+            if task.expected_schema:
+                schema_ok, missing = validate_schema(summary, task.expected_schema)
+                if not schema_ok and task.schema_required:
+                    return SubTaskResult(
+                        name=task.name, success=False,
+                        error=f"输出契约校验失败: 缺 {', '.join(missing)}",
+                        summary=summary, schema_ok=False,
+                        schema_missing=missing,
+                        duration_ms=(time.time() - start) * 1000,
+                        steps=data.get("step_count", data.get("total_steps", 0)),
+                    )
+            return SubTaskResult(
+                name=task.name, success=True, summary=summary,
+                duration_ms=(time.time() - start) * 1000,
+                steps=data.get("step_count", data.get("total_steps", 0)),
+                schema_ok=schema_ok, schema_missing=missing,
+            )
+        return SubTaskResult(
+            name=task.name, success=False,
+            error=str(result.error or "任务失败"),
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except Exception as e:
+        return SubTaskResult(
+            name=task.name, success=False, error=str(e),
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+def run_subtasks(tasks: list[SubTask], workdir: str = ".",
+                 parallel: bool = True) -> CommandResult:
+    """并行/串行执行多个子任务
+
+    Args:
+        tasks: 子任务列表
+        workdir: 工作目录
+        parallel: 是否并行（默认 True）
+    """
+    results = []
+    if parallel and len(tasks) > 1:
+        from concurrent.futures import ThreadPoolExecutor
+        with ThreadPoolExecutor(max_workers=min(len(tasks), 4)) as pool:
+            futures = {pool.submit(run_subtask, t, workdir): t.name
+                       for t in tasks}
+            # 保持任务顺序
+            ordered = [futures[f] for f in futures]
+            for f, name in zip(futures, ordered):
+                results.append(f.result())
+    else:
+        for t in tasks:
+            results.append(run_subtask(t, workdir))
+
+    success = sum(1 for r in results if r.success)
+    total = len(results)
+    return CommandResult(success=success == total, data={
+        "results": [r.to_dict() for r in results],
+        "success_count": success,
+        "total": total,
+        "message": f"Sub-agents: {success}/{total} 成功",
+        "summary": "\n".join(
+            f"[{'✅' if r.success else '❌'}] {r.name}: "
+            f"{r.summary or r.error}" for r in results
+        )[:800],
+    })

{devmate-2.5.0 → devmate-2.5.2}/src/devmate/workflow/__init__.py

@@ -1238,9 +1238,14 @@ def list_schedules() -> CommandResult:
     })
 
 
-def run_due_workflows(now: time.struct_time | None = None) -> CommandResult:
+def run_due_workflows(now: time.struct_time | None = None,
+                      retries: int = 0) -> CommandResult:
     """执行所有到期的调度工作流（供 scheduler 守护进程调用）
 
+    Args:
+        now: 当前时间（测试可注入）
+        retries: 失败自动重试次数（P2-⑪，默认 0 不重试）
+
     返回: 已执行的调度列表
     """
     schedules = _load_schedules()
@@ -1256,15 +1261,27 @@ def run_due_workflows(now: time.struct_time | None = None) -> CommandResult:
                 continue
             result = run(name)
             ok = result.success and result.data.get("fail_count", 0) == 0
+            retry_count = 0
+
+            # 失败重试（指数退避：2s → 4s → 8s）
+            while not ok and retry_count < retries:
+                retry_count += 1
+                import time as _t
+                _t.sleep(min(2 ** retry_count, 10))
+                result = run(name)
+                ok = result.success and result.data.get("fail_count", 0) == 0
+
             # 更新调度状态
             sched["last_run"] = time.strftime("%Y-%m-%d %H:%M:%S")
             sched["last_status"] = "success" if ok else "failed"
+            sched["retries"] = retry_count
             executed.append({
                 "name": name,
                 "status": "success" if ok else "failed",
                 "success_count": result.data.get("success_count", 0),
                 "fail_count": result.data.get("fail_count", 0),
                 "verified": result.data.get("verified"),
+                "retries": retry_count,
             })
             # 失败告警（调度级 notify）
             if sched.get("notify") and not ok:
@@ -1365,9 +1382,14 @@ def daemon_status() -> CommandResult:
         })
 
 
-def daemon_start(interval: int = POLL_INTERVAL) -> CommandResult:
+def daemon_start(interval: int = POLL_INTERVAL,
+                 retries: int = 0) -> CommandResult:
     """启动守护进程（后台）
 
+    Args:
+        interval: 检查间隔（秒）
+        retries: 失败自动重试次数（P2-⑪）
+
     每 interval 秒检查一次 cron 到期的工作流并执行。
     """
     import subprocess
@@ -1382,15 +1404,17 @@ import sys, time, json
 sys.path.insert(0, {str(Path(__file__).resolve().parent.parent.parent)!r})
 from devmate.workflow import run_due_workflows, daemon_status
 INTERVAL = {int(interval)}
+RETRIES = {int(retries)}
 def _log(msg):
     ts = time.strftime("%Y-%m-%d %H:%M:%S")
     print(f"[{{ts}}] {{msg}}", flush=True)
 while True:
     try:
-        r = run_due_workflows()
+        r = run_due_workflows(retries=RETRIES)
         if r.data.get("ran"):
             for item in r.data["ran"]:
-                _log(f"执行 {{item['name']}}: {{item.get('status')}}")
+                _log(f"执行 {{item['name']}}: {{item.get('status')}}"
+                     f"(重试{{item.get('retries', 0)}})")
     except Exception as e:
         _log(f"调度错误: {{e}}")
     time.sleep(INTERVAL)
@@ -1405,13 +1429,88 @@ while True:
         )
         DAEMON_PID_FILE.write_text(str(proc.pid))
         return CommandResult(success=True, data={
-            "message": f"✅ 守护进程已启动 (PID {proc.pid}, 每 {interval}s 检查)",
+            "message": (f"✅ 守护进程已启动 (PID {proc.pid}, 每 {interval}s 检查, "
+                        f"重试 {retries} 次)"),
             "pid": proc.pid, "log": str(DAEMON_LOG_FILE),
         })
     except Exception as e:
         return CommandResult(success=False, error=f"启动失败: {e}")
 
 
+def daemon_install_launchd() -> CommandResult:
+    """安装 launchd 开机自启（P2-⑫ · macOS）
+
+    生成 ~/Library/LaunchAgents/com.devmate.scheduler.plist
+    开机自动启动 `devmate wf daemon start`
+    """
+    import shutil as _shutil
+    import subprocess as _subprocess
+
+    label = "com.devmate.scheduler"
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"
+
+    # 找到 devmate 可执行文件
+    devmate_bin = _shutil.which("devmate")
+    if not devmate_bin:
+        # 回退到 python -m devmate
+        import sys
+        devmate_bin = f"{sys.executable} -m devmate"
+
+    plist = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{label}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>bash</string>
+        <string>-lc</string>
+        <string>{devmate_bin} wf daemon start --interval 30 --retries 2</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>{DAEMON_LOG_FILE}</string>
+    <key>StandardErrorPath</key>
+    <string>{DAEMON_LOG_FILE}</string>
+</dict>
+</plist>
+"""
+    try:
+        plist_path.parent.mkdir(parents=True, exist_ok=True)
+        plist_path.write_text(plist)
+        # 加载
+        _subprocess.run(["launchctl", "load", str(plist_path)],
+                        capture_output=True, timeout=15)
+        return CommandResult(success=True, data={
+            "message": f"✅ 已安装开机自启: {plist_path}",
+            "plist": str(plist_path),
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=f"安装失败: {e}")
+
+
+def daemon_uninstall_launchd() -> CommandResult:
+    """卸载 launchd 开机自启"""
+    import subprocess as _subprocess
+
+    label = "com.devmate.scheduler"
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"
+    try:
+        if plist_path.exists():
+            _subprocess.run(["launchctl", "unload", str(plist_path)],
+                            capture_output=True, timeout=15)
+            plist_path.unlink()
+        return CommandResult(success=True, data={
+            "message": "✅ 已卸载开机自启",
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=f"卸载失败: {e}")
+
+
 def daemon_stop() -> CommandResult:
     """停止守护进程"""
     st = daemon_status()

{devmate-2.5.0 → devmate-2.5.2}/src/devmate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devmate
-Version: 2.5.0
+Version: 2.5.2
 Summary: 程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定
 Author-email: DevMate Team <devmate@example.com>
 License: MIT

{devmate-2.5.0 → devmate-2.5.2}/src/devmate.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/devmate/security/audit.py
 src/devmate/security/vault.py
 src/devmate/share/__init__.py
 src/devmate/skill/__init__.py
+src/devmate/sub_agent/__init__.py
 src/devmate/workflow/__init__.py
 src/devmate_agent/__init__.py
 src/devmate_apidev/__init__.py

{devmate-2.5.0 → devmate-2.5.2}/src/devmate_agent/__init__.py

@@ -133,6 +133,10 @@ class ToolRegistry:
     def list_names(self) -> list[str]:
         return list(self._tools.keys())
 
+    def unregister(self, name: str):
+        """移除工具（Sub-agent 隔离用）"""
+        self._tools.pop(name, None)
+
     def register_builtin(self):
         """注册 16 个模块的核心工具"""
         self.register(Tool(
@@ -384,20 +388,25 @@ class ToolRegistry:
         p.parent.mkdir(parents=True, exist_ok=True)
         p.write_text(content, encoding="utf-8")
         result = f"已写入 {len(content)} 字节到 {path}"
-        # Post-edit checkpoint：写文件后自动校验（验证信号注入）
+        # Post-edit checkpoint：写文件后自动校验 + 自动修复（验证信号注入）
         # 下沉到 handler —— Agent 主循环 / workflow / skill 所有路径统一受益
         try:
             from devmate.agent.validators import (
                 summarize_validation,
-                validate_file,
-                validate_file_feedback,
+                validate_with_autofix,
             )
-            results = validate_file(str(p))
-            feedback = validate_file_feedback(str(p))
-            if feedback:
-                result += f"\n\n[校验反馈]\n{feedback}"
-            elif results:
-                result += f"\n\n[校验] {summarize_validation(results)}"
+            outcome = validate_with_autofix(str(p))
+            if outcome["auto_fixed"]:
+                result += ("\n\n[校验] 已自动修复风格问题，"
+                           "重新校验通过")
+            elif outcome["feedback"]:
+                result += f"\n\n[校验反馈]\n{outcome['feedback']}"
+            else:
+                results = outcome.get("results", [])
+                if results:
+                    result += f"\n\n[校验] {summarize_validation(results)}"
+                else:
+                    result += "\n\n[校验] 通过"
         except Exception:
             pass  # 校验失败不影响写入结果
         return result
@@ -556,21 +565,46 @@ class TraceStep:
 
 @dataclass
 class SessionMemory:
-    """会话记忆（滑动窗口）"""
+    """会话记忆（滑动窗口 + 摘要压缩）"""
     messages: list[dict] = field(default_factory=list)
     max_turns: int = 10
+    compress: bool = False  # 超窗口时压缩为摘要（P1-⑦），而非丢弃
+    summary: str = ""       # 已压缩的早期历史摘要
 
     def add(self, role: str, content: str, tool_calls: list | None = None):
         msg = {"role": role, "content": content}
         if tool_calls:
             msg["tool_calls"] = tool_calls
         self.messages.append(msg)
-        # 滑动窗口
+        # 滑动窗口（超窗时压缩或丢弃早期历史）
         if len(self.messages) > self.max_turns * 2:
-            if self.messages[0]["role"] == "system":
-                self.messages = [self.messages[0]] + self.messages[-(self.max_turns * 2 - 1):]
-            else:
-                self.messages = self.messages[-(self.max_turns * 2):]
+            overflow = self.messages[:-(self.max_turns * 2)]
+            keep = self.messages[-(self.max_turns * 2):]
+            if self.compress:
+                self._compress(overflow)
+            if keep and keep[0]["role"] == "system":
+                keep = keep[1:]
+            # 压缩摘要作为 system 消息注入最前
+            if self.summary:
+                keep.insert(0, {
+                    "role": "system",
+                    "content": f"[历史摘要] {self.summary[:500]}",
+                })
+            self.messages = keep
+
+    def _compress(self, overflow: list[dict]):
+        """把溢出的历史压缩为摘要（保留关键信息）"""
+        parts = []
+        for msg in overflow:
+            role = msg.get("role", "")
+            content = str(msg.get("content", ""))[:100]
+            if role == "user":
+                parts.append(f"用户说: {content}")
+            elif role == "assistant":
+                parts.append(f"助手: {content[:60]}")
+            elif role == "tool":
+                parts.append(f"工具({msg.get('name','')}): {content[:50]}")
+        self.summary = "；".join(parts[-10:])  # 只保留最近 10 条溢出
 
     def add_tool_result(self, tool_call_id: str, name: str, content: str):
         self.messages.append({
@@ -585,6 +619,7 @@ class SessionMemory:
 
     def clear(self):
         self.messages = []
+        self.summary = ""
 
 
 _DEFAULT_SYSTEM_PROMPT = """你是一个 DevMate 智能助手，可以调用工具来帮助用户完成开发任务。
@@ -603,10 +638,11 @@ class AgentRuntime:
     """Agent 运行时——真正的 ReAct 循环 + LLM 驱动"""
 
     def __init__(self, llm_config: dict | None = None,
-                 system_prompt: str = "", connect_mcp: bool = False):
+                 system_prompt: str = "", connect_mcp: bool = False,
+                 compress_memory: bool = True):
         self.tools = ToolRegistry()
         self.tools.register_builtin()
-        self.memory = SessionMemory()
+        self.memory = SessionMemory(compress=compress_memory)
         self.trace: list[TraceStep] = []
         self.system_prompt = system_prompt or _DEFAULT_SYSTEM_PROMPT
 
@@ -803,6 +839,12 @@ class AgentRuntime:
             "duration_ms": round(duration_ms, 1),
         })
         self._save_audit()
+        # 行为信号自动采集（P1-⑨）：成功工具调用 → 记忆观察计数自动递增
+        if success and action == "execute":
+            try:
+                self._collect_behavior_signal(tool, args)
+            except Exception:
+                pass
         # 同步到全局审计模块
         try:
             from devmate.security.audit import AuditEntry, audit
@@ -817,6 +859,28 @@ class AgentRuntime:
         except Exception:
             pass
 
+    def _collect_behavior_signal(self, tool: str, args: dict):
+        """行为信号自动采集（P1-⑨）
+
+        成功工具调用 → 记忆观察计数自动递增（无需手动 set）
+        key 形如: tool:monitor_dashboard / tool:write_file
+        """
+        from devmate.memory_store import set_memory
+        key = f"tool:{tool}"
+        # 高频工具自动采集（排除敏感写操作）
+        if tool in ("write_file", "file_organize", "ssh_run"):
+            return
+        label = {"monitor_dashboard": "巡检系统资源",
+                 "git_stats": "查看 Git 统计",
+                 "http_request": "请求 API",
+                 "note_search": "搜索笔记",
+                 "rag_search": "检索知识库",
+                 "file_size": "查看文件大小",
+                 "read_file": "读取文件",
+                 "skill_run": "执行 Skill",
+                 "db_query": "查询数据库"}.get(tool, f"调用 {tool}")
+        set_memory(key, label, scope="session", category="behavior")
+
     def run(self, user_message: str, max_steps: int = 10,
             dry_run: bool = False) -> CommandResult:
         """运行 Agent ReAct 循环