@memlab/mcp-server 2.3.0 → 2.52.0

package/dist/string-index.js

@@ -0,0 +1,91 @@
+/**
+ * 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 { getEvalScratch } from './heap-state.js';
+// Bounded so the index cannot grow with instance count; 20 is what the
+// deepest consumer (intern_opportunities' referrer sampling) needs.
+const MAX_EXAMPLE_IDS = 20;
+const CACHE_KEY = '__memlabStringIndex';
+/**
+ * Build (or reuse) the per-value string duplication index for a snapshot.
+ *
+ * `memlab_duplicated_strings` and `memlab_intern_opportunities` were each doing
+ * their own full pass over every string node to build the same value → {count,
+ * size, ids} map, and both are commonly run back to back on the same snapshot —
+ * so the second one re-walked millions of nodes to recompute what the first had
+ * already produced. The scan is cached in the per-snapshot eval scratch, which
+ * already has exactly the lifecycle this needs: keyed by the active handle, and
+ * dropped when that snapshot is replaced or unloaded, so a stale index can never
+ * outlive the graph its node ids refer to.
+ *
+ * `withDevOnly` gates the dev/automation reachability pass, which is a whole-
+ * graph walk that only `intern_opportunities` needs. A cached index built
+ * without it is UPGRADED (rebuilt once) rather than silently returned, since
+ * `devOnlyCount: -1` would otherwise be read as "no dev-only copies".
+ */
+export function buildStringIndex(snapshot, opts = {}) {
+    const scratch = getEvalScratch();
+    const cached = scratch[CACHE_KEY];
+    const wantDevOnly = opts.withDevOnly === true;
+    if (cached && (!wantDevOnly || cached.hasDevOnly)) {
+        return cached;
+    }
+    const isDevOnly = wantDevOnly ? opts.isDevOnlyNode : undefined;
+    const byValue = new Map();
+    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;
+        // Sliced strings share a parent's storage, so they are not independent
+        // duplicates and counting them would overstate any interning win.
+        if (node.name === 'system / SlicedString')
+            return;
+        const strNode = node.toStringNode();
+        if (!strNode)
+            return;
+        const value = strNode.stringValue;
+        const devOnly = isDevOnly != null && isDevOnly(node);
+        const entry = byValue.get(value);
+        if (entry) {
+            entry.count++;
+            entry.totalSize += node.retainedSize;
+            if (devOnly)
+                entry.devOnlyCount++;
+            if (entry.exampleIds.length < MAX_EXAMPLE_IDS) {
+                entry.exampleIds.push(node.id);
+            }
+        }
+        else {
+            byValue.set(value, {
+                count: 1,
+                totalSize: node.retainedSize,
+                exampleIds: [node.id],
+                devOnlyCount: isDevOnly == null ? -1 : devOnly ? 1 : 0,
+            });
+        }
+    });
+    const index = {
+        byValue,
+        hasDevOnly: isDevOnly != null,
+        concatStringCount,
+        concatStringSize,
+    };
+    scratch[CACHE_KEY] = index;
+    return index;
+}
+/** True when this snapshot's string index is already built and resident. */
+export function stringIndexIsCached() {
+    return getEvalScratch()[CACHE_KEY] != null;
+}
+//# sourceMappingURL=string-index.js.map

package/dist/string-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-index.js","sourceRoot":"","sources":["../src/string-index.ts"],"names":[],"mappings":"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"}

