What's new

Threadnote 4.2.5 makes vector-enabled code graph builds faster on multicore CPUs while keeping GPU workloads and
interactive semantic queries conservative by default.

Faster CPU graph embeddings

• Code graph vector materialization now shares one loaded model across up to eight independent embedding contexts and
  divides the complete detected math-core thread budget between them. Smaller CPUs automatically select the largest
  supported pool that fits.
• On the governed eight-math-core, 10,000-symbol benchmark, the upper-median cold index time fell from 61.84 seconds to
  42.40 seconds, and the vector stage fell from 50.72 seconds to 30.99 seconds. Eight contexts won all four paired
  rounds with a 1.49× upper-median paired-run speedup; ordered symbol-to-vector digests stayed identical, and upper-median
  sampled embedding process-tree RSS increased by about 6%.
• Vector ordering, incremental-versus-fresh-rebuild parity, and the previous active mapping remain protected when a build
  fails or is interrupted; a retry can safely rebuild the pooled session.

Conservative accelerator and query behavior

• Models with GPU layers, or an unknown offload state, continue to use one embedding context. Recall and semantic code
  graph queries also remain serial by default, so the graph-build optimization does not add unmeasured cold-query or
  accelerator contention.
• THREADNOTE_EMBEDDING_CONTEXTS=1, 2, 4, or 8 remains a process-wide override. Prefix only the graph command to
  scope a low-memory rollback to that build:

THREADNOTE_EMBEDDING_CONTEXTS=1 threadnote graph index

Existing standalone installations upgrade with:

threadnote update

What's Changed

• ci(telemetry): automate gateway and dashboard delivery by @Kashkovsky in #160
• ci(telemetry): provision Grafana dashboard safely by @Kashkovsky in #161
• Fix Grafana dashboard permission audit by @Kashkovsky in #163
• Fix Grafana v42 dashboard normalization by @Kashkovsky in #164
• Prepare Threadnote 4.2.5 with parallel graph embeddings by @Kashkovsky in #162

Full Changelog: v4.2.4...v4.2.5

What's new

Threadnote 4.2.4 keeps ordinary file-local TypeScript edits incremental and adds privacy-bounded diagnostics for
detecting unexpectedly expensive code-graph rebuilds.

Incremental graph updates for local declarations

• Adding, removing, or renaming an unexported path-local TypeScript declaration—such as a private class method or a
  local test callback—now rewrites only the changed files instead of replaying the full cached graph.
• Published resolution changes remain fail-closed. New exports may use the existing bounded declared-project closure;
  oversized or ambiguous projects still select a safe full materialization.
• Persisted activation uses the same published-surface check, and explicit global lookups, reexports, export changes,
  malformed facts, and deletion-only changed-file activations retain their conservative behavior.

Inefficient-rematerialization diagnostics

• Optional anonymous telemetry can emit one terminal, path-free observation for each successful graph build, with
  clean/dirty build kind; closed materialization, fallback, resolution-closure, and efficiency classes; and coarse
  file-count, fact-byte, and amplification buckets. Failed graph builds add only bounded outcome/type to that lifecycle
  surface and interruptions only outcome/duration; neither adds graph classifications or buckets.
• The operated dashboard shows unexpected-full percentage, fallback reasons, rewrite and cached-fact replay
  distributions, and recent inefficient materializations without repository, path, commit, session, or invocation
  identifiers.
• This is a material expansion of the optional telemetry contract. Existing telemetry consent fails closed after the
  upgrade; review the current preview and opt in again only if you agree:

threadnote telemetry status
threadnote telemetry enable
threadnote telemetry enable --apply

The production telemetry gateway must be upgraded and its v1/v2 storage canaries must pass before publishing the
4.2.4 application binaries.

Existing standalone installations upgrade with:

threadnote update

What's Changed

• fix(code-graph): preserve local overlays and diagnose rebuilds by @Kashkovsky in #159

Full Changelog: v4.2.3...v4.2.4

