Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
118 KB
Raw Blame
// Generated by scripts/build-behavior-changes.ts from behavior-changes.d/ and the CHANGELOG markers; do not edit.
// Regenerate: bun scripts/build-behavior-changes.ts (the release does it). Docs: behavior-changes.d/README.md

/** The plain-text rows of behavior-changes.d/, each dated by the release whose CHANGELOG section marks it. */
export const RELEASED_BEHAVIOR_CHANGES: ReadonlyArray<{ since: string; id: string; kind?: string; text: string }> = [
  { since: '0.60.706.0', id: 'db_wins_unimported_gst2579', text: "A database-wins file-drift repair no longer overwrites a newer change to the file that sync has not imported. `gbrain repair file-drift --prefer database` by `--held` or `--all-drifted` now lists such a page `kept_newer_file` (a file edited since the last import) or `kept_newer_delete` (a file another writer deleted) and leaves it held; naming the page with `--slug` previews it and names the commit it would discard (sha, author, date). Every file-drift apply now asks for the user's consent, so a script that applies without `--yes` exits 3. `gbrain sources reconcile --apply` refuses `source_changed` when its result takes the database copy over such an edit. A database copy newer than the file (the file still holds what sync imported, or gbrain's own write of a revision the page has since moved past) repairs as before; gbrain's own writer commit of a revision the database never took counts as newer. The keep_db policy is unchanged." },
  { since: '0.60.708.0', id: 'extract_receipt_sealed_7620', text: "An extraction run's receipt page (type `extract_receipt`, under `extracts/`) is now chunked and sealed in the transaction that writes it. Remote/MCP `search` and `query` on the extracted source no longer report `safe_index_pending` or `projection_pending` after every extraction, doctor `safe_index_pending` no longer counts new receipts, and remote readers can now find receipts like other generated pages (demoted in ranking). Receipts an earlier release wrote stay unsealed until `gbrain repair safe-chunks --apply`. A receipt is database-only bookkeeping on every brain, with or without a Git repository: when its slug already holds a content page or a page with a file in Git, the receipt is not written (the extraction logs a warning and carries on) instead of overwriting that page." },
  { since: '0.60.708.0', id: 'commit_push_dry_run_checks_paths', text: "`gbrain git commit-push --dry-run` now asks git about the planned paths the way the real run stages them, and runs the real run's checks before staging, so it exits 1 with the real run's code and text where that run would refuse (`commit_outside_source_root` for a path outside `gbrain.sourceRoot` unless `--allow-outside-source-root` is passed, `commit_prestaged_paths`, and `commit_paths_invalid` for a path outside a sparse-checkout definition or one that matches nothing) instead of exiting 0 and listing it. It still takes no lock and writes nothing." },
  { since: '0.60.708.0', id: 'schema_client_behind_7776', text: "A gbrain binary older than the brain's schema (the database's schema version is above its newest migration because a newer gbrain on another host or install migrated it) now refuses schema setup with `client_behind` and changes nothing: `gbrain init` and `init --migrate-only`, the schema step of `gbrain upgrade`, and `gbrain apply-migrations` (before any orchestrator runs, and before the schema pass of `--force-schema` or `--force-all`; `--list` and `--dry-run` still work). Before, it replayed its own older schema, which reinstalled superseded function bodies (the writer-fence guards among them) over the newer ones, and reported success. Reads and ordinary commands on the older binary are unchanged; the fix is `gbrain upgrade` on that host. A new doctor check, `schema_function_bodies`, fails when a function of this gbrain's schema has another body installed (what an older replay leaves behind) and names each one: upgrade every gbrain that shares the database, then run `gbrain init --migrate-only`. PGLite and Postgres alike, with or without a git repo." },
  { since: '0.60.708.0', id: 'purge_keeps_outcome_markers_7831', text: "Purging a fact whose text is exactly `EXTRACTION_COMPLETE` or `EXTRACTION_NOT_APPLICABLE` (`gbrain forget <id> --purge`) no longer removes the conversation-facts outcome rows that carry the same text: the purge, its receipt, `--status` and a restore replay leave them in place, so those pages are not extracted again. The purged claim itself is still removed and tombstoned." },
  { since: '0.60.708.0', id: 'audit_secrets_glued_marker_8034', text: "`gbrain transcripts audit-secrets` and re-scans of stored pages again report a password glued to an importer redaction marker by punctuation (`<REDACTED:user-pattern>,<password>`, `<REDACTED:x>.<password>`): punctuation after a marker ends it only when a space or the line end follows. Pages that hold such a line show up as affected again; import-time redaction is unchanged." },
  { since: '0.60.708.0', id: 'fence_locators_skip_code_8020', text: "A fence marker written inside markdown code (an inline `code` span or a fenced code block) no longer counts as a fence for concept republication, the Google connector's fence carry, `gbrain repair connector-fences` or `gbrain repair take-supersession`, matching how the fence readers already read the page. Pages that quote a marker in code are no longer held `concept_preservation_hold` or `connector_fence_below_timeline`, or skipped as unparsed, for that reason alone." },
  { since: '0.60.708.0', id: 'ghost_code_page_recorded_file_7967', text: "`gbrain repair ghost-pages` on a managed brain now retires a code or image page (a JSON, YAML or image file indexed as a page) at its recorded file instead of at `<slug>.md` (#7967): when that file is restored after the request was prepared, publication refuses and the page is kept (outcome `file_restored`), and the door commits the removal of the recorded file, so on a git-canonical source HEAD stops holding the file of a page the database deleted." },
  { since: '0.60.708.0', id: 'derived_write_through_retry_8092', text: "The dream cycle's atom and concept write-through (#8092) waits for a busy checkout commit lock without freezing the worker (up to 30 s, as before). After a refused commit, a rewrite of an existing atom or concept file and the removal of a retired atom's file are now retried on the next run like new files, instead of staying behind the database until the page changes again; the summary reads \"N file(s) rolled back; the next run writes them again\". The rollback runs under the commit lock and takes its files out of the pending write-through ledger, so a later hand edit at one of those paths is never swept into a gbrain commit; when the lock stays busy the files are left for that writer's commit." },
  { since: '0.60.708.0', id: 'owner_repair_file_restore_7960', text: "On an unmanaged repository brain, `gbrain repair provenance --apply` or `gbrain trust backfill --repair-unknown-markers` whose database write fails after the page file was written now puts the file's previous bytes back, and when the write had been committed on a hardened checkout, commits that restore (`gbrain: restore write-through <slug>`), so a failed apply leaves the file, Git and the database unchanged (#7960)." },
  { since: '0.60.708.0', id: 'protocol_guard_refusal_typed_7777', text: "A write refused during publication by a persistence protocol guard (SQLSTATE 42501) now fails with the guard's own code on its receipt, `writer_upgrade_required`, `writer_not_quiesced`, `unsupported_mutation_protocol` or `writer_coordinator_required` (relationship `unreadable_state` when the database role cannot read the writer state), with `write_error_detail` naming the guard and a suggestion for that refusal, instead of `storage_error` for an unexpected owner exception. `gbrain sources writer status` gives the same step in `recent_failures[].next_action`. Any other permission error is unchanged, and so is the same refusal outside publication (write admission, protocol activation), which still reports `permission_denied`. Every `unreadable_state` refusal (#7780) now reads \"writer state this database role cannot fully read (row-level security hides it or applies to the role, or a singleton row is missing)\", its receipt suggests running gbrain as a role that can read that state instead of upgrading, and `gbrain sources writer status` shows the table in `recent_failures[].error_detail.state`." },
  { since: '0.60.708.0', id: 'door_index_refresh_7717', text: "On a source with `canonical: git`, a page committed with a legacy file mode (100664) no longer gets a mode-only commit when a write leaves its bytes unchanged, and with `core.fileMode=false` a write of it commits the page as 100644 (before, Git refused the rebuilt tree and the write failed `git_unavailable`). A write replayed after its commit landed and refused `git_index_conflict` because someone staged the page meanwhile now says HEAD already holds its bytes, instead of that it committed nothing. The index refresh after a door commit removes the index copies (`index.gbrain-<pid>-*` in the git directory) a killed gbrain process left behind, and on Windows retries a briefly refused rename of the index before it reports that the commit landed but the index was not updated." },
  { since: '0.60.708.0', id: 'stored_root_predicate_7646', text: "Stored paths (`sources.local_path`, `sync.repo_path`) are judged absolute by one rule in sync, `config set sync.repo_path`, write-through, `gbrain sources set-path --clear` and doctor. On Windows only a drive path (`C:\\...`) or a UNC share counts: a root-relative `\\brain` or `/brain`, which names a folder on whatever drive gbrain runs from, is refused by sync (`sync_anchor_relative`) and cleared by `--clear` like `.`. Doctor's `default_source_local_path` now warns when the `default` source's own path is absolute only on another operating system (a Windows drive path read on Linux or macOS), where it reported ok. A page or fact write whose stored root is not absolute on this host records the database-only reason `relative_root` (it was `no_repo_configured` or none)." },
  { since: '0.60.708.0', id: 'sync_anchor_relative_jobs_7646', text: "A queued `sync` job for a source whose stored path is not absolute on this host completes as a skip (`reason: sync_anchor_relative`, with the ask-the-user fix) instead of failing and using up its attempts. `gbrain sync --all --json` gives such a source's entry `code`, `why` and `fix` beside `error`. With a stored `.`, `gbrain sync --repo ./` is refused like `--repo .`. A relative `sync.repo_path` behind a `default` source with no path no longer lets an explicit `--repo` advance default's last synced commit. `gbrain dream --json` puts a failed phase's ask-the-user fix in its `cycle_failed` envelope." },
  { since: '0.60.708.0', id: 'conversion_root_owner_7956', text: "`gbrain sources canonical <id> --to git` refuses a registered root it cannot read (gone, unmounted, a file, no permission or a symlink loop) with `source_root_unreadable` (reason and fix) instead of a raw filesystem or Git error, and an archived or re-registered source refuses `owner_unavailable` before the Git checkout check instead of `git_checkout_required`. An apply whose source was returned to mixed (`--to mixed`) while it ran reports `incomplete` with a message that the source is mixed, never `converted` (#7956)." },
  { since: '0.60.708.0', id: 'stuck_recovery_strict_followup_7715', text: "On a git-canonical (strict) source, `gbrain repair stuck-recovery --keep disk` now says the kept bytes are an uncommitted edit at the file's path and hands off to commit then sync (`gbrain git commit-push --path <checkout> -m \"<message>\" -- <path>`, or `git -C <checkout> restore -- <path>` to discard, then `gbrain sync --source <id> --no-pull`; verify with `git status --porcelain` then `gbrain sync status --source <id> --json`), with an ask-the-user `fix` in the item detail, instead of a database-side `sources reconcile`. Mixed sources keep the reconcile follow-up (#7715)." },
  { since: '0.60.708.0', id: 'url_clone_fences_held_preview_7910', text: "`gbrain repair url-clone-fences` lists a held file (for example `visibility_noncanonical`) once, as an apply item, and no longer also counts it as a residual; its preview says the restored file equals HEAD, so sync does not screen it again and the page changes once an upstream fix is pulled and synced (it no longer claims sync holds the file) (#7910)." },
  { since: '0.60.708.0', id: 'streamed_put_visibility_wording_7881', text: "On a brain without managed persistence, `gbrain put --file` and `gbrain capture --file` of a page over the single-string ceiling that asks for `visibility: private` in a spelling page privacy does not read refuse `visibility_not_applied` with the page-write message a smaller put gives (nothing was written; write `visibility: private` on its own frontmatter line), not the import hold's \"sync or import the file again\" (#7881)." },
  { since: '0.60.708.0', id: 'git_durability_refusal_no_side_effects_7634', text: "`gbrain sources writer git-durability <source>` without `--dry-run` now checks `--admin-intent writer_git_durability` and `--expected-state` first: a missing, wrong or stale approval refuses (`writer_admin_intent_required` or `writer_admin_state_changed`) before the token file is read and before anything changes. It used to rewrite the durability block in `AGENTS.md`/`RESOLVER.md`, wire the `--pat-file` credential and retry parked pushes first. After an approved apply, `agents.commit` now names `gbrain git commit-push --path <root> -m \"<msg>\" -- <file>` instead of plain git." },
  { since: '0.60.708.0', id: 'parked_push_hidden_page_7110', text: "`gbrain sources writer retry-effects <source> --parked-pushes` (and `git-durability --pat-file`) no longer stops the whole run when one parked request's remote writer can no longer see its page (it became private): that request is listed in `refused` with its `request_id`, code `page_not_found`, the page slug and a read-only receipt command, the other parked pushes are retried, and the run ends `partial` (exit 1). The refused request stays parked; nothing retries it under another authority." },
  { since: '0.60.708.0', id: 'embedding_preflight_abort_7772', text: "An embedding effect whose stop signal fires while its provider call is being admitted (for example a one-shot `gbrain put` exiting) is now retried (`queued`, `embedding_aborted`) instead of failing for good as `embedding_budget_refused`, which blocked writer quiescence and showed in doctor `stale_embedding_effects` until `gbrain repair embedding-effects --apply`. A real budget refusal still fails as `embedding_budget_refused`." },
  { since: '0.60.708.0', id: 'mirror_read_only_legacy_writers_7098', text: "On a brain without managed persistence, a source marked `gbrain sources mirror-readonly` is now left untouched by the legacy disk writers below (#7098): `sync --full` no longer re-exports never-committed database pages into its checkout, `brainstorm --save`, page write-through, timeline entries and fact fences keep the write in the database (write-through and timeline report `skipped: mirror_read_only`), `forget` expires a fenced fact in the database without rewriting the file, and the extract cycle neither fences its database-only facts into the file nor counts them in its legacy-row guard. An owner trust repair (`gbrain repair provenance`, `trust backfill`) lists such a page `needs_review` with detail `mirror_read_only` instead of rewriting its file. The dream cycle leaves such a checkout alone too: its reverse-written synthesis, patterns and cycle-summary pages stay in the database (#8935). Before, only managed publication honored the flag, so these writers gave the mirror local changes that could stop its `git pull --ff-only`." },
  { since: '0.60.708.0', id: 'copied_root_fix_names_self_transfer_7671', text: "A managed write refused `recovery_required` because a source's checkout is a new directory at its recorded path (a copied or restored brain, detail `physical_root_directory_changed`) now carries the relocated-root self-transfer as its `fix` (#7671): `gbrain sources writer transfer prepare <source> --self-transfer --confirm-relocated-root` with its admin intent, then the accept as `fix.then`, a host-admin step (`next: tell_user_to_run`), on a put_page receipt too, where `fix` used to point at the write receipt. Nothing is re-stamped automatically; the write still refuses until the self-transfer runs." },
  { since: '0.60.708.0', id: 'door_landed_replay_gst2517', text: "On a source configured `canonical: git`, a write whose door commit landed in Git and whose database transaction then failed before committing (an owner exception after the commit) is now replayed by its owner instead of ending `failed` / `storage_error`: the replay finds its change already committed and records it without a second commit. A `forget` caught there now records its withdrawal, so the fact turns inactive and remembering the same claim is refused `fact_withdrawn`; before, the fact stayed active until a sync, no withdrawal was recorded (so the claim could be remembered again) and the reply said nothing was saved. A replay that fails as well ends failed with the commit named on its receipt (`landed_before_row`), and a `remember` or `forget` reply then names that commit instead of saying nothing was saved. `gbrain repair failed-writes` lists a refused `forget` as a caller write to resubmit instead of one the next dream cycle produces again." },
  { since: '0.60.708.0', id: 'requester_scope_gst363', text: "On a brain that serves several people (two or more enabled members, or config `access.serves = several`; a brain pinned `access.serves one` never does), a remote read through a connection bound to no member (an access token, an OAuth client, or a stdio server with no member binding) is now refused with `requester_scope_required` before any work; `whoami`, `get_brain_identity`, `get_status_snapshot`, `search_modes`, `get_health` and a non-admin key's own `get_job` / `wait_job` still answer. A connection that existed when the brain started serving several people (config `access.serves_since`, set once, or this upgrade) reads for 14 more days with `_meta.access.requester_scope` naming the date and the fix; one created later is refused at once. Bind each connection to the person it serves: `gbrain auth rescope --token <name>|--client <id> --member <id>`; a stdio harness only one person uses, `gbrain setup claude-code|codex --stdio-member <id>`; a harness several people talk to, one `--member` key per person over `gbrain serve --http`. A shared agent names the person per call (`--may-act-for`), and `--reads-unscoped --yes` marks one credential to read unscoped on purpose. `gbrain auth create` and `gbrain auth register-client` refuse an unbound credential on such a brain (`credential_scope_required`); `gbrain doctor` fails `unscoped_shared_reads` per unbound credential and `gbrain post-upgrade` lists them. `gbrain doctor` also fails `shared_stdio_binding` when `mcp.stdio_member` is set on a host where OpenClaw or Hermes is installed and the brain serves several people; a `hermes` on PATH counts as Hermes only when it is a script. Hosted brains set `access.requester_scope_enforce false`, which turns every refusal into the notice. Member-bound credentials (the owner's included), attested calls, a one-person brain and the local CLI see no change; writes are not affected." },
  { since: '0.60.710.0', id: 'writer_fence_fail_closed_7636', text: "Since v0.60.474.0 (#7636, migration v278), a Postgres role that row-level security hides gbrain's writer state from (the `persistence_brain` row; on a managed brain also the `git_canonical_brain` row, a source row while any source is Git-canonical, or the page behind a tag, timeline entry or take) is refused with `writer_coordinator_required` (relationship `unreadable_state`) on every guarded write, unmanaged brains included, where such writes used to pass as unmanaged. Run gbrain as the table owner, a role that bypasses RLS, or a scoped role whose policies cover those rows (docs/ENGINES.md#writer-protocol-fences)." },
  { since: '0.60.711.0', id: 'propose_takes_rejected_memory_7299', text: "The dream cycle's `propose_takes` phase no longer puts a claim back in the review queue after you rejected the same claim text on the same page (#7299). Before, any edit to the page re-extracted it and the rejected claims came back as new proposals. A reworded claim is still proposed; the run reports how many it dropped as `rejected_claims_skipped`." },
  { since: '0.60.711.0', id: 'grade_takes_auto_resolve_7542', text: "`gbrain config set cycle.grade_takes.auto_resolve.enabled true` now does what it documents (#7542): the dream cycle's `grade_takes` phase applies a verdict with confidence 0.95 or higher (3/3 at 0.85 or higher on the ensemble path) to the take. Before, the key was ignored and every verdict stayed review-only. Unset or false is unchanged: verdicts wait for review in `gbrain takes grades`." },
  { since: '0.60.711.0', id: 'dream_write_deferral_w3', text: "A dream purge or consolidate write that was accepted but is still pending after its publish wait no longer fails the phase: the phase warns `dream_write_deferred` with the receipt id, and the next pass reads that receipt before it submits anything for the source (committed clears it; a failure is reported with its real code). After 3 passes still pending, doctor `dream_write_deferred` warns with `gbrain write-request -- <id>`. `gbrain config set dream.write_deferral.enabled false` restores the failing phase." },
  { since: '0.60.711.0', id: 'synthesize_no_candidates_w3', text: "A dream synthesize window where every transcript is already synthesized now returns before triage, the manifest context and the child queue, with `details.reason: no_candidates` and the cooldown stamped. Synthesize deaths also count per transcript under `dream:synth-v2:@file:<source>:<file>` once they span two content keys, so a transcript that grows between dying runs is refused after 3 deaths in 24 hours like any other key, and `gbrain dream reset-key` now accepts every key `--list` prints, `dream:phase:` keys included." },
  { since: '0.60.711.0', id: 'embedding_restamp_w3', text: "The maintenance cycle's embed phase now first stamps the current embedding signature on pages whose every chunk already holds a current-model vector, up to 500 pages a run, with no provider call; a page edited or re-embedded during the stamp is left for the next run. Three failed runs in a row warn as doctor `embedding_restamp_stalled`. `gbrain config set embed.restamp.enabled false` turns it off. Health's embedding coverage now counts live pages only, so chunks kept on a soft-deleted page no longer lower it." },
  { since: '0.60.711.0', id: 'doctor_foreign_skills_folder', text: "`gbrain doctor` no longer grades a skills folder it found by walking up from the current directory unless gbrain installed it (a skills.lock.json, a valid manifest.json or the skillpack block in its resolver file): resolver_health and skill_currency report \"not a gbrain skills folder (<path>)\" as info, so an agent's own skills folder no longer lowers health_score or fails doctor. Pass --skills-dir (or set GBRAIN_SKILLS_DIR / OPENCLAW_WORKSPACE) to grade it as before. Agent crons should page on the new `gbrain doctor --alert` (exit 17 act, 18 unknown), not on health_score." },
  { since: '0.60.711.0', id: 'upgrade_installs_no_autopilot', text: "An upgrade no longer installs autopilot on a Postgres brain that has none, even with sync.repo_path set: the v0.11.0 migration's Phase F is skipped (reason not_installed), prints the install command and records it, and `gbrain doctor` shows it as a minions_migration line until you run it. An autopilot already installed for the brain is reinstalled as before." },
  { since: '0.60.711.0', id: 'session_lane_budget_gbra133', text: "New read-only `gbrain doctor` check `session_lane_budget` counts this database role's connections across every gbrain process (by process kind and host, from the `gbrain <kind>:<pid>:<nonce>` connection name) and warns at 80% of the limit, naming the kinds holding the most. Behind a Supabase pooler, set `GBRAIN_SESSION_LANE_LIMIT` to the project's `pool_size` to compare (Postgres cannot read it); without it the check reports the counts only. Without a pooler the limit is `max_connections` less the reserved slots. Not applicable on PGLite." },
  { since: '0.60.711.0', id: 'github_item_webhook_backlog_8799', text: "A GitHub webhook for an item event (issue, pull request, comment, review, check) now answers HTTP 429 `webhook_backlog_full` with `Retry-After: 30` when 50 item jobs are already waiting for that source and none of them covers the event; it used to answer 202 with another item's job while the event was dropped. GitHub does not redeliver a 429 on its own: redeliver it from the webhook's Recent Deliveries, or let the next sweep or `gbrain sync --source <id>` catch it." },
  { since: '0.60.711.0', id: 'webhook_capture_no_default_fallback_gst2113', text: "A webhook capture (`POST /ingest` and its `ingest_capture` job) whose credential's write source is archived, unregistered or removed before the capture lands now fails the job with `source_changed` (`detail: webhook_source_unavailable`) and writes nothing. Before, it was written under `default`, a source the credential may not be granted, and could replace a page there. Restore the source and run `gbrain jobs retry` on the job. Captures that do not come from a webhook keep the `default` fallback." },
  { since: '0.60.711.0', id: 'code_rechunk_module_elixir_8128', text: "Code sync re-chunks TypeScript, TSX, JavaScript, Python, Ruby and Elixir files once (a per-language chunker revision): top-level code with no named definition (anonymous default exports, top-level `if`/`for`/`try`, Python's `__main__` block) becomes `<file>::__module__` chunks with call edges, and Elixir modules and functions become named definitions that `code-def` and `code-callers` find. The sync cost gate prices only those files." },
  { since: '0.60.711.0', id: 'db_link_child_folder_6983', text: "On the DB link path (`gbrain extract links --source db` and automatic link backfills), a `.md` link with a folder and no `./` or `../` prefix (`[x](notes/a.md)`) now resolves against the linking page's folder first, then its parent folders, then the brain root, matching `--source fs`. Where both a child page and a root page exist, the edge now points at the child." },
  { since: '0.60.711.0', id: 'remote_think_host_model_gbra437', text: "A remote `think` (MCP, HTTP or a thin client) now runs on the brain host's think model (`models.think`, then `models.default`) unless the host lists the requested `model` in the new `think.remote_models` key (comma-separated, empty by default). An unlisted model, or a listed one the host cannot run, no longer fails the call with the explicit-model error: the host model answers, `warnings` carries `MODEL_OVERRIDE_IGNORED:not_allowed` or `:unusable`, and the result carries a `model_override_ignored` notice. Remote `rounds` runs one round. The local CLI `--model` is unchanged, and a keyless brain answers as before." },
  { since: '0.60.711.0', id: 'physical_root_moved_8625', text: "On a managed brain, a checkout moved to a new path (or whose parent folder was renamed) is now named: `gbrain sources add`, `gbrain sources set-path` and `gbrain sources writer claim` refuse with `recovery_required`, detail `physical_root_moved`, naming the recorded path, the worktree and the commands that bring it back, instead of a generic identity error (add, claim) or detail-less `source_checkout_missing` (set-path). Their `--dry-run` now refuses as the real run does: before, the add, claim and set-path dry runs of a moved checkout, the add and claim dry runs of a folder holding a copied ownership stamp, and the set-path dry run of a missing checkout exited 0. Nothing about ownership changed; the dry runs still write nothing." },
  { since: '0.60.712.0', id: 'moved_pages_fold_gst2584', text: "gbrain repair file-drift --held no longer offers a delete or a recreate for a page whose file moved while its deletion was held: it lists the page as moved_to <slug> with the new gbrain repair moved-pages --source <id> --slug <old-slug> fold command, and --prefer file skips it. A file that names the page type gbrain-base 1.0.0 gave its path, equal to the type copy an older gbrain stored in the page's frontmatter, now keeps the type a later schema pack gave the page on import, and the import records the rename as a legacy_type retype stamp; before, the next edit read the old type back into the page." },
  { since: '0.60.712.0', id: 'folder_holding_page_gst2492', text: "On a source whose pages are canonical in Git (`canonical: git`), a fact for an entity with no page under a folder access rule is no longer kept in the database only: it is held on the holding page of the entity's folder (`partners/memory/unattributed` for `partners/acme-example`), in Git (or database-only where the folder is) with exactly the readers the entity's page would have. The reply names that `page`. `gbrain access rule add` previews the held facts a new rule covers (`held_facts_moving`) and its apply moves them off their holding page (`held_facts`), as do `gbrain access apply`, `gbrain access resume` and a sync that applies a rule from Git; the moved rows and those entities' struck rows also leave that page's saved versions in the database (`held_versions_editing`, `held_versions_edited`), and Git history is not rewritten. A saved version stored in segments is not edited: the preview names how many (`segmented_versions_not_edited`) and the apply says `complete: false`. A move still pending is reported with its request id (`pending`, `HELD_FACT_PENDING`), not counted as moved. A held fact is now also hidden from a caller who cannot read its holding page, even under a rule with `covers_derived: false`. `gbrain repair facts-home` writes such facts to their folder's page and lists as `folder_restricted` only an exact page rule or unreadable rules. A `remember` for a page-less entity under an exact page rule now refuses `git_home_required` with a fix that creates the page, and one whose access rules this database role cannot read refuses `access_policy_pending`; both wrote the fact to the database before. An existing page whose slug ends in `/memory/unattributed` is now read as a holding page: a row with no `entity` cell becomes a fact with no entity, a row naming an entity in the page's own folder becomes that entity's held fact, and a row naming an entity of another folder is a fence problem. Non-strict sources and brains with no Git repository are unchanged." },
  { since: '0.60.713.0', id: 'stuck_head_released_9227', text: "On a PGLite brain, the next gbrain process that opens the brain now releases at once every write claim an earlier, exited process left running and runs those writes again, instead of leaving later writes to the same source pending for the rest of the claim's lease (30 s, or about 6 minutes while publishing). `gbrain sources writer status` reports a claim whose owner has provably exited (that case on PGLite, a dead process on the same machine on Postgres) with `owner_exited: true`, `resumes_on_its_own: true`, `owner_live: false` and `next.code: claim_owner_exited`, where it said `claim_running`." },
  { since: '0.60.713.0', id: 'receipt_git_state_live_9227', text: "A write receipt read after the write (`gbrain write-request`, `get_write_request`, `list_write_requests`) for a page on a checkout that is not `canonical: git` now takes `persistence.git_state` from the page's Git effect: `committed` with the commit in `persistence.git_commit`, or `superseded`, `skipped`, `failed` or `retrying` with `persistence.git_reason`, where it always said `queued`. Stored receipts are not rewritten; the stored `outcome` still says `queued`." },
  { since: '0.60.713.0', id: 'label_repairs_hold_refusals_gst2603', text: "gbrain repair visibility and gbrain repair private-labels now ignore stamps gbrain keeps only in the database (a pack-renamed type, the validate: false grandfather stamp, a legacy_type retype record) when they edit a page's label line, so those pages are labelled. A page whose file still differs in a real key, or whose label line cannot be edited as one line, is held by the preview with the blocking key and its next step and is left out of the approved set. A page that starts refusing after the preview is declined with label_edit_refused, nothing is written for it, the run exits 0 and it no longer counts toward item_failures_systemic. Their previews, and those of gbrain access rule add and import, also list same-slug pages in other sources that the change leaves readable (open_twins), with their count and the command that covers them; nothing changes those pages for you." },
  { since: '0.60.713.0', id: 'corpus_segmented_entity_9279', text: "Captured session files whose facts name a large entity page (one stored in segments, over about 1 MiB) are now extracted: facts inferred from a mention of that page were refused after the model call, so those files were retried five times and then stopped. The first sweep after this upgrade retries each file stopped that way once, at the cost of one model call per stopped window, with no command needed. From now on a refusal that retrying cannot change stops its window after one paid attempt instead of five, retention keeps the session file instead of deleting it at the un-ingested limit, and gbrain doctor (memory_writeback) counts these files as held. gbrain sweep --retry-failed --apply still retries them by hand." },
  { since: '0.60.715.0', id: 'skillpack_update_untouched', text: "Installed skills can now take gbrain's current version whole when you never edited them. `gbrain skillpack scaffold` (including `--harness` installs) and every update record the sha256 of each skill file it installed in `~/.gbrain/skillpack-state.json` (schema `gbrain-skillpack-state-v2`; an older gbrain refuses that file instead of dropping its records). Preview what would change with `gbrain skillpack reference --all --update-untouched --dry-run`; a skill with any edited file, a pinned skill (`gbrain skillpack pin <skill>`) or one with no recorded hash is skipped with a reason and a diff. Every update is journaled under `~/.gbrain/skillpack-backups/` and undone with `gbrain skillpack restore <id>`. `gbrain upgrade` writes no skill files; nothing runs on upgrade." },
  { since: '0.60.715.0', id: 'claude_cli_setting_sources_8342', text: "On Claude Code 2.1.314 or newer, the claude-cli provider now runs its child with `--setting-sources \"\"`, so your own `~/.claude/CLAUDE.md`, memory and `settings.json` no longer steer gbrain's background claude-cli calls. The subscription login is kept, but `settings.json`'s `env`, `apiKeyHelper` and permission rules no longer reach the child either. `GBRAIN_CLAUDE_CLI_USER_SETTINGS=1` (shell or ~/.gbrain/.env) loads them again. Older CLIs are unchanged." },
  { since: '0.60.715.0', id: 'unattended_maintenance_doctor_gbra438', text: "`gbrain doctor` has a new check, `unattended_maintenance`, which reads the free-upkeep record `maintenance.last_run`: it warns (and so can lower doctor status from healthy) when no upkeep run is recorded on a brain older than 48 hours, when the last run is older than 48 hours, or when one step failed three runs in a row; the fix is `gbrain maintain --unattended`. Upkeep turned off (`maintenance.auto false`) or owned by an autopilot reads ok. New commands: `gbrain maintain --unattended`, `--status` and `--purge` (preview, then `--yes --expect <hash>`)." },
  { since: '0.60.715.0', id: 'bookkeeping_gc_phase_gbra438', text: "The dream cycle has a new phase, `bookkeeping_gc`, after `purge`: it now does the retention GC that `purge` used to do (op checkpoints, brainstorm checkpoints, batch-retry audit files, volunteer events, decision receipts, applied captures, retrieval feedback), with the same retentions. `gbrain dream --json` reports those counts under `bookkeeping_gc` instead of `purge`, whose details keep only sources, pages and orphan clones; `--phase purge` no longer runs the GC." },
  { since: '0.60.715.0', id: 'autopilot_refusals_structured_gbra438', text: "`gbrain autopilot --install` refusals (a PGLite brain without --force, no repo path) now go through the agent error contract: codes `autopilot_pglite_daemon` and `autopilot_no_repo`, a why, a fix and `--json` output, instead of a bare line on stderr; PGLite and repo-less users are pointed to `gbrain maintain --status`." },
  { since: '0.60.715.0', id: 'cycle_skip_text_gbra438', text: "A dream cycle phase skipped for want of a checkout no longer says (postgres/remote engine), which was wrong on PGLite: the summary is now: requires a local brain directory; this brain has no on-disk checkout; pass --dir <path> to run filesystem phases. The reason code `no_brain_dir` is unchanged." },
  { since: '0.60.715.0', id: 'cycle_freshness_keyless_consent_gbra438', text: "On a brain with no chat or embedding key, the `cycle_freshness` doctor fix (`gbrain dream --source <id>`) now asks no paid consent (`consent: []`, so `next: run`), because no phase it runs can spend." },
  { since: '0.60.715.0', id: 'serve_idle_upkeep_gbra438', text: "An open `gbrain serve` (stdio or HTTP) now runs the free unattended upkeep (`gbrain maintain --unattended`: link and timeline extraction, stale-page checks, free repair lanes, bookkeeping GC, and on a keyed brain the capped embedding step) while it is idle, at most once every 24 hours per brain, in slices of about 3 seconds that stop when a tool call arrives. It never deletes a page. `maintenance.auto false` or `GBRAIN_SWEEP=0` turns it off; an autopilot brain is left to autopilot. The record it writes is `maintenance.last_run` with runner `serve`." },
  { since: '0.60.715.0', id: 'serve_http_idle_timer_gbra438', text: "HTTP `gbrain serve --http` now has an idle timer: it counts an MCP POST as foreground work and runs the idle upkeep only when no request is in flight, aborting the upkeep slice when one arrives. Before, only the stdio server had idle work." },
  { since: '0.60.715.0', id: 'init_upkeep_line_gbra438', text: "The first-run settings block printed by `gbrain init` and `gbrain setup <harness>` (and its `--json` decisions) now includes an `upkeep` decision when it shows other settings: upkeep runs while an agent has `gbrain serve` open and idle, on by default, turned off with `gbrain config set maintenance.auto false`. New commands: `gbrain maintain --schedule` (opt-in launchd, systemd or cron job every 6 hours, preview with `--dry-run`, asks consent) and `--unschedule`." },
  { since: '0.60.716.0', id: 'chronicle_events_trust_cap_9284', text: "Legacy Life Chronicle event pages (captured_via: life-chronicle:auto) are now capped at agent_written and at the tier of their depth page when gbrain trust claim-sources lifts a source, so they no longer read as your own notes; rows a claim already lifted change only when you run gbrain trust claim-sources --relower (preview with gbrain trust claim-sources --relower --dry-run first, and add --source <id> for a source whose claim has ended), and gbrain doctor counts them." },
  { since: '0.60.716.0', id: 'audit_secrets_escaped_encoded_8265', text: "The opt-in high-entropy assignment detector now also catches a credential whose key quote is escaped (`{\\\"password\\\":\\\"…\\\"}`, JSON inside a JSON string, with up to three backslashes) and one after a URL-encoded separator (`password%3D…`, `token%3A…`). The value stops before an escaped closing quote and, after an encoded separator, before the next `%26` parameter; a URL-encoded URL value is treated as a reference, not a secret. `gbrain doctor` asks once for a fresh `gbrain transcripts audit-secrets` run: it is read-only, makes no model or network call, and on a 5 MB synthetic transcript took about a third of a second. Transcripts imported from now on redact both shapes. Pages imported before are not rewritten; the audit lists the ones that hold such a line as affected." },
  { since: '0.60.717.0', id: 'holding_page_versions_gst2497', text: "A holding page (memory/unattributed, or a folder's <folder>/memory/unattributed) now keeps only its newest five saved versions, whatever their size, as large pages already did. `get_versions` and `gbrain revert` see only those five. Every fact row on the page is kept, the page itself still holds every row, and Git keeps every state of the page where the brain has a repository. An older holding page sheds its extra versions in batches of at most 100 on its next saves, so nothing runs on upgrade. Once a version is removed, an `as_of` read of the page reports incomplete history, and `gbrain repair unwithdrawn-facts` lists that page's candidates as ambiguous: restore them with `--include-ambiguous` and the hash of that preview. Nothing to run." },
  { since: '0.60.717.0', id: 'owner_room_marks_gst2639', text: "A harness can now declare the group chat an answer goes into (the X-Gbrain-Room header, request-level _meta.room, or a room tool argument once whoami shows features.room). The caller's read is unchanged; every page and fact in the answer is marked room_access with whether the people in that chat could have read it, and the room_above_level notice tells the agent to keep those items out of the reply. A call with no room is unaffected. With mcp.strict_params set to reject, every tool schema now also declares the optional room argument. See docs/guides/rooms.md." },
  { since: '0.60.718.0', id: 'managed_push_scan_every_publish_gst2650', text: "Every push gbrain makes is now scanned for secrets with no opt-out: `commitAndPush` no longer has an unscanned mode, so a push handed over from a busy publish lock is scanned too. Only the commits the remote lacks are read, and a missing remote-tracking branch is fetched first instead of scanning the whole history. In a managed root below the repository's top level, a commit changing that root's own `.gbrain-scan-allow` is held like one at the top level, and its path globs match paths relative to that root. A strict (canonical: git) source's commit whose files a Git clean filter changed is scanned instead of trusted, and so is one made before this release that is still unpushed; either is still pushed when the scan finds nothing. Git replace refs no longer change what a page-write commit holds. A false positive in an unpushed commit holds the push with `publish_secret_found` naming the file, line and rule, never the value: add its fingerprint to `.gbrain-scan-allow`, then run `gbrain sources writer retry-effects <source> --parked-pushes`, or the push fix `gbrain doctor` names." },
  { since: '0.60.718.0', id: 'strict_fallback_refusal_gst2635', text: "On a source whose pages are canonical in Git (`canonical: git`), a fact the Google loops extraction (or any writer that keeps a fallback entity, writeSingleFact) finds for an entity with no page that an exact page rule names is now refused `git_home_required` (reason `facts_lane`) before anything is stored, with a fix that creates the entity's page; before, it was stored in the database only, with no file in Git, or refused with a message naming memory/unattributed. When the access rules cannot be read the write refuses `access_policy_pending` (retry), and that refusal's message now names the entity, for `remember` too. The loops job still records the loop and logs the refusal code with the entity's page; nothing is stored for that fact. Facts stored the old way are not changed: `gbrain repair facts-home` lists them as `folder_restricted`. Sources that are not strict and brains with no Git repository are unchanged." },
  { since: '0.60.719.0', id: 'access_first_import_history_gst2638', text: "A folder-rule edit (gbrain access rule add, rm, revert or import) on a git-backed source that has no folder-rule revision yet now refuses before writing anything, with access_policy_history_unreadable, when its checkout is shallow or a partial clone missing the Git objects of its folder-rule history; it used to commit the file and leave the whole source reading as nobody. When you hit it, run git -C <source root> fetch --unshallow (for a partial clone, git -C <source root> log --first-parent -p HEAD -- .gbrain/access.yml, which fetches every version), then rerun the same gbrain access rule command; nothing was written, so the source keeps its current reads meanwhile. A first edit on a source with no folder-rule history no longer reads the whole source as nobody while it applies. An edit whose result state is invalid now exits 1 instead of 0. Unchanged: a plain gbrain sync of a shallow checkout whose commits already hold folder-rule history still fails closed as before, reading the whole source as nobody because the history cannot be replayed; recover the same way, git -C <source root> fetch --unshallow, then gbrain sync --source <id> --no-pull." },
  { since: '0.60.719.0', id: 'room_cli_think_writes_gst2639', text: "`--room <list>` now works on every gbrain operation command (`gbrain query \"plan\" --room alice-example,group:team-a`). The command prints what it always printed; the room only adds marks. With --json every item carries room_access and the document carries _meta.room, and a list answer becomes { results, _meta } only when --room is given. Without --json, stderr adds a [gbrain room: ...] summary. The local CLI marks the brain owner's view (gbrain access owner set) or the member --as names; with no owner every item is unknown (unbound). A trailing --room with no value marks every item unknown (invalid) with the degraded stamp and exits 0. A running gbrain serve that owns a PGLite brain marks delegated answers, and a thin client sends the room as _meta.room; an owner or host that predates room marks leaves every item unknown (not_supported). With a room declared, think answers are now marked at the strictest class of everything their synthesis retrieved (unknown when built partly from takes or with no recorded evidence), and put_page and remember mark the page or fact they wrote without a degraded stamp, where before they answered op_not_covered. Calls with no room are unchanged. Guide: docs/guides/rooms.md." },
  { since: '0.60.719.0', id: 'owner_turn_sends_templates_gst2656', text: "New installs get two changed templates. The access-policy template's group-chat rule now says a turn the owner sends, verified by sender identity, is done at the owner's scope exactly as in a private chat, written for the room, with truly private material offered in the owner's private chat and never a refusal; every other member is answered at the group's level, and a member saying the owner wants something is making their own ask. The agent template's red line on messaging third parties now says a send the principal asks for in their own verified message (or through a delegate the principal set up and the host authenticates) goes out as asked, in any chat and to any recipient, with no approval phrase and no draft-first step; the agent still never messages anyone as the principal on its own initiative, and a request another person quotes, forwards or relays is that person's. The money and deletion red lines are unchanged. Existing installs keep their own ACCESS_POLICY.md and AGENTS.md; to adopt the new wording, copy it from templates/ACCESS_POLICY.md.template and templates/bootstrap/template-repo/AGENTS.md." },
  { since: '0.60.720.0', id: 'storage_shelf_stored_object_type_8894', text: "The bundled `gbrain-base-v2` schema pack (the `init` default, also inherited by `company-brain`) is now version 1.6.0 and declares the `stored-object` page type the storage verbs stamp on every storage shelf card, so registering, adopting or importing a card no longer prints a `page_type_undeclared` notice, doctor `schema_pack_consistency` does not warn about the shelf, and `unify-types` never retypes cards to `note`. Existing pages keep their type; no data changes. The active pack identity reads `[email protected]+<hash>`." },
  { since: '0.60.721.0', id: 'derived_origin_carry_private_gst2689', text: "Deleting a page that keeps other pages private now writes a visibility: private label on each page that was private only because of it (a summary whose derived_from names it, an atom extracted from it, a synthesized concept built from such an atom), before the deleted page's row is removed. On a brain with Git the derived page's file gains that one label line. The label stays if you restore the deleted page later. If a label cannot be written, the purge keeps the deleted page soft-deleted and gbrain doctor reports it as derived_origin_parked with the page that blocks it; an explicit gbrain delete --purge then returns purge_held instead of purging." },
  { since: '0.60.722.0', id: 'owner_remote_private_writes_gst2091', text: "The brain owner's own remote agents can now change private pages. A credential bound to the brain owner (gbrain access owner set) that has write scope and speaks for itself (no audience, not an attested call, not a subagent job, no slug fence) may rewrite, edit, append to and relabel a page marked visibility: private that it already reads, through put_page, edit_page and append_page, and through put_pages and staged uploads (begin_page_upload and commit_page_upload), which write the same pages; before, these writes answered page_not_found. A put_page that leaves out visibility or readable_by keeps the stored ones, an empty visibility counts as left out, and a page private only through a privacy alias, a pinned question, a derived type or a private origin is saved as visibility: private (a pinned question keeps its marker) by any of these writes that states no visibility; the change is recorded under the owner's credential. Everyone else is refused exactly as before: other members, unbound tokens and OAuth clients, attested calls, the owner's credential asserting a shared room, the owner's credential without write scope, and any write to a page whose readable_by or folder rule leaves the owner out. delete_page on a private page, and any write to a soft-deleted private page, stays refused, and a credential fenced to slug prefixes, even after the write was submitted, gets no owner widening. An owner who does not want an agent to change private pages gives that agent a credential without write scope (gbrain auth create <name> --member <owner> --scopes read; without --scopes the token gets full access), or binds it to its own member instead of the owner." },
  { since: '0.60.722.0', id: 'guest_notes_gbra504', text: "New guest notes (GBRA-504): a brain can keep what people outside it say in a group chat with your agent, in a guest source that only a listed broker credential writes, once per note. Nothing changes until you run gbrain guests init: a brain without a guest source reads, writes and costs exactly as before, and no grant, privacy label or search scope changes on upgrade. With a guest source, every read that returns a guest note marks it as an outside guest's words (origin guest, trust tier external_untrusted, a guest object in JSON and a warning line in text), guest notes feed no facts, takes, timeline entries or links, and your own CLI cannot write there. You keep a note as your own page with gbrain guests promote <slug> (MCP promote_guest_note, owner only; anyone else is refused guest_promotion_owner_only), after which the broker can no longer delete it (guest_page_promoted). A guest writer can delete only the guest notes it saved itself. Your own tokens and OAuth clients read the guest source only once it is on their read list: gbrain guests grant-owner-clients previews that and --yes applies it, and gbrain doctor --only guest_source checks the whole setup." },
  { since: '0.60.723.0', id: 'access_rule_keeps_owner_gst2698', text: "gbrain access rule add now refuses a reader list that leaves out the brain owner when one is set (gbrain access owner), the same refusal gbrain repair visibility --readers already gives (readers_omit_owner), because such a rule closes the folder or page to the owner's own keys. Add the owner to --readers, or pass --allow-without-owner when the owner should not read it. A group that holds the owner does not count. Rules already in place are not changed, and a brain with no owner set behaves as before." },
  { since: '0.60.723.0', id: 'new_sources_join_default_search_gst2732', text: "A source added with no `--federated` or `--no-federated` choice is now federated (in default search, and readable by connections with no source grant) when the brain serves one person: `access.serves` reads one, `brain.audience` classifies personal and the client is not thin. Otherwise it stays unset as before, and `sources add` and `sync --source <id>` print the `source_not_in_default_search` notice with `gbrain sources federate <id>` as the fix (asking the user first on a shared brain). Existing sources are not changed. Adds from a remote MCP caller keep the old default." },
  { since: '0.60.723.0', id: 'plain_folder_sources_gst2732', text: "`gbrain sources add <id> --path <folder>` no longer needs `--force` for a plain folder outside any git repository: it registers as a plain directory (sync imports its files without Git, a removed file keeps its page). The `not_a_git_repo` refusal now applies only to a path inside a git repository with no committed, tracked content." },
  { since: '0.60.723.0', id: 'install_no_postinstall_gst2732', text: "gbrain ships no postinstall script, so a global `bun install -g` of the stable release no longer ends with Bun's \"Blocked 1 postinstall\" line and a clone's `bun install` no longer prints \"postinstall skipped\". Nothing it did is lost: every command already refuses on a Bun below the floor, `gbrain setup` applies a new brain's setup migrations, `gbrain upgrade` runs migrations in post-upgrade, and the first command on a brain applies pending schema migrations. New: when upgrade migrations are still pending (after reinstalling over an older brain with `bun install -g`), every command except apply-migrations, upgrade, post-upgrade, doctor, init, setup and serve prints a `migrations_pending` notice naming them, with `gbrain apply-migrations --yes` as the fix." },
  { since: '0.60.723.0', id: 'first_run_connects_then_reports_gst2732', text: "`gbrain init` no longer asks the user to approve connecting gbrain to their agent. The first-run bundle (`first_run_decisions`) now lists the settings in effect and how to change them, with no \"Reply 'defaults'\" question: search mode as applied, automatic saving (`writeback`) shown as in effect `off` with `salient` recommended (it was shown as default `salient` while off), skills and upkeep. Connecting the agent moved out of the bundle into its own `harness_wiring` notice (kind info, actor agent, no consent), because it is an install step. The install docs (AGENTS.md step 3, INSTALL_FOR_AGENTS.md Step 3.5) drop the STOP for every harness: connect first, then relay the settings and the cost matrix in the reply that reports the install. Nothing paid turns on from these settings without a key the user supplied." },
  { since: '0.60.723.0', id: 'resynthesis_hold_6753', text: "gbrain dream no longer re-synthesizes a transcript that keeps growing on every pass. A transcript synthesized within dream.synthesize.cooldown_hours (12 by default) is held until that window passes, and the run reports how many grown transcripts it held (resynthesis_cooldown). A busy transcript is now re-synthesized at most twice a day instead of up to 24 times; the daily spend ceiling is unchanged. An explicit gbrain dream --input or --date run is never held. To re-synthesize sooner, lower dream.synthesize.cooldown_hours or pass --input." },
  { since: '0.60.723.0', id: 'skill_resolver_gate_default_gst2704', text: "The skill resolver now stays quiet when no skill fits. Before, it showed a skills block on almost every message, including ones that need no skill, because some skill always shared a word with the message. It now leaves the block out when its best match is weak (skills.resolver.top_gate, default 0.6), and a skill you name in the message is still suggested. On a 351-skill public test catalog this cut blocks on no-skill requests from 100% to 11.5% and kept the right skill in the block for 174 of 228 requests that needed one, against 176 before. To tune it, run gbrain config set skills.resolver.top_gate <number>; set it to 0 to get the old behavior back. OpenClaw and Pi pick up the setting on the next gbrain setup <harness> --skill-loading resolve." },
  { since: '0.60.723.0', id: 'thin_client_serve_stdio_bridge_8543', text: "On a thin client (gbrain init --mcp-only), plain `gbrain serve` no longer refuses: it is now a stdio MCP server that relays every call to the brain host with the stored OAuth client's grant, opens no local database and adds no access. A harness entry that runs `gbrain serve` on a thin client now connects to the remote brain instead of exiting with requires_local_engine. `gbrain serve --http`, `--access` and the other host flags still refuse there. `gbrain doctor` on a read or read+write client now reports the missing admin scope as expected (ok) instead of a warning that suggested re-registering with admin." },
  { since: '0.60.723.0', id: 'guest_sources_scoped_role_fail_closed_9354', text: "Brains whose gbrain process connects to Postgres as a scoped row-level-security role now need that role to read the guest_sources table. Before, such a role read it as empty, so guest-source checks passed every write as if no source were a guest source. Now a role that row-level security keeps from reading guest_sources is refused with writer_coordinator_required (unreadable_state, state guest_sources) on page, fact, take and timeline writes, because it cannot tell a guest source from an ordinary one. The table owner, a role that bypasses row-level security, and PGLite brains are unaffected. To keep writing, give the scoped writer the SELECT policy on guest_sources from the maintainer recipe in docs/ENGINES.md (derived-state maintainers)." },
  { since: '0.60.724.0', id: 'commit_push_symlinked_source_gst2767', text: "gbrain git commit-push now resolves a named path through any symlinked folder to its real place in the checkout, so a path spelled through a source path that links into the repository is committed instead of refused as outside the checkout, and a leftover .git folder or file that git itself ignores no longer makes a folder count as skipped. Each skipped path carries why next to reason in the JSON detail, and the push log gets a [push] SKIPPED, NEEDS ATTENTION line for it. gbrain embed <slug> refuses a flag it does not take with unknown_flag (exit 2) before asking for spend approval, instead of reading the next argument as a page. gbrain sources writer git-durability --enable returns agents.commit_argv, the exact gbrain git commit-push command, whenever the durability file it owns is not committed, including an untracked copy an earlier run left. A named folder whose tracked files are staged for removal while still on disk is refused as staged_for_removal, naming --untrack and git restore --staged, instead of as commit_prestaged_paths, and --dry-run reports the same skipped paths and reasons the real run would. A source folder whose .git links to the repository's own .git now commits at its real place in the repository instead of in a copy at the top. gbrain sync no longer creates a repository in a brain folder that sits inside another repository it cannot read." },
  { since: '0.60.724.0', id: 'transcript_secret_rules_gst2768', text: "Imported conversation pages now also redact cookie values (`Cookie:` and `Set-Cookie:` headers, curl `-b`/`--cookie`; names kept), a one-line `.netrc` password, and a value that arrives alone on the line after a key or token label or in the message after any credential label (`password:`, then the password). These rules run only for transcripts; the `sources push` gate and the compiled-context scan are unchanged. Pages imported earlier are not rewritten: doctor's `transcript_secret_exposure` asks for a fresh `gbrain transcripts audit-secrets`, which now lists pages carrying cookie values, `.netrc` passwords and a key label with its value on the next line. It cannot see a value that was sent as its own message, because a stored page no longer marks where one message ends. Three cases still reach the page verbatim, as they do today: a `.netrc` entry written over several lines (`machine`, `login` and `password` each on its own line), a `-b` cookie on its own continued line of a multi-line curl command (what Chrome's \"Copy as cURL\" produces), and a quoted cookie value inside escaped JSON (`sid=\\\"…\\\"`)." },
  { since: '0.60.725.0', id: 'doctor_git_gap_unknown_gbra541', text: "`gbrain doctor` now reads the 800 most recently changed pages of each source in db_ahead_of_git and strict_facts_outside_git, and says how far back it looked; `gbrain sources git-gap <source-id>` still reads every page. A census that runs out of its time budget or cannot run, and in strict_facts_outside_git a fenced fact on a page older than that window, now report warn with health unknown instead of ok, and git_index_lag does the same when it cannot read the lag. An agent that pages on `doctor --fail-on warn` may see these checks warn where they used to pass; run `gbrain sources git-gap <source-id>` for the full count." },
  { since: '0.60.725.0', id: 'setup_codex_backups_gst2779', text: "gbrain setup codex and gbrain setup codex --remove now copy each config.toml or hooks.json they change to a .bak.<timestamp> file beside it before writing, and print the backup path. Nothing else about the setup changes; delete the backups once you no longer need them." },
  { since: '0.60.725.0', id: 'keyless_any_word_fill_gst2762', text: "On a brain with no embedding provider (the default keyless install), search and query now add pages that hold only some of the question's words when the first page of results comes back shorter than the limit. Every row returned before keeps its place, text and score, and the added pages follow them. The added rows pass the same read policy, redirect, superseded-page, evidence and injection checks as any other row, carry keyword_fill: true, and --explain-target says they matched only some of the words. When adding them would change another row, or a check that is on was skipped for them, they are left out; a row from a source on decide.egress.deny_sources is treated like any other row from that source, which today means it is returned and counted as judged. Brains with embeddings search exactly as before, and there is no setting to change." },
  { since: '0.60.725.0', id: 'launcher_records_bun_gst2784', text: "gbrain's hook launcher (<config dir>/hook-launcher/gbrain-hook), which every MCP server entry and hook gbrain setup writes starts gbrain through, now records the Bun that installed gbrain and puts it first on PATH. Before, a Codex session started without bun on its PATH (the desktop app, a launcher, a terminal opened before the shell profile changed) could not start gbrain serve or its hooks, and showed no tools. gbrain post-upgrade rewrites the launcher in place, and gbrain setup codex does the same; no config.toml, hooks.json or trust entry changes. gbrain doctor reports a launcher that records no Bun, or a Bun that is gone. The compiled gbrain binary needs no Bun and its launcher does not change." },
  { since: '0.60.725.0', id: 'notifier_sync_disabled_gst2515', text: "The commit notifier now honours a source's sync setting: a source with sync turned off (config.syncEnabled=false) is no longer synced when HEAD moves, and a retry it owed is dropped. An explicit sync request (a sync trigger or webhook) still runs once; if that run fails, the notifier waits for a new request instead of retrying it. To have commits sync that source again, turn sync back on with gbrain sources set-sync <id> on." },
  { since: '0.60.726.0', id: 'transcript_archive_default_gst2768', text: "On a personal brain the conversation archive is now on: the maintenance pass (the idle upkeep of an agent's gbrain serve, gbrain maintain --unattended or its schedule, and autopilot) writes one redacted page per conversation per local day from your Claude Code, Codex, OpenClaw, Hermes and Grok sessions, plus a day index, into the conversations source, then fills in older days a capped run at a time. To turn it off, run gbrain transcripts archive off (pages already written stay). A shared team brain is only offered the archive and stays off until its owner runs gbrain transcripts archive on. On a keyless brain nothing leaves this machine. With an embedding key, the archived text of new days is sent to that provider to be embedded, like any new page (unattended upkeep caps that at maintenance.embed_daily_usd; autopilot and a managed brain's write coordinator embed new pages as they arrive); older history is written keyword-only and its embedding waits until you see the price with gbrain embed --held --dry-run and approve it. No facts are extracted and no Dream synthesis runs on archive pages. gbrain doctor --only transcript_archive_freshness says whether the archive is keeping up." },
  { since: '0.60.731.0', id: 'stable_important_three_classes_gst2818', text: "The stable channel now moves within a day only for a security fix, a data-loss fix or a fix for a regression in a release that is already on stable. Everything else, a fix that only unblocks one setup included, waits for the weekly move; if you need such a fix sooner, install its release by tag (docs/STABILITY.md, \"Pinning a version\")." },
  { since: '0.60.732.0', id: 'owner_purge_tombstones_survive_9469', kind: 'fix', text: "A page the owner purged while a derived page kept it private now gets its purge records whichever later run removes it (an automatic expiry purge, or a run after a failed or deferred one), on repo brains and on brains without a repository, so a restore no longer brings it back. Restoring a backup now removes the same rows a live page purge removes (write requests, files, derived generation items and their effects), not only the page itself, and stops with purge_replay_incomplete, naming the purge it could not replay, instead of reporting success on a partial sweep. A new doctor warning, purge_mirror, says when recent purges are missing from this machine's purge mirror, so restoring an older backup would not replay them (#9469)." },
  { since: '0.60.733.0', id: 'keyword_skip_rerun_7082', kind: 'fix', text: "On Postgres, a hybrid keyword statement that hit the keyword statement timeout is still skipped by later identical searches in the same serving process (`keyword_arm_failed: skipped_after_timeout`), but the skip no longer always lasts the whole `search.keyword_timeout_negative_cache_seconds` (default 600 s, unchanged, now the longest skip). The serve re-runs the statement once in the background 30 s after the timeout, then after 60 s, 120 s and so on while it keeps failing, with the same scope and the same bound, only when the pool has no waiting query and keeps a connection free for other queries, and one at a time per brain. Its rows are thrown away and it is not recorded as a search. The first re-run that answers ends the skip, so a timeout on a cold cache stops costing keyword results within about a minute of the cache warming. One-shot CLI commands are unchanged." },
  { since: '0.60.733.0', id: 'migration_host_work_owed', kind: 'fix', text: "A migration that stopped three or more runs in a row on a conflict in one or more sources, and recorded that host work is still owed (today only v0.53.0, the shared-skills content migration), is no longer called history once a newer migration completes. gbrain apply-migrations --list, the notice other commands and gbrain serve print at startup, and gbrain doctor (as a warning) now all say the work is still owed and that it does not clear without a person, and they all name the same first step, gbrain apply-migrations --migration 0.53.0 --dry-run --json, which lists each source's conflict and changes nothing. They give the order that works: after the user reviews each conflict, gbrain apply-migrations --force-retry 0.53.0 clears the wedge, then the command the inspect output names for that source (or gbrain apply-migrations --yes) settles it. That inspect command used to refuse a wedged version as not registered; it now works. Running a wedged migration by name, for example the accept command a conflict message names, still exits 2 but now says the version is wedged and names those steps, instead of calling it not registered. Nothing runs the migration again by itself, and the exit status of apply-migrations, post-upgrade and upgrade does not change." },
  { since: '0.60.733.0', id: 'commit_paths_unmerged', kind: 'fix', text: "gbrain git commit-push now refuses, before staging anything, when a file you name still has unresolved merge conflicts in the index, for example after a merge, rebase or stash pop that stopped on a conflict. It used to stage the file and commit it with its conflict markers as if it were resolved, and on an ordinary checkout push it. The refusal is commit_paths_unmerged (exit 1): nothing is staged or committed, the file stays unmerged, and the message names each file. Resolve each one with the user (edit out the markers, keeping the changes from both sides that belong in the file, since one side may be a write gbrain made), mark it resolved with git add -- <file>, then rerun the commit. The same check covers every gbrain write that commits named files, such as lint --fix and connector writes." },
  { since: '0.60.733.0', id: 'git_large_index_listing', kind: 'fix', text: "gbrain git commit-push no longer fails on a large checkout with git_unavailable \"git ls-files -v failed: exit -1\". Its git calls were limited to 1 MiB of output, so naming a folder whose index listing passed that (a few thousand tracked files with long names, more on a checkout of hundreds of thousands) killed git; they now read git's whole output. A git command that is stopped before it finishes (its time limit, or a signal such as the out-of-memory killer) now reports git_command_stopped with its reason (timeout or signal) instead of git_unavailable, still exit 1, and gbrain never uses its partial output as the answer. A push, fetch or remote listing stopped after the local commit still reports push_unconfirmed (exit 4)." },
  { since: '0.60.733.0', id: 'atom_retirement_keeps_tier_9456', kind: 'fix', text: "An atom a re-extraction retires now keeps the trust tier and write origin its extraction gave it, and an atom a later extraction produces again comes back at that tier. The retirement used to store the atom as unknown with no origin, so a revived atom stayed unknown. The same holds for every page a derived writer retires (chronicle events, synthesis outputs, gbrain repair stale-atoms). Atoms retired before this release keep the tier they were stored with." },
  { since: '0.60.733.0', id: 'provider_response_unparseable_9466', kind: 'fix', text: "A model provider that answers with a success status and a body that is not one JSON document (a route that streams when a request omits stream is the common cause) now fails with the non-retryable code provider_response_unparseable instead of a transient error. A facts job that hits it ends on its first attempt instead of retrying the same paid call, gbrain facts retry-dead does not resubmit it, and its recorded error reads cause=AIConfigError provider_response_unparseable. No response text is kept. Fix the route, for example with gbrain config set provider_chat_options.<provider>:<model> '{\"stream\": false}', then retry the job." },
  { since: '0.60.733.0', id: 'sync_freshness_content_directory_9471', kind: 'fix', text: "gbrain doctor's sync_freshness no longer fails a source whose folder sits inside gbrain's own content directory (for example one added beside the default source with gbrain sources add) and no longer tells you to run gbrain sync for it, a command that refuses such a source with sync_not_applicable. It counts the source as a content directory where sync does not apply and names gbrain import <dir> --source <id> for adding files instead." },
  { since: '0.60.734.0', id: 'repair_write_gate_markers_9511', kind: 'breaking', text: "Managed file repairs (gbrain repair rows-behind, file-drift, frontmatter, slug-conflicts, fence repair and local-edit adoption) now run the write gate a sync of the same file runs, with the file's path, so they keep a page's instruction_like flag or quarantine instead of stripping it, and an owner allow rule scoped to that path holds during the repair. Under write_gate.external_mode=reject, a repair of external instruction-like content now refuses with write_gate_rejected, the way sync already holds that file, instead of publishing it. If a repair refuses this way and you trust the file, allow it with gbrain trust allow --source <id> --uri-prefix <path>, or edit the file, then preview and apply the repair again; nothing was written." },
  { since: '0.60.734.0', id: 'relink_keeps_fact_instant_9260', kind: 'fix', text: "gbrain facts relink no longer changes a linked fact's trust tier or write origin, and no longer rounds its valid_from and valid_until to the second; the entity page's facts table keeps the stored instant to the millisecond. A fact whose stored instant is finer than a millisecond (only raw SQL or a database clock default writes one) is now left unlinked and counted claim_unfenceable instead of being linked with rounded dates. Facts linked before this release keep the dates they have." },
  { since: '0.60.734.0', id: 'consolidate_restatement_stays_open', kind: 'fix', text: "The consolidate upkeep step now ends a fact only at the next fact in its cluster that says something else, by claim text and typed value. A value restated on a later date stays active from the date it was first stated, and every restated copy ends together when the value changes. Before, each copy ended at the next copy's date, so the date a value was first stated was no longer on any active row. Facts consolidated before this release keep the dates they have." },
  { since: '0.60.734.0', id: 'open_facts_repair_8194', kind: 'add', text: "New command: gbrain repair open-facts opens facts that were saved private before facts.default_visibility became world, so remote callers that are not the brain owner can recall them. Nothing changes until the operator runs it on the brain host: preview with gbrain repair open-facts --source <id> --created-before <ISO-8601>, then apply exactly that preview with --apply --expect <hash>. Facts on private, member or quarantined pages, withdrawn, contested, expired or superseded facts stay private and are counted by reason. Each change is recorded in ~/.gbrain/repair/open-facts/, and --undo <ledger> makes the opened facts private again (what was already read stays read)." },
  { since: '0.60.734.0', id: 'remember_restated_private_hold_2875', kind: 'fix', text: "A remote remember of the exact claim of a private fact on the same entity that is more trusted than the caller is now stored private with a trust proposal, instead of as a world copy other connected clients could read. The operator lists it with gbrain trust review and makes it world with gbrain trust confirm tp<N>. Other remembers are unchanged." },
  { since: '0.60.734.0', id: 'setup_turn_hook_unmarked_9505', kind: 'fix', text: "gbrain setup claude-code no longer exits 1 with turn_hook_not_loaded on a re-run, and doctor's harness_wiring no longer warns that the per-turn hook is missing, when Claude Code has rewritten ~/.claude/settings.json and dropped the _gbrain key from gbrain's hook entries. The check now recognises a hook entry that gbrain setup wrote (its setup receipt owns the entry) with or without that key. Nothing to do after upgrading; if you saw the warning, your hook was already working." },
  { since: '0.60.734.0', id: 'git_reconcile_stopped_retryable', kind: 'fix', text: "gbrain sources git-reconcile now reports a source whose commit-push stopped with git_command_stopped because a git command ran past its time limit or was killed from outside as failed and retryable, exit 4, instead of needs_user, exit 1. A script that retries on exit 4 now retries it. A git command stopped by its output limit, or one that crashed (SIGSEGV, SIGBUS, SIGILL, SIGFPE or SIGABRT), still reports needs_user, exit 1, because a retry stops the same way." },
  { since: '0.60.734.0', id: 'frontmatter_validate_every_path', kind: 'fix', text: "gbrain frontmatter validate now checks every path it is given. With several paths it used to check only the last one, so a bad file named earlier could pass with exit 0. It now checks all of them, exits 1 if any fails, and refuses before checking anything when a path does not exist. With --json and more than one path, the output adds a targets list." },
  { since: '0.60.734.0', id: 'serve_http_refused_not_activity_9484', kind: 'fix', text: "gbrain serve --http no longer counts a request refused for a missing or wrong bearer token as activity. Idle upkeep waits for a quiet interval, and requests anyone could send without a token used to reset that interval, so upkeep might never run. Authenticated requests, including pings, still count as before." },
  { since: '0.60.734.0', id: 'update_cache_future_stamp_8795', kind: 'fix', text: "The update check no longer trusts a saved answer stamped in the future. After a computer's clock moved backwards, the saved answer could stay \"fresh\" and block every refresh, which hid newer releases and a withdrawn-release notice. A saved answer more than 5 minutes ahead of the clock is now stale and is replaced on the next check." },
  { since: '0.60.734.0', id: 'title_arm_candidate_cap_7082', kind: 'fix', text: "On a local search (the CLI and gbrain serve's local callers), the title step now ranks at most 5,000 of the pages that match the query in their title or timeline: the 5,000 with the lowest page ids, so the same pages on every call for the same data. Before, a very common word made it rank every matching page and read every matching timeline until the keyword time limit. A query that matches 5,000 pages or fewer gets the same result as before, timeline-only matches included. When the cut applies, the pages whose title holds the words come first (the rows remote callers get), then the other matching pages among the 5,000 kept, and hybrid search reports `keyword_candidates_incomplete`. A query of several words is cut on the pages that match the whole query, not word by word. Remote callers' results do not change." },
  { since: '0.60.734.0', id: 'guard_ledgers_fail_closed_7632', kind: 'fix', text: "On Postgres, a database write role that neither owns gbrain's purge and withdrawal ledgers (`fact_purges`, `fact_withdrawals`, `take_purges`, `page_purges`, `page_segment_derivation_purges`, `page_segment_derivation_purge_pages`) nor bypasses row-level security, and holds no policy that lets it read one, now gets a refusal on the writes that ledger's guard checks, where before the guard read the ledger as empty and let the write through: a purged claim, take, page or derivation could be stored again and a withdrawn fact saved active. The refusal is `writer_coordinator_required: writer state is unreadable to this database role` (P0001, `unreadable_state`); its hint names the table and the policy to add, and docs/ENGINES.md (\"Purge and withdrawal guards\") lists the policies a scoped write role needs. The guards stay SECURITY INVOKER: no trigger runs with different rights. The owner, a role that bypasses RLS, a ledger without row-level security and PGLite are unaffected. Where the role running migrations does not own a guard function, the upgrade leaves that function, names it on stderr and finishes; the next migration run by a role that owns it fixes it (#7632, #7659)." },
  { since: '0.60.734.0', id: 'purged_change_reason_8635', kind: 'fix', text: "A sync that read a page's change reason from a gbrain-reason commit trailer, then saved the page after a fact purge removed that text, used to store the purged text in the page's history as the reason for the change. The save now checks for the purge when it writes the history row and stores no reason instead; the page content still imports, and other files' reasons from the same commit are kept. Nothing to do. Reasons already stored before this release are not changed." },
  { since: '0.60.734.0', id: 'mirror_compare_reads_file_gst2843', kind: 'fix', text: "On a read-only mirror source, gbrain repair file-drift --held without --prefer now compares each held page with its file. A page that differs from its file reads prefer_file or needs_human with its evidence (what differs and which side is newer), and one that matches reads release_hold. Only a page whose file is gone reads no_drift with database_only. Before, every held page on a mirror read no_drift with database_only, whether or not it matched its file. Every compared page in details.pages now carries an evidence field, null when nothing was read. The comparison still writes nothing, and sync holds the same pages as before." },
  { since: '0.60.734.0', id: 'held_compare_complete_window_gst2843', kind: 'fix', text: "A gbrain repair file-drift --held dry run (a comparison, or a --prefer preview) now reports complete: false while held pages remain past its window, and details.window.next_command names the command for the next window. Before, complete was true after every window, even with thousands of held pages left. Applies keep the old meaning: every item of the approved window was attempted." },
  { since: '0.60.734.0', id: 'hold_by_code_counts_all_gst2843', kind: 'fix', text: "gbrain sources status --json now counts git_holds.by_code over every hold of the source. Before, the counts came only from the held files the listing read (at most 500), so a source with more holds under-counted each code. A code with no held file in the listing has no example. If the per-code count cannot be read, by_code falls back to the listed files and by_code_complete is false." },
  { since: '0.60.734.0', id: 'fact_rows_observed_date_gbra574', kind: 'fix', text: "Saved facts in query results now say when they were said. The facts block (on by default for a query with a token budget), the temporal fact reserve, the facts arm and recall's date headers fill the observed date in their [observed ...; valid ...] header from the page the fact was taken from, read under the caller's own page access, so a page the caller may not read dates nothing. If that read fails the header shows observed unknown and the response reports the degraded stage fact_observed_date_unavailable (recall: facts_degraded reason fact_observed_date_unavailable). Copies of one claim take one row in the facts block, dated as first stated and followed by (stated N times, last DATE); facts that differ by even one word keep their own rows. Question ranking of saved facts now matches words on their stems, with a word matched only through its stem ranking a little below an exact match (a question naming Roger puts a Roger fact above a Rogers fact), and dates, years and auxiliary verbs such as had or been no longer count toward the match, so a question phrased as of a date admits the facts it names and a fact sharing only a year with the question is no longer admitted. A fact about another person who shares the named person's surname can still be admitted when it also shares a verb with the question; its row names that person." },
  { since: '0.60.734.0', id: 'superseded_fact_valid_until_gbra574', kind: 'fix', text: "When a newer fact replaces an older one, every writer now ends the older fact's validity by one rule. It ends on the newer fact's valid_from when that date falls after the older fact began and before the older fact's own end (or now, if it had none); otherwise it ends at its own earlier end or now, and never before its own valid_from (a fact dated in the future ends where it begins). Per writer: remember with replaces (managed or not) and the engine supersede path used to leave the older fact open-ended when the newer fact was backdated, and now end it at the time of the write; the unmanaged remember that strikes the row in a page's facts table used to end it on today's date and now ends it at the newer fact's valid_from, which for remember is the time of the write; an accepted gbrain decide proposal used to end it at the time of acceptance and now ends it on the newer fact's valid_from when that falls inside the older fact's window; expireFact takes an optional successor date and applies the same rule. Extraction already used the rule and only gains the backdated case. A backdated replacement is one dated on or before the day the older fact began. For one of those, the older fact's end date is the day gbrain learned of the replacement (the time of the write), not a date taken from the source, unless the older fact already had an earlier end, which it keeps. Only future writes change. No stored row is rewritten, and forgetting or withdrawing a fact works exactly as before." },
  { since: '0.60.735.0', id: 'archive_rescope_on_shared_9563', kind: 'fix', text: "Conversation archive pages written while a brain was personal are now kept to the owner as soon as a command makes the brain shared: gbrain access member add and member enable (before the new member is added, enabled or bound to a token, so its credentials never read those pages), gbrain config set brain.audience shared and gbrain access owner set. Each prints one line on stderr per archive source saying the pages are kept to the owner or why they still wait. If the re-scope fails, member add and member enable change nothing and exit non-zero. Before, every member could read those pages until the next archive run." },
  { since: '0.60.735.0', id: 'forward_fyi_no_loop_gst2899', kind: 'fix', text: "A forwarded email whose own note asks nothing (\"FYI, see below.\") no longer opens a waiting-on-them loop just because the forwarded message contains a question. Since #8941 a forward keeps its whole body, and the loop detector read a question mark anywhere in it as your ask; it now reads only the note above the forward separator (Gmail's \"Forwarded message\" line or Apple Mail's \"Begin forwarded message:\"). The same rule applies to mail sent to you, so your \"Thanks!\" to someone's FYI forward counts as the reply again. A forward whose note does ask (\"Can you take this one?\") still opens a loop, and forwards still keep their full content in the brain. A loop that opened this way before the upgrade stays open until the other person replies or you close it yourself with gbrain loops drop <id> (gbrain waiting lists it)." },
  { since: '0.60.735.0', id: 'title_retry_reads_timelines_gst2899', kind: 'fix', text: "Keyword search finds the people behind a reworded relationship question again. When no page holds every word of a question, the title step retries with any word; since v0.60.338.0 (#7135) that retry read page titles only, so a question that names a company in words its people's pages don't use (\"Who is on the payroll at Acme?\") lost the people whose timeline names the company. For a local caller the retry now reads titles and timelines while at most 5,000 pages match the question's words, and titles only past that, so a date or a very common word in a question still doesn't pull every dated timeline into ranking. Remote MCP callers still match titles only. Results for such questions can change order, and on a very large brain the retry adds one bounded statement (0.03 to 0.14 s measured at 1,000,000 pages)." },
  { since: '0.60.735.0', id: 'open_facts_lapsed_timeline_8194', kind: 'fix', text: "gbrain repair open-facts now leaves a fact private when its valid_until date has passed, and counts it as lapsed in the preview. It also opens a fenced fact whose ## Facts table sits below the timeline sentinel; before, such a fact was always reported fact_left_private. The preview now warns that a fact saved private on purpose before the cut looks the same as a legacy one, and that --ids-file narrows the set." },
  { since: '0.60.735.0', id: 'date_only_since_utc_9533', kind: 'fix', text: "A date-only since now starts at UTC midnight on search, query and image query, the way a date-only until already ends at UTC midnight. A brain whose database timezone isn't UTC can gain or lose rows dated within that offset of midnight. On a UTC database nothing changes, and a since given as a timestamp or a relative duration is read as before." },
  { since: '0.60.735.0', id: 'connectors_sync_managed_brain_9124', kind: 'fix', text: "gbrain connectors sync <provider> run in the foreground now imports chat history on a brain whose writes go through the writer: it submits each imported page through the CLI's own write context, the way gbrain transcripts ingest already does. Before, the import was refused on such a brain and no conversations landed. If you saw that refusal, run gbrain connectors sync again in the foreground. A --background or scheduled sync and the connector_sync operation are unchanged and still refused there." },
  { since: '0.60.735.0', id: 'gmail_html_plain_body_8937', kind: 'fix', text: "A Gmail message part labelled text/plain whose content is really an HTML document (it starts with a doctype, html or head tag) is now stripped to readable text, the way an HTML part is. Before, the page stored the raw tags and CSS as the message body. Pages already imported are not rewritten." },
  { since: '0.60.735.0', id: 'captured_facts_codex_sessions_9554', kind: 'fix', text: "gbrain repair captured-facts now recognises facts captured from Codex sessions: it reads the session ids from the rollout file names in the live and archived Codex session folders, so those facts count as not suspect instead of unclassifiable. The preview's counts change on brains that capture from Codex; nothing is deleted or changed by the classification itself." },
  { since: '0.60.735.0', id: 'doctor_only_engine_free_9527', kind: 'fix', text: "gbrain doctor --only <check> on a check that needs no database (for example skill_resolver) now reports \"No finding\" at info level when the check has nothing to say, with no connection row. Before, it warned that the database checks stopped early and pointed at a connection that was never tried. A connection that really failed still reports the stop and keeps its connection row." },
  { since: '0.60.735.0', id: 'private_facts_grant_8194', kind: 'add', text: "Access tokens and OAuth clients have a new private-facts grant, `none` for every existing and new token and client, so remote fact reads stay world-only until the brain host opts a connection in: `gbrain auth rescope --token <name> --private-facts granted-sources` (or `--client <id>`) means this key will read every private fact in the sources its grant lists, including facts saved private on purpose, without rewriting any fact. A source opens only when the grant lists it by id: a token with no source grant, a source federated before or after the grant was written and a request's `source_ids` never add one. A fact held on, provenanced from or about a private, `readable_by`, folder-ruled, quarantined or member page stays hidden, and so does a fact with no page to check (no holding page, or a transcript lane such as the conversation archive). `context_pack`, `delta`, writes and audience or attested reads stay world-only. `--private-facts none` turns it off on the next request. No MCP operation or admin HTTP route can set it. `gbrain auth list` and `gbrain auth clients` show it." },
  { since: '0.60.735.0', id: 'migration_wedge_notice_history', kind: 'fix', text: "Ordinary commands (remember, recall, config get and every command except apply-migrations, post-upgrade, upgrade, doctor, init and setup) no longer print a \"wedged\" migrations_pending notice, with a request to ask the user for a forced retry, for an upgrade migration that stopped three or more runs in a row once a newer migration has completed since. apply-migrations already treats such a wedge as history; since v0.60.725.0 the notice did not, so a brain with three old partial rows for v0.53.0 printed it on every call. A wedge with no newer migration past it still gets the notice. The v0.53.0 shared-skills migration's source conflicts stay visible where an operator looks: gbrain doctor (as a warning, when connected), gbrain apply-migrations --dry-run and --yes, and post-upgrade name each source in conflict with a code and its next step, read from the migration's read-only preview, and none of them advises --force-retry. A new code, shared_skills_unmanifested, marks a source whose skills/ folder holds skills with no skillpack.json declaring them: declare the ones to share in a skillpack.json at the source's root, or keep the source out of shared-skills adoption with gbrain sources shared-skills <id> off. Doctor stops warning once the preview finds no source in conflict. A named run of a wedged v0.53.0 still refuses, now with the read-only preview as its fix instead of a forced retry." },
  { since: '0.60.735.0', id: 'guard_ledger_checks_gst2885', kind: 'add', text: "New doctor check `guard_ledger_checks` (Postgres only). It fails when a purge or withdrawal guard still lacks its ledger check, which happens when another role owned the guard at the v318 upgrade. It names the owning role and the fix. A migration run now prints a `guards:` line when it cannot re-create a guard for a reason other than another role owning it, where it used to stay silent. PGLite and brains whose guards are current see no change." },
  { since: '0.60.735.0', id: 'purged_change_reasons_repair_gst2886', kind: 'add', text: "New command gbrain repair purged-change-reasons. If you purged a fact before upgrading, a page's history could still show a change reason quoting it (#8635). Run gbrain repair purged-change-reasons on the brain host to see how many such reasons this brain holds; nothing runs it for you. If it finds any, the preview prints the apply command, which sets exactly those reasons to [purged] after you agree. Pages, files and Git history are not changed." },
  { since: '0.60.735.0', id: 'mirror_compare_names_writable_route_gst2869', kind: 'fix', text: "On a read-only mirror source, gbrain repair file-drift --held without --prefer no longer names a --prefer file (or --prefer database) preview for a page that differs from its file or a held deleted page whose file differs, in the page's why or in next_actions. Those previews read every mirror page as database-only and found nothing. The comparison keeps each page's verdict and evidence and says the page stays held until the user makes the source writable again with gbrain sources mirror-writable <id>." },
  { since: '0.60.735.0', id: 'rehold_retry_not_progress_gst2869', kind: 'fix', text: "A stopped sync pass no longer counts as progress when the only holds it rewrote were re-checked because gbrain sync unblock or gbrain sources retry-held asked and kept their code and file bytes (the hold is now marked retry_only; a retry that changed either restarts the hold and still counts once), or when the rewrite brought a transient hold (preparation_stalled, write_interrupted, or a page write that failed while frozen) to its attempt cap. Before, such a re-hold reset the abandoned-pass count once per retry round, so a source could stay pass_interrupted instead of reaching pass_abandoned." },
  { since: '0.60.735.0', id: 'sync_sigterm_recorded_gst2869', kind: 'fix', text: "gbrain sync stopped by SIGTERM or SIGHUP during a managed pass (an outer timeout, a supervisor stop, a closed terminal) now records the stop before it exits. The pass ends resumable with stop reason terminated, the drain stops terminated, gbrain sync status reads pass_terminated with the plain sync as its next step, and the run exits 143 (129 for SIGHUP). Before, the row was left open and status read pass_interrupted. A pass stopped this way that committed nothing still counts toward pass_abandoned, as a killed pass did. A second signal, or a run still saving or printing its result 3 seconds after the handler starts, exits as before. On PGLite the handler can start tens of seconds after the signal, as it already did before this change, so a supervisor that kills the process sooner leaves the pass open as before: it reads pass_interrupted and the plain sync resumes it. Ctrl-C and a sync job inside jobs work are unchanged." },
  { since: '0.60.735.0', id: 'facts_block_history_gbra574', kind: 'add', text: "When a query asks about the past, the facts block now shows the named person's or company's earlier values too. A question with a history word (before, earlier, previously, first, used to, in order and similar) or a date that has already passed, about one entity the brain has a page for, also pulls that entity's ended facts: facts a newer fact replaced, and facts whose valid_until has passed. Each keeps its own dates in its header, for example [observed 2025-01-16; valid 2025-01-16 to 2025-03-02], inside the block's usual share of the token budget, oldest first beside the current facts. A forgotten or withdrawn fact never appears, nor one from a page that was deleted and purged, and a remote caller sees only the world-visible facts it could already read. A question without such a cue gets exactly what it got before." },
  { since: '0.60.735.0', id: 'facts_block_told_after_gbra574', kind: 'add', text: "When a query names one date, each fact row in the facts block now says whether it was told after that date. A fact said after the date ends its header with \"; told after DATE\", for example [observed 2025-06-30; valid 2025-02-15 to unknown; told after 2025-04-01], and a fact whose saying date is unknown ends it with \"; learn date unknown\", so neither reads as known on that day. A question that names no date, or several, gets the headers it got before. Dates are read by the same fixed English grammar gbrain uses for time ranges in queries." },
  { since: '0.60.735.0', id: 'facts_block_contested_gbra574', kind: 'fix', text: "The query facts block now marks a fact another saved fact disputes, as recall already did. When a fact is in a pending gbrain decide supersede proposal, its row ends with (contested by #ID) naming the other fact, but only when the caller can read that other fact (remote callers see world facts only; private provenance and the trust floor apply). If the lookup fails, the rows carry no label and the response reports the degraded stage contested_unavailable." },
  { since: '0.60.735.0', id: 'conversation_fact_slot_windows_gbra574', kind: 'add', text: "Conversation facts can now carry a slot: where a person lives, who employs them or their role. `gbrain extract-conversation-facts` asks the model for it and stores it on the fact's ontology columns. The facts block in `query` then works out each value's validity window when it reads: an older value shows \"valid FROM to UNTIL\", ending where the next value starts, when both came from the same conversation page or the newer fact says the value changed in plain English (moved, joined, left, was promoted and similar); otherwise both values stay open and nothing is labelled. Nothing is closed in storage, so re-extracting pages in any order gives the same windows, a stored end date always wins, and a fact the caller cannot read never ends a window the caller can. Facts without a slot read exactly as before, and the ontology (ontology_get, ontology_propose, conflicts and the ontology-facts repair) ignores conversation facts. Pages extracted before this release keep their facts without slots and are not re-extracted automatically. To add slots to an existing brain, preview the paid run first with `gbrain extract-conversation-facts --force --dry-run`, which now prints the segment count and an estimated token count and dollar cost, then run `gbrain extract-conversation-facts --force`." },
  { since: '0.60.735.0', id: 'scan_allow_rule_entry', kind: 'add', text: "A .gbrain-scan-allow line of the form path:<glob> pattern:<rule> now allows only that secret-scan rule in the files the glob matches, so a rule that keeps flagging harmless values (for example jwt on newsletter unsubscribe links) can be quieted without turning off every other rule for those files. Existing fingerprint and path-glob lines work as before. A line that starts with pattern:, or with path: and contains a space, is read only as a rule entry: if it is malformed or names an unknown rule it allows nothing, and the push refusal, gbrain git scan and bootstrap verify name it. A bare path: line with no space is still a path glob, and gbrain git scan now warns about it." },
  { since: '0.60.735.0', id: 'takes_extract_dry_run_needs_yes_9547', kind: 'action', text: "`gbrain takes extract --from-pages --dry-run` without `--yes` no longer sends page content to the chat model. It lists the candidate pages and counts them, reports no claim count (`claims_extracted` is null and `dry_run` is true in `--json`), and writes nothing. A script that relied on a dry run classifying claims without `--yes` now needs `--dry-run --yes`, which classifies the candidates and still writes nothing." },
  { since: '0.60.735.0', id: 'auth_list_member_status_gbra593', kind: 'add', text: "gbrain auth list --json adds a member_status field to each token: enabled, disabled or removed for the member the token is bound to, missing when that member row is gone, and null for an unbound token. The status field keeps its meaning (active or revoked). The text table prints refused for an active token whose member is disabled or removed, because the brain refuses that token at verification (access_member_disabled)." },
  { since: '0.60.735.0', id: 'mirror_keep_deleted', kind: 'fix', text: "On a read-only mirror source, keeping the deletion of a page whose file the upstream edited after you deleted it now sticks. gbrain repair file-drift --held --side deleted --state tombstone_edited --prefer database lists such a page keep_deleted instead of removing a file gbrain never writes, and its apply (the user's yes on the preview hash) records the decision on the hold. The hold stays and is reported carried with reason mirror_keep_deleted, with needs_human false, in gbrain sources status, gbrain sync status and doctor, so it no longer asks again on every re-check; a re-check of the same file bytes keeps the decision. A new upstream edit of the file or gbrain restore of the page makes it ask again, and purging the deleted page moves the decision to the purged_differs hold. Nothing is deleted, restored or written into the mirror. Writable sources behave as before." },
  { since: '0.60.736.0', id: 'held_private_replies_2900', kind: 'fix', text: "A world restatement of a private fact that waits for the operator's accept is now also left out of think for remote callers who cannot read the private fact, and the reply to such a held write (remember, put_page and the other page writes, their outcome and write_request copies, get_write_request and list_write_requests) no longer carries contested.proposal_ref for those callers, so it reads like a saved write. The owner's callers, the local CLI and callers who can read the private fact still get the reference. A page write whose Facts row restates a more trusted private fact about the page's own entity kept on another page, or on none, is now held like a same-page restatement until gbrain trust confirm tp<N>; like the same-page hold, that includes the owner's own local writes and sync when the private copy is more trusted. A credential with a private_facts grant reads a held row again in get_page, search and think, as before the held-row page reads, when it can read every private copy that row restates. A remote get_page or get_versions of a page stored in segments now reports a size without the held rows." },
  { since: '0.60.736.0', id: 'held_row_page_reads_2891', kind: 'fix', text: "A world fence row restating a private fact that waits for the operator's accept (a remote put_page or remember restatement) is now left out of page, chunk, search and edit reads for remote callers who cannot read that private fact: get_page (as_of and known_as_of included), get_versions bodies and diffs, fetch, search, query, search_exact, get_chunks, the entity card and the edit_page diff. Such a caller's put_page keeps the held row it could not read, restored exactly as stored. The owner's callers, the local CLI and a member reading their own member page see the page as before. A world copy of the claim saved about another entity no longer lets a remote remember skip that hold. A held row also stays private when the page is synced or rewritten, until the operator accepts it with gbrain trust confirm tp<N>. If the lookup of held rows fails, the page read fails rather than return the page, and search drops every fence row. The page file in the brain repository still holds the world cell, and restatements that were never held stay world." },
  { since: '0.60.736.0', id: 'untrack_db_only_by_path_gst2964', kind: 'fix', text: "gbrain git commit-push --untrack in a managed canonical worktree now admits a file by its path under a storage.db_only folder that gbrain.yml declares and .gitignore ignores, whatever its extension. Before, every file was matched by its page slug, so .json, .yml and other files whose slug sync flattens refused untrack_not_db_only even though their folder was declared and ignored. A Markdown page still needs its slug under a declared folder. A code-extension file (sync's code list, .json and .yml included) is checked against the brain, because on a source whose sync strategy is code or auto it is a page with a flattened slug that a database-only folder does not cover: it is admitted only when no live page comes from it and the source's strategy does not import code, refused when it is a page whatever the strategy is now or when the strategy imports it, refused when the source's last finished sync has not seen it at its current version (run gbrain sync --source <id>, then rerun the untrack), and refused when the brain cannot be read within 10 seconds (retry when it is free). A tracked symlink out of the folder, a file reached through a symlinked folder and a sibling folder that only shares the name as a prefix now refuse. Each refusal's fix names what is missing for that file. The managed sync note about pages kept from the working tree now says that pages under a declared storage.db_only folder are database-only by declaration and need nothing, instead of telling every such page to be deleted or committed." },
  { since: '0.60.736.0', id: 'untrack_reads_brain_gst2964', kind: 'breaking', text: "In a managed checkout, gbrain git commit-push --untrack now reads the brain for every file, Markdown and CSV included, to learn which folder the source is rooted in (it used to read the checkout's top-level gbrain.yml, which refused every file of a source rooted in a folder and could admit a folder only that stray file declared, whose pages the next sync deleted), so on PGLite an untrack that worked while gbrain serve or a sync held the brain now refuses untrack_not_db_only and changes nothing until that process stops." },
  { since: '0.60.736.0', id: 'facts_block_retractions_gbra574', kind: 'add', text: "The query facts block now shows a later retraction next to the fact it answers, for every caller. When the block shows a fact about a person or company, a later fact about the same entity that retracts it or calls it off (retracted, scratch that, I was wrong, cancelled, called off, fell through, not happening, never happened, no longer planned, just a rumour and similar) comes right after it, with its own date header, inside the block's usual share of the token budget and row count. It pairs only when it is dated after the fact, its cue is not negated (\"not cancelled\", \"wasn't called off\" and \"isn't a rumour\" never pair), and it carries the same slot (the same dimension and value) or, leaving out the entity's name and the cue words, every word it has is in the fact or it shares at least two words with it. It is read under the caller's read policy, so a remote caller or another member never sees a retraction it could not already read, and a forgotten or withdrawn fact never appears. There is no setting; a question with no such later fact gets exactly the block it got before." },
  { since: '0.60.736.0', id: 'owner_remote_fact_reads_more_gst2951', kind: 'fix', text: "The brain owner's own remote agents (a credential bound to the member gbrain access owner set names, speaking for itself) now get the owner's private facts on the entity card (its recent facts and its active fact count) and the context_pack cards built from it, in the facts search and query attach about the entity a query names and the saved facts matching its words, in extraction_pending's list of facts saved without an entity, and in the similar facts forget names after a withdrawal. Before, these returned only world facts to every remote caller. Every other remote caller reads what it read before: another member, a labelled-only member, an unbound token, a call with no credential and the owner's credential speaking for an audience of several still get world facts only, and a private-facts grant admits a private fact on a world page where it already did. Page rules still apply to the owner, so a fact taken from a page whose readers leave the owner out stays hidden, and withdrawn facts stay out of every read." },
  { since: '0.60.736.0', id: 'owner_remote_fact_ops_gst2951', kind: 'fix', text: "The brain owner's own remote agents (a credential bound to the member gbrain access owner set names, speaking for itself) now read the owner's private facts through find_trajectory, ontology_get, ontology_conflicts and volunteer_chronicle, and get_write_attribution now finds a private fact for the owner's admin credential, as recall, query and think already did. Facts taken from a private page the owner can read come through too. Before, these operations returned only world facts to every remote caller, so a trajectory or ontology built from private facts came back empty for the owner. Every other remote caller reads no private fact it did not read before: another member, a labelled-only member, an unbound token, a call with no credential and the owner's credential speaking for an audience of several still get world facts only, and a private-facts grant still works on find_trajectory only. Page rules still apply to the owner, so a fact taken from a page whose readers leave the owner out stays hidden, withdrawn facts stay out of every read, and ontology from life/diary pages stays redacted for remote callers. Diary observations are now left out before each value resolves, so a newer diary note no longer hides the older value a remote caller may read." },
  { since: '0.60.736.0', id: 'dotdot_folder_names_inside', kind: 'fix', text: "Files in a folder whose name starts with two dots, such as ..drafts or ..., are now treated as inside the brain by the path checks this release fixes. Before, gbrain refused or skipped them, or called them outside, at those checks. Remote file uploads into such a folder are still refused; a separate fix covers that check. Three outputs change for such folders. First, gbrain frontmatter now expects the slug ..drafts/note for ..drafts/note.md (the same rule as any other folder) instead of note. Second, an extract-atoms transcript under meetings/..drafts/ gets the meetings label instead of corpus. Third, the LongMemEval call plan records a tracked, unchanged input under a ..inputs/ folder as a pinned INPUT line instead of a PRECONDITION. A gbrain.sourceRoot of ..drafts now scopes git commit-push to that folder instead of the whole checkout. Paths that really leave the brain are still refused." },
  { since: '0.60.737.0', id: 'conversation_extraction_no_slot_gbra574', kind: 'fix', text: "`gbrain extract-conversation-facts` no longer asks the model for a slot (where a person lives, who employs them or their role), because asking made it save fewer facts, wishes and preferences most of all. New conversation facts carry no slot, so skip the paid `--force` re-extraction the 0.60.735.0 notice suggested for adding slots: it now adds none. A fact stored with a slot under 0.60.735.0 keeps it, and its validity window, until the part of its page it came from is extracted again (an edit there, or `--force`, which re-extracts every page); the new rows then have no slot, and those facts read as they did before 0.60.735.0. The fact text is kept either way." },
];

