Pathrule is a shared knowledge layer, so two people will eventually edit the same memory, rule, or skill at the same time. Cloud writes are shared, overlaps are checked when you save, and you decide how to resolve them.

## Reading the current state

A memory, rule or skill written to a Cloud workspace becomes part of that shared workspace. The current Cloud backend does not provide a real-time subscription that pushes every teammate's edit into an open view.

Refresh the knowledge view or make another knowledge request to read current state. Local hooks and instruction files use prepared workspace knowledge; run `pathrule sync` to refresh those files and indexes. Do not assume an already prepared session has received a teammate's latest edit.

A local workspace lives on one machine. Other people do not receive its changes until you copy the knowledge into a shared Cloud workspace.

## Overlap detection at save time

Pathrule does not lock an item while someone has it open. Locking would stall the team for edits that never actually collide. Instead, every save carries a version token (the same token described in [Writing memories](/docs/content/memories)), and overlap is detected only when two saves target the same starting version.

| Situation | What happens |
|-----------|--------------|
| You save and your starting version is still current | The save goes through normally |
| You save but a teammate saved a newer version since you started | A conflict, resolved with the choices below. Your version is not saved until you choose |

Because the check is scoped to the individual item, teammates editing different memories never block each other.

## Resolving a conflict

In Pathrule for VS Code, a memory, rule or skill is a markdown tab. When a save hits a conflict, VS Code tells you the content changed remotely and that your version was not saved, and offers three choices:

| Choice | What it does |
|--------|--------------|
| Reload | Loads the current version and drops your unsaved edits. |
| Copy My Version & Reload | Copies your text to the clipboard first, then loads the current version, so you can reapply what you meant. |
| Keep Mine (Overwrite) | Saves your version over the current one. This discards the other person's change, so it is an explicit choice. |

Nothing is overwritten until you pick one. Through MCP, an assistant can pass the version it last read; on a mismatch it gets the current version back, re-reads it, and merges its change in rather than overwriting.

## Change history

Every change to a memory, rule, or skill is versioned and recorded.

- Each change keeps who made it, when, and whether it came from a person or an AI client.
- In VS Code, the **Info** action shows an item's version, who created it, who last edited it and its source.

The history is for visibility. It tells you how an item reached its current state, which is the same question a [refresh task](/docs/content/suggestions) helps answer when knowledge starts to drift.

## What to read next

- [Writing memories](/docs/content/memories) for how the version token works on a single item.
- [Suggestions and self-audit](/docs/content/suggestions) for how stale or conflicting knowledge gets flagged.
- [MCP overview](/docs/mcp/overview) for how external AI clients read the synced context.