What's new

Threadnote 4.2.3 makes semantic recall work offline and across Unicode languages, adds optional privacy-bounded
diagnostics for CLI and MCP problems, and introduces graceful automatic updates. It also makes graph activity easier to
manage and clarifies the one-user Cursor Cloud setup.

Optional anonymous diagnostics for CLI and MCP

• Anonymous operational telemetry is disabled by default and starts only after an explicit preview and applied consent.
  It covers fixed CLI and MCP operations, duration, graph and recall phases, typed failures, timeouts, parser
  degradation, and bucketed process-memory signals.
• A random agent-session identifier correlates activity within one MCP broker lifetime without creating a persistent
  installation or user identifier. Command arguments, paths, repositories, queries, results, memory content, logs,
  exception messages, and stack traces are never included.
• The first-party endpoint validates a strict versioned OTLP schema before storing traces. DO_NOT_TRACK=1 and
  THREADNOTE_TELEMETRY=0 remain immediate process-level kill switches.

Review the exact data contract before opting in:

threadnote telemetry status
threadnote telemetry enable
threadnote telemetry enable --apply

Disable it at any time with threadnote telemetry disable --apply.

Offline and multilingual semantic recall

• The pinned BGE Small core embedding model is now bundled in every standalone executable. Fresh install and repair can
  provision the default semantic-recall model without a second network download, while verified existing models are
  preserved.
• Lexical and vector recall now retain scrubbed Unicode natural-language memory text instead of reducing it to
  ASCII-only identifiers. NFC normalization and common apostrophe and dash variants improve equivalent-query matching,
  including Ukrainian and other non-Latin text.
• Existing derived lexical and vector indexes rebuild automatically under the new format; canonical memories are not
  rewritten.

Graceful automatic updates

• threadnote update --auto on enables coordinated background updates; --auto off returns to notifications only.
• threadnote update --status reports the effective policy, an active attempt, and the latest success or failure. Add
  --json for the versioned machine-readable form.
• Session-start hooks and the long-lived MCP broker share one install-scoped coordinator with duplicate suppression,
  retry backoff, stale-run recovery, safe side-by-side activation, and next-request MCP runtime promotion. No updater
  daemon is added.

Clearer graph and Cursor Cloud operation

• Manager separates the interactive graph explorer from graph status and administration. Build cards stay in stable
  order, the canvas remains usable during concurrent indexing, and administration starts expanded with an explicit
  disclosure control.
• The Cursor Cloud beta guide now separates personal MCP registration from VM provisioning and documents personal saved
  environments, idempotent Build installation, Git-share bootstrap, and in-VM verification without changing a team
  environment. Managed remote memory remains a deployment foundation rather than a hosted end-user service.

Existing standalone installations upgrade with:

threadnote update

What's Changed

• fix(manager): separate graph status from explorer by @Kashkovsky in #146
• Bundle the core embedding model in standalone executables by @Kashkovsky in #147
• feat: add graceful automatic updates by @Kashkovsky in #148
• Add managed Cursor Cloud remote memory by @Kashkovsky in #145
• feat: add optional anonymous telemetry by @Kashkovsky in #149
• Fix telemetry storage canary polling by @Kashkovsky in #152
• fix(recall): preserve Unicode text across lexical and vector recall by @Kashkovsky in #151
• Clarify personal Cursor Cloud environment setup by @Kashkovsky in #153

Full Changelog: v4.2.2...v4.2.3

What's new

Threadnote 4.2.2 keeps native code graphs available while work moves across linked worktrees and reduces unnecessary
whole-repository graph rebuilds after ordinary source-file changes. It also keeps existing MCP transports connected
when a standalone update or exact-HEAD development install activates a new runtime.

MCP sessions survive runtime promotion

• MCP launchers now keep a small stable session broker on editor-owned stdio and promote the versioned Threadnote MCP
  runtime behind it at a request boundary.
• Requests already admitted to the previous runtime finish there. Threadnote never automatically replays a tool call
  whose outcome could be unknown.
