fix: order graph edges by source then target in buffered encoder (SPEC 16.1)

The buffered graph encoder emitted edges in input order; SPEC 16.1 requires
ordering by source ID then target ID. Edges are now sorted by (source ID, target
ID, edge type) before emitting. Decode-invariant (edges are a set) and does not
affect pack_root (which sorts edge records independently), so no content addresses
change. Streaming edges remain in producer-arrival order. Pinned by shared fixture
graph-encode/003.

Author: blackwell-systems

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Buffered graph encoder: order edges by source ID, then target ID, then edge type (SPEC 16.1), instead of emitting them in input order. Decode-invariant (edges are a set) and does not affect `pack_root` (which sorts edge records independently), so no content addresses change. Pinned by shared fixture `graph-encode/003`. Streaming edges remain in producer-arrival order.
 - Decoder: reject an orphan `.field` attachment (a `.field` whose name is neither a `^`-marked column of its row nor a `>`-containing field name, SPEC 7.4.6.1.4) instead of silently absorbing it as an undeclared extra field. Such a stray attachment previously decoded to a record no encoder produces, silently injecting a field onto the last-parsed row (a lossless round-trip hole); now rejected per SPEC 16.5 (`orphan_attachment`).
 - Decoder: reject an orphan positional inline body (a pipe-delimited line with no eligible `^{}` attachment-marker cell) instead of silently dropping it. The object-body parser previously skipped any unrecognized line, so a stray positional body (e.g. a second `Bob|b@t.com` after a row's one inline cell was filled) vanished with no error (silent data loss); now rejected per SPEC 16.5 (`orphan_inline_attachment`).
 - Graph streaming trailer: the edge count is now always the last `counts` entry, even when the stream has no edges (positional `counts=2,1,0`; labeled `counts=…,edges:0`). A zero-edge stream previously dropped it, violating the SPEC §8.4 / §8.4.1 rule that the edge count is always present and last (the invariant that keeps the positional form unambiguous). The graph trailer is decoder-ignored, so this changes producer output only.

src/gcf/encode.py

@@ -52,17 +52,25 @@ def encode(p: Payload) -> str:
             kind = KIND_ABBREV.get(s.kind, s.kind)
             parts.append(f"@{idx} {kind} {s.qualified_name} {s.score:.2f} {s.provenance}")
 
-    # Edges section.
+    # Edges section. Order edges by source ID then target ID (then edge type
+    # for parallel edges) so the wire is canonical regardless of the order
+    # edges were provided (SPEC 16.1). Edge reordering is decode-invariant
+    # (edges are a set) and does not affect pack_root, which sorts edge records
+    # independently.
     if p.edges:
-        edge_lines: list[str] = []
+        resolved: list[tuple[int, int, str, str]] = []
         for e in p.edges:
             src_idx = sym_index.get(e.source)
             tgt_idx = sym_index.get(e.target)
             if src_idx is None or tgt_idx is None:
                 continue
-            line = f"@{tgt_idx}<@{src_idx} {e.edge_type}"
-            if e.status and e.status != "unchanged":
-                line += f" {e.status}"
+            resolved.append((src_idx, tgt_idx, e.edge_type, e.status))
+        resolved.sort(key=lambda r: (r[0], r[1], r[2]))
+        edge_lines: list[str] = []
+        for src_idx, tgt_idx, edge_type, status in resolved:
+            line = f"@{tgt_idx}<@{src_idx} {edge_type}"
+            if status and status != "unchanged":
+                line += f" {status}"
             edge_lines.append(line)
         parts.append(f"## edges [{len(edge_lines)}]")
         parts.extend(edge_lines)