Memtrace v1.0.0

Memtrace v1.0.0

A new Memtrace: redesigned throughout, a graph engine 27x faster, and dependencies you could not see before

New

• A completely redesigned application. Every workspace surface — the graph, Insights, the inspector, Cortex, Fleet, notifications, settings — has been rebuilt rather than restyled, and the old interface has been removed. The new workspace ships with 841 tests across 83 files, against 693 for the interface it replaces.
• A new graph engine, roughly 27x faster. Layout runs as a Barnes-Hut force kernel on the GPU instead of the CPU: measured on a live 136,048-node, 328,522-link workspace, a simulation step went from 295 ms to 11.3 ms, the graph settles in about 3.4 seconds, and once settled frames cost 0.1 ms. Positions never leave the GPU between compute and drawing.
• The graph is legible at that size, not just fast. Edge lengths went from a 269x spread to 7.9x, so long-range links no longer swamp everything near them; there is no boundary wall, because the space is unbounded and nothing is pinned against an edge; and the layout is re-fit on every update so the graph cannot drift out of view.
• Related code is clustered before the simulation starts. Communities are detected and used to seed the layout, so the graph resolves into readable lobes — this force model settles two groups only a little apart, a difference invisible among a hundred thousand points, so structure has to be placed rather than discovered.
• A light mode for the graph, built as a second rendering path rather than an inverted palette, and using the same colours as the rest of the product.
• A redesigned service topology. A repository is a container and every participating caller and receiver is listed inside it, with each connection landing on the exact function it reaches. Repository-level arrows can only tell you two services talk; with twenty functions in a box, the question left is which of them is doing the talking. Labels are sized from measured text, so they cannot overflow their boxes.
• Dependencies that are not HTTP now appear in the topology, across eighteen languages: gRPC, message queues (Kafka, RabbitMQ, JMS, SQS, Google Pub/Sub, NATS, MassTransit, NServiceBus, Azure Service Bus), WebSocket, Socket.IO, SignalR, STOMP and GraphQL. A service whose only link to its neighbours was a gRPC channel or a queue topic previously appeared to have none.
• Java and C# are first-class in cross-repository topology. Both previously contributed HTTP routes only — between them not a single gRPC service, queue topic, hub or GraphQL endpoint was visible. Their API surfaces are also detected now: Spring and JAX-RS including the jakarta namespace, ASP.NET attribute routing and Minimal API.
• Kubernetes manifests are part of the graph. Every object is indexed with its kind and namespace — including custom resources from any operator, because they share the same contract — and a workload's configured service URLs are read as outbound dependencies, so a deployment states who it talks to.
• SQL schemas are navigable. Tables, columns, views and indexes are searchable symbols, with foreign keys shown on the column and each column scoped to its table. A repository that writes a table and one that reads it are linked.
• OpenAPI specifications contribute their endpoints, so a service that publishes a contract is connected to the clients that call it.
• R and Nextflow projects are indexed.
• Deep code search over full source. Whole files are indexed with lexical search, and results are returned as windows centred on the query rather than whole-file dumps.
• Test coverage in Insights, derived from the call graph. It shows which code no test reaches, in every language at once, with nothing to run. It measures reachability rather than executed lines and says so — the actionable half is the list of code with no test path at all.
• A governance review room in Cortex: Memtrace finds the documents that govern how code is written — architecture decision records, agent rule files, contributing guides — and a human confirms, excludes or scope-approves each one.
• Release notes inside the product, so you can see what changed without leaving the workspace.
• Startup and job progress are visible in the activity centre, and graph self-repair appears as its own state rather than looking like a routine re-index.

Improved

• Insights reports an evidence-bounded quality profile instead of a flattering weighted average. The headline is limited by the weakest measured dimension, each dimension states its confidence and what it was calculated from, and missing evidence is reported as missing rather than scored as a pass — an unmeasured dimension no longer invents a failing grade either.
• Dead code is scored by reachability from real entry points, with confidence bands, so a symbol reached only dynamically is not reported as confidently as one nothing references. Test modules and configuration formats are excluded.
• Coupling is measured from component topology rather than directory nesting, and distinguishes missing evidence from a clean result.
• Complexity rankings say which metric put an item first, and no longer look nearly perfect by scoring only part of the codebase.
• The graph payload is 43% smaller — measured on a real seventeen-repository workspace, 40.5 MB down to 23.1 MB — and decodes far faster, which is what a reload actually waits on rather than the download.
• Pages stop refetching data nothing is watching: the episode timeline revalidates instead of re-downloading megabytes, unrelated changes no longer invalidate its cache, and a single repository no longer double-fetches on every load.
• Code search is faster and steadier — query time no longer grows with the size of the candidate pool, repeated queries skip redundant work, and results are better matched for questions phrased as observed behaviour rather than as symbol names.
• Memtrace will not exhaust your machine. A footprint watchdog is armed in every long-running entry point after an incident where a session reached 63 GB with no guard firing, because the limit was read but never enforced anywhere.
• Large repositories catch up in bounded chunks, with individual file failures quarantined rather than stalling the pass, and full git-history replay streams commit by commit instead of holding all of it in memory.
• Episode detail is complete: deleted files appear, and multi-batch catch-up episodes list every file they applied.

Fixed

• Selecting a very large file no longer freezes the graph.
• The code panel in the inspector scrolls with the mouse wheel.
• The graph refresh indicator stops instead of spinning forever.
• Large updates no longer defeat the file watcher.
• Blessed Folder Groups keep every member repository live.
• A repository being refreshed no longer empties while it rebuilds, and cross-repository topology refreshes leave it intact.
• Insights no longer reports perfect health while its analysis is still building, keeps dead-code, coupling and API results through a database restart, and reflects newly indexed code instead of holding a stale picture.
• Cross-repository connections that were closed are restored when the dependency returns, instead of staying invisible.
• A file no longer splits into a second, empty copy of itself, and existing splits are repaired at startup.
• Renaming a file while Memtrace is watching no longer leaves the old name behind.
• Concurrent indexing can no longer permanently disable embeddings, and concurrent saves no longer leave two live versions of one symbol.
• Shared local databases no longer erase each other's snapshots, stored lookups survive dependency upgrades and restarts, and a read issued just after the server returns no longer hangs.
• A graph view is never served from a snapshot built under a stale branch, and a good snapshot is never overwritten by an empty one.
• Decision recall fails fast rather than hanging when Cortex is unresponsive, stays available on Windows and macOS, and supervision no longer stops a healthy daemon.
• MCP indexing runs in the background instead of blocking the session, and a standalone MCP session can own its own database.
• Clean symlinks no longer mark a repository as changed.
• Hosted projects keep their identity across reseeds.
• Source files stay searchable by ordinary text tools after indexing.
• Public pages render correctly on first load for search engines and link previews.
• Accepting a governance batch from the command line now persists it.
• Telemetry documentation matches the events actually sent, with all eleven types and their properties listed.

Install

npm install -g memtrace