• threadnote update and exact-HEAD development installs use the same active-release promotion contract. Sessions
  started before this release still need one host restart to enter the brokered architecture.

Ready graphs across active worktrees

• A newly created linked worktree can attach an existing clean snapshot immediately instead of waiting for another cold
  graph build.
• After a source edit, graph queries continue to return usable current or stale evidence while the refreshed snapshot
  converges, across TypeScript, Python, and Rust repositories.
• Two worktrees from the same repository can build at the same time without sharing dirty state or blocking one another.

Smaller refreshes for project-scoped changes

• Adding, deleting, or renaming a source file inside a complete declared project graph now refreshes only the affected
  project and its reverse dependencies when that closure is safe and bounded.
• The same bounded behavior applies to uncommitted edits and committed changes.
• Ambiguous ownership, incomplete project metadata, global resolution changes, and other uncertain cases still fall back
  to full materialization.

To require evidence from the latest graph after an edit, run:

threadnote graph query --cwd /path/to/worktree --freshness current --query YourSymbol

Existing standalone installations upgrade with:

threadnote update

What's Changed

• release: Threadnote 4.2.2 graph readiness by @Kashkovsky in #143
• Fix seamless MCP runtime promotion for 4.2.2 by @Kashkovsky in #144

Full Changelog: v4.2.1...v4.2.2

What's new

Threadnote 4.2.1 makes native code-graph upgrades recognize source files newly supported by a language pack instead of
continuing to serve an older clean snapshot.

Refresh graphs when language support changes

• Existing graphs now become stale when their recorded language-pack contract differs from the installed Threadnote
  runtime. The next current graph query refreshes the snapshot automatically.
• Aspect AXL (.axl) sources are included after upgrading, even when the repository was already indexed before AXL
  support was added. They appear as Starlark modules, declarations, imports, and relationships.
• Clean snapshots, dirty overlays, incremental builds, and shared snapshot attachments all retain the language-pack
  provenance needed for future upgrade checks.

To refresh a repository immediately after updating, run:

threadnote graph query --cwd /path/to/repository --freshness current --query path/to/source.axl

Existing standalone installations upgrade with:

threadnote update

What's Changed

• docs: mark Cursor Cloud beta live in 4.2 by @Kashkovsky in #141
• Fix graph refresh after language-pack upgrades and prepare 4.2.1 by @Kashkovsky in #142

Full Changelog: v4.2.0...v4.2.1

What's new

Threadnote 4.2 brings multi-repository Projects and Worksets into Manager, extends native graph investigation across
prepared repository sets, and makes graph storage and local runtime activity easier to understand and control. It also
introduces an initial Cursor Cloud Agents shared-memory profile and safer stable and preview updates.

Manage Projects and Worksets end to end

• Manager can create, inspect, edit, rename, and delete manifest Projects and Worksets, including an Add your first
  project flow for an empty manifest. Project cards lead with the repository folder and observed branch instead of
  opaque checkout IDs.
• Project writes preserve supported YAML comments and use revision-fenced atomic updates. Git roots are canonicalized,
  duplicate checkout ownership is rejected, and seeding blocks escaping patterns, symbolic-link traversal, and
  path-swap races.
• Renaming a Project updates referencing Worksets in the same transaction. Deleting one leaves dependent member names
  visibly unresolved and never deletes repositories, seeded resources, memories, or graph databases.
• Worksets can prepare a published graph generation, then run bounded queries and continuation, exact paths, reverse
  impact, topology, and Context Briefs with per-repository provenance. Queries never fan out cold builds; run
  threadnote workset prepare <name> when a member needs its first or a fresher ready snapshot.
• Client-injected agent guidance is shorter, graph-first for unfamiliar source, and documents the same published-ready
  Workset contract.

Keep graph storage and runtimes bounded

• Retired repository snapshots and Workset generations are reclaimed with bounded storage admission and physically
  paged cleanup, preventing repeated builds from accumulating retired payloads without bound.
