sidegraph 0.13.0__tar.gz → 0.14.0__tar.gz

{sidegraph-0.13.0 → sidegraph-0.14.0}/.github/workflows/ci.yml

@@ -329,11 +329,15 @@ jobs:
           cache-dependency-glob: "uv.lock"
 
       - name: Rebuild graph and run sidegraph-sync --check
+        env:
+          GRAPHIFY_NO_AUTO_REFRESH: "1"
+          PYTHONHASHSEED: "0"
+          GRAPHIFY_MAX_WORKERS: "1"
         run: |
           if [ ! -d .sidegraph ]; then
             echo "no .sidegraph in this checkout — anchor health not applicable"
             exit 0
           fi
-          uvx --from graphifyy==0.9.6 graphify update .
+          uvx --from graphifyy==0.9.90 graphify update .
           uv sync --locked
           uv run sidegraph-sync --json --check

sidegraph-0.14.0/.opencode/INSTALL.md

@@ -0,0 +1,67 @@
+# Install Sidegraph in OpenCode V2
+
+Requires OpenCode V2, `uv` and Git on PATH. The current native integration baseline is
+OpenCode 2.0.29. Sidegraph provides MCP tools and shared skills; lifecycle hooks are not
+included. Ask for context and capture decisions explicitly through the tools.
+
+Install the Git package with OpenCode's native command:
+
+```bash
+opencode plugin add 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+```
+
+Start a new OpenCode session in your project. Follow `@sidegraph-setup` to prepare its
+graph and store, then call `list_domains()` to check MCP access. Use
+`get_task_context(files=[...])` before working on files and `propose_decisions` to capture
+durable findings. Other shared skills use `@sidegraph-<skill>` (for example,
+`@sidegraph-check-plan`). There is no automatic SessionStart map or Stop nudge.
+
+The equivalent `opencode.json` entry is:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["git+https://github.com/SantyagoSeaman/sidegraph.git#main"]
+}
+```
+
+Merge that entry with any existing plugin list. The plugin supplies one `sidegraph` MCP
+server only when that name has no explicit configuration. An existing entry, including
+`disabled: true`, stays unchanged. OpenCode V2 stores overrides under `mcp.servers`:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "sidegraph": {
+        "type": "local",
+        "command": [
+          "uvx",
+          "--from",
+          "git+https://github.com/SantyagoSeaman/sidegraph.git@main",
+          "sidegraph-mcp",
+          "--repo-root"
+        ],
+        "environment": {
+          "SIDEGRAPH_DIR": ".sidegraph",
+          "SIDEGRAPH_GRAPH": "graphify-out/graph.json"
+        }
+      }
+    }
+  }
+}
+```
+
+Use this override only when you want to manage the server yourself. Keep OpenCode's normal
+MCP and skill permissions; no additional Sidegraph plugin-approval command is required.
+
+Check and apply package updates, then restart OpenCode:
+
+```bash
+opencode plugin check 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+opencode plugin update 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+```
+
+The Git package target `#main` follows public releases. The MCP runtime uses its configured
+Git ref (normally `@main`); this host has no SessionStart version pin. Updating cached
+plugin files and resolving the MCP runtime are separate operations.

{sidegraph-0.13.0 → sidegraph-0.14.0}/AGENTS.md

@@ -76,4 +76,4 @@ Rules:
 - Dirty graphify-out/ files are expected after hooks or incremental updates; dirty graph files are not a reason to skip graphify. Only skip graphify if the task is about stale or incorrect graph output, or the user explicitly says not to use it.
 - If graphify-out/wiki/index.md exists, use it for broad navigation instead of raw source browsing.
 - Read graphify-out/GRAPH_REPORT.md only for broad architecture review or when query/path/explain do not surface enough context.
-- After modifying code, run `graphify update .` to keep the graph current (AST-only, no API cost).
+- After modifying code, run `graphify update .` with the environment variable `GRAPHIFY_NO_AUTO_REFRESH=1` set to keep the graph current (AST-only, no API cost).

{sidegraph-0.13.0 → sidegraph-0.14.0}/CHANGELOG.md

