feat(adapters): GitShardAdapter write=commit + current_rev drift (WP-0012 T2)

Writable mode: write(key, body) stages and commits the file (skipping a no-op so
no empty commit is created), returning the page at the new commit sha. The
writable profile declares WRITE + VERSION with PER_PAGE granularity. current_rev
is the per-path commit sha, so a write — or an external commit to the same path —
moves it, driving apply-under-drift. Passes the conformance positive-write probe.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/shard_wiki/adapters/git.py

@@ -29,6 +29,7 @@ from shard_wiki.model import (
     Identity,
     MergeModel,
     NativeQuery,
+    NotSupported,
     OperationalEnvelope,
     Page,
     Placement,
@@ -52,9 +53,10 @@ _GIT_IDENTITY = {
 class GitShardAdapter(ShardAdapter):
     """A shard whose store is a git repo: keys are tracked ``*.md`` paths, revs are commit shas."""
 
-    def __init__(self, shard_id: str, repo_path: str | Path) -> None:
+    def __init__(self, shard_id: str, repo_path: str | Path, writable: bool = False) -> None:
         self._shard_id = shard_id
         self._repo = Path(repo_path)
+        self._writable = writable
         self._repo.mkdir(parents=True, exist_ok=True)
         if not (self._repo / ".git").exists():
             self._git("init", "--quiet")
@@ -64,10 +66,16 @@ class GitShardAdapter(ShardAdapter):
         return self._shard_id
 
     def profile(self) -> CapabilityProfile:
+        # Write is a commit; VERSION is git-native history (adopt, §A.5). Read-only drops both.
+        verbs = {Verb.READ}
+        granularity = WriteGranularity.NONE
+        if self._writable:
+            verbs |= {Verb.WRITE, Verb.VERSION}
+            granularity = WriteGranularity.PER_PAGE
         return CapabilityProfile(
             substrate=Substrate.GIT,
             attachment_mode=AttachmentMode.GIT_IS_STORE,
-            write_granularity=WriteGranularity.NONE,
+            write_granularity=granularity,
             content_opacity=ContentOpacity.TRANSPARENT,
             operational_envelope=OperationalEnvelope.LOCAL_UNBOUNDED,
             access_grant=AccessGrant.OPEN,
@@ -77,9 +85,23 @@ class GitShardAdapter(ShardAdapter):
             addressing=Addressing.PATH,
             native_query=NativeQuery.NONE,
             translation=Translation.NATIVE,
-            supported_verbs=frozenset({Verb.READ}),
+            supported_verbs=frozenset(verbs),
         ).validate()
 
+    def write(self, key: str, body: str) -> Page:
+        """Write = **commit**: stage the file and commit it (skip a no-op so no empty commit),
+        returning the page at the new sha. Drift detection rides on ``current_rev`` = that sha."""
+        if not self._writable:
+            raise NotSupported(f"{type(self).__name__} is read-only")
+        rel = f"{key}.md"
+        path = self._path_for(key)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(body, encoding="utf-8")
+        self._git("add", "--", rel)
+        if self._run("diff", "--cached", "--quiet").returncode != 0:  # staged changes present
+            self._git("commit", "-m", f"write {rel}", env=_GIT_IDENTITY)
+        return self.read(key)
+
     def keys(self) -> Iterable[str]:
         out = self._git("ls-files", "*.md").decode()
         for line in out.splitlines():
@@ -117,11 +139,15 @@ class GitShardAdapter(ShardAdapter):
         return self._repo / f"{key}.md"
 
     def _git(self, *args: str, stdin: bytes | None = None, env: dict | None = None) -> bytes:
-        result = subprocess.run(
+        return self._run(*args, stdin=stdin, env=env, check=True).stdout
+
+    def _run(
+        self, *args: str, stdin: bytes | None = None, env: dict | None = None, check: bool = False
+    ) -> subprocess.CompletedProcess:
+        return subprocess.run(
             ["git", "-C", str(self._repo), *args],
             input=stdin,
             capture_output=True,
             env={**os.environ, **(env or {})},
-            check=True,
+            check=check,
         )
-        return result.stdout