• Manager distinguishes allocated SQLite pages, useful live data, and reusable freelist space. While Manager is
  running, it automatically compacts at most one eligible freelist-heavy database at a time after conservative
  disk-headroom, cooldown, build, and maintenance checks.
• The Processes tab shows a compact, privacy-safe inventory of registered Threadnote runtimes. Graph compaction and
  deep-diagnostics workers appear only while alive, and a confirmed identity-bound icon action can stop a selected
  process without exposing arguments, environment variables, paths, or private registration data. The current Manager
  is protected.
• Graph databases with neither a verified folder nor a ready snapshot are labeled unassociated graph storage, with
  explicit guidance to index from the repository folder or preview and purge obsolete derived data.
• The core embedding model is available from an immutable Threadnote release asset, with resumable transfer, SHA-256
  verification, and atomic promotion when Hugging Face is unavailable.

Update safely across stable and previews

• Stable installations continue to select stable releases only. The beta channel is inclusive: it selects the newest
  immutable stable or prerelease, so an invoked update from beta.2 can discover Threadnote 4.2 without --stable.
  After graduation, ordinary updates infer stable-only selection again; use threadnote update --beta to re-enter
  preview selection.
• threadnote update --force refuses semantic downgrades, preventing stale or incomplete release listings from turning
  a forced reinstall into an older installation. Reinstalling the current version and upgrading remain supported; an
  explicit threadnote update --stable can still move a prerelease to an older stable release.
• Release archive checksum verification, installation locking, and atomic promotion remain in force.

Try the Cursor Cloud Agents profile (beta)

• The initial Cursor Cloud profile adds threadnote cloud cursor config, bootstrap, and verify commands for
  deterministic stdio MCP setup, idempotent writable-share preparation, and runtime verification in an ephemeral
  checkout.
• The profile confines memory reads and durable writes to one designated Git-backed share. Durable writes are scrubbed,
  committed, and pushed; local code-graph inspection remains available for the current checkout while Worksets,
  maintenance, review, and separate publishing tools are disabled.
• Full first-class Cursor Cloud lifecycle automation is still in development. Keep Git credentials outside repository
  files, remote URLs, MCP JSON, and agent instructions, and treat VM-local handoffs as transient.

Upgrade to Threadnote 4.2

Existing standalone installations upgrade with:

threadnote update

An installation already following the beta channel also discovers stable 4.2 automatically because it is newer than
the 4.2 prereleases. For a fresh macOS or Linux installation:

curl -fsSL https://raw.githubusercontent.com/Kashkovsky/threadnote/main/scripts/install.sh | sh

Updates preserve Threadnote data and verified model files.

What's Changed

• Publish prepared release notes from main by @Kashkovsky in #135
• Complete graph phases 0-2 and enforce zero-warning lint by @Kashkovsky in #136
• feat: add Manager project CRUD by @Kashkovsky in #137
• feat: prepare Threadnote 4.2 beta.2 by @Kashkovsky in #138
• Add Cursor Cloud shared memory profile by @Kashkovsky in #139
• release: prepare Threadnote 4.2 stable by @Kashkovsky in #140

Full Changelog: v4.1.1...v4.2.0

What's new

Threadnote 4.2 beta.2 improves preview updates and makes local runtime and graph-storage activity easier to understand
and control.

• The beta channel now follows the newest immutable Threadnote release across both stable and prerelease releases. A
  beta installation can therefore graduate to a newer stable release during an update without --stable, while
  threadnote update --beta explicitly re-enters this inclusive preview channel from a stable installation. After
  graduation, ordinary updates infer the stable channel again; no separate channel preference is persisted.
• threadnote update --force now refuses to install an older release from the installation's current channel. A
  temporarily incomplete GitHub release listing can no longer turn a forced reinstall into an accidental downgrade.