package/dist/tool-registry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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
+ */
+/**
+ * Name -> handler index of every registered tool, so one tool can dispatch to
+ * another in-process (see `memlab_batch`).
+ *
+ * Populated from the same `server.tool` monkey-patch the wall-clock guardrail
+ * installs, which is the one place every registration already funnels through —
+ * so no call site has to opt in and the index cannot drift from the real tool
+ * list.
+ *
+ * The RAW (pre-guardrail) handler is stored on purpose. The wrapped handler arms
+ * an analysis budget per call, and a batch is itself running inside one; nesting
+ * `beginAnalysisBudget` would let an inner step's `endAnalysisBudget` retire the
+ * outer batch's budget early. Storing the raw handler keeps exactly one budget
+ * per MCP call — the batch's own, which callers can size with `timeout_ms`.
+ */
+type RawToolHandler = (...args: unknown[]) => unknown;
+/**
+ * The raw handler expects arguments the SDK has ALREADY validated against the
+ * tool's zod shape, which is where `.default()` values are materialized. A
+ * caller that invokes the raw handler with a plain object therefore gets
+ * `undefined` for every omitted optional — and an omitted `min_count` silently
+ * turns a scan into "no results found" rather than an error. So the shape is
+ * stored next to the handler and re-applied by the dispatcher.
+ */
+export interface RegisteredTool {
+    handler: RawToolHandler;
+    shape: Record<string, unknown> | null;
+}
+export declare function recordToolHandler(name: string, handler: RawToolHandler, shape: Record<string, unknown> | null): void;
+export declare function getRegisteredTool(name: string): RegisteredTool | undefined;
+export declare function listToolNames(): string[];
+export {};
+//# sourceMappingURL=tool-registry.d.ts.map

package/dist/tool-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../src/tool-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,KAAK,cAAc,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AAEtD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACvC;AAID,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACpC,IAAI,CAEN;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAE1E;AAED,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAExC"}

package/dist/tool-registry.js

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+const tools = new Map();
+export function recordToolHandler(name, handler, shape) {
+    tools.set(name, { handler, shape });
+}
+export function getRegisteredTool(name) {
+    return tools.get(name);
+}
+export function listToolNames() {
+    return [...tools.keys()].sort();
+}
+//# sourceMappingURL=tool-registry.js.map

package/dist/tool-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-registry.js","sourceRoot":"","sources":["../src/tool-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiCH,MAAM,KAAK,GAAG,IAAI,GAAG,EAA0B,CAAC;AAEhD,MAAM,UAAU,iBAAiB,CAC/B,IAAY,EACZ,OAAuB,EACvB,KAAqC;IAErC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,OAAO,EAAE,KAAK,EAAC,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,aAAa;IAC3B,OAAO,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AAClC,CAAC"}

package/dist/tools/analyze-run.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAnalyzeRun(server: McpServer): void;
+//# sourceMappingURL=analyze-run.d.ts.map

package/dist/tools/analyze-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-run.d.ts","sourceRoot":"","sources":["../../src/tools/analyze-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AA6KvE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA8U1D"}

package/dist/tools/analyze-run.js

