@memlab/mcp-server 2.18.1 → 2.52.0

package/dist/tools/hypothesis.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall memory_lab
+ */
+import fs from 'fs';
+import vm from 'vm';
+import { z } from 'zod';
+import memlabHeapAnalysis from '@memlab/heap-analysis';
+const { getFullHeapFromFile } = memlabHeapAnalysis;
+import { resolveSnapshotPath } from './load-snapshot.js';
+import { resolveLadderPaths } from './ladder.js';
+import { formatBytes, formatNumber, markdownTable, errorResult, toolResult, } from '../utils.js';
+// Property names used to fingerprint a shape, matching the other shape tools.
+const SHAPE_PROP_CAP = 12;
+// Shapes tracked per rung. Once this many distinct shapes are seen, tracking
+// STOPS and the tail is uncounted (not folded into an "(other)" bucket) — the
+// report says so explicitly. A heap with a million distinct shapes must not turn
+// this into a memory problem of its own.
+const MAX_SHAPES = 2000;
+function shapeKey(node) {
+    if (node.edge_count > 1024)
+        return `${node.name} (too wide)`;
+    const props = [];
+    node.forEachReference(edge => {
+        if (edge.type === 'property') {
+            props.push(String(edge.name_or_index));
+            if (props.length >= SHAPE_PROP_CAP)
+                return { stop: true };
+        }
+    });
+    props.sort();
+    return `${node.name} {${props.join(',')}}`;
+}
+function trendOf(counts) {
+    let up = true;
+    for (let i = 1; i < counts.length; i++) {
+        if (counts[i] <= counts[i - 1])
+            up = false;
+    }
+    const net = counts[counts.length - 1] - counts[0];
+    if (up && net > 0)
+        return '↑ every step';
+    if (net > 0)
+        return 'grew net';
+    if (net < 0)
+        return 'shrank';
+    return 'flat';
+}
+export function registerHypothesis(server) {
+    server.tool('memlab_hypothesis', 'Test one hypothesis against EVERY rung of a snapshot ladder in a single call: supply a JavaScript predicate over heap nodes and get its match count, total self size, and trend per rung. ' +
+        'This is the "is my theory true across the whole ladder?" tool. Without it, confirming a specific theory — "the growth is Maps with a `_pending` field", "it is closures capturing `chatId`" — meant loading each rung separately and re-running a query by hand, at minutes per rung, which is why theories tended to be checked against one snapshot and generalized. ' +
+        'Set group_by_shape to break matches down by property shape per rung instead of a single count, which answers "WHICH variant of this class is the one accumulating?" — the shape sweep that otherwise required a separate pass. Snapshots are loaded one at a time and released, so a long ladder is memory-safe.', {
+        paths: z
+            .array(z.string())
+            .min(1)
+            .describe('Ordered snapshot paths (oldest first). Local paths, manifold:// URLs, bare filenames, or a single ["ladder:<name>"] reference to a ladder saved with memlab_ladder.'),
+        predicate: z
+            .string()
+            .describe('JavaScript expression over `node` returning a boolean, e.g. `node.name === "Map" && node.retainedSize > 10000`, or `node.type === "closure" && node.name.includes("chat")`. Evaluated in a sandbox with no I/O; only the node is exposed. Compiled once and applied per node, so keep it cheap — avoid walking `node.references` for every node in a multi-million-node heap.'),
+        group_by_shape: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Break matches down by property-shape fingerprint per rung (default false: one count per rung). Use to find which variant of a class is accumulating.'),
+        limit: z
+            .number()
+            .optional()
+            .default(15)
+            .describe('Maximum shape rows to report when group_by_shape is set.'),
+        max_file_size_mb: z
+            .number()
+            .optional()
+            .describe('Per-file size ceiling in MB; see memlab_load_snapshot.'),
+    }, async ({ paths, predicate, group_by_shape, limit, max_file_size_mb }) => {
+        try {
+            let test;
+            try {
+                // Compiled ONCE, in a context with nothing in it: the predicate gets
+                // the node it is called with and no ambient capability.
+                test = vm.runInNewContext(`(function(node){ return !!(${predicate}); })`, Object.create(null), { timeout: 1000 });
+            }
+            catch (e) {
+                return errorResult(`Could not compile predicate: ${e instanceof Error ? e.message : String(e)}. It must be a JavaScript EXPRESSION over \`node\` (no statements, no return).`);
+            }
+            const rungs = [];
+            const { paths: rungPaths } = resolveLadderPaths(paths);
+            for (const p of rungPaths) {
+                const { localPath, fetchedFrom } = resolveSnapshotPath(p);
+                if (!fs.existsSync(localPath)) {
+                    return errorResult(`File not found: ${localPath}`);
+                }
+                const sizeMB = fs.statSync(localPath).size / (1024 * 1024);
+                if (max_file_size_mb != null && sizeMB > max_file_size_mb) {
+                    return errorResult(`${p} is ${sizeMB.toFixed(0)} MB, over the ${max_file_size_mb} MB limit.`);
+                }
+                const snapshot = await getFullHeapFromFile(localPath);
+                let matched = 0;
+                let selfBytes = 0;
+                let scanned = 0;
+                let predicateError = null;
+                // memlab's nodes.forEach has no early exit, so a predicate that throws
+                // on the first node would otherwise still walk every remaining node in
+                // a multi-million-node heap before the error is reported. Throwing a
+                // sentinel out of the callback actually stops the walk.
+                class AbortWalk extends Error {
+                }
+                const shapes = new Map();
+                try {
+                    snapshot.nodes.forEach(node => {
+                        scanned++;
+                        let hit = false;
+                        try {
+                            hit = test(node);
+                        }
+                        catch (e) {
+                            // Report the predicate's own failure rather than a silent zero:
+                            // a predicate that throws on the first node would otherwise look
+                            // exactly like a hypothesis that is simply false.
+                            predicateError = e instanceof Error ? e.message : String(e);
+                            throw new AbortWalk();
+                        }
+                        if (!hit)
+                            return;
+                        matched++;
+                        selfBytes += node.self_size;
+                        if (group_by_shape && shapes.size < MAX_SHAPES) {
+                            const k = shapeKey(node);
+                            shapes.set(k, (shapes.get(k) ?? 0) + 1);
+                        }
+                    });
+                }
+                catch (e) {
+                    if (!(e instanceof AbortWalk))
+                        throw e;
+                }
+                if (predicateError != null) {
+                    return errorResult(`Predicate threw while scanning ${p}: ${predicateError}. Guard against missing fields — it is applied to every node in the heap, not just the ones you have in mind.`);
+                }
+                rungs.push({
+                    label: fetchedFrom ?? p.replace(/^.*\//, ''),
+                    matched,
+                    selfBytes,
+                    scanned,
+                    shapes,
+                });
+            }
+            const counts = rungs.map(r => r.matched);
+            const net = counts[counts.length - 1] - counts[0];
+            const lines = [
+                `## Hypothesis across ${rungs.length} snapshot(s)`,
+                '',
+                `\`${predicate}\``,
+                '',
+                markdownTable(['#', 'Snapshot', 'Matches', 'Self size', 'Scanned'], rungs.map((r, i) => [
+                    String(i + 1),
+                    r.label.length > 38 ? '…' + r.label.slice(-37) : r.label,
+                    formatNumber(r.matched),
+                    formatBytes(r.selfBytes),
+                    formatNumber(r.scanned),
+                ]), new Set([2, 3, 4])),
+                '',
+            ];
+            if (rungs.length > 1) {
+                lines.push(`**Verdict: ${trendOf(counts)}** — ${net >= 0 ? '+' : '−'}${formatNumber(Math.abs(net))} matches across the ladder (${formatNumber(counts[0])} → ${formatNumber(counts[counts.length - 1])}).`);
+                if (rungs.length === 2) {
+                    lines.push('', '> ⚠️ With 2 rungs "↑ every step" is the same statement as "grew overall" and cannot separate a trend from a single GC-band sample. Add a third rung.');
+                }
+            }
+            else {
+                lines.push('_Single snapshot: this is a count, not a trend. Pass an ordered ladder to test whether the hypothesis holds over time._');
+            }
+            if (counts.every(c => c === 0)) {
+                lines.push('', '_Zero matches in every rung. The predicate compiled and ran against every node, so this is a real negative — the hypothesis is false as written, or the property/class is named differently than assumed (check with `memlab_class_histogram`)._');
+            }
+            if (group_by_shape) {
+                const allShapes = new Set();
+                for (const r of rungs)
+                    for (const k of r.shapes.keys())
+                        allShapes.add(k);
+                const shapeRows = [...allShapes]
+                    .map(k => ({
+                    shape: k,
+                    per: rungs.map(r => r.shapes.get(k) ?? 0),
+                }))
+                    .map(x => ({
+                    ...x,
+                    net: x.per[x.per.length - 1] - x.per[0],
+                }))
+                    .sort((a, b) => b.net - a.net ||
+                    b.per[b.per.length - 1] - a.per[a.per.length - 1])
+                    .slice(0, limit);
+                if (shapeRows.length > 0) {
+                    lines.push('', '### Matches by shape', '', markdownTable([
+                        'Shape',
+                        ...rungs.map((_, i) => `#${i + 1}`),
+                        'Δ',
+                        ...(rungs.length > 1 ? ['Trend'] : []),
+                    ], shapeRows.map(r => [
+                        r.shape.length > 56 ? r.shape.slice(0, 53) + '…}' : r.shape,
+                        ...r.per.map(c => formatNumber(c)),
+                        `${r.net >= 0 ? '+' : '−'}${formatNumber(Math.abs(r.net))}`,
+                        ...(rungs.length > 1 ? [trendOf(r.per)] : []),
+                    ]), new Set(rungs.map((_, i) => i + 1).concat([rungs.length + 1]))));
+                    if (rungs.some(r => r.shapes.size >= MAX_SHAPES)) {
+                        lines.push('', `_⚠ Shape tracking capped at ${formatNumber(MAX_SHAPES)} distinct shapes per rung; the tail is not counted. Narrow the predicate._`);
+                    }
+                }
+            }
+            return toolResult(lines.join('\n'));
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+}
+//# sourceMappingURL=hypothesis.js.map

package/dist/tools/hypothesis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypothesis.js","sourceRoot":"","sources":["../../src/tools/hypothesis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,kBAAkB,MAAM,uBAAuB,CAAC;AACvD,MAAM,EAAC,mBAAmB,EAAC,GAAG,kBAAkB,CAAC;AACjD,OAAO,EAAC,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAC/C,OAAO,EACL,WAAW,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,8EAA8E;AAC9E,MAAM,cAAc,GAAG,EAAE,CAAC;AAC1B,6EAA6E;AAC7E,8EAA8E;AAC9E,iFAAiF;AACjF,yCAAyC;AACzC,MAAM,UAAU,GAAG,IAAI,CAAC;AAExB,SAAS,QAAQ,CAAC,IAAe;IAC/B,IAAI,IAAI,CAAC,UAAU,GAAG,IAAI;QAAE,OAAO,GAAG,IAAI,CAAC,IAAI,aAAa,CAAC;IAC7D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;QAC3B,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC7B,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACvC,IAAI,KAAK,CAAC,MAAM,IAAI,cAAc;gBAAE,OAAO,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC;QAC1D,CAAC;IACH,CAAC,CAAC,CAAC;IACH,KAAK,CAAC,IAAI,EAAE,CAAC;IACb,OAAO,GAAG,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED,SAAS,OAAO,CAAC,MAAgB;IAC/B,IAAI,EAAE,GAAG,IAAI,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;YAAE,EAAE,GAAG,KAAK,CAAC;IAC7C,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,EAAE,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,cAAc,CAAC;IACzC,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,UAAU,CAAC;IAC/B,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC7B,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,MAAiB;IAClD,MAAM,CAAC,IAAI,CACT,mBAAmB,EACnB,4LAA4L;QAC1L,yWAAyW;QACzW,kTAAkT,EACpT;QACE,KAAK,EAAE,CAAC;aACL,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aACjB,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CACP,qKAAqK,CACtK;QACH,SAAS,EAAE,CAAC;aACT,MAAM,EAAE;aACR,QAAQ,CACP,+WAA+W,CAChX;QACH,cAAc,EAAE,CAAC;aACd,OAAO,EAAE;aACT,QAAQ,EAAE;aACV,OAAO,CAAC,KAAK,CAAC;aACd,QAAQ,CACP,sJAAsJ,CACvJ;QACH,KAAK,EAAE,CAAC;aACL,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,OAAO,CAAC,EAAE,CAAC;aACX,QAAQ,CAAC,0DAA0D,CAAC;QACvE,gBAAgB,EAAE,CAAC;aAChB,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,QAAQ,CAAC,wDAAwD,CAAC;KACtE,EACD,KAAK,EAAE,EAAC,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,EAAC,EAAE,EAAE;QACpE,IAAI,CAAC;YACH,IAAI,IAAkC,CAAC;YACvC,IAAI,CAAC;gBACH,qEAAqE;gBACrE,wDAAwD;gBACxD,IAAI,GAAG,EAAE,CAAC,eAAe,CACvB,8BAA8B,SAAS,OAAO,EAC9C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EACnB,EAAC,OAAO,EAAE,IAAI,EAAC,CACgB,CAAC;YACpC,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,WAAW,CAChB,gCAAgC,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,gFAAgF,CAC3J,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAMN,EAAE,CAAC;YAER,MAAM,EAAC,KAAK,EAAE,SAAS,EAAC,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;YACrD,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;gBAC1B,MAAM,EAAC,SAAS,EAAE,WAAW,EAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;gBACxD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;oBAC9B,OAAO,WAAW,CAAC,mBAAmB,SAAS,EAAE,CAAC,CAAC;gBACrD,CAAC;gBACD,MAAM,MAAM,GAAG,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;gBAC3D,IAAI,gBAAgB,IAAI,IAAI,IAAI,MAAM,GAAG,gBAAgB,EAAE,CAAC;oBAC1D,OAAO,WAAW,CAChB,GAAG,CAAC,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB,gBAAgB,YAAY,CAC1E,CAAC;gBACJ,CAAC;gBACD,MAAM,QAAQ,GAAG,MAAM,mBAAmB,CAAC,SAAS,CAAC,CAAC;gBACtD,IAAI,OAAO,GAAG,CAAC,CAAC;gBAChB,IAAI,SAAS,GAAG,CAAC,CAAC;gBAClB,IAAI,OAAO,GAAG,CAAC,CAAC;gBAChB,IAAI,cAAc,GAAkB,IAAI,CAAC;gBACzC,uEAAuE;gBACvE,uEAAuE;gBACvE,qEAAqE;gBACrE,wDAAwD;gBACxD,MAAM,SAAU,SAAQ,KAAK;iBAAG;gBAChC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,CAAC;oBACH,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;wBAC5B,OAAO,EAAE,CAAC;wBACV,IAAI,GAAG,GAAG,KAAK,CAAC;wBAChB,IAAI,CAAC;4BACH,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;wBACnB,CAAC;wBAAC,OAAO,CAAC,EAAE,CAAC;4BACX,gEAAgE;4BAChE,iEAAiE;4BACjE,kDAAkD;4BAClD,cAAc,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;4BAC5D,MAAM,IAAI,SAAS,EAAE,CAAC;wBACxB,CAAC;wBACD,IAAI,CAAC,GAAG;4BAAE,OAAO;wBACjB,OAAO,EAAE,CAAC;wBACV,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC;wBAC5B,IAAI,cAAc,IAAI,MAAM,CAAC,IAAI,GAAG,UAAU,EAAE,CAAC;4BAC/C,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;4BACzB,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;wBAC1C,CAAC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,IAAI,CAAC,CAAC,CAAC,YAAY,SAAS,CAAC;wBAAE,MAAM,CAAC,CAAC;gBACzC,CAAC;gBACD,IAAI,cAAc,IAAI,IAAI,EAAE,CAAC;oBAC3B,OAAO,WAAW,CAChB,kCAAkC,CAAC,KAAK,cAAc,+GAA+G,CACtK,CAAC;gBACJ,CAAC;gBACD,KAAK,CAAC,IAAI,CAAC;oBACT,KAAK,EAAE,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;oBAC5C,OAAO;oBACP,SAAS;oBACT,OAAO;oBACP,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;YAED,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACzC,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,KAAK,GAAa;gBACtB,wBAAwB,KAAK,CAAC,MAAM,cAAc;gBAClD,EAAE;gBACF,KAAK,SAAS,IAAI;gBAClB,EAAE;gBACF,aAAa,CACX,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,CAAC,EACpD,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAClB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;oBACb,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK;oBACxD,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;oBACvB,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;oBACxB,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;iBACxB,CAAC,EACF,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CACnB;gBACD,EAAE;aACH,CAAC;YAEF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,KAAK,CAAC,IAAI,CACR,cAAc,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,+BAA+B,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAC/L,CAAC;gBACF,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACvB,KAAK,CAAC,IAAI,CACR,EAAE,EACF,sJAAsJ,CACvJ,CAAC;gBACJ,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CACR,yHAAyH,CAC1H,CAAC;YACJ,CAAC;YAED,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC/B,KAAK,CAAC,IAAI,CACR,EAAE,EACF,kPAAkP,CACnP,CAAC;YACJ,CAAC;YAED,IAAI,cAAc,EAAE,CAAC;gBACnB,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;gBACpC,KAAK,MAAM,CAAC,IAAI,KAAK;oBACnB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE;wBAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACpD,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;qBAC7B,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBACT,KAAK,EAAE,CAAC;oBACR,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;iBAC1C,CAAC,CAAC;qBACF,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBACT,GAAG,CAAC;oBACJ,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;iBACxC,CAAC,CAAC;qBACF,IAAI,CACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACP,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG;oBACb,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CACpD;qBACA,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBACnB,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzB,KAAK,CAAC,IAAI,CACR,EAAE,EACF,sBAAsB,EACtB,EAAE,EACF,aAAa,CACX;wBACE,OAAO;wBACP,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBACnC,GAAG;wBACH,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;qBACvC,EACD,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;wBACjB,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK;wBAC3D,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;wBAClC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE;wBAC3D,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;qBAC9C,CAAC,EACF,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAC/D,CACF,CAAC;oBACF,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,IAAI,UAAU,CAAC,EAAE,CAAC;wBACjD,KAAK,CAAC,IAAI,CACR,EAAE,EACF,+BAA+B,YAAY,CAAC,UAAU,CAAC,4EAA4E,CACpI,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;YAED,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACtC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/intern-opportunities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intern-opportunities.d.ts","sourceRoot":"","sources":["../../src/tools/intern-opportunities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AAyNvE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAi3BnE"}
+{"version":3,"file":"intern-opportunities.d.ts","sourceRoot":"","sources":["../../src/tools/intern-opportunities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AAmPvE,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAq8BnE"}

package/dist/tools/intern-opportunities.js

@@ -10,6 +10,9 @@
 import { z } from 'zod';
 import { getSnapshot, getSnapshotMetadata, getSessionConfig, } from '../heap-state.js';
 import { formatBytes, formatNumber, markdownTable, errorResult, toolResult, } from '../utils.js';
+import { collectDevRoots, computeReachableWithoutDevRoots, } from './dev-artifacts.js';
+import { buildStringIndex } from '../string-index.js';
+import { classifyNonProductionString, isHarnessToolManifestShape, } from '../artifact-classes.js';
 // V8 splits a single logical object's storage across several internal backing
 // structures: a `system / PropertyArray` (named props once the object grows past
 // the inline slot count), `(object properties)` / `(object elements)` arrays, and
@@ -150,7 +153,7 @@ function isFrameworkOwned(propertyName, parentShape, parentShapeProps) {
 export function registerInternOpportunities(server) {
     server.tool('memlab_intern_opportunities', 'Identify string interning opportunities by grouping duplicated strings by the property name and parent object shape that holds them. Shows total savings per (property × shape) combination — the key metric for deciding where to add a string interning pool. Also surfaces ARRAY-ELEMENT / columnar duplication (strings held as elements of a rowsAsArray / string[][] result buffer — a common Nest mysql2/Drizzle shape) as first-class groups keyed by column index and array-owner shape, folded into the within-load headline; these are marked with a filled square and fixed by interning at the array-construction/parse site. The within-load figure is split at the canonical 128-char intern cap into cappable (<=128 chars, what the recommended fix reclaims) vs over-cap (longer strings the cap skips), so the headline matches what a compliant fix actually reclaims. Replaces the manual workflow of: duplicated_strings → retainer_summary → codebase grep. ' +
         'Retention-aware: flags groups whose duplicated instances are ALSO held by another structure (e.g. a raw array/matrix) as "co-retained" — interning the property there reclaims ~0, so the savings are reported separately and you must dedupe the shared source instead. ' +
-        'The headline "within-load capturable" figure also excludes framework/infra-owned strings (HTTP headers, cookies, auth tokens, Next.js URL/cache context) and low-ROI groups (high-cardinality + long strings, where the intern pool costs more than it saves), reporting each in its own bucket; and it flags concatenated-string (rope) buildup, which is accumulation rather than duplication and cannot be interned. ' +
+        'The headline "within-load capturable" figure also excludes framework/infra-owned strings (HTTP headers, cookies, auth tokens, Next.js URL/cache context), measurement-harness content (the CDP/devtools bridge injected to drive the session — an injected bundle can be the single largest "opportunity" in a driven snapshot while reclaiming nothing in production), and low-ROI groups (high-cardinality + long strings, where the intern pool costs more than it saves), reporting each in its own bucket; and it flags concatenated-string (rope) buildup, which is accumulation rather than duplication and cannot be interned. ' +
         '⚠ Full-heap scan (builds string-duplication groups) — slow and memory-heavy on very large heaps (millions of nodes); raise min_copies / min_savings to bound it.', {
         limit: z
             .number()
@@ -177,45 +180,35 @@ export function registerInternOpportunities(server) {
             const snapshot = getSnapshot();
             const meta = getSnapshotMetadata();
             const totalSize = meta?.totalSize ?? 0;
-            // Step 1: Build frequency map of duplicated strings
-            const stringMap = new Map();
-            // Cheap retention-pattern signal (Feedback round 7 §4): a heap dominated
-            // by `(concatenated string)` (cons/rope) nodes is string ACCUMULATION
-            // (repeated `+=` / join into a long-lived buffer), NOT value duplication
-            // — interning cannot help. Count them by name in the pass we already do
-            // (O(1) per node, no value materialization) so we can flag the pattern
-            // instead of silently reporting tiny interning wins.
-            let concatStringCount = 0;
-            let concatStringSize = 0;
-            snapshot.nodes.forEach(node => {
-                if (node.name === '(concatenated string)') {
-                    concatStringCount++;
-                    concatStringSize += node.self_size;
-                }
-                if (node.type !== 'string')
-                    return;
-                if (node.name === 'system / SlicedString')
-                    return;
-                const strNode = node.toStringNode();
-                if (!strNode)
-                    return;
-                const value = strNode.stringValue;
-                const entry = stringMap.get(value);
-                if (entry) {
-                    entry.count++;
-                    entry.totalSize += node.retainedSize;
-                    if (entry.exampleIds.length < 20) {
-                        entry.exampleIds.push(node.id);
-                    }
-                }
-                else {
-                    stringMap.set(value, {
-                        count: 1,
-                        totalSize: node.retainedSize,
-                        exampleIds: [node.id],
-                    });
-                }
+            // Step 1: per-value string duplication index.
+            //
+            // Shared with memlab_duplicated_strings and cached per snapshot, so the
+            // two tools (routinely run back to back) walk the string nodes once
+            // between them rather than once each. The dev-root reachability pass is
+            // requested here because only this tool needs it: strings retained ONLY
+            // through a dev/automation root — overwhelmingly the attached
+            // inspector's console holding dev-build log records — cannot be
+            // reclaimed by an intern pool in production, and counting them inflates
+            // the headline saving.
+            //
+            // `(concatenated string)` (cons/rope) nodes are counted by the same
+            // index: a heap dominated by them is string ACCUMULATION (repeated `+=`
+            // / join into a long-lived buffer), NOT value duplication, and
+            // interning cannot help. Flagging the pattern beats reporting a tiny
+            // interning win against it. (Feedback round 7 §4.)
+            const devRoots = collectDevRoots(snapshot);
+            const productionReachable = devRoots.byId.size > 0
+                ? computeReachableWithoutDevRoots(snapshot, devRoots)
+                : null;
+            const isDevOnlyNode = (node) => productionReachable != null &&
+                productionReachable[node.nodeIndex] === 0;
+            const stringIndex = buildStringIndex(snapshot, {
+                withDevOnly: true,
+                isDevOnlyNode,
             });
+            const stringMap = stringIndex.byValue;
+            const concatStringCount = stringIndex.concatStringCount;
+            const concatStringSize = stringIndex.concatStringSize;
             // Step 2: For duplicated strings, sample referrers to get property × shape
             const groupMap = new Map();
             for (const [value, stats] of stringMap) {
@@ -383,6 +376,8 @@ export function registerInternOpportunities(server) {
                     const scaleFactor = stats.count / samplesProcessed;
                     const trueCount = Math.round(dist.sampledCount * scaleFactor);
                     const trueSize = stats.totalSize * (dist.sampledCount / samplesProcessed);
+                    const devOnlyShare = stats.count > 0 ? stats.devOnlyCount / stats.count : 0;
+                    const trueDevOnly = trueCount * devOnlyShare;
                     const existing = groupMap.get(groupKey);
                     if (existing) {
                         const strEntry = existing.strings.get(value);
@@ -398,6 +393,7 @@ export function registerInternOpportunities(server) {
                         }
                         existing.totalCopies += trueCount;
                         existing.totalSize += trueSize;
+                        existing.devOnlyCopies += trueDevOnly;
                         existing.groupSamples += dist.sampledCount;
                         existing.coRetainedSamples += dist.coRetainedCount;
                         if (!existing.coRetainedVia && dist.coRetainedVia) {
@@ -419,6 +415,7 @@ export function registerInternOpportunities(server) {
                             strings: new Map([[value, { count: trueCount, size: trueSize }]]),
                             totalCopies: trueCount,
                             totalSize: trueSize,
+                            devOnlyCopies: trueDevOnly,
                             exampleParentId: dist.parentId,
                             groupSamples: dist.sampledCount,
                             coRetainedSamples: dist.coRetainedCount,
@@ -436,6 +433,12 @@ export function registerInternOpportunities(server) {
                 let savingsIfInterned = 0;
                 let savingsCappable = 0;
                 let savingsOverCap = 0;
+                // Savings attributable to harness-injected string CONTENT. Compared
+                // against savingsIfInterned below rather than tripping on the first
+                // match, so one stray bridge string in an otherwise-app group does
+                // not relabel the whole group.
+                let savingsHarness = 0;
+                let harnessWhat;
                 const topStrings = [];
                 for (const [value, strStats] of g.strings) {
                     if (strStats.count > 1) {
@@ -448,6 +451,16 @@ export function registerInternOpportunities(server) {
                             savingsCappable += s;
                         else
                             savingsOverCap += s;
+                        const nonProd = classifyNonProductionString(value);
+                        if (nonProd != null) {
+                            savingsHarness += s;
+                            if (!harnessWhat) {
+                                harnessWhat =
+                                    nonProd.kind === 'dev-build'
+                                        ? `${nonProd.what} — DEV build only, absent in production`
+                                        : nonProd.what;
+                            }
+                        }
                     }
                     topStrings.push({
                         value,
@@ -462,6 +475,16 @@ export function registerInternOpportunities(server) {
                 // another structure — interning the property alone reclaims ~0.
                 const coRetained = g.coRetainedSamples > 0 &&
                     g.coRetainedSamples >= g.groupSamples * 0.5;
+                // Harness by CONTENT (majority of the group's savings sits in
+                // bridge-injected strings) or by SHAPE (the parent is one of the
+                // bridge's tool-manifest entries, whose long `.description` strings a
+                // per-load pool would happily "save"). The shape test is what catches
+                // the manifest — its descriptions are ordinary English and no content
+                // signature can distinguish them from app copy.
+                const harnessShape = isHarnessToolManifestShape(g.parentShapeProps);
+                const harness = harnessShape ||
+                    (savingsIfInterned > 0 &&
+                        savingsHarness >= savingsIfInterned * 0.5);
                 groups.push({
                     propertyName: g.propertyName,
                     parentShape: g.parentShapeKey,
@@ -479,6 +502,15 @@ export function registerInternOpportunities(server) {
                     coRetainedVia: coRetained ? g.coRetainedVia : undefined,
                     lowRoi: isLowRoiGroup(g.strings.size, g.totalCopies, g.totalSize),
                     frameworkOwned: isFrameworkOwned(g.propertyName, g.parentShapeKey, g.parentShapeProps),
+                    // Majority-dev-only rather than any-dev-only: a group can legitimately
+                    // mix a few console-held copies with real app data, and only a group
+                    // that is essentially all inspector-held should leave the headline.
+                    devOnly: g.totalCopies > 0 && g.devOnlyCopies / g.totalCopies >= 0.8,
+                    harness,
+                    harnessWhat: harness
+                        ? (harnessWhat ??
+                            'automation/devtools bridge tool manifest (.description strings)')
+                        : undefined,
                 });
             }
             groups.sort((a, b) => b.savingsIfInterned - a.savingsIfInterned);
@@ -563,6 +595,15 @@ export function registerInternOpportunities(server) {
             // is retention-then-ROI; every non-`within` bucket is excluded from the
             // within-load headline regardless of which one a group lands in.
             const bucketOf = (g) => {
+                // Checked before everything else: harness content is not the
+                // application's memory at all — it is the rig injected to observe it —
+                // so no other classification of it is meaningful.
+                if (g.harness)
+                    return 'harness';
+                // Retention through a dev root means interning reclaims nothing in
+                // production, whatever the property is named.
+                if (g.devOnly)
+                    return 'devOnly';
                 if (g.frameworkOwned)
                     return 'framework';
                 if (g.coRetained)
@@ -579,7 +620,9 @@ export function registerInternOpportunities(server) {
             const coRetainedSavings = sumBucket('coRetained');
             const crossLoadSavings = sumBucket('crossLoad');
             const frameworkSavings = sumBucket('framework');
+            const devOnlySavings = sumBucket('devOnly');
             const lowRoiSavings = sumBucket('lowRoi');
+            const harnessSavings = sumBucket('harness');
             const withinLoadSavings = sumBucket('within');
             // Within the capturable bucket, split by the canonical 128-char cap so the
             // headline reports what a COMPLIANT fix reclaims, not the raw total that
@@ -600,7 +643,9 @@ export function registerInternOpportunities(server) {
                 crossLoadSavings +
                 coRetainedSavings +
                 frameworkSavings +
-                lowRoiSavings;
+                devOnlySavings +
+                lowRoiSavings +
+                harnessSavings;
             const pctOf = (n) => totalSize > 0
                 ? ` (${((n / totalSize) * 100).toFixed(1)}% of heap)`
                 : '';
@@ -642,7 +687,7 @@ export function registerInternOpportunities(server) {
                 // produce a malformed label, so only prefix `.` for named properties.
                 const label = g.arrayElement ? g.propertyName : `.${g.propertyName}`;
                 return [
-                    `${label}${g.arrayElement ? ' ▦' : ''}${g.coRetained ? ' ⚠' : ''}${g.crossLoad ? ' ⤫' : ''}${g.frameworkOwned ? ' ▤' : ''}${g.lowRoi ? ' ▽' : ''}`,
+                    `${label}${g.arrayElement ? ' ▦' : ''}${g.coRetained ? ' ⚠' : ''}${g.crossLoad ? ' ⤫' : ''}${g.devOnly ? ' 🛠' : ''}${g.harness ? ' 🧪' : ''}${g.frameworkOwned ? ' ▤' : ''}${g.lowRoi ? ' ▽' : ''}`,
                     shape,
                     formatNumber(g.uniqueStrings),
                     formatNumber(g.totalCopies),
@@ -707,18 +752,21 @@ export function registerInternOpportunities(server) {
                 coRetainedSavings >= crossLoadSavings &&
                 coRetainedSavings >= frameworkSavings &&
                 coRetainedSavings >= lowRoiSavings &&
+                coRetainedSavings >= harnessSavings &&
                 coRetainedSavings > 0) {
                 verdict = `Verdict: mostly **co-retained** (${formatBytes(coRetainedSavings)}) — interning the property won't help; dedupe at the shared source.`;
             }
             else if (crossLoadSavings >= withinLoadSavings &&
                 crossLoadSavings >= frameworkSavings &&
                 crossLoadSavings >= lowRoiSavings &&
+                crossLoadSavings >= harnessSavings &&
                 crossLoadSavings > 0) {
                 verdict = `Verdict: mostly **cross-load** (${formatBytes(crossLoadSavings)}) — a per-request pool won't collapse it; needs a shared/module-scope pool or a retention fix.`;
             }
             else if (withinLoadSavings > 0 &&
                 withinLoadSavings >= frameworkSavings &&
-                withinLoadSavings >= lowRoiSavings) {
+                withinLoadSavings >= lowRoiSavings &&
+                withinLoadSavings >= harnessSavings) {
                 // Lead with the ≤128-char cappable figure — the amount the canonical
                 // intern fix actually reclaims — not the raw within-load total that also
                 // counts over-cap strings the fix skips (feedback §3).
@@ -730,11 +778,15 @@ export function registerInternOpportunities(server) {
                     : '';
                 verdict = `Verdict: **${formatBytes(withinCappable)} cappable** by the canonical ≤${CANONICAL_CAP_CHARS}-char per-load/per-request intern pool at the parse boundary${capNote}.${columnarNote}`;
             }
-            else if (frameworkSavings + lowRoiSavings > 0) {
-                // Framework/low-ROI dominate (each ≥ the within-load figure). Lead with
-                // them so a small capturable remainder isn't mistaken for the headline,
-                // but still name that remainder when nonzero so it isn't hidden.
+            else if (frameworkSavings + lowRoiSavings + harnessSavings > 0) {
+                // Framework/low-ROI/harness dominate (each ≥ the within-load figure).
+                // Lead with them so a small capturable remainder isn't mistaken for the
+                // headline, but still name that remainder when nonzero so it isn't
+                // hidden.
                 const parts = [];
+                if (harnessSavings > 0) {
+                    parts.push('measurement-harness content (the injected automation/devtools bridge — not application memory)');
+                }
                 if (frameworkSavings > 0) {
                     parts.push('framework/infra-owned (headers/cookies/tokens)');
                 }
@@ -777,6 +829,17 @@ export function registerInternOpportunities(server) {
             if (frameworkSavings > 0) {
                 headerLines.push(`- **▤ Framework/infra-owned (HTTP headers, cookies, auth tokens, Next.js URL/cache context — not app data; out of scope for an app-level intern pool): ${formatBytes(frameworkSavings)}${pctOf(frameworkSavings)}**`);
             }
+            if (devOnlySavings > 0) {
+                headerLines.push(`- **🛠 Dev/automation-retained (held only via the attached inspector's console or another dev root — reclaims NOTHING in production; do not chase): ${formatBytes(devOnlySavings)}${pctOf(devOnlySavings)}**`);
+            }
+            if (harnessSavings > 0) {
+                const whats = [
+                    ...new Set(shown
+                        .filter(g => g.harness && g.harnessWhat)
+                        .map(g => g.harnessWhat)),
+                ];
+                headerLines.push(`- **🧪 Measurement-harness content (${whats.join('; ')}) — the CDP/devtools bridge injected into the page to drive this session, NOT application memory; interning it reclaims nothing in production: ${formatBytes(harnessSavings)}${pctOf(harnessSavings)}**`);
+            }
             if (lowRoiSavings > 0) {
                 headerLines.push(`- **▽ Low-ROI (high-cardinality, few repeats + long strings — a per-load pool retains a large unique set for a small collapse; usually skip): ${formatBytes(lowRoiSavings)}${pctOf(lowRoiSavings)}**`);
             }
@@ -794,9 +857,11 @@ export function registerInternOpportunities(server) {
             if (coRetainedGroups.length > 0 ||
                 crossLoadSavings > 0 ||
                 frameworkSavings > 0 ||
+                devOnlySavings > 0 ||
+                harnessSavings > 0 ||
                 lowRoiSavings > 0 ||
                 hasArrayElement) {
-                lines.push("▦ = array element (columnar / rowsAsArray — intern at the parse site); ⚠ = co-retained (interning won't reclaim); ⤫ = cross-load (high Dup ×, needs shared pool); ▤ = framework/infra-owned (not app data); ▽ = low-ROI (high-cardinality + long; usually skip).", '');
+                lines.push("▦ = array element (columnar / rowsAsArray — intern at the parse site); ⚠ = co-retained (interning won't reclaim); ⤫ = cross-load (high Dup ×, needs shared pool); ▤ = framework/infra-owned (not app data); 🛠 = dev/automation-retained (inspector console — reclaims nothing in production); 🧪 = measurement-harness content (injected automation/devtools bridge — not app memory); ▽ = low-ROI (high-cardinality + long; usually skip).", '');
             }
             // Triage mode: stop after the headline split + ranked table. Drops the
             // per-group string lists, partial-interning detail, and the fix recipe