@@ -7,6 +7,125 @@ interfaces, exactly, and what each one promises: [`docs/reference/stability.md`]
 
 ## [Unreleased]
 
+## [0.14.0] — 2026-10-16
+
+### Graphify 0.9.90
+
+Migration steps: [migrate to Sidegraph 0.14](docs/guides/migrating-to-0.14.md).
+
+- Anchors to files with the same basename keep resolving after the engine upgrade.
+- External names resolve when Graphify emits several identical stub nodes.
+- Re-importing rationale does not duplicate compatible labels shortened by a newer engine.
+- `sidegraph-domains snapshot` preserves domain membership across engine regrouping.
+- A store can require a minimum Sidegraph version before clients read or write it.
+- Graphify leaves installed agent skills alone when Sidegraph runs it.
+
+### Changed
+
+- OpenCode V2 can install Sidegraph as a native Git package with shared skills and MCP
+  tools. Existing skill IDs and explicit MCP server settings take precedence. See the
+  [OpenCode installation guide](.opencode/INSTALL.md).
+- Muse has an experimental native plugin with shared skills and MCP tools. Launch Muse
+  from the intended project directory; lifecycle hooks are deferred. See the
+  [Muse installation guide](docs/integrations/muse.md).
+- A graph community that holds code and documents is split in two before domains are
+  computed. Graphify 0.9.62 and later link documents to the code they mention, which merged
+  them.
+- Domain membership is computed by each sync and kept per node. A path prefix now adds its
+  files at sync time, not when a domain is read. A decision anchored under a path rule that
+  the 20% cap kept off the communities now reaches that domain too.
+- A domain whose refresh fails keeps its previous membership whole and is reported again by
+  every later sync until its cause is fixed; `--force` retries it.
+- A domain-membership pass that cannot run because another process holds the store is
+  reported once, as `domain membership not refreshed: the store's writer was busy`, and the
+  next sync runs it; `--check` does not count it. A pass that fails as a whole is reported
+  as `*` (every accepted domain) until its cause is fixed.
+- The `supersede_domain` answer carries `snapshot_note` when the domain's membership is
+  frozen.
+
+### Fixed
+
+- SessionStart and Stop no longer create an absent store. Missing host-relative stores are
+  selected at the Git root; MCP first use requires explicit setup for nested or non-Git
+  destinations. Init distinguishes an empty scaffold from a store with authored content
+  and still prints setup guidance.
+- The MCP server applies the committed ratification policy from the selected store's
+  project when no policy is set in its environment, including cross-project and symlinked
+  stores. Missing settings keep the manual default.
+- Doctor excludes committed file deletions from code drift while binding statuses are
+  uncomputed, and qualifies remaining changes as having unknown binding status. Projects
+  without a graph still report changes to surviving anchored files.
+- Hot hooks withhold records and memory counts on a new store or after an index reload until
+  sync computes binding statuses, so placeholder `live` rows cannot revive orphaned anchors.
+- Community names from newer Graphify builds are read from curated labels, pending hub names,
+  then node names. Hub labels use the file's basename within their own community.
+- Graphify's post-merge hook marker is recognised alongside its other refresh-hook markers.
+- SessionStart and doctor advise when a graph's engine stamp is outside the tested releases.
+  The advisory adds no human notice; doctor's `--check` exits 2 when it is present.
+
+- `sidegraph-import` recognises compatible re-cut rationale labels by their exact file/node
+  context as well as the existing title/origin key, reducing duplicate imports after a
+  Graphify upgrade or rollback.
+
+- Every Graphify run Sidegraph starts or tells you to start now sets `GRAPHIFY_NO_AUTO_REFRESH=1`.
+  Graphify 0.9.87 and later refresh the agent skills they installed (such as
+  `~/.claude/skills/graphify/`) on the first run after a Graphify upgrade unless that variable is
+  set. The graph refresh hook's helper, the CI recipes, the copyable commands in the docs and the
+  setup skill set it, and the rebuild instructions Sidegraph prints name it. Graphify 0.9.6 does
+  not read the variable.
+- Anchors to files that share a basename keep resolving on newer Graphify. Graphify 0.9.87 and
+  later label such a file by a path suffix (`sidegraph/cli.py`) instead of its basename; Sidegraph
+  reads those nodes as basenames again, so an anchor `cli.py` in `src/sidegraph/cli.py` still
+  finds its node, and the engine's own label still resolves too.
+- A path-named anchor (`src/sidegraph/store.py` with its own `file_path`) now resolves to that
+  file's node on any Graphify version, and is stored under the basename. Entities an earlier
+  version named by the full path heal at the one-time resync that follows the upgrade.
+- `find_entity` reads the spelling twins of one file (an entity named by the file's path beside
+  one named by its basename) as one entity, and `get_entity_history` lists the records bound to
+  any twin. New anchors, lookups and duplicate detection compare names the same way.
+- An anchor `file_path` given as an absolute path under the repository, with backslashes on
+  Windows, or with a leading `./` is stored repo-relative with forward slashes and binds live
+  instead of orphaning, through the MCP write tools and through capture. When a store sits in a
+  subdirectory of its repository, the root whose path the graph holds is the one used.
+- An anchor naming an imported external type (`BaseModel`, `Path`) now binds even when Graphify
+  emits one stub node per importing file. The stubs count as one match when none has a file and
+  they share a label and a node type, and the anchor gets a group binding only when they share a
+  community. This applies on every Graphify version. A type and a module of one name (`FastMCP`
+  and `fastmcp`) and repository code are still told apart. Document mentions of such names do
+  not gain a precise leaf binding, and reading surfaces keep their earlier resolution answers.
+- Sync reports an anchor whose file disappeared and whose name now matches only external stubs
+  as orphaned. A resolved external anchor without a community no longer prevents other anchors'
+  previous community bindings from being retired. A formerly shared group also retires when
+  the stubs split. Ambiguous anchors and failed rebinds keep those bindings when their current
+  community is unknown.
+
+### Added
+
+- `sidegraph-domains snapshot` freezes every accepted domain's membership into
+  `.sidegraph/domain-snapshot.json`, so a Graphify upgrade that regroups communities does not
+  move domains. It raises the store's minimum Sidegraph version to 0.14.0. `--build-with
+  VERSION` takes the snapshot from `HEAD` rebuilt with an older Graphify; `--refresh`
+  re-freezes it; `--dry-run` prints the counts it would freeze and leaves committed files unchanged.
+- `sidegraph-verify` reports `bad-domain-snapshot` and `snapshot-without-requirement`;
+  `sidegraph-doctor` reports `snapshot-split`; `sidegraph-sync --json` and `sync_anchors`
+  carry `snapshot_splits`.
+
+
+- `sidegraph-require --sidegraph X.Y.Z` makes a store require at least that Sidegraph release:
+  the committed marker is raised atomically and never lowered. New clients check it before
+  using the store; verification reports malformed requirements and requirements above its version.
+
+- `sidegraph-doctor` prints informational `spelling twins` lines for an entity named by a path of
+  its file beside one named by the basename. They are not findings and do not change the exit
+  code. `duplicate-entity` no longer reports such a pair.
+
+- A new advisory check, `refresh-helper-outdated`, reports a graph refresh hook whose helper runs
+  Graphify without `GRAPHIFY_NO_AUTO_REFRESH=1` (the helper an earlier `sidegraph-init` wrote). It
+  shows as a SessionStart line and notice and as a `sidegraph-doctor` finding, and
+  `sidegraph-doctor --check` exits `2` on it. Run `sidegraph-init` with no flag: it rewrites the
+  helper and keeps your recorded hook choice. The helper lives in `.git/hooks`, so each clone
+  runs it once.
+
 ## [0.13.0] — 2026-10-14
 
 ### Fixed

{sidegraph-0.13.0 → sidegraph-0.14.0}/CLAUDE.md

@@ -5,7 +5,7 @@ that doesn't forget *why* things are the way they are as time passes and people
 
 **Thesis: own the memory, rent the graph.** Sidegraph owns an append-only, repo-committed
 decision store and layers it as a **sidecar** over a mature code-graph engine
-([Graphify](https://github.com/safishamsi/graphify)) rather than re-building entity extraction
+([Graphify](https://github.com/Graphify-Labs/graphify)) rather than re-building entity extraction
 and graph construction. The edge over session-memory tools is durable anchoring + budgeted,
 task-aware retrieval + decision memory riding on the engine's entity graph.
 
@@ -13,7 +13,7 @@ task-aware retrieval + decision memory riding on the engine's entity graph.
 continuing participant in the project. A core feature must preserve, organize, or deliver
 accumulated project understanding. Document search by itself is not the product.
 
-Sidegraph is pre-1.0 (v0.13.0) — the full loop (capture, ratification, mistakes-first
+Sidegraph is pre-1.0 (v0.14.0) — the full loop (capture, ratification, mistakes-first
 retrieval, refactor-surviving re-anchoring, semantic docs layer, mind-model domains, and the
 facts evidence layer) ships and is exercised end-to-end, but interfaces may still move before
 a stable release. See
@@ -53,6 +53,7 @@ src/sidegraph/
 ├── schema.py        # Pydantic models: Entity, Decision, Fact, AnchorBinding, Domain, Initiative
 ├── store.py         # owned append-only store (file-per-record JSON); enforces invariants on write
 ├── retrieval.py     # multi-altitude, budget-bounded, task-aware read path (mistakes first)
+├── domain_snapshot.py  # committed domain-membership snapshot: format and matching rules
 ├── hot_index.py     # raw-sqlite handle on index.db for the hook hot path (no Store, no pydantic)
 ├── store_layout.py  # store constants and rules shared with the hot path (pydantic-free)
 ├── server.py        # FastMCP decision MCP — the tools agents call

{sidegraph-0.13.0 → sidegraph-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sidegraph
-Version: 0.13.0
+Version: 0.14.0
 Summary: Own the memory, rent the graph — a durable decision/lessons layer as a sidecar over a code-graph engine.
 Project-URL: Homepage, https://github.com/SantyagoSeaman/sidegraph
 Project-URL: Repository, https://github.com/SantyagoSeaman/sidegraph
@@ -44,9 +44,10 @@ rejected, and what was learned during implementation, then retrieves that contex
 the files and symbols an agent is working on.
 
 Records live in your repository as reviewable JSON files. A derived SQLite index supports
-retrieval; [Graphify](https://github.com/safishamsi/graphify) supplies the code and document
+retrieval; [Graphify](https://github.com/Graphify-Labs/graphify) supplies the code and document
 graph used to anchor records. Claude Code and Codex plugins connect capture and retrieval
-to coding sessions.
+to coding sessions. OpenCode V2 and experimental Muse expose MCP tools and shared skills
+for explicit retrieval and capture.
 
 - Keep decisions, rejected alternatives, and evidence with their provenance and history.
 - Hand the agent the relevant mistakes and constraints before it edits, sized to fit its context.
@@ -60,7 +61,7 @@ to coding sessions.
 
 ### Set up a repository (once)
 
-**You need** Git, Claude Code or Codex, and [uv](https://docs.astral.sh/uv/getting-started/installation/),
+**You need** Git, one of the four hosts below, and [uv](https://docs.astral.sh/uv/getting-started/installation/),
 which also downloads Python 3.13 if you do not have it. On Windows you also need
 [Git for Windows](https://gitforwindows.org/) with its default options
 ([details](docs/getting-started/installation.md#windows)); run the commands below in
@@ -71,12 +72,19 @@ curl -LsSf https://astral.sh/uv/install.sh | sh
 powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"   # uv on Windows
 ```
 
