Merge branch 'main' of https://github.com/AsieduDevelopmentHub/SentraCore

# Conflicts:
#	dashboard/lib/providers/engine_provider.dart
#	dashboard/lib/screens/dashboard_screen.dart
#	dashboard/lib/screens/hardware_screen.dart
#	dashboard/lib/services/engine_service.dart

Author: AsieduDevelopmentHub

.githooks/commit-msg

@@ -1,7 +1,7 @@
 #!/bin/sh
 set -eu
 
-# Strip Cursor co-author trailer(s) from commit message.
+# Strip AI co-author/trailer lines from commit message.
 # Runs after the message is composed, before the commit is finalized.
 #
 # Usage: enable repo hooks with:
@@ -14,12 +14,14 @@ fi
 
 tmp="${MSG_FILE}.tmp.$$"
 
-# Remove any "Co-authored-by: Cursor ..." trailer lines (case-insensitive).
-# Keep all other co-authors intact.
+# Remove:
+# - ALL "Co-authored-by:" trailer lines (case-insensitive)
+# - ANY git trailer line mentioning Cursor/cursoragent (case-insensitive)
 awk '
 BEGIN { IGNORECASE = 1 }
-/^[[:space:]]*Co-authored-by:[[:space:]]*Cursor([[:space:]]|<|$)/ { next }
-/^[[:space:]]*Co-Authored-By:[[:space:]]*Cursor([[:space:]]|<|$)/ { next }
+NR==1 { print; next }
+/^[[:space:]]*Co-authored-by:[[:space:]]*/ { next }
+/^[[:space:]]*[A-Za-z0-9-]+:[[:space:]]+.*(cursoragent|cursor).*/ { next }
 { print }
 ' "$MSG_FILE" > "$tmp"
 

.gitignore

@@ -258,3 +258,11 @@ release.md
 
 # Pages
 landingpage.md
