Sync: local uncommitted work (2026-10-11)

legacy-extension-source/content.js

@@ -0,0 +1,108 @@
+// content.js — Page-level tracking and intervention overlay host
+
+import { createPageTracker } from './page-tracker.js';
+import { createInterventionOverlay } from './intervention-overlay.js';
+
+let pageTracker = null;
+let overlay = null;
+let trackingActive = false;
+
+function sendContentEvent(payload) {
+  chrome.runtime.sendMessage({
+    type: 'CONTENT_EVENT',
+    payload,
+  }, () => {
+    void chrome.runtime.lastError;
+  });
+}
+
+function ensureTracker() {
+  if (pageTracker) return pageTracker;
+  pageTracker = createPageTracker({
+    onReport: (payload) => sendContentEvent(payload),
+  });
+  return pageTracker;
+}
+
+function ensureOverlay() {
+  if (!overlay) {
+    overlay = createInterventionOverlay({
+      onOverride: (reflection) => {
+        chrome.runtime.sendMessage({
+          type: 'OVERLAY_OVERRIDE',
+          payload: {
+            reflection,
+            url: window.location.href,
+            pageTitle: document.title,
+          },
+        }, () => {
+          void chrome.runtime.lastError;
+        });
+      },
+      onDismiss: () => {
+        chrome.runtime.sendMessage({ type: 'OVERLAY_DISMISS' }, () => {
+          void chrome.runtime.lastError;
+        });
+      },
+    });
+  }
+  return overlay;
+}
+
+function startTracking() {
+  if (trackingActive) return;
+  trackingActive = true;
+  ensureTracker().start();
+}
+
+function stopTracking() {
+  if (!trackingActive) return;
+  trackingActive = false;
+  if (pageTracker) pageTracker.stop();
+}
+
+function syncSessionState() {
+  chrome.storage.local.get(['activeSession'], (result) => {
+    if (result.activeSession?.isActive) {
+      startTracking();
+    } else {
+      stopTracking();
+    }
+  });
+}
+
+chrome.storage.onChanged.addListener((changes, areaName) => {
+  if (areaName !== 'local' || !changes.activeSession) return;
+  if (changes.activeSession.newValue?.isActive) {
+    startTracking();
+  } else {
+    stopTracking();
+  }
+});
+
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message.type === 'SHOW_INTERVENTION') {
+    ensureOverlay().show({
+      reason: message.reason,
+      intent: message.intent,
+    });
+    sendResponse({ shown: true });
+    return true;
+  }
+
+  if (message.type === 'HIDE_INTERVENTION') {
+    if (overlay) overlay.hide();
+    sendResponse({ hidden: true });
+    return true;
+  }
+
+  if (message.type === 'STOP_TRACKING') {
+    stopTracking();
+    sendResponse({ status: 'ok' });
+    return true;
+  }
+
+  return false;
+});
+
+syncSessionState();

legacy-extension-source/diagnostics.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>IntentLock — Diagnostics</title>
+  <link rel="stylesheet" href="newtab.css">
+</head>
+<body class="options">
+  <div class="options-container">
+    <div class="header">
+      <h1>Diagnostics</h1>
+      <p>Recent errors and issues logged locally on your device. Copy this log when reporting problems.</p>
+    </div>
+
+    <div class="section">
+      <div class="diagnostics-actions">
+        <button id="copy-log-btn" class="complete-btn">Copy log</button>
+        <button id="clear-log-btn" class="danger-btn">Clear log</button>
+      </div>
+      <div id="copy-status" class="hidden status-feedback"></div>
+
+      <div class="history-filters diagnostics-filters">
+        <button class="filter-btn active" data-filter="all">All</button>
+        <button class="filter-btn" data-filter="api">API</button>
+        <button class="filter-btn" data-filter="validation">Validation</button>
+        <button class="filter-btn" data-filter="storage">Storage</button>
+        <button class="filter-btn" data-filter="ui">UI</button>
+        <button class="filter-btn" data-filter="runtime">Runtime</button>
+      </div>
+
+      <div id="empty-log" class="hidden">
+        <p class="no-session">No errors logged yet.</p>
+        <p class="field-hint">If a button does nothing or an API call fails, the issue will appear here.</p>
+      </div>
+
+      <div id="error-log-list"></div>
+    </div>
+  </div>
+
+  <script type="module" src="diagnostics.js"></script>
+</body>
+</html>

legacy-extension-source/diagnostics.js

