hoi4-agent-tools 2.8.1 → 2.8.3

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 No unreleased changes.
 
+## 2.8.3 - 2026-08-27
+
+- Centered native button labels when HOI4 GUI source uses `text =` instead of `buttonText =`, matching the in-game horizontal and vertical alignment inside button frames.
+- Added one scenario `values` map for concrete runtime variables, dynamic text, meter fills, sprites, frames, positions, visibility, and enabled states so agents can render complete value-driven GUI versions without assembling several low-level override maps.
+
+## 2.8.2 - 2026-08-27
+
+- Composed top-level scripted-GUI child windows through `parent_scripted_gui`, instantiated external dynamic-list entry containers, and applied row-scoped image, frame, position, visibility, and enabled values.
+- Applied constant scripted visibility and click-enabled triggers, narrowed target scans and diagnostics to linked GUI surfaces, and accepted documented installed-game scripted-GUI contexts without hard false failures.
+- Rendered language-correct HOI4 bitmap fonts and recovered installed-game first-page atlases whose actual filename omits the declared page suffix.
+- Resolved alternate installed raster extensions, stopped shared sprite textures from producing false symbol collisions, cached unchanged scanned bytes, refreshed active artifact recency, and reclaimed stale temporary artifact debris.
+- Made concurrent artifact accounting tolerate entries that finish publishing between enumeration and inspection, and emit the first long-operation progress heartbeat immediately.
+
 ## 2.8.1 - 2026-08-27
 
 - Added periodic MCP progress heartbeats for long GUI inspections, renders, and rewrites, with repeated progress notifications that preserve monotonic work values and still honor cancellation.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { link, lstat, mkdir, open, readFile, readdir, stat, unlink } from 'node:fs/promises';
