Kanban and session items cleaning

Author: Test User

AGENTS.md

@@ -154,6 +154,7 @@ Acepe uses the Compounding Engineering workflow as its engineering operating sys
 
 - Suggest architecture overhauls when you find recurring smells, leaky provider logic, or brittle abstractions.
 - Do not preserve a bad pattern just because it is widespread. Prefer durable, tested abstractions grounded in real product needs.
+- Do not frame work as a migration, coexistence plan, or cutover strategy. Assume speed-of-light execution: design and plan for the clean replacement architecture directly, with old paths removed rather than accommodated in parallel.
 
 ### Debugging
 
@@ -163,6 +164,7 @@ Acepe uses the Compounding Engineering workflow as its engineering operating sys
 
 - NEVER run `bun dev` — the user manages the dev server.
 - NEVER run `git stash` without explicit user consent.
+- NEVER set `core.bare=true` in this repository's root `.git/config` or otherwise convert this checkout into a bare repository. If bare-style workflows are needed, use a separate bare mirror or linked worktree instead of changing the active checkout.
 
 ## Detailed Guides
 

CLAUDE.md

@@ -181,6 +181,7 @@ The agent panel follows a View–Model–Controller split across packages:
 
 - NEVER run `bun dev` — the user manages the dev server.
 - NEVER run `git stash` without explicit user consent.
+- NEVER set `core.bare=true` in this repository's root `.git/config` or otherwise convert this checkout into a bare repository. If bare-style workflows are needed, use a separate bare mirror or linked worktree instead of changing the active checkout.
 
 ## Detailed Guides
 

packages/desktop/messages/en.json

@@ -611,7 +611,7 @@
 	"tool_notebook_edit_completed": "Edited notebook",
 	"tool_bash_preparing": "Generating command",
 	"tool_bash_running": "Running command",
-	"tool_bash_completed": "Ran command",
+	"tool_bash_completed": "Executed",
 	"tool_kill_shell_running": "Killing shell",
 	"tool_kill_shell_completed": "Killed shell",
 	"tool_task_output_running": "Getting output",
@@ -777,6 +777,7 @@
 	"permission_deny": "Deny",
 	"permission_allow": "Allow",
 	"permission_always_allow": "Always",
+	"permission_autonomous": "Autonomous",
 	"tool_fetch_fetching": "Fetching",
 	"tool_fetch_fetched": "Fetched",
 	"tool_fetch_failed": "Fetch failed",
@@ -871,5 +872,9 @@
 	"voice_error_load_failed": "Failed to load model",
 	"voice_error_transcription_timeout": "Transcription timed out",
 	"voice_model_menu_label": "Voice model",
-	"voice_model_menu_downloading": "Downloading…"
+	"voice_model_menu_downloading": "Downloading…",
+	"error_boundary_panel_failed": "This panel encountered an error.",
+	"error_boundary_sidebar_failed": "Sidebar encountered an error.",
+	"error_boundary_session_item_failed": "Failed to render session.",
+	"error_boundary_retry": "Retry"
 }

packages/desktop/src-tauri/src/acp/parsers/arguments.rs

