A sync that changed nothing says so again

Comparing the per-node digest against an engine that does not record one is
comparing against nothing, and reporting every node as changed on every sync
for ever — which is what a client newer than its engine did, since `NodeDef`
drops fields it has never heard of. A node is named now only when both sides
carry a digest, so a no-op sync is `unchanged` again and the signal one syncs
for is back.

That silence had also been the only sign of the mismatch, so sync now names
it: one line saying the engine stored no record of what a node's code reaches,
with both versions in it and what to run. Bumped to 0.1.6 — the digest changed
the stored document's shape, and a version that does not move makes two
different engines indistinguishable, which is the thing it was made
load-bearing for a day ago.

`— draft` was printed whenever there was simply nothing to publish, which
reads as work left unfinished. It is said only when a draft is genuinely
there, and `— published` when one was.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01A9Hdrmf2cwNABCnE5x9UJa

backend/fluksio/sdk/client.py

@@ -636,6 +636,13 @@ class SyncReport:
         self.created = False
         self.changed: list[str] = []
         self.published = False
+        #: A draft exists and was left alone, because publishing was not asked
+        #: for. False when there was simply nothing to publish, which is not
+        #: the same thing and used to read as if it were.
+        self.drafted = False
+        #: The engine stored the node document without what each node's code
+        #: reaches, which means it is older than this client.
+        self.forgot_code = False
 
     @property
     def unchanged(self) -> bool:
@@ -729,6 +736,14 @@ def _sync_one(
     document = target.document(origin)
     moved = _moved_code(stored, document)
     saved = client.put_flow(document | {"version": version})
+    # An engine older than the per-node digest parses the document without
+    # those fields and stores it without them, silently: no error, no 404, and
+    # a cache still keyed on the whole repository.
+    kept = _digests(saved.get("definition"))
+    report.forgot_code = any(
+        digest and not kept.get(node_id)
+        for node_id, digest in _digests(document).items()
+    )
     stored_version = int((saved.get("definition") or {}).get("version") or version)
     if report.created or stored_version != version:
         # The store bumps the version only when the content actually changed,
@@ -751,12 +766,23 @@ def _sync_one(
         if node_id not in report.changed:
             report.changed.append(node_id)
 
-    if publish and (client.get_flow(target.name) or {}).get("has_draft"):
+    has_draft = bool((client.get_flow(target.name) or {}).get("has_draft"))
+    if publish and has_draft:
         client.publish(target.name, version)
         report.published = True
+    else:
+        # Only when one is actually there. "Nothing needed publishing" and
+        # "left as a draft" are different answers to the same question.
+        report.drafted = has_draft
     return report
 
 
+def _digests(document: dict[str, Any] | None) -> dict[str, str]:
+    """Each node's recorded code digest, by node id."""
+    nodes = (document or {}).get("nodes") or []
+    return {str(node.get("id")): str(node.get("code_digest") or "") for node in nodes}
+
+
 def _moved_code(stored: dict[str, Any] | None, document: dict[str, Any]) -> list[str]:
     """The nodes whose reachable code changed since the last sync.
 
@@ -764,18 +790,19 @@ def _moved_code(stored: dict[str, Any] | None, document: dict[str, Any]) -> list
     the shim reflects the declared ports rather than what the function calls
     into — so editing a helper printed as nothing at all, which reads as
     "there was nothing to do".
+
+    A node is named only when *both* sides carry a digest. An engine that does
+    not record one drops the field on the way in, so comparing against nothing
+    would report every node as changed on every sync, for ever — which is a
+    worse answer than the silence this replaced.
     """
     if stored is None:
         return []
-    before = {
-        node.get("id"): node.get("code_digest") or ""
-        for node in (stored.get("definition") or {}).get("nodes") or []
-    }
+    before = _digests(stored.get("definition"))
     return [
         node_id
-        for node in document.get("nodes") or []
-        if (node_id := node.get("id")) in before
-        and before[node_id] != (node.get("code_digest") or "")
+        for node_id, digest in _digests(document).items()
+        if digest and before.get(node_id) and before[node_id] != digest
     ]