@coderook/cli 0.42.5 → 0.42.7

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "coderook",
   "displayName": "CodeRook",
   "description": "Save, browse and restore whole-snapshot versions of a project on CodeRook, with cbx or plain git, from Claude Code.",
-  "version": "0.42.5",
+  "version": "0.42.7",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cbx/src/core/upload.js

@@ -1938,9 +1938,63 @@ class Uploader {
             return priorByDigest.get(declaration.sha256) ?? null;
         };
         const keptAsItWas = (declaration) => storedAs(declaration) !== null;
-        const declarations = hashed.declarations.filter((one) => !keptAsItWas(one));
+        /*
+          A copy left stale by somebody else's save is not an edit.
+    
+          Both callers select everything, so a file nobody touched here is still
+          "selected". When the version this save starts from holds a newer copy,
+          merged in from somebody else, the untouched old bytes on this disk
+          differ from it, and they were sent as though they were a change: the
+          second unrelated save after a colleague's edit put their file back to
+          what it was (state-matrix R1, reproduced 2026-11-06: v4 reverted v2).
+    
+          What the file IS decides it, not where it sits: bytes identical to what
+          this folder last received (request.known) are not this person's work.
+          The version's own copy is kept, and the folder's record still says it
+          received the old bytes, so the file shows as behind until fetched. A
+          file the version no longer holds at all was removed by somebody else,
+          and an untouched copy here does not bring it back.
+        */
+        const received = request.known ?? null;
+        const staleHere = new Set();
+        if (received && prior.size) {
+            for (const one of hashed.declarations) {
+                if (received[one.path] !== one.sha256)
+                    continue;
+                const now = prior.get(one.path);
+                if (now && now.sha256 === one.sha256)
+                    continue;
+                staleHere.add(one.path);
+            }
+        }
+        const declarations = hashed.declarations.filter((one) => !staleHere.has(one.path) && !keptAsItWas(one));
         let totalBytes = hashed.totalBytes;
         for (const one of hashed.declarations) {
+            if (!staleHere.has(one.path))
+                continue;
+            totalBytes -= one.size;
+            const now = prior.get(one.path);
+            if (!now) {
+                ticked.delete(one.path);
+                continue;
+            }
+            reused.push({
+                path: one.path,
+                sourceSize: now.sourceSize,
+                storedSize: now.storedSize,
+                mediaType: now.mediaType,
+                added: 0,
+                removed: 0,
+                included: true,
+                deleted: false,
+                binary: false,
+                lines: 0,
+            });
+        }
+        (0, profile_js_1.counted)("stale copies kept as the version has them", staleHere.size);
+        for (const one of hashed.declarations) {
+            if (staleHere.has(one.path))
+                continue;
             const held = storedAs(one);
             if (!held)
                 continue;

package/dist/cli/src/cli.js

@@ -1541,12 +1541,26 @@ async function commandGet(parsed) {
               would bury the only copy.
             */
             if (resuming) {
+                /*
+                  Only a file this fetch rewrites can be buried by finishing it: one
+                  whose incoming copy differs from what was placed here. An edit to a
+                  file the version left alone is kept, exactly as an ordinary fetch
+                  keeps it, so it is no reason to stop. It used to be: completing in
+                  "replace" mode rewrote every file, so any edit at all, anywhere,
+                  refused the resume (2026-11-06, two page edits blocked a catch-up).
+                */
                 const notYetArrived = await (0, worktree_js_1.changedFiles)(folder, rules, incoming);
                 const changedInTheGap = notYetArrived.filter((file) => !file.deleted &&
                     incoming.has(file.path) &&
+                    incoming.get(file.path) !== link.local[file.path] &&
                     edited.some((one) => one.path === file.path));
                 if (!changedInTheGap.length) {
-                    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null, "replace", await (0, track_commands_js_1.trackFor)(folder));
+                    /*
+                      Reconciling finishes the job: every file the version changed is
+                      placed (the half the interrupted run already placed are placed
+                      again, harmlessly), and what it left alone stays as it is.
+                    */
+                    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null, "reconcile", await (0, track_commands_js_1.trackFor)(folder));
                 }
                 console.error(red(`${changedInTheGap.length} file${changedInTheGap.length === 1 ? "" : "s"} ` +
                     `changed while the interrupted fetch was stopped:`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.42.5",
+  "version": "0.42.7",
   "description": "The command line for CodeRook (coderook.com): version control and project hosting for projects of any size. Every save is a compressed snapshot, private or public, never used to train AI.",
   "license": "Apache-2.0",
   "homepage": "https://coderook.com",