diff --git a/changelog/+store-merge-behaviour.changed.md b/changelog/+store-merge-behaviour.changed.md
new file mode 100644
index 000000000..ecdd6318f
--- /dev/null
+++ b/changelog/+store-merge-behaviour.changed.md
@@ -0,0 +1 @@
+The client store merge fix comes with four observable behaviour changes. First, the object returned by `get`, `filters` or `all` is a per-query snapshot and is no longer the same Python object as the store entry: `client.get(id) is client.store.get(id)` was previously true and now is false, although the two still compare equal (`==`). Second, the store hands out living objects: `store.get()` returns the same object across calls, and a later query that re-fetches the node updates that object in place. Third, the store is now timestamp-coherent per branch: the first population stamps the branch cache as live or as one `at` point in time, queries at the same timestamp use the store normally (a fully historical script gets complete store functionality), and a query at a mismatching timestamp skips the store with a warning instead of silently blending or overwriting data from a different point in time (which is what pre-1.23.0 versions did). Fourth, a successful `save()`, `create()` or `update()` now resets the node's in-memory mutation tracking: the persisted values count as server state, so later fetches of the same node refresh those fields in the store instead of treating the long-saved edit as a pending local change forever.
diff --git a/changelog/413.fixed.md b/changelog/413.fixed.md
new file mode 100644
index 000000000..c3f2bc18f
--- /dev/null
+++ b/changelog/413.fixed.md
@@ -0,0 +1 @@
+Fixed the client store silently losing data when the same node was fetched more than once. Previously the latest query fully replaced the stored node, so a shallow re-fetch (for example a node returned as a related node of another query) dropped attributes and relationships that an earlier, deeper query had loaded, and left duplicate entries in the store. The store now keeps one object per node UUID and merges each fetch into it field by field: fields carried by the new fetch overwrite the stored ones (even to empty or `None`), fields the fetch did not request keep their stored value, and local unsaved edits always win over a re-fetch. The previous replace behaviour remains available per query and per `store.set()` call with `merge=False`, or globally with the new `store_merge` configuration option (`INFRAHUB_STORE_MERGE`).
diff --git a/dev/specs/ihs-138-store-merge/decisions.md b/dev/specs/ihs-138-store-merge/decisions.md
new file mode 100644
index 000000000..46afc93f3
--- /dev/null
+++ b/dev/specs/ihs-138-store-merge/decisions.md
@@ -0,0 +1,311 @@
+# IHS-138 - Decision sign-off sheet
+
+One row per open decision from [`plan.md`](./plan.md) section 11. Each has a
+recommendation and the reasoning; mark **Accept** / **Override** and note any
+change. Nothing in Stage 1 (presence flags) depends on these - they gate Stage 2
+onward.
+
+Already settled (recorded in the plan, listed here for completeness):
+
+- **Version:** SDK 1.23.0, semver minor, shipped as a bug fix with a required
+  opt-out and a required behaviour-change note.
+- **Where the option lives:** `Config` default -> store default -> per-call
+  `merge=` override.
+
+---
+
+## D1 - Returned object vs stored object (C2)
+
+**Question.** After a re-fetch, the store keeps the merged canonical object. What
+does a query method (`get` / `all` / `filters`) return?
+
+- **(a) Return the freshly built per-query object** (diverges from the store copy).
+- **(b) Return the canonical merged store object.**
+
+**Recommendation: (a).**
+
+**Why.**
+
+- Minor-version safe: what `client.get()` returns is byte-for-byte what it returns
+  today (exactly the fields this query asked for). Only `store.get()` gets richer.
+  Option (b) changes every query's return value to carry data the caller did not
+  request - much harder to call non-breaking.
+- It shrinks the D2 blast radius: the only "living" object is the internal store
+  copy; returned objects are stable per-query snapshots.
+- Less code: (b) needs the query path to map incoming -> canonical and swap
+  returned references.
+- Clean mental model: "the return value is this query's result; the store
+  accumulates across queries."
+
+**Cost / what to verify.** `client.get(id) is client.store.get(id)` stops being
+true (it holds today). Value equality `==` still holds (id-based, `node.py:720`).
+Add a `save()` test: `save()` calls `store.set(self)`, so `self` merges into the
+canonical copy while the caller keeps `self` - confirm no field is revived that
+the save did not touch.
+
+**Decision: ACCEPTED (a).** Query methods return the per-query object; the store
+holds the merged canonical copy. Guiding rule agreed with the reporter: *"queries
+hand you what you asked for; the store remembers the union of everything it has
+seen."*
+
+---
+
+## D2 - In-place mutation / living objects (C3)
+
+**Question.** Merge mutates the existing stored object, so a `store.get()`
+reference can change under the caller when an unrelated query re-fetches that node.
+Is that the intended model?
+
+**Recommendation: accept it, documented, with local-edit protection.**
+
+**Why.**
+
+- It is the correct property for a cache: every store reference points at the one
+  canonical object, which is always current. The alternative (merge into a new
+  object, replace the entry) leaves previously handed-out `store.get()` references
+  stale and diverging from the store - worse.
+- Under D1(a) the surprise is confined to code that deliberately holds a
+  `store.get()` result across queries; plain query return values never mutate.
+- Protect unsaved local edits: merge must skip fields flagged
+  `value_has_been_mutated` (`attribute.py:100`) / `_peer_has_been_mutated`
+  (`related_node.py:74`), so re-querying never discards in-memory changes.
+
+**Cost.** New, documented behaviour. Covered by the section 6 "behaviour change
+must be clear" requirement.
+
+**Decision: ACCEPTED.** The store keeps one always-current, merged object per node;
+`store.get()` references reflect later fetches. Unsaved local edits are protected.
+
+---
+
+## D3 - Default for the public `store.set()` (C5)
+
+**Question.** The query-population path defaults to merge (the fix). What should the
+public `store.set(node=...)` default to?
+
+- **(a) `merge=False` (replace) by default**, opt into merge.
+- **(b) `merge=True` (merge) by default**, same as queries.
+
+**Recommendation: (a) - public `set()` defaults to replace.**
+
+**Why.**
+
+- "set" reads as an imperative "make the store hold this," like `dict[k] = v`.
+  Merge is the enrichment behaviour the *query* path needs, not what an explicit
+  `set` implies.
+- Preserves the documented contract ("store this object", `store.mdx:147`). That
+  example sets a fresh object under a custom key, usually with no prior entry, so
+  replace and merge are identical there - no example breaks.
+- The IHS-138 bug lives in the query path, not in manual `set()`. Keep the default
+  change where the bug is; leave the explicit call predictable.
+- A user who wants enrichment passes `merge=True`.
+
+**Note.** This means the default differs by entry point: queries follow
+`Config.store_merge` (default merge); `set()` defaults to replace regardless. That
+is intentional and should be stated in the `set()` docstring.
+
+**Decision: OVERRIDE -> (b) merge by default, uniformly.** The recommendation above
+was not taken. Agreed model: *anything that lands in the store gets merged*, with no
+special-casing by entry point - `store.set()` merges just like the query path. This
+is the simpler, single-rule mental model. Consequence: **replace is opt-in only** -
+the sole way to store a node verbatim / drop previously cached data is
+`store.set(node, merge=False)` or the `store_merge=False` config opt-out. The public
+`store.set()` docstring must state that it merges by default and how to force
+replace.
+
+---
+
+## D4 - Config option name and type
+
+**Question.** How is the global default expressed on `Config`?
+
+- **(a) Bool `store_merge` with a full `description`** (drafted in plan section 3).
+- **(b) A clearer bool name** (e.g. `merge_store_results`).
+- **(c) Enum `store_update_mode: StoreUpdateMode` (`MERGE` / `REPLACE`)**, matching
+  existing `Config` enums (`InfrahubClientMode`, `RecorderType`).
+
+**Recommendation: (a) - bool `store_merge` carried by its description.**
+
+**Why.**
+
+- Type-consistency with the per-call `merge: bool` argument. An enum on `Config`
+  plus a bool per call is a mismatch; keeping both bool is simplest to reason about.
+- The clarity the user asked for is delivered by the `description` (which states
+  both behaviours and the default), per the section 6 hard requirement - so the
+  terse name is acceptable.
+- Enum is the fallback if call-site self-documentation is valued over type
+  consistency, and we are willing to accept the enum/bool split (or make the
+  per-call arg accept the enum too).
+
+**Decision: ACCEPTED (a).** Bool `store_merge` with the full description. Revisit only
+if the description proves insufficient in review.
+
+---
+
+## D5 - Internal presence-flag naming
+
+**Question.** Name for the new "present in this response" flag on `Attribute` and
+`RelatedNode`.
+
+**Recommendation: `is_fetched`, with a uniform accessor across all three field
+types.**
+
+**Why.**
+
+- `RelatedNode` already has `initialized` meaning "has a peer"
+  (`related_node.py:189`) - a *different* concept - so the new flag there cannot be
+  called `initialized` without a confusing collision.
+- `RelationshipManager.initialized` already means "was fetched." Expose
+  `is_fetched` on it as a thin alias of `initialized`, add a real `is_fetched`
+  flag to `Attribute` and `RelatedNode`, and the merge code can branch uniformly
+  on `field.is_fetched` regardless of field type.
+- Internal only (not public API), so low stakes - but the uniform accessor removes
+  per-type special-casing in the merge.
+
+**Decision: ACCEPTED.** `is_fetched` on `Attribute` and `RelatedNode`; uniform
+`is_fetched` accessor on `RelationshipManager` aliasing its existing `initialized`.
+
+---
+
+## D6 - Scope of `merge=False` (replace)
+
+**Question.** When a node is stored with `merge=False`, does it also drop that
+node's relationship peers from the store, or only replace the node's own entry?
+
+**Recommendation: only replace the node's own entry.**
+
+**Why.**
+
+- Peers are independent store entries that other nodes may reference; cascading
+  eviction could break unrelated references.
+- Peers fetched in the same query go through their own `set()` calls and follow the
+  same `merge` flag independently. No special cascade needed.
+
+**Decision: ACCEPTED.** `merge=False` replaces the node's own entry only; peers are
+handled independently.
+
+---
+
+## D7 - Mutation-flag lifecycle (added during implementation, 2026-07-04)
+
+**Question.** D2 protects "unsaved local edits" via the mutation flags
+(`value_has_been_mutated`, `_peer_has_been_mutated`, `_has_update`). The code review
+showed those flags were sticky - never reset after a successful save - so a saved
+edit would block merge refreshes of that field forever, and the store would serve
+the stale saved value even after the server changed. What is the flag lifecycle?
+
+**Decision: reset on save, propagate on merge.**
+
+- A successful `create()`/`update()`/`save()` resets all three flag types
+  (`_reset_mutation_tracking()` at the end of `_process_mutation_result`): the
+  persisted values count as server state from then on.
+- The merge propagates the markers from an unsaved incoming copy instead of
+  clearing them, so an unsaved edit merged into the store (manual `store.set`)
+  keeps its will-be-saved status and is still sent by the store copy's next save.
+
+**Why.** The two halves depend on each other: propagation is only safe because
+saving resets the flags (a freshly saved copy no longer reads as "pending"), and
+resetting is what makes "local edits win" mean *unsaved* edits, which is what D2
+intended. Consequence, listed in the changelog: mutation tracking now resets after
+a successful mutation, so a second `update()` no longer re-sends relationship edits
+that were already persisted.
+
+---
+
+## D8 - Same-peer identity fields gate on presence (refines the merge rule)
+
+**Question.** The plan said cardinality-one peer identity "always refreshes" when
+the relationship was fetched. A payload carrying only `node { id }` for the *same*
+peer would then null previously fetched `hfid`/`display_label`/`typename`/`kind`
+and drop the cached `_peer` - the silent-loss class this feature exists to prevent
+(reachable via `from_graphql` on custom payloads + `store.set`, not via
+SDK-generated queries).
+
+**Decision: split by peer change.** A changed peer (different id, including cleared
+to none) takes the full incoming identity, so moves and move-to-root behave as
+specified. The same peer only refreshes the descriptive identity fields the
+incoming payload actually carried - consistent with how attribute properties and
+edge properties already merge.
+
+---
+
+## D9 - Timestamp-coherent store (supersedes grill item 3's mechanism, 2026-07-04)
+
+**Question.** Grill item 3 decided historical (`at`) reads must not blend into the
+live cache. The first implementation made `at` queries skip the store by default,
+with an explicit `populate_store=True` opt-in that forced replace. That required
+widening `populate_store` from `bool = True` to `bool | None = None` (to detect an
+explicit `True`), left `at` + `prefetch_relationships` without `.peer` resolution,
+and - because the opt-in forced replace - quietly revived the IHS-138 bug for
+fully-historical scripts. Was the signature change actually needed?
+
+**Decision: no - make the store timestamp-coherent instead.** The store holds one
+timestamp context per branch: live data, or one `at` instant, stamped by the first
+population. Same-context queries use the store normally, so a script running all
+its queries at one `at` gets full store functionality (merge, `.peer`, hfid
+lookups). A mismatching population (live vs historical, or two different instants)
+emits a warning and skips the store for that query; the query itself still returns
+its results.
+
+**Why.**
+
+- The incoherence grill item 3 feared comes only from *mixing* timestamps; a
+  consistent-`at` session is exactly as coherent as a live one and deserves the
+  same cache behaviour, including the merge semantics this whole feature adds.
+- `populate_store: bool = True` is restored - no public signature change, no `None`
+  sentinel in a boolean parameter.
+- Strictly safer than both alternatives considered: pre-1.23 silently overwrote
+  live entries with historical data; skip-by-default silently degraded historical
+  scripts. Warn-and-skip makes the mismatch visible without breaking mixed scripts
+  (which are safer than they were on 1.22, not worse).
+- Mismatch policy is warn + skip rather than raise: raising would break scripts
+  that mix `at` and live queries, which worked (subtly wrong) before, and this
+  ships as a semver-minor bug fix.
+- Documented footgun: recompute a relative timestamp per call and every query
+  after the first trips the warning - compute `at` once, or use one
+  `client.clone()` per timestamp (the context is per client store, per branch).
+
+---
+
+## Summary table
+
+| ID | Decision | Outcome |
+| -- | -------- | ------- |
+| D1 | Returned vs stored object | Return per-query object; store holds the merged canonical copy |
+| D2 | In-place mutation model | Accept; one always-current merged object per node; protect local edits |
+| D3 | `store.set()` default | **Merge by default, uniformly** (override); replace is opt-in via `merge=False` |
+| D4 | Config option name/type | Bool `store_merge` + full description |
+| D5 | Presence-flag name | `is_fetched`, uniform accessor on all three field types |
+| D6 | `merge=False` scope | Node entry only; peers handled independently |
+| D7 | Mutation-flag lifecycle | Reset on successful save; merge propagates pending markers (2026-07-04) |
+| D8 | Same-peer identity fields | Presence-gated for the same peer; full refresh on peer change (2026-07-04) |
+| D9 | `at` and the store | Timestamp-coherent per branch; mismatching populations warn + skip (2026-07-04) |
+
+**Guiding rule:** queries hand you what you asked for; the store remembers the union
+of everything it has seen. Replace happens only when explicitly requested
+(`merge=False` / `store_merge=False`).
+
+All decisions are settled and implemented (D1-D6 as planned; D7/D8/D9 added during
+the 2026-07-04 code-review hardening - see plan section 13 for the full list of
+implementation outcomes, including the performance constraints on `store.set()`).
+The remaining external gate is the 1.23.0 pre-release run of the Ansible collection
+and `infrahubctl` integration suites.
+
+## Grill refinements (2026-07-02)
+
+Stress-testing the plan (see plan section 12) added these, all accepted:
+
+- **Merge scope** also covers node-level scalars (`display_label`, `typename`) and
+  merges attributes/properties field-by-field (not object-swap).
+- **Kind change is a documented exception to D2:** if `typename` differs for the same
+  uuid (a `ConvertObjectType` migration), the store entry is *replaced* wholesale, not
+  mutated in place - merging across schemas is incoherent.
+- **`at` (time-travel) queries skip store population by default** (behaviour change
+  from today; must be in the migration note). Explicit `populate_store=True` + `at`
+  replaces rather than blends. *Superseded by D9:* the shipped mechanism is a
+  timestamp-coherent store (one `at` context per branch, warn + skip on mismatch),
+  which keeps the same goal - never blend timestamps - without the `populate_store`
+  signature change.
+- **Release gate:** Ansible collection + `infrahubctl` integration suites run against
+  the 1.23.0 pre-release; migration note enumerates the D1 identity change and the
+  `at` change with before/after.
diff --git a/dev/specs/ihs-138-store-merge/plan.md b/dev/specs/ihs-138-store-merge/plan.md
new file mode 100644
index 000000000..a8af1d976
--- /dev/null
+++ b/dev/specs/ihs-138-store-merge/plan.md
@@ -0,0 +1,676 @@
+# IHS-138 - Merge nodes in the client store instead of overwriting
+
+- **Ticket:** [IHS-138](https://opsmill.atlassian.net/browse/IHS-138) (GitHub [#413](https://github.com/opsmill/infrahub-sdk-python/issues/413))
+- **Priority:** High
+- **Affected versions:** observed on SDK 1.12.1
+- **Target version:** SDK 1.23.0 (ships alongside Infrahub 1.11.0)
+- **Status:** implemented (2026-07-02); hardened after code review (2026-07-04, section 13)
+
+> The SDK is versioned independently of Infrahub core. 1.23.0 is a semver *minor*
+> bump even though it rides the Infrahub 1.11.0 release. Because it changes
+> default store behaviour (see sections 3 and 10), shipping it as a minor depends
+> on two things being true: the change is framed as a bug fix, and an explicit
+> opt-out exists. Both are required deliverables, not nice-to-haves.
+
+## 1. Problem
+
+Querying the same Infrahub node more than once can silently drop information
+that was previously held in the client store.
+
+Reproduction from the ticket:
+
+```python
+client = InfrahubClientSync(address="https://demo.infrahub.app/")
+
+interface = client.get("InfraInterface", device__name__value="jfk1-edge1",
+                       name__value="Ethernet6", prefetch_relationships=True)
+client.store.get(interface.id).device.id          # works
+
+client.all("InfraCircuitEndpoint", prefetch_relationships=True)
+client.store.get(interface.id).device.id          # AttributeError: 'NoneType' has no attribute 'id'
+```
+
+The first query stores the interface with its `device` relationship. The second
+query re-fetches the same interface as a *related node* of each circuit endpoint,
+at a depth that does not include the interface's `device`. After the second query
+the device link is gone, and the interface is present in the store twice.
+
+## 2. Root cause
+
+The store keys objects by a random per-object id, not by their stable UUID.
+
+- `infrahub_sdk/node/node.py:110` - every node object gets a fresh
+  `self._internal_id = generate_short_id()` on construction.
+- `infrahub_sdk/store.py:47-60` - `NodeStoreBranch.set()` stores under
+  `self._objs[node._internal_id]` and points `self._uuids[node.id]` /
+  `self._hfids[...]` at that random id.
+- `infrahub_sdk/client.py:1161-1168` - the query paths unconditionally call
+  `self.store.set(node=node)` for every node and related node, with no check for
+  whether the UUID is already present.
+
+So a second fetch of the same UUID:
+
+1. creates a new Python object with a new `_internal_id`,
+2. leaves a duplicate entry in `_objs` (unbounded growth),
+3. overwrites `_uuids[node.id]` to point at the newest, possibly poorer copy.
+
+`store.get(uuid)` then resolves to the poorer copy, whose relationship was never
+initialized -> `AttributeError`.
+
+## 3. Design
+
+Replace "last write wins, keyed by a random id" with "merge into the existing
+object, keyed by UUID, field by field." A field is only overwritten when the new
+fetch actually carried it; fields the new fetch did not request are left intact.
+
+The decision of whether the new fetch carried a field requires a per-field
+"was this present in the response" signal. The state of that signal across the
+field types is **not uniform today**, and getting it uniform is the heart of the
+fix:
+
+- **Cardinality-many relationships** (`RelationshipManager`, including the
+  hierarchical `children` / `ancestors` / `descendants`) already have a correct
+  signal: `initialized = (data is not None)` (`relationship.py:202`). This genuinely
+  means "was fetched." Usable as-is.
+- **Cardinality-one relationships** (`RelatedNode`, including the hierarchical
+  `parent` and every normal one-relationship) have a *misleading* signal:
+  `initialized = bool(self.id) or bool(self.hfid)` (`related_node.py:189`) means
+  "has a peer," NOT "was fetched." A fetched-but-empty one-relationship (node moved
+  to root, optional relationship cleared) reports `initialized == False` and is
+  indistinguishable from "not fetched." Using it as the merge gate would keep a
+  stale parent after a move-to-root. **We must add a real presence flag to
+  `RelatedNode`** (set from key-presence in `_init_relationships`) and gate the
+  merge on that, not on `initialized`.
+- **Attributes** have no signal at all. `_init_attributes` (`node.py:269`) builds an
+  `Attribute` for every schema attribute regardless of the query, and a field absent
+  from the response collapses to `_value = None` (`attribute.py:88-99`),
+  indistinguishable from "fetched and genuinely null." We add the flag.
+
+**Unifying principle:** every field type - attribute, cardinality-one,
+cardinality-many, hierarchical - must carry a "present in this response" flag, and
+the merge replaces present fields (even to empty / None) and keeps absent ones.
+This is what makes moves, clears, and partial fetches all behave the way a user
+reads them: *the store reflects the latest server state for whatever you actually
+re-fetched, and leaves everything else untouched.*
+
+### Merge rule (per field)
+
+```text
+for each field on the incoming node:
+    if field was present in this response (initialized):
+        if the stored field was locally mutated by the user (unsaved):
+            keep the local value      # local edits win
+        else:
+            take the incoming value   # refresh, even to None
+    else:
+        keep the stored value         # not queried -> no fresher info
+```
+
+- Within a fetched cardinality-many relationship, the member list is *replaced*,
+  never unioned, so a peer removed on the server is correctly dropped.
+- For attributes, merge **field-by-field into the existing `Attribute`**, not by
+  swapping the whole object (grill 4, 2026-07-02). An attribute carries more than a
+  value - properties (`source`, `owner`, `is_protected`, `is_visible`) and metadata
+  (`is_default`, `is_from_profile`). A query can fetch the value without the
+  properties; a blind object-swap would then null previously-fetched properties -
+  the same silent-loss bug one level down. Rule: overwrite the value when the
+  attribute is fetched; overwrite each property/metadata sub-field only when the
+  re-fetch actually included it, otherwise keep the stored one. The same applies to
+  relationship properties and `node_metadata`.
+
+### "Field" means all three relationship buckets *and* node-level scalars
+
+A node holds relationships in **three** separate containers, and the merge must
+iterate all of them or it reintroduces the bug on the ones it skips:
+
+- `_relationship_cardinality_one_data` (`RelatedNode`)
+- `_relationship_cardinality_many_data` (`RelationshipManager`)
+- `_hierarchical_data` (parent / children / ancestors / descendants)
+
+Note `self._relationships` (`node.py:117`) lists **only** `schema.relationships`,
+so it does *not* include the hierarchical bucket. Do not drive the merge off
+`self._relationships` alone.
+
+It must **also** cover node-level scalars set directly in `__init__` - `display_label`
+and `typename` (`node.py:113-114`) - which live on neither `_attribute_data` nor a
+relationship bucket (grill 1, 2026-07-02). They are gated on presence like any other
+field: refresh `display_label` when the response carried it, keep it otherwise.
+`display_label` is user-visible (it drives `__repr__`, `node.py:298`), so leaving it
+stale after a refresh would visibly violate the guiding rule. `id` is exempt (it is
+the merge key). `hfid` is derived from attributes, so it refreshes once attributes
+merge.
+
+### Kind change -> full replace, not merge
+
+If the incoming node's concrete kind (`get_kind()`, == GraphQL `__typename`) differs
+from the stored node's kind for the same uuid, the node was migrated to another kind
+(the `ConvertObjectType` mutation, `convert_object_type.py`, converts in place and
+preserves the uuid). Merging field-by-field across two schemas is incoherent - it
+would leave phantom attributes/relationships from the old kind. In that case
+**discard the stored entry and store the incoming node wholesale**, regardless of the
+`merge` setting (grill 1b, 2026-07-02). This is the one case where the store object
+identity is replaced even in merge mode - a deliberate exception to "mutate in place"
+(D2). Purge the old kind's `_hfids` entries on replace so the index does not point at
+the discarded object. Misfire risk is low: GraphQL `__typename` is always the concrete
+kind, so a peer fetched via a generic relationship still reports its concrete kind.
+
+### Object identity
+
+Merge mutates the *existing* stored object and keeps its `_internal_id`. This
+removes the duplicate `_objs` entries and keeps `store.get(id)` returning a stable
+object across repeated fetches. Equality is unaffected: `InfrahubNode.__eq__` /
+`__hash__` are id-based (`node.py:717-723`), so `node == client.store.get(node.id)`
+remains true.
+
+### Decisions deliberately taken
+
+1. **Local edits win over a re-fetch.** Honour `value_has_been_mutated`
+   (`attribute.py:100`) and `_peer_has_been_mutated` so re-collecting the same
+   info never clobbers unsaved in-memory changes. Least surprising.
+2. **Merge is the default.** Re-collecting the same information is therefore
+   idempotent and only ever refreshes or adds knowledge.
+3. **`fetched-None` counts as fetched.** The presence flag means "present in the
+   response," not "value is non-null," so a genuine server-side clear still
+   overwrites a stale cached value.
+
+### Known limitation -> escape hatch
+
+Merge can never *forget* a field that was cached earlier but not re-fetched (for
+example, to observe that a relationship no longer exists when your refresh query
+did not select it). This is the one case where a full replace is wanted. Provide
+an explicit opt-out rather than guessing. It lives in three layers, mirroring how
+`populate_store` / `pagination_size` already work (config default -> per-call
+override):
+
+1. **Implementation:** `NodeStoreBranch.set()` / `NodeStoreBase._set()` in
+   `store.py` - the only place that writes `_objs`.
+2. **Per-call control:** a `merge` argument on `NodeStore.set()` /
+   `NodeStoreSync.set()` (`store.py:344`/`432`) and on the query methods `get` /
+   `all` / `filters` (and sync variants), placed next to the existing
+   `populate_store` argument. It threads into the `store.set(...)` calls at
+   `client.py:1164`/`1168`/`2903`/`2907`.
+3. **Global default / opt-out:** a field on `Config` (`config.py`), passed into the
+   store at construction (`client.py:358`, currently
+   `NodeStore(default_branch=self.default_branch)`). Defaults to merge.
+   `InfrahubClient(config=Config(<option>=...))` restores the pre-1.23.0
+   replace-everything behaviour in one place, and (like other `Config` bools) can
+   be set via environment variable without code changes.
+
+Resolution chain: **config default -> store default -> per-call `merge=` override.**
+
+`merge=False` (or the config opt-out) clears prior knowledge of the node and stores
+exactly what was fetched. The `at`/timestamp case (store is partitioned by branch,
+not by `at`) is the practical reason this hatch earns its place.
+
+#### Naming the config option (needs a decision)
+
+`store_merge: bool` is terse and does not, on its own, say what it does. Two ways to
+fix that, pick one:
+
+- **Bool with a description that carries the meaning**, for example:
+
+  ```python
+  store_merge: bool = Field(
+      default=True,
+      description=(
+          "When True, re-querying a node already in the store updates only the "
+          "fields that were fetched and preserves previously fetched attributes "
+          "and relationships. When False, the latest query fully replaces the "
+          "stored node, which can drop data fetched by earlier queries "
+          "(the pre-1.23.0 behaviour)."
+      ),
+  )
+  ```
+
+- **An enum** (consistent with existing `Config` enums such as `InfrahubClientMode`,
+  `RecorderType`), e.g. `store_update_mode: StoreUpdateMode` with `MERGE` / `REPLACE`.
+  More self-documenting at the call site, more code.
+
+Whichever is chosen, the description must spell out the behaviour *and* name the
+default, so the option is understandable without reading this plan.
+
+## 4. Save-path safety (verified)
+
+Adding a presence flag to `Attribute` does **not** change what gets written on
+save. `Attribute._initialize_graphql_payload` (`attribute.py:148-151`) only emits
+`{"value": None}` when the attribute was deliberately cleared
+(`optional and value_has_been_mutated`); otherwise it emits an empty payload that
+`node.py:458` drops from the mutation. Serialization keys on *mutation*, never on
+null-ness or presence. The new flag is consumed solely by the store merge logic.
+
+## 5. Implementation stages
+
+Single PR, layered commits so the mechanism is reviewable end to end (see section
+8 for the alternative split).
+
+### Stage 1 - Presence flags (no behaviour change)
+
+Add the "present in this response" signal everywhere the merge needs it:
+
+- `RelatedNode` - add a presence flag (separate from `initialized`, which stays as
+  the "has a peer" predicate other code relies on). Set it in `_init_relationships`
+  (`node.py:898`/`928`) from `rel_schema.name in data`. Required for cardinality-one
+  and hierarchical-`parent` merges to handle move-to-root / cleared relationships.
+- `Attribute` - the attribute presence flag described below.
+
+#### Stage 1a - Attribute presence flag
+
+- `attribute.py` - add `initialized: bool = True` to `Attribute.__init__` and
+  store it (`self.initialized`). Default `True` preserves behaviour for manual
+  construction and every existing call site.
+- `node.py:269` `_init_attributes` - compute presence unambiguously and pass it:
+
+  ```python
+  present = isinstance(data, dict) and attr_schema.name in data
+  Attribute(..., data=attr_data, initialized=present)
+  ```
+
+  Detection must live here, not solely in `Attribute.__init__`, because the
+  manual-construction path passes a bare scalar that `__init__` cannot tell apart
+  from "absent."
+- Verify nothing reads attribute state in a way the new field disturbs (save path
+  already verified in section 4).
+
+### Stage 2 - Store merges relationships instead of overwriting
+
+- `store.py` `NodeStoreBranch.set()` - if `node.id` already maps to a stored
+  object, merge into that object and keep its `_internal_id` instead of inserting
+  a duplicate. Update `_keys` / `_uuids` / `_hfids` to the retained internal id.
+- Implement the relationship half of the merge rule, gated on
+  `RelationshipManager.initialized` / `RelatedNode.initialized`, with member-list
+  replacement for cardinality-many. Cover **all three** buckets:
+  `_relationship_cardinality_one_data`, `_relationship_cardinality_many_data`,
+  and `_hierarchical_data` (see C1).
+- Resolve the return-value vs store-identity decision (C2) before writing this -
+  it changes whether the query path swaps returned references.
+- This stage (with the cardinality-one + hierarchical buckets) fixes the literal
+  ticket reproduction.
+
+### Stage 3 - Extend merge to attributes
+
+- Consume `Attribute.initialized` in the merge: take the incoming attribute when
+  present and not locally mutated; otherwise keep the stored one.
+- Swap the whole `Attribute` object on take so metadata refreshes with the value.
+
+### Stage 4 - Explicit replace escape hatch
+
+- Add the per-call `merge` argument to `NodeStore.set` / `NodeStoreSync.set` and
+  thread a matching argument through the query methods (`get`, `all`, `filters`,
+  and the sync variants) next to `populate_store`.
+- Add the global default to `Config` (see section 3 for the naming decision and the
+  required description) and pass it into the store at construction (`client.py:358`).
+- `merge=False` (or the config opt-out) removes prior knowledge of the node before
+  storing the fresh copy.
+- This is a public API change on three surfaces (query-method args, `store.set`,
+  `Config`) -> needs sign-off per `AGENTS.md` before implementing.
+
+### Stage 5 - Tests (section 7)
+
+### Stage 6 - End-user documentation (section 6)
+
+## 6. End-user documentation (must ship with the change)
+
+The store behaviour is user-visible and the change alters a long-standing
+(buggy) behaviour, so the docs are part of the deliverable, not a follow-up.
+
+**Guiding requirement - every behaviour change must be made clear.** This is a
+hard gate on the work, not a documentation nicety:
+
+- Any change to observable behaviour (the default merge, shared/living objects,
+  returned-vs-stored object differences) must be stated explicitly in the guide
+  *and* called out in the changelog / release notes, with before/after wording so a
+  user upgrading to 1.23.0 can tell what changed and why.
+- Any new configuration option must ship with a self-explanatory `description`
+  (see section 3) that states what it does and its default. A reader who has never
+  seen this plan must be able to understand the option from the description alone.
+  A terse name (`store_merge`) is acceptable only if the description carries the
+  meaning; otherwise prefer a clearer name or an enum.
+- Frame the change as a bug fix, and document the opt-out, so the minor-version
+  classification holds (see the version note at the top).
+
+Update `docs/docs/python-sdk/guides/store.mdx` and/or add a topic under
+`docs/docs/python-sdk/topics/` explaining:
+
+1. **What the store guarantees now.** "The store keeps, per field, the freshest
+   value the SDK has seen. Re-querying a node merges new data in; it does not
+   replace the cached node wholesale." State plainly that this is a per-field
+   freshness cache, not a point-in-time snapshot.
+2. **Why a node can hold data from several queries.** Walk the ticket scenario:
+   a deep fetch then a shallow re-fetch keeps the relationship, instead of losing
+   it. This is the behaviour change users most need to understand.
+3. **Re-collecting the same info is safe / idempotent.** It refreshes fetched
+   fields and never drops un-fetched ones.
+4. **Local unsaved edits win** over a re-fetch (so re-querying does not silently
+   discard in-memory changes).
+5. **How to force a clean replace** with `merge=False`, and when you would want
+   it (observing server-side deletions of fields your refresh did not select;
+   querying at a different `at`).
+6. **Staleness caveat.** A cached value can still be out of date relative to the
+   server, and the store does not track `at`.
+7. **Returned object vs stored object (depends on C2).** If option (a) is chosen,
+   document that the object returned by a query reflects only that query, while
+   `store.get()` returns the merged view - they may differ.
+8. **Shared, living objects (C3).** Document that the store hands back the same
+   object across fetches and that re-querying a node refreshes the object other
+   references already point at.
+
+Follow `docs/AGENTS.md`: async/sync `Tabs`, language on every code block, callouts
+for the behaviour-change note. Run `uv run invoke lint-docs` and, since this is a
+hand-written guide (not generated), confirm `docs-validate` is unaffected.
+
+A changelog / release-notes entry calling out the behaviour change explicitly is
+**required** (see the guiding requirement above), not optional. Ride the Infrahub
+1.11.0 release attention to surface it.
+
+## 7. Testing
+
+Unit tests in `tests/unit/` (see `tests/AGENTS.md`), async and sync:
+
+- **Relationship regression (the ticket):** deep fetch of a node with a
+  relationship, then a shallow fetch of the same node as a related node; assert
+  the relationship survives in the store and `store.get(id)` is the enriched
+  object.
+- **Attribute regression (symmetric, currently unreported):** fetch a node with
+  attributes A and B; re-fetch selecting only A; assert B survives in the store.
+- **Refresh updates fetched fields:** changed attribute / changed relationship
+  peers on re-fetch are reflected, including a cardinality-many peer removal.
+- **Move reflected (cardinality-one / hierarchical):** node's `parent` changes
+  from A to B on re-fetch with prefetch -> store shows B.
+- **Move-to-root reflected (the `RelatedNode.initialized` trap):** node's `parent`
+  is cleared on re-fetch with prefetch -> store shows no parent. This is the test
+  that fails if the merge gates on `RelatedNode.initialized` instead of the new
+  presence flag.
+- **Not re-fetched -> kept:** re-fetch without prefetch leaves the cached `parent`
+  untouched.
+- **`fetched-None` overwrites:** an attribute that genuinely becomes null on the
+  server overwrites a previously non-null cached value.
+- **Local edits win:** mutate in memory, re-fetch the same info, assert the local
+  value is preserved.
+- **No duplicates:** after repeated fetches of one UUID, `_objs` / `_uuids` /
+  `_hfids` hold exactly one entry for it; object identity is stable.
+- **`merge=False`:** prior knowledge is dropped and only fetched fields remain.
+- **Save unaffected:** a merged node serializes the same set of fields on save as
+  before (guards the section 4 invariant).
+- **Hierarchical relationships (C1):** deep then shallow fetch of a hierarchical
+  node keeps parent / children / ancestors / descendants in the store.
+- **Custom key consistency (incidental fix):** after a re-fetch,
+  `store.get(custom_key)` and `store.get(uuid)` return the same object (today they
+  diverge because `_keys` still points at the old internal id).
+- **Return vs store identity (C2):** assert the documented behaviour of whichever
+  option is chosen, so a future change does not regress it silently.
+- **Aliased / fragment-inlined query (C6):** presence detection still fires when
+  fields arrive under aliases.
+
+Run `uv run invoke format lint-code` and `uv run pytest tests/unit/`.
+
+## 8. Rollout / PR strategy
+
+Recommended: **one PR, layered commits** (stages 1-6), so reviewers see how the
+presence flag feeds the merge and the bug fix lands atomically. The presence flag
+is inert on its own, which is why splitting along the flag/merge seam is a poor
+idea.
+
+Acceptable alternative if the ticket fix must ship sooner: split along the
+relationship/attribute seam.
+
+- PR 1: stage 2 (relationship merge) - fixes IHS-138 literally, uses existing
+  `initialized`, lowest risk.
+- PR 2: stages 1 + 3 + 4 (attribute presence flag, attribute merge, escape hatch)
+  - the generalization plus the debatable policy calls.
+
+Do not split along the flag/merge seam (flag PR then merge PR): the flag PR would
+be unexplainable dead code.
+
+## 10. Failure scenarios, lurking bugs, and gaps
+
+These were found while reviewing the plan against the code. Items C1-C3 need a
+decision before coding starts.
+
+### C1 - Hierarchical relationships are easy to miss (would re-introduce the bug)
+
+Covered in section 3 ("all three relationship buckets"). Called out here because a
+merge written against `self._relationships` looks correct, passes the ticket's
+relationship test, and still silently clobbers parent/children/ancestors/
+descendants. Add an explicit hierarchical-relationship regression test.
+
+### C2 - The query methods return a different object than the store keeps
+
+`get` / `all` / `filters` build fresh nodes and `return nodes` (`client.py:1162`),
+but merge keeps the *existing* store object. After the change,
+`client.get(id) is client.store.get(id)` is no longer true, and the returned
+object does not benefit from the merge (only the store copy does). `__eq__` /
+`__hash__` are id-based (`node.py:717-723`), so value equality and the documented
+`tag == tag_in_store` example survive; identity (`is`) does not.
+
+Decision required - pick one:
+
+- **(a) Accept divergence.** Store is the canonical, merged copy; returned objects
+  are per-query snapshots. Simplest, lowest blast radius. Must be documented
+  loudly so users do not expect the returned object to carry merged data.
+- **(b) Return the canonical object.** After merging, the query path returns the
+  retained store object instead of the freshly built one. Gives "one object per
+  UUID" coherence but is more invasive (the return path must map incoming ->
+  canonical) and changes what a caller gets back from a query.
+
+Whichever is chosen, audit internal callers that assume the returned object is the
+stored object: `RelatedNode.fetch()` (`related_node.py:367`/`463`) caches the
+`client.get` result as `_peer`, and `save()` (`node.py:1287`/`2471`) calls
+`store.set(node=self)`.
+
+### C3 - Merge mutates objects the user already holds
+
+Today each query builds independent objects, so a reference the user is holding is
+stable. Merge-into-existing means an unrelated query that re-fetches the same UUID
+will mutate the object the user's variable points at (refreshing fetched
+attributes, replacing fetched relationships). This is inherent to "one living
+object per UUID" and may be the right model, but it is a new, surprising behaviour
+and must be a documented, deliberate decision. "Local edits win" softens it for
+mutated fields, but un-mutated fields still change under the caller.
+
+### C4 - Direct `_peer` references shadow the merged store copy
+
+`RelatedNode.peer` returns a cached `self._peer` if set, falling back to
+store-by-id only otherwise (`related_node.py:404-411`). `.fetch()` and explicit
+assignment set `_peer` directly, so a relationship resolved that way will ignore
+later store merges. The normal prefetch path resolves peers by id through the
+store (which is why the store-level merge fixes the ticket), so this affects only
+explicitly fetched/assigned peers. Document the limitation; do not try to
+invalidate `_peer` caches as part of this change.
+
+### C5 - `store.set()` default (RESOLVED: merge by default, uniformly)
+
+Originally proposed as replace-by-default for the explicit `set()`. **Decided
+otherwise (see `decisions.md` D3):** the store merges uniformly, with no
+entry-point special-casing - `store.set()` merges just like the query path. Replace
+is opt-in only, via `store.set(node, merge=False)` or `store_merge=False`. The
+`store.set()` docstring must state that it merges by default and how to force
+replace. Update the `store.mdx:147` example accordingly so "store this object"
+does not read as "replace."
+
+### C6 - Aliased fields / fragment inlining vs the presence check
+
+`from_graphql` runs `_strip_alias` (`node.py:894`) before init, and a
+fragment-inlining feature exists (`dev/specs/infp-496-graphql-fragment-inlining`).
+If a queried field arrives under an alias that strip-alias does not normalise to
+the schema name, `attr_schema.name in data` reads false and the merge skips a
+field that *was* fetched (silent staleness). Add a test that exercises aliased /
+fragment-inlined queries and assert presence detection still fires.
+
+### C8 - `RelatedNode.initialized` means "has a peer," not "was fetched"
+
+`RelationshipManager.initialized` is `data is not None` (a true fetched signal),
+but `RelatedNode.initialized` is `bool(self.id) or bool(self.hfid)`
+(`related_node.py:189`) - "has a peer." A fetched-but-empty cardinality-one
+relationship (move to root, optional relationship cleared) reports
+`initialized == False`, indistinguishable from "not fetched." Gating the merge on
+it would keep a stale `parent` after a move-to-root - the opposite of expected.
+Fix: add a presence flag to `RelatedNode` (Stage 1) and gate the merge on it. This
+is the single most likely "looks correct, ships a bug" mistake in this work.
+
+### C7 - Minor
+
+- Attribute metadata staleness on wholesale `Attribute` swap (see section 3 caveat).
+- Compute and register `_uuids` / `_hfids` / `_keys` from the merged object
+  *after* merging; the hfid may change when an hfid-component attribute is
+  refreshed.
+- Threaded sync usage widens the read-modify-write window in `set()` (asyncio is
+  unaffected). Pre-existing; note, do not fix here.
+
+## 11. Open questions
+
+Decided (see `decisions.md`, all settled 2026-07-01):
+
+- **Version / classification:** SDK 1.23.0, semver minor, shipped as a bug fix with
+  a required opt-out and a required behaviour-change note (see top + section 6).
+- **Where the merge option lives:** `Config` default -> store default -> per-call
+  `merge=` override (see section 3).
+- **D1 - returned vs stored object:** query methods return the per-query object;
+  the store holds the merged canonical copy.
+- **D2 - living objects:** accepted; one always-current merged object per node,
+  local edits protected.
+- **D3 / C5 - `store.set()` default:** merge by default, uniformly; replace is
+  opt-in via `merge=False` / `store_merge=False`.
+- **D4 - config option:** bool `store_merge` with a full description.
+- **D5 - presence-flag name:** `is_fetched`, uniform accessor on all three field
+  types.
+- **D6 - `merge=False` scope:** node entry only; peers handled independently.
+
+Decided during implementation (see section 13 and `decisions.md`):
+
+- **Public API sign-off:** granted with the go-ahead to implement the full plan.
+  Shipped surfaces: `merge: bool | None` on `get`/`all`/`filters` and `store.set`,
+  and `Config.store_merge`. `populate_store` keeps its `bool = True` signature.
+- **D7 - mutation-flag lifecycle:** reset on successful save; merge propagates
+  pending markers.
+- **D8 - same-peer identity fields:** presence-gated; full refresh on peer change.
+- **D9 - timestamp-coherent store:** supersedes grill item 3's skip-by-default
+  mechanism; the store holds one `at` context per branch and refuses (warn + skip)
+  mismatching populations.
+
+## 12. Grill review outcomes (2026-07-02)
+
+Stress-tested the plan against overall impact and the other in-flight specs
+(`infp-496-graphql-fragment-inlining` is Implemented; `infp-504-artifact-composition`
+in flight). Findings, all accepted:
+
+1. **Node-level scalars in merge scope.** `display_label` / `typename` are merged,
+   gated on presence (section 3). Folded in.
+2. **Kind change -> full replace.** `typename` differing for the same uuid means a
+   `ConvertObjectType` migration; replace wholesale instead of merging (section 3).
+   Folded in.
+3. **`at` (time-travel) queries skip the store by default.** The store is not
+   `at`-aware, so a historical read must not blend into the live cache. New rule:
+   when `at` is set, default `populate_store=False`; if the caller explicitly passes
+   `populate_store=True`, honour it but force `merge=False` (replace, never blend).
+   This is itself a behaviour change from today (where `at` reads populate the store)
+   and must be in the migration note. *Superseded during implementation by D9
+   (section 13): the shipped mechanism is a timestamp-coherent store instead.*
+4. **Attribute property/metadata fidelity.** Merge field-by-field into the existing
+   `Attribute`, not a blind object-swap, so value-only re-fetches don't null cached
+   `source`/`owner`/`is_protected` etc. (section 3). Folded in.
+5. **Blast radius / release gate.** Internal SDK reliance is minimal and additive
+   (only `related_node` peer resolution and `save()` touch the store, both benefit).
+   Risk is external: `client.get(id) is client.store.get(id)` identity loss (D1) and
+   `at` no longer populating (item 3). Make the **Ansible collection** and
+   **`infrahubctl`** integration suites a pre-release gate for 1.23.0, and enumerate
+   both changes with before/after in the migration note.
+
+Lower-priority (noted, not blockers):
+
+- **Unbounded store growth.** Merge reduces growth (dedups today's duplicates) and
+  the store is per-client, so generator/transform runs stay bounded. Out of scope;
+  possible future `store.clear()` / eviction.
+- **Fragment inlining / custom aliases (downgrades C6).** Store population uses
+  SDK-generated queries (canonical field names + `__alias__`, normalised by
+  `_strip_alias`); fragment inlining acts on hand-authored `.gql` via
+  `execute_graphql`, which does not feed store population the same way. Downgrade C6
+  to a verification test, not a risk.
+- **Thread-safety.** Merge adds a read-modify-write in `set()`; fine under asyncio,
+  and sharing one sync client across threads was already unsafe. Document "the store
+  is not thread-safe"; do not fix here.
+
+### Additional tests from the grill
+
+- `display_label` refreshes on re-fetch that includes it; is kept when absent.
+- Kind conversion: convert a node to another kind, re-fetch -> store holds the
+  new-kind object, old-kind-only attributes are gone, `_hfids` has no stale entry.
+- Value-only re-fetch preserves previously fetched attribute `source`/`owner`.
+- `at` query does not populate the store by default; `populate_store=True` + `at`
+  replaces (does not blend).
+- SDK prefetch/hierarchical queries still map to schema names after `_strip_alias`
+  (guards the fragment/alias concern).
+
+## 13. Implementation outcomes (2026-07-02 .. 2026-07-04)
+
+The feature was implemented as planned (stages 1-6, single PR, all D1-D6 decisions
+honoured), then hardened after a full code review. What shipped differs from the
+plan above in the following ways; the new decisions are recorded as D7/D8 in
+`decisions.md`.
+
+### Corrections found by the review
+
+1. **Mutation-flag lifecycle (D7, new decision).** The plan gated "local edits win"
+   on `value_has_been_mutated` / `_peer_has_been_mutated` / `_has_update`, assuming
+   those flags meant "unsaved edit". They were in fact sticky - nothing ever reset
+   them after a successful save - so any saved edit would have blocked merge
+   refreshes of that field forever (permanent store staleness; the pre-merge replace
+   semantics had masked this). Shipped fix, two halves: a successful
+   `create()`/`update()`/`save()` now calls `_reset_mutation_tracking()`
+   (`_process_mutation_result`, async and sync), and the merge *propagates* the
+   markers from an unsaved incoming copy instead of clearing them, so a merged
+   unsaved edit is still sent by the store copy's next save. This is a user-visible
+   behaviour change (listed in the changelog): mutation tracking resets on save.
+2. **Same-peer identity gating (D8, refines section 3).** "Peer identity always
+   refreshes" was too coarse: a payload carrying only `node { id }` for the same
+   peer would have nulled previously fetched `hfid`/`display_label`/`typename` and
+   dropped the cached `_peer` (unreachable via SDK-generated queries, which always
+   select all four, but reachable via `from_graphql` on custom payloads +
+   `store.set`). Shipped rule: a *changed* peer takes the full incoming identity
+   (moves and clears still work); the *same* peer only refreshes identity fields the
+   incoming payload actually carried.
+3. **`_data` baseline merges key-wise.** Section 3's field-by-field fidelity rule is
+   also applied to the raw `_data` dict (the baseline `update()` diffs against), so
+   a value-only re-fetch does not shrink `_data[name]` and cause `update()` to
+   re-send untouched properties.
+
+### Performance constraints added (not covered by the plan)
+
+- `NodeStoreBranch.set()` is the hottest path in the SDK; the first implementation
+  made store population O(N^2) via a linear hfid-index scan per set (measured: 30k
+  inserts = 4.9s). The store now keeps reverse indexes (`_hfids_by_internal_id`,
+  `_keys_by_internal_id`) so set/evict are O(1) per call (30k inserts = 0.03s).
+- The per-field presence sets (`_fetched_fields` / `_fetched_properties`) are
+  interned via `utils.intern_frozenset` - objects built from the same query shape
+  share one instance. Without this the bookkeeping measured ~64% of an Attribute's
+  memory footprint (~0.5 GB per 50k-node sync).
+
+### Timestamp-coherent store (D9, supersedes grill item 3's mechanism)
+
+Grill item 3 was first implemented as "skip the store when `at` is set unless the
+caller explicitly opts in (then replace)", which required widening `populate_store`
+to `bool | None` to detect an explicit `True`, and left `at` +
+`prefetch_relationships` without working `.peer` resolution. Review discussion
+replaced that mechanism: the store now holds **one timestamp context per branch**
+(live, or one `at` instant), stamped by the first population. Same-context queries
+use the store normally - a fully historical script gets complete store
+functionality including merge and peer resolution, which the first mechanism could
+not offer (its opt-in forced replace, quietly reviving the IHS-138 bug for
+historical work). A mismatching population (live vs historical, or two different
+instants) warns and skips the store, so nothing ever blends across timestamps -
+strictly safer than both pre-1.23 (silent overwrite) and the first mechanism.
+`populate_store` stays `bool = True` with no signature change. Known footgun,
+documented: a per-call recomputed relative timestamp trips the mismatch warning;
+compute `at` once and reuse it, or use one `client.clone()` per timestamp.
+
+### Minor deviations from the plan text
+
+- The presence flag on `RelatedNode` is a constructor parameter (like `Attribute`),
+  not a post-construction assignment; presence detection lives in one helper
+  (`InfrahubNodeBase._field_was_fetched`).
+- Each field type owns its merge: `Attribute._merge`, `RelatedNodeBase._merge`,
+  and `RelationshipManagerBase._merge` (the plan only implied the first two).
+- Follow-up filed separately: generated typed protocols for test schemas
+  (GitHub #1132), prompted by the test suite written for this feature.
+
+Still pending from section 12: the 1.23.0 pre-release gate (Ansible collection +
+`infrahubctl` integration suites).
diff --git a/docs/docs/python-sdk/guides/store.mdx b/docs/docs/python-sdk/guides/store.mdx
index 8836cae60..d0c927685 100644
--- a/docs/docs/python-sdk/guides/store.mdx
+++ b/docs/docs/python-sdk/guides/store.mdx
@@ -12,6 +12,72 @@ The store is mainly used for the internal working of the SDK. It is used to crea
 
 The store stores objects that we are retrieving from Infrahub using the different query methods. This allows to not have to keep references to objects throughout scripts, or avoids situations where we have to re-execute queries.
 
+## What the store guarantees
+
+The store keeps, per field, the freshest value the SDK has seen. Re-querying a node merges the new data into the stored node; it does not replace the cached node wholesale. The store is a per-field freshness cache, not a point-in-time snapshot: a single stored node can hold data collected by several queries.
+
+:::warning Behaviour change in version 1.23.0
+
+Before SDK 1.23.0, every query fully replaced the stored node, so a shallow re-fetch could silently drop attributes or relationships that an earlier, deeper query had loaded. Since 1.23.0 the store merges instead. See [forcing a clean replace](#forcing-a-clean-replace) to restore the previous behaviour.
+
+:::
+
+The merge works field by field, for attributes and relationships alike:
+
+- A field that was part of the query overwrites the stored value, even when the new value is empty or `None`. A relationship cleared on the server, or an attribute set back to `None`, is reflected after a re-fetch that includes it.
+- A field that was not part of the query keeps its stored value. Fetching a node with a subset of its attributes never erases what an earlier query loaded.
+- A re-fetched relationship of cardinality many replaces its full member list, so a peer removed on the server is dropped from the store.
+- Local unsaved edits win: if you modified an attribute or assigned a relationship in memory and did not save yet, a re-fetch of the same node does not discard your changes.
+
+This makes re-collecting the same information safe and idempotent: it refreshes what you fetched and never drops what you did not.
+
+Consider a deep fetch followed by a shallow one:
+
+<Tabs groupId="async-sync">
+  <TabItem value="Async" default>
+
+  ```python
+  interface = await client.get(
+      "InfraInterface", name__value="Ethernet6", prefetch_relationships=True
+  )
+  # A later query returns the same interface as a related node, without its relationships
+  await client.all("InfraCircuitEndpoint", prefetch_relationships=True)
+
+  # The device relationship loaded by the first query is still there
+  device = client.store.get(key=interface.id).device.peer
+  ```
+
+  </TabItem>
+  <TabItem value="Sync" default>
+
+  ```python
+  interface = client.get(
+      "InfraInterface", name__value="Ethernet6", prefetch_relationships=True
+  )
+  # A later query returns the same interface as a related node, without its relationships
+  client.all("InfraCircuitEndpoint", prefetch_relationships=True)
+
+  # The device relationship loaded by the first query is still there
+  device = client.store.get(key=interface.id).device.peer
+  ```
+
+  </TabItem>
+</Tabs>
+
+### Returned objects compared to stored objects
+
+Queries hand you what you asked for; the store remembers the union of everything it has seen. The object returned by `get`, `filters` or `all` reflects only that query, while `store.get()` returns the merged view, so the two can differ. They compare equal (`==`, equality is based on the node id) but they are not the same Python object (`is`).
+
+### The store hands out living objects
+
+The store keeps one object per node and mutates it in place when new data arrives. Every `store.get()` call for the same node returns the same object, and a later query that re-fetches the node refreshes the object that earlier references already point at. If you need a snapshot that does not change under you, keep the object returned by the query instead of the store copy.
+
+One exception: a relationship peer resolved with `fetch()` or assigned directly is cached on the relationship itself and does not pick up later store merges.
+
+### Staleness caveat
+
+A merged value is only as fresh as the last query that fetched it. The store does not track when each individual field was fetched: within its timestamp context (see below), it always represents the latest data seen per branch.
+
 Objects are stored in the following scenario:
 
 - The resulting objects from using the SDK client's `get`, `filters` or `all` methods
@@ -139,6 +205,8 @@ You can retrieve objects from the store using their `id` or `hfid`. When using t
 
 You can store objects in the store manually using the `set` method. This has the advantage that you can choose a key that you want to use to reference the object in the store, besides the `id` or `hfid`. For example, we could use the name attribute value of the node as the key.
 
+Like the query methods, `set` merges by default: if a node with the same `id` is already in the store, the object you pass is merged into the existing entry instead of replacing it. Pass `merge=False` to store the object verbatim and drop what the store previously knew about that node.
+
 <Tabs groupId="async-sync">
   <TabItem value="Async" default>
 
@@ -166,6 +234,61 @@ You can store objects in the store manually using the `set` method. This has the
   </TabItem>
 </Tabs>
 
+## Forcing a clean replace
+
+A merge can never *forget* a field that was cached earlier but not re-fetched. For example, to observe that a relationship no longer exists when your refresh query did not select it, the merged entry is not enough. For those cases you can force a clean replace, which drops all prior knowledge of the node and stores exactly what the query fetched.
+
+The replace behaviour is available at three levels:
+
+- Per query, with the `merge` argument on `get`, `filters` and `all`.
+- Per store write, with the `merge` argument on `store.set()`.
+- Globally, with the `store_merge` configuration option (or the `INFRAHUB_STORE_MERGE` environment variable), which restores the pre-1.23.0 replace-everything behaviour for the whole client.
+
+<Tabs groupId="async-sync">
+  <TabItem value="Async" default>
+
+  ```python
+  # Per query
+  tag = await client.get(kind="BuiltinTag", name__value="RED", merge=False)
+
+  # Per store write
+  client.store.set(node=tag, merge=False)
+
+  # Globally
+  client = InfrahubClient(config=Config(store_merge=False))
+  ```
+
+  </TabItem>
+  <TabItem value="Sync" default>
+
+  ```python
+  # Per query
+  tag = client.get(kind="BuiltinTag", name__value="RED", merge=False)
+
+  # Per store write
+  client.store.set(node=tag, merge=False)
+
+  # Globally
+  client = InfrahubClientSync(config=Config(store_merge=False))
+  ```
+
+  </TabItem>
+</Tabs>
+
+## Historical queries and the store
+
+The store holds one timestamp context per branch: live data, or one `at` point in time. The first query that populates a branch stamps its context, and every later query at the same timestamp uses the store normally - a script that runs all of its queries at one `at` gets the full store behaviour, including merging and relationship peer resolution.
+
+A query whose timestamp does not match the branch context (a historical query against a live cache, a live query against a historical cache, or two different `at` values) does not populate the store: the query still returns its results, but the SDK emits a warning and leaves the store untouched, because blending data from different points in time into one cache would silently produce inconsistent nodes. If you need both contexts, use a dedicated client per timestamp (`client.clone()`), or pass `populate_store=False` on the mismatching queries to silence the warning.
+
+:::warning Behaviour change in version 1.23.0
+
+Before SDK 1.23.0, queries using `at` overwrote store entries regardless of what the store held, so historical data could silently replace live data. Since 1.23.0 the store is timestamp-coherent: mismatching queries skip the store with a warning instead. Note that on a node whose query skipped the store, relationship peers cannot be resolved through `.peer` (the peers were never stored) - read the peer identity directly from the relationship (`.id`, `.display_label`, `.typename`) or use a dedicated client for that timestamp.
+
+One caveat: compute the `at` timestamp once and reuse it. A script that rebuilds a relative timestamp for every call creates a slightly different instant each time and will trip the mismatch warning on every query after the first.
+
+:::
+
 ## Disable storing objects in the store using the different query methods
 
 In some scenarios it might not be desirable to automatically store the retrieved objects in the store, when using the SDK client's different query methods. In this case you can set the `populate_store` argument to `False`.
diff --git a/docs/docs/python-sdk/reference/config.mdx b/docs/docs/python-sdk/reference/config.mdx
index bbb1b8a79..8858997b8 100644
--- a/docs/docs/python-sdk/reference/config.mdx
+++ b/docs/docs/python-sdk/reference/config.mdx
@@ -136,6 +136,13 @@ The following settings can be defined in the `Config` class
 **Default value**: 60<br />
 **Environment variable**: `INFRAHUB_SCHEMA_CONVERGE_TIMEOUT`<br />
 <!-- vale off -->
+## store_merge
+<!-- vale on -->
+**Description**: When True, re-querying a node already in the client store updates only the fields that were fetched and preserves previously fetched attributes and relationships. When False, the latest query fully replaces the stored node, which can drop data fetched by earlier queries (the pre-1.23.0 behaviour).<br />
+**Type**: `boolean`<br />
+**Default value**: True<br />
+**Environment variable**: `INFRAHUB_STORE_MERGE`<br />
+<!-- vale off -->
 ## timeout
 <!-- vale on -->
 **Description**: Default connection timeout in seconds<br />
diff --git a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/client.mdx b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/client.mdx
index c23de5292..9a01ede81 100644
--- a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/client.mdx
+++ b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/client.mdx
@@ -16,7 +16,7 @@ GraphQL Client to interact with Infrahub.
 #### `get`
 
 ```python
-get(self, kind: type[SchemaType], raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType | None
+get(self, kind: type[SchemaType], raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType | None
 ```
 
 <details>
@@ -25,37 +25,37 @@ get(self, kind: type[SchemaType], raise_when_missing: Literal[False], at: Timest
 #### `get`
 
 ```python
-get(self, kind: type[SchemaType], raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType
+get(self, kind: type[SchemaType], raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType
 ```
 
 #### `get`
 
 ```python
-get(self, kind: type[SchemaType], raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType
+get(self, kind: type[SchemaType], raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaType
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode | None
+get(self, kind: str, raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode | None
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode
+get(self, kind: str, raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode
+get(self, kind: str, raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNode
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str | type[SchemaType], raise_when_missing: bool = True, at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, id: str | None = None, hfid: list[str] | None = None, include: list[str] | None = None, exclude: list[str] | None = None, populate_store: bool = True, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> InfrahubNode | SchemaType | None
+get(self, kind: str | type[SchemaType], raise_when_missing: bool = True, at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, id: str | None = None, hfid: list[str] | None = None, include: list[str] | None = None, exclude: list[str] | None = None, populate_store: bool = True, merge: bool | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> InfrahubNode | SchemaType | None
 ```
 
 </details>
@@ -219,7 +219,7 @@ Requires Infrahub 1.10 or later.
 #### `all`
 
 ```python
-all(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[SchemaType]
+all(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[SchemaType]
 ```
 
 <details>
@@ -228,13 +228,13 @@ all(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str | None
 #### `all`
 
 ```python
-all(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[InfrahubNode]
+all(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[InfrahubNode]
 ```
 
 #### `all`
 
 ```python
-all(self, kind: str | type[SchemaType], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None) -> list[InfrahubNode] | list[SchemaType]
+all(self, kind: str | type[SchemaType], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, merge: bool | None = None, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None) -> list[InfrahubNode] | list[SchemaType]
 ```
 
 Retrieve all nodes of a given kind.
@@ -245,6 +245,10 @@ Retrieve all nodes of a given kind.
 - `at`: Time of the query. Defaults to Now.
 - `branch`: Name of the branch to query from. Defaults to default_branch.
 - `populate_store`: Flag to indicate whether to populate the store with the retrieved nodes.
+The store holds one timestamp context per branch (live, or the first `at` used)\: a query whose `at`
+does not match that context skips the store with a warning instead of blending inconsistent data.
+- `merge`: Whether nodes added to the store merge into an existing entry for the same UUID
+(True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
 - `timeout`: Overrides default timeout used when querying the GraphQL API. Specified in seconds.
 - `offset`: The offset for pagination.
 - `limit`: The limit for pagination.
@@ -265,7 +269,7 @@ Retrieve all nodes of a given kind.
 #### `filters`
 
 ```python
-filters(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[SchemaType]
+filters(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[SchemaType]
 ```
 
 <details>
@@ -274,13 +278,13 @@ filters(self, kind: type[SchemaType], at: Timestamp | None = ..., branch: str |
 #### `filters`
 
 ```python
-filters(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[InfrahubNode]
+filters(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[InfrahubNode]
 ```
 
 #### `filters`
 
 ```python
-filters(self, kind: str | type[SchemaType], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, partial_match: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> list[InfrahubNode] | list[SchemaType]
+filters(self, kind: str | type[SchemaType], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, merge: bool | None = None, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, partial_match: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> list[InfrahubNode] | list[SchemaType]
 ```
 
 Retrieve nodes of a given kind based on provided filters.
@@ -292,6 +296,10 @@ Retrieve nodes of a given kind based on provided filters.
 - `branch`: Name of the branch to query from. Defaults to default_branch.
 - `timeout`: Overrides default timeout used when querying the GraphQL API. Specified in seconds.
 - `populate_store`: Flag to indicate whether to populate the store with the retrieved nodes.
+The store holds one timestamp context per branch (live, or the first `at` used)\: a query whose `at`
+does not match that context skips the store with a warning instead of blending inconsistent data.
+- `merge`: Whether nodes added to the store merge into an existing entry for the same UUID
+(True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
 - `offset`: The offset for pagination.
 - `limit`: The limit for pagination.
 - `include`: List of attributes or relationships to include in the query.
@@ -518,7 +526,7 @@ mapping. See https://docs.infrahub.app/guides/object-conversion for more informa
 #### `get`
 
 ```python
-get(self, kind: type[SchemaTypeSync], raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync | None
+get(self, kind: type[SchemaTypeSync], raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync | None
 ```
 
 <details>
@@ -527,37 +535,37 @@ get(self, kind: type[SchemaTypeSync], raise_when_missing: Literal[False], at: Ti
 #### `get`
 
 ```python
-get(self, kind: type[SchemaTypeSync], raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync
+get(self, kind: type[SchemaTypeSync], raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync
 ```
 
 #### `get`
 
 ```python
-get(self, kind: type[SchemaTypeSync], raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync
+get(self, kind: type[SchemaTypeSync], raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> SchemaTypeSync
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync | None
+get(self, kind: str, raise_when_missing: Literal[False], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync | None
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync
+get(self, kind: str, raise_when_missing: Literal[True], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str, raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync
+get(self, kind: str, raise_when_missing: bool = ..., at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., id: str | None = ..., hfid: list[str] | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., populate_store: bool = ..., merge: bool | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> InfrahubNodeSync
 ```
 
 #### `get`
 
 ```python
-get(self, kind: str | type[SchemaTypeSync], raise_when_missing: bool = True, at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, id: str | None = None, hfid: list[str] | None = None, include: list[str] | None = None, exclude: list[str] | None = None, populate_store: bool = True, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> InfrahubNodeSync | SchemaTypeSync | None
+get(self, kind: str | type[SchemaTypeSync], raise_when_missing: bool = True, at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, id: str | None = None, hfid: list[str] | None = None, include: list[str] | None = None, exclude: list[str] | None = None, populate_store: bool = True, merge: bool | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> InfrahubNodeSync | SchemaTypeSync | None
 ```
 
 </details>
@@ -761,7 +769,7 @@ Requires Infrahub 1.10 or later.
 #### `all`
 
 ```python
-all(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[SchemaTypeSync]
+all(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[SchemaTypeSync]
 ```
 
 <details>
@@ -770,13 +778,13 @@ all(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: str |
 #### `all`
 
 ```python
-all(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[InfrahubNodeSync]
+all(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ...) -> list[InfrahubNodeSync]
 ```
 
 #### `all`
 
 ```python
-all(self, kind: str | type[SchemaTypeSync], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None) -> list[InfrahubNodeSync] | list[SchemaTypeSync]
+all(self, kind: str | type[SchemaTypeSync], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, merge: bool | None = None, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None) -> list[InfrahubNodeSync] | list[SchemaTypeSync]
 ```
 
 Retrieve all nodes of a given kind.
@@ -788,6 +796,10 @@ Retrieve all nodes of a given kind.
 - `branch`: Name of the branch to query from. Defaults to default_branch.
 - `timeout`: Overrides default timeout used when querying the GraphQL API. Specified in seconds.
 - `populate_store`: Flag to indicate whether to populate the store with the retrieved nodes.
+The store holds one timestamp context per branch (live, or the first `at` used)\: a query whose `at`
+does not match that context skips the store with a warning instead of blending inconsistent data.
+- `merge`: Whether nodes added to the store merge into an existing entry for the same UUID
+(True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
 - `offset`: The offset for pagination.
 - `limit`: The limit for pagination.
 - `include`: List of attributes or relationships to include in the query.
@@ -807,7 +819,7 @@ Retrieve all nodes of a given kind.
 #### `filters`
 
 ```python
-filters(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[SchemaTypeSync]
+filters(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[SchemaTypeSync]
 ```
 
 <details>
@@ -816,13 +828,13 @@ filters(self, kind: type[SchemaTypeSync], at: Timestamp | None = ..., branch: st
 #### `filters`
 
 ```python
-filters(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[InfrahubNodeSync]
+filters(self, kind: str, at: Timestamp | None = ..., branch: str | None = ..., timeout: int | None = ..., populate_store: bool = ..., merge: bool | None = ..., offset: int | None = ..., limit: int | None = ..., include: list[str] | None = ..., exclude: list[str] | None = ..., fragment: bool = ..., prefetch_relationships: bool = ..., partial_match: bool = ..., property: bool = ..., parallel: bool = ..., order: Order | None = ..., include_metadata: bool = ..., query_name: str | None = ..., **kwargs: Any) -> list[InfrahubNodeSync]
 ```
 
 #### `filters`
 
 ```python
-filters(self, kind: str | type[SchemaTypeSync], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, partial_match: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> list[InfrahubNodeSync] | list[SchemaTypeSync]
+filters(self, kind: str | type[SchemaTypeSync], at: Timestamp | None = None, branch: str | None = None, timeout: int | None = None, populate_store: bool = True, merge: bool | None = None, offset: int | None = None, limit: int | None = None, include: list[str] | None = None, exclude: list[str] | None = None, fragment: bool = False, prefetch_relationships: bool = False, partial_match: bool = False, property: bool = False, parallel: bool = False, order: Order | None = None, include_metadata: bool = False, query_name: str | None = None, **kwargs: Any) -> list[InfrahubNodeSync] | list[SchemaTypeSync]
 ```
 
 Retrieve nodes of a given kind based on provided filters.
@@ -834,6 +846,10 @@ Retrieve nodes of a given kind based on provided filters.
 - `branch`: Name of the branch to query from. Defaults to default_branch.
 - `timeout`: Overrides default timeout used when querying the GraphQL API. Specified in seconds.
 - `populate_store`: Flag to indicate whether to populate the store with the retrieved nodes.
+The store holds one timestamp context per branch (live, or the first `at` used)\: a query whose `at`
+does not match that context skips the store with a warning instead of blending inconsistent data.
+- `merge`: Whether nodes added to the store merge into an existing entry for the same UUID
+(True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
 - `offset`: The offset for pagination.
 - `limit`: The limit for pagination.
 - `include`: List of attributes or relationships to include in the query.
diff --git a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/attribute.mdx b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/attribute.mdx
index 44ba26c6c..26d968ec1 100644
--- a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/attribute.mdx
+++ b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/attribute.mdx
@@ -22,6 +22,9 @@ used by ``InfrahubNode.update()`` to send only the changed fields to the API.
 - `id`: The unique identifier of the attribute, when known.
 - `value`: The current attribute value. Setting this marks the attribute as mutated.
 - `value_has_been_mutated`: True when ``value`` has been assigned after construction.
+- `is_fetched`: True when this attribute was present in the response the node
+was built from. Used by the client store to decide whether a re-fetch carried
+fresh data for this attribute.
 - `is_default`: True when the value comes from the schema default.
 - `is_from_profile`: True when the value is inherited from a profile.
 - `is_inherited`: True when the attribute is inherited from a generic.
diff --git a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/related_node.mdx b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/related_node.mdx
index 80e6fdd92..88b677329 100644
--- a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/related_node.mdx
+++ b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/related_node.mdx
@@ -22,6 +22,10 @@ The full peer node is fetched lazily through :meth:`RelatedNode.fetch` /
 - `schema`: The schema describing the relationship.
 - `name`: The name of the relationship slot on the parent node.
 - `updated_at`: ISO-8601 timestamp of the most recent edge update.
+- `is_fetched`: True when this relationship was present in the response the
+node was built from. Unlike ``initialized`` (which means "has a peer"), this
+is also True for a fetched-but-empty relationship, so the client store can
+distinguish "cleared on the server" from "not queried".
 
 **Methods:**
 
diff --git a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/relationship.mdx b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/relationship.mdx
index 1a2baf19a..4f0a0cac8 100644
--- a/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/relationship.mdx
+++ b/docs/docs/python-sdk/sdk_ref/infrahub_sdk/node/relationship.mdx
@@ -26,6 +26,22 @@ members are not loaded and editing is not allowed.
 
 **Methods:**
 
+#### `is_fetched`
+
+```python
+is_fetched(self) -> bool
+```
+
+Return whether this relationship was present in the response the node was built from.
+
+Alias of ``initialized`` (which already means "was fetched" for cardinality-many
+relationships), exposed under the same name as on ``Attribute`` and
+``RelatedNode`` so merge logic can branch uniformly on ``is_fetched``.
+
+**Returns:**
+
+- ``True`` when the peer set was populated from a response.
+
 #### `peer_ids`
 
 ```python
diff --git a/infrahub_sdk/client.py b/infrahub_sdk/client.py
index 01e8d5f0f..3295b2d34 100644
--- a/infrahub_sdk/client.py
+++ b/infrahub_sdk/client.py
@@ -355,7 +355,7 @@ def _initialize(self) -> None:
         self.schema = InfrahubSchema(self)
         self.branch = InfrahubBranchManager(self)
         self.object_store = ObjectStore(self)
-        self.store = NodeStore(default_branch=self.default_branch)
+        self.store = NodeStore(default_branch=self.default_branch, default_merge=self.config.store_merge)
         self.task = InfrahubTaskManager(self)
         self._request_method: AsyncRequester = self.config.requester or self._default_request_method
         self.group_context = InfrahubGroupContext(self)
@@ -429,6 +429,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -450,6 +451,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -471,6 +473,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -492,6 +495,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -513,6 +517,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -534,6 +539,7 @@ async def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -554,6 +560,7 @@ async def get(
         include: list[str] | None = None,
         exclude: list[str] | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         fragment: bool = False,
         prefetch_relationships: bool = False,
         property: bool = False,
@@ -589,6 +596,7 @@ async def get(
             branch=branch,
             timeout=timeout,
             populate_store=populate_store,
+            merge=merge,
             include=include,
             exclude=exclude,
             fragment=fragment,
@@ -883,6 +891,7 @@ async def all(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -904,6 +913,7 @@ async def all(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -924,6 +934,7 @@ async def all(
         branch: str | None = None,
         timeout: int | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         offset: int | None = None,
         limit: int | None = None,
         include: list[str] | None = None,
@@ -943,6 +954,10 @@ async def all(
             at (Timestamp, optional): Time of the query. Defaults to Now.
             branch (str, optional): Name of the branch to query from. Defaults to default_branch.
             populate_store (bool, optional): Flag to indicate whether to populate the store with the retrieved nodes.
+                The store holds one timestamp context per branch (live, or the first `at` used): a query whose `at`
+                does not match that context skips the store with a warning instead of blending inconsistent data.
+            merge (bool, optional): Whether nodes added to the store merge into an existing entry for the same UUID
+                (True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
             timeout (int, optional): Overrides default timeout used when querying the GraphQL API. Specified in seconds.
             offset (int, optional): The offset for pagination.
             limit (int, optional): The limit for pagination.
@@ -967,6 +982,7 @@ async def all(
             branch=branch,
             timeout=timeout,
             populate_store=populate_store,
+            merge=merge,
             offset=offset,
             limit=limit,
             include=include,
@@ -988,6 +1004,7 @@ async def filters(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -1011,6 +1028,7 @@ async def filters(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -1033,6 +1051,7 @@ async def filters(  # noqa: C901
         branch: str | None = None,
         timeout: int | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         offset: int | None = None,
         limit: int | None = None,
         include: list[str] | None = None,
@@ -1055,6 +1074,10 @@ async def filters(  # noqa: C901
             branch (str, optional): Name of the branch to query from. Defaults to default_branch.
             timeout (int, optional): Overrides default timeout used when querying the GraphQL API. Specified in seconds.
             populate_store (bool, optional): Flag to indicate whether to populate the store with the retrieved nodes.
+                The store holds one timestamp context per branch (live, or the first `at` used): a query whose `at`
+                does not match that context skips the store with a warning instead of blending inconsistent data.
+            merge (bool, optional): Whether nodes added to the store merge into an existing entry for the same UUID
+                (True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
             offset (int, optional): The offset for pagination.
             limit (int, optional): The limit for pagination.
             include (list[str], optional): List of attributes or relationships to include in the query.
@@ -1158,14 +1181,18 @@ async def process_non_batch() -> tuple[list[InfrahubNode], list[InfrahubNode]]:
         # Select parallel or non-parallel processing
         nodes, related_nodes = await (process_batch() if parallel else process_non_batch())
 
-        if populate_store:
+        if (
+            populate_store
+            and (nodes or related_nodes)
+            and self.store._reserve_at_context(at=at.to_string() if at else None, branch=branch)
+        ):
             for node in nodes:
                 if node.id:
-                    self.store.set(node=node)
+                    self.store.set(node=node, merge=merge)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(node=node)
+                    self.store.set(node=node, merge=merge)
         return nodes
 
     def clone(self, branch: str | None = None) -> InfrahubClient:
@@ -2058,7 +2085,7 @@ def _initialize(self) -> None:
         self.schema = InfrahubSchemaSync(self)
         self.branch = InfrahubBranchManagerSync(self)
         self.object_store = ObjectStoreSync(self)
-        self.store = NodeStoreSync(default_branch=self.default_branch)
+        self.store = NodeStoreSync(default_branch=self.default_branch, default_merge=self.config.store_merge)
         self.task = InfrahubTaskManagerSync(self)
         self._request_method: SyncRequester = self.config.sync_requester or self._default_request_method
         self.group_context = InfrahubGroupContextSync(self)
@@ -2579,6 +2606,7 @@ def all(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -2600,6 +2628,7 @@ def all(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -2620,6 +2649,7 @@ def all(
         branch: str | None = None,
         timeout: int | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         offset: int | None = None,
         limit: int | None = None,
         include: list[str] | None = None,
@@ -2640,6 +2670,10 @@ def all(
             branch (str, optional): Name of the branch to query from. Defaults to default_branch.
             timeout (int, optional): Overrides default timeout used when querying the GraphQL API. Specified in seconds.
             populate_store (bool, optional): Flag to indicate whether to populate the store with the retrieved nodes.
+                The store holds one timestamp context per branch (live, or the first `at` used): a query whose `at`
+                does not match that context skips the store with a warning instead of blending inconsistent data.
+            merge (bool, optional): Whether nodes added to the store merge into an existing entry for the same UUID
+                (True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
             offset (int, optional): The offset for pagination.
             limit (int, optional): The limit for pagination.
             include (list[str], optional): List of attributes or relationships to include in the query.
@@ -2663,6 +2697,7 @@ def all(
             branch=branch,
             timeout=timeout,
             populate_store=populate_store,
+            merge=merge,
             offset=offset,
             limit=limit,
             include=include,
@@ -2725,6 +2760,7 @@ def filters(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -2748,6 +2784,7 @@ def filters(
         branch: str | None = ...,
         timeout: int | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         offset: int | None = ...,
         limit: int | None = ...,
         include: list[str] | None = ...,
@@ -2770,6 +2807,7 @@ def filters(  # noqa: C901
         branch: str | None = None,
         timeout: int | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         offset: int | None = None,
         limit: int | None = None,
         include: list[str] | None = None,
@@ -2792,6 +2830,10 @@ def filters(  # noqa: C901
             branch (str, optional): Name of the branch to query from. Defaults to default_branch.
             timeout (int, optional): Overrides default timeout used when querying the GraphQL API. Specified in seconds.
             populate_store (bool, optional): Flag to indicate whether to populate the store with the retrieved nodes.
+                The store holds one timestamp context per branch (live, or the first `at` used): a query whose `at`
+                does not match that context skips the store with a warning instead of blending inconsistent data.
+            merge (bool, optional): Whether nodes added to the store merge into an existing entry for the same UUID
+                (True) or replace it wholesale (False). Defaults to the client's `store_merge` configuration (merge).
             offset (int, optional): The offset for pagination.
             limit (int, optional): The limit for pagination.
             include (list[str], optional): List of attributes or relationships to include in the query.
@@ -2897,14 +2939,18 @@ def process_non_batch() -> tuple[list[InfrahubNodeSync], list[InfrahubNodeSync]]
         # Select parallel or non-parallel processing
         nodes, related_nodes = process_batch() if parallel else process_non_batch()
 
-        if populate_store:
+        if (
+            populate_store
+            and (nodes or related_nodes)
+            and self.store._reserve_at_context(at=at.to_string() if at else None, branch=branch)
+        ):
             for node in nodes:
                 if node.id:
-                    self.store.set(node=node)
+                    self.store.set(node=node, merge=merge)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(node=node)
+                    self.store.set(node=node, merge=merge)
         return nodes
 
     @overload
@@ -2920,6 +2966,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -2941,6 +2988,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -2962,6 +3010,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -2983,6 +3032,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -3004,6 +3054,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -3025,6 +3076,7 @@ def get(
         include: list[str] | None = ...,
         exclude: list[str] | None = ...,
         populate_store: bool = ...,
+        merge: bool | None = ...,
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
@@ -3045,6 +3097,7 @@ def get(
         include: list[str] | None = None,
         exclude: list[str] | None = None,
         populate_store: bool = True,
+        merge: bool | None = None,
         fragment: bool = False,
         prefetch_relationships: bool = False,
         property: bool = False,
@@ -3080,6 +3133,7 @@ def get(
             branch=branch,
             timeout=timeout,
             populate_store=populate_store,
+            merge=merge,
             include=include,
             exclude=exclude,
             fragment=fragment,
diff --git a/infrahub_sdk/config.py b/infrahub_sdk/config.py
index e9e66e6f4..64aaec359 100644
--- a/infrahub_sdk/config.py
+++ b/infrahub_sdk/config.py
@@ -64,6 +64,15 @@ class ConfigBase(BaseSettings):
     schema_converge_timeout: int = Field(
         default=60, description="Number of seconds to wait for schema to have converged"
     )
+    store_merge: bool = Field(
+        default=True,
+        description=(
+            "When True, re-querying a node already in the client store updates only the "
+            "fields that were fetched and preserves previously fetched attributes and "
+            "relationships. When False, the latest query fully replaces the stored node, "
+            "which can drop data fetched by earlier queries (the pre-1.23.0 behaviour)."
+        ),
+    )
     timeout: int = Field(default=60, description="Default connection timeout in seconds")
     transport: RequesterTransport = Field(
         default=RequesterTransport.HTTPX, description="Set an alternate transport using a predefined option"
diff --git a/infrahub_sdk/node/attribute.py b/infrahub_sdk/node/attribute.py
index d70d7ee93..b40346a1c 100644
--- a/infrahub_sdk/node/attribute.py
+++ b/infrahub_sdk/node/attribute.py
@@ -4,6 +4,7 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, NamedTuple, get_args
 
+from ..utils import intern_frozenset
 from ..uuidt import UUIDT
 from .constants import ATTRIBUTE_METADATA_OBJECT, IP_TYPES, PROPERTIES_FLAG, PROPERTIES_OBJECT, SAFE_VALUE
 from .property import NodeProperty
@@ -53,6 +54,9 @@ class Attribute:
         id (str | None): The unique identifier of the attribute, when known.
         value (Any): The current attribute value. Setting this marks the attribute as mutated.
         value_has_been_mutated (bool): True when ``value`` has been assigned after construction.
+        is_fetched (bool): True when this attribute was present in the response the node
+            was built from. Used by the client store to decide whether a re-fetch carried
+            fresh data for this attribute.
         is_default (bool | None): True when the value comes from the schema default.
         is_from_profile (bool | None): True when the value is inherited from a profile.
         is_inherited (bool | None): True when the attribute is inherited from a generic.
@@ -64,7 +68,7 @@ class Attribute:
 
     """
 
-    def __init__(self, name: str, schema: AttributeSchemaAPI, data: Any | dict) -> None:
+    def __init__(self, name: str, schema: AttributeSchemaAPI, data: Any | dict, is_fetched: bool = True) -> None:
         """Build an ``Attribute`` from raw GraphQL data.
 
         IP-typed attributes (``IPHost``, ``IPNetwork``) are parsed via the standard
@@ -76,11 +80,16 @@ def __init__(self, name: str, schema: AttributeSchemaAPI, data: Any | dict) -> N
             data (Any | dict): The data for the attribute. Either a scalar value, a dict
                 with a ``value`` key (and optional metadata properties), or a dict with a
                 ``from_pool`` key to allocate the value from a resource pool when saving.
+            is_fetched (bool, optional): Whether this attribute was present in the response
+                the node was built from. Defaults to ``True`` so manual construction keeps
+                its current behaviour; ``InfrahubNodeBase._init_attributes`` passes the real
+                key-presence signal.
 
         """
         self.name = name
         self._schema = schema
         self._from_pool: dict[str, Any] | None = None
+        self.is_fetched = is_fetched
 
         if isinstance(data, dict) and "from_pool" in data:
             self._from_pool = data.pop("from_pool")
@@ -94,6 +103,12 @@ def __init__(self, name: str, schema: AttributeSchemaAPI, data: Any | dict) -> N
 
         self._read_only = ["updated_at", "is_inherited"]
 
+        # Sub-fields carried by the response this attribute was built from. Consumed by
+        # _merge() so a value-only re-fetch does not null out previously fetched
+        # properties (source, owner, is_protected, ...). Interned: every attribute
+        # built from the same query shape shares one instance.
+        self._fetched_fields: frozenset[str] = intern_frozenset(data.keys()) if is_fetched else frozenset()
+
         self.id: str | None = data.get("id")
 
         self._value: Any | None = data.get("value")
@@ -135,6 +150,38 @@ def value(self, value: Any) -> None:
         self._value = value
         self.value_has_been_mutated = True
 
+    def _merge(self, incoming: Attribute) -> None:
+        """Merge a fresher copy of this attribute into this one, sub-field by sub-field.
+
+        Only the sub-fields the incoming fetch actually carried are overwritten (even to
+        ``None``); sub-fields it did not carry keep their stored value. An incoming
+        unsaved edit is taken along with its pending-mutation marker, so it is still
+        sent on the next save of the merged object. Callers are responsible for the
+        higher-level gates (``is_fetched`` on the incoming attribute,
+        ``value_has_been_mutated`` on this one).
+        """
+        fetched = incoming._fetched_fields
+        if "value" in fetched or incoming.value_has_been_mutated:
+            self._value = incoming._value
+            # The pool-allocation intent travels with the value: a fetched copy carries
+            # None, clearing any stale allocation request that would otherwise take
+            # precedence over the value in the next mutation payload.
+            self._from_pool = incoming._from_pool
+            if incoming.value_has_been_mutated:
+                self.value_has_been_mutated = True
+        for field_name in (
+            "id",
+            "is_default",
+            "is_from_profile",
+            "is_inherited",
+            *self._properties,
+            *ATTRIBUTE_METADATA_OBJECT,
+        ):
+            if field_name in fetched:
+                setattr(self, field_name, getattr(incoming, field_name))
+        self._fetched_fields = intern_frozenset(self._fetched_fields | fetched)
+        self.is_fetched = True
+
     def _initialize_graphql_payload(self) -> _GraphQLPayloadAttribute:
         """Resolve the attribute value into a GraphQL mutation payload object."""
         # Pool-based allocation (dict data or resource-pool node)
diff --git a/infrahub_sdk/node/node.py b/infrahub_sdk/node/node.py
index 9bdaa20cc..6b341d6b3 100644
--- a/infrahub_sdk/node/node.py
+++ b/infrahub_sdk/node/node.py
@@ -42,6 +42,7 @@
 
     from ..client import InfrahubClient, InfrahubClientSync
     from ..context import RequestContext
+    from ..protocols_base import CoreNodeBase
     from ..schema import MainSchemaTypesAPI
     from ..types import Order
 
@@ -72,6 +73,15 @@ class UploadResult:
     checksum: str | None
 
 
+# A node holds relationships in three separate containers (defined on the async/sync
+# subclasses); everything that walks "all relationships" must cover all three.
+RELATIONSHIP_CONTAINER_FIELDS = (
+    "_relationship_cardinality_one_data",
+    "_relationship_cardinality_many_data",
+    "_hierarchical_data",
+)
+
+
 class InfrahubNodeBase:
     """Base class for :class:`InfrahubNode` and :class:`InfrahubNodeSync`.
 
@@ -266,11 +276,24 @@ def get_node_metadata(self) -> NodeMetadata | None:
         """
         return self._metadata
 
+    @staticmethod
+    def _field_was_fetched(data: object, name: str) -> bool:
+        """Return whether a field was present in the response a node was built from.
+
+        Key-presence is the only unambiguous "was fetched" signal: an absent field and
+        a fetched-but-null one both collapse to a ``None`` value. Non-dict data (nodes
+        built without a payload) carries no fields.
+        """
+        return isinstance(data, dict) and name in data
+
     def _init_attributes(self, data: dict | None = None) -> None:
         for attr_schema in self._schema.attributes:
             attr_data = data.get(attr_schema.name, None) if isinstance(data, dict) else None
             self._attribute_data[attr_schema.name] = Attribute(
-                name=attr_schema.name, schema=attr_schema, data=attr_data
+                name=attr_schema.name,
+                schema=attr_schema,
+                data=attr_data,
+                is_fetched=self._field_was_fetched(data, attr_schema.name),
             )
 
     def __setattr__(self, name: str, value: Any) -> None:
@@ -294,6 +317,121 @@ def _get_request_context(self, request_context: RequestContext | None = None) ->
     def _init_relationships(self, data: dict | None = None) -> None:
         pass
 
+    def _merge(self, node: InfrahubNodeBase | CoreNodeBase) -> None:
+        """Merge a fresher copy of the same node into this one, field by field.
+
+        Used by the client store when a node with this UUID is fetched again: fields the
+        new fetch carried (attributes, relationships, node-level scalars) overwrite the
+        stored ones - even to empty or ``None`` - while fields the new fetch did not
+        request keep their stored value. Local unsaved edits on this node
+        (``value_has_been_mutated`` / ``_peer_has_been_mutated``) always win over the
+        incoming copy. Both nodes must be of the same kind; the store replaces the entry
+        wholesale on a kind change instead of calling this.
+        """
+        incoming_data = node._data if isinstance(node._data, dict) else {}
+        if not isinstance(self._data, dict):
+            self._data = {}
+        stored_data = self._data
+
+        if "display_label" in incoming_data:
+            self.display_label = node.display_label
+            stored_data["display_label"] = incoming_data["display_label"]
+        if "__typename" in incoming_data:
+            self.typename = node.typename
+            stored_data["__typename"] = incoming_data["__typename"]
+        if node._metadata is not None:
+            self._metadata = node._metadata
+        if node._existing:
+            self._existing = True
+
+        for name, incoming_attr in node._attribute_data.items():
+            if self._merge_attribute(name, incoming_attr):
+                self._merge_raw_field(name=name, stored_data=stored_data, incoming_data=incoming_data)
+
+        for container_field in RELATIONSHIP_CONTAINER_FIELDS:
+            incoming_bucket: dict[str, RelatedNodeBase | RelationshipManagerBase] = getattr(node, container_field, {})
+            stored_bucket: dict[str, RelatedNodeBase | RelationshipManagerBase] = getattr(self, container_field, {})
+            for name, incoming_rel in incoming_bucket.items():
+                if self._merge_relationship(stored_bucket, name, incoming_rel):
+                    self._merge_raw_field(name=name, stored_data=stored_data, incoming_data=incoming_data)
+
+    @staticmethod
+    def _merge_raw_field(name: str, stored_data: dict, incoming_data: dict) -> None:
+        """Fold one field of the incoming raw GraphQL payload into ``stored_data``.
+
+        ``_data`` is the baseline ``update()`` diffs against, so it must track the
+        merged object state: dicts merge key-wise (mirroring the sub-field merge on
+        ``Attribute`` / ``RelatedNode``), anything else is replaced.
+        """
+        if name not in incoming_data:
+            return
+        incoming_value = incoming_data[name]
+        stored_value = stored_data.get(name)
+        if isinstance(stored_value, dict) and isinstance(incoming_value, dict):
+            stored_data[name] = {**stored_value, **incoming_value}
+        else:
+            stored_data[name] = incoming_value
+
+    def _merge_attribute(self, name: str, incoming_attr: Attribute) -> bool:
+        """Merge one attribute into ``_attribute_data``; return whether it was taken."""
+        if not incoming_attr.is_fetched and not incoming_attr.value_has_been_mutated:
+            return False
+        stored_attr = self._attribute_data.get(name)
+        if stored_attr is None:
+            self._attribute_data[name] = incoming_attr
+        elif stored_attr.value_has_been_mutated:
+            return False
+        else:
+            stored_attr._merge(incoming_attr)
+        return True
+
+    @staticmethod
+    def _merge_relationship(
+        stored_bucket: dict[str, RelatedNodeBase | RelationshipManagerBase],
+        name: str,
+        incoming_rel: RelatedNodeBase | RelationshipManagerBase,
+    ) -> bool:
+        """Merge one relationship entry into ``stored_bucket``; return whether it was taken."""
+        stored_rel = stored_bucket.get(name)
+        if isinstance(incoming_rel, RelatedNodeBase):
+            if not incoming_rel.is_fetched and not incoming_rel._peer_has_been_mutated:
+                return False
+            if not isinstance(stored_rel, RelatedNodeBase):
+                stored_bucket[name] = incoming_rel
+            elif stored_rel._peer_has_been_mutated:
+                return False
+            else:
+                stored_rel._merge(incoming_rel)
+            return True
+
+        if not incoming_rel.is_fetched:
+            return False
+        if not isinstance(stored_rel, RelationshipManagerBase):
+            stored_bucket[name] = incoming_rel
+        elif stored_rel.has_update:
+            return False
+        else:
+            stored_rel._merge(incoming_rel)
+        return True
+
+    def _reset_mutation_tracking(self) -> None:
+        """Mark the current in-memory state as persisted.
+
+        Called after a successful create/update mutation: every value this object holds
+        now matches what the server accepted, so the per-field mutation markers are
+        cleared. Without this, the store merge would treat long-saved edits as pending
+        local changes and never refresh those fields from later fetches.
+        """
+        for attr in self._attribute_data.values():
+            attr.value_has_been_mutated = False
+        for container_field in RELATIONSHIP_CONTAINER_FIELDS:
+            container: dict[str, RelatedNodeBase | RelationshipManagerBase] = getattr(self, container_field, {})
+            for rel in container.values():
+                if isinstance(rel, RelatedNodeBase):
+                    rel._peer_has_been_mutated = False
+                elif isinstance(rel, RelationshipManagerBase):
+                    rel._has_update = False
+
     def __repr__(self) -> str:
         if self.display_label:
             return self.display_label
@@ -912,7 +1050,12 @@ def _init_relationships(self, data: dict | RelatedNode | None = None) -> None:
                     }
                     rel_data = peer_id_data or None
                 self._relationship_cardinality_one_data[rel_schema.name] = RelatedNode(
-                    name=rel_schema.name, branch=self._branch, client=self._client, schema=rel_schema, data=rel_data
+                    name=rel_schema.name,
+                    branch=self._branch,
+                    client=self._client,
+                    schema=rel_schema,
+                    data=rel_data,
+                    is_fetched=self._field_was_fetched(data, rel_schema.name),
                 )
             else:
                 self._relationship_cardinality_many_data[rel_schema.name] = RelationshipManager(
@@ -933,6 +1076,7 @@ def _init_relationships(self, data: dict | RelatedNode | None = None) -> None:
                     branch=self._branch,
                     schema=rel_schema,
                     data=rel_data,
+                    is_fetched=self._field_was_fetched(data, rel_schema.name),
                 )
             else:
                 self._hierarchical_data[rel_schema.name] = RelationshipManager(
@@ -1599,6 +1743,10 @@ async def _process_mutation_result(
             await related_node.fetch(timeout=timeout)
             setattr(self, rel_name, related_node)
 
+        # The mutation succeeded: the in-memory state (including pool allocations
+        # applied above) is now the persisted state.
+        self._reset_mutation_tracking()
+
     async def create(
         self, allow_upsert: bool = False, timeout: int | None = None, request_context: RequestContext | None = None
     ) -> None:
@@ -2102,7 +2250,12 @@ def _init_relationships(self, data: dict | None = None) -> None:
                     }
                     rel_data = peer_id_data or None
                 self._relationship_cardinality_one_data[rel_schema.name] = RelatedNodeSync(
-                    name=rel_schema.name, branch=self._branch, client=self._client, schema=rel_schema, data=rel_data
+                    name=rel_schema.name,
+                    branch=self._branch,
+                    client=self._client,
+                    schema=rel_schema,
+                    data=rel_data,
+                    is_fetched=self._field_was_fetched(data, rel_schema.name),
                 )
             else:
                 self._relationship_cardinality_many_data[rel_schema.name] = RelationshipManagerSync(
@@ -2124,6 +2277,7 @@ def _init_relationships(self, data: dict | None = None) -> None:
                     branch=self._branch,
                     schema=rel_schema,
                     data=rel_data,
+                    is_fetched=self._field_was_fetched(data, rel_schema.name),
                 )
             else:
                 self._hierarchical_data[rel_schema.name] = RelationshipManagerSync(
@@ -2786,6 +2940,10 @@ def _process_mutation_result(
             related_node.fetch(timeout=timeout)
             setattr(self, rel_name, related_node)
 
+        # The mutation succeeded: the in-memory state (including pool allocations
+        # applied above) is now the persisted state.
+        self._reset_mutation_tracking()
+
     def create(
         self, allow_upsert: bool = False, timeout: int | None = None, request_context: RequestContext | None = None
     ) -> None:
diff --git a/infrahub_sdk/node/related_node.py b/infrahub_sdk/node/related_node.py
index 229aad61f..ca3b993bc 100644
--- a/infrahub_sdk/node/related_node.py
+++ b/infrahub_sdk/node/related_node.py
@@ -7,6 +7,7 @@
 
 from ..exceptions import Error
 from ..protocols_base import CoreNodeBase
+from ..utils import intern_frozenset
 from .constants import PROFILE_KIND_PREFIX, PROPERTIES_FLAG, PROPERTIES_OBJECT
 from .metadata import NodeMetadata, RelationshipMetadata
 
@@ -36,10 +37,29 @@ class RelatedNodeBase:
         schema (RelationshipSchemaAPI): The schema describing the relationship.
         name (str | None): The name of the relationship slot on the parent node.
         updated_at (str | None): ISO-8601 timestamp of the most recent edge update.
+        is_fetched (bool): True when this relationship was present in the response the
+            node was built from. Unlike ``initialized`` (which means "has a peer"), this
+            is also True for a fetched-but-empty relationship, so the client store can
+            distinguish "cleared on the server" from "not queried".
 
     """
 
-    def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict, name: str | None = None) -> None:
+    # Relationship-edge properties, assigned dynamically in _init_properties from
+    # PROPERTIES_FLAG / PROPERTIES_OBJECT; declared here so they are part of the
+    # visible class surface.
+    is_protected: bool | None
+    updated_at: str | None
+    source: str | None
+    owner: str | None
+
+    def __init__(
+        self,
+        branch: str,
+        schema: RelationshipSchemaAPI,
+        data: Any | dict,
+        name: str | None = None,
+        is_fetched: bool | None = None,
+    ) -> None:
         """Build a ``RelatedNodeBase`` from raw data.
 
         Args:
@@ -49,6 +69,10 @@ def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict,
                 :class:`CoreNodeBase` instance, a list (treated as an HFID), a string
                 (treated as an ID), or a dict in either paginated or flat GraphQL format.
             name (str, optional): The name of the relationship slot on the parent node.
+            is_fetched (bool, optional): Whether this relationship was present in the
+                response the node was built from. ``InfrahubNodeBase._init_relationships``
+                passes the real key-presence signal so a fetched-but-empty relationship
+                still reads as fetched; when omitted it is inferred from ``data``.
 
         """
         self.schema = schema
@@ -60,6 +84,11 @@ def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict,
         self._properties_object = PROPERTIES_OBJECT
         self._properties = self._properties_flag + self._properties_object
 
+        self.is_fetched: bool = data is not None if is_fetched is None else is_fetched
+        # Relationship-edge properties carried by the response, consumed by _merge() so a
+        # re-fetch without properties does not null out previously fetched ones.
+        self._fetched_properties: frozenset[str] = frozenset()
+
         self._peer: InfrahubNodeBase | CoreNodeBase | None = None
         self._id: str | None = None
         self._hfid: list[str] | None = None
@@ -107,21 +136,28 @@ def __init__(self, branch: str, schema: RelationshipSchemaAPI, data: Any | dict,
             if self._typename and self._typename.startswith("Related"):
                 self._typename = self._typename[7:]
 
-            for prop in self._properties:
-                prop_data = properties_data.get(prop, properties_data.get(f"_relation__{prop}", None))
-                if prop_data and isinstance(prop_data, dict) and "id" in prop_data:
-                    setattr(self, prop, prop_data["id"])
-                    if prop == "source" and "__typename" in prop_data:
-                        self._source_typename = prop_data["__typename"]
-                elif prop_data and isinstance(prop_data, (str, bool)):
-                    setattr(self, prop, prop_data)
-                else:
-                    setattr(self, prop, None)
+            self._init_properties(properties_data)
 
             # Parse relationship metadata (at edge level)
             if data.get("relationship_metadata"):
                 self._relationship_metadata = RelationshipMetadata(data["relationship_metadata"])
 
+    def _init_properties(self, properties_data: dict) -> None:
+        self._fetched_properties = intern_frozenset(
+            prop for prop in self._properties if prop in properties_data or f"_relation__{prop}" in properties_data
+        )
+
+        for prop in self._properties:
+            prop_data = properties_data.get(prop, properties_data.get(f"_relation__{prop}"))
+            if prop_data and isinstance(prop_data, dict) and "id" in prop_data:
+                setattr(self, prop, prop_data["id"])
+                if prop == "source" and "__typename" in prop_data:
+                    self._source_typename = prop_data["__typename"]
+            elif prop_data and isinstance(prop_data, (str, bool)):
+                setattr(self, prop, prop_data)
+            else:
+                setattr(self, prop, None)
+
     @property
     def id(self) -> str | None:
         """Return the parsed peer id without triggering a store lookup.
@@ -251,6 +287,58 @@ def get_relationship_metadata(self) -> RelationshipMetadata | None:
         """
         return self._relationship_metadata
 
+    def _merge(self, incoming: RelatedNodeBase) -> None:
+        """Merge a fresher copy of this relationship into this one.
+
+        Which peer the relationship points at always refreshes (even to no peer, so a
+        cleared relationship or a move-to-root is reflected). A changed peer means a
+        different relationship edge, so the incoming edge is taken wholesale,
+        properties included. When the peer stays the same, its descriptive identity
+        fields (hfid, display label, typename, kind) and the edge properties are only
+        overwritten when the incoming fetch actually carried them, so a narrow payload
+        does not null out previously fetched data. An incoming unsaved edit keeps its
+        pending-mutation marker. Callers are responsible for the higher-level gates
+        (``is_fetched`` on the incoming relationship, ``_peer_has_been_mutated`` on
+        this one).
+        """
+        # An hfid-only relationship (no id on either side) changes peer when the hfid does.
+        peer_changed = incoming._id != self._id or (incoming._id is None and incoming._hfid != self._hfid)
+        if peer_changed:
+            self._peer = incoming._peer
+            self._id = incoming._id
+            self._hfid = incoming._hfid
+            self._display_label = incoming._display_label
+            self._typename = incoming._typename
+            self._kind = incoming._kind
+            # The stored properties and metadata described the edge to the old peer;
+            # they must not survive onto the new edge.
+            for prop in self._properties:
+                setattr(self, prop, getattr(incoming, prop))
+            self._source_typename = incoming._source_typename
+            self._relationship_metadata = incoming._relationship_metadata
+            self._fetched_properties = incoming._fetched_properties
+        else:
+            if incoming._peer is not None:
+                self._peer = incoming._peer
+            if incoming._hfid is not None:
+                self._hfid = incoming._hfid
+            if incoming._display_label is not None:
+                self._display_label = incoming._display_label
+            if incoming._typename is not None:
+                self._typename = incoming._typename
+            if incoming._kind is not None:
+                self._kind = incoming._kind
+            for prop in self._properties:
+                if prop in incoming._fetched_properties:
+                    setattr(self, prop, getattr(incoming, prop))
+                    if prop == "source":
+                        self._source_typename = incoming._source_typename
+            if incoming._relationship_metadata is not None:
+                self._relationship_metadata = incoming._relationship_metadata
+            self._fetched_properties = intern_frozenset(self._fetched_properties | incoming._fetched_properties)
+        self.is_fetched = True
+        self._peer_has_been_mutated = incoming._peer_has_been_mutated
+
     def _generate_input_data(self, allocate_from_pool: bool = False) -> dict[str, Any]:
         data: dict[str, Any] = {}
 
@@ -333,6 +421,7 @@ def __init__(
         schema: RelationshipSchemaAPI,
         data: Any | dict,
         name: str | None = None,
+        is_fetched: bool | None = None,
     ) -> None:
         """Initialize the async related node.
 
@@ -342,10 +431,12 @@ def __init__(
             schema (RelationshipSchema): The schema of the relationship.
             data (Union[Any, dict]): Data representing the related node.
             name (Optional[str]): The name of the related node.
+            is_fetched (Optional[bool]): Whether the relationship was present in the response
+                the node was built from. Inferred from ``data`` when omitted.
 
         """
         self._client = client
-        super().__init__(branch=branch, schema=schema, data=data, name=name)
+        super().__init__(branch=branch, schema=schema, data=data, name=name, is_fetched=is_fetched)
 
     async def fetch(self, timeout: int | None = None) -> None:
         """Fetch the full peer node from the backend and cache it on this object.
@@ -429,6 +520,7 @@ def __init__(
         schema: RelationshipSchemaAPI,
         data: Any | dict,
         name: str | None = None,
+        is_fetched: bool | None = None,
     ) -> None:
         """Initialize the sync related node.
 
@@ -438,10 +530,12 @@ def __init__(
             schema (RelationshipSchema): The schema of the relationship.
             data (Union[Any, dict]): Data representing the related node.
             name (Optional[str]): The name of the related node.
+            is_fetched (Optional[bool]): Whether the relationship was present in the response
+                the node was built from. Inferred from ``data`` when omitted.
 
         """
         self._client = client
-        super().__init__(branch=branch, schema=schema, data=data, name=name)
+        super().__init__(branch=branch, schema=schema, data=data, name=name, is_fetched=is_fetched)
 
     def fetch(self, timeout: int | None = None) -> None:
         """Fetch the full peer node from the backend and cache it on this object.
diff --git a/infrahub_sdk/node/relationship.py b/infrahub_sdk/node/relationship.py
index 7069b13ee..dbc7aacc6 100644
--- a/infrahub_sdk/node/relationship.py
+++ b/infrahub_sdk/node/relationship.py
@@ -57,6 +57,20 @@ def __init__(self, name: str, branch: str, schema: RelationshipSchemaAPI) -> Non
 
         self.peers: list[RelatedNode[PeerT] | RelatedNodeSync[PeerT]] = []
 
+    @property
+    def is_fetched(self) -> bool:
+        """Return whether this relationship was present in the response the node was built from.
+
+        Alias of ``initialized`` (which already means "was fetched" for cardinality-many
+        relationships), exposed under the same name as on ``Attribute`` and
+        ``RelatedNode`` so merge logic can branch uniformly on ``is_fetched``.
+
+        Returns:
+            bool: ``True`` when the peer set was populated from a response.
+
+        """
+        return self.initialized
+
     @property
     def peer_ids(self) -> list[str]:
         """Return the IDs of all peers that have one.
@@ -113,6 +127,18 @@ def is_from_profile(self) -> bool:
         all_profiles = [p.is_from_profile for p in self.peers]
         return bool(all_profiles) and all(all_profiles)
 
+    def _merge(self, incoming: RelationshipManagerBase[PeerT]) -> None:
+        """Merge a fresher copy of this relationship into this one.
+
+        The fetched member list replaces the stored one, never unions with it, so a peer
+        removed on the server is correctly dropped. An incoming unsaved add()/remove()
+        keeps its pending-update marker. Callers are responsible for the higher-level
+        gates (``is_fetched`` on the incoming manager, ``has_update`` on this one).
+        """
+        self.peers = list(incoming.peers)
+        self.initialized = True
+        self._has_update = incoming._has_update
+
     def _generate_input_data(self, allocate_from_pool: bool = False) -> list[dict]:
         return [peer._generate_input_data(allocate_from_pool=allocate_from_pool) for peer in self.peers]
 
diff --git a/infrahub_sdk/protocols_base.py b/infrahub_sdk/protocols_base.py
index 57d4f23fd..520b4e87d 100644
--- a/infrahub_sdk/protocols_base.py
+++ b/infrahub_sdk/protocols_base.py
@@ -6,6 +6,8 @@
     import ipaddress
 
     from .context import RequestContext
+    from .node import InfrahubNodeBase
+    from .node.attribute import Attribute as NodeAttribute
     from .node.metadata import NodeMetadata
     from .schema import MainSchemaTypes
 
@@ -175,6 +177,10 @@ class AnyAttributeOptional(Attribute):
 class CoreNodeBase:
     _schema: MainSchemaTypes
     _internal_id: str
+    _data: dict | None
+    _existing: bool
+    _metadata: NodeMetadata | None
+    _attribute_data: dict[str, NodeAttribute]
     id: str  # NOTE this is incorrect, should be str | None
     display_label: str | None
     typename: str | None
@@ -211,6 +217,9 @@ def get_raw_graphql_data(self) -> dict | None: ...
 
     def get_node_metadata(self) -> NodeMetadata | None: ...
 
+    def _merge(self, node: CoreNodeBase | InfrahubNodeBase) -> None:
+        raise NotImplementedError
+
 
 class CoreNode(CoreNodeBase):
     async def save(
diff --git a/infrahub_sdk/store.py b/infrahub_sdk/store.py
index 9b061ec31..274b125a0 100644
--- a/infrahub_sdk/store.py
+++ b/infrahub_sdk/store.py
@@ -40,24 +40,88 @@ def __init__(self, name: str) -> None:
         self._hfids: dict[str, dict[tuple, str]] = {}
         self._keys: dict[str, str] = {}
         self._uuids: dict[str, str] = {}
+        # The timestamp context this branch cache holds data for: None means live data,
+        # a timestamp string means every entry was fetched at that point in time. Set on
+        # first population; queries at a different timestamp must not blend in (see
+        # NodeStoreBase._reserve_at_context).
+        self._at_context: str | None = None
+        self._has_at_context: bool = False
+        # Reverse indexes so set()/_evict() never scan the forward indexes. Both are
+        # keyed by internal id: which (kind, hfid) entries and which custom keys point
+        # at that object. set() is the hottest path in the SDK (every fetched node and
+        # every related node goes through it), so it must stay O(1) per call.
+        self._hfids_by_internal_id: dict[str, list[tuple[str, tuple]]] = {}
+        self._keys_by_internal_id: dict[str, set[str]] = {}
 
     def count(self) -> int:
         return len(self._objs)
 
-    def set(self, node: InfrahubNode | InfrahubNodeSync | CoreNode | CoreNodeSync, key: str | None = None) -> None:
+    def set(
+        self,
+        node: InfrahubNode | InfrahubNodeSync | CoreNode | CoreNodeSync,
+        key: str | None = None,
+        merge: bool = True,
+    ) -> None:
+        if node.id and node.id in self._uuids:
+            existing = self._objs.get(self._uuids[node.id])
+            if existing is not None and existing is not node:
+                if merge and existing.get_kind() == node.get_kind():
+                    # Merge into the existing object and keep its internal id so every
+                    # reference already handed out by the store stays current.
+                    existing._merge(node)
+                    node = existing
+                else:
+                    # Replace wholesale: explicit merge=False, or the node was converted
+                    # to another kind (merging across two schemas is incoherent).
+                    self._evict(existing, replacement_internal_id=node._internal_id)
+
+        # The hfid may have changed if one of its component attributes was refreshed;
+        # drop the entries registered for this object before re-registering below.
+        self._discard_hfid_entries(internal_id=node._internal_id)
+
         self._objs[node._internal_id] = node
 
         if key:
-            self._keys[key] = node._internal_id
+            self._set_key(key=key, internal_id=node._internal_id)
 
         if node.id:
             self._uuids[node.id] = node._internal_id
 
         if hfid := node.get_human_friendly_id():
+            hfid_key = tuple(hfid)
+            registered: list[tuple[str, tuple]] = []
             for kind in node.get_all_kinds():
                 if kind not in self._hfids:
                     self._hfids[kind] = {}
-                self._hfids[kind][tuple(hfid)] = node._internal_id
+                self._hfids[kind][hfid_key] = node._internal_id
+                registered.append((kind, hfid_key))
+            self._hfids_by_internal_id[node._internal_id] = registered
+
+    def _set_key(self, key: str, internal_id: str) -> None:
+        previous_internal_id = self._keys.get(key)
+        if previous_internal_id is not None and previous_internal_id != internal_id:
+            previous_keys = self._keys_by_internal_id.get(previous_internal_id)
+            if previous_keys is not None:
+                previous_keys.discard(key)
+        self._keys[key] = internal_id
+        self._keys_by_internal_id.setdefault(internal_id, set()).add(key)
+
+    def _evict(
+        self, node: InfrahubNode | InfrahubNodeSync | CoreNode | CoreNodeSync, replacement_internal_id: str
+    ) -> None:
+        """Remove a stored node and repoint its custom keys at the node replacing it."""
+        self._objs.pop(node._internal_id, None)
+        self._discard_hfid_entries(internal_id=node._internal_id)
+        for custom_key in self._keys_by_internal_id.pop(node._internal_id, set()):
+            self._set_key(key=custom_key, internal_id=replacement_internal_id)
+
+    def _discard_hfid_entries(self, internal_id: str) -> None:
+        for kind, hfid_key in self._hfids_by_internal_id.pop(internal_id, []):
+            entries = self._hfids.get(kind)
+            # Only drop the entry if it still points at this object: another node may
+            # have claimed the same hfid since it was registered.
+            if entries is not None and entries.get(hfid_key) == internal_id:
+                del entries[hfid_key]
 
     def get(
         self,
@@ -204,7 +268,7 @@ class NodeStoreBase:
     we need to save them in order to reuse them later to associate them with another node for example.
     """
 
-    def __init__(self, default_branch: str | None = None) -> None:
+    def __init__(self, default_branch: str | None = None, default_merge: bool = True) -> None:
         self._branches: dict[str, NodeStoreBranch] = {}
 
         if default_branch is None:
@@ -217,22 +281,59 @@ def __init__(self, default_branch: str | None = None) -> None:
             )
 
         self._default_branch = default_branch
+        self._default_merge = default_merge
 
     def _get_branch(self, branch: str | None = None) -> str:
         return branch or self._default_branch
 
+    def _reserve_at_context(self, at: str | None, branch: str | None = None) -> bool:
+        """Return whether a query at the given timestamp may populate this branch cache.
+
+        The store is a per-field freshness cache and holds exactly one timestamp
+        context per branch: live data (``at is None``) or one point in time. The first
+        population stamps the context; later populations at the same timestamp merge as
+        usual, so a script that runs all its queries at one ``at`` gets full store
+        functionality. A mismatching timestamp must not blend in: the query is refused
+        (the caller skips population) and a warning is emitted, since the resulting
+        cache would silently mix data from different points in time.
+        """
+        branch = self._get_branch(branch)
+        if branch not in self._branches:
+            self._branches[branch] = NodeStoreBranch(name=branch)
+        store_branch = self._branches[branch]
+
+        if not store_branch._has_at_context:
+            store_branch._at_context = at
+            store_branch._has_at_context = True
+            return True
+        if store_branch._at_context == at:
+            return True
+
+        def describe(context: str | None) -> str:
+            return "live data" if context is None else f"data fetched at {context}"
+
+        warnings.warn(
+            f"Not populating the store for this query: the store for branch {branch!r} holds "
+            f"{describe(store_branch._at_context)} and this query uses {describe(at)}. Mixing "
+            "timestamps in the store would blend inconsistent data. Use a separate client "
+            "(client.clone()) for a different timestamp, or pass populate_store=False.",
+            stacklevel=4,
+        )
+        return False
+
     def _set(
         self,
         node: InfrahubNode | InfrahubNodeSync | SchemaType | SchemaTypeSync,
         key: str | None = None,
         branch: str | None = None,
+        merge: bool | None = None,
     ) -> None:
         branch = self._get_branch(branch or node.get_branch())
 
         if branch not in self._branches:
             self._branches[branch] = NodeStoreBranch(name=branch)
 
-        self._branches[branch].set(node=node, key=key)
+        self._branches[branch].set(node=node, key=key, merge=self._default_merge if merge is None else merge)
 
     def _get(  # type: ignore[no-untyped-def]
         self,
@@ -341,8 +442,33 @@ def get_by_hfid(
         )
         return self.get(key=key, raise_when_missing=raise_when_missing, branch=branch)
 
-    def set(self, node: InfrahubNode | SchemaType, key: str | None = None, branch: str | None = None) -> None:
-        return self._set(node=node, key=key, branch=branch)
+    def set(
+        self,
+        node: InfrahubNode | SchemaType,
+        key: str | None = None,
+        branch: str | None = None,
+        merge: bool | None = None,
+    ) -> None:
+        """Add a node to the store, merging it into any node already stored under the same UUID.
+
+        By default (``merge=None`` with the client's ``store_merge`` config left at
+        ``True``), a node whose UUID is already present is merged into the existing
+        object field by field: fields carried by ``node`` overwrite the stored ones,
+        fields it does not carry keep their stored value, and unsaved local edits on the
+        stored object win. Pass ``merge=False`` to drop all prior knowledge of the node
+        and store exactly this object instead.
+
+        Args:
+            node (InfrahubNode): The node to store.
+            key (str, optional): A custom key to also index the node under.
+            branch (str, optional): The branch to store the node in. Defaults to the
+                node's own branch.
+            merge (bool, optional): Whether to merge into an existing entry for the same
+                UUID (``True``) or replace it wholesale (``False``). Defaults to the
+                client's ``store_merge`` configuration (merge).
+
+        """
+        return self._set(node=node, key=key, branch=branch, merge=merge)
 
 
 class NodeStoreSync(NodeStoreBase):
@@ -429,5 +555,30 @@ def get_by_hfid(
         )
         return self.get(key=key, raise_when_missing=raise_when_missing, branch=branch)
 
-    def set(self, node: InfrahubNodeSync | SchemaTypeSync, key: str | None = None, branch: str | None = None) -> None:
-        return self._set(node=node, key=key, branch=branch)
+    def set(
+        self,
+        node: InfrahubNodeSync | SchemaTypeSync,
+        key: str | None = None,
+        branch: str | None = None,
+        merge: bool | None = None,
+    ) -> None:
+        """Add a node to the store, merging it into any node already stored under the same UUID.
+
+        By default (``merge=None`` with the client's ``store_merge`` config left at
+        ``True``), a node whose UUID is already present is merged into the existing
+        object field by field: fields carried by ``node`` overwrite the stored ones,
+        fields it does not carry keep their stored value, and unsaved local edits on the
+        stored object win. Pass ``merge=False`` to drop all prior knowledge of the node
+        and store exactly this object instead.
+
+        Args:
+            node (InfrahubNodeSync): The node to store.
+            key (str, optional): A custom key to also index the node under.
+            branch (str, optional): The branch to store the node in. Defaults to the
+                node's own branch.
+            merge (bool, optional): Whether to merge into an existing entry for the same
+                UUID (``True``) or replace it wholesale (``False``). Defaults to the
+                client's ``store_merge`` configuration (merge).
+
+        """
+        return self._set(node=node, key=key, branch=branch, merge=merge)
diff --git a/infrahub_sdk/utils.py b/infrahub_sdk/utils.py
index 95da7504d..1f6efb037 100644
--- a/infrahub_sdk/utils.py
+++ b/infrahub_sdk/utils.py
@@ -4,6 +4,7 @@
 import hashlib
 import json
 import uuid
+from collections.abc import Iterable
 from itertools import groupby
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -32,6 +33,22 @@ def generate_short_id() -> str:
     return base64.urlsafe_b64encode(uuid.uuid4().bytes).rstrip(b"=").decode("ascii").lower()
 
 
+_INTERNED_FROZENSETS: dict[frozenset[str], frozenset[str]] = {}
+
+
+def intern_frozenset(value: Iterable[str]) -> frozenset[str]:
+    """Return a canonical shared frozenset for the given items.
+
+    Field-presence sets are attached to every attribute and relationship the SDK
+    builds, and all objects produced by the same query carry identical sets. Sharing
+    one instance per distinct set keeps the per-object overhead at pointer size
+    instead of a full frozenset (~700 bytes) each. The cache is unbounded but only
+    grows with the number of distinct query shapes, which is small in practice.
+    """
+    candidate = frozenset(value)
+    return _INTERNED_FROZENSETS.setdefault(candidate, candidate)
+
+
 def base36encode(number: int) -> str:
     if not isinstance(number, (int)):
         raise TypeError("number must be an integer")
diff --git a/tests/unit/sdk/test_store_merge.py b/tests/unit/sdk/test_store_merge.py
new file mode 100644
index 000000000..b8c375bf5
--- /dev/null
+++ b/tests/unit/sdk/test_store_merge.py
@@ -0,0 +1,1169 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import pytest
+
+from infrahub_sdk.node import InfrahubNode, InfrahubNodeSync
+from infrahub_sdk.protocols import CoreRepository, CoreRepositorySync
+from infrahub_sdk.protocols_base import CoreNode, CoreNodeSync
+from infrahub_sdk.schema import AttributeSchema, NodeSchema
+from infrahub_sdk.schema.main import AttributeKind
+from infrahub_sdk.store import NodeStore, NodeStoreSync
+from infrahub_sdk.timestamp import Timestamp
+
+if TYPE_CHECKING:
+    from pytest_httpx import HTTPXMock
+
+    from infrahub_sdk import InfrahubClient, InfrahubClientSync
+    from infrahub_sdk.node import (
+        RelatedNode,
+        RelatedNodeSync,
+        RelationshipManager,
+        RelationshipManagerSync,
+    )
+    from infrahub_sdk.node.related_node import RelatedNodeBase
+    from infrahub_sdk.node.relationship import RelationshipManagerBase
+    from infrahub_sdk.protocols_base import String, StringOptional
+    from infrahub_sdk.schema import NodeSchemaAPI
+
+    from .conftest import BothClients
+
+pytestmark = pytest.mark.httpx_mock(can_send_already_matched_responses=True)
+
+client_types = ["standard", "sync"]
+
+LOCATION_ID = "llllllll-llll-llll-llll-llllllllllll"
+TAG_RED_ID = "rrrrrrrr-rrrr-rrrr-rrrr-rrrrrrrrrrrr"
+TAG_GREEN_ID = "gggggggg-gggg-gggg-gggg-gggggggggggg"
+TAG_BLUE_ID = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+
+
+class BuiltinLocation(CoreNode):
+    """Typed protocol matching the `location_schema` conftest fixture."""
+
+    name: String
+    description: StringOptional
+    type: String
+    primary_tag: RelatedNode
+    tags: RelationshipManager
+
+
+class BuiltinLocationSync(CoreNodeSync):
+    name: String
+    description: StringOptional
+    type: String
+    primary_tag: RelatedNodeSync
+    tags: RelationshipManagerSync
+
+
+def deep_location_data() -> dict[str, Any]:
+    """A full fetch: all attributes, the cardinality-one and cardinality-many relationships."""
+    return {
+        "node": {
+            "__typename": "BuiltinLocation",
+            "id": LOCATION_ID,
+            "display_label": "jfk1",
+            "name": {"value": "JFK1"},
+            "description": {"value": "JFK Airport"},
+            "type": {"value": "SITE"},
+            "primary_tag": {
+                "node": {"id": TAG_RED_ID, "display_label": "red", "__typename": "BuiltinTag"},
+            },
+            "tags": {
+                "count": 2,
+                "edges": [
+                    {"node": {"id": TAG_BLUE_ID, "display_label": "blue", "__typename": "BuiltinTag"}},
+                    {"node": {"id": TAG_GREEN_ID, "display_label": "green", "__typename": "BuiltinTag"}},
+                ],
+            },
+        }
+    }
+
+
+def shallow_location_data() -> dict[str, Any]:
+    """A shallow re-fetch of the same node: only the name attribute, no relationships."""
+    return {
+        "node": {
+            "__typename": "BuiltinLocation",
+            "id": LOCATION_ID,
+            "display_label": "jfk1",
+            "name": {"value": "JFK1"},
+        }
+    }
+
+
+def setup_store(
+    client_type: str, clients: BothClients
+) -> tuple[InfrahubClient | InfrahubClientSync, NodeStore | NodeStoreSync, type[InfrahubNode | InfrahubNodeSync]]:
+    if client_type == "standard":
+        return clients.standard, NodeStore(default_branch="main"), InfrahubNode
+    return clients.sync, NodeStoreSync(default_branch="main"), InfrahubNodeSync
+
+
+def get_location(store: NodeStore | NodeStoreSync) -> BuiltinLocation | BuiltinLocationSync:
+    """Return the stored location through the typed protocol matching the store flavour."""
+    if isinstance(store, NodeStore):
+        return store.get(key=LOCATION_ID, kind=BuiltinLocation)
+    return store.get(key=LOCATION_ID, kind=BuiltinLocationSync)
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_keeps_relationships_after_shallow_refetch(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """The ticket regression: a shallow re-fetch must not drop previously fetched relationships."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    deep = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=deep)
+    shallow = node_class(client=client, schema=location_schema, data=shallow_location_data())
+    store.set(node=shallow)
+
+    stored = get_location(store)
+    assert stored is deep
+    assert stored.primary_tag.id == TAG_RED_ID
+    assert stored.tags.peer_ids == [TAG_BLUE_ID, TAG_GREEN_ID]
+    # No duplicate entries: one object, one uuid pointer, stable identity
+    branch = store._branches["main"]
+    assert len(branch._objs) == 1
+    assert branch._uuids[LOCATION_ID] == deep._internal_id
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_keeps_attributes_not_refetched(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    refetch = shallow_location_data()
+    refetch["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.name.value == "JFK2"
+    assert stored.description.value == "JFK Airport"
+    assert stored.type.value == "SITE"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_refreshes_fetched_relationships(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A re-fetched relationship reflects the server: one-relationship move, many-member removal."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {
+        "node": {"id": TAG_GREEN_ID, "display_label": "green", "__typename": "BuiltinTag"}
+    }
+    refetch["node"]["tags"] = {
+        "count": 1,
+        "edges": [{"node": {"id": TAG_BLUE_ID, "display_label": "blue", "__typename": "BuiltinTag"}}],
+    }
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.primary_tag.id == TAG_GREEN_ID
+    assert stored.tags.peer_ids == [TAG_BLUE_ID]
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_reflects_cleared_cardinality_one(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A fetched-but-empty one-relationship clears the stored peer (the move-to-root trap)."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {"node": None}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.primary_tag.id is None
+    assert stored.primary_tag.initialized is False
+    # Not re-fetched relationships are untouched
+    assert stored.tags.peer_ids == [TAG_BLUE_ID, TAG_GREEN_ID]
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_fetched_none_attribute_overwrites(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """The presence flag means "present in the response": a genuine server-side clear wins."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    refetch = shallow_location_data()
+    refetch["node"]["description"] = {"value": None}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    assert get_location(store).description.value is None
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_local_edits_win(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    node = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=node)
+    stored = get_location(store)
+    assert stored is node
+    stored.description.value = "local edit"
+    node.primary_tag = TAG_BLUE_ID
+
+    refetch = deep_location_data()
+    refetch["node"]["description"] = {"value": "server edit"}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    assert get_location(store) is node
+    assert stored.description.value == "local edit"
+    assert stored.primary_tag.id == TAG_BLUE_ID
+    # Untouched fields still refresh
+    assert stored.name.value == "JFK1"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_false_replaces(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """merge=False drops prior knowledge of the node and stores exactly what was fetched."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    shallow = node_class(client=client, schema=location_schema, data=shallow_location_data())
+    store.set(node=shallow, merge=False)
+
+    stored = get_location(store)
+    assert stored is shallow
+    assert stored.description.value is None
+    assert stored.primary_tag.initialized is False
+    assert stored.tags.peer_ids == []
+    assert len(store._branches["main"]._objs) == 1
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_store_default_merge_from_config(client_type: str, clients: BothClients) -> None:
+    """The client store default comes from Config.store_merge; merge is the default."""
+    if client_type == "standard":
+        assert clients.standard.store._default_merge is True
+    else:
+        assert clients.sync.store._default_merge is True
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_refreshes_display_label(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    # Absent display_label -> kept
+    no_label = shallow_location_data()
+    del no_label["node"]["display_label"]
+    store.set(node=node_class(client=client, schema=location_schema, data=no_label))
+    assert get_location(store).display_label == "jfk1"
+
+    # Present display_label -> refreshed
+    new_label = shallow_location_data()
+    new_label["node"]["display_label"] = "jfk1-renamed"
+    store.set(node=node_class(client=client, schema=location_schema, data=new_label))
+    assert get_location(store).display_label == "jfk1-renamed"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_value_only_refetch_preserves_attribute_properties(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    with_properties = deep_location_data()
+    with_properties["node"]["name"] = {
+        "value": "JFK1",
+        "is_protected": True,
+        "updated_at": "2024-01-15T10:30:00.000000Z",
+        "source": {"id": "ssssssss-ssss-ssss-ssss-ssssssssssss", "display_label": "crm", "__typename": "CoreAccount"},
+        "owner": None,
+    }
+    deep = node_class(client=client, schema=location_schema, data=with_properties)
+    store.set(node=deep)
+
+    value_only = shallow_location_data()
+    value_only["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=location_schema, data=value_only))
+
+    assert get_location(store) is deep
+    stored_name = deep._attribute_data["name"]
+    assert stored_name.value == "JFK2"
+    assert stored_name.is_protected is True
+    assert stored_name.updated_at == "2024-01-15T10:30:00.000000Z"
+    assert stored_name.source is not None
+    assert stored_name.source.id == "ssssssss-ssss-ssss-ssss-ssssssssssss"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_does_not_mark_attributes_mutated(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """Guards the save path: a merged node must not serialize fields the user never touched."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    deep = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=deep)
+    refetch = shallow_location_data()
+    refetch["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    assert get_location(store) is deep
+    assert all(attr.value_has_been_mutated is False for attr in deep._attribute_data.values())
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_reindexes_hfid(
+    client_type: str, clients: BothClients, schema_with_hfid: dict[str, NodeSchemaAPI]
+) -> None:
+    """When an hfid-component attribute refreshes, the hfid index follows and drops the stale entry."""
+    client, store, node_class = setup_store(client_type, clients)
+    schema = schema_with_hfid["location"]
+
+    store.set(node=node_class(client=client, schema=schema, data=deep_location_data()))
+    assert store.get(key="BuiltinLocation__JFK1").id == LOCATION_ID
+
+    refetch = shallow_location_data()
+    refetch["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=schema, data=refetch))
+
+    assert store.get(key="BuiltinLocation__JFK2").id == LOCATION_ID
+    assert store.get(key="BuiltinLocation__JFK1", raise_when_missing=False) is None
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_custom_key_points_to_merged_object(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()), key="mykey")
+    store.set(node=node_class(client=client, schema=location_schema, data=shallow_location_data()))
+
+    assert store.get(key="mykey") is store.get(key=LOCATION_ID)
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_kind_change_replaces_wholesale(
+    client_type: str, clients: BothClients, schema_with_hfid: dict[str, NodeSchemaAPI]
+) -> None:
+    """The same uuid arriving as another kind (ConvertObjectType) replaces the entry, even in merge mode."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    location = node_class(client=client, schema=schema_with_hfid["location"], data=deep_location_data())
+    store.set(node=location, key="mykey")
+    assert store.get(key="BuiltinLocation__JFK1").id == LOCATION_ID
+
+    converted_data = {
+        "node": {
+            "__typename": "BuiltinRack",
+            "id": LOCATION_ID,
+            "display_label": "jfk1",
+            "facility_id": {"value": "JFK1"},
+        }
+    }
+    converted = node_class(client=client, schema=schema_with_hfid["rack"], data=converted_data)
+    store.set(node=converted)
+
+    stored = store.get(key=LOCATION_ID)
+    assert stored is converted
+    assert stored.get_kind() == "BuiltinRack"
+    assert len(store._branches["main"]._objs) == 1
+    # The old kind's hfid index no longer points at the discarded object
+    assert store.get(key="BuiltinLocation__JFK1", raise_when_missing=False) is None
+    # Custom keys follow the replacement
+    assert store.get(key="mykey") is converted
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_same_peer_keeps_identity_details_not_carried(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A narrow payload for the same peer must not null previously fetched identity data."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {"node": {"id": TAG_RED_ID}}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.primary_tag.id == TAG_RED_ID
+    assert stored.primary_tag.display_label == "red"
+    assert stored.primary_tag.typename == "BuiltinTag"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_clears_pool_allocation_intent_on_refetch(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A fetched value clears a stale from_pool request.
+
+    A surviving from_pool would take precedence over the value in the next mutation
+    payload and trigger a re-allocation.
+    """
+    client, store, node_class = setup_store(client_type, clients)
+
+    pool_data = deep_location_data()
+    pool_data["node"]["description"] = {"from_pool": {"id": "pppppppp-pppp-pppp-pppp-pppppppppppp"}}
+    stored_node = node_class(client=client, schema=location_schema, data=pool_data)
+    assert stored_node._attribute_data["description"]._from_pool is not None
+    store.set(node=stored_node)
+
+    refetch = shallow_location_data()
+    refetch["node"]["description"] = {"value": "allocated-value"}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    assert get_location(store) is stored_node
+    assert stored_node._attribute_data["description"].value == "allocated-value"
+    assert stored_node._attribute_data["description"]._from_pool is None
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_peer_change_drops_old_edge_properties(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A changed peer is a different edge: the old edge's properties must not survive."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    with_properties = deep_location_data()
+    with_properties["node"]["primary_tag"] = {
+        "properties": {
+            "is_protected": True,
+            "source": {
+                "id": "ssssssss-ssss-ssss-ssss-ssssssssssss",
+                "display_label": "crm",
+                "__typename": "CoreAccount",
+            },
+        },
+        "node": {"id": TAG_RED_ID, "display_label": "red", "__typename": "BuiltinTag"},
+    }
+    store.set(node=node_class(client=client, schema=location_schema, data=with_properties))
+
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {
+        "node": {"id": TAG_GREEN_ID, "display_label": "green", "__typename": "BuiltinTag"}
+    }
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.primary_tag.id == TAG_GREEN_ID
+    assert stored.primary_tag.is_protected is None
+    assert stored.primary_tag.source is None
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_clears_hfid_only_relationship(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A cleared relationship tracked only by hfid (no id on either side) is reflected."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    hfid_only = deep_location_data()
+    hfid_only["node"]["primary_tag"] = {"node": {"hfid": ["red"], "__typename": "BuiltinTag"}}
+    store.set(node=node_class(client=client, schema=location_schema, data=hfid_only))
+    assert get_location(store).primary_tag.hfid == ["red"]
+
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {"node": None}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.primary_tag.hfid is None
+    assert stored.primary_tag.initialized is False
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_local_manager_edits_win(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """An unsaved add()/remove() on the stored member list is not clobbered by a re-fetch."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    stored_node = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=stored_node)
+    stored_node._relationship_cardinality_many_data["tags"].add(TAG_RED_ID)
+
+    refetch = shallow_location_data()
+    refetch["node"]["tags"] = {"count": 0, "edges": []}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert TAG_RED_ID in stored.tags.peer_ids
+    assert stored.tags.has_update is True
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_same_peer_refreshes_carried_identity_and_properties(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A same-peer re-fetch refreshes the identity details and properties it carried."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    refetch = shallow_location_data()
+    refetch["node"]["primary_tag"] = {
+        "properties": {
+            "is_protected": True,
+            "source": {
+                "id": "ssssssss-ssss-ssss-ssss-ssssssssssss",
+                "display_label": "crm",
+                "__typename": "CoreAccount",
+            },
+        },
+        "node": {
+            "id": TAG_RED_ID,
+            "hfid": ["crimson"],
+            "kind": "BuiltinTag",
+            "display_label": "crimson",
+            "__typename": "BuiltinTag",
+        },
+        "relationship_metadata": {"updated_at": "2026-07-04T00:00:00.000000Z"},
+    }
+    incoming = node_class(client=client, schema=location_schema, data=refetch)
+    # Simulate a previously fetch()ed peer riding along with the relationship
+    peer = node_class(client=client, schema=location_schema, data=deep_location_data())
+    incoming._relationship_cardinality_one_data["primary_tag"]._peer = peer
+    store.set(node=incoming)
+
+    stored = get_location(store)
+    inner_rel = store.get(key=LOCATION_ID)._relationship_cardinality_one_data["primary_tag"]
+    assert inner_rel._id == TAG_RED_ID
+    assert inner_rel._display_label == "crimson"
+    assert inner_rel._hfid == ["crimson"]
+    assert inner_rel._kind == "BuiltinTag"
+    assert inner_rel._peer is peer
+    assert stored.primary_tag.is_protected is True
+    assert stored.primary_tag.source == "ssssssss-ssss-ssss-ssss-ssssssssssss"
+    metadata = inner_rel.get_relationship_metadata()
+    assert metadata is not None
+    assert metadata.updated_at == "2026-07-04T00:00:00.000000Z"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_refreshes_attribute_properties(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A re-fetch that carries attribute properties updates the stored ones."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    refetch = shallow_location_data()
+    refetch["node"]["name"] = {
+        "value": "JFK1",
+        "is_protected": True,
+        "source": {"id": "ssssssss-ssss-ssss-ssss-ssssssssssss", "display_label": "crm", "__typename": "CoreAccount"},
+    }
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored_name = store.get(key=LOCATION_ID)._attribute_data["name"]
+    assert stored_name.is_protected is True
+    assert stored_name.source is not None
+    assert stored_name.source.id == "ssssssss-ssss-ssss-ssss-ssssssssssss"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_propagates_edit_on_unfetched_attribute(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """An unsaved edit on an attribute the incoming fetch did not carry still merges."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    incoming = node_class(client=client, schema=location_schema, data=shallow_location_data())
+    assert incoming._attribute_data["description"].is_fetched is False
+    incoming._attribute_data["description"].value = "draft"
+    store.set(node=incoming)
+
+    stored = get_location(store)
+    assert stored.description.value == "draft"
+    inner = store.get(key=LOCATION_ID)
+    assert inner._attribute_data["description"].value_has_been_mutated is True
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_into_node_created_without_data(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A locally created node (no raw payload) accepts merges once it has an id."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    created = node_class(client=client, schema=location_schema, data=None)
+    created.id = LOCATION_ID
+    store.set(node=created)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    stored = get_location(store)
+    assert stored is created
+    assert stored.name.value == "JFK1"
+    assert stored.primary_tag.id == TAG_RED_ID
+    assert isinstance(created._data, dict)
+    assert created._data["name"] == {"value": "JFK1"}
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_updates_node_metadata(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+    assert get_location(store).get_node_metadata() is None
+
+    refetch = shallow_location_data()
+    refetch["node_metadata"] = {"updated_at": "2026-07-04T00:00:00.000000Z"}
+    # A payload without __typename leaves the stored typename untouched
+    del refetch["node"]["__typename"]
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+
+    stored = get_location(store)
+    assert stored.typename == "BuiltinLocation"
+    metadata = stored.get_node_metadata()
+    assert metadata is not None
+    assert metadata.updated_at == "2026-07-04T00:00:00.000000Z"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_from_locally_created_copy_keeps_existing_flag(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """Merging a locally created (never persisted) copy does not unmark the stored node."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    created = node_class(client=client, schema=location_schema, data=None)
+    created.id = LOCATION_ID
+    created._attribute_data["description"].value = "draft"
+    store.set(node=created)
+
+    stored = get_location(store)
+    assert store.get(key=LOCATION_ID)._existing is True
+    assert stored.description.value == "draft"
+
+
+def test_merge_helpers_insert_into_empty_containers(clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """The per-field merge helpers insert wholesale when no stored entry exists.
+
+    The helpers live on the shared InfrahubNodeBase, so one flavour covers both.
+    """
+    target = InfrahubNode(client=clients.standard, schema=location_schema, data=shallow_location_data())
+    incoming = InfrahubNode(client=clients.standard, schema=location_schema, data=deep_location_data())
+
+    target._attribute_data.pop("description")
+    assert target._merge_attribute("description", incoming._attribute_data["description"]) is True
+    assert target._attribute_data["description"] is incoming._attribute_data["description"]
+
+    empty_bucket: dict[str, RelatedNodeBase | RelationshipManagerBase] = {}
+    incoming_rel = incoming._relationship_cardinality_one_data["primary_tag"]
+    assert target._merge_relationship(empty_bucket, "primary_tag", incoming_rel) is True
+    assert empty_bucket["primary_tag"] is incoming_rel
+
+    incoming_manager = incoming._relationship_cardinality_many_data["tags"]
+    assert target._merge_relationship(empty_bucket, "tags", incoming_manager) is True
+    assert empty_bucket["tags"] is incoming_manager
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_store_set_same_object_twice_is_stable(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    stored_node = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=stored_node)
+    store.set(node=stored_node)
+
+    assert get_location(store) is stored_node
+    assert len(store._branches["main"]._objs) == 1
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_store_custom_key_reassignment(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """Reassigning a custom key to another node keeps the reverse index consistent."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    first = node_class(client=client, schema=location_schema, data=deep_location_data())
+    store.set(node=first, key="mykey")
+
+    other_data = shallow_location_data()
+    other_data["node"]["id"] = "oooooooo-oooo-oooo-oooo-oooooooooooo"
+    second = node_class(client=client, schema=location_schema, data=other_data)
+    store.set(node=second, key="mykey")
+
+    assert store.get(key="mykey") is second
+    branch = store._branches["main"]
+    assert "mykey" not in branch._keys_by_internal_id.get(first._internal_id, set())
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_store_hfid_claimed_by_other_node_is_kept(
+    client_type: str, clients: BothClients, schema_with_hfid: dict[str, NodeSchemaAPI]
+) -> None:
+    """Re-setting a renamed node must not drop an hfid entry another node now owns."""
+    client, store, node_class = setup_store(client_type, clients)
+    schema = schema_with_hfid["location"]
+
+    store.set(node=node_class(client=client, schema=schema, data=deep_location_data()))
+
+    # Another node claims the JFK1 hfid
+    other_data = deep_location_data()
+    other_data["node"]["id"] = "oooooooo-oooo-oooo-oooo-oooooooooooo"
+    other = node_class(client=client, schema=schema, data=other_data)
+    store.set(node=other)
+
+    # The first node is re-fetched under a new name; its stale JFK1 entry must not
+    # remove the entry now owned by the other node
+    refetch = shallow_location_data()
+    refetch["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=schema, data=refetch))
+
+    assert store.get(key="BuiltinLocation__JFK1") is other
+    assert store.get(key="BuiltinLocation__JFK2").id == LOCATION_ID
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_propagates_unsaved_edits(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """Unsaved edits merged into the store keep their pending-mutation markers.
+
+    A later save of the merged store copy must still send them.
+    """
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    incoming = node_class(client=client, schema=location_schema, data=deep_location_data())
+    incoming._attribute_data["description"].value = None
+    incoming.primary_tag = TAG_GREEN_ID
+    incoming._relationship_cardinality_many_data["tags"].add(TAG_RED_ID)
+    store.set(node=incoming)
+
+    stored = get_location(store)
+    assert stored is not incoming
+    assert stored.description.value is None
+    assert stored.name.value == "JFK1"
+    inner = store.get(key=LOCATION_ID)
+    assert inner._attribute_data["description"].value_has_been_mutated is True
+    assert inner._attribute_data["name"].value_has_been_mutated is False
+    assert stored.primary_tag.id == TAG_GREEN_ID
+    assert inner._relationship_cardinality_one_data["primary_tag"]._peer_has_been_mutated is True
+    assert TAG_RED_ID in stored.tags.peer_ids
+    assert stored.tags.has_update is True
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_update_resets_mutation_tracking(
+    httpx_mock: HTTPXMock, client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """A successful mutation marks the in-memory state as persisted.
+
+    The store can then refresh those fields from later fetches instead of protecting
+    them as pending local edits forever.
+    """
+    httpx_mock.add_response(
+        method="POST",
+        json={"data": {"BuiltinLocationUpdate": {"ok": True, "object": {"id": LOCATION_ID}}}},
+    )
+    client, store, node_class = setup_store(client_type, clients)
+
+    node = node_class(client=client, schema=location_schema, data=deep_location_data())
+    node._attribute_data["description"].value = "edited"
+    node.primary_tag = TAG_GREEN_ID
+    node._relationship_cardinality_many_data["tags"].add(TAG_RED_ID)
+    if isinstance(node, InfrahubNode):
+        await node.update()
+    else:
+        node.update()
+
+    assert node._attribute_data["description"].value_has_been_mutated is False
+    assert node._relationship_cardinality_one_data["primary_tag"]._peer_has_been_mutated is False
+    assert node._relationship_cardinality_many_data["tags"].has_update is False
+
+    # The saved field is persisted state now: a later fetch refreshes it in the store
+    store.set(node=node)
+    refetch = shallow_location_data()
+    refetch["node"]["description"] = {"value": "server refresh"}
+    store.set(node=node_class(client=client, schema=location_schema, data=refetch))
+    assert get_location(store).description.value == "server refresh"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_fetched_fields_are_interned(client_type: str, clients: BothClients, location_schema: NodeSchemaAPI) -> None:
+    """Attributes built from the same query shape share one presence frozenset."""
+    client, _, node_class = setup_store(client_type, clients)
+
+    first = node_class(client=client, schema=location_schema, data=deep_location_data())
+    second = node_class(client=client, schema=location_schema, data=deep_location_data())
+
+    assert first._attribute_data["name"]._fetched_fields is second._attribute_data["name"]._fetched_fields
+    assert (
+        first._relationship_cardinality_one_data["primary_tag"]._fetched_properties
+        is second._relationship_cardinality_one_data["primary_tag"]._fetched_properties
+    )
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_keeps_data_baseline_in_sync(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """The raw _data baseline used by update() diffs merges key-wise like the attributes."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    with_properties = deep_location_data()
+    with_properties["node"]["name"] = {"value": "JFK1", "is_protected": True}
+    deep = node_class(client=client, schema=location_schema, data=with_properties)
+    store.set(node=deep)
+
+    value_only = shallow_location_data()
+    value_only["node"]["name"] = {"value": "JFK2"}
+    store.set(node=node_class(client=client, schema=location_schema, data=value_only))
+
+    assert get_location(store) is deep
+    assert isinstance(deep._data, dict)
+    assert deep._data["name"] == {"value": "JFK2", "is_protected": True}
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_presence_detection_with_aliased_fields(
+    client_type: str, clients: BothClients, location_schema: NodeSchemaAPI
+) -> None:
+    """Presence detection still fires when fields arrive under aliases normalised by _strip_alias."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=location_schema, data=deep_location_data()))
+
+    aliased = {
+        "node": {
+            "__typename": "BuiltinLocation",
+            "id": LOCATION_ID,
+            "attr__alias__name": {"value": "JFK2"},
+        }
+    }
+    refetch = node_class(client=client, schema=location_schema, data=node_class._strip_alias(aliased))
+    assert refetch._attribute_data["name"].is_fetched is True
+    store.set(node=refetch)
+
+    stored = get_location(store)
+    assert stored.name.value == "JFK2"
+    assert stored.description.value == "JFK Airport"
+
+
+HIERARCHY_ID = "hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh"
+PARENT_A_ID = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+PARENT_B_ID = "cccccccc-cccc-cccc-cccc-cccccccccccc"
+CHILD_ID = "dddddddd-dddd-dddd-dddd-dddddddddddd"
+
+
+class InfraLocation(CoreNode):
+    """Typed protocol matching the hierarchical schema fixture below."""
+
+    name: String
+    description: StringOptional
+    parent: RelatedNode
+    children: RelationshipManager
+    ancestors: RelationshipManager
+    descendants: RelationshipManager
+
+
+class InfraLocationSync(CoreNodeSync):
+    name: String
+    description: StringOptional
+    parent: RelatedNodeSync
+    children: RelationshipManagerSync
+    ancestors: RelationshipManagerSync
+    descendants: RelationshipManagerSync
+
+
+def get_hierarchical_location(store: NodeStore | NodeStoreSync) -> InfraLocation | InfraLocationSync:
+    if isinstance(store, NodeStore):
+        return store.get(key=HIERARCHY_ID, kind=InfraLocation)
+    return store.get(key=HIERARCHY_ID, kind=InfraLocationSync)
+
+
+@pytest.fixture
+async def hierarchical_location_schema() -> NodeSchemaAPI:
+    schema = NodeSchema(
+        name="Location",
+        namespace="Infra",
+        default_filter="name__value",
+        attributes=[
+            AttributeSchema(name="name", kind=AttributeKind.TEXT, unique=True),
+            AttributeSchema(name="description", kind=AttributeKind.TEXT, optional=True),
+        ],
+        relationships=[],
+    )
+    schema_api = schema.convert_api()
+    schema_api.hierarchy = "InfraLocation"
+    return schema_api
+
+
+def deep_hierarchical_data() -> dict[str, Any]:
+    return {
+        "node": {
+            "__typename": "InfraLocation",
+            "id": HIERARCHY_ID,
+            "display_label": "california",
+            "name": {"value": "California"},
+            "parent": {"node": {"id": PARENT_A_ID, "display_label": "USA", "__typename": "InfraLocation"}},
+            "children": {
+                "count": 1,
+                "edges": [{"node": {"id": CHILD_ID, "display_label": "Yolo County", "__typename": "InfraLocation"}}],
+            },
+            "ancestors": {
+                "count": 1,
+                "edges": [{"node": {"id": PARENT_A_ID, "display_label": "USA", "__typename": "InfraLocation"}}],
+            },
+            "descendants": {
+                "count": 1,
+                "edges": [{"node": {"id": CHILD_ID, "display_label": "Yolo County", "__typename": "InfraLocation"}}],
+            },
+        }
+    }
+
+
+def shallow_hierarchical_data() -> dict[str, Any]:
+    return {
+        "node": {
+            "__typename": "InfraLocation",
+            "id": HIERARCHY_ID,
+            "display_label": "california",
+            "name": {"value": "California"},
+        }
+    }
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_keeps_hierarchical_fields_after_shallow_refetch(
+    client_type: str, clients: BothClients, hierarchical_location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=deep_hierarchical_data()))
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=shallow_hierarchical_data()))
+
+    stored = get_hierarchical_location(store)
+    assert stored.parent.id == PARENT_A_ID
+    assert stored.children.peer_ids == [CHILD_ID]
+    assert stored.ancestors.peer_ids == [PARENT_A_ID]
+    assert stored.descendants.peer_ids == [CHILD_ID]
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_reflects_hierarchical_parent_move(
+    client_type: str, clients: BothClients, hierarchical_location_schema: NodeSchemaAPI
+) -> None:
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=deep_hierarchical_data()))
+    refetch = shallow_hierarchical_data()
+    refetch["node"]["parent"] = {"node": {"id": PARENT_B_ID, "display_label": "Canada", "__typename": "InfraLocation"}}
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=refetch))
+
+    assert get_hierarchical_location(store).parent.id == PARENT_B_ID
+
+
+@pytest.mark.parametrize("client_type", client_types)
+def test_merge_reflects_hierarchical_move_to_root(
+    client_type: str, clients: BothClients, hierarchical_location_schema: NodeSchemaAPI
+) -> None:
+    """The RelatedNode.initialized trap: a fetched-but-empty parent must clear the stored one."""
+    client, store, node_class = setup_store(client_type, clients)
+
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=deep_hierarchical_data()))
+    refetch = shallow_hierarchical_data()
+    refetch["node"]["parent"] = {"node": None}
+    store.set(node=node_class(client=client, schema=hierarchical_location_schema, data=refetch))
+
+    stored = get_hierarchical_location(store)
+    assert stored.parent.id is None
+    # Children were not re-fetched and are kept
+    assert stored.children.peer_ids == [CHILD_ID]
+
+
+REPOSITORY_ID = "bfae43e8-5ebb-456c-a946-bf64e930710a"
+REPOSITORY_LOCATION = "git@github.com:opsmill/infrahub-demo-core.git"
+
+
+def repository_response(include_location: bool = True) -> dict[str, Any]:
+    node: dict[str, Any] = {
+        "__typename": "CoreRepository",
+        "id": REPOSITORY_ID,
+        "name": {"value": "infrahub-demo-core"},
+    }
+    if include_location:
+        node["location"] = {"value": REPOSITORY_LOCATION}
+    return {"data": {"CoreRepository": {"edges": [{"node": node}]}}}
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_query_merges_into_store_and_returns_per_query_object(
+    httpx_mock: HTTPXMock, clients: BothClients, mock_schema_query_01: HTTPXMock, client_type: str
+) -> None:
+    """Queries hand you what you asked for; the store remembers the union of everything it has seen."""
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=True),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=False),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+
+    first: CoreRepository | CoreRepositorySync
+    second: CoreRepository | CoreRepositorySync
+    stored: CoreRepository | CoreRepositorySync
+    if client_type == "standard":
+        first = await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID)
+        second = await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID, exclude=["location"])
+        stored = clients.standard.store.get(key=REPOSITORY_ID, kind=CoreRepository)
+    else:
+        first = clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID)
+        second = clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID, exclude=["location"])
+        stored = clients.sync.store.get(key=REPOSITORY_ID, kind=CoreRepositorySync)
+
+    # The store holds the merged canonical copy
+    assert stored is first
+    assert stored.location.value == REPOSITORY_LOCATION
+    # The second query returns a per-query snapshot, not the merged store object
+    assert second is not stored
+    assert second == stored
+    assert second.location.value is None
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_prefetched_related_nodes_merge_into_store(
+    httpx_mock: HTTPXMock, clients: BothClients, mock_schema_query_01: HTTPXMock, client_type: str
+) -> None:
+    """Related nodes from a prefetch go through the same store merge as top-level nodes."""
+    response = repository_response(include_location=True)
+    response["data"]["CoreRepository"]["edges"][0]["node"]["tags"] = {
+        "count": 1,
+        "edges": [{"node": {"id": TAG_RED_ID, "display_label": "red", "__typename": "BuiltinTag"}}],
+    }
+    httpx_mock.add_response(
+        method="POST",
+        json=response,
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+        is_reusable=True,
+    )
+
+    if client_type == "standard":
+        repo = await clients.standard.get(kind="CoreRepository", id=REPOSITORY_ID, prefetch_relationships=True)
+        tag = clients.standard.store.get(key=TAG_RED_ID, raise_when_missing=False)
+    else:
+        repo = clients.sync.get(kind="CoreRepository", id=REPOSITORY_ID, prefetch_relationships=True)
+        tag = clients.sync.store.get(key=TAG_RED_ID, raise_when_missing=False)
+
+    assert repo.id == REPOSITORY_ID
+    assert tag is not None
+    assert tag.id == TAG_RED_ID
+    assert tag.display_label == "red"
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_consistent_at_queries_populate_and_merge(
+    httpx_mock: HTTPXMock, clients: BothClients, mock_schema_query_01: HTTPXMock, client_type: str
+) -> None:
+    """A script running all its queries at one timestamp gets full store functionality."""
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=True),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=False),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+
+    stored: CoreRepository | CoreRepositorySync
+    # Two distinct Timestamp objects for the same instant share one store context
+    if client_type == "standard":
+        await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID, at=Timestamp("2023-01-01T00:00:00Z"))
+        await clients.standard.get(
+            kind=CoreRepository, id=REPOSITORY_ID, at=Timestamp("2023-01-01T00:00:00Z"), exclude=["location"]
+        )
+        stored = clients.standard.store.get(key=REPOSITORY_ID, kind=CoreRepository)
+    else:
+        clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID, at=Timestamp("2023-01-01T00:00:00Z"))
+        clients.sync.get(
+            kind=CoreRepositorySync, id=REPOSITORY_ID, at=Timestamp("2023-01-01T00:00:00Z"), exclude=["location"]
+        )
+        stored = clients.sync.store.get(key=REPOSITORY_ID, kind=CoreRepositorySync)
+
+    # The shallow historical re-fetch merged instead of replacing: no data lost
+    assert stored.location.value == REPOSITORY_LOCATION
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_at_query_after_live_context_skips_store_with_warning(
+    httpx_mock: HTTPXMock, clients: BothClients, mock_schema_query_01: HTTPXMock, client_type: str
+) -> None:
+    """A historical read must not blend into a live cache: it warns and skips the store."""
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=True),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=False),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+
+    at = Timestamp("2023-01-01T00:00:00Z")
+    stored: CoreRepository | CoreRepositorySync
+    if client_type == "standard":
+        await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID)
+        with pytest.warns(UserWarning, match="Mixing timestamps"):
+            node = await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID, at=at)
+        stored = clients.standard.store.get(key=REPOSITORY_ID, kind=CoreRepository)
+    else:
+        clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID)
+        with pytest.warns(UserWarning, match="Mixing timestamps"):
+            node = clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID, at=at)
+        stored = clients.sync.store.get(key=REPOSITORY_ID, kind=CoreRepositorySync)
+
+    # The historical query still returned its result, but the live cache is untouched
+    assert node.id == REPOSITORY_ID
+    assert stored.location.value == REPOSITORY_LOCATION
+
+
+@pytest.mark.parametrize("client_type", client_types)
+async def test_live_query_after_at_context_skips_store_with_warning(
+    httpx_mock: HTTPXMock, clients: BothClients, mock_schema_query_01: HTTPXMock, client_type: str
+) -> None:
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=True),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+    httpx_mock.add_response(
+        method="POST",
+        json=repository_response(include_location=False),
+        match_headers={"X-Infrahub-Tracker": "query-corerepository-page1"},
+    )
+
+    at = Timestamp("2023-01-01T00:00:00Z")
+    stored: CoreRepository | CoreRepositorySync
+    if client_type == "standard":
+        await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID, at=at)
+        with pytest.warns(UserWarning, match="Mixing timestamps"):
+            await clients.standard.get(kind=CoreRepository, id=REPOSITORY_ID)
+        stored = clients.standard.store.get(key=REPOSITORY_ID, kind=CoreRepository)
+    else:
+        clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID, at=at)
+        with pytest.warns(UserWarning, match="Mixing timestamps"):
+            clients.sync.get(kind=CoreRepositorySync, id=REPOSITORY_ID)
+        stored = clients.sync.store.get(key=REPOSITORY_ID, kind=CoreRepositorySync)
+
+    # The store keeps the historical context it was stamped with
+    assert stored.location.value == REPOSITORY_LOCATION