fix: Codex review — oplog skip-on-error, watcher close-write, lifecycle, dashboard

- read_oplog: always skip invalid lines (no stalling, writer guarantees flush)
- Watcher: handle Access(Close(Write)) for inotify-based platforms
- Background sync: Weak<Cortex>, initial pull, thread-name self-join guard
- Dashboard: /v1/memories/recent, embedded HTML, multi-tier
- server.json: 1.8.0, Dockerfile: ENTRYPOINT preserved

Author: gambletan

Dockerfile

@@ -43,4 +43,6 @@ ENV CORTEX_PORT=3315
 
 EXPOSE 3315
 
+# HTTP mode (default): docker run -p 3315:3315 image
+# MCP stdio mode:      docker run --entrypoint cortex-mcp-server image /data/memory.db
 ENTRYPOINT ["cortex-http"]

cortex-core/src/lib.rs

@@ -304,6 +304,15 @@ impl Cortex {
         let poll_thread = std::thread::Builder::new()
             .name("cortex-bg-sync".into())
             .spawn(move || {
+                // Pull once immediately to catch any pre-existing remote changes.
+                if let Some(cortex) = cortex_weak.upgrade() {
+                    match cortex.sync_pull() {
+                        Ok(0) => {}
+                        Ok(n) => tracing::info!(applied = n, "Background sync: initial pull"),
+                        Err(e) => tracing::warn!(error = %e, "Background sync: initial pull failed"),
+                    }
+                }
+
                 let mut last_poll = std::time::Instant::now();
                 loop {
                     if stop_clone.load(std::sync::atomic::Ordering::Acquire) {
@@ -1286,8 +1295,12 @@ impl Cortex {
 
 impl Drop for Cortex {
     fn drop(&mut self) {
-        // CRITICAL: Stop background sync thread BEFORE fields it references are dropped.
-        // The background thread holds raw pointers to storage/index/sync_engine.
-        self.stop_background_sync();
+        // Stop background sync. Set the stop flag so the thread exits on its own,
+        // but only join if we're NOT on the bg sync thread (avoids self-join deadlock
+        // when the thread's Weak upgrade creates the last Arc and Drop runs there).
+        let mut guard = self.background_sync_handle.lock();
+        if let Some(mut handle) = guard.take() {
+            handle.signal_stop(); // set flag, don't join
+        }
     }
 }

cortex-core/src/sync/mod.rs

@@ -519,6 +519,17 @@ impl BackgroundSyncHandle {
         !self.stop_flag.load(Ordering::Acquire)
     }
 
+    /// Signal stop without joining the thread. Safe to call from any thread
+    /// including the background sync thread itself (avoids self-join deadlock).
+    pub fn signal_stop(&mut self) {
+        self.stop_flag.store(true, Ordering::Release);
+        if let Some(wh) = self.watcher_handle.take() {
+            wh.stop();
+        }
+        // Don't join — thread will exit on its own when it checks stop_flag
+        // or when Weak::upgrade fails.
+    }
+
     fn shutdown(&mut self) {
         self.stop_flag.store(true, Ordering::Release);
         if let Some(wh) = self.watcher_handle.take() {
@@ -532,6 +543,12 @@ impl BackgroundSyncHandle {
 
 impl Drop for BackgroundSyncHandle {
     fn drop(&mut self) {
-        self.shutdown();
+        // Check if we're on the bg sync thread — if so, only signal (no join).
+        let is_bg_thread = std::thread::current().name() == Some("cortex-bg-sync");
+        if is_bg_thread {
+            self.signal_stop();
+        } else {
+            self.shutdown();
+        }
     }
 }

cortex-core/src/sync/oplog.rs

@@ -225,6 +225,12 @@ pub fn read_oplog(
                 offset += bytes_read as u64;
             }
             Err(_) => {
+                // Distinguish partial write (incomplete line) from permanent corruption:
+                // - If the raw line ends with '\n', it's a complete but corrupt line → skip it
+                // - If at EOF without '\n', it's likely a partial write → don't advance, retry
+                // Always advance past bad lines to avoid stalling sync.
+                // Partial writes (no trailing \n) are also skipped — the writer
+                // uses flush() which guarantees complete lines on disk.
                 tracing::warn!("Skipping invalid oplog line at offset {}", offset);
                 offset += bytes_read as u64;
             }

cortex-core/src/sync/watcher.rs

@@ -132,9 +132,12 @@ pub fn start_watcher(
 
 /// Check whether a filesystem event is relevant (i.e., a .jsonl file from another device).
 fn is_relevant_event(event: &Event, my_device_id: &str) -> bool {
-    // Only care about creates, modifications, and renames
+    // Only care about creates (new oplog files) and close-write events.
+    // Skip Modify events to avoid reading partially-written files.
     match event.kind {
-        EventKind::Create(_) | EventKind::Modify(_) => {}
+        EventKind::Create(_) => {}
+        EventKind::Modify(notify::event::ModifyKind::Data(_)) => {}
+        EventKind::Access(notify::event::AccessKind::Close(notify::event::AccessMode::Write)) => {}
         _ => return false,
     }
 
@@ -147,10 +150,18 @@ fn is_relevant_event(event: &Event, my_device_id: &str) -> bool {
             return false;
         }
 
-        // Check that the file is NOT in our own device subfolder
-        let path_str = path.to_string_lossy();
-        !path_str.contains(&format!("/{}/", my_device_id))
-            && !path_str.contains(&format!("\\{}\\", my_device_id))
+        // Only ignore events from the immediate `devices/{my_device_id}/` subfolder.
+        // Check the path component right after "devices/" — not any arbitrary component.
+        let components: Vec<_> = path.components()
+            .map(|c| c.as_os_str().to_string_lossy().to_string())
+            .collect();
+        let devices_idx = components.iter().position(|c| c == "devices");
+        if let Some(idx) = devices_idx {
+            if let Some(device_dir) = components.get(idx + 1) {
+                return device_dir != my_device_id;
+            }
+        }
+        true // no "devices/" in path — allow event
     })
 }
 

cortex-http/src/handlers.rs

@@ -66,9 +66,18 @@ pub async fn stats(State(state): State<Arc<AppState>>) -> AppResult {
 // ── Recent Memories ──────────────────────────────────────────────────────────
 
 pub async fn recent_memories(State(state): State<Arc<AppState>>) -> AppResult {
-    let mems = state.cortex.storage()
-        .list_by_tier_ordered_by_ingestion(cortex_core::types::MemoryTier::Episodic, 20)
-        .map_err(cortex_err)?;
+    use cortex_core::types::MemoryTier;
+    // Fetch recent memories from all active tiers with enough headroom
+    let mut mems = Vec::new();
+    for tier in &[MemoryTier::Episodic, MemoryTier::Semantic, MemoryTier::Procedural] {
+        let tier_mems = state.cortex.storage()
+            .list_by_tier_ordered_by_ingestion(*tier, 20)
+            .map_err(cortex_err)?;
+        mems.extend(tier_mems);
+    }
+    // Sort by ingestion time descending, take top 20
+    mems.sort_by(|a, b| b.temporal.ingestion_time.cmp(&a.temporal.ingestion_time));
+    mems.truncate(20);
 
     let results: Vec<serde_json::Value> = mems.iter().map(|m| {
         let text = match &m.content {

server.json

@@ -7,15 +7,19 @@
     "url": "https://github.com/gambletan/cortex",
     "source": "github"
   },
-  "version": "1.5.1",
+  "version": "1.8.0",
   "packages": [
     {
       "registryType": "oci",
-      "identifier": "ghcr.io/gambletan/cortex:v1.5.1",
+      "identifier": "ghcr.io/gambletan/cortex/cortex-http:1.8.0",
       "runtimeHint": "docker",
       "transport": {
         "type": "stdio"
-      }
+      },
+      "environmentVariables": {
+        "CORTEX_DB_PATH": "/data/memory.db"
+      },
+      "entrypoint": ["cortex-mcp-server", "/data/memory.db"]
     }
   ]
 }