@@ -45,8 +45,14 @@ pub(crate) fn extract_parser_string_list(
 pub(crate) fn parse_generic_edit_arguments(raw_arguments: &serde_json::Value) -> ToolArguments {
     let file_path = extract_parser_string(raw_arguments, &["file_path", "filePath", "path"]);
     let move_from = extract_parser_string(raw_arguments, &["move_from", "moveFrom"]);
-    let old_string = extract_parser_string(raw_arguments, &["old_string", "oldString", "oldText"]);
-    let new_string = extract_parser_string(raw_arguments, &["new_string", "newString", "newText"]);
+    let old_string = extract_parser_string(
+        raw_arguments,
+        &["old_string", "oldString", "oldText", "old_str"],
+    );
+    let new_string = extract_parser_string(
+        raw_arguments,
+        &["new_string", "newString", "newText", "new_str"],
+    );
     let content = extract_parser_string(raw_arguments, &["content"]);
 
     ToolArguments::Edit {

packages/desktop/src-tauri/src/acp/parsers/shared_chat.rs

@@ -17,9 +17,15 @@ pub(crate) fn infer_tool_kind_from_raw_arguments(
     if object.contains_key("file_path")
         || object.contains_key("filePath")
         || object.contains_key("path")
+        || object.contains_key("query")
+        || object.contains_key("cmd")
         || object.contains_key("command")
         || object.contains_key("pattern")
         || object.contains_key("url")
+        || object.contains_key("from")
+        || object.contains_key("to")
+        || object.contains_key("source")
+        || object.contains_key("destination")
     {
         return None;
     }
@@ -133,6 +139,22 @@ pub(crate) fn detect_update_type(data: &serde_json::Value) -> Result<UpdateType,
     ))
 }
 
+#[cfg(test)]
+mod tests {
+    use super::infer_tool_kind_from_raw_arguments;
+    use crate::acp::session_update::ToolKind;
+
+    #[test]
+    fn description_and_query_do_not_infer_task_kind() {
+        let inferred = infer_tool_kind_from_raw_arguments(&serde_json::json!({
+            "description": "Create planning todos",
+            "query": "INSERT INTO todos VALUES ('todo-1')"
+        }));
+
+        assert_ne!(inferred, Some(ToolKind::Task));
+    }
+}
+
 pub(crate) fn parse_tool_call_update(
     data: &serde_json::Value,
     normalize_tool_kind: fn(&str) -> ToolKind,

packages/desktop/src-tauri/src/acp/providers/copilot.rs

@@ -14,7 +14,7 @@ use sea_orm::DbConn;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::future::Future;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::pin::Pin;
 use tauri::{AppHandle, Manager};
 
@@ -109,32 +109,7 @@ impl AgentProvider for CopilotProvider {
                 return Ok(Vec::new());
             };
 
-            let agents_root = cwd.join(".agents");
-            let skills_root = agents_root.join("skills");
-            let nested_skill_commands =
-                crate::acp::preconnection_slash::load_preconnection_commands_from_root(
-                    &skills_root,
-                )
-                .await?;
-            let nested_agent_commands =
-                crate::acp::preconnection_slash::load_preconnection_commands_from_root(
-                    &agents_root,
-                )
-                .await?;
-            let flat_agent_commands =
-                crate::acp::preconnection_slash::load_preconnection_commands_from_flat_markdown_root(
-                    &agents_root,
-                )
-                .await?;
-
-            Ok(
-                crate::acp::preconnection_slash::dedupe_preconnection_commands(
-                    nested_skill_commands
-                        .into_iter()
-                        .chain(nested_agent_commands)
-                        .chain(flat_agent_commands),
-                ),
-            )
+            load_copilot_preconnection_commands(cwd, dirs::home_dir().as_deref()).await
         })
     }
 
@@ -234,6 +209,51 @@ fn filtered_env() -> HashMap<String, String> {
     crate::shell_env::build_env(crate::shell_env::EnvStrategy::Allowlist(ALLOWED_ENV_KEYS))
 }
 