• Forced reinstall of the current version and newer updates remain supported. An explicit threadnote update --stable
  can still move a prerelease installation to an older stable release. Archive checksum verification and atomic
  promotion are unchanged.
• Manager adds a Processes tab with a bounded, privacy-safe inventory of registered Threadnote runtimes. Isolated graph
  compaction and deep-diagnostics workers now appear while they are alive, and an identity-bound icon action can stop
  a selected process without exposing arguments, environment variables, paths, or private registration data. The
  Manager process hosting the page is protected from self-termination.
• Manager now labels graph databases with neither a verified local folder nor a ready snapshot as unassociated graph
  storage and explains whether to index from the repository folder or preview and purge obsolete derived data.

What's Changed

• feat: prepare Threadnote 4.2 beta.2 by @Kashkovsky in #138

Full Changelog: v4.2.0-beta.1...v4.2.0-beta.2

What's new

Threadnote 4.2 beta adds end-to-end Project and Workset management to Manager, cross-repository graph investigation,
and safer automatic reclamation of reusable graph storage.

Manage Projects and Worksets end to end

• Manager can create, inspect, edit, rename, and delete manifest Projects and Worksets. An empty manifest starts with
  an Add your first project flow, and project cards lead with the repository folder and observed branch rather than
  opaque checkout IDs.
• Project saves preserve supported YAML comments and use revision-fenced atomic writes. Observable Git roots are
  canonicalized, duplicate checkout ownership is rejected, and linked-worktree identity is retained.
• Renaming a Project updates referencing Worksets in the same manifest transaction. Deleting one warns about dependent
  Worksets and leaves their member names visibly unresolved; it never deletes repository files, seeded resources,
  memories, or graph databases.
• Project seeding rejects escaping patterns, symbolic-link traversal, and path-swap races before reading content while
  preserving prior resources when a filesystem observation fails.

Investigate prepared systems across repositories

• The Worksets tab provides full definition management, background preparation, published-generation status, bounded
  queries and continuation, exact paths, reverse impact, topology, and Context Briefs with per-repository provenance.
• Workset queries use only the published ready generation and never fan out cold graph builds. Run
  threadnote workset prepare <name> when a member lacks a ready snapshot or fresher repository evidence is required,
  then query it with threadnote graph query --workset <name> --query "<concept>".
• Client-injected agent guidance is shorter and documents the same published-ready Workset contract. The bundled Cursor
  rule is versioned as 1.0.1; Cursor Marketplace publication remains a separate workflow.

Keep graph storage bounded and understandable

• Retired repository snapshots and Workset generations are reclaimed with pre-build backpressure, token-fenced staging,
  bounded storage admission, and physically paged cleanup so repeated builds cannot accumulate retired payloads without
  bound.
• Manager distinguishes allocated SQLite pages, useful live data, and reusable freelist space. While Manager is
  running, it compacts at most one eligible freelist-heavy database at a time using cross-process claims, persisted
  cooldowns, conservative disk-headroom checks, and active-build protection.
• The core embedding model now downloads from an immutable Threadnote GitHub release asset, allowing installation where
  Hugging Face is blocked, while retaining resumable transfer, SHA-256 verification, and atomic promotion.

Upgrade to the beta

Existing installations can opt in with:

threadnote update --beta

For a fresh beta installation:

curl -fsSL https://raw.githubusercontent.com/Kashkovsky/threadnote/main/scripts/install.sh | sh -s -- --beta

After opting in, ordinary updates remain on the beta channel. Use threadnote update --stable to return to stable.
Updates preserve existing Threadnote data and verified model files.

Beta limitations

• A symbolic-link manifest, or Project or Workset YAML using aliases, anchors, or unsupported node shapes, remains
  read-only at the affected editing boundary.
• Creating or editing a Workset does not build graphs. Preparation is explicit, belongs to the current Manager session,
  and is interrupted safely when Manager closes.
• Reads use only published ready generations. Missing or stale members require another Prepare operation.
• Automatic compaction handles qualifying SQLite freelist space only while Manager is running. Structural-fragmentation
  analysis and manual timing remain available through threadnote graph compact --dry-run.

