modwright 0.1.2 → 0.1.3

package/README.md

@@ -64,6 +64,43 @@ without tcli." Most features need nothing. ModWright can install some
 external tools itself, and any other tool or data folder only has to be
 pointed at once.
 
+## Which mod is doing this?
+
+With hundreds of mods installed, the usual question is not "is something
+broken" but "which mod did it". Three tools answer it from different sides,
+without launching the game:
+
+- **`owner_of`**: which mod a file comes from. Give it a DLL named in a
+  crash log, a path from `triage_logs`, or a bare file name. It answers
+  from the game's own mod folders, Vortex's deployment records and Mod
+  Organizer 2's profiles (Skyrim), and says how it decided. For example,
+  `owner_of game=cyberpunk2077 paths=["TweakXL.dll"]` names the Vortex mod
+  that deployed it.
+- **`who_touches`**: which mods write the same record or entry: Cyberpunk
+  2077 TweakDB records and flats, Baldur's Gate 3 stats entries, Stardew
+  Valley Content Patcher assets and entries. With no `key` it lists the
+  keys mods actually disagree on, for example
+  `who_touches game=cyberpunk2077`. These don't count as a disagreement:
+  - identical writes;
+  - list edits on different items;
+  - a mod the game does not load (a BG3 pak missing from
+    `modsettings.lsx`);
+  - a second copy of the same mod.
+
+  Copies of one mod are reported separately, under `duplicateCopies`.
+  `who_touches key=<record>` shows every writer of one key, and `mod=<name>`
+  shows what one mod writes.
+- **`triage_logs`** with `attributionFor`: what the frameworks' own logs say
+  happened. For example, TweakXL's log gives the order it read tweak files
+  in, and a later file wins the same flat.
+
+Together they catch the quiet problems, for example a tweak file installed
+twice and loaded twice, or a stale copy of a mod that the game binds instead
+of the current one. `who_touches` reads files, not the running game, so
+scripts that change things at runtime are not seen. Which of two
+disagreeing mods wins depends on load order, which these tools report but
+do not decide.
+
 ## Supported games
 
 | Surface | Game | Tested | Mod systems modeled |
@@ -99,11 +136,13 @@ Epic paths where they apply. Override with `installPath` on any tool, or set
 | `detect_install` | Locate one game, and report every mod root and log source, marking which exist. |
 | `list_mods` | Enumerate installed mods across all roots, with sizes, timestamps and parsed manifests. |
 | `inspect_mod` | Full detail on one mod: files owned, manifest, warnings. |
-| `find_conflicts` | Paths claimed by more than one mod, restricted to roots where that is actually possible. |
+| `find_conflicts` | Paths claimed by more than one mod, restricted to roots where that is actually possible. Where Mod Organizer 2 manages the game, it also reports the files one MO2 mod overrides in another. |
+| `owner_of` | Which installed mod a file comes from, and which copy the game sees when several provide it: for a DLL named in a crash log, a path from `triage_logs`, or a bare file name. It reads the game's own mod folders, Mod Organizer 2's profiles (Skyrim) and Vortex's deployment records, and says how each answer was decided. |
+| `who_touches` | Which installed mods write a given record or entry, at the level the game merges on: Cyberpunk 2077 TweakDB records and flats, Baldur's Gate 3 stats entries (read out of paks), Stardew Valley Content Patcher assets and entries. With no key it lists the contested ones. A mod the game does not load is listed but never contests, and copies of one mod count once. Static: it does not decide load order, and runtime scripts are not seen. |
 | `load_order` | Read the game's explicit load order and cross-check it against what is installed. |
 | `load_order_diff` | Snapshot the load order before a launch, then report what the game dropped, added or reordered (BG3 `modsettings.lsx`). |
 | `read_log` | Tail a mod-related log (redscript, RED4ext, CET, SKSE, BG3SE, BepInEx, SMAPI and more). |