/** The release of every marked id, so a function row dated releasedIn(id) takes the release that disclosed it. */
export const BEHAVIOR_CHANGE_RELEASES: Readonly<Record<string, string>> = {
  db_wins_unimported_gst2579: '0.60.706.0',
  extract_receipt_sealed_7620: '0.60.708.0',
  commit_push_dry_run_checks_paths: '0.60.708.0',
  schema_client_behind_7776: '0.60.708.0',
  purge_keeps_outcome_markers_7831: '0.60.708.0',
  audit_secrets_glued_marker_8034: '0.60.708.0',
  fence_locators_skip_code_8020: '0.60.708.0',
  ghost_code_page_recorded_file_7967: '0.60.708.0',
  derived_write_through_retry_8092: '0.60.708.0',
  owner_repair_file_restore_7960: '0.60.708.0',
  protocol_guard_refusal_typed_7777: '0.60.708.0',
  door_index_refresh_7717: '0.60.708.0',
  stored_root_predicate_7646: '0.60.708.0',
  sync_anchor_relative_jobs_7646: '0.60.708.0',
  conversion_root_owner_7956: '0.60.708.0',
  stuck_recovery_strict_followup_7715: '0.60.708.0',
  url_clone_fences_held_preview_7910: '0.60.708.0',
  streamed_put_visibility_wording_7881: '0.60.708.0',
  git_durability_refusal_no_side_effects_7634: '0.60.708.0',
  parked_push_hidden_page_7110: '0.60.708.0',
  embedding_preflight_abort_7772: '0.60.708.0',
  mirror_read_only_legacy_writers_7098: '0.60.708.0',
  copied_root_fix_names_self_transfer_7671: '0.60.708.0',
  door_landed_replay_gst2517: '0.60.708.0',
  requester_scope_gst363: '0.60.708.0',
  writer_fence_fail_closed_7636: '0.60.710.0',
  propose_takes_rejected_memory_7299: '0.60.711.0',
  grade_takes_auto_resolve_7542: '0.60.711.0',
  dream_write_deferral_w3: '0.60.711.0',
  synthesize_no_candidates_w3: '0.60.711.0',
  embedding_restamp_w3: '0.60.711.0',
  doctor_foreign_skills_folder: '0.60.711.0',
  upgrade_installs_no_autopilot: '0.60.711.0',
  session_lane_budget_gbra133: '0.60.711.0',
  github_item_webhook_backlog_8799: '0.60.711.0',
  webhook_capture_no_default_fallback_gst2113: '0.60.711.0',
  code_rechunk_module_elixir_8128: '0.60.711.0',
  db_link_child_folder_6983: '0.60.711.0',
  remote_think_host_model_gbra437: '0.60.711.0',
  physical_root_moved_8625: '0.60.711.0',
  moved_pages_fold_gst2584: '0.60.712.0',
  folder_holding_page_gst2492: '0.60.712.0',
  stuck_head_released_9227: '0.60.713.0',
  receipt_git_state_live_9227: '0.60.713.0',
  label_repairs_hold_refusals_gst2603: '0.60.713.0',
  corpus_segmented_entity_9279: '0.60.713.0',
  skillpack_update_untouched: '0.60.715.0',
  claude_cli_setting_sources_8342: '0.60.715.0',
  unattended_maintenance_doctor_gbra438: '0.60.715.0',
  bookkeeping_gc_phase_gbra438: '0.60.715.0',
  autopilot_refusals_structured_gbra438: '0.60.715.0',
  cycle_skip_text_gbra438: '0.60.715.0',
  cycle_freshness_keyless_consent_gbra438: '0.60.715.0',
  serve_idle_upkeep_gbra438: '0.60.715.0',
  serve_http_idle_timer_gbra438: '0.60.715.0',
  init_upkeep_line_gbra438: '0.60.715.0',
  chronicle_events_trust_cap_9284: '0.60.716.0',
  audit_secrets_escaped_encoded_8265: '0.60.716.0',
  holding_page_versions_gst2497: '0.60.717.0',
  owner_room_marks_gst2639: '0.60.717.0',
  managed_push_scan_every_publish_gst2650: '0.60.718.0',
  strict_fallback_refusal_gst2635: '0.60.718.0',
  access_first_import_history_gst2638: '0.60.719.0',
  room_cli_think_writes_gst2639: '0.60.719.0',
  owner_turn_sends_templates_gst2656: '0.60.719.0',
  storage_shelf_stored_object_type_8894: '0.60.720.0',
  derived_origin_carry_private_gst2689: '0.60.721.0',
  owner_remote_private_writes_gst2091: '0.60.722.0',
  guest_notes_gbra504: '0.60.722.0',
  access_rule_keeps_owner_gst2698: '0.60.723.0',
  new_sources_join_default_search_gst2732: '0.60.723.0',
  plain_folder_sources_gst2732: '0.60.723.0',
  install_no_postinstall_gst2732: '0.60.723.0',
  first_run_connects_then_reports_gst2732: '0.60.723.0',
  resynthesis_hold_6753: '0.60.723.0',
  skill_resolver_gate_default_gst2704: '0.60.723.0',
  thin_client_serve_stdio_bridge_8543: '0.60.723.0',
  guest_sources_scoped_role_fail_closed_9354: '0.60.723.0',
  commit_push_symlinked_source_gst2767: '0.60.724.0',
  transcript_secret_rules_gst2768: '0.60.724.0',
  doctor_git_gap_unknown_gbra541: '0.60.725.0',
  setup_codex_backups_gst2779: '0.60.725.0',
  keyless_any_word_fill_gst2762: '0.60.725.0',
  launcher_records_bun_gst2784: '0.60.725.0',
  notifier_sync_disabled_gst2515: '0.60.725.0',
  transcript_archive_default_gst2768: '0.60.726.0',
  stable_important_three_classes_gst2818: '0.60.731.0',
  owner_purge_tombstones_survive_9469: '0.60.732.0',
  keyword_skip_rerun_7082: '0.60.733.0',
  migration_host_work_owed: '0.60.733.0',
  commit_paths_unmerged: '0.60.733.0',
  git_large_index_listing: '0.60.733.0',
  atom_retirement_keeps_tier_9456: '0.60.733.0',
  provider_response_unparseable_9466: '0.60.733.0',
  sync_freshness_content_directory_9471: '0.60.733.0',
  repair_write_gate_markers_9511: '0.60.734.0',
  relink_keeps_fact_instant_9260: '0.60.734.0',
  consolidate_restatement_stays_open: '0.60.734.0',
  open_facts_repair_8194: '0.60.734.0',
  remember_restated_private_hold_2875: '0.60.734.0',
  setup_turn_hook_unmarked_9505: '0.60.734.0',
  git_reconcile_stopped_retryable: '0.60.734.0',
  frontmatter_validate_every_path: '0.60.734.0',
  serve_http_refused_not_activity_9484: '0.60.734.0',
  update_cache_future_stamp_8795: '0.60.734.0',
  title_arm_candidate_cap_7082: '0.60.734.0',
  guard_ledgers_fail_closed_7632: '0.60.734.0',
  purged_change_reason_8635: '0.60.734.0',
  mirror_compare_reads_file_gst2843: '0.60.734.0',
  held_compare_complete_window_gst2843: '0.60.734.0',
  hold_by_code_counts_all_gst2843: '0.60.734.0',
  fact_rows_observed_date_gbra574: '0.60.734.0',
  superseded_fact_valid_until_gbra574: '0.60.734.0',
  archive_rescope_on_shared_9563: '0.60.735.0',
  forward_fyi_no_loop_gst2899: '0.60.735.0',
  title_retry_reads_timelines_gst2899: '0.60.735.0',
  open_facts_lapsed_timeline_8194: '0.60.735.0',
  date_only_since_utc_9533: '0.60.735.0',
  connectors_sync_managed_brain_9124: '0.60.735.0',
  gmail_html_plain_body_8937: '0.60.735.0',
  captured_facts_codex_sessions_9554: '0.60.735.0',
  doctor_only_engine_free_9527: '0.60.735.0',
  private_facts_grant_8194: '0.60.735.0',
  migration_wedge_notice_history: '0.60.735.0',
  guard_ledger_checks_gst2885: '0.60.735.0',
  purged_change_reasons_repair_gst2886: '0.60.735.0',
  mirror_compare_names_writable_route_gst2869: '0.60.735.0',
  rehold_retry_not_progress_gst2869: '0.60.735.0',
  sync_sigterm_recorded_gst2869: '0.60.735.0',
  facts_block_history_gbra574: '0.60.735.0',
  facts_block_told_after_gbra574: '0.60.735.0',
  facts_block_contested_gbra574: '0.60.735.0',
  conversation_fact_slot_windows_gbra574: '0.60.735.0',
  scan_allow_rule_entry: '0.60.735.0',
  takes_extract_dry_run_needs_yes_9547: '0.60.735.0',
  auth_list_member_status_gbra593: '0.60.735.0',
  mirror_keep_deleted: '0.60.735.0',
  held_private_replies_2900: '0.60.736.0',
  held_row_page_reads_2891: '0.60.736.0',
  untrack_db_only_by_path_gst2964: '0.60.736.0',
  untrack_reads_brain_gst2964: '0.60.736.0',
  facts_block_retractions_gbra574: '0.60.736.0',
  owner_remote_fact_reads_more_gst2951: '0.60.736.0',
  owner_remote_fact_ops_gst2951: '0.60.736.0',
  dotdot_folder_names_inside: '0.60.736.0',
  conversation_extraction_no_slot_gbra574: '0.60.737.0',
};