@@ -0,0 +1,105 @@
+import {
+  getErrorLog,
+  clearErrorLog,
+  formatErrorLogForExport,
+} from './error-log.js';
+
+document.addEventListener('DOMContentLoaded', () => {
+  const listEl = document.getElementById('error-log-list');
+  const emptyEl = document.getElementById('empty-log');
+  const copyBtn = document.getElementById('copy-log-btn');
+  const clearBtn = document.getElementById('clear-log-btn');
+  const copyStatus = document.getElementById('copy-status');
+  let allEntries = [];
+  let activeFilter = 'all';
+
+  function showStatus(text) {
+    copyStatus.textContent = text;
+    copyStatus.classList.remove('hidden');
+    copyStatus.style.display = 'block';
+    clearTimeout(copyStatus._timer);
+    copyStatus._timer = setTimeout(() => {
+      copyStatus.style.display = 'none';
+    }, 2500);
+  }
+
+  function formatTime(timestamp) {
+    return new Date(timestamp).toLocaleString();
+  }
+
+  function renderEntries() {
+    const filtered = activeFilter === 'all'
+      ? allEntries
+      : allEntries.filter((entry) => entry.type === activeFilter);
+
+    listEl.textContent = '';
+    emptyEl.classList.toggle('hidden', filtered.length > 0);
+
+    filtered.forEach((entry) => {
+      const card = document.createElement('article');
+      card.className = 'diagnostics-entry';
+
+      const meta = document.createElement('div');
+      meta.className = 'diagnostics-meta';
+      meta.textContent = `${formatTime(entry.timestamp)} · ${entry.type} · ${entry.source || 'unknown'}`;
+
+      const message = document.createElement('p');
+      message.className = 'diagnostics-message';
+      message.textContent = entry.message;
+
+      card.append(meta, message);
+
+      if (entry.details && Object.keys(entry.details).length > 0) {
+        const details = document.createElement('pre');
+        details.className = 'diagnostics-details';
+        details.textContent = JSON.stringify(entry.details, null, 2);
+        card.appendChild(details);
+      }
+
+      listEl.appendChild(card);
+    });
+  }
+
+  async function refresh() {
+    allEntries = await getErrorLog();
+    renderEntries();
+  }
+
+  document.querySelectorAll('.diagnostics-filters .filter-btn').forEach((btn) => {
+    btn.addEventListener('click', () => {
+      document.querySelectorAll('.diagnostics-filters .filter-btn').forEach((b) => b.classList.remove('active'));
+      btn.classList.add('active');
+      activeFilter = btn.dataset.filter;
+      renderEntries();
+    });
+  });
+
+  copyBtn.addEventListener('click', async () => {
+    const filtered = activeFilter === 'all'
+      ? allEntries
+      : allEntries.filter((entry) => entry.type === activeFilter);
+    const text = formatErrorLogForExport(filtered);
+    try {
+      await navigator.clipboard.writeText(text);
+      showStatus('Log copied to clipboard.');
+    } catch {
+      const blob = new Blob([text], { type: 'text/plain' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `intentlock-diagnostics-${Date.now()}.txt`;
+      a.click();
+      URL.revokeObjectURL(url);
+      showStatus('Log downloaded as text file.');
+    }
+  });
+
+  clearBtn.addEventListener('click', async () => {
+    await clearErrorLog();
+    allEntries = [];
+    renderEntries();
+    showStatus('Diagnostic log cleared.');
+  });
+
+  refresh();
+});

legacy-extension-source/distraction-sites.js

@@ -0,0 +1,13 @@
+// distraction-sites.js — Default distraction domains for heuristic drift
+
+export const DEFAULT_DISTRACTION_SITES = [
+  'twitter.com', 'x.com', 'facebook.com', 'reddit.com',
+  'instagram.com', 'youtube.com', 'netflix.com', 'tiktok.com',
+];
+
+export function getEffectiveDistractionSites(storedSites, fallback = DEFAULT_DISTRACTION_SITES) {
+  if (Array.isArray(storedSites) && storedSites.length > 0) {
+    return storedSites;
+  }
+  return fallback;
+}

legacy-extension-source/drift-cache.js

@@ -0,0 +1,61 @@
+// drift-cache.js — In-memory TTL cache for LLM drift check results
+
+export const DRIFT_CACHE_TTL_MS = 60_000;
+export const DRIFT_CACHE_MAX_ENTRIES = 100;
+
+const cache = new Map();
+
+export function buildDriftCacheKey(intent, url, history = []) {
+  const recent = (Array.isArray(history) ? history : [])
+    .slice(-5)
+    .map((event) => `${event.actionType || 'unknown'}:${event.url || 'n/a'}`)
+    .join('|');
+  return `${String(intent || '').trim()}::${String(url || '').trim()}::${recent}`;
+}
+
+function pruneExpired(now = Date.now()) {
+  for (const [key, entry] of cache.entries()) {
+    if (!entry || entry.expiresAt <= now) {
+      cache.delete(key);
+    }
+  }
+}
+
+function evictOldestIfNeeded() {
+  if (cache.size < DRIFT_CACHE_MAX_ENTRIES) return;
+  const oldestKey = cache.keys().next().value;
+  if (oldestKey !== undefined) {
+    cache.delete(oldestKey);
+  }
+}
+
+export function getCachedDrift(key, now = Date.now()) {
+  pruneExpired(now);
+  const entry = cache.get(key);
+  if (!entry || entry.expiresAt <= now) {
+    if (entry) cache.delete(key);
+    return null;
+  }
+  return { ...entry.result, cached: true };
+}
+
+export function setCachedDrift(key, result, now = Date.now()) {
+  pruneExpired(now);
+  evictOldestIfNeeded();
+  cache.set(key, {
+    result: {
+      isAligned: Boolean(result?.isAligned),
+      confidence: typeof result?.confidence === 'number' ? result.confidence : 0,
+    },
+    expiresAt: now + DRIFT_CACHE_TTL_MS,
+  });
+}
+
+export function clearDriftCache() {
+  cache.clear();
+}
+
+export function getDriftCacheSize() {
+  pruneExpired();
+  return cache.size;
+}