openagentd 1.76.0__tar.gz → 1.76.2__tar.gz

{openagentd-1.76.0 → openagentd-1.76.2}/.openagentd/skills/oad/release/SKILL.md

@@ -72,6 +72,21 @@ git diff --stat main..HEAD -- documents/docs/features.md documents/docs/roadmap.
 
 6. Version PR:
 
+- **Before bumping, verify CI is green on `main`.** Check both the `Core` (pytest) and `Web` (lint + typecheck + tests) workflows on the latest commit:
+
+```bash
+# Get the SHA of the commit you are about to release from
+git rev-parse HEAD
+
+# List the most recent runs of each CI workflow and confirm conclusion=success
+gh run list --workflow=core.yml --branch=main --limit=3
+gh run list --workflow=web.yml  --branch=main --limit=3
+
+# If either shows failure, inspect and fix before continuing:
+gh run view <run-id> --log-failed
+```
+
+- Do **not** proceed with the version bump if any required CI workflow is failing on `main`. Fix the failures first, push the fix to `main`, confirm CI goes green, then resume the release.
 - Reuse the existing feature branch when present; do not spin a fresh `release/` branch on top of it.
 - `app/version.txt` is the **single human-edited source of truth** for release versioning.
 - Use the release helper to propagate that version to every release-facing file, refresh lockfiles, and update release docs metadata:

{openagentd-1.76.0 → openagentd-1.76.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openagentd
-Version: 1.76.0
+Version: 1.76.2
 Summary: Self-hosted AI agents — streaming chat, tool use, persistent memory, multi-agent teams
 Project-URL: Repository, https://github.com/lthoangg/openagentd
 Project-URL: Bug Tracker, https://github.com/lthoangg/openagentd/issues

{openagentd-1.76.0 → openagentd-1.76.2}/app/agent/providers/googlegenai/googlegenai.py

@@ -413,7 +413,17 @@ class GeminiProviderBase(LLMProviderBase):
                 # and emit a second, never-completed tool_call SSE event.
                 # Track id → idx once and reuse so the buffer sees stable
                 # slots regardless of intra-chunk part ordering.
+                #
+                # Me each Gemini SSE chunk is a full snapshot, not a delta —
+                # the same function_call (same id, same args) is re-emitted
+                # verbatim in every subsequent chunk until the stream ends.
+                # The generic accumulator in streaming.py appends each chunk's
+                # args to the buffer, so a re-emitted chunk doubles the JSON
+                # and breaks validation.  Suppress args (and name) on every
+                # chunk after the first for a given tool call id so the
+                # accumulator receives exactly one copy.
                 tool_idx_by_id: dict[str, int] = {}
+                tool_args_emitted: set[str] = set()
 
                 async for data in iter_sse_data(response, sentinel=None):
                     gemini_resp = GeminiChatResponse.model_validate(data)
@@ -444,13 +454,20 @@ class GeminiProviderBase(LLMProviderBase):
                             stable_idx = tool_idx_by_id.setdefault(
                                 fc_id, len(tool_idx_by_id)
                             )
+                            first_emission = fc_id not in tool_args_emitted
+                            if first_emission:
+                                tool_args_emitted.add(fc_id)
                             delta_tool_calls.append(
                                 ToolCallDelta(
                                     index=stable_idx,
                                     id=fc_id,
                                     function=FunctionCallDelta(
-                                        name=part.function_call.name,
-                                        arguments=json.dumps(part.function_call.args),
+                                        name=part.function_call.name
+                                        if first_emission
+                                        else None,
+                                        arguments=json.dumps(part.function_call.args)
+                                        if first_emission
+                                        else None,
                                         thought_signature=part.thought_signature,
                                     ),
                                 )

{openagentd-1.76.0 → openagentd-1.76.2}/app/agent/providers/openai/responses.py

@@ -340,6 +340,13 @@ class ResponsesHandler:
         current_tool_call_index = -1
         tool_call_map: dict[str, int] = {}  # item_id -> index
         tool_names: dict[str, str] = {}  # item_id -> function_name
+        # Me: OpenAI /responses streams both delta events (partial args) AND
+        # a final .done event (complete args).  The assembler in streaming.py
+        # appends every arguments fragment it receives, so emitting the full
+        # args string on .done after all deltas doubles the JSON and breaks
+        # json.loads with "Extra data".  Track which call_ids have received
+        # at least one .delta so .done can skip re-emitting arguments.
+        tool_had_deltas: set[str] = set()  # call_ids that received delta chunks
         # Me: OpenAI's /responses API emits reasoning as multiple
         # ``summary_part`` items per response. Each part starts with its
         # own bold header (``**Title**``) and its deltas carry NO separator
@@ -449,6 +456,7 @@ class ResponsesHandler:
                     tool_call_map[call_id] = current_tool_call_index
                 if inline_name and call_id and call_id not in tool_names:
                     tool_names[call_id] = inline_name
+                tool_had_deltas.add(call_id)
 
                 idx = tool_call_map[call_id]
                 emit_name = inline_name if first_delta and inline_name else None
@@ -490,6 +498,11 @@ class ResponsesHandler:
 
                 idx = tool_call_map[call_id]
 
+                # Suppress arguments when deltas were already streamed — the
+                # assembler has the full string from concatenated delta chunks.
+                # Only fall back to fn_args when no deltas arrived (edge case).
+                emit_args = fn_args if call_id not in tool_had_deltas else None
+
                 yield ChatCompletionChunk(
                     id=response_id,
                     created=int(time.time()),
@@ -504,7 +517,7 @@ class ResponsesHandler:
                                         id=call_id,
                                         function=FunctionCallDelta(
                                             name=fn_name,
-                                            arguments=fn_args,
+                                            arguments=emit_args,
                                         ),
                                     )
                                 ]

{openagentd-1.76.0 → openagentd-1.76.2}/app/api/routes/team/files.py

@@ -384,10 +384,20 @@ async def get_coding_workspace_git_diff(
     # restricts to those pathspecs (which can be files or directories).
     diff_paths = scoped if scoped else ["."]
 
+    # We want changes to show whether or not they've been staged. Plain
+    # ``git diff`` only reports working-tree-vs-index (unstaged) changes, so a
+    # file disappears from the panel the moment it's ``git add``-ed.
+    # ``git diff HEAD`` instead reports working-tree-vs-HEAD, i.e. the combined
+    # staged + unstaged changes for every tracked file in a single diff with no
+    # duplicate per-file sections. When there is no HEAD yet (a repo with zero
+    # commits) ``git diff HEAD`` fails, so we fall back to a plain ``git diff``.
+    has_head = await _run_git(resolved, "rev-parse", "--verify", "HEAD") is not None
+    diff_args = ["diff", "HEAD"] if has_head else ["diff"]
+
     try:
         result = await asyncio.to_thread(
             subprocess.run,
-            ["git", "-C", resolved, "diff", "--", *diff_paths],
+            ["git", "-C", resolved, *diff_args, "--", *diff_paths],
             capture_output=True,
             text=True,
             timeout=10,

openagentd-1.76.2/app/version.txt

@@ -0,0 +1 @@
+1.76.2

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/Cargo.lock

@@ -403,9 +403,9 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "byte-unit"
-version = "5.2.3"
+version = "5.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37bcaa4a0975bed4a760af3efe4368825098ce5f9d37a30c5a021d635dc63d8f"
+checksum = "ea91eef119026f16da52985896b3572d9abbb14f1ea5c9417fdf05da8309b66e"
 dependencies = [
  "rust_decimal",
  "schemars 1.2.1",
@@ -2603,7 +2603,7 @@ dependencies = [
 
 [[package]]
 name = "openagentd-desktop"
-version = "1.76.0"
+version = "1.76.2"
 dependencies = [
  "anyhow",
  "block2",

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "openagentd-desktop"
-version = "1.76.0"
+version = "1.76.2"
 description = "OpenAgentd — on-machine AI agents (desktop shell)"
 authors = ["openagentd contributors"]
 license = "Apache-2.0"

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/build.rs

@@ -7,6 +7,7 @@ fn main() {
                 "backend_health",
                 "backend_logs_path",
                 "app_new_window",
+                "reapply_window_chrome",
                 "app_stop_bundled_backend",
                 "set_tray_session",
                 "updater_check",

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/capabilities/default.json

@@ -36,6 +36,7 @@
     "allow-app-use-external-backend",
     "allow-app-use-bundled-backend",
     "allow-app-new-window",
+    "allow-reapply-window-chrome",
     "allow-app-stop-bundled-backend",
     "allow-set-tray-session",
     "allow-updater-check",

openagentd-1.76.2/desktop/src-tauri/permissions/autogenerated/reapply_window_chrome.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-reapply-window-chrome"
+description = "Enables the reapply_window_chrome command without any pre-configured scope."
+commands.allow = ["reapply_window_chrome"]
+
+[[permission]]
+identifier = "deny-reapply-window-chrome"
+description = "Denies the reapply_window_chrome command without any pre-configured scope."
+commands.deny = ["reapply_window_chrome"]

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/src/main.rs

@@ -19,6 +19,7 @@ use tauri::{
     WindowEvent, Wry,
 };
 use tauri_plugin_dialog::DialogExt;
+use tauri_plugin_log::{Target, TargetKind};
 
 #[cfg(test)]
 use std::collections::HashMap as StdHashMap;
@@ -129,6 +130,7 @@ const MENU_ZOOM_OUT: &str = "zoom_out";
 const MENU_ZOOM_RESET: &str = "zoom_reset";
 const MENU_CHECK_UPDATES: &str = "check_updates";
 const MENU_OPEN_CONFIG_DIR: &str = "open_config_dir";
+const MENU_REVEAL_DESKTOP_LOG: &str = "reveal_desktop_log";
 const MENU_REVEAL_BACKEND_LOG: &str = "reveal_backend_log";
 const MENU_QUIT: &str = "quit";
 
@@ -175,6 +177,29 @@ fn configure_window_chrome(
     }
 }
 
+/// Re-assert the macOS overlay title-bar chrome on `window`.
+///
+/// New windows occasionally lose their traffic-light vertical centring after
+/// the webview triggers an AppKit relayout (e.g. navigating into
+/// cockpit/coding mode). Re-applying ``TitleBarStyle::Overlay`` toggles the
+/// window style mask (tao `set_style_mask_sync`), which forces AppKit to
+/// recompute the standard window buttons and marks the content view for
+/// redraw. tao's `draw_rect` then re-runs its stored `inset_traffic_lights`,
+/// restoring the configured 12/22 pt position. No-op off macOS.
+#[tauri::command]
+fn reapply_window_chrome(window: tauri::WebviewWindow) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    {
+        use tauri::TitleBarStyle;
+        window
+            .set_title_bar_style(TitleBarStyle::Overlay)
+            .map_err(|e| format!("{e:#}"))?;
+    }
+    #[cfg(not(target_os = "macos"))]
+    let _ = window;
+    Ok(())
+}
+
 #[derive(Clone, Serialize)]
 struct BackendReady {
     port: u16,
@@ -372,6 +397,13 @@ async fn backend_logs_path(state: tauri::State<'_, AppState>) -> Result<String,
     }
 }
 
+#[tauri::command]
+fn desktop_logs_path(app: AppHandle) -> Result<String, String> {
+    desktop_log_path(&app)
+        .map(|p| p.to_string_lossy().into_owned())
+        .map_err(|e| format!("desktop log path unavailable: {e}"))
+}
+
 #[tauri::command]
 async fn app_backend_status(
     app: AppHandle,
@@ -677,6 +709,21 @@ fn open_config_dir(app: &AppHandle) {
     }
 }
 
+fn desktop_log_path(app: &AppHandle) -> Result<PathBuf> {
+    Ok(app.path().app_log_dir()?.join("desktop.log"))
+}
+
+fn reveal_desktop_log(app: &AppHandle) {
+    match desktop_log_path(app) {
+        Ok(path) => {
+            if let Err(e) = app.opener().reveal_item_in_dir(&path) {
+                log::warn!("failed to reveal desktop log {}: {e}", path.display());
+            }
+        }
+        Err(e) => log::warn!("desktop log path unavailable: {e:#}"),
+    }
+}
+
 fn reveal_backend_log(app: &AppHandle) {
     let state: tauri::State<'_, AppState> = app.state();
     let sidecar = state.sidecar.clone();
@@ -889,6 +936,7 @@ fn handle_desktop_menu(app: &AppHandle, id: &str) {
         MENU_ZOOM_RESET => set_zoom(app, ZOOM_DEFAULT),
         MENU_CHECK_UPDATES => request_update_check(app),
         MENU_OPEN_CONFIG_DIR => open_config_dir(app),
+        MENU_REVEAL_DESKTOP_LOG => reveal_desktop_log(app),
         MENU_REVEAL_BACKEND_LOG => reveal_backend_log(app),
         MENU_QUIT => quit_app(app),
         _ => {}
@@ -972,11 +1020,13 @@ async fn updater_release_notes(version: String) -> Result<ReleaseNotesResponse,
 }
 
 async fn run_update_check(app: AppHandle, silent: bool) -> Result<UpdateStatus, String> {
+    log::info!("updater check started silent={silent}");
     let updater = app
         .updater()
         .map_err(|e| format!("Updater unavailable: {e}"))?;
     match updater.check().await {
         Ok(Some(update)) => {
+            log::info!("updater check found version={}", update.version);
             let state: tauri::State<'_, AppState> = app.state();
             let cached = state.update_state.lock().await.clone();
             let status = if cached
@@ -1007,6 +1057,7 @@ async fn run_update_check(app: AppHandle, silent: bool) -> Result<UpdateStatus,
             Ok(status)
         }
         Ok(None) => {
+            log::info!("updater check found no update silent={silent}");
             let status = UpdateStatus {
                 status: "up_to_date".into(),
                 version: None,
@@ -1025,11 +1076,15 @@ async fn run_update_check(app: AppHandle, silent: bool) -> Result<UpdateStatus,
             }
             Ok(status)
         }
-        Err(e) => Err(format!("Couldn't check for updates: {e}")),
+        Err(e) => {
+            log::warn!("updater check failed: {e}");
+            Err(format!("Couldn't check for updates: {e}"))
+        }
     }
 }
 
 async fn run_update_download(app: AppHandle) -> Result<UpdateStatus, String> {
+    log::info!("updater download started");
     let updater = app
         .updater()
         .map_err(|e| format!("Updater unavailable: {e}"))?;
@@ -1041,6 +1096,7 @@ async fn run_update_download(app: AppHandle) -> Result<UpdateStatus, String> {
 
     update_tray_status(&app, "Status: Downloading update…");
     let version = update.version.clone();
+    log::info!("updater download available version={version}");
     let mut downloaded: u64 = 0;
     let app_for_progress = app.clone();
     let bytes = update
@@ -1076,6 +1132,7 @@ async fn run_update_download(app: AppHandle) -> Result<UpdateStatus, String> {
     let path =
         cached_update_path(&app, &update.version).map_err(|e| format!("Cache update: {e}"))?;
     std::fs::write(&path, bytes).map_err(|e| format!("Write cached update: {e}"))?;
+    log::info!("updater download cached version={} path={}", update.version, path.display());
     let state: tauri::State<'_, AppState> = app.state();
     *state.update_state.lock().await = Some(CachedUpdateState {
         version: update.version.clone(),
@@ -1096,6 +1153,7 @@ async fn run_update_download(app: AppHandle) -> Result<UpdateStatus, String> {
 }
 
 async fn run_update_install(app: AppHandle) -> Result<(), String> {
+    log::info!("updater install started");
     let state: tauri::State<'_, AppState> = app.state();
     let cached_guard = state.update_state.lock().await;
     let cached = cached_guard.clone();
@@ -1124,6 +1182,11 @@ async fn run_update_install(app: AppHandle) -> Result<(), String> {
     // SAFETY: validate_install_preconditions returned Ok, so `cached` is Some
     // and `cached.bytes_path.is_file()`.
     let cached = cached.expect("cached is Some after validate_install_preconditions");
+    log::info!(
+        "updater install preconditions ok version={} path={}",
+        cached.version,
+        cached.bytes_path.display()
+    );
 
     let bytes =
         std::fs::read(&cached.bytes_path).map_err(|e| format!("Read cached update: {e}"))?;
@@ -1141,50 +1204,31 @@ async fn run_update_install(app: AppHandle) -> Result<(), String> {
     shutdown_sidecar_now(&app).await;
 
     update_tray_status(&app, "Status: Installing update…");
+    log::info!("updater install applying version={}", update.version);
     update.install(bytes).map_err(|e| {
         update_tray_status(&app, "Status: Running");
         format!("Failed to install update: {e}")
     })?;
 
-    // Relaunch. Platform behaviour differs and getting this wrong is exactly
-    // why the app previously installed the update but never came back up:
-    //
-    //   • macOS: `install()` extracts the new `.app` over the running bundle
-    //     and spawns a *detached* helper that re-launches it. Calling
-    //     `app.restart()` here re-execs the OLD executable path while that
-    //     bundle is mid-swap — the exec target is momentarily invalid, the
-    //     spawn fails silently, and the process just exits. The correct move
-    //     is to exit cleanly and let the updater helper bring the new bundle
-    //     back up. (Docs: "restarting immediately after install is not
-    //     required.")
-    //
-    //   • Windows: the NSIS/MSI installer already terminates the app itself,
-    //     so reaching a manual restart is unusual; `restart()` is still the
-    //     supported call when we get here.
-    //
-    //   • Linux (AppImage): the binary is replaced in place, so `restart()`
-    //     re-execs the new image correctly.
+    // Relaunch. Tauri's updater installs the new bundle but does not reliably
+    // bring the app back on macOS/Linux unless the host process explicitly
+    // relaunches. Call `restart()` on the main thread so Tauri can run its
+    // cleanup immediately before re-execing the updated app; calling it from
+    // this worker task requests an event-loop exit and can hang behind window
+    // close guards during the update flow.
     update_tray_status(&app, "Status: Restarting…");
-    #[cfg(target_os = "macos")]
-    {
-        // Give the detached relaunch helper a beat to register before we tear
-        // the process down, then exit so it can bring the new bundle up.
-        // `cleanup_before_exit()` + `process::exit()` MUST run on the main
-        // thread — calling them from this worker task can crash on macOS
-        // (tauri-apps/tauri#12534) — so hop onto the run loop.
-        tokio::time::sleep(Duration::from_millis(300)).await;
-        let handle = app.clone();
-        let _ = app.run_on_main_thread(move || {
-            handle.cleanup_before_exit();
-            std::process::exit(0);
-        });
-        // The line above never returns once the closure runs; this keeps the
-        // function type-correct on the off chance the dispatch is dropped.
-        return Ok(());
-    }
-    #[cfg(not(target_os = "macos"))]
-    {
-        app.restart();
+    log::info!("updater install complete; dispatching app restart");
+    let handle = app.clone();
+    let _ = app.run_on_main_thread(move || {
+        log::info!("updater restart executing on main thread");
+        handle.restart();
+    });
+
+    // `restart()` never returns once the closure runs. Keep the command pending
+    // so the frontend remains on the installing/restarting state if dispatch is
+    // delayed, instead of resolving successfully without a relaunch.
+    loop {
+        tokio::time::sleep(Duration::from_secs(60)).await;
     }
 }
 
@@ -1344,6 +1388,13 @@ fn install_desktop_menus(app: &tauri::App) -> Result<()> {
         true,
         None::<&str>,
     )?;
+    let app_reveal_desktop_log = MenuItem::with_id(
+        app,
+        MENU_REVEAL_DESKTOP_LOG,
+        "View Desktop Log",
+        true,
+        None::<&str>,
+    )?;
     let app_reveal_backend_log = MenuItem::with_id(
         app,
         MENU_REVEAL_BACKEND_LOG,
@@ -1428,6 +1479,7 @@ fn install_desktop_menus(app: &tauri::App) -> Result<()> {
         .item(&app_telemetry)
         .separator()
         .item(&app_open_config_dir)
+        .item(&app_reveal_desktop_log)
         .item(&app_reveal_backend_log)
         .separator()
         .item(&app_quit)
@@ -1499,6 +1551,13 @@ fn install_desktop_menus(app: &tauri::App) -> Result<()> {
         true,
         None::<&str>,
     )?;
+    let tray_reveal_desktop_log = MenuItem::with_id(
+        app,
+        MENU_REVEAL_DESKTOP_LOG,
+        "View Desktop Log",
+        true,
+        None::<&str>,
+    )?;
     let tray_reveal_backend_log = MenuItem::with_id(
         app,
         MENU_REVEAL_BACKEND_LOG,
@@ -1522,6 +1581,7 @@ fn install_desktop_menus(app: &tauri::App) -> Result<()> {
             &PredefinedMenuItem::separator(app)?,
             &tray_settings,
             &tray_open_config_dir,
+            &tray_reveal_desktop_log,
             &tray_reveal_backend_log,
             &tray_reload,
             &PredefinedMenuItem::separator(app)?,
@@ -2093,6 +2153,12 @@ fn main() {
 
     let log_plugin = tauri_plugin_log::Builder::new()
         .level(log::LevelFilter::Info)
+        .targets([
+            Target::new(TargetKind::Stdout),
+            Target::new(TargetKind::LogDir {
+                file_name: Some("desktop".into()),
+            }),
+        ])
         .build();
 
     tauri::Builder::default()
@@ -2116,6 +2182,7 @@ fn main() {
             save_workspace_file,
             backend_health,
             backend_logs_path,
+            desktop_logs_path,
             app_backend_status,
             app_remove_backend_server,
             app_save_backend_server,
@@ -2123,6 +2190,7 @@ fn main() {
             app_use_bundled_backend,
             app_stop_bundled_backend,
             app_new_window,
+            reapply_window_chrome,
             set_tray_session,
             updater_check,
             updater_download,
@@ -2131,6 +2199,16 @@ fn main() {
         ])
         .setup(|app| {
             install_desktop_menus(app)?;
+            match desktop_log_path(app.handle()) {
+                Ok(path) => log::info!("desktop log path={}", path.display()),
+                Err(e) => log::warn!("desktop log path unavailable: {e:#}"),
+            }
+            log::info!(
+                "desktop app starting version={} pid={} target_os={}",
+                env!("CARGO_PKG_VERSION"),
+                std::process::id(),
+                std::env::consts::OS
+            );
             let handle = app.handle().clone();
             tauri::async_runtime::spawn(async move {
                 let updater_handle = handle.clone();

{openagentd-1.76.0 → openagentd-1.76.2}/desktop/src-tauri/tauri.conf.json

@@ -2,7 +2,7 @@
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "OpenAgentd",
   "mainBinaryName": "OpenAgentd",
-  "version": "1.76.0",
+  "version": "1.76.2",
   "identifier": "com.openagentd.desktop",
   "build": {
     "devUrl": "http://localhost:5173",

{openagentd-1.76.0 → openagentd-1.76.2}/documents/docs/features.md

@@ -16,7 +16,7 @@ exists. When you ship something new, **add it here first** — slides, README,
 > double-clickable app that runs a team of AI agents on your machine, with a
 > real UI to watch every step. Open source (Apache 2.0). 15 providers. Your keys.
 
-**Latest release:** v1.76.0 · June 27, 2026 · [release notes](https://github.com/lthoangg/openagentd/releases/tag/v1.76.0)
+**Latest release:** v1.76.2 · June 27, 2026 · [release notes](https://github.com/lthoangg/openagentd/releases/tag/v1.76.2)
 
 ---
 
@@ -243,7 +243,8 @@ Coding mode (`/coding`) opens a local project folder and runs a workspace-aware
 team against it. Deeper doc: [`web/coding-sessions.md`](./web/coding-sessions.md).
 
 - **Open any local project folder** `[since v1.0]` — server-local paths only.
-  Coding mode shows file tree + live git diff (including untracked files) in
+  Coding mode shows file tree + live git diff (staged, unstaged, and untracked
+  files) in
   the side drawer. Desktop uses the native folder picker only for the bundled
   sidecar or loopback backends; LAN/external backends use the web folder browser
   so the selected path exists on the backend host.

{openagentd-1.76.0 → openagentd-1.76.2}/documents/docs/web/mobile.md

@@ -72,6 +72,7 @@ Right-side workspace explorer for `/coding` mode.
 - `CommandPalette` is never rendered on mobile (`!isMobile && showPalette`).
 - User and queued-message bubbles can use the full chat width on mobile; `md:` and wider viewports keep the narrower desktop caps.
 - Long single-agent transcripts render the newest 80 turns first and expose **Show earlier messages** to reveal older turns in chunks, reducing initial mobile layout cost.
+- The **Tasks** header button toggles the todos overlay (tap again to close). All header overlays (todos, files, capabilities, scheduler, palette) are mutually exclusive on both mobile and desktop via `closeOtherMobileOverlays`; sidebar/actions/coding-panel guards remain mobile-only.
 
 ### FloatingInputBar (`FloatingInputBar.tsx`) / InputBar (`InputBar.tsx`)
 - Mobile: static docked `<div>` at the bottom with `border-t`, `backdrop-blur`, `.pb-safe`. No drag, no localStorage position.

openagentd-1.76.2/documents/docs/web/performance.md

@@ -0,0 +1,73 @@
+---
+title: Frontend Performance
+description: Render optimization patterns used across the web UI — memo, useMemo, useCallback.
+status: stable
+updated: 2026-06-13
+---
+
+# Frontend performance
+
+Patterns applied across the component tree to prevent unnecessary re-renders,
+especially during high-frequency SSE streaming.
+
+---
+
+## Patterns in use
+
+### `memo` on list-item and block components
+
+Components that appear in loops and receive stable props are wrapped with
+`React.memo` so a parent re-render (e.g. a new streaming delta) doesn't
+re-render every sibling:
+
+| Component | Why |
+|---|---|
+| `BlockRenderer` (AgentView, AgentPane) | Re-renders only when its own block content changes, not on every SSE tick |
+| `UserBubble` (AgentPane) | Stable between stream updates |
+| `SessionRow` (Sidebar) | Stable when session list is unchanged |
+| `FileRow` (WorkspaceFilesPanel) | Stable when file selection changes elsewhere |
+| `HighlightedCode` (CodingFileViewerPanel) | Syntax highlighting only re-runs when the line string changes, not on selection state |
+
+### `useMemo` on derived arrays
+
+| Location | Value memoized |
+|---|---|
+| `Sidebar` | `normalSessions` (flatMap over pages), `dateGroups` (groupByDate result) |
+| `TodosPopover` | `sortedTodos` ([...todos].sort) |
+| `CodingFileViewerPanel / TextPreview` | `lines` (content.split('\n')) |
+
+### `useCallback` on stable handlers
+
+| Location | Handler |
+|---|---|
+| `AssistantTurnFooter` | `handleCopy` — deps: `[textContent]` |
+| `AgentPane / UserBubble` | `handleCopy` — deps: `[content]` |
+| `Sidebar` | `handleDelete`, `handleEdit` — deps: `[]` (only call setters) |
+
+### Stable Zustand selectors
+
+Inline selector lambdas `(s) => s.someFn` create a new function reference
+every render, which can cause spurious re-subscriptions. For selectors that
+return store *functions* (already stable), a module-level constant is used:
+
+```ts
+// ToastStack.tsx
+const dismissSelector = (s: ReturnType<typeof useToastStore.getState>) => s.dismiss
+```
+
+---
+
+## Rules of Hooks note
+
+Hooks must not appear after early returns. In `TextPreview` the `useMemo`
+for `lines` is declared **before** the `deleted` / `tooLarge` / `loading`
+early returns — even though `content` may be `null` at that point — using a
+`?? []` fallback to keep the call unconditional.
+
+---
+
+## Tests
+
+`web/src/__tests__/components/performance.memo.test.tsx` — behavioral
+coverage for the memoized sort order in `TodosPopover`, copy-button stability
+in `AssistantTurnFooter`, and progress-bar accuracy.