browser-assistant 2.8.6 → 2.8.21

package/extension/automation-policy.js

@@ -94,10 +94,36 @@
         id: 'semantic-mcq',
         getQuestion(doc) {
             const visible = (element) => element.getClientRects().length > 0;
+            const preserveMatrices = (clone) => {
+                for (const math of clone.querySelectorAll('math')) {
+                    const tables = math.querySelectorAll('mtable');
+                    if (tables.length !== 1)
+                        continue;
+                    const matrix = tables[0];
+                    const surrounding = math.cloneNode(true);
+                    surrounding.querySelectorAll('mtable,annotation,annotation-xml').forEach(node => node.remove());
+                    if (!/^[\s()[\]{}|‖]*$/.test(surrounding.textContent || ''))
+                        continue;
+                    const rows = [...matrix.children];
+                    if (!rows.length || rows.some(row => !row.matches('mtr')))
+                        continue;
+                    const cells = rows.map(row => [...row.children].map(cell => {
+                        if (!cell.matches('mtd'))
+                            return '';
+                        const value = (cell.textContent || '').trim().replace(/−/g, '-').replace(/^([+-])\s+/, '$1');
+                        return /^[+-]?\d+(?:\.\d+)?$/.test(value) ? value : '';
+                    }));
+                    if (!cells[0].length || cells.some(row => row.length !== cells[0].length || row.some(value => !value)))
+                        continue;
+                    const renderer = math.closest('.katex,mjx-container') || math;
+                    renderer.replaceWith(doc.createTextNode(` ${JSON.stringify(cells).replace(/"/g, '')} `));
+                }
+            };
             const textOf = (element) => {
                 if (!element)
                     return '';
                 const clone = element.cloneNode(true);
+                preserveMatrices(clone);
                 const editors = element.querySelectorAll('.ace_editor,.CodeMirror,.monaco-editor');
                 [...clone.querySelectorAll('.ace_editor,.CodeMirror,.monaco-editor')].forEach((block, index) => {
                     const source = typeof browserAssistantCachedMcqSnippet === 'function'
@@ -222,8 +248,8 @@
                 // Coding MCQs often render the code separately from the prose
                 // question. Preserve that visible context before asking the AI.
                 const questionRegion = optionScope.closest('[data-question],article,section,main') || optionScope.parentElement;
-                const promptRegion = questionRegion?.querySelector('#generic-question-wrapper-id,[data-question-text]')
-                    || doc.querySelector('#generic-question-wrapper-id');
+                const promptRegion = questionRegion?.querySelector('#generic-question-wrapper-id,#exam-question-wrapper-id,[data-question-text]')
+                    || doc.querySelector('#generic-question-wrapper-id,#exam-question-wrapper-id');
                 const sourceRegion = promptRegion || questionRegion;
                 const snippets = [...(sourceRegion?.querySelectorAll('pre,code,.ace_editor,.CodeMirror,.monaco-editor') || [])]
                     .filter(node => visible(node) && !node.parentElement?.closest('pre,code,.ace_editor,.CodeMirror,.monaco-editor'));
@@ -240,6 +266,7 @@
                     // Preserve filenames, prose and ALL snippets together; the
                     // last code block alone is not the question's full context.
                     const clone = promptRegion.cloneNode(true);
+                    preserveMatrices(clone);
                     for (const block of clone.querySelectorAll('pre,.ace_editor,.CodeMirror,.monaco-editor')) {
                         const plain = doc.createElement('pre');
                         plain.textContent = '\n' + codeText(block) + '\n';

package/extension/background.js

@@ -61,14 +61,122 @@ async function attachUpdatedPanels() {
     }
 }
 chrome.alarms.create('assistant-workspace-update', { periodInMinutes: 1 });
-chrome.alarms.onAlarm.addListener(alarm => { if (alarm.name === 'assistant-workspace-update')
-    void checkWorkspaceUpdate(); });
+chrome.alarms.onAlarm.addListener(alarm => {
+    if (alarm.name !== 'assistant-workspace-update')
+        return;
+    void checkWorkspaceUpdate();
+    void checkJournalReminder();
+    void updateJournalBadge();
+});
 chrome.runtime.onInstalled.addListener(() => { void attachUpdatedPanels(); });
+let journalBadgeRevision = 0;
+function activeJournalTimers(data, now = Date.now()) {
+    const prefix = 'assistantJournalTimer:';
+    const timers = new Map();
+    const last = data.assistantJournalTimer;
+    if (typeof last?.path === 'string')
+        timers.set(last.path.replace(/\/$/, ''), last.deadline);
+    for (const [key, deadline] of Object.entries(data)) {
+        if (key.startsWith(prefix) && typeof deadline === 'number')
+            timers.set(key.slice(prefix.length), deadline);
+    }
+    return [...timers].filter(([path, deadline]) => /^\/modules\/reflective-journal\/[^/]+$/.test(path) &&
+        Number.isFinite(deadline) && deadline > now && !data[`assistantJournalConfirmed:${path}`])
+        .map(([path, deadline]) => ({ path, deadline })).sort((a, b) => a.deadline - b.deadline);
+}
+async function updateJournalBadge() {
+    const storage = chrome.storage?.local;
+    if (!storage || !chrome.action)
+        return;
+    const revision = ++journalBadgeRevision;
+    try {
+        const timers = activeJournalTimers(await storage.get());
+        const remaining = timers[0]?.deadline - Date.now();
+        if (revision !== journalBadgeRevision)
+            return;
+        const minutes = Math.ceil(remaining / 60000);
+        const active = Number.isFinite(minutes) && minutes > 0;
+        const text = active ? (remaining < 60000 ? '<1m' : minutes > 999 ? '999+' : `${minutes}m`) : '';
+        await Promise.all([
+            chrome.action.setBadgeText({ text }),
+            chrome.action.setBadgeBackgroundColor({ color: '#5b39db' }),
+            chrome.action.setTitle({ title: active ? `Browser Assistant · ${timers.length > 1 ? 'Next journal' : 'Journal'}: about ${minutes} min left` : 'Browser Assistant' }),
+        ]);
+    }
+    catch { /* Retry when the timer changes or on the next alarm. */ }
+}
+chrome.storage?.local.onChanged?.addListener(changes => {
+    if (Object.keys(changes).some(key => key.startsWith('assistantJournalTimer') || key.startsWith('assistantJournalConfirmed:'))) {
+        void updateJournalBadge();
+    }
+});
+void updateJournalBadge();
+let checkingJournalReminder = false;
+async function checkJournalReminder() {
+    if (checkingJournalReminder)
+        return;
+    checkingJournalReminder = true;
+    try {
+        const storage = chrome.storage.local;
+        const data = await storage.get();
+        const config = data.assistantJournalReminderConfig;
+        if (!config?.url || !config?.token)
+            return;
+        await Promise.all(activeJournalTimers(data).map(timer => sendJournalReminder(timer, config)));
+    }
+    catch { /* The minute alarm keeps timer checks independent of workspace updates. */ }
+    finally {
+        checkingJournalReminder = false;
+    }
+}
+async function sendJournalReminder(timer, config) {
+    try {
+        const storage = chrome.storage.local;
+        const remaining = timer.deadline - Date.now();
+        // Give the portal time to confirm an existing submission at 30:00.
+        if (remaining > (30 * 60 - 45) * 1000 || remaining <= 0)
+            return;
+        const stateKey = `assistantJournalReminder:${timer.path}`;
+        const confirmationKey = `assistantJournalConfirmed:${timer.path}`;
+        const previous = await storage.get([stateKey, confirmationKey]);
+        if (previous[stateKey] || previous[confirmationKey])
+            return;
+        // Reserve the one attempt before the network call. A timed-out webhook
+        // can still have sent a message, so replay would risk a duplicate.
+        await storage.set({ [stateKey]: 'sending' });
+        const latest = await storage.get();
+        const current = activeJournalTimers(latest).find(candidate => candidate.path === timer.path);
+        if (!current || Math.abs(current.deadline - timer.deadline) > 2000 ||
+            latest.assistantJournalReminderConfig?.url !== config.url || latest.assistantJournalReminderConfig.token !== config.token) {
+            await storage.remove(stateKey);
+            return;
+        }
+        let result = 'failed';
+        try {
+            const response = await fetch(config.url, {
+                method: 'POST', credentials: 'omit', redirect: 'error', signal: AbortSignal.timeout(15000),
+                headers: { 'Content-Type': 'application/json', 'X-Journal-Reminder-Token': config.token },
+                body: JSON.stringify({ event: 'journal_submission_unconfirmed' }),
+            });
+            if (response.ok)
+                result = 'sent';
+        }
+        finally {
+            await storage.set({ [stateKey]: result });
+        }
+    }
+    catch { /* One failed request does not interrupt the other journals. */ }
+}
 chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
     if (!request || typeof request.action !== 'string') {
         sendResponse({ error: 'Invalid extension message' });
         return false;
     }
+    if (request.action === 'journalCountdowns' && sender.id === chrome.runtime.id) {
+        chrome.storage.local.get().then(data => sendResponse(activeJournalTimers(data)))
+            .catch(() => sendResponse([]));
+        return true;
+    }
     if (request.action === 'questionImage') {
         let url;
         try {

package/extension/content.js

@@ -1,4 +1,63 @@
 // Browser Assistant Content Script v3.0 — High Accuracy Edition
+function mountJournalCountdown(signal) {
+    const storage = chrome.storage.local;
+    const badge = document.createElement('div');
+    badge.id = 'assistant-journal-countdown-badge';
+    const clock = document.createElement('span');
+    clock.setAttribute('role', 'timer');
+    badge.attachShadow({ mode: 'closed' }).append(clock);
+    let timers = [];
+    let tick;
+    let revision = 0;
+    function renderCountdown() {
+        window.clearTimeout(tick);
+        if (signal.aborted)
+            return;
+        const now = Date.now();
+        const active = timers.filter(timer => timer.deadline > now);
+        const path = location.pathname.replace(/\/$/, '');
+        const aurora = location.origin === 'https://admissions.aurora.edu.in';
+        const visible = active.filter(timer => !aurora || (path.startsWith('/modules/reflective-journal/') && timer.path !== path));
+        if (!visible.length)
+            badge.remove();
+        else {
+            const times = visible.map(timer => {
+                const seconds = Math.ceil((timer.deadline - now) / 1000);
+                return `${String(Math.floor(seconds / 60)).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`;
+            });
+            clock.textContent = `${times.length === 1 ? 'Journal time left' : 'Journal times left'} ≈ ${times.join(' · ')}`;
+            if (!badge.isConnected)
+                document.body.appendChild(badge);
+        }
+        if (active.length && !document.hidden)
+            tick = window.setTimeout(renderCountdown, 1000);
+    }
+    async function refreshCountdown() {
+        const request = ++revision;
+        try {
+            const next = await chrome.runtime.sendMessage({ action: 'journalCountdowns' });
+            if (request !== revision || signal.aborted)
+                return;
+            timers = Array.isArray(next) ? next : [];
+            renderCountdown();
+        }
+        catch { /* Reloading the extension can invalidate the old tab context. */ }
+    }
+    const onStorageChange = (changes) => {
+        if (Object.keys(changes).some(key => key.startsWith('assistantJournalTimer') || key.startsWith('assistantJournalConfirmed:'))) {
+            void refreshCountdown();
+        }
+    };
+    storage.onChanged.addListener(onStorageChange);
+    document.addEventListener('visibilitychange', renderCountdown, { signal });
+    signal.addEventListener('abort', () => {
+        window.clearTimeout(tick);
+        storage.onChanged.removeListener(onStorageChange);
+        badge.remove();
+    }, { once: true });
+    void refreshCountdown();
+    return badge;
+}
 (function () {
     // Abort on pages without a body (about:blank, PDFs, XML docs, etc.)
     if (!document.body)
@@ -22,6 +81,8 @@
     const root = document.createElement('div');
     root.id = 'assistant-root';
     document.body.appendChild(root);
+    const journalCountdownBadge = ['http:', 'https:'].includes(location.protocol)
+        ? mountJournalCountdown(lifecycle.signal) : null;
     // ── Move panel ───────────────────────────────────────────────────────────
     // Drag the header to put the panel anywhere on the current page. The saved
     // location is restored after a refresh on that site.
@@ -2077,10 +2138,13 @@
         setLoading("Capturing screen…");
         let timeoutId;
         let panelVisibility = '';
+        const countdownVisibility = journalCountdownBadge?.style.visibility;
         try {
-            // Do not include our own floating panel in the captured screenshot.
+            // Keep extension UI out of the captured screenshot.
             panelVisibility = root.style.visibility;
             root.style.visibility = 'hidden';
+            if (journalCountdownBadge)
+                journalCountdownBadge.style.visibility = 'hidden';
             const context = await prepareVisionQuestionContext();
             const visuals = window.BrowserAssistantQuestionVisuals;
             let images;
@@ -2098,6 +2162,8 @@
                 images = [response.dataUrl];
             }
             root.style.visibility = panelVisibility;
+            if (journalCountdownBadge)
+                journalCountdownBadge.style.visibility = countdownVisibility;
             await assertVisionQuestionCurrent(context);
             setLoading("Analyzing and cross-checking…");
             const res = await apiRequest('/solve-vision', 'POST', {
@@ -2140,6 +2206,8 @@
         }
         finally {
             root.style.visibility = panelVisibility;
+            if (journalCountdownBadge)
+                journalCountdownBadge.style.visibility = countdownVisibility;
             // Text Scan can hand off to Vision without a visible error. In that
             // case, leave its in-progress state for the caller to clear.
             if (!scanWasAlreadyRunning) {
@@ -2509,6 +2577,7 @@
                     <div><dt>Progress</dt><dd id="assistant-automation-progress">0 / —</dd></div>
                     <div class="assistant-qa-wide"><dt>Current question</dt><dd id="assistant-automation-question">—</dd></div>
                 </dl>
+                <div class="assistant-qa-latest" id="assistant-journal-list-clock" hidden></div>
                 <div class="assistant-qa-latest" id="assistant-automation-latest" aria-live="polite"></div>
                 <div id="assistant-journal-slot"></div>
                 <div class="assistant-automation-actions assistant-qa-actions">

package/extension/journal-automation.js

@@ -1,3 +1,6 @@
+function formatJournalTime(seconds) {
+    return `${String(Math.floor(seconds / 60)).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`;
+}
 function browserAssistantJournal(global) {
     'use strict';
     const keys = ['experience', 'feelings', 'learning', 'application', 'conclusion'];
@@ -84,10 +87,10 @@ function browserAssistantJournal(global) {
         }
         if (explicit.size)
             return explicit.size === 1 ? [...explicit][0] : null;
-        for (const node of doc.querySelectorAll('span,div,p,output,strong,b')) {
+        for (const node of doc.querySelectorAll('span,div,p,output,strong,b,time,label')) {
             if (excluded(node) || !node.getClientRects().length)
                 continue;
-            const value = labeled(node.textContent);
+            const value = labeled(node.innerText ?? node.textContent);
             if (value !== null)
                 values.add(value);
         }
@@ -130,7 +133,7 @@ function browserAssistantJournal(global) {
     panel.id = 'assistant-journal';
     panel.dataset.build = journalBuild;
     panel.style.cssText = 'position:fixed;right:16px;top:160px;width:290px;z-index:2147483646;background:white;color:#17233d;padding:16px;border:2px solid #7638ff;border-radius:12px;box-shadow:0 4px 20px #0003;font:14px Arial';
-    panel.innerHTML = '<strong>Reflective Journal</strong><p data-info></p><textarea aria-label="Your class experience and feelings" placeholder="Your actual class experience / feelings (optional)" rows="3" style="width:100%;box-sizing:border-box"></textarea><button type="button" style="margin-top:8px;padding:10px">Fill &amp; Submit Journal</button><p role="status" aria-live="polite"></p>';
+    panel.innerHTML = '<strong>Reflective Journal</strong><p data-info></p><p data-countdown style="font-weight:600;margin:8px 0"></p><textarea aria-label="Your class experience and feelings" placeholder="Your actual class experience / feelings (optional)" rows="3" style="width:100%;box-sizing:border-box"></textarea><button type="button" style="margin-top:8px;padding:10px">Fill &amp; Submit Journal</button><p role="status" aria-live="polite"></p>';
     document.body.appendChild(panel);
     const controls = document.createElement('div');
     controls.innerHTML = '<label>Subject <select data-subject aria-label="Journal subject"><option value="">Detect from page</option><option>Backend Development Fundamentals</option><option>Computer Organization and Architecture</option><option>Advanced Data Structures</option><option>Linear Algebra Essentials</option><option>Fundamentals of Artificial Intelligence</option></select></label><label>Module / Journal <select data-number aria-label="Journal number"><option value="">Detect from page</option>' + Array.from({ length: 10 }, (_, i) => `<option value="${i + 1}">${i + 1}</option>`).join('') + '</select></label>';
@@ -140,6 +143,93 @@ function browserAssistantJournal(global) {
         select.style.cssText = 'display:block;width:100%;padding:5px;color:#17233d;background:white;border:1px solid #abb3c3';
     panel.insertBefore(controls, panel.querySelector('textarea'));
     const status = panel.querySelector('[role=status]'), button = panel.querySelector('button');
+    const countdown = panel.querySelector('[data-countdown]');
+    const countdownKey = 'assistantJournalTimer';
+    const journalPath = location.pathname.replace(/\/$/, '');
+    const journalDeadlineKey = `${countdownKey}:${journalPath}`;
+    let deadline;
+    let lastPortalTime = null;
+    let observedInForeground = false;
+    let publishedDeadline;
+    let journalConfirmed = false;
+    async function loadCountdown() {
+        try {
+            const cached = sessionStorage.getItem(journalDeadlineKey);
+            if (cached && Number.isFinite(Number(cached))) {
+                deadline = Number(cached);
+                renderCountdown(null);
+                return;
+            }
+        }
+        catch { /* Fall back to extension storage. */ }
+        try {
+            const data = await global.chrome?.storage?.local.get([journalDeadlineKey, countdownKey]);
+            const latest = data?.[countdownKey];
+            const saved = data?.[journalDeadlineKey] ?? (latest?.path?.replace(/\/$/, '') === journalPath ? latest.deadline : undefined);
+            if (deadline === undefined && Number.isFinite(saved)) {
+                deadline = saved;
+                renderCountdown(null);
+            }
+        }
+        catch { /* The portal clock remains available if extension storage is unavailable. */ }
+    }
+    function renderCountdown(portalTime) {
+        const seconds = portalTime ?? (deadline === undefined ? null : Math.max(0, Math.ceil((deadline - Date.now()) / 1000)));
+        const label = portalTime === null ? 'Estimated time left' : 'Portal time left';
+        const restoringDraft = portalTime === null && /Unsaved draft detected\./i.test(document.body.innerText || pageText(document));
+        const clockText = seconds === null ? 'Waiting for the portal timer to appear' : `${label} ${formatJournalTime(seconds)}`;
+        const text = restoringDraft
+            ? `${clockText}. To reopen your draft, review the declaration and use the portal’s Accept Terms to Start button.`
+            : seconds === null ? `${clockText}.` : clockText;
+        if (countdown.textContent !== text)
+            countdown.textContent = text;
+    }
+    async function recordJournalConfirmation() {
+        if (!journalConfirmed && (controller.getState().completed === 1 || [...document.querySelectorAll('p,h1,h2,h3,[role=status],[role=alert]')].some(node => !node.closest('#assistant-root,#assistant-journal,[contenteditable]') && node.getClientRects().length &&
+            /^(?:journal (?:has been )?submitted successfully|journal submission successful)[.!]?$/i.test(node.textContent.trim())))) {
+            try {
+                await global.chrome?.storage?.local.set({ [`assistantJournalConfirmed:${journalPath}`]: true });
+                journalConfirmed = true;
+            }
+            catch { /* Retry on the next tick while the confirmation is available. */ }
+        }
+    }
+    async function updateCountdown() {
+        if (!document.contains(panel) || storageKey !== `assistantJournal:${location.pathname}`)
+            return;
+        const observed = remainingSeconds(document);
+        // The editor can briefly render zero before the active clock loads.
+        const portalTime = observed === 0 && lastPortalTime === null ? null : observed;
+        const visible = !document.hidden;
+        const returnedToJournal = visible && !observedInForeground;
+        observedInForeground = visible;
+        if (portalTime !== null && portalTime !== lastPortalTime) {
+            deadline = Date.now() + portalTime * 1000;
+            lastPortalTime = portalTime;
+            // Keep the observed deadline through an immediate same-tab reload,
+            // even if the extension storage write is still in flight.
+            try {
+                sessionStorage.setItem(journalDeadlineKey, String(deadline));
+            }
+            catch { }
+        }
+        renderCountdown(portalTime);
+        if (!visible || portalTime === null || deadline === undefined ||
+            (!returnedToJournal && publishedDeadline !== undefined && Math.abs(deadline - publishedDeadline) <= 2000))
+            return;
+        const pendingDeadline = deadline;
+        publishedDeadline = pendingDeadline;
+        try {
+            await global.chrome?.storage?.local.set({
+                [journalDeadlineKey]: pendingDeadline,
+                [countdownKey]: { path: journalPath, deadline: pendingDeadline },
+            });
+        }
+        catch {
+            if (publishedDeadline === pendingDeadline)
+                publishedDeadline = undefined;
+        }
+    }
     button.title = 'Fill & Submit Journal (Alt + Shift + J)';
     button.setAttribute('aria-keyshortcuts', 'Alt+Shift+J');
     const shortcutHint = document.createElement('p');
@@ -319,7 +409,7 @@ function browserAssistantJournal(global) {
             if (remaining === null || remaining > 30 * 60) {
                 waitingForTimer = true;
                 const time = remaining === null ? 'Waiting for the portal timer to become readable.'
-                    : `Current timer: ${String(Math.floor(remaining / 60)).padStart(2, '0')}:${String(remaining % 60).padStart(2, '0')}.`;
+                    : `Current timer: ${formatJournalTime(remaining)}.`;
                 status.textContent = `${count} words ready. Waiting to submit at 30:00 remaining. ${time}`;
                 return;
             }
@@ -447,6 +537,14 @@ function browserAssistantJournal(global) {
         }
     });
     refreshInfo();
+    void loadCountdown();
+    void updateCountdown();
+    const clockObserver = global.MutationObserver ? new global.MutationObserver(records => {
+        if (records.some(({ target }) => !(target.nodeType === 1 ? target : target.parentElement)?.closest('#assistant-root,#assistant-journal'))) {
+            void updateCountdown();
+        }
+    }) : null;
+    clockObserver?.observe(document.body, { subtree: true, childList: true, characterData: true });
     controller.mount(document.getElementById('assistant-journal-slot'));
     document.dispatchEvent(new global.Event('assistant-journal-ready'));
     try {
@@ -460,27 +558,20 @@ function browserAssistantJournal(global) {
     // Poll only the journal page; field discovery never changes platform restrictions.
     const timer = setInterval(() => {
         if (global.BrowserAssistantJournal?.current !== controller && global.BrowserAssistantJournal) {
-            clearInterval(timer);
-            document.removeEventListener('keydown', shortcutListener, true);
+            stopWatching();
             return;
         }
-        if (!document.contains(panel)) {
+        if (!document.contains(panel) || storageKey !== `assistantJournal:${location.pathname}`) {
             draft = null;
             global.BrowserAssistantJournalBusy = false;
-            document.removeEventListener('keydown', shortcutListener, true);
-            clearInterval(timer);
-            return;
-        }
-        if (!/^\/modules\/reflective-journal\//.test(location.pathname) || storageKey !== `assistantJournal:${location.pathname}`) {
-            draft = null;
-            global.BrowserAssistantJournalBusy = false;
-            document.removeEventListener('keydown', shortcutListener, true);
-            clearInterval(timer);
+            stopWatching();
             panel.remove();
             return;
         }
         if (!info)
             refreshInfo();
+        void updateCountdown();
+        void recordJournalConfirmation();
         notify();
         if (draft && !submitting && !starting) {
             const run = generation;
@@ -499,6 +590,11 @@ function browserAssistantJournal(global) {
             });
         }
     }, 1000);
+    function stopWatching() {
+        clearInterval(timer);
+        clockObserver?.disconnect();
+        document.removeEventListener('keydown', shortcutListener, true);
+    }
 }
 if (typeof window !== 'undefined' && location.origin === 'https://admissions.aurora.edu.in') {
     window.BrowserAssistantJournal = window.BrowserAssistantJournal || {
@@ -552,7 +648,36 @@ if (typeof window !== 'undefined' && location.origin === 'https://admissions.aur
 browserAssistantJournal(typeof window === 'undefined' ? globalThis : window);
 if (typeof window !== 'undefined' && location.origin === 'https://admissions.aurora.edu.in' && !window.BrowserAssistantJournalBoot) {
     window.BrowserAssistantJournalBoot = true;
+    let lastDeadline;
+    const storage = window.chrome?.storage?.local;
+    let clockChanged = false;
+    function updateJournalListClock() {
+        const clock = document.getElementById('assistant-journal-list-clock');
+        if (!clock)
+            return;
+        clock.hidden = /^\/modules\/reflective-journal\//.test(location.pathname) || !Number.isFinite(lastDeadline);
+        if (!clock.hidden) {
+            const seconds = Math.max(0, Math.ceil((lastDeadline - Date.now()) / 1000));
+            clock.textContent = `Last journal · Estimated time left ${formatJournalTime(seconds)}`;
+        }
+    }
+    function loadJournalListClock(saved) {
+        lastDeadline = typeof saved === 'object' && saved !== null && 'deadline' in saved && typeof saved.deadline === 'number'
+            ? saved.deadline : undefined;
+        updateJournalListClock();
+    }
+    storage?.onChanged?.addListener(changes => {
+        if (!Object.hasOwn(changes, 'assistantJournalTimer'))
+            return;
+        clockChanged = true;
+        loadJournalListClock(changes.assistantJournalTimer.newValue);
+    });
+    void storage?.get('assistantJournalTimer').then(data => {
+        if (!clockChanged)
+            loadJournalListClock(data.assistantJournalTimer);
+    }).catch(() => { });
     setInterval(() => {
+        updateJournalListClock();
         if (/^\/modules\/reflective-journal\//.test(location.pathname) && !document.getElementById('assistant-journal'))
             browserAssistantJournal(window);
     }, 1000);

package/extension/manifest.json

@@ -1,13 +1,14 @@
 {
     "manifest_version": 3,
     "name": "Browser Assistant",
-  "version": "2.8.6",
+    "version": "2.8.21",
     "description": "Scans webpages for MCQs and coding problems. Powered by Groq (cloud) and Ollama (local fallback).",
     "permissions": [
         "activeTab",
         "scripting",
         "tabs",
         "clipboardWrite",
+        "storage",
         "alarms"
     ],
     "background": {

package/extension/popup.html

@@ -39,6 +39,11 @@
         #server-status { color: #f59e0b; }
         #server-status.online { color: #10b981; }
         #server-status.offline { color: #ef4444; }
+        #journal-reminder { margin: 10px 0; font-size: 11px; }
+        #journal-reminder summary { cursor: pointer; }
+        #journal-reminder label { display: block; margin: 7px 0; }
+        #journal-reminder input { box-sizing: border-box; width: 100%; }
+        #journal-reminder-status { margin-top: 6px; }
     </style>
 </head>
 <body>
@@ -48,6 +53,17 @@
     </div>
     <p>Extension active. The floating panel appears on every page.</p>
     <div class="status">Server: <span id="server-status">checking...</span></div>
+    <p id="journal-countdown" hidden></p>
+    <details id="journal-reminder">
+        <summary>WhatsApp journal reminder</summary>
+        <form id="journal-reminder-form">
+            <label>n8n production webhook URL<input id="journal-webhook-url" type="url" required></label>
+            <label>Webhook token<input id="journal-webhook-token" type="password" required autocomplete="off"></label>
+            <button type="submit">Enable</button>
+            <button type="button" id="journal-reminder-disable">Disable</button>
+        </form>
+        <p id="journal-reminder-status" role="status">Checking settings…</p>
+    </details>
     <div class="shortcuts">
         <div class="shortcut-row"><span>Open panel</span> <kbd>`</kbd></div>
         <div class="shortcut-row"><span>Close panel</span> <kbd>]</kbd></div>

package/extension/popup.js

@@ -17,3 +17,79 @@ new Promise((resolve, reject) => {
     el.textContent = 'offline';
     el.className = 'offline';
 });
+const journalCountdown = document.getElementById('journal-countdown');
+let journalTimers = [];
+function showJournalCountdown() {
+    const now = Date.now();
+    const times = journalTimers.filter(timer => timer.deadline > now).map(timer => {
+        const seconds = Math.ceil((timer.deadline - now) / 1000);
+        return `${String(Math.floor(seconds / 60)).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`;
+    });
+    journalCountdown.hidden = !times.length;
+    journalCountdown.textContent = times.length ? `Journal time left ≈ ${times.join(' · ')}` : '';
+}
+const journalTimerStorage = chrome.storage.local;
+let journalTimerRevision = 0;
+async function refreshPopupJournalTimers() {
+    const request = ++journalTimerRevision;
+    try {
+        const timers = await chrome.runtime.sendMessage({ action: 'journalCountdowns' });
+        if (request !== journalTimerRevision)
+            return;
+        journalTimers = Array.isArray(timers) ? timers : [];
+        showJournalCountdown();
+    }
+    catch { /* A closed popup no longer needs an update. */ }
+}
+journalTimerStorage.onChanged.addListener(changes => {
+    if (Object.keys(changes).some(key => key.startsWith('assistantJournalTimer') || key.startsWith('assistantJournalConfirmed:'))) {
+        void refreshPopupJournalTimers();
+    }
+});
+void refreshPopupJournalTimers();
+setInterval(showJournalCountdown, 1000);
+const reminderForm = document.querySelector('#journal-reminder-form');
+if (reminderForm) {
+    const key = 'assistantJournalReminderConfig';
+    const urlInput = document.querySelector('#journal-webhook-url');
+    const tokenInput = document.querySelector('#journal-webhook-token');
+    const status = document.getElementById('journal-reminder-status');
+    const disable = document.querySelector('#journal-reminder-disable');
+    void journalTimerStorage.get(key).then(data => {
+        const config = data[key];
+        if (config)
+            urlInput.value = config.url;
+        status.textContent = config ? 'Reminder enabled.' : 'Reminder disabled.';
+    }).catch(() => { status.textContent = 'Could not load reminder settings.'; });
+    reminderForm.addEventListener('submit', async (event) => {
+        event.preventDefault();
+        try {
+            const url = new URL(urlInput.value);
+            const local = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+            if (!(url.protocol === 'https:' || (local && url.protocol === 'http:')) || url.username || url.password ||
+                url.search || url.hash || !url.pathname.includes('/webhook/')) {
+                throw Error('Enter the n8n production webhook URL. Use HTTPS for remote n8n.');
+            }
+            const token = tokenInput.value.trim();
+            if (!/^[\x21-\x7e]{20,256}$/.test(token))
+                throw Error('Use a webhook token of at least 20 characters, with no spaces.');
+            await journalTimerStorage.set({ [key]: { url: url.href, token } });
+            tokenInput.value = '';
+            status.textContent = 'Reminder enabled.';
+        }
+        catch (error) {
+            status.textContent = error.message;
+        }
+    });
+    disable.addEventListener('click', async () => {
+        try {
+            await journalTimerStorage.remove(key);
+            urlInput.value = '';
+            tokenInput.value = '';
+            status.textContent = 'Reminder disabled.';
+        }
+        catch {
+            status.textContent = 'Could not disable reminder.';
+        }
+    });
+}

package/extension/styles.css

@@ -1,5 +1,22 @@
 /* Browser Assistant – Styles v2.0 */
 
+#assistant-journal-countdown-badge {
+    all: initial;
+    position: fixed;
+    bottom: 16px;
+    left: 16px;
+    z-index: 2147483647;
+    padding: 8px 12px;
+    border: 1px solid #a78bfa;
+    border-radius: 999px;
+    background: #20163b;
+    color: #fff;
+    font: 600 13px/1.3 system-ui, sans-serif;
+    font-variant-numeric: tabular-nums;
+    pointer-events: none;
+    user-select: none;
+}
+
 #assistant-root {
     position: fixed;
     top: 20px;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-assistant",
-  "version": "2.8.6",
+  "version": "2.8.21",
   "description": "Chrome extension and local Python backend for exploring webpage questions and coding exercises",
   "license": "MIT",
   "repository": {

package/server/main.py

@@ -24,7 +24,7 @@ from fastapi.exception_handlers import http_exception_handler
 from local_security import install_local_guards, redact, sanitize_data
 from vision_images import (compress_image_base64, unique_image_blocks, collect_image_evidence,
                            cross_check_visual_answers, relative_percentage_question, RELATIVE_PERCENTAGE_INSTRUCTION,
-                           answer_permutation, cross_check_text_answers, solve_matrix_choice,
+                           answer_permutation, cross_check_text_answers, solve_matrix_choice, solve_row_parallel_choice,
                            VisionRateLimitError, VisionUnconfirmedError)
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
@@ -191,7 +191,7 @@ async def lifespan(_app: FastAPI):
             client.close()
 
 
-app = FastAPI(title="Browser Assistant API", version="2.8.6", lifespan=lifespan)
+app = FastAPI(title="Browser Assistant API", version="2.8.21", lifespan=lifespan)
 install_local_guards(app)
 
 @app.exception_handler(HTTPException)
@@ -1191,10 +1191,14 @@ async def review_and_correct_code(
 
 # ── Routes ────────────────────────────────────────────────────────────────────
 
-def calculated_matrix_result(text, language):
+def local_choice_result(text, language):
     item = solve_matrix_choice(text)
+    provider = "local matrix calculation"
+    if item is None:
+        item = solve_row_parallel_choice(text)
+        provider = "local tensor dimension check"
     if item is not None:
-        return {"results": json.dumps([item], ensure_ascii=False), "provider": "local matrix calculation [verified]",
+        return {"results": json.dumps([item], ensure_ascii=False), "provider": f"{provider} [verified]",
                 "language": language, "answer_verified": True, "code_reviewed": False}
 
 
@@ -1241,13 +1245,13 @@ REPAIR MODE:
     strict_code_review = require_code and (content.review_before_submit or not FAST_CODE_MODE or STRICT_REPAIR_REVIEW)
     verify_answers = not require_code and (content.verify_answer or not FAST_SCAN_MODE)
     if not require_code and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
-        matrix_result = calculated_matrix_result(trimmed_text, language)
-        if matrix_result is not None:
-            return matrix_result
+        local_result = local_choice_result(trimmed_text, language)
+        if local_result is not None:
+            return local_result
 
     async def confirm_answers(cleaned, source_model=None):
         if not verify_answers or not any(item['type'] == 'mcq' for item in json.loads(cleaned)):
-            return False
+            return cleaned, False
 
         async def independent_solve(prompt_messages):
             if source_model is None:
@@ -1261,14 +1265,14 @@ REPAIR MODE:
             return await try_groq(prompt_messages, model=source_model, temperature=0.0)
 
         try:
-            await cross_check_text_answers(messages, cleaned, independent_solve)
+            checked = await cross_check_text_answers(messages, cleaned, independent_solve, question_text=trimmed_text)
         except Exception as exc:
             if isinstance(exc, VisionUnconfirmedError):
                 message = str(exc)
             else:
                 message = 'An independent solve was unavailable.'
             raise HTTPException(422, detail={'code': 'answer_unconfirmed', 'message': message}) from exc
-        return True
+        return checked, True
 
     # Try each Groq text model in the fallback chain
     for model_id in TEXT_MODELS:
@@ -1294,7 +1298,7 @@ REPAIR MODE:
             )
             if cleaned != "[]":
                 logger.info(f"Groq ({model_id}) returned a validated result ({len(cleaned)} characters)")
-                verified = await confirm_answers(cleaned, model_id)
+                cleaned, verified = await confirm_answers(cleaned, model_id)
                 return {"results": cleaned, "provider": f"groq ({model_id})" + (' [cross-checked]' if verified else ''),
                         "language": language, "answer_verified": verified,
                         "code_reviewed": strict_code_review and language != 'web'}
@@ -1330,7 +1334,7 @@ REPAIR MODE:
             starter_code=content.starter_code,
         )
         if cleaned != "[]":
-            verified = await confirm_answers(cleaned)
+            cleaned, verified = await confirm_answers(cleaned)
             return {
                 "results": cleaned,
                 "provider": f"ollama ({OLLAMA_MODEL})" + (' [cross-checked]' if verified else ''),
@@ -1409,9 +1413,9 @@ async def _solve_vision(content: VisionContent):
             raise HTTPException(422, f'Image {index}: {exc}') from exc
     is_code_scan = content.practice_type == "code" or (content.practice_type == "auto" and bool(content.language))
     if not is_code_scan and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
-        matrix_result = calculated_matrix_result(content.text, content.language or CODE_DEFAULT_LANGUAGE)
-        if matrix_result is not None:
-            return matrix_result
+        local_result = local_choice_result(content.text, content.language or CODE_DEFAULT_LANGUAGE)
+        if local_result is not None:
+            return local_result
     image_blocks, image_positions = unique_image_blocks(compressed)
 
     clients = tuple(_groq_clients)

package/server/vision_images.py

@@ -196,21 +196,61 @@ def numeric_matrix_key(value):
     return None
 
 
-def matrix_2x2(value):
+def numeric_matrix(value):
     rows = matrix_cells(value)
-    if not rows or len(rows) != 2 or any(len(row) != 2 for row in rows):
+    if not rows or any(len(row) != len(rows[0]) for row in rows):
         return None
     entries = []
-    for cell in (cell for row in rows for cell in row):
-        cell = re.sub(r'^([+-]?)\\(?:[dt]?frac)\{([+-]?\d{1,15})\}\{(\d{1,15})\}$',
-                      r'\1\2/\3', cell)
-        if not re.fullmatch(rf'(?:{DECIMAL_VALUE}|[+-]?\d{{1,15}}/\d{{1,15}})', cell):
-            return None
-        try:
-            entries.append(Fraction(cell))
-        except ZeroDivisionError:
+    for row in rows:
+        numbers = []
+        for cell in row:
+            cell = re.sub(r'^([+-]?)\\(?:[dt]?frac)\{([+-]?\d{1,15})\}\{(\d{1,15})\}$', r'\1\2/\3', cell)
+            if not re.fullmatch(rf'(?:{DECIMAL_VALUE}|[+-]?\d{{1,15}}/\d{{1,15}})', cell):
+                return None
+            try:
+                numbers.append(Fraction(cell))
+            except ZeroDivisionError:
+                return None
+        entries.append(numbers)
+    return entries
+
+
+def matrix_2x2(value):
+    rows = numeric_matrix(value)
+    if rows and len(rows) == 2 and len(rows[0]) == 2:
+        return tuple(rows[0] + rows[1])
+
+
+def rref_pivot_count(matrix):
+    rows = numeric_matrix(matrix)
+    if not rows:
+        return None
+    previous = -1
+    count = 0
+    for index, row in enumerate(rows):
+        column = next((col for col, entry in enumerate(row) if entry), None)
+        if column is None:
+            # Any remaining rows must also be zero.
+            return None if any(any(later) for later in rows[index + 1:]) else count
+        if column <= previous or row[column] != 1 or any(other[column] for i, other in enumerate(rows) if i != index):
             return None
-    return tuple(entries)
+        previous = column
+        count += 1
+    return count
+
+
+def parse_labeled_choices(option_text):
+    lines = ('A.' + option_text).splitlines()
+    if not 2 <= len(lines) <= 26:
+        return {}
+    choices = {}
+    for index, line in enumerate(lines):
+        letter = chr(ord('A') + index)
+        option = re.fullmatch(rf'{letter}\.\s*(\S.*)', line)
+        if not option:
+            return {}
+        choices[letter] = option[1]
+    return choices
 
 
 def solve_matrix_choice(text):
@@ -231,6 +271,10 @@ def solve_matrix_choice(text):
         r'([A-Z]) with shape \(\s*([a-z])\s*,\s*([a-z])\s*\),\s*'
         r'which condition must hold for the product (\1\4|\4\1) to be defined\?', prompt,
     )
+    pivots = re.fullmatch(
+        r'How many (?:pivot(?: position)?s) does the following (?:RREF|reduced row echelon form) matrix have\?\s*(.+)',
+        prompt, flags=re.I,
+    )
     if inverse:
         entries = matrix_2x2(inverse[2])
         if entries is None:
@@ -254,23 +298,26 @@ def solve_matrix_choice(text):
             return frozenset(equation.groups()) if equation else None
 
         reasoning = f'The left matrix has {left_cols} columns and the right matrix has {right_rows} rows. These must be equal.'
+    elif pivots:
+        expected = rref_pivot_count(pivots[1])
+        if expected is None:
+            return None
+
+        def parse_option(value):
+            count = re.fullmatch(r'\d{1,5}', unwrap_math(value))
+            return int(count[0]) if count else None
+
+        reasoning = f'Each nonzero row in reduced row echelon form has one leading 1. There are {expected} such rows.'
     else:
         return None
 
-    lines = ('A.' + option_text).splitlines()
-    if not 2 <= len(lines) <= 26:
-        return None
     matches = []
-    for index, line in enumerate(lines):
-        letter = chr(ord('A') + index)
-        option = re.fullmatch(rf'{letter}\.\s*(\S.*)', line)
-        if not option:
-            return None
-        value = parse_option(option[1])
+    for letter, option in parse_labeled_choices(option_text).items():
+        value = parse_option(option)
         if value is None:
             return None
         if value == expected:
-            matches.append(f'Option {letter}: {option[1]}')
+            matches.append(f'Option {letter}: {option}')
     if len(matches) != 1:
         return None
     return {'type': 'mcq', 'question': question, 'answer': matches[0], 'reasoning': reasoning}
@@ -326,7 +373,56 @@ def parse_answer_check(raw, count):
     return answers
 
 
-async def cross_check_text_answers(messages, results, complete):
+def displayed_single_choices(text):
+    question, separator, option_text = text.strip().rpartition('\nA.')
+    if not separator or not re.search(r'\n(?:Question format: )?Select one answer\.$', question, re.I):
+        return {}
+    return parse_labeled_choices(option_text)
+
+
+def solve_row_parallel_choice(text):
+    """Check the shared multiplication dimension in a row-parallel linear layer."""
+    choices = displayed_single_choices(text)
+    if not choices:
+        return None
+    question = re.split(r'\n(?:Question format: )?Select one answer\.', text.strip(), maxsplit=1, flags=re.I)[0]
+    prompt = ' '.join(question.split())
+    if not re.fullmatch(r'In row(?:[- ]tensor)? parallelism, why must the input also be split, not just the weights\?',
+                        prompt, flags=re.I):
+        return None
+    matches = [(letter, option) for letter, option in choices.items() if re.fullmatch(
+        r'(?:so that )?the input (?:shape|feature dimension) matches the (?:corresponding )?weight (?:rows|shard)\.?', option, re.I)]
+    if len(matches) != 1:
+        return None
+    letter, option = matches[0]
+    return {
+        'type': 'mcq', 'question': question, 'answer': f'Option {letter}: {option}',
+        'reasoning': 'In Y = XW, rows of W index input features. Each GPU needs the corresponding columns of X '
+                     'so the inner dimensions match. The GPUs sum their partial products.',
+    }
+
+
+def bind_displayed_choice(value, choices, *, matrix_math):
+    if type(value) not in (str, int, float):
+        return None
+    answer = str(value).strip()
+
+    def key(text):
+        return normalize_checked_answer(text, matrix_math=matrix_math)
+
+    labeled = re.fullmatch(r'(?:Option\s+)?([A-Z])\s*[:.)]\s*(\S.*)', answer, re.I)
+    if labeled:
+        letter, body = labeled[1].upper(), labeled[2]
+        return letter if letter in choices and key(choices[letter]) == key(body) else None
+    matches = [letter for letter, body in choices.items() if key(body) == key(answer)]
+    letter_only = re.fullmatch(r'(?:Option\s+)?([A-Z])\s*[:.)]?', answer, re.I)
+    if letter_only and letter_only[1].upper() in choices:
+        matches.append(letter_only[1].upper())
+    unique = set(matches)
+    return unique.pop() if len(unique) == 1 else None
+
+
+async def cross_check_text_answers(messages, results, complete, *, question_text=''):
     items = json.loads(results)
     if not items or any(item.get('type') != 'mcq' for item in items):
         raise VisionUnconfirmedError('Verification requires a complete set of question answers.')
@@ -340,22 +436,42 @@ async def cross_check_text_answers(messages, results, complete):
         'If the information is incomplete or any answer is uncertain, return {"readable":false,"answers":[]}.'
     )
     check_messages = [{'role': 'system', 'content': instruction}, *messages[1:]]
+    matrix_math = matrix_question(messages)
+    choices = displayed_single_choices(question_text) if len(items) == 1 else {}
+
+    def answer_key(entries):
+        if choices:
+            return bind_displayed_choice(entries[0].get('answer'), choices, matrix_math=matrix_math)
+        keys = tuple(normalize_checked_answer(item.get('answer'), matrix_math=matrix_math) for item in entries)
+        return keys if all(keys) else None
+
+    first = answer_key(items)
+    previous = None
     for attempt in range(2):
         raw = await complete(check_messages)
         try:
             verified = parse_answer_check(raw, len(items))
+            current = answer_key(verified)
+        except ValueError:
+            current = None
+        if current is not None and (current == first or current == previous):
+            if choices:
+                if current != first:
+                    items[0].pop('reasoning', None)
+                items[0]['answer'] = f'Option {current}: {choices[current]}'
+                return json.dumps(items, ensure_ascii=False)
+            return results
+        if not choices and current is not None:
             break
-        except ValueError as exc:
-            if attempt:
-                raise VisionUnconfirmedError('The independent solve could not verify every answer after retrying.') from exc
+        if not attempt:
+            previous = current
             check_messages = [*check_messages, {
                 'role': 'user',
                 'content': 'Solve again using the original question and options. Return the full verification JSON with the required ids.',
             }]
-    matrix_math = matrix_question(messages)
-    first = [normalize_checked_answer(item['answer'], matrix_math=matrix_math) for item in items]
-    if not all(first) or first != [normalize_checked_answer(item['answer'], matrix_math=matrix_math) for item in verified]:
-        raise VisionUnconfirmedError('The two solves disagreed on at least one answer.')
+    if current is None and previous is None:
+        raise VisionUnconfirmedError('The independent solve could not verify every answer after retrying.')
+    raise VisionUnconfirmedError('The independent solves could not agree on the displayed answer.')
 
 
 async def cross_check_visual_answers(messages, results, model, complete, comparison=None, *, require_agreement=False):