Open Manager with threadnote manage, add or select the Projects that belong to a system, create a Workset, and prepare
its first published generation before running cross-repository operations.

What's Changed

• Publish prepared release notes from main by @Kashkovsky in #135
• Complete graph phases 0-2 and enforce zero-warning lint by @Kashkovsky in #136
• feat: add Manager project CRUD by @Kashkovsky in #137

Full Changelog: v4.1.1...v4.2.0-beta.1

What's new

Threadnote 4.1.1 makes small changes in mixed Nx and Bazel monorepos substantially cheaper and keeps existing graph
results available while a newer checkout snapshot is being prepared.

Faster incremental monorepo updates

• Nx, package-manager, and nested Bazel workspace compatibility is evaluated by semantic project scope instead of one
  repository-wide workspace fingerprint. Local metadata and source edits can reuse unrelated projects while changes
  to ownership or unresolved dependency boundaries continue to fall back safely.
• Exact dirty-to-clean reversions reuse a retained clean snapshot, and interrupted-build cleanup performs only bounded
  foreground work before continuing through normal maintenance.
• Structural-only indexing defers opaque image, audio, and video assets. Structured JSON, YAML, schema, and Apple
  resource extraction now uses deterministic classifier-specific budgets with source-to-storage attribution.
• Redundant symbol indexes are removed, unresolved edge targets no longer occupy the reverse-adjacency index, and
  compaction recommendations include live-page fragmentation as well as SQLite freelist bytes.

Ready graphs remain useful during refresh

• Non-strict query, node, neighbors, and explain operations can serve the latest immutable ready snapshot while
  indexing continues, with explicit stale freshness. Relationship-sensitive path and impact operations remain
  strict-current.
• CLI and Manager progress now report whether materialization is full or incremental and expose the exact bounded
  fallback reason when known. This distinguishes parser-cache reuse from final graph reuse on large repositories.
• Existing 4.1 graph databases migrate the optimized adjacency index atomically before it is queried. An already
  prepared partial index is retained without a repository-scale rebuild, and SQLite schema errors no longer appear as
  misleading filesystem-permission failures.

Bounded upgrades and repeatable scale gates

• Reusable clean snapshots now record per-language-pack cache, derivation, and resolution provenance. A compatible
  extractor rollout re-extracts only files owned by changed packs; pack membership and unresolved resolution-surface
  changes continue to fail closed to a full rebuild.
• Dirty indexing no longer performs a complete committed-tree/workspace observation before the real inventory pass,
  and source-only overlays reuse the manifest-derived workspace from that pass. Exact worktree bytes are still checked
  before and after lock acquisition, including successive edits to an already-dirty file.
• Degraded parser results are now admitted from their persisted cache generation instead of rereading and reparsing the
  same resource-heavy source on every edit. Incremental activation also releases inventory heap pages and bounds both
  main and temporary SQLite pager caches before full-graph validation.
• Refreshes that arrive during a build are serialized and collapse intermediate targets to the newest checkout state.
  The just-completed graph remains a reusable base, preventing a moving HEAD from automatically replaying a full
  materialization.
• A deterministic mixed Nx/Bazel fixture generator pins reviewed Nx, rules_js, and Angular commits. Its release gate
  covers inventory, no-op and one-file indexing, queries, stale reads, recovery, storage growth, cached topology
  analysis, cold-build reduction, and moving-target behavior. On the 10,398-file standalone fixture, two successive
  one-file edits completed in 5.94–7.38 seconds at no more than 498.7 MiB RSS; both reused 10,397 files and staged one.

Use threadnote graph query --freshness allow-stale for an explicitly stale-tolerant CLI read. threadnote graph status shows the ready snapshot, active target, materialization mode, and indexing progress.

What's Changed

• Fix mixed Nx/Bazel dirty graph rebuilds for 4.1.1 by @Kashkovsky in #134