+import { link, lstat, mkdir, open, readFile, readdir, rmdir, stat, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod/v4';
 import { canonicalJson, compareCodeUnits, sha256Bytes } from './canonical.js';
@@ -157,6 +157,7 @@ const artifactReadBufferBytes = 1_048_576;
 const artifactPageMaxEntries = 100;
 const artifactManifestMaxBytes = 1_048_576;
 const artifactLogicalBatchMaxBytes = 536_870_912;
+const artifactDebrisMinimumAgeMs = 15 * 60 * 1_000;
 const artifactHashYieldBytes = 16_777_216;
 const artifactPreflightYieldEntries = 256;
 const interruptedManifestMinimumAgeMs = 1_000;
@@ -306,6 +307,27 @@ async function withArtifactQueue(root, action, signal) {
 async function artifactUsage(root, signal) {
     let bytes = 0;
     let entries = 0;
+    const canonicalRoot = await containedGeneratedPath(root);
+    const resolveListedPath = async (directory, name) => {
+        const lexicalPath = path.join(directory, name);
+        try {
+            return await containedGeneratedPath(canonicalRoot, path.relative(canonicalRoot, lexicalPath));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            if (error instanceof ServiceError && error.code === 'PATH_GENERATED_ROOT_ESCAPE') {
+                try {
+                    await lstat(lexicalPath);
+                }
+                catch (metadataError) {
+                    if (metadataError.code === 'ENOENT')
+                        return undefined;
+                }
+            }
+            throw error;
+        }
+    };
     const walk = async (directory) => {
         signal?.throwIfAborted();
         let children;
@@ -322,9 +344,24 @@ async function artifactUsage(root, signal) {
             if (child.isSymbolicLink()) {
                 throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
             }
-            if (child.isFile() && child.name.startsWith(artifactTemporaryPrefix))
+            if (child.isFile() && child.name.startsWith(artifactTemporaryPrefix)) {
+                const temporary = await resolveListedPath(directory, child.name);
+                if (temporary === undefined)
+                    continue;
+                try {
+                    const metadata = await lstat(temporary);
+                    if (Date.now() - metadata.mtimeMs >= artifactDebrisMinimumAgeMs)
+                        await unlink(temporary);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                continue;
+            }
+            const candidate = await resolveListedPath(directory, child.name);
+            if (candidate === undefined)
                 continue;
-            const candidate = await containedGeneratedPath(root, path.relative(root, path.join(directory, child.name)));
             if (child.isDirectory())
                 await walk(candidate);
             else if (child.isFile()) {
@@ -345,8 +382,17 @@ async function artifactUsage(root, signal) {
                 }
             }
         }
+        if (directory !== canonicalRoot) {
+            try {
+                await rmdir(directory);
+            }
+            catch (error) {
+                if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code ?? ''))
+                    throw error;
+            }
+        }
     };
-    await walk(await containedGeneratedPath(root));
+    await walk(canonicalRoot);
     return { bytes, entries };
 }
 async function readArtifactManifest(filePath, signal) {
@@ -388,6 +434,25 @@ async function readArtifactManifest(filePath, signal) {
         throw new ServiceError('ARTIFACT_MANIFEST_INVALID', 'Artifact provenance manifest is invalid');
     }
 }
+async function refreshArtifactManifest(filePath) {
+    let handle;
+    try {
+        handle = await open(filePath, 'r+');
+        const metadata = await handle.stat();
+        if (!metadata.isFile())
+            throw new ServiceError('ARTIFACT_MANIFEST_INVALID', 'Artifact provenance manifest is invalid');
+        const now = new Date();
+        await handle.utimes(now, now);
+    }
+    catch (error) {
+        if (error instanceof ServiceError)
+            throw error;
+        throw new ServiceError('ARTIFACT_NOT_FOUND', 'Artifact provenance manifest is unavailable');
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
 async function readBoundedManifestBytes(filePath, signal) {
     signal?.throwIfAborted();
     let metadata;
@@ -672,6 +737,58 @@ export class ArtifactStore {
             }
         };
         await walk(await containedGeneratedPath(workspace.artifactRoot));
+        const referencedTargets = new Set([
+            ...retained.map(({ targetPath }) => targetPath),
+            ...protectedTargets,
+        ]);
+        const reclaimDebris = async (directory) => {
+            signal?.throwIfAborted();
+            let children;
+            try {
+                children = await readdir(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return;
+                throw error;
+            }
+            for (const child of children) {
+                signal?.throwIfAborted();
+                if (child.isSymbolicLink())
+                    throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
+                const candidate = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, child.name)));
+                if (child.isDirectory()) {
+                    await reclaimDebris(candidate);
+                    continue;
+                }
+                if (!child.isFile() || child.name.endsWith('.manifest.json'))
+                    continue;
+                const temporary = child.name.startsWith(artifactTemporaryPrefix);
+                if (!temporary && referencedTargets.has(candidate))
+                    continue;
+                let metadata;
+                try {
+                    metadata = await lstat(candidate);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                if (Date.now() - metadata.mtimeMs < artifactDebrisMinimumAgeMs)
+                    continue;
+                try {
+                    await unlink(candidate);
+                    if (!temporary)
+                        usage.bytes = Math.max(0, usage.bytes - metadata.size);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+        };
+        await reclaimDebris(await containedGeneratedPath(workspace.artifactRoot));
         retained.sort((left, right) => left.modifiedAt - right.modifiedAt ||
             compareCodeUnits(left.manifestPath, right.manifestPath));
         const current = { ...usage };
@@ -1192,6 +1309,10 @@ export class ArtifactStore {
                     }
                 }
                 signal?.throwIfAborted();
+                for (const artifact of uniqueManifests.values()) {
+                    await refreshArtifactManifest(artifact.manifestPath);
+                }
+                signal?.throwIfAborted();
                 // The caller's commit callback is the ownership boundary. Once entered,
                 // it completes or fails under its own critical-phase rules; a late abort
                 // cannot make the store remove evidence already committed elsewhere.
@@ -1245,6 +1366,7 @@ export class ArtifactStore {
         const verificationKey = `${workspace.workspaceIdentity}\0${workspace.ownerIdentity}\0${target}\0${sha256}`;
         const { bytes, totalSize, identity } = await readVerifiedArtifactRange(target, sha256, range, this.#verifiedContent.get(verificationKey), signal);
         this.#verifiedContent.set(verificationKey, identity);
+        await refreshArtifactManifest(manifestPath);
         return { bytes, mimeType: manifest.mimeType, name, totalSize };
     }
     uri(workspaceId, sha256, provenanceHash, name) {

package/dist/hoi4_agent_tools/core/index.js

@@ -1299,7 +1299,9 @@ export class SymbolIndex {
                 continue;
             const active = candidates[0];
             this.#active.set(key, active);
-            const additiveCategory = active.kind === 'decision_category' || active.kind === 'technology_category';
+            const additiveCategory = active.kind === 'decision_category' ||
+                active.kind === 'technology_category' ||
+                active.kind === 'texture';
             for (const candidate of group) {
                 candidate.overridden = additiveCategory ? candidate.sourceShadowed : candidate !== active;
             }

package/dist/hoi4_agent_tools/core/scanner.js

@@ -25,10 +25,33 @@ export class WorkspaceScanner {
     serverMaxFiles;
     serverMaxBytes;
     serverMaxFileBytes;
+    #sourceCache = new Map();
+    #sourceCacheBytes = 0;
+    #sourceCacheMaxBytes;
     constructor(serverMaxFiles = 20_000, serverMaxBytes = 134_217_728, serverMaxFileBytes = 67_108_864) {
         this.serverMaxFiles = serverMaxFiles;
         this.serverMaxBytes = serverMaxBytes;
         this.serverMaxFileBytes = serverMaxFileBytes;
+        this.#sourceCacheMaxBytes = Math.max(serverMaxFileBytes, Math.min(536_870_912, serverMaxBytes * 2));
+    }
+    cacheKey(absolutePath) {
+        const resolved = path.resolve(absolutePath);
+        return process.platform === 'win32' ? resolved.toLocaleLowerCase('en-US') : resolved;
+    }
+    retainSource(key, source) {
+        const previous = this.#sourceCache.get(key);
+        if (previous !== undefined)
+            this.#sourceCacheBytes -= previous.bytes.length;
+        this.#sourceCache.delete(key);
+        this.#sourceCache.set(key, source);
+        this.#sourceCacheBytes += source.bytes.length;
+        while (this.#sourceCacheBytes > this.#sourceCacheMaxBytes && this.#sourceCache.size > 1) {
+            const oldest = this.#sourceCache.entries().next().value;
+            if (oldest === undefined)
+                break;
+            this.#sourceCache.delete(oldest[0]);
+            this.#sourceCacheBytes -= oldest[1].bytes.length;
+        }
     }
     async scan(workspace, options) {
         options.signal?.throwIfAborted();
@@ -72,6 +95,7 @@ export class WorkspaceScanner {
                 if (hiddenByReplacePath(workspace, root, relativePath))
                     continue;
                 const absolutePath = path.join(root.path, relativePath);
+                const cacheKey = this.cacheKey(absolutePath);
                 const handle = await open(absolutePath, 'r');
                 try {
                     const metadata = await handle.stat();
@@ -81,7 +105,24 @@ export class WorkspaceScanner {
                     if (metadata.size > remaining || metadata.size > this.serverMaxFileBytes) {
                         throw new ServiceError('SCAN_BYTE_LIMIT', 'Scan exceeds the configured byte limit');
                     }
-                    const bytes = await readBoundedFile(handle, Math.min(remaining, this.serverMaxFileBytes), options.signal);
+                    const cached = this.#sourceCache.get(cacheKey);
+                    const retained = cached?.size === metadata.size &&
+                        cached.modifiedMs === metadata.mtimeMs &&
+                        cached.changedMs === metadata.ctimeMs &&
+                        cached.inode === metadata.ino
+                        ? cached
+                        : undefined;
+                    const bytes = retained?.bytes ??
+                        (await readBoundedFile(handle, Math.min(remaining, this.serverMaxFileBytes), options.signal));
+                    const sha256 = retained?.sha256 ?? sha256Bytes(bytes);
+                    this.retainSource(cacheKey, {
+                        size: metadata.size,
+                        modifiedMs: metadata.mtimeMs,
+                        changedMs: metadata.ctimeMs,
+                        inode: metadata.ino,
+                        sha256,
+                        bytes,
+                    });
                     totalBytes += bytes.length;
                     result.push({
                         absolutePath,
@@ -91,7 +132,7 @@ export class WorkspaceScanner {
                         loadOrder: root.loadOrder,
                         size: bytes.length,
                         modifiedMs: metadata.mtimeMs,
-                        sha256: sha256Bytes(bytes),
+                        sha256,
                         bytes,
                     });
                 }

package/dist/hoi4_agent_tools/gui/assets.js

@@ -153,7 +153,7 @@ export class GuiAssetCatalog {
     glyphRasters = new Map();
     metrics = new Map();
     fontDefinitions = new Map();
-    constructor(graph, scannedFiles, budget = new RenderBudget()) {
+    constructor(graph, scannedFiles, budget = new RenderBudget(), language = 'l_english') {
         this.graph = graph;
         this.budget = budget;
         for (const file of scannedFiles
@@ -166,14 +166,35 @@ export class GuiAssetCatalog {
             candidates.push(file);
             this.basenames.set(basename, candidates);
         }
-        for (const definition of graph.fonts)
-            this.fontDefinitions.set(definition.name.toLowerCase(), definition);
+        const normalizedLanguage = language.toLocaleLowerCase('en-US');
+        for (const definition of graph.fonts) {
+            const key = definition.name.toLocaleLowerCase('en-US');
+            const existing = this.fontDefinitions.get(key);
+            const definitionMatches = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
+            const existingMatches = existing?.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage) ?? false;
+            if (existing === undefined ||
+                (definitionMatches && !existingMatches) ||
+                (definitionMatches === existingMatches && existing.override && !definition.override) ||
+                (definitionMatches === existingMatches &&
+                    existing.languages.length > 0 &&
+                    definition.languages.length === 0))
+                this.fontDefinitions.set(key, definition);
+        }
     }
     resolveFile(assetPath, relativeTo) {
         const normalized = normalizeAssetPath(assetPath);
-        const normalizedCandidates = path.posix.extname(normalized).length === 0
+        const extension = path.posix.extname(normalized);
+        const rasterExtensions = ['.png', '.bmp', '.tga', '.dds', '.svg'];
+        const normalizedCandidates = extension.length === 0
             ? [normalized, `${normalized}.fnt`, `${normalized}.ttf`, `${normalized}.otf`]
-            : [normalized];
+            : rasterExtensions.includes(extension)
+                ? [
+                    normalized,
+                    ...rasterExtensions
+                        .filter((candidate) => candidate !== extension)
+                        .map((candidate) => `${normalized.slice(0, -extension.length)}${candidate}`),
+                ]
+                : [normalized];
         for (const candidatePath of normalizedCandidates) {
             const direct = this.files.get(candidatePath);
             if (direct !== undefined)
@@ -399,13 +420,12 @@ export class GuiAssetCatalog {
                 if (previous !== undefined)
                     penX += (entry.bmfont.kerning.get(`${previous}:${codePoint}`) ?? 0) * scale;
                 const pagePath = entry.bmfont.pages[metric.page];
-                const raster = pagePath === undefined
+                const pageFile = pagePath === undefined ? undefined : this.resolveBmFontPage(entry, pagePath, metric.page);
+                const raster = pageFile === undefined
                     ? undefined
-                    : await this.loadBmFontGlyph(entry, pagePath, metric, codePoint);
-                if (raster !== undefined && pagePath !== undefined) {
-                    const page = this.resolveFile(pagePath, entry.sourceFile.relativePath);
-                    if (page !== undefined)
-                        pageHashes.add(page.sha256);
+                    : await this.loadBmFontGlyph(entry, pageFile, metric, codePoint);
+                if (raster !== undefined && pageFile !== undefined) {
+                    pageHashes.add(pageFile.sha256);
                     glyphs.push({
                         kind: 'bitmap',
                         key: `${entry.sourceFile.sha256}:${codePoint}:${Math.max(1, fontSize)}`,
@@ -520,14 +540,14 @@ export class GuiAssetCatalog {
         this.metrics.set(key, null);
         return undefined;
     }
-    loadBmFontGlyph(entry, pagePath, metric, codePoint) {
+    loadBmFontGlyph(entry, pageFile, metric, codePoint) {
         if (metric.width <= 0 || metric.height <= 0)
             return Promise.resolve(undefined);
-        const key = `${entry.sourceFile.sha256}:${pagePath}:${codePoint}:${metric.x}:${metric.y}:${metric.width}:${metric.height}`;
+        const key = `${entry.sourceFile.sha256}:${pageFile.sha256}:${codePoint}:${metric.x}:${metric.y}:${metric.width}:${metric.height}`;
         let promise = this.glyphRasters.get(key);
         if (promise === undefined) {
             promise = (async () => {
-                const raster = await this.loadRaster(pagePath, entry.sourceFile.relativePath);
+                const raster = await this.loadRaster(pageFile.relativePath);
                 if (!raster.supported ||
                     metric.x < 0 ||
                     metric.y < 0 ||
@@ -555,6 +575,35 @@ export class GuiAssetCatalog {
         }
         return promise;
     }
+    resolveBmFontPage(entry, pagePath, pageIndex) {
+        const normalizedPage = normalizeAssetPath(pagePath);
+        const relativePage = normalizeAssetPath(path.posix.join(path.posix.dirname(normalizeAssetPath(entry.sourceFile.relativePath)), normalizedPage));
+        const rasterExtensions = ['.png', '.bmp', '.tga', '.dds', '.svg'];
+        for (const candidate of [relativePage, normalizedPage]) {
+            const candidateExtension = path.posix.extname(candidate).toLowerCase();
+            const candidateStem = candidate.slice(0, -candidateExtension.length);
+            const variants = candidateExtension.length === 0
+                ? rasterExtensions.map((suffix) => `${candidate}${suffix}`)
+                : rasterExtensions.includes(candidateExtension)
+                    ? [candidate, ...rasterExtensions.map((suffix) => `${candidateStem}${suffix}`)]
+                    : [candidate];
+            for (const variant of variants) {
+                const file = this.files.get(variant);
+                if (file !== undefined)
+                    return file;
+            }
+        }
+        if (pageIndex === 0) {
+            const sourcePath = normalizeAssetPath(entry.sourceFile.relativePath);
+            const sourceStem = sourcePath.slice(0, -path.posix.extname(sourcePath).length);
+            for (const suffix of rasterExtensions) {
+                const file = this.files.get(`${sourceStem}${suffix}`);
+                if (file !== undefined)
+                    return file;
+            }
+        }
+        return this.resolveFile(pagePath, entry.sourceFile.relativePath);
+    }
     async decodeRaster(file) {
         const extension = path.extname(file.relativePath).toLowerCase();
         const operationKey = `gui-raster:${file.displayPath}:${file.sha256}`;

package/dist/hoi4_agent_tools/gui/inspection-artifact.js

@@ -42,36 +42,107 @@ function graphCounts(graph) {
  * directly connected node while recording exact full-inventory counts.
  */
 export function projectGuiGraphForArtifact(graph, selectedSourceIds = [], fullGraphNodeLimit = GUI_INSPECTION_FULL_GRAPH_NODE_LIMIT) {
-    if (graph.nodes.length <= fullGraphNodeLimit)
+    const selectedWindow = selectedSourceIds.length > 0;
+    if (!selectedWindow && graph.nodes.length <= fullGraphNodeLimit)
         return { graph };
     const retainedIds = new Set(selectedSourceIds);
-    for (const node of graph.nodes)
-        if (isWorkspaceGraphSeed(node))
-            retainedIds.add(node.id);
-    const retainedEdges = graph.edges.filter(({ from, to }) => retainedIds.has(from) || retainedIds.has(to));
-    for (const edge of retainedEdges) {
+    if (selectedWindow) {
+        const selectedElementNames = new Set(graph.elements.filter(({ id }) => retainedIds.has(id)).map(({ name }) => name));
+        const retainedScriptedGuiNames = new Set(graph.scriptedGuis
+            .filter(({ windowName, parentWindowName }) => (windowName !== undefined && selectedElementNames.has(windowName)) ||
+            (parentWindowName !== undefined && selectedElementNames.has(parentWindowName)))
+            .map(({ name }) => name));
+        let addedRelatedScriptedGui = true;
+        while (addedRelatedScriptedGui) {
+            addedRelatedScriptedGui = false;
+            for (const scripted of graph.scriptedGuis) {
+                if (scripted.parentScriptedGui === undefined)
+                    continue;
+                if (retainedScriptedGuiNames.has(scripted.parentScriptedGui) &&
+                    !retainedScriptedGuiNames.has(scripted.name)) {
+                    retainedScriptedGuiNames.add(scripted.name);
+                    addedRelatedScriptedGui = true;
+                }
+                if (retainedScriptedGuiNames.has(scripted.name) &&
+                    !retainedScriptedGuiNames.has(scripted.parentScriptedGui)) {
+                    retainedScriptedGuiNames.add(scripted.parentScriptedGui);
+                    addedRelatedScriptedGui = true;
+                }
+            }
+        }
+        for (const scripted of graph.scriptedGuis)
+            if (retainedScriptedGuiNames.has(scripted.name))
+                retainedIds.add(scripted.id);
+    }
+    else {
+        for (const node of graph.nodes)
+            if (isWorkspaceGraphSeed(node))
+                retainedIds.add(node.id);
+    }
+    const retainedEdges = [];
+    const retainedEdgeIds = new Set();
+    let addedDependency = true;
+    while (addedDependency) {
+        addedDependency = false;
+        for (const edge of graph.edges) {
+            if (!retainedIds.has(edge.from) || retainedEdgeIds.has(edge.id))
+                continue;
+            retainedEdges.push(edge);
+            retainedEdgeIds.add(edge.id);
+            if (!retainedIds.has(edge.to)) {
+                retainedIds.add(edge.to);
+                addedDependency = true;
+            }
+        }
+    }
+    for (const edge of graph.edges) {
+        if (!retainedIds.has(edge.to) ||
+            retainedEdgeIds.has(edge.id) ||
+            !['contains', 'decision_category_entry'].includes(edge.kind))
+            continue;
+        retainedEdges.push(edge);
+        retainedEdgeIds.add(edge.id);
         retainedIds.add(edge.from);
-        retainedIds.add(edge.to);
     }
     const retainedLocalisation = new Set(graph.nodes
         .filter(({ id, kind }) => kind === 'localisation' && retainedIds.has(id))
         .map(({ name, path }) => `${path}\u0000${name}`));
+    const retainedPaths = new Set([
+        ...graph.elements.filter(({ id }) => retainedIds.has(id)).map(({ sourcePath }) => sourcePath),
+        ...graph.sprites.filter(({ id }) => retainedIds.has(id)).map(({ sourcePath }) => sourcePath),
+        ...graph.fonts.filter(({ id }) => retainedIds.has(id)).map(({ sourcePath }) => sourcePath),
+        ...graph.scriptedGuis
+            .filter(({ id }) => retainedIds.has(id))
+            .map(({ sourcePath }) => sourcePath),
+        ...graph.animationSources
+            .filter(({ id }) => retainedIds.has(id))
+            .map(({ sourcePath }) => sourcePath),
+        ...graph.scriptedLocalisation
+            .filter(({ id }) => retainedIds.has(id))
+            .map(({ sourcePath }) => sourcePath),
+    ]);
     const retainedGraph = {
         ...graph,
         nodes: graph.nodes.filter(({ id }) => retainedIds.has(id)),
         edges: retainedEdges,
-        elements: graph.elements.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
-        sprites: graph.sprites.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
-        fonts: graph.fonts.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
-        scriptedGuis: graph.scriptedGuis.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
-        animationSources: graph.animationSources.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
-        scriptedLocalisation: graph.scriptedLocalisation.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        elements: graph.elements.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
+        sprites: graph.sprites.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
+        fonts: graph.fonts.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
+        scriptedGuis: graph.scriptedGuis.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
+        animationSources: graph.animationSources.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
+        scriptedLocalisation: graph.scriptedLocalisation.filter(({ id, sourcePath }) => retainedIds.has(id) || (!selectedWindow && isWorkspaceSource(sourcePath))),
         localisation: graph.localisation.filter(({ key, sourcePath }) => retainedLocalisation.has(`${sourcePath}\u0000${key}`)),
+        diagnostics: selectedWindow
+            ? graph.diagnostics.filter(({ code, location, related }) => (code === 'GUI_ANIMATION_SOURCE_MANIFEST_INVALID' &&
+                location?.path.startsWith('mod:hoi4_agent/animation_sources/') === true) ||
+                (location !== undefined && retainedPaths.has(location.path)) ||
+                related?.some(({ path }) => retainedPaths.has(path)) === true)
+            : graph.diagnostics,
     };
     return {
         graph: retainedGraph,
         projection: {
-            mode: 'workspace-overlay-and-selected',
+            mode: selectedWindow ? 'selected-window' : 'workspace-overlay-and-selected',
             fullCounts: graphCounts(graph),
             returnedCounts: graphCounts(retainedGraph),
         },