9268fc3e · permissionBRICK/SillyTavern

     #skew = 0;
     /**
 -     * @type {number} The starting depth of the global scan depth. Incremented by "min activations" feature to not repeat scans. When > 0 it means a complete scan was done up to #startDepth already, and `advanceScanPosition` was called.
 +     * @type {number} The starting depth of the global scan depth.
      */
     #startDepth = 0;

@@ -222,12 +222,12 @@ class WorldInfoBuffer {
222	222	}
223	223
224	224	if (depth < 0) {
225	225	console.error(`[WI] Invalid WI scan depth ${depth}. Must be >= 0`);
226	226	return '';
227	227	}
228	228
229	229	if (depth > MAX_SCAN_DEPTH) {
230	230	console.warn(`[WI] Invalid WI scan depth ${depth}. Truncating to ${MAX_SCAN_DEPTH}`);
231	231	depth = MAX_SCAN_DEPTH;
232	232	}
233	233

+    }
     /**
      * IncrementsChecks skewif andthe setsrecursion startDepthbuffer tois previousnot depthempty.
 +     * @returns {boolean} Returns true if the recursion buffer is not empty, otherwise false
      */
     advanceScanPositionhasRecurse() {
         return this.#startDepthrecurseBuffer.length => this.getDepth()0;
 +    }
++
 +    /**
 +     * Increments skew to advance the scan range.
 +     */
 +    advanceScan() {
         this.#skew++;
+    }

             const key = this.#getEntryKey(entry);
             const effect = this.#getEntryTimedEffect('cooldown', entry, true);
             chat_metadata.timedWorldInfo.cooldown[key] = effect;
             console.log(`[WI] Adding cooldown entry ${key} on ended sticky: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);
             // Set the cooldown immediately for this evaluation
             this.#buffer.cooldown.push(entry);
         },

          * @param {WIScanEntry} entry Entry that ended cooldown
          */
         'cooldown': (entry) => {
             console.debug('[WI] Cooldown ended for entry', entry.uid);
         },
         'delay': () => { },
     };
     /**

         /** @type {[string, WITimedEffect][]} */
         const effects = Object.entries(chat_metadata.timedWorldInfo[type]);
         for (const [key, value] of effects) {
             console.log(`[WI] Processing ${type} entry ${key}`, value);
             const entry = this.#entries.find(x => String(this.#getEntryHash(x)) === String(value.hash));
             if (this.#chat.length <= Number(value.start) && !value.protected) {
                 console.log(`[WI] Removing ${type} entry ${key} from timedWorldInfo: chat not advanced`, value);
                 delete chat_metadata.timedWorldInfo[type][key];
                 continue;
+            }

             // Missing entries (they could be from another character's lorebook)
             if (!entry) {
                 if (this.#chat.length >= Number(value.end)) {
                     console.log(`[WI] Removing ${type} entry from timedWorldInfo: entry not found and interval passed`, entry);
                     delete chat_metadata.timedWorldInfo[type][key];
+                }
                 continue;

             // Ignore invalid entries (not configured for timed effects)
             if (!entry[type]) {
                 console.log(`[WI] Removing ${type} entry from timedWorldInfo: entry not ${type}`, entry);
                 delete chat_metadata.timedWorldInfo[type][key];
                 continue;
+            }
             if (this.#chat.length >= Number(value.end)) {
                 console.log(`[WI] Removing ${type} entry from timedWorldInfo: ${type} interval passed`, entry);
                 delete chat_metadata.timedWorldInfo[type][key];
                 if (typeof onEnded === 'function') {
                     onEnded(entry);

@@ -572,7 +579,7 @@ class WorldInfoTimedEffects {
572	579	}
573	580
574	581	buffer.push(entry);
575	582	console.log(`[WI] Timed effect "${type}" applied to entry`, entry);
576	583	}
577	584	}
578	585

@@ -588,7 +595,7 @@ class WorldInfoTimedEffects {
588	595
589	596	if (this.#chat.length < entry.delay) {
590	597	buffer.push(entry);
591	598	console.log('[WI] Timed effect "delay" applied to entry', entry);
592	599	}
593	600	}
594	601

@@ -635,7 +642,7 @@ class WorldInfoTimedEffects {
635	642	const effect = this.#getEntryTimedEffect(type, entry, false);
636	643	chat_metadata.timedWorldInfo[type][key] = effect;
637	644
638	645	console.log(`[WI] Adding ${type} entry ${key}: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);
639	646	}
640	647	}
641	648

