Complete MVP hardening, recovery, and full test loop

Author: baboonzero

README.md

@@ -34,6 +34,15 @@ Chrome extension MVP that tracks tab-level activity and shows what you worked on
 3. Run end-to-end tests:
    - `npm run test:e2e`
 
+## Full Verification Loop
+
+- Run unit and E2E suites together:
+  - `npm run test:all`
+
+Includes:
+- Unit tests for session engine transitions and IndexedDB retention/query boundaries.
+- Playwright dashboard tests for timeline filters, focus/open behavior, and settings action.
+
 ## Notes
 
 - MVP tracks tab/window focus activity only.

background/service-worker.js

@@ -5,24 +5,26 @@ import {
   pruneSessionsOlderThan,
   upsertTabSnapshot
 } from "../shared/db.js";
-import { toDurationSeconds } from "../shared/time.js";
-import { extractDomain, isExcludedDomain, isTrackableUrl, readableTitle } from "../shared/url.js";
+import { createSessionEngine } from "./session-engine.js";
+import { isExcludedDomain, isTrackableUrl, readableTitle } from "../shared/url.js";
 
 const CLEANUP_ALARM = "retention-cleanup";
 const CLEANUP_INTERVAL_MINUTES = 360;
-const SWITCH_DEBOUNCE_MS = 250;
+const RUNTIME_STORAGE_KEY = "runtime_state_v1";
 
 const state = {
-  activeSession: null,
   focusedWindowId: chrome.windows.WINDOW_ID_NONE,
   idleState: "active",
   paused: false,
   excludedDomains: [],
-  retentionDays: 30,
-  lastContextFingerprint: "",
-  lastContextAt: 0
+  retentionDays: 30
 };
 
+const sessionEngine = createSessionEngine({
+  debounceMs: 250,
+  isTrackableTab
+});
+
 function getDashboardUrl() {
   return chrome.runtime.getURL("ui/dashboard.html");
 }
@@ -43,87 +45,59 @@ function isTrackableTab(tab) {
   return true;
 }
 
-function createSession(tab) {
-  const now = Date.now();
-  return {
-    id: crypto.randomUUID(),
-    tabId: tab.id,
-    windowId: tab.windowId,
-    url: tab.url,
-    title: readableTitle(tab.title, tab.url),
-    domain: extractDomain(tab.url),
-    startAt: now,
-    endAt: now,
-    durationSec: 0,
-    endReason: "unknown"
-  };
-}
-
 async function refreshSettingsCache() {
   const settings = await getSettings();
   state.paused = Boolean(settings.paused);
   state.retentionDays = Number(settings.retentionDays) || 30;
   state.excludedDomains = Array.isArray(settings.excludedDomains) ? settings.excludedDomains : [];
 }
 
