Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="src-tauri/src/commands/maa_agent.rs" line_range="38-39" />
<code_context>

 /// 发送 Agent 输出事件
 fn emit_agent_output(app: &tauri::AppHandle, instance_id: &str, stream: &str, line: &str) {
+    let clean_line = strip_ansi_escapes(line);
+    let timestamp = chrono::Local::now().format("%H:%M:%S");
+    cprintln!("[{timestamp}][AGT] {clean_line}");
+
</code_context>
<issue_to_address>
**suggestion (performance):** Skip work for console logging when the console output is disabled.

Currently this still allocates for `strip_ansi_escapes` and computes a timestamp on every call, even when `--console` is not passed and `cprintln!` is a no-op. For high-volume agent output this overhead can be significant. Consider adding a cheap `is_console_enabled()` helper (e.g., in `utils`) and returning early or guarding this whole block so ANSI stripping and timestamp calculation only run when console output is enabled.

Suggested implementation:

```rust
use super::types::{AgentConfig, MaaState, TaskConfig};
use super::utils::{emit_callback_event, get_logs_dir, is_console_enabled, normalize_path};
use crate::cprintln;
use regex::Regex;
use std::sync::LazyLock;

```

```rust

```

```rust
    if is_console_enabled() {
        let clean_line = strip_ansi_escapes(line);
        let timestamp = chrono::Local::now().format("%H:%M:%S");
        cprintln!("[{timestamp}][AGT] {clean_line}");
    }

```

1. Implement an `is_console_enabled() -> bool` helper in `super::utils` (likely `src-tauri/src/commands/utils.rs` or similar). It should return `true` when `--console` has been enabled and `false` otherwise, using whatever configuration/state you already maintain for console output.
2. Ensure `is_console_enabled()` is cheap (no allocation, no heavy locking) since it's called on each agent output.
3. In `emit_agent_output`, keep all non-console-related logic (such as emitting Tauri events via `emit_callback_event`) outside the `if is_console_enabled()` block so that event delivery is not affected by console configuration.
</issue_to_address>

### Comment 2
<location path="src-tauri/src/commands/utils.rs" line_range="25-36" />
<code_context>
+        use windows::Win32::System::Console::{AttachConsole, ATTACH_PARENT_PROCESS};
+
+        // 附着到父进程终端（从 cmd/powershell 启动时生效）
+        if unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }.is_ok() {
+            if let Ok(f) = std::fs::OpenOptions::new().write(true).open("CONOUT$") {
+                let _ = CONSOLE_FILE.set(std::sync::Mutex::new(f));
+                CONSOLE_ENABLED.store(true, Ordering::Relaxed);
</code_context>
<issue_to_address>
**suggestion:** Consider surfacing failures to attach to the parent console when `--console` is requested.

If `--console` is used but `AttachConsole` or opening `CONOUT$` fails, this returns silently and console logging is never enabled, which can make `--console` look ineffective. Consider logging a one-time warning on failure (e.g., via `log::warn!`) to explain why console output wasn’t enabled.

```suggestion
    #[cfg(windows)]
    {
        use windows::Win32::System::Console::{AttachConsole, ATTACH_PARENT_PROCESS};

        // 附着到父进程终端（从 cmd/powershell 启动时生效）
        if unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }.is_ok() {
            if let Ok(f) = std::fs::OpenOptions::new().write(true).open("CONOUT$") {
                let _ = CONSOLE_FILE.set(std::sync::Mutex::new(f));
                CONSOLE_ENABLED.store(true, Ordering::Relaxed);
            } else {
                log::warn!(
                    "Failed to open CONOUT$ for console output; `--console` will have no effect."
                );
            }
        } else {
            log::warn!(
                "Failed to attach to the parent console; `--console` will have no effect."
            );
        }
    }
```
</issue_to_address>

Please address the comments from this code review:

## Overall Comments
- The logic for Tauri console invocation/enablement (`getConsoleInvoke`, `_consoleEnabled`, `_invoke`) is duplicated between `appStore.ts` and `useMaaCallbackLogger.ts`; consider extracting this into a shared utility to avoid future divergence and keep the behavior consistent.
- The persistence subscription now serializes the selected slice of `AppState` with `JSON.stringify` on every change; if this becomes a hot path, consider a cheaper equality strategy (e.g., shallow compares on fields you know change, or incrementing a version counter when persisted fields mutate) to reduce CPU cost and GC pressure.
- The pending console log maps (`pendingTaskConsoleLogs`, `pendingTaskConsoleReplayTimers`, `pendingTaskConsoleReplayRetries`) are global; it may be worth explicitly clearing related entries when an instance is removed or all tasks for an instance are cleared to avoid long-lived memory/timer leaks in edge cases.

## Individual Comments

### Comment 1
<location path="src/stores/appStore.ts" line_range="45-54" />
<code_context>
+let _consoleEnabled: boolean | null = null;
+let _invoke: ((cmd: string, args?: Record<string, unknown>) => Promise<unknown>) | null = null;
+
+async function getConsoleInvoke() {
+  if (_consoleEnabled === false) return null;
+  if (_invoke && _consoleEnabled === true) return _invoke;
+  if (!isTauri()) {
+    _consoleEnabled = false;
+    return null;
+  }
+  const { invoke } = await import('@tauri-apps/api/core');
+  _invoke = invoke;
+  try {
+    _consoleEnabled = await invoke<boolean>('is_console_enabled');
+  } catch {
+    _consoleEnabled = false;
+  }
+  return _consoleEnabled ? _invoke : null;
+}
+
</code_context>
<issue_to_address>
**suggestion:** Consider de-duplicating the Tauri console invoke/flag logic shared with `useMaaCallbackLogger`

This `getConsoleInvoke` / `_consoleEnabled` / `_invoke` pattern closely mirrors the implementation in `useMaaCallbackLogger.ts`. Duplicating it in two places risks them drifting apart (e.g., command name/behavior changes applied in only one file). Consider extracting a small shared helper (e.g. `consoleBridge.ts`) that provides `getConsoleInvoke()` and possibly `getConsoleOutputMode()`, and using it both here and in the callback logger.

Suggested implementation:

```typescript
import { generateId, initializeAllOptionValues, convertPresetOptionValue } from './helpers';
// 从独立模块导入类型和辅助函数
import type { AppState, LogEntry, TaskRunStatus } from './types';
import { isTauri } from '@/utils/paths';
import { getConsoleInvoke } from '@/utils/consoleBridge';

```

To fully implement the suggestion and avoid duplication, you should also:

1. **Create a shared helper** `src/utils/consoleBridge.ts` (path can be adjusted to your conventions) that encapsulates the console/Tauri logic currently duplicated between `appStore.ts` and `useMaaCallbackLogger.ts`, e.g.:
   - Cache `_consoleEnabled` and `_invoke` at module scope.
   - Implement and export `async function getConsoleInvoke()`.
   - Optionally implement and export `async function getConsoleOutputMode()` or similar if both call sites need it.
2. **Move the existing implementation** of `getConsoleInvoke` (including `_consoleEnabled` / `_invoke` and `is_console_enabled` invoke logic) from `appStore.ts` and `useMaaCallbackLogger.ts` into `consoleBridge.ts`.
3. **Remove the local `getConsoleInvoke` implementation** (function definition and the associated `_consoleEnabled` / `_invoke` variables) from `appStore.ts` and from `useMaaCallbackLogger.ts`.
4. **Import and use the shared helper**:
   - In `appStore.ts`, keep the `getConsoleInvoke(...)` call sites unchanged; they will now reference the imported function.
   - In `useMaaCallbackLogger.ts`, replace any local `getConsoleInvoke` usage with an import from `@/utils/consoleBridge`.
5. If `consoleBridge.ts` now owns the Tauri dependency, you can **remove any now-unused `isTauri` imports** from `appStore.ts` and `useMaaCallbackLogger.ts` (or keep them if used elsewhere in those files).
</issue_to_address>

Please address the comments from this code review:

## Overall Comments
- In `forwardLogToConsole` the HTML stripping uses a very broad regex (`/<[^>]*>/g`), which will also remove any literal `<...>` content in messages; consider using a more robust HTML-to-text approach (e.g., a DOM-based parser or a narrower pattern that only targets known tags) to avoid losing legitimate text.
- In `consoleBridge.getConsoleInvoke` and `consoleLog`, all failures are silently swallowed; adding at least a one-time debug log when console detection or invocation fails would make diagnosing misconfigured `--log-mode` or Tauri command issues much easier without spamming the console.