Nightly

New features,
as they land.

Install with npm install -g memtrace@nightly. Same memtrace command. It can break. Switch back with npm install -g memtrace@latest.

Restart recovery and fixes from the 42-repository report

New

memtrace gpu verify-embedding profiles the actual embedding model and saves which execution providers ran its operators, the graph precision, and separate initialization, warmup and embedding timings. A successful CUDA MatMul probe alone does not establish that the embedding model uses the GPU.
MCP clients can use --attach-only to wait for their workspace owner without starting a private engine. Owner apps need to set this flag for their editor integrations; Memtrace cannot infer an external app's Enable setting.

Fixed

Restart recovery no longer appends historical node versions again when rebuilding the live UUID lookup. Repeated opens keep that log stable, while a genuinely stale checkpoint is repaired once. This stops the repeated recovery writes found in the large Windows workspace report; it does not shrink bucket files already allocated.
Long-running daemons now checkpoint changed primary records every five minutes. Idle checks do not rewrite the snapshot, and checkpoint writes are serialized with WAL rotation so a later restart can resume from an updated watermark.
After three failed sidecar starts, the same store backs off for five minutes even if its supervisor restarts. A successful start clears the failure marker. An explicit retry, changed binary or changed startup timeout permits another attempt.
Sidecar startup keeps three previous log generations instead of erasing the previous attempt. If rotation fails, the next attempt appends to the existing log.
Claude registration preserves existing workspace arguments and custom environment values during upgrades, including project-local MCP configuration. Legacy workspace arguments migrate when the user registration is missing.
An indexing command whose embedding stage fails now exits with an error and says that structural indexing was saved but embedding is incomplete. Failed model initialization and cache-only batches no longer claim that inference warmed the model.
Workspace runtime records are published once the backend and control endpoint are ready, before background startup work. The dashboard address is added after its listener binds, and records belonging to exited processes are pruned.

Improved

GPU status distinguishes requested providers from measured operator execution and reports the actual graph precision. The Jina int8 cache directory name does not mean its default graph is quantized; that graph is fp32, while explicit q8 selects the quantized graph.
This nightly also includes the earlier fix for loading property snapshots above the old 1 GiB limit. A 1.86 GB snapshot passed the recovery regression.
Thanks for the detailed 42-repository Windows report. Recovery checks passed on Windows, macOS and Linux, including repeated unclean restarts. The original private workspace has not been rerun for 36 hours, and GPU profiling here used an RTX 5070 rather than the reported 5070 Ti.

Saved refactor runs, clearer background work, and fixes from public reports

New

Quality now opens saved guided refactor runs. An agent can record a diagnosis, plan bounded edits, and submit compiler, test, and API checks between steps. Failed checks pause the run, and its history survives a restart. The first workflow supports test capture and helper extraction; the recorded checks are evidence, not a proof of equivalent behavior.

Fixed

Python named imports now connect importing files to the class or function they import, including aliases and imports inside functions. Exporter queries can find those files after full indexing, incremental edits, and history replay.
OpenCode routing recognizes repository roots and nested folders, and accepts workspace selectors with JSON supplied on stdin. Installation leaves one managed plugin instead of loading it twice.
Standalone dashboards no longer index the current directory or claim workspace ownership. They connect to an existing engine and remain open when stdin closes.
Starting with --allow-non-git now discovers the selected plain folder, indexes it, and watches subsequent edits while preserving ignore rules.
MCP sessions shut down on SIGTERM, SIGHUP, and incomplete-handshake disconnects. Linux stop commands also recognize exited children that have not yet been reaped.
Heartbeat retries no longer burst through missed intervals after a computer resumes from sleep. An offline period reports one network warning and a recovery message.
Stop keeps incomplete cleanup and unconfirmed persistence sync visible in its final summary instead of ending with an unconditional Done.
An owned engine exiting now makes the wrapper report an unhealthy backend and shut down its listeners. Windows watcher hashes and symbol path selectors use consistent path spellings.

Improved

Background replay and semantic-index repair appear in the job list. Paged embedding shows how many symbols it has examined and leaves the total unknown until the scan finishes, instead of displaying a percentage against a growing denominator.
Related skills explain when to use each entry point, and a guided refactor skill walks agents through the saved workflow and its checks.

More dependable agent queries and decision memory, shaped by Magalz's feedback

New

Agents can use get_query_revision to wait for an indexed source revision and detect changes across a report's queries, including saved edits and branch switches.
Decision recall includes source documents, content hashes, decision revisions, category, scope and lifecycle information, with missing metadata identified explicitly.

Fixed

Ignored files stay outside current analysis after edits, reconnects, restarts, full indexing and history replay. Ignore negation and removal of stale indexed results work consistently.
Accepted architecture decisions retain their workspace scope for reliable recall on Windows and Linux, including concurrent clients and owner restarts.
Numeric review catches the supplied integral and decimal narrowing cases, including a declaration change supplied as an unapplied diff with matching base source. Unrelated changes remain quiet.
Symbol context distinguishes available, empty and unavailable annotation metadata, while full related-symbol results preserve annotation arguments.

Improved

The quality skill now explicitly uses the existing find_hotspots MCP tool and explains how change frequency, complexity and fallback results affect its findings.
Thanks to Magalz for the detailed feedback, reproducible fixtures and acceptance criteria that drove these improvements. The supplied workflows were checked on Windows and Linux.

No new customer-facing notes this soak.

1.2.8-nightly.20260925.9e285d5

Fixed

Upgrading with npm 12 no longer leaves your coding agents on the previous version's skills, MCP configuration and Claude Code plugin. npm 12 blocks install scripts unless you allow them, so Memtrace now finishes setup on the first memtrace command after an install or upgrade: an existing setup is refreshed with a one-line notice, a new install asks first in a terminal, and elsewhere it prints how to run memtrace setup --yes. Your earlier --no-hooks and --project-only choices are kept, npm i -g memtrace --allow-scripts=memtrace runs setup during the install instead, and MEMTRACE_NO_AUTO_SETUP=1 turns the first-run step off.

A re-thought engine for every language, a code graph you can actually read, and sharper tools for your agents

Improved

The All repositories graph shows each repository as its own island. Repositories that call or import each other sit side by side and blend along their shared border, unrelated ones sit apart, files with no relationships stay at the edge of their own repository, and each island keeps the shape it has when you open that repository on its own.

Fixed

The graph toolbar's zoom in, zoom out and fit-to-screen buttons work with the default renderer; they did nothing unless the compatibility renderer was selected. The graph also frames itself again once its layout settles, instead of staying framed on the wider starting layout.

1.2.8-nightly.20260924.a5b8db1

New

Memtrace offers four ready-made workflows as MCP prompts: before_modifying, before_deleting, new_codebase and incident. Hosts that support prompts show them as slash commands, and each one expands into the full multi-tool routine with your symbol and repository filled in.
Every Memtrace MCP tool now declares whether it only reads, can remove data, or reaches the network. Hosts use these hints to decide what needs your approval, and Codex runs read-only Memtrace calls in parallel instead of one at a time.

Improved

The before_modifying prompt and the routing instructions check a symbol with one preflight_check call, which returns its dependents, the process flows it sits in, the files that change with it, its recent churn and a checklist of what to re-verify. They used to walk four separate lookups to gather the same answer.
find_central_symbols names the symbol kinds a repository actually has when a request ranks nothing or asks for a kind that does not exist, such as Interface or Protocol in a Rust repository. The next call can ask for traits directly instead of listing every symbol to find out.
find_symbol and find_code name the repositories to choose from when they need a repo_id, so a retry no longer has to list every indexed repository first. get_timeline called with a guessed scope_path that matches nothing now says to copy it from a find_symbol hit.

Fixed

Four MCP tool descriptions no longer contradict their tools. get_changes_since stopped asking for inputs it rejects, so the calls an agent built from it now succeed; calculate_cyclomatic_complexity states the risk bands it actually reports and whether a score was measured or estimated; get_timeline names its required inputs and where to find them; and delete_repository no longer claims re-indexing restores what it deletes.
MCP clients now see Memtrace's documentation pages as resources. The list was always empty because Memtrace asked the docs site for a page that does not exist. Listing resources also no longer waits up to 20 seconds on a machine that cannot reach the docs site: it answers within 2 seconds and falls back to the copy it cached last time.
find_dependency_path refuses an edge_type it does not recognise and lists the valid ones, and find_central_symbols and find_bridge_symbols report kinds they did not recognise in kinds_ignored. Both used to answer a different question without saying so.
get_episode_replay in graph_summary mode says which section could not be computed and why, instead of returning an empty list that reads as "nothing central changed".
Passing a blank or placeholder repo_id is reported as an input error rather than a server fault.
Skills installed as the Claude Code plugin now find the parameter reference they point to, because the installer copies it into the plugin. Pi skills name each tool the way Pi registers it, in their descriptions as well as their instructions.
get_changes_since, get_evolution and episode replay count each change once. A full index could store its episode twice, so one commit read as two episodes with every total doubled, a commit recorded by both indexing and history replay was listed twice, and the markers an embedding pass and history replay leave behind were listed as changes.
Indexing a repository with history no longer leaves a second live copy of every symbol an earlier commit introduced and the latest commit did not touch. Reads showed one copy, but the duplicate doubled the raw graph, gave each symbol's timeline a phantom second version, and made deleted code look like it was still there.
get_codebase_briefing called without a repo_id briefs the only repository in the workspace. It used to report that nothing was indexed and advise re-indexing a repository that was already there; with several repositories indexed it now asks which one.
calculate_cyclomatic_complexity no longer refuses a unique function as ambiguous on a store that holds two rows for it, and it accepts the scope_path or the id other tools return, not only the bare name.
find_code with include_related=true now returns the callers, callees and type users of its top hits, the same relationships get_symbol_context lists, with each row marked outbound or inbound and its edge kind. Search also lifts the graph neighbours of strong matches into its ranking. Both used to come back empty, because the graph walk was filtered by a number the store does not index edges under.
The symbol panel in /ui no longer lists a caller or callee whose link exists only on another branch.
The code graph no longer collapses into one white mass pushed to one side, with a ring of loose nodes around it. On repositories with many execution flows, every flow step was laid out as its own link, which switched the layout to a mode that does no clustering. Each flow is now drawn with one link to its entry point, so related code groups into clusters again. Selecting a flow still highlights every step, and the edge count shows how many links are drawn beside the total.
Test functions no longer start execution flows. Every test that reached shared code added a near-copy of the same large flow, which buried the real flows and multiplied the graph size several times on large repositories. Run a reindex to shrink an existing index; otherwise each repository is corrected on its next saved edit.
On Windows, the Files panel, search results, symbol details and the all-repositories file tree show paths relative to each repository instead of putting every file under a single c: folder. Ignoring a file from the Files panel or from a graph node now works on Windows, and ignoring a file at the repository root ignores only that file, not every file with the same name in subfolders. A file's symbol list no longer includes symbols from a same-named file elsewhere in the repository.

1.2.8-nightly.20260924.03ca906

Fixed

On Windows, Microsoft Defender began quarantining memcore-server.exe from the 1.2.8 nightly after a security intelligence update on September 24, which stopped Memtrace from opening its store. The store server is now built with the same compiler as every other Memtrace binary, and each Windows build is still scanned with current Defender definitions before it is published.

A re-thought engine, across every language we support

New

Perl is indexed from the grammar rather than by pattern. A package statement changes the current lexical namespace, a qualified definition does not change the namespace of its body, and dynamic dispatch is reported as unresolved instead of guessed at.
Zig reads the module graph its build.zig declares. Zig binds a bare-name import per module, so @import("config") in two different executables names two different files; flattening those aliases into one repo-wide map sent the second module's import to the wrong file.
Zig enum variants are understood as receivers. Op.create.event_max() reads a variant as the receiver, and a variant is not a container — the receiver of its method is the enum that declares it. Nothing in the graph could previously say which names were variants.
Zig calls excluded by a comptime-known condition no longer produce edges. A branch guarded by a const bound to false cannot call what it contains, and an edge saying otherwise invites you to trace a path the compiler already removed.
SQL routine bodies contribute calls, taken from parsed expressions and never from text inside comments or string literals.
COBOL paragraphs and sections are both indexed as units control can be transferred to, which is what makes a COBOL program's flow followable.
Nextflow repositories are indexed across all three syntaxes they mix: DSL2 pipeline and component files, the declarative configuration files, and nf-test suites.
Dart indexing covers the declarations the language actually has — classes, mixins, extensions, extension types, enums, constructors, and function and method signatures — verified against the grammar's own node types.
R projects expose the surface that makes an R graph useful: package and namespace dependencies, and sourced files.
Vue component events are now a relationship you can follow. A template's @event="handler" is a subscription, not a call: the handler binds to the child component and the child records what it emits, so “who handles what this component emits” is answerable across files.
Swift attributes reach the graph. @objc, @available, @MainActor and @discardableResult were recorded nowhere, so “what is exposed to Objective-C” and “what is deprecated” had no answer.
TypeScript ambient and namespace declarations are extracted. Members of a declare class were never read, so a call inherited from an ambient base could not resolve, and a namespace body was treated as a block, so every value it declared was absent.
A callable's written signature facts reach the store and the read path. Each parameter's type and the return annotation are published in one canonical spelling — whitespace collapsed, a C++ plain name unqualified, a Rust borrow reduced to the type it borrows — with C++ member constness beside them, and get_symbol_context returns them on the symbol, on its callers, callees and siblings, and on the candidate list returned when a name matches several declarations — which is where overloads are actually compared. They were computed during indexing and discarded before, so nothing outside the indexer could see them. The candidate list also names annotations and marks contributed symbols, so an ambiguous match no longer reads as if every choice were parsed and unannotated.
Named tool registrations are anchored to the exact handler declaration that serves them, so a codebase that registers tools can be asked which handler answers which name.

