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	if (depth < 0) {	224	if (depth < 0) {
225	console.error(`Invalid WI scan depth ${depth}. Must be >= 0`);	225	console.error(`[WI] Invalid WI scan depth ${depth}. Must be >= 0`);
226	return '';	226	return '';
227	}	227	}
228		228
229	if (depth > MAX_SCAN_DEPTH) {	229	if (depth > MAX_SCAN_DEPTH) {
230	console.warn(`Invalid WI scan depth ${depth}. Truncating to ${MAX_SCAN_DEPTH}`);	230	console.warn(`[WI] Invalid WI scan depth ${depth}. Truncating to ${MAX_SCAN_DEPTH}`);
231	depth = MAX_SCAN_DEPTH;	231	depth = MAX_SCAN_DEPTH;
232	}	232	}
233		233

+    }
     /**
-     * Increments skew and sets startDepth to previous depth.
+     * Checks if the recursion buffer is not empty.
+     * @returns {boolean} Returns true if the recursion buffer is not empty, otherwise false
      */
-    advanceScanPosition() {
+    hasRecurse() {
-        this.#startDepth = this.getDepth();
+        return this.#recurseBuffer.length > 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(`Adding cooldown entry ${key} on ended sticky: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);
+            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('Cooldown ended for entry', entry.uid);
+            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(`Processing ${type} entry ${key}`, value);
+            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(`Removing ${type} entry ${key} from timedWorldInfo: chat not advanced`, value);
+                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(`Removing ${type} entry from timedWorldInfo: entry not found and interval passed`, entry);
+                    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(`Removing ${type} entry from timedWorldInfo: entry not ${type}`, entry);
+                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(`Removing ${type} entry from timedWorldInfo: ${type} interval passed`, entry);
+                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	buffer.push(entry);	581	buffer.push(entry);
575	console.log(`Timed effect "${type}" applied to entry`, entry);	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	if (this.#chat.length < entry.delay) {	596	if (this.#chat.length < entry.delay) {
590	buffer.push(entry);	597	buffer.push(entry);
591	console.log('Timed effect "delay" applied to entry', entry);	598	console.log('[WI] Timed effect "delay" applied to entry', entry);
592	}	599	}
593	}	600	}
594		601

@@ -635,7 +642,7 @@ class WorldInfoTimedEffects {
635	const effect = this.#getEntryTimedEffect(type, entry, false);	642	const effect = this.#getEntryTimedEffect(type, entry, false);
636	chat_metadata.timedWorldInfo[type][key] = effect;	643	chat_metadata.timedWorldInfo[type][key] = effect;
637		644
638	console.log(`Adding ${type} entry ${key}: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);	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	if (newState) {	674	if (newState) {
668	const effect = this.#getEntryTimedEffect(type, entry, false);	675	const effect = this.#getEntryTimedEffect(type, entry, false);
669	chat_metadata.timedWorldInfo[type][key] = effect;	676	chat_metadata.timedWorldInfo[type][key] = effect;
670	console.log(`Adding ${type} entry ${key}: start=${effect.start}, end=${effect.end}, protected=${effect.protected}`);	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?

@@ -3435,40 +3441,48 @@ async function getCharacterLore() {
3435	worldsToSearch = new Set([...worldsToSearch, ...extraCharLore.extraBooks]);	3441	worldsToSearch = new Set([...worldsToSearch, ...extraCharLore.extraBooks]);
3436	}	3442	}
3437		3443
		3444	if (!worldsToSearch.size) {
		3445	return [];
		3446	}
		3447
3438	let entries = [];	3448	let entries = [];
3439	for (const worldName of worldsToSearch) {	3449	for (const worldName of worldsToSearch) {
3440	if (selected_world_info.includes(worldName)) {	3450	if (selected_world_info.includes(worldName)) {
3441	console.debug(`Character ${name}'s world ${worldName} is already activated in global world info! Skipping...`);	3451	console.debug(`[WI] Character ${name}'s world ${worldName} is already activated in global world info! Skipping...`);
3442	continue;	3452	continue;
3443	}	3453	}
3444		3454
3445	if (chat_metadata[METADATA_KEY] === worldName) {	3455	if (chat_metadata[METADATA_KEY] === worldName) {
3446	console.debug(`Character ${name}'s world ${worldName} is already activated in chat lore! Skipping...`);	3456	console.debug(`[WI] Character ${name}'s world ${worldName} is already activated in chat lore! Skipping...`);
3447	continue;	3457	continue;
3448	}	3458	}
3449		3459
3450	const data = await loadWorldInfoData(worldName);	3460	const data = await loadWorldInfoData(worldName);
3451	const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(x => ({ ...x, world: worldName })) : [];	3461	const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(({ uid, ...rest }) => ({ uid, world: worldName, ...rest })) : [];
3452	entries = entries.concat(newEntries);	3462	entries = entries.concat(newEntries);
		3463
		3464	if (!newEntries.length) {
		3465	console.debug(`[WI] Character ${name}'s world ${worldName} could not be found or is empty`);
		3466	}
3453	}	3467	}
3454		3468
3455	console.debug(`Character ${name} lore (${Array.from(worldsToSearch)}) has ${entries.length} world info entries`);	3469	console.debug(`[WI] Character ${name}'s lore has ${entries.length} world info entries`, [...worldsToSearch]);
3456	return entries;	3470	return entries;
3457	}	3471	}
3458		3472
3459	async function getGlobalLore() {	3473	async function getGlobalLore() {
3460	if (!selected_world_info) {	3474	if (!selected_world_info?.length) {
3461	return [];	3475	return [];
3462	}	3476	}
3463		3477
3464	let entries = [];	3478	let entries = [];
3465	for (const worldName of selected_world_info) {	3479	for (const worldName of selected_world_info) {
3466	const data = await loadWorldInfoData(worldName);	3480	const data = await loadWorldInfoData(worldName);
3467	const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(x => ({ ...x, world: worldName })) : [];	3481	const newEntries = data ? Object.keys(data.entries).map((x) => data.entries[x]).map(({ uid, ...rest }) => ({ uid, world: worldName, ...rest })) : [];
3468	entries = entries.concat(newEntries);	3482	entries = entries.concat(newEntries);
3469	}	3483	}
3470		3484
3471	console.debug(`Global world info has ${entries.length} entries`);	3485	console.debug(`[WI] Global world info has ${entries.length} entries`, selected_world_info);
3472		3486
3473	return entries;	3487	return entries;
3474	}	3488	}

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

                 entries = [...globalLore.sort(sortFn), ...characterLore.sort(sortFn)];
                 break;
             default:
