scip-query 0.19.1 → 0.19.3

package/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to `scip-query` are documented here. This file starts at 0.1
 
 ## [Unreleased]
 
+## [0.19.3]
+
+### Performance and operations
+
+- Watchers now suppress a queued cooldown reindex when the completed index's
+  fingerprint proves the queued file events are already represented. Stale or
+  unavailable freshness still preserves the follow-up refresh.
+- A bounded two-segment activity ledger powers rolling 24-hour watch status
+  counts for rebuilt, reused, failed, and suppressed refreshes plus estimated
+  logical artifact bytes. The estimate is explicitly not physical SSD writes.
+- Source watching retries with 500 ms polling only when the host refuses an
+  event-backed subscription with `EMFILE`, preserving refresh correctness
+  without adding polling I/O to the normal path.
+
+## [0.19.2]
+
+### Fixes
+
+- Watch-service reuse no longer reports a startup warning when a sandboxed
+  client cannot update the optional activity timestamp in the user cache.
+- Reindexing now removes abandoned staging workspaces under the exclusive
+  reindex lock. Affected-set history stores compact calibration summaries and
+  rotates at 8 MiB with one previous segment instead of appending unbounded
+  full records; the complete latest status record is unchanged.
+
 ## [0.19.0]
 
 ### Architecture coherence

package/README.md

@@ -461,7 +461,13 @@ child writes only to that worktree's writable `index.scip` and `index.db`. A
 cross-platform source watcher maintains the directory subscriptions needed to
 detect ordinary unstaged edits even when Node does not provide recursive
 filesystem events, while separate Git polling detects commit and staging-state
-changes. A
+changes. File events that arrive during a reindex still mark the watcher dirty,
+but the queued rerun is suppressed when the completed index's source
+fingerprint proves those events are already represented; a stale or unreadable
+fingerprint always preserves the rerun. If the host refuses an event-backed
+subscription because its open-file allowance is exhausted, that project
+retries with 500 ms file polling; ordinary event-backed watchers do not pay
+that polling cost. A
 shared generation is only a warm starting snapshot; it never implies a shared
 watcher or shared later writes. A daemon that exits after its configured idle
 timeout starts warm again when that worktree is next used.
@@ -495,6 +501,11 @@ and any conservative fallback reason. `scip-query status` shows a compact
 summary and telemetry path; `status --json` exposes the structured
 `affectedSetShadow` object. Shadow results are observational in this phase and
 never decide which indexer runs or which generation publishes.
+Historical shadow rows are compact calibration summaries. They rotate at
+8 MiB and retain one previous segment, bounding history near 16 MiB per
+project; the complete latest record remains available for status diagnostics.
+After acquiring a project's exclusive reindex lock, each reindex also removes
+staging directories abandoned by interrupted earlier reindexes.
 
 TypeScript monorepos can opt into project sharding with `indexer.typescript.projectMode: "workspace"`. In that mode, `scip-query` discovers repo-local TypeScript project roots, runs one `scip-typescript` process per project with bounded concurrency, merges the shard protobufs, and still publishes one TypeScript language index. Set `indexer.typescript.projects` to an explicit list of project directories or tsconfig paths when automatic discovery is too broad. When `projects` is set to a non-empty list, it is authoritative: only the listed projects are indexed, automatic discovery does not run, and the repo root is not re-added alongside them (even if the root tsconfig covers subdirectories) — files that are only covered by an excluded root tsconfig (e.g. shared ambient `.d.ts` files) drop out of the index, so pick the list deliberately. An empty or absent `projects` falls back to full discovery, unchanged. Workspace mode also caches each project shard: reindexing after an edit reruns only the changed projects and their dependents (workspace `package.json` dependencies and tsconfig `paths`/`references` targets count as dependencies), serves untouched projects from `language-indexes/typescript-projects/`, and reports every reuse decision in `reindex --json` shard diagnostics. Set `indexerConcurrency` when a repo needs a persistent worker cap; CLI `--indexer-concurrency` and `SCIP_QUERY_INDEXER_CONCURRENCY` still override ad hoc runs.
 Use `indexer.typescript.pnpmWorkspaces` only with the default single-project mode; workspace mode passes explicit projects instead.
@@ -567,6 +578,11 @@ the first command that needs ts-morph semantics. Separate CLI processes reuse
 that session through a repository-local atomic mailbox; source-only index
 generations refresh the existing Projects, while configuration or uncertain
 changes replace them. `watch --status` reports Project/session/request counts.
+It also reports a rolling 24-hour reindex activity summary: rebuilt, reused,
+failed, and freshness-proven suppressed refreshes plus estimated logical output
+bytes. The estimate counts scip-query artifacts emitted by rebuilt refreshes;
+it is not a measurement of physical SSD writes. The underlying
+`reindex-activity.jsonl` history uses two bounded 1 MiB segments.
 If the service is stopped, incompatible, busy beyond its bound, or returns an
 invalid response, the command falls back to the existing in-process ts-morph
 provider.