@plinth-music/cli 0.21.0 → 0.21.1

package/dist/cli.js

@@ -7584,7 +7584,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.21.0",
+  version: "0.21.1",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -26125,6 +26125,27 @@ function isLaterVersion(a, b) {
     return false;
   return ta > tb;
 }
+function committedEntryIfNewer(workspaceSlug, entityType, entry) {
+  let raw;
+  try {
+    raw = readFileSync7(stateFilePath(workspaceSlug), "utf8");
+  } catch {
+    return;
+  }
+  let committed;
+  try {
+    const parsed = JSON.parse(raw);
+    committed = parsed.entries?.[entityType]?.[entry.id];
+  } catch {
+    return;
+  }
+  if (committed === undefined)
+    return;
+  const valid = StateEntrySchema.safeParse(committed);
+  if (!valid.success)
+    return;
+  return isLaterVersion(valid.data, entry) ? valid.data : undefined;
+}
 function mergeKey(fresh, before, after) {
   if (before === after)
     return { value: fresh, overruled: false };
@@ -26200,8 +26221,7 @@ function mergeAnchor(fresh, before, after) {
     return fresh;
   return after;
 }
-function commitState(before, after) {
-  const fresh = loadState(after.workspace_slug);
+function mergeWorkspaceState(fresh, before, after, wantCorrected = true) {
   const entityTypes = new Set([
     ...Object.keys(fresh.entries),
     ...Object.keys(before.entries),
@@ -26242,10 +26262,11 @@ function commitState(before, after) {
     last_trim_at: mergeScalar(fresh.last_trim_at, before.last_trim_at, after.last_trim_at),
     memory_facts: mergeScalar(fresh.memory_facts, before.memory_facts, after.memory_facts)
   };
-  writeState(merged);
+  if (!wantCorrected)
+    return { merged, corrected: after };
   const singletonOverruled = rules.overruled || memory.overruled || userMemory.overruled || userVoice.overruled;
   if (overruledEntries.length === 0 && files.overruled.length === 0 && !singletonOverruled) {
-    return after;
+    return { merged, corrected: after };
   }
   let corrected = after;
   if (rules.overruled)
@@ -26264,8 +26285,20 @@ function commitState(before, after) {
     const committed = merged.files?.[path];
     corrected = committed ? upsertFileEntry(corrected, committed).state : removeFileEntry(corrected, path).state;
   }
+  return { merged, corrected };
+}
+function commitState(before, after) {
+  const { merged, corrected } = mergeWorkspaceState(loadState(after.workspace_slug), before, after);
+  writeState(merged);
   return corrected;
 }
+function rebaseState(current, base2, next) {
+  if (next === base2)
+    return current;
+  if (current === base2)
+    return next;
+  return mergeWorkspaceState(current, base2, next, false).merged;
+}
 function upsertEntry(state, entityType, entry) {
   const bucket = state.entries[entityType] ?? {};
   const existing = bucket[entry.id];
@@ -34324,7 +34357,7 @@ class PerIdMutex {
 
 // src/lib/push.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
 import { basename as basename5, relative as relative5 } from "node:path";
 
 // src/lib/frontmatter-id.ts
@@ -34512,6 +34545,10 @@ function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor,
 }
 
 // src/lib/push.ts
+var DELETE_DECLINED_PATH_EXISTS = "the file is on disk again — a newer write owns this row";
+function deleteDeclinedSentence(relPath) {
+  return `Not deleted: ${relPath} is on disk again, so the row was left alone. If you meant to delete it, remove the file and it will be retried.`;
+}
 function normaliseWireBody(body) {
   if (body === undefined)
     return;
@@ -34889,6 +34926,7 @@ async function reconcileContextDocConflict(args) {
     now,
     output
   } = args;
+  const base2 = args.state;
   let state = args.state;
   const existingSlug = existing.slug;
   const existingId = existing.id;
@@ -34938,7 +34976,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: fileSlug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: base2
     };
   }
   const stashPreLandCloudCopy = () => stashConflict({
@@ -35000,7 +35039,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: updated.slug,
         stashPath: preLandStash
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.code === 404) {
@@ -35058,7 +35098,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: fileSlug,
         stashPath
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.reason === "context_doc_conflict") {
@@ -35086,10 +35127,11 @@ async function runPushUpsert(args) {
     const hashBody = hashableBody(strategy, bodyMarkdown);
     const newBodyHash = stableHash(hashBody);
     const newFrontmatterHash = stableHash({ ...userFm, ...lifted.topLevel });
-    const liveEntry = getEntry(args.state, strategy.type, args.stateEntry.id) ?? args.stateEntry;
+    const snapshotEntry = getEntry(args.state, strategy.type, args.stateEntry.id) ?? args.stateEntry;
+    const liveEntry = committedEntryIfNewer(args.workspaceSlug, strategy.type, snapshotEntry) ?? snapshotEntry;
     const bodyChanged = newBodyHash !== liveEntry.body_hash;
     const frontmatterChanged = newFrontmatterHash !== liveEntry.frontmatter_hash;
-    let workingState = args.state;
+    let workingState = liveEntry === snapshotEntry ? args.state : upsertEntry(args.state, strategy.type, liveEntry).state;
     if (fm["id"] === undefined && workingState.frontmatter_id_backfill_version !== undefined) {
       const cleared = clearFrontmatterIdBackfillMarker(workingState);
       if (cleared.changed) {
@@ -35098,6 +35140,69 @@ async function runPushUpsert(args) {
         } catch {}
       }
     }
+    const wireProjection = (md) => {
+      try {
+        const p = import_gray_matter10.default(md);
+        const f = p.data ?? {};
+        const l = splitUserFrontmatter(strategy, f);
+        const u = userFrontmatter(strategy, l.frontmatter);
+        return stableHash({
+          body: strategy.bodyToWire(p.content),
+          frontmatter: { ...u, ...l.topLevel }
+        });
+      } catch {
+        return null;
+      }
+    };
+    if (liveEntry !== snapshotEntry) {
+      let onDisk = null;
+      try {
+        onDisk = readFileSync17(args.absolutePath, "utf8");
+      } catch {
+        onDisk = null;
+      }
+      if (onDisk !== null && onDisk !== args.raw) {
+        let disk = null;
+        try {
+          disk = computeMirrorHashes(strategy, onDisk);
+        } catch {
+          disk = null;
+        }
+        if (disk !== null && disk.bodyHash === liveEntry.body_hash && disk.frontmatterHash === liveEntry.frontmatter_hash) {
+          const ours = wireProjection(args.raw);
+          const theirs = wireProjection(onDisk);
+          if (ours !== null && theirs !== null && ours === theirs) {
+            return {
+              outcome: {
+                kind: "noop",
+                entityType: strategy.type,
+                entitySlug: liveEntry.slug
+              },
+              state: workingState,
+              base: workingState
+            };
+          }
+          const stashPath2 = stashConflict({
+            workspaceSlug: args.workspaceSlug,
+            entityType: strategy.type,
+            entitySlug: liveEntry.slug,
+            timestamp: args.now(),
+            contents: args.raw,
+            side: "local"
+          });
+          return {
+            outcome: {
+              kind: "conflict",
+              entityType: strategy.type,
+              entitySlug: liveEntry.slug,
+              stashPath: stashPath2
+            },
+            state: workingState,
+            base: workingState
+          };
+        }
+      }
+    }
     if (!bodyChanged && !frontmatterChanged) {
       return {
         outcome: {
@@ -35105,7 +35210,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: workingState
+        state: workingState,
+        base: workingState
       };
     }
     const wireBodyFields = bodyChanged ? strategy.bodyToWire(bodyMarkdown) : undefined;
@@ -35124,7 +35230,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: persistEntry(workingState, strategy.type, updated)
+        state: persistEntry(workingState, strategy.type, updated),
+        base: workingState
       };
     }
     const mergedTopLevel = split || wireBodyFields?.topLevel ? {
@@ -35160,7 +35267,8 @@ async function runPushUpsert(args) {
           fields,
           pushed: false
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     let patchResult = await patchEntity({
@@ -35233,7 +35341,8 @@ async function runPushUpsert(args) {
             fields,
             pushed: true
           },
-          state: nextState2
+          state: nextState2,
+          base: workingState
         };
       }
       return {
@@ -35242,7 +35351,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: updated.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (patchResult.code === 404) {
@@ -35252,7 +35362,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: workingState
+        state: workingState,
+        base: workingState
       };
     }
     if (patchResult.reason === "slug_conflict") {
@@ -35322,7 +35433,8 @@ async function runPushUpsert(args) {
         entitySlug: liveEntry.slug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -35341,6 +35453,7 @@ async function reconcileTaskConflict(args) {
     now,
     output
   } = args;
+  const base2 = args.state;
   let state = args.state;
   const stashLocalSide = () => stashConflict({
     workspaceSlug,
@@ -35373,7 +35486,8 @@ async function reconcileTaskConflict(args) {
         entitySlug: liveEntry.slug,
         stashPath: stashPath2
       },
-      state
+      state,
+      base: base2
     };
   }
   let cloudRow = null;
@@ -35391,7 +35505,8 @@ async function reconcileTaskConflict(args) {
         entityType: strategy.type,
         entitySlug: liveEntry.slug
       },
-      state
+      state,
+      base: base2
     };
   }
   const stashCloudSide = () => stashConflict({
@@ -35431,7 +35546,8 @@ async function reconcileTaskConflict(args) {
         entitySlug: patchResult.doc.slug,
         stashPath: stashPath2
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.code === 404) {
@@ -35442,7 +35558,8 @@ async function reconcileTaskConflict(args) {
         entityType: strategy.type,
         entitySlug: liveEntry.slug
       },
-      state
+      state,
+      base: base2
     };
   }
   const stashPath = stashLocalSide();
@@ -35465,7 +35582,8 @@ async function reconcileTaskConflict(args) {
       entitySlug: liveEntry.slug,
       stashPath
     },
-    state
+    state,
+    base: base2
   };
 }
 function writeCreatedIdBack(args) {
@@ -35576,7 +35694,8 @@ async function runPushCreate(args) {
             fields,
             pushed: true
           },
-          state: nextState2
+          state: nextState2,
+          base: args.state
         };
       }
       return {
@@ -35585,7 +35704,8 @@ async function runPushCreate(args) {
           entityType: strategy.type,
           entitySlug: doc2.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: args.state
       };
     }
     if (createResult.reason === "context_doc_conflict") {
@@ -35634,7 +35754,8 @@ async function runPushCreate(args) {
         entitySlug: args.slug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: args.state
     };
   });
 }
@@ -35668,12 +35789,31 @@ async function runPushDelete(args) {
         absolutePath: args.absolutePath,
         reason: "untracked file — no cloud row to delete"
       },
-      state: args.state
+      state: args.state,
+      base: args.state
     };
   }
   return args.mutex.run(id, async () => {
-    const live = getEntry(args.state, strategy.type, id) ?? null;
+    const snapshot = getEntry(args.state, strategy.type, id) ?? null;
+    const live = snapshot ? committedEntryIfNewer(args.workspaceSlug, strategy.type, snapshot) ?? snapshot : null;
+    if (existsSync4(args.absolutePath)) {
+      args.output?.log(entityDeleteSuppressedLine({
+        entityType: strategy.type,
+        slug,
+        reason: "path_exists"
+      }));
+      return {
+        outcome: {
+          kind: "ignored",
+          absolutePath: args.absolutePath,
+          reason: DELETE_DECLINED_PATH_EXISTS
+        },
+        state: args.state,
+        base: args.state
+      };
+    }
     const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const workingState = live && live !== snapshot ? upsertEntry(args.state, strategy.type, live).state : args.state;
     const result = await deleteEntity({
       strategy,
       baseUrl: args.baseUrl,
@@ -35683,7 +35823,7 @@ async function runPushDelete(args) {
       fetchImpl: args.fetchImpl
     });
     if (result.ok) {
-      const nextState2 = dropEntry(args.state, strategy.type, id);
+      const nextState2 = dropEntry(workingState, strategy.type, id);
       args.output?.log(`[DELETE entityType=${strategy.type} slug=${slug} id=${id}]`);
       return {
         outcome: {
@@ -35691,11 +35831,12 @@ async function runPushDelete(args) {
           entityType: strategy.type,
           entitySlug: slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (result.code === 404) {
-      const nextState2 = dropEntry(args.state, strategy.type, id);
+      const nextState2 = dropEntry(workingState, strategy.type, id);
       args.output?.log(`[DELETE entityType=${strategy.type} slug=${slug} id=${id} note=already_absent]`);
       return {
         outcome: {
@@ -35703,7 +35844,8 @@ async function runPushDelete(args) {
           entityType: strategy.type,
           entitySlug: slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     const nextState = await pullAndWriteMirror({
@@ -35725,7 +35867,8 @@ async function runPushDelete(args) {
         entitySlug: slug,
         stashPath: ""
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -35757,8 +35900,10 @@ async function pushRename(args) {
     toSlug = basename5(toPath, ".md");
   }
   return mutex.run(id, async () => {
-    const live = getEntry(state, entityType, id);
+    const snapshot = getEntry(state, entityType, id);
+    const live = snapshot ? committedEntryIfNewer(workspaceSlug, entityType, snapshot) ?? snapshot : undefined;
     const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const workingState = live && live !== snapshot ? upsertEntry(state, entityType, live).state : state;
     let patchResult = await patchEntity({
       strategy,
       baseUrl,
@@ -35818,7 +35963,7 @@ async function pushRename(args) {
           updated.body_len = renameHashBody.length;
         } catch {}
       }
-      const nextState2 = persistEntry(state, entityType, updated);
+      const nextState2 = persistEntry(workingState, entityType, updated);
       output?.log(`[RENAME entityType=${entityType} fromSlug=${fromSlug} toSlug=${doc2.slug} id=${doc2.id}]`);
       return {
         outcome: {
@@ -35827,13 +35972,15 @@ async function pushRename(args) {
           fromSlug,
           toSlug: doc2.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (patchResult.code === 404) {
       return {
         outcome: { kind: "not_found", entityType, entitySlug: fromSlug },
-        state
+        state: workingState,
+        base: workingState
       };
     }
     if (patchResult.reason === "slug_conflict") {
@@ -35855,7 +36002,7 @@ async function pushRename(args) {
         baseUrl,
         pat,
         id: patchResult.existing.id,
-        state,
+        state: workingState,
         fetchImpl,
         echo,
         output,
@@ -35881,7 +36028,8 @@ async function pushRename(args) {
           toSlug,
           stashPath: stashPath2
         },
-        state: finalState
+        state: finalState,
+        base: workingState
       };
     }
     let contents = "";
@@ -35902,7 +36050,7 @@ async function pushRename(args) {
       baseUrl,
       pat,
       id,
-      state,
+      state: workingState,
       fetchImpl,
       echo,
       output,
@@ -35915,7 +36063,8 @@ async function pushRename(args) {
         entitySlug: fromSlug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -35951,13 +36100,14 @@ async function applyBatch(batch, deps, mutex) {
         await applyFileOp(op, deps);
         continue;
       }
+      const base2 = deps.getState();
       const result = await pushFile({
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         absolutePath: opPath(deps.workspaceSlug, op),
         entityType: op.entityType,
-        state: deps.getState(),
+        state: base2,
         exists: op.kind === "overwrite",
         unlinkContext: op.kind === "delete" ? { id: op.id, slug: op.slug, updated_at: op.updated_at } : null,
         deps: {
@@ -35968,7 +36118,10 @@ async function applyBatch(batch, deps, mutex) {
           echo: deps.echo
         }
       });
-      deps.setState(result.state);
+      deps.applyState(result.base ?? base2, result.state);
+      if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+        deps.output?.warn(deleteDeclinedSentence(opPath(deps.workspaceSlug, op)));
+      }
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       deps.output?.warn(`Apply failed for ${opLabel(op)}: ${msg} (left for the next pull to reconcile).`);
@@ -35978,27 +36131,29 @@ async function applyBatch(batch, deps, mutex) {
 async function applyFileOp(op, deps) {
   const fileDeps = { fetchImpl: deps.fetchImpl, now: deps.now, output: deps.output };
   if (op.kind === "delete") {
+    const base3 = deps.getState();
     const result2 = await pushFilesDelete({
       workspaceSlug: deps.workspaceSlug,
       baseUrl: deps.baseUrl,
       pat: deps.pat,
       relPath: op.path,
-      state: deps.getState(),
+      state: base3,
       deps: fileDeps
     });
-    deps.setState(result2.state);
+    deps.applyState(base3, result2.state);
     return;
   }
+  const base2 = deps.getState();
   const result = await pushFilesUpsert({
     workspaceSlug: deps.workspaceSlug,
     baseUrl: deps.baseUrl,
     pat: deps.pat,
     absolutePath: filesSubtreePath(deps.workspaceSlug, op.path),
     relPath: op.path,
-    state: deps.getState(),
+    state: base2,
     deps: fileDeps
   });
-  deps.setState(result.state);
+  deps.applyState(base2, result.state);
 }
 async function discardBatchOps(batch, deps) {
   for (const op of batch.ops) {
@@ -36027,19 +36182,20 @@ async function discardBatchOps(batch, deps) {
           });
         }
       }
+      const base2 = deps.getState();
       const next = await pullAndWriteMirror({
         strategy,
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         id: op.id,
-        state: deps.getState(),
+        state: base2,
         fetchImpl: deps.fetchImpl,
         echo: deps.echo,
         output: deps.output,
         now: deps.now
       });
-      deps.setState(next);
+      deps.applyState(base2, next);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       deps.output?.warn(`Discard restore failed for ${opLabel(op)}: ${msg} (the next pull will reconcile).`);
@@ -36063,17 +36219,18 @@ async function discardFileOp(op, deps) {
       side: "local"
     });
   }
+  const base2 = deps.getState();
   const next = await restoreFileFromCloud({
     workspaceSlug: deps.workspaceSlug,
     baseUrl: deps.baseUrl,
     pat: deps.pat,
     id: op.id,
     relPath: op.path,
-    state: deps.getState(),
+    state: base2,
     fetchImpl: deps.fetchImpl,
     output: deps.output
   });
-  deps.setState(next);
+  deps.applyState(base2, next);
 }
 function opPath(workspaceSlug, op) {
   try {
@@ -36634,7 +36791,7 @@ function recordFileUnsynced(args) {
   });
 }
 async function drainUnsyncedOps(args) {
-  const { workspaceSlug, baseUrl, pat, getState, setState, fetchImpl, mutex, output, echo } = args;
+  const { workspaceSlug, baseUrl, pat, getState, applyState, fetchImpl, mutex, output, echo } = args;
   const now = args.now ?? (() => new Date);
   const ops = listUnsynced(getState());
   let attempted = 0;
@@ -36645,7 +36802,7 @@ async function drainUnsyncedOps(args) {
     const before = getState();
     const { state: next, changed } = removeUnsynced(before, target, path5);
     if (changed)
-      setState(commitState(before, next));
+      applyState(before, commitState(before, next));
   };
   for (const op of ops) {
     attempted += 1;
@@ -36658,38 +36815,46 @@ async function drainUnsyncedOps(args) {
           resolved += 1;
           continue;
         }
+        const base2 = getState();
         const result = await pushFile({
           workspaceSlug,
           baseUrl,
           pat,
           absolutePath,
           entityType: classified.entityType,
-          state: getState(),
+          state: base2,
           exists: op.op === "upsert",
           unlinkContext: null,
           deps: { fetchImpl, now, mutex, output, echo }
         });
-        setState(result.state);
+        applyState(result.base ?? base2, result.state);
+        if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+          output?.warn(deleteDeclinedSentence(op.path));
+        }
       } else {
         const absolutePath = filesSubtreePath(workspaceSlug, op.path);
-        const doFile = () => op.op === "delete" ? pushFilesDelete({
-          workspaceSlug,
-          baseUrl,
-          pat,
-          relPath: op.path,
-          state: getState(),
-          deps: { fetchImpl, now, output }
-        }) : pushFilesUpsert({
-          workspaceSlug,
-          baseUrl,
-          pat,
-          absolutePath,
-          relPath: op.path,
-          state: getState(),
-          deps: { fetchImpl, now, output }
-        });
+        let base2;
+        const doFile = () => {
+          base2 = getState();
+          return op.op === "delete" ? pushFilesDelete({
+            workspaceSlug,
+            baseUrl,
+            pat,
+            relPath: op.path,
+            state: base2,
+            deps: { fetchImpl, now, output }
+          }) : pushFilesUpsert({
+            workspaceSlug,
+            baseUrl,
+            pat,
+            absolutePath,
+            relPath: op.path,
+            state: base2,
+            deps: { fetchImpl, now, output }
+          });
+        };
         const result = mutex ? await mutex.run(`files:${op.path}`, doFile) : await doFile();
-        setState(result.state);
+        applyState(base2, result.state);
       }
       clear(op.target, op.path);
       resolved += 1;
@@ -36709,7 +36874,7 @@ async function drainUnsyncedOps(args) {
           message: cat.serverMessage,
           rejected_at: now().toISOString()
         });
-        setState(commitState(beforeReject, next2));
+        applyState(beforeReject, commitState(beforeReject, next2));
         continue;
       }
       stillFailing += 1;
@@ -36722,7 +36887,7 @@ async function drainUnsyncedOps(args) {
         last_reason: cat.reason
       });
       if (changed)
-        setState(commitState(beforeRetry, next));
+        applyState(beforeRetry, commitState(beforeRetry, next));
     }
   }
   return { attempted, resolved, stillFailing, rejected };
@@ -39001,7 +39166,9 @@ async function pushArtistMemory(args) {
   }
   const localHash = stableHash(local);
   const runPatch = async () => {
-    let base2 = args.mutex ? loadState(workspaceSlug) : state;
+    const snapshotEntry = getEntryBySlug(state, ENTITY_TYPE, slug);
+    const fresher = args.mutex && snapshotEntry ? committedEntryIfNewer(workspaceSlug, ENTITY_TYPE, snapshotEntry) : undefined;
+    let base2 = fresher ? upsertEntry(state, ENTITY_TYPE, fresher).state : state;
     const entry2 = getEntryBySlug(base2, ENTITY_TYPE, slug);
     if (!entry2)
       return { state: base2, outcome: { kind: "ignored", slug } };
@@ -43877,7 +44044,7 @@ function makeWatchHandler(deps) {
     spinner,
     mutex,
     getState,
-    setState,
+    applyState,
     fetchImpl,
     now,
     output,
@@ -43887,6 +44054,10 @@ function makeWatchHandler(deps) {
     fileGate,
     isFileFrozen
   } = deps;
+  const applyFromCurrent = (update) => {
+    const base2 = getState();
+    applyState(base2, update(base2));
+  };
   const handleFilesEvent = async (relPath, absolutePath, exists) => {
     try {
       if (isFileFrozen?.(relPath))
@@ -43896,8 +44067,8 @@ function makeWatchHandler(deps) {
       } catch (err) {
         if (!(err instanceof MirrorSymlinkError))
           throw err;
-        setState(recordFileSymlinkRefused({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileSymlinkRefused({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           now: now ?? (() => new Date)
@@ -43923,15 +44094,16 @@ function makeWatchHandler(deps) {
           }
         }
         await mutex.run(`files:${relPath}`, async () => {
+          const base2 = getState();
           const result = await pushFilesDelete({
             workspaceSlug,
             baseUrl,
             pat,
             relPath,
-            state: getState(),
+            state: base2,
             deps: { fetchImpl, now, output, suppressor }
           });
-          setState(clearReportedSafeFileRejected(result.state, relPath));
+          applyState(base2, clearReportedSafeFileRejected(result.state, relPath));
           reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
         });
         return;
@@ -43956,8 +44128,8 @@ function makeWatchHandler(deps) {
           max: MAX_WORKSPACE_FILE_BYTES,
           source: "client"
         }));
-        setState(recordFileOverCap({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileOverCap({
+          state: base2,
           relPath,
           size: st.size,
           max: MAX_WORKSPACE_FILE_BYTES,
@@ -43985,17 +44157,18 @@ function makeWatchHandler(deps) {
         }
       }
       await mutex.run(`files:${relPath}`, async () => {
+        const base2 = getState();
         const result = await pushFilesUpsert({
           workspaceSlug,
           baseUrl,
           pat,
           absolutePath,
           relPath,
-          state: getState(),
+          state: base2,
           prepared: { bytes, hash: hash2, size: st.size, inode: st.ino },
           deps: { fetchImpl, now, output, suppressor }
         });
-        setState(result.outcome.kind === "over_cap" ? result.state : clearFileRejected(result.state, relPath));
+        applyState(base2, result.outcome.kind === "over_cap" ? result.state : clearFileRejected(result.state, relPath));
         reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
       });
     } catch (err) {
@@ -44003,16 +44176,16 @@ function makeWatchHandler(deps) {
       output?.log(fileFailedLine({ path: relPath, ...categorizeError(err) }));
       spinner.warn(`File push failed for files/${relPath}: ${msg}`);
       if (isRecordableFailure(err)) {
-        setState(recordFileUnsynced({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileUnsynced({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           err,
           now: now ?? (() => new Date)
         }));
       } else if (isPermanentReject(err)) {
-        setState(recordFileRejected({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileRejected({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           err,
@@ -44040,17 +44213,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(WORKSPACE_RULES_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushWorkspaceRules({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportWorkspaceRulesOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -44078,17 +44252,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushWorkspaceMemory({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportWorkspaceMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -44116,17 +44291,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(USER_MEMORY_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushUserMemory({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportUserMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -44154,17 +44330,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(VOICE_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushVoice({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportVoiceOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -44191,19 +44368,20 @@ function makeWatchHandler(deps) {
       }
     }
     try {
+      const base2 = getState();
       const result = await pushArtistMemory({
         workspaceSlug,
         baseUrl,
         pat,
         slug,
-        state: getState(),
+        state: base2,
         fetchImpl,
         now,
         output,
         suppressor,
         mutex
       });
-      setState(result.state);
+      applyState(base2, result.state);
       reportArtistMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
@@ -44236,6 +44414,7 @@ function makeWatchHandler(deps) {
           await handle({ kind: "upsert", absolutePath: event.toPath });
           return;
         }
+        const base3 = getState();
         const result2 = await pushRename({
           workspaceSlug,
           baseUrl,
@@ -44246,7 +44425,7 @@ function makeWatchHandler(deps) {
           id: event.id,
           expectedUpdatedAt: event.expectedUpdatedAt,
           fromSlug: event.fromSlug,
-          state: getState(),
+          state: base3,
           deps: {
             fetchImpl,
             now,
@@ -44255,7 +44434,7 @@ function makeWatchHandler(deps) {
             echo: suppressor ? { watcher: "live", suppressor } : undefined
           }
         });
-        setState(result2.state);
+        applyState(base3, result2.state);
         reportOutcome(spinner, workspaceSlug, result2.state, result2.outcome);
         return;
       }
@@ -44314,8 +44493,8 @@ function makeWatchHandler(deps) {
       if (!classified) {
         const key = entitySymlinkRefusalKey({ workspaceSlug, absolutePath });
         if (key) {
-          setState(recordEntitySymlinkRefused({
-            state: getState(),
+          applyFromCurrent((base3) => recordEntitySymlinkRefused({
+            state: base3,
             mirrorRelativePath: key,
             op: event.kind === "unlink" ? "delete" : "upsert",
             now: now ?? (() => new Date)
@@ -44372,13 +44551,14 @@ function makeWatchHandler(deps) {
           return;
         }
       }
+      const base2 = getState();
       const result = await pushFile({
         workspaceSlug,
         baseUrl,
         pat,
         absolutePath,
         entityType: classified.entityType,
-        state: getState(),
+        state: base2,
         exists: event.kind === "upsert",
         unlinkContext: event.kind === "unlink" && event.stateEntry ? {
           id: event.stateEntry.id,
@@ -44394,7 +44574,7 @@ function makeWatchHandler(deps) {
           echo: suppressor ? { watcher: "live", suppressor } : undefined
         }
       });
-      setState(clearEntityRejected(result.state, workspaceSlug, absolutePath));
+      applyState(result.base ?? base2, clearEntityRejected(result.state, workspaceSlug, absolutePath));
       reportOutcome(spinner, workspaceSlug, getState(), result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
@@ -44410,8 +44590,8 @@ function makeWatchHandler(deps) {
         }));
       }
       if (classified && event.kind !== "renamed" && isRecordableFailure(err)) {
-        setState(recordEntityUnsynced({
-          state: getState(),
+        applyFromCurrent((base2) => recordEntityUnsynced({
+          state: base2,
           workspaceSlug,
           absolutePath: path5,
           op: event.kind === "unlink" ? "delete" : "upsert",
@@ -44419,8 +44599,8 @@ function makeWatchHandler(deps) {
           now: now ?? (() => new Date)
         }));
       } else if (classified && event.kind !== "renamed" && isPermanentReject(err)) {
-        setState(recordEntityRejected({
-          state: getState(),
+        applyFromCurrent((base2) => recordEntityRejected({
+          state: base2,
           workspaceSlug,
           absolutePath: path5,
           op: event.kind === "unlink" ? "delete" : "upsert",
@@ -44439,6 +44619,7 @@ function discardSink() {
 }
 async function flushHeldEntityOp(deps) {
   const now = deps.now ?? (() => new Date);
+  const base2 = deps.getState();
   try {
     const result = await pushFile({
       workspaceSlug: deps.workspaceSlug,
@@ -44446,7 +44627,7 @@ async function flushHeldEntityOp(deps) {
       pat: deps.pat,
       absolutePath: deps.op.absolutePath,
       entityType: deps.op.entityType,
-      state: deps.getState(),
+      state: base2,
       exists: deps.op.kind === "overwrite",
       unlinkContext: deps.op.kind === "delete" ? { id: deps.op.id, slug: deps.op.slug, updated_at: deps.op.updatedAt } : null,
       deps: {
@@ -44457,7 +44638,10 @@ async function flushHeldEntityOp(deps) {
         echo: deps.echo
       }
     });
-    deps.setState(result.state);
+    deps.applyState(result.base ?? base2, result.state);
+    if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+      deps.spinner.warn(deleteDeclinedSentence(deps.op.absolutePath));
+    }
     reportOutcome(deps.spinner, deps.workspaceSlug, deps.getState(), result.outcome);
   } catch (err) {
     const msg = err instanceof Error ? err.message : "unknown push error";
@@ -44469,8 +44653,8 @@ async function flushHeldEntityOp(deps) {
     }));
     deps.spinner.warn(`Push failed for ${deps.op.entityType}/${deps.op.slug}: ${msg}`);
     if (isRecordableFailure(err)) {
-      deps.setState(recordEntityUnsynced({
-        state: deps.getState(),
+      deps.applyState(base2, recordEntityUnsynced({
+        state: base2,
         workspaceSlug: deps.workspaceSlug,
         absolutePath: deps.op.absolutePath,
         op: deps.op.kind === "delete" ? "delete" : "upsert",
@@ -44488,14 +44672,16 @@ async function flushHeldFileOpImpl(deps) {
     output: deps.output,
     suppressor: deps.suppressor
   };
+  let base2;
   const run = async () => {
+    base2 = deps.getState();
     try {
       const result = deps.op.kind === "delete" ? await pushFilesDelete({
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         relPath: deps.op.relPath,
-        state: deps.getState(),
+        state: base2,
         deps: fileDeps
       }) : await pushFilesUpsert({
         workspaceSlug: deps.workspaceSlug,
@@ -44503,18 +44689,18 @@ async function flushHeldFileOpImpl(deps) {
         pat: deps.pat,
         absolutePath: deps.op.absolutePath,
         relPath: deps.op.relPath,
-        state: deps.getState(),
+        state: base2,
         deps: fileDeps
       });
-      deps.setState(result.state);
+      deps.applyState(base2, result.state);
       reportFileOutcome(deps.spinner, deps.workspaceSlug, deps.getState(), result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
       deps.output?.log(fileFailedLine({ path: deps.op.relPath, ...categorizeError(err) }));
       deps.spinner.warn(`File push failed for files/${deps.op.relPath}: ${msg}`);
       if (isRecordableFailure(err)) {
-        deps.setState(recordFileUnsynced({
-          state: deps.getState(),
+        deps.applyState(base2, recordFileUnsynced({
+          state: base2,
           relPath: deps.op.relPath,
           op: deps.op.kind === "delete" ? "delete" : "upsert",
           err,
@@ -44809,8 +44995,8 @@ async function runStart(workspaceSlug, deps = {}) {
     baseUrl: entry2.api_base_url,
     pat,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -44827,8 +45013,8 @@ async function runStart(workspaceSlug, deps = {}) {
     baseUrl: entry2.api_base_url,
     pat,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -44866,8 +45052,8 @@ async function runStart(workspaceSlug, deps = {}) {
     pat,
     op,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     mutex,
     fetchImpl,
@@ -44930,8 +45116,8 @@ async function runStart(workspaceSlug, deps = {}) {
     pat,
     op,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     mutex,
     fetchImpl,
@@ -44987,8 +45173,8 @@ async function runStart(workspaceSlug, deps = {}) {
     spinner,
     mutex,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -45053,8 +45239,8 @@ async function runStart(workspaceSlug, deps = {}) {
             baseUrl: entry2.api_base_url,
             pat,
             getState: () => state,
-            setState: (s) => {
-              state = s;
+            applyState: (base2, next) => {
+              state = rebaseState(state, base2, next);
             },
             fetchImpl,
             now: deps.now,
@@ -45071,8 +45257,8 @@ async function runStart(workspaceSlug, deps = {}) {
             baseUrl: entry2.api_base_url,
             pat,
             getState: () => state,
-            setState: (s) => {
-              state = s;
+            applyState: (base2, next) => {
+              state = rebaseState(state, base2, next);
             },
             fetchImpl,
             now: deps.now,
@@ -45087,58 +45273,70 @@ async function runStart(workspaceSlug, deps = {}) {
             spinner.warn(`${redriven.rejected} write${redriven.rejected === 1 ? "" : "s"} permanently rejected — see \`plinth status\``);
             spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
           }
-          const rulesRecon = await mutex.run(WORKSPACE_RULES_MUTEX_KEY, () => reconcileWorkspaceRules({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (rulesRecon.state !== state)
-            state = rulesRecon.state;
+          let rulesBase = state;
+          const rulesRecon = await mutex.run(WORKSPACE_RULES_MUTEX_KEY, () => {
+            rulesBase = state;
+            return reconcileWorkspaceRules({
+              workspaceSlug: slug,
+              baseUrl: entry2.api_base_url,
+              pat,
+              state: rulesBase,
+              fetchImpl,
+              now: deps.now,
+              output: out,
+              suppressor
+            });
+          });
+          state = rebaseState(state, rulesBase, rulesRecon.state);
           reportSingletonReconcile(spinner, slug, state, WORKSPACE_RULES_FILENAME, rulesRecon.outcome);
-          const memoryRecon = await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, () => reconcileWorkspaceMemory({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (memoryRecon.state !== state)
-            state = memoryRecon.state;
+          let memoryBase = state;
+          const memoryRecon = await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, () => {
+            memoryBase = state;
+            return reconcileWorkspaceMemory({
+              workspaceSlug: slug,
+              baseUrl: entry2.api_base_url,
+              pat,
+              state: memoryBase,
+              fetchImpl,
+              now: deps.now,
+              output: out,
+              suppressor
+            });
+          });
+          state = rebaseState(state, memoryBase, memoryRecon.state);
           reportSingletonReconcile(spinner, slug, state, WORKSPACE_MEMORY_FILENAME, memoryRecon.outcome);
-          const userMemoryRecon = await mutex.run(USER_MEMORY_MUTEX_KEY, () => reconcileUserMemory({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (userMemoryRecon.state !== state)
-            state = userMemoryRecon.state;
-          reportSingletonReconcile(spinner, slug, state, USER_MEMORY_FILENAME, userMemoryRecon.outcome);
-          try {
-            const voiceRecon = await mutex.run(VOICE_MUTEX_KEY, () => reconcileVoice({
+          let userMemoryBase = state;
+          const userMemoryRecon = await mutex.run(USER_MEMORY_MUTEX_KEY, () => {
+            userMemoryBase = state;
+            return reconcileUserMemory({
               workspaceSlug: slug,
               baseUrl: entry2.api_base_url,
               pat,
-              state,
+              state: userMemoryBase,
               fetchImpl,
               now: deps.now,
               output: out,
               suppressor
-            }));
-            if (voiceRecon.state !== state)
-              state = voiceRecon.state;
+            });
+          });
+          state = rebaseState(state, userMemoryBase, userMemoryRecon.state);
+          reportSingletonReconcile(spinner, slug, state, USER_MEMORY_FILENAME, userMemoryRecon.outcome);
+          try {
+            let voiceBase = state;
+            const voiceRecon = await mutex.run(VOICE_MUTEX_KEY, () => {
+              voiceBase = state;
+              return reconcileVoice({
+                workspaceSlug: slug,
+                baseUrl: entry2.api_base_url,
+                pat,
+                state: voiceBase,
+                fetchImpl,
+                now: deps.now,
+                output: out,
+                suppressor
+              });
+            });
+            state = rebaseState(state, voiceBase, voiceRecon.state);
             reportSingletonReconcile(spinner, slug, state, VOICE_FILENAME, voiceRecon.outcome);
             const reconWarning = voiceMalformedWarning(state, slug);
             if (reconWarning)
@@ -45146,19 +45344,19 @@ async function runStart(workspaceSlug, deps = {}) {
           } catch (err) {
             out.log(`[VOICE_RECONCILE_FAILED ${categorizeError(err).reason}]`);
           }
+          const memBase = state;
           const memRecon = await reconcileArtistMemory({
             workspaceSlug: slug,
             baseUrl: entry2.api_base_url,
             pat,
-            state,
+            state: memBase,
             fetchImpl,
             now: deps.now,
             output: out,
             suppressor,
             mutex
           });
-          if (memRecon.state !== state)
-            state = memRecon.state;
+          state = rebaseState(state, memBase, memRecon.state);
           if (memRecon.pushed > 0) {
             spinner.success(`↑ synced ${memRecon.pushed} memory file${memRecon.pushed === 1 ? "" : "s"}`);
             spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);