~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
fix(logpanel): preserve warnings/errors when cap prunes the log (#4900)
Sefdf31a1ae0d
diff --git a/changelog.d/+logpanel-per-category-prune.bugfix.md b/changelog.d/+logpanel-per-category-prune.bugfix.mdnew file mode 100644index 0000000000..0f0dca4603--- /dev/null+++ b/changelog.d/+logpanel-per-category-prune.bugfix.md@@ -0,0 +1 @@+When the Research Logs panel hits its 500-entry DOM cap, the oldest entries are flushed first — which previously meant old warnings and errors got dropped even when the cap was blown by a flood of routine info entries. The prune now walks the cap-excess slots in priority order (info first, then milestones, then warnings, then errors), so the panel keeps its most diagnostic entries even on long research runs.diff --git a/src/local_deep_research/web/static/js/components/logpanel.js b/src/local_deep_research/web/static/js/components/logpanel.jsindex 65dc04d2ab..a87d9ae790 100644--- a/src/local_deep_research/web/static/js/components/logpanel.js+++ b/src/local_deep_research/web/static/js/components/logpanel.js@@ -477,6 +477,73 @@return await response.json();}+ /**+ * Trim log entries from the container down to `cap`, preferring to drop+ * the least-actionable categories first.+ *+ * The plain "remove from head" prune loses the panel's most diagnostic+ * entries — old warnings and errors get flushed even when the cap was+ * blown by a flood of routine info entries. Walk the DOM and, for each+ * excess slot, drop the oldest entry whose type is in the currently-+ * removable category (info, then milestone). Once those are exhausted,+ * fall back to dropping warnings, then errors, in age order.+ *+ * Trade-off: ordered pruning means surviving entries are no longer+ * strictly the newest N — an early error can sit among hundreds of+ * newer info entries. That is intentional: warnings/errors are the+ * most diagnostic categories and should outlive routine info spam+ * during a long research run.+ *+ * Only `.ldr-console-log-entry` children are pruned; transient+ * placeholders such as `.ldr-empty-log-message`,+ * `.ldr-loading-spinner`, and `.ldr-error-message` (which can+ * briefly co-exist with log entries during async loads) are left+ * alone.+ *+ * @param {Element} container - The log container element.+ * @param {number} cap - The maximum allowed entry count after pruning.+ * @returns {string[]} The categories of removed entries, in removal+ * order. Each element corresponds to one DOM removal. Callers can+ * consume the return value to keep an external per-category counter+ * in sync without re-querying the DOM.+ */+ const PRUNE_REMOVABLE_ORDER = Object.freeze(['info', 'milestone', 'warning', 'error']);+ function pruneToCap(container, cap) {+ const removed = [];+ while (true) {+ // Re-query every iteration: each remove() mutates the live+ // NodeList, so a cached handle would go stale.+ const entries = container.querySelectorAll('.ldr-console-log-entry');+ if (entries.length <= cap) break;+ let dropped = null;+ for (const targetType of PRUNE_REMOVABLE_ORDER) {+ for (const entry of entries) {+ const type = (entry.dataset.logType || 'info').toLowerCase();+ if (type === targetType) {+ dropped = entry;+ break;+ }+ }+ if (dropped) break;+ }+ // Defensive fallback — should be unreachable because every log+ // entry is created via createLogEntryElement which sets+ // dataset.logType, but if some non-log child slipped through+ // somehow, drop the oldest of those to guarantee forward+ // progress.+ if (!dropped) {+ const fallback = entries[0];+ if (!fallback) break;+ removed.push((fallback.dataset.logType || 'info').toLowerCase());+ fallback.remove();+ continue;+ }+ removed.push(dropped.dataset.logType.toLowerCase());+ dropped.remove();+ }+ return removed;+ }+/*** Load logs for a specific research* @param {string} researchId - The research ID to load logs for@@ -700,10 +767,10 @@}logContent.appendChild(fragment);- // Prune oldest entries (at DOM start, since oldest-first ordering)- while (logContent.children.length > MAX_LOG_ENTRIES) {- logContent.firstElementChild.remove();- }+ // Prune to the cap, preferring to drop info/milestone entries over+ // warnings/errors so the panel keeps its diagnostic entries+ // even after a long research run flushes the head.+ pruneToCap(logContent, MAX_LOG_ENTRIES);// Reset and recompute per-category counts from the DOM// after the batch insert + prune. Counting off the DOM@@ -1035,23 +1102,22 @@}// Prune oldest entries if over limit to prevent unbounded DOM growth.- // DOM order is oldest -> newest, so the oldest entries sit at the- // head of the NodeList.- const entries = consoleLogContainer.querySelectorAll('.ldr-console-log-entry');- if (entries.length > MAX_LOG_ENTRIES) {- const toRemove = entries.length - MAX_LOG_ENTRIES;- for (let i = 0; i < toRemove; i++) {- // Read the log type before removing so we can decrement- // the matching per-category count for the per-filter- // badges. Unknown types default to 'info' to match the- // createLogEntryElement fallback below.- const prunedType = (entries[i].dataset.logType || 'info').toLowerCase();- entries[i].remove();+ // Prefer to drop the least-actionable categories first (info, then+ // milestones, then warnings, then errors) so a long research run+ // doesn't flush the panel's diagnostic tail. Mirrors the batch-load+ // prune above.+ const removed = pruneToCap(consoleLogContainer, MAX_LOG_ENTRIES);+ if (removed.length > 0) {+ // Keep the per-category counter for the filter badges in sync+ // with what was actually removed. pruneToCap returns the+ // categories in removal order, so we can decrement directly+ // without re-querying the DOM for each entry's type.+ for (const prunedType of removed) {if (window._logPanelState.counts[prunedType] !== undefined) {window._logPanelState.counts[prunedType]--;}}- updateLogCounter(-toRemove);+ updateLogCounter(-removed.length);updateFilterCounters();}@@ -1222,7 +1288,10 @@initialize: initializeLogPanel,addLog: addConsoleLog,filterLogs: filterLogsByType,- loadLogs: loadLogsForResearch+ loadLogs: loadLogsForResearch,+ // Exposed for unit tests so the per-category prune ordering can be+ // exercised in isolation from the rest of the panel pipeline.+ _pruneToCap: pruneToCap};// Self-invoke to initialize when DOM content is loadeddiff --git a/tests/js/components/logpanel.test.js b/tests/js/components/logpanel.test.jsindex 4825b01064..a18e3ea2f2 100644--- a/tests/js/components/logpanel.test.js+++ b/tests/js/components/logpanel.test.js@@ -142,11 +142,14 @@ function setupPanelDom({ page = 'progress', researchId } = {}) {logPanel.initialize(rid);}-function makeLiveEntry(message) {- // Mimic what addLogEntryToPanel produces in the DOM.+function makeLiveEntry(message, type = 'info') {+ // Mimic what addLogEntryToPanel produces in the DOM. The optional+ // `type` argument lets the per-category prune tests seed entries+ // of a specific category into the container directly.const entry = document.createElement('div');entry.className = 'ldr-console-log-entry';entry.dataset.logId = `live-${message}`;+ entry.dataset.logType = type;const span = document.createElement('span');span.className = 'ldr-log-message';span.textContent = message;@@ -431,7 +434,14 @@ describe('addLog / loadLogs — ordering invariants', () => {// it while the timer bug was still the root cause. The test must fill// to the real MAX_LOG_ENTRIES cap to exercise the prune, so the work// can't be reduced without weakening the assertion.- it('prunes the oldest entries when count exceeds MAX_LOG_ENTRIES', { timeout: 20000 }, () => {+ // Note: this is the all-info case. With all-info inserts the new+ // per-category prune ordering is observationally identical to the+ // old head-drop behavior (info is dropped first, so the oldest info+ // entry is what comes off the head). Per-category prune ordering --+ // the part the priority order actually changes -- is exercised by+ // the `pruneToCap -- per-category ordered prune` describe block+ // lower in this file.+ it('drops the oldest info entry when the cap is exceeded by info-only inserts', { timeout: 20000 }, () => {const container = document.getElementById('console-log-container');// One insert over the cap. The live-insert prune in@@ -1003,3 +1013,151 @@ describe('per-category counters', () => {expect(getFilterCount('all')).toBe(4);});});++describe('pruneToCap — per-category ordered prune', () => {+ function seedEntry(container, message, type, index) {+ const entry = makeLiveEntry(message, type);+ // logpanel.js sorts by dataset.logTimeMs for chronological ordering.+ // We use a synthetic timestamp so insertion order matches DOM order.+ entry.dataset.logTimeMs = String(index);+ container.appendChild(entry);+ return entry;+ }++ it('drops info entries before any other category', () => {+ const container = document.getElementById('console-log-container');+ // 3 info + 1 warning + 1 error; cap=2.+ seedEntry(container, 'info-0', 'info', 0);+ seedEntry(container, 'info-1', 'info', 1);+ seedEntry(container, 'info-2', 'info', 2);+ seedEntry(container, 'warn-0', 'warning', 3);+ seedEntry(container, 'err-0', 'error', 4);++ const removed = logPanel._pruneToCap(container, 2);++ // 3 removals needed (5 -> 2). All should be info entries.+ expect(removed.length).toBe(3);+ for (const r of removed) expect(r).toBe('info');+ expect(container.children.length).toBe(2);+ // The warning and error must survive.+ const survivingTypes = Array.from(container.children).map(+ (c) => c.dataset.logType+ );+ expect(survivingTypes).toEqual(['warning', 'error']);+ });++ it('drops milestone entries after info is exhausted', () => {+ const container = document.getElementById('console-log-container');+ seedEntry(container, 'info-0', 'info', 0);+ seedEntry(container, 'info-1', 'info', 1);+ seedEntry(container, 'milestone-0', 'milestone', 2);+ seedEntry(container, 'warn-0', 'warning', 3);+ seedEntry(container, 'err-0', 'error', 4);++ // cap=2 -> need 3 removals. 2 info first, then the milestone.+ const removed = logPanel._pruneToCap(container, 2);++ expect(removed).toEqual(['info', 'info', 'milestone']);+ expect(container.children.length).toBe(2);+ const surviving = Array.from(container.children).map(+ (c) => c.dataset.logType+ );+ expect(surviving).toEqual(['warning', 'error']);+ });++ it('preserves old warnings and errors even when the cap is blown by a flood of info', () => {+ const container = document.getElementById('console-log-container');+ // 1 early error, 1 early warning, then 1000 info entries.+ seedEntry(container, 'early-error', 'error', 0);+ seedEntry(container, 'early-warning', 'warning', 1);+ for (let i = 0; i < 1000; i++) {+ seedEntry(container, `info-${i}`, 'info', 2 + i);+ }++ // cap=200. We need to drop 1002 - 200 = 802 entries. The two+ // diagnostic entries are the oldest, but the ordered prune must+ // protect them: all 802 drops must be info entries.+ const removed = logPanel._pruneToCap(container, 200);++ expect(removed.length).toBe(802);+ expect(removed.every((r) => r === 'info')).toBe(true);+ expect(container.children.length).toBe(200);+ const survivingMessages = Array.from(+ container.querySelectorAll('.ldr-log-message')+ ).map((el) => el.textContent);+ expect(survivingMessages).toContain('early-error');+ expect(survivingMessages).toContain('early-warning');+ });++ it('falls back to dropping warnings then errors when no info/milestone are left', () => {+ const container = document.getElementById('console-log-container');+ seedEntry(container, 'warn-0', 'warning', 0);+ seedEntry(container, 'warn-1', 'warning', 1);+ seedEntry(container, 'err-0', 'error', 2);++ // cap=1 -> need 2 removals. No info/milestone, so fall back to+ // dropping the oldest warning first, then the next oldest+ // warning, before touching the error. Errors are the most+ // diagnostic category, so they're the last to be dropped.+ const removed = logPanel._pruneToCap(container, 1);++ expect(removed).toEqual(['warning', 'warning']);+ expect(container.children.length).toBe(1);+ expect(container.firstElementChild.dataset.logType).toBe('error');+ expect(+ container.firstElementChild.querySelector('.ldr-log-message')+ .textContent+ ).toBe('err-0');+ });++ it('is a no-op when already under the cap', () => {+ const container = document.getElementById('console-log-container');+ seedEntry(container, 'info-0', 'info', 0);+ seedEntry(container, 'err-0', 'error', 1);++ const removed = logPanel._pruneToCap(container, 10);++ expect(removed).toEqual([]);+ expect(container.children.length).toBe(2);+ });+++ it('ignores placeholder children (.ldr-empty-log-message / spinner / error) when pruning', () => {+ const container = document.getElementById('console-log-container');+ // Simulate the loadLogsForResearch moment where a transient+ // spinner is still in the container alongside incoming entries.+ const spinner = document.createElement('div');+ spinner.className = 'ldr-loading-spinner';+ spinner.textContent = 'Loading...';+ container.appendChild(spinner);++ // Seed one of every category so each priority bucket is exercised.+ seedEntry(container, 'info-A', 'info', 0);+ seedEntry(container, 'milestone-A', 'milestone', 1);+ seedEntry(container, 'warn-A', 'warning', 2);+ seedEntry(container, 'err-A', 'error', 3);++ // Cap of 2 means 2 of the 4 log entries must be dropped.+ // The helper must walk the priority order (info, milestone,+ // warning, error) AND must NOT count or remove the placeholder.+ // If it had counted the spinner, only one entry would be+ // dropped and the test would fail on .removed.length.+ const removed = logPanel._pruneToCap(container, 2);++ expect(removed).toEqual(['info', 'milestone']);+ // Placeholder is left in place; entry nodes are kept too.+ expect(container.querySelector('.ldr-loading-spinner')).toBe(spinner);+ const survivingLogEntries =+ container.querySelectorAll('.ldr-console-log-entry');+ expect(survivingLogEntries.length).toBe(2);+ expect(survivingLogEntries[0].dataset.logType).toBe('warning');+ expect(survivingLogEntries[1].dataset.logType).toBe('error');+ // Total DOM children = surviving 2 entries + 1 placeholder.+ expect(container.children.length).toBe(3);+ expect(container.children[0]).toBe(spinner);+ });++ // The "no-op when already under the cap" case is covered by+ // `it('is a no-op when already under the cap', ...)` above; no+ // need to duplicate it here.+});