-| `triage_logs` | Read every mod log for the current run and classify lines against known failure signatures. It returns one verdict: which systems loaded, what failed first, and the usual fix. |
+| `triage_logs` | Read every mod log for the current run and classify lines against known failure signatures. It returns one verdict: which systems loaded, what failed first, and the usual fix. Where a framework's log names who acted (TweakXL's read order, ArchiveXL's merges), it also says which mod did what; `attributionFor` narrows that to one asset, record or mod. |
 | `check_compat` | Detect the game build, loaders, frameworks and tools, and check them against cited compatibility floors. |
 | `check_toolchain` | Locate the external tools (LSLib divine, WolvenKit CLI, Blender, Cpp2IL and others), report each one's path and version (never guessed), and say what each feature needs. It also remembers a tool or data folder you point it at, installs the tools ModWright can install, and trusts a project to run its own build commands. |
 | `project_info` | Load a `modwright.json` mod project: sources, build, deploy targets, dependencies and publish targets, with paths resolved and structural warnings. |

package/bridges/cp2077-cet/ModWrightBridge/probes.lua

@@ -39,6 +39,9 @@
 --                                                   (verified, 2.31, observed in game 2026-08-16)
 --   TweakDB:GetRecord / TweakDB:GetFlat             observed in the CET console on
 --                                                   2026-09-08 (see the rows below).
+--   obj:GetNPCsAroundObject(radius)                 the game's RTTI dump (rayshader/cp2077-nativedb,
+--   obj:GetEntitiesAroundObject(radius, filter)     gameObject methods); no CET mod or wiki page calls
+--   TSF_Or / TSF_Any / Enum.new                     them — `unverified`; CET's source pins the Lua side
 --
 -- MUTATION. Two rows have effect `mutate`: `cp2077.inventory.add`, and `cp2077.lua.eval`
 -- (added 2026-09-11). They are the two handlers in this
@@ -816,6 +819,116 @@ Probes.handlers = {
         end,
     },
 