@@ -667,7 +674,7 @@ class WorldInfoTimedEffects {
667	674	if (newState) {
668	675	const effect = this.#getEntryTimedEffect(type, entry, false);
669	676	chat_metadata.timedWorldInfo[type][key] = effect;
670	677	console.log(`[WI] Adding ${type} entry ${key}: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);
671	678	}
672	679	}
673	680

 async function getCharacterLore() {
     const character = characters[this_chid];
     const name = character?.name;
 +    /** @type {Set<string>} */
     let worldsToSearch = new Set();
     const baseWorldName = character?.data?.extensions?.world;
     if (baseWorldName) {
         worldsToSearch.add(baseWorldName);
 -    } else {
 -        console.debug(`Character ${name}'s base world could not be found or is empty! Skipping...`);
+    }
     // TODO: Maybe make the utility function not use the window context?

         worldsToSearch = new Set([...worldsToSearch, ...extraCharLore.extraBooks]);
+    }
 +    if (!worldsToSearch.size) {
 +        return [];
 +    }
++
     let entries = [];
     for (const worldName of worldsToSearch) {
         if (selected_world_info.includes(worldName)) {
             console.debug(`[WI] Character ${name}'s world ${worldName} is already activated in global world info! Skipping...`);
             continue;
+        }
         if (chat_metadata[METADATA_KEY] === worldName) {
             console.debug(`[WI] Character ${name}'s world ${worldName} is already activated in chat lore! Skipping...`);
             continue;
+        }
         const data = await loadWorldInfoData(worldName);
         const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(x({ uid, ...rest }) => ({ ...xuid, world: worldName, ...rest })) : [];
         entries = entries.concat(newEntries);
++
 +        if (!newEntries.length) {
 +            console.debug(`[WI] Character ${name}'s world ${worldName} could not be found or is empty`);
 +        }
+    }
     console.debug(`[WI] Character ${name}'s lore (${Array.from(worldsToSearch)}) has ${entries.length} world info entries`, [...worldsToSearch]);
     return entries;
+}
 async function getGlobalLore() {
     if (!selected_world_info?.length) {
         return [];
+    }
     let entries = [];
     for (const worldName of selected_world_info) {
         const data = await loadWorldInfoData(worldName);
         const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(x({ uid, ...rest }) => ({ ...xuid, world: worldName, ...rest })) : [];
         entries = entries.concat(newEntries);
+    }
     console.debug(`[WI] Global world info has ${entries.length} entries`, selected_world_info);
     return entries;
+}

@@ -3481,14 +3495,14 @@ async function getChatLore() {
3481	3495	}
3482	3496
3483	3497	if (selected_world_info.includes(chatWorld)) {
3484	3498	console.debug(`[WI] Chat world ${chatWorld} is already activated in global world info! Skipping...`);
3485	3499	return [];
3486	3500	}
3487	3501
3488	3502	const data = await loadWorldInfoData(chatWorld);
3489	3503	const entries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(x({ uid, ...rest }) => ({ ...xuid, world: chatWorld, ...rest })) : [];
3490	3504
3491	3505	console.debug(`[WI] Chat lore has ${entries.length} entries`, [chatWorld]);
3492	3506
3493	3507	return entries;
3494	3508	}

                 entries = [...globalLore.sort(sortFn), ...characterLore.sort(sortFn)];
                 break;
             default:
                 console.error('[WI] Unknown WI insertion strategy: ', world_info_character_strategy, 'defaulting to evenly');
                 entries = [...globalLore, ...characterLore].sort(sortFn);
                 break;
