diff --git a/BACKLOG.md b/BACKLOG.md
index aaa40930..66b88c43 100644
--- a/BACKLOG.md
+++ b/BACKLOG.md
@@ -88,26 +88,57 @@ The surface check shows `Manifest entries: 70` vs `index.js exports: 66`. This m
 
 **Files:** `contracts/type-surface.m8.json`, `index.js`
 
+### B-TYPE-3: Establish test-file wildcard ratchet
+
+`ts-policy-check.js` only scans `src/`, `bin/`, and `scripts/` by design — test files are excluded. This means `@type {any}` usages across test files are unchecked. Options:
+- Add a separate ratchet for test files with a higher threshold
+- Add per-file caps to prevent individual test files from growing unbounded
+- Document the exclusion as intentional and accept it
+
+**Files:** `scripts/ts-policy-check.js`
+
 ---
 
 ## Feature: Content Attachment
 
-### B-FEAT-1: Implement content attachment (`Atom(p)` payloads on nodes)
+### B-FEAT-1: ~~Implement content attachment~~ DONE (v11.5.0)
+
+Shipped in v11.5.0. See `docs/specs/CONTENT_ATTACHMENT.md` and CHANGELOG.
+
+### B-FEAT-2: Determinism fuzzer for tree construction
+
+Content blob tree entries are sorted by filename for deterministic tree OIDs. A property-based test should randomize:
+- content blob insertion order in `PatchBuilderV2`
+- content OID iteration order in `CheckpointService.createV5()`
+
+and verify the resulting tree OID is identical regardless of insertion order. This would catch any accidental order-dependence in tree construction.
+
+**Files:** new test in `test/unit/domain/services/`
 
-Full spec in `docs/specs/CONTENT_ATTACHMENT.md`. Proposal to attach content-addressed blobs to graph nodes as first-class payloads, bridging git-warp's flat key-value properties to the paper's `α(v)` vertex attachment model.
+### B-FEAT-3: Reconcile Map vs Record asymmetry in getNodeProps/getEdgeProps
 
-**Core idea:** Store blobs in the Git object store (already a CAS), reference them via a `_content` property on nodes. This gets CRDT merge (LWW on the SHA), time-travel (`materialize({ ceiling })`), and observer scoping for free — zero changes to the CRDT model.
+`getNodeProps()` returns a `Map<string, unknown>` while `getEdgeProps()` returns a plain `Record<string, unknown>`. This forces callers to use `.get()` for node props and `[key]` for edge props — an easy source of bugs. Options:
+- Both return Map (breaking change for edge prop consumers)
+- Both return Record (breaking change for node prop consumers)
+- Keep both, document the asymmetry prominently
 
-**Key decisions needed:**
+**Files:** `src/domain/warp/query.methods.js`, `src/domain/WarpGraph.js`
+
+---
+
+## Documentation Quality
+
+### B-DOC-1: Add markdownlint to CI
+
+Add a markdownlint check to the CI pipeline to catch MD040 (missing code fence language tags) and similar doc issues automatically. Currently these are only caught by CodeRabbit review, which is slow and non-blocking.
+
+**File:** `.github/workflows/ci.yml`
 
-- **API shape:** Property convention only (zero new API) vs dedicated `patch.attachContent()` / `graph.getContent()` methods vs hybrid. Spec recommends hybrid.
-- **Metadata properties:** Whether to store `_content.size`, `_content.mime`, `_content.encoding` at the substrate level or leave to consumers.
-- **Dependency:** `git-cas` package or equivalent `git hash-object -w` / `git cat-file blob` via existing plumbing.
-- **Edge attachments:** Deferred to v2 unless trivially included. Same mechanism — `_content` property on edges.
+### B-DOC-2: Add a code sample linter for markdown files
 
-**Out of scope (future):** Nested WARP attachments (where `α(v)` is itself a full WARP graph, not just an atom), content-level merge, MIME handling, content GC protection.
+Syntax-check JS/TS code blocks embedded in markdown files (specs, guides, etc.) to catch issues like duplicate `const` declarations, TDZ errors, and other syntax errors before they reach review. Could use `eslint-plugin-markdown` (runs ESLint natively on fenced blocks) or a custom script that extracts code blocks and pipes them through `eslint --stdin`.
 
-**Spec:** `docs/specs/CONTENT_ATTACHMENT.md`
+**Files:** new script or CI step, `docs/**/*.md`
 
 ---
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3a5519a0..288ad659 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [11.5.0] — 2026-02-20 — Content Attachment (Paper I `Atom(p)`)
+
+Implements content attachment — the ability to attach content-addressed blobs
+to WARP graph nodes and edges as first-class payloads. A blob OID stored as
+a `_content` string property gets CRDT merge (LWW), time-travel, and observer
+scoping for free — zero changes to JoinReducer, serialization, or the CRDT layer.
+
+### Added
+
+- **`CONTENT_PROPERTY_KEY`** constant (`'_content'`) exported from `KeyCodec` and `index.js`.
+- **`PatchBuilderV2.attachContent(nodeId, content)`** — writes blob to Git object store, sets `_content` property, tracks OID for GC anchoring.
+- **`PatchBuilderV2.attachEdgeContent(from, to, label, content)`** — same for edges.
+- **`PatchSession.attachContent()`** / **`attachEdgeContent()`** — async pass-through delegates.
+- **`WarpGraph.getContent(nodeId)`** — returns `Buffer | null` from the content blob.
+- **`WarpGraph.getContentOid(nodeId)`** — returns hex OID or null.
+- **`WarpGraph.getEdgeContent(from, to, label)`** / **`getEdgeContentOid(from, to, label)`** — edge variants.
+- **Blob anchoring** — content blob OIDs embedded in patch commit tree as `_content_<oid>` entries (self-documenting, unique by construction). Survives `git gc --prune=now`.
+- **Type declarations** — all new methods in `index.d.ts`, `type-surface.m8.json`, `consumer.ts`.
+- **Integration tests** — 11 tests covering single-writer, LWW, time-travel, deletion, Writer API, GC durability, binary round-trip.
+- **Unit tests** — 23 tests for PatchBuilderV2 content ops and WarpGraph query methods.
+- **ADR-001 Folds** — design document for future recursive attachments (structural zoom portals). Deferred; documents the path from `Atom(p)` to full `α(v) → WARP` recursion.
+
+### Fixed
+
+- **Checkpoint content anchoring** — `CheckpointService.createV5()` now scans `state.prop` for `_content` values and embeds the referenced blob OIDs in the checkpoint tree as `_content_<oid>` entries. This ensures content survives `git gc` even if patch commits are ever pruned.
+- **`GitGraphAdapter.readBlob()`** — Now always returns a real Node `Buffer` (wraps `Uint8Array` from plumbing with `Buffer.from()`). Consumers can call `.toString('utf8')` directly.
+- **`observedFrontier` staleness (#43)** — `JoinReducer.join()` now folds the patch's own dot (`{writer, lamport}`) into `observedFrontier`. Previously the frontier only reflected patch context VVs (pre-creation state), lagging by one tick per writer. The graph's `_versionVector` — cloned from `observedFrontier` after materialization — now reflects actual Lamport ticks.
+
 ## [11.4.0] — 2026-02-20 — M8 IRONCLAD Phase 3: Declaration Surface Automation
 
 Completes M8 IRONCLAD with automated declaration surface validation and expanded
diff --git a/README.md b/README.md
index c8877e69..227e2569 100644
--- a/README.md
+++ b/README.md
@@ -328,6 +328,29 @@ const sha = await (await graph.createPatch())
 
 Each `commit()` creates one Git commit containing all the operations, advances the writer's Lamport clock, and updates the writer's ref via compare-and-swap.
 
+### Content Attachment
+
+Attach content-addressed blobs to nodes and edges as first-class payloads (Paper I `Atom(p)`). Blobs are stored in the Git object store, referenced by SHA, and inherit CRDT merge, time-travel, and observer scoping automatically.
+
+```javascript
+const patch = await graph.createPatch();
+patch.addNode('adr:0007');                                    // sync — queues a NodeAdd op
+await patch.attachContent('adr:0007', '# ADR 0007\n\nDecision text...'); // async — writes blob
+await patch.commit();
+
+// Read content back
+const buffer = await graph.getContent('adr:0007');   // Buffer | null
+const oid    = await graph.getContentOid('adr:0007'); // hex SHA or null
+
+// Edge content works the same way (assumes nodes and edge already exist)
+const patch2 = await graph.createPatch();
+await patch2.attachEdgeContent('a', 'b', 'rel', 'edge payload');
+await patch2.commit();
+const edgeBuf = await graph.getEdgeContent('a', 'b', 'rel');
+```
+
+Content blobs survive `git gc` — their OIDs are embedded in the patch commit tree and checkpoint tree, keeping them reachable.
+
 ### Writer API
 
 For repeated writes, the Writer API is more convenient:
@@ -508,7 +531,7 @@ npm run test:matrix     # All runtimes in parallel
 ## When NOT to Use It
 
 - **High-throughput transactional workloads.** If you need thousands of writes per second with immediate consistency, use Postgres or Redis.
-- **Large binary or blob storage.** Data lives in Git commit messages (default cap 1 MB). Use object storage for images or videos.
+- **Large binary or blob storage.** Properties live in Git commit messages; content blobs live in the Git object store. Neither is optimized for large media files. Use object storage for images or videos.
 - **Sub-millisecond read latency.** Materialization has overhead. Use an in-memory database for real-time gaming physics or HFT.
 - **Simple key-value storage.** If you don't have relationships or need traversals, a graph database is overkill.
 - **Non-Git environments.** The value proposition depends on Git infrastructure (push/pull, content-addressing).
diff --git a/contracts/type-surface.m8.json b/contracts/type-surface.m8.json
index 9cdfcc4c..0e2e774d 100644
--- a/contracts/type-surface.m8.json
+++ b/contracts/type-surface.m8.json
@@ -72,6 +72,34 @@
           ],
           "returns": "Promise<Record<string, unknown> | null>"
         },