-                console.error('Unknown WI insertion strategy: ', world_info_character_strategy, 'defaulting to evenly');
+                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 ${entries.length} world lore entries using strategy ${world_info_character_strategy}`);
+        console.debug(`[WI] Found ${entries.length} world lore entries. Sorted 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(`Budget ${budget} exceeds cap ${world_info_budget_cap}, using cap`);
+        console.debug(`[WI] Budget ${budget} exceeds cap ${world_info_budget_cap}, using cap`);
         budget = world_info_budget_cap;
+    }
-    console.debug(`Context size: ${maxContext}; WI budget: ${budget} (max% = ${world_info_budget}%, cap = ${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.debug(`WI entry ${entry.uid} filtered out by character`);
+                    log('filtered out by character');
                     continue;
+                }
+            }

@@ -3611,7 +3654,7 @@ async function checkWorldInfo(chat, maxContext, isDryRun) {
3611	const filtered = entry.characterFilter.isExclude ? includesTag : !includesTag;	3654	const filtered = entry.characterFilter.isExclude ? includesTag : !includesTag;
3612		3655
3613	if (filtered) {	3656	if (filtered) {
3614	console.debug(`WI entry ${entry.uid} filtered out by tag`);	3657	log('filtered out by tag');
3615	continue;	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.delayUntilRecursion) {
+            if (entry.constant) {
-                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 (!Array.isArray(entry.key) || !entry.key.length) {
-                // 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) {
+            // Cache the text to scan before the loop, it won't change its content
-                    const substituted = substituteParams(key);
             const textToScan = buffer.get(entry, scanState);
-                    if (substituted && buffer.matchKeys(textToScan, substituted.trim(), entry)) {
+            // PRIMARY KEYWORDS
-                        console.debug(`WI UID ${entry.uid} found by primary match: ${substituted}.`);
+            let primaryKeyMatch = entry.key.find(key => {
+                const substituted = substituteParams(key);
+                return substituted && buffer.matchKeys(textToScan, substituted.trim(), entry);
+            });
-                        //selective logic begins
+            if (!primaryKeyMatch) {
-                        if (
+                // Don't write logs for simple no-matches
+                continue;
+            }
+            const hasSecondaryKeywords = (
                 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}`);