+        }

         // Chat lore always goes first
         entries = [...chatLore.sort(sortFn), ...entries];
         console.debug(`Sorted[WI] Found ${entries.length} world lore entries. usingSorted by strategy`, ${Object.entries(world_info_insertion_strategy).find((x) => x[1] === world_info_character_strategy}`));
         // Need to deep clone the entries to avoid modifying the cached data
         return structuredClone(entries);

     const context = getContext();
     const buffer = new WorldInfoBuffer(chat);
 +    console.debug(`[WI] --- START WI SCAN (on ${chat.length} messages) ---`);
++
     // Combine the chat
     // Add the depth or AN if enabled

     let budget = Math.round(world_info_budget * maxContext / 100) || 1;
     if (world_info_budget_cap > 0 && budget > world_info_budget_cap) {
         console.debug(`[WI] Budget ${budget} exceeds cap ${world_info_budget_cap}, using cap`);
         budget = world_info_budget_cap;
+    }
     console.debug(`[WI] Context size: ${maxContext}; WI budget: ${budget} (max% = ${world_info_budget}%, cap = ${world_info_budget_cap})`);
     const sortedEntries = await getSortedEntries();
     const timedEffects = new WorldInfoTimedEffects(chat, sortedEntries);

         return { worldInfoBefore: '', worldInfoAfter: '', WIDepthEntries: [], EMEntries: [], allActivatedEntries: new Set() };
+    }
 +    console.debug(`[WI] --- SEARCHING ENTRIES (on ${sortedEntries.length} entries) ---`);
++
     while (scanState) {
         // Track how many times the loop has run. May be useful for debugging.
 -        // eslint-disable-next-line no-unused-vars
         count++;
 +        console.debug(`[WI] Loop #${count}. Search state`, Object.entries(scan_state).find(x => x[1] === scanState));
++
 +        // Until decided otherwise, we set the loop to stop scanning after this
 +        let nextScanState = scan_state.NONE;
++
 +        // Loop and find all entries that can activate here
         let activatedNow = new Set();
         for (let entry of sortedEntries) {
 +            // Logging preparation
 +            let headerLogged = false;
 +            function log(...args) {
 +                if (!headerLogged) {
 +                    console.debug(`[WI] Entry ${entry.uid}`, `from '${entry.world}' processing`, entry);
 +                    headerLogged = true;
 +                }
 +                console.debug(`[WI] Entry ${entry.uid}`, ...args);
 +            }
++
 +            // Already processed, considered and then skipped entries should still be skipped
 +            if (failedProbabilityChecks.has(entry) || allActivatedEntries.has(entry)) {
 +                continue;
 +            }
++
 +            if (entry.disable == true) {
 +                log('disabled');
 +                continue;
 +            }
++
             // Check if this entry applies to the character or if it's excluded
             if (entry.characterFilter && entry.characterFilter?.names?.length > 0) {
                 const nameIncluded = entry.characterFilter.names.includes(getCharaFilename());
                 const filtered = entry.characterFilter.isExclude ? nameIncluded : !nameIncluded;
                 if (filtered) {
                     console.debuglog(`WI entry ${entry.uid} 'filtered out by character`');
                     continue;
+                }
+            }

@@ -3611,7 +3654,7 @@ async function checkWorldInfo(chat, maxContext, isDryRun) {
3611	3654	const filtered = entry.characterFilter.isExclude ? includesTag : !includesTag;
3612	3655
3613	3656	if (filtered) {
3614	3657	console.debuglog(`WI entry ${entry.uid} 'filtered out by tag`');
3615	3658	continue;
3616	3659	}
3617	3660	}

             const isDelay = timedEffects.isEffectActive('delay', entry);
             if (isDelay) {
 -                console.debug(`WI entry ${entry.uid} suppressed by delay`, entry);
 +                log('suppressed by delay');
                 continue;
+            }
             if (isCooldown && !isSticky) {
 -                console.debug(`WI entry ${entry.uid} suppressed by cooldown`, entry);
 +                log('suppressed by cooldown');
                 continue;
+            }
 -            if (failedProbabilityChecks.has(entry)) {
 +            // Only use checks for recursion flags if the scan step was activated by recursion
 +            if (scanState !== scan_state.RECURSION && entry.delayUntilRecursion) {
 +                log('suppressed by delay until recursion');
                 continue;
+            }
 -            if (allActivatedEntries.has(entry) || entry.disable == true) {
 +            if (scanState === scan_state.RECURSION && world_info_recursive && entry.excludeRecursion) {
 +                log('suppressed by exclude recursion');
                 continue;
+            }
 -            // Only use checks for recursion flags if the scan step was activated by recursion
 +            // Now do checks for immediate activations
             if (scanState !== scan_state.RECURSION && entry.delayUntilRecursionconstant) {
 -                console.debug(`WI entry ${entry.uid} suppressed by delay until recursion`, entry);
 +                log('activated because of constant');
 +                activatedNow.add(entry);
                 continue;
+            }
 -            if (scanState === scan_state.RECURSION && world_info_recursive && entry.excludeRecursion) {
 +            if (buffer.isExternallyActivated(entry)) {
 -                console.debug(`WI entry ${entry.uid} suppressed by exclude recursion`, entry);
 +                log('externally activated');
 +                activatedNow.add(entry);
                 continue;
+            }
 -            if (entry.constant || buffer.isExternallyActivated(entry) || isSticky) {
 +            if (isSticky) {
 +                log('activated because active sticky');
                 activatedNow.add(entry);
                 continue;
+            }
             if (!Array.isArray(entry.key) &&|| !entry.key.length) { //check for keywords existing
 -                // If selectiveLogic isn't found, assume it's AND, only do this once per entry
 +                log('has no keys defined, skipped');
 -                const selectiveLogic = entry.selectiveLogic ?? 0;
 +                continue;
+-
 +            }
 -                primary: for (let key of entry.key) {
 -                    const substituted = substituteParams(key);
 -                    const textToScan = buffer.get(entry, scanState);
+-
 -                    if (substituted && buffer.matchKeys(textToScan, substituted.trim(), entry)) {
 -                        console.debug(`WI UID ${entry.uid} found by primary match: ${substituted}.`);
+-
 -                        //selective logic begins
 -                        if (
 -                            entry.selective && //all entries are selective now
 -                            Array.isArray(entry.keysecondary) && //always true
 -                            entry.keysecondary.length //ignore empties
 -                        ) {
 -                            console.debug(`WI UID:${entry.uid} found. Checking logic: ${entry.selectiveLogic}`);
 -                            let hasAnyMatch = false;
 -                            let hasAllMatch = true;
 -                            secondary: for (let keysecondary of entry.keysecondary) {
 -                                const secondarySubstituted = substituteParams(keysecondary);
 -                                const hasSecondaryMatch = secondarySubstituted && buffer.matchKeys(textToScan, secondarySubstituted.trim(), entry);
 -                                console.debug(`WI UID:${entry.uid}: Filtering for secondary keyword - "${secondarySubstituted}".`);
+-
 -                                if (hasSecondaryMatch) {
 -                                    hasAnyMatch = true;
 -                                }
+-
 -                                if (!hasSecondaryMatch) {
 -                                    hasAllMatch = false;
 -                                }
+-
 -                                // Simplified AND ANY / NOT ALL if statement. (Proper fix for PR#1356 by Bronya)
 -                                // If AND ANY logic and the main checks pass OR if NOT ALL logic and the main checks do not pass
 -                                if ((selectiveLogic === world_info_logic.AND_ANY && hasSecondaryMatch) || (selectiveLogic === world_info_logic.NOT_ALL && !hasSecondaryMatch)) {
 -                                    // Differ both logic statements in the debugger
 -                                    if (selectiveLogic === world_info_logic.AND_ANY) {
 -                                        console.debug(`(AND ANY Check) Activating WI Entry ${entry.uid}. Found match for word: ${substituted} ${secondarySubstituted}`);
 -                                    } else {
 -                                        console.debug(`(NOT ALL Check) Activating WI Entry ${entry.uid}. Found match for word "${substituted}" without secondary keyword: ${secondarySubstituted}`);
 -                                    }
 -                                    activatedNow.add(entry);
 -                                    break secondary;
 -                                }
 -                            }
 -                            // Handle NOT ANY logic
 +            // Cache the text to scan before the loop, it won't change its content
 -                            if (selectiveLogic === world_info_logic.NOT_ANY && !hasAnyMatch) {
 +            const textToScan = buffer.get(entry, scanState);
 -                                console.debug(`(NOT ANY Check) Activating WI Entry ${entry.uid}, no secondary keywords found.`);
 -                                activatedNow.add(entry);
 -                            }
 -                            // Handle AND ALL logic
 +            // PRIMARY KEYWORDS
 -                            if (selectiveLogic === world_info_logic.AND_ALL && hasAllMatch) {
 +            let primaryKeyMatch = entry.key.find(key => {
 -                                console.debug(`(AND ALL Check) Activating WI Entry ${entry.uid}, all secondary keywords found.`);
 +                const substituted = substituteParams(key);
 -                                activatedNow.add(entry);
 +                return substituted && buffer.matchKeys(textToScan, substituted.trim(), entry);
 -                            }
 +            });
 -                        } else {
++
 -                            // Handle cases where secondary is empty
 +            if (!primaryKeyMatch) {
 -                            console.debug(`WI UID ${entry.uid}: Activated without filter logic.`);
 +                // Don't write logs for simple no-matches
 -                            activatedNow.add(entry);
 +                continue;
 -                            break primary;
 +            }
 -                        }
++
 +            const hasSecondaryKeywords = (
 +                entry.selective && //all entries are selective now
 +                Array.isArray(entry.keysecondary) && //always true
 +                entry.keysecondary.length //ignore empties
 +            );
++
 +            if (!hasSecondaryKeywords) {
 +                // Handle cases where secondary is empty
 +                log('activated by primary key match', primaryKeyMatch);
 +                activatedNow.add(entry);
 +                continue;
 +            }
++
++
 +            // SECONDARY KEYWORDS
 +            const selectiveLogic = entry.selectiveLogic ?? 0; // If selectiveLogic isn't found, assume it's AND, only do this once per entry
 +            log('Entry with primary key match', primaryKeyMatch, 'has secondary keywords. Checking with logic logic', Object.entries(world_info_logic).find(x => x[1] === entry.selectiveLogic));
++
 +            /** @type {() => boolean} */
 +            function matchSecondaryKeys() {
 +                let hasAnyMatch = false;
 +                let hasAllMatch = true;
 +                for (let keysecondary of entry.keysecondary) {
 +                    const secondarySubstituted = substituteParams(keysecondary);
 +                    const hasSecondaryMatch = secondarySubstituted && buffer.matchKeys(textToScan, secondarySubstituted.trim(), entry);
++
 +                    if (hasSecondaryMatch) hasAnyMatch = true;
 +                    if (!hasSecondaryMatch) hasAllMatch = false;
++
 +                    // Simplified AND ANY / NOT ALL if statement. (Proper fix for PR#1356 by Bronya)
 +                    // If AND ANY logic and the main checks pass OR if NOT ALL logic and the main checks do not pass
 +                    if (selectiveLogic === world_info_logic.AND_ANY && hasSecondaryMatch) {
 +                        log('activated. (AND ANY) Found match secondary keyword', secondarySubstituted);
 +                        return true;
+                    }
 +                    if (selectiveLogic === world_info_logic.NOT_ALL && !hasSecondaryMatch) {
 +                        log('activated. (NOT ALL) Found not matching secondary keyword', secondarySubstituted);
 +                        return true;
 +                    }
 +                }
++
 +                // Handle NOT ANY logic
 +                if (selectiveLogic === world_info_logic.NOT_ANY && !hasAnyMatch) {
 +                    log('activated. (NOT ANY) No secondary keywords found', entry.keysecondary);
 +                    return true;
 +                }
++
 +                // Handle AND ALL logic
 +                if (selectiveLogic === world_info_logic.AND_ALL && hasAllMatch) {
 +                    log('activated. (AND ALL) All secondary keywords found', entry.keysecondary);
 +                    return true;
+                }
++
 +                return false;
+            }
++
 +            const matched = matchSecondaryKeys();
 +            if (!matched) {
 +                log('skipped. Secondary keywords not satisfied', entry.keysecondary);
 +                continue;
 +            }
++
 +            // Success logging was already done inside the function, so just add the entry
 +            activatedNow.add(entry);
 +            continue;
+        }
 -        scanState = world_info_recursive && activatedNow.size > 0 ? scan_state.RECURSION : scan_state.NONE;
 +        console.debug(`[WI] Search done. Found ${activatedNow.size} possible entries.`);
         const newEntries = [...activatedNow]
             .sort((a, b) => sortedEntries.indexOf(a) - sortedEntries.indexOf(b));
         let newContent = '';
         const textToScanTokens = await getTokenCountAsync(allActivatedText);
 -        const probabilityChecksBefore = failedProbabilityChecks.size;
         filterByInclusionGroups(newEntries, allActivatedEntries, buffer, scanState);
         console.debug('[WI] --- PROBABILITY CHECKS BEGIN ---');
         for (const entry of newEntries) {
 -            const rollValue = Math.random() * 100;
 +            function verifyProbability() {
 +                // If we don't need to roll, it's always true
 +                if (!entry.useProbability || entry.probability === 100) {
 +                    console.debug(`WI entry ${entry.uid} does not use probability`);
 +                    return true;
 +                }
 -            if (entry.useProbability && rollValue > entry.probability) {
                 const isSticky = timedEffects.isEffectActive('sticky', entry);
                 if (!isSticky) {
                     console.debug(`WI entry ${entry.uid} ${entry.key}is failedsticky, probabilitydoes check,not skippingneed to re-roll probability`);
 -                    failedProbabilityChecks.add(entry);
 +                    return true;
 -                    continue;
 +                }
++
 +                const rollValue = Math.random() * 100;
 +                if (rollValue <= entry.probability) {
 +                    console.debug(`WI entry ${entry.uid} passed probability check of ${entry.probability}%`);
 +                    return true;
+                }
 -            } else { console.debug(`uid:${entry.uid} passed probability check, inserting to prompt`); }
++
 +                failedProbabilityChecks.add(entry);
 +                return false;
 +            }
++
 +            const success = verifyProbability();
 +            if (!success) {
 +                console.debug(`WI entry ${entry.uid} failed probability check, removing from activated entries`, entry);
 +                continue;
 +            }
             // Substitute macros inline, for both this checking and also future processing
             entry.content = substituteParams(entry.content);
             newContent += `${entry.content}\n`;
             if ((textToScanTokens + (await getTokenCountAsync(newContent))) >= budget) {
 -                console.debug('WI budget reached, stopping');
                 if (world_info_overflow_alert) {
 -                    console.log('Alerting');
 +                    console.warn(`[WI] budget of ${budget} reached, stopping after ${allActivatedEntries.size} entries`);
                     toastr.warning(`World info budget reached after ${allActivatedEntries.size} entries.`, 'World Info');
 +                } else {
 +                    console.debug(`[WI] budget of ${budget} reached, stopping after ${allActivatedEntries.size} entries`);
+                }
 -                scanState = scan_state.NONE;
                 token_budget_overflowed = true;
                 break;
+            }
             allActivatedEntries.add(entry);
             console.debug('`[WI] Entry ${entry.uid} activated:'activation successful, adding to prompt`, entry);
+        }
         const probabilityChecksAftersuccessfulNewEntries = newEntries.filter(x => !failedProbabilityChecks.sizehas(x));
 +        const successfulNewEntriesForRecursion = successfulNewEntries.filter(x => !x.preventRecursion);
 -        if ((probabilityChecksAfter - probabilityChecksBefore) === activatedNow.size) {
 +        if (!newEntries.length) {
             console.debug('[WI probability checks] failedNo fornew allentries activated entries, stopping');
 -            scanState = scan_state.NONE;
 +        } else if (!successfulNewEntries.length) {
 +            console.debug('[WI] Probability checks failed for all activated entries, stopping');
 +        } else {
 +            console.debug(`[WI] Successfully activated ${successfulNewEntries.length} new entries to prompt. ${allActivatedEntries.size} total entries activated.`, successfulNewEntries);
+        }
 -        if (newEntries.length === 0) {
 +        // After processing and rolling entries is done, see if we should continue with normal recursion
 -            console.debug('No new entries activated, stopping');
 +        if (world_info_recursive && !token_budget_overflowed && successfulNewEntriesForRecursion.length) {
             scanStatenextScanState = scan_state.NONERECURSION;
+        }
 -        if (scanState) {
 +        // If we are inside min activations scan, and we have recursive buffer, we should do a recursive scan before increasing the buffer again
 -            const text = newEntries
 +        // There might be recurse-trigger-able entries that match the buffer, so we need to check that
 -                .filter(x => !failedProbabilityChecks.has(x))
 +        if (world_info_recursive && !token_budget_overflowed && scanState === scan_state.MIN_ACTIVATIONS && buffer.hasRecurse()) {
 -                .filter(x => !x.preventRecursion)
 +            nextScanState = scan_state.RECURSION;
 -                .map(x => x.content).join('\n');
 -            buffer.addRecurse(text);
 -            allActivatedText = (text + '\n' + allActivatedText);
+        }
 -        // world_info_min_activations
 +        // If scanning is planned to stop, but min activations is set and not satisfied, check if we should continue
 -        if (!scanState && !token_budget_overflowed) {
 +        const minActivationsNotSatisfied = world_info_min_activations > 0 && (allActivatedEntries.size < world_info_min_activations);
                     if (world_info_min_activations > 0!nextScanState && (allActivatedEntries.size!token_budget_overflowed <&& world_info_min_activations)minActivationsNotSatisfied) {
 -                let over_max = (
 +            console.debug('[WI] --- MIN ACTIVATIONS CHECK ---');
 -                    world_info_min_activations_depth_max > 0 &&
 -                    buffer.getDepth() > world_info_min_activations_depth_max
 -                ) || (buffer.getDepth() > chat.length);
 -                if (!over_max) {
 +            let over_max = (
 -                    scanState = scan_state.MIN_ACTIVATIONS; // loop
 +                world_info_min_activations_depth_max > 0 &&
 -                    buffer.advanceScanPosition();
 +                buffer.getDepth() > world_info_min_activations_depth_max
 -                }
 +            ) || (buffer.getDepth() > chat.length);
++
 +            if (!over_max) {
 +                console.debug(`[WI] Min activations not reached (${allActivatedEntries.size}/${world_info_min_activations}), advancing depth to ${buffer.getDepth() + 1} and checking again`);
 +                nextScanState = scan_state.MIN_ACTIVATIONS; // loop
 +                buffer.advanceScan();
 +            } else {
 +                console.debug(`[WI] Min activations not reached (${allActivatedEntries.size}/${world_info_min_activations}), but reached on of depth. Stopping`);
+            }
+        }
++
 +        // Final check if we should really continue scan, and extend the current WI recurse buffer
 +        scanState = nextScanState;
 +        if (scanState) {
 +            const text = successfulNewEntriesForRecursion
 +                .map(x => x.content).join('\n');
 +            buffer.addRecurse(text);
 +            allActivatedText = (text + '\n' + allActivatedText);
 +        }
+    }
 +    console.debug('[WI] --- BUILDING PROMPT ---');
++
     // Forward-sorted list of entries for joining
     const WIBeforeEntries = [];
     const WIAfterEntries = [];

         const content = getRegexedString(entry.content, regex_placement.WORLD_INFO, { depth: regexDepth, isMarkdown: false, isPrompt: true });
         if (!content) {
             console.debug('Skipping adding `[WI] Entry ${entry.uid}`, 'skipped adding to prompt due to empty content:', entry);
             return;
+        }

     buffer.resetExternalEffects();
     timedEffects.cleanUp();
 +    console.log(`[WI] Adding ${allActivatedEntries.size} entries to prompt`, Array.from(allActivatedEntries));
 +    console.debug('[WI] --- DONE ---');
++
     return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, allActivatedEntries };
+}

     for (const [key, group] of Object.entries(groups)) {
         // Group scoring is disabled both globally and for the group entries
         if (!world_info_use_group_scoring && !group.some(x => x.useGroupScoring)) {
             console.debug(`[WI] Skipping group scoring for group '${key}'`);
             continue;
+        }
         const scores = group.map(entry => buffer.getScore(entry, scanState));
         const maxScore = Math.max(...scores);
         console.debug(`[WI] Group '${key}' max score:`, ${maxScore}`);
         //console.table(group.map((entry, i) => ({ uid: entry.uid, key: JSON.stringify(entry.key), score: scores[i] })));
         for (let i = 0; i < group.length; i++) {

+            }
             if (scores[i] < maxScore) {
                 console.debug(`Removing[WI] Entry ${group[i].uid}`, `removed as score loser from inclusion group '${key}' entry '${group[i].uid}'`, group[i]);
                 removeEntry(group[i]);
                 group.splice(i, 1);
                 scores.splice(i, 1);

  * @param {number} scanState The current scan state
  */
 function filterByInclusionGroups(newEntries, allActivatedEntries, buffer, scanState) {
     console.debug('[WI] --- INCLUSION GROUP CHECKS BEGIN ---');
++
     const grouped = newEntries.filter(x => x.group).reduce((acc, item) => {
         item.group.split(/,\s*/).filter(x => x).forEach(group => {
             if (!acc[group]) {

     }, {});
     if (Object.keys(grouped).length === 0) {
         console.debug('[WI] No inclusion groups found');
         return;
+    }

@@ -3948,7 +4051,7 @@ function filterByInclusionGroups(newEntries, allActivatedEntries, buffer, scanSt
3948	4051	continue;
3949	4052	}
3950	4053
3951	4054	if (logging) console.debug(`Removing[WI] Entry ${entry.uid}`, `removed as loser from inclusion group '${entry.group}' entry '${entry.uid}'`, entry);
3952	4055	removeEntry(entry);
3953	4056	}
3954	4057	}

     filterGroupsByScoring(grouped, buffer, removeEntry, scanState);
     for (const [key, group] of Object.entries(grouped)) {
         console.debug(`[WI] Checking inclusion group '${key}' with ${group.length} entries`, group);
         if (Array.from(allActivatedEntries).some(x => x.group === key)) {
             console.debug(`[WI] Skipping inclusion group check, group already activated '${key}' was already activated`);
             // We need to forcefully deactivate all other entries in the group
             removeAllBut(group, null, false);
             continue;
+        }
         if (!Array.isArray(group) || group.length <= 1) {
             console.debug('[WI] Skipping inclusion group check, only one entry');
             continue;
+        }
         // Check for group prio
         const prios = group.filter(x => x.groupOverride).sort(sortFn);
         if (prios.length) {
             console.debug(`Activated inclusion[WI] groupEntry '${keyprios[0].uid}'`, with`activated byas prio winner entryfrom inclusion group '${prios[0].uidkey}'`, prios[0]);
             removeAllBut(group, prios[0]);
             continue;
+        }

@@ -3988,14 +4091,14 @@ function filterByInclusionGroups(newEntries, allActivatedEntries, buffer, scanSt
3988	4091	currentWeight += (entry.groupWeight ?? DEFAULT_WEIGHT);
3989	4092
3990	4093	if (rollValue <= currentWeight) {
3991	4094	console.debug(`Activated inclusion[WI] groupEntry '${keyentry.uid}'`, with`activated as roll winner entryfrom inclusion group '${entry.uidkey}'`, entry);
3992	4095	winner = entry;
3993	4096	break;
3994	4097	}
3995	4098	}
3996	4099
3997	4100	if (!winner) {
3998	4101	console.debug(`[WI] Failed to activate inclusion group '${key}', no winner found`);
3999	4102	continue;
4000	4103	}
4001	4104

Merge pull request #2479 from SillyTavern/wi-processing-refactoring WI scan refactoring: Extended logging, updated code flow, changed Min Activations