+        "getContentOid": {
+          "async": true,
+          "params": [{ "name": "nodeId", "type": "string" }],
+          "returns": "Promise<string | null>"
+        },
+        "getContent": {
+          "async": true,
+          "params": [{ "name": "nodeId", "type": "string" }],
+          "returns": "Promise<Buffer | null>"
+        },
+        "getEdgeContentOid": {
+          "async": true,
+          "params": [
+            { "name": "from", "type": "string" },
+            { "name": "to", "type": "string" },
+            { "name": "label", "type": "string" }
+          ],
+          "returns": "Promise<string | null>"
+        },
+        "getEdgeContent": {
+          "async": true,
+          "params": [
+            { "name": "from", "type": "string" },
+            { "name": "to", "type": "string" },
+            { "name": "label", "type": "string" }
+          ],
+          "returns": "Promise<Buffer | null>"
+        },
         "neighbors": {
           "async": true,
           "params": [
@@ -310,6 +338,8 @@
         "removeEdge": { "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }], "returns": "PatchBuilderV2" },
         "setProperty": { "params": [{ "name": "nodeId", "type": "string" }, { "name": "key", "type": "string" }, { "name": "value", "type": "unknown" }], "returns": "PatchBuilderV2" },
         "setEdgeProperty": { "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }, { "name": "key", "type": "string" }, { "name": "value", "type": "unknown" }], "returns": "PatchBuilderV2" },
+        "attachContent": { "async": true, "params": [{ "name": "nodeId", "type": "string" }, { "name": "content", "type": "Buffer | string" }], "returns": "Promise<PatchBuilderV2>" },
+        "attachEdgeContent": { "async": true, "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }, { "name": "content", "type": "Buffer | string" }], "returns": "Promise<PatchBuilderV2>" },
         "build": { "params": [], "returns": "PatchV2" },
         "commit": { "async": true, "params": [], "returns": "Promise<string>" }
       },
@@ -326,6 +356,8 @@
         "removeEdge": { "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }], "returns": "this" },
         "setProperty": { "params": [{ "name": "nodeId", "type": "string" }, { "name": "key", "type": "string" }, { "name": "value", "type": "unknown" }], "returns": "this" },
         "setEdgeProperty": { "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }, { "name": "key", "type": "string" }, { "name": "value", "type": "unknown" }], "returns": "this" },
+        "attachContent": { "async": true, "params": [{ "name": "nodeId", "type": "string" }, { "name": "content", "type": "Buffer | string" }], "returns": "Promise<this>" },
+        "attachEdgeContent": { "async": true, "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }, { "name": "content", "type": "Buffer | string" }], "returns": "Promise<this>" },
         "build": { "params": [], "returns": "PatchV2" },
         "commit": { "async": true, "params": [], "returns": "Promise<string>" }
       },
@@ -413,6 +445,7 @@
     "encodeEdgePropKey": { "kind": "function", "params": [{ "name": "from", "type": "string" }, { "name": "to", "type": "string" }, { "name": "label", "type": "string" }, { "name": "propKey", "type": "string" }], "returns": "string" },
     "decodeEdgePropKey": { "kind": "function", "params": [{ "name": "encoded", "type": "string" }], "returns": "{ from: string; to: string; label: string; propKey: string }" },
     "isEdgePropKey": { "kind": "function", "params": [{ "name": "key", "type": "string" }], "returns": "boolean" },
+    "CONTENT_PROPERTY_KEY": { "kind": "const" },
     "computeTranslationCost": { "kind": "function" },
     "migrateV4toV5": { "kind": "function" },
 
diff --git a/docs/ADR-001-Folds.md b/docs/ADR-001-Folds.md
new file mode 100644
index 00000000..7871b784
--- /dev/null
+++ b/docs/ADR-001-Folds.md
@@ -0,0 +1,205 @@
+# ADR-001: Folds — Structural Zoom Portals for Recursive Attachments
+
+- **Date:** 2026-02-20
+- **Status:** Proposed (Deferred)
+- **Owner:** @flyingrobots
+- **Decision Type:** Architecture / Data Model / Query Semantics
+
+## Context
+
+git-warp currently models a WARP graph skeleton (nodes + edges) with a property system that provides:
+- multi-writer convergence (CRDT semantics / LWW for props)
+- time-travel via materialization ceilings
+- observer scoping / visibility rules
+
+We also want **attachments** per the AIΩN Foundations Paper I lore:
+- `α(v)` attaches a WARP value to each vertex
+- `β(e)` attaches a WARP value to each edge
+- base case is `Atom(p)` (external payload IDs, bytestrings, etc.)
+- recursive case allows attachments to be WARP graphs (fractal structure)
+
+Today, git-mind (and related consumers) are blocked primarily on a minimal “content attachment” primitive:
+- store a git blob OID (CAS key) on a node as a normal property (e.g. `_content`)
+- read/write blobs using the existing BlobPort
+- rely on existing merge/time-travel semantics with no CRDT changes
+
+This ADR proposes an optional future mechanism called **Folds** to support **structural recursion** (fractal attachments) as a **view/projection** feature first — without conflating it with network causality.
+
+### Terminology Clarification
+
+We have two concepts that must not be overloaded:
+
+- **Wormhole (Causal):** a causal/sync concept (frontiers, receipts, replication topology)
+- **Fold (Structural):** a structural boundary / zoom portal for recursive attachments (pure view)
+
+This ADR is strictly about **Folds**.
+
+## Decision
+
+### For now (Immediate): Keep It Silly Simple
+
+We will ship v1 content attachment using an Atom/CAS technique:
+
+- Reserve a system property key:
+  - `CONTENT_PROPERTY_KEY = "_content"`
+- Attach content by storing a blob OID (git-cas key / git blob hash) as the property value.
+- Read content by resolving the stored OID via BlobPort.
+
+This is `Atom(p)` where `p` is a Git object ID — faithful to the Paper I base case.
+
+### Proposed (Deferred): Add **Folds** for Structural Recursion
+
+If/when we pursue true recursive WARP attachments, we will implement **Fold boundaries** as a structural convention:
+
+- A fold is represented by a deterministic “fold root” node ID in the same graph.
+- A skeleton entity (node or edge) has an attachment subgraph rooted at that fold root.
+- Traversal/render/query operate at configurable “zoom levels”:
+  - collapsed (ignore fold interiors)
+  - shallow (peek one fold deep)
+  - recursive (expand folds up to max depth)
+
+Folds are **not causal shortcuts**, do not change synchronization, and do not create new op types.
+
+## Fold Design
+
+### 1) Representation
+
+Folds are encoded using existing nodes/edges/props only.
+
+#### 1.1 Fold Root IDs (deterministic)
+
+We define deterministic fold root IDs to avoid collisions:
+
+- **Node fold root:** `fold:node:<nodeId>`
+- **Edge fold root:** `fold:edge:<from>|<label>|<to>`
+
+Rules:
+- `<nodeId>`, `<from>`, `<label>`, `<to>` must be encoded using existing codec rules (KeyCodec-safe).
+- Fold root IDs are considered system-reserved namespace. Consumers must not invent IDs under `fold:*`.
+
+#### 1.2 Fold Portal Edge Label
+
+We use a reserved edge label (structural portal), e.g.:
+
+- `@fold` (recommended for readability)
+- (optional future mapping to paper notation: `_α` for vertex attachments, `_β` for edge attachments)
+
+For node attachments:
+- `<nodeId> -[@fold]-> fold:node:<nodeId>`
+
+For edge attachments:
+- `fold:edge:<from>|<label>|<to>` is reachable via a deterministic lookup, not necessarily by a visible portal edge.
+  (We may add a portal edge if visualization benefits.)
+
+### 2) Zoom Semantics (view/projection only)
+
+Fold traversal is controlled by a **FoldPolicy**:
+
+```ts
+type FoldMode = "collapsed" | "shallow" | "recursive";
+
+type FoldPolicy = {
+  mode: FoldMode;
+  maxDepth?: number;          // default: 0 for collapsed, 1 for shallow, Infinity for recursive
+  include?: (foldRootId: string) => boolean; // optional filter
+};
+```
+
+Default behavior for existing APIs:
+- collapsed (fold interiors are ignored unless explicitly requested)
+
+Rationale:
+- prevents accidental "graph explosion"
+- preserves current mental model for consumers
+- makes Fold an opt-in "zoom lens"
+
+### 3) API Surface (Proposed)
+
+Folds should be exposed as explicit view operations, not implicit traversal surprises.
+
+#### 3.1 View API
+
+```javascript
+const view = graph.view({ fold: { mode: "shallow", maxDepth: 1 } });
+
+await view.traverse(startNodeId);
+await view.query(...);
+await view.renderAscii(...);
+```
+
+`graph.view()` returns a wrapper that:
+- shares the same underlying state
+- applies FoldPolicy to traversal and query expansions
+- never changes commit/sync behavior
+
+#### 3.2 Attachment Graph Accessors
+
+```javascript
+// returns fold root id (even if fold is empty)
+graph.getFoldRootForNode(nodeId) -> string
+
+// returns a "scoped view" whose traversals are rooted inside the fold
+graph.getFoldViewForNode(nodeId, foldPolicy?) -> GraphView
+```
+
+### 4) Invariants
+
+Folds must uphold:
+1. Determinism: same graph state + same FoldPolicy => same view results
+2. Non-causality: Fold does not affect sync, receipts, frontiers, or writer ordering
+3. Safety by default: existing calls do not suddenly traverse recursive interiors
+4. Codec safety: fold ids are canonical and cannot collide with consumer ids
+5. Separation of concerns: "wormholes" remain causal; "folds" remain structural
+
+## Consequences
+
+### Benefits
+- Enables a faithful "recursive WARP" structure without new op types.
+- Adds "zoom levels" to tame fractal graphs for humans and tooling.
+- Creates a path from blob attachments to structured, mergeable attachment graphs.
+- Avoids conflating structural recursion with causal sync (wormhole drift).
+
+### Costs / Risks
+- Introduces a long-lived convention (fold namespace + portal semantics).
+- Requires traversal/render/query APIs to accept FoldPolicy (complexity tax).
+- Needs careful boundary handling to prevent accidental mutation of fold internals.
+- Indexing may need fold-aware modes (exclude folds by default).
+
+## Alternatives Considered
+
+1. **Pointer recursion only** (Echo style: node stores ref to another graph)
+   - Pros: simple, decoupled, aligns with existing multi-graph workflows
+   - Cons: attachments not mergeable structurally within the same causal universe; harder partial replication
+2. **Nested op logs per node/edge**
+   - Pros: "true recursion" in a formal sense
+   - Cons: extremely complex reducer/interpreter; heavy migration risk
+3. **Store nested graphs as CAS blobs**
+   - Pros: cheap
+   - Cons: not structural recursion; merges become coarse (LWW)
+
+Folds (namespaced subgraphs) are the "sane structural recursion" option.
+
+## Rollout Plan
+
+**Phase 0 (Now):** Ship Atom/CAS attachment (v1)
+- `_content` property storing OID
+- helper methods for attach/read
+- tests + type surface
+- docs/spec for content attachment
+
+**Phase 1 (Later):** Fold MVP as view-only
+- define fold id codec + reserved portal edge label
+- implement `graph.view({ fold })` traversal expansion
+- update renderers to show fold markers (collapsed vs expanded)
+- no changes to sync / receipts / writers / JoinReducer
+
+**Phase 2 (Later):** Structural attachment graphs
+- standardize attachment schema conventions within fold subgraphs
+- (optional) edge folds
+- (optional) "attachment-aware" indexing/query helpers
+
+## Decision Summary
+
+We will proceed immediately with the minimal Atom/CAS `_content` technique to unblock consumers.
+
+Folds are approved as a future direction for structural recursion and zoomable fractal graphs, but are explicitly deferred until a concrete consumer need demands it.
diff --git a/docs/specs/CONTENT_ATTACHMENT.md b/docs/specs/CONTENT_ATTACHMENT.md
index 4557e55d..e400f6b8 100644
--- a/docs/specs/CONTENT_ATTACHMENT.md
+++ b/docs/specs/CONTENT_ATTACHMENT.md
@@ -1,7 +1,7 @@
 # Content Attachment Specification
 
-> **Spec Version:** 0 (proposal)
-> **Status:** Proposal
+> **Spec Version:** 1 (implemented)
+> **Status:** Implemented (v11.5.0)
 > **Paper References:** Paper I Section 2 (WARP definition, vertex/edge attachments, `Atom(p)`)
 
 ---
@@ -54,7 +54,6 @@ This proposal implements the depth-0 case of attachments: nodes carry `Atom(p)`
 - CLI commands for content manipulation (consumer concerns)
 - Editor integration, conflict resolution UX (consumer concerns)
 - Nested WARP attachments (future work)
-- Edge attachments (deferred to v2 unless trivially included)
 
 ---
 
@@ -84,50 +83,43 @@ This approach:
 
 The `_content` key prefix convention (underscore) signals a system-level property, distinguishing it from user-defined properties.
 
-### 3.3 API Surface (Sketch)
+### 3.3 Final API
 
-The exact API is an implementation decision. Two options are outlined:
+The hybrid approach was implemented: dedicated methods that encapsulate CAS details, while the `_content` property remains directly accessible for advanced use.
 
-#### Option A: Property Convention (Minimal)
-
-No new API methods. Consumers use existing property methods with the `_content` key:
+#### Write API (PatchBuilderV2 / PatchSession)
 
 ```javascript
-// Write
-const sha = await cas.writeBlob(buffer);
-patch.setProperty('adr:0007', '_content', sha);
-patch.commit();
-```
+const patch = await graph.createPatch();
+patch.addNode('adr:0007');
+await patch.attachContent('adr:0007', '# ADR 0007\n\nDecision text...');
+await patch.commit();
 
-```javascript
-// Read
-const props = graph.getNodeProps('adr:0007');
-const contentSha = props.get('_content');
-const buffer = await cas.readBlob(contentSha);
+// Edge content
+await patch.attachEdgeContent('a', 'b', 'rel', 'edge payload');
 ```
 
-**Pro:** Zero API surface change. **Con:** Consumer must manage CAS independently.
+Both methods are async (they call `writeBlob()` internally) and return the builder for chaining.
 
-#### Option B: Dedicated Methods (Recommended)
-
-New methods on the patch and graph API:
+#### Read API (WarpGraph)
 
 ```javascript
-// Write (patch API)
-await patch.attachContent('adr:0007', buffer);
-// Internally: cas.writeBlob(buffer) → sha, then setProperty(nodeId, '_content', sha)
-patch.commit();
-
-// Read (graph API)
-const buffer = await graph.getContent('adr:0007');
-// Internally: getNodeProps(nodeId).get('_content') → sha, then cas.readBlob(sha)
+const buffer = await graph.getContent('adr:0007');   // Buffer | null
+const oid    = await graph.getContentOid('adr:0007'); // string | null
+
+// Edge content
+const edgeBuf = await graph.getEdgeContent('a', 'b', 'rel');
+const edgeOid = await graph.getEdgeContentOid('a', 'b', 'rel');
 ```
 
-**Pro:** Discoverable, encapsulates CAS details, can add integrity checks. **Con:** New API surface.
+`getContent()` returns a raw `Buffer`. Consumers wanting text call `.toString('utf8')`.
 
-#### Hybrid
+#### Constant
 
-Expose dedicated methods but also allow direct property access for advanced use cases. The `_content` property is documented as the underlying mechanism.
+```javascript
+import { CONTENT_PROPERTY_KEY } from '@git-stunts/git-warp';
+// CONTENT_PROPERTY_KEY === '_content'
+```
 
 ### 3.4 Content Metadata
 
@@ -170,38 +162,51 @@ The `_content` property at tick `N` points to whatever blob SHA was current at t
 
 ---
 
-## 6. Dependency: git-cas
+## 6. Durability / Git GC
+
+Content blobs created by `git hash-object -w` are loose objects. Without anchoring, `git gc --prune=now` would delete them.
+
+**Solution:** `PatchBuilderV2.commit()` embeds content blob OIDs in the patch commit tree alongside the CBOR patch blob:
+
+```text
+patch.cbor          → CBOR-encoded patch blob
+_content_<oid>      → content blob, keyed by its hex OID (self-documenting, unique by construction)
+```
+
+This makes content blobs reachable via the writer ref chain (`refs/warp/<graph>/writers/<id>` → commit → tree → blob). GC protection is automatic. Sync replicates content along with patches. Zero new refs, zero new Git commands.
+
+**Checkpoint anchoring:** `CheckpointService.createV5()` also scans `state.prop` for `_content` values and embeds the referenced blob OIDs in the checkpoint tree. This ensures content survives GC even if patch commits are ever pruned (e.g., by future compaction or writer-chain truncation). The invariant is: **content blobs referenced by live state are always reachable from at least one ref** — either the writer ref (patch commit tree) or the checkpoint ref (checkpoint commit tree).
+
+Integration tests verify both anchoring paths with `git gc --prune=now`.
+
+---
 
-`git-cas` provides content-addressed blob storage over Git plumbing:
+## 7. Implementation Notes
 
-- `writeBlob(buffer) → sha` — write a blob to the Git object store
-- `readBlob(sha) → buffer` — read a blob by SHA
-- No index or working tree involvement
-- Blobs are subject to standard Git GC rules
+No external `git-cas` dependency was needed. The existing `BlobPort` on `GitGraphAdapter` (`writeBlob` via `git hash-object -w`, `readBlob` via `git cat-file blob`) provides all required CAS operations.
 
-If `git-cas` is not suitable or available, equivalent functionality can be achieved with `git hash-object -w` (write) and `git cat-file blob` (read) via the existing plumbing layer.
+Edge attachments are included in v1 (not deferred).
 
 ---
 
-## 7. Future Work
+## 8. Future Work
 
-- **Edge attachments:** Extend the same mechanism to edges (`β(e)` in the paper). The implementation is identical — a `_content` property on edges. Deferred unless trivially included in v1.
-- **Nested WARP attachments:** The paper allows `α(v)` to be a full WARP graph, not just an atom. This would mean a node's attachment is itself a graph with nodes, edges, and their own attachments. This is a significant extension beyond content blobs and is out of scope for this proposal.
+- **Nested WARP attachments:** The paper allows `α(v)` to be a full WARP graph, not just an atom. This would mean a node's attachment is itself a graph with nodes, edges, and their own attachments. This is a significant extension beyond content blobs and is out of scope.
 - **Content integrity verification:** Optionally verify blob SHA on read to detect corruption.
-- **Content garbage collection:** Mechanism to identify and protect content blobs from Git GC when they are still referenced by live graph state.
 
 ---
 
-## 8. Summary
+## 9. Summary
 
 | Aspect | Decision |
 |---|---|
 | Where content is stored | Git object store (content-addressed blobs) |
-| How content is referenced | `_content` property on nodes (CAS SHA) |
+| How content is referenced | `_content` property on nodes/edges (CAS SHA) |
 | CRDT model | Existing LWW property semantics, no change |
 | Time-travel | Automatic via `materialize({ ceiling })` |
-| New dependency | `git-cas` (or equivalent plumbing) |
-| API shape | TBD — property convention, dedicated methods, or hybrid |
-| Edge attachments | Deferred to v2 |
+| New dependency | None (uses existing BlobPort on GitGraphAdapter) |
+| API shape | Hybrid: dedicated methods + direct property access |
+| GC protection | Blob OIDs embedded in patch commit tree |
+| Edge attachments | Included in v1 |
 | Nested WARP attachments | Future work |
-| Paper alignment | Implements `Atom(p)` for vertex attachments |
+| Paper alignment | Implements `Atom(p)` for vertex and edge attachments |
diff --git a/index.d.ts b/index.d.ts
index ad8ac144..4eba613f 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -1147,6 +1147,12 @@ export function decodeEdgePropKey(encoded: string): { from: string; to: string;
  */
 export function isEdgePropKey(key: string): boolean;
 
+/**
+ * Well-known property key for content attachment.
+ * Stores a content-addressed blob OID as the property value.
+ */
+export const CONTENT_PROPERTY_KEY: '_content';
+
 /**
  * Configuration for an observer view.
  */
@@ -1345,6 +1351,10 @@ export class PatchBuilderV2 {
   setProperty(nodeId: string, key: string, value: unknown): PatchBuilderV2;
   /** Sets a property on an edge. */
   setEdgeProperty(from: string, to: string, label: string, key: string, value: unknown): PatchBuilderV2;
+  /** Attaches content to a node (writes blob + sets _content property). */
+  attachContent(nodeId: string, content: Buffer | string): Promise<PatchBuilderV2>;
+  /** Attaches content to an edge (writes blob + sets _content edge property). */
+  attachEdgeContent(from: string, to: string, label: string, content: Buffer | string): Promise<PatchBuilderV2>;
   /** Builds the PatchV2 object without committing. */
   build(): PatchV2;
   /** Commits the patch to the graph and returns the commit SHA. */
@@ -1375,6 +1385,10 @@ export class PatchSession {
   setProperty(nodeId: string, key: string, value: unknown): this;
   /** Sets a property on an edge. */
   setEdgeProperty(from: string, to: string, label: string, key: string, value: unknown): this;
+  /** Attaches content to a node (writes blob + sets _content property). */
+  attachContent(nodeId: string, content: Buffer | string): Promise<this>;
+  /** Attaches content to an edge (writes blob + sets _content edge property). */
+  attachEdgeContent(from: string, to: string, label: string, content: Buffer | string): Promise<this>;
   /** Builds the PatchV2 object without committing. */
   build(): PatchV2;
   /** Commits the patch with CAS protection. */
@@ -1645,6 +1659,28 @@ export default class WarpGraph {
    */
   getEdgeProps(from: string, to: string, label: string): Promise<Record<string, unknown> | null>;
 
+  /**
+   * Gets the content blob OID for a node, or null if none is attached.
+   */
+  getContentOid(nodeId: string): Promise<string | null>;
+
+  /**
+   * Gets the content blob for a node, or null if none is attached.
+   * Returns raw Buffer; call `.toString('utf8')` for text.
+   */
+  getContent(nodeId: string): Promise<Buffer | null>;
+
+  /**
+   * Gets the content blob OID for an edge, or null if none is attached.
+   */
+  getEdgeContentOid(from: string, to: string, label: string): Promise<string | null>;
+
+  /**
+   * Gets the content blob for an edge, or null if none is attached.
+   * Returns raw Buffer; call `.toString('utf8')` for text.
+   */
+  getEdgeContent(from: string, to: string, label: string): Promise<Buffer | null>;
+
   /**
    * Checks if a node exists in the materialized state.
    */
diff --git a/index.js b/index.js
index 2d3a354c..b4881ec0 100644
--- a/index.js
+++ b/index.js
@@ -75,6 +75,7 @@ import {
   encodeEdgePropKey,
   decodeEdgePropKey,
   isEdgePropKey,
+  CONTENT_PROPERTY_KEY,
 } from './src/domain/services/KeyCodec.js';
 import {
   createTickReceipt,
@@ -173,6 +174,7 @@ export {
   encodeEdgePropKey,
   decodeEdgePropKey,
   isEdgePropKey,
+  CONTENT_PROPERTY_KEY,
 
   // WARP migration
   migrateV4toV5,
diff --git a/package-lock.json b/package-lock.json
index 1caee709..7d8d790d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@git-stunts/git-warp",
-  "version": "11.4.0",
+  "version": "11.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@git-stunts/git-warp",
-      "version": "11.4.0",
+      "version": "11.5.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@git-stunts/alfred": "^0.4.0",
diff --git a/package.json b/package.json
index 5f296fca..d47c4b0e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@git-stunts/git-warp",
-  "version": "11.4.0",
+  "version": "11.5.0",
   "description": "Deterministic WARP graph over Git: graph-native storage, traversal, and tooling.",
   "type": "module",
   "license": "Apache-2.0",
diff --git a/src/domain/services/CheckpointService.js b/src/domain/services/CheckpointService.js
index 85a36cc2..4d681e3c 100644
--- a/src/domain/services/CheckpointService.js
+++ b/src/domain/services/CheckpointService.js
@@ -25,7 +25,7 @@ import { createORSet, orsetAdd, orsetCompact } from '../crdt/ORSet.js';
 import { createDot } from '../crdt/Dot.js';
 import { createVersionVector } from '../crdt/VersionVector.js';
 import { cloneStateV5, reduceV5 } from './JoinReducer.js';
-import { encodeEdgeKey, encodePropKey } from './KeyCodec.js';
+import { encodeEdgeKey, encodePropKey, CONTENT_PROPERTY_KEY, decodePropKey, isEdgePropKey, decodeEdgePropKey } from './KeyCodec.js';
 import { ProvenanceIndex } from './ProvenanceIndex.js';
 
 // ============================================================================
@@ -132,6 +132,20 @@ export async function createV5({
     provenanceIndexBlobOid = await persistence.writeBlob(/** @type {Buffer} */ (provenanceIndexBuffer));
   }
 
+  // 6c. Collect content blob OIDs from state properties for GC anchoring.
+  // If patch commits are ever pruned, content blobs remain reachable via
+  // the checkpoint tree. Without this, git gc would nuke content blobs
+  // whose only anchor was the (now-pruned) patch commit tree.
+  const contentOids = new Set();
+  for (const [propKey, register] of checkpointState.prop) {
+    const { propKey: decodedKey } = isEdgePropKey(propKey)
+      ? decodeEdgePropKey(propKey)
+      : decodePropKey(propKey);
+    if (decodedKey === CONTENT_PROPERTY_KEY && typeof register.value === 'string') {
+      contentOids.add(register.value);
+    }
+  }
+
   // 7. Create tree with sorted entries
   const treeEntries = [
     `100644 blob ${appliedVVBlobOid}\tappliedVV.cbor`,
@@ -145,6 +159,11 @@ export async function createV5({
     treeEntries.push(`100644 blob ${provenanceIndexBlobOid}\tprovenanceIndex.cbor`);
   }
 
+  // Add content blob anchors
+  for (const oid of contentOids) {
+    treeEntries.push(`100644 blob ${oid}\t_content_${oid}`);
+  }
+
   // Sort entries by filename for deterministic tree (git requires sorted entries by path)
   treeEntries.sort((a, b) => {
     const filenameA = a.split('\t')[1];
diff --git a/src/domain/services/JoinReducer.js b/src/domain/services/JoinReducer.js
index e3a77015..0aa2fa43 100644
--- a/src/domain/services/JoinReducer.js
+++ b/src/domain/services/JoinReducer.js
@@ -328,6 +328,19 @@ function propSetOutcome(propMap, op, eventId) {
   return { target, result: 'redundant' };
 }
 
+/**
+ * Folds a patch's own dot into the observed frontier.
+ * @param {Map<string, number>} frontier
+ * @param {string} writer
+ * @param {number} lamport
+ */
+function foldPatchDot(frontier, writer, lamport) {
+  const current = frontier.get(writer) || 0;
+  if (lamport > current) {
+    frontier.set(writer, lamport);
+  }
+}
+
 /**
  * Joins a patch into state, applying all operations in order.
  *
@@ -366,6 +379,7 @@ export function join(state, patch, patchSha, collectReceipts) {
       ? patch.context
       : vvDeserialize(patch.context);
     state.observedFrontier = vvMerge(state.observedFrontier, contextVV);
+    foldPatchDot(state.observedFrontier, patch.writer, patch.lamport);
     return state;
   }
 
@@ -423,6 +437,7 @@ export function join(state, patch, patchSha, collectReceipts) {
     ? patch.context
     : vvDeserialize(patch.context);
   state.observedFrontier = vvMerge(state.observedFrontier, contextVV);
+  foldPatchDot(state.observedFrontier, patch.writer, patch.lamport);
 
   const receipt = createTickReceipt({
     patchSha,
diff --git a/src/domain/services/KeyCodec.js b/src/domain/services/KeyCodec.js
index 42e04c89..f177c407 100644
--- a/src/domain/services/KeyCodec.js
+++ b/src/domain/services/KeyCodec.js
@@ -18,6 +18,13 @@ export const FIELD_SEPARATOR = '\0';
  */
 export const EDGE_PROP_PREFIX = '\x01';
 
+/**
+ * Well-known property key for content attachment.
+ * Stores a content-addressed blob OID as the property value.
+ * @const {string}
+ */
+export const CONTENT_PROPERTY_KEY = '_content';
+
 /**
  * Encodes an edge key to a string for Map storage.
  *
diff --git a/src/domain/services/PatchBuilderV2.js b/src/domain/services/PatchBuilderV2.js
index e1a08f80..76742124 100644
--- a/src/domain/services/PatchBuilderV2.js
+++ b/src/domain/services/PatchBuilderV2.js
@@ -23,7 +23,7 @@ import {
   createPropSetV2,
   createPatchV2,
 } from '../types/WarpTypesV2.js';
-import { encodeEdgeKey, EDGE_PROP_PREFIX } from './KeyCodec.js';
+import { encodeEdgeKey, EDGE_PROP_PREFIX, CONTENT_PROPERTY_KEY } from './KeyCodec.js';
 import { encodePatchMessage, decodePatchMessage, detectMessageKind } from './WarpMessageCodec.js';
 import { buildWriterRef } from '../utils/RefLayout.js';
 import WriterError from '../errors/WriterError.js';
@@ -124,6 +124,13 @@ export class PatchBuilderV2 {
     /** @type {{ warn: Function }} */
     this._logger = logger || nullLogger;
 
+    /**
+     * Content blob OIDs written during this patch via attachContent/attachEdgeContent.
+     * These are embedded in the commit tree for GC protection.
+     * @type {string[]}
+     */
+    this._contentBlobs = [];
+
     /**
      * Nodes/edges read by this patch (for provenance tracking).
      *
@@ -430,6 +437,45 @@ export class PatchBuilderV2 {
     return this;
   }
 
+  /**
+   * Attaches content to a node by writing the blob to the Git object store
+   * and storing the blob OID as the `_content` property.
+   *
+   * The blob OID is also tracked for embedding in the commit tree, which
+   * ensures content blobs survive `git gc` (GC protection via reachability).
+   *
+   * Note: The node must exist in the materialized state (or be added in
+   * this patch) for `getContent()` to find it later. `attachContent()`
+   * only sets the `_content` property — it does not create the node.
+   *
+   * @param {string} nodeId - The node ID to attach content to
+   * @param {Buffer|string} content - The content to attach
+   * @returns {Promise<PatchBuilderV2>} This builder instance for method chaining
+   */
+  async attachContent(nodeId, content) {
+    const oid = await this._persistence.writeBlob(content);
+    this.setProperty(nodeId, CONTENT_PROPERTY_KEY, oid);
+    this._contentBlobs.push(oid);
+    return this;
+  }
+
+  /**
+   * Attaches content to an edge by writing the blob to the Git object store
+   * and storing the blob OID as the `_content` edge property.
+   *
+   * @param {string} from - Source node ID
+   * @param {string} to - Target node ID
+   * @param {string} label - Edge label
+   * @param {Buffer|string} content - The content to attach
+   * @returns {Promise<PatchBuilderV2>} This builder instance for method chaining
+   */
+  async attachEdgeContent(from, to, label, content) {
+    const oid = await this._persistence.writeBlob(content);
+    this.setEdgeProperty(from, to, label, CONTENT_PROPERTY_KEY, oid);
+    this._contentBlobs.push(oid);
+    return this;
+  }
+
   /**
    * Builds the PatchV2 object without committing.
    *
@@ -577,10 +623,14 @@ export class PatchBuilderV2 {
     const patchCbor = this._codec.encode(patch);
     const patchBlobOid = await this._persistence.writeBlob(/** @type {Buffer} */ (patchCbor));
 
-    // 6. Create tree with the blob
+    // 6. Create tree with the patch blob + any content blobs (deduplicated)
     // Format for mktree: "mode type oid\tpath"
-    const treeEntry = `100644 blob ${patchBlobOid}\tpatch.cbor`;
-    const treeOid = await this._persistence.writeTree([treeEntry]);
+    const treeEntries = [`100644 blob ${patchBlobOid}\tpatch.cbor`];
+    const uniqueBlobs = [...new Set(this._contentBlobs)];
+    for (const blobOid of uniqueBlobs) {
+      treeEntries.push(`100644 blob ${blobOid}\t_content_${blobOid}`);
+    }
+    const treeOid = await this._persistence.writeTree(treeEntries);
 
     // 7. Create commit with proper trailers linking to the parent
     const commitMessage = encodePatchMessage({
diff --git a/src/domain/warp/PatchSession.js b/src/domain/warp/PatchSession.js
index 09f793da..de04a694 100644
--- a/src/domain/warp/PatchSession.js
+++ b/src/domain/warp/PatchSession.js
@@ -148,6 +148,37 @@ export class PatchSession {
     return this;
   }
 
+  /**
+   * Attaches content to a node.
+   *
+   * @param {string} nodeId - The node ID to attach content to
+   * @param {Buffer|string} content - The content to attach
+   * @returns {Promise<this>} This session for chaining
+   * @throws {Error} If this session has already been committed
+   */
+  async attachContent(nodeId, content) {
+    this._ensureNotCommitted();
+    await this._builder.attachContent(nodeId, content);
+    return this;
+  }
+
+  /**
+   * Attaches content to an edge.
+   *
+   * @param {string} from - Source node ID
+   * @param {string} to - Target node ID
+   * @param {string} label - Edge label/type
+   * @param {Buffer|string} content - The content to attach
+   * @returns {Promise<this>} This session for chaining
+   * @throws {Error} If this session has already been committed
+   */
+  // eslint-disable-next-line max-params -- direct delegate matching PatchBuilderV2 signature
+  async attachEdgeContent(from, to, label, content) {
+    this._ensureNotCommitted();
+    await this._builder.attachEdgeContent(from, to, label, content);
+    return this;
+  }
+
   /**
    * Builds the PatchV2 object without committing.
    *
diff --git a/src/domain/warp/query.methods.js b/src/domain/warp/query.methods.js
index 93e92abe..920031c8 100644
--- a/src/domain/warp/query.methods.js
+++ b/src/domain/warp/query.methods.js
@@ -8,7 +8,7 @@
  */
 
 import { orsetContains, orsetElements } from '../crdt/ORSet.js';
-import { decodePropKey, isEdgePropKey, decodeEdgePropKey, encodeEdgeKey, decodeEdgeKey } from '../services/KeyCodec.js';
+import { decodePropKey, isEdgePropKey, decodeEdgePropKey, encodeEdgeKey, decodeEdgeKey, CONTENT_PROPERTY_KEY } from '../services/KeyCodec.js';
 import { compareEventIds } from '../utils/EventId.js';
 import { cloneStateV5 } from '../services/JoinReducer.js';
 import QueryBuilder from '../services/QueryBuilder.js';
@@ -278,3 +278,85 @@ export async function translationCost(configA, configB) {
   const s = /** @type {import('../services/JoinReducer.js').WarpStateV5} */ (this._cachedState);
   return computeTranslationCost(configA, configB, s);
 }
+
+/**
+ * Gets the content blob OID for a node, or null if none is attached.
+ *
+ * @this {import('../WarpGraph.js').default}
+ * @param {string} nodeId - The node ID to check
+ * @returns {Promise<string|null>} Hex blob OID or null
+ * @throws {import('../errors/QueryError.js').default} If no cached state exists (code: `E_NO_STATE`)
+ */
+export async function getContentOid(nodeId) {
+  const props = await getNodeProps.call(this, nodeId);
+  if (!props) {
+    return null;
+  }
+  // getNodeProps returns a Map — use .get() for property access
+  const oid = props.get(CONTENT_PROPERTY_KEY);
+  return (typeof oid === 'string') ? oid : null;
+}
+
+/**
+ * Gets the content blob for a node, or null if none is attached.
+ *
+ * Returns the raw Buffer from `readBlob()`. Consumers wanting text
+ * should call `.toString('utf8')` on the result.
+ *
+ * @this {import('../WarpGraph.js').default}
+ * @param {string} nodeId - The node ID to get content for
+ * @returns {Promise<Buffer|null>} Content buffer or null
+ * @throws {Error} If the referenced blob OID is not in the object store
+ *   (e.g., garbage-collected despite anchoring). Callers should handle this
+ *   if operating on repos with aggressive GC or partial clones.
+ */
+export async function getContent(nodeId) {
+  const oid = await getContentOid.call(this, nodeId);
+  if (!oid) {
+    return null;
+  }
+  return await this._persistence.readBlob(oid);
+}
+
+/**
+ * Gets the content blob OID for an edge, or null if none is attached.
+ *
+ * @this {import('../WarpGraph.js').default}
+ * @param {string} from - Source node ID
+ * @param {string} to - Target node ID
+ * @param {string} label - Edge label
+ * @returns {Promise<string|null>} Hex blob OID or null
+ * @throws {import('../errors/QueryError.js').default} If no cached state exists (code: `E_NO_STATE`)
+ */
+export async function getEdgeContentOid(from, to, label) {
+  const props = await getEdgeProps.call(this, from, to, label);
+  if (!props) {
+    return null;
+  }
+  // getEdgeProps returns a plain object — use bracket access
+  const oid = props[CONTENT_PROPERTY_KEY];
+  return (typeof oid === 'string') ? oid : null;
+}
+
+/**
+ * Gets the content blob for an edge, or null if none is attached.
+ *
+ * Returns the raw Buffer from `readBlob()`. Consumers wanting text
+ * should call `.toString('utf8')` on the result.
+ *
+ * @this {import('../WarpGraph.js').default}
+ * @param {string} from - Source node ID
+ * @param {string} to - Target node ID
+ * @param {string} label - Edge label
+ * @returns {Promise<Buffer|null>} Content buffer or null
+ * @throws {Error} If the referenced blob OID is not in the object store
+ *   (e.g., garbage-collected despite anchoring). Callers should handle this
+ *   if operating on repos with aggressive GC or partial clones.
+ */
+export async function getEdgeContent(from, to, label) {
+  const oid = await getEdgeContentOid.call(this, from, to, label);
+  if (!oid) {
+    return null;
+  }
+  return await this._persistence.readBlob(oid);
+}
diff --git a/src/infrastructure/adapters/GitGraphAdapter.js b/src/infrastructure/adapters/GitGraphAdapter.js
index f0b61780..bc41bbbb 100644
--- a/src/infrastructure/adapters/GitGraphAdapter.js
+++ b/src/infrastructure/adapters/GitGraphAdapter.js
@@ -43,6 +43,7 @@
  * @see {@link https://git-scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain} for Git plumbing concepts
  */
 
+import { Buffer } from 'node:buffer';
 import { retry } from '@git-stunts/alfred';
 import GraphPersistencePort from '../../ports/GraphPersistencePort.js';
 import { validateOid, validateRef, validateLimit, validateConfigKey } from './adapterValidation.js';
@@ -510,7 +511,9 @@ export default class GitGraphAdapter extends GraphPersistencePort {
     const stream = await this.plumbing.executeStream({
       args: ['cat-file', 'blob', oid]
     });
-    return await stream.collect({ asString: false });
+    const raw = await stream.collect({ asString: false });
+    // Ensure a real Node Buffer (plumbing may return Uint8Array)
+    return Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
   }
 
   /**
diff --git a/test/integration/api/content-attachment.test.js b/test/integration/api/content-attachment.test.js
new file mode 100644
index 00000000..5cb261ab
--- /dev/null
+++ b/test/integration/api/content-attachment.test.js
@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'node:child_process';
+import { createTestRepo } from './helpers/setup.js';
+
+describe('API: Content Attachment', () => {
+  /** @type {any} */
+  let repo;
+
+  beforeEach(async () => {
+    repo = await createTestRepo('content');
+  });
+
+  afterEach(async () => {
+    await repo?.cleanup();
+  });
+
+  it('attach → materialize → getContent returns exact buffer', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const patch = await graph.createPatch();
+    patch.addNode('doc:1');
+    await patch.attachContent('doc:1', '# Hello World\n\nThis is content.');
+    await patch.commit();
+
+    await graph.materialize();
+    const content = await graph.getContent('doc:1');
+    expect(content).not.toBeNull();
+    expect(content.toString('utf8')).toBe('# Hello World\n\nThis is content.');
+  });
+
+  it('getContentOid returns hex OID', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const patch = await graph.createPatch();
+    patch.addNode('doc:1');
+    await patch.attachContent('doc:1', 'test content');
+    await patch.commit();
+
+    await graph.materialize();
+    const oid = await graph.getContentOid('doc:1');
+    expect(oid).not.toBeNull();
+    // Support both SHA-1 (40 chars) and SHA-256 (64 chars)
+    expect(oid).toMatch(/^[0-9a-f]+$/);
+    expect(oid.length).toBeGreaterThanOrEqual(40);
+  });
+
+  it('returns null when no content attached', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const patch = await graph.createPatch();
+    patch.addNode('doc:1').setProperty('doc:1', 'title', 'No content');
+    await patch.commit();
+
+    await graph.materialize();
+    expect(await graph.getContent('doc:1')).toBeNull();
+    expect(await graph.getContentOid('doc:1')).toBeNull();
+  });
+
+  it('returns null for nonexistent node', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+    await graph.materialize();
+
+    expect(await graph.getContent('nonexistent')).toBeNull();
+    expect(await graph.getContentOid('nonexistent')).toBeNull();
+  });
+
+  it('edge content: attach and retrieve via getEdgeContent', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const p1 = await graph.createPatch();
+    p1.addNode('a').addNode('b').addEdge('a', 'b', 'rel');
+    await p1.attachEdgeContent('a', 'b', 'rel', 'edge payload');
+    await p1.commit();
+
+    await graph.materialize();
+    const content = await graph.getEdgeContent('a', 'b', 'rel');
+    expect(content).not.toBeNull();
+    expect(content.toString('utf8')).toBe('edge payload');
+
+    const oid = await graph.getEdgeContentOid('a', 'b', 'rel');
+    expect(oid).toMatch(/^[0-9a-f]+$/);
+  });
+
+  it('multi-writer LWW: concurrent attachments resolve deterministically', async () => {
+    const graph1 = await repo.openGraph('test', 'alice');
+    const graph2 = await repo.openGraph('test', 'bob');
+
+    // Alice creates the node
+    const p1 = await graph1.createPatch();
+    p1.addNode('doc:shared');
+    await p1.attachContent('doc:shared', 'alice version');
+    await p1.commit();
+
+    // Bob sees the node via materialize, then attaches different content
+    await graph2.materialize();
+    const p2 = await graph2.createPatch();
+    await p2.attachContent('doc:shared', 'bob version');
+    await p2.commit();
+
+    // Materialize from both writers — LWW resolves deterministically
+    await graph1.materialize();
+    const content = await graph1.getContent('doc:shared');
+    expect(content).not.toBeNull();
+
+    // Bob's content should win (higher Lamport tick)
+    expect(content.toString('utf8')).toBe('bob version');
+  });
+
+  it('time-travel: materialize with ceiling returns historical content', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    // Tick 1: attach v1
+    const p1 = await graph.createPatch();
+    p1.addNode('doc:1');
+    await p1.attachContent('doc:1', 'version 1');
+    await p1.commit();
+
+    // Tick 2: update to v2
+    await graph.materialize();
+    const p2 = await graph.createPatch();
+    await p2.attachContent('doc:1', 'version 2');
+    await p2.commit();
+
+    // Latest should be v2
+    await graph.materialize();
+    const latest = await graph.getContent('doc:1');
+    expect(latest.toString('utf8')).toBe('version 2');
+
+    // Ceiling=1 should be v1
+    await graph.materialize({ ceiling: 1 });
+    const historical = await graph.getContent('doc:1');
+    expect(historical.toString('utf8')).toBe('version 1');
+  });
+
+  it('node deletion removes content reference', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const p1 = await graph.createPatch();
+    p1.addNode('doc:1');
+    await p1.attachContent('doc:1', 'soon to be deleted');
+    await p1.commit();
+
+    await graph.materialize();
+    expect(await graph.getContent('doc:1')).not.toBeNull();
+
+    const p2 = await graph.createPatch();
+    p2.removeNode('doc:1');
+    await p2.commit();
+
+    await graph.materialize();
+    // After removing the node, getContent returns null (node not alive)
+    expect(await graph.getContent('doc:1')).toBeNull();
+  });
+
+  it('writer API: commitPatch with attachContent', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+    const writer = await graph.writer();
+
+    await writer.commitPatch(async (/** @type {any} */ p) => {
+      p.addNode('doc:1');
+      await p.attachContent('doc:1', 'via writer API');
+    });
+
+    await graph.materialize();
+    const content = await graph.getContent('doc:1');
+    expect(content.toString('utf8')).toBe('via writer API');
+  });
+
+  it('GC durability: content survives git gc --prune=now', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    const p1 = await graph.createPatch();
+    p1.addNode('doc:1');
+    await p1.attachContent('doc:1', 'must survive gc');
+    await p1.commit();
+
+    // Run aggressive GC in the test repo
+    execSync('git gc --prune=now', { cwd: repo.tempDir, stdio: 'pipe' });
+
+    // Content should still be retrievable (blob is anchored in commit tree)
+    await graph.materialize();
+    const content = await graph.getContent('doc:1');
+    expect(content).not.toBeNull();
+    expect(content.toString('utf8')).toBe('must survive gc');
+  });
+
+  it('checkpoint anchoring: content survives GC after checkpoint', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+
+    // Attach content and commit
+    const p1 = await graph.createPatch();
+    p1.addNode('doc:1');
+    await p1.attachContent('doc:1', 'checkpointed content');
+    await p1.commit();
+
+    // Materialize + create checkpoint (anchors content blob in checkpoint tree)
+    await graph.materialize();
+    await graph.createCheckpoint();
+
+    // Aggressive GC — would nuke loose blobs not reachable from any ref
+    execSync('git gc --prune=now', { cwd: repo.tempDir, stdio: 'pipe' });
+
+    // Re-open graph (fresh instance, no cached state)
+    const graph2 = await repo.openGraph('test', 'alice');
+    await graph2.materialize();
+    const content = await graph2.getContent('doc:1');
+    expect(content).not.toBeNull();
+    expect(content.toString('utf8')).toBe('checkpointed content');
+  });
+
+  it('binary content round-trips correctly', async () => {
+    const graph = await repo.openGraph('test', 'alice');
+    const binary = Buffer.from([0x00, 0x01, 0x02, 0xff, 0xfe, 0xfd]);
+
+    const patch = await graph.createPatch();
+    patch.addNode('bin:1');
+    await patch.attachContent('bin:1', binary);
+    await patch.commit();
+
+    await graph.materialize();
+    const content = await graph.getContent('bin:1');
+    expect(content).not.toBeNull();
+    expect(Buffer.compare(content, binary)).toBe(0);
+  });
+});
diff --git a/test/type-check/consumer.ts b/test/type-check/consumer.ts
index d228f0c4..e2b78c54 100644
--- a/test/type-check/consumer.ts
+++ b/test/type-check/consumer.ts
@@ -76,6 +76,7 @@ import WarpGraph, {
   encodeEdgePropKey,
   decodeEdgePropKey,
   isEdgePropKey,
+  CONTENT_PROPERTY_KEY,
 } from '../../index.js';
 
 import type {
@@ -177,6 +178,15 @@ const propCount: number = await graph.getPropertyCount();
 const snapshot: WarpStateV5 | null = await graph.getStateSnapshot();
 const edges: Array<{ from: string; to: string; label: string; props: Record<string, unknown> }> = await graph.getEdges();
 
+// ---- content attachment ----
+const contentOid: string | null = await graph.getContentOid('n1');
+const contentBuf: Buffer | null = await graph.getContent('n1');
+const edgeContentOid: string | null = await graph.getEdgeContentOid('n1', 'n2', 'knows');
+const edgeContentBuf: Buffer | null = await graph.getEdgeContent('n1', 'n2', 'knows');
+const _attachResult: PatchBuilderV2 = await pb.attachContent('n1', 'hello');
+const _attachEdgeResult: PatchBuilderV2 = await pb.attachEdgeContent('n1', 'n2', 'knows', Buffer.from('data'));
+const _contentKey: '_content' = CONTENT_PROPERTY_KEY;
+
 // ---- query builder ----
 const qb: QueryBuilder = graph.query();
 
@@ -213,6 +223,8 @@ const ps3: PatchSession = ps.setProperty('x', 'k', 'v').setEdgeProperty('a', 'b'
 const psPatch: PatchV2 = ps.build();
 const psSha: string = await ps.commit();
 const psOpCount: number = ps.opCount;
+const psAttach: PatchSession = await ps.attachContent('x', 'content');
+const psAttachEdge: PatchSession = await ps.attachEdgeContent('a', 'b', 'c', 'content');
 
 // ---- sync protocol ----
 const syncReq: SyncRequest = await graph.createSyncRequest();
@@ -440,3 +452,6 @@ await WarpGraph.open({ graphName: 'test', writerId: 'w1' });
 
 // @ts-expect-error -- createNodeAdd requires string, not number
 createNodeAdd(42);
+
+// @ts-expect-error -- getContent requires string, not number
+await graph.getContent(42);
diff --git a/test/unit/domain/WarpGraph.content.test.js b/test/unit/domain/WarpGraph.content.test.js
new file mode 100644
index 00000000..2bb570d2
--- /dev/null
+++ b/test/unit/domain/WarpGraph.content.test.js
@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import WarpGraph from '../../../src/domain/WarpGraph.js';
+import { createEmptyStateV5, encodeEdgeKey, encodeEdgePropKey } from '../../../src/domain/services/JoinReducer.js';
+import { orsetAdd } from '../../../src/domain/crdt/ORSet.js';
+import { createDot } from '../../../src/domain/crdt/Dot.js';
+import { encodePropKey } from '../../../src/domain/services/KeyCodec.js';
+
+function setupGraphState(/** @type {any} */ graph, /** @type {any} */ seedFn) {
+  const state = createEmptyStateV5();
+  /** @type {any} */ (graph)._cachedState = state;
+  graph.materialize = vi.fn().mockResolvedValue(state);
+  seedFn(state);
+}
+
+function addNode(/** @type {any} */ state, /** @type {any} */ nodeId, /** @type {any} */ counter) {
+  orsetAdd(state.nodeAlive, nodeId, createDot('w1', counter));
+}
+
+function addEdge(/** @type {any} */ state, /** @type {any} */ from, /** @type {any} */ to, /** @type {any} */ label, /** @type {any} */ counter) {
+  const edgeKey = encodeEdgeKey(from, to, label);
+  orsetAdd(state.edgeAlive, edgeKey, createDot('w1', counter));
+  state.edgeBirthEvent.set(edgeKey, { lamport: 1, writerId: 'w1', patchSha: 'aabbccdd', opIndex: 0 });
+}
+
+describe('WarpGraph content attachment (query methods)', () => {
+  /** @type {any} */
+  let mockPersistence;
+  /** @type {any} */
+  let graph;
+
+  beforeEach(async () => {
+    mockPersistence = {
+      readRef: vi.fn().mockResolvedValue(null),
+      listRefs: vi.fn().mockResolvedValue([]),
+      updateRef: vi.fn().mockResolvedValue(undefined),
+      configGet: vi.fn().mockResolvedValue(null),
+      configSet: vi.fn().mockResolvedValue(undefined),
+      readBlob: vi.fn().mockResolvedValue(Buffer.from('hello world')),
+    };
+
+    graph = await WarpGraph.open({
+      persistence: mockPersistence,
+      graphName: 'test',
+      writerId: 'writer-1',
+    });
+  });
+
+  describe('getContentOid()', () => {
+    it('returns the _content property value for a node', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'doc:1', 1);
+        const propKey = encodePropKey('doc:1', '_content');
+        state.prop.set(propKey, { eventId: null, value: 'abc123' });
+      });
+
+      const oid = await graph.getContentOid('doc:1');
+      expect(oid).toBe('abc123');
+    });
+
+    it('returns null when node has no _content property', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'doc:1', 1);
+      });
+
+      const oid = await graph.getContentOid('doc:1');
+      expect(oid).toBeNull();
+    });
+
+    it('returns null when node does not exist', async () => {
+      setupGraphState(graph, () => {});
+
+      const oid = await graph.getContentOid('nonexistent');
+      expect(oid).toBeNull();
+    });
+
+    it('returns null when _content is not a string', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'doc:1', 1);
+        const propKey = encodePropKey('doc:1', '_content');
+        state.prop.set(propKey, { eventId: null, value: 42 });
+      });
+
+      const oid = await graph.getContentOid('doc:1');
+      expect(oid).toBeNull();
+    });
+  });
+
+  describe('getContent()', () => {
+    it('reads and returns the blob buffer', async () => {
+      const buf = Buffer.from('# ADR 001\n\nSome content');
+      mockPersistence.readBlob.mockResolvedValue(buf);
+
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'doc:1', 1);
+        const propKey = encodePropKey('doc:1', '_content');
+        state.prop.set(propKey, { eventId: null, value: 'abc123' });
+      });
+
+      const content = await graph.getContent('doc:1');
+      expect(content).toEqual(buf);
+      expect(mockPersistence.readBlob).toHaveBeenCalledWith('abc123');
+    });
+
+    it('returns null when no content attached', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'doc:1', 1);
+      });
+
+      const content = await graph.getContent('doc:1');
+      expect(content).toBeNull();
+      expect(mockPersistence.readBlob).not.toHaveBeenCalled();
+    });
+
+    it('returns null for nonexistent node', async () => {
+      setupGraphState(graph, () => {});
+
+      const content = await graph.getContent('nonexistent');
+      expect(content).toBeNull();
+    });
+  });
+
+  describe('getEdgeContentOid()', () => {
+    it('returns the _content property value for an edge', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'a', 1);
+        addNode(state, 'b', 2);
+        addEdge(state, 'a', 'b', 'rel', 3);
+        const propKey = encodeEdgePropKey('a', 'b', 'rel', '_content');
+        state.prop.set(propKey, { eventId: { lamport: 2, writerId: 'w1', patchSha: 'aabbccdd', opIndex: 0 }, value: 'def456' });
+      });
+
+      const oid = await graph.getEdgeContentOid('a', 'b', 'rel');
+      expect(oid).toBe('def456');
+    });
+
+    it('returns null when edge has no _content', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'a', 1);
+        addNode(state, 'b', 2);
+        addEdge(state, 'a', 'b', 'rel', 3);
+      });
+
+      const oid = await graph.getEdgeContentOid('a', 'b', 'rel');
+      expect(oid).toBeNull();
+    });
+
+    it('returns null when edge does not exist', async () => {
+      setupGraphState(graph, () => {});
+
+      const oid = await graph.getEdgeContentOid('a', 'b', 'rel');
+      expect(oid).toBeNull();
+    });
+  });
+
+  describe('getEdgeContent()', () => {
+    it('reads and returns the blob buffer', async () => {
+      const buf = Buffer.from('edge content');
+      mockPersistence.readBlob.mockResolvedValue(buf);
+
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'a', 1);
+        addNode(state, 'b', 2);
+        addEdge(state, 'a', 'b', 'rel', 3);
+        const propKey = encodeEdgePropKey('a', 'b', 'rel', '_content');
+        state.prop.set(propKey, { eventId: { lamport: 2, writerId: 'w1', patchSha: 'aabbccdd', opIndex: 0 }, value: 'def456' });
+      });
+
+      const content = await graph.getEdgeContent('a', 'b', 'rel');
+      expect(content).toEqual(buf);
+      expect(mockPersistence.readBlob).toHaveBeenCalledWith('def456');
+    });
+
+    it('returns null when no content attached', async () => {
+      setupGraphState(graph, (/** @type {any} */ state) => {
+        addNode(state, 'a', 1);
+        addNode(state, 'b', 2);
+        addEdge(state, 'a', 'b', 'rel', 3);
+      });
+
+      const content = await graph.getEdgeContent('a', 'b', 'rel');
+      expect(content).toBeNull();
+    });
+  });
+});
diff --git a/test/unit/domain/WarpGraph.test.js b/test/unit/domain/WarpGraph.test.js
index dfae1242..a949f900 100644
--- a/test/unit/domain/WarpGraph.test.js
+++ b/test/unit/domain/WarpGraph.test.js
@@ -1652,8 +1652,10 @@ eg-schema: 2`;
         builder.addNode('user:alice');
         await builder.commit();
 
-        // After commit: writer-1 should be 1, writer-other should still be 5
-        expect(/** @type {any} */ (graph)._versionVector.get('writer-1')).toBe(1);
+        // After commit: writer-1 has lamport 6 (max(0, maxObserved=5) + 1),
+        // and observedFrontier (→ _versionVector) reflects the actual tick.
+        // writer-other should still be 5.
+        expect(/** @type {any} */ (graph)._versionVector.get('writer-1')).toBe(6);
         expect(/** @type {any} */ (graph)._versionVector.get('writer-other')).toBe(5);
       });
     });
diff --git a/test/unit/domain/__snapshots__/WarpGraph.apiSurface.test.js.snap b/test/unit/domain/__snapshots__/WarpGraph.apiSurface.test.js.snap
index 4132b63c..81507cdc 100644
--- a/test/unit/domain/__snapshots__/WarpGraph.apiSurface.test.js.snap
+++ b/test/unit/domain/__snapshots__/WarpGraph.apiSurface.test.js.snap
@@ -172,6 +172,26 @@ exports[`WarpGraph API surface > all prototype methods have correct property des
     "enumerable": false,
     "type": "getter",
   },
