The community train: 54 contributor PRs absorbed. Wave K triaged all 141
open PRs against the live codebase, verified each fix still real at HEAD, and
absorbed the 54 that complement the v0.46.28.0 megawave — one commit per PR,
contributor authorship preserved via Co-authored-by trailers, fixups applied
where master had drifted. 32 community authors credited. This entry lists what
lands NET-NEW on top of v0.46.29.0–v0.46.31.0: #3617, #4400, #4411, #4414,
#4425, #4453 and issues #3729/#4416/#2036 also shipped independently in
v0.46.29.0 — this wave's implementations of those were reconciled at merge and
are not re-credited here.

Credits

Absorbed with thanks from: @Masashi-Ono0611 (13 incl. #4459 whose
implementation was superseded mid-flight by the megawave's #3885 fix — its
e2e tests ship here), @avs-io (5), @calebhicks (4), @frxiaobei,
@alexey-metaengage, @harjothkhara (2 each), and 26 more contributors — full
per-PR attribution in the release PR body and each commit's trailers.

Added

• Semantic takes retrieval: gbrain takes embed populates take embeddings and
  think gains a vector retrieval arm alongside keyword takes search (#3776).
  Migration v142 resizes takes.embedding to the configured embedding
  dimension; any pre-existing take vectors (including manually embedded ones)
  are cleared by design and repopulate on the next gbrain takes embed.

gbrain smoke-test no longer starts a surprise shell-enabled worker. The
worker check now asks the native supervisor status surface, which understands
brain-scoped PID files and the queue's live database lock. A healthy managed
worker therefore passes without creating a second unmanaged process.

Changed

• INTENTIONAL CONTRACT CHANGE: worker repair is no longer auto-fixed. A
  missing worker now produces an explicit
  gbrain jobs supervisor start --detach repair hint instead of silently
  launching jobs work with shell jobs enabled, and the smoke test exits 1
  when nothing manages workers.

Fixed

• gbrain takes --help and gbrain auth --help print full subcommand usage
  without an engine (#3780, #4083); think --take records a take end-to-end
  instead of silently no-oping (#4469, fixes #2556).

• Bun 1.3.10 warm-transpiler-cache poisoning of test/doctor.test.ts (59-test
  cascade on any warm re-run): sync require() sites converted to
  await import. (The search cache key is unchanged in this release — this
  wave's keyword-fallback fold was already covered by v0.46.29.0's re-key.)

• Page ingest no longer aborts an entire document (or batch run) when the body
  or a chunk contains a raw NUL byte or lone UTF-16 surrogate: pages body
  columns and chunk_text are sanitized at write time in both engines, the same
  policy as links/timeline/takes free-text. (#3998)

• A live supervisor plus a legacy worker PID is reported as a duplicate
  topology that requires operator review.

• Smoke-test worker detection is hermetically covered without touching live
  processes or global PID files.

• Doctor health-score extraction uses POSIX sed instead of GNU-only
  grep -P, eliminating the macOS warning and ?/100 fallback.

• Page-retrieval metrics can no longer exceed their mathematical bounds when
  search returns multiple chunks from one page: Precision@k, Recall@k, MRR,
  nDCG@k, NamedThingBench, and the qrels correctness gate now share one
  unique-page ranking primitive that keeps only the first/best occurrence of
  each ranked page before any cutoff. Duplicate non-relevant chunks no longer
  consume page-level ranks, and qrels ground-truth duplicates count as one
  relevant page. Historical baselines that included duplicate page hits may
  decrease and should be reviewed before changing quality thresholds. (#4184)

To take advantage of v0.46.32.0

gbrain upgrade
gbrain apply-migrations --yes   # v142 resizes takes.embedding to your configured dimension
gbrain takes embed              # repopulate take vectors (v142 clears them by design)
gbrain doctor                   # verify

Privacy hardening pass: the read-side privacy boundary is now guarded by a
registry-driven sweep, so the whole class of "a new remote surface forgets
the world-only filter" fails the build instead of shipping.

Added

• Remote privacy sweep (test/remote-privacy-sweep.test.ts): every
  remote-callable operation — including ones added in the future — is
  dispatched against a seeded private corpus in both the single-source and
  federated caller shapes, and the full response envelope (structured
  fields, rendered text, error messages, and the hot-memory _meta
  channel) is asserted free of private content. Fail-closed by design: a
  new operation breaks the suite until it is classified, local-only
  operations must be denied over non-local transports, and publish-gated
  operations must deny with their gate named. Companion curated probes
  landed in the trust-boundary suite (its static sibling).

Fixed

• Several list-style read operations now honor page visibility for remote
  callers the same way page reads and ambient-recall deltas already do
  (same fix family as the v0.46.29.0 privacy work; found by the new sweep
  on its first runs). Published aggregate counts and derived statistics
  are adjusted with the filtered rows — and re-sorted — so remote
  responses stay self-consistent and reveal nothing about what was
  filtered; soft-deleted pages and mid-read deletions are handled
  fail-closed. Trusted local callers are unaffected.
• find_anomalies no longer clamps large-cohort counts to the display cap
  of its page list when filtering, and find_orphans' totals stay
  coherent for the thin-client doctor's orphan-ratio check.

To take advantage of v0.46.30.0

gbrain upgrade        # no migration needed — handler + test changes only
gbrain doctor         # confirms the upgrade; remote surfaces re-verified

Remote MCP callers may see slightly fewer rows from list operations on
brains with private pages — that is the fix working, not data loss; local
CLI reads are unchanged.

The community wave: 38 contributor PRs landed (37 authors credited below) plus
49 more verified issue fixes — everything filed or rebased since the megawave,
re-trialed against it, and integrated with the same reproduce-first discipline.

Privacy & data integrity

• Remote write-backs can no longer drop invisible fence rows. A remote
  caller that reads a page (seeing only world-visible facts), edits prose, and
  writes back now gets a row-level visibility-aware merge: rows it couldn't
  see are restored at their stable row numbers; its own edits and deletions of
  visible rows are honored exactly. Covers timeline-embedded fences too, and
  forgotten/struck claims round-trip without resurrection (#4548 #4554 #4546,
  extending community warn-work from #4553/#4555/#4547 — thank you).
• Ambient-recall deltas honor page visibility for remote callers (#4549 via
  community PR #4550); timeline fences are stripped from remote page reads
  (#4546 via #4547).
• Per-call salience/recency modes and intent-pattern config now fold into the
  query-cache key (knobs v=26; also folds the keyword-fallback knob and closes
  a negative-offset cache gap from community PRs #3617/#4414) — one-time
  cache re-warm on upgrade.
• WSL transcript-path translation confines strictly to the known Claude config
  tree (#4522), and hook transcripts translate Windows drive paths at all.

Community wave (38 PRs, landed with credit)

Highlights: doctor schema-column drift detection (#4425) and wedged-queue
worker-liveness split (#4400); sync working-tree drift visibility with
--working-tree (#3974); parallel source-resolution for large repos (#4411);
PGLite embed-backfill admission gate with typed drain outcomes (#4512);
openrouter Anthropic-route subagent loops (#4514, also fixing the replay
matrix); UTF-16-safe truncation in extract paths (#4529); CJK cross-modal
recall (#4538); bench metric correctness (#4453); a new opt-in third-party
reranker recipe (nan.builders, #4491 — off unless you configure a key); plus
25 more fixes across doctor, search, sync, schema, gateway, and CLI surfaces.

Verified issue fixes (49)

• Cycle: extractor input/output/pacing config caps (#4540), drain errors
  surfaced (#4539), atoms truncation UTF-16-safe (#4528 with #4529).
• Sync/import: YAML-error files named with a validate hint (#4543), leading
  blank line before frontmatter tolerated (#4526), break-lock resolves the
  ambient source chain (#4412 — the under-serve e2e defect), image imports
  incremental (#4521).
• Doctor: orphans definition unified with health's islanded semantics
  (#4524, mode:'inbound' for the legacy view), upgrade-error warns
  auto-resolve when provably superseded but fail closed otherwise (#4517),
  schema ledger can't mask missing columns (#4421 with #4425).
• MCP/ops: OAuth refresh maps to invalid_grant instead of 500 (#4532),
  remote put_page documents unreconciled wikilinks (#4525), migrate-engine
  preserves timestamps and reports real removal counts (#4527).
• CLI: --explain reaches extract/whoknows/onboard instead of being
  swallowed globally (#4541), zero-meeting extractions warn instead of
  silently succeeding (#4542).
• Plus 30 more across think, dream, takes, transcripts, jobs, search,
  schema-packs, embedding limits (#4530), and test infrastructure.

To take advantage of v0.46.29.0

gbrain upgrade
gbrain migrate        # v141 (extract-rollup expected-limit config)
gbrain doctor         # new drift + liveness checks run automatically

First queries re-warm the semantic cache (knobs v=26). Code chunks re-chunk
once on upgrade (CHUNKER_VERSION 6) for decorated-def support.

The megawave: 111 verified issues fixed in one release — every remaining
fixable item from the full-backlog triage, implemented reproduce-first with
failing-first tests and two-lens adversarial review per area. Fully
reconciled with v0.46.26.0–27.0 (the daemon env file supersedes interim key
channels; both rc files now source independently on top of it).

Security & visibility

• Private-page visibility (visibility: private frontmatter) is now enforced
  uniformly across every remote read surface — search arms, page reads, link
  and graph traversal, chunk/version/timeline/raw reads, and slug resolution —
  with one shared predicate so engines and ops can't drift. Private pages read
  exactly like missing ones to untrusted callers (no existence oracle). Trusted
  local CLI use is unchanged; operators keep a config opt-out
  (search.remote_private_pages) and an incident escape hatch
  (GBRAIN_REMOTE_PRIVATE_PAGES=1), documented in the MCP surface runbook.
• Query caching stays fully effective for remote callers: the visibility
  posture folds into the cache key (knobs_hash v=23) instead of skipping the
  cache — one-time cold-miss on upgrade, cross-posture contamination is
  structurally impossible (pinned at hash, cache-store, and hybrid levels).
• Untrusted frontmatter can no longer point conversation ingestion at
  arbitrary host files (absolute-path traversal guard, fail-closed).
• Trust-gate hardening: tombstone payloads and code-graph readiness rechecks
  now fail closed on unset trust.

Retrieval

• CJK queries recover keyword matches on both engines (bigram fallback parity,
  #3986); relational-arm results carry evidence stamps and monotone scores.
• CRAG-style escalation seam (config-gated, default off, experimental) — a
  degraded search can escalate to a deeper re-run (#1663).
• Degradation visibility: searches that fall back now say so in _meta
  (#3873 note: model-tier config now takes precedence over models.default —
  set your tier explicitly if you relied on the old order).
• Multi-type filters, snippet caps, and deep-research ids thread through every
  search leg uniformly (#3985 #3800).

Sync, ingestion & timeline

• Legacy timeline rows are repaired one-time by migration (content-anchored,
  idempotent) so re-extraction dedups instead of duplicating (#3957); the
  dedup index re-keys on md5(summary) so long summaries can't abort timeline
  writes (#3737).
• sync --dry-run is pure again (no config writes, #4342); image files import
  incrementally (#2683); FS-walk stamps snapshot page state before reading so
  concurrent edits stay stale-visible (#3875).
• Entity identity groups (manual cross-source linking, v1) respect source
  scope in both directions (#4224).

Jobs, cycle & operations

• Durable per-call chat usage ledger (chat_usage_log, read via get_usage,
  now admin-scoped) with canonical-table cost estimates (#4218).
• Probe-liveness wedge in the LLM halt/cooldown path unlatched — a deferred
  probe can no longer freeze a worker queue until restart; strikes escalate
  per halted probe, not per concurrent failure.
• Cycle stale-drain is time-budgeted; lock refreshers feature-detect signal
  shapes; PID-1 zombie reaping under container/daemon use (#2443 #2308).
• Embed retry/backoff cluster peeled into core (core/embed-retry.ts) fixing
  a core→commands layering hazard; Voyage/OpenAI embedding prices re-verified.

Release-gate hardening (caught by this release's own gate battery)

• Schema-pack regex inference no longer uses a node:vm watchdog — it could
  wedge the event loop in embedded-engine processes (silent hangs during
  large imports); replaced with input caps + a nested-quantifier refusal
  shared with the lint rule (#3190 follow-up).
• Autopilot launchd installs survive repo deletion: the job's working
  directory no longer pins the repo, so the self-disable guard actually runs
  (previously every respawn died before reaching it).

Doctor, CLI & DX

• Doctor: silent-death checks, self-upgrade honesty, dead-check pruning, and
  quieter output on healthy brains (#3944 #3925 #3958).
• CLI: silent-failure surfacing on exit paths, confirm-race gate on
  destructive prompts, Bun.which PATH fix for bootstrap detection (#4325).
• Decorated Python defs chunk correctly for code-def resolution (#3821).
• Note for RTL users: pointed-Hebrew (niqqud) slugs re-key under the
  normalized scheme — existing links self-heal on next sync (#3700).

Historical CHANGELOG corrections

• v0.13.1 entry: corrected the budget figure (#3748).
• v0.46.x entry: gbrain migrate-engine → gbrain migrate --to (#3697).

To take advantage of v0.46.26.0

gbrain upgrade         # or: bun install -g gbrain@latest
gbrain migrate         # runs migrations v137–v140 (identity groups, timeline
                       # dedup re-key + one-time repair, chat usage ledger)
gbrain doctor          # confirms the new checks pass on your brain

First queries after upgrade re-warm the semantic cache (knobs v=23). If you
relied on models.default overriding tier config, re-check gbrain search modes output (#3873 precedence change).

The autopilot daemon can no longer lose your API keys silently. The
failure mode: autopilot --install generated a wrapper that loaded env only
from interactive shell rc files, which daemon supervisors (launchd, systemd,
cron) never run — so the daemon started green while every LLM phase
(chronicle, dream, enrich) quietly produced nothing, for days, with no error
anywhere. This release adopts the env-file fix from PR #4443 (thank you
@Masashi-Ono0611) and hardens the whole lane. Closes #2608.

Added

• The daemon wrapper now sources a gbrain-owned ~/.gbrain/env file (after
  your shell profiles, so it wins on conflicts; honors GBRAIN_HOME).
  autopilot --install creates it as a fully-commented, owner-only (0600)
  template — API keys plus the process-level env only a wrapper can deliver
  (NODE_EXTRA_CA_CERTS, proxy vars, custom base URLs). gbrain never
  overwrites or deletes it; a pre-existing group/world-readable file gets one
  warning and is left untouched.
• Autopilot prints one loud line at boot when no chat provider is available,
  naming both remediation paths and the reload step — the silent no-op is now
  visible in autopilot.log at startup instead of surfacing as "runs green,
  extracts nothing."

Fixed

• autopilot --install now actually reloads a running daemon: launchd
  unloads before loading (a bare launchctl load over a loaded agent also
  errored and aborted every reinstall), systemd restarts an already-active
  unit, and the cron/container paths tell you when a running loop keeps its
  old environment and exactly how to end it.
• Env files with plain KEY=value lines (no export) now reach the daemon —
  the wrapper sources under set -a, matching how dedicated env files are
  usually written.

To take advantage of v0.46.27.0:

• Existing daemon installs: re-run gbrain autopilot --install once. The
  upgrade alone swaps the binary but does not regenerate the wrapper, so the
  env-file sourcing (and the template) only appear after a reinstall — which
  now also reloads the daemon for you on launchd and systemd.
• Then put your keys in ~/.gbrain/env (or keep them in
  ~/.gbrain/config.json); the wrapper sources the env file on every daemon
  start.

Dream fan-out can no longer strand work in queues nobody owns. The
production incident: dead parent runs left thousands of waiting jobs in
private dream-inline-* queues for 16-27 hours, and every dashboard said
"restart the worker" — advice that cannot work, because no shared worker can
claim a private queue. This release adopts the lifecycle repair from
PR #4361 (thank you @garrytan-agents) and hardens every recovery lane the
review found unwired. Closes #4332.

Added

• Private dream queues now carry an explicit owner job, owner token, and
  renewable lease (adopted from #4361). Synthesize and patterns reconcile
  their children on every terminal path — success, throw, timeout, abort,
  cancellation — and startup recovery cancels provably-orphaned queues
  (owner terminal/missing, or lease expired) while never touching live ones.
• Recovery now runs on EVERY lane that can strand a queue: the supervisor's
  pre-spawn hook (adopted), bare gbrain jobs work startup, autopilot's
  worker spawns and crash respawns, and dream-cycle start — the last one
  being the only possible lane on PGLite brains, which previously had no
  recovery surface at all.
• Reconcile cancellations are stamped with a machine-readable reason family
  (private_queue_reconciled: <detail>), mirroring the waiting-TTL prefix,
  so operators and tooling can tell reconciliation from TTL expiry.

Changed

• Lease renewal is monotonic (a renewal can only extend, never shrink) and
  fires from the drain loop's idle polls and fast-failure iterations too —
  a live queue with slow or bouncing children can no longer read as orphaned
  mid-run.
• The maintenance lane (where synthesize/patterns actually run on
  multi-source brains) now threads its job id as the private-queue owner, so
  its queues get the fast owner-terminal recovery path instead of waiting
  out the lease.
• Doctor's orphaned_private_queue check now runs on PGLite too and buckets
  findings through the same classifier recovery uses: metadata-backed
  orphans advertise auto-recovery, legacy unowned queues advertise the
  retriage preview, and owner-pending queues say which owner job to inspect.
  The wedged-queue surfaces (doctor, jobs stats, the get_job_stats op)
  never call a private queue "wedged" and never advertise a worker restart
  for it.
• Doctor's stale-lock hints now name only commands that exist:
  gbrain dream --break-lock was advertised for years but never implemented
  — pasting it ran a full (paid) dream cycle instead of breaking a lock. The
  cycle-lock remediation is gbrain doctor --fix (dead holders on this
  host; also swept at the next dream start), and the circular gbrain doctor fallback hint is gone. The wedged-queue restart hint names the
  wedged queue (supervisor start --queue '<q>') instead of always bouncing
  the default worker.

Fixed

• Doctor's orphaned-queue check is honest about truncation on the healthy
  path too: with more than 100 candidate queues, the never-classified
  remainder is now reported (unclassified_candidates) even when everything
  classified came back live — previously 100 live + 50 unexamined orphans
  read as a clean bill of health. waiting_jobs now counts flagged queues
  only, matching what orphaned_private_queues reports.
• The upgrade bootstrap probes all three private-queue columns (owner id,
  owner token, lease) in both engines — a partially-upgraded brain missing
  only the token column now repairs itself instead of wedging.
• The private-queue lease keepalive is one shared, tested helper
  (MinionQueue.makeThrottledLeaseRenewer) instead of twin inline copies in
  synthesize and patterns; the coverage wave backfills behavioral tests for
  every recovery lane, the renewing wait, the v136 migration replay, doctor's
  hint/bucket surfaces, and token redaction on the jobs MCP ops.

To take advantage of v0.46.26.0:

• gbrain upgrade (or reinstall the binary). No schema action needed beyond
  the automatic migration that adds the owner/lease columns.
• Existing abandoned queues from before this release are legacy-unowned:
  gbrain doctor now tells you exactly which repair applies; use the
  gbrain dream retriage preview for those.

The backlog release: 62 community pull requests merged, ~50 maintainer fixes, and 87 open issues closed in one landing. Every pull request was individually trial-merged and tested before inclusion; every fix started from a reproduced bug and shipped with a failing-first test. The headline classes: embedding backfills can no longer quietly destroy vectors (probe-gated invalidation, honest counts, content-revision staleness, registry-aware writes end to end), sync can no longer delete the wrong page or be repointed by a foreign repo, search caching can no longer serve one source's rows to another or one query's rows to a different query, page timelines survive filesystem rebuilds, large piped CLI output is delivered to the last byte on every path, and the DB config plane is finally read at runtime.

Added

• Ops accept an explicit per-call source_id on get_page/delete_page/restore_page — honored or rejected, never silently ignored. Destructive ops act only within the caller's write authority; federated read grants confer no delete access.
• gbrain migrate-engine now copies the facts table and all config rows (minus engine-local keys, printed when skipped) with a per-table copied-count summary — a migrated brain arrives whole.
• Doctor warns when chat_fallback_chain is set but inert. Contributed by @Masashi-Ono0611.

Changed

• Embedding backfills and stale sweeps are honest end to end: a live embedder probe gates any invalidation, a run that nulls vectors but embeds zero fails loudly, updated pages re-embed on content change (not just signature), and embed_skip pages are never invalidated into a permanent hole.
• The embedding write path, stale selectors, coverage counts, invalidation, and bootstrap verify all resolve the same active embedding column through the registry — multi-column brains no longer see false 0% coverage or phantom stale loops.
• The sole-non-default source shortcut only routes bare writes when the default corpus is empty, and says so on stderr when it declines — no more silent write hijacks.

Fixed

• 23 community fixes, each trial-merged in isolation and tested before landing: C# file-scoped namespace indexing (@gregario), a $HOME bootstrap guard and unknown-flag rejection on config set and subagent-loop capability classification and DB-plane eval.* gating and doctor effective-date re-parsing and inert-fallback-chain warning and latest-model cache invalidation (@Masashi-Ono0611), chat probe token floor (@ethanbeard), models.dream.synthesize honored in concept synthesis (@awilhite), recipe secret-name matching (@rayers), two unregisterable config keys (@JavanC), source-aware backlog drain hints and trigger-only skills dirs (@javieraldape), keyword-arm fail-open in hybrid search (@Jinstronda), wasm-embed check under pipefail and skillpack binary path resolution (@abhiramasonny), conversation-miner facts in verify and thin-client think routing (@mdcruz88), win32 resolve-ipc client gate (@oscampo), stub entity-page types from the active pack (@marmikcfc), image assets by source root and chronicle backfill source ids (@frxiaobei).
• Facts fences and page writes now compute the identical target file, and an unresolvable target routes to a DB-only insert instead of being dropped — closing a fact-wipe class. Co-authored with @harjothkhara.
• A facts-only target brain refuses a destructive engine-migration overwrite instead of losing its memory.

Also landed (the full wave)

• 39 further community PRs beyond the first 23, each trial-merged and tested: contributions by @gregario, @Masashi-Ono0611, @ethanbeard, @awilhite, @rayers, @JavanC, @javieraldape, @Jinstronda, @abhiramasonny, @mdcruz88, @oscampo, @marmikcfc, @frxiaobei, @herove-successor accounts and more — every author is credited on their merged PR. The oldest open PR in the repo (June) landed in this pass.
• The remaining P0s: sync delete-by-approximation (a page with a trailing-hyphen path could delete a DIFFERENT page), cross-host page-lock stealing, and stranded manual timeline entries on filesystem-canonical brains.
• Retrieval correctness: the long-standing ranking inversion, a pre-fusion candidate floor so exact matches at rank >20 are reachable at default limits, per-source cache isolation, and a same-text guard so near-identical embeddings (worst in CJK) can't serve one query's cached rows to a different query.
• Serve hardening: per-request MCP transport teardown (multi-GB RSS growth gone), an opt-in event-loop stall watchdog, SIGTERM/SIGHUP cleanup, and default-deny CORS on the auth endpoints.
• Ops honesty: jobs list/get --json, duplicate timeline entries report skipped instead of lying ok, doctor stops recommending a sunsetting reranker default, and CLI output over 64KiB is delivered to the last byte on every emission path — including console.log-shaped --json handlers.
• Windows: git sync credentials, msys path healing, and resolve-IPC client gating.

To take advantage of v0.46.25.0

gbrain upgrade should do this automatically. If it didn't, or if gbrain doctor warns about a partial migration:

1. Run the orchestrator manually:

   gbrain apply-migrations --yes

2. Migration v133 adds a content-revision stamp to chunks; no manual action needed. Existing embeddings are grandfathered and re-embed only when content actually changes.
3. Verify the outcome:

   gbrain doctor
   gbrain stats

4. If any step fails or the numbers look wrong, please file an issue: https://github.com/garrytan/gbrain/issues with the output of gbrain doctor and ~/.gbrain/upgrade-errors.jsonl if it exists.

gbrain sync now works while your agent's brain is live. On a PGLite
brain, a running gbrain serve (the MCP server your agent harness spawns)
owns the database's single-writer connection, and a sync used to require
stopping the serve — killing your agent's memory to feed it. Sync now
delegates the run to the serve process over its local IPC socket: the lock
owner does the work, the CLI streams progress, and your agent stays up the
whole time.

Added

• Serve-delegated sync: gbrain sync under a live gbrain serve runs inside
  the serve process (secret-gated sync_start/sync_status/sync_abort
  kinds on the existing resolve-IPC socket; never raw SQL). The CLI prints a
  delegation banner with the job id, polls progress (phases, banked-file
  counts), and prints the same result a direct sync would. Ctrl-C aborts to a
  durable checkpoint the next sync resumes from; a second Ctrl-C exits
  without waiting.
• Embeds under delegation are always deferred and drained by the serve's idle
  maintenance sweep afterwards (the serve's environment/API keys apply);
  --no-embed also suppresses the drain. The inline embed cost gate is never
  silently bypassed.
• Bounded by construction: the client always sends its resolved hard deadline
  (interactive default 3600s) so a job whose client died still ends;
  --no-hard-deadline is the only unbounded encoding. A serve shutdown
  mid-sync aborts the job and waits a bounded settle
  (GBRAIN_SERVE_SYNC_SETTLE_MS, default 3000ms) for the checkpoint flush
  before disconnecting.
• Safety posture: unsupported sync flags (--repo, --all, --watch,
  --exclude, --workers, --json, …) refuse BY NAME under delegation
  (default-deny — a silently dropped flag would perform the wrong sync), with
  three remediations in every message. Opt-outs: --no-delegate /
  GBRAIN_SYNC_NO_DELEGATE=1 (client) and GBRAIN_SERVE_SYNC_IPC=0 (serve).
  serve --http exposes no IPC and keeps the stop-the-serve behavior.

Changed

• The LiveServeLockError message now says sync runs through the live serve
  automatically; stopping the serve remains the remedy for OTHER CLI write
  commands.
• docs/architecture/serve-sync-concurrency.md rewritten around delegation
  (limits table, crash/resume notes, unchanged hang-triage recipes).

To take advantage of v0.46.24.0:

• gbrain upgrade (or reinstall the binary), then restart any running
  gbrain serve so it registers the sync IPC kinds — a serve from an older
  version answers with a typed "restart the serve" refusal instead of
  delegating.
• If a serve dies mid-delegated-sync, re-run gbrain sync to resume from the
  checkpoint; a dead-PID sync lock younger than 60s can be cleared with
  gbrain sync --force-break-lock.

A 23-contribution community wave, plus an end to silently lost pages.
If your agent ever "saved" a page and a re-read came back without the change,
or a page you were editing came back blanked, this release closes both halves
of that story: large piped reads no longer lose their tail on process exit,
and the store itself now refuses to overwrite a page's real content with an
empty body. Beyond that, the wave spans dream-pipeline correctness, budget
and pricing coverage, search and link quality, transcript and reindex
resilience, provider error surfacing, and a set of long-tail adoptions from
older PRs — including a new GitHub source kind that puts issues and PRs in
the brain.

Added

• putPage refuses to overwrite a non-empty page body with a blank one.
  A page edit is a read-modify-write; when the read comes back empty for any
  reason, the write used to blank the page silently. It now fails loudly with
  a clear error instead. Genuinely new empty pages still save, file-sourced
  syncs of a deliberately emptied file still clear, and a deliberate clear
  passes allow_empty / allowEmptyOverwrite: true. Contributed by
  @JamisonMercurio.
• GitHub is now a source kind: gbrain sources add --kind github mirrors
  issues and PRs into the brain, with webhook refresh, a demo fixture, and
  a guide at docs/guides/github-source.md. Contributed by @veltri-23.
• Superseded pages are down-ranked and flagged SUPERSEDED in rerank
  results, so a stale answer no longer outranks the page that replaced it.
  Contributed by @rspinabellaagent.
• search.autocut_min_keep is wired end to end — the documented autocut
  floor was declared but never read, so raising it did nothing. It now flows
  through the mode bundles, the resolver, and the cache key. Contributed by
  @paul-0320.
• sync.write_through opt-out flag for DB-only brains: set it to false
  and page writes stay in the database instead of dual-writing to disk.
  Contributed by @DanCanadian.
• A standalone exporter writes conversation pages back to envelope-v0,
  closing the round trip. Contributed by @SeanGearin.
• Dart code intelligence: the bundled grammar now matches the pinned
  tree-sitter runtime (ABI 15) and Dart files produce a call graph.
  Contributed by @Jey2311.
• llama-server declares chat prompt caching, so local deployments get the
  same cache accounting as hosted providers. Contributed by
  @erionjuniordeandrade-a11y.
• Canonical pricing rows for GLM-5.2 (Z.ai) — contributed by @SomeUserName1 —
  and static rates for router-prefixed OpenRouter ids, which previously fell
  through to a no-pricing refusal. Contributed by @kweiner.

Changed

• Concept synthesis gets budget priority and falls back to labels instead of
  dropping work when the budget runs short. Contributed by @calebhicks.
• LLM cycle phases (propose, grade, atom extraction, and concept synthesis)
  halt on global billing, auth, and rate-limit errors instead of swallowing
  them per page, so one bad credential fails loudly once rather than quietly
  on every page — and a global outage no longer counts against per-page
  failure budgets or overwrites concept pages with fallback stubs.
  Contributed by @Masashi-Ono0611.
• The claude-cli provider surfaces api_error_status as a typed error rather
  than a raw exit blob. Contributed by @Masashi-Ono0611.
• dream extract-atoms failure details name the provider and model that
  failed. Contributed by @proprieties.
• Reserve failures caused by missing pricing are recorded in the budget audit
  trail instead of vanishing. Contributed by @herove.

Fixed

• Piped CLI output larger than 64KiB no longer truncates with exit 0 when the
  reader drains slowly (#3423). This was the root cause of agents reporting
  that saves "didn't stick": a verify-read of a big page lost its tail, which
  is exactly where the fresh edit lives, and feeding that truncated read back
  through an edit could shrink or blank the page. Output delivery is now
  awaited to the last byte before exit — get_page, gbrain call, and
  --tools-json all return complete payloads at any reader pace.
• claude-cli auth and configuration failures (401/403/400) now classify as
  configuration errors instead of retryable transients, so callers stop
  re-billing a revoked credential.
• An invalid configured timezone degrades to "unknown" instead of breaking
  context assembly on every turn.
• Pattern excerpts split UTF-16 surrogate pairs, which could make Postgres
  reject the subagent job payload; excerpts now use the shared UTF-16-safe
  truncator. Contributed by @calebhicks.
• Reindex repairs are scoped and advance past failures instead of stalling on
  the first one; reindex --type reaches the flag registry. Contributed by
  @calebhicks.
• Oversized codex rollouts import instead of throwing, and --max-bytes
  reaches the transcript adapters; a truncated scan never advances the
  ingest watermark over unscanned content. Contributed by @mweber82.
• Malformed extractor output is retried once with an explicit JSON-only
  reminder before the turn's facts are given up on. Contributed by @herove.
• Fence writes are committed durably. Contributed by @herove.
• Reflex telemetry writes register before the CLI drain, so they are no
  longer lost at shutdown. Contributed by @monkeygold.
• International home locations are supported in context resolution.
  Contributed by @arisgysel-design.
• Relative markdown links resolve against the linking page's directory
  instead of the brain root. Contributed by @alexey-metaengage.

To take advantage of v0.46.23.0:

• gbrain upgrade (or reinstall the binary).
• If your agent harness ever reported pages that "didn't save" or reads that
  came back incomplete on large pages, upgrading is the fix: reads deliver
  fully, and the store refuses a blank body over real content (a deliberate
  clear passes allow_empty on the put_page op).
• Search cache cold-miss: the knobs hash moves 18 → 19 to fold the
  autocut floor into the cache key. Existing query_cache rows become
  unreachable on first re-query and refill within cache.ttl_seconds. No
  action needed.
• To mirror a GitHub repo's issues and PRs into your brain, see
  docs/guides/github-source.md.
• DB-only brains can now skip disk dual-writes with
  gbrain config set sync.write_through false.

A wedged database shutdown can now die fast and loud instead of hanging
forever. Issue #4284 (analysis and measurements by @cheRoma — thank you)
proved that the time-bound around the embedded database's close could never
fire against the exact deadlock it was written for: a wedge starves the
event loop, and no timer on a starved loop ever runs. The bound is now
honest about what it covers, and a new opt-in out-of-band watchdog covers
what it can't.

Fixed

• The in-loop close bound is now honest and correctly armed. The timer
  arms before the close begins (not after), stays referenced so a quiet
  process can't exit before the warning and lock release fire, reads its
  override per call, and clamps oversized values so a huge
  GBRAIN_PGLITE_CLOSE_TIMEOUT_MS means a longer bound — never an instant
  spurious timeout. Its warning now states plainly that a close which wedges
  the event loop cannot be caught in-process, and names the watchdog knob
  that can catch it. Code comments and docs describe the layered defense
  truthfully: the pre-close drain prevents the known wedge, the in-loop
  bound covers a close that still yields, and only the watchdog observes a
  wedged one.
• The CLI teardown backstop now budgets the real close bound. Raising
  the close timeout widens the teardown deadline with it, instead of the
  backstop force-exiting mid-honest-close against a stale hardcoded copy.
• Watchdog timer arithmetic can never overflow into an instant kill.
  Deadline, grace, and their sum are clamped below the platform timer
  ceiling (an overflowed timer fires at ~1ms — for the kill timer that
  would have meant SIGKILLing a healthy process), and a non-numeric grace
  is coerced safely instead of arming a ~1ms kill.

Added

• Opt-in out-of-band disconnect watchdog — a diagnostic instrument for
  CI lanes and wedge hunts, off by default. Set
  GBRAIN_PGLITE_CLOSE_WATCHDOG_MS (and optionally
  GBRAIN_PGLITE_CLOSE_WATCHDOG_GRACE_MS, default 30000; an explicit 0
  means SIGKILL at the deadline) and a worker-thread watchdog arms around
  each embedded-database disconnect: SIGTERM at the deadline, SIGKILL at
  deadline+grace, firing even while the main event loop is completely
  wedged — converting a silent 10-minute CI kill into a fast, loud,
  attributed death. A drain-aware floor clamps a too-small deadline UP
  (with a warning) so a units typo can never kill a healthy slow teardown,
  garbage values warn instead of silently disarming, and the armed
  breadcrumb re-fires whenever the effective deadline changes in a
  long-lived process.
• A regression pin that genuinely wedges an event loop. A new spawned-
  fixture test suite starves a real Bun loop the way the measured incident
  did, proving the watchdog SIGKILLs it at deadline+grace, that nothing
  in-process can fire without the watchdog, and that a healthy disconnect
  is never harmed. The heavy read-latency reproducer now arms the watchdog
  as a canary.

To take advantage of v0.46.22.0

• Nothing changes by default — teardown behavior with the env knobs unset
  is the same layered defense that already shipped, now honestly
  documented.
• In CI lanes or when hunting a suspected shutdown wedge, export
  GBRAIN_PGLITE_CLOSE_WATCHDOG_MS=30000 (optionally
  GBRAIN_PGLITE_CLOSE_WATCHDOG_GRACE_MS=10000): a wedge then dies loudly
  with a pglite-disconnect-watchdog stderr label at ~40s instead of
  hanging until an outer timeout. Values below the safe floor are clamped
  up with a warning, never applied literally.
• If you previously raised GBRAIN_PGLITE_CLOSE_TIMEOUT_MS, the CLI
  teardown backstop now automatically widens to match — no action needed.