get-claudia 1.42.2 → 1.42.3

package/bin/index.js

@@ -376,7 +376,7 @@ async function main() {
         stdio: 'inherit',
         env: {
           ...process.env,
-          CLAUDIA_PROJECT_PATH: isUpgrade ? targetPath : '',
+          CLAUDIA_PROJECT_PATH: targetPath,
           CLAUDIA_NONINTERACTIVE: '1'
         }
       });

package/memory-daemon/claudia_memory/daemon/health.py

@@ -160,6 +160,31 @@ class HealthCheckHandler(BaseHTTPRequestHandler):
         else:
             self.send_error(404, "Not Found")
 
+    def do_POST(self):
+        """Handle POST requests"""
+        if self.path == "/backup":
+            self._send_backup_response()
+        else:
+            self.send_error(405, "Method Not Allowed")
+
+    def _send_backup_response(self):
+        """Trigger a database backup and return the path."""
+        try:
+            db = get_db()
+            path = db.backup()
+            self._send_json({"status": "ok", "path": str(path)})
+        except Exception as e:
+            logger.exception("Error triggering backup")
+            self._send_json({"status": "error", "message": str(e)}, code=500)
+
+    def _send_json(self, data: dict, code: int = 200):
+        """Helper to send a JSON response."""
+        body = json.dumps(data).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
     def _send_health_response(self):
         """Send basic health check response"""
         health = {

package/memory-daemon/claudia_memory/mcp/server.py

@@ -722,6 +722,19 @@ async def list_tools() -> ListToolsResult:
                 "properties": {},
             },
         ),
+        Tool(
+            name="memory.backup",
+            title="Trigger Database Backup",
+            description=(
+                "Trigger an immediate backup of the memory database. Returns the path "
+                "of the newly created backup file. Backups use a timestamp suffix and "
+                "older backups are pruned automatically per the retention policy."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
         Tool(
             name="memory.project_health",
             title="Project Health Check",
@@ -2587,8 +2600,14 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 )
 
             elif name == "memory.system_health":
-                from ..daemon.health import build_status_report
-                report = build_status_report()
+                import urllib.request, urllib.error
+                report = None
+                try:
+                    with urllib.request.urlopen("http://localhost:3848/status", timeout=2) as resp:
+                        report = json.loads(resp.read().decode())
+                except (urllib.error.URLError, OSError):
+                    from ..daemon.health import build_status_report
+                    report = build_status_report()
                 embedding_svc = get_embedding_service()
                 if hasattr(embedding_svc, '_model_mismatch') and embedding_svc._model_mismatch:
                     if "components" not in report:
@@ -2603,6 +2622,28 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                     ]
                 )
 
+            elif name == "memory.backup":
+                import urllib.request, urllib.error
+                result = None
+                try:
+                    req = urllib.request.Request(
+                        "http://localhost:3848/backup", method="POST", data=b""
+                    )
+                    with urllib.request.urlopen(req, timeout=10) as resp:
+                        result = json.loads(resp.read().decode())
+                except (urllib.error.URLError, OSError):
+                    # Daemon not running — trigger backup directly
+                    backup_path = get_db().backup()
+                    result = {"status": "ok", "path": str(backup_path)}
+                return CallToolResult(
+                    content=[
+                        TextContent(
+                            type="text",
+                            text=json.dumps(result, indent=2),
+                        )
+                    ]
+                )
+
             elif name == "memory.sync_vault":
                 from ..config import _project_id
                 from ..services.vault_sync import run_vault_sync

package/memory-daemon/claudia_memory/services/consolidate.py

@@ -2010,6 +2010,49 @@ class ConsolidateService:
 
         logger.debug(f"Merged reflection {duplicate['id']} into {primary['id']}")
 
+    def close_stale_episodes(self) -> int:
+        """Auto-close orphan episodes that have no end_session call.
+
+        Single-turn sessions and interrupted sessions leave episodes with
+        ``ended_at IS NULL``.  After 24 hours these will never be closed
+        naturally, so this pass marks them as summarized with a synthetic
+        summary to prevent them from appearing as false positives in health
+        reports.
+
+        Returns the number of episodes closed.
+        """
+        cutoff = (datetime.utcnow() - timedelta(hours=24)).isoformat()
+        try:
+            # Find stale open episodes and close them.  ended_at is set to the
+            # timestamp of the latest buffered turn if one exists, otherwise to
+            # started_at itself (single-turn / empty sessions).
+            self.db.execute(
+                """
+                UPDATE episodes
+                SET
+                    ended_at = COALESCE(
+                        (
+                            SELECT MAX(created_at) FROM turn_buffer
+                            WHERE turn_buffer.session_id = episodes.session_id
+                        ),
+                        started_at
+                    ),
+                    is_summarized = 1,
+                    summary = 'Auto-closed: session ended without explicit end_session call'
+                WHERE ended_at IS NULL
+                  AND started_at < ?
+                """,
+                (cutoff,),
+            )
+            rows = self.db.execute("SELECT changes()", fetch=True)
+            count = rows[0][0] if rows else 0
+            if count:
+                logger.info(f"Auto-closed {count} stale open episode(s)")
+            return count
+        except Exception as e:
+            logger.warning(f"close_stale_episodes failed: {e}")
+            return 0
+
     def run_retention_cleanup(self) -> Dict[str, int]:
         """Clean up old data per retention policies.
 
@@ -2018,6 +2061,7 @@ class ConsolidateService:
         - Expired predictions past retention window
         - Archived turn_buffer from old episodes
         - Old metrics rows
+        - Auto-closes stale open episodes (no end_session after 24 h)
         """
         results = {}
         now = datetime.utcnow()
@@ -2074,6 +2118,9 @@ class ConsolidateService:
             logger.warning(f"Metrics cleanup failed: {e}")
             results["metrics_deleted"] = 0
 
+        # Auto-close orphan episodes (no end_session after 24 h)
+        results["stale_episodes_closed"] = self.close_stale_episodes()
+
         logger.info(f"Retention cleanup: {results}")
         return results
 

package/memory-daemon/scripts/install.ps1

@@ -366,9 +366,13 @@ try {
     }
 
     # Create the scheduled task action
+    $taskArgs = "-m claudia_memory --standalone"
+    if ($env:CLAUDIA_PROJECT_PATH) {
+        $taskArgs += " --project-dir `"$($env:CLAUDIA_PROJECT_PATH)`""
+    }
     $action = New-ScheduledTaskAction `
         -Execute $VENV_PYTHON `
-        -Argument "-m claudia_memory --standalone" `
+        -Argument $taskArgs `
         -WorkingDirectory $DAEMON_DIR
 
     # Trigger: at logon for current user

package/memory-daemon/scripts/install.sh

@@ -518,7 +518,7 @@ if [[ "$OSTYPE" == "darwin"* ]]; then
         <string>$VENV_DIR/bin/python</string>
         <string>-m</string>
         <string>claudia_memory</string>
-        <string>--standalone</string>
+        <string>--standalone</string>$(if [ -n "$CLAUDIA_PROJECT_PATH" ]; then printf '\n        <string>--project-dir</string>\n        <string>%s</string>' "$CLAUDIA_PROJECT_PATH"; fi)
     </array>
     <key>WorkingDirectory</key>
     <string>$DAEMON_DIR</string>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.42.2",
+  "version": "1.42.3",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",