Improved

Text search now runs inside MemDB. Before find_code could answer, it built a private search index on the machine asking, by reading every record of the repository back out of the store. Against a hosted or self-hosted MemDB that meant downloading the whole repository over the network first. MemDB now builds that index beside the data and answers the search itself, so nothing is downloaded. In our measurements on a repository of about 4,000 indexed records at 45 ms of network latency, the first find_code went from 32.8 seconds to 2.2 seconds, and repeat searches against a local store answer in about 60 ms. It makes no difference to ranking which side answers: the server and the local path share one scoring implementation, checked to produce bit-identical scores. Self-hosted MemDB servers gain this once they run this release; until then Memtrace keeps using the previous path, now with a time limit.
Every programming language Memtrace indexes is affected by this round. Twenty language frontends changed outright, and the shared work behind constructors, receivers, visibility and call resolution reaches the rest — ActionScript, Elixir, GDScript and Lua included. Configuration and infrastructure formats such as YAML, JSON, TOML and Kubernetes manifests are deliberately unchanged.
Go projects resolve their imports. A module whose path carries no dot or slash — module myapp, which covers most internal modules — resolved no package imports at all, so “what depends on this file” returned nothing for the whole project.
Java imports follow the package a file declares rather than the directory it sits in, so flat and non-standard layouts resolve. Wildcard imports such as import com.example.models.* reached nothing whatsoever and now resolve, and a module boundary marked by a pom.xml or build.gradle is respected rather than crossed.
Swift files in one module now connect when one genuinely uses the other. Same-module files see each other without an import, which we modelled as every file importing every other — that does not scale, and above a size threshold it silently produced nothing at all. A 400-file target went from no connections to roughly 2,400 meaningful ones.
Whether a declaration is exported is now decided the way each language expresses it, and that decision is the root set for dead-code analysis — a symbol nothing calls is only dead if it is also not part of the public API surface.
Rust namespace paths resolve through declared modules and imports, so a value that happens to share a module's spelling can no longer hide it.
Processes and impact walks get the benefit directly: cross-file imports now exist for Go, Java and Swift layouts that previously had none, so a process crossing a file boundary in those projects can be followed at all, and a blast radius no longer lists callers that never called.

Changed

Java types carry their package, so com.a.User and com.b.User stop collapsing into a single symbol, and a type declared inside a method carries the name the JVM gives it. This changes symbol identity for packaged Java — reindex your workspace after upgrading to pick it up.
C# file-scoped namespaces (namespace Foo;, the modern default) now own the types written after them. Previously every type in such a file was unqualified, so two namespaces sharing a class name read as one type.
Constructors are one concept across fourteen languages, so “list this class's constructors” no longer answers differently depending on which language the class was written in. Python keeps __init__ as a method, because that is what the language makes it.
Members of a type are indexed as the kind they are. A property declared in a Kotlin, Dart or PHP class is now a field, as in Java and C#, where it used to be a variable, and a member of a Kotlin companion object belongs to its class. A Swift static let written after an attribute such as @available(*, deprecated) is a constant; it was read as a mutable field. A Java enum's constants are indexed, as constants owned by their enum. Java, Go, JavaScript and Ruby methods are methods rather than functions, so a search filtered to methods no longer leaves them out. Anonymous functions in Dart, Elixir and GDScript are named by where they are written, <anonymous>@line:column, with the function that holds them recorded as their owner. Kinds and names are part of a symbol's identity, so each repository is re-parsed once, automatically, on the first start after upgrading.
A class-qualified call resolves only where the type is declared locally and nothing shadows it, and a named upper bound is treated as a receiver contract rather than a concrete construction type.

Fixed

find_code against a hosted or self-hosted MemDB no longer waits indefinitely. Building its search index had no time limit, a request that gave up threw that partial work away so the next attempt started from nothing, and loading the query's embedding model could stall forever on a host with no route to the model download. Each is now bounded, and while an index is still being prepared find_code says so, answering not_ready with search_warming, instead of reporting no matches and suggesting a filesystem search.
Memtrace's own bookkeeping records, such as tool-call savings, session anchors and branch markers, are no longer indexed as searchable text, so they cannot appear among find_code results or skew its ranking.
The same query over the same data now returns results in the same order every time. The search index was built on several threads at once, so scores that were almost equal could swap places from one build of the index to the next.
A local store no longer loses saved changes after an unclean shutdown or a disk error. Four separate recovery faults could each discard changes that had already been saved, while the store still opened as if nothing was wrong: damage in data a checkpoint had already covered; a crash that cut a write off in its first few bytes, so the next save was written behind the fragment and lost on the restart after; a write that failed on a full disk; and an error while replaying changes at startup, which discarded the store's index of everything older. Recovery now keeps those changes. Where it cannot recover a store safely, the store now refuses to open with an error that names the problem, instead of opening without part of your data. A store that already lost changes this way is not repaired by upgrading: reindexing that repository rebuilds what was lost.
An editor that launches Memtrace's MCP server while memtrace start is still coming up now waits for it. Start makes itself visible a few seconds before it records how to attach, and an editor arriving in that window exited with “no runtime record … refusing to attach”, leaving it without Memtrace tools until it was restarted.
An MCP session opened before any Memtrace store is running no longer hangs on each tool call. It used to wait about 25 seconds on a connection nothing would answer; until a store is up, calls now fail at once, and the session attaches as soon as a store appears.
Ruby assignments inside class_eval, instance_eval, instance_exec or Class.new are no longer attributed to the enclosing class's instance. Those blocks move self somewhere else entirely, so the resulting answers pointed at the wrong object.
A method defined in a TypeScript object literal binds this to that literal rather than to the class around it. We were reporting a member access the compiler rejects outright.
Java method references in a predicate slot, such as .filter(User::getName), no longer resolve to calls the compiler refuses. An unwritten or type-variable result now abstains instead of guessing.
A receiver typed with a bounded wildcard no longer resolves a call that cannot be written. ? super in Java and in in Kotlin genuinely can be called and still resolve.
PHP member calls on an untyped receiver are admitted only where the workspace holds exactly one method of that name with a matching arity and compatible arguments, and such a suggestion is never fed back into return-type propagation.
Rust attributes are recorded against the declaration they were written on, so two fmt methods on one type no longer trade #[inline] between them.
The graph now shows every relationship a repository's edge count includes. The count covered every kind, but the graph's edge list used an older, fixed list of kinds, so field reads and writes, interface implementations, definitions and component events were counted yet never drawn, and the graph tools that rank or cluster symbols left them out too. A JavaScript or Python function parameter is also no longer reported as reading a field of the same name elsewhere in the repository.

No new customer-facing notes this soak.

A refused start leaves your daemon running

Fixed

A memtrace start that cannot open the store no longer stops the Memtrace already serving that workspace. When a store belongs to a workspace file or a named workspace, a bare memtrace start from a folder above your projects is refused rather than allowed to widen it — but it stopped the running daemon on its way to refusing, so the workspace was left with nothing serving and no dashboard, under an error that ended “No data was changed”. The refusal now happens before anything is stopped, so the Memtrace you already had keeps serving and the message tells you which command to run. The added check is read-only — it takes no locks and writes nothing — and the authoritative check still runs where it always did.
The line Memtrace prints when a memtrace start replaces the daemon already serving a workspace no longer calls that daemon unhealthy. Three of the four reasons to replace one — --force, a change in workspace membership, and an unsafe store scope — say nothing about its health, and the actual reason is already printed on the line above.

The graph comes back, and your agents stop colliding

Fixed

A tool call whose Memtrace goes away underneath it — a daemon that crashed, or one replaced by a newly started owner — now waits for the workspace's Memtrace to come back and answers, instead of failing after two quick retries. The wait is bounded at a minute, so a call never hangs waiting for something that is not coming. A store whose Memtrace you stopped on purpose is deliberately not waited for: that call fails straight away and says the owner exited.

1.2.7-nightly.20260921.f203f99

Fixed

Cleaning up one project can no longer stop another one's Memtrace. memtrace stop and memtrace doctor --fix now require proof that whatever they are about to terminate belongs to the workspace being cleaned — the process must name that workspace's data directory itself, or be the daemon that workspace published, and still be the same process it was when it was inspected. Anything that cannot be identified is left running and the reason is printed instead of being silently skipped. Before, freeing a port terminated whichever process held it under a name match, and because a Memtrace whose port is busy moves to the next free one, that was routinely another project's healthy daemon.
A Memtrace session no longer waits on another session to read. A session that is not changing which repositories a workspace holds now takes no workspace lock at all. Before, the lock was held for the whole time a store was being opened, so an editor's session could sit for thirty seconds behind another one's startup and then fail outright with a lock timeout — on a large workspace that was every editor reload.
An editor-spawned Memtrace session can no longer change which repositories a workspace holds, under any flag — including when the editor's configuration passes a workspace file. It may set up a brand-new workspace and nothing more. Changing an existing one means editing the manifest and starting Memtrace with it, which is now the only path and is named in the refusal.
A tool call whose Memtrace restarts underneath it now waits for the workspace's Memtrace to come back and answers, instead of failing after two quick retries. The wait is bounded, so a call never hangs waiting for something that is not coming.
The retrieval hook agents use now asks the Memtrace that owns the folder it ran in, rather than assuming the dashboard is on port 3030. On a machine running more than one project, port 3030 belongs to whichever project started first, so the hook could answer from a different project's graph with nothing in the answer to say so. When no Memtrace owns the folder, the hook now says so instead of guessing.

Improved

One project's heavy query no longer blocks everyone else's. Graph work that reads a whole repository still runs one at a time — that is a memory limit — but a call that cannot start within its budget now comes back as a retryable busy answer naming what is holding the lane and for how long, instead of queueing behind it indefinitely. Questions routed from another workspace get their own narrower lane, so a neighbour's work cannot crowd out the session in front of you.
Every running Memtrace is now reachable by the others. Each one opens a small loopback port and publishes it, so a question can be routed to a workspace whose Memtrace was started by an editor rather than from a terminal. Before, such a workspace had no reachable address and the question was refused even though the answer existed on the same machine.
The Memtrace skills no longer tell an agent to re-index when a repository looks missing. A repository that is indexed in a different workspace now produces a refusal naming where it lives, and the guidance an agent reads treats that as a routing answer rather than a coverage problem — following the old advice built a second copy of the repository in the wrong workspace.

1.2.7-nightly.20260918.2a7b2c3

Fixed

On a machine running more than one Memtrace — a workspace on port 3030 and a second store that fell back to 3031 — a tool call routed to the other daemon now reaches it. The runtime registry advertised the port each daemon was configured with, not the one it actually bound after the fallback, so the call went to whichever daemon held the configured port and was refused there. The registry now records the bound port, and the router reads the port from the daemon's own published state first.
Session-ledger rows no longer fuse when two Memtrace sessions write at the same moment. A row was written as two pieces — the JSON, then its newline — so simultaneous sessions could interleave and produce a line holding two records, which the ledger readers then dropped. Each row is now written in one piece.

1.2.7-nightly.20260918.6121f8f

Fixed

