From 4e4c71ef294475244d2d6d54fd5d1dc6506423d9 Mon Sep 17 00:00:00 2001
From: nonoqing <y_yqingfiona@163.com>
Date: Sun, 20 Sep 2026 16:56:41 +0800
Subject: [PATCH 1/3] fix(scheduled-jobs): surface agent-created jobs in the
 product surfaces
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A scheduled job created from a session through the Cron tool stayed invisible
even though the backend reported success: the tool call rendered as a generic
card, no open view was told to re-read the job list, and the workspace-scoped
list filtered to workspace-targeted jobs — the one kind the agent cannot
create. Agents can also create a job with "enabled": false, which the nav
count skipped entirely.

- Render a dedicated Cron tool card in the chat transcript (design-system
  card plus the web-ui adapter, registry entry, and copy).
- Emit cron://jobs-changed from the cron service on create, update, delete,
  and run-state changes; mirror it to Peer Device controllers and let the
  scheduled-jobs surfaces reload from the hint.
- List every job in the workspace, with its target, in the scheduled-jobs
  views and in the agent's own cron_jobs list, instead of hiding
  session-targeted jobs behind a target-kind filter.
- Count scheduled jobs per workspace and per session in the nav, disabled
  jobs included, matching what the panels list.
---
 .../flow-chat/tool-cards/SessionToolCards.tsx |   9 +-
 .../tool-cards/StandardToolCards.meta.ts      |  10 +
 .../ui/src/flow-chat/tool-cards/index.ts      |   2 +
 design-system/packages/ui/src/registry.ts     |   2 +
 .../ui/tests/flow-chat-tool-card.test.mjs     |   6 +
 .../packages/ui/tests/registry.test.mjs       |   1 +
 .../desktop/src/api/remote_connect_api.rs     |   7 +
 .../tools/implementations/cron_tool.rs        | 143 ++++++++--
 .../assembly/core/src/service/cron/events.rs  |  67 +++++
 .../assembly/core/src/service/cron/mod.rs     |   2 +
 .../assembly/core/src/service/cron/service.rs |  52 +++-
 src/crates/assembly/core/src/service/mod.rs   |   3 +-
 .../sections/sessions/SessionsSection.scss    |  16 ++
 .../sections/sessions/SessionsSection.tsx     |  22 ++
 .../sections/workspaces/WorkspaceItem.tsx     |  21 ++
 .../scheduled-jobs/ScheduledJobsView.tsx      |  20 +-
 .../scheduled-jobs/cronJobCountsStore.test.ts |  88 ++++++
 .../scheduled-jobs/cronJobCountsStore.ts      | 131 +++++++++
 .../src/app/scenes/todos/TodosScene.tsx       |   4 +-
 .../src/flow_chat/tool-cards/CronToolCard.tsx | 270 ++++++++++++++++++
 .../src/flow_chat/tool-cards/index.test.ts    |   1 +
 src/web-ui/src/flow_chat/tool-cards/index.ts  |   4 +
 .../flow_chat/tool-cards/toolCardMetadata.ts  |  13 +
 .../infrastructure/api/service-api/CronAPI.ts |  13 +
 .../peer-device/deviceSurfaceRouting.test.ts  |   1 +
 .../peer-device/deviceSurfaceRouting.ts       |   1 +
 src/web-ui/src/locales/en-US/common.json      |   4 +-
 src/web-ui/src/locales/en-US/flow-chat.json   |  37 +++
 src/web-ui/src/locales/zh-CN/common.json      |   4 +-
 src/web-ui/src/locales/zh-CN/flow-chat.json   |  37 +++
 src/web-ui/src/locales/zh-TW/common.json      |   4 +-
 src/web-ui/src/locales/zh-TW/flow-chat.json   |  37 +++
 32 files changed, 984 insertions(+), 48 deletions(-)
 create mode 100644 src/crates/assembly/core/src/service/cron/events.rs
 create mode 100644 src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.test.ts
 create mode 100644 src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.ts
 create mode 100644 src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx

diff --git a/design-system/packages/ui/src/flow-chat/tool-cards/SessionToolCards.tsx b/design-system/packages/ui/src/flow-chat/tool-cards/SessionToolCards.tsx
index db3f563f18..778ab967ce 100644
--- a/design-system/packages/ui/src/flow-chat/tool-cards/SessionToolCards.tsx
+++ b/design-system/packages/ui/src/flow-chat/tool-cards/SessionToolCards.tsx
@@ -1,6 +1,6 @@
 import { OverflowText } from '../../primitives/OverflowText';
 import type { HTMLAttributes, ReactNode } from "react";