Full Changelog: v4.1.0...v4.1.1

What's new

Threadnote 4.1 is a substantial code-graph reliability and performance release. It keeps existing 4.0.10 graphs
available through upgrades, makes graph storage self-maintaining across worktrees, adds bounded incremental reuse for
large repositories, and gives operators precise repair, removal, retention, and progress controls. It also hardens
shared-memory lifecycle operations and introduces persistent read-only shared teams.

Non-disruptive graph upgrades and recovery

• Ready 4.0.10 graphs remain queryable while additive lease, reconciliation, and retention schema migrations run in
  the background. Supported legacy databases are reported as migrating instead of incompatible.
• Query leases can use the verified legacy read surface during migration. Partial schema publication and interrupted
  extension revisions converge on the next writer open without discarding ready snapshots.
• Doctor, repair, graph status, and Manager distinguish usable migration-pending data from corruption, count only
  readable snapshots as ready, and no longer recommend destructive recovery for an additive upgrade.
• threadnote graph repair now targets the current repository by default. Use --cwd or --checkout-id for another
  exact checkout, or --all for home-wide maintenance. A targeted repair does not block unrelated graph indexing.
• Deep repair runs SQLite integrity diagnostics in a killable child process. SIGTERM now stops promptly and releases
  maintenance, checkout, worktree, and database-writer locks.
• Unreadable or transiently unavailable graph stores are preserved. Destructive recovery is limited to data proven
  disposable after a deep check, while failed refreshes keep the prior ready graph usable.

Automatic lifecycle, retention, and storage control

• Graph views carry durable checkout and worktree provenance with verified, missing, stale, invalid, or legacy-unknown
  state. Mutable paths do not become part of snapshot identity, and public/MCP errors remain path-free.
• Active views are separate from reusable snapshot caches. Removing a view cannot be undone by a leased historical
  snapshot or an older writer, while a verified current promotion can recreate it intentionally.
• Exact view removal is available from the CLI and Manager. Missing-worktree mappings are reconciled only from
  authority-proven local state, so temporarily offline or merely unreadable worktrees are preserved.
• Snapshot retention bounds detached clean and dirty generations, retires abandoned and superseded builds, protects
  live leases and reusable bases, and reclaims unreferenced parser facts and vector data in bounded batches.
• Reviewed purge and compaction previews report their exact target and reclaimable storage. Selected snapshot/view
  retirement is available without purging an entire repository.
• Routine maintenance and safe automatic recovery run alongside ordinary graph use. Active writers, queued targets,
  attach operations, and reusable clean generations remain protected by typed lock and ownership contracts.
• Cross-process disk reservations and native capacity probes prevent concurrent builds from overcommitting storage.
  Admission, temporary SQLite growth, WAL reuse, vector staging, and cleanup all use bounded capacity accounting.
• Storage diagnostics attribute bytes to tables, indexes, snapshots, caches, vectors, WAL/SHM files, and obsolete
  stores. Cleanup decisions remain conservative when filesystem or database evidence is incomplete.

Faster incremental graphs and large-repository analysis

• Clean commits can reuse the nearest compatible persisted graph. Dirty worktrees rebuild a conservative Nx,
  TypeScript, and workspace reverse-dependent closure while preserving full-rebuild query parity.
• Interrupted materialization resumes from durable checkpoints. Stale completed commits remain queryable while the
  latest target is queued, and isolated builders publish their exact result without a completion race.
• Compressed, identity-validated parser fact envelopes reduce repeated extraction and write amplification. Corrupt or
  mismatched cached shards become bounded misses and self-heal through an ordinary rebuild.
• Inventory policy excludes oversized or low-signal generated data before extraction, shares source-line indexes, and
  bounds parser lanes, cache capacity, resolution passes, and materialization work under contention.
• Nx, pnpm, Bazel, and TypeScript workspace components retain stable identities, declared dependencies, source roots,
  diagnostics, and precomputed cross-component aggregates for architecture analysis.