+  "getContent": {
+    "configurable": true,
+    "enumerable": false,
+    "type": "method",
+  },
+  "getContentOid": {
+    "configurable": true,
+    "enumerable": false,
+    "type": "method",
+  },
+  "getEdgeContent": {
+    "configurable": true,
+    "enumerable": false,
+    "type": "method",
+  },
+  "getEdgeContentOid": {
+    "configurable": true,
+    "enumerable": false,
+    "type": "method",
+  },
   "getEdgeProps": {
     "configurable": true,
     "enumerable": false,
@@ -380,7 +400,7 @@ exports[`WarpGraph API surface > all prototype methods have correct property des
 }
 `;
 
-exports[`WarpGraph API surface > prototype method count matches snapshot 1`] = `75`;
+exports[`WarpGraph API surface > prototype method count matches snapshot 1`] = `79`;
 
 exports[`WarpGraph API surface > prototype methods match snapshot 1`] = `
 [
@@ -418,6 +438,10 @@ exports[`WarpGraph API surface > prototype methods match snapshot 1`] = `
   "discoverWriters",
   "fork",
   "gcPolicy",
+  "getContent",
+  "getContentOid",
+  "getEdgeContent",
+  "getEdgeContentOid",
   "getEdgeProps",
   "getEdges",
   "getFrontier",
diff --git a/test/unit/domain/services/JoinReducer.test.js b/test/unit/domain/services/JoinReducer.test.js
index 3d7d7abb..6a98f4c3 100644
--- a/test/unit/domain/services/JoinReducer.test.js
+++ b/test/unit/domain/services/JoinReducer.test.js
@@ -673,5 +673,70 @@ describe('JoinReducer', () => {
       expect(state.observedFrontier.get('B')).toBe(8); // took higher
       expect(state.observedFrontier.get('C')).toBe(3); // added new
     });
+
+    it('incorporates the patch own dot into observedFrontier', () => {
+      const state = createEmptyStateV5();
+
+      const context = createVersionVector();
+      context.set('A', 5);
+      context.set('B', 3);
+
+      const patch = createPatchV2({
+        writer: 'C',
+        lamport: 1,
+        ops: [createNodeAddV2('x', createDot('C', 1))],
+        context,
+      });
+
+      join(state, patch, 'aaaa1234');
+
+      expect(state.observedFrontier.get('A')).toBe(5);
+      expect(state.observedFrontier.get('B')).toBe(3);
+      expect(state.observedFrontier.get('C')).toBe(1);
+    });
+
+    it('observedFrontier advances with each patch from the same writer', () => {
+      const state = createEmptyStateV5();
+
+      join(state, createPatchV2({
+        writer: 'A', lamport: 1,
+        ops: [createNodeAddV2('n1', createDot('A', 1))],
+        context: createVersionVector(),
+      }), 'aaaa0001');
+
+      expect(state.observedFrontier.get('A')).toBe(1);
+
+      const ctx2 = createVersionVector();
+      ctx2.set('A', 1);
+      join(state, createPatchV2({
+        writer: 'A', lamport: 2,
+        ops: [createNodeAddV2('n2', createDot('A', 2))],
+        context: ctx2,
+      }), 'aaaa0002');
+
+      expect(state.observedFrontier.get('A')).toBe(2);
+    });
+
+    it('incorporates patch own dot on receipt path', () => {
+      const state = createEmptyStateV5();
+
+      const context = createVersionVector();
+      context.set('A', 5);
+
+      const patch = createPatchV2({
+        writer: 'C',
+        lamport: 1,
+        ops: [createNodeAddV2('x', createDot('C', 1))],
+        context,
+      });
+
+      const result = join(state, patch, 'aaaa1234', true);
+
+      expect('state' in result).toBe(true);
+      const { state: s, receipt } = /** @type {{state: import('../../../../src/domain/services/JoinReducer.js').WarpStateV5, receipt: *}} */ (result);
+      expect(s.observedFrontier.get('A')).toBe(5);
+      expect(s.observedFrontier.get('C')).toBe(1);
+      expect(receipt).toBeDefined();
+    });
   });
 });
