@plinth-music/cli 0.2.0 → 0.3.0

package/dist/cli.js

@@ -4102,11 +4102,11 @@ var require_excerpt = __commonJS((exports, module) => {
     if (typeof opts.excerpt === "function") {
       return opts.excerpt(file2, opts);
     }
-    const sep2 = file2.data.excerpt_separator || opts.excerpt_separator;
-    if (sep2 == null && (opts.excerpt === false || opts.excerpt == null)) {
+    const sep3 = file2.data.excerpt_separator || opts.excerpt_separator;
+    if (sep3 == null && (opts.excerpt === false || opts.excerpt == null)) {
       return file2;
     }
-    const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep2 || opts.delimiters[0];
+    const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep3 || opts.delimiters[0];
     const idx = file2.content.indexOf(delimiter);
     if (idx !== -1) {
       file2.excerpt = file2.content.slice(0, idx);
@@ -5570,15 +5570,15 @@ class AsyncTaskManager {
     this.#browserFrame = browserFrame;
   }
   waitUntilComplete() {
-    return new Promise((resolve, reject) => {
-      this.waitUntilCompleteResolvers.push({ resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.waitUntilCompleteResolvers.push({ resolve: resolve2, reject });
       this.resolveWhenComplete();
     });
   }
   abort() {
     if (this.destroyed) {
-      return new Promise((resolve, reject) => {
-        this.waitUntilCompleteResolvers.push({ resolve, reject });
+      return new Promise((resolve2, reject) => {
+        this.waitUntilCompleteResolvers.push({ resolve: resolve2, reject });
         this.resolveWhenComplete();
       });
     }
@@ -5586,8 +5586,8 @@ class AsyncTaskManager {
   }
   destroy() {
     if (this.destroyed) {
-      return new Promise((resolve, reject) => {
-        this.waitUntilCompleteResolvers.push({ resolve, reject });
+      return new Promise((resolve2, reject) => {
+        this.waitUntilCompleteResolvers.push({ resolve: resolve2, reject });
         this.resolveWhenComplete();
       });
     }
@@ -5773,8 +5773,8 @@ The following traces were recorded:
     for (const key of Object.keys(runningTasks)) {
       runningTasks[key](destroy2);
     }
-    return new Promise((resolve, reject) => {
-      this.waitUntilCompleteResolvers.push({ resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.waitUntilCompleteResolvers.push({ resolve: resolve2, reject });
       this.resolveWhenComplete();
     });
   }
@@ -16194,12 +16194,12 @@ var init_CustomElementRegistry = __esm(() => {
       if (this.get(name2)) {
         return Promise.resolve();
       }
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const callbacks2 = this[callbacks].get(name2);
         if (callbacks2) {
-          callbacks2.push(resolve);
+          callbacks2.push(resolve2);
         } else {
-          this[callbacks].set(name2, [resolve]);
+          this[callbacks].set(name2, [resolve2]);
         }
       });
     }
@@ -18788,7 +18788,7 @@ class Fetch {
     return true;
   }
   sendRequest() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const taskID = this.#browserFrame[asyncTaskManager].startTask(() => this.onAsyncTaskManagerAbort());
       if (this.resolve) {
         throw new this.#window.Error("Fetch already sent.");
@@ -18812,7 +18812,7 @@ class Fetch {
         if (returnResponse instanceof Response && !returnResponse.ok) {
           this.#browserFrame.page.console.error(`${this.request.method} ${this.request.url} ${returnResponse.status} (${returnResponse.statusText})`);
         }
-        resolve(returnResponse);
+        resolve2(returnResponse);
       };
       this.reject = (error53) => {
         this.#browserFrame[asyncTaskManager].endTask(taskID);
@@ -27205,9 +27205,9 @@ class BrowserFrameFactory {
       return Promise.resolve();
     }
     frame.closed = true;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (!frame.window) {
-        resolve();
+        resolve2();
         return;
       }
       if (frame.parentFrame) {
@@ -27227,7 +27227,7 @@ class BrowserFrameFactory {
           if (frame[listeners]) {
             frame[listeners].navigation = [];
           }
-          resolve();
+          resolve2();
         }).catch((error53) => reject(error53));
         if (frame.window) {
           frame.window[destroy]();
@@ -27245,7 +27245,7 @@ class BrowserFrameFactory {
           if (frame[listeners]) {
             frame[listeners].navigation = [];
           }
-          resolve();
+          resolve2();
         }).catch((error53) => reject(error53));
         if (frame.window) {
           frame.window[destroy]();
@@ -27351,15 +27351,15 @@ class BrowserFrameNavigator {
         const asyncTaskManager3 = frame[asyncTaskManager];
         const taskID2 = readyStateManager3.startTask();
         const code = targetURL.href.replace("javascript:", "");
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           frame.window.requestAnimationFrame(() => {
             const immediate = setImmediate(() => {
               asyncTaskManager3.endTask(taskID3);
-              resolve(null);
+              resolve2(null);
             });
             const taskID3 = asyncTaskManager3.startTask(() => () => {
               clearImmediate(immediate);
-              resolve(null);
+              resolve2(null);
             });
             frame.window[evaluateScript](code, { filename: frame.url });
           });
@@ -27430,7 +27430,7 @@ class BrowserFrameNavigator {
       if (frame.page.context.browser.settings.navigation.beforeContentCallback) {
         frame.page.context.browser.settings.navigation.beforeContentCallback(frame.window);
       }
-      await new Promise((resolve) => frame.page.mainFrame.window.requestAnimationFrame(resolve));
+      await new Promise((resolve2) => frame.page.mainFrame.window.requestAnimationFrame(resolve2));
       resolveNavigationListeners();
       return null;
     }
@@ -27499,16 +27499,16 @@ class BrowserFrameNavigator {
     if (frame.page.context.browser.settings.navigation.beforeContentCallback) {
       frame.page.context.browser.settings.navigation.beforeContentCallback(frame.window);
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       frame.window.requestAnimationFrame(() => {
         let immediate;
         const taskID2 = asyncTaskManager2.startTask(() => () => {
           clearImmediate(immediate);
-          resolve(null);
+          resolve2(null);
         });
         immediate = setImmediate(() => {
           asyncTaskManager2.endTask(taskID2);
-          resolve(null);
+          resolve2(null);
         });
         frame.content = responseText;
       });
@@ -27521,14 +27521,14 @@ class BrowserFrameNavigator {
     const history2 = frame[history];
     const historyItem = history2.items[history2.items.indexOf(history2.currentItem) - 1];
     if (!historyItem) {
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         frame.window.requestAnimationFrame(() => {
           const listeners2 = frame[listeners].navigation;
           frame[listeners].navigation = [];
           for (const listener of listeners2) {
             listener();
           }
-          resolve(null);
+          resolve2(null);
         });
       });
     }
@@ -27561,14 +27561,14 @@ class BrowserFrameNavigator {
     const history2 = frame[history];
     const historyItem = history2.items[history2.items.indexOf(history2.currentItem) + 1];
     if (!historyItem) {
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         frame.window.requestAnimationFrame(() => {
           const listeners2 = frame[listeners].navigation;
           frame[listeners].navigation = [];
           for (const listener of listeners2) {
             listener();
           }
-          resolve(null);
+          resolve2(null);
         });
       });
     }
@@ -27606,14 +27606,14 @@ class BrowserFrameNavigator {
     const toIndex = fromIndex + steps;
     const historyItem = history2.items[toIndex];
     if (!historyItem) {
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         frame.window.requestAnimationFrame(() => {
           const listeners2 = frame[listeners].navigation;
           frame[listeners].navigation = [];
           for (const listener of listeners2) {
             listener();
           }
-          resolve(null);
+          resolve2(null);
         });
       });
     }
@@ -30379,12 +30379,12 @@ class UnresolvedModule {
   async preload() {
     throw new this.#window.TypeError("Unresolved module. We should never end up here.");
   }
-  addResolveListener(resolve, reject) {
+  addResolveListener(resolve2, reject) {
     if (this.#error) {
       reject(this.#error);
       return;
     }
-    this.#hooks.push({ resolve, reject });
+    this.#hooks.push({ resolve: resolve2, reject });
   }
   resolve(error53) {
     if (error53) {
@@ -31150,8 +31150,8 @@ var init_ECMAScriptModule = __esm(() => {
           }
           return this.#exports;
         }
-        return new Promise((resolve) => {
-          this.#evaluateQueue.push(resolve);
+        return new Promise((resolve2) => {
+          this.#evaluateQueue.push(resolve2);
         });
       }
       if (this.#exports) {
@@ -31206,8 +31206,8 @@ var init_ECMAScriptModule = __esm(() => {
       });
       const evaluateQueue = this.#evaluateQueue;
       this.#evaluateQueue = null;
-      for (const resolve of evaluateQueue) {
-        resolve(exports);
+      for (const resolve2 of evaluateQueue) {
+        resolve2(exports);
       }
       return exports;
     }
@@ -31267,8 +31267,8 @@ class ModuleFactory {
     const cached2 = window3[modules][type2].get(absoluteURLString);
     if (cached2) {
       if (cached2 instanceof UnresolvedModule) {
-        await new Promise((resolve, reject) => {
-          cached2.addResolveListener(resolve, reject);
+        await new Promise((resolve2, reject) => {
+          cached2.addResolveListener(resolve2, reject);
         });
         return window3[modules][type2].get(absoluteURLString);
       }
@@ -31342,8 +31342,8 @@ class PreloadEntry {
   error = null;
   #callback = null;
   onResponseAvailable() {
-    return new Promise((resolve, reject) => {
-      this.#callback = { resolve, reject };
+    return new Promise((resolve2, reject) => {
+      this.#callback = { resolve: resolve2, reject };
     });
   }
   responseAvailable(error53, response) {
@@ -54743,14 +54743,14 @@ var init_BrowserFrame = __esm(() => {
       ]);
     }
     waitForNavigation() {
-      return new Promise((resolve) => this[listeners].navigation.push(resolve));
+      return new Promise((resolve2) => this[listeners].navigation.push(resolve2));
     }
     abort() {
       if (!this.childFrames.length) {
         return this[asyncTaskManager].abort();
       }
-      return new Promise((resolve, reject) => {
-        Promise.all(this.childFrames.map((frame) => frame.abort()).concat([this[asyncTaskManager].abort()])).then(() => resolve()).catch(reject);
+      return new Promise((resolve2, reject) => {
+        Promise.all(this.childFrames.map((frame) => frame.abort()).concat([this[asyncTaskManager].abort()])).then(() => resolve2()).catch(reject);
       });
     }
     evaluate(script) {
@@ -55205,12 +55205,12 @@ var init_BrowserContext = __esm(() => {
       await Promise.all(this.pages.map((page) => page.waitUntilComplete()));
     }
     abort() {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (!this.pages.length) {
-          resolve();
+          resolve2();
           return;
         }
-        Promise.all(this.pages.slice().map((page) => page.abort())).then(() => resolve()).catch((error53) => reject(error53));
+        Promise.all(this.pages.slice().map((page) => page.abort())).then(() => resolve2()).catch((error53) => reject(error53));
       });
     }
     newPage() {
@@ -55515,14 +55515,14 @@ var init_DetachedBrowserFrame = __esm(() => {
       ]);
     }
     waitForNavigation() {
-      return new Promise((resolve) => this[listeners].navigation.push(resolve));
+      return new Promise((resolve2) => this[listeners].navigation.push(resolve2));
     }
     abort() {
       if (!this.childFrames.length) {
         return this[asyncTaskManager].abort();
       }
-      return new Promise((resolve, reject) => {
-        Promise.all(this.childFrames.map((frame) => frame.abort()).concat([this[asyncTaskManager].abort()])).then(() => resolve()).catch(reject);
+      return new Promise((resolve2, reject) => {
+        Promise.all(this.childFrames.map((frame) => frame.abort()).concat([this[asyncTaskManager].abort()])).then(() => resolve2()).catch(reject);
       });
     }
     evaluate(script) {
@@ -55605,13 +55605,13 @@ class DetachedBrowserPage {
     this.mainFrame.url = url3;
   }
   close() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const context = this.context;
       BrowserPageUtility.closePage(this).then(() => {
         if (context.pages[0] === this) {
-          context.browser.close().then(resolve).catch(reject);
+          context.browser.close().then(resolve2).catch(reject);
         } else {
-          resolve();
+          resolve2();
         }
       }).catch(reject);
     });
@@ -55705,12 +55705,12 @@ var init_DetachedBrowserContext = __esm(() => {
       await Promise.all(this.pages.map((page) => page.waitUntilComplete()));
     }
     abort() {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (!this.pages.length) {
-          resolve();
+          resolve2();
           return;
         }
-        Promise.all(this.pages.slice().map((page) => page.abort())).then(() => resolve()).catch((error53) => reject(error53));
+        Promise.all(this.pages.slice().map((page) => page.abort())).then(() => resolve2()).catch((error53) => reject(error53));
       });
     }
     newPage() {
@@ -55765,12 +55765,12 @@ var init_DetachedBrowser = __esm(() => {
       await Promise.all(this.contexts.map((page) => page.waitUntilComplete()));
     }
     abort() {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (!this.contexts.length) {
-          resolve();
+          resolve2();
           return;
         }
-        Promise.all(this.contexts.slice().map((context) => context.abort())).then(() => resolve()).catch((error53) => reject(error53));
+        Promise.all(this.contexts.slice().map((context) => context.abort())).then(() => resolve2()).catch((error53) => reject(error53));
       });
     }
     newIncognitoContext() {
@@ -73049,7 +73049,7 @@ var require_DOMImplementation = __commonJS((exports, module) => {
         utils.InvalidCharacterError();
       return new DocumentType2(this.contextObject, qualifiedName, publicId2, systemId2);
     },
-    createDocument: function createDocument(namespace, qualifiedName, doctype) {
+    createDocument: function createDocument2(namespace, qualifiedName, doctype) {
       var d3 = new Document2(false, null);
       var e2;
       if (qualifiedName)
@@ -73931,14 +73931,14 @@ var require_turndown_cjs = __commonJS((exports, module) => {
       } else if (node.nodeType === 1) {
         replacement = replacementForNode.call(self2, node);
       }
-      return join3(output, replacement);
+      return join4(output, replacement);
     }, "");
   }
   function postProcess(output) {
     var self2 = this;
     this.rules.forEach(function(rule) {
       if (typeof rule.append === "function") {
-        output = join3(output, rule.append(self2.options));
+        output = join4(output, rule.append(self2.options));
       }
     });
     return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -73951,7 +73951,7 @@ var require_turndown_cjs = __commonJS((exports, module) => {
       content2 = content2.trim();
     return whitespace.leading + rule.replacement(content2, node, this.options) + whitespace.trailing;
   }
-  function join3(output, replacement) {
+  function join4(output, replacement) {
     var s1 = trimTrailingNewlines(output);
     var s2 = trimLeadingNewlines(replacement);
     var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -75578,7 +75578,7 @@ async function runMain(cmd, opts = {}) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.2.0",
+  version: "0.3.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -89969,6 +89969,12 @@ var PatchConflictResponseSchema = exports_external.object({
   code: exports_external.literal("precondition_failed"),
   current_updated_at: exports_external.string().datetime({ offset: true })
 });
+var SlugConflictResponseSchema = exports_external.object({
+  error: exports_external.string(),
+  code: exports_external.literal("slug_conflict"),
+  existing: SyncDocumentLiveSchema
+});
+var DeleteDocumentResponseSchema = SyncDocumentTombstoneSchema;
 
 // src/lib/api.ts
 class ApiError extends Error {
@@ -90043,9 +90049,18 @@ async function getDocument(args) {
   return parsed.data;
 }
 async function patchDocument(args) {
-  const { baseUrl, pat, id, expectedUpdatedAt, body, frontmatter, fetchImpl = fetch } = args;
-  if (body === undefined && frontmatter === undefined) {
-    throw new Error("patchDocument requires at least one of body or frontmatter");
+  const {
+    baseUrl,
+    pat,
+    id,
+    expectedUpdatedAt,
+    body,
+    frontmatter,
+    slug,
+    fetchImpl = fetch
+  } = args;
+  if (body === undefined && frontmatter === undefined && slug === undefined) {
+    throw new Error("patchDocument requires at least one of body, frontmatter, or slug");
   }
   const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/documents/${id}`;
   const payload = {};
@@ -90053,6 +90068,8 @@ async function patchDocument(args) {
     payload.body = body;
   if (frontmatter !== undefined)
     payload.frontmatter = frontmatter;
+  if (slug !== undefined)
+    payload.slug = slug;
   let res;
   try {
     res = await fetchImpl(url2, {
@@ -90082,11 +90099,25 @@ async function patchDocument(args) {
   }
   if (res.status === 409) {
     const json2 = await res.json();
-    const parsed = PatchConflictResponseSchema.safeParse(json2);
-    if (!parsed.success) {
-      throw new ApiError(409, "patch document 409 body did not match the expected shape");
+    const slugParse = SlugConflictResponseSchema.safeParse(json2);
+    if (slugParse.success) {
+      return {
+        ok: false,
+        code: 409,
+        reason: "slug_conflict",
+        existing: slugParse.data.existing
+      };
     }
-    return { ok: false, code: 409, currentUpdatedAt: parsed.data.current_updated_at };
+    const preconditionParse = PatchConflictResponseSchema.safeParse(json2);
+    if (preconditionParse.success) {
+      return {
+        ok: false,
+        code: 409,
+        reason: "precondition_failed",
+        currentUpdatedAt: preconditionParse.data.current_updated_at
+      };
+    }
+    throw new ApiError(409, "patch document 409 body did not match either precondition_failed or slug_conflict shape");
   }
   if (res.status === 401) {
     throw new ApiError(401, "Token was rejected by the server. Run `plinth login --workspace <slug>` to refresh.");
@@ -90143,11 +90174,135 @@ async function syncDocuments(args) {
   }
   return parsed.data;
 }
+async function createDocument(args) {
+  const {
+    baseUrl,
+    pat,
+    slug,
+    title,
+    body,
+    frontmatter,
+    artist_id,
+    project_id,
+    fetchImpl = fetch
+  } = args;
+  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/documents`;
+  const payload = { slug, title, body, frontmatter };
+  if (artist_id !== undefined)
+    payload.artist_id = artist_id;
+  if (project_id !== undefined)
+    payload.project_id = project_id;
+  let res;
+  try {
+    res = await fetchImpl(url2, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${pat}`,
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "network error";
+    throw new ApiError(0, `Could not reach ${url2}: ${msg}`);
+  }
+  if (res.status === 200 || res.status === 201) {
+    const json2 = await res.json();
+    const parsed = SyncDocumentResponseSchema.safeParse(json2);
+    if (!parsed.success) {
+      throw new ApiError(res.status, "create document response did not match the expected shape");
+    }
+    return { ok: true, doc: parsed.data };
+  }
+  if (res.status === 409) {
+    const json2 = await res.json();
+    const parsed = SlugConflictResponseSchema.safeParse(json2);
+    if (!parsed.success) {
+      throw new ApiError(409, "create document 409 body did not match slug_conflict shape");
+    }
+    return { ok: false, code: 409, existing: parsed.data.existing };
+  }
+  if (res.status === 401) {
+    throw new ApiError(401, "Token was rejected by the server. Run `plinth login --workspace <slug>` to refresh.");
+  }
+  if (res.status === 429) {
+    throw new ApiError(429, "Rate limited by the server. Wait a few seconds and retry.");
+  }
+  if (res.status === 400) {
+    let serverMsg = "bad request";
+    try {
+      const json2 = await res.json();
+      if (typeof json2.error === "string")
+        serverMsg = json2.error;
+    } catch {}
+    throw new ApiError(400, serverMsg);
+  }
+  throw new ApiError(res.status, `create document failed with HTTP ${res.status}`);
+}
+async function deleteDocument(args) {
+  const { baseUrl, pat, id, expectedUpdatedAt, fetchImpl = fetch } = args;
+  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/documents/${id}`;
+  let res;
+  try {
+    res = await fetchImpl(url2, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${pat}`,
+        Accept: "application/json",
+        "X-Plinth-Expected-Updated-At": expectedUpdatedAt
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "network error";
+    throw new ApiError(0, `Could not reach ${url2}: ${msg}`);
+  }
+  if (res.status === 200) {
+    const json2 = await res.json();
+    const parsed = DeleteDocumentResponseSchema.safeParse(json2);
+    if (!parsed.success) {
+      throw new ApiError(200, "delete document response did not match the expected tombstone shape");
+    }
+    return { ok: true, tombstone: parsed.data };
+  }
+  if (res.status === 404) {
+    return { ok: false, code: 404 };
+  }
+  if (res.status === 409) {
+    const json2 = await res.json();
+    const parsed = PatchConflictResponseSchema.safeParse(json2);
+    if (!parsed.success) {
+      throw new ApiError(409, "delete document 409 body did not match precondition_failed shape");
+    }
+    return {
+      ok: false,
+      code: 409,
+      currentUpdatedAt: parsed.data.current_updated_at
+    };
+  }
+  if (res.status === 401) {
+    throw new ApiError(401, "Token was rejected by the server. Run `plinth login --workspace <slug>` to refresh.");
+  }
+  if (res.status === 429) {
+    throw new ApiError(429, "Rate limited by the server. Wait a few seconds and retry.");
+  }
+  if (res.status === 400) {
+    let serverMsg = "bad request";
+    try {
+      const json2 = await res.json();
+      if (typeof json2.error === "string")
+        serverMsg = json2.error;
+    } catch {}
+    throw new ApiError(400, serverMsg);
+  }
+  throw new ApiError(res.status, `delete document failed with HTTP ${res.status}`);
+}
 
 // src/lib/pat.ts
-var PAT_REGEX = /^plnth_pat_[a-z2-7]{52}$/;
-function isPlausiblePat(raw) {
-  return PAT_REGEX.test(raw);
+var PAT_SEARCH_REGEX = /plnth_pat_[a-z2-7]{52}/;
+function extractPat(raw) {
+  const match = raw.match(PAT_SEARCH_REGEX);
+  return match ? match[0] : null;
 }
 function patLastFour(raw) {
   return raw.slice(-4);
@@ -90158,9 +90313,89 @@ var ETX = "\x03";
 var BACKSPACE = "\b";
 var DEL = "";
 var CSI_RE = /\x1b\[[\d;]*[A-Za-z~]/g;
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+var ENTER_CSI = /^\x1b\[13(?:;\d+)?u$/;
 function sanitizeInput(input) {
   return input.replace(CSI_RE, "");
 }
+var INITIAL_READER_STATE = {
+  buf: "",
+  pending: "",
+  inPaste: false
+};
+function matchEscape(s2) {
+  if (s2[0] !== "\x1B")
+    return { len: 0 };
+  if (s2.length < 2)
+    return null;
+  const c1 = s2[1];
+  if (c1 === "[") {
+    let i2 = 2;
+    while (i2 < s2.length) {
+      const code = s2.charCodeAt(i2);
+      const isDigit = code >= 48 && code <= 57;
+      const isSemicolon = s2[i2] === ";";
+      if (!isDigit && !isSemicolon)
+        break;
+      i2++;
+    }
+    if (i2 >= s2.length)
+      return null;
+    return { len: i2 + 1 };
+  }
+  if (c1 === "O") {
+    if (s2.length < 3)
+      return null;
+    return { len: 3 };
+  }
+  return { len: 2 };
+}
+function feedChunk(state, chunk) {
+  let { buf, pending, inPaste } = state;
+  pending = pending + chunk;
+  while (pending.length > 0) {
+    const ch = pending[0];
+    if (ch === ETX) {
+      return { kind: "abort" };
+    }
+    if (ch === "\x1B") {
+      const m2 = matchEscape(pending);
+      if (m2 === null) {
+        return { kind: "continue", state: { buf, pending, inPaste } };
+      }
+      const seq = pending.slice(0, m2.len);
+      pending = pending.slice(m2.len);
+      if (seq === PASTE_START) {
+        inPaste = true;
+        continue;
+      }
+      if (seq === PASTE_END) {
+        inPaste = false;
+        continue;
+      }
+      if (!inPaste && ENTER_CSI.test(seq)) {
+        return { kind: "submit", value: buf };
+      }
+      continue;
+    }
+    pending = pending.slice(1);
+    if (ch === "\r" || ch === `
+`) {
+      if (!inPaste)
+        return { kind: "submit", value: buf };
+      buf += ch;
+      continue;
+    }
+    if (ch === BACKSPACE || ch === DEL) {
+      if (!inPaste)
+        buf = buf.slice(0, -1);
+      continue;
+    }
+    buf += ch;
+  }
+  return { kind: "continue", state: { buf, pending, inPaste } };
+}
 function readSecret(promptText) {
   const stdin2 = process.stdin;
   if (stdin2.isTTY === true) {
@@ -90175,7 +90410,7 @@ function readTtySecret(stdin2, promptText) {
       stdin2.setRawMode(true);
     stdin2.resume();
     stdin2.setEncoding("utf8");
-    let buf = "";
+    let state = INITIAL_READER_STATE;
     const cleanup = () => {
       stdin2.removeListener("data", onData);
       stdin2.removeListener("error", onError);
@@ -90183,37 +90418,27 @@ function readTtySecret(stdin2, promptText) {
         stdin2.setRawMode(false);
       stdin2.pause();
     };
-    const finish = (raw) => {
-      cleanup();
-      process.stdout.write(`
+    const onData = (chunk) => {
+      const result = feedChunk(state, chunk);
+      if (result.kind === "submit") {
+        cleanup();
+        process.stdout.write(`
 `);
-      resolve(sanitizeInput(raw));
+        resolve(result.value);
+        return;
+      }
+      if (result.kind === "abort") {
+        cleanup();
+        process.stdout.write(`
+`);
+        process.exit(130);
+      }
+      state = result.state;
     };
     const onError = (err) => {
       cleanup();
       reject(err);
     };
-    const onData = (chunk) => {
-      for (const ch of chunk) {
-        if (ch === ETX) {
-          if (typeof stdin2.setRawMode === "function")
-            stdin2.setRawMode(false);
-          process.stdout.write(`
-`);
-          process.exit(130);
-        }
-        if (ch === "\r" || ch === `
-`) {
-          finish(buf);
-          return;
-        }
-        if (ch === BACKSPACE || ch === DEL) {
-          buf = buf.slice(0, -1);
-          continue;
-        }
-        buf += ch;
-      }
-    };
     stdin2.on("data", onData);
     stdin2.on("error", onError);
   });
@@ -90393,8 +90618,9 @@ async function runLogin(workspaceSlug, apiBaseUrl, deps = {}) {
 
 `);
   openFn(settingsUrl);
-  const pat = (await readFn("Paste your token here (input hidden): ")).trim();
-  if (!isPlausiblePat(pat)) {
+  const raw = await readFn("Paste your token here (nothing will appear — paste, then press Enter): ");
+  const pat = extractPat(raw);
+  if (pat === null) {
     err.write(`Error: that does not look like a Plinth personal access token.
 `);
     return 1;
@@ -90463,6 +90689,94 @@ var loginCommand = defineCommand({
   }
 });
 
+// src/commands/start.ts
+import { statSync as statSync4 } from "node:fs";
+
+// src/lib/mirror.ts
+import {
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2, join as join2, resolve, sep as sep2 } from "node:path";
+var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+class MirrorPathError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MirrorPathError";
+  }
+}
+function assertSlug(label, slug) {
+  if (!SLUG_RE.test(slug) || slug.length > 200) {
+    throw new MirrorPathError(`Invalid ${label}: ${JSON.stringify(slug)}`);
+  }
+}
+function assertNotSymlink(path) {
+  try {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink()) {
+      throw new MirrorPathError(`Refusing to follow symlink at ${path}. ` + `Remove it and re-run plinth sync.`);
+    }
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return;
+    if (err instanceof MirrorPathError)
+      throw err;
+    throw err;
+  }
+}
+function workspaceMirrorPath(workspaceSlug) {
+  assertSlug("workspace slug", workspaceSlug);
+  const root = mirrorRoot();
+  const ws = join2(root, workspaceSlug);
+  const resolved = resolve(ws);
+  if (resolved !== resolve(root, workspaceSlug)) {
+    throw new MirrorPathError(`Resolved workspace path escapes mirror root`);
+  }
+  assertNotSymlink(resolved);
+  return resolved;
+}
+function entityFilePath(workspaceSlug, entityType, entitySlug, ext = "md") {
+  assertSlug("entity type", entityType);
+  assertSlug("entity slug", entitySlug);
+  const ws = workspaceMirrorPath(workspaceSlug);
+  const target = join2(ws, entityType, `${entitySlug}.${ext}`);
+  const resolved = resolve(target);
+  const prefix = ws.endsWith(sep2) ? ws : ws + sep2;
+  if (!resolved.startsWith(prefix)) {
+    throw new MirrorPathError(`Resolved entity path escapes workspace folder`);
+  }
+  return resolved;
+}
+function writeMirrorFile(workspaceSlug, entityType, entitySlug, content, ext = "md") {
+  const target = entityFilePath(workspaceSlug, entityType, entitySlug, ext);
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  mkdirSync2(dirname2(target), { recursive: true, mode: 448 });
+  writeFileSync2(tmp, content, { mode: 384 });
+  try {
+    renameSync2(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync2(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function deleteMirrorFile(workspaceSlug, entityType, entitySlug, ext = "md") {
+  const target = entityFilePath(workspaceSlug, entityType, entitySlug, ext);
+  try {
+    unlinkSync2(target);
+    return true;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return false;
+    throw err;
+  }
+}
+
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -93906,118 +94220,53 @@ class Output {
   }
 }
 
+// src/lib/per-id-mutex.ts
+class PerIdMutex {
+  chains = new Map;
+  async run(key, fn) {
+    const prior = this.chains.get(key) ?? Promise.resolve();
+    const next = prior.then(fn, fn);
+    this.chains.set(key, next);
+    const cleanup = () => {
+      if (this.chains.get(key) === next) {
+        this.chains.delete(key);
+      }
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  }
+  size() {
+    return this.chains.size;
+  }
+}
+
 // src/lib/push.ts
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync as readFileSync3 } from "node:fs";
-import { relative } from "node:path";
+import { readFileSync as readFileSync3, statSync } from "node:fs";
+import { basename, relative } from "node:path";
 
 // src/lib/conflicts.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
 function conflictsRoot(workspaceSlug) {
-  return join2(plinthHome(), "_conflicts", workspaceSlug);
+  return join3(plinthHome(), "_conflicts", workspaceSlug);
 }
 function conflictFilePath(args) {
   const { workspaceSlug, entityType, entitySlug, timestamp } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  return join2(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.md`);
+  return join3(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.md`);
 }
 function stashConflict(args) {
   const target = conflictFilePath(args);
-  mkdirSync2(dirname2(target), { recursive: true, mode: 448 });
-  writeFileSync2(target, args.contents, { mode: 384 });
+  mkdirSync3(dirname3(target), { recursive: true, mode: 448 });
+  writeFileSync3(target, args.contents, { mode: 384 });
   return target;
 }
 
 // src/lib/push.ts
 init_markdown();
 
-// src/lib/mirror.ts
-import {
-  lstatSync,
-  mkdirSync as mkdirSync3,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "node:fs";
-import { dirname as dirname3, join as join3, resolve, sep as sep2 } from "node:path";
-var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
-
-class MirrorPathError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MirrorPathError";
-  }
-}
-function assertSlug(label2, slug) {
-  if (!SLUG_RE.test(slug) || slug.length > 200) {
-    throw new MirrorPathError(`Invalid ${label2}: ${JSON.stringify(slug)}`);
-  }
-}
-function assertNotSymlink(path) {
-  try {
-    const stat = lstatSync(path);
-    if (stat.isSymbolicLink()) {
-      throw new MirrorPathError(`Refusing to follow symlink at ${path}. ` + `Remove it and re-run plinth sync.`);
-    }
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return;
-    if (err instanceof MirrorPathError)
-      throw err;
-    throw err;
-  }
-}
-function workspaceMirrorPath(workspaceSlug) {
-  assertSlug("workspace slug", workspaceSlug);
-  const root2 = mirrorRoot();
-  const ws = join3(root2, workspaceSlug);
-  const resolved = resolve(ws);
-  if (resolved !== resolve(root2, workspaceSlug)) {
-    throw new MirrorPathError(`Resolved workspace path escapes mirror root`);
-  }
-  assertNotSymlink(resolved);
-  return resolved;
-}
-function entityFilePath(workspaceSlug, entityType, entitySlug, ext = "md") {
-  assertSlug("entity type", entityType);
-  assertSlug("entity slug", entitySlug);
-  const ws = workspaceMirrorPath(workspaceSlug);
-  const target2 = join3(ws, entityType, `${entitySlug}.${ext}`);
-  const resolved = resolve(target2);
-  const prefix2 = ws.endsWith(sep2) ? ws : ws + sep2;
-  if (!resolved.startsWith(prefix2)) {
-    throw new MirrorPathError(`Resolved entity path escapes workspace folder`);
-  }
-  return resolved;
-}
-function writeMirrorFile(workspaceSlug, entityType, entitySlug, content2, ext = "md") {
-  const target2 = entityFilePath(workspaceSlug, entityType, entitySlug, ext);
-  const tmp = `${target2}.${process.pid}.${Date.now()}.tmp`;
-  mkdirSync3(dirname3(target2), { recursive: true, mode: 448 });
-  writeFileSync3(tmp, content2, { mode: 384 });
-  try {
-    renameSync2(tmp, target2);
-  } catch (err) {
-    try {
-      unlinkSync2(tmp);
-    } catch {}
-    throw err;
-  }
-}
-function deleteMirrorFile(workspaceSlug, entityType, entitySlug, ext = "md") {
-  const target2 = entityFilePath(workspaceSlug, entityType, entitySlug, ext);
-  try {
-    unlinkSync2(target2);
-    return true;
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return false;
-    throw err;
-  }
-}
-
 // src/lib/state.ts
 import {
   mkdirSync as mkdirSync4,
@@ -94033,7 +94282,8 @@ var StateEntrySchema = exports_external.object({
   updated_at: exports_external.string().datetime({ offset: true }),
   revision: exports_external.number().int().nonnegative(),
   body_hash: exports_external.string().min(1),
-  frontmatter_hash: exports_external.string().min(1)
+  frontmatter_hash: exports_external.string().min(1),
+  inode: exports_external.number().int().nonnegative().optional()
 });
 var WorkspaceStateSchema = exports_external.object({
   version: exports_external.literal(1),
@@ -94086,6 +94336,9 @@ function upsertEntry(state2, entry2) {
   };
   return { state: next, changed: true };
 }
+function getEntry(state2, id2) {
+  return state2.documents[id2];
+}
 function getEntryBySlug(state2, slug) {
   for (const entry2 of Object.values(state2.documents)) {
     if (entry2.slug === slug)
@@ -94094,7 +94347,7 @@ function getEntryBySlug(state2, slug) {
   return;
 }
 function entriesEqual(a2, b3) {
-  return a2.id === b3.id && a2.slug === b3.slug && a2.updated_at === b3.updated_at && a2.revision === b3.revision && a2.body_hash === b3.body_hash && a2.frontmatter_hash === b3.frontmatter_hash;
+  return a2.id === b3.id && a2.slug === b3.slug && a2.updated_at === b3.updated_at && a2.revision === b3.revision && a2.body_hash === b3.body_hash && a2.frontmatter_hash === b3.frontmatter_hash && a2.inode === b3.inode;
 }
 
 // src/lib/push.ts
@@ -94151,30 +94404,120 @@ function classifyMirrorPath(args) {
   }
   return { entityType, entitySlug };
 }
+function resolveTitle(parsedBody, fm, slug) {
+  const lines = parsedBody.split(`
+`);
+  for (const line of lines) {
+    const m3 = line.match(/^#\s+(.+?)\s*$/);
+    if (m3 && m3[1]?.length)
+      return m3[1];
+  }
+  if (typeof fm.title === "string" && fm.title.length > 0)
+    return fm.title;
+  return humaniseSlug(slug);
+}
+function humaniseSlug(slug) {
+  return slug.split("-").filter((part) => part.length > 0).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+function safeInode(absolutePath) {
+  try {
+    return statSync(absolutePath).ino;
+  } catch {
+    return;
+  }
+}
+function persistEntry(state2, entry2) {
+  const { state: nextState, changed } = upsertEntry(state2, entry2);
+  if (changed)
+    writeState(nextState);
+  return nextState;
+}
+function dropEntry(state2, id2) {
+  if (!(id2 in state2.documents))
+    return state2;
+  const nextDocs = { ...state2.documents };
+  delete nextDocs[id2];
+  const next = { ...state2, documents: nextDocs };
+  writeState(next);
+  return next;
+}
+async function pullAndWriteMirror(args) {
+  const cloud = await getDocument({
+    baseUrl: args.baseUrl,
+    pat: args.pat,
+    id: args.id,
+    fetchImpl: args.fetchImpl
+  });
+  const { serialiseDocument: serialiseDocument2 } = await Promise.resolve().then(() => (init_markdown(), exports_markdown));
+  writeMirrorFile(args.workspaceSlug, args.entityType, cloud.slug, serialiseDocument2(cloud));
+  const mirrorPath = entityFilePath(args.workspaceSlug, args.entityType, cloud.slug);
+  const mirrorRaw = readFileSync3(mirrorPath, "utf8");
+  const mirrorParsed = import_gray_matter2.default(mirrorRaw);
+  const refreshed = {
+    id: cloud.id,
+    slug: cloud.slug,
+    updated_at: cloud.updated_at,
+    revision: cloud.revision,
+    body_hash: stableHash(mirrorParsed.content),
+    frontmatter_hash: stableHash(userFrontmatter(mirrorParsed.data ?? {})),
+    inode: safeInode(mirrorPath)
+  };
+  return persistEntry(args.state, refreshed);
+}
 async function pushFile(args) {
-  const { workspaceSlug, baseUrl, pat, absolutePath, entityType, state: state2, exists, deps } = args;
+  const {
+    workspaceSlug,
+    baseUrl,
+    pat,
+    absolutePath,
+    entityType,
+    state: state2,
+    exists,
+    unlinkContext,
+    deps
+  } = args;
   const fetchImpl = deps?.fetchImpl;
   const now = deps?.now ?? (() => new Date);
+  const mutex = deps?.mutex ?? new PerIdMutex;
   if (entityType !== "documents") {
     return {
-      outcome: { kind: "ignored", absolutePath, reason: `entity type ${entityType} not yet pushed` },
+      outcome: {
+        kind: "ignored",
+        absolutePath,
+        reason: `entity type ${entityType} not yet pushed`
+      },
       state: state2
     };
   }
   if (!exists) {
-    if (!existsSync(absolutePath)) {
-      return {
-        outcome: { kind: "deferred_delete", absolutePath },
-        state: state2
-      };
-    }
+    return runPushDelete({
+      workspaceSlug,
+      entityType,
+      baseUrl,
+      pat,
+      absolutePath,
+      state: state2,
+      unlinkContext,
+      mutex,
+      fetchImpl
+    });
   }
   let raw;
   try {
     raw = readFileSync3(absolutePath, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
-      return { outcome: { kind: "deferred_delete", absolutePath }, state: state2 };
+      return runPushDelete({
+        workspaceSlug,
+        entityType,
+        baseUrl,
+        pat,
+        absolutePath,
+        state: state2,
+        unlinkContext: null,
+        mutex,
+        fetchImpl
+      });
     }
     throw err;
   }
@@ -94189,100 +94532,404 @@ async function pushFile(args) {
   }
   const fm = parsed.data ?? {};
   const slugFromFm = typeof fm.slug === "string" && fm.slug.length > 0 ? fm.slug : null;
-  if (!slugFromFm) {
+  const slugFromPath = basename(absolutePath, ".md");
+  const slug = slugFromFm ?? slugFromPath;
+  if (slug.length === 0) {
     return {
-      outcome: { kind: "deferred_new_file", absolutePath },
+      outcome: { kind: "ignored", absolutePath, reason: "empty slug" },
       state: state2
     };
   }
-  const stateEntry = getEntryBySlug(state2, slugFromFm);
+  const stateEntry = getEntryBySlug(state2, slug);
   if (!stateEntry) {
-    return {
-      outcome: { kind: "deferred_new_file", absolutePath },
-      state: state2
-    };
+    return runPushCreate({
+      workspaceSlug,
+      entityType,
+      baseUrl,
+      pat,
+      absolutePath,
+      slug,
+      raw,
+      parsed,
+      state: state2,
+      mutex,
+      fetchImpl,
+      now
+    });
   }
-  const userFm = userFrontmatter(fm);
-  const bodyMarkdown = parsed.content;
-  const newBodyHash = stableHash(bodyMarkdown);
-  const newFrontmatterHash = stableHash(userFm);
-  const bodyChanged = newBodyHash !== stateEntry.body_hash;
-  const frontmatterChanged = newFrontmatterHash !== stateEntry.frontmatter_hash;
-  if (!bodyChanged && !frontmatterChanged) {
-    return { outcome: { kind: "noop", entitySlug: slugFromFm }, state: state2 };
-  }
-  const html = bodyChanged ? markdownToHtml(bodyMarkdown) : undefined;
-  const patchResult = await patchDocument({
+  return runPushUpsert({
+    workspaceSlug,
+    entityType,
     baseUrl,
     pat,
-    id: stateEntry.id,
-    expectedUpdatedAt: stateEntry.updated_at,
-    body: html,
-    frontmatter: frontmatterChanged ? userFm : undefined,
-    fetchImpl
+    absolutePath,
+    raw,
+    parsed,
+    stateEntry,
+    state: state2,
+    mutex,
+    fetchImpl,
+    now
   });
-  if (patchResult.ok) {
-    const updated = {
-      id: patchResult.doc.id,
-      slug: patchResult.doc.slug,
-      updated_at: patchResult.doc.updated_at,
-      revision: patchResult.doc.revision,
-      body_hash: newBodyHash,
-      frontmatter_hash: newFrontmatterHash
+}
+async function runPushUpsert(args) {
+  return args.mutex.run(args.stateEntry.id, async () => {
+    const fm = args.parsed.data ?? {};
+    const userFm = userFrontmatter(fm);
+    const bodyMarkdown = args.parsed.content;
+    const newBodyHash = stableHash(bodyMarkdown);
+    const newFrontmatterHash = stableHash(userFm);
+    const liveEntry = getEntry(args.state, args.stateEntry.id) ?? args.stateEntry;
+    const bodyChanged = newBodyHash !== liveEntry.body_hash;
+    const frontmatterChanged = newFrontmatterHash !== liveEntry.frontmatter_hash;
+    if (!bodyChanged && !frontmatterChanged) {
+      return { outcome: { kind: "noop", entitySlug: liveEntry.slug }, state: args.state };
+    }
+    const html = bodyChanged ? markdownToHtml(bodyMarkdown) : undefined;
+    const patchResult = await patchDocument({
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      id: liveEntry.id,
+      expectedUpdatedAt: liveEntry.updated_at,
+      body: html,
+      frontmatter: frontmatterChanged ? userFm : undefined,
+      fetchImpl: args.fetchImpl
+    });
+    if (patchResult.ok) {
+      const updated = {
+        id: patchResult.doc.id,
+        slug: patchResult.doc.slug,
+        updated_at: patchResult.doc.updated_at,
+        revision: patchResult.doc.revision,
+        body_hash: newBodyHash,
+        frontmatter_hash: newFrontmatterHash,
+        inode: safeInode(args.absolutePath)
+      };
+      const nextState2 = persistEntry(args.state, updated);
+      return {
+        outcome: { kind: "pushed", entitySlug: updated.slug },
+        state: nextState2
+      };
+    }
+    if (patchResult.code === 404) {
+      return {
+        outcome: { kind: "not_found", entitySlug: liveEntry.slug },
+        state: args.state
+      };
+    }
+    if (patchResult.reason === "slug_conflict") {
+      throw new Error("patchDocument returned slug_conflict for a body+frontmatter PATCH (no slug sent)");
+    }
+    const stashPath = stashConflict({
+      workspaceSlug: args.workspaceSlug,
+      entityType: args.entityType,
+      entitySlug: liveEntry.slug,
+      timestamp: args.now(),
+      contents: args.raw
+    });
+    const nextState = await pullAndWriteMirror({
+      workspaceSlug: args.workspaceSlug,
+      entityType: args.entityType,
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      id: liveEntry.id,
+      state: args.state,
+      fetchImpl: args.fetchImpl
+    });
+    return {
+      outcome: { kind: "conflict", entitySlug: liveEntry.slug, stashPath },
+      state: nextState
     };
-    const { state: nextState2, changed } = upsertEntry(state2, updated);
-    if (changed)
-      writeState(nextState2);
+  });
+}
+async function runPushCreate(args) {
+  const key = `create:${args.entityType}:${args.slug}`;
+  return args.mutex.run(key, async () => {
+    const inLock = getEntryBySlug(args.state, args.slug);
+    if (inLock) {
+      return runPushUpsert({
+        workspaceSlug: args.workspaceSlug,
+        entityType: args.entityType,
+        baseUrl: args.baseUrl,
+        pat: args.pat,
+        absolutePath: args.absolutePath,
+        raw: args.raw,
+        parsed: args.parsed,
+        stateEntry: inLock,
+        state: args.state,
+        mutex: args.mutex,
+        fetchImpl: args.fetchImpl,
+        now: args.now
+      });
+    }
+    const fm = args.parsed.data ?? {};
+    const userFm = userFrontmatter(fm);
+    if ("title" in userFm)
+      delete userFm.title;
+    const title = resolveTitle(args.parsed.content, fm, args.slug);
+    const htmlBody = markdownToHtml(args.parsed.content);
+    const artistId = isOptionalUuid(fm.artist_id);
+    const projectId = isOptionalUuid(fm.project_id);
+    const createResult = await createDocument({
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      slug: args.slug,
+      title,
+      body: htmlBody,
+      frontmatter: userFm,
+      artist_id: artistId,
+      project_id: projectId,
+      fetchImpl: args.fetchImpl
+    });
+    if (createResult.ok) {
+      const doc2 = createResult.doc;
+      const nextState2 = persistEntry(args.state, {
+        id: doc2.id,
+        slug: doc2.slug,
+        updated_at: doc2.updated_at,
+        revision: doc2.revision,
+        body_hash: stableHash(args.parsed.content),
+        frontmatter_hash: stableHash(userFm),
+        inode: safeInode(args.absolutePath)
+      });
+      return {
+        outcome: { kind: "created", entitySlug: doc2.slug },
+        state: nextState2
+      };
+    }
+    const stashPath = stashConflict({
+      workspaceSlug: args.workspaceSlug,
+      entityType: args.entityType,
+      entitySlug: args.slug,
+      timestamp: args.now(),
+      contents: args.raw
+    });
+    const nextState = await pullAndWriteMirror({
+      workspaceSlug: args.workspaceSlug,
+      entityType: args.entityType,
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      id: createResult.existing.id,
+      state: args.state,
+      fetchImpl: args.fetchImpl
+    });
     return {
-      outcome: { kind: "pushed", entitySlug: slugFromFm },
-      state: nextState2
+      outcome: {
+        kind: "create_slug_conflict",
+        entitySlug: args.slug,
+        stashPath
+      },
+      state: nextState
     };
+  });
+}
+async function runPushDelete(args) {
+  let id2;
+  let slug;
+  let expectedUpdatedAt;
+  if (args.unlinkContext) {
+    id2 = args.unlinkContext.id;
+    slug = args.unlinkContext.slug;
+    expectedUpdatedAt = args.unlinkContext.updated_at;
+  } else {
+    const slugFromPath = basename(args.absolutePath, ".md");
+    const entry2 = getEntryBySlug(args.state, slugFromPath);
+    if (entry2) {
+      id2 = entry2.id;
+      slug = entry2.slug;
+      expectedUpdatedAt = entry2.updated_at;
+    }
   }
-  if (patchResult.code === 404) {
+  if (!id2 || !slug || !expectedUpdatedAt) {
     return {
-      outcome: { kind: "not_found", entitySlug: slugFromFm },
-      state: state2
+      outcome: {
+        kind: "ignored",
+        absolutePath: args.absolutePath,
+        reason: "untracked file — no cloud row to delete"
+      },
+      state: args.state
     };
   }
-  const stashPath = stashConflict({
-    workspaceSlug,
-    entityType,
-    entitySlug: slugFromFm,
-    timestamp: now(),
-    contents: raw
+  return args.mutex.run(id2, async () => {
+    const live = getEntry(args.state, id2) ?? null;
+    const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const result2 = await deleteDocument({
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      id: id2,
+      expectedUpdatedAt: effectiveExpected,
+      fetchImpl: args.fetchImpl
+    });
+    if (result2.ok) {
+      const nextState2 = dropEntry(args.state, id2);
+      return {
+        outcome: { kind: "deleted", entitySlug: slug },
+        state: nextState2
+      };
+    }
+    if (result2.code === 404) {
+      const nextState2 = dropEntry(args.state, id2);
+      return {
+        outcome: { kind: "deleted", entitySlug: slug },
+        state: nextState2
+      };
+    }
+    const nextState = await pullAndWriteMirror({
+      workspaceSlug: args.workspaceSlug,
+      entityType: args.entityType,
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      id: id2,
+      state: args.state,
+      fetchImpl: args.fetchImpl
+    });
+    return {
+      outcome: { kind: "conflict", entitySlug: slug, stashPath: "" },
+      state: nextState
+    };
   });
-  const cloud = await getDocument({
+}
+async function pushRename(args) {
+  const {
+    workspaceSlug,
     baseUrl,
     pat,
-    id: stateEntry.id,
-    fetchImpl
+    fromPath,
+    toPath,
+    id: id2,
+    expectedUpdatedAt,
+    fromSlug,
+    state: state2,
+    deps
+  } = args;
+  const fetchImpl = deps?.fetchImpl;
+  const now = deps?.now ?? (() => new Date);
+  const mutex = deps?.mutex ?? new PerIdMutex;
+  const entityType = "documents";
+  const toSlug = basename(toPath, ".md");
+  return mutex.run(id2, async () => {
+    const live = getEntry(state2, id2);
+    const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const patchResult = await patchDocument({
+      baseUrl,
+      pat,
+      id: id2,
+      expectedUpdatedAt: effectiveExpected,
+      slug: toSlug,
+      fetchImpl
+    });
+    if (patchResult.ok) {
+      const doc2 = patchResult.doc;
+      const prior = live ?? null;
+      const updated = {
+        id: doc2.id,
+        slug: doc2.slug,
+        updated_at: doc2.updated_at,
+        revision: doc2.revision,
+        body_hash: prior?.body_hash ?? "",
+        frontmatter_hash: prior?.frontmatter_hash ?? "",
+        inode: safeInode(toPath)
+      };
+      if (!updated.body_hash || !updated.frontmatter_hash) {
+        try {
+          const mirrorRaw = readFileSync3(toPath, "utf8");
+          const mirrorParsed = import_gray_matter2.default(mirrorRaw);
+          updated.body_hash = stableHash(mirrorParsed.content);
+          updated.frontmatter_hash = stableHash(userFrontmatter(mirrorParsed.data ?? {}));
+        } catch {}
+      }
+      const nextState2 = persistEntry(state2, updated);
+      return {
+        outcome: { kind: "renamed", fromSlug, toSlug: doc2.slug },
+        state: nextState2
+      };
+    }
+    if (patchResult.code === 404) {
+      return {
+        outcome: { kind: "not_found", entitySlug: fromSlug },
+        state: state2
+      };
+    }
+    if (patchResult.reason === "slug_conflict") {
+      let contents2 = "";
+      try {
+        contents2 = readFileSync3(toPath, "utf8");
+      } catch {}
+      const stashPath2 = stashConflict({
+        workspaceSlug,
+        entityType,
+        entitySlug: fromSlug,
+        timestamp: now(),
+        contents: contents2
+      });
+      const afterColliding = await pullAndWriteMirror({
+        workspaceSlug,
+        entityType,
+        baseUrl,
+        pat,
+        id: patchResult.existing.id,
+        state: state2,
+        fetchImpl
+      });
+      const finalState = await pullAndWriteMirror({
+        workspaceSlug,
+        entityType,
+        baseUrl,
+        pat,
+        id: id2,
+        state: afterColliding,
+        fetchImpl
+      });
+      return {
+        outcome: {
+          kind: "rename_slug_conflict",
+          fromSlug,
+          toSlug,
+          stashPath: stashPath2
+        },
+        state: finalState
+      };
+    }
+    let contents = "";
+    try {
+      contents = readFileSync3(toPath, "utf8");
+    } catch {}
+    const stashPath = stashConflict({
+      workspaceSlug,
+      entityType,
+      entitySlug: fromSlug,
+      timestamp: now(),
+      contents
+    });
+    const nextState = await pullAndWriteMirror({
+      workspaceSlug,
+      entityType,
+      baseUrl,
+      pat,
+      id: id2,
+      state: state2,
+      fetchImpl
+    });
+    return {
+      outcome: { kind: "conflict", entitySlug: fromSlug, stashPath },
+      state: nextState
+    };
   });
-  const { serialiseDocument: serialiseDocument2 } = await Promise.resolve().then(() => (init_markdown(), exports_markdown));
-  writeMirrorFile(workspaceSlug, entityType, cloud.slug, serialiseDocument2(cloud));
-  const refreshed = {
-    id: cloud.id,
-    slug: cloud.slug,
-    updated_at: cloud.updated_at,
-    revision: cloud.revision,
-    body_hash: "",
-    frontmatter_hash: ""
-  };
-  const mirrorPath = entityFilePath(workspaceSlug, entityType, cloud.slug);
-  const mirrorRaw = readFileSync3(mirrorPath, "utf8");
-  const mirrorParsed = import_gray_matter2.default(mirrorRaw);
-  refreshed.body_hash = stableHash(mirrorParsed.content);
-  refreshed.frontmatter_hash = stableHash(userFrontmatter(mirrorParsed.data ?? {}));
-  const { state: nextState } = upsertEntry(state2, refreshed);
-  writeState(nextState);
-  return {
-    outcome: { kind: "conflict", entitySlug: slugFromFm, stashPath },
-    state: nextState
-  };
+}
+function isOptionalUuid(value2) {
+  if (value2 === null)
+    return null;
+  if (typeof value2 !== "string")
+    return;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value2)) {
+    return value2;
+  }
+  return;
 }
 
 // src/commands/sync.ts
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync2, readdirSync } from "node:fs";
+import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "node:fs";
 init_markdown();
 var ENTITY_TYPE = "documents";
 function hasExistingContent(workspacePath) {
@@ -94404,13 +95051,20 @@ function applyDocument(workspaceSlug, doc2, state2) {
   writeMirrorFile(workspaceSlug, ENTITY_TYPE, doc2.slug, content2);
   const parsed = import_gray_matter3.default(content2);
   const userFm = userFrontmatter(parsed.data ?? {});
+  let inode;
+  try {
+    inode = statSync2(entityFilePath(workspaceSlug, ENTITY_TYPE, doc2.slug)).ino;
+  } catch {
+    inode = undefined;
+  }
   const { state: nextState } = upsertEntry(state2, {
     id: doc2.id,
     slug: doc2.slug,
     updated_at: doc2.updated_at,
     revision: doc2.revision,
     body_hash: stableHash(parsed.content),
-    frontmatter_hash: stableHash(userFm)
+    frontmatter_hash: stableHash(userFm),
+    inode
   });
   return nextState;
 }
@@ -94608,10 +95262,10 @@ class ReaddirpStream extends Readable {
   }
   async _formatEntry(dirent, path) {
     let entry2;
-    const basename = this._isDirent ? dirent.name : dirent;
+    const basename2 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path, basename));
-      entry2 = { path: prelative(this._root, fullPath), fullPath, basename };
+      const fullPath = presolve(pjoin(path, basename2));
+      entry2 = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
       entry2[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -95138,9 +95792,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path);
-    const basename2 = sp.basename(path);
+    const basename3 = sp.basename(path);
     const parent2 = this.fsw._getWatchedDir(directory);
-    parent2.add(basename2);
+    parent2.add(basename3);
     const absolutePath = sp.resolve(path);
     const options3 = {
       persistent: opts.persistent
@@ -95150,7 +95804,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options3.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
+      options3.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path, absolutePath, options3, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -95169,10 +95823,10 @@ class NodeFsHandler {
       return;
     }
     const dirname6 = sp.dirname(file2);
-    const basename2 = sp.basename(file2);
+    const basename3 = sp.basename(file2);
     const parent2 = this.fsw._getWatchedDir(dirname6);
     let prevStats = stats;
-    if (parent2.has(basename2))
+    if (parent2.has(basename3))
       return;
     const listener = async (path, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -95197,9 +95851,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error53) {
-          this.fsw._remove(dirname6, basename2);
+          this.fsw._remove(dirname6, basename3);
         }
-      } else if (parent2.has(basename2)) {
+      } else if (parent2.has(basename3)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -96053,7 +96707,121 @@ function watch(paths, options3 = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/lib/watcher.ts
+import { statSync as statSync3 } from "node:fs";
 import { sep as sep3 } from "node:path";
+
+// src/lib/rename-classifier.ts
+import { basename as basename4, dirname as dirname7 } from "node:path";
+
+class RenameClassifier {
+  buffer = new Map;
+  emit;
+  opts;
+  constructor(emit, opts) {
+    this.emit = emit;
+    this.opts = opts;
+  }
+  onAdd(absolutePath) {
+    this.handleArrival(absolutePath);
+  }
+  onChange(absolutePath) {
+    this.handleArrival(absolutePath);
+  }
+  handleArrival(absolutePath) {
+    let inode;
+    try {
+      inode = this.opts.statSync(absolutePath).ino;
+    } catch {
+      this.emit({ kind: "upsert", absolutePath });
+      return;
+    }
+    const buffered2 = this.buffer.get(inode);
+    if (buffered2) {
+      clearTimeout(buffered2.timer);
+      this.buffer.delete(inode);
+      this.emit({
+        kind: "renamed",
+        fromPath: buffered2.absolutePath,
+        toPath: absolutePath,
+        id: buffered2.stateEntry.id,
+        expectedUpdatedAt: buffered2.stateEntry.updated_at,
+        fromSlug: buffered2.stateEntry.slug
+      });
+      return;
+    }
+    this.emit({ kind: "upsert", absolutePath });
+  }
+  onUnlink(absolutePath) {
+    const slug = slugFromPath(absolutePath);
+    if (slug === null) {
+      this.emit({
+        kind: "unlink",
+        absolutePath,
+        stateEntry: null,
+        renameFallback: false
+      });
+      return;
+    }
+    const entry2 = this.opts.getStateEntry(slug);
+    if (!entry2 || entry2.inode === undefined) {
+      this.emit({
+        kind: "unlink",
+        absolutePath,
+        stateEntry: entry2,
+        renameFallback: true
+      });
+      return;
+    }
+    const inode = entry2.inode;
+    const existing = this.buffer.get(inode);
+    if (existing)
+      clearTimeout(existing.timer);
+    const timer = setTimeout(() => {
+      this.buffer.delete(inode);
+      this.opts.onWindowExpired?.(inode);
+      this.emit({
+        kind: "unlink",
+        absolutePath,
+        stateEntry: entry2,
+        renameFallback: false
+      });
+    }, this.opts.pairingWindowMs);
+    this.buffer.set(inode, {
+      absolutePath,
+      inode,
+      stateEntry: entry2,
+      timer
+    });
+  }
+  shutdown() {
+    const entries2 = Array.from(this.buffer.entries());
+    this.buffer.clear();
+    for (const [, buffered2] of entries2) {
+      clearTimeout(buffered2.timer);
+      this.emit({
+        kind: "unlink",
+        absolutePath: buffered2.absolutePath,
+        stateEntry: buffered2.stateEntry,
+        renameFallback: false
+      });
+    }
+  }
+  size() {
+    return this.buffer.size;
+  }
+}
+function slugFromPath(absolutePath) {
+  const base = basename4(absolutePath);
+  if (!base.endsWith(".md"))
+    return null;
+  const slug = base.slice(0, -3);
+  if (slug.length === 0)
+    return null;
+  dirname7(absolutePath);
+  return slug;
+}
+
+// src/lib/watcher.ts
 var DEFAULT_DEBOUNCE_MS = 500;
 var DEFAULT_MAX_PENDING_PATHS = 5000;
 function defaultIgnores(workspaceRoot) {
@@ -96082,15 +96850,16 @@ class DebounceMap {
     this.maxPending = opts.maxPending;
   }
   schedule(event) {
-    const existing = this.pending.get(event.absolutePath);
+    const key = debounceKey(event);
+    const existing = this.pending.get(key);
     if (existing) {
       clearTimeout(existing.timer);
     }
     const timer = setTimeout(() => {
-      this.pending.delete(event.absolutePath);
+      this.pending.delete(key);
       this.handler(event);
     }, this.debounceMs);
-    this.pending.set(event.absolutePath, {
+    this.pending.set(key, {
       timer,
       event,
       insertedAt: Date.now()
@@ -96132,12 +96901,26 @@ class DebounceMap {
     return this.pending.size;
   }
 }
+function debounceKey(event) {
+  switch (event.kind) {
+    case "upsert":
+    case "unlink":
+      return event.absolutePath;
+    case "renamed":
+      return event.toPath;
+  }
+}
 function startWatcher(opts, handler) {
   const workspaceRoot = workspaceMirrorPath(opts.workspaceSlug);
   const debounce = new DebounceMap(handler, {
     debounceMs: opts.debounceMs ?? DEFAULT_DEBOUNCE_MS,
     maxPending: opts.maxPendingPaths ?? DEFAULT_MAX_PENDING_PATHS
   });
+  const classifier = new RenameClassifier((event) => debounce.schedule(event), {
+    pairingWindowMs: opts.renamePairingWindowMs ?? DEFAULT_DEBOUNCE_MS,
+    getStateEntry: opts.getStateEntry,
+    statSync: opts.statSync ?? ((p) => ({ ino: statSync3(p).ino }))
+  });
   const factory = opts.chokidarFactory ?? ((paths, watcherOpts) => chokidar_default.watch(paths, watcherOpts));
   const watcher = factory(workspaceRoot, {
     ignored: defaultIgnores(workspaceRoot),
@@ -96149,11 +96932,12 @@ function startWatcher(opts, handler) {
       pollInterval: 50
     }
   });
-  watcher.on("add", (p) => debounce.schedule({ kind: "upsert", absolutePath: p }));
-  watcher.on("change", (p) => debounce.schedule({ kind: "upsert", absolutePath: p }));
-  watcher.on("unlink", (p) => debounce.schedule({ kind: "unlink", absolutePath: p }));
+  watcher.on("add", (p) => classifier.onAdd(p));
+  watcher.on("change", (p) => classifier.onChange(p));
+  watcher.on("unlink", (p) => classifier.onUnlink(p));
   return {
     async stop() {
+      classifier.shutdown();
       await watcher.close();
     },
     drainPending() {
@@ -96167,6 +96951,90 @@ function startWatcher(opts, handler) {
 
 // src/commands/start.ts
 var SHUTDOWN_DRAIN_TIMEOUT_MS = 5000;
+function backfillStateInodes(workspaceSlug, state2, statFn = (p) => statSync4(p)) {
+  let changed = false;
+  const nextDocs = {};
+  for (const [id2, entry2] of Object.entries(state2.documents)) {
+    if (entry2.inode !== undefined) {
+      nextDocs[id2] = entry2;
+      continue;
+    }
+    try {
+      const path = entityFilePath(workspaceSlug, "documents", entry2.slug);
+      const inode = statFn(path).ino;
+      nextDocs[id2] = { ...entry2, inode };
+      changed = true;
+    } catch {
+      nextDocs[id2] = entry2;
+    }
+  }
+  if (!changed)
+    return { state: state2, changed: false };
+  return { state: { ...state2, documents: nextDocs }, changed: true };
+}
+function makeWatchHandler(deps) {
+  const {
+    workspaceSlug,
+    baseUrl,
+    pat,
+    spinner,
+    mutex,
+    getState,
+    setState,
+    fetchImpl,
+    now
+  } = deps;
+  return async (event) => {
+    try {
+      if (event.kind === "renamed") {
+        const result3 = await pushRename({
+          workspaceSlug,
+          baseUrl,
+          pat,
+          fromPath: event.fromPath,
+          toPath: event.toPath,
+          id: event.id,
+          expectedUpdatedAt: event.expectedUpdatedAt,
+          fromSlug: event.fromSlug,
+          state: getState(),
+          deps: { fetchImpl, now, mutex }
+        });
+        setState(result3.state);
+        reportOutcome(spinner, workspaceSlug, result3.state, result3.outcome);
+        return;
+      }
+      const absolutePath = event.kind === "upsert" ? event.absolutePath : event.absolutePath;
+      const classified = classifyMirrorPath({ workspaceSlug, absolutePath });
+      if (!classified)
+        return;
+      if (event.kind === "unlink" && event.renameFallback) {
+        const slugHint = event.stateEntry?.slug ? `documents/${event.stateEntry.slug}` : absolutePath;
+        spinner.warn(`Rename pair miss for ${slugHint} — no inode in state, treated as delete (classifier degraded to create+delete). ` + `If you just ran \`mv\`, the cloud row was likely tombstoned; check ~/.plinth/_conflicts/ or restore from cloud.`);
+      }
+      const result2 = await pushFile({
+        workspaceSlug,
+        baseUrl,
+        pat,
+        absolutePath,
+        entityType: classified.entityType,
+        state: getState(),
+        exists: event.kind === "upsert",
+        unlinkContext: event.kind === "unlink" && event.stateEntry ? {
+          id: event.stateEntry.id,
+          slug: event.stateEntry.slug,
+          updated_at: event.stateEntry.updated_at
+        } : null,
+        deps: { fetchImpl, now, mutex }
+      });
+      setState(result2.state);
+      reportOutcome(spinner, workspaceSlug, result2.state, result2.outcome);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "unknown push error";
+      const path = event.kind === "renamed" ? event.toPath : event.absolutePath;
+      spinner.warn(`Push failed for ${path}: ${msg}`);
+    }
+  };
+}
 async function runStart(workspaceSlug, deps = {}) {
   const out = new Output({ sink: deps.sink, noColor: deps.noColor });
   const keychain = deps.keychain ?? macKeychain;
@@ -96196,40 +97064,44 @@ async function runStart(workspaceSlug, deps = {}) {
     out.error(`No personal access token in Keychain for "${slug}".`);
     return { exitCode: 1 };
   }
-  const warnedPaths = new Set;
   let state2 = loadState(slug);
+  const backfill = backfillStateInodes(slug, state2);
+  if (backfill.changed) {
+    state2 = backfill.state;
+    writeState(state2);
+  }
   const spinner = (deps.spinnerFactory ?? (() => createSpinner({ noColor: deps.noColor })))();
   spinner.start(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
-  const handler = async (event) => {
-    const classified = classifyMirrorPath({
-      workspaceSlug: slug,
-      absolutePath: event.absolutePath
-    });
-    if (!classified)
-      return;
-    try {
-      const result2 = await pushFile({
-        workspaceSlug: slug,
-        baseUrl: entry2.api_base_url,
-        pat,
-        absolutePath: event.absolutePath,
-        entityType: classified.entityType,
-        state: state2,
-        exists: event.kind === "upsert",
-        deps: { fetchImpl, now: deps.now }
-      });
-      state2 = result2.state;
-      reportOutcome(spinner, slug, state2, result2.outcome, warnedPaths);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "unknown push error";
-      spinner.warn(`Push failed for ${event.absolutePath}: ${msg}`);
-    }
+  const mutex = new PerIdMutex;
+  const getStateEntry = (entitySlug) => {
+    const entry3 = getEntryBySlug(state2, entitySlug);
+    if (!entry3)
+      return null;
+    return {
+      id: entry3.id,
+      slug: entry3.slug,
+      updated_at: entry3.updated_at,
+      inode: entry3.inode
+    };
   };
+  const handler = makeWatchHandler({
+    workspaceSlug: slug,
+    baseUrl: entry2.api_base_url,
+    pat,
+    spinner,
+    mutex,
+    getState: () => state2,
+    setState: (s2) => {
+      state2 = s2;
+    },
+    fetchImpl,
+    now: deps.now
+  });
   if (deps.skipWatch) {
     spinner.stop();
     return { exitCode: 0 };
   }
-  const watcher = startWatcher({ workspaceSlug: slug }, handler);
+  const watcher = startWatcher({ workspaceSlug: slug, getStateEntry }, handler);
   const shutdown = (signal2) => {
     (async () => {
       spinner.warn(`Received ${signal2}, draining pending pushes…`);
@@ -96252,35 +97124,41 @@ async function runStart(workspaceSlug, deps = {}) {
   });
   return { exitCode: 0 };
 }
-function reportOutcome(spinner, slug, state2, outcome, warnedPaths) {
+function reportOutcome(spinner, slug, state2, outcome) {
   switch (outcome.kind) {
     case "pushed":
       spinner.success(`Pushed documents/${outcome.entitySlug}`);
       spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
       return;
+    case "created":
+      spinner.success(`Created documents/${outcome.entitySlug}`);
+      spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
+      return;
+    case "deleted":
+      spinner.success(`Deleted documents/${outcome.entitySlug}`);
+      spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
+      return;
+    case "renamed":
+      spinner.success(`Renamed documents/${outcome.fromSlug} → documents/${outcome.toSlug}`);
+      spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
+      return;
     case "noop":
       return;
     case "conflict":
       spinner.warn(`Conflict on documents/${outcome.entitySlug} → ${outcome.stashPath} (cloud-wins; local copy stashed)`);
       spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
       return;
-    case "not_found":
-      spinner.warn(`documents/${outcome.entitySlug} not on cloud (deleted or never existed)`);
+    case "create_slug_conflict":
+      spinner.warn(`Slug conflict on documents/${outcome.entitySlug} → ${outcome.stashPath} (cloud copy adopted; local stashed)`);
+      spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
       return;
-    case "deferred_new_file": {
-      if (warnedPaths.has(outcome.absolutePath))
-        return;
-      warnedPaths.add(outcome.absolutePath);
-      spinner.warn(`${outcome.absolutePath} - new local file not pushed (rename + create handling lands in PR #8)`);
+    case "rename_slug_conflict":
+      spinner.warn(`Rename slug conflict documents/${outcome.fromSlug} → documents/${outcome.toSlug}: target slug already exists on cloud. Local stashed at ${outcome.stashPath}`);
+      spinner.update(`Watching ${slug} · ${Object.keys(state2.documents).length} docs tracked`);
       return;
-    }
-    case "deferred_delete": {
-      if (warnedPaths.has(outcome.absolutePath))
-        return;
-      warnedPaths.add(outcome.absolutePath);
-      spinner.warn(`${outcome.absolutePath} - local delete not pushed (delete handling lands in PR #8)`);
+    case "not_found":
+      spinner.warn(`documents/${outcome.entitySlug} not on cloud (deleted or never existed)`);
       return;
-    }
     case "ignored":
       return;
   }