An MCP session attached to a store that does not hold the repository you ask about now gets its answer from the running Memtrace that does hold it. Tools such as get_codebase_briefing, find_central_symbols, list_processes, find_code and find_symbol used to answer “0 symbols” or empty results from the wrong store while the Memtrace holding the repository sat idle; they now hand the same call to that runtime and return its answer, marked under _meta.answered_by so you can see who answered. When no running Memtrace holds the repository, or it cannot answer, the call is refused with a diagnostic naming this session's store, its members, where the repository lives and why it was not routed — never a silent empty. Only reads are routed; nothing is ever written to another store. A routed call counts once against your query quota, and a refused one not at all.
Running memtrace start or memtrace index in a terminal when a newer version is available no longer prints the update twice. The background version check printed its notice card — the versions, the release notes link, the upgrade command — and the interactive “Upgrade now?” offer printed the same card again right underneath it. The notice now yields to the offer. It still prints on its own for commands that never ask, and when the version check finishes too late for the prompt to have asked.
A store started from a workspace manifest or a named workspace now remembers who declared its member list, and a plain memtrace start run from the folder above it — or an MCP session Cursor or Claude spawned there while the daemon was down — can no longer widen that list to every repository it finds in the folder. Before, either would silently rewrite the store's scope to the whole folder, and the next memtrace start --workspace-file refused to open the store because its declared members no longer matched the manifest. A folder-walked start over an owned store is now refused up front with the manifest or workspace name and the command that may change the members; an MCP session opens the store's declared members as they are and never rewrites the scope of an existing store (it may still create the scope of a brand-new one). Every change to a store's member list now keeps the previous file beside it and appends one line to a journal naming the process, its arguments and working folder, so a surprise rewrite is answerable in seconds instead of hours.

Improved

The session ledger now records failed tool calls, not only answered ones, and every row names the runtime that answered: its store, owner process, endpoint, role (owner, attached, pending or standalone), working folder and workspace root, the repository you asked for and whether this store holds it. When a memtrace mcp session starts it prints one line with the same facts. After the demo incident it took an hour of log forensics to establish which store had answered a call; that is now one line in the ledger.

1.2.7-nightly.20260917.02fa2d7

Fixed

Stale copies of edited functions no longer hang on the outer ring of the graph. When a function moves to a different line, Memtrace records the moved version as a new symbol and retires the old one; on some stores the old version's connections were retired but the symbol itself was written back as live, so it survived with no connections at all and the layout parked it on the ring reserved for unconnected nodes — on a nine-repository workspace that was about 1,200 ghost Rust functions, each with a connected twin of the same name in the same file. The graph now drops a symbol that has no connections when a connected symbol with the same name exists in the same file. Nothing else on that ring changes: files with no symbols (READMEs, empty init.py files) and symbols whose file has no entry of its own are real and stay. The ghosts leave the picture the next time a repository is indexed; run memtrace index to apply it to an existing store in one step.

The graph stops going blank

Fixed

Picking a point on the timeline shows the graph as it was at that moment again. Since 1.1.4 the dashboard had no way to build a historical picture: the change that stopped Memtrace from re-scanning the whole store on every dashboard load also removed the only code path that answered a time-travel request, so every point on the timeline came back as an empty graph marked “Graph view is materializing”. The chosen time is kept in the page address, so a reload brought the empty picture straight back, and the only way out was to switch to a single repository and back to all of them. Historical views are now built on request from the store — for one repository or for all of them — and are never written over the live graph's cache. The live graph is unchanged: it is still served from cache and a dashboard load still never triggers a store scan.
While a new picture is loading — after a timeline scrub, a branch switch or a repository switch — the graph already on screen stays put with the refresh indicator on, instead of being replaced by the “materializing” overlay until the next answer lands. A historical picture is a live walk of the store, so that gap is seconds, and it no longer blanks the view.
The graph no longer sits on “Graph view is materializing” after a reload. When the first answer for a view is still warming up or empty, the dashboard now keeps asking every couple of seconds until a drawable graph lands, then stops and goes back to push-driven updates. Before, it waited for a refresh signal that had already fired, so an empty first answer stayed empty until you switched repositories and back. A graph that is already on screen is never re-fetched on a timer, so the flicker fixed earlier does not come back.

Improved

The GitHub badge in the top bar says what it counts. “5/6” now reads “GitHub 5/6 connected”, and its tooltip explains that it counts the repositories in this workspace that have a GitHub remote — not every repository — so a nine-repository workspace with six GitHub remotes no longer looks like a mistake.

Deleted code leaves the graph, and pulls no longer stall

Improved

The node inspector in /ui now shows the route registration for an API endpoint that was discovered from a route, instead of an empty Code tab, and says where a widened code snippet came from. When the Memtrace owner process is unreachable, the inspector's Code, Info and History tabs show the backend's message and the memtrace start recovery step with a Retry, instead of a spinner or a claim that the symbol has no history.

1.2.6-nightly.20260916.9976905

Fixed

Upgrading no longer leaves Memtrace running the previous version's program. A global install can keep a leftover copy of the native program from an earlier install alongside the current one, and when the package manager removed the newly installed copy during an upgrade, Memtrace fell back to that leftover and ran it — while memtrace --version, and the package itself, reported the new version. Anyone verifying a fresh build could be testing one that was weeks old, with the version check itself doing the lying. Memtrace now requires the native program to match the version of the package that installed it: the installer fetches the correct one instead of accepting whichever copy it finds first, and if a mismatch survives that, Memtrace refuses to start and prints both versions and the location of the leftover copy, so you can delete it and reinstall.
Established projects now run the startup repair that removes leftover duplicate copies of a symbol. Memtrace has a repair pass that closes extra live copies of the same symbol left behind by older versions — the copies that make a deleted function keep turning up in search and for your agent — but on projects whose graph had grown large enough for Memtrace to skip its full startup scan, this repair was skipped along with it. Those are precisely the projects that accumulate the copies, having been indexed for weeks, so the stores most in need of repair were the only ones never receiving it, and upgrading did nothing for them. The repair now runs on large projects too. It stays bounded — it declines a repository too large to scan cleanly rather than slowing start — and it is a cheap no-op on a healthy store. Turning startup indexing off still turns it off.
Re-indexing a project no longer leaves a second live copy of every unchanged symbol. When Memtrace re-indexed a repository, it timestamped the current code from the moment HEAD last moved to the checked-out commit (a checkout or branch switch), while its git-history pass timestamped the same code from the commit's own time. Whenever those two moments fell in different seconds — routine after any branch switch, and the norm on a long-lived project — the two passes disagreed by a second and the store kept both, so one symbol became two live rows. Reads still showed one (the newest wins), but the raw graph doubled, and a store re-indexed for weeks accumulated a heavy layer of these twins that made deletions look like they had not taken. Both passes now read the commit's own time, so they agree and only one row is written. Existing duplicate rows are closed by the startup repair with nothing for you to do.

1.2.6-nightly.20260916.6f8d45d

Fixed

Deleting a file, or removing a function or type from one, while Memtrace is running now reliably removes it from the graph, whether you or your coding agent made the change. Some graph stores had accumulated more than one live copy of the same symbol (indexing a repository that has several local branches did this about half the time), and a deletion retired only one copy, so search, the graph page, and your agent kept being handed code that no longer existed anywhere in your checkout. Every copy is now retired when its file is deleted or its definition removed, including copies that were already in your store, with no reindex required.

1.2.6-nightly.20260916.1676171

Fixed

Files deleted by a pull are now removed from the graph on large projects. Their functions and types used to stay behind and keep being returned by search and to your coding agent, so an agent could be told about code that no longer existed anywhere in your checkout, and follow it. Memtrace looks up a deleted file's existing entries to retire them, but it was searching under a different spelling of the file path than the one it stores, so it found nothing and retired nothing. On smaller projects this never showed, because they load their index differently and never reach that lookup. Verified on a 1,600-file pull, where the clean-up now runs instead of being skipped entirely. A side benefit: entries superseded by a large pull are now retired rather than accumulating, so stores stop growing with copies of code that has already changed.

Pulling no longer leaves Memtrace stuck

Fixed

Memtrace no longer stops reconciling after a git pull on an established project. Once a project graph grew past the point where Memtrace skips its full startup scan, the first change after a pull could leave the watcher retrying the same step every few seconds indefinitely: the pull was never applied, newly pulled files never appeared in search or for your agent, and the only cure was a manual reindex. Startup left a marker saying a graph publication still had to be confirmed, and the step that would have confirmed it was the very step being held back. Memtrace now tells an in-progress publication apart from a leftover marker, so the pull is applied normally. Verified on a 1,600-file pull: applied without stalling, with the API responsive throughout.

1.2.6-nightly.20260916.0d11d8d

Improved

The update prompt says what the new version contains. When a newer build is available, Memtrace now links that version's release notes next to the version you are on and the one on offer — on the nightly channel that is the whole question you are being asked. Accepting shows which step the upgrade is on and how long it has been running, rather than a single line while the package manager's output scrolls past; if the upgrade fails, that output is printed in full before the remedy. Output that is captured rather than shown in a terminal — an agent's log, CI — keeps the plain form. Set MEMTRACE_PLAIN_OUTPUT=1 for plain text in a terminal too, or MEMTRACE_VERBOSE_UPGRADE=1 to watch the package manager's own output during an upgrade.

Fixed

A function handed to another function by reference now counts as a caller. Passing a function as an argument — run_in_threadpool(parse_transactions_csv, body), rows.map(formatRow), Thread(target=run_job) — was invisible to the graph, because only the function being called directly was read from each call. A symbol used that way reported zero callers and showed only its importing file under "Called by", so dead-code and blast-radius answers were wrong in the direction that costs you: they said nothing reached a symbol that something did. These now resolve to the function that passes the reference, labelled "passed as an argument" so you can tell an indirect call from a direct one. Sibling files in a Go package are still an exception, because Go names them with no import to resolve against. Existing indexes pick this up when a file is re-indexed or edited; memtrace index --clear applies it to a repository in one step.
The Called by and References lists explain how each relationship was found in words rather than internal codes — "imported here, never called" instead of unused-import-specifier.
⌘V / Ctrl+V works in the dashboard's search and filter fields when it is open inside an embedded browser. Preview panes in coding tools consume the paste shortcut themselves and never pass it to the page, so the field stayed empty while typing worked normally. The dashboard now reads the clipboard itself when the paste never arrives, and leaves the ordinary path alone everywhere it already works.

Memtrace keeps up with what you pulled

Fixed

Memtrace no longer skips its startup catch-up on large projects. When an existing graph store is big, Memtrace skips the full startup scan so that start stays fast — that is deliberate — but it was also skipping the much cheaper catch-up that applies whatever changed since the last run, so that step never ran at all on those projects. It now runs, and its cost tracks what actually changed rather than how big the store is. First-time indexing of brand-new repositories is still deferred on large stores, and the catch-up runs in the background, so start is no slower than before.
A pull or branch switch that deletes files now removes them from the graph. Memtrace read the incoming change correctly but forwarded only the added and modified paths, so deleted files lingered in search results and on the graph page until the next full index — symbols that no longer existed anywhere in your checkout were still offered to your agent.
When Memtrace cannot measure the size of an existing store in time, it now treats it as a large store and still runs the catch-up, instead of treating it the same as a store you had explicitly told Memtrace to leave alone.

Decision recall finds your decisions again

Fixed

Decision recall returns your recorded decisions again on Windows. Recall asks decision memory for decisions belonging to the workspace you are in, and the answer is matched against the workspace each decision was captured under — but the two were being written in different spellings of the same path, so nothing ever matched. Every query answered "no decisions recorded" while the Cortex tab showed a full store, which is a misleading answer for an agent checking prior decisions before it edits. Both sides now spell a workspace the same way, and decisions captured by earlier versions are still found.
A failure in the Memtrace rail hook no longer blocks your coding agent. When the hook could not run — unreadable input, or arguments a newer configuration used that the installed version did not recognise — it exited in a way the editor reads as "denied", and the editor then refused every tool call for the rest of the conversation, including the ones needed to diagnose it. Reloading the editor did not clear it. The hook now allows the tool call and explains itself instead.
Members of an organization with an active subscription get the Insights panel. Insights unlocked only through referrals, so people whose organization had already bought seats were told to go and refer others first. Approving an organization now grants every member access, with nothing to set per person.

No new customer-facing notes this soak.

1.2.4-nightly.20260915.72202ed

Fixed

Cortex no longer reports a connection problem when decision memory is merely busy. A request that had to wait — because the service was still starting, or because it was working through a slow first classification — was reported as though the service were missing. Busy and absent are now told apart, and only a genuinely absent service is described as one.
Opening Cortex starts decision memory on demand when it is entitled and not already serving, instead of showing a connection error until something else happened to start it first.
Cortex now shows only the repositories this workspace is watching or has indexed. Governance previously listed repositories belonging to other workspaces on the same machine, which made it look as though Memtrace were tracking work you had never opened here.
Stopping Memtrace now keeps decision memory stopped. The on-demand start honours the saved opt-out and entitlement, so a workspace you have closed — or a session you have opted out of — no longer brings the service back.
Governance documents such as ADRs kept in a watched repository are classified through decision memory rather than being skipped, so they appear in Cortex for the repositories you are actually working in.
On Windows, a workspace is recognised as the same workspace however its path is spelled, so Cortex no longer treats one project as two. Records left behind by a session that has since exited are cleared instead of keeping a workspace listed as active.
memtrace stop no longer fails when the workspace it is stopping has already stopped. The operating system may reissue a recorded process id to something unrelated; stop now recognises that the record outlived the process that wrote it and reports the workspace as stopped, rather than refusing and returning an error.
On Windows, governance classification no longer fails with “The pipe is being closed” as soon as a repository has more than one governance document. A request larger than the local pipe's buffer was refused whole and the connection never recovered, so two ADRs — or one long one — could not be classified while decision memory was running and idle; one short ADR fitted and worked, which is why the fault looked like a connection problem rather than a size one. Requests are now sent in pieces the pipe always accepts.

