@plinth-music/cli 0.8.0 → 0.9.1

package/CHANGELOG.md

@@ -2,6 +2,129 @@
 
 Notable changes to `@plinth-music/cli`. Grouped by what a user notices, not by PR.
 
+## 0.9.1 — 2026-08-25
+
+Seven PRs since `0.9.0` (`v0.9.0..1efa7d7`, #98–#104). Every one of them is the
+same bug seen from a different side: the daemon treated a failed compare-and-swap
+as proof that the cloud content had changed, and then let the cloud win. It had
+not changed. Fixes only, all client-side; there is no server prerequisite and a
+0.9.0 client talks to the same API. Upgrading is strongly recommended — the
+defects below lose user work silently, and `plinth status` said "All local writes
+synced" the whole time.
+
+### ⚠️ A cloud write that touched only a timestamp no longer costs you your edit
+
+This is the one to read. The CAS token is `updated_at`, so **any** write that moves
+that column fails the precondition — including a server-side backfill that changes
+no bytes at all. On 24 Aug a backfill moved `updated_at` on 161 of 307 live rows to
+the same microsecond; every later local edit to one of those rows was stashed out
+of sight into `~/.plinth/_conflicts/` and overwritten with a cloud copy that was
+byte-identical to what the daemon had already acknowledged.
+
+A 409 is now a question rather than a verdict: the daemon asks the row what its
+content hash is, compares it with the hash it last acked, and re-pushes when they
+match. Nothing is stashed and nothing is overwritten, because there was no conflict
+to reconcile. A genuine cloud edit still conflicts, still stashes, and still wins —
+that half is unchanged and is pinned by its own tests.
+
+Fixed on every path, not just the one that bit: `files/` rows, entity rows, tasks,
+and the three singleton lanes (`user-memory.md`, `workspace-rules.md`,
+`workspace-memory.md`), which shared an engine that had been missed.
+
+### ⚠️ A local status, priority or due-date edit is no longer silently discarded
+
+Found while fixing the above. On an entity conflict the retry dropped the
+structured fields the first attempt had carried, as "cloud's win" — so a metadata
+bump on a row you had just re-prioritised threw the re-prioritisation away with no
+stash and no record. A bump is not a conflict, so it no longer gets a conflict's
+resolution.
+
+### ⚠️ `plinth login` no longer wipes your sync cursors, and `--reset-sync` is new
+
+Logging in again to the same workspace is a token rotation, not a re-registration,
+and it now keeps your cursors — the next sync resumes instead of re-pulling the
+world. Cursors are still cleared when the token belongs to a different workspace or
+user, and login now says which happened rather than leaving you to guess.
+
+That removed the only way to force a full re-pull, so `--reset-sync` restores it as
+something you ask for. Use it after rebuilding a mirror from scratch; without it, a
+mirror rebuilt from an empty ledger would never refill, silently, behind a green
+sync.
+
+### Two files saved at the same time no longer lose one file's bookkeeping
+
+Every write of `state.json` used to land on a snapshot taken before the network
+call that preceded it, so two saves a moment apart — or a scheduled pull arriving
+while a push was in flight — could leave the file missing one of the two
+acknowledgements. The losing write's record simply vanished, and the next edit to
+that file hit the defect above through a door the fix could not close.
+
+State is now merged at write time rather than overwritten, an acknowledgement can
+never be committed over a newer one, and a cursor is never advanced ahead of the
+rows it describes — so an interrupted pull leaves cursors, state and disk agreeing
+rather than stranding rows that would never be delivered again. HTTP concurrency is
+untouched; the cost is about 2 ms per state write.
+
+### `plinth status` shows conflict stashes
+
+The Conflicts block lists how many local copies are set aside in
+`~/.plinth/_conflicts/<workspace>/`, names the newest, and says what to do with
+them. They had been accumulating unseen since May.
+
+### Proven against production
+
+The changes above were reproduced end to end against a live workspace before this
+release rather than only in tests: a metadata-only bump followed by a local edit
+survives on both the file and entity paths, two overlapping pushes both keep their
+acknowledgement, and — the part that makes the rest mean anything — a genuine cloud
+content change still conflicts and still stashes under otherwise identical
+conditions. The pull-ordering half and the three singleton lanes remain
+test-proven only; both are named in the repo's `CLAUDE.md`.
+
+## 0.9.0 — 2026-08-24
+
+Two PRs since `0.8.0` (`v0.8.0..4842d40`). An agent is now told to read a draft
+back from the tool that staged it before calling it ready. No server prerequisite:
+the change is client-side, and a 0.8.0 client is unaffected.
+
+### An agent reads its own draft back before saying it is ready
+
+Primitive (e)'s outbound group gains a paragraph. The voice guidance added on
+20 Aug already told the agent that nothing inspects a draft between it and the
+reader, then aimed that observation only at the WORDS. This is the other half:
+inspect the artefact. Fetch the staged draft, look at its body, its recipients
+and the thread it landed on, and only then say it is ready. A tool's own
+description of how it handles your text is a claim like any other, and the first
+use in a session is checked against what actually came out.
+
+**The gap was the trigger, not the rule.** The workspace `CLAUDE.md` already
+carried "where a document and the running system disagree, the system wins", and
+it did not fire — a line describing tool usage does not read like a claim needing
+verification. So this ships as a concrete read-back step rather than as another
+principle the agent grades itself against.
+
+Found by ordinary management work rather than by a sweep. An agent staged a mail
+reply whose body was visible `<p>` and `<b>` markup and reported it staged; the
+user found it in his own mailbox. The cause was not the tool but prose describing
+it — a rule said a local helper "handles `text/html`", true of what that script
+emits and false of what it takes. Two more defects of the same shape surfaced
+while repairing it: an update path that silently strips `In-Reply-To` and
+`References`, and a re-run that duplicates a draft rather than replacing it.
+
+The prose deliberately names no email tool, and a test pins that: Plinth ships
+none and cannot know what the user has. Grounding budget 9,050 → 9,944 bytes,
+all of it in (e); primitive (j) held at 1,266 for the seventh time.
+
+Honest limit, recorded rather than argued away: this is prose, and prose gets
+skipped. The durable fix is a Plinth-owned outbound draft path that owns escaping
+and threading in code for every user, at which point this paragraph becomes a
+backstop rather than the surface.
+
+### Housekeeping
+
+The test baseline in `CLAUDE.md` now reads 2052 pass / 0 fail / 107 files at
+`b4d8ed3`, re-measured on a clean checkout rather than carried forward.
+
 ## 0.8.0 — 2026-08-23
 
 Two PRs and two direct commits since `0.7.0` (`v0.7.0..af83c59`). The daemon

package/README.md

@@ -22,10 +22,10 @@ plinth start                      # run the daemon: continuous pull + watch + pu
 
 ## Commands
 
-- `plinth login --workspace <slug>` — issue a personal access token in the browser, paste it back, store it in the OS keychain (macOS Keychain / Linux Secret Service / Windows Credential Manager).
+- `plinth login --workspace <slug> [--reset-sync]` — issue a personal access token in the browser, paste it back, store it in the OS keychain (macOS Keychain / Linux Secret Service / Windows Credential Manager). Logging in again to the same workspace is a token rotation and **keeps your sync cursors**, so the next sync picks up where the last one left off; it clears them only when the token belongs to a different workspace or user. `--reset-sync` discards them deliberately, making the next sync a full re-pull — use it after rebuilding a mirror from scratch, which is otherwise unreachable now that rotation preserves them.
 - `plinth sync [--workspace <slug>]` — one-shot pull into `~/Plinth/<workspace>/`. Also generates the workspace-root `CLAUDE.md` (a thin TOC + entity model + skill pointers), an empty `CLAUDE.local.md` stub on first sync, and the two session-boundary commands (below), and silently refreshes `CLAUDE.md` on a schema-version change. Defaults to the active workspace if `--workspace` is omitted.
 - `plinth start` — run the long-running sync daemon: pull the latest, then watch the mirror for local edits and push them. It also projects each mapped artist's Google calendar into `views/calendar/` in the mirror — a file per artist plus an `upcoming.md` — on its own 15-minute timer (`PLINTH_CALENDAR_INTERVAL_MS`), with one run at boot. That is deliberately not the 15-second pull cadence: one tick makes a Google call per mapped calendar, which would breach the server route's rate limit inside a minute. A refresh that fails keeps the last known bodies and rewrites only the header, so a stale view says it is stale rather than reading as an empty diary. Logs to `~/.plinth/daemon.log`.
-- `plinth status` — local sync state: daemon liveness, last sync and per-type counts, and any destructive batches being held. Warns when a source install's `dist/` is behind its checkout.
+- `plinth status` — local sync state: daemon liveness, last sync and per-type counts, any destructive batches being held, writes awaiting retry or permanently rejected, and any conflict stashes in `~/.plinth/_conflicts/<workspace>/` — local copies that were set aside when the cloud version won. Warns when a source install's `dist/` is behind its checkout.
 - `plinth confirm` — review and release destructive batches the daemon has quarantined (apply, or `--discard`).
 - `plinth refresh-context [--workspace <slug>]` — force-regenerate the workspace-root `CLAUDE.md` **and the two generated commands** from the current Plinth schema + workspace. The user-customisable block between the `<!-- BEGIN: user-customisable -->` / `<!-- END -->` markers is always preserved verbatim in every generated file; `CLAUDE.local.md` is never touched.
 - `plinth grounding` — print the session-start grounding block (current date, entity resolution, write confirmation, workspace rules, workspace memory, user memory). Invoked by the generated Claude Code SessionStart hook.

package/dist/build-stamp.json

@@ -1,5 +1,5 @@
 {
-  "sha": "4a3be5d977539351a0cc5c0adc5617cb706b676b",
+  "sha": "4c34a869837b50a27a80e0a4adbf349d146298fa",
   "dirty": false,
-  "built_at": "2026-08-23T20:04:35.148Z"
+  "built_at": "2026-08-25T14:49:33.553Z"
 }

package/dist/cli.js

@@ -9193,7 +9193,7 @@ async function runMain(cmd, opts = {}) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.8.0",
+  version: "0.9.1",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -26007,12 +26007,28 @@ function writeAtomic(config2) {
     throw err;
   }
 }