+            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;
-                            secondary: for (let keysecondary of entry.keysecondary) {
+                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) {
+                    if (hasSecondaryMatch) hasAnyMatch = true;
-                                    hasAllMatch = false;
+                    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)) {
+                    if (selectiveLogic === world_info_logic.AND_ANY && hasSecondaryMatch) {
-                                    // Differ both logic statements in the debugger
+                        log('activated. (AND ANY) Found match secondary keyword', secondarySubstituted);
-                                    if (selectiveLogic === world_info_logic.AND_ANY) {
+                        return true;
-                                        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);
+                    if (selectiveLogic === world_info_logic.NOT_ALL && !hasSecondaryMatch) {
-                                    break secondary;
+                        log('activated. (NOT ALL) Found not matching secondary keyword', secondarySubstituted);
+                        return true;
+                    }
+                }
                 // Handle NOT ANY logic
                 if (selectiveLogic === world_info_logic.NOT_ANY && !hasAnyMatch) {
-                                console.debug(`(NOT ANY Check) Activating WI Entry ${entry.uid}, no secondary keywords found.`);
+                    log('activated. (NOT ANY) No secondary keywords found', entry.keysecondary);
-                                activatedNow.add(entry);
+                    return true;
+                }
                 // Handle AND ALL logic
                 if (selectiveLogic === world_info_logic.AND_ALL && hasAllMatch) {
-                                console.debug(`(AND ALL Check) Activating WI Entry ${entry.uid}, all secondary keywords found.`);
+                    log('activated. (AND ALL) All secondary keywords found', entry.keysecondary);
-                                activatedNow.add(entry);
+                    return true;
-                            }
-                        } else {
-                            // Handle cases where secondary is empty
-                            console.debug(`WI UID ${entry.uid}: Activated without filter logic.`);
-                            activatedNow.add(entry);
-                            break primary;
-                        }
+                }
+                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('-- PROBABILITY CHECKS BEGIN --');
+        console.debug('[WI] --- PROBABILITY CHECKS ---');
         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) {
+                if (isSticky) {
-                    console.debug(`WI entry ${entry.uid} ${entry.key} failed probability check, skipping`);
+                    console.debug(`WI entry ${entry.uid} is sticky, does not need to re-roll probability`);
+                    return true;
+                }
+                const rollValue = Math.random() * 100;
+                if (rollValue <= entry.probability) {
+                    console.debug(`WI entry ${entry.uid} passed probability check of ${entry.probability}%`);
+                    return true;
+                }
                 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;
+            }
-            } else { console.debug(`uid:${entry.uid} passed probability check, inserting to prompt`); }
             // 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 activated:', entry);
+            console.debug(`[WI] Entry ${entry.uid} activation successful, adding to prompt`, entry);
+        }
-        const probabilityChecksAfter = failedProbabilityChecks.size;
+        const successfulNewEntries = newEntries.filter(x => !failedProbabilityChecks.has(x));
+        const successfulNewEntriesForRecursion = successfulNewEntries.filter(x => !x.preventRecursion);
-        if ((probabilityChecksAfter - probabilityChecksBefore) === activatedNow.size) {
+        if (!newEntries.length) {
-            console.debug('WI probability checks failed for all activated entries, stopping');
+            console.debug('[WI] No new entries activated, 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) {
-            scanState = scan_state.NONE;
+            nextScanState = scan_state.RECURSION;
+        }
-        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 && (allActivatedEntries.size < world_info_min_activations)) {
+        if (!nextScanState && !token_budget_overflowed && minActivationsNotSatisfied) {
+            console.debug('[WI] --- MIN ACTIVATIONS CHECK ---');
             let over_max = (
                 world_info_min_activations_depth_max > 0 &&
                 buffer.getDepth() > world_info_min_activations_depth_max
             ) || (buffer.getDepth() > chat.length);
             if (!over_max) {
-                    scanState = scan_state.MIN_ACTIVATIONS; // loop
+                console.debug(`[WI] Min activations not reached (${allActivatedEntries.size}/${world_info_min_activations}), advancing depth to ${buffer.getDepth() + 1} and checking again`);
-                    buffer.advanceScanPosition();
+                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 to prompt due to empty content:', entry);
+            console.debug(`[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(`Skipping group scoring for group '${key}'`);
+            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(`Group '${key}' max score: ${maxScore}`);
+        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 score loser from inclusion group '${key}' entry '${group[i].uid}'`, group[i]);
+                console.debug(`[WI] Entry ${group[i].uid}`, `removed as score loser from inclusion group '${key}'`, 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('-- INCLUSION GROUP CHECKS BEGIN --');
+    console.debug('[WI] --- INCLUSION GROUP CHECKS ---');
     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('No inclusion groups found');
+        console.debug('[WI] No inclusion groups found');
         return;
+    }

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

     filterGroupsByScoring(grouped, buffer, removeEntry, scanState);
     for (const [key, group] of Object.entries(grouped)) {
-        console.debug(`Checking inclusion group '${key}' with ${group.length} entries`, group);
+        console.debug(`[WI] Checking inclusion group '${key}' with ${group.length} entries`, group);
         if (Array.from(allActivatedEntries).some(x => x.group === key)) {
-            console.debug(`Skipping inclusion group check, group already activated '${key}'`);
+            console.debug(`[WI] Skipping inclusion group check, group '${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('Skipping inclusion group check, only one entry');
+            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 group '${key}' with by prio winner entry '${prios[0].uid}'`, prios[0]);
+            console.debug(`[WI] Entry ${prios[0].uid}`, `activated as prio winner from inclusion group '${key}'`, prios[0]);
             removeAllBut(group, prios[0]);
             continue;
+        }

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