Improved

When Cortex genuinely cannot start, the message now says what to do about it — check memtrace status, and run memtrace cortex debug for a redacted report — instead of repeating an internal error string.

1.2.4-nightly.20260914.1fd7d7e

Fixed

Organization invitations can be accepted when the invited address and the account differ only by a plus tag — an invite sent to name@example.com now works for someone who signs in as name+tag@example.com, because both spellings reach the same mailbox.
The organization invite page now says why an invitation cannot be used instead of giving one message for every cause: whether it was sent to a different address, has expired, or was cancelled. Its sign-in button signs you out first, so it no longer returns you to the same error while you are still signed in as the wrong account, and opening an invite link for an organization you already joined takes you into that workspace rather than reporting a failure.

Changed

Configuration keys are identified by their key path rather than their position in the file from this release on. Existing indexes keep working and need no action: the entries for a file are brought up to date the first time that file is re-indexed or edited. If you would rather clear a store in one step, run memtrace index --clear on that repository.

1.2.4-nightly.20260914.309c70d

Fixed

Organization invitations can be accepted when the invited address and the account differ only by a plus tag — an invite sent to name@example.com now works for someone who signs in as name+tag@example.com, because both spellings reach the same mailbox. When the addresses genuinely differ, the invite page says which address it expected instead of giving one message for every cause, and its sign-in button signs you out first rather than returning you to the same error.

Changed

The first start after upgrading re-indexes each repository once. Configuration keys are identified by their key path rather than their position in the file from this release on, so existing indexes are rebuilt to match; this happens automatically and reports progress. Repositories stay searchable from their existing index until the rebuild for that repository finishes.

Saving a file stops re-indexing the whole file

Fixed

Saving a file no longer re-indexes it from scratch. Editors that save atomically — VS Code, IntelliJ, and vim in its default configuration — write a temporary file and rename it over the original, which the file watcher reports as a deletion followed by a creation. Memtrace treated that as a real deletion, discarded everything it knew about the file, and then re-created every symbol and relationship in it. On a 6,000-key YAML, inserting one line re-created 6,063 symbols and tombstoned 12,119 relationships in about three seconds; it now updates 1 symbol and 2 relationships in about 0.7 seconds, and writes roughly a tenth as much to the store. This affected every file type, not only configuration files.
A configuration key's identity is now its dotted path rather than its line number, so inserting or removing a line above other keys no longer changes their identity. Config files were the most affected because they emit roughly one symbol per line, where source code emits about one per twenty.

1.2.4-nightly.20260914.7d4d26a

Fixed

Editing a YAML config file no longer re-creates its symbols. A config key's identity is now its dotted path rather than its line number, so inserting or removing a line above other keys leaves their symbols untouched. Measured on a 6,000-key YAML: adding one line used to re-create 6,063 symbols and 12,123 relationships in about seven seconds, and now re-creates 2 symbols in about two seconds. Relationship rewriting per save is unchanged and is tracked separately. Config files were the worst affected because they emit roughly one symbol per line, where source code emits about one per twenty.

Config files stop re-indexing whole on every save

Fixed

Editing a YAML config file no longer re-indexes the entire file. A key's identity is now its dotted path rather than its line number, so inserting or removing a line above other keys leaves them untouched. On a 6,000-key YAML, adding one line previously re-created 6,063 symbols and 12,123 relationships and took about seven seconds; it now changes only the key you added. Projects with several large, frequently-edited config files were the worst affected, because config emits roughly one symbol per line where source code emits about one per twenty.
Items in a YAML list now carry their position in the key path, so the steps of a CI job read as jobs.build.steps[0].uses and jobs.build.steps[1].run. Previously every step in a list produced the same path and the same display name, which made them indistinguishable in search and the graph view.

No new customer-facing notes this soak.

Nightly development starts from Memtrace 1.2.3

New

New features reach the nightly channel first: npm install -g memtrace@nightly. Nightly is not always stable. The default install receives stable releases, and memtrace install keeps the current channel.

Changed

The nightly channel moves to the 1.2.4 development series, starting from stable 1.2.3, where memtrace mcp and memtrace status attach to a running external-mode daemon by its heartbeat. The complete notes are in the 1.2.3 entry below.

External MemDB clients attach to the running daemon

Fixed

In external MemDB mode, memtrace mcp and memtrace status attach to a running memtrace start daemon for the same workspace right away. Daemon liveness is now judged by the daemon's own heartbeat instead of a short probe of the remote database endpoint, which previously waited 12 seconds and then reported a healthy, idle daemon as not responding.
MemDB endpoints without an explicit port, such as an Azure Container Apps address, resolve with the standard port for their scheme instead of being treated as unreachable.

Improved

When an external-mode daemon really has stopped responding, the startup error reports the age of its last heartbeat so the stale owner is easier to recognise.

Windows CUDA works across fresh launches and npm upgrades

Fixed

Windows tools that launch the native Memtrace executable directly now find the installed user-local CUDA runtime. Warmup, GPU status, CUDA verification and the engine use the same runtime as CUDA setup.
A healthy CUDA installation is reused after npm replaces or moves the Memtrace package, without requiring another runtime download. Custom ONNX runtime overrides, CPU fallback and no-AVX2 packages remain supported.

Improved

GPU diagnostics identify MEMTRACE_SKIP_EMBED or MEMTRACE_NO_EMBED when either setting disables CUDA verification, including verification performed by CUDA setup. Unset the reported variable before retrying.

Quieter background work, clearer resource usage and complete release history

Fixed

Synthetic search warmup finishes after startup instead of repeating while the workspace is idle. Normal search and model warmup remain available.
Cursor transcript capture uses indexed lookups instead of scanning unrelated records in large local conversation databases. Regression checks preserve the captured records and literal conversation identifiers.
File notifications from Memtrace storage are filtered before they enter the watcher queue, reducing background work caused by the database writing its own files.
Insights loads and refreshes panels on demand, so opening the dashboard no longer starts expensive work for every hidden panel.
Database property queries filter matching records before decoding their properties, reducing repeated work on large stores.
Windows-shaped import paths resolve consistently across platforms. Explicitly imported callees remain distinct from same-named declarations in neighbouring files.

Improved

Resource accounting includes the database and decision-memory processes owned by Memtrace, making background CPU and memory usage easier to diagnose.
Windows packages must pass Microsoft Defender scans before publication. Release checks cover both standard and no-AVX2 packages; a rejected executable blocks publication.
The public website and installed UI retain the complete archived Stable and Nightly release history. Original publication dates and actual nightly versions are preserved, older notes remain readable during a failed refresh, and new release archives update independently of Discord announcements.
Release notes retain environment-variable underscores and accept older Markdown layouts, so published instructions and historical notes remain readable.

Changed

These changes do not establish a universal idle-CPU target or a guaranteed first-index time. Large populated macOS workspaces and long first-index runs still require a measured retest on the affected setup.

No new customer-facing notes this soak.

Nightly development starts from Memtrace 1.2.0

New

New features reach the nightly channel first: npm install -g memtrace@nightly. Nightly is not always stable. The default install receives stable releases, and memtrace install keeps the current channel.

Changed

The nightly channel moves to the 1.2.1 development series, starting from stable 1.2.0 with native desktop receipts, Apple Silicon and CUDA embedding fixes, indexing improvements, and branch-aware graphs. The complete feature notes are in the 1.2.0 entry below.

No new customer-facing notes this soak.

1.1.13-nightly.20260906.6948f83

Improved

macOS embedding allows CoreML to use the GPU as well as the Neural Engine and CPU. Bounded model inputs let CoreML accept work previously excluded by dynamic shapes, and incomplete batches return only the requested vectors. Physical M5 Pro checks confirmed GPU execution, vector accuracy and full-repository indexing. The Apple Silicon path has no M5-only restriction; older chips and macOS releases still need physical validation.

Fixed

The macOS CPU governor now reads real AC/battery state, battery percentage and session idle time, so its existing battery and idle policies respond to the Mac. Governance remains opt-in and can increase background completion time.
Mac memory gating now follows the kernel pressure state. Compressed-memory estimates no longer cause false critical-memory pauses; actual warning and critical pressure still reach the existing safety policies.
Agent hooks now follow the Memtrace daemon lifetime. Cached hooks return silently after shutdown or a crash, and registrations are removed when no running daemon needs them. Saved off settings survive inherited agent settings and installation updates.
On macOS, hooks recognize alternate paths to the same workspace, including temporary-directory aliases. Nested workspaces select their own daemon, while similarly named sibling directories stay separate.
Exact identifier searches try indexed symbol lookup before semantic fallback and check the returned name, repository, path and source line. Normal supported hooks route directly to the running daemon.
Agent installation preserves custom MCP settings and unrelated hooks. Claude has a user-level registration fallback, and the bundled VS Code registration supplies the active workspace directory.

No new customer-facing notes this soak.

Working CUDA setup, cheaper indexing, and graphs that follow your checkout

New

Windows and Linux x64 can install the complete CUDA runtime from the terminal when an NVIDIA GPU is available. Install and startup offer consent before downloading missing dependencies; memtrace gpu install-cuda --yes supports unattended setup. Downloads are versioned and checksum-verified, need no Python or CUDA toolkit, and require a working NVIDIA driver.
memtrace gpu verify-cuda runs real GPU inference with CPU fallback disabled and checks its output. Setup uses this check before reporting success, and GPU diagnostics retain the selected device and runtime failure reason.

Improved

CUDA embedding uses the full-precision code model on supported NVIDIA hardware. Warm embedding throughput on an RTX 5070 improved 22.3 times on Windows and 24.1 times on Linux under WSL2, with minimum CPU/GPU vector cosine similarity above 0.99999986. These measurements cover embedding after warmup, not total repository indexing time.
macOS embedding now allows CoreML to use the GPU as well as the Neural Engine and CPU. Bounded model inputs let CoreML accept work previously excluded by dynamic shapes, and incomplete batches return only the requested vectors. The macOS validation lane records actual CoreML operator placement; Mac performance measurements are still pending.
Indexing reuses bounded parse, syntax-tree and query caches, builds line offsets lazily, and avoids repeated syntax-tree traversal and service-root discovery. Changes to parser code invalidate cached results, and unchanged derived-label inputs skip redundant computation.
Matched indexing benchmarks reduced end-to-end wall time by 9–13% on Windows and 5–8% on Linux under WSL2. The Windows database-backed workload used 74–89% less CPU time. Structural parsing and graph construction improved 2.6–3.7 times on cold runs and 5.0–5.3 times on warm runs; cached and uncached output was checked across 22 languages. These results do not establish temperature or energy savings.

Fixed

Linux x64 nightly and stable packages now compile CUDA support. Managed runtime activation reaches child processes, upgrades can replace the incomplete older bundled runtime, and an outdated GPU architecture list no longer rejects a newer runtime that can execute inference successfully.
The opt-in CPU governor now enforces zero-budget pauses, charges concurrent CPU samples once, restores the correct allowance when interactive work ends, and keeps safety pauses in force during interactive boosts. A disabled governor no longer scales batches or parks work. Eight-worker measurements held requested two- and four-core budgets within about 1.1% on Windows and WSL2; enabling the governor still requires MEMTRACE_CPU_GOVERNOR=on.
Windows history replay uses consistent file identities, so moving a declaration between lines no longer leaves every old version live. A versioned repair pass revisits affected history on upgrade, preserves explicit replay limits, and records completion so subsequent starts do not repeat the repair. Startup logs distinguish checking HEAD and repairing history from a fresh index.
Branches inherit shared graph records and store their own changes, including removals and restorations, without copying or deleting parent records. Full indexing and incremental label updates preserve those removals, so deleted symbols, relationships and derived labels do not reappear through inheritance. Replacement metadata is acknowledged before older records are retired, making partial-write retries safe.
The watcher follows the actual checked-out branch, including linked worktrees, detached HEAD and Git metadata outside the working directory. It arms the relevant metadata watches before reporting readiness, rejects duplicate watches of the same canonical path, and recovers missed branch notifications with a lightweight poll.
Switching branches reconciles the destination before publishing its identity to the UI. Work from the outgoing branch cannot publish into the new checkout, failed reconciliation retries with backoff, and files unchanged from the default branch reuse inherited records. When the default branch advances, only files whose Git content differs are invalidated for reconciliation.
Repeated checkouts compact redundant repository and branch summary records while preserving lineage metadata. A known main or master lineage no longer includes the other branch as an unrelated fallback. Windows can now read resident memory correctly when deciding whether to reconstruct a cached graph.
Graph views, symbol lookup, hybrid-search results and repository statistics consistently resolve the selected branch, prefer its overrides, and hide inherited removals and unrelated branches. Statistics include inherited records even when a branch also has a substantial delta; previously incorrect counts can change.
A graph already on screen stays usable when a refresh times out. A compact delayed-refresh notice offers retry instead of covering the graph with a blocking error; an initial load failure still shows an error. Existing inflated history requires the repair pass before its graph counts shrink.
Database-writing regression tests use isolated stores, and an integration-test fallback can no longer inherit a configured external database endpoint.