+    -- World-placed object verification — **unverified**, written 2026-09-10 with no game on
+    -- hand and never run in game. `gameObject` (parent `entGameEntity`) carries
+    -- `GetNPCsAroundObject(range: Float) -> array<ref<NPCPuppet>>` and
+    -- `GetEntitiesAroundObject(range: Float, searchFilter: gameTargetSearchFilter) -> array<ref<entEntity>>`
+    -- in the shipped game's own RTTI (rayshader/cp2077-nativedb at b5d29af, game 2.31), so both
+    -- exist — stronger evidence than "nothing on disk", which is why this row exists instead of
+    -- sitting out like `cp2077.loot.roll`. Neither a shipped CET mod nor a wiki page calls either
+    -- one from Lua, but CET's own source (yamashi/CyberEngineTweaks 9a8522f; knowledge facts
+    -- cp2077.cet.*) settles the calling convention:
+    --   * the TSF_* filter constructors are exposed as bare globals, `Game.TSF_X` and
+    --     `Game["TSF_X;"]`; a returned struct is a ClassReference copy that passes straight back
+    --     as a struct parameter (no layout is ever guessed);
+    --   * an enum parameter accepts a number, a member name or `Enum.new(type, name)`, but an
+    --     UNDECLARED value is coerced to 0 silently — so no ORed masks; declared members only,
+    --     combined with TSF_Or, and `Enum.new` with the full type name so a mistake is loud;
+    --   * an array return is a 1-based table whose null handles are nil holes — count with
+    --     pairs, never `#`.
+    -- Two shapes, chosen by `params.filter`:
+    --   "npc" (default): `GetNPCsAroundObject(radius)`, one scalar argument, the same risk class
+    --     as `ent:GetWorldPosition()` and `GetTaggedIDs(tag)` above.
+    --   "objects": `GetEntitiesAroundObject(radius, TSF_Or(TSF_Any(Obj_Device), TSF_Any(Obj_Other),
+    --     TSF_Any(Obj_Puppet), TSF_Any(Obj_Sensor)))` — the call that could verify a placed static
+    --     prop (a loot-container template carrying a gameTargetingComponent is plausibly in the
+    --     targeting set). TSF_Any/TSF_Or semantics and whether the prop is in the set are exactly
+    --     what a live run observes; every step is pcall-wrapped and reported, never swallowed.
+    -- The anchor defaults to the player; `params.tag`/`params.entityRef` pick another, exactly as
+    -- `resolveEntity` does for the rows above.
+    ["cp2077.entity.nearby"] = {
+        attestation = "unverified (RTTI dump confirms gameObject::GetNPCsAroundObject/GetEntitiesAroundObject exist; CET source pins the Lua calling convention; no live call observed yet)",
+        citation = "rayshader/cp2077-nativedb classes.json at b5d29af (gameObject::GetNPCsAroundObject;Float, GetEntitiesAroundObject;FloatTargetSearchFilter); " ..
+            "yamashi/CyberEngineTweaks 9a8522f (RTTI binding)",
+        effect = "read",
+        run = function(probe)
+            local p = params(probe)
+            local radius = tonumber(p.radius)
+            if radius == nil or radius <= 0 then return errored("params.radius is required and must be a positive number") end
+            local filter = p.filter == nil and "npc" or tostring(p.filter)
+            if filter ~= "npc" and filter ~= "objects" then
+                return errored("params.filter must be \"npc\" (default) or \"objects\", got " .. tostring(p.filter))
+            end
+
+            local anchorParams = p
+            if p.tag == nil and p.entityRef == nil then anchorParams = { entityRef = "$player" } end
+            local ent, describe, e = resolveEntity(anchorParams)
+            if ent == nil then return errored(e or "could not resolve an anchor entity", { resolve = describe }) end
+
+            local evidence = { resolve = describe, radius = radius, filter = filter }
+
+            local list
+            if filter == "npc" then
+                evidence.attemptedCall = "GetNPCsAroundObject(radius) — NPCs only; a static prop like a placed item does not " ..
+                    "show up here even when it does exist"
+                local okCall, callErr = pcall(function() list = ent:GetNPCsAroundObject(radius) end)
+                if not okCall then
+                    return errored("obj:GetNPCsAroundObject(" .. tostring(radius) .. ") raised an error (recorded rather " ..
+                        "than swallowed, since this row is unverified): " .. tostring(callErr), evidence)
+                end
+            else
+                evidence.attemptedCall = "GetEntitiesAroundObject(radius, TSF_Or(TSF_Any(Obj_Device), TSF_Any(Obj_Other), " ..
+                    "TSF_Any(Obj_Puppet), TSF_Any(Obj_Sensor))) — each member via Enum.new so a wrong name is an error, " ..
+                    "never a silent 0"
+                local searchFilter
+                local okFilter, filterErr = pcall(function()
+                    local function member(name) return Enum.new("gametargetingSystemSearchFilterMaskValue", name) end
+                    searchFilter = TSF_Or(TSF_Any(member("Obj_Device")), TSF_Any(member("Obj_Other")),
+                        TSF_Any(member("Obj_Puppet")), TSF_Any(member("Obj_Sensor")))
+                end)
+                if not okFilter or searchFilter == nil then
+                    return errored("building the gameTargetSearchFilter raised an error or returned nil (TSF_*/Enum.new " ..
+                        "exposure is what this settles): " .. tostring(filterErr), evidence)
+                end
+                local okCall, callErr = pcall(function() list = ent:GetEntitiesAroundObject(radius, searchFilter) end)
+                if not okCall then
+                    return errored("obj:GetEntitiesAroundObject(" .. tostring(radius) .. ", filter) raised an error (recorded " ..
+                        "rather than swallowed, since this row is unverified): " .. tostring(callErr), evidence)
+                end
+            end
+            if list == nil then
+                return errored(evidence.attemptedCall:match("^[%w]+") .. " returned nil — the RTTI method exists but this " ..
+                    "call did not resolve here; a live run is needed to say why", evidence)
+            end
+            if type(list) ~= "table" then
+                return errored("expected a table from the array return, got " .. type(list), evidence)
+            end
+
+            -- CET returns an array as a 1-based table, but a null handle inside it becomes a nil
+            -- hole, so `#` and ipairs can stop early: walk with pairs and count what is there.
+            local count, holes = 0, 0
+            local out = Protocol.array({})
+            local slots = 0
+            for k, _ in pairs(list) do if type(k) == "number" and k > slots then slots = k end end
+            for i = 1, slots do
+                local other = list[i]
+                if other == nil then
+                    holes = holes + 1
+                else
+                    count = count + 1
+                    local okName, name = pcall(function() return other:GetClassName() end)
+                    local entry = { className = (okName and name ~= nil) and tostring(name) or nil }
+                    local okApp, app = pcall(function() return other:GetCurrentAppearanceName() end)
+                    if okApp and app ~= nil then entry.appearance = tostring(app) end
+                    out[#out + 1] = entry
+                end
+            end
+            evidence.entities = out
+            evidence.nilHoles = holes
+            return ok(count, evidence)
+        end,
+    },
+
     -- Row 10. `TweakDB:GetRecord(id)`, not attested by any page or mod on disk, but observed
     -- to work from the CET console (2026-09-08):
     --   print(tostring(TweakDB:GetRecord("Items.Preset_Example")))

package/bridges/cp2077-cet/README.md

@@ -111,7 +111,7 @@ be diagnosed.
 
 Fenced with `-- MODWRIGHT-PROBE-TABLE-BEGIN` / `-- MODWRIGHT-PROBE-TABLE-END` in
 `probes.lua`, so the parity test reads only the table and never an id that appears in a
-comment. Thirteen ids, one per catalogue row, each carrying that row's own status word:
+comment. Fifteen ids, one per catalogue row, each carrying that row's own status word:
 
 | id | Status | If its call is missing |
 |---|---|---|
@@ -120,10 +120,12 @@ comment. Thirteen ids, one per catalogue row, each carrying that row's own statu
 | `cp2077.player.present` | attested(engine) | `error` if `Game` is absent |
 | `cp2077.item.equipped` | attested(engine) | — |
 | `cp2077.inventory.add` | attested(doc), **mutate** | `error`; skipped without `allowMutate` |
+| `cp2077.lua.eval` | **mutate**; runs a request's Lua chunk | skipped without the `session` tier |
 | `cp2077.entity.tagged` | attested(engine) | — |
 | `cp2077.entity.components` | attested(engine) for the call; names unverified | `error` without `params.names` |
 | `cp2077.entity.transform` | attested(engine) for item objects; unverified for a sector prop | says which, in `evidence.attestationForThisCall` |
 | `cp2077.entity.appearance` | unverified (composite) | `skipped` without a baseline |
+| `cp2077.entity.nearby` | unverified — the RTTI methods exist; never run in game | `error` naming the call that raised or returned nil |
 | `cp2077.tweakdb.record` | unverified | `error` |
 | `cp2077.tweakdb.flat` | unverified | `error` |
 | `cp2077.interaction.present` | unverified (the component *name*) | `error` without `params.names` |

package/bridges/cp2077-cet/bridge.json

@@ -43,7 +43,7 @@
     },
     {
       "path": "ModWrightBridge/probes.lua",
-      "sha256": "a9dc28d3fd949f353f17404366bd2bb329813b9ca639e06a9b51aa34c104fb7d"
+      "sha256": "169a31b158edcefda6721c3b90656c59fd9f7d7bf928a96d03ef3645a5eb1991"
     },
     {
       "path": "ModWrightBridge/protocol.lua",

package/dist/core/build/stage.js

@@ -96,12 +96,13 @@ async function planFiles(step, ctx) {
         };
         const isIncluded = (relForMatch) => includeRes.length === 0 || includeRes.some((re) => re.test(relForMatch));
         const add = (abs, relDest) => {
-            const existing = claimed.get(relDest);
+            const key = relDest.toLowerCase();
+            const existing = claimed.get(key);
             if (existing !== undefined && existing !== origin) {
                 throw new BuildStepError(`stage: ${existing} and ${origin} both write "${relDest}" — one would silently overlay the other. ` +
                     `Give one of them its own "into" prefix.`, step.id, step.step);
             }
-            claimed.set(relDest, origin);
+            claimed.set(key, origin);
             files.push({ abs, relDest, origin });
         };
         if (entry.output !== undefined) {

package/dist/core/ini.js

@@ -0,0 +1,26 @@
+export function parseIni(text) {
+    const out = new Map();
+    let section = "";
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith(";") || line.startsWith("#"))
+            continue;
+        const sec = /^\[(.+)\]$/.exec(line);
+        if (sec) {
+            section = sec[1].trim().toLowerCase();
+            continue;
+        }
+        const eq = line.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = line.slice(0, eq).trim().toLowerCase();
+        let value = line.slice(eq + 1).trim();
+        const wrapped = /^@ByteArray\((.*)\)$/.exec(value);
+        if (wrapped)
+            value = wrapped[1];
+        if (!out.has(section))
+            out.set(section, new Map());
+        out.get(section).set(key, value);
+    }
+    return out;
+}

