feat: 清理 control_node + 引入 task 一等公民

- control_node 标注 DEPRECATED：保留目录壳子供未来远程探针节点复用，删除调用路径与相关测试
- 新增 task 表：极简元数据持久化 regulatory_node 完成的短任务（出报告/写文件/查询整理）
- regulatory_node 自标注：MessageResponse 扩展 task_action/title/summary，_run 末尾非阻塞落库
- query_task_list 改查 task 表，符合用户对"任务列表"的直觉，与 workflow 体系解耦
- 新增 /api/v1/task/list|/{id} 只读 API（task 由 regulatory 内部触发，不开放对外创建）

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

kilostar/core/postgres_database/model/__init__.py

@@ -37,6 +37,7 @@ from kilostar.core.postgres_database.model.system_event_log import SystemEventLo
 from kilostar.core.postgres_database.model.persona_template import PersonaTemplate
 from kilostar.core.postgres_database.model.org_task import OrgTask
 from kilostar.core.postgres_database.model.org_task_event import OrgTaskEvent
+from kilostar.core.postgres_database.model.task import Task
 
 # 兼容旧代码的别名
 Provider = ProviderModel
@@ -69,5 +70,6 @@ __all__ = [
     "PersonaTemplate",
     "OrgTask",
     "OrgTaskEvent",
+    "Task",
     "AgentType",
 ]

kilostar/core/postgres_database/model/task.py

@@ -0,0 +1,54 @@
+#  Copyright 2026 zhaoxi826
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+"""Task：管控节点（regulatory_node）完成的短任务记录。
+
+与 workflow 不同，task 是上下文内能完成的轻量任务（写文件/查询/出报告等），
+表里只存最终元数据 + 结果摘要 + 关联 artifact，不入库执行过程。
+"""
+
+from sqlalchemy import String, DateTime, Text, func
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.dialects.postgresql import JSONB
+from .base import BaseDataModel
+
+
+class Task(BaseDataModel):
+    __tablename__ = "task"
+
+    task_id: Mapped[str] = mapped_column(
+        String(64), primary_key=True, comment="任务唯一 ID（UUID）"
+    )
+    user_id: Mapped[str] = mapped_column(
+        String(64), index=True, comment="所属用户 ID"
+    )
+    chat_id: Mapped[str | None] = mapped_column(
+        String(64), index=True, nullable=True, comment="所属对话（如有）"
+    )
+    command: Mapped[str] = mapped_column(
+        Text, comment="用户原始指令"
+    )
+    title: Mapped[str] = mapped_column(
+        String(255), comment="任务简短标题（LLM 生成）"
+    )
+    status: Mapped[str] = mapped_column(
+        String(20), index=True, default="completed",
+        comment="running / completed / failed",
+    )
+    result_summary: Mapped[str | None] = mapped_column(
+        Text, nullable=True, comment="完成后的结果摘要"
+    )
+    artifact_refs: Mapped[list | None] = mapped_column(
+        JSONB, nullable=True, comment="关联的 artifact url 列表"
+    )
+    created_at: Mapped[str] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), index=True
+    )
+    updated_at: Mapped[str] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )

kilostar/core/postgres_database/module/task.py