-import { Layers, MessageSquare } from "lucide-react";
+import { CalendarClock, Layers, MessageSquare } from "lucide-react";
 import {
   AmbientToolCard,
   AmbientToolCardHeader,
@@ -124,3 +124,10 @@ export interface SessionMessageToolCardProps
 export function SessionMessageToolCard(props: SessionMessageToolCardProps) {
   return <SessionToolCardBase {...props} icon={<MessageSquare aria-hidden="true" />} toolCard="session-message" />;
 }
+
+export interface CronToolCardProps
+  extends Omit<SessionToolCardBaseProps, "icon" | "sessions" | "toolCard"> {}
+
+export function CronToolCard(props: CronToolCardProps) {
+  return <SessionToolCardBase {...props} icon={<CalendarClock aria-hidden="true" />} toolCard="cron" />;
+}
diff --git a/design-system/packages/ui/src/flow-chat/tool-cards/StandardToolCards.meta.ts b/design-system/packages/ui/src/flow-chat/tool-cards/StandardToolCards.meta.ts
index f96b4620de..942b82e932 100644
--- a/design-system/packages/ui/src/flow-chat/tool-cards/StandardToolCards.meta.ts
+++ b/design-system/packages/ui/src/flow-chat/tool-cards/StandardToolCards.meta.ts
@@ -49,6 +49,16 @@ export const agentWaitToolCardMeta = {
   tokens: ambientTokens,
 } as const satisfies ComponentMeta;
 
+export const cronToolCardMeta = {
+  category: "flow-chat",
+  description: "An ambient scheduled-job card with schedule, next-run, and payload details.",
+  maturity: "stable",
+  name: "CronToolCard",
+  props: expandableProps,
+  states: ["default", "hover", "loading", "expanded", "error"],
+  tokens: ambientTokens,
+} as const satisfies ComponentMeta;
+
 export const defaultToolCardMeta = {
   category: "flow-chat",
   description: "The fallback ambient card for a tool summary, sanitized input, result, and confirmation state.",
diff --git a/design-system/packages/ui/src/flow-chat/tool-cards/index.ts b/design-system/packages/ui/src/flow-chat/tool-cards/index.ts
index fada8e932b..900bd5fedb 100644
--- a/design-system/packages/ui/src/flow-chat/tool-cards/index.ts
+++ b/design-system/packages/ui/src/flow-chat/tool-cards/index.ts
@@ -61,8 +61,10 @@ export {
   type SearchToolCardResult,
 } from "./SearchResultsToolCards";
 export {
+  CronToolCard,
   SessionControlToolCard,
   SessionMessageToolCard,
+  type CronToolCardProps,
   type SessionControlToolCardProps,
   type SessionMessageToolCardProps,
   type SessionToolCardField,
diff --git a/design-system/packages/ui/src/registry.ts b/design-system/packages/ui/src/registry.ts
index 771a956bec..e4a94f1341 100644
--- a/design-system/packages/ui/src/registry.ts
+++ b/design-system/packages/ui/src/registry.ts
@@ -82,6 +82,7 @@ import {
 import { readFileToolCardMeta } from "./flow-chat/tool-cards/ReadFileToolCard.meta";
 import {
   agentWaitToolCardMeta,
+  cronToolCardMeta,
   defaultToolCardMeta,
   directoryListToolCardMeta,
   getToolSpecToolCardMeta,
@@ -124,6 +125,7 @@ export const componentRegistry = [
   comboboxMeta,
   confirmDialogMeta,
   contextCompressionToolCardMeta,
+  cronToolCardMeta,
   defaultToolCardMeta,
   disclosureMeta,
   emptyMeta,
diff --git a/design-system/packages/ui/tests/flow-chat-tool-card.test.mjs b/design-system/packages/ui/tests/flow-chat-tool-card.test.mjs
index 7513ab0644..e588350c3c 100644
--- a/design-system/packages/ui/tests/flow-chat-tool-card.test.mjs
+++ b/design-system/packages/ui/tests/flow-chat-tool-card.test.mjs
@@ -10,6 +10,7 @@ import {
   AmbientToolCardHeader,
   CommandToolCard,
   ContextCompressionToolCard,
+  CronToolCard,
   DefaultToolCard,
   DirectoryListToolCard,
   FileDiffToolCard,
@@ -586,6 +587,11 @@ test("every migrated FlowChat tool view publishes a stable concrete card identit
       summary: "Completed",
       toolName: "custom_tool",
     })],
+    ["cron", createElement(CronToolCard, {
+      action: "Scheduled job:",
+      status: "completed",
+      summary: "Created scheduled job",
+    })],
     ["directory-list", createElement(DirectoryListToolCard, {
       results: [{ key: "src", title: "src/" }],
       status: "completed",
diff --git a/design-system/packages/ui/tests/registry.test.mjs b/design-system/packages/ui/tests/registry.test.mjs
index 50ffe2587a..e4599b3487 100644
--- a/design-system/packages/ui/tests/registry.test.mjs
+++ b/design-system/packages/ui/tests/registry.test.mjs
@@ -29,6 +29,7 @@ test("registry exposes only the formal stable components", () => {
       "Combobox",
       "ConfirmDialog",
       "ContextCompressionToolCard",
+      "CronToolCard",
       "DefaultToolCard",
       "Disclosure",
       "Empty",
diff --git a/src/apps/desktop/src/api/remote_connect_api.rs b/src/apps/desktop/src/api/remote_connect_api.rs
index 8e89b68fd8..a901d47461 100644
--- a/src/apps/desktop/src/api/remote_connect_api.rs
+++ b/src/apps/desktop/src/api/remote_connect_api.rs
@@ -487,6 +487,7 @@ fn should_fanout_peer_ui_event(event: &str) -> bool {
             | "permission://event"
             | AI_MODEL_CATALOG_UPDATED_EVENT
             | openbitfun_core::service::workspace::WORKSPACE_CATALOG_CHANGED_EVENT
+            | openbitfun_core::service::cron::CRON_JOBS_CHANGED_EVENT
     )
 }
 
@@ -3590,6 +3591,12 @@ mod peer_event_tests {
         assert!(should_fanout_peer_ui_event("workspace-catalog-changed"));
         assert!(!should_fanout_peer_ui_event("workspace-identity-changed"));
     }
+
+    #[test]
+    fn cron_job_change_hints_are_fanned_out_to_peer_controllers() {
+        assert!(should_fanout_peer_ui_event("cron://jobs-changed"));
+        assert!(!should_fanout_peer_ui_event("cron://internal"));
+    }
 }
 
 static SESSION_SUBSCRIPTIONS: OnceLock<
diff --git a/src/crates/assembly/core/src/agentic/tools/implementations/cron_tool.rs b/src/crates/assembly/core/src/agentic/tools/implementations/cron_tool.rs
index de6775c0d6..8de27be2bb 100644
--- a/src/crates/assembly/core/src/agentic/tools/implementations/cron_tool.rs
+++ b/src/crates/assembly/core/src/agentic/tools/implementations/cron_tool.rs
@@ -396,39 +396,42 @@ impl CronTool {
         }
     }
 
-    fn build_list_result_for_assistant(
-        &self,
-        workspace: &str,
-        session_id: &str,
-        jobs: &[CronJob],
-    ) -> String {
+    fn build_list_result_for_assistant(&self, workspace: &str, jobs: &[CronJob]) -> String {
         if jobs.is_empty() {
-            return format!(
-                "No scheduled jobs found for session '{}' in workspace '{}'.",
-                session_id, workspace
-            );
+            return format!("No scheduled jobs found in workspace '{}'.", workspace);
         }
 
         let mut lines = vec![format!(
-            "Found {} scheduled job(s) for session '{}' in workspace '{}'.",
+            "Found {} scheduled job(s) in workspace '{}'.",
             jobs.len(),
-            session_id,
             workspace,
         )];
         lines.push(String::new());
-        lines.push("| job_id | name | enabled | schedule |".to_string());
-        lines.push("| --- | --- | --- | --- |".to_string());
+        lines.push("| job_id | name | enabled | schedule | target |".to_string());
+        lines.push("| --- | --- | --- | --- | --- |".to_string());
         for job in jobs {
             lines.push(format!(
-                "| {} | {} | {} | {} |",
+                "| {} | {} | {} | {} | {} |",
                 Self::escape_markdown_table_cell(&job.id),
                 Self::escape_markdown_table_cell(&job.name),
                 if job.enabled { "true" } else { "false" },
                 Self::escape_markdown_table_cell(&Self::schedule_summary(&job.schedule)),
+                Self::escape_markdown_table_cell(&Self::target_summary(job)),
             ));
         }
         lines.join("\n")
     }
+
+    /// Which conversation a job delivers into. The list is workspace-scoped, so
+    /// the agent needs this to tell its own jobs from another session's.
+    fn target_summary(job: &CronJob) -> String {
+        match &job.target {
+            CronJobTarget::Session { session_id, .. } => format!("session {}", session_id),
+            CronJobTarget::Workspace { launch, .. } => {
+                format!("new session ({})", launch.agent_type)
+            }
+        }
+    }
 }
 
 impl Default for CronTool {
@@ -681,7 +684,7 @@ Defaults:
 
 Actions:
 - "get_time": Return the current local time including timezone information.
-- "list": List all jobs for the effective session scope.
+- "list": List every job in the workspace, including jobs that belong to other sessions. Each row reports its target, and "job_id" from here works with "update", "remove", and "run".
 - "add": Create a job. Requires "job". When "job.name" is omitted, uses "Cron job".
 - "update": Update a job. Requires "job_id" and "patch".
 - "remove": Delete a job. Requires "job_id".
@@ -725,7 +728,7 @@ Patch schema for "update":
             "properties": {
                 "session_id": {
                     "type": "string",
-                    "description": "Optional target session ID. Defaults to the current session for list/add."
+                    "description": "Optional session ID. Defaults to the current session; for add it is the session the payload is delivered to, for list it selects the workspace to report on."
                 },
                 "action": {
                     "type": "string",
@@ -1085,13 +1088,30 @@ Patch schema for "update":
                     .resolve_effective_workspace_for_session(&session_id, context)
                     .await?;
                 let workspace = workspace_ref.workspace_path.clone();
-                let mut jobs = cron_service
-                    .list_jobs_filtered(
-                        workspace_ref.workspace_id.as_deref(),
-                        Some(&session_id),
-                        Some(CronJobTargetKind::Session),
-                    )
-                    .await;
+                // Workspace scope, not session scope: the product surfaces list
+                // every job in the workspace, and a session-only list made the
+                // agent report "no scheduled jobs" while the UI showed them.
+                let workspace_id = workspace_ref.workspace_id.as_deref();
+                let mut jobs = match workspace_id {
+                    Some(workspace_id) => {
+                        cron_service
+                            .list_jobs_filtered(Some(workspace_id), None, None)
+                            .await
+                    }
+                    // A workspace without a stable id cannot be filtered by id,
+                    // and the service refuses to match unmigrated records by
+                    // path. Reporting every workspace would be worse than
+                    // reporting only this session's jobs.
+                    None => {
+                        cron_service
+                            .list_jobs_filtered(
+                                None,
+                                Some(&session_id),
+                                Some(CronJobTargetKind::Session),
+                            )
+                            .await
+                    }
+                };
                 jobs.sort_by(|left, right| {
                     left.created_at_ms
                         .cmp(&right.created_at_ms)
@@ -1099,15 +1119,20 @@ Patch schema for "update":
                 });
                 let serialized_jobs = Self::serialize_jobs(&jobs)?;
 
-                let result_for_assistant =
-                    self.build_list_result_for_assistant(&workspace, &session_id, &jobs);
+                let mut result_for_assistant =
+                    self.build_list_result_for_assistant(&workspace, &jobs);
+                if workspace_id.is_none() {
+                    result_for_assistant.push_str(&format!(
+                        "\n\nScope note: this workspace has no stable id, so only jobs targeting session '{}' are listed.",
+                        session_id
+                    ));
+                }
 
                 Ok(vec![ToolResult::Result {
                     data: json!({
                         "success": true,
                         "action": "list",
                         "workspace": workspace,
-                        "session_id": session_id,
                         "count": jobs.len(),
                         "jobs": serialized_jobs,
                     }),
@@ -1533,4 +1558,68 @@ mod tests {
             CronTool::add_result_summary(&job_with_schedule(every_30_minutes(), "session_1"), None);
         assert!(!summary.contains("end your turn"), "got: {summary}");
     }
+
+    fn workspace_target_job(id: &str) -> CronJob {
+        CronJob {
+            id: id.to_string(),
+            name: "nightly report".to_string(),
+            schedule: every_30_minutes(),
+            payload: CronJobPayload {
+                text: "summarize the day".to_string(),
+            },
+            enabled: true,
+            target: CronJobTarget::Workspace {
+                workspace: CronWorkspaceRef {
+                    workspace_id: None,
+                    workspace_path: "/home/wsp/projects/test".to_string(),
+                    project_workspace_path: None,
+                    execution_target: None,
+                    remote_connection_id: None,
+                    remote_ssh_host: None,
+                },
+                launch: Default::default(),
+            },
+            created_at_ms: 0,
+            config_updated_at_ms: 0,
+            updated_at_ms: 0,
+            state: Default::default(),
+        }
+    }
+
+    #[test]
+    fn list_summary_covers_every_job_in_the_workspace_with_its_target() {
+        // The list is workspace-scoped, so a job another session owns is still
+        // reported — hiding it made the agent deny jobs the UI was showing.
+        let tool = CronTool::new();
+        let mut other_session_job = job_with_schedule(every_30_minutes(), "session_other");
+        other_session_job.id = "cron_aaaaaaaa".to_string();
+        let jobs = vec![other_session_job, workspace_target_job("cron_bbbbbbbb")];
+
+        let summary = tool.build_list_result_for_assistant("/home/wsp/projects/test", &jobs);
+
+        assert!(
+            summary.contains("Found 2 scheduled job(s)"),
+            "got: {summary}"
+        );
+        assert!(
+            summary.contains("workspace '/home/wsp/projects/test'"),
+            "got: {summary}"
+        );
+        assert!(!summary.contains("for session"), "got: {summary}");
+        // Each row says which conversation the job delivers into.
+        assert!(summary.contains("session session_other"), "got: {summary}");
+        assert!(summary.contains("new session ("), "got: {summary}");
+    }
+
+    #[test]
+    fn list_summary_reports_an_empty_workspace() {
+        let tool = CronTool::new();
+
+        let summary = tool.build_list_result_for_assistant("/home/wsp/projects/test", &[]);
+
+        assert_eq!(
+            summary,
+            "No scheduled jobs found in workspace '/home/wsp/projects/test'."
+        );
+    }
 }
diff --git a/src/crates/assembly/core/src/service/cron/events.rs b/src/crates/assembly/core/src/service/cron/events.rs
new file mode 100644
index 0000000000..709e829775
--- /dev/null
+++ b/src/crates/assembly/core/src/service/cron/events.rs
@@ -0,0 +1,67 @@
+//! Scheduled-job change events for product surfaces.
+//!
+//! Scheduled jobs can change without the rendering surface asking for it: the
+//! agent creates or edits a job through the `Cron` tool, the scheduler mutates
+//! run state, or a session delete removes its jobs. Surfaces that cache the
+//! job list must be told to re-read it.
+//!
+//! Like the other `*://changed` hints, this is a hint, not a payload contract:
+//! consumers re-read jobs through `list_cron_jobs` / `list_jobs_filtered`.
+
+use serde::{Deserialize, Serialize};
+
+/// Event name delivered to host UI surfaces (and mirrored to attached Peer
+/// Mode controllers by the host adapter).
+pub const CRON_JOBS_CHANGED_EVENT: &str = "cron://jobs-changed";
+
+/// Why the job set changed. Serialized in camelCase.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum CronJobsChangedReason {
+    /// A job was created.
+    Created,
+    /// A job's config was edited.
+    Updated,
+    /// One or more jobs were deleted.
+    Deleted,
+    /// Run state changed (trigger, enqueue, turn lifecycle), config untouched.
+    StateChanged,
+}
+
+/// Payload for [`CRON_JOBS_CHANGED_EVENT`]. The job id is present when the
+/// change concerns a single known job and absent for batch or unknown targets.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CronJobsChangedEvent {
+    pub reason: CronJobsChangedReason,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn serializes_camel_case_payload() {
+        let payload = serde_json::to_value(CronJobsChangedEvent {
+            reason: CronJobsChangedReason::Created,
+            job_id: Some("cron_abc".to_string()),
+        })
+        .expect("payload should serialize");
+
+        assert_eq!(payload, json!({ "reason": "created", "jobId": "cron_abc" }));
+    }
+
+    #[test]
+    fn omits_absent_job_id() {
+        let payload = serde_json::to_value(CronJobsChangedEvent {
+            reason: CronJobsChangedReason::StateChanged,
+            job_id: None,
+        })
+        .expect("payload should serialize");
+
+        assert_eq!(payload, json!({ "reason": "stateChanged" }));
+    }
+}
diff --git a/src/crates/assembly/core/src/service/cron/mod.rs b/src/crates/assembly/core/src/service/cron/mod.rs
index f460513a9d..a455bd7786 100644
--- a/src/crates/assembly/core/src/service/cron/mod.rs
+++ b/src/crates/assembly/core/src/service/cron/mod.rs
@@ -1,11 +1,13 @@
 //! Scheduled job service.
 
+mod events;
 mod schedule;
 mod service;
 mod store;
 mod subscriber;
 mod types;
 
+pub use events::{CronJobsChangedEvent, CronJobsChangedReason, CRON_JOBS_CHANGED_EVENT};
 pub use service::{get_global_cron_service, set_global_cron_service, CronService};
 pub use subscriber::CronEventSubscriber;
 pub use types::{
diff --git a/src/crates/assembly/core/src/service/cron/service.rs b/src/crates/assembly/core/src/service/cron/service.rs
index bd2d71cb30..6f43af415c 100644
--- a/src/crates/assembly/core/src/service/cron/service.rs
+++ b/src/crates/assembly/core/src/service/cron/service.rs
@@ -8,12 +8,14 @@ use super::types::{
     CreateCronJobRequest, CronJob, CronJobPayload, CronJobTarget, CronJobTargetKind,
     CronLaunchSpec, CronSchedule, CronWorkspaceRef, UpdateCronJobRequest, DEFAULT_RETRY_DELAY_MS,
 };
+use super::{CronJobsChangedEvent, CronJobsChangedReason, CRON_JOBS_CHANGED_EVENT};
 use crate::agentic::coordination::{
     ConversationCoordinator, DialogQueuePriority, DialogScheduler, DialogSubmissionPolicy,
     DialogTriggerSource,
 };
 use crate::agentic::core::SessionConfig;
 use crate::agentic::workspace::WorkspaceBinding;
+use crate::infrastructure::events::{emit_global_event, BackendEvent};
 use crate::infrastructure::PathManager;
 use crate::service_agent_runtime::CoreServiceAgentRuntime;
 use crate::util::errors::{OpenBitFunError, OpenBitFunResult};
@@ -124,6 +126,29 @@ impl CronService {
         jobs.values().cloned().collect::<Vec<_>>()
     }
 
+    /// Broadcast a job-set change hint to product surfaces.
+    ///
+    /// The event bus is created later than this service during startup, so an
+    /// early emit is a no-op; surfaces still bootstrap their lists with an
+    /// explicit `list_cron_jobs` fetch.
+    async fn notify_jobs_changed(&self, reason: CronJobsChangedReason, job_id: Option<String>) {
+        let payload = match serde_json::to_value(CronJobsChangedEvent { reason, job_id }) {
+            Ok(payload) => payload,
+            Err(error) => {
+                warn!("Failed to serialize scheduled job change event: {}", error);
+                return;
+            }
+        };
+        if let Err(error) = emit_global_event(BackendEvent::Custom {
+            event_name: CRON_JOBS_CHANGED_EVENT.to_string(),
+            payload,
+        })
+        .await
+        {
+            warn!("Failed to emit scheduled job change event: {}", error);
+        }
+    }
+
     pub async fn list_jobs_filtered(
         &self,
         workspace_id: Option<&str>,
@@ -181,6 +206,8 @@ impl CronService {
 
         self.persist_jobs_locked(&jobs).await?;
         drop(jobs);
+        self.notify_jobs_changed(CronJobsChangedReason::Created, Some(job.id.clone()))
+            .await;
         self.wakeup.notify_one();
 
         Ok(job)
@@ -240,6 +267,8 @@ impl CronService {
         let updated = job.clone();
         self.persist_jobs_locked(&jobs).await?;
         drop(jobs);
+        self.notify_jobs_changed(CronJobsChangedReason::Updated, Some(updated.id.clone()))
+            .await;
         self.wakeup.notify_one();
 
         Ok(updated)
@@ -263,6 +292,8 @@ impl CronService {
         if existed {
             self.persist_jobs_locked(&jobs).await?;
             drop(jobs);
+            self.notify_jobs_changed(CronJobsChangedReason::Deleted, Some(job_id.to_string()))
+                .await;
             self.wakeup.notify_one();
         }
         Ok(existed)
@@ -282,6 +313,8 @@ impl CronService {
         if removed > 0 {
             self.persist_jobs_locked(&jobs).await?;
             drop(jobs);
+            self.notify_jobs_changed(CronJobsChangedReason::Deleted, None)
+                .await;
             self.wakeup.notify_one();
         }
         Ok(removed)
@@ -301,6 +334,11 @@ impl CronService {
 
             self.persist_jobs_locked(&jobs).await?;
             drop(jobs);
+            self.notify_jobs_changed(
+                CronJobsChangedReason::StateChanged,
+                Some(job_id.to_string()),
+            )
+            .await;
             self.wakeup.notify_one();
         }
 
@@ -352,16 +390,21 @@ impl CronService {
     {
         let _guard = self.mutation_lock.lock().await;
         let mut jobs = self.jobs.write().await;
-        let Some(job) = jobs
+        let Some(job_id) = jobs
             .values_mut()
             .find(|job| job.state.active_turn_id.as_deref() == Some(turn_id))
+            .map(|job| {
+                update(job, now_ms());
+                job.id.clone()
+            })
         else {
             return Ok(());
         };
 
-        update(job, now_ms());
         self.persist_jobs_locked(&jobs).await?;
         drop(jobs);
+        self.notify_jobs_changed(CronJobsChangedReason::StateChanged, Some(job_id))
+            .await;
         self.wakeup.notify_one();
         Ok(())
     }
@@ -561,6 +604,11 @@ impl CronService {
 
         self.persist_jobs_locked(&jobs).await?;
         drop(jobs);
+        self.notify_jobs_changed(
+            CronJobsChangedReason::StateChanged,
+            Some(job_id.to_string()),
+        )
+        .await;
         self.wakeup.notify_one();
         Ok(())
     }
diff --git a/src/crates/assembly/core/src/service/mod.rs b/src/crates/assembly/core/src/service/mod.rs
index 5105555603..e9de5b73a6 100644
--- a/src/crates/assembly/core/src/service/mod.rs
+++ b/src/crates/assembly/core/src/service/mod.rs
@@ -75,7 +75,8 @@ pub use canvas::{CanvasMemoryStore, CanvasService};
 pub use config::{ConfigManager, ConfigProvider, ConfigService};
 #[cfg(all(feature = "agent-runtime", feature = "scheduled-jobs"))]
 pub use cron::{
-    get_global_cron_service, set_global_cron_service, CronEventSubscriber, CronService,
+    get_global_cron_service, set_global_cron_service, CronEventSubscriber, CronJobsChangedEvent,
+    CronJobsChangedReason, CronService, CRON_JOBS_CHANGED_EVENT,
 };
 #[cfg(feature = "diff")]
 pub use diff::{
diff --git a/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.scss b/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.scss
index 7e13a7a9f4..e02b4a6079 100644
--- a/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.scss
+++ b/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.scss
@@ -361,6 +361,22 @@
     }
   }
 
+  &__inline-item-cron-badge {
+    flex: 0 0 auto;
+    display: inline-flex;
+    align-items: center;
+    gap: 3px;
+    height: 14px;
+    padding: 0 5px;
+    border: 1px solid var(--openbitfun-color-border-subtle);
+    border-radius: 999px;
+    background: var(--openbitfun-color-action-quiet-hover);
+    color: var(--openbitfun-color-content-secondary);
+    font-size: var(--openbitfun-type-micro-font-size);
+    font-weight: var(--openbitfun-type-label-selected-font-weight);
+    white-space: nowrap;
+  }
+
   &__inline-item-background-subagent-badge {
     flex: 0 0 auto;
     position: relative;
diff --git a/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.tsx b/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.tsx
index 0f677754c5..3d0d8f51ee 100644
--- a/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.tsx
+++ b/src/web-ui/src/app/components/NavPanel/sections/sessions/SessionsSection.tsx
@@ -78,6 +78,11 @@ import {
 } from '@/features/dispatch/types';
 import { useDispatchJobStore } from '@/features/dispatch/dispatchJobStore';
 import { resolveDispatchNavPresentation } from '@/features/dispatch/dispatchNavPresentation';
+import {
+  ensureCronJobCountsListener,
+  getCronJobCountsSnapshot,
+  subscribeCronJobCounts,
+} from '@/app/components/scheduled-jobs/cronJobCountsStore';
 import {
   SESSION_METADATA_DEFERRED_FALLBACK_MS,
   SESSION_METADATA_DEFERRED_FRAME_COUNT,
@@ -220,6 +225,7 @@ const SessionsSection: React.FC<SessionsSectionProps> = ({
 }) => {
   useDeviceDirectory();
   const { t } = useI18n('common');
+  useEffect(() => { ensureCronJobCountsListener(); }, []);
   const storedSessionOrdering = useWorkspaceSessionViewStore(state => state.ordering);
   const storedSessionShow = useWorkspaceSessionViewStore(state => state.show);
   const storedSessionFilters = useWorkspaceSessionViewStore(state => state.filters);
@@ -292,6 +298,12 @@ const SessionsSection: React.FC<SessionsSectionProps> = ({
     return new Set([...flowChatState.sessions.keys()].filter(sessionNavStatusService.isRunning));
   }, [flowChatState.sessions, orderingRevision]);
   const [scheduledJobsSessionId, setScheduledJobsSessionId] = useState<string | null>(null);
+  const cronJobCountsRevision = useSyncExternalStore(
+    subscribeCronJobCounts,
+    () => getCronJobCountsSnapshot(),
+    () => getCronJobCountsSnapshot(),
+  );
+  const cronJobCountsBySession = cronJobCountsRevision.bySessionId;
   const [batchWorkspace, setBatchWorkspace] = useState<WorkspaceSessionScope | null>(null);
   const editInputRef = useRef<HTMLInputElement>(null);
   const sessionMenuPopoverRef = useRef<HTMLDivElement>(null);
@@ -1500,6 +1512,7 @@ const SessionsSection: React.FC<SessionsSectionProps> = ({
             : undefined;
           const backgroundSubagentActivityCount = backgroundSubagentActivity?.totalCount ?? 0;
           const showBackgroundSubagentActivity = !isChildSession && backgroundSubagentActivityCount > 0;
+          const scheduledJobCount = cronJobCountsBySession.get(session.sessionId) ?? 0;
           const parentSessionId = relationship.parentSessionId;
           const parentSession = parentSessionId ? flowChatState.sessions.get(parentSessionId) : undefined;
           const parentTitle = parentSession ? resolveSessionTitle(parentSession) : '';
@@ -1711,6 +1724,15 @@ const SessionsSection: React.FC<SessionsSectionProps> = ({
                         {dispatchPresentation?.badgeLabel}
                       </OverflowText></span>
                     ) : null}
+                    {scheduledJobCount > 0 ? (
+                      <span
+                        className="openbitfun-nav-panel__inline-item-cron-badge"
+                        title={t('nav.scheduledJobs.badgeTooltip', { count: scheduledJobCount })}
+                      >
+                        <Icon name="clock" size="2xs" aria-hidden />
+                        {scheduledJobCount}
+                      </span>
+                    ) : null}
                     {reviewActivityKind ? (
                       <span className="openbitfun-nav-panel__inline-item-review-badge">
                         <Loader2 className="openbitfun-nav-panel__inline-item-review-icon" aria-hidden />
diff --git a/src/web-ui/src/app/components/NavPanel/sections/workspaces/WorkspaceItem.tsx b/src/web-ui/src/app/components/NavPanel/sections/workspaces/WorkspaceItem.tsx
index b0001e0a69..6aff0ef174 100644
--- a/src/web-ui/src/app/components/NavPanel/sections/workspaces/WorkspaceItem.tsx
+++ b/src/web-ui/src/app/components/NavPanel/sections/workspaces/WorkspaceItem.tsx
@@ -54,6 +54,11 @@ import {
   type WorkspaceInfo,
 } from '@/shared/types';
 import { SSHContext } from '@/features/ssh-remote/SSHRemoteContext';
+import {
+  ensureCronJobCountsListener,
+  getCronJobCountsSnapshot,
+  subscribeCronJobCounts,
+} from '@/app/components/scheduled-jobs/cronJobCountsStore';
 import { useWorkspaceSearchIndex } from '@/tools/file-explorer';
 import { WORKSPACE_SEARCH_AVAILABLE } from '@/infrastructure/config/workspaceSearchAvailability';
 import { useSideAnchoredPopoverPosition } from '@/shared/utils/useSideAnchoredPopoverPosition';
@@ -105,6 +110,13 @@ const WorkspaceItem: React.FC<WorkspaceItemProps> = ({
 }) => {
   const { t } = useI18n('common');
   const { t: tFiles } = useTranslation('panels/files');
+  useEffect(() => { ensureCronJobCountsListener(); }, []);
+  const cronJobCounts = useSyncExternalStore(
+    subscribeCronJobCounts,
+    getCronJobCountsSnapshot,
+    getCronJobCountsSnapshot,
+  );
+  const scheduledJobCount = cronJobCounts.byWorkspaceId.get(workspace.id) ?? 0;
   const {
     setActiveWorkspace,
     closeWorkspaceById,
@@ -859,6 +871,15 @@ const WorkspaceItem: React.FC<WorkspaceItemProps> = ({
               data-workspace-id={workspace.id}
             >
               <OverflowText className="openbitfun-nav-panel__assistant-item-label" data-openbitfun-product-component="workspace-item" data-openbitfun-product-part="label">{workspaceDisplayName}</OverflowText>
+              {scheduledJobCount > 0 ? (
+                <span
+                  className="openbitfun-nav-panel__inline-item-cron-badge"
+                  title={t('nav.scheduledJobs.badgeTooltip', { count: scheduledJobCount })}
+                >
+                  <Icon name="clock" size="2xs" aria-hidden />
+                  {scheduledJobCount}
+                </span>
+              ) : null}
             </ActionItem>
           </Tooltip>
 
diff --git a/src/web-ui/src/app/components/scheduled-jobs/ScheduledJobsView.tsx b/src/web-ui/src/app/components/scheduled-jobs/ScheduledJobsView.tsx
index 09460e9258..32d47b5fc7 100644
--- a/src/web-ui/src/app/components/scheduled-jobs/ScheduledJobsView.tsx
+++ b/src/web-ui/src/app/components/scheduled-jobs/ScheduledJobsView.tsx
@@ -111,17 +111,13 @@ function formatJobMetaSummary(
   formatDate: (date: Date | number, options?: Intl.DateTimeFormatOptions) => string,
   t: (key: string, params?: Record<string, unknown>) => string,
   options?: {
-    showTarget: boolean;
     resolveSessionLabel: (sessionId: string) => string | undefined;
   },
 ): string {
   const scheduleSummary = formatScheduleSummary(job.schedule, formatDate, t);
-  if (options?.showTarget) {
-    if (job.target.kind === 'session') {
-      const sessionLabel = options.resolveSessionLabel(job.target.sessionId) || job.target.sessionId;
-      return `${sessionLabel} · ${scheduleSummary}`;
-    }
-    return `${t('nav.scheduledJobs.targets.newSession')} · ${scheduleSummary}`;
+  if (job.target.kind === 'session') {
+    const sessionLabel = options?.resolveSessionLabel(job.target.sessionId) || job.target.sessionId;
+    return `${sessionLabel} · ${scheduleSummary}`;
   }
   if (job.target.kind === 'workspace') {
     return `${job.target.launch.agentType} · ${scheduleSummary}`;
@@ -282,10 +278,15 @@ const ScheduledJobsView: React.FC<ScheduledJobsViewProps> = ({
   const loadJobs = useCallback(async () => {
     if (!workspaceRef) { setJobs([]); return; }
     setLoading(true);
+    // Deliberately no `targetKind` filter: the agent's Cron tool creates
+    // session-targeted jobs, so a workspace-scoped list that asked for
+    // workspace-targeted jobs only would hide exactly the jobs the user just
+    // asked the agent to create.
     const request = {
       workspaceId: workspaceRef?.workspaceId ?? undefined,
-      sessionId: targetKind === 'session' && lockSessionId && !assistantWorkspaceMode ? sessionId || undefined : undefined,
-      targetKind: assistantWorkspaceMode ? undefined : targetKind,
+      sessionId: targetKind === 'session' && lockSessionId && !assistantWorkspaceMode
+        ? sessionId || undefined
+        : undefined,
     };
     try {
       const result = await cronAPI.listJobs(request);
@@ -663,7 +664,6 @@ const ScheduledJobsView: React.FC<ScheduledJobsViewProps> = ({
                     <div className="asv__item-meta-row" data-openbitfun-component="scheduled-jobs-view" data-openbitfun-part="jobMeta">
                       <div className="asv__item-meta"><OverflowText>
                         {formatJobMetaSummary(job, formatDate, t, {
-                          showTarget: assistantWorkspaceMode,
                           resolveSessionLabel: sessionId => sessionLabelById.get(sessionId),
                         })}
                       </OverflowText></div>
diff --git a/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.test.ts b/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.test.ts
new file mode 100644
index 0000000000..54ce6ee96c
--- /dev/null
+++ b/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.test.ts
@@ -0,0 +1,88 @@
+/**
+ * The nav badge is the only scheduled-job signal visible without opening a
+ * panel, so what it counts has to match what the panel lists. A job the agent
+ * created with "enabled": false used to disappear from the badge entirely.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { CronJob } from '@/infrastructure/api';
+import { computeCronJobCounts } from './cronJobCountsStore';
+
+function sessionJob(id: string, sessionId: string, workspaceId: string, enabled = true): CronJob {
+  return {
+    id,
+    name: id,
+    schedule: { kind: 'every', everyMs: 60_000 },
+    payload: { text: 'hello' },
+    enabled,
+    target: {
+      kind: 'session',
+      sessionId,
+      workspace: { workspaceId, workspacePath: '/tmp/workspace' },
+    },
+    createdAtMs: 0,
+    configUpdatedAtMs: 0,
+    updatedAtMs: 0,
+    state: { consecutiveFailures: 0, coalescedRunCount: 0 },
+  };
+}
+
+function workspaceJob(id: string, workspaceId: string): CronJob {
+  return {
+    id,
+    name: id,
+    schedule: { kind: 'every', everyMs: 60_000 },
+    payload: { text: 'hello' },
+    enabled: true,
+    target: {
+      kind: 'workspace',
+      workspace: { workspaceId, workspacePath: '/tmp/workspace' },
+      launch: { agentType: 'Standard' },
+    },
+    createdAtMs: 0,
+    configUpdatedAtMs: 0,
+    updatedAtMs: 0,
+    state: { consecutiveFailures: 0, coalescedRunCount: 0 },
+  };
+}
+
+describe('computeCronJobCounts', () => {
+  it('counts a session job towards its workspace and its session', () => {
+    const counts = computeCronJobCounts([
+      sessionJob('cron_a', 'session_1', 'ws_1'),
+      sessionJob('cron_b', 'session_1', 'ws_1'),
+      sessionJob('cron_c', 'session_2', 'ws_1'),
+    ]);
+
+    expect(counts.byWorkspaceId.get('ws_1')).toBe(3);
+    expect(counts.bySessionId.get('session_1')).toBe(2);
+    expect(counts.bySessionId.get('session_2')).toBe(1);
+  });
+
+  it('counts a workspace job without attributing it to a session', () => {
+    const counts = computeCronJobCounts([workspaceJob('cron_d', 'ws_1')]);
+
+    expect(counts.byWorkspaceId.get('ws_1')).toBe(1);
+    expect(counts.bySessionId.size).toBe(0);
+  });
+
+  it('keeps disabled jobs counted, matching the panel list', () => {
+    const counts = computeCronJobCounts([
+      sessionJob('cron_e', 'session_1', 'ws_1', false),
+      sessionJob('cron_f', 'session_1', 'ws_1'),
+    ]);
+
+    expect(counts.byWorkspaceId.get('ws_1')).toBe(2);
+    expect(counts.bySessionId.get('session_1')).toBe(2);
+  });
+
+  it('ignores jobs whose workspace has no id', () => {
+    const job = sessionJob('cron_g', 'session_1', 'ws_1');
+    job.target.workspace = { workspacePath: '/tmp/workspace' };
+
+    const counts = computeCronJobCounts([job]);
+
+    expect(counts.byWorkspaceId.size).toBe(0);
+    expect(counts.bySessionId.get('session_1')).toBe(1);
+  });
+});
diff --git a/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.ts b/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.ts
new file mode 100644
index 0000000000..1d4c0eecf2
--- /dev/null
+++ b/src/web-ui/src/app/components/scheduled-jobs/cronJobCountsStore.ts
@@ -0,0 +1,131 @@
+/**
+ * Scheduled-job counts for navigation badges.
+ *
+ * This module owns the single backend subscription for `cron://jobs-changed`
+ * (agent Cron tool calls, the scheduler, session cleanup). It re-reads the job
+ * list, publishes per-workspace / per-session counts, and mirrors the hint onto
+ * the existing browser event so every mounted scheduled-job view also reloads.
+ * Nav rows read the counts through `useSyncExternalStore` without each row
+ * owning a Tauri listener.
+ */
+
+import { cronAPI } from '@/infrastructure/api';
+import { notifyScheduledJobsChanged, SCHEDULED_JOBS_CHANGED_EVENT } from './scheduledJobDraft';
+import { createLogger } from '@/shared/utils/logger';
+import type { CronJob } from '@/infrastructure/api';
+
+const log = createLogger('CronJobCountsStore');
+
+export interface CronJobCountsSnapshot {
+  /** Count per workspace id. */
+  byWorkspaceId: ReadonlyMap<string, number>;
+  /** Count per session id (session-targeted jobs only). */
+  bySessionId: ReadonlyMap<string, number>;
+}
+
+const EMPTY_SNAPSHOT: CronJobCountsSnapshot = {
+  byWorkspaceId: new Map(),
+  bySessionId: new Map(),
+};
+
+let snapshot: CronJobCountsSnapshot = EMPTY_SNAPSHOT;
+const listeners = new Set<() => void>();
+let loadInFlight = false;
+let listenerRegistered = false;
+
+function publish(): void {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function countsEqual(
+  left: CronJobCountsSnapshot,
+  right: CronJobCountsSnapshot,
+): boolean {
+  if (left.byWorkspaceId.size !== right.byWorkspaceId.size) return false;
+  if (left.bySessionId.size !== right.bySessionId.size) return false;
+  for (const [key, value] of left.byWorkspaceId) {
+    if (right.byWorkspaceId.get(key) !== value) return false;
+  }
+  for (const [key, value] of left.bySessionId) {
+    if (right.bySessionId.get(key) !== value) return false;
+  }
+  return true;
+}
+
+/**
+ * Counts per workspace and per session. Mirrors what the scheduled-jobs views
+ * list, disabled jobs included: a paused job the agent just created must still
+ * be visible in the nav.
+ */
+export function computeCronJobCounts(jobs: CronJob[]): CronJobCountsSnapshot {
+  const byWorkspaceId = new Map<string, number>();
+  const bySessionId = new Map<string, number>();
+  for (const job of jobs) {
+    const workspaceId = job.target.workspace.workspaceId;
+    if (workspaceId) {
+      byWorkspaceId.set(workspaceId, (byWorkspaceId.get(workspaceId) ?? 0) + 1);
+    }
+    if (job.target.kind === 'session') {
+      bySessionId.set(job.target.sessionId, (bySessionId.get(job.target.sessionId) ?? 0) + 1);
+    }
+  }
+  return { byWorkspaceId, bySessionId };
+}
+
+function applyJobs(jobs: CronJob[]): void {
+  const next = computeCronJobCounts(jobs);
+  if (countsEqual(snapshot, next)) return;
+  snapshot = next;
+  publish();
+}
+
+async function reload(): Promise<void> {
+  if (loadInFlight) return;
+  loadInFlight = true;
+  try {
+    const jobs = await cronAPI.listJobs({});
+    applyJobs(jobs);
+  } catch (error) {
+    // Badges are a hint; keep the previous counts and let the next change
+    // signal retry.
+    log.warn('Failed to load scheduled job counts', { error });
+  } finally {
+    loadInFlight = false;
+  }
+}
+
+/** Subscribe the badge store; idempotent and safe to call from an effect. */
+export function ensureCronJobCountsListener(): void {
+  if (listenerRegistered) return;
+  listenerRegistered = true;
+
+  // Local editor saves, plus the backend hints mirrored below.
+  window.addEventListener(SCHEDULED_JOBS_CHANGED_EVENT, () => {
+    void reload();
+  });
+
+  try {
+    // Backend hints are only a signal; the payload carries no job state. The
+    // source id matches no view instance, so every mounted view reloads.
+    cronAPI.onJobsChanged(() => {
+      notifyScheduledJobsChanged('backend');
+    });
+  } catch (error) {
+    // Badges still track local edits and the initial load below.
+    log.error('Failed to subscribe scheduled job changes', { error });
+  }
+
+  void reload();
+}
+
+/** useSyncExternalStore snapshot: stable between changes. */
+export function getCronJobCountsSnapshot(): CronJobCountsSnapshot {
+  return snapshot;
+}
+
+export function subscribeCronJobCounts(notify: () => void): () => void {
+  listeners.add(notify);
+  return () => { listeners.delete(notify); };
+}
diff --git a/src/web-ui/src/app/scenes/todos/TodosScene.tsx b/src/web-ui/src/app/scenes/todos/TodosScene.tsx
index 3a5efc7869..096f8361b6 100644
--- a/src/web-ui/src/app/scenes/todos/TodosScene.tsx
+++ b/src/web-ui/src/app/scenes/todos/TodosScene.tsx
@@ -173,7 +173,9 @@ const TodosScene: React.FC = () => {
   useEffect(() => { void loadJobs(); }, [loadJobs]);
 
   // Another view (a workspace editor, or the agent's own scheduling tool)
-  // changed a job — reload so the panel is never stale.
+  // changed a job — reload so the panel is never stale. Backend-originated
+  // changes arrive through the cron://jobs-changed subscription owned by
+  // cronJobCountsStore, which mirrors them onto this same browser event.
   useEffect(() => {
     const handleChanged = (event: Event) => {
       const sourceId = (event as CustomEvent<{ sourceId?: string }>).detail?.sourceId;
diff --git a/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx b/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx
new file mode 100644
index 0000000000..fb0d75127e
--- /dev/null
+++ b/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx
@@ -0,0 +1,270 @@
+import React, { useMemo, useState } from 'react';
+import { CronToolCard as CronToolCardView } from '@openbitfun/ui/flow-chat';
+import { useI18n } from '@/infrastructure/i18n';
+import type { CronSchedule } from '@/infrastructure/api';
+import { formatDateTime, formatScheduleSummary } from '@/app/scenes/todos/todoPresentation';
+import type { ToolCardProps } from '../types/flow-chat';
+import { useToolCardHeightContract } from './useToolCardHeightContract';
+
+type CronAction = 'get_time' | 'list' | 'add' | 'update' | 'remove' | 'run';
+
+/**
+ * Schedule shape emitted by the backend `Cron` tool.
+ *
+ * It intentionally differs from the `CronJob` wire shape used by the scheduled
+ * job APIs: the tool speaks seconds and ISO strings so a model can write them,
+ * while the service stores milliseconds.
+ */
+interface CronToolSchedule {
+  kind?: 'at' | 'every' | 'cron';
+  at?: string;
+  every?: number;
+  anchor?: string;
+  expr?: string;
+  tz?: string;
+}
+
+interface CronToolJobState {
+  nextRunAtMs?: number | null;
+  pendingTriggerAtMs?: number | null;
+  retryAtMs?: number | null;
+  lastRunStatus?: string | null;
+  lastError?: string | null;
+}
+
+interface CronToolJob {
+  id?: string;
+  name?: string;
+  schedule?: CronToolSchedule;
+  payload?: string;
+  enabled?: boolean;
+  sessionId?: string;
+  workspacePath?: string;
+  state?: CronToolJobState;
+}
+
+interface CronToolJobInput {
+  name?: string;
+  schedule?: CronToolSchedule;
+  payload?: string;
+  enabled?: boolean;
+}
+
+interface CronToolInput {
+  action?: CronAction;
+  session_id?: string;
+  job_id?: string;
+  job?: CronToolJobInput;
+  patch?: CronToolJobInput;
+}
+
+interface CronToolResult {
+  success?: boolean;
+  action?: CronAction;
+  now?: string;
+  workspace?: string;
+  session_id?: string;
+  job_id?: string;
+  count?: number;
+  deleted?: boolean;
+  job?: CronToolJob;
+  jobs?: CronToolJob[];
+}
+
+function parseData<T>(value: unknown): T | null {
+  if (!value) return null;
+
+  try {
+    return typeof value === 'string' ? JSON.parse(value) as T : value as T;
+  } catch {
+    return null;
+  }
+}
+
+/** Convert the tool's seconds/ISO schedule into the service wire shape. */
+function toCronSchedule(schedule: CronToolSchedule | undefined): CronSchedule | null {
+  if (!schedule) return null;
+
+  if (schedule.kind === 'at') {
+    return schedule.at ? { kind: 'at', at: schedule.at } : null;
+  }
+  if (schedule.kind === 'every') {
+    if (!Number.isFinite(schedule.every)) return null;
+    const anchorMs = schedule.anchor ? new Date(schedule.anchor).getTime() : null;
+    return {
+      kind: 'every',
+      everyMs: Number(schedule.every) * 1000,
+      anchorMs: Number.isFinite(anchorMs) ? anchorMs : null,
+    };
+  }
+  if (schedule.kind === 'cron') {
+    return schedule.expr ? { kind: 'cron', expr: schedule.expr, tz: schedule.tz ?? null } : null;
+  }
+  return null;
+}
+
+/** Timestamp the scheduler will actually act on next, mirroring getNextExecutionAtMs. */
+function nextExecutionAtMs(state: CronToolJobState | undefined): number | null {
+  if (!state) return null;
+  return state.pendingTriggerAtMs ?? state.retryAtMs ?? state.nextRunAtMs ?? null;
+}
+
+export const CronToolCard: React.FC<ToolCardProps> = React.memo(({ toolItem }) => {
+  const { t, formatDate } = useI18n('flow-chat');
+  const { t: tTodos } = useI18n('scenes/todos');
+  const { toolCall, toolResult, status } = toolItem;
+  const [isExpanded, setIsExpanded] = useState(false);
+  const toolId = toolItem.id ?? toolCall?.id;
+  const { cardRootRef, applyExpandedState } = useToolCardHeightContract({
+    toolId,
+    toolName: toolItem.toolName,
+  });
+
+  const inputData = useMemo(
+    () => parseData<CronToolInput>(toolCall?.input) ?? {},
+    [toolCall?.input]
+  );
+
+  const resultData = useMemo(
+    () => parseData<CronToolResult>(toolResult?.result),
+    [toolResult?.result]
+  );
+
+  const action = resultData?.action ?? inputData.action ?? 'list';
+  const job = resultData?.job;
+  const jobs = Array.isArray(resultData?.jobs) ? resultData.jobs : [];
+  const jobId = job?.id ?? resultData?.job_id ?? inputData.job_id;
+  const jobName = job?.name
+    ?? inputData.job?.name
+    ?? inputData.patch?.name
+    ?? jobId
+    ?? t('toolCards.cron.unknownJob');
+  const payload = job?.payload ?? inputData.job?.payload ?? inputData.patch?.payload;
+  const workspace = job?.workspacePath ?? resultData?.workspace;
+  const sessionId = job?.sessionId ?? resultData?.session_id ?? inputData.session_id;
+  const jobCount = resultData?.count ?? jobs.length;
+
+  const describeSchedule = useMemo(() => (schedule: CronToolSchedule | undefined): string | null => {
+    const converted = toCronSchedule(schedule);
+    return converted ? formatScheduleSummary(converted, tTodos, formatDate) : null;
+  }, [formatDate, tTodos]);
+
+  const scheduleText = describeSchedule(job?.schedule ?? inputData.job?.schedule ?? inputData.patch?.schedule);
+  const nextRunMs = nextExecutionAtMs(job?.state);
+  const nextRunText = nextRunMs != null ? formatDateTime(nextRunMs, formatDate) : null;
+  const enabled = job?.enabled ?? inputData.job?.enabled ?? inputData.patch?.enabled;
+  const lastRunStatus = job?.state?.lastRunStatus ?? null;
+  const lastError = job?.state?.lastError ?? null;
+
+  const fields = useMemo(() => {
+    if (action === 'get_time') {
+      return resultData?.now
+        ? [{ label: `${t('toolCards.cron.currentTime')}:`, value: resultData.now }]
+        : [];
+    }
+
+    if (action === 'list') {
+      return jobs.map((item) => ({
+        label: `${item.name ?? item.id ?? t('toolCards.cron.unknownJob')}:`,
+        value: describeSchedule(item.schedule) ?? item.id ?? '-',
+      }));
+    }
+
+    return [
+      scheduleText ? { label: `${t('toolCards.cron.schedule')}:`, value: scheduleText } : null,
+      nextRunText ? { label: `${t('toolCards.cron.nextRun')}:`, value: nextRunText } : null,
+      enabled !== undefined ? {
+        label: `${t('toolCards.cron.enabled')}:`,
+        value: enabled ? t('toolCards.cron.enabledYes') : t('toolCards.cron.enabledNo'),
+      } : null,
+      lastRunStatus ? { label: `${t('toolCards.cron.lastRunStatus')}:`, value: lastRunStatus } : null,
+      lastError ? { label: `${t('toolCards.cron.lastError')}:`, value: lastError } : null,
+      jobId ? { label: `${t('toolCards.cron.jobId')}:`, value: jobId } : null,
+      sessionId ? { label: `${t('toolCards.cron.sessionId')}:`, value: sessionId } : null,
+      workspace ? { label: `${t('toolCards.cron.workspace')}:`, value: workspace } : null,
+    ].filter((field): field is NonNullable<typeof field> => Boolean(field));
+  }, [
+    action,
+    describeSchedule,
+    enabled,
+    jobId,
+    jobs,
+    lastError,
+    lastRunStatus,
+    nextRunText,
+    resultData?.now,
+    scheduleText,
+    sessionId,
+    t,
+    workspace,
+  ]);
+
+  const emptyState = action === 'list' && jobs.length === 0 && status === 'completed'
+    ? t('toolCards.cron.noJobs')
+    : undefined;
+  const message = action === 'add' || action === 'update' ? payload : undefined;
+  const hasDetails = Boolean(fields.length || emptyState || message || toolResult?.error);
+
+  const renderSummary = () => {
+    if (status === 'error' || status === 'cancelled') {
+      return t('toolCards.cron.actionFailed');
+    }
+
+    const running = status === 'running' || status === 'streaming';
+
+    switch (action) {
+      case 'get_time':
+        if (status === 'completed') {
+          return t('toolCards.cron.gotTime', { time: resultData?.now ?? '' });
+        }
+        return running ? t('toolCards.cron.gettingTime') : t('toolCards.cron.preparingGetTime');
+      case 'add':
+        if (status === 'completed') return t('toolCards.cron.addedJob', { name: jobName });
+        return running
+          ? t('toolCards.cron.addingJob', { name: jobName })
+          : t('toolCards.cron.preparingAdd', { name: jobName });
+      case 'update':
+        if (status === 'completed') return t('toolCards.cron.updatedJob', { name: jobName });
+        return running
+          ? t('toolCards.cron.updatingJob', { name: jobName })
+          : t('toolCards.cron.preparingUpdate', { name: jobName });
+      case 'remove':
+        if (status === 'completed') {
+          return resultData?.deleted === false
+            ? t('toolCards.cron.jobNotFound', { name: jobName })
+            : t('toolCards.cron.removedJob', { name: jobName });
+        }
+        return running
+          ? t('toolCards.cron.removingJob', { name: jobName })
+          : t('toolCards.cron.preparingRemove', { name: jobName });
+      case 'run':
+        if (status === 'completed') return t('toolCards.cron.ranJob', { name: jobName });
+        return running
+          ? t('toolCards.cron.runningJob', { name: jobName })
+          : t('toolCards.cron.preparingRun', { name: jobName });
+      case 'list':
+      default:
+        if (status === 'completed') return t('toolCards.cron.listedJobs', { count: jobCount });
+        return running ? t('toolCards.cron.listingJobs') : t('toolCards.cron.preparingList');
+    }
+  };
+
+  return (
+    <div ref={cardRootRef} data-openbitfun-adapter="cron" data-tool-card-id={toolId ?? ''}>
+      <CronToolCardView
+        status={status}
+        isExpanded={isExpanded}
+        onToggle={hasDetails
+          ? () => applyExpandedState(isExpanded, !isExpanded, setIsExpanded)
+          : undefined}
+        action={`${t('toolCards.cron.title')}:`}
+        summary={renderSummary()}
+        fields={fields}
+        message={message}
+        messageLabel={message ? t('toolCards.cron.payload') : undefined}
+        emptyState={emptyState}
+        error={toolResult?.error}
+      />
+    </div>
+  );
+});
diff --git a/src/web-ui/src/flow_chat/tool-cards/index.test.ts b/src/web-ui/src/flow_chat/tool-cards/index.test.ts
index 1533263852..9109271777 100644
--- a/src/web-ui/src/flow_chat/tool-cards/index.test.ts
+++ b/src/web-ui/src/flow_chat/tool-cards/index.test.ts
@@ -61,6 +61,7 @@ describe('tool card registry', () => {
       'GetFileDiff',
       'SessionControl',
       'SessionMessage',
+      'Cron',
       'RunCode',
       'ExecCommand',
       'WriteStdin',
diff --git a/src/web-ui/src/flow_chat/tool-cards/index.ts b/src/web-ui/src/flow_chat/tool-cards/index.ts
index 7a4bc3fa31..cb74472b77 100644
--- a/src/web-ui/src/flow_chat/tool-cards/index.ts
+++ b/src/web-ui/src/flow_chat/tool-cards/index.ts
@@ -57,6 +57,7 @@ import { ReviewSessionSummaryCard } from './ReviewSessionSummaryCard';
 import { SessionControlToolCard } from './SessionControlToolCard';
 import { SessionMessageToolCard } from './SessionMessageToolCard';
 import { ComputerUseToolCard } from './ComputerUseToolCard';
+import { CronToolCard } from './CronToolCard';
 import { ViewImageToolCard } from './ViewImageToolCard';
 import { OpenBitFunControlToolCard } from './OpenBitFunControlToolCard';
 
@@ -104,6 +105,9 @@ export const STANDARD_TOOL_CARD_ADAPTERS = {
   'SessionControl': SessionControlToolCard,
   'SessionMessage': SessionMessageToolCard,
 
+  // Scheduled jobs
+  'Cron': CronToolCard,
+
   // Code-mode agents: one program per step instead of one card per action
   'RunCode': RunCodeToolCard,
 
diff --git a/src/web-ui/src/flow_chat/tool-cards/toolCardMetadata.ts b/src/web-ui/src/flow_chat/tool-cards/toolCardMetadata.ts
index 26c770ed12..bac786b56e 100644
--- a/src/web-ui/src/flow_chat/tool-cards/toolCardMetadata.ts
+++ b/src/web-ui/src/flow_chat/tool-cards/toolCardMetadata.ts
@@ -28,6 +28,7 @@ const AMBIENT_TOOL_CARD_NAMES = new Set([
   'TerminalControl',
   'SessionControl',
   'SessionMessage',
+  'Cron',
   'RunCode',
   'ComputerUse',
   'view_image',
@@ -351,6 +352,17 @@ const TOOL_CARD_DEFINITIONS: Record<string, ToolCardDefinition> = {
     primaryColor: APPEARANCE_DOMAIN_TOKENS.toolIdentity.assistantAction
   },
 
+  'Cron': {
+    toolName: 'Cron',
+    displayName: 'Scheduled Job',
+    icon: 'CRON',
+    requiresConfirmation: false,
+    resultDisplayType: 'summary',
+    description: 'Create, update, list, or run scheduled jobs',
+    displayMode: 'compact',
+    primaryColor: APPEARANCE_DOMAIN_TOKENS.toolIdentity.assistantAction
+  },
+
   // Code-mode agents (e.g. DeepSeek Harness's PTC preset) answer a step by
   // writing one program instead of calling one tool per action.
   'RunCode': {
@@ -644,6 +656,7 @@ export const DEDICATED_TOOL_CARD_NAMES = new Set([
   'CreatePlan',
   'SessionControl',
   'SessionMessage',
+  'Cron',
   'RunCode',
   'ExecCommand',
   'WriteStdin',
diff --git a/src/web-ui/src/infrastructure/api/service-api/CronAPI.ts b/src/web-ui/src/infrastructure/api/service-api/CronAPI.ts
index c9ac857d77..30ef65f993 100644
--- a/src/web-ui/src/infrastructure/api/service-api/CronAPI.ts
+++ b/src/web-ui/src/infrastructure/api/service-api/CronAPI.ts
@@ -107,6 +107,19 @@ export interface UpdateCronJobRequest {
 }
 
 export class CronAPI {
+  /**
+   * Register a listener for backend scheduled-job change hints. The backend
+   * emits these when the job set or a job's run state changes (agent tool
+   * calls, scheduler runs, session cleanup); the payload is only a hint, so
+   * consumers re-read the job list. Returns an unlisten function.
+   */
+  onJobsChanged(callback: (payload: { reason?: string; jobId?: string | null }) => void): () => void {
+    return api.listen<{ reason?: string; jobId?: string | null }>(
+      'cron://jobs-changed',
+      callback,
+    );
+  }
+
   async notifyHostReady(): Promise<void> {
     if (!isTauriRuntime()) {
       return;
diff --git a/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.test.ts b/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.test.ts
index 4442214eaf..dcb6c84c05 100644
--- a/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.test.ts
+++ b/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.test.ts
@@ -24,6 +24,7 @@ describe('isSurfaceScopedEvent', () => {
     expect(isSurfaceScopedEvent('permission://event')).toBe(true);
     expect(isSurfaceScopedEvent('session_title_generated')).toBe(true);
     expect(isSurfaceScopedEvent('workspace-catalog-changed')).toBe(true);
+    expect(isSurfaceScopedEvent('cron://jobs-changed')).toBe(true);
   });
 
   it('leaves control-plane events unscoped so they always pass', () => {
diff --git a/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.ts b/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.ts
index 5cb254fb01..3f1213d428 100644
--- a/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.ts
+++ b/src/web-ui/src/infrastructure/peer-device/deviceSurfaceRouting.ts
@@ -43,6 +43,7 @@ const SURFACE_SCOPED_EVENTS = new Set<string>([
   'ai://model-catalog-updated',
   'session_title_generated',
   'workspace-catalog-changed',
+  'cron://jobs-changed',
 ]);
 
 const SURFACE_SCOPED_PREFIXES = ['agentic://', 'backend-event-'];
diff --git a/src/web-ui/src/locales/en-US/common.json b/src/web-ui/src/locales/en-US/common.json
index 545c877420..fe035b5838 100644
--- a/src/web-ui/src/locales/en-US/common.json
+++ b/src/web-ui/src/locales/en-US/common.json
@@ -456,6 +456,7 @@
       "title": "Scheduled Jobs",
       "open": "Scheduled jobs",
       "shortLabel": "Schedule",
+      "badgeTooltip": "{{count}} scheduled job(s)",
       "listTitle": "Jobs",
       "assistantFallback": "Current assistant",
       "loading": "Loading scheduled jobs...",
@@ -504,8 +505,7 @@
         }
       },
       "targets": {
-        "session": "Session",
-        "newSession": "New session"
+        "session": "Session"
       },
       "status": {
         "idle": "Idle",
diff --git a/src/web-ui/src/locales/en-US/flow-chat.json b/src/web-ui/src/locales/en-US/flow-chat.json
index 904be6727f..ed94122d7b 100644
--- a/src/web-ui/src/locales/en-US/flow-chat.json
+++ b/src/web-ui/src/locales/en-US/flow-chat.json
@@ -2220,6 +2220,43 @@
       "agentType": "Agent type",
       "message": "Message"
     },
+    "cron": {
+      "title": "Scheduled job",
+      "unknownJob": "Unknown job",
+      "preparingGetTime": "Preparing to read the current time",
+      "gettingTime": "Reading the current time",
+      "gotTime": "Current time {{time}}",
+      "preparingList": "Preparing to list scheduled jobs",
+      "listingJobs": "Listing scheduled jobs",
+      "listedJobs": "Found {{count}} scheduled jobs",
+      "noJobs": "No scheduled jobs found",
+      "preparingAdd": "Preparing to create {{name}}",
+      "addingJob": "Creating {{name}}",
+      "addedJob": "Created {{name}}",
+      "preparingUpdate": "Preparing to update {{name}}",
+      "updatingJob": "Updating {{name}}",
+      "updatedJob": "Updated {{name}}",
+      "preparingRemove": "Preparing to delete {{name}}",
+      "removingJob": "Deleting {{name}}",
+      "removedJob": "Deleted {{name}}",
+      "jobNotFound": "No scheduled job found for {{name}}",
+      "preparingRun": "Preparing to run {{name}}",
+      "runningJob": "Triggering {{name}}",
+      "ranJob": "Triggered {{name}}",
+      "actionFailed": "Scheduled job operation failed",
+      "schedule": "Schedule",
+      "nextRun": "Next run",
+      "enabled": "Enabled",
+      "enabledYes": "Yes",
+      "enabledNo": "No",
+      "lastRunStatus": "Last run status",
+      "lastError": "Last error",
+      "jobId": "Job ID",
+      "sessionId": "Session ID",
+      "workspace": "Workspace path",
+      "payload": "Payload",
+      "currentTime": "Current time"
+    },
     "contextCompression": {
       "beforeUserMessage": "Before user message",
       "toolBatchComplete": "Tool batch complete",
diff --git a/src/web-ui/src/locales/zh-CN/common.json b/src/web-ui/src/locales/zh-CN/common.json
index 219195a1b7..b8ed7da5c0 100644
--- a/src/web-ui/src/locales/zh-CN/common.json
+++ b/src/web-ui/src/locales/zh-CN/common.json
@@ -456,6 +456,7 @@
       "title": "定时任务",
       "open": "定时任务",
       "shortLabel": "定时任务",
+      "badgeTooltip": "{{count}} 个定时任务",
       "listTitle": "任务列表",
       "assistantFallback": "当前助理",
       "loading": "正在加载定时任务...",
@@ -504,8 +505,7 @@
         }
       },
       "targets": {
-        "session": "会话",
-        "newSession": "新会话"
+        "session": "会话"
       },
       "status": {
         "idle": "待命",
diff --git a/src/web-ui/src/locales/zh-CN/flow-chat.json b/src/web-ui/src/locales/zh-CN/flow-chat.json
index 682f39e8e5..3ce8e9f6d6 100644
--- a/src/web-ui/src/locales/zh-CN/flow-chat.json
+++ b/src/web-ui/src/locales/zh-CN/flow-chat.json
@@ -2220,6 +2220,43 @@
       "agentType": "智能体类型",
       "message": "消息内容"
     },
+    "cron": {
+      "title": "定时任务",
+      "unknownJob": "未知任务",
+      "preparingGetTime": "准备读取当前时间",
+      "gettingTime": "正在读取当前时间",
+      "gotTime": "当前时间 {{time}}",
+      "preparingList": "准备列出定时任务",
+      "listingJobs": "正在列出定时任务",
+      "listedJobs": "找到 {{count}} 个定时任务",
+      "noJobs": "未找到定时任务",
+      "preparingAdd": "准备创建 {{name}}",
+      "addingJob": "正在创建 {{name}}",
+      "addedJob": "已创建 {{name}}",
+      "preparingUpdate": "准备更新 {{name}}",
+      "updatingJob": "正在更新 {{name}}",
+      "updatedJob": "已更新 {{name}}",
+      "preparingRemove": "准备删除 {{name}}",
+      "removingJob": "正在删除 {{name}}",
+      "removedJob": "已删除 {{name}}",
+      "jobNotFound": "未找到定时任务 {{name}}",
+      "preparingRun": "准备运行 {{name}}",
+      "runningJob": "正在触发 {{name}}",
+      "ranJob": "已触发 {{name}}",
+      "actionFailed": "定时任务操作失败",
+      "schedule": "调度规则",
+      "nextRun": "下次执行",
+      "enabled": "已启用",
+      "enabledYes": "是",
+      "enabledNo": "否",
+      "lastRunStatus": "上次执行状态",
+      "lastError": "上次错误",
+      "jobId": "任务 ID",
+      "sessionId": "会话 ID",
+      "workspace": "工作空间",
+      "payload": "任务内容",
+      "currentTime": "当前时间"
+    },
     "contextCompression": {
       "beforeUserMessage": "用户消息前",
       "toolBatchComplete": "工具批次完成",
diff --git a/src/web-ui/src/locales/zh-TW/common.json b/src/web-ui/src/locales/zh-TW/common.json
index b47062ee67..db9f557b91 100644
--- a/src/web-ui/src/locales/zh-TW/common.json
+++ b/src/web-ui/src/locales/zh-TW/common.json
@@ -456,6 +456,7 @@
       "title": "定時任務",
       "open": "定時任務",
       "shortLabel": "定時任務",
+      "badgeTooltip": "{{count}} 個定時任務",
       "listTitle": "任務列表",
       "assistantFallback": "目前助理",
       "loading": "正在載入定時任務...",
@@ -504,8 +505,7 @@
         }
       },
       "targets": {
-        "session": "會話",
-        "newSession": "新會話"
+        "session": "會話"
       },
       "status": {
         "idle": "待命",
diff --git a/src/web-ui/src/locales/zh-TW/flow-chat.json b/src/web-ui/src/locales/zh-TW/flow-chat.json
index d3c9b64561..cbe3e5f1ce 100644
--- a/src/web-ui/src/locales/zh-TW/flow-chat.json
+++ b/src/web-ui/src/locales/zh-TW/flow-chat.json
@@ -2220,6 +2220,43 @@
       "agentType": "智能體類型",
       "message": "消息內容"
     },
+    "cron": {
+      "title": "定時任務",
+      "unknownJob": "未知任務",
+      "preparingGetTime": "準備讀取當前時間",
+      "gettingTime": "正在讀取當前時間",
+      "gotTime": "當前時間 {{time}}",
+      "preparingList": "準備列出定時任務",
+      "listingJobs": "正在列出定時任務",
+      "listedJobs": "找到 {{count}} 個定時任務",
+      "noJobs": "未找到定時任務",
+      "preparingAdd": "準備創建 {{name}}",
+      "addingJob": "正在創建 {{name}}",
+      "addedJob": "已創建 {{name}}",
+      "preparingUpdate": "準備更新 {{name}}",
+      "updatingJob": "正在更新 {{name}}",
+      "updatedJob": "已更新 {{name}}",
+      "preparingRemove": "準備刪除 {{name}}",
+      "removingJob": "正在刪除 {{name}}",
+      "removedJob": "已刪除 {{name}}",
+      "jobNotFound": "未找到定時任務 {{name}}",
+      "preparingRun": "準備執行 {{name}}",
+      "runningJob": "正在觸發 {{name}}",
+      "ranJob": "已觸發 {{name}}",
+      "actionFailed": "定時任務操作失敗",
+      "schedule": "調度規則",
+      "nextRun": "下次執行",
+      "enabled": "已啟用",
+      "enabledYes": "是",
+      "enabledNo": "否",
+      "lastRunStatus": "上次執行狀態",
+      "lastError": "上次錯誤",
+      "jobId": "任務 ID",
+      "sessionId": "會話 ID",
+      "workspace": "工作空間",
+      "payload": "任務內容",
+      "currentTime": "當前時間"
+    },
     "contextCompression": {
       "beforeUserMessage": "用戶消息前",
       "toolBatchComplete": "工具批次完成",

From 49b3ae21178aae77787b9f3111b599dabb17d7a9 Mon Sep 17 00:00:00 2001
From: nonoqing <y_yqingfiona@163.com>
Date: Sun, 20 Sep 2026 17:13:30 +0800
Subject: [PATCH 2/3] fix(web-ui): keep the Cron tool-card memo dependencies
 stable

Frontend Build failed on `pnpm run lint:web`:

  src/flow_chat/tool-cards/CronToolCard.tsx:135  react-hooks/exhaustive-deps

The empty fallback array for list results was rebuilt on every render, so
the `fields` memo could never keep a stable dependency list. Memoize the
fallback next to the other parsed tool-call data.
---
 src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx b/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx
index fb0d75127e..679897dbfc 100644
--- a/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx
+++ b/src/web-ui/src/flow_chat/tool-cards/CronToolCard.tsx
@@ -132,7 +132,10 @@ export const CronToolCard: React.FC<ToolCardProps> = React.memo(({ toolItem }) =
 
   const action = resultData?.action ?? inputData.action ?? 'list';
   const job = resultData?.job;
-  const jobs = Array.isArray(resultData?.jobs) ? resultData.jobs : [];
+  const jobs = useMemo(
+    () => (Array.isArray(resultData?.jobs) ? resultData.jobs : []),
+    [resultData?.jobs]
+  );
   const jobId = job?.id ?? resultData?.job_id ?? inputData.job_id;
   const jobName = job?.name
     ?? inputData.job?.name

From 8e6cee46187d8934c9db244bf4836fccc22c1eb9 Mon Sep 17 00:00:00 2001
From: nonoqing <y_yqingfiona@163.com>
Date: Sun, 20 Sep 2026 17:13:30 +0800
Subject: [PATCH 3/3] fix(design-lab): register the Cron tool card preview

`flowChatPreviewDefinitions` is typed with `satisfies
FlowChatPreviewDefinitionMap`, so every migrated flow-chat component needs
a preview definition. Add the Cron ambient preview, its gallery specimen,
and the specimen contract entry, following the other standard tool cards.
---
 .../src/preview/FlowChatPreviewRegistry.tsx   | 31 ++++++++++++++++++-
 .../vite/component-detail-contract.test.mjs   |  1 +
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/design-system/apps/design-lab/src/preview/FlowChatPreviewRegistry.tsx b/design-system/apps/design-lab/src/preview/FlowChatPreviewRegistry.tsx
index 20779c2d5b..6d6057e8c9 100644
--- a/design-system/apps/design-lab/src/preview/FlowChatPreviewRegistry.tsx
+++ b/design-system/apps/design-lab/src/preview/FlowChatPreviewRegistry.tsx
@@ -7,6 +7,7 @@ import {
   Archive,
   ArrowDownToLine,
   ArrowUp,
+  CalendarClock,
   CheckCircle2,
   Circle,
   Code2,
@@ -59,6 +60,7 @@ import {
   ChatComposerQueueTitle,
   CommandToolCard,
   ContextCompressionToolCard,
+  CronToolCard,
   DefaultToolCard,
   DirectoryListToolCard,
   FileDiffToolCard,
@@ -678,7 +680,7 @@ function SessionPreview({
 
 const PREVIEW_IMAGE = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='320' height='320' viewBox='0 0 320 320'%3E%3Crect width='320' height='320' rx='32' fill='%23232a35'/%3E%3Cpath d='M60 235l64-76 42 45 31-36 63 67z' fill='%237e8ca3'/%3E%3Ccircle cx='224' cy='91' r='25' fill='%23c6cfdb'/%3E%3C/svg%3E";
 
-type StandardAmbientPreviewKind = "default" | "run-code" | "todo" | "view-image" | "web-fetch";
+type StandardAmbientPreviewKind = "cron" | "default" | "run-code" | "todo" | "view-image" | "web-fetch";
 
 function StandardAmbientPreview({
   interactive,
@@ -753,6 +755,25 @@ function StandardAmbientPreview({
         statusText={state === "loading" ? t("components.preview.flowChat.running") : "Viewed image"}
       />
     );
+  } else if (kind === "cron") {
+    card = (
+      <CronToolCard
+        {...common}
+        action="Scheduled job:"
+        error={state === "error" ? t("components.preview.flowChat.failed") : undefined}
+        fields={[
+          { label: "Schedule:", value: "Every 30 minutes" },
+          { label: "Next run:", value: "Today 14:30" },
+          { label: "Enabled:", value: "Yes" },
+          { label: "Job id:", value: "job_7f3a91" },
+        ]}
+        message={isExpanded ? "Summarize the open pull requests and report blockers." : undefined}
+        messageLabel="Payload"
+        summary={state === "error"
+          ? t("components.preview.flowChat.failed")
+          : "Created Nightly repository review"}
+      />
+    );
   } else {
     card = (
       <TodoToolCard
@@ -1050,6 +1071,14 @@ export const flowChatPreviewDefinitions = {
     section: "tool-card",
     specimens: [{ tool: "ContextCompression" }],
   },
+  CronToolCard: {
+    attention: "ambient",
+    codeSample: concreteCodeSample("CronToolCard"),
+    icon: CalendarClock,
+    render: (options) => <StandardAmbientPreview {...options} kind="cron" />,
+    section: "tool-card",
+    specimens: [{ tool: "Cron" }],
+  },
   DefaultToolCard: {
     attention: "ambient",
     codeSample: concreteCodeSample("DefaultToolCard"),
diff --git a/design-system/apps/design-lab/vite/component-detail-contract.test.mjs b/design-system/apps/design-lab/vite/component-detail-contract.test.mjs
index c9527480b6..5f2aaa21b9 100644
--- a/design-system/apps/design-lab/vite/component-detail-contract.test.mjs
+++ b/design-system/apps/design-lab/vite/component-detail-contract.test.mjs
@@ -120,6 +120,7 @@ test("FlowChat gallery renders only the real migrated tool-card components", asy
     "WriteStdin",
     "ExecControl",
     "ContextCompression",
+    "Cron",
     "ControlHub",
     "FinalizeMiniApp",
     "PublishMiniApp",