package/dist/core/knowledge/facts.js

@@ -20,18 +20,6 @@ export function idPrefixFor(game) {
 }
 const ID_PATTERN = /^[a-z0-9]+(\.[a-z0-9-]+)+$/;
 const TOPIC_PATTERN = /^[a-z0-9]+(\.[a-z0-9-]+)*$/;
-const KNOWN_FACT_KEYS = [
-    "id",
-    "claim",
-    "status",
-    "verified_on",
-    "verified_by",
-    "source",
-    "tags",
-    "detail",
-    "supersedes",
-    "related",
-];
 const factStatusSchema = z.enum(FACT_STATUSES);
 const optionalString = () => z
     .string()

package/dist/core/logs/registry.js

@@ -21,6 +21,25 @@ export class SignatureRegistry {
                     }
                 }
             }
+            if (sig.attribution) {
+                const spec = sig.attribution;
+                const groups = namedGroupsOf(sig.pattern);
+                for (const field of ["subject", "subjectFallback", "actor", "via", "detail"]) {
+                    const name = spec[field];
+                    if (name !== undefined && !groups.has(name)) {
+                        throw new Error(`Signature "${sig.id}" attribution ${field} "${name}" has no named group "(?<${name}>...)" in its pattern`);
+                    }
+                }
+                if (spec.setsContext && spec.subject === undefined && spec.actor === undefined) {
+                    throw new Error(`Signature "${sig.id}" sets attribution context but captures neither subject nor actor`);
+                }
+                if (spec.setsContext && spec.alsoFinding) {
+                    throw new Error(`Signature "${sig.id}" cannot both set attribution context and report a finding`);
+                }
+                if (spec.subject !== undefined && spec.subjectLabel !== undefined) {
+                    throw new Error(`Signature "${sig.id}" attribution names both a subject group and a subjectLabel`);
+                }
+            }
             seenInBatch.add(sig.id);
         }
         for (const sig of signatures) {

package/dist/core/logs/scan.js

@@ -37,14 +37,14 @@ function parseScanKey(key) {
 }
 export async function scanSource(source, signatures, scope, ctx) {
     if (!source.exists) {
-        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [], attributions: [] };
     }
     let stat;
     try {
         stat = await fs.stat(source.path);
     }
     catch {
-        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [], attributions: [] };
     }
     const sizeBytes = stat.size;
     const modifiedAt = stat.mtime;
