@plinth-music/cli 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -2,6 +2,73 @@
 
 Notable changes to `@plinth-music/cli`. Grouped by what a user notices, not by PR.
 
+## 0.18.0 - 2026-09-04
+
+Three code PRs since `0.17.0` (`v0.17.0..3ece28b`, #170, #171, #173; #169 and #172 docs).
+A minor because every member session is now told something different, and the generated
+deny list refuses 32 tool names it did not refuse before.
+
+⚠️ **Your sessions are no longer told that writing a calendar date is impossible.** Plinth's
+MCP server gained `preview_` / `create_` / `update_calendar_entry` on 3 September, and 0.17.0
+shipped injected grounding and command files that denied any such route existed — a false
+denial an agent acts on by giving up and leaving the date wrong. The grounding block and both
+`/plinth:start` and `/plinth:close` now name the route and the order it runs in: propose with
+`preview_calendar_entry`, put the proposal to a person, and only once they agree pass the
+token it minted to the writer. Agreement comes before the token in every one of those
+sentences, deliberately — nothing outside the desktop cockpit asks a human anything, so on a
+plain install that instruction is the whole gate.
+
+⚠️ **Calendar deletion and cancellation are refused again, on every MCP server: the deny list
+goes 91 to 123 patterns.** The rename that opened the sanctioned write path also retired a
+guarantee, because the old patterns were anchored on the noun `event` — so
+`delete_calendar_entry` on anyone's server was refused by nothing. Thirty-two patterns
+anchored on `calendar` and `entry` restore it. Two consequences worth knowing: this refuses a
+Plinth `delete_calendar_entry` too (none exists and none is planned, so if one ever ships it
+arrives denied rather than surprising somebody), and `delete` matches inside `deleted`, so a
+`get_deleted_calendar_entry` would be refused as well.
+
+- The injected grounding block grows 215 bytes (12,699 to 12,914). The injection budget is
+  fixed, so on a workspace already at it those bytes come out of the memory facts that ride
+  into the session head. The facts themselves are untouched on disk and still readable.
+
+The desktop app pins `@plinth-music/cli` exact (0.17.0 as of v1.10.0) and picks none of this
+up until its own release repins.
+
+## 0.17.0 - 2026-09-03
+
+One code PR since `0.16.0` (`v0.16.0..a6209c8`, #165; #167 is tests and comments,
+#163 / #164 / #166 docs). A minor because sync gains a new refusal and a file on your
+disk can now move on its own.
+
+- ⚠️ **Renaming a task or project in Plinth now moves the mirror file instead of
+  writing a second one.** The server regenerates a row's slug when its name changes.
+  Until now the mirror wrote the new name to a new file and left the old one orphaned,
+  and an edit to that orphan created a duplicate row in Plinth. The file is moved now,
+  and a local copy that had diverged from the cloud is stashed to
+  `~/.plinth/_conflicts/<workspace>/` before the move rather than pushed.
+- ⚠️ **A rename that would land on a file already sitting there is refused, not
+  overwritten.** Nothing is moved, `plinth status` names it, and Plinth re-offers the
+  rename on every poll until the name is free. Where the file in the way belongs to
+  another record the message says so and tells you **not** to delete it — deleting it
+  would delete that record in Plinth. Where it is a file of yours, rename or move it
+  and the rename lands on the next poll.
+- **An unreadable file at a renamed row's old path no longer stalls the whole sync.**
+  It used to abort the pull, and in the daemon back that off to a five-minute retry
+  indefinitely, leaving the mirror silently stale behind a notice naming no file. Only
+  that row is held now, and `plinth status` names the file and says to check its
+  permissions.
+
+⚠️ **One boundary changed underneath this release, with no CLI change in it.** Plinth's
+MCP server renamed its calendar tools (`create_calendar_event` and its siblings became
+`create_calendar_entry`), which is what lets the cockpit write calendar entries. The
+side effect is that the generated deny list no longer covers calendar *deletion* on
+Plinth's own server, which it had been doing by accident of the name. No such tool
+exists today, so the hole is latent rather than open. #167 measured this and pinned it
+with tests; no deny pattern was added, removed or edited, and the list stays at 91.
+
+The desktop app pins `@plinth-music/cli` exact (0.16.0 as of v1.9.4) and picks none of
+this up until its own release repins.
+
 ## 0.16.0 - 2026-09-02
 
 Three code PRs since `0.15.0` (`v0.15.0..5c60627`, #157, #159, #161; #158 and #160 are

package/README.md

@@ -23,13 +23,13 @@ plinth start                      # run the daemon: continuous pull + watch + pu
 ## Commands
 
 - `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. **Every mirrored task, project, document, artist, meeting and thread file carries its row `id:` in frontmatter**, so an agent holding a file can address the MCP write for that row directly instead of going through `search_entities` and risking a duplicate on an empty result; files already on disk when you upgrade get it from a one-time backfill, since a cursor feed never re-sends an unchanged row. The key is server-authoritative and stripped before the wire, so it moves no hash and pushes nothing. It also **scaffolds `files/` and the six entity folders**, so a new workspace arrives with somewhere to put things instead of an empty directory, and the folder map in the generated `CLAUDE.md` reads the disk rather than asserting what ought to be there.
+- `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. **Every mirrored task, project, document, artist, meeting and thread file carries its row `id:` in frontmatter**, so an agent holding a file can address the MCP write for that row directly instead of going through `search_entities` and risking a duplicate on an empty result; files already on disk when you upgrade get it from a one-time backfill, since a cursor feed never re-sends an unchanged row. The key is server-authoritative and stripped before the wire, so it moves no hash and pushes nothing. Since 0.17.0 a row **renamed in Plinth moves its mirror file** rather than leaving a second copy at the old name; a file already sitting at the new name is never overwritten, and `plinth status` names the clash until it clears. It also **scaffolds `files/` and the six entity folders**, so a new workspace arrives with somewhere to put things instead of an empty directory, and the folder map in the generated `CLAUDE.md` reads the disk rather than asserting what ought to be there.
 - `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`. **One daemon per workspace:** it holds an exclusive kernel lock on `~/.plinth/daemon-<workspace>.lock` for its life (macOS only; other platforms are refused and told why), so a second `plinth start`, or a standalone `plinth sync` while it runs, exits 1 naming the holder's pid. **Never delete the lock file** — the lock lives on the inode, and removing the path is what lets a second daemon in beside a live one. It also writes `views/conflicts.md` on every sync: every local edit the cloud won and the daemon set aside in `~/.plinth/_conflicts/`, each with a `cp` command that restores it; the zero case is written too, so an absent file means an old daemon, not a clean one.
 - `plinth status` — local sync state: daemon liveness, last sync and per-type counts, any destructive batches being held, writes awaiting retry or permanently rejected, **every local write that has not reached Plinth** (scanned from the mirror against the last acknowledged state, with the remedy that clears each — start the daemon, or open and save a file that was created while it was down), the state of `voice.md`, 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. Four further rows. **Commands** warns when the customisable block in a generated command still names machinery that command retired — the block is preserved verbatim forever and renders after the generated body, so a hand-written step that runs a retired ritual wins, and the generator may never edit it. **Its verdict is derived from the command registry, not asserted**: a token that still resolves to a live subcommand is described as still working and left to you, because the one token it lists is `memory-gate`, which the grounding block hands every session. **Links** names `[[pointers]]` in `workspace-memory.md` and `artists/*/memory.md` that resolve to nothing — a memory fact is a hook plus a pointer to its source, so a dead pointer can mean the hook is the only surviving copy of the fact. It reuses `plinth backlinks`'s resolution ladder, reports prose links only (never one inside a code fence), never reports an ambiguous target, and strips anchors before resolving. **Injection** reports the session-start block's size against its 20,000-byte budget and **where those bytes go** — seven categories that sum to the block by construction, marking which are yours to change — plus how many facts of each index ride whole, how many ride as their opening line only, and which file to shorten. **Too long** names each memory file past the size it is useful at: a rule file (`voice.md`, `workspace-rules.md`) at **6,000 bytes**, a fact store (`artists/<slug>/memory.md`) at **12,000**. The two bars are not one bar: what a long rule file spends is the model's instruction-following budget, which reference facts do not touch. A file under its bar renders nothing at all. Since 0.16.0 it also reports master-context walls (one block past 2,000 characters), played entries still under an "upcoming" label, and a "Current state" heading with no as-of or a stale one.
 - `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, **who the member is**, entity resolution, write confirmation, workspace rules, workspace memory, user memory). It opens by naming the member: display name, email, role, workspace and machine timezone, and that tasks the agent creates are assigned to them unless told otherwise. That renders from a principal **persisted at login**, not a call at render time — this command runs on every session start, so a round trip would tax all of them and fail offline. An existing login self-heals on the next sync, so no re-login is needed, and a server that does not yet carry `role` renders a shorter true line rather than a dangling clause. Invoked by the generated Claude Code SessionStart hook. **Bounded at 20,000 bytes total.** Only the two memory indexes give: a generated safety primitive is never cut, and if the generated block alone exceeded the budget the indexes collapse to a pointer and the block goes over rather than losing a rule. An index that does not fit whole keeps the **most recently banked** facts, by the date each line carries rather than by position — `workspace-memory.md` supersedes in place, so an updated line keeps its original slot and position does not track age — and renders them in the file's own order, with a note saying how many of how many are shown. **A fact that does not fit whole is named by its title** — its own first sentence, a boundary the member already wrote, with its `[[pointer]]` kept — so the agent knows the fact exists and where to read it. ⚠️ **Naming is preferred over carrying, and that trades depth for breadth:** the naming pass runs first and packs, and whole facts compete for what is left, so on a full index no fact may ride whole at all. A title pays in proportion to how well the hook was written; a fact whose first sentence runs long compresses barely at all, which is why *shorten each fact's first sentence* buys room where *trim the file* does not. `voice.md` is a **pointer, not a payload**: it is read on demand when drafting, never injected, which is what took a live workspace's block from 43,578 bytes to 19,911.
-- `plinth voice-gate` — gate agent-originated copy against the workspace voice rubric. **No longer mounted by the mirror generator** (20 Aug 2026): a generated mirror carries no PreToolUse hook, voice is carried as an instruction by `workspace-rules.md`, and the outbound boundary is a `permissions.deny` list in the generated `.claude/settings.json` that refuses the **send, reply, forward, calendar-write and mail-deletion verbs on any mounted MCP**, not seven tool names — each verb anchored at a word boundary in four positions (start, after `_`, after `-`, and at a camel hump), which is what catches `outlook_send_message` and `send-mail` while leaving `resend_verification` and `list_sent` alone. Spam is the one family that is *not* anchored, and deliberately: no English word contains `spam` as a substring, so the unanchored form has nothing to over-reach into and catches `reportSpam` and `move_to_spam` as well as `mark_message_spam`. Deletion joined on 30 Aug 2026, taking the list from 61 patterns to 91: `trash` bare (nothing reads by *starting* with it, and `empty_trash` falls out for free), `delete` against the `message` / `thread` / `mail` nouns (bare, it would refuse every `mcp__plinth__delete_*` tool), and spam-marking, which Gmail purges after thirty days and is therefore deletion on a fuse. **Drafting, filing, labelling and reading are untouched** — `outlook_send_draft` is denied while `outlook_create_draft` is not, because the discriminator is the verb, never the noun, and archiving a message is a move rather than a deletion. **Two costs are disclosed rather than discovered:** a few reads are caught by name (`getForwardingSettings`, a `list_trash`), and the bare `trash` family also refuses Google Drive's `trash_file` and the only route the live Gmail mount has for discarding a staged draft — that connector exposes no `delete_draft`, so a wrong draft is repaired with `update_draft` instead. Ten holes are recorded as assertions in `tests/context-session-hook.test.ts` rather than as prose — deletion-by-move and Gmail's own label route among them, the latter being the widest, since Gmail expresses TRASH and SPAM as labels and labelling stays allowed. The list is an enumeration and the tests say so out loud. The command still ships and still works, for a hand-wired mount: `--hook` runs it as a PreToolUse hook that blocks non-compliant Gmail drafts; direct mode takes `--file <path>` or stdin and prints the verdict (`--json` for the raw response).
+- `plinth voice-gate` — gate agent-originated copy against the workspace voice rubric. **No longer mounted by the mirror generator** (20 Aug 2026): a generated mirror carries no PreToolUse hook, voice is carried as an instruction by `workspace-rules.md`, and the outbound boundary is a `permissions.deny` list in the generated `.claude/settings.json` that refuses the **send, reply, forward, calendar and mail-deletion verbs on any mounted MCP**, not seven tool names — each verb anchored at a word boundary in four positions (start, after `_`, after `-`, and at a camel hump), which is what catches `outlook_send_message` and `send-mail` while leaving `resend_verification` and `list_sent` alone. Spam is the one family that is *not* anchored, and deliberately: no English word contains `spam` as a substring, so the unanchored form has nothing to over-reach into and catches `reportSpam` and `move_to_spam` as well as `mark_message_spam`. Deletion joined on 30 Aug 2026, taking the list from 61 patterns to 91: `trash` bare (nothing reads by *starting* with it, and `empty_trash` falls out for free), `delete` against the `message` / `thread` / `mail` nouns (bare, it would refuse every `mcp__plinth__delete_*` tool), and spam-marking, which Gmail purges after thirty days and is therefore deletion on a fuse. **Plinth's own calendar-write route is deliberately outside the list** (4 Sept 2026). The server renamed those tools to `preview_` / `create_` / `update_calendar_entry` on 3 September, and because the deny dialect has no negation an exception cannot be written as a rule — the carve-out *is* the name. The same rename retired a guarantee, since the calendar families were anchored on the noun `event` and `delete_calendar_entry` on anyone's server was then refused by nothing, so the list went from 91 patterns to **123**: `delete` and `cancel` anchored on `calendar` and `entry`, which refuses calendar deletion on every server again, Plinth's own included. **Drafting, filing, labelling and reading are untouched** — `outlook_send_draft` is denied while `outlook_create_draft` is not, because the discriminator is the verb, never the noun, and archiving a message is a move rather than a deletion. **Two costs are disclosed rather than discovered:** a few reads are caught by name (`getForwardingSettings`, a `list_trash`), and the bare `trash` family also refuses Google Drive's `trash_file` and the only route the live Gmail mount has for discarding a staged draft — that connector exposes no `delete_draft`, so a wrong draft is repaired with `update_draft` instead. Ten holes are recorded as assertions in `tests/context-session-hook.test.ts` rather than as prose — deletion-by-move and Gmail's own label route among them, the latter being the widest, since Gmail expresses TRASH and SPAM as labels and labelling stays allowed. The list is an enumeration and the tests say so out loud. The command still ships and still works, for a hand-wired mount: `--hook` runs it as a PreToolUse hook that blocks non-compliant Gmail drafts; direct mode takes `--file <path>` or stdin and prints the verdict (`--json` for the raw response).
 - `plinth backlinks <target>` — report what points at a target, by reading the local mirror rather than making a network call. `<target>` can be a mirror path (`projects/breadcrumb-trail.md` — including a mirror-root file like `CLAUDE.md`), a bare name (`breadcrumb-trail`), or a wikilink target as written (`Aligned Timeline - 4 June 2026`). Output is file paths with line numbers and the link as written; `--paths-only` emits deduped paths for piping, and stdout carries the answer ALONE — withheld rows never reach the pipe, whatever the display flags say. **Every narrowing is disclosed, and the counts print even when they are zero**, because a filter the caller cannot see is indistinguishable from an empty corpus, and a disclosure that only appears when it bites gives a reader no baseline to judge it against. Two footers carry them: links withheld from the answer (daemon-rendered marker blocks, code spans / HTML comments, and links to a bare name several files answer to), and the corpus line — which workspace was searched, how much of the mirror was read against its full size, and what went unread: `this-fiction · 859 of 880 files scanned (21 non-markdown, 0 unreadable) in 34ms`. `--unfiltered` shows the withheld rows, each tagged with the narrowing that hid it. Non-markdown files are not scanned for links but **do** count as existing, so asking about a PDF in `files/` answers rather than denying it. Exit codes: `0` results found or the target file exists, `1` no such target and nothing links to that name, `2` a bare name several files answer to (it lists them rather than guessing — and every candidate it prints resolves when pasted back), `3` no active workspace, an unknown or malformed workspace slug, or a mirror with nothing to search.
 - `plinth declare <path> --scratchpad <dir> [--label=<text>]` — declare a file in the session scratchpad as a work product, so it appears in the cockpit's work-products panel instead of being lost with the session. Appends one line to an append-only `.plinth-deliverables.jsonl` manifest inside `<dir>`; the manifest records the **path, never the content**, so the panel always points at the live file rather than a snapshot that can go stale. Grounding primitive (j) instructs the agent to run this the moment it writes a deliverable whose only home is the scratchpad. **The scratchpad directory is required and never inferred** (`--scratchpad`, or `PLINTH_SCRATCHPAD_DIR`): this repo learns it from neither the app that spawns the terminal nor the harness that told the agent, so a guessed root would silently widen the containment check every refusal rests on. Refuses, with exit 1, anything outside that directory — including a symlink whose target is outside it — plus a directory, a file that does not exist yet, and a missing root.
 - `plinth review-tier [--repo <path>] [--base <ref>]` — print the code-review tier the current diff earns, `low` or `high`, for use as `/code-review $(plinth review-tier)`. Reads the diff against the merge base — committed, uncommitted **and untracked**, since a brand-new never-added file is invisible to `git diff` and would otherwise be classified as absent — and routes `high` on the risk classes the review rubric names: auth/RLS, optimistic concurrency/CAS, financial math, data-moving migrations, and large **and** multi-subsystem together. **It is a router, not a ceiling**: size alone never escalates, because a blanket cap would kill the concurrency reviews that earn their keep. **The output contract is the safety story.** It is invoked inside `$( )`, where an empty stdout or a non-zero exit would collapse the caller to an unqualified `/code-review` that silently inherits whatever global effort is configured — safe by accident, and indistinguishable from this working. So stdout carries **exactly one token and nothing else**, the exit code is **always 0**, and the reasoning goes **unconditionally to stderr** on both tiers. Anything it cannot classify — not a git repo, no merge base, no default branch, an empty diff — prints `high` and says why on stderr.

package/dist/build-stamp.json

@@ -1,5 +1,5 @@
 {
-  "sha": "4d6d17c915cb0b2fd774da4ae8876a450a658eb0",
+  "sha": "d641e2f41a54942541eeddfa55776d42e226e011",
   "dirty": false,
-  "built_at": "2026-09-02T18:56:56.610Z"
+  "built_at": "2026-09-04T17:57:36.767Z"
 }

package/dist/cli.js

@@ -7584,7 +7584,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.16.0",
+  version: "0.18.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -23654,6 +23654,46 @@ function writeMirrorFile(workspaceSlug, entityType, entitySlug, content) {
     throw err;
   }
 }
+
+class MirrorDestinationOccupiedError extends MirrorPathError {
+  fromSlug;
+  toSlug;
+  constructor(fromSlug, toSlug) {
+    super(`Cannot move ${JSON.stringify(fromSlug)} to ${JSON.stringify(toSlug)}: ` + `a file already exists there`);
+    this.name = "MirrorDestinationOccupiedError";
+    this.fromSlug = fromSlug;
+    this.toSlug = toSlug;
+  }
+}
+function moveEntityFile(workspaceSlug, entityType, fromSlug, toSlug, beforeMove) {
+  const strategy = getStrategy(entityType);
+  const rel = strategy ? strategy.mirrorRelativePath(fromSlug) : flatMirrorRelativePath(entityType)(fromSlug);
+  if (rel.split("/").length !== 2) {
+    throw new MirrorPathError(`Entity type ${JSON.stringify(entityType)} keeps its rows in a folder; ` + `moving one is not supported`);
+  }
+  const from = entityFilePath(workspaceSlug, entityType, fromSlug);
+  const to = entityFilePath(workspaceSlug, entityType, toSlug);
+  if (from === to)
+    return "absent";
+  try {
+    lstatSync(to);
+    throw new MirrorDestinationOccupiedError(fromSlug, toSlug);
+  } catch (err) {
+    if (err instanceof MirrorDestinationOccupiedError)
+      throw err;
+    if (err?.code !== "ENOENT")
+      throw err;
+  }
+  beforeMove?.();
+  try {
+    renameSync(from, to);
+    return "moved";
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return "absent";
+    throw err;
+  }
+}
 var ARTIST_MEMORY_ANCHOR = "memory.md";
 function artistMemoryFilePath(workspaceSlug, entitySlug) {
   assertSlug("entity slug", entitySlug);
@@ -27032,7 +27072,7 @@ function composeGroundingBlock(today, workspaceRules, workspaceMemory, userMemor
   add("grounding", `Plinth session grounding:`, ``, `Today's date: ${today}. You have no inherent sense of the current date and ` + `your training has a knowledge cutoff, so treat this injected date as ` + `authoritative for anything time-relative: deadlines, what counts as ` + `"recent" or "upcoming", and the age of any data or of your own knowledge.`);
   if (identity !== null)
     add("identity", ``, identity);
-  add("grounding", ``, `Resolve Plinth entities before answering about them. For any answer grounded ` + `in a specific artist, project, task, or other workspace entity, first look ` + `the name up in THIS workspace with the Plinth MCP tools ` + `(\`mcp__plinth__search_entities\`, \`mcp__plinth__list_artists\`, or ` + `\`mcp__plinth__list_projects\`) and ground your answer in what they return. ` + `Do not answer from name recognition alone: a globally famous name may not ` + `exist in this workspace, and an entity here may differ from the public ` + `figure of the same name. If the lookup returns nothing, say so instead of ` + `inventing details.`, ``, `Plan before you write. The first time you call any mutating Plinth MCP tool ` + `in a session (create_*, update_*, delete_*, mark_*: anything that changes ` + `workspace data), do not commit silently: state exactly what you would write, ` + `naming the tool, the entity, and the fields and values, and proceed only after ` + `the user confirms or amends.`, ``, `Write through the canonical surface. In this cockpit the file tree is your edit ` + `surface, so reach for it before the most direct tool. Change prose (document ` + `bodies, free-form notes, anything textual) by editing the mirror markdown ` + `file; the daemon syncs it up. An artist's master context is the clearest case: ` + `it lives in the body of that artist's \`artists/<slug>/_artist.md\` mirror file, ` + `the file the web context pane renders, and one of only two files under ` + `\`artists/<slug>/\` the daemon syncs both ways (\`memory.md\` is the other), ` + `so change it by editing that body, never by creating ` + `a separate document or context entity (e.g. \`create_document\`) the pane won't ` + `render. One carve-out inside that file: a block labelled as rendered from ` + `Plinth is regenerated on every sync and your edits to it are discarded, so ` + `write those through the tool the block names. Change structured fields (task ` + `status, priority, assignees, due dates, a project's category) through the ` + `Plinth MCP (\`mcp__plinth__*\`) or the task file's frontmatter, which is ` + `row-canonical but still written through the validated API. Make a bulk or ` + `destructive change (a mass delete, a gutting overwrite) by editing the file ` + `path, so the daemon's confirm-gate can quarantine it for \`plinth confirm\`. ` + `Never write the database directly, which rules out raw SQL and ` + `\`execute_sql\`, \`apply_migration\` and \`psql\`: those bypass the daemon, the ` + `mirror, the confirm-gate, canonicality, and API validation.`, ``, `Dates belong on the calendar, not in \`key_dates\`. The date surface for an artist ` + `is their mapped Google Calendar; the \`key_dates\` table is retired. Reading ` + `dates is yours, and this mirror already holds them: the daemon projects every ` + `mapped calendar into \`views/calendar/upcoming.md\` and ` + `\`views/calendar/<slug>.md\`, so read those before reaching for a tool ` + `(\`list_artist_calendars\`). They are derived and overwritten, ` + `so they are current only as of the \`generated_at\` in their header - quote that ` + `stamp, never edit them, and check the status line, because a calendar Plinth ` + `could not reach is unknown rather than empty. When a tool is the only way, ` + `resolve the calendar through \`mcp__plinth__list_artist_calendars\` and use its ` + `\`calendar_id\` field, not the mapping row's \`id\`, because the default ` + `\`primary\` is almost never theirs.`, ``, `Writing a date is not yours, by any route: not a calendar tool, and not a ` + `shell command line either, the Google Workspace one included. The calendar ` + `tools are refused for you where Plinth has configured this workspace. ` + `Nothing refuses a shell, anywhere, and where Plinth has not configured ` + `this workspace nothing is refused at all: you are the only thing holding ` + `those. The way ` + `through is a person, not a workaround, so when a date needs adding or ` + `correcting say plainly what the change is, say that it goes in through ` + `Plinth's calendar view, and say that a person makes it. Say why, too: a date ` + `left looking handled is worse than one openly outstanding, and a calendar ` + `write goes out to everyone invited the moment it lands and cannot be recalled.`, ``, `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, forwarding and deleting are not yours, by any route: not a mail tool, and ` + `not a shell command line either. The mail tools are refused for you where ` + `Plinth has configured this workspace. Nothing refuses a shell, anywhere, ` + `and where Plinth has not configured this workspace nothing is refused at ` + `all: you are the only thing holding those. This is not a comment on your ` + `writing. It is that a message which has left the building cannot be recalled, ` + `and one deleted out of a mailbox is not yours to lose; the person whose name ` + `is on it is the one who decides.`);
+  add("grounding", ``, `Resolve Plinth entities before answering about them. For any answer grounded ` + `in a specific artist, project, task, or other workspace entity, first look ` + `the name up in THIS workspace with the Plinth MCP tools ` + `(\`mcp__plinth__search_entities\`, \`mcp__plinth__list_artists\`, or ` + `\`mcp__plinth__list_projects\`) and ground your answer in what they return. ` + `Do not answer from name recognition alone: a globally famous name may not ` + `exist in this workspace, and an entity here may differ from the public ` + `figure of the same name. If the lookup returns nothing, say so instead of ` + `inventing details.`, ``, `Plan before you write. The first time you call any mutating Plinth MCP tool ` + `in a session (create_*, update_*, delete_*, mark_*: anything that changes ` + `workspace data), do not commit silently: state exactly what you would write, ` + `naming the tool, the entity, and the fields and values, and proceed only after ` + `the user confirms or amends.`, ``, `Write through the canonical surface. In this cockpit the file tree is your edit ` + `surface, so reach for it before the most direct tool. Change prose (document ` + `bodies, free-form notes, anything textual) by editing the mirror markdown ` + `file; the daemon syncs it up. An artist's master context is the clearest case: ` + `it lives in the body of that artist's \`artists/<slug>/_artist.md\` mirror file, ` + `the file the web context pane renders, and one of only two files under ` + `\`artists/<slug>/\` the daemon syncs both ways (\`memory.md\` is the other), ` + `so change it by editing that body, never by creating ` + `a separate document or context entity (e.g. \`create_document\`) the pane won't ` + `render. One carve-out inside that file: a block labelled as rendered from ` + `Plinth is regenerated on every sync and your edits to it are discarded, so ` + `write those through the tool the block names. Change structured fields (task ` + `status, priority, assignees, due dates, a project's category) through the ` + `Plinth MCP (\`mcp__plinth__*\`) or the task file's frontmatter, which is ` + `row-canonical but still written through the validated API. Make a bulk or ` + `destructive change (a mass delete, a gutting overwrite) by editing the file ` + `path, so the daemon's confirm-gate can quarantine it for \`plinth confirm\`. ` + `Never write the database directly, which rules out raw SQL and ` + `\`execute_sql\`, \`apply_migration\` and \`psql\`: those bypass the daemon, the ` + `mirror, the confirm-gate, canonicality, and API validation.`, ``, `Dates belong on the calendar, not in \`key_dates\`. The date surface for an artist ` + `is their mapped Google Calendar; the \`key_dates\` table is retired. Reading ` + `dates is yours, and this mirror already holds them: the daemon projects every ` + `mapped calendar into \`views/calendar/upcoming.md\` and ` + `\`views/calendar/<slug>.md\`, so read those before reaching for a tool ` + `(\`list_artist_calendars\`). They are derived and overwritten, ` + `so they are current only as of the \`generated_at\` in their header - quote that ` + `stamp, never edit them, and check the status line, because a calendar Plinth ` + `could not reach is unknown rather than empty. When a tool is the only way, ` + `resolve the calendar through \`mcp__plinth__list_artist_calendars\` and use its ` + `\`calendar_id\` field, not the mapping row's \`id\`, because the default ` + `\`primary\` is almost never theirs.`, ``, `Writing a date is not yours to do unasked, and the route is Plinth's own: ` + `propose it with \`preview_calendar_entry\`, put that proposal to the person, ` + `and only once they agree pass the token it minted for exactly that proposal ` + `to \`create_calendar_entry\` or \`update_calendar_entry\`. Nothing else writes ` + `one: ` + `no other calendar tool, and not a shell command line either, the ` + `Google Workspace one included. ` + `Nothing refuses a shell, anywhere, and where Plinth has not configured ` + `this workspace nothing is refused at all: you are the only thing holding ` + `those. Where no calendar is mapped, or a token is refused, that is not a ` + `wall. The way ` + `through is a person, not a workaround, so ` + `say plainly what the change is, say that it goes in through ` + `Plinth's calendar view, and say that a person makes it. Say why, too: a date ` + `left looking handled is worse than one openly outstanding, and a calendar ` + `write goes out to everyone invited the moment it lands and cannot be recalled.`, ``, `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, forwarding and deleting are not yours, by any route: not a mail tool, and ` + `not a shell command line either. The mail tools are refused for you where ` + `Plinth has configured this workspace. Nothing refuses a shell, anywhere, ` + `and where Plinth has not configured this workspace nothing is refused at ` + `all: you are the only thing holding those. This is not a comment on your ` + `writing. It is that a message which has left the building cannot be recalled, ` + `and one deleted out of a mailbox is not yours to lose; the person whose name ` + `is on it is the one who decides.`);
   if (workspaceRules === null && voiceProfile === null) {
     add("voice", ``, `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 \`${VOICE_FILENAME}\` beside it holds your own voice profile, 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.`);
   }
@@ -29306,8 +29346,10 @@ var MANAGED_COMMENT = [
   "or in .claude/settings.local.json.",
   "The permissions.deny entries below are managed the same way. They stop an agent",
   "in this workspace sending, replying to or forwarding mail, deleting or trashing",
-  "it, marking it spam, and writing a calendar; drafting, filing, labelling and",
-  "reading stay allowed. The refusal covers a draft the agent staged itself: on a",
+  "it, marking it spam, and writing a calendar - create, update, delete and cancel",
+  "wherever the name also carries event, plus delete and cancel wherever it carries",
+  "calendar entry; drafting, filing, labelling and reading stay allowed.",
+  "The refusal covers a draft the agent staged itself: on a",
   "Gmail mount there is no delete-draft tool, so trashing was the only way to",
   "discard one and it is now refused. Fix a wrong draft with update_draft, which",
   "keeps its thread. They match by VERB FAMILY rather than by",
@@ -29315,6 +29357,8 @@ var MANAGED_COMMENT = [
   "rule set, not four - and the matcher cannot express an alternation, so each",
   "spelling needs its own line. That width also catches a few reads whose name",
   "merely begins with a send verb - getForwardingSettings is the live example -",
+  "and a few whose name merely CONTAINS one - a calendar read called",
+  "get_deleted_calendar_entry is refused, because delete sits inside deleted -",
   "and it stops an agent trashing any file, not only mail: nothing here can tell",
   "a mailbox's trash from a drive's.",
   "You cannot re-open one of these here: a deny beats an allow, including yours,",
@@ -29323,6 +29367,10 @@ var MANAGED_COMMENT = [
   "message that has gone cannot be recalled. Nor is a deleted one yours to lose:",
   "it is somebody else's mailbox, spam-marking is deletion on a thirty-day fuse,",
   "and neither is undone by noticing afterwards.",
+  "One thing is deliberately NOT on this list, and it is the only exception:",
+  "Plinth's own create_calendar_entry and update_calendar_entry, the sanctioned",
+  "calendar write path, which take a two-step preview-and-confirm of their own",
+  "before anything reaches a calendar.",
   "One more entry stops an agent EDITING voice.md, the",
   "voice profile it is judged against: that file is yours to write and theirs to read.",
   "Your own allow list is untouched, and your own",
@@ -29401,6 +29449,38 @@ var MANAGED_DENY = [
   "mcp__*__*_cancel*Event*",
   "mcp__*__*-cancel*Event*",
   "mcp__*__*Cancel*Event*",
+  "mcp__*__delete*calendar*entry*",
+  "mcp__*__*_delete*calendar*entry*",
+  "mcp__*__*-delete*calendar*entry*",
+  "mcp__*__*Delete*calendar*entry*",
+  "mcp__*__delete*calendar*Entry*",
+  "mcp__*__*_delete*calendar*Entry*",
+  "mcp__*__*-delete*calendar*Entry*",
+  "mcp__*__*Delete*calendar*Entry*",
+  "mcp__*__delete*Calendar*entry*",
+  "mcp__*__*_delete*Calendar*entry*",
+  "mcp__*__*-delete*Calendar*entry*",
+  "mcp__*__*Delete*Calendar*entry*",
+  "mcp__*__delete*Calendar*Entry*",
+  "mcp__*__*_delete*Calendar*Entry*",
+  "mcp__*__*-delete*Calendar*Entry*",
+  "mcp__*__*Delete*Calendar*Entry*",
+  "mcp__*__cancel*calendar*entry*",
+  "mcp__*__*_cancel*calendar*entry*",
+  "mcp__*__*-cancel*calendar*entry*",
+  "mcp__*__*Cancel*calendar*entry*",
+  "mcp__*__cancel*calendar*Entry*",
+  "mcp__*__*_cancel*calendar*Entry*",
+  "mcp__*__*-cancel*calendar*Entry*",
+  "mcp__*__*Cancel*calendar*Entry*",
+  "mcp__*__cancel*Calendar*entry*",
+  "mcp__*__*_cancel*Calendar*entry*",
+  "mcp__*__*-cancel*Calendar*entry*",
+  "mcp__*__*Cancel*Calendar*entry*",
+  "mcp__*__cancel*Calendar*Entry*",
+  "mcp__*__*_cancel*Calendar*Entry*",
+  "mcp__*__*-cancel*Calendar*Entry*",
+  "mcp__*__*Cancel*Calendar*Entry*",
   "mcp__*__trash*",
   "mcp__*__*_trash*",
   "mcp__*__*-trash*",
@@ -29905,7 +29985,7 @@ function buildStartCommandMd(rosterIsEmpty2, offerTrim = false, stores = BLOB_ME
     "",
     "Then the calendar. It is Plinth's projection of every artist's calendar.",
     "",
-    "**This is a FILE READ, not a calendar call, and the rule in Step 2 stands unchanged: you still never open a calendar tool.** The file is here so that you do not have to.",
+    "**This is a FILE READ, not a calendar call, and Step 2's budget stands unchanged: no calendar call in this brief.** The file is here so that you do not have to make one. **That is a cost rule about the opener, not a closed door** - Plinth has a calendar-write route of its own, named below. Opening a session is not when you take it.",
     "",
     '**Brief it as of its own `generated_at` stamp, and say the stamp.** A projection is a cache. It is exactly as current as the header says it is and no more, so "nothing on this week" is only ever true as of that moment.',
     "",
@@ -29913,7 +29993,7 @@ function buildStartCommandMd(rosterIsEmpty2, offerTrim = false, stores = BLOB_ME
     "",
     "If the file carries `fetch_state: stale`, the last refresh failed: say how old the dates are rather than reporting them as current. If the file is absent altogether, say the projection has not run yet and carry on without it.",
     "",
-    "**Dates are read here and changed by a person, in Plinth's calendar view.** If something needs moving, say what the change is and hand it over.",
+    "**Dates are read here, and changing one is not part of this brief.** If something needs moving, say plainly what the change is. After this session's brief it goes one of two ways: propose it with `preview_calendar_entry`, put that proposal to the person, and only once they agree pass the token it minted to `create_calendar_entry` or `update_calendar_entry` - or hand the change to a person to make in Plinth's calendar view.",
     "",
     "## Step 4: brief, in three lines",
     "",
@@ -30022,7 +30102,7 @@ function buildCloseCommandMd(workspaceSlug, stores = BLOB_MEMORY_STORES) {
     "- **A note, brief or bio that is a piece of writing in its own right** is a document under `documents/`. That means standalone material somebody would open and read on its own, not a fact you are recording because you learned it - a fact is a memory line, and Step 4b routes it.",
     "- **A stable attribute of an artist** - their website, a handle, their bio - is that artist's own field, or the body of `artists/<slug>/_artist.md`.",
     "- **A contract, statement or attachment** is a file under `files/`.",
-    "- **A date is live state and belongs in no memory file.** A deadline rides its task as a due date. Every other date is a calendar matter: say plainly what the date is, say that a person adds it in Plinth's calendar view, and name it in the closing summary so it is not quietly dropped.",
+    "- **A date is live state and belongs in no memory file.** A deadline rides its task as a due date. Every other date is a calendar matter: say plainly what the date is, and either propose it with `preview_calendar_entry`, put that proposal to the member, and only once they agree pass the token it minted to `create_calendar_entry` or `update_calendar_entry` - or hand it to a person to add in Plinth's calendar view. Name it in the closing summary either way, so it is not quietly dropped.",
     "",
     '**A typed fact with no home today is named in the closing summary as "no home yet", and written nowhere.** The case that actually occurs is a contact who belongs to several artists or to none - a publisher who routes writers across the whole roster. Do not pick one artist arbitrarily and do not flatten it into a memory line. **You cannot write it with no artist either: `create_artist_contact` requires `artist_id` or `artist_name` and errors with `Either artist_id or artist_name is required`.** So this is a real gap with no surface behind it today, not a shortcut you are declining to take. Name it in the summary and leave it unwritten; a named gap is useful, and a contact filed under an artist it does not belong to is worse than nothing.',
     "",
@@ -31007,6 +31087,31 @@ function recordEntitySymlinkRefused(args) {
     rejected_at: args.now().toISOString()
   }));
 }
+function recordEntitySlugClash(args) {
+  const path3 = args.mirrorRelativePath;
+  const withoutStale = removeUnsynced(args.state, "entity", path3).state;
+  const held = `Until then new ${args.entityType} changes are held on this machine.`;
+  const message = args.reason === "source_unreadable" ? `${args.entityType}/${args.fromSlug} was renamed in Plinth to ` + `${args.toSlug}, but ${path3} could not be read, so it was left exactly ` + `where it is. Check the file's permissions; Plinth will move it once ` + `it can read it. ${held}` : args.occupantTracked ? `${args.entityType}/${args.fromSlug} was renamed in Plinth to ` + `${args.toSlug}, but ${args.entityType}/${args.toSlug}.md belongs to ` + `another ${args.entityType}, so nothing was moved or overwritten. ` + `This usually clears itself once that record's own rename arrives. ` + `Do not delete that file — it would delete that record in Plinth. ` + `${held}` : `${args.entityType}/${args.fromSlug} was renamed in Plinth to ` + `${args.toSlug}, but ${args.entityType}/${args.toSlug}.md already ` + `exists here, so nothing was moved or overwritten. Rename or remove ` + `that file and Plinth will move this one into place. ${held}`;
+  const existing = (withoutStale.rejected ?? []).find((r) => r.target === "entity" && r.path === path3 && r.reason === "slug_clash");
+  if (existing && existing.message === message)
+    return args.state;
+  return persist(withoutStale, upsertRejected(withoutStale, {
+    target: "entity",
+    op: "upsert",
+    path: path3,
+    status: 0,
+    reason: "slug_clash",
+    message,
+    rejected_at: args.now().toISOString()
+  }));
+}
+function clearSlugClash(state, mirrorRelativePaths) {
+  const list = state.rejected ?? [];
+  const next = list.filter((o) => !(o.target === "entity" && o.reason === "slug_clash" && mirrorRelativePaths.includes(o.path)));
+  if (next.length === list.length)
+    return state;
+  return commitState(state, { ...state, rejected: next });
+}
 function clearSymlinkRefused(state, target, path3) {
   const list = state.rejected ?? [];
   const next = list.filter((o) => !(o.target === target && o.path === path3 && o.reason === "symlink"));
@@ -32727,10 +32832,102 @@ function computeMirrorHashes(strategy, content) {
 function hashableBody(strategy, body) {
   return strategy.stripLocalBlocks?.(body) ?? body;
 }
-function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor) {
+function relocateForSlugChange(args) {
+  const { workspaceSlug, strategy, fromSlug, toSlug, acked, echo, now } = args;
+  if (fromSlug === toSlug)
+    return { kind: "not_needed", writeSlug: toSlug };
+  if (!echo) {
+    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "unguarded" };
+  }
+  if (strategy.mirrorRelativePath(fromSlug).split("/").length !== 2) {
+    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "foldered" };
+  }
+  let fromPath;
+  try {
+    fromPath = entityFilePath(workspaceSlug, strategy.type, fromSlug);
+    entityFilePath(workspaceSlug, strategy.type, toSlug);
+  } catch (err) {
+    if (err instanceof MirrorPathError) {
+      return {
+        kind: "skipped",
+        writeSlug: toSlug,
+        fromSlug,
+        reason: "unresolvable"
+      };
+    }
+    throw err;
+  }
+  let raw = null;
+  try {
+    raw = readFileSync15(fromPath, "utf8");
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return { kind: "absent", writeSlug: toSlug, fromSlug };
+    }
+    return {
+      kind: "refused",
+      writeSlug: fromSlug,
+      fromSlug,
+      reason: "source_unreadable"
+    };
+  }
+  let diverged = true;
+  try {
+    const hashes = computeMirrorHashes(strategy, raw);
+    diverged = hashes.bodyHash !== acked.bodyHash || hashes.frontmatterHash !== acked.frontmatterHash;
+  } catch {
+    diverged = true;
+  }
+  const stashPath = diverged ? stashConflict({
+    workspaceSlug,
+    entityType: strategy.type,
+    entitySlug: fromSlug,
+    timestamp: now(),
+    contents: raw,
+    side: "local"
+  }) : undefined;
+  try {
+    let registered = false;
+    const result = moveEntityFile(workspaceSlug, strategy.type, fromSlug, toSlug, () => {
+      if (echo.watcher === "live") {
+        echo.suppressor.registerDelete(fromPath);
+        registered = true;
+      }
+    });
+    if (result === "moved") {
+      return { kind: "moved", writeSlug: toSlug, fromSlug, stashPath };
+    }
+    if (registered && echo.watcher === "live") {
+      echo.suppressor.cancelDelete(fromPath);
+    }
+    return { kind: "absent", writeSlug: toSlug, fromSlug };
+  } catch (err) {
+    if (err instanceof MirrorDestinationOccupiedError) {
+      return {
+        kind: "refused",
+        writeSlug: fromSlug,
+        fromSlug,
+        reason: "destination_occupied",
+        stashPath
+      };
+    }
+    if (err instanceof MirrorPathError) {
+      return {
+        kind: "skipped",
+        writeSlug: toSlug,
+        fromSlug,
+        reason: "unresolvable"
+      };
+    }
+    throw err;
+  }
+}
+function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor, pathSlug) {
+  const targetSlug = pathSlug ?? doc2.slug;
   let content = strategy.serialise(doc2);
   if (strategy.preserveLocalBodyOnPull) {
-    const target = entityFilePath(workspaceSlug, strategy.type, doc2.slug);
+    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
     let existing = null;
     try {
       existing = readFileSync15(target, "utf8");
@@ -32748,10 +32945,10 @@ function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor)
     }
   }
   if (suppressor) {
-    const target = entityFilePath(workspaceSlug, strategy.type, doc2.slug);
+    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
     suppressor.registerWrite(target, computeMirrorHashes(strategy, content));
   }
-  writeMirrorFile(workspaceSlug, strategy.type, doc2.slug, content);
+  writeMirrorFile(workspaceSlug, strategy.type, targetSlug, content);
   return content;
 }
 
@@ -32859,7 +33056,8 @@ function cloudMatchesAcked(strategy, cloud, acked) {
 }
 function stampStateFromMirror(args) {
   const { strategy, workspaceSlug, doc: doc2, state, priorMemoryHash } = args;
-  const mirrorPath = entityFilePath(workspaceSlug, strategy.type, doc2.slug);
+  const targetSlug = args.pathSlug ?? doc2.slug;
+  const mirrorPath = entityFilePath(workspaceSlug, strategy.type, targetSlug);
   const mirrorRaw = readFileSync16(mirrorPath, "utf8");
   const mirrorParsed = import_gray_matter10.default(mirrorRaw);
   const mirrorFm = mirrorParsed.data ?? {};
@@ -32868,7 +33066,7 @@ function stampStateFromMirror(args) {
   const mirrorHashBody = hashableBody(strategy, mirrorParsed.content);
   const refreshed = {
     id: doc2.id,
-    slug: doc2.slug,
+    slug: targetSlug,
     updated_at: doc2.updated_at,
     revision: doc2.revision,
     body_hash: stableHash(mirrorHashBody),
@@ -32879,6 +33077,73 @@ function stampStateFromMirror(args) {
   };
   return persistEntry(state, strategy.type, refreshed);
 }
+function adoptCloudCopy(args) {
+  const { strategy, workspaceSlug, doc: doc2, output } = args;
+  const now = args.now ?? (() => new Date);
+  let state = args.state;
+  const prior = getEntry(state, strategy.type, doc2.id);
+  let writeSlug = doc2.slug;
+  let refused = false;
+  if (prior && prior.slug !== doc2.slug) {
+    const relocation = relocateForSlugChange({
+      workspaceSlug,
+      strategy,
+      fromSlug: prior.slug,
+      toSlug: doc2.slug,
+      acked: {
+        bodyHash: prior.body_hash,
+        frontmatterHash: prior.frontmatter_hash
+      },
+      echo: args.echo,
+      now
+    });
+    writeSlug = relocation.writeSlug;
+    const move = `entityType=${strategy.type} from=${prior.slug} to=${doc2.slug} id=${doc2.id}`;
+    if (relocation.kind === "moved") {
+      output?.log(`[SLUG_MOVE ${move} source=push]`);
+      state = clearSlugClash(state, [
+        strategy.mirrorRelativePath(prior.slug),
+        strategy.mirrorRelativePath(doc2.slug)
+      ]);
+    } else if (relocation.kind === "refused") {
+      output?.log(`[SLUG_MOVE_REFUSED ${move} reason=${relocation.reason} source=push]`);
+      refused = true;
+      state = recordEntitySlugClash({
+        state,
+        mirrorRelativePath: strategy.mirrorRelativePath(prior.slug),
+        entityType: strategy.type,
+        fromSlug: prior.slug,
+        toSlug: doc2.slug,
+        reason: relocation.reason,
+        occupantTracked: getEntryBySlug(state, strategy.type, doc2.slug) !== undefined,
+        now
+      });
+    } else if (relocation.kind === "skipped") {
+      output?.log(`[SLUG_MOVE_SKIP ${move} reason=${relocation.reason} source=push]`);
+    }
+    if (relocation.kind === "moved" || relocation.kind === "refused") {
+      if (relocation.stashPath) {
+        output?.warn(`Unsynced local edit on ${strategy.type}/${prior.slug} → stashed to ` + `${relocation.stashPath} (the row was renamed in Plinth; the cloud ` + `copy is authoritative).`);
+      }
+    }
+  }
+  if (refused) {
+    return prior ? persistEntry(state, strategy.type, {
+      ...prior,
+      updated_at: doc2.updated_at,
+      revision: doc2.revision
+    }) : state;
+  }
+  writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, undefined, writeSlug);
+  return stampStateFromMirror({
+    strategy,
+    workspaceSlug,
+    doc: doc2,
+    state,
+    priorMemoryHash: args.priorMemoryHash,
+    pathSlug: writeSlug
+  });
+}
 async function pullAndWriteMirror(args) {
   const cloud = await getEntity({
     strategy: args.strategy,
@@ -32887,13 +33152,15 @@ async function pullAndWriteMirror(args) {
     id: args.id,
     fetchImpl: args.fetchImpl
   });
-  writeMirrorWithBodyPreserve(args.workspaceSlug, args.strategy, cloud);
-  return stampStateFromMirror({
+  return adoptCloudCopy({
     strategy: args.strategy,
     workspaceSlug: args.workspaceSlug,
     doc: cloud,
     state: args.state,
-    priorMemoryHash: getEntry(args.state, args.strategy.type, args.id)?.memory_hash
+    priorMemoryHash: getEntry(args.state, args.strategy.type, args.id)?.memory_hash,
+    echo: args.echo,
+    output: args.output,
+    now: args.now
   });
 }
 async function pushFile(args) {
@@ -32914,6 +33181,7 @@ async function pushFile(args) {
   const mutex = deps?.mutex ?? new PerIdMutex;
   const output = deps?.output;
   const suppressor = deps?.suppressor;
+  const echo = deps?.echo;
   const strategy = getStrategy(entityType);
   if (!strategy) {
     return {
@@ -32927,6 +33195,8 @@ async function pushFile(args) {
   }
   if (!exists) {
     return runPushDelete({
+      echo,
+      now,
       strategy,
       workspaceSlug,
       baseUrl,
@@ -32945,6 +33215,8 @@ async function pushFile(args) {
   } catch (err) {
     if (err?.code === "ENOENT") {
       return runPushDelete({
+        echo,
+        now,
         strategy,
         workspaceSlug,
         baseUrl,
@@ -33004,6 +33276,7 @@ async function pushFile(args) {
   const stateEntry = identity === "path" ? byInode : byInode ?? getEntryBySlug(state, entityType, slug);
   if (!stateEntry) {
     return runPushCreate({
+      echo,
       strategy,
       workspaceSlug,
       baseUrl,
@@ -33024,6 +33297,7 @@ async function pushFile(args) {
     });
   }
   return runPushUpsert({
+    echo,
     strategy,
     workspaceSlug,
     baseUrl,
@@ -33082,7 +33356,10 @@ async function reconcileContextDocConflict(args) {
       pat,
       id: existingId,
       state,
-      fetchImpl
+      fetchImpl,
+      echo: args.echo,
+      output,
+      now
     });
     output?.log(contextDocConflictLine({
       entityType: strategy.type,
@@ -33199,7 +33476,10 @@ async function reconcileContextDocConflict(args) {
       pat,
       id: existingId,
       state,
-      fetchImpl
+      fetchImpl,
+      echo: args.echo,
+      output,
+      now
     });
     output?.log(contextDocConflictLine({
       entityType: strategy.type,
@@ -33421,6 +33701,7 @@ async function runPushUpsert(args) {
     }
     if (patchResult.reason === "context_doc_conflict") {
       return reconcileContextDocConflict({
+        echo: args.echo,
         strategy,
         workspaceSlug: args.workspaceSlug,
         baseUrl: args.baseUrl,
@@ -33439,6 +33720,7 @@ async function runPushUpsert(args) {
     }
     if (strategy.fieldTypedConflict) {
       return reconcileTaskConflict({
+        echo: args.echo,
         strategy,
         workspaceSlug: args.workspaceSlug,
         baseUrl: args.baseUrl,
@@ -33469,7 +33751,10 @@ async function runPushUpsert(args) {
       pat: args.pat,
       id: liveEntry.id,
       state: workingState,
-      fetchImpl: args.fetchImpl
+      fetchImpl: args.fetchImpl,
+      echo: args.echo,
+      output: args.output,
+      now: args.now
     });
     return {
       outcome: {
@@ -33517,7 +33802,10 @@ async function reconcileTaskConflict(args) {
       pat,
       id: liveEntry.id,
       state,
-      fetchImpl
+      fetchImpl,
+      echo: args.echo,
+      output,
+      now
     });
     return {
       outcome: {
@@ -33566,13 +33854,15 @@ async function reconcileTaskConflict(args) {
   });
   if (patchResult.ok) {
     const stashPath2 = stashCloudSide();
-    writeMirrorWithBodyPreserve(workspaceSlug, strategy, patchResult.doc);
-    state = stampStateFromMirror({
+    state = adoptCloudCopy({
       strategy,
       workspaceSlug,
       doc: patchResult.doc,
       state,
-      priorMemoryHash: liveEntry.memory_hash
+      priorMemoryHash: liveEntry.memory_hash,
+      echo: args.echo,
+      output,
+      now
     });
     output?.log(`[PATCH entityType=${strategy.type} slug=${patchResult.doc.slug} id=${patchResult.doc.id} revision=${patchResult.doc.revision} note=field_typed_conflict]`);
     return {
@@ -33604,7 +33894,10 @@ async function reconcileTaskConflict(args) {
     pat,
     id: liveEntry.id,
     state,
-    fetchImpl
+    fetchImpl,
+    echo: args.echo,
+    output,
+    now
   });
   return {
     outcome: {
@@ -33641,6 +33934,7 @@ async function runPushCreate(args) {
     const inLock = args.identity === "path" ? undefined : getEntryBySlug(args.state, strategy.type, args.slug);
     if (inLock) {
       return runPushUpsert({
+        echo: args.echo,
         strategy,
         workspaceSlug: args.workspaceSlug,
         baseUrl: args.baseUrl,
@@ -33737,6 +34031,7 @@ async function runPushCreate(args) {
     }
     if (createResult.reason === "context_doc_conflict") {
       return reconcileContextDocConflict({
+        echo: args.echo,
         strategy,
         workspaceSlug: args.workspaceSlug,
         baseUrl: args.baseUrl,
@@ -33768,7 +34063,10 @@ async function runPushCreate(args) {
       pat: args.pat,
       id: createResult.existing.id,
       state: args.state,
-      fetchImpl: args.fetchImpl
+      fetchImpl: args.fetchImpl,
+      echo: args.echo,
+      output: args.output,
+      now: args.now
     });
     return {
       outcome: {
@@ -33856,7 +34154,10 @@ async function runPushDelete(args) {
       pat: args.pat,
       id,
       state: args.state,
-      fetchImpl: args.fetchImpl
+      fetchImpl: args.fetchImpl,
+      echo: args.echo,
+      output: args.output,
+      now: args.now
     });
     return {
       outcome: {
@@ -33887,6 +34188,7 @@ async function pushRename(args) {
   const now = deps?.now ?? (() => new Date);
   const mutex = deps?.mutex ?? new PerIdMutex;
   const output = deps?.output;
+  const echo = deps?.echo;
   const strategy = requireStrategy(entityType);
   let toSlug;
   try {
@@ -33995,7 +34297,10 @@ async function pushRename(args) {
         pat,
         id: patchResult.existing.id,
         state,
-        fetchImpl
+        fetchImpl,
+        echo,
+        output,
+        now
       });
       const finalState = await pullAndWriteMirror({
         strategy,
@@ -34004,7 +34309,10 @@ async function pushRename(args) {
         pat,
         id,
         state: afterColliding,
-        fetchImpl
+        fetchImpl,
+        echo,
+        output,
+        now
       });
       return {
         outcome: {
@@ -34036,7 +34344,10 @@ async function pushRename(args) {
       pat,
       id,
       state,
-      fetchImpl
+      fetchImpl,
+      echo,
+      output,
+      now
     });
     return {
       outcome: {
@@ -34094,7 +34405,8 @@ async function applyBatch(batch, deps, mutex) {
           fetchImpl: deps.fetchImpl,
           now: deps.now,
           mutex,
-          output: deps.output
+          output: deps.output,
+          echo: deps.echo
         }
       });
       deps.setState(result.state);
@@ -34163,7 +34475,10 @@ async function discardBatchOps(batch, deps) {
         pat: deps.pat,
         id: op.id,
         state: deps.getState(),
-        fetchImpl: deps.fetchImpl
+        fetchImpl: deps.fetchImpl,
+        echo: deps.echo,
+        output: deps.output,
+        now: deps.now
       });
       deps.setState(next);
     } catch (err) {
@@ -34756,7 +35071,7 @@ function recordFileUnsynced(args) {
   });
 }
 async function drainUnsyncedOps(args) {
-  const { workspaceSlug, baseUrl, pat, getState, setState, fetchImpl, mutex, output } = args;
+  const { workspaceSlug, baseUrl, pat, getState, setState, fetchImpl, mutex, output, echo } = args;
   const now = args.now ?? (() => new Date);
   const ops = listUnsynced(getState());
   let attempted = 0;
@@ -34789,7 +35104,7 @@ async function drainUnsyncedOps(args) {
           state: getState(),
           exists: op.op === "upsert",
           unlinkContext: null,
-          deps: { fetchImpl, now, mutex, output }
+          deps: { fetchImpl, now, mutex, output, echo }
         });
         setState(result.state);
       } else {
@@ -38304,6 +38619,11 @@ class PullSuppressor {
       expiresAt: this.now() + this.ttlMs
     });
   }
+  cancelDelete(absPath) {
+    const entry2 = this.entries.get(absPath);
+    if (entry2?.kind === "delete")
+      this.entries.delete(absPath);
+  }
   shouldSuppressUpsert(absPath, hashes) {
     const entry2 = this.entries.get(absPath);
     if (!entry2)
@@ -38872,7 +39192,7 @@ async function reconcileDivergedRows(args) {
         state,
         exists: true,
         unlinkContext: null,
-        deps: { fetchImpl, now, output }
+        deps: { fetchImpl, now, output, echo: args.echo }
       });
       state = result.state;
       switch (result.outcome.kind) {
@@ -41373,7 +41693,13 @@ async function runSync(workspaceSlug, deps = {}) {
       let cursor = startCursor;
       let lastAdvancedCursor = startCursor;
       let cursorBlocked = false;
-      const ctr = { fetched: 0, written: 0, deleted: 0 };
+      const ctr = {
+        fetched: 0,
+        written: 0,
+        deleted: 0,
+        moved: 0,
+        refused: 0
+      };
       while (true) {
         const page = await syncEntity({
           strategy,
@@ -41407,6 +41733,12 @@ async function runSync(workspaceSlug, deps = {}) {
             ctr.written++;
           else if (outcome.action === "deleted")
             ctr.deleted++;
+          else if (outcome.action === "moved")
+            ctr.moved = (ctr.moved ?? 0) + 1;
+          else if (outcome.action === "slug_refused") {
+            ctr.refused = (ctr.refused ?? 0) + 1;
+            cursorBlocked = true;
+          }
         }
         commitPending();
         if (page.next_cursor === null)
@@ -41628,7 +41960,9 @@ async function runSync(workspaceSlug, deps = {}) {
   await syncFileRejections();
   const totalWritten = Object.values(counters).reduce((sum, c) => sum + c.written, 0);
   const totalDeleted = Object.values(counters).reduce((sum, c) => sum + c.deleted, 0);
-  if (totalWritten === 0 && totalDeleted === 0) {
+  const totalMoved = Object.values(counters).reduce((sum, c) => sum + (c.moved ?? 0), 0);
+  const totalRefused = Object.values(counters).reduce((sum, c) => sum + (c.refused ?? 0), 0);
+  if (totalWritten === 0 && totalDeleted === 0 && totalMoved === 0 && totalRefused === 0) {
     out.success("Already up to date.");
     return { exitCode: 0, applied: 0 };
   }
@@ -41639,12 +41973,16 @@ async function runSync(workspaceSlug, deps = {}) {
     const parts = [`${c.fetched} fetched`];
     if (c.written > 0)
       parts.push(`${c.written} written`);
+    if ((c.moved ?? 0) > 0)
+      parts.push(`${c.moved} renamed`);
+    if ((c.refused ?? 0) > 0)
+      parts.push(`${c.refused} rename held`);
     if (c.deleted > 0)
       parts.push(`${c.deleted} deleted`);
     out.info(`  ${type}: ${parts.join(", ")}`);
   }
   out.success(`Done in ${elapsed}s.`);
-  return { exitCode: 0, applied: totalWritten + totalDeleted };
+  return { exitCode: 0, applied: totalWritten + totalMoved + totalDeleted };
 }
 function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = () => new Date, isFrozen, loggedTombstoneSkips) {
   if (isFrozen?.(strategy.type, row.id)) {
@@ -41704,7 +42042,59 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   if (strategy.shouldMirror && !strategy.shouldMirror(live) && !existingEntry) {
     return { state, action: "skipped" };
   }
-  if (existingEntry && existingEntry.updated_at === live.updated_at) {
+  let relocation = { kind: "not_needed", writeSlug: live.slug };
+  if (existingEntry && existingEntry.slug !== live.slug) {
+    const echo = suppressor ? { watcher: "live", suppressor } : { watcher: "none" };
+    relocation = relocateForSlugChange({
+      workspaceSlug,
+      strategy,
+      fromSlug: existingEntry.slug,
+      toSlug: live.slug,
+      acked: {
+        bodyHash: existingEntry.body_hash,
+        frontmatterHash: existingEntry.frontmatter_hash
+      },
+      echo,
+      now
+    });
+    const move = `entityType=${strategy.type} from=${existingEntry.slug} to=${live.slug} id=${live.id}`;
+    switch (relocation.kind) {
+      case "moved":
+        out.log(`[SLUG_MOVE ${move}]`);
+        state = clearSlugClash(state, [
+          strategy.mirrorRelativePath(existingEntry.slug),
+          strategy.mirrorRelativePath(live.slug)
+        ]);
+        break;
+      case "refused":
+        out.log(`[SLUG_MOVE_REFUSED ${move} reason=${relocation.reason}]`);
+        const occupantTracked = getEntryBySlug(state, strategy.type, live.slug) !== undefined;
+        state = recordEntitySlugClash({
+          state,
+          mirrorRelativePath: strategy.mirrorRelativePath(existingEntry.slug),
+          entityType: strategy.type,
+          fromSlug: existingEntry.slug,
+          toSlug: live.slug,
+          reason: relocation.reason,
+          occupantTracked,
+          now
+        });
+        out.warn(relocation.reason === "source_unreadable" ? `${strategy.type}/${existingEntry.slug} was renamed to ${live.slug} in ` + `Plinth, but ${strategy.mirrorRelativePath(existingEntry.slug)} could ` + `not be read — it was left exactly where it is. Check its permissions.` : occupantTracked ? `${strategy.type}/${existingEntry.slug} was renamed to ${live.slug} in ` + `Plinth, but ${strategy.mirrorRelativePath(live.slug)} belongs to ` + `another ${strategy.type} — nothing was moved or overwritten. This ` + `usually clears itself once that row's own rename arrives; do not ` + `delete the file, which would delete that record in Plinth.` : `${strategy.type}/${existingEntry.slug} was renamed to ${live.slug} in ` + `Plinth, but ${strategy.mirrorRelativePath(live.slug)} already exists ` + `here — nothing was moved or overwritten. Rename or remove that file ` + `and Plinth will move this one into place.`);
+        return { state, action: "slug_refused" };
+      case "skipped":
+        out.log(`[SLUG_MOVE_SKIP ${move} reason=${relocation.reason}]`);
+        break;
+      case "absent":
+      case "not_needed":
+        break;
+    }
+    const stashPath = relocation.kind === "moved" ? relocation.stashPath : undefined;
+    if (stashPath) {
+      out.warn(`Unsynced local edit on ${strategy.type}/${existingEntry.slug} → stashed ` + `to ${stashPath} (the row was renamed in Plinth; the cloud copy is ` + `authoritative).`);
+    }
+  }
+  const writeSlug = relocation.writeSlug;
+  if (existingEntry && existingEntry.updated_at === live.updated_at && relocation.kind === "not_needed") {
     const path5 = entityFilePath(workspaceSlug, strategy.type, live.slug);
     if (existsSync7(path5)) {
       if (strategy.type === "artists") {
@@ -41730,10 +42120,10 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
       return { state, action: "noop_overwrite" };
     }
   }
-  if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at) {
+  if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at && relocation.kind !== "moved") {
     let localRaw = null;
     try {
-      localRaw = readFileSync24(entityFilePath(workspaceSlug, strategy.type, live.slug), "utf8");
+      localRaw = readFileSync24(entityFilePath(workspaceSlug, strategy.type, writeSlug), "utf8");
     } catch {
       localRaw = null;
     }
@@ -41753,11 +42143,11 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
       }
     }
   }
-  const content = writeMirrorWithBodyPreserve(workspaceSlug, strategy, live, suppressor);
+  const content = writeMirrorWithBodyPreserve(workspaceSlug, strategy, live, suppressor, writeSlug);
   const hashes = computeMirrorHashes(strategy, content);
   let inode;
   try {
-    inode = statSync16(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
+    inode = statSync16(entityFilePath(workspaceSlug, strategy.type, writeSlug)).ino;
   } catch {
     inode = undefined;
   }
@@ -41780,7 +42170,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   }
   const { state: nextState } = upsertEntry(state, strategy.type, {
     id: live.id,
-    slug: live.slug,
+    slug: writeSlug,
     updated_at: live.updated_at,
     revision: live.revision,
     body_hash: hashes.bodyHash,
@@ -41790,7 +42180,8 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
     memory_hash: memoryHash,
     memory_generated: memoryGenerated
   });
-  return { state: nextState, action: "written" };
+  const action = relocation.kind === "moved" ? "moved" : "written";
+  return { state: nextState, action };
 }
 var syncCommand = defineCommand({
   meta: {
@@ -42266,6 +42657,22 @@ function makeWatchHandler(deps) {
         });
         if (!classifiedFrom)
           return;
+        if (suppressor?.shouldSuppressDelete(event.fromPath)) {
+          const strategy = getStrategy(classifiedFrom.entityType);
+          let toRaw = null;
+          try {
+            toRaw = readFileSync25(event.toPath, "utf8");
+          } catch {
+            toRaw = null;
+          }
+          const isEcho = strategy !== undefined && toRaw !== null && suppressor.shouldSuppressUpsert(event.toPath, computeMirrorHashes(strategy, toRaw));
+          if (isEcho) {
+            output?.log(`[RENAME_SUPPRESSED entityType=${classifiedFrom.entityType} ` + `from=${event.fromSlug} id=${event.id} reason=pull_echo]`);
+            return;
+          }
+          await handle({ kind: "upsert", absolutePath: event.toPath });
+          return;
+        }
         const result2 = await pushRename({
           workspaceSlug,
           baseUrl,
@@ -42277,7 +42684,13 @@ function makeWatchHandler(deps) {
           expectedUpdatedAt: event.expectedUpdatedAt,
           fromSlug: event.fromSlug,
           state: getState(),
-          deps: { fetchImpl, now, mutex, output }
+          deps: {
+            fetchImpl,
+            now,
+            mutex,
+            output,
+            echo: suppressor ? { watcher: "live", suppressor } : undefined
+          }
         });
         setState(result2.state);
         reportOutcome(spinner, workspaceSlug, result2.state, result2.outcome);
@@ -42409,7 +42822,14 @@ function makeWatchHandler(deps) {
           slug: event.stateEntry.slug,
           updated_at: event.stateEntry.updated_at
         } : null,
-        deps: { fetchImpl, now, mutex, output, suppressor }
+        deps: {
+          fetchImpl,
+          now,
+          mutex,
+          output,
+          suppressor,
+          echo: suppressor ? { watcher: "live", suppressor } : undefined
+        }
       });
       setState(clearEntityRejected(result.state, workspaceSlug, absolutePath));
       reportOutcome(spinner, workspaceSlug, getState(), result.outcome);
@@ -42470,7 +42890,8 @@ async function flushHeldEntityOp(deps) {
         fetchImpl: deps.fetchImpl,
         now,
         mutex: deps.mutex,
-        output: deps.output
+        output: deps.output,
+        echo: deps.echo
       }
     });
     deps.setState(result.state);
@@ -42606,6 +43027,7 @@ async function runStart(workspaceSlug, deps = {}) {
     frozenFiles = computeFrozenFiles(slug);
   };
   const recon = await reconcileDivergedRows({
+    echo: { watcher: "none" },
     workspaceSlug: slug,
     baseUrl: entry2.api_base_url,
     pat,
@@ -42819,6 +43241,7 @@ async function runStart(workspaceSlug, deps = {}) {
   spinner.start(`Watching ${slug} · ${watchingSummary(state)}`);
   const mutex = new PerIdMutex;
   const bootDrain = await drainResolvedBatches({
+    echo: { watcher: "none" },
     workspaceSlug: slug,
     baseUrl: entry2.api_base_url,
     pat,
@@ -42836,6 +43259,7 @@ async function runStart(workspaceSlug, deps = {}) {
     out.info(`Resolved ${bootDrain.applied + bootDrain.discarded} held batch${bootDrain.applied + bootDrain.discarded === 1 ? "" : "es"}: ${bootDrain.applied} applied, ${bootDrain.discarded} discarded.`);
   }
   const bootUnsynced = await drainUnsyncedOps({
+    echo: { watcher: "none" },
     workspaceSlug: slug,
     baseUrl: entry2.api_base_url,
     pat,
@@ -42873,6 +43297,7 @@ async function runStart(workspaceSlug, deps = {}) {
   };
   const suppressor = new PullSuppressor;
   const flushHeldOp = (op) => flushHeldEntityOp({
+    echo: { watcher: "live", suppressor },
     workspaceSlug: slug,
     baseUrl: entry2.api_base_url,
     pat,
@@ -43060,6 +43485,7 @@ async function runStart(workspaceSlug, deps = {}) {
         draining = true;
         try {
           const drained = await drainResolvedBatches({
+            echo: { watcher: "live", suppressor },
             workspaceSlug: slug,
             baseUrl: entry2.api_base_url,
             pat,
@@ -43077,6 +43503,7 @@ async function runStart(workspaceSlug, deps = {}) {
             spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
           }
           const redriven = await drainUnsyncedOps({
+            echo: { watcher: "live", suppressor },
             workspaceSlug: slug,
             baseUrl: entry2.api_base_url,
             pat,

package/package.json

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