@@ -0,0 +1,104 @@
+#  Copyright 2026 zhaoxi826
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+"""Task DAO：管控节点短任务的最小持久化层。"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+from sqlalchemy import select, desc, update
+from sqlalchemy.ext.asyncio import async_sessionmaker, AsyncSession
+
+from kilostar.core.postgres_database.model.task import Task
+from kilostar.core.postgres_database.database_exception import database_exception
+
+
+class TaskDatabase:
+    def __init__(self, async_session_maker: async_sessionmaker[AsyncSession]):
+        self.async_session_maker = async_session_maker
+
+    @database_exception
+    async def create_task(
+        self,
+        task_id: str,
+        user_id: str,
+        command: str,
+        title: str,
+        chat_id: Optional[str] = None,
+        status: str = "completed",
+        result_summary: Optional[str] = None,
+        artifact_refs: Optional[list] = None,
+    ) -> None:
+        async with self.async_session_maker() as session:
+            row = Task(
+                task_id=task_id,
+                user_id=user_id,
+                chat_id=chat_id,
+                command=command,
+                title=title,
+                status=status,
+                result_summary=result_summary,
+                artifact_refs=artifact_refs,
+            )
+            session.add(row)
+            await session.commit()
+
+    @database_exception
+    async def update_status(
+        self,
+        task_id: str,
+        status: str,
+        result_summary: Optional[str] = None,
+    ) -> None:
+        async with self.async_session_maker() as session:
+            values = {"status": status}
+            if result_summary is not None:
+                values["result_summary"] = result_summary
+            stmt = update(Task).where(Task.task_id == task_id).values(**values)
+            await session.execute(stmt)
+            await session.commit()
+
+    @database_exception
+    async def get_task(self, task_id: str) -> Optional[dict]:
+        async with self.async_session_maker() as session:
+            stmt = select(Task).where(Task.task_id == task_id)
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            if not row:
+                return None
+            return _row_to_dict(row)
+
+    @database_exception
+    async def list_tasks_by_user(
+        self,
+        user_id: str,
+        status: Optional[str] = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> List[dict]:
+        async with self.async_session_maker() as session:
+            stmt = select(Task).where(Task.user_id == user_id)
+            if status:
+                stmt = stmt.where(Task.status == status)
+            stmt = stmt.order_by(desc(Task.created_at)).offset(offset).limit(limit)
+            rows = (await session.execute(stmt)).scalars().all()
+            return [_row_to_dict(r) for r in rows]
+
+
+def _row_to_dict(row: Task) -> dict:
+    return {
+        "task_id": row.task_id,
+        "user_id": row.user_id,
+        "chat_id": row.chat_id,
+        "command": row.command,
+        "title": row.title,
+        "status": row.status,
+        "result_summary": row.result_summary,
+        "artifact_refs": row.artifact_refs or [],
+        "created_at": str(row.created_at) if row.created_at else None,
+        "updated_at": str(row.updated_at) if row.updated_at else None,
+    }

kilostar/core/postgres_database/postgres.py

@@ -59,6 +59,7 @@ from .module.custom_toolset import CustomToolsetDatabase
 from .module.system_event_log import SystemEventLogDatabase
 from .module.persona_template import PersonaTemplateDatabase
 from .module.org_task import OrgTaskDatabase
+from .module.task import TaskDatabase
 
 
 @actor_class
@@ -93,6 +94,7 @@ class PostgresDatabase:
         self._system_event_log_database = SystemEventLogDatabase(self.async_session_maker)
         self._persona_template_database = PersonaTemplateDatabase(self.async_session_maker)
         self._org_task_database = OrgTaskDatabase(self.async_session_maker)
+        self._task_database = TaskDatabase(self.async_session_maker)
 
         self.ready_event = asyncio.Event()
 
@@ -487,3 +489,49 @@ class PostgresDatabase:
     async def query_org_events(self, task_id: str, limit=200):
         await self.ready_event.wait()
         return await self._org_task_database.query_events(task_id, limit)
+
+    # Task Methods（管控节点短任务）
+    async def create_task(
+        self,
+        task_id: str,
+        user_id: str,
+        command: str,
+        title: str,
+        chat_id: str | None = None,
+        status: str = "completed",
+        result_summary: str | None = None,
+        artifact_refs: list | None = None,
+    ):
+        await self.ready_event.wait()
+        return await self._task_database.create_task(
+            task_id=task_id,
+            user_id=user_id,
+            command=command,
+            title=title,
+            chat_id=chat_id,
+            status=status,
+            result_summary=result_summary,
+            artifact_refs=artifact_refs,
+        )
+
+    async def update_task_status(
+        self, task_id: str, status: str, result_summary: str | None = None
+    ):
+        await self.ready_event.wait()
+        return await self._task_database.update_status(task_id, status, result_summary)
+
+    async def get_task(self, task_id: str):
+        await self.ready_event.wait()
+        return await self._task_database.get_task(task_id)
+
+    async def list_tasks_by_user(
+        self,
+        user_id: str,
+        status: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ):
+        await self.ready_event.wait()
+        return await self._task_database.list_tasks_by_user(
+            user_id=user_id, status=status, limit=limit, offset=offset
+        )