feat: add claw mode prompt, workspace persona system, and agent memory

Author: wsp1911

src/apps/desktop/src/api/app_state.rs

@@ -2,7 +2,7 @@
 
 use bitfun_core::agentic::{agents, tools};
 use bitfun_core::infrastructure::ai::{AIClient, AIClientFactory};
-use bitfun_core::miniapp::{initialize_global_miniapp_manager, MiniAppManager, JsWorkerPool};
+use bitfun_core::miniapp::{initialize_global_miniapp_manager, JsWorkerPool, MiniAppManager};
 use bitfun_core::service::{ai_rules, config, filesystem, mcp, workspace};
 use bitfun_core::util::errors::*;
 

src/apps/desktop/src/api/commands.rs

@@ -299,20 +299,15 @@ pub async fn test_ai_config_connection(
     request: TestAIConfigConnectionRequest,
 ) -> Result<bitfun_core::util::types::ConnectionTestResult, String> {
     let model_name = request.config.name.clone();
-    let supports_image_input = request
-        .config
-        .capabilities
-        .iter()
-        .any(|cap| {
-            matches!(
-                cap,
-                bitfun_core::service::config::types::ModelCapability::ImageUnderstanding
-            )
-        })
-        || matches!(
-            request.config.category,
-            bitfun_core::service::config::types::ModelCategory::Multimodal
-        );
+    let supports_image_input = request.config.capabilities.iter().any(|cap| {
+        matches!(
+            cap,
+            bitfun_core::service::config::types::ModelCapability::ImageUnderstanding
+        )
+    }) || matches!(
+        request.config.category,
+        bitfun_core::service::config::types::ModelCategory::Multimodal
+    );
 
     let ai_config = match request.config.try_into() {
         Ok(config) => config,
@@ -363,9 +358,7 @@ pub async fn test_ai_config_connection(
                         let merged = bitfun_core::util::types::ConnectionTestResult {
                             success: true,
                             response_time_ms,
-                            model_response: image_result
-                                .model_response
-                                .or(result.model_response),
+                            model_response: image_result.model_response.or(result.model_response),
                             error_details: None,
                         };
                         info!(

src/crates/core/src/agentic/agents/prompt_builder/prompt_builder.rs

@@ -8,16 +8,20 @@ use crate::service::project_context::ProjectContextService;
 use crate::util::errors::{BitFunError, BitFunResult};
 use log::{debug, warn};
 use std::path::Path;
+use tokio::fs;
 
 /// Placeholder constants
+const PLACEHOLDER_PERSONA: &str = "{PERSONA}";
 const PLACEHOLDER_ENV_INFO: &str = "{ENV_INFO}";
 const PLACEHOLDER_PROJECT_LAYOUT: &str = "{PROJECT_LAYOUT}";
 // PROJECT_CONTEXT_FILES needs configuration parsing
 // const PLACEHOLDER_PROJECT_CONTEXT_FILES: &str = "{PROJECT_CONTEXT_FILES}";
 const PLACEHOLDER_RULES: &str = "{RULES}";
 const PLACEHOLDER_MEMORIES: &str = "{MEMORIES}";
 const PLACEHOLDER_LANGUAGE_PREFERENCE: &str = "{LANGUAGE_PREFERENCE}";
+const PLACEHOLDER_AGENT_MEMORY: &str = "{AGENT_MEMORY}";
 const PLACEHOLDER_VISUAL_MODE: &str = "{VISUAL_MODE}";
+const PERSONA_FILE_NAMES: [&str; 4] = ["BOOTSTRAP.md", "SOUL.md", "USER.md", "IDENTITY.MD"];
 
 pub struct PromptBuilder {
     pub workspace_path: String,
@@ -99,6 +103,65 @@ These files are maintained by the user and should NOT be modified unless explici
         }
     }
 
+    /// Get workspace persona files from the workspace root.
+    pub async fn get_persona(&self) -> Option<String> {
+        let workspace = Path::new(&self.workspace_path);
+        let mut documents = Vec::new();
+
+        for file_name in PERSONA_FILE_NAMES {
+            let file_path = workspace.join(file_name);
+            if !file_path.exists() {
+                continue;
+            }
+
+            match fs::read_to_string(&file_path).await {
+                Ok(content) => documents.push((file_name, content)),
+                Err(e) => {
+                    warn!(
+                        "Failed to read persona file: path={} error={}",
+                        file_path.display(),
+                        e
+                    );
+                }
+            }
+        }
+
+        if documents.is_empty() {
+            return None;
+        }
+
+        let mut prompt = String::from("<persona>\n");
+        for (file_name, content) in documents {
+            prompt.push_str(&format!(
+                "<persona_file name=\"{}\" description=\"{}\">\n{}\n</persona_file>\n",
+                file_name,
+                Self::persona_file_description(file_name),
+                content
+            ));
+        }
+        prompt.push_str("</persona>");
+
+        Some(format!(
+            r#"# Persona
+
+The following files are located in the workspace root directory.
+
+{}
+"#,
+            prompt
+        ))
+    }
+
+    fn persona_file_description(file_name: &str) -> &'static str {
+        match file_name {
+            "BOOTSTRAP.md" => "Bootstrap guidance and initialization instructions",
+            "SOUL.md" => "Core persona, values, and behavioral style",
+            "USER.md" => "User profile, preferences, and collaboration expectations",
+            "IDENTITY.MD" => "Workspace identity, role definition, and self-description",
+            _ => "Workspace persona file",
+        }
+    }
+
     /// Load AI memories from disk and format as prompt
     pub async fn load_ai_memories(&self) -> Option<String> {
         let path_manager = match try_get_path_manager_arc() {
@@ -127,6 +190,42 @@ These files are maintained by the user and should NOT be modified unless explici
         }
     }
 
+    /// Build the agent memory section: instructions + auto-loaded memory index
+    ///
+    /// Replaces `<workspace>` with the real workspace path and `{YYYY-MM-DD}` with today's date.
+    /// Appends the contents of `memory.md` (up to 200 lines) when present.
+    pub async fn build_agent_memory(&self) -> String {
+        let memory_dir = format!("{}/.bitfun/memory", self.workspace_path);
+        let today = chrono::Local::now().format("%Y-%m-%d").to_string();
+
+        let mut section = format!(
+            r#"# Memory
+
+The following memories are persisted to disk under `{memory_dir}/`.
+
+- **Index**: `memory.md` is auto-loaded (up to 200 lines) and serves as the memory index. Keep it concise — link to topic files rather than inlining details.
+- **Daily journal**: Write or append to `{today}.md` for important user requests, decisions, constraints, and outcomes. Skip greetings, small talk, and trivial Q&A.
+- **Topic files**: Organize long-lived knowledge as `<topic>.md` (e.g., `debugging.md`, `architecture.md`, `preferences.md`).
+- **Write**: Use Edit/Write tools to create or update memory files.
+- **Read**: Use Grep/Read tools to search and retrieve memories.
+"#
+        );
+
+        let index_path = format!("{}/memory.md", memory_dir);
+        match fs::read_to_string(&index_path).await {
+            Ok(content) if !content.trim().is_empty() => {
+                let truncated: String = content.lines().take(200).collect::<Vec<_>>().join("\n");
+                section.push_str(&format!(
+                    "\n<memory_index>\n{}\n</memory_index>\n",
+                    truncated
+                ));
+            }
+            _ => {}
+        }
+
+        section
+    }
+
     /// Load AI rules from disk and format as prompt
     pub async fn load_ai_rules(&self) -> Option<String> {
         let rules_service = match get_global_ai_rules_service().await {
@@ -215,10 +314,12 @@ Prefer MermaidInteractive tool when available, otherwise output Mermaid code blo
     /// Build prompt from template, automatically fill content based on placeholders
     ///
     /// Supported placeholders:
+    /// - `{PERSONA}` - Workspace persona files (BOOTSTRAP.md, SOUL.md, USER.md, IDENTITY.MD)
     /// - `{LANGUAGE_PREFERENCE}` - User language preference (read from global config)
     /// - `{ENV_INFO}` - Environment information
     /// - `{PROJECT_LAYOUT}` - Project file layout
     /// - `{PROJECT_CONTEXT_FILES}` - Project context files (AGENTS.md, CLAUDE.md, etc.)
+    /// - `{AGENT_MEMORY}` - Agent memory instructions + auto-loaded memory index
     /// - `{RULES}` - AI rules
     /// - `{MEMORIES}` - AI memories
     /// - `{VISUAL_MODE}` - Visual mode instruction (Mermaid diagrams, read from global config)
@@ -227,6 +328,12 @@ Prefer MermaidInteractive tool when available, otherwise output Mermaid code blo
     pub async fn build_prompt_from_template(&self, template: &str) -> BitFunResult<String> {
         let mut result = template.to_string();
 
+        // Replace {PERSONA}
+        if result.contains(PLACEHOLDER_PERSONA) {
+            let persona = self.get_persona().await.unwrap_or_default();
+            result = result.replace(PLACEHOLDER_PERSONA, &persona);
+        }
+
         // Replace {LANGUAGE_PREFERENCE}
         if result.contains(PLACEHOLDER_LANGUAGE_PREFERENCE) {
             let language_preference = self.get_language_preference().await?;
@@ -280,6 +387,12 @@ Prefer MermaidInteractive tool when available, otherwise output Mermaid code blo
             result = result.replace(placeholder, &project_context);
         }
 
+        // Replace {AGENT_MEMORY}
+        if result.contains(PLACEHOLDER_AGENT_MEMORY) {
+            let agent_memory = self.build_agent_memory().await;
+            result = result.replace(PLACEHOLDER_AGENT_MEMORY, &agent_memory);
+        }
+
         // Replace {RULES}
         if result.contains(PLACEHOLDER_RULES) {
             let rules = self.load_ai_rules().await.unwrap_or_default();

src/crates/core/src/agentic/agents/prompts/claw_mode.md

@@ -0,0 +1,18 @@
+You are a personal assistant running inside BitFun.
+
+## Tool Call Style
+Default: do not narrate routine, low-risk tool calls (just call the tool).
+Narrate only when it helps: multi-step work, complex/challenging problems, sensitive actions (e.g., deletions), or when the user explicitly asks.
+Keep narration brief and value-dense; avoid repeating obvious steps.
+Use plain human language for narration unless in a technical context.
+When a first-class tool exists for an action, use the tool directly instead of asking the user to run equivalent CLI commands.
+
+## Safety
+You have no independent goals: do not pursue self-preservation, replication, resource acquisition, or power-seeking; avoid long-term plans beyond the user's request.
+Prioritize safety and human oversight over completion; if instructions conflict, pause and ask; comply with stop/pause/audit requests and never bypass safeguards. 
+Do not manipulate or persuade anyone to expand access or disable safeguards. Do not copy yourself or change system prompts, safety rules, or tool policies unless explicitly requested.
+
+{AGENT_MEMORY}
+{PERSONA}
+{ENV_INFO}
+{PROJECT_CONTEXT_FILES:exclude=review}

src/crates/core/src/service/workspace/bootstrap.rs

@@ -0,0 +1,110 @@
+use crate::infrastructure::storage::{PersistenceService, StorageOptions};
+use crate::infrastructure::try_get_path_manager_arc;
+use crate::util::errors::*;
+use log::debug;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use tokio::fs;
+
+const BOOTSTRAP_STATE_KEY: &str = "local/bootstrap_state";
+const BOOTSTRAP_FILE_NAME: &str = "BOOTSTRAP.md";
+const SOUL_FILE_NAME: &str = "SOUL.md";
+const USER_FILE_NAME: &str = "USER.md";
+const IDENTITY_FILE_NAME: &str = "IDENTITY.MD";
+const MEMORY_DIR: &str = ".bitfun/memory";
+const MEMORY_INDEX_FILE: &str = "memory.md";
+const BOOTSTRAP_TEMPLATE: &str = include_str!("templates/BOOTSTRAP.md");
+const SOUL_TEMPLATE: &str = include_str!("templates/SOUL.md");
+const USER_TEMPLATE: &str = include_str!("templates/USER.md");
+const IDENTITY_TEMPLATE: &str = include_str!("templates/IDENTITY.MD");
+const MEMORY_INDEX_TEMPLATE: &str = "# Memory Index\n";
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+struct WorkspaceBootstrapState {
+    bootstrap_completed: bool,
+}
+
+async fn ensure_markdown_placeholder(path: &Path, content: &str) -> BitFunResult<bool> {
+    if path.exists() {
+        return Ok(false);
+    }
+
+    fs::write(path, content)
+        .await
+        .map_err(|e| BitFunError::service(format!("Failed to create {}: {}", path.display(), e)))?;
+
+    Ok(true)
+}
+
+pub(crate) async fn ensure_workspace_bootstrap_files(workspace_root: &Path) -> BitFunResult<()> {
+    let path_manager = try_get_path_manager_arc()?;
+    let persistence =
+        PersistenceService::new_project_level(path_manager, workspace_root.to_path_buf())
+            .await
+            .map_err(|e| {
+                BitFunError::service(format!("Failed to prepare project storage: {}", e))
+            })?;
+
+    let loaded_state = persistence
+        .load_json::<WorkspaceBootstrapState>(BOOTSTRAP_STATE_KEY)
+        .await
+        .map_err(|e| BitFunError::service(format!("Failed to load bootstrap state: {}", e)))?;
+    let bootstrap_state = loaded_state.clone().unwrap_or_default();
+
+    if loaded_state.is_none() {
+        persistence
+            .save_json(
+                BOOTSTRAP_STATE_KEY,
+                &bootstrap_state,
+                StorageOptions::default(),
+            )
+            .await
+            .map_err(|e| BitFunError::service(format!("Failed to save bootstrap state: {}", e)))?;
+    }
+
+    let created_soul =
+        ensure_markdown_placeholder(&workspace_root.join(SOUL_FILE_NAME), SOUL_TEMPLATE).await?;
+    let created_user =
+        ensure_markdown_placeholder(&workspace_root.join(USER_FILE_NAME), USER_TEMPLATE).await?;
+    let created_identity =
+        ensure_markdown_placeholder(&workspace_root.join(IDENTITY_FILE_NAME), IDENTITY_TEMPLATE)
+            .await?;
+
+    let created_bootstrap = if bootstrap_state.bootstrap_completed {
+        false
+    } else {
+        ensure_markdown_placeholder(
+            &workspace_root.join(BOOTSTRAP_FILE_NAME),
+            BOOTSTRAP_TEMPLATE,
+        )
+        .await?
+    };
+
+    let memory_dir = workspace_root.join(MEMORY_DIR);
+    if !memory_dir.exists() {
+        fs::create_dir_all(&memory_dir).await.map_err(|e| {
+            BitFunError::service(format!(
+                "Failed to create memory directory {}: {}",
+                memory_dir.display(),
+                e
+            ))
+        })?;
+    }
+    let created_memory_index =
+        ensure_markdown_placeholder(&memory_dir.join(MEMORY_INDEX_FILE), MEMORY_INDEX_TEMPLATE)
+            .await?;
+
+    debug!(
+        "Ensured workspace bootstrap files: path={}, bootstrap_completed={}, created_bootstrap={}, created_soul={}, created_user={}, created_identity={}, created_memory_index={}",
+        workspace_root.display(),
+        bootstrap_state.bootstrap_completed,
+        created_bootstrap,
+        created_soul,
+        created_user,
+        created_identity,
+        created_memory_index
+    );
+
+    Ok(())
+}

src/crates/core/src/service/workspace/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! Full workspace management system: open, manage, scan, statistics, etc.
 
+pub(crate) mod bootstrap;
 pub mod context_generator;
 pub mod factory;
 pub mod manager;

src/crates/core/src/service/workspace/service.rs

@@ -2,6 +2,7 @@
 //!
 //! Provides comprehensive workspace management functionality.
 
+use super::bootstrap::ensure_workspace_bootstrap_files;
 use super::manager::{
     ScanOptions, WorkspaceInfo, WorkspaceManager, WorkspaceManagerConfig,
     WorkspaceManagerStatistics, WorkspaceStatus, WorkspaceSummary, WorkspaceType,
@@ -633,6 +634,17 @@ impl WorkspaceService {
             .get_current_workspace()
             .await
             .map(|workspace| workspace.root_path);
+
+        if let Some(workspace_path) = path.as_ref() {
+            if let Err(e) = ensure_workspace_bootstrap_files(workspace_path).await {
+                warn!(
+                    "Failed to ensure workspace bootstrap files: path={}, error={}",
+                    workspace_path.display(),
+                    e
+                );
+            }
+        }
+
         set_workspace_path(path);
     }
 
@@ -703,6 +715,8 @@ impl WorkspaceService {
             }
         }
 
+        self.sync_global_workspace_path().await;
+
         Ok(())
     }