+
+# Datastore
+/engine/datastore/*.json
+/engine/datastore/state/*.json
+/engine/datastore/history/**
+/engine/datastore/logs/**
+/engine/datastore/cache/**
+/engine/datastore/reports/**

dashboard/lib/navigation/dashboard_navigation.dart

@@ -4,7 +4,7 @@ import 'package:flutter/scheduler.dart';
 class DashboardNavigation {
   DashboardNavigation._();
 
-  /// Switch main rail: 0 Overview … 4 Diagnostics, 5 Hardware, 6 Settings.
+  /// Switch main rail: 0 Overview … 4 Diagnostics, 5 Hardware, 6 Storage, 7 Settings.
   static void Function(int index)? selectMainTab;
 
   /// Switches Diagnostics inner tab to "Alerts & RCA" (index 1).

dashboard/lib/providers/engine_provider.dart

@@ -446,6 +446,10 @@ class EngineProvider extends ChangeNotifier {
     if (!_connected) {
       _connected = true;
       _connectionError = '';
+      // Once we are talking to the engine, pull the authoritative history
+      // archive so charts survive a dashboard restart even if SharedPreferences
+      // is empty (e.g. after `flutter clean` or a fresh install).
+      _history?.startPeriodicRefresh(_service);
     }
 
     _currentState = state;
@@ -502,6 +506,70 @@ class EngineProvider extends ChangeNotifier {
     return r ?? {'ok': false, 'error': 'No response'};
   }
 
+  // ── Datastore (history, cache, baseline) ──
+
+  /// Fetch on-disk layout + history summary from the engine.
+  Future<Map<String, dynamic>?> getStorageInfo() {
+    return _service.getStorageInfo();
+  }
+
+  /// Delete every file under the engine's cache/ directory.
+  Future<Map<String, dynamic>?> clearEngineCache() async {
+    final r = await _service.clearCache();
+    notifyListeners();
+    return r;
+  }
+
+  /// Wipe the engine-side history archive AND the dashboard's offline mirror.
+  Future<Map<String, dynamic>?> clearAllHistory() async {
+    final r = await _service.deleteHistory();
+    _history?.clear();
+    notifyListeners();
+    return r;
+  }
+
+  /// Reset the behavioral baseline (engine continues running).
+  Future<Map<String, dynamic>?> resetEngineBaseline() async {
+    final r = await _service.resetBaseline();
+    notifyListeners();
+    return r;
+  }
+
+  /// Pull the latest history window from the engine immediately.
+  Future<void> refreshHistoryNow() async {
+    await _history?.refreshFromEngine(_service);
+  }
+
+  // ── Disk cleanup + large file finder ──
+
+  Future<Map<String, dynamic>?> getCleanupCategories() {
+    return _service.getCleanupCategories();
+  }
+
+  Future<Map<String, dynamic>?> runCleanupScan({List<String>? categoryIds}) {
+    return _service.runCleanupScan(categoryIds: categoryIds);
+  }
+
+  Future<Map<String, dynamic>?> applyCleanup({
+    required String scanId,
+    required List<String> categoryIds,
+    String mode = 'recycle',
+  }) {
+    return _service.applyCleanup(
+      scanId: scanId,
+      categoryIds: categoryIds,
+      mode: mode,
+    );
+  }
+
+  Future<Map<String, dynamic>?> findLargeFiles({
+    required String path,
+    double minMb = 100.0,
+    int limit = 200,
+  }) {
+    return _service.findLargeFiles(path: path, minMb: minMb, limit: limit);
+  }
+
   /// Aggregated CPU / memory / disk health (slow probe — caller should cache).
   Future<Map<String, dynamic>?> getHardwareHealth({bool refresh = false}) {
     return _service.getHardwareHealth(refresh: refresh);
@@ -519,6 +587,7 @@ class EngineProvider extends ChangeNotifier {
     _eventFetchTimer?.cancel();
     _reconnectTimer?.cancel();
     _cooldownTicker?.cancel();
+    _history?.stopPeriodicRefresh();
     _service.dispose();
     // Do NOT kill the engine on app close. The engine is designed to be a
     // background component and should survive dashboard restarts.

dashboard/lib/providers/history_provider.dart

@@ -6,25 +6,49 @@ import 'package:shared_preferences/shared_preferences.dart';
 
 import 'package:sentracore_dashboard/models/history_sample.dart';
 import 'package:sentracore_dashboard/models/system_state.dart';
-
+import 'package:sentracore_dashboard/services/engine_service.dart';
+
+/// History samples ultimately live with the engine (persisted under
+/// ``history/`` next to the rest of its datastore). This provider:
+///
+/// * Pulls authoritative samples from the engine via `/api/v1/history`.
+/// * Keeps a small `SharedPreferences` mirror so charts still render when the
+///   engine is offline (e.g. during the first second of dashboard startup or
+///   while the engine restarts).
+/// * Records live samples opportunistically — the data is rolled into the
+///   offline mirror but the engine remains the source of truth across
+///   restarts.
 class HistoryProvider extends ChangeNotifier {
-  static const _kHistorySamples = 'history_samples_v1';
+  static const _kHistorySamples = 'history_samples_v2';
 
-  /// Default sampling cadence (engine pushes every ~2s; we downsample to keep storage sane).
+  /// Local downsample cadence (engine pushes every ~2s).
   static const Duration sampleInterval = Duration(seconds: 30);
 
-  /// Hard cap to prevent unbounded growth in SharedPreferences.
-  static const int maxSamples =
-      12000; // ~4 days at 30s; UI ranges use downsampling
+  /// Hard cap for the offline mirror; the server-side archive holds the rest.
+  static const int maxSamples = 12000;
+
+  /// How often we re-fetch from the engine while it is connected.
+  static const Duration _refreshInterval = Duration(minutes: 1);
+
+  /// How far back we ask the engine for on each refresh.
+  static const Duration _refreshWindow = Duration(days: 7);
 
   final List<HistorySample> _samples = [];
   bool _loaded = false;
   DateTime? _lastSampleAt;
   Timer? _saveDebounce;
 
+  /// When `true`, _samples reflects data pulled from the engine and is the
+  /// source of truth. Local appends from [recordIfDue] still augment it
+  /// between server refreshes.
+  bool _syncedFromEngine = false;
+
   List<HistorySample> get samples => List<HistorySample>.unmodifiable(_samples);
   bool get loaded => _loaded;
 
+  /// True once we've populated samples from the engine since launch.
+  bool get syncedFromEngine => _syncedFromEngine;
+
   Future<void> load() async {
     if (_loaded) return;
     final p = await SharedPreferences.getInstance();
@@ -58,10 +82,98 @@ class HistoryProvider extends ChangeNotifier {
   void clear() {
     _samples.clear();
     _lastSampleAt = null;
+    _syncedFromEngine = false;
     notifyListeners();
     _scheduleSave();
   }
 
+  /// Pull the persistent server-side archive and replace local samples with
+  /// it. Falls back silently if the engine is unreachable so we keep showing
+  /// the offline mirror.
+  Future<void> refreshFromEngine(EngineService service,
+      {Duration? window}) async {
+    final now = DateTime.now();
+    final from = now.subtract(window ?? _refreshWindow);
+    final raw = await service.getHistory(
+      from: from,
+      to: now,
+      // Engine collects at 30s spacing; granularity matches so we don't waste
+      // bytes on near-duplicate samples for long ranges.
+      granularitySec: 30.0,
+      limit: maxSamples,
+    );
+    if (raw.isEmpty) return;
+
+    final parsed = <HistorySample>[];
+    for (final m in raw) {
+      final at = m['at'];
+      DateTime when;
+      if (at is num) {
+        when = DateTime.fromMillisecondsSinceEpoch(
+          (at.toDouble() * 1000).round(),
+        );
+      } else {
+        continue;
+      }
+      parsed.add(
+        HistorySample(
+          at: when,
+          cpuPercent: (m['cpu_percent'] as num?)?.toDouble() ?? 0,
+          memPercent: (m['mem_percent'] as num?)?.toDouble() ?? 0,
+          diskPressurePercent:
+              (m['disk_pressure_percent'] as num?)?.toDouble() ?? 0,
+          topProcesses: _parseEngineProcesses(m['top_processes']),
+        ),
+      );
+    }
+    if (parsed.isEmpty) return;
+
+    parsed.sort((a, b) => a.at.compareTo(b.at));
+    _samples
+      ..clear()
+      ..addAll(parsed);
+    _lastSampleAt = parsed.last.at;
+    _syncedFromEngine = true;
+    notifyListeners();
+    _scheduleSave();
+  }
+
+  Timer? _refreshTimer;
+
+  /// Begin periodically pulling from the engine. Safe to call repeatedly.
+  void startPeriodicRefresh(EngineService service) {
+    _refreshTimer?.cancel();
+    // Fire an immediate refresh then continue on the interval.
+    unawaited(refreshFromEngine(service));
+    _refreshTimer = Timer.periodic(
+      _refreshInterval,
+      (_) => unawaited(refreshFromEngine(service)),
+    );
+  }
+
+  void stopPeriodicRefresh() {
+    _refreshTimer?.cancel();
+    _refreshTimer = null;
+  }
+
+  static List<HistoryProcessSample> _parseEngineProcesses(dynamic raw) {
+    if (raw is! List) return const [];
+    final out = <HistoryProcessSample>[];
+    for (final m in raw) {
+      if (m is! Map) continue;
+      out.add(
+        HistoryProcessSample(
+          name: '${m['name'] ?? ''}',
+          pid: (m['pid'] as num?)?.toInt() ?? 0,
+          cpuPercent: (m['cpu_percent'] as num?)?.toDouble() ?? 0,
+          memPercent: (m['mem_percent'] as num?)?.toDouble() ?? 0,
+          impact: (m['impact'] as num?)?.toDouble() ?? 0,
+        ),
+      );
+    }
+    return out;
+  }
+
   /// Called by EngineProvider on every live state; this function decides whether
   /// we should record a new sample based on [sampleInterval].
   void recordIfDue({
@@ -127,6 +239,8 @@ class HistoryProvider extends ChangeNotifier {
   void dispose() {
     _saveDebounce?.cancel();
     _saveDebounce = null;
+    _refreshTimer?.cancel();
+    _refreshTimer = null;
     super.dispose();
   }
 }