fix(subconscious): remove HEARTBEAT.md task import, use SQLite as sole task source

Tasks are now managed exclusively in SQLite via the Subconscious UI.
HEARTBEAT.md is retained for instructions/context only, not as a task list.
Situation report now reads pending tasks from SQLite instead of HEARTBEAT.md.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sanil-23

src/openhuman/heartbeat/engine.rs

@@ -114,14 +114,12 @@ impl HeartbeatEngine {
     pub async fn ensure_heartbeat_file(workspace_dir: &Path) -> Result<()> {
         let path = workspace_dir.join("HEARTBEAT.md");
         if !path.exists() {
-            let default = "# Periodic Tasks\n\
+            let default = "# Subconscious Instructions\n\
                            #\n\
-                           # The subconscious loop checks these tasks periodically against\n\
+                           # The subconscious loop evaluates pending tasks periodically against\n\
                            # your workspace state (memory, skills, email, etc.)\n\
-                           # Add or remove tasks — one per line starting with `- `\n\n\
-                           - Check for new emails that need attention\n\
-                           - Review upcoming deadlines and calendar events\n\
-                           - Monitor connected skills for errors or disconnections\n";
+                           # Tasks are managed in the Subconscious UI — this file provides\n\
+                           # additional context and instructions for task evaluation.\n";
             tokio::fs::write(&path, default).await?;
         }
         Ok(())
@@ -178,9 +176,10 @@ mod tests {
         let path = dir.join("HEARTBEAT.md");
         assert!(path.exists());
         let content = tokio::fs::read_to_string(&path).await.unwrap();
+        assert!(content.contains("Subconscious Instructions"));
+        // Instructions only — no task lines
         let tasks = HeartbeatEngine::parse_tasks(&content);
-        assert_eq!(tasks.len(), 3);
-        assert!(tasks.iter().any(|t| t.contains("email")));
+        assert_eq!(tasks.len(), 0);
 
         let _ = tokio::fs::remove_dir_all(&dir).await;
     }

src/openhuman/subconscious/engine.rs

@@ -57,7 +57,7 @@ impl SubconsciousEngine {
         // Seed default system tasks eagerly so they show in the UI immediately,
         // without waiting for the first tick.
         let seeded = match store::with_connection(&workspace_dir, |conn| {
-            store::seed_from_heartbeat(conn, &workspace_dir)
+            store::seed_default_tasks(conn)
         }) {
             Ok(count) => {
                 if count > 0 {
@@ -130,7 +130,7 @@ impl SubconsciousEngine {
 
         let mut state = self.state.lock().await;
 
-        // Seed from HEARTBEAT.md on first tick (fallback if init seeding failed)
+        // Seed default tasks on first tick (fallback if init seeding failed)
         if !state.seeded {
             self.seed_tasks();
             state.seeded = true;
@@ -418,11 +418,11 @@ impl SubconsciousEngine {
 
     fn seed_tasks(&self) {
         match store::with_connection(&self.workspace_dir, |conn| {
-            store::seed_from_heartbeat(conn, &self.workspace_dir)
+            store::seed_default_tasks(conn)
         }) {
             Ok(count) => {
                 if count > 0 {
-                    info!("[subconscious] seeded {count} tasks from HEARTBEAT.md");
+                    info!("[subconscious] seeded {count} default tasks");
                 }
             }
             Err(e) => warn!("[subconscious] seed failed: {e}"),

src/openhuman/subconscious/integration_test.rs

@@ -202,14 +202,9 @@ mod tests {
     #[test]
     fn seed_then_query_tasks() {
         let dir = tempfile::tempdir().unwrap();
-        std::fs::write(
-            dir.path().join("HEARTBEAT.md"),
-            "# Tasks\n\n- Check email\n- Monitor skills\n- Review calendar\n",
-        )
-        .unwrap();
 
         store::with_connection(dir.path(), |conn| {
-            let count = store::seed_from_heartbeat(conn, dir.path())?;
+            let count = store::seed_default_tasks(conn)?;
             assert_eq!(count, 3);
 
             let tasks = store::list_tasks(conn, true)?;

src/openhuman/subconscious/situation_report.rs

@@ -1,6 +1,6 @@
 //! Assembles a bounded "situation report" for the subconscious tick.
 //! Gathers deltas since the last tick from memory, tools, environment,
-//! and HEARTBEAT.md — capped at the configured token budget.
+//! and pending tasks — capped at the configured token budget.
 
 use crate::openhuman::memory::MemoryClient;
 use std::fmt::Write;
@@ -27,8 +27,8 @@ pub async fn build_situation_report(
     let env_section = build_environment_section(workspace_dir);
     append_section(&mut report, &mut remaining, &env_section);
 
-    // Section 2: HEARTBEAT.md tasks
-    let tasks_section = build_tasks_section(workspace_dir).await;
+    // Section 2: Pending tasks from SQLite
+    let tasks_section = build_tasks_section(workspace_dir);
     append_section(&mut report, &mut remaining, &tasks_section);
 
     // Section 3: Memory documents (delta since last tick)
@@ -74,25 +74,21 @@ fn build_environment_section(workspace_dir: &Path) -> String {
     )
 }
 
-async fn build_tasks_section(workspace_dir: &Path) -> String {
-    let heartbeat_path = workspace_dir.join("HEARTBEAT.md");
-    let content = match tokio::fs::read_to_string(&heartbeat_path).await {
-        Ok(c) => c,
-        Err(_) => return "## Pending Tasks\n\nNo HEARTBEAT.md found.\n".to_string(),
+fn build_tasks_section(workspace_dir: &Path) -> String {
+    let tasks = match super::store::with_connection(workspace_dir, |conn| {
+        super::store::list_tasks(conn, false)
+    }) {
+        Ok(tasks) => tasks,
+        Err(_) => return "## Pending Tasks\n\nFailed to read tasks.\n".to_string(),
     };
 
-    let tasks: Vec<&str> = content
-        .lines()
-        .filter_map(|line| line.trim().strip_prefix("- "))
-        .collect();
-
     if tasks.is_empty() {
         return "## Pending Tasks\n\nNo tasks defined.\n".to_string();
     }
 
     let mut section = String::from("## Pending Tasks\n\n");
     for task in &tasks {
-        let _ = writeln!(section, "- {task}");
+        let _ = writeln!(section, "- {}", task.title);
     }
     section
 }

src/openhuman/subconscious/store.rs

@@ -420,7 +420,7 @@ pub fn get_escalation(conn: &Connection, escalation_id: &str) -> Result<Escalati
     .with_context(|| format!("escalation not found: {escalation_id}"))
 }
 
-// ── Seed from HEARTBEAT.md ───────────────────────────────────────────────────
+// ── Seed default system tasks ────────────────────────────────────────────────
 
 /// Default system tasks that are always seeded and cannot be deleted.
 const DEFAULT_SYSTEM_TASKS: &[&str] = &[
@@ -429,36 +429,18 @@ const DEFAULT_SYSTEM_TASKS: &[&str] = &[
     "Monitor system health (Ollama, memory, connections)",
 ];
 
-/// Seed default system tasks + any tasks from HEARTBEAT.md into SQLite.
+/// Seed default system tasks into SQLite.
 /// Skips tasks whose title already exists. Returns the count of newly created tasks.
-pub fn seed_from_heartbeat(conn: &Connection, workspace_dir: &Path) -> Result<usize> {
+pub fn seed_default_tasks(conn: &Connection) -> Result<usize> {
     let mut count = 0;
 
-    // 1. Always seed the default system tasks
     for title in DEFAULT_SYSTEM_TASKS {
         if !task_title_exists(conn, title)? {
             add_task(conn, title, TaskSource::System, TaskRecurrence::Pending)?;
             count += 1;
         }
     }
 
-    // 2. Also import from HEARTBEAT.md if it exists
-    let heartbeat_path = workspace_dir.join("HEARTBEAT.md");
-    if let Ok(content) = std::fs::read_to_string(&heartbeat_path) {
-        let tasks: Vec<&str> = content
-            .lines()
-            .filter_map(|line| line.trim().strip_prefix("- "))
-            .filter(|s| !s.is_empty())
-            .collect();
-
-        for title in tasks {
-            if !task_title_exists(conn, title)? {
-                add_task(conn, title, TaskSource::System, TaskRecurrence::Pending)?;
-                count += 1;
-            }
-        }
-    }
-
     Ok(count)
 }
 
@@ -699,35 +681,21 @@ mod tests {
     }
 
     #[test]
-    fn seed_from_heartbeat_imports_tasks() {
+    fn seed_default_tasks_creates_system_tasks() {
         let conn = test_conn();
-        let dir = tempfile::tempdir().unwrap();
-        std::fs::write(
-            dir.path().join("HEARTBEAT.md"),
-            "# Tasks\n\n- Check email\n- Monitor skills\n",
-        )
-        .unwrap();
 
-        let count = seed_from_heartbeat(&conn, dir.path()).unwrap();
-        assert_eq!(count, 2);
+        let count = seed_default_tasks(&conn).unwrap();
+        assert_eq!(count, DEFAULT_SYSTEM_TASKS.len());
 
         // Second seed should not duplicate
-        let count2 = seed_from_heartbeat(&conn, dir.path()).unwrap();
+        let count2 = seed_default_tasks(&conn).unwrap();
         assert_eq!(count2, 0);
 
         let tasks = list_tasks(&conn, false).unwrap();
-        assert_eq!(tasks.len(), 2);
+        assert_eq!(tasks.len(), DEFAULT_SYSTEM_TASKS.len());
         assert!(tasks.iter().all(|t| t.source == TaskSource::System));
     }
 
-    #[test]
-    fn seed_from_missing_heartbeat_returns_zero() {
-        let conn = test_conn();
-        let dir = tempfile::tempdir().unwrap();
-        let count = seed_from_heartbeat(&conn, dir.path()).unwrap();
-        assert_eq!(count, 0);
-    }
-
     #[test]
     fn recurrence_roundtrip() {
         assert_eq!(