Hosted stores index at full speed again

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

Fixed

A graph cache that outlives its store no longer stalls a start. When the store behind a workspace is reset or written by another release, the cache files under .memdb/graph-cache can no longer be proven complete; 1.1.10 re-read them on every refresh, kept the repositories queued, and waited out remote scan deadlines between repositories, up to 21 minutes each. A cache that fails the proof is now evicted at the first rejection and rebuilt from the store.
The per-repository insight card printed during memtrace start is limited to 30 seconds; when the graph is busy the card is skipped and the next repository starts at once.
Startup embedding no longer vanishes when cross-repo linking is still settling. A repository whose embedding had to wait is listed as deferred in the memtrace start summary and embedded automatically once the graph settles, instead of being counted as embedded.
A repository whose graph was rebuilt during memtrace start (a fresh index, or the self-heal regeneration) is always embedded in that same start, even when the restart shortcut would otherwise skip the full pass. Such a repository could previously finish the start with no vectors at all.
A repository that an earlier start left without vectors is embedded at the next memtrace start. The restart shortcut that skips embedding when HEAD is already indexed now also requires the embedding-complete marker for that HEAD.
Indexing against a hosted MemDB is dramatically faster. Memtrace read records from the store four at a time, a width picked for a database on the same machine where a read costs CPU. On a hosted database a read costs a network round trip instead, so that width capped the client at about 125 records a second and a workspace that used to index in minutes could run for hours with both machines almost idle. Memtrace now measures the round trip to its store and reads as wide as that justifies, and sizes the connection for a remote database. A local database keeps exactly the width it had. MEMTRACE_STORE_READ_CONCURRENCY pins it if you need to.
memtrace no longer reports the database connection as lost when it was not. A single failed request marked the connection down before anything had checked it, so a recovered hiccup logged a "connection lost" warning that the next line contradicted. The connection is reported lost only once a repair attempt has actually failed, and the reason it failed is logged with it.

1.1.11-nightly.20260903.2e33fc5

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

A second Ctrl-C no longer strands the sidecars; a Cortex owner stops only its own store's daemon

Fixed

A second Ctrl-C during shutdown used to leave the database sidecar and the Cortex daemon running until the next memtrace stop, start, or doctor --fix: the second press exits the owner immediately, before its shutdown reaches the sidecars, and macOS ties no child to its parent. The owner now hands every sidecar it recorded a termination signal on that immediate exit, from the signal handler itself, so one press or two both end with nothing left behind; whatever ignores the signal is still closed from the ledger by the next stop.
A Memtrace owner or MCP session that had just claimed its Cortex store used to stop every Cortex daemon on the machine before starting its own, including daemons serving other stores (a second MEMCORTEX_STORE_DIR on the same machine, for instance), whose owners then restarted them. It now stops only daemons whose command line names its own store, and leaves alone any process whose command line it cannot read.

1.1.10-nightly.20260903.fbb793a

Fixed

Sidecars are always closed by memtrace stop and by Ctrl-C, on every platform. On macOS the Cortex daemon (memcortex-daemon) kept running and burning CPU after memtrace stop and after Ctrl-C: the stop command matched sidecars to a workspace by a --data-dir argument that the Cortex daemon does not use, and macOS ties no child to its parent the way Windows job objects and Linux parent-death signals do. Every owner now records each sidecar it spawns in a ledger next to its pid file, and memtrace stop, the owner's own shutdown and signal paths, the next owner's start, and memtrace doctor --fix close whatever that ledger names, with a hard kill after three seconds; a recycled pid is never touched.

The 1.1.9 CPU governor is opt-in

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

Changed

The CPU governor introduced in 1.1.9 is now opt-in (MEMTRACE_CPU_GOVERNOR=on). On by default it budgeted background work to half the performance cores and a quarter on battery, moved indexing and embedding threads to efficiency cores, and parked work its watchdog judged idle; on a busy laptop that read as memtrace start and memtrace index doing nothing. 1.1.10 schedules exactly as 1.1.8 did. The restart fixes that made 1.1.9 cheap to leave running (a checkpoint and vector-index recovery proportional to what changed, no re-embedding on restart) do not depend on the governor and stay on.
The database sidecar runs at normal scheduling priority again. 1.1.9 started it one notch below normal (MEMTRACE_SIDECAR_PRIORITY=low brings that back), which made every query wait behind whatever else a loaded machine was running.

Fixed

The 1.1.9 check for symbols that already have a vector is now limited to 5 seconds per repository (MEMTRACE_EMBED_PRESENCE_SCAN_SECS; 0 disables it); past that the pass embeds from cache as before, and its duration is logged. MEMTRACE_FORCE_EMBED=1 re-embeds everything.

The 1.1.9 stall on large stores

Fixed

Starting Memtrace, and running memtrace index, no longer stalls for minutes on a large store. The 1.1.9 check for symbols that already have a vector read every vector record of a repository, about 1.4 ms per symbol, on every start and on every index while holding the store's scan permit; on a 300k-symbol workspace that was minutes per repository with nothing printed. The check is now limited to 5 seconds per repository (MEMTRACE_EMBED_PRESENCE_SCAN_SECS; 0 disables it), and a repository that exceeds it embeds from cache as 1.1.8 did.
Windows: a workspace owner started from an elevated terminal, or any process the current user may not open, is no longer treated as dead. Attaching sessions tried to take over its store and reported the store as locked.

No new customer-facing notes this soak.

1.1.9-nightly.20260903.865f01a

Fixed

A startup embedding pass no longer re-embeds symbols that already have a vector. When a restart found the embedding completion record missing, the daemon re-embedded the entire repository from cache and rewrote every vector in the store — hours of sustained CPU on a large workspace, on every start, and it never converged when the pass was interrupted. The pass now skips symbols whose vector already exists, records those as complete, and so finishes in proportion to what is actually missing. memtrace index now reports the symbols that already had vectors in its summary, and MEMTRACE_FORCE_EMBED=1 re-embeds everything, for a model change or a suspect store. Thanks to BadMrPotatoHead for the report.

No new customer-facing notes this soak.

Memtrace governs its own CPU

New