@@ -63,7 +63,7 @@ export async function scanSource(source, signatures, scope, ctx) {
         };
         if (stale !== undefined)
             status.stale = stale;
-        return { status, findings: [] };
+        return { status, findings: [], attributions: [] };
     }
     const birthtimeMs = Math.round(stat.birthtimeMs);
     const mtimeMs = Math.round(stat.mtimeMs);
@@ -125,7 +125,7 @@ export async function scanSource(source, signatures, scope, ctx) {
             };
             if (stale !== undefined)
                 status.stale = stale;
-            return { status, findings: [] };
+            return { status, findings: [], attributions: [] };
         }
     }
     if (startOffset === 0 && text.charCodeAt(0) === 0xfeff)
@@ -133,14 +133,18 @@ export async function scanSource(source, signatures, scope, ctx) {
     let lines = splitLines(text);
     if (clipped && lines.length > 0)
         lines.shift();
+    let headTrimmed = clipped;
     if ((!hadOffset || rotated) && lines.length > maxLines) {
         lines = lines.slice(lines.length - maxLines);
+        headTrimmed = true;
     }
     const sinceDate = scope.since ? new Date(scope.since) : undefined;
     let anyTimestampSeen = false;
     let lastTimestamp;
     const findingsBySignature = new Map();
     const findings = [];
+    const attributions = [];
+    const context = {};
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (sinceDate) {
@@ -157,6 +161,39 @@ export async function scanSource(source, signatures, scope, ctx) {
             const match = sig.pattern.exec(line);
             if (!match)
                 continue;
+            const spec = sig.attribution;
+            if (spec) {
+                const group = (name) => name === undefined ? undefined : match.groups?.[name];
+                if (spec.setsContext) {
+                    const subject = group(spec.subject);
+                    const actor = group(spec.actor);
+                    if (subject !== undefined)
+                        context.subject = subject;
+                    if (actor !== undefined)
+                        context.actor = actor;
+                    continue;
+                }
+                const subject = group(spec.subject) ?? group(spec.subjectFallback) ?? spec.subjectLabel ?? context.subject;
+                if (subject !== undefined) {
+                    const record = {
+                        sourceId: source.id,
+                        signatureId: sig.id,
+                        kind: spec.kind,
+                        subject,
+                        actor: group(spec.actor) ?? context.actor ?? "?",
+                        lineNumber: i + 1,
+                    };
+                    const via = group(spec.via);
+                    if (via !== undefined)
+                        record.via = via;
+                    const detail = group(spec.detail);
+                    if (detail !== undefined)
+                        record.detail = detail;
+                    attributions.push(record);
+                }
+                if (!spec.alsoFinding)
+                    continue;
+            }
             const existing = findingsBySignature.get(sig.id);
             if (existing) {
                 existing.repeats = (existing.repeats ?? 0) + 1;
@@ -207,5 +244,7 @@ export async function scanSource(source, signatures, scope, ctx) {
         status.rewritten = true;
     if (sinceDate && !anyTimestampSeen)
         status.timestamps = false;
-    return { status, findings };
+    if (headTrimmed)
+        status.headTrimmed = true;
+    return { status, findings, attributions };
 }

package/dist/core/logs/triage.js

@@ -3,7 +3,9 @@ import { findRunningProcesses } from "../process.js";
 import { resolveLogs } from "../surfaceutil.js";
 import { scanSource } from "./scan.js";
 const FINDINGS_CAP = 200;
-export async function triageLogs(surface, install, registry, scope = {}) {
+const ATTRIBUTION_SUBJECT_CAP = 150;
+const ATTRIBUTION_ACTOR_CAP = 100;
+export async function triageLogs(surface, install, registry, scope = {}, options = {}) {
     const sources = await resolveLogs(surface, install);
     const processResult = await findRunningProcesses(surface.processNames ?? []);
     const gameRunning = processResult.checked ? processResult.running.length > 0 : undefined;
@@ -34,15 +36,17 @@ export async function triageLogs(surface, install, registry, scope = {}) {
     }
     const statuses = [];
     const allFindings = [];
+    const allAttributions = [];
     const offsets = {};
     const offsetKeys = {};
     for (const source of sources) {
         const signatures = registry.forSource(surface.id, source.id);
-        const { status, findings } = await scanSource(source, signatures, scope, { lastLaunch });
+        const { status, findings, attributions } = await scanSource(source, signatures, scope, { lastLaunch });
         if (!source.exists && missingReasons[source.id])
             status.missingReason = missingReasons[source.id];
         statuses.push(status);
         allFindings.push(...findings);
+        allAttributions.push(...attributions);
         if (status.endOffset !== undefined)
             offsets[source.id] = status.endOffset;
         if (status.key !== undefined)
@@ -104,8 +108,81 @@ export async function triageLogs(surface, install, registry, scope = {}) {
         verdict.truncated = true;
     if (Object.keys(systemNotes).length > 0)
         verdict.systemNotes = systemNotes;
+    if (allAttributions.length > 0) {
+        verdict.attribution = buildAttributionReport(allAttributions, statuses, options.attributionFor);
+    }
     return verdict;
 }
+export function buildAttributionReport(records, statuses, filter) {
+    const needle = filter?.trim().toLowerCase();
+    const kept = needle
+        ? records.filter((r) => [r.subject, r.actor, r.via].some((v) => v !== undefined && v.toLowerCase().includes(needle)))
+        : records;
+    const bySubject = new Map();
+    for (const record of kept) {
+        let entry = bySubject.get(record.subject);
+        if (!entry) {
+            entry = { subject: record.subject, kinds: [], actors: [], order: bySubject.size };
+            bySubject.set(record.subject, entry);
+        }
+        if (!entry.kinds.includes(record.kind))
+            entry.kinds.push(record.kind);
+        const same = entry.actors.find((a) => a.actor === record.actor && a.via === record.via && a.kind === record.kind && a.detail === record.detail);
+        if (same) {
+            same.count++;
+            continue;
+        }
+        const actor = {
+            actor: record.actor,
+            kind: record.kind,
+            sourceId: record.sourceId,
+            firstLine: record.lineNumber,
+            count: 1,
+        };
+        if (record.via !== undefined)
+            actor.via = record.via;
+        if (record.detail !== undefined)
+            actor.detail = record.detail;
+        entry.actors.push(actor);
+    }
+    const distinctActors = (subject) => new Set(subject.actors.map((a) => `${a.actor}\u0000${a.via ?? ""}`)).size;
+    const isContested = (subject) => !subject.kinds.every((k) => k === "read-order") && distinctActors(subject) > 1;
+    const all = [...bySubject.values()];
+    const contested = all.filter(isContested).length;
+    all.sort((a, b) => Number(isContested(b)) - Number(isContested(a)) || a.order - b.order);
+    const subjects = all.slice(0, ATTRIBUTION_SUBJECT_CAP).map(({ order: _order, ...subject }) => {
+        if (subject.actors.length <= ATTRIBUTION_ACTOR_CAP)
+            return subject;
+        return {
+            ...subject,
+            actors: subject.actors.slice(0, ATTRIBUTION_ACTOR_CAP),
+            omittedActors: subject.actors.length - ATTRIBUTION_ACTOR_CAP,
+        };
+    });
+    const report = {
+        records: records.length,
+        contested,
+        subjects,
+        note: "Straight from the logs: each actor is who the log line itself names, listed in the order " +
+            "the log shows them acting, so for edits and reads the later actor applied last. Only what " +
+            "the frameworks chose to log is here; a mod that changes something without the loader " +
+            "logging it will not appear.",
+    };
+    if (needle)
+        report.filter = filter.trim();
+    if (all.length > ATTRIBUTION_SUBJECT_CAP)
+        report.omittedSubjects = all.length - ATTRIBUTION_SUBJECT_CAP;
+    const partial = statuses
+        .filter((st) => st.headTrimmed && records.some((r) => r.sourceId === st.source.id))
+        .map((st) => st.source.id);
+    if (partial.length > 0) {
+        report.partialSources = partial;
+        report.note +=
+            ` The start of ${partial.join(", ")} was not read (tail cap), so earlier attribution lines ` +
+                "are missing; pass a larger maxLines (up to 20000) for the whole run.";
+    }
+    return report;
+}
 function buildHeadline(sources, statuses, findings, systems) {
     if (sources.length === 0) {
         return "No log sources are declared for this game; triage has nothing to read.";

package/dist/core/managers/mo2.js

@@ -0,0 +1,121 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { localAppData, pathExists } from "../fsutil.js";
+import { parseIni } from "../ini.js";
+function iniPath(value) {
+    return value.replace(/\\\\/g, "\\");
+}
+function samePath(a, b) {
+    const norm = (p) => path.resolve(iniPath(p)).replace(/[\\/]+$/, "").toLowerCase();
+    return norm(a) === norm(b);
+}
+export async function readMo2Instance(iniFile, portable) {
+    let ini;
+    try {
+        ini = parseIni(await fs.readFile(iniFile, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const instanceDir = path.dirname(iniFile);
+    const general = ini.get("general");
+    const settings = ini.get("settings");
+    const base = iniPath(settings?.get("base_directory") ?? instanceDir);
+    const configured = (key, fallback) => path.resolve(instanceDir, iniPath(settings?.get(key) ?? `%BASE_DIR%/${fallback}`).replace(/%BASE_DIR%/gi, base));
+    const profileName = general?.get("selected_profile") ?? "Default";
+    const profilesDir = configured("profiles_directory", "profiles");
+    const gamePath = general?.get("gamepath");
+    const instance = {
+        instanceDir,
+        iniPath: iniFile,
+        portable,
+        profileName,
+        profileDir: path.join(profilesDir, profileName),
+        modsDir: configured("mod_directory", "mods"),
+        overwriteDir: configured("overwrite_directory", "overwrite"),
+        downloadsDir: configured("download_directory", "downloads"),
+    };
+    if (gamePath)
+        instance.gamePath = iniPath(gamePath);
+    return instance;
+}
+export async function findMo2Instance(install, options = {}) {
+    if (options.instancePath) {
+        const iniFile = options.instancePath.toLowerCase().endsWith(".ini")
+            ? options.instancePath
+            : path.join(options.instancePath, "ModOrganizer.ini");
+        if (await pathExists(iniFile))
+            return readMo2Instance(iniFile, true);
+        return undefined;
+    }
+    const root = options.instancesRoot ?? localAppData("ModOrganizer");
+    let names;
+    try {
+        names = await fs.readdir(root);
+    }
+    catch {
+        return undefined;
+    }
+    for (const name of names) {
+        const iniFile = path.join(root, name, "ModOrganizer.ini");
+        if (!(await pathExists(iniFile)))
+            continue;
+        const instance = await readMo2Instance(iniFile, false);
+        if (instance?.gamePath && samePath(instance.gamePath, install.root))
+            return instance;
+    }
+    return undefined;
+}
+export function parseMo2Modlist(text) {
+    const lines = [];
+    const seen = new Set();
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/^/, "");
+        if (!line.trim() || line.startsWith("#"))
+            continue;
+        const marker = line[0];
+        const hasMarker = marker === "+" || marker === "-" || marker === "*";
+        const name = (hasMarker ? line.slice(1) : line).trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        lines.push({ name, enabled: marker !== "-", foreign: marker === "*" });
+    }
+    return lines.map((entry, index) => ({
+        ...entry,
+        separator: entry.name.endsWith("_separator"),
+        priority: lines.length - index,
+    }));
+}
+export async function readMo2Modlist(profileDir) {
+    try {
+        return parseMo2Modlist(await fs.readFile(path.join(profileDir, "modlist.txt"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readMo2ModMeta(modDir) {
+    let ini;
+    try {
+        ini = parseIni(await fs.readFile(path.join(modDir, "meta.ini"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+    const general = ini.get("general");
+    const meta = {};
+    const modId = Number(general?.get("modid"));
+    if (Number.isInteger(modId) && modId > 0)
+        meta.nexusModId = modId;
+    const version = general?.get("version");
+    if (version)
+        meta.version = version;
+    const installationFile = general?.get("installationfile");
+    if (installationFile)
+        meta.installationFile = installationFile;
+    const gameName = general?.get("gamename");
+    if (gameName)
+        meta.gameName = gameName;
+    return meta;
+}