-async function endActiveSession(reason) {
-  if (!state.activeSession) {
-    return;
-  }
-
-  const now = Date.now();
-  const completed = {
-    ...state.activeSession,
-    endAt: now,
-    durationSec: toDurationSeconds(state.activeSession.startAt, now),
-    endReason: reason
-  };
-
-  state.activeSession = null;
-  state.lastContextFingerprint = "";
-  state.lastContextAt = 0;
+function getActiveSession() {
+  return sessionEngine.readState().activeSession;
+}
 
-  if (!completed.url || completed.durationSec < 0) {
+async function persistRuntimeState() {
+  const runtimeState = sessionEngine.exportRuntimeState();
+  if (runtimeState.activeSession) {
+    await chrome.storage.local.set({
+      [RUNTIME_STORAGE_KEY]: runtimeState
+    });
     return;
   }
 
-  await addSession(completed);
+  await chrome.storage.local.remove(RUNTIME_STORAGE_KEY);
 }
 
-function isDebouncedContext(tab) {
-  const fingerprint = `${tab.windowId}:${tab.id}:${tab.url}`;
-  const now = Date.now();
-  const isDebounced =
-    fingerprint === state.lastContextFingerprint && now - state.lastContextAt < SWITCH_DEBOUNCE_MS;
+async function loadRuntimeState() {
+  const stored = await chrome.storage.local.get(RUNTIME_STORAGE_KEY);
+  const runtimeState = stored?.[RUNTIME_STORAGE_KEY];
+  if (!runtimeState) {
+    return false;
+  }
 
-  state.lastContextFingerprint = fingerprint;
-  state.lastContextAt = now;
-  return isDebounced;
+  return sessionEngine.hydrateRuntimeState(runtimeState);
 }
 
-async function startOrSwitchSession(tab, reason) {
-  if (!isTrackableTab(tab)) {
-    await endActiveSession(reason);
+async function storeEndedSession(endedSession) {
+  if (!endedSession || !endedSession.url || endedSession.durationSec < 0) {
     return;
   }
 
-  if (isDebouncedContext(tab)) {
-    return;
-  }
+  await addSession(endedSession);
+}
 
-  if (
-    state.activeSession &&
-    state.activeSession.tabId === tab.id &&
-    state.activeSession.windowId === tab.windowId
-  ) {
-    state.activeSession.url = tab.url || state.activeSession.url;
-    state.activeSession.title = readableTitle(tab.title, state.activeSession.url);
-    state.activeSession.domain = extractDomain(state.activeSession.url);
-    return;
-  }
+async function endActiveSession(reason) {
+  const endedSession = sessionEngine.endActiveSession(reason);
+  await persistRuntimeState();
+  await storeEndedSession(endedSession);
+  return endedSession;
+}
 
-  await endActiveSession(reason);
-  state.activeSession = createSession(tab);
+async function startOrSwitchSession(tab, reason) {
+  const result = sessionEngine.startOrSwitchSession(tab, reason);
+  await persistRuntimeState();
+  await storeEndedSession(result.endedSession);
+  return result;
 }
 
 async function cacheTabSnapshot(tab) {
@@ -189,6 +163,7 @@ async function runRetentionCleanup() {
 async function initializeExtension(reason) {
   await initDatabase();
   await refreshSettingsCache();
+  await loadRuntimeState();
 
   await chrome.alarms.clear(CLEANUP_ALARM);
   await chrome.alarms.create(CLEANUP_ALARM, { periodInMinutes: CLEANUP_INTERVAL_MINUTES });
@@ -226,29 +201,23 @@ chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
     console.error("Failed to cache tab snapshot", error);
   });
 
-  if (
-    state.activeSession &&
-    tabId === state.activeSession.tabId &&
-    typeof changeInfo.url === "string" &&
-    isTrackableUrl(changeInfo.url)
-  ) {
-    state.activeSession.url = changeInfo.url;
-    state.activeSession.domain = extractDomain(changeInfo.url);
-  }
-
-  if (state.activeSession && tabId === state.activeSession.tabId && typeof changeInfo.title === "string") {
-    state.activeSession.title = readableTitle(changeInfo.title, state.activeSession.url);
+  const activeSessionChanged = sessionEngine.updateActiveSessionMetadata(tabId, changeInfo);
+  if (activeSessionChanged) {
+    persistRuntimeState().catch((error) => {
+      console.error("Failed to persist runtime state on metadata update", error);
+    });
   }
 
-  if (tab.active && tab.windowId === state.focusedWindowId && (changeInfo.url || changeInfo.status === "complete")) {
+  if (tab && tab.active && tab.windowId === state.focusedWindowId && (changeInfo.url || changeInfo.status === "complete")) {
     syncCurrentActiveContext("navigation").catch((error) => {
       console.error("Failed to sync on navigation", error);
     });
   }
 });
 
 chrome.tabs.onRemoved.addListener((tabId) => {
-  if (state.activeSession && tabId === state.activeSession.tabId) {
+  const activeSession = getActiveSession();
+  if (activeSession && tabId === activeSession.tabId) {
     endActiveSession("tab_closed")
       .then(() => syncCurrentActiveContext("tab_closed"))
       .catch((error) => {
@@ -316,9 +285,10 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
   }
 
   if (message?.type === "get-runtime-status") {
+    const runtimeState = sessionEngine.readState();
     sendResponse({
       ok: true,
-      activeSession: state.activeSession,
+      activeSession: runtimeState.activeSession,
       paused: state.paused,
       retentionDays: state.retentionDays,
       idleState: state.idleState