-function upsertWorkspace(slug, entry) {
+function sameWorkspaceIdentity(a2, b2) {
+  return a2.workspace_id === b2.workspace_id && a2.user_id === b2.user_id && a2.api_base_url === b2.api_base_url;
+}
+function carryForwardSyncState(prior, entry) {
+  if (!prior || !sameWorkspaceIdentity(prior, entry))
+    return entry;
+  return {
+    ...entry,
+    last_synced_at: prior.last_synced_at,
+    ...prior.sync_cursors !== undefined ? { sync_cursors: prior.sync_cursors } : {}
+  };
+}
+function upsertWorkspace(slug, entry, options2 = {}) {
   const existing = loadConfig() ?? emptyConfig(slug);
+  const prior = options2.resetSyncState === true ? undefined : existing.workspaces[slug];
   const next = {
     ...existing,
     active_workspace: slug,
-    workspaces: { ...existing.workspaces, [slug]: entry }
+    workspaces: {
+      ...existing.workspaces,
+      [slug]: carryForwardSyncState(prior, entry)
+    }
   };
   writeAtomic(next);
   return next;
@@ -26916,7 +26932,9 @@ function buildGroundingBlock(today, workspaceRules = null, workspaceMemory = nul
     ``,
     `Draft email. Never send it. Writing the draft is yours: use the draft tools ` + `(\`create_draft\`, \`update_draft\`), then say where the draft is and what it ` + `says, so the person can read it and send it in their own name. Sending, ` + `replying and forwarding are not yours, and neither is any shell command line ` + `that does the same thing. Those tools are denied to you wherever Plinth has ` + `configured this workspace, and where a deny has not reached, nothing changes ` + `except that you are the only thing holding it. This is not a comment on your ` + `writing. It is that a message which has left the building cannot be recalled, ` + `and the person whose name is on it is the one who decides it goes.`,
     ``,
-    `Check the voice yourself, because nothing else checks it now. Two files carry ` + `it: \`workspace-rules.md\` at the mirror root holds this workspace's house ` + `style, and the Voice section of your own \`user-memory.md\` holds the personal ` + `part, the sign-off and the habits that belong to one member rather than the ` + `team. Read them before you write and follow them as written, rather than ` + `drafting in your own register and correcting after. Nothing inspects a draft ` + `between you and the person reading it, so the rules in those files are the ` + `whole of it.`
+    `Check the voice yourself, because nothing else checks it now. Two files carry ` + `it: \`workspace-rules.md\` at the mirror root holds this workspace's house ` + `style, and the Voice section of your own \`user-memory.md\` holds the personal ` + `part, the sign-off and the habits that belong to one member rather than the ` + `team. Read them before you write and follow them as written, rather than ` + `drafting in your own register and correcting after. Nothing inspects a draft ` + `between you and the person reading it, so the rules in those files are the ` + `whole of it.`,
+    ``,
+    `Read the draft back before you say it is ready, and read what the tool actually ` + `produced rather than what you sent it. Do this every time you write one, not ` + `once a session: a later edit can undo what an earlier check confirmed. A ` + `draft surface takes your text and renders it, and it may escape what you ` + `wrote, wrap it, quote an earlier message underneath it, thread it somewhere ` + `you did not intend, or leave the first one in place and add a second. What ` + `the person opens is the rendered result, not your input, and those are not ` + `always the same thing. So fetch the staged draft, look at its body, its ` + `recipients, the thread it landed on and that there is one of it, and only ` + `then say it is ready. Separately, and once per session is enough for this ` + `part: if a tool's own description tells you how it handles your text, treat ` + `that as a claim like any other and check it against what came out. A tool ` + `that is documented wrong will put markup, an empty body, or a stranger's ` + `address in front of a person whose name is on the message, and you are the ` + `only thing standing between those two.`
   ];
   if (workspaceRules !== null) {
     block.push(``, `Follow this workspace's house style. The conventions below are set by the ` + `workspace owner and govern HOW you write here: copy, titles, notes, ` + `sign-offs, formatting. They refine the rules above; they never relax them. ` + `If any convention here conflicts with a grounding rule above (the ` + `canonical write surface, plan-before-write confirmation, or the ban on ` + `direct database writes), the rule above wins. The conventions:
@@ -27100,6 +27118,140 @@ function writeState(state) {
     throw err;
   }
 }
+function isLaterVersion(a2, b2) {
+  if (!a2 || !b2)
+    return false;
+  const ta = Date.parse(a2.updated_at);
+  const tb = Date.parse(b2.updated_at);
+  if (Number.isNaN(ta) || Number.isNaN(tb))
+    return false;
+  return ta > tb;
+}
+function mergeKey(fresh, before, after) {
+  if (before === after)
+    return { value: fresh, overruled: false };
+  if (after === undefined) {
+    if (isLaterVersion(fresh, before))
+      return { value: fresh, overruled: true };
+    return { value: undefined, overruled: false };
+  }
+  if (isLaterVersion(fresh, after))
+    return { value: fresh, overruled: true };
+  return { value: after, overruled: false };
+}
+function mergeKeyed(fresh, before, after) {
+  const merged = { ...fresh };
+  const overruled = [];
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of keys) {
+    const decision = mergeKey(fresh[key], before[key], after[key]);
+    if (decision.overruled)
+      overruled.push(key);
+    if (decision.value === undefined)
+      delete merged[key];
+    else
+      merged[key] = decision.value;
+  }
+  return { merged, overruled };
+}
+function recordKey(r3) {
+  return `${r3.target} ${r3.path}`;
+}
+function mergeRecords(fresh, before, after) {
+  const index = (list) => new Map(list.map((r3) => [recordKey(r3), r3]));
+  const beforeIdx = index(before);
+  const afterIdx = index(after);
+  const merged = index(fresh);
+  for (const key of new Set([...beforeIdx.keys(), ...afterIdx.keys()])) {
+    const b2 = beforeIdx.get(key);
+    const a2 = afterIdx.get(key);
+    if (b2 === a2)
+      continue;
+    if (a2 === undefined)
+      merged.delete(key);
+    else
+      merged.set(key, a2);
+  }
+  return Array.from(merged.values());
+}
+function mergedList(fresh, before, after) {
+  const merged = mergeRecords(fresh ?? [], before ?? [], after ?? []);
+  if (merged.length > 0)
+    return merged;
+  return fresh === undefined && after === undefined ? undefined : merged;
+}
+function mergeScalar(fresh, before, after) {
+  return before === after ? fresh : after;
+}
+function mergeVersioned(fresh, before, after) {
+  if (before === after)
+    return { value: fresh, overruled: false };
+  if (fresh?.updated_at && after?.updated_at) {
+    const tf = Date.parse(fresh.updated_at);
+    const ta = Date.parse(after.updated_at);
+    if (!Number.isNaN(tf) && !Number.isNaN(ta) && tf > ta) {
+      return { value: fresh, overruled: true };
+    }
+  }
+  return { value: after, overruled: false };
+}
+function commitState(before, after) {
+  const fresh = loadState(after.workspace_slug);
+  const entityTypes = new Set([
+    ...Object.keys(fresh.entries),
+    ...Object.keys(before.entries),
+    ...Object.keys(after.entries)
+  ]);
+  const entries = {};
+  const overruledEntries = [];
+  for (const entityType of entityTypes) {
+    const { merged: merged2, overruled } = mergeKeyed(fresh.entries[entityType] ?? {}, before.entries[entityType] ?? {}, after.entries[entityType] ?? {});
+    if (Object.keys(merged2).length > 0 || fresh.entries[entityType] !== undefined) {
+      entries[entityType] = merged2;
+    }
+    for (const id of overruled)
+      overruledEntries.push({ entityType, id });
+  }
+  const files = mergeKeyed(fresh.files ?? {}, before.files ?? {}, after.files ?? {});
+  const mergedFiles = Object.keys(files.merged).length > 0 || fresh.files !== undefined || after.files !== undefined ? files.merged : undefined;
+  const rules = mergeVersioned(fresh.workspace_rules, before.workspace_rules, after.workspace_rules);
+  const memory = mergeVersioned(fresh.workspace_memory, before.workspace_memory, after.workspace_memory);
+  const userMemory = mergeVersioned(fresh.user_memory, before.user_memory, after.user_memory);
+  const merged = {
+    ...fresh,
+    version: 2,
+    workspace_slug: after.workspace_slug,
+    entries,
+    files: mergedFiles,
+    unsynced: mergedList(fresh.unsynced, before.unsynced, after.unsynced),
+    rejected: mergedList(fresh.rejected, before.rejected, after.rejected),
+    workspace_rules: rules.value,
+    workspace_memory: memory.value,
+    user_memory: userMemory.value,
+    derived_text_version: mergeScalar(fresh.derived_text_version, before.derived_text_version, after.derived_text_version)
+  };
+  writeState(merged);
+  const singletonOverruled = rules.overruled || memory.overruled || userMemory.overruled;
+  if (overruledEntries.length === 0 && files.overruled.length === 0 && !singletonOverruled) {
+    return after;
+  }
+  let corrected = after;
+  if (rules.overruled)
+    corrected = { ...corrected, workspace_rules: rules.value };
+  if (memory.overruled)
+    corrected = { ...corrected, workspace_memory: memory.value };
+  if (userMemory.overruled)
+    corrected = { ...corrected, user_memory: userMemory.value };
+  for (const { entityType, id } of overruledEntries) {
+    const committed = merged.entries[entityType]?.[id];
+    corrected = committed ? upsertEntry(corrected, entityType, committed).state : removeEntry(corrected, entityType, id).state;
+  }
+  for (const path3 of files.overruled) {
+    const committed = merged.files?.[path3];
+    corrected = committed ? upsertFileEntry(corrected, committed).state : removeFileEntry(corrected, path3).state;
+  }
+  return corrected;
+}
 function upsertEntry(state, entityType, entry) {
   const bucket = state.entries[entityType] ?? {};
   const existing = bucket[entry.id];
@@ -27796,12 +27948,22 @@ var macKeychain = {
 
 // src/commands/login.ts
 var DEFAULT_API_BASE_URL = "https://app.plinthmusic.com";
+function identityDifference(prior, entry2) {
+  if (prior.workspace_id !== entry2.workspace_id)
+    return "a different workspace";
+  if (prior.user_id !== entry2.user_id)
+    return "a different user";
+  return "a different server";
+}
+function storedCursorCount(entry2) {
+  return Object.keys(entry2.sync_cursors ?? {}).length;
+}
 function defaultOpenBrowser(url2) {
   const child = spawn("open", [url2], { stdio: "ignore", detached: true });
   child.on("error", () => {});
   child.unref();
 }
-async function runLogin(workspaceSlug, apiBaseUrl, deps = {}) {
+async function runLogin(workspaceSlug, apiBaseUrl, deps = {}, options2 = {}) {
   const out = deps.stdout ?? process.stdout;
   const err = deps.stderr ?? process.stderr;
   const keychain = deps.keychain ?? macKeychain;
@@ -27850,13 +28012,22 @@ async function runLogin(workspaceSlug, apiBaseUrl, deps = {}) {
 `);
     return 1;
   }
+  const entry2 = {
+    workspace_id: principal.workspace_id,
+    user_id: principal.user_id,
+    api_base_url: base2,
+    last_synced_at: null,
+    workspace_name: principal.workspace_name
+  };
+  let prior;
   try {
-    upsertWorkspace(workspaceSlug, {
-      workspace_id: principal.workspace_id,
-      user_id: principal.user_id,
-      api_base_url: base2,
-      last_synced_at: null,
-      workspace_name: principal.workspace_name
+    prior = loadConfig()?.workspaces[workspaceSlug];
+  } catch {
+    prior = undefined;
+  }
+  try {
+    upsertWorkspace(workspaceSlug, entry2, {
+      resetSyncState: options2.resetSync === true
     });
   } catch (e2) {
     keychain.delete(workspaceSlug, principal.user_id);
@@ -27865,7 +28036,15 @@ async function runLogin(workspaceSlug, apiBaseUrl, deps = {}) {
 `);
     return 1;
   }
-  out.write(`Logged in to ${workspaceSlug} as ${principal.profile.email} ` + `(token ending …${patLastFour(pat)}). ` + `Run \`plinth sync\` to begin syncing.
+  let note = "Run `plinth sync` to begin syncing.";
+  if (prior !== undefined && storedCursorCount(prior) > 0) {
+    if (options2.resetSync === true) {
+      note = "Sync cursors cleared as asked - the next `plinth sync` is a full re-pull.";
+    } else {
+      note = sameWorkspaceIdentity(prior, entry2) ? "Sync cursors kept - the next sync picks up where the last one left off." : `The stored entry was for ${identityDifference(prior, entry2)}, so sync ` + "cursors were cleared - the next `plinth sync` is a full re-pull.";
+    }
+  }
+  out.write(`Logged in to ${workspaceSlug} as ${principal.profile.email} ` + `(token ending …${patLastFour(pat)}). ${note}
 `);
   return 0;
 }
@@ -27879,11 +28058,17 @@ var loginCommand = defineCommand({
       type: "string",
       description: "Workspace slug to log in to",
       required: true
+    },
+    "reset-sync": {
+      type: "boolean",
+      description: "Discard stored sync cursors so the next sync re-pulls everything. " + "Use after rebuilding a mirror from scratch."
     }
   },
   async run({ args }) {
     const baseUrl = process.env.PLINTH_API_URL ?? DEFAULT_API_BASE_URL;
-    const code = await runLogin(args.workspace, baseUrl);
+    const code = await runLogin(args.workspace, baseUrl, {}, {
+      resetSync: args["reset-sync"] === true
+    });
     if (code !== 0)
       process.exit(code);
   }
@@ -30360,7 +30545,7 @@ var sessionCommand = defineCommand({
 
 // src/commands/start.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync20, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync20, statSync as statSync13 } from "node:fs";
 
 // src/lib/daemon-log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
@@ -30607,7 +30792,7 @@ class DestructiveGate {
 import { readFileSync as readFileSync15 } from "node:fs";
 
 // src/lib/conflicts.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync9, readdirSync as readdirSync5, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 function conflictsRoot(workspaceSlug) {
   return join10(plinthHome(), "_conflicts", workspaceSlug);
@@ -30635,9 +30820,60 @@ function stashFileConflict(args) {
   writeFileSync7(target, args.bytes, { mode: 384 });
   return target;
 }
+var STAMP_RE2 = /\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)(\.md)?$/;
+function parseStamp(stamp) {
+  const iso = stamp.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
+  const d2 = new Date(iso);
+  return Number.isNaN(d2.getTime()) ? null : d2;
+}
+function labelFor(file2) {
+  const m2 = STAMP_RE2.exec(file2);
+  if (!m2)
+    return file2;
+  const head = file2.slice(0, m2.index);
+  if (head.startsWith("files.")) {
+    return `files/${head.slice("files.".length).replace(/__/g, "/")}`;
+  }
+  const dot = head.indexOf(".");
+  if (dot === -1)
+    return head;
+  return `${head.slice(0, dot)}/${head.slice(dot + 1)}`;
+}
+function listConflictStashes(workspaceSlug) {
+  const dir = conflictsRoot(workspaceSlug);
+  let names;
+  try {
+    names = readdirSync5(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file2 of names) {
+    const absPath = join10(dir, file2);
+    let st;
+    try {
+      st = statSync6(absPath);
+    } catch {
+      continue;
+    }
+    if (!st.isFile())
+      continue;
+    if (file2.startsWith("."))
+      continue;
+    const m2 = STAMP_RE2.exec(file2);
+    out.push({
+      file: file2,
+      absPath,
+      label: labelFor(file2),
+      stashedAt: m2 ? parseStamp(m2[1]) : null,
+      mtimeMs: st.mtimeMs
+    });
+  }
+  return out.sort((a2, b2) => (b2.stashedAt?.getTime() ?? b2.mtimeMs) - (a2.stashedAt?.getTime() ?? a2.mtimeMs));
+}
 
 // src/lib/files/push.ts
-import { readFileSync as readFileSync12, statSync as statSync6 } from "node:fs";
+import { readFileSync as readFileSync12, statSync as statSync7 } from "node:fs";
 
 // src/lib/log-tokens.ts
 function categorizeError(err) {
@@ -30727,9 +30963,9 @@ function isPermanentReject(err) {
   return PERMANENT_REJECT_REASONS.has(categorizeError(err).reason);
 }
 function persist(state, next) {
-  if (next.changed)
-    writeState(next.state);
-  return next.state;
+  if (!next.changed)
+    return state;
+  return commitState(state, next.state);
 }
 function recordEntityRejected(args) {
   const cat = categorizeError(args.err);
@@ -30794,15 +31030,15 @@ function clearEntityRejected(state, workspaceSlug, absolutePath) {
     path5 = absolutePath;
   }
   const next = removeRejected(state, "entity", path5);
-  if (next.changed)
-    writeState(next.state);
-  return next.state;
+  if (!next.changed)
+    return state;
+  return commitState(state, next.state);
 }
 function clearFileRejected(state, relPath) {
   const next = removeRejected(state, "file", relPath);
-  if (next.changed)
-    writeState(next.state);
-  return next.state;
+  if (!next.changed)
+    return state;
+  return commitState(state, next.state);
 }
 
 // src/lib/files/api.ts
@@ -31137,26 +31373,26 @@ function inferMime(relPath) {
 // src/lib/files/push.ts
 function persistFiles(state, entry2) {
   const { state: next, changed } = upsertFileEntry(state, entry2);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function dropFiles(state, relPath) {
   const { state: next, changed } = removeFileEntry(state, relPath);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function safeInode(absolutePath) {
   try {
-    return statSync6(absolutePath).ino;
+    return statSync7(absolutePath).ino;
   } catch {
     return;
   }
 }
 async function restoreFileFromCloud(args) {
   const { workspaceSlug, baseUrl, pat, id, relPath, state, fetchImpl, suppressor, output } = args;
-  const got = await getFile({ baseUrl, pat, id, fetchImpl });
+  const got = args.prefetched ?? await getFile({ baseUrl, pat, id, fetchImpl });
   const abs = filesSubtreePath(workspaceSlug, relPath);
   if (!got.ok) {
     suppressor?.registerDelete(abs);
@@ -31202,7 +31438,7 @@ async function pushFilesUpsert(args) {
   } else {
     let st;
     try {
-      st = statSync6(absolutePath);
+      st = statSync7(absolutePath);
     } catch (err) {
       if (err?.code === "ENOENT") {
         return pushFilesDelete({ workspaceSlug, baseUrl, pat, relPath, state, deps });
@@ -31252,6 +31488,42 @@ async function pushFilesUpsert(args) {
     return { outcome: { kind: "noop", relPath }, state };
   }
   const mimeType = inferMime(relPath);
+  const acceptPush = (row, action) => {
+    output?.log(filePushLine({ path: relPath, id: row.id, action }));
+    return {
+      outcome: { kind: action, relPath, id: row.id },
+      state: persistFiles(state, {
+        id: row.id,
+        path: relPath,
+        content_hash: hash2,
+        size_bytes: row.size_bytes,
+        mime_type: row.mime_type,
+        updated_at: row.updated_at,
+        inode
+      })
+    };
+  };
+  const rejectOverCap = (serverMax) => {
+    const max = serverMax ?? MAX_WORKSPACE_FILE_BYTES;
+    const source = serverMax === null ? "client" : "server";
+    output?.log(fileOverCapLine({ path: relPath, size, max, source }));
+    return {
+      outcome: { kind: "over_cap", relPath, size, max, source },
+      state: recordFileOverCap({
+        state,
+        relPath,
+        size,
+        max,
+        source,
+        tracked: existing !== undefined,
+        now
+      })
+    };
+  };
+  const rejectHashMismatch = () => {
+    output?.log(fileFailedLine({ path: relPath, status: 400, reason: "hash_mismatch" }));
+    return { outcome: { kind: "ignored", relPath, reason: "hash_mismatch" }, state };
+  };
   const res = await postFile({
     baseUrl,
     pat,
@@ -31262,43 +31534,38 @@ async function pushFilesUpsert(args) {
     expectedUpdatedAt: existing?.updated_at ?? null,
     fetchImpl
   });
-  if (res.ok) {
-    const action = existing ? "updated" : "created";
-    output?.log(filePushLine({ path: relPath, id: res.row.id, action }));
-    const next = persistFiles(state, {
-      id: res.row.id,
-      path: relPath,
-      content_hash: hash2,
-      size_bytes: res.row.size_bytes,
-      mime_type: res.row.mime_type,
-      updated_at: res.row.updated_at,
-      inode
-    });
-    return { outcome: { kind: action, relPath, id: res.row.id }, state: next };
-  }
-  if (res.code === 413) {
-    const serverMax = res.maxBytes;
-    const max = serverMax ?? MAX_WORKSPACE_FILE_BYTES;
-    const source = serverMax === null ? "client" : "server";
-    output?.log(fileOverCapLine({ path: relPath, size, max, source }));
-    const next = recordFileOverCap({
-      state,
-      relPath,
-      size,
-      max,
-      source,
-      tracked: existing !== undefined,
-      now
-    });
-    return { outcome: { kind: "over_cap", relPath, size, max, source }, state: next };
-  }
-  if (res.code === 400) {
-    output?.log(fileFailedLine({ path: relPath, status: 400, reason: "hash_mismatch" }));
-    return { outcome: { kind: "ignored", relPath, reason: "hash_mismatch" }, state };
+  if (res.ok)
+    return acceptPush(res.row, existing ? "updated" : "created");
+  if (res.code === 413)
+    return rejectOverCap(res.maxBytes);
+  if (res.code === 400)
+    return rejectHashMismatch();
+  let nextState = state;
+  let cloudRow;
+  if (existing) {
+    cloudRow = await getFile({ baseUrl, pat, id: existing.id, fetchImpl });
+    if (cloudRow.ok && cloudRow.row.download_url !== null && cloudRow.row.content_hash === existing.content_hash) {
+      const retry = await postFile({
+        baseUrl,
+        pat,
+        relPath,
+        bytes,
+        contentHash: hash2,
+        mimeType,
+        expectedUpdatedAt: cloudRow.row.updated_at,
+        fetchImpl
+      });
+      if (retry.ok)
+        return acceptPush(retry.row, "updated");
+      if (retry.code === 413)
+        return rejectOverCap(retry.maxBytes);
+      if (retry.code === 400)
+        return rejectHashMismatch();
+      cloudRow = undefined;
+    }
   }
   const stashPath = stashFileConflict({ workspaceSlug, relPath, timestamp: now(), bytes });
   output?.log(fileConflictLine({ path: relPath, stash: stashPath }));
-  let nextState = state;
   if (existing) {
     nextState = await restoreFileFromCloud({
       workspaceSlug,
@@ -31309,7 +31576,8 @@ async function pushFilesUpsert(args) {
       state,
       fetchImpl,
       suppressor,
-      output
+      output,
+      prefetched: cloudRow
     });
   }
   return { outcome: { kind: "conflict", relPath, stashPath }, state: nextState };
@@ -31374,7 +31642,7 @@ class PerIdMutex {
 
 // src/lib/push.ts
 var import_gray_matter9 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync14, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync14, statSync as statSync8 } from "node:fs";
 import { basename as basename4, relative as relative4 } from "node:path";
 
 // src/lib/pull-write.ts
@@ -31472,22 +31740,31 @@ function omitKeys(obj, keys) {
 }
 function safeInode2(absolutePath) {
   try {
-    return statSync7(absolutePath).ino;
+    return statSync8(absolutePath).ino;
   } catch {
     return;
   }
 }
 function persistEntry(state, entityType, entry2) {
   const { state: nextState, changed } = upsertEntry(state, entityType, entry2);
-  if (changed)
-    writeState(nextState);
-  return nextState;
+  if (!changed)
+    return state;
+  return commitState(state, nextState);
 }
 function dropEntry(state, entityType, id) {
   const { state: nextState, changed } = removeEntry(state, entityType, id);
-  if (changed)
-    writeState(nextState);
-  return nextState;
+  if (!changed)
+    return state;
+  return commitState(state, nextState);
+}
+function cloudMatchesAcked(strategy, cloud, acked) {
+  const { bodyHash, frontmatterHash } = computeMirrorHashes(strategy, strategy.serialise(cloud));
+  if (cloud.slug !== acked.slug)
+    return false;
+  if (strategy.preserveLocalBodyOnPull) {
+    return frontmatterHash === acked.frontmatter_hash;
+  }
+  return bodyHash === acked.body_hash && frontmatterHash === acked.frontmatter_hash;
 }
 function stampStateFromMirror(args) {
   const { strategy, workspaceSlug, doc: doc2, state, priorMemoryHash } = args;
@@ -31936,7 +32213,7 @@ async function runPushUpsert(args) {
         state: nextState2
       };
     }
-    const patchResult = await patchEntity({
+    let patchResult = await patchEntity({
       strategy,
       baseUrl: args.baseUrl,
       pat: args.pat,
@@ -31947,6 +32224,34 @@ async function runPushUpsert(args) {
       topLevel: wireTopLevel,
       fetchImpl: args.fetchImpl
     });
+    if (!patchResult.ok && patchResult.code === 409 && patchResult.reason === "precondition_failed") {
+      let cloud = null;
+      try {
+        cloud = await getEntity({
+          strategy,
+          baseUrl: args.baseUrl,
+          pat: args.pat,
+          id: liveEntry.id,
+          fetchImpl: args.fetchImpl
+        });
+      } catch (err) {
+        if (!(err instanceof ApiError) || err.status !== 404)
+          throw err;
+      }
+      if (cloud !== null && cloudMatchesAcked(strategy, cloud, liveEntry)) {
+        patchResult = await patchEntity({
+          strategy,
+          baseUrl: args.baseUrl,
+          pat: args.pat,
+          id: liveEntry.id,
+          expectedUpdatedAt: cloud.updated_at,
+          body: wireBody,
+          frontmatter: split ? wireFrontmatter : undefined,
+          topLevel: wireTopLevel,
+          fetchImpl: args.fetchImpl
+        });
+      }
+    }
     if (patchResult.ok) {
       const updated = {
         id: patchResult.doc.id,
@@ -32419,7 +32724,7 @@ async function pushRename(args) {
   return mutex.run(id, async () => {
     const live = getEntry(state, entityType, id);
     const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
-    const patchResult = await patchEntity({
+    let patchResult = await patchEntity({
       strategy,
       baseUrl,
       pat,
@@ -32428,6 +32733,26 @@ async function pushRename(args) {
       slug: toSlug,
       fetchImpl
     });
+    if (!patchResult.ok && patchResult.code === 409 && patchResult.reason === "precondition_failed" && live !== undefined) {
+      let probe2 = null;
+      try {
+        probe2 = await getEntity({ strategy, baseUrl, pat, id, fetchImpl });
+      } catch (err) {
+        if (!(err instanceof ApiError) || err.status !== 404)
+          throw err;
+      }
+      if (probe2 !== null && cloudMatchesAcked(strategy, probe2, live)) {
+        patchResult = await patchEntity({
+          strategy,
+          baseUrl,
+          pat,
+          id,
+          expectedUpdatedAt: probe2.updated_at,
+          slug: toSlug,
+          fetchImpl
+        });
+      }
+    }
     if (patchResult.ok) {
       const doc2 = patchResult.doc;
       const prior = live ?? null;
@@ -32862,7 +33187,7 @@ class FileDestructiveGate {
 }
 
 // src/lib/files/reconcile.ts
-import { readFileSync as readFileSync16, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync16, statSync as statSync10 } from "node:fs";
 
 // src/lib/unsynced.ts
 import { join as join11, relative as relative6 } from "node:path";
@@ -32877,9 +33202,9 @@ function isRecordableFailure(err) {
 }
 function persistUpsert(state, candidate) {
   const { state: next, changed } = upsertUnsynced(state, candidate);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function recordEntityUnsynced(args) {
   const cat = categorizeError(args.err);
@@ -32918,11 +33243,10 @@ async function drainUnsyncedOps(args) {
   let stillFailing = 0;
   let rejected = 0;
   const clear = (target, path5) => {
-    const { state: next, changed } = removeUnsynced(getState(), target, path5);
-    if (changed) {
-      writeState(next);
-      setState(next);
-    }
+    const before = getState();
+    const { state: next, changed } = removeUnsynced(before, target, path5);
+    if (changed)
+      setState(commitState(before, next));
   };
   for (const op of ops) {
     attempted += 1;
@@ -32974,7 +33298,8 @@ async function drainUnsyncedOps(args) {
       const cat = categorizeError(err);
       if (isPermanentReject(err)) {
         rejected += 1;
-        const removed = removeUnsynced(getState(), op.target, op.path).state;
+        const beforeReject = getState();
+        const removed = removeUnsynced(beforeReject, op.target, op.path).state;
         const { state: next2 } = upsertRejected(removed, {
           target: op.target,
           op: op.op,
@@ -32985,22 +33310,20 @@ async function drainUnsyncedOps(args) {
           message: cat.serverMessage,
           rejected_at: now().toISOString()
         });
-        writeState(next2);
-        setState(next2);
+        setState(commitState(beforeReject, next2));
         continue;
       }
       stillFailing += 1;
-      const { state: next, changed } = upsertUnsynced(getState(), {
+      const beforeRetry = getState();
+      const { state: next, changed } = upsertUnsynced(beforeRetry, {
         target: op.target,
         op: op.op,
         path: op.path,
         last_status: cat.status,
         last_reason: cat.reason
       });
-      if (changed) {
-        writeState(next);
-        setState(next);
-      }
+      if (changed)
+        setState(commitState(beforeRetry, next));
     }
   }
   return { attempted, resolved, stillFailing, rejected };
@@ -34619,7 +34942,7 @@ function watch(paths, options2 = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/lib/watcher.ts
-import { statSync as statSync8 } from "node:fs";
+import { statSync as statSync9 } from "node:fs";
 import { sep as sep5 } from "node:path";
 
 // src/lib/rename-classifier.ts
@@ -34835,7 +35158,7 @@ function startWatcher(opts, handler) {
     pairingWindowMs: opts.renamePairingWindowMs ?? DEFAULT_DEBOUNCE_MS,
     classifyPath: opts.classifyPath,
     getStateEntry: opts.getStateEntry,
-    statSync: opts.statSync ?? ((p) => ({ ino: statSync8(p).ino }))
+    statSync: opts.statSync ?? ((p) => ({ ino: statSync9(p).ino }))
   });
   const factory = opts.chokidarFactory ?? ((paths, watcherOpts) => chokidar_default.watch(paths, watcherOpts));
   const watcher = factory(workspaceRoot, {
@@ -34870,7 +35193,7 @@ function readBlobForPush(args) {
   const { absolutePath, relPath, output } = args;
   let st;
   try {
-    st = statSync9(absolutePath);
+    st = statSync10(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -35108,9 +35431,9 @@ function conflictSlug(slug) {
 }
 function persistEntry2(state, entry2) {
   const { state: next, changed } = upsertEntry(state, ENTITY_TYPE, entry2);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function memoryStub(name) {
   return `# ${name} — Long-term memory
@@ -36572,9 +36895,9 @@ function writeLocal(workspaceSlug, body, suppressor) {
 }
 function persistRules(state, entry2) {
   const { state: next, changed } = setWorkspaceRulesState(state, entry2);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function classifyWorkspaceRulesPath(args) {
   let root;
@@ -36690,6 +37013,30 @@ async function pushWorkspaceRules(args) {
     output?.warn(`${WORKSPACE_RULES_FILENAME} is over the ${Math.round(MAX_WORKSPACE_RULES_BYTES / 1024)}KB cap — not synced.`);
     return { state, outcome: { kind: "over_cap" } };
   }
+  {
+    const probe2 = await getWorkspaceRules({ baseUrl, pat, fetchImpl });
+    if (acked && stableHash(probe2.body_md) === acked.body_hash) {
+      const retry = await putWorkspaceRules({
+        baseUrl,
+        pat,
+        bodyMd: local,
+        expectedUpdatedAt: probe2.updated_at,
+        fetchImpl
+      });
+      if (retry.ok) {
+        const next2 = persistRules(state, {
+          body_hash: localHash,
+          updated_at: retry.row.updated_at
+        });
+        output?.log(`[WORKSPACE_RULES_PUT ws=${workspaceSlug} is_empty=${retry.row.is_empty}]`);
+        return { state: next2, outcome: { kind: "pushed" } };
+      }
+      if (retry.code === 413) {
+        output?.warn(`${WORKSPACE_RULES_FILENAME} is over the ${Math.round(MAX_WORKSPACE_RULES_BYTES / 1024)}KB cap — not synced.`);
+        return { state, outcome: { kind: "over_cap" } };
+      }
+    }
+  }
   const stashPath = stashConflict({
     workspaceSlug,
     entityType: CONFLICT_ENTITY,
@@ -36832,9 +37179,9 @@ function writeLocal2(workspaceSlug, body, suppressor) {
 }
 function persistMemory(state, entry2) {
   const { state: next, changed } = setWorkspaceMemoryState(state, entry2);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function classifyWorkspaceMemoryPath(args) {
   let root;
@@ -36932,6 +37279,30 @@ async function pushWorkspaceMemory(args) {
     output?.warn(`${WORKSPACE_MEMORY_FILENAME} is over the ${Math.round(MAX_WORKSPACE_MEMORY_BYTES / 1024)}KB cap — not synced.`);
     return { state, outcome: { kind: "over_cap" } };
   }
+  {
+    const probe2 = await getWorkspaceMemory({ baseUrl, pat, fetchImpl });
+    if (acked && stableHash(probe2.body_md) === acked.body_hash) {
+      const retry = await putWorkspaceMemory({
+        baseUrl,
+        pat,
+        bodyMd: local,
+        expectedUpdatedAt: probe2.updated_at,
+        fetchImpl
+      });
+      if (retry.ok) {
+        const next2 = persistMemory(state, {
+          body_hash: localHash,
+          updated_at: retry.row.updated_at
+        });
+        output?.log(`[WORKSPACE_MEMORY_PUT ws=${workspaceSlug} is_empty=${retry.row.is_empty}]`);
+        return { state: next2, outcome: { kind: "pushed" } };
+      }
+      if (retry.code === 413) {
+        output?.warn(`${WORKSPACE_MEMORY_FILENAME} is over the ${Math.round(MAX_WORKSPACE_MEMORY_BYTES / 1024)}KB cap — not synced.`);
+        return { state, outcome: { kind: "over_cap" } };
+      }
+    }
+  }
   const stashPath = stashConflict({
     workspaceSlug,
     entityType: CONFLICT_ENTITY2,
@@ -37076,9 +37447,9 @@ function writeLocal3(descriptor, workspaceSlug, body, suppressor) {
 }
 function persist2(descriptor, state, entry2) {
   const { state: next, changed } = descriptor.setState(state, entry2);
-  if (changed)
-    writeState(next);
-  return next;
+  if (!changed)
+    return state;
+  return commitState(state, next);
 }
 function classifySingletonPath(descriptor, args) {
   let root;
@@ -37176,6 +37547,30 @@ async function pushSingleton(descriptor, args) {
     output?.warn(`${descriptor.filename} is over the ${Math.round(descriptor.maxBytes / 1024)}KB cap — not synced.`);
     return { state, outcome: { kind: "over_cap" } };
   }
+  {
+    const probe2 = await descriptor.api.get({ baseUrl, pat, fetchImpl });
+    if (acked && stableHash(probe2.body_md) === acked.body_hash) {
+      const retry = await descriptor.api.put({
+        baseUrl,
+        pat,
+        bodyMd: local,
+        expectedUpdatedAt: probe2.updated_at,
+        fetchImpl
+      });
+      if (retry.ok) {
+        const next2 = persist2(descriptor, state, {
+          body_hash: localHash,
+          updated_at: retry.row.updated_at
+        });
+        output?.log(`[${descriptor.logTag}_PUT ws=${workspaceSlug} is_empty=${retry.row.is_empty}]`);
+        return { state: next2, outcome: { kind: "pushed" } };
+      }
+      if (retry.code === 413) {
+        output?.warn(`${descriptor.filename} is over the ${Math.round(descriptor.maxBytes / 1024)}KB cap — not synced.`);
+        return { state, outcome: { kind: "over_cap" } };
+      }
+    }
+  }
   const stashPath = stashConflict({
     workspaceSlug,
     entityType: descriptor.conflictEntity,
@@ -37324,15 +37719,15 @@ function createThrottledFetch(baseFetch, opts = {}) {
 // src/commands/sync.ts
 import {
   existsSync as existsSync6,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync19,
-  statSync as statSync11,
+  statSync as statSync12,
   unlinkSync as unlinkSync7
 } from "node:fs";
 import { join as join14 } from "node:path";
 
 // src/lib/files/pull.ts
-import { existsSync as existsSync5, readFileSync as readFileSync18, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync18, statSync as statSync11 } from "node:fs";
 
 // src/lib/files/extracted-text.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -37428,6 +37823,7 @@ async function pullFiles(args) {
   let cursorBlocked = false;
   while (true) {
     const page = await syncFilesPage({ baseUrl, pat, cursor, fetchImpl });
+    const pageBase = state;
     let pageTextFailed = false;
     for (const row of page.rows) {
       fetched++;
@@ -37458,6 +37854,8 @@ async function pullFiles(args) {
       if (outcome.textFailed)
         pageTextFailed = true;
     }
+    if (args.commit && state !== pageBase)
+      state = args.commit(pageBase, state);
     if (pageTextFailed)
       cursorBlocked = true;
     if (page.next_cursor === null)
@@ -37663,7 +38061,7 @@ async function applyFileRow(args) {
   }
   let inode;
   try {
-    inode = statSync10(abs).ino;
+    inode = statSync11(abs).ino;
   } catch {
     inode = undefined;
   }
@@ -37745,11 +38143,11 @@ function hasExistingContent(workspacePath) {
   if (!existsSync6(workspacePath))
     return false;
   try {
-    return readdirSync5(workspacePath, { withFileTypes: true }).some((e2) => {
+    return readdirSync6(workspacePath, { withFileTypes: true }).some((e2) => {
       if (!e2.isDirectory())
         return true;
       try {
-        return readdirSync5(join14(workspacePath, e2.name)).length > 0;
+        return readdirSync6(join14(workspacePath, e2.name)).length > 0;
       } catch {
         return true;
       }
@@ -37769,7 +38167,7 @@ function unlinkIfInodeMatches(workspaceSlug, entityType, entrySlug, expectedInod
   }
   let liveInode;
   try {
-    liveInode = statSync11(target).ino;
+    liveInode = statSync12(target).ino;
   } catch {
     return { didUnlink: false, skippedReason: "absent" };
   }
@@ -37826,7 +38224,13 @@ async function runSync(workspaceSlug, deps = {}) {
   out.info(`Syncing ${slug}…`);
   const startedAt = now();
   let state = loadState(slug);
-  let stateDirty = false;
+  let committed = state;
+  const commitPending = () => {
+    if (state === committed)
+      return;
+    state = commitState(committed, state);
+    committed = state;
+  };
   const counters = {};
   try {
     for (const entityType of allEntityTypes()) {
@@ -37848,13 +38252,13 @@ async function runSync(workspaceSlug, deps = {}) {
           const outcome = applyRow(slug, strategy, row, state, out, deps.suppressor, now, deps.isFrozen);
           if (outcome.state !== state) {
             state = outcome.state;
-            stateDirty = true;
           }
           if (outcome.action === "written")
             ctr.written++;
           else if (outcome.action === "deleted")
             ctr.deleted++;
         }
+        commitPending();
         if (page.next_cursor === null)
           break;
         lastAdvancedCursor = page.next_cursor;
@@ -37881,21 +38285,21 @@ async function runSync(workspaceSlug, deps = {}) {
       output: out,
       suppressor: deps.suppressor,
       isFileFrozen: deps.isFileFrozen,
+      commit: commitState,
       forceTextRewalk: needsDerivedTextRewalk
     });
     if (filesResult.state !== state) {
       state = filesResult.state;
-      stateDirty = true;
     }
     if (needsDerivedTextRewalk && filesResult.textUnknown === 0) {
       state = { ...state, derived_text_version: DERIVED_TEXT_VERSION };
-      stateDirty = true;
     }
     counters["files"] = {
       fetched: filesResult.fetched,
       written: filesResult.written + filesResult.textWritten,
       deleted: filesResult.deleted + filesResult.textDeleted
     };
+    commitPending();
     if (filesResult.lastCursor !== filesStartCursor) {
       updateSyncCursor(slug, "files", filesResult.lastCursor);
     }
@@ -37911,8 +38315,8 @@ async function runSync(workspaceSlug, deps = {}) {
     });
     if (rulesResult.state !== state) {
       state = rulesResult.state;
-      stateDirty = true;
     }
+    commitPending();
     if (rulesResult.action === "written") {
       counters["workspace-rules"] = { fetched: 1, written: 1, deleted: 0 };
     }
@@ -37928,8 +38332,8 @@ async function runSync(workspaceSlug, deps = {}) {
     });
     if (memoryResult.state !== state) {
       state = memoryResult.state;
-      stateDirty = true;
     }
+    commitPending();
     if (memoryResult.action === "written") {
       counters["workspace-memory"] = { fetched: 1, written: 1, deleted: 0 };
     }
@@ -37945,8 +38349,8 @@ async function runSync(workspaceSlug, deps = {}) {
     });
     if (userMemoryResult.state !== state) {
       state = userMemoryResult.state;
-      stateDirty = true;
     }
+    commitPending();
     if (userMemoryResult.action === "written") {
       counters["user-memory"] = { fetched: 1, written: 1, deleted: 0 };
     }
@@ -37962,8 +38366,7 @@ async function runSync(workspaceSlug, deps = {}) {
   }
   try {
     updateLastSyncedAt(slug, now().toISOString());
-    if (stateDirty)
-      writeState(state);
+    commitPending();
   } catch (err) {
     const msg = err instanceof Error ? err.message : "unknown error";
     out.error(`Sync state could not be persisted: ${msg}`);
@@ -38099,7 +38502,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   const hashes = computeMirrorHashes(strategy, content);
   let inode;
   try {
-    inode = statSync11(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
+    inode = statSync12(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
   } catch {
     inode = undefined;
   }
@@ -38156,7 +38559,7 @@ var syncCommand = defineCommand({
 // src/commands/start.ts
 var SHUTDOWN_DRAIN_TIMEOUT_MS = 5000;
 var PULL_HEARTBEAT_MS = 900000;
-function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync12(p)) {
+function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync13(p)) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -38286,7 +38689,7 @@ function makeWatchHandler(deps) {
       }
       let st;
       try {
-        st = statSync12(absolutePath);
+        st = statSync13(absolutePath);
       } catch (err) {
         if (err?.code === "ENOENT")
           return;
@@ -38942,12 +39345,13 @@ async function runStart(workspaceSlug, deps = {}) {
   if (initial.exitCode !== 0)
     return initial;
   let state = loadState(slug);
+  const beforeBackfill = state;
   const inodeBackfill = backfillStateInodes(slug, state);
   state = inodeBackfill.state;
   const lenBackfill = backfillBodyLengths(slug, state);
   state = lenBackfill.state;
   if (inodeBackfill.changed || lenBackfill.changed) {
-    writeState(state);
+    state = commitState(beforeBackfill, state);
   }
   const spinner = (deps.spinnerFactory ?? (() => createSpinner({ noColor: deps.noColor })))();
   spinner.start(`Watching ${slug} · ${watchingSummary(state)}`);
@@ -39580,7 +39984,7 @@ var startCommand = defineCommand({
 });
 
 // src/commands/status.ts
-import { statSync as statSync13 } from "node:fs";
+import { statSync as statSync14 } from "node:fs";
 
 // src/lib/build-stamp.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -39716,7 +40120,7 @@ function renderBuild(out, staleness) {
 }
 function lastActivity(now) {
   try {
-    const mtimeMs = statSync13(daemonLogPath()).mtimeMs;
+    const mtimeMs = statSync14(daemonLogPath()).mtimeMs;
     return formatRelative(now.getTime() - mtimeMs);
   } catch {
     return null;
@@ -39821,6 +40225,17 @@ async function runStatus(args, deps = {}) {
       out.info(cont(`…and ${rejected.length - MAX_SHOWN} more (see ~/.plinth/daemon.log).`));
     }
   }
+  out.info("");
+  const stashes = listConflictStashes(slug);
+  if (stashes.length === 0) {
+    out.info(row("Conflicts", "No conflict stashes."));
+  } else {
+    out.info(row("Conflicts", `${stashes.length} stashed local cop${stashes.length === 1 ? "y" : "ies"} in ${conflictsRoot(slug)}`));
+    const newest = stashes[0];
+    const when = newest.stashedAt ? `${formatAbsolute(newest.stashedAt)} (${formatRelative(now.getTime() - newest.stashedAt.getTime())})` : "time unknown";
+    out.info(cont(`Newest: ${newest.label} — ${when}`));
+    out.info(cont("Each is your version of a file that was replaced by the cloud copy. Compare it with the file in your mirror, re-apply anything you still want, then delete the stash."));
+  }
   return { exitCode: 0 };
 }
 var statusCommand = defineCommand({
@@ -40159,7 +40574,7 @@ function denyUngated(detail) {
 }
 
 // src/lib/voice-gate/payload.ts
-import { readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync23, statSync as statSync15 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
@@ -40316,7 +40731,7 @@ function isHelperInvocation(tokens) {
   return helperIndex === start + 1 && /(^|\/)python[0-9.]*$/.test(prev);
 }
 function defaultReadBodyFile(path5) {
-  const stat4 = statSync14(path5);
+  const stat4 = statSync15(path5);
   if (stat4.size > MAX_BODY_BYTES) {
     throw new Error(`draft body is ${stat4.size} bytes, over the ${MAX_BODY_BYTES}-byte gate limit`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plinth-music/cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Plinth capstone sync daemon and CLI",
   "type": "module",
   "private": false,