Memtrace now governs its own CPU. Background work — daemon rebuilds, the file watcher, embedding, cross-repo convergence — draws from one CPU budget (half the performance cores by default) that yields to your own builds and editors, runs at a quarter rate on battery and pauses below 15%, and lifts to full speed once you have been away from the keyboard for five minutes. An interactive memtrace index keeps every performance core but still backs off under heat, on battery, or under critical memory pressure. MEMTRACE_CPU_GOVERNOR=off restores the previous scheduling; MEMTRACE_CPU_BUDGET_CORES sets the allowance and MEMTRACE_BACKGROUND_ON_BATTERY=off|full changes the battery policy.
An idle-burn watchdog ends the class of overheating where Memtrace burned CPU for hours on a machine where nothing changed. When the daemon and its database sidecar spend CPU for ten minutes without parsing, embedding, converging, or serving anything, every background loop is parked and the budget drops to a trickle until real work arrives — a saved file or an index request lifts it immediately. memtrace status, /api/health, and the mem_diag tool now show where every CPU-second went (parse, embed, convergence, watcher, serving), the current budget and why it was chosen, and any parked loops.
New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.
A real int8 build of the default code model is available as an opt-in (MEMTRACE_EMBED_QUANT=q8): a 162 MB first-run download instead of 641 MB and the same recall on natural-language queries against the vector index alone. In a paired benchmark of name-style find_code queries the int8 graph combined with the new length-sorted batching lost 4 points of top-10 accuracy (the quantised graph calibrates per batch, so documents batched together drift away from queries embedded alone), while the int8 graph on its own lost half a point at 45 % less embedding CPU. So every host keeps the full-precision graph by default, batching is switched off automatically under q8, and existing caches stay valid; switching to q8 re-embeds once. (The auto tier's previous "int8" label had always loaded the full-precision graph; the label is unchanged.)
Code the machine has already embedded is never embedded again: a second worktree, a clone under another name, a fork, or a vendored copy of the same symbols reuses the vectors from a machine-wide cache keyed by symbol content (MEMTRACE_EMBED_CACHE_GLOBAL_CAP_MB, default 512 MB). MEMTRACE_EMBED_CACHE=off disables caching for benchmarks.

Improved

Bulk indexing threads, the embedding worker, and the database sidecar now run below normal priority — on Windows 11 with EcoQoS, which moves them onto efficiency cores — so Memtrace stays out of the way of whatever you are doing. MEMTRACE_SIDECAR_PRIORITY=normal keeps the sidecar at the default priority.
Embedding, reranking, and SPLADE inference threads no longer spin-wait between operators, which burned one core per thread whenever the model pool was idle; MEMTRACE_ORT_SPIN=1 restores spinning. The SPLADE session also no longer takes one thread per core.
Hybrid Intel and AMD processors are now recognised on Windows and Linux. An 8P+12E Core Ultra previously counted as 20 performance cores, so both the interactive and the background thread pools sized themselves to every core on the chip.
Embedding batches are sorted by length and cut by a token budget, so short symbols no longer pay for the longest symbol in their batch (every batch used to be padded to its longest text). The vectors are identical to the unsorted ones (per-document cosine 1.00000 in our check) at 28 to 35 % less embedding CPU per symbol in our measurements; memtrace status and /api/health report the share of inference spent on real tokens. MEMTRACE_EMBED_BUCKETING=off restores the old batching.
The vector index writes far less to disk: adding a symbol no longer rewrites the full record (vector included) of every neighbour it links to, only their neighbour lists, and the 1-bit codec (MEMTRACE_HNSW_CODEC=rabitq) now scores candidates by popcount instead of decoding each one back to floats. The first start after this upgrade rebuilds the vector index once from the stored vectors.
A new embed-text recipe is available for operators who want the last bit of indexing CPU: MEMTRACE_EMBED_RECIPE=headtail:900,400 embeds the head and the tail of long symbol bodies instead of the first 1500 characters — in our measurements the same recall at 13 % less embedding CPU. It changes the cache namespace, so switching re-embeds once; the default recipe is unchanged.
memtrace gpu status reports the NPU: whether one is present, whether the OpenVINO runtime and provider are installed, and what is still missing before MEMTRACE_ENABLE_OPENVINO=1 can use it. MEMTRACE_OPENVINO_DEVICE selects the device (default AUTO:NPU,CPU) and the provider now takes precedence over DirectML when enabled.
On Windows, a failed ONNX Runtime load now names the usual cause — the Microsoft Visual C++ 2015-2022 runtime is missing — with the download, instead of pointing at PATH.
memtrace doctor on Windows now checks for the Microsoft Visual C++ 2015-2022 runtime that Memtrace's embedding runtime needs and prints the download link when it is missing, so a fresh machine learns this before the first memtrace start fails to load ONNX Runtime.
list_watched_paths, embed_diag and mem_diag now say which process answered (_meta.scope: the daemon, or an MCP session's own stdio process, with the daemon's pid), so an empty watch list or idle embed state seen from an editor session is no longer mistaken for the daemon doing nothing.
MCP tool results say when the graph is still being written. While indexing or cross-repo linking is running, every result carries _meta.graph_converging: true with the pass state, so an agent can tell a partial impact or caller answer from a settled one and retry instead of trusting it. Thanks to Magalz for the report.

Fixed

A working-tree change whose exact delta could not be computed re-parsed the repository every five seconds forever, and every attempt re-armed cross-repo linking. The retry now backs off from five seconds to five minutes and resets as soon as a delta applies.
The observe-mode measurement drain no longer runs real searches every 20 seconds against an empty spool; it backs off and parks after five empty passes, resuming on its own when entries appear.
A vector index holding a single symbol was never written to disk until a second symbol arrived, and compacting a 1-bit index silently rebuilt it as full floats.
Semantic search kept working on large stores: once a local store passed 512 MB, background maintenance of the vector index was switched off to save CPU, so every symbol saved after that was findable by name but not by meaning. The vector index now keeps updating on stores of any size; only the structural index rebuild is skipped on large stores, and memtrace start says so.
On Windows the file watcher reported itself armed but never recorded a change: the watched folder was stored in one path spelling and change events arrived in another, so every save was silently dropped. Saves and pulls now reach the index, dropped events are counted, and a batch that lands during a merge or rebase is deferred until git is done instead of being thrown away.
memtrace govern and the dashboard's Governance panel no longer fail with "cortex.sock I/O failed: The pipe is being closed" on repositories with many rules or ADRs (Windows). Classification is now sent in bounded batches instead of one request carrying every document's text.
memtrace govern docs/architecture now finds ADRs under numbered or underscored directories such as 09_architecture_decisions; previously the sweep reported 0 governance docs for them.
The installer registers the Memtrace MCP server where Claude Code actually reads it (~/.claude.json) when the claude CLI is unavailable, and memtrace doctor checks that file; before, skills appeared in a session while every Memtrace tool was missing and doctor still reported the registration healthy.
memtrace start picks the next free port when 3030 turned out busy between the check and the bind instead of aborting.
memtrace govern and the Governance panel no longer say "MemCortex is not running" when MemCortex is running but did not accept a connection in time (starting up or busy); the message now says what happened and suggests retrying.
Restarting Memtrace on a large store no longer burns CPU for an hour with nothing to do. After an unclean stop (a crash, a kill, a machine restart) the database used to flush every mapped page of the whole store up to three times and rewrite its entire record index, and when the vector-index log had grown past 512 MB it replayed that whole log in the background on every start, forever, because nothing ever shrank it. The checkpoint now costs only what changed since the last one, and the vector-index log is rotated down to one record per live symbol after such a recovery and whenever it outgrows the live index, so the next start recovers it in seconds. Measured on a copied store restarted after a kill: checkpoint 0.12 s, vector index recovered from the rotated log with no background rebuild. Existing stores get the rotation on their first start after the upgrade.
Restarting Memtrace no longer re-embeds every repository. Three minutes after each start, a background clean-up of duplicate record versions marked every repository's symbols as changed even when it had nothing to close, which invalidated the embedding completion record (or withheld it while embedding was still running), so the next start re-ran the whole embedding pass — on large stores, sustained CPU after every restart. The clean-up now scans first and records a change only when it actually closes something.
memtrace mcp answers initialize as soon as it is attached to the workspace store, before it hydrates repositories, starts Cortex, or validates the licence session; those now run in the background and the first tool call waits for them (up to a minute). On a busy or very large workspace the server used to sit silently after MemDB ready until every MCP client timed out. While it starts, stderr now names the phase it is in (still starting (10s): validating the licence session), and a start that cannot reach the session within two minutes exits with that phase instead of lingering — so periodic probes no longer accumulate as hung processes. MEMTRACE_MCP_STARTUP_TIMEOUT_SECS raises the limit. Thanks to BadMrPotatoHead for the report.
A startup embedding pass no longer re-embeds symbols that already have a vector. When a restart found the embedding completion record missing, the daemon re-embedded the entire repository from cache and rewrote every vector in the store — hours of sustained CPU on a large workspace, on every start, and it never converged when the pass was interrupted. The pass now skips symbols whose vector already exists, records those as complete, and so finishes in proportion to what is actually missing. Thanks to BadMrPotatoHead for the report.
On Windows, memtrace doctor --fix, memtrace reset, and memtrace stop now recognise that a workspace owner has exited. The liveness check behind all three always answered "alive", so a killed owner's daemon.pid and daemon-state.json were never swept, doctor reported "heartbeat is alive but health is not responding", and reset refused to proceed until the files were moved by hand. A pid is now checked against its real exit state, including the case where a parent shell still holds a handle to the dead process. Thanks to Magalz for the report.
Related symbols in get_symbol_context (contains, community_siblings, callers) now carry annotations and annotation_args like the primary symbol; the related-symbol projection had dropped both fields, which rendered them as null for symbols whose direct payload had them. Thanks to Magalz for the report.
get_repository_stats.nodes_by_kind now includes every kind the indexer stamps — Constant, Field, Variable, TypeAlias, SQL, Terraform, and CI kinds among them — instead of a fixed subset, so the rollup reconciles with what find_symbol returns. Thanks to Magalz for the report.
Attaching memtrace mcp to a long-running owner no longer fails after the machine's clock is adjusted. The owner's runtime record was verified by its wall-clock start time, which shifts under WSL2 after a clock step and made every later attach refuse a healthy daemon ("has no runtime record for store"). On Linux the record now carries the kernel's clock-tick start time and boot id and is verified by those; other platforms keep the start-time check. Thanks to Magalz for the report.
Agent guidance from the Memtrace MCP server now reaches the agent intact. The routing instructions had grown past the size limit coding agents apply to a server's instructions, so the tail was silently cut off — including the note telling agents to pass an explicit repo_id in an ambiguous multi-repo workspace, which is exactly where scoping mistakes happen.
Memtrace's MCP tools are now offered to the agent from the first turn. Coding agents defer tool definitions until something asks for them, so Memtrace's tools arrived as bare names while the built-in search tools arrived complete — biasing the agent toward grep before it could see what Memtrace offered. Run memtrace install to pick this up.
Operator surfaces now answer for the daemon that actually does the work. An MCP child spawned without workspace context (an IDE launching at the filesystem root) used to answer list_jobs, list_watched_paths, mem_diag, and embed_diag from its own empty process — zero watches while the daemon held 44, an 18 MB memory report while the engine held gigabytes — with no hint anything was wrong. These surfaces now find the workspace daemon through the same runtime discovery repository listing uses and answer from it, naming the answering process in _meta.answered_by; jobs and watches merge both processes' entries, a daemon job id can be polled from the child, and when no daemon is reachable the payload says so (_meta.daemon_unreachable with the exact reason and remedy — including "restart the daemon" when it predates these routes) instead of presenting silent empty lists as the truth.

No new customer-facing notes this soak.

1.1.8-nightly.20260901.5b76df4

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

1.1.8-nightly.20260901.6ce67f8

Fixed

Decision-memory queries no longer fail against a momentarily busy Cortex sidecar. The sidecar serves local IPC one request at a time, so a recall queued behind a long ingest could burn its whole deadline and be reported unavailable — enterprise sessions measured roughly one failure in four calls. Read-only decision queries now retry once with a fresh window, a transport failure reports how many attempts were made and stays unmistakably distinct from a genuine “no matching memories” answer, and recall answers name the workspace scope they were filtered by — so a zero-match answer against a store the dashboard shows full of decisions is diagnosable as a scope mismatch rather than reading as “no decisions recorded”. MEMCORTEX_DECISION_TIMEOUT_MS raises the deadline for very large stores.
memtrace doctor no longer flags three healthy states as problems needing --fix: a locked workspace PID file is the live owner's own singleton advertisement, not a stale file (and --fix no longer offers to delete it out from under the running daemon); the UI port being held by the very owner doctor just called healthy is not a port conflict; and Claude Code skills installed through the plugin marketplace are now found in the plugin cache instead of being reported as “0 skills” on a fully working setup.
Manually curated symbol links (link_symbols) now survive a repository clear-and-rebuild. A full reindex previously wiped them along with the parser's own output; the rebuild now snapshots them first and restores them afterwards, re-attached to the re-parsed symbols through their deterministic identities.

No new customer-facing notes this soak.

1.1.8-nightly.20260901.624aed8

Fixed

Indexing no longer crashes on non-ASCII source. Statement windows in the Rust transport detector sliced at fixed byte offsets that can land inside a multi-byte character, killing ingestion on any codebase with Danish, German, French, or Czech comments or identifiers ("byte index N is not a char boundary"). All four windowing sites now align to character boundaries, pinned by a property test that feeds the detector arbitrary unicode.
The telemetry opt-out now means zero non-licence traffic. Previously the licence heartbeat carried graph statistics and record counts regardless of the opt-out, so an opted-out user's usage still appeared server-side. With MEMTRACE_TELEMETRY=off — or the industry DO_NOT_TRACK convention, now honoured equally — the heartbeat still validates your session and carries contract-billing meter counts, but graph statistics, repository rows, and record counts never leave the machine, and the launcher's npm version check goes quiet too. TELEMETRY.md now documents exactly what flows in every mode, verifiable with a network sniffer.
One global VS Code MCP entry now serves every project: the installer writes "cwd": "${workspaceFolder}", so each window anchors the server on its own project instead of the editor's ambient directory — previously all projects could silently share one wrong, empty user-level store. memtrace mcp --help also finally documents the --workspace flags it has always accepted.
Windows lock-contention classification is now guarded at the source level: every file-lock site routes through one shared platform rule, so a raw os error 33 (the Windows spelling of "lock is busy") can never again be treated as a fatal error by a site that missed the mapping.
.memtraceignore now governs live working-tree ingestion, not just memtrace index. Saving an ignored file used to re-ingest it into the graph as a working-tree episode — the ignore file appeared to work until the file was next touched. The watcher batch now filters through the exact matcher the CLI uses (user patterns over the built-in noise baseline, !path re-includes intact), edits to .memtraceignore take effect on the very next save, and benchmark-fixture saves stop generating episodes the CLI scan would never have indexed.

No new customer-facing notes this soak.

Convergence knows when to stop

New

The built-in CPU profiler now works on Linux and macOS as well as Windows: set MEMCORE_SELF_PROFILE=1 and the database engine samples its own hot functions and writes named stack reports into its normal log — no admin rights or external tools on any platform, and reports carry function names rather than raw addresses.

Fixed

Preserving a repository's last-published graph is now a settled, certified-clean outcome of convergence instead of a reported failure. Treating it as an error left the repository permanently dirty and queued, and both halves of convergence looped on that state — the link pass re-armed itself off the non-empty queue, and every dashboard poll and boot probe re-queued the still-dirty publication.
Background link passes that leave repositories queued but make no progress now stop re-arming themselves under one capped policy. Index completions, watcher saves, and dashboard polls still schedule passes normally, so no single unsettleable repository state can pin a background loop again.

1.1.7-nightly.20260901.4b89988

Fixed

memtrace start no longer aborts a completed boot with a bare "No such file or directory (os error 2)". Concurrent publishers of the daemon's owner-state file shared one temp filename, so one could lose a rename race — a benign, self-healing condition the write layer already classified as ignorable, but the startup path treated as fatal. Each write now uses a unique temp name, a lost publish is logged and re-published by the heartbeat within seconds, and the heartbeat republishes the resolved UI port rather than the boot-time one.
A warming flag can no longer outlive the condition it reports. The boot readiness probe ran exactly once; when an editor's MCP child booted before memtrace start, every response carried warming: true and empty_state_reason: "warming" forever — including fully populated results, which taught agents to abandon a healthy graph for grep. The flag now re-probes on observation and in the background once an owner appears, and a non-empty result is always labelled as real data (not_empty) no matter what the flag says.
Repository discovery no longer sweeps OS profile trees. Launched from a home directory, the scan used to walk the entire user profile — registering package caches, Temp scratch directories, and editor backup folders as zero-node repositories, slowly. AppData, Library, and Application Data are now skipped, the walk is depth-bounded, and multi-repo discovery rooted at the home directory itself is refused with a clear message.
When the MemCortex local endpoint is reserved by a leftover handle that no longer answers, Memtrace no longer launches a daemon doomed to print an ownership error on every supervisor tick. It skips the futile spawn, explains once what actually holds the endpoint and how to free it — including the case a plain taskkill cannot fix, where a process that inherited the handle outlived the daemon — and takes over automatically the moment the endpoint frees.
The one-time post-upgrade index refresh now verifies itself: each refreshed repository is re-checked, and if its schema markers did not persist — the condition that made a demo estate silently re-parse and re-embed on every start — the boot log names the repository and the exact stored versions instead of looping quietly.

Relinking settles instead of retrying forever

Changed

Setting MEMTRACE_MEMDB_ENDPOINT (or MEMTRACE_MEMDB_ENDPOINTS) now always means "connect to that server" — external mode — including loopback addresses such as an SSH tunnel or kubectl port-forward to a hosted MemDB. Previously a loopback value silently selected local mode, ignored the address, and started a local engine, so writes meant for the appliance landed in a local store. Only the literal default endpoint still selects local mode; set MEMTRACE_MEMDB_MODE=local explicitly if you relied on the old inference.

Fixed

Cross-repository relinking no longer loops forever on a repository whose live graph is empty while a good last-published graph is on disk: keeping that graph is now a settled outcome rather than a retried failure, so convergence completes, the dashboard stops reporting an endless warm-up, and startup embedding stops waiting behind it. Stores already stuck this way settle on their own after upgrading, no reindex needed. Background link passes that repeatedly make no progress now back off and eventually stop re-arming themselves, so no single repository state can pin that loop again.
Live file-watch updates against an https:// hosted MemDB no longer fail while every other query path reports the server healthy: the watcher's incremental persists now dial through the same TLS-capable connection as the rest of Memtrace instead of a cleartext-only path that could never reach a TLS endpoint.
A refreshed seat token can no longer replace a working credential with one the server rejects. Session start used to blindly store the freshly minted seat token for the active endpoint; on a deployment that does not authorize that seat yet (the organization's pinned endpoint does not cover it, or the seat was revoked), this overwrote the credential memtrace connect had installed and every following session failed. The refreshed token is now verified against the live server first, and an unauthorized one is reported — with the endpoint-pinning fix to apply — while the existing credential stays in place.
An authentication rejection from a hosted MemDB is now reported as exactly that, instead of "could not reach the external MemDB" with DNS-and-firewall guidance for a server that answered. The error now says the server is reachable but rejected the bearer, and lists the credential-side fixes: pin the endpoint in the dashboard so member seats are accepted, or reconnect with your connection file.

1.1.6-nightly.20260831.7fcb5d9

New

Fields and constants are now first-class symbols with read and write edges, extracted across 18 language families and classified by each language's own write-once form — so get_impact finally answers who reads a feature flag, config constant, or magic number, with no getter workaround. Compound assignments record both a read and a write. Thanks to Magalz for the field report behind this batch.
link_symbols records cross-repository relationships at symbol granularity — queue producer/consumer pairs, gRPC seams, shared schemas the HTTP linker cannot infer — and get_impact walks them in both directions. An ambiguous name is refused with the candidates listed, never guessed.
ingest_graph_fragment lets your own tools contribute nodes and edges for structure Memtrace cannot parse — generated stubs, in-house DSLs, build-graph output — with a provenance tag stamped on every contributed record and surfaced in queries, and rerunning generators rewrite their rows instead of duplicating them.
find_code_review_issues flags a value consumed inconsistently across call sites — the classic money, timestamp, and ID bug no single-file rule can see — listing every consuming site, and staying quiet when narrowing is unanimous and deliberate.
Annotation names and their arguments are captured and queryable: find_symbol can filter by annotation and get_symbol_context surfaces them, across Java and Kotlin annotations and Python and TypeScript decorators.
Named milestone anchors bind a name to an instant, and get_evolution can diff the graph between two named states — release-to-release change reports without hunting timestamps. Re-creating a name moves the anchor, because a re-cut release is the common case.
An opt-in query-level audit log (MEMTRACE_QUERY_AUDIT=1) records one line per tool call — who, what, when, outcome — exported with export_query_audit. Tool arguments are deliberately not recorded, so the audit trail can never become a second copy of your source under weaker access control.

Fixed

index_directory now attaches to a repository's index job already in flight instead of starting a second run, which could race the first and leave the older job's record stalled forever.

Improved

A branch-scoped symbol miss now names the branches that do carry the symbol, instead of returning the same empty answer as a symbol that does not exist.

1.1.6-nightly.20260831.a32b951

Fixed

memtrace index no longer stalls for five minutes and exits with an error when embeddings are enabled: the wait for cross-repository graph convergence now happens only after the index has published its results, so indexing and background relinking can no longer lock each other out.

1.1.6-nightly.20260831.6ece81f

Fixed

find_duplicate_code no longer reports a symbol as a duplicate of itself. Copies the index holds more than once — branch snapshots, working-tree saves, path-spelling variants — are collapsed before pairing, so each real duplicate appears exactly once and cites the correct original. Thanks to Trekkie for the report.
find_duplicate_code now honors its branch parameter: results are scoped to the requested branch, or to the repository's current branch when omitted, and asking for a branch with no indexed code is a clear error instead of a silent unscoped scan. Thanks to Trekkie for the report.
The dashboard's exact-duplication figure now counts real duplicated function bodies instead of raw scan rows, which could overstate duplication roughly twenty to one. Thanks to Trekkie for the report.
cleanup_stale_records now treats file_path_pattern as a strict boundary: combined with any staleness scope, nothing outside the pattern can be selected for deletion, a pattern that matches nothing deletes nothing, and the sampled paths always satisfy the pattern. Previously the scopes combined as a union, so a cleanup scoped to one file could silently select records across the whole repository; scrubs that intentionally span scopes now take one call per scope. Thanks to Trekkie for the report.
get_repository_stats can no longer present a healthy graph as empty: when an exact branch match finds almost nothing, statistics are recomputed with the same branch-ancestry visibility every other graph tool uses, and any remaining divergence is explained in the response with the store's real live counts and the likely cause — so zero edges never silently looks like a failed index. Thanks to Trekkie for the report.
get_repository_stats without a branch now reports the repository's primary indexed branch — the one list_indexed_repositories shows — instead of whatever branch the local checkout happened to be on, and the tool reference now defines every node count and when indexing_incomplete is set. Thanks to Trekkie for the report.
When the database backend dies or stops answering mid-session, the heavy graph tools — get_cochange_context, get_evolution, get_symbol_context — now fail within seconds with the clear endpoint-unreachable error, even for calls already queued behind another heavy query, instead of blocking for up to thirty minutes. Thanks to Trekkie for the report.
Cancelling or abandoning a tool call now stops its server-side work, so an abandoned heavy query no longer keeps burning CPU or starving the queries behind it. Thanks to Trekkie for the report.

Improved

The documentation now covers clone detection and repository statistics: what find_duplicate_code pairs and how its branch scoping works, what the dashboard's duplication figure counts, every get_repository_stats node count and when indexing_incomplete is set, and how cleanup scopes combine. Thanks to Trekkie for flagging the gaps.

No new customer-facing notes this soak.

1.1.6-nightly.20260831.e9810ad

Fixed

Installs and upgrades now succeed even from a shell where Node itself is not on PATH: the installer carries its own Node location into every step it runs. It also stops a running Memtrace before replacing its files, so a live daemon can no longer make a Windows upgrade half-land on locked binaries.

1.1.6-nightly.20260830.9a5dd4e

Fixed

memtrace install no longer depends on npm being resolvable from the shell it happens to run in — it now finds the npm that ships beside Node itself. And when the upgrade genuinely cannot run, it says what went wrong in one line instead of crashing with a stack trace that buried the reason.
Upgrades no longer complete silently WITHOUT their finishing step on newer npm versions whose script policy blocks install scripts by default: the installer now grants itself permission to run its own completion step, so the platform binary and the consented configuration always arrive together with the package.

No new customer-facing notes this soak.

1.1.6-nightly.20260830.44c6524

New

--index-ignored (or MEMTRACE_INDEX_IGNORED) indexes the files a repository's ignore rules would normally hide. Every ignore source is turned off together, parent directories included, so an ancestor cannot keep filtering a tree you asked to see in full. Off by default: a repository's ignore rules are written for building the product, and honouring them is what almost everyone wants.

Fixed

--allow-non-git passed inside an actual git repository no longer disappears without a word. The flag only opens the gate for a directory with no version control, so it now says it does not apply, names the repository it resolved, and points at --index-ignored when indexing ignored files is what you were after.
Files whose extension matches no supported language are now counted and reported by the scan instead of vanishing from every statistic. A tree Memtrace has no parser for used to be indistinguishable from an empty one.
Running out of file watches on the host no longer costs you the whole daemon. Exhausting the operating system's watch capacity used to abort startup outright — no dashboard, no agent connection, no way to reach an index that was already complete. Memtrace now starts without live watching, names the limit it hit and the exact command to raise it, and keeps serving search, graph and impact. Watcher failures it cannot explain still stop startup, because those are not something a host setting fixes.

No new customer-facing notes this soak.

1.1.6-nightly.20260825.27a8817

Fixed

Workspaces whose store had grown past the large-store threshold stopped drawing cross-repo connections and the topology view: once the store crossed that size, the graph stopped being relinked at all, so repositories rendered as disconnected blobs and no amount of re-indexing brought the links back. Indexing a repository now always reconnects it, on any store size. Idle CPU stays where 1.1.4 put it.
After a first index finishes, Insights tabs wait until you open them instead of rebuilding every panel in the background. That background mill is what kept the graph database busy after indexing had already stopped.
Opening the graph or an Insights tab no longer waits for every other lookup to finish first. A couple of lookups can overlap, and CPU drops when the query is done instead of sitting at several hundred percent.
Once the first graph pass goes quiet, later file saves do not kick off another whole-store sweep. memtrace start can sit still even if you indexed from empty after a reset.

1.1.6-nightly.20260825.56e1c76

New

memtrace ui serves the dashboard on its own against an engine that is already running. It does not index, watch, or take workspace ownership, so the dashboard and the engine can be restarted independently and a status page can outlive the editor session that used to keep it alive.
memtrace claude install writes a Memtrace routing directive into a project's own CLAUDE.md, so Claude Code reaches for Memtrace before text search in that repository. It survives context compaction, can be committed so a team shares one rule, and memtrace claude uninstall removes it leaving the rest of the file byte-identical.
Directories that are not git repositories can now be indexed as a point-in-time snapshot, with --allow-non-git or MEMTRACE_ALLOW_NON_GIT. Symbols, relationships, impact and search all work; history-derived answers are unavailable by construction and now say so rather than returning an empty result that looks like nothing ever changed.
cleanup_stale_records gained a check_stale_spans scope that reaches symbols left behind in files that still exist — the case the missing-file scope cannot see, which previously needed deleting the whole repository.

Fixed

Starting no longer aborts with a multi-gigabyte allocation failure when a recovery checkpoint points into the middle of a record instead of at a record boundary. A damaged checkpoint now costs a slower start rather than a database that can never be opened again, and the recovery path can no longer shorten a log to a position it has not verified.
Repository enumeration is bounded and no longer stalls a whole agent session. If it outruns its deadline it reports what to do instead of leaving the client to give up in silence, and tools that need a repository will now read the store's own membership record when enumeration cannot answer — so a slow discovery call no longer blocks everything behind it.
A relationship query that finds no connections now says whether that is a conclusive answer. A count of zero used to read as proof that a symbol was unused even when the lookup itself had not resolved, which is the worst possible wording ahead of a deletion.
A background pass that processed nothing is no longer reported as a failure. An empty work-set cannot have failed, and calling it one led users toward wiping a store whose data was intact and only needed its index repaired.
The graph view only suggests running an index when the store is confirmed empty. While indexing is in progress, or while counts are briefly unavailable, it now says so instead of advising a second indexer against a store the first one is still writing.
The upgrade hint names sudo when, and only when, the install location actually needs it, so an upgrade on a system-owned install no longer fails with a permissions error after you have already confirmed it.
memtrace status confirms the dashboard is really listening before printing its address, and says so plainly when the port is recorded but nothing answers on it.
MCP sessions no longer leave behind lease files owned by processes that have exited, and a session that is stopped abruptly is cleaned up by the next start rather than accumulating. The Cortex socket is removed when the daemon that owned it stops.
doctor --fix now names the sessions it could not stop, which application owns each one, and the exact command to stop them — rather than reporting that it found processes and then leaving them running.
A workstation that sleeps overnight no longer fills the log with one identical heartbeat warning per cycle. The first failure is reported, the rest stay quiet, and a single line says when the network came back and how long it was gone.
The documentation assistant no longer tells Windows and Linux readers to press a key their keyboard does not have; the search shortcut now shows the modifier for the reader's platform.
The documentation assistant follows a streaming answer the way a terminal does: it stays pinned while you are at the bottom, releases as soon as you scroll up to read, and re-attaches when you scroll back down.

No new customer-facing notes this soak.

1.1.6-nightly.20260823.977d333

New

A built-in CPU profiler: set MEMCORE_SELF_PROFILE=1 and the engine samples its own hot functions and writes named stack reports into its normal log — no admin rights or external tools needed on any machine.

Fixed

History and timeline questions no longer scan and decode the entire store: all-time and as-of queries are answered from the property index, so a daemon left running with no clients measures around one percent of a core instead of holding two or more cores forever.
Deleted or superseded code now stays deleted after a restart. Soft-deletes used to live only in memory, so every boot brought removed vectors back as live and searchable and the compactor re-reclaimed them each time; deletes are now durably logged and replayed on boot, with no store migration needed.
If the property index cannot record a write, the store now marks that index incomplete and answers from the full data until it heals, instead of silently missing rows.
A single slow engine call can no longer hold a client request open indefinitely: per-call deadlines fail fast with a clear error instead.
On NVIDIA cards, embeddings no longer route through DirectML when the runtime documents a better provider for that hardware — and when CPU is measurably faster, Memtrace says so plainly instead of pretending the GPU helps.
Windows no longer loops demoting and rebuilding the insights cache: file replacement follows one atomic rule everywhere, and Windows now matches macOS across path handling, locks, and Cortex startup.
Startup embedding and cross-repository relinking can no longer deadlock each other during boot.
Starting the dashboard next to a headless agent session takes over the store cleanly instead of leaving both processes wedged.
Stale overlay copies of a symbol no longer outrank the current version in search results, and a modified symbol now closes its superseded predecessor rows so watched repositories stop accumulating duplicates.
Cleanup no longer flags virtual paths as missing files, and branch-scoped statistics explain a near-empty scan instead of looking broken.

Improved

Symbol evolution views make one pass over the history window instead of one query per episode, so long histories load quickly.
Cross-repository topology lookups seek directly to the rows they need instead of walking unrelated ones.
Background maintenance now reports each tick's cost in the log, so a busy daemon can say what it was doing.

No new customer-facing notes this soak.

1.1.6-nightly.20260823.67c481c

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

Sessions clean up after themselves, and reset never deletes your history

New

Clearing or resetting a store no longer deletes anything: everything it held moves to a sibling history archive next to the store, ready to restore by moving it back. The new memtrace history command lists archived generations, and only the explicit memtrace history purge --store <path> --delete-forever can permanently remove them.
memtrace stop now also collects engine processes left behind in other workspaces when the store's own records prove their owning session is gone, so a forgotten window can no longer leave a database engine running for days.

Fixed

Closing an agent session no longer leaves its database engine running in the background — every exit path now shuts the engine down with the session.
Background agent sessions no longer advertise a dashboard port they never opened, which made memtrace start mistake a healthy session for a broken one and restart it, briefly taking every connected agent down with it.
Memory no longer spikes by hundreds of megabytes per code search in each connected agent: searches now reuse the running workspace engine for query embedding, the reranking model unloads when idle, and freed memory returns to the system promptly.
Recovering a store with damaged records no longer floods the engine log with megabytes of repeated warnings per minute; repairs are summarized instead.
Stopping Memtrace in one workspace can no longer discard the runtime record of a different workspace whose session is still running.

Improved

The agent-tooling hook that routes code searches now asks the running workspace service directly instead of launching a new program for every terminal command, removing dozens of short-lived processes per minute during active coding sessions.

1.1.5-nightly.20260820.5a40550

Fixed

Opening a cross-repository call from the service map now keeps that relationship in the main graph and makes the connection visible instead of selecting an apparently isolated node. Agent impact and blast-radius queries follow the same call through its remote endpoint and handler, and identify the affected repositories explicitly.

Cross-repository calls stay connected from service map to graph

New

Python subprocess calls and commands embedded in Nextflow script and shell processes can now connect to matching command-line programs in another repository when the executable is statically identifiable.
R projects now retain structured evidence for base and Tidyverse pipelines, tidy-evaluation operators, data masks, tidy-select helpers, and formula lambdas instead of flattening those expressions into unrelated symbols.

Improved

Cross-repository service discovery now recognizes more C# and C++ HTTP clients plus gRPC, WebSocket, and common message-queue framework calls.
Django model relations, string URL views, class-based views, decorators, dynamic module imports, and common framework string references now leave inspectable graph evidence when their targets can be resolved.
Inferred relationships expose their confidence and reason in the graph inspector, so a framework or cross-repository link can be checked instead of accepted as an unexplained line.

Fixed

Opening a cross-repository call from the service map now keeps that relationship in the main graph and makes the connection visible instead of selecting an apparently isolated node.
Code previews now apply syntax highlighting to R and use one supported-language mapping for every language Memtrace indexes.
Python handlers and framework entrypoints no longer look dead merely because the framework reaches them through a decorator or a resolved string reference.
Malformed Kotlin input can no longer leave an extra-symbol query consuming a full core and gigabytes of memory indefinitely.

First index leaves the rest of the machine usable

Fixed

The first memtrace index or memtrace start used to keep embeddings and parsing on a full-speed CPU pool even after the indexer itself stepped down to a background slice of cores. Those jobs now share that same cap, so a first run on a passively cooled laptop stays usable. Pass --max-cores N if you want a smaller slice.
Parsed symbols are written as soon as resolve finishes, so find_symbol and the graph in /ui can start answering while modules are still being detected.
On Windows, indexer threads run at below-normal priority so the desktop stays in front while a first index is running.

1.1.4-nightly.20260816.6918590

Fixed

On a large already-indexed store, start no longer counts every node per repository and no longer rebuilds search indexes in the background while you sit still. That was the leftover CPU after Skip.
Closing Claude Code or another editor's memtrace mcp no longer leaves memcore-server listening on 127.0.0.1:50051. On Linux the sidecar dies with the parent, including a hard kill. The next spawn reaps a leftover for this store, and WSL can see that port with ss when lsof is missing.
memtrace mcp can join a running memtrace start even when the npm wrapper started several seconds before the real binary. That timestamp mismatch used to look like an unverifiable runtime and closed the MCP connection.
get_cochange_context no longer times out on repositories whose working-tree history is a dense in-tree build. It skips those wide save episodes, uses the files already on each episode, and does not scan the graph once per episode. A 30-second client deadline is enough again; other tools on the same daemon are not starved by abandoned co-change calls.
Checking out a feature branch keeps the original main graph and applies only that branch's delta. It does not copy the whole graph. Changed nodes are restamped on the feature; checking main back out returns the original.

Start Memtrace and sit still — idle CPU stays down

Fixed

After memtrace start on a database you already indexed, Memtrace no longer rebuilds search indexes just to open it. Leave it running with no agent and no index job and the machine stays quiet.
Cortex no longer rereads every decision document on a timer while nothing changed. Saving an ADR or an agent-rule file is what wakes capture.
Cortex Governance no longer reports the daemon as down when a request fails. If Cortex is running, the page says so, including when the editor has more than one folder open.
Starting with a different workspace than the one already in .memdb no longer moves that database aside and rebuilds from empty. Memtrace keeps the existing graphs, adds newly listed repositories, and refuses when the requested set would drop or replace members. Pass --clear only if you mean to discard the store.
Indexing a workspace no longer leaves later repositories empty because another graph pass briefly held the store. Those indexes wait for the lock instead of failing.
A new repository in the workspace is indexed when you run memtrace start or when the editor's memtrace mcp owns the store. A terminal start asks first (default yes). Large stores still skip re-walking repositories that already have a graph.
After memtrace start, Memtrace does not re-read the whole database to fill dashboard graph pictures. A file save patches the picture you already have. Indexing a repository writes that picture from the graph just built. Indexed repositories with no changes stay idle.

1.1.4-nightly.20260815.76dd456

Fixed

You do not have to sit in the workspace folder. After memtrace start, an editor opened on one repository in that folder joins the same runtime and lists every repository.
A leftover editor helper that never connected, including one whose folder we cannot see, is closed when start comes up so the next agent call can attach.

1.1.4-nightly.20260815.16f28a9

Fixed

Any editor that runs memtrace mcp — Cursor, Claude, Codex, VS Code, Zed, and the rest — joins memtrace start whether the editor or Memtrace came up first. A live helper stays alive and attaches; start does not kill it to force a respawn, because Claude Code does not respawn a dead stdio server. Only a leftover helper from an older build that never registered is closed.

1.1.4-nightly.20260814.c3d81c3

Fixed

Asking an editor what Memtrace has indexed no longer comes back empty when that editor started Memtrace from your home folder. It joins the one running memtrace start and lists those repositories.
Any editor that runs memtrace mcp — Cursor, Claude, Codex, Zed, Kiro, OpenHands, and the rest — joins memtrace start whether the editor or Memtrace came up first. If the editor is already open, running memtrace start is enough. You do not quit Claude, Cursor, or anything else to connect.
Nightly Discord notes now list only what this soak changed. They no longer repeat the whole pending release every time a new nightly ships.

1.1.4-nightly.20260814.5664d1c

Fixed

Nightly memtrace start no longer repeats Memtrace on the version line.
The in-app Nightly What's new list is this soak's notes, not an older handwritten snapshot.

1.1.4-nightly.20260814.09686c8

Fixed

Asking Cursor what Memtrace has indexed no longer comes back empty when Cursor started Memtrace from your home folder. It joins the one running memtrace start and lists those repositories. Fully quit Cursor after this upgrade so it respawns that process; reloading MCP is not enough.
The memtrace start banner now shows the real logo spiral and a title-case Memtrace wordmark, not a block MEMTRACE stencil.

No new customer-facing notes this soak.

Nightly is for new features, and Insights tabs keep their picture

New

New features land on Nightly first: npm install -g memtrace@nightly is the same memtrace command, and it is not always stable. They still ship on the default install. memtrace install stays on the channel you already have.

Stable will ship more slowly, and Insights tabs keep their picture

New

Stable releases will ship more slowly from here, so the default install can soak. New features land first on Nightly: npm install -g memtrace@nightly replaces the same memtrace command, and memtrace install then stays on that channel.

Fixed

The terminal startup screen shows the Memtrace mark in the teal from the logo, and the last E in MEMTRACE is a full letter.

1.1.4-nightly.20260814.42765b2

Fixed

Cursor, Claude, Codex, and the other stdio editors now join an already-running memtrace start instead of hanging on Not connected or opening a second empty database. If the editor launched first, it waits and connects when you start Memtrace. Fully quit the editor after this upgrade so it respawns that process. Reloading the MCP server is not enough.

1.1.4-nightly.20260814.eb01266

Fixed

The All repositories graph also paints the repository graphs that are already ready while another repository is still rebuilding.
Cortex Governance now lists the docs for the repository you have selected, even when the editor window has more than one folder open.

No new customer-facing notes this soak.

Insights tabs keep their picture, and the service map names the call

New

Install a soak build with npm install -g memtrace@nightly. It replaces the same memtrace command. Stable installs keep using npm install -g memtrace and only offer stable upgrades.

Fixed

Insights tabs that already have something to show now paint it instead of spinning while another tab rebuilds. Reconnecting the dashboard no longer forces every tab to start over.
The All repositories graph no longer sits empty for tens of seconds just because graph work is happening somewhere else. If that view was already built, it paints immediately.
Scrolling to zoom the GPU graph no longer fights the browser. The wheel zooms instead of scrolling the page.

Improved

The service map draws the function that makes an HTTP or gRPC call, with the method and the file it lives in. gRPC is a different color from HTTP.
A new API route shows up on the API tab once the graph has the endpoint. A route nobody calls will not grow a topology arrow, because there is no caller to draw.

Changed

On Apple Silicon, embedding uses the Neural Engine by default. Set MEMTRACE_DISABLE_COREML=1 if you want CPU only.

Ship with memory

Your next release deserves this paper trail.

Memtrace remembers what changed, why, and what it broke — for your agents and for you.

New features,as they land.

Restart recovery and fixes from the 42-repository report

New

Fixed

Improved

Saved refactor runs, clearer background work, and fixes from public reports

New

Fixed

Improved

More dependable agent queries and decision memory, shaped by Magalz's feedback

New

Fixed

Improved

No new customer-facing notes this soak.

1.2.8-nightly.20260925.9e285d5

Fixed

A re-thought engine for every language, a code graph you can actually read, and sharper tools for your agents

Improved

Fixed

1.2.8-nightly.20260924.a5b8db1

New

Improved

Fixed

1.2.8-nightly.20260924.03ca906

Fixed

A re-thought engine, across every language we support

New

Improved

Changed

Fixed

No new customer-facing notes this soak.

A refused start leaves your daemon running

Fixed

The graph comes back, and your agents stop colliding

Fixed

1.2.7-nightly.20260921.f203f99

Fixed

Improved

1.2.7-nightly.20260918.2a7b2c3

Fixed

1.2.7-nightly.20260918.6121f8f

Fixed

Improved

1.2.7-nightly.20260917.02fa2d7

Fixed

The graph stops going blank

Fixed

Improved

Deleted code leaves the graph, and pulls no longer stall

Improved

1.2.6-nightly.20260916.9976905

Fixed

1.2.6-nightly.20260916.6f8d45d

Fixed

1.2.6-nightly.20260916.1676171

Fixed

Pulling no longer leaves Memtrace stuck

Fixed

1.2.6-nightly.20260916.0d11d8d

Improved

Fixed

Memtrace keeps up with what you pulled

Fixed

Decision recall finds your decisions again

Fixed

No new customer-facing notes this soak.

No new customer-facing notes this soak.

1.2.4-nightly.20260915.72202ed

Fixed

Improved

1.2.4-nightly.20260914.1fd7d7e

Fixed

Changed

1.2.4-nightly.20260914.309c70d

Fixed

Changed

Saving a file stops re-indexing the whole file

Fixed

1.2.4-nightly.20260914.7d4d26a

Fixed

New features,
as they land.