@@ -0,0 +1,343 @@
+/**
+ * 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 path from 'path';
+import memlabHeapAnalysis from '@memlab/heap-analysis';
+import { z } from 'zod';
+import { getRegisteredTool } from '../tool-registry.js';
+import { activeElapsedMs, activeTimeoutMs_, beginAnalysisBudget, endAnalysisBudget, ScanTimeoutError, } from '../analysis-budget.js';
+import { clearAllSnapshots, listSnapshots, setCurrentSnapshot, setSnapshot, } from '../heap-state.js';
+import { artifactLabel } from '../artifact-classes.js';
+import { errorResult, formatBytes, formatNumber, markdownTable, toolResult, } from '../utils.js';
+import { computeSequenceTrends } from './sequence-analysis.js';
+const { getFullHeapFromFile } = memlabHeapAnalysis;
+/**
+ * Run one already-registered tool in-process against the current snapshot.
+ *
+ * Same dispatch `memlab_batch` uses, and for the same reason: the analysis is a
+ * fixed sequence of existing tools, and re-implementing any of them here would
+ * let the protocol's answer drift from the answer the operator gets by hand.
+ * Failures are captured as text rather than thrown — one missing section must
+ * not cost the whole write-up.
+ *
+ * Each step gets its OWN wall clock, armed through the server's COOPERATIVE
+ * budget rather than a timer. That distinction is the whole design: a heap walk
+ * is synchronous, so it blocks the event loop and a `setTimeout` racing it can
+ * never fire — a timer-based budget bounds nothing and only looks like it does.
+ * Measured while building this: with a 90s timer-based step budget, the deep
+ * dive on a 3-rung / 700 MB ladder was still running at 14 minutes with no
+ * output. `beginAnalysisBudget` instead makes `tickAnalysis()`, which the
+ * snapshot's patched `forEach` already calls, throw from INSIDE the walk.
+ *
+ * A step that overruns is reported as UNANALYZED — the same contract the rest
+ * of this tool holds itself to — and the protocol moves on.
+ *
+ * The outer budget is restored afterwards so the remaining steps still run
+ * under the caller's overall `timeout_ms`.
+ */
+async function runTool(name, args, budgetMs, unanalyzed) {
+    const entry = getRegisteredTool(name);
+    if (entry == null)
+        return `_(${name} is not registered on this server)_`;
+    const outerRemaining = Math.max(0, activeTimeoutMs_() - activeElapsedMs());
+    const outerTimeout = activeTimeoutMs_();
+    beginAnalysisBudget(budgetMs);
+    try {
+        const res = await entry.handler(args, {});
+        const content = res?.content;
+        const text = Array.isArray(content)
+            ? content.map(c => c.text ?? '').join('\n')
+            : String(res);
+        // A tool that fails does NOT throw: every handler catches its own errors
+        // and returns an `isError` envelope, budget overruns included. Treating
+        // only exceptions as failures is how this write-up printed "every step of
+        // the protocol ran" underneath a step that had aborted mid-walk — the exact
+        // false clean-bill this tool exists to prevent. (`memlab_batch` learned the
+        // same lesson; see `isErrorResult` there.)
+        if (res?.isError === true) {
+            const overran = /budget|timed? ?out|exceeded/i.test(text);
+            unanalyzed.push(overran
+                ? `${name} exceeded its ${Math.round(budgetMs / 1000)}s step budget`
+                : `${name} failed`);
+            return overran
+                ? `_(${name} exceeded its ${Math.round(budgetMs / 1000)}s step budget and was aborted mid-walk — raise \`step_timeout_s\`, or run it directly against the resident snapshots.)_\n\n${text}`
+                : text;
+        }
+        return text.trim() || '_(no output)_';
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const timedOut = err instanceof ScanTimeoutError || /timed? ?out|budget/i.test(msg);
+        unanalyzed.push(timedOut
+            ? `${name} exceeded its ${Math.round(budgetMs / 1000)}s step budget`
+            : `${name} failed`);
+        return timedOut
+            ? `_(${name} exceeded its ${Math.round(budgetMs / 1000)}s step budget and was aborted mid-walk. Run it directly against the resident snapshots with a larger \`timeout_ms\`, or raise \`step_timeout_s\`.)_`
+            : `_(${name} failed: ${msg})_`;
+    }
+    finally {
+        // Restore the caller's budget, minus what this step consumed, so the
+        // remaining steps still run under the overall timeout rather than getting
+        // a fresh one each.
+        if (outerTimeout > 0) {
+            beginAnalysisBudget(Math.max(1, outerRemaining));
+        }
+        else {
+            endAnalysisBudget();
+        }
+    }
+}
+/** Load a snapshot file and register it under `alias`, keeping the others. */
+async function loadRung(filePath, alias) {
+    const snapshot = await getFullHeapFromFile(filePath);
+    let nodeCount = 0;
+    let totalSize = 0;
+    snapshot.nodes.forEach(n => {
+        nodeCount++;
+        totalSize += n.self_size;
+    });
+    let edgeCount = 0;
+    snapshot.edges.forEach(() => {
+        edgeCount++;
+    });
+    setSnapshot(snapshot, filePath, {
+        fileName: path.basename(filePath),
+        nodeCount,
+        edgeCount,
+        totalSize,
+        env: 'browser',
+    }, { alias, replace: false });
+}
+/**
+ * One-line, non-empty label for a class in a table or a sentence.
+ *
+ * V8 leaves anonymous arrays and closures unnamed, and value-named string
+ * "classes" carry their whole (often multi-line) value — both of which render as
+ * a blank cell or a broken paragraph if passed through unchanged.
+ */
+function classLabel(name, type, maxLen = 38) {
+    const flat = name.replace(/\s+/g, ' ').trim();
+    if (flat.length === 0)
+        return `(unnamed ${type})`;
+    return flat.length > maxLen ? `${flat.slice(0, maxLen - 1)}…` : flat;
+}
+export function registerAnalyzeRun(server) {
+    server.tool('memlab_analyze_run', "Point at a leak hunt's `run.json` and get the whole analysis protocol executed in one call: ladder trend, owner attribution for the growth, a detached-DOM population comparison between the first and last rung, dev/automation-artifact classification, and a per-grower adjudication — plus the run's own caveats (gating, relink seams, stall) carried into the write-up. " +
+        '`memlab_hunt_report` renders the run and `memlab_leak_report` analyses the ladder; nothing chained them, so how thorough a round got depended on how thorough the operator felt like being, which is the single largest source of variance between rounds. This runs the same sequence every time and states explicitly which steps did not run. ' +
+        'Cost: it loads the ladder transiently for the trend, then holds the FIRST and LAST rung resident together for the attribution and population steps — size `timeout_ms` accordingly (600000+ for a multi-hundred-MB ladder), and expect several minutes. ' +
+        'KNOWN LIMITATION, measured on two apps: the `dev_artifacts` step reliably exceeds a 200-240s step budget here (aborting at ~10.8M nodes scanned) while the same tool returns in 2-5s when called directly on the same snapshot. Unloading the baseline first does NOT change it, so residency is not the cause and the cause is not yet identified. The step is reported as UNANALYZED rather than waited out; run `memlab_dev_artifacts` yourself against the final rung, or raise `step_timeout_s`, to complete that part of the protocol.', {
+        run_json: z
+            .string()
+            .describe('Path to a run.json written by hunt_runner (or to the run directory containing it).'),
+        cycles_between_rungs: z
+            .number()
+            .optional()
+            .describe('Override the interaction cycles between consecutive rungs. Defaults to the per-rung `cycles` recorded in the manifest.'),
+        top: z
+            .number()
+            .optional()
+            .default(12)
+            .describe('How many growing classes to adjudicate (default 12).'),
+        skip_deep_dive: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Run only the ladder trend, skipping the two-snapshot-resident steps (owner attribution, population diff, artifacts). Use on a ladder too large to hold two rungs in memory at once.'),
+        step_timeout_s: z
+            .number()
+            .optional()
+            .default(240)
+            .describe('Wall clock for EACH deep-dive step (default 240s). A step that overruns is reported as UNANALYZED instead of being waited out — several whole-heap steps chained behind one budget is how a protocol turns into a hung session. Raise it for very large ladders.'),
+        max_file_size_mb: z
+            .number()
+            .optional()
+            .describe('Per-file size limit override (MB).'),
+    }, async ({ run_json, cycles_between_rungs, top, skip_deep_dive, step_timeout_s, max_file_size_mb, }) => {
+        try {
+            let manifestPath = run_json;
+            if (fs.existsSync(manifestPath) &&
+                fs.statSync(manifestPath).isDirectory()) {
+                manifestPath = path.join(manifestPath, 'run.json');
+            }
+            if (!fs.existsSync(manifestPath)) {
+                return errorResult(`No run.json at ${manifestPath}.`);
+            }
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            const rungs = (manifest.rungs ?? []).filter(r => fs.existsSync(r.path));
+            const missing = (manifest.rungs ?? []).length - rungs.length;
+            if (rungs.length < 2) {
+                return errorResult(`The run has ${rungs.length} readable rung(s); the protocol needs at least 2. ` +
+                    (missing > 0
+                        ? `${missing} rung file(s) listed in the manifest are missing from disk — snapshots are usually written to /tmp and may have been cleaned up.`
+                        : 'Capture more rungs, or analyze the single snapshot directly with memlab_load_snapshot + memlab_auto_investigate.'));
+            }
+            // The steps that did NOT run are part of the result. A protocol whose
+            // gaps are invisible reads as a complete analysis, which is how a round
+            // gets published with a step quietly missing.
+            const unanalyzed = [];
+            const stepBudgetMs = Math.max(1, step_timeout_s) * 1000;
+            if (missing > 0) {
+                unanalyzed.push(`${missing} rung file(s) from the manifest are missing on disk and were excluded.`);
+            }
+            const paths = rungs.map(r => r.path);
+            const first = rungs[0];
+            const last = rungs[rungs.length - 1];
+            const perRungCycles = cycles_between_rungs ??
+                (rungs.length > 1
+                    ? Math.round((last.cycles - first.cycles) / (rungs.length - 1))
+                    : 0);
+            const out = [
+                `# Leak-hunt analysis — ${manifest.run_id ?? path.basename(path.dirname(manifestPath))}`,
+                '',
+                `Combos: ${(manifest.config?.combos ?? []).join(', ') || '(unrecorded)'} · cycles driven: ${formatNumber(manifest.totals?.cycles ?? last.cycles)} (ok ${formatNumber(manifest.totals?.ok ?? 0)} / fail ${formatNumber(manifest.totals?.fail ?? 0)}) · ${rungs.length} rungs · ~${formatNumber(perRungCycles)} cycles between rungs`,
+                manifest.stop_reason ? `Stop reason: ${manifest.stop_reason}` : '',
+                '',
+                '## Ladder',
+                '',
+                markdownTable(['Rung', 'Cycles', 'Post-GC heap', 'Reason'], rungs.map(r => [
+                    String(r.index),
+                    formatNumber(r.cycles),
+                    `${r.post_gc_heap_mb.toFixed(1)} MB`,
+                    r.reason ?? '',
+                ]), new Set([0, 1, 2])),
+                '',
+            ].filter(Boolean);
+            const heapDelta = last.post_gc_heap_mb - first.post_gc_heap_mb;
+            out.push(`Aggregate post-GC heap moved **${heapDelta >= 0 ? '+' : ''}${heapDelta.toFixed(1)} MB** across the run. Aggregate heap is the weakest signal here and is reported for completeness only: a measured round found a real leak (+6.25 undo entries/cycle, linear across five rungs) while aggregate heap FELL 8.9 MB. The per-class trend below is what decides.`, '');
+            // ---- Step 1: ladder trend (transient loads, one graph at a time) ----
+            out.push('## 1. Per-class trend across the ladder', '');
+            let growers = [];
+            try {
+                const trends = await computeSequenceTrends(paths, {
+                    minGrowthCount: 1,
+                    maxFileSizeMB: max_file_size_mb,
+                    toolName: 'memlab_analyze_run',
+                });
+                growers = trends.rows.slice(0, top).map(r => ({
+                    name: r.name,
+                    type: r.type,
+                    netCount: r.netCount,
+                    netSize: r.netSize,
+                    trend: r.trend,
+                    artifact: r.artifact,
+                }));
+                if (growers.length === 0) {
+                    out.push('No class grew across the ladder. That is a RESULT, not a failed analysis — record the round as no-leak for these combos rather than re-running until something appears.', '');
+                }
+                else {
+                    out.push(markdownTable([
+                        'Class',
+                        'Type',
+                        'Δ count',
+                        'Δ/cycle',
+                        'Δ size',
+                        'Adjudication',
+                    ], growers.map(g => [
+                        classLabel(g.name, g.type),
+                        g.type,
+                        `+${formatNumber(g.netCount)}`,
+                        perRungCycles > 0
+                            ? (g.netCount /
+                                (perRungCycles * (rungs.length - 1))).toFixed(2)
+                            : '—',
+                        `${g.netSize >= 0 ? '+' : ''}${formatBytes(g.netSize)}`,
+                        g.artifact != null
+                            ? artifactLabel(g.artifact)
+                            : g.trend === 'monotonic-up'
+                                ? '↑ every rung — LEAK CANDIDATE'
+                                : 'grew net (noisy) — weak',
+                    ]), new Set([2, 3, 4])), '');
+                    const candidates = growers.filter(g => g.artifact == null && g.trend === 'monotonic-up');
+                    out.push(candidates.length > 0
+                        ? `**${candidates.length} leak candidate(s)** after artifact classification: ${candidates.map(c => `\`${classLabel(c.name, c.type, 28)}\``).join(', ')}. A candidate is not a verdict — the retainer evidence below is what promotes it.`
+                        : '**No leak candidates** survived artifact classification: every grower is either a known measurement-artifact family or non-monotonic.', '');
+                }
+            }
+            catch (err) {
+                out.push(`_Trend step FAILED: ${err instanceof Error ? err.message : String(err)}_`, '');
+                unanalyzed.push('per-class ladder trend');
+            }
+            // ---- Step 2+: two rungs resident ----
+            if (skip_deep_dive) {
+                unanalyzed.push('owner attribution, detached-DOM population diff and artifact classification (skip_deep_dive was set)');
+            }
+            else {
+                // Start from a clean slate: the deep dive needs exactly two graphs
+                // resident, and anything left over from an earlier call is both
+                // memory pressure and a chance to attribute against the wrong pair.
+                clearAllSnapshots();
+                let loaded = false;
+                try {
+                    await loadRung(first.path, 'run_first');
+                    await loadRung(last.path, 'run_last');
+                    loaded = true;
+                }
+                catch (err) {
+                    out.push(`_Could not hold both rungs resident: ${err instanceof Error ? err.message : String(err)}. Re-run with skip_deep_dive to get the trend alone._`, '');
+                    unanalyzed.push('owner attribution, population diff and artifact classification (both rungs would not load)');
+                }
+                if (loaded) {
+                    setCurrentSnapshot('run_last');
+                    out.push('## 2. Who owns the growth', '', await runTool('memlab_explain_delta', {
+                        baseline_handle: 'run_first',
+                        target_handle: 'run_last',
+                        limit: 12,
+                        min_delta_bytes: 65536,
+                        include_artifacts: false,
+                    }, stepBudgetMs, unanalyzed), '', '## 3. Detached DOM — same population, or the same count?', '', await runTool('memlab_population_diff', {
+                        baseline_handle: 'run_first',
+                        target_handle: 'run_last',
+                        population: 'detached',
+                        group_by: 'owner',
+                        limit: 15,
+                        min_delta: 0,
+                    }, stepBudgetMs, unanalyzed), '', await runTool('memlab_detached_dom', {
+                        output_mode: 'full',
+                        group_by: 'dominator',
+                        limit: 8,
+                        offset: 0,
+                        classify_dev_only: true,
+                        only_with_retainer_path: false,
+                    }, stepBudgetMs, unanalyzed), '', '## 4. Is it real? (dev/automation artifacts on the final rung)', '', await runTool('memlab_dev_artifacts', {}, stepBudgetMs, unanalyzed), '');
+                }
+            }
+            // ---- Provenance and caveats ----
+            out.push('## Round provenance and caveats', '');
+            const gating = manifest.gating_verified ?? {};
+            const gatingKeys = Object.keys(gating);
+            out.push(gatingKeys.length > 0
+                ? `Gating: ${gatingKeys.length} ABProp(s) verified in-page. ${gatingKeys
+                    .map(k => `\`${k}\`=${JSON.stringify(gating[k])}`)
+                    .join(', ')}`
+                : '⚠ **No verified gating recorded in this run.** A round driven without its gating manifest re-discovers already-fixed leaks and cannot be compared with a gated round — treat every finding above as provisional.', '');
+            const caveats = manifest.caveats ?? [];
+            if (caveats.length > 0) {
+                out.push('**Caveats recorded by the runner** (these constrain what the analysis above can claim):', ...caveats.map(c => `- ${c}`), '');
+            }
+            if (unanalyzed.length > 0) {
+                out.push('**UNANALYZED** — these protocol steps did not run, so the round is not a clean no-leak result:', ...unanalyzed.map(u => `- ${u}`), '');
+            }
+            else {
+                out.push('_Every step of the protocol ran. "No leak candidates" from a complete run is a genuine no-leak result; the same words from a run with UNANALYZED steps are not._', '');
+            }
+            const resident = listSnapshots()
+                .map(m => m.handle)
+                .join(', ');
+            if (resident) {
+                out.push(`_Resident snapshots: ${resident}. Follow up on a specific object with \`memlab_dominator_chain\` / \`memlab_retainer_trace\`, or unload them with \`memlab_snapshots\`._`);
+            }
+            return toolResult(out.join('\n'));
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+}
+//# sourceMappingURL=analyze-run.js.map

package/dist/tools/analyze-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-run.js","sourceRoot":"","sources":["../../src/tools/analyze-run.ts"],"names":[],"mappings":"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"}

package/dist/tools/app-heap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAppHeap(server: McpServer): void;
+//# sourceMappingURL=app-heap.d.ts.map

package/dist/tools/app-heap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-heap.d.ts","sourceRoot":"","sources":["../../src/tools/app-heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,yCAAyC,CAAC;AAsCvE,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAqIvD"}