feat(beaver): 完成Task Team功能v1实现，重构后端架构支持统一内核

新增内部Task系统，包括验证、反馈门控机制，实现自动质量验证
(通过率>=0.75)和用户反馈闭环(satisfied/revise/abandon)。

实现Agent Team v1协调器，支持sequence/parallel/dag执行策略，
sub-agent复用主AgentLoop，每个run使用独立memory snapshot。

建立Skill学习pipeline，包含draft/审核/发布/回滚完整生命周期，
通过Task验证通过且用户满意才生成学习候选。

重构目录结构，移除third_party依赖，建立统一engine内核，
所有agent共享运行时基础组件。

更新ContextBuilder清理provider消息字段，增强SkillContext版本管理，
集成TaskExecutionPlanner和TaskSkillResolver实现技能解析机制。

app-instance/backend/beaver/tasks/store.py

@@ -0,0 +1,100 @@
+"""File-backed internal task store."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+from pathlib import Path
+from typing import Any
+
+from .models import TaskEvent, TaskRecord
+
+
+class TaskStore:
+    def __init__(self, root: str | Path) -> None:
+        self.root = Path(root)
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.tasks_path = self.root / "tasks.json"
+        self.events_path = self.root / "events.jsonl"
+        self._lock = threading.Lock()
+
+    def list_tasks(self) -> list[TaskRecord]:
+        with self._lock:
+            payload = self._read_tasks_unlocked()
+        return [TaskRecord.from_dict(item) for item in payload.values()]
+
+    def get_task(self, task_id: str) -> TaskRecord | None:
+        with self._lock:
+            payload = self._read_tasks_unlocked().get(task_id)
+        return TaskRecord.from_dict(payload) if isinstance(payload, dict) else None
+
+    def get_task_by_run_id(self, run_id: str) -> TaskRecord | None:
+        for task in self.list_tasks():
+            if run_id in task.run_ids:
+                return task
+        return None
+
+    def get_latest_open_task(self, session_id: str) -> TaskRecord | None:
+        tasks = [
+            task
+            for task in self.list_tasks()
+            if task.session_id == session_id and task.status in {"awaiting_feedback", "needs_revision", "open", "running"}
+        ]
+        if not tasks:
+            return None
+        return sorted(tasks, key=lambda item: item.updated_at)[-1]
+
+    def upsert_task(self, task: TaskRecord) -> None:
+        with self._lock:
+            payload = self._read_tasks_unlocked()
+            payload[task.task_id] = task.to_dict()
+            self._write_tasks_unlocked(payload)
+
+    def append_event(self, event: TaskEvent) -> None:
+        self.events_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._lock:
+            with self.events_path.open("a", encoding="utf-8") as handle:
+                handle.write(json.dumps(event.to_dict(), ensure_ascii=False, sort_keys=True) + "\n")
+
+    def list_events(self, task_id: str | None = None) -> list[TaskEvent]:
+        if not self.events_path.exists():
+            return []
+        results: list[TaskEvent] = []
+        for line in self.events_path.read_text(encoding="utf-8").splitlines():
+            cleaned = line.strip()
+            if not cleaned:
+                continue
+            payload = json.loads(cleaned)
+            if not isinstance(payload, dict):
+                continue
+            event = TaskEvent.from_dict(payload)
+            if task_id is not None and event.task_id != task_id:
+                continue
+            results.append(event)
+        return results
+
+    def _read_tasks_unlocked(self) -> dict[str, dict[str, Any]]:
+        if not self.tasks_path.exists():
+            return {}
+        payload = json.loads(self.tasks_path.read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            return {}
+        tasks = payload.get("tasks", payload)
+        if not isinstance(tasks, dict):
+            return {}
+        return {str(key): dict(value) for key, value in tasks.items() if isinstance(value, dict)}
+
+    def _write_tasks_unlocked(self, payload: dict[str, dict[str, Any]]) -> None:
+        self.tasks_path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp_name = tempfile.mkstemp(prefix=".tasks-", suffix=".json", dir=str(self.tasks_path.parent))
+        tmp_path = Path(tmp_name)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump({"tasks": payload}, handle, ensure_ascii=False, indent=2, sort_keys=True)
+                handle.write("\n")
+            os.replace(tmp_path, self.tasks_path)
+        finally:
+            if tmp_path.exists():
+                tmp_path.unlink()