• Android XML and Apple plist, storyboard, XIB, and asset-catalog identifiers participate in graph search. Corpus and
  schema extractors use bounded structural policies for documentation and data files.
• Package-scoped graph queries report honest local absence hints. graph query --workset returns bounded results with
  repository and snapshot provenance instead of implicitly building cold repositories.
• Watcher, progress, and build-status telemetry are path-free and bounded. Phase metrics, queue state, ownership,
  materialization mode, storage high-water marks, and estimated current-phase progress are available to CLI, MCP, and
  Manager consumers.

Manager and MCP experience

• Manager streams graph indexing and maintenance state while work is active, keeps graph reads responsive during
  builds, validates cached view leases, and refreshes view counts immediately after removal.
• Graph administration uses one inline remove action, omits duplicate folder text, bounds historical job output, and
  gives the query workspace full width on desktop and mobile layouts.
• Manager binds only to loopback, and its catalog revision contract prevents stale responses from restoring removed
  views or overwriting newer graph state.
• MCP recall and graph operations preserve cancellation, stream bounded progress, cap semantic candidate selection,
  and avoid unbounded payload hydration.
• MCP exposes bounded Threadnote resources for discoverable local context while keeping production diagnostics and
  graph failures path-free.

Shared memory and local data safety

• Share rename and unpublish are retry-safe around their Git commit points. A post-commit warning no longer reports an
  already-applied rename as failed, and unpublish dry-run uses the same destination-collision preflight as apply.
• Persistent read-only teams can fetch, rebase, ingest, recall, report status, and install artifacts without publishing
  or pushing. Configure them with share init --read-only or share set-access --mode read-only.
• Read-only sync refuses dirty worktrees and local commits ahead of upstream instead of auto-committing them. Memory,
  artifact, pack, unpublish, and local/merged conflict publication fail before mutation; --take shared remains
  available for remote-authoritative conflict resolution.
• Recursive shared-subtree forget now removes only the selected subtree, preserves siblings, and reports resource-lock
  and filesystem failures through the native store contract. Collection roots remain protected from accidental
  deletion.

CLI, runtime, and release engineering

• Compatibility aliases preserve established CLI spellings while the exact installed command help remains
  authoritative.
• Bun/Effect platform adapters now own filesystem, command, process, disk-capacity, and runtime boundaries without
  production Node built-in imports. Process identity probes are bounded and superseded development runtimes can be
  terminated safely after exact-HEAD installation.
• The native code-graph store was split into focused modules with narrow schema, lifecycle, query, staging,
  reconciliation, retention, vector, and visualization responsibilities.
• Intel macOS uses a bounded capacity fallback verified on the release runner. macOS arm64/x64 and Linux arm64/x64
  remain the published standalone targets, with Windows and musl builds retained as compile gates.
• Release builds reuse a checksum-verified embedding model artifact, require exact v4 tag provenance and immutable
  GitHub releases, and retain bounded production-large and heavy-tail evidence without presenting it as a portable
  latency SLA.
• The CI plan now isolates stateful, parser-heavy, property, lifecycle, and OS-contention suites within the hosted
  runner quota, while keeping standard tests, cross-platform compilation, installed-release E2E, recall quality, and
  self-contained payload checks mandatory for release source.

What's Changed

• chore(deps-dev): bump prettier from 3.9.5 to 3.9.6 by @dependabot[bot] in #118
• Harden Threadnote 4.0.10 dogfood reliability and cleanup by @Kashkovsky in #130
• chore(deps-dev): bump oxlint from 1.76.0 to 1.77.0 by @dependabot[bot] in #121
• Harden 4.0.10 code graph build lifecycle by @Kashkovsky in #131
• Stabilize 4.1.0 beta release evidence and macOS Intel capacity probes by @Kashkovsky in #132
• Prepare Threadnote 4.1.0 beta.2 release by @Kashkovsky in #133

Full Changelog: v4.0.10...v4.1.0