-**1. Build the code graph.** [Graphify](https://github.com/safishamsi/graphify) maps your
+**Already using Sidegraph?** Follow the [0.14 migration guide](docs/guides/migrating-to-0.14.md)
+before upgrading Graphify, so accepted domains keep their membership. Update every client
+first, then use the existing-install update recipe for your host below. Claude Code and
+Codex keep the same `sidegraph@sidegraph` identity; no uninstall/reinstall is needed.
+
+**1. Build the code graph.** [Graphify](https://github.com/Graphify-Labs/graphify) maps your
 functions, classes and files, so a record can point at the exact function it is about.
 
 ```sh
-uv tool install "graphifyy==0.9.6"   # two y's in the package name; the command is graphify
+uv tool install "graphifyy==0.9.90"   # two y's in the package name; the command is graphify
 cd /path/to/your/repo
+export GRAPHIFY_NO_AUTO_REFRESH=1        # macOS, Linux: keeps Graphify off your agent skills
+$env:GRAPHIFY_NO_AUTO_REFRESH = "1"      # Windows PowerShell: use this line instead
 graphify update .
 echo "graphify-out/" >> .gitignore   # the graph is rebuilt from your code; keep it out of git
 Add-Content .gitignore "graphify-out/"   # the same line on Windows (PowerShell); do not use >> there
@@ -93,41 +101,134 @@ It asks two questions. Both default to yes, so press Enter twice.
 - *Keep the code graph fresh?* Yes installs a git hook that rebuilds the graph after each commit.
 - *Auto-ratify low-risk records?* Yes means the lessons, gotchas and facts the agent proposes
   are accepted without review. Other proposals still wait for you. The answer is saved in
-  `.claude/settings.json`, which you commit. The plugin applies it in Claude Code and in Codex,
-  so it covers the whole team.
+  `.claude/settings.json`, which you commit. Sidegraph reads it for all four MCP integrations unless an explicit
+  `SIDEGRAPH_RATIFY_POLICY` overrides it, so teammates use the same project policy.
 
 Details: [`sidegraph-init`](docs/reference/cli.md#sidegraph-init).
 
-**3. Install the plugin.** It gives the agent the memory at session start and asks it to save
-new decisions at the end of a session. It updates itself: each new session downloads and runs
-the latest Sidegraph release.
+**3. Choose one host.** Install its cached plugin assets, then start a new session in this
+repository. Host plugin updates and the MCP runtime are separate: the default runtime
+follows the public repository's `main`, which advances at releases; that does not refresh
+cached skills, manifests or hook definitions. Use your host's update recipe after a release.
+
+#### Claude Code
 
-In Claude Code, run these inside a session in the repository, then start a new session:
+In a Claude Code session in the repository:
 
 ```text
 /plugin marketplace add SantyagoSeaman/sidegraph
 /plugin install sidegraph@sidegraph
 ```
 
-In Codex, run these in a terminal in the repository, then start `codex` and approve the
-Sidegraph hooks when it asks:
+Review the installation summary and any approval prompts, then start a new Claude Code
+session. It provides MCP, skills, session memory, capture reminders and context on reads.
+For an existing install, run these in your terminal:
+
+```sh
+claude plugin marketplace update sidegraph
+claude plugin update sidegraph@sidegraph
+```
+
+Keep the same install scope; see the [Claude Code guide](docs/getting-started/claude-code-setup.md#update-an-existing-plugin).
+Start a new session after updating, or use `/reload-plugins` and review its prompts.
+
+#### Codex
+
+Run these in a terminal in the repository:
 
 ```sh
 codex plugin marketplace add SantyagoSeaman/sidegraph
 codex plugin add sidegraph@sidegraph
 ```
 
+Start a new interactive Codex session. Review Sidegraph's hooks through the startup warning
+or `/hooks`, then approve them. Without approval, MCP remains available but automatic session
+memory, capture reminders and subagent notices stay silent.
+For an existing install, run this in your terminal:
+
+```sh
+codex plugin marketplace upgrade sidegraph
+```
+
+Start a new session and review any changed hook definitions through the startup warning or
+`/hooks`; updating does not grant approval. This update recipe requires Codex CLI 0.162.1
+or a version with that command. See the [Codex guide](docs/getting-started/codex-setup.md#keep-the-plugin-updated).
+
+#### Muse (experimental)
+
+MCP and shared skills only; no automatic session map, read context or capture reminder.
+Run the install and update commands from the same stable directory outside any project
+(for example, your home directory). Keep that checkout with LF line endings:
+
+```sh
+git clone -c core.autocrlf=false https://github.com/SantyagoSeaman/sidegraph.git sidegraph-plugin
+muse plugins install ./sidegraph-plugin/plugin/sidegraph
+muse plugins inspect sidegraph
+```
+
+Review the MCP capability, then approve it:
+
+```sh
+muse plugins approve sidegraph
+```
+
+Exit Muse and start a new Muse process from the intended project directory. Restart it there
+whenever you switch projects; selecting a workspace in a running process is insufficient.
+For an existing install, refresh the maintained checkout and inspect the changed capability:
+
+```sh
+git -C sidegraph-plugin pull --ff-only
+muse plugins update sidegraph
+muse plugins inspect sidegraph
+```
+
+Review changes, then approve and restart Muse from the target project:
+
+```sh
+muse plugins approve sidegraph
+```
+
+Basic installation and MCP access were checked on Muse 1.4.7 on macOS; the update command is supported by native
+help, with full lifecycle and Windows acceptance deferred. See the [Muse guide](docs/integrations/muse.md).
+
+#### OpenCode V2
+
+Requires OpenCode V2 (native baseline 2.0.29), `uv` and Git on PATH. Native packaging/MCP
+was checked on macOS; Windows acceptance is pending. In your terminal:
+
+```sh
+opencode plugin add 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+```
+
+Start a new OpenCode session in your project and use `@sidegraph-setup`. Keep OpenCode's
+normal MCP and skill permissions; no additional plugin-approval command is needed. This
+route supplies MCP and skills only: ask for context and capture decisions explicitly.
+For an existing install, check and update the Git package, then restart OpenCode:
+
+```sh
+opencode plugin check 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+opencode plugin update 'git+https://github.com/SantyagoSeaman/sidegraph.git#main'
+```
+
+The [OpenCode installation guide](.opencode/INSTALL.md) is the canonical recipe, including
+configuration overrides. The package target `#main` and the MCP runtime's Git ref are
+separate settings.
+
+### First memory
+
 **4. Record a decision.** In a session, ask the agent, naming a real file and function:
 
 > Record this gotcha: the upstream API limits batch requests to 100 items. We rejected
 > a single unbounded request because it fails for larger imports. Anchor it to
 > `import_batch` in `src/importer.py`.
 
-It is saved right away. Records the agent proposes on its own may wait for your review: run
-`/sidegraph:ratify-decisions` in Claude Code, or ask Codex to "review pending decisions".
+It is saved right away. Records the agent proposes on its own may wait for your review.
+Ask the agent to review pending Sidegraph decisions through MCP on any host; Claude Code
+also offers `/sidegraph:ratify-decisions`.
 
 **5. Check and commit.** Start a new session and ask: "Before I edit `src/importer.py`, what
-should I know?" The agent should show the gotcha. Then commit `.sidegraph/` and `.gitignore`,
+should I know? Retrieve Sidegraph context for that file with `get_task_context`." The agent
+should show the gotcha on every host, including those without lifecycle hooks. Then commit `.sidegraph/` and `.gitignore`,
 and `.claude/settings.json` if step 2 created or changed it. The index file inside
 `.sidegraph/` is git-ignored automatically.
 
@@ -145,9 +246,9 @@ contents, or import existing ADRs and design specs with the
 
 - **Without the graph.** Skip step 1 and answer no to the first question in step 2. Records
   then attach to whole files instead of functions.
-- **Versions.** You always run the latest release. The plugin and the step 2 command install
-  Sidegraph from the public repository on GitHub, whose `main` branch changes only when a
-  release is published. To pin a version instead, see
+- **Versions.** The default MCP runtime and the step 2 command install Sidegraph from the
+  public repository on GitHub, whose `main` branch changes only when a release is published.
+  Update cached plugin assets with your host recipe above. To pin a version instead, see
   [pinning](docs/getting-started/installation.md#mutable-development-references).
 - **Sidegraph commands in your own terminal.** Optional:
   `uv tool install git+https://github.com/SantyagoSeaman/sidegraph.git@main`, from the same place as the plugin. It does not update itself, so
@@ -176,17 +277,17 @@ evaluate it on your own repository.
 ## How it works
 
 1. **Capture.** During a session the agent saves a decision when you ask for one. At the end of
-   a session the plugin reminds it to propose the decisions worth keeping. Secrets are redacted
-   before anything is written.
+   a Claude Code or Codex session the plugin reminds it to propose decisions worth keeping.
+   In OpenCode and Muse, ask for capture explicitly. Secrets are redacted before storage.
 2. **Review.** You accept or drop what the agent proposed; Sidegraph calls this *ratifying*.
    Records are JSON files in `.sidegraph/`, committed with your code.
 3. **Anchoring.** Each record is linked to the functions, classes, files or document headings it
    is about, using the graph Graphify builds from your code. When a refactor moves code,
    Sidegraph follows the move; when it cannot tell where the code went, it flags the record for
    review.
-4. **Recall.** At the start of the next session the agent gets a short table of contents of the
-   project's areas, called *domains*. Before changing a file it asks for that file's records,
-   with known mistakes first. In Claude Code, the agent also receives a file's records the
+4. **Recall.** Claude Code and Codex inject a short table of contents of the project's areas,
+   called *domains*, at session start. In every host, ask the agent to retrieve a file's
+   records with `get_task_context` before changing it, with known mistakes first. In Claude Code, the agent also receives a file's records the
    first time it reads or edits that file.
 5. **Subagents.** In Claude Code, when the agent hands a task to a subagent, the records for the
    files named in that task are added to it. In Claude Code and Codex, each new subagent is told
@@ -262,7 +363,7 @@ concepts and themes that records can anchor to. Walkthrough:
 ## The engine underneath
 
 The graph of your code and documents comes from
-[Graphify](https://github.com/safishamsi/graphify), built without an LLM. Sidegraph only reads
+[Graphify](https://github.com/Graphify-Labs/graphify), built without an LLM. Sidegraph only reads
 it and never writes into it. Without a graph, records anchor to files and domains, and recall
 still works. Three things need the graph: anchoring a record to a function, grouping related
 code automatically, and following moved code (see the
@@ -273,13 +374,14 @@ cannot: they are the source of truth, so keep them in your repository and backup
 ## Status
 
 Sidegraph is in beta. Read the [stability policy](docs/reference/stability.md) before
-building automation against it. By default the plugin follows the latest release; for
+building automation against it. By default the MCP runtime follows the latest release; for
 reproducible deployments, [pin a version](docs/getting-started/installation.md#mutable-development-references).
 The [changelog](CHANGELOG.md) records release changes.
 
-The platform badges at the top summarize the 0.13.0 release checks of 2026-10-14: Windows x64
-and macOS arm64 both ran the full plugin session for Claude Code and Codex. The badges are not
-live CI status; see [Platform coverage](docs/getting-started/installation.md#platform-coverage).
+The platform badges summarize the release gate: full Claude Code and Codex plugin sessions
+on Windows x64 and macOS arm64, with Python 3.13 and 3.14. Publication of 0.14.0 requires
+this gate, including Windows PowerShell 5.1 without PowerShell 7. See
+[Platform coverage](docs/getting-started/installation.md#platform-coverage) for limits.
 
 ## Contributing and support
 
@@ -299,7 +401,8 @@ Contributions are reviewed here and carried over, with attribution, before the n
 [Concepts](docs/concepts/decision-memory.md) ·
 [Guides](docs/guides/capturing-decisions.md) ·
 [Reference](docs/reference/mcp-tools.md) ·
-[Integrations](docs/integrations/graphify.md) (Graphify · Claude Code · Codex) ·
+[Integrations](docs/integrations/graphify.md) (Graphify · [Claude Code](docs/integrations/claude-code.md) · [Codex](docs/integrations/codex.md) ·
+[Muse](docs/integrations/muse.md) · [OpenCode V2](docs/integrations/opencode.md)) ·
 [Verify your setup](docs/guides/verifying-your-setup.md) ·
 [Operations](docs/reference/operations.md) ·
 [Pilot kit](docs/pilot-kit/README.md) ·