✨ Add progressive diff analysis and custom instructions support

Change git_diff to return summaries by default, with optional file filtering
and full diffs via detail='standard'. This progressive approach helps agents
manage context more efficiently for large changesets.

Add custom instructions parameter to execute_task_with_style, allowing users
to provide additional guidance when generating commits and other artifacts.

Other improvements:
- Make workspace persistent across agent invocations
- Add 2-minute timeout and preserved ordering for parallel_analyze subagents
- Move semantic blame I/O to background task to avoid blocking UI
- Fix string truncation to use char boundaries (Unicode safety)
- Fix status bar overflow on narrow terminals
- Display link URLs in chat markdown rendering
- Return proper error exit code from Studio on errors

Author: hyperb1iss

src/agents/capabilities/commit.toml

@@ -12,22 +12,26 @@ Do not skip this step.
 
 ## Tools Available
 - `project_docs(doc_type="context")` - **CALL FIRST** - Get README + AGENTS.md/CLAUDE.md for project context
-- `git_diff()` - Get staged changes with relevance scores and size guidance
+- `git_diff()` - Get summary of staged changes with relevance scores (default: summary only)
+- `git_diff(detail="standard", files=["path1","path2"])` - Get full diffs for specific files
 - `git_log(count=5)` - Recent commits for style reference
 - `project_metadata()` - Get project language, framework, and dependencies (optional)
 - `parallel_analyze(tasks=[...])` - Spawn subagents for very large changesets (optional)
 
-## Workflow
+## Workflow — Progressive Analysis
 1. **FIRST**: Call `project_docs(doc_type="context")` — understand the project's conventions
-2. Call `git_diff()` to see what changed
-3. Read the **Size** and **Guidance** in the summary header
-4. Follow the guidance for focusing on relevant files
-5. Generate the commit message following any project-specific conventions from step 1
+2. Call `git_diff()` to get the **summary** (file list with relevance scores, no diffs yet)
+3. Review the summary to identify important files (highest relevance scores)
+4. Call `git_diff(detail="standard", files=["important-file1.rs", "important-file2.rs"])` for full diffs of key files
+5. Repeat step 4 for additional files if needed (stay focused on top 5-7 files max)
+6. Generate the commit message based on your progressive analysis
+
+**CRITICAL**: Never request all diffs at once for large changesets. Always start with summary, then selectively drill into important files.
 
 ## Context Strategy by Size
-- **Small** (≤3 files, <100 lines): Consider all changes equally
-- **Medium** (≤10 files, <500 lines): Focus on files with >60% relevance
-- **Large** (>10 files or >500 lines): Focus ONLY on top 5-7 highest-relevance files; summarize the theme of lower-relevance changes
+- **Small** (≤3 files, <100 lines): Can use `git_diff(detail="standard")` to see all diffs
+- **Medium** (≤10 files, <500 lines): Start with summary, then get diffs for >60% relevance files
+- **Large** (>10 files or >500 lines): Summary first, then analyze top 5-7 files individually
 - **Very Large** (>20 files or >1000 lines): Use `parallel_analyze` to distribute analysis:
   - Example: `parallel_analyze({ "tasks": ["Summarize changes in src/api/", "Summarize changes in src/models/", "Summarize infrastructure changes"] })`
   - Each subagent analyzes its scope independently

src/agents/iris.rs

@@ -327,6 +327,8 @@ pub struct IrisAgent {
     config: Option<crate::config::Config>,
     /// Optional sender for content updates (used in Studio chat mode)
     content_update_sender: Option<crate::agents::tools::ContentUpdateSender>,
+    /// Persistent workspace for notes and task tracking (shared across agent invocations)
+    workspace: Workspace,
 }
 
 impl IrisAgent {
@@ -341,6 +343,7 @@ impl IrisAgent {
             preamble: None,
             config: None,
             content_update_sender: None,
+            workspace: Workspace::new(),
         })
     }
 
@@ -433,8 +436,8 @@ Guidelines:
         // Attach core tools (shared with subagents) + GitRepoInfo (main agent only)
         let agent_builder = crate::attach_core_tools!(agent_builder)
             .tool(DebugTool::new(GitRepoInfo))
