fix(task): address PR #135 review findings

- task_center: infer scheduled task when run_once=True so missing run_at/cron
  raises a proper validation error instead of silently executing immediately.
- task_center: coerce string booleans ("false"/"0"/"no"/...) in the schedule
  JSON compat layer via _coerce_legacy_bool, preventing recurring tasks from
  being misclassified as one-time.
- webui QueuedSection: refresh the open detail drawer by execution id so the
  detail keeps updating after pagination/filter changes, independent of the
  current page's tasks list.
- tests: add compat tests for the two task_center regressions above.

Made-with: Cursor

Author: xiami762

flocks/tool/task/task_center.py

@@ -21,6 +21,25 @@
 log = Log.create(service="task.tools")
 
 
+_TRUTHY_STRINGS = {"true", "1", "yes", "y", "on"}
+_FALSY_STRINGS = {"false", "0", "no", "n", "off", ""}
+
+
+def _coerce_legacy_bool(value: object, *, default: bool = False) -> bool:
+    """Coerce values that may arrive as strings from legacy clients."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in _TRUTHY_STRINGS:
+            return True
+        if normalized in _FALSY_STRINGS:
+            return False
+    return default
+
+
 def _normalize_task_create_inputs(
     type_value: Optional[str],
     schedule_type: Optional[str],
@@ -63,15 +82,19 @@ def _normalize_task_create_inputs(
         )
         timezone = str(schedule_data.get("timezone") or timezone)
         if schedule_data.get("run_once") is not None:
-            run_once = bool(schedule_data.get("run_once"))
+            run_once = _coerce_legacy_bool(schedule_data.get("run_once"), default=run_once)
         elif schedule_data.get("runOnce") is not None:
-            run_once = bool(schedule_data.get("runOnce"))
+            run_once = _coerce_legacy_bool(schedule_data.get("runOnce"), default=run_once)
 
     if type_value:
         return type_value, run_once, run_at, cron, cron_description, timezone
     if not schedule_type:
-        inferred_type = "scheduled" if (cron or run_at) else "queued"
-        return inferred_type, run_once, run_at, cron, cron_description, timezone
+        # When the caller signalled a scheduled intent (run_once / run_at / cron),
+        # keep it scheduled so build_schedule can surface proper validation errors
+        # instead of silently falling back to an immediate queued execution.
+        if cron or run_at or run_once:
+            return "scheduled", run_once, run_at, cron, cron_description, timezone
+        return "queued", run_once, run_at, cron, cron_description, timezone
 
     normalized = schedule_type.strip().lower()
     if normalized == "queued":

tests/tool/test_task_center_compat.py

@@ -172,6 +172,51 @@ async def test_task_update_defaults_to_update_and_accepts_schedule_fields(self):
         assert updated.trigger.timezone == "UTC"
         assert updated.source.user_prompt == "更新后的执行内容"
 
+    @pytest.mark.asyncio
+    async def test_task_create_rejects_run_once_without_time_instead_of_immediate(self):
+        """run_once=True with no run_at/cron must NOT silently become an immediate task.
+
+        Previously such inputs were inferred as ``queued`` and executed right away,
+        masking missing-schedule mistakes from legacy clients.
+        """
+        result = await ToolRegistry.execute(
+            "task_create",
+            ctx=_make_ctx(),
+            title="缺少时间参数",
+            description="只传了 run_once=True 但没给 run_at/cron",
+            run_once=True,
+            user_prompt="不应该被立即执行",
+        )
+
+        assert result.success is False
+        assert result.error is not None
+        assert "run_at" in result.error or "cron" in result.error
+
+        _, total = await TaskManager.list_schedulers(limit=10)
+        assert total == 0
+
+    @pytest.mark.asyncio
+    async def test_task_create_schedule_json_accepts_string_boolean_run_once(self):
+        """Legacy clients may serialise run_once as the string "false"/"0" —
+        those must be coerced to False, not treated as truthy."""
+        result = await ToolRegistry.execute(
+            "task_create",
+            ctx=_make_ctx(),
+            title="字符串布尔值兼容",
+            description="run_once 以字符串 'false' 传入",
+            schedule='{"cron": "*/5 * * * *", "run_once": "false"}',
+            user_prompt="循环任务",
+        )
+
+        assert result.success is True
+
+        schedulers, total = await TaskManager.list_schedulers(limit=10)
+        assert total == 1
+        scheduler = schedulers[0]
+        assert scheduler.mode == SchedulerMode.CRON
+        assert scheduler.trigger.cron == "*/5 * * * *"
+        assert scheduler.trigger.run_immediately is False
+
     @pytest.mark.asyncio
     async def test_task_update_can_disable_and_enable_scheduled_task(self):
         scheduler = await TaskManager.create_scheduler(

webui/src/pages/Task/QueuedSection.tsx

@@ -83,21 +83,22 @@ export default function QueuedSection({ onRefreshGlobal }: { onRefreshGlobal: ()
 
   // When the user selects a task, also fetch it directly to be sure
   // we have the latest data even if it's not on the current page.
-  const fetchDetailTask = useCallback(async (task: TaskExecution) => {
+  const fetchDetailTask = useCallback(async (taskId: string) => {
     try {
-      const res = await taskAPI.getExecution(task.id);
+      const res = await taskAPI.getExecution(taskId);
       const detail = await markViewedIfNeeded(res.data);
       setDetailTask(detail);
     } catch { /* ignore — list sync will cover it */ }
   }, [markViewedIfNeeded]);
 
+  // The detail drawer is intentionally kept open across page/filter changes,
+  // so we must refresh it by ID rather than looking it up in the current page.
   const refreshWithDetail = useCallback(() => {
     refresh();
     if (selectedId) {
-      const selected = tasks.find(t => t.id === selectedId);
-      if (selected) fetchDetailTask(selected);
+      fetchDetailTask(selectedId);
     }
-  }, [refresh, selectedId, fetchDetailTask, tasks]);
+  }, [refresh, selectedId, fetchDetailTask]);
 
   const closeDetail = useCallback(() => {
     setSelectedId(null);
@@ -111,7 +112,7 @@ export default function QueuedSection({ onRefreshGlobal }: { onRefreshGlobal: ()
     }
     setSelectedId(task.id);
     setDetailTask(task);
-    fetchDetailTask(task);
+    fetchDetailTask(task.id);
   }, [selectedId, closeDetail, fetchDetailTask]);
 
   const handleAction = async (action: string, taskId: string) => {
@@ -138,8 +139,7 @@ export default function QueuedSection({ onRefreshGlobal }: { onRefreshGlobal: ()
       }
       refresh();
       if (selectedId === taskId) {
-        const selected = tasks.find(t => t.id === taskId);
-        if (selected) fetchDetailTask(selected);
+        fetchDetailTask(taskId);
       }
     } catch (err: unknown) {
       toast.error(t('queued.actionFailed'), err instanceof Error ? err.message : String(err));