+async fn load_copilot_preconnection_commands(
+    cwd: &Path,
+    home_dir: Option<&Path>,
+) -> Result<Vec<AvailableCommand>, String> {
+    let agent_roots = copilot_agent_roots(cwd, home_dir);
+    let skill_roots = agent_roots
+        .iter()
+        .map(|root: &PathBuf| root.join("skills"))
+        .collect::<Vec<_>>();
+
+    let nested_skill_commands =
+        crate::acp::preconnection_slash::load_preconnection_commands_from_roots(&skill_roots)
+            .await?;
+    let nested_agent_commands =
+        crate::acp::preconnection_slash::load_preconnection_commands_from_roots(&agent_roots)
+            .await?;
+
+    let mut flat_agent_commands = Vec::new();
+    for root in &agent_roots {
+        let commands =
+            crate::acp::preconnection_slash::load_preconnection_commands_from_flat_markdown_root(
+                root,
+            )
+            .await?;
+        flat_agent_commands.extend(commands);
+    }
+
+    Ok(crate::acp::preconnection_slash::dedupe_preconnection_commands(
+        nested_skill_commands
+            .into_iter()
+            .chain(nested_agent_commands)
+            .chain(flat_agent_commands),
+    ))
+}
+
+fn copilot_agent_roots(cwd: &Path, home_dir: Option<&Path>) -> Vec<PathBuf> {
+    let mut roots = vec![cwd.join(".agents")];
+
+    if let Some(home_dir) = home_dir {
+        roots.push(home_dir.join(".agents"));
+    }
+
+    roots
+}
+
 fn copilot_debug_binary_override() -> Option<String> {
     let override_value = std::env::var(COPILOT_BINARY_OVERRIDE_ENV).ok()?;
     let trimmed = override_value.trim();
@@ -298,6 +318,14 @@ mod tests {
     use crate::acp::client::{AvailableModel, SessionModelState, SessionModes};
     use serde_json::json;
     use std::fs;
+    use tempfile::tempdir;
+
+    fn skill_file_content(name: &str, description: &str) -> String {
+        format!(
+            "---\nname: \"{}\"\ndescription: \"{}\"\n---\n\n# {}\n",
+            name, description, name
+        )
+    }
 
     #[test]
     fn resolve_spawn_configs_prefers_cached_binary_before_debug_override() {
@@ -405,9 +433,64 @@ mod tests {
         assert!(error.to_string().contains("copilot login"));
     }
 
+    #[test]
+    fn copilot_agent_roots_prioritize_project_before_home() {
+        let roots = copilot_agent_roots(Path::new("/repo"), Some(Path::new("/Users/tester")));
+
+        assert_eq!(
+            roots,
+            vec![
+                PathBuf::from("/repo/.agents"),
+                PathBuf::from("/Users/tester/.agents"),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn copilot_preconnection_commands_merge_home_and_project_agents() {
+        let temp = tempdir().expect("temp dir");
+        let project = temp.path().join("project");
+        let home = temp.path().join("home");
+
+        tokio::fs::create_dir_all(project.join(".agents/skills/systematic-debugging"))
+            .await
+            .expect("create project skill dir");
+        tokio::fs::create_dir_all(home.join(".agents/skills/ce-review"))
+            .await
+            .expect("create home skill dir");
+        tokio::fs::write(
+            project.join(".agents/skills/systematic-debugging/SKILL.md"),
+            skill_file_content(
+                "systematic-debugging",
+                "Project-specific systematic debugging flow",
+            ),
+        )
+        .await
+        .expect("write project skill");
+        tokio::fs::write(
+            home.join(".agents/skills/ce-review/SKILL.md"),
+            skill_file_content("ce-review", "Review code changes"),
+        )
+        .await
+        .expect("write home skill");
+
+        let commands = load_copilot_preconnection_commands(&project, Some(&home))
+            .await
+            .expect("load commands");
+
+        assert_eq!(commands.len(), 2);
+        assert_eq!(commands[0].name, "systematic-debugging");
+        assert_eq!(
+            commands[0].description,
+            "Project-specific systematic debugging flow"
+        );
+        assert_eq!(commands[1].name, "ce-review");
+        assert_eq!(commands[1].description, "Review code changes");
+    }
+
     #[test]
     fn configured_copilot_model_prefers_project_config_over_user_config() {
-        let temp = tempfile::tempdir().expect("tempdir");
+        let temp = tempdir().expect("tempdir");
         let home = temp.path().join("home");
         let project = temp.path().join("project");
         fs::create_dir_all(home.join(".copilot")).expect("create user copilot dir");

packages/desktop/src-tauri/src/acp/session_update/tests.rs

@@ -988,6 +988,38 @@ mod parse_tool_call_from_acp {
         }
     }
 
+    #[test]
+    fn copilot_parses_edit_arguments_with_short_snake_case_keys() {
+        let data = json!({
+            "toolCallId": "tool-edit-short-snake",
+            "status": "pending",
+            "_meta": {
+                "claudeCode": {
+                    "toolName": "Edit"
+                }
+            },
+            "rawInput": {
+                "path": "/path/to/file.ts",
+                "old_str": "old content",
+                "new_str": "new content"
+            }
+        });
+
+        let result: Result<ToolCallData, serde_json::Error> = parse_tool_call_from_acp(&data);
+
+        assert!(result.is_ok());
+        let tool_call = result.unwrap();
+        match tool_call.arguments {
+            ToolArguments::Edit { edits } => {
+                let e = edits.first().expect("edit entry");
+                assert_eq!(e.file_path, Some("/path/to/file.ts".to_string()));
+                assert_eq!(e.old_string, Some("old content".to_string()));
+                assert_eq!(e.new_string, Some("new content".to_string()));
+            }
+            _ => panic!("Expected edit tool arguments"),
+        }
+    }
+
     #[test]
     fn parses_normalized_questions_for_ask_user_question_tool() {
         let data = json!({
@@ -2289,6 +2321,37 @@ mod parse_tool_call_update_from_acp {
         });
     }
 
+    #[test]
+    fn copilot_tool_call_update_maps_short_snake_case_edit_arguments() {
+        with_agent(AgentType::Copilot, || {
+            let data = json!({
+                "toolCallId": "tool-copilot-edit-short-snake",
+                "status": "completed",
+                "kind": "edit",
+                "rawInput": {
+                    "path": "/tmp/example.ts",
+                    "old_str": "const value = 1;",
+                    "new_str": "const value = 2;"
+                }
+            });
+
+            let result: Result<ToolCallUpdateData, serde_json::Error> =
+                parse_tool_call_update_from_acp(&data, None);
+
+            assert!(result.is_ok(), "Expected Ok, got {:?}", result);
+            let update = result.unwrap();
+            match update.arguments {
+                Some(ToolArguments::Edit { edits }) => {
+                    let edit = edits.first().expect("edit entry");
+                    assert_eq!(edit.file_path.as_deref(), Some("/tmp/example.ts"));
+                    assert_eq!(edit.old_string.as_deref(), Some("const value = 1;"));
+                    assert_eq!(edit.new_string.as_deref(), Some("const value = 2;"));
+                }
+                other => panic!("Expected edit tool arguments, got {:?}", other),
+            }
+        });
+    }
+
     #[test]
     fn copilot_tool_call_update_infers_task_arguments_without_tool_name() {
         with_agent(AgentType::Copilot, || {