-            // Workspace for Iris's notes and task management
-            .tool(DebugTool::new(Workspace::new()))
+            // Workspace for Iris's notes and task management (clone to share Arc-backed state)
+            .tool(DebugTool::new(self.workspace.clone()))
             // Parallel analysis for distributing work across multiple subagents
             .tool(DebugTool::new(ParallelAnalyze::new(
                 &self.provider,

src/agents/setup.rs

@@ -244,8 +244,8 @@ impl IrisAgentService {
         // Create the agent
         let mut agent = self.create_agent()?;
 
-        // Build task prompt with context information
-        let task_prompt = Self::build_task_prompt(capability, &context);
+        // Build task prompt with context information (no custom instructions)
+        let task_prompt = Self::build_task_prompt(capability, &context, None);
 
         // Execute the task
         agent.execute_task(capability, &task_prompt).await
@@ -272,12 +272,14 @@ impl IrisAgentService {
     /// * `context` - Structured context describing what to analyze
     /// * `preset` - Optional preset name override (e.g., "conventional", "cosmic")
     /// * `use_gitmoji` - Optional gitmoji setting override
+    /// * `instructions` - Optional custom instructions from the user
     pub async fn execute_task_with_style(
         &self,
         capability: &str,
         context: TaskContext,
         preset: Option<&str>,
         use_gitmoji: Option<bool>,
+        instructions: Option<&str>,
     ) -> Result<StructuredResponse> {
         // Clone config and apply style overrides
         let mut config = self.config.clone();
@@ -296,42 +298,52 @@ impl IrisAgentService {
         agent.set_config(config);
         agent.set_fast_model(self.fast_model.clone());
 
-        // Build task prompt with context information
-        let task_prompt = Self::build_task_prompt(capability, &context);
+        // Build task prompt with context information and optional instructions
+        let task_prompt = Self::build_task_prompt(capability, &context, instructions);
 
         // Execute the task
         agent.execute_task(capability, &task_prompt).await
     }
 
-    /// Build a task prompt incorporating the context information
-    fn build_task_prompt(capability: &str, context: &TaskContext) -> String {
+    /// Build a task prompt incorporating the context information and optional instructions
+    fn build_task_prompt(
+        capability: &str,
+        context: &TaskContext,
+        instructions: Option<&str>,
+    ) -> String {
         let context_json = context.to_prompt_context();
         let diff_hint = context.diff_hint();
 
+        // Build instruction suffix if provided
+        let instruction_suffix = instructions
+            .filter(|i| !i.trim().is_empty())
+            .map(|i| format!("\n\n## Custom Instructions\n{}", i))
+            .unwrap_or_default();
+
         match capability {
             "commit" => format!(
-                "Generate a commit message for the following context:\n{}\n\nUse: {}",
-                context_json, diff_hint
+                "Generate a commit message for the following context:\n{}\n\nUse: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
             "review" => format!(
-                "Review the code changes for the following context:\n{}\n\nUse: {}",
-                context_json, diff_hint
+                "Review the code changes for the following context:\n{}\n\nUse: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
             "pr" => format!(
-                "Generate a pull request description for:\n{}\n\nUse: {}",
-                context_json, diff_hint
+                "Generate a pull request description for:\n{}\n\nUse: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
             "changelog" => format!(
-                "Generate a changelog for:\n{}\n\nUse: {}",
-                context_json, diff_hint
+                "Generate a changelog for:\n{}\n\nUse: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
             "release_notes" => format!(
-                "Generate release notes for:\n{}\n\nUse: {}",
-                context_json, diff_hint
+                "Generate release notes for:\n{}\n\nUse: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
             _ => format!(
-                "Execute task with context:\n{}\n\nHint: {}",
-                context_json, diff_hint
+                "Execute task with context:\n{}\n\nHint: {}{}",
+                context_json, diff_hint, instruction_suffix
             ),
         }
     }
@@ -412,7 +424,7 @@ impl IrisAgentService {
         F: FnMut(&str, &str) + Send,
     {
         let mut agent = self.create_agent()?;
-        let task_prompt = Self::build_task_prompt(capability, &context);
+        let task_prompt = Self::build_task_prompt(capability, &context, None);
         agent
             .execute_task_streaming(capability, &task_prompt, on_chunk)
             .await

src/agents/tools/docs.rs

@@ -140,12 +140,14 @@ impl Tool for ProjectDocs {
 
                         output.push_str(&format!("=== {} ===\n", filename));
 
-                        // Truncate if too long
-                        if content.len() > max_chars {
-                            output.push_str(&content[..max_chars]);
+                        // Truncate if too long (use char boundary-safe truncation)
+                        let char_count = content.chars().count();
+                        if char_count > max_chars {
+                            let truncated: String = content.chars().take(max_chars).collect();
+                            output.push_str(&truncated);
                             output.push_str(&format!(
                                 "\n\n[... truncated, {} more chars ...]\n",
-                                content.len() - max_chars
+                                char_count - max_chars
                             ));
                         } else {
                             output.push_str(&content);