diff --git a/test/unit/domain/services/PatchBuilderV2.content.test.js b/test/unit/domain/services/PatchBuilderV2.content.test.js
new file mode 100644
index 00000000..1116712f
--- /dev/null
+++ b/test/unit/domain/services/PatchBuilderV2.content.test.js
@@ -0,0 +1,339 @@
+import { describe, it, expect, vi } from 'vitest';
+import { PatchBuilderV2 } from '../../../../src/domain/services/PatchBuilderV2.js';
+import { createVersionVector } from '../../../../src/domain/crdt/VersionVector.js';
+import { createORSet, orsetAdd } from '../../../../src/domain/crdt/ORSet.js';
+import { createDot } from '../../../../src/domain/crdt/Dot.js';
+import { encodeEdgeKey } from '../../../../src/domain/services/KeyCodec.js';
+
+/**
+ * Creates a mock persistence adapter for testing.
+ * @param {Object} [overrides]
+ * @returns {any}
+ */
+function createMockPersistence(overrides = {}) {
+  return {
+    readRef: vi.fn().mockResolvedValue(null),
+    showNode: vi.fn(),
+    writeBlob: vi.fn().mockResolvedValue('d'.repeat(40)),
+    writeTree: vi.fn().mockResolvedValue('e'.repeat(40)),
+    commitNodeWithTree: vi.fn().mockResolvedValue('f'.repeat(40)),
+    updateRef: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock V5 state for testing.
+ * @returns {any}
+ */
+function createMockState() {
+  return {
+    nodeAlive: createORSet(),
+    edgeAlive: createORSet(),
+    prop: new Map(),
+    observedFrontier: createVersionVector(),
+  };
+}
+
+describe('PatchBuilderV2 content attachment', () => {
+  describe('attachContent()', () => {
+    it('writes blob and sets _content property', async () => {
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockResolvedValue('abc123'),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+      }));
+
+      await builder.attachContent('node:1', 'hello world');
+
+      expect(persistence.writeBlob).toHaveBeenCalledWith('hello world');
+      const patch = builder.build();
+      expect(patch.ops).toHaveLength(1);
+      expect(patch.ops[0]).toMatchObject({
+        type: 'PropSet',
+        node: 'node:1',
+        key: '_content',
+        value: 'abc123',
+      });
+    });
+
+    it('tracks blob OID in _contentBlobs', async () => {
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockResolvedValue('abc123'),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+      }));
+
+      await builder.attachContent('node:1', 'content');
+
+      expect(builder._contentBlobs).toEqual(['abc123']);
+    });
+
+    it('returns the builder for chaining', async () => {
+      const persistence = createMockPersistence();
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+      }));
+
+      const result = await builder.attachContent('node:1', 'content');
+      expect(result).toBe(builder);
+    });
+
+    it('propagates writeBlob errors', async () => {
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockRejectedValue(new Error('disk full')),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+      }));
+
+      await expect(builder.attachContent('node:1', 'x')).rejects.toThrow('disk full');
+    });
+  });
+
+  describe('attachEdgeContent()', () => {
+    it('writes blob and sets _content edge property', async () => {
+      const state = createMockState();
+      const edgeKey = encodeEdgeKey('a', 'b', 'rel');
+      orsetAdd(state.edgeAlive, edgeKey, createDot('w1', 1));
+
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockResolvedValue('def456'),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => state,
+      }));
+
+      await builder.attachEdgeContent('a', 'b', 'rel', Buffer.from('binary'));
+
+      expect(persistence.writeBlob).toHaveBeenCalledWith(Buffer.from('binary'));
+      const patch = builder.build();
+      expect(patch.ops).toHaveLength(1);
+      expect(patch.ops[0]).toMatchObject({
+        type: 'PropSet',
+        key: '_content',
+        value: 'def456',
+      });
+      // Schema should be 3 (edge properties present)
+      expect(patch.schema).toBe(3);
+    });
+
+    it('tracks blob OID in _contentBlobs', async () => {
+      const state = createMockState();
+      orsetAdd(state.edgeAlive, encodeEdgeKey('a', 'b', 'rel'), createDot('w1', 1));
+
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockResolvedValue('def456'),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => state,
+      }));
+
+      await builder.attachEdgeContent('a', 'b', 'rel', 'content');
+
+      expect(builder._contentBlobs).toEqual(['def456']);
+    });
+
+    it('returns the builder for chaining', async () => {
+      const state = createMockState();
+      orsetAdd(state.edgeAlive, encodeEdgeKey('a', 'b', 'rel'), createDot('w1', 1));
+
+      const persistence = createMockPersistence();
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => state,
+      }));
+
+      const result = await builder.attachEdgeContent('a', 'b', 'rel', 'x');
+      expect(result).toBe(builder);
+    });
+
+    it('does not pollute _contentBlobs when edge does not exist', async () => {
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockResolvedValue('def456'),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => createMockState(),
+      }));
+
+      await expect(
+        builder.attachEdgeContent('no', 'such', 'edge', 'content')
+      ).rejects.toThrow();
+      expect(builder._contentBlobs).toEqual([]);
+    });
+  });
+
+  describe('multiple attachments in one patch', () => {
+    it('tracks multiple blob OIDs', async () => {
+      let callCount = 0;
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockImplementation(() => {
+          callCount++;
+          return Promise.resolve(`blob${callCount}`);
+        }),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+      }));
+
+      await builder.attachContent('node:1', 'first');
+      await builder.attachContent('node:2', 'second');
+
+      expect(builder._contentBlobs).toEqual(['blob1', 'blob2']);
+      expect(persistence.writeBlob).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('commit() with content blobs', () => {
+    it('includes _content_<oid> entries in tree when content blobs exist', async () => {
+      const contentOid = 'a'.repeat(40);
+      const patchBlobOid = 'b'.repeat(40);
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn()
+          .mockResolvedValueOnce(contentOid) // attachContent writeBlob
+          .mockResolvedValueOnce(patchBlobOid), // commit() CBOR blob
+        writeTree: vi.fn().mockResolvedValue('c'.repeat(40)),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        graphName: 'g',
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+        expectedParentSha: null,
+      }));
+
+      builder.addNode('n1');
+      await builder.attachContent('n1', 'hello');
+      await builder.commit();
+
+      // writeTree should be called with both patch.cbor and _content_<oid>
+      const treeEntries = persistence.writeTree.mock.calls[0][0];
+      expect(treeEntries).toHaveLength(2);
+      expect(treeEntries[0]).toBe(`100644 blob ${patchBlobOid}\tpatch.cbor`);
+      expect(treeEntries[1]).toBe(`100644 blob ${contentOid}\t_content_${contentOid}`);
+    });
+
+    it('creates single-entry tree when no content blobs', async () => {
+      const persistence = createMockPersistence();
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        graphName: 'g',
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+        expectedParentSha: null,
+      }));
+
+      builder.addNode('n1');
+      await builder.commit();
+
+      const treeEntries = persistence.writeTree.mock.calls[0][0];
+      expect(treeEntries).toHaveLength(1);
+      expect(treeEntries[0]).toContain('patch.cbor');
+    });
+
+    it('includes multiple _content_<oid> entries for multiple attachments', async () => {
+      let blobIdx = 0;
+      const contentA = '1'.repeat(40);
+      const contentB = '2'.repeat(40);
+      const patchBlob = '3'.repeat(40);
+      const blobOids = [contentA, contentB, patchBlob];
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockImplementation(() =>
+          Promise.resolve(blobOids[blobIdx++])),
+        writeTree: vi.fn().mockResolvedValue('4'.repeat(40)),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        graphName: 'g',
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+        expectedParentSha: null,
+      }));
+
+      builder.addNode('n1').addNode('n2');
+      await builder.attachContent('n1', 'first');
+      await builder.attachContent('n2', 'second');
+      await builder.commit();
+
+      const treeEntries = persistence.writeTree.mock.calls[0][0];
+      expect(treeEntries).toHaveLength(3);
+      expect(treeEntries[0]).toContain('patch.cbor');
+      expect(treeEntries[1]).toBe(`100644 blob ${contentA}\t_content_${contentA}`);
+      expect(treeEntries[2]).toBe(`100644 blob ${contentB}\t_content_${contentB}`);
+    });
+
+    it('deduplicates tree entries when same content is attached to multiple nodes', async () => {
+      const sharedOid = 'a'.repeat(40);
+      const patchBlob = 'b'.repeat(40);
+      let callCount = 0;
+      const blobOids = [sharedOid, sharedOid, patchBlob];
+      const persistence = createMockPersistence({
+        writeBlob: vi.fn().mockImplementation(() =>
+          Promise.resolve(blobOids[callCount++])),
+        writeTree: vi.fn().mockResolvedValue('c'.repeat(40)),
+      });
+      const builder = new PatchBuilderV2(/** @type {any} */ ({
+        persistence,
+        graphName: 'g',
+        writerId: 'w1',
+        lamport: 1,
+        versionVector: createVersionVector(),
+        getCurrentState: () => null,
+        expectedParentSha: null,
+      }));
+
+      builder.addNode('n1').addNode('n2');
+      await builder.attachContent('n1', 'same-data');
+      await builder.attachContent('n2', 'same-data');
+      await builder.commit();
+
+      const treeEntries = persistence.writeTree.mock.calls[0][0];
+      expect(treeEntries).toHaveLength(2);
+      expect(treeEntries[0]).toContain('patch.cbor');
+      expect(treeEntries[1]).toBe(`100644 blob ${sharedOid}\t_content_${sharedOid}`);
+    });
+  });
+});