@plinth-music/cli 0.20.1 → 0.21.1

package/dist/cli.js

@@ -7584,7 +7584,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.20.1",
+  version: "0.21.1",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -26125,6 +26125,27 @@ function isLaterVersion(a, b) {
     return false;
   return ta > tb;
 }
+function committedEntryIfNewer(workspaceSlug, entityType, entry) {
+  let raw;
+  try {
+    raw = readFileSync7(stateFilePath(workspaceSlug), "utf8");
+  } catch {
+    return;
+  }
+  let committed;
+  try {
+    const parsed = JSON.parse(raw);
+    committed = parsed.entries?.[entityType]?.[entry.id];
+  } catch {
+    return;
+  }
+  if (committed === undefined)
+    return;
+  const valid = StateEntrySchema.safeParse(committed);
+  if (!valid.success)
+    return;
+  return isLaterVersion(valid.data, entry) ? valid.data : undefined;
+}
 function mergeKey(fresh, before, after) {
   if (before === after)
     return { value: fresh, overruled: false };
@@ -26200,8 +26221,7 @@ function mergeAnchor(fresh, before, after) {
     return fresh;
   return after;
 }
-function commitState(before, after) {
-  const fresh = loadState(after.workspace_slug);
+function mergeWorkspaceState(fresh, before, after, wantCorrected = true) {
   const entityTypes = new Set([
     ...Object.keys(fresh.entries),
     ...Object.keys(before.entries),
@@ -26242,10 +26262,11 @@ function commitState(before, after) {
     last_trim_at: mergeScalar(fresh.last_trim_at, before.last_trim_at, after.last_trim_at),
     memory_facts: mergeScalar(fresh.memory_facts, before.memory_facts, after.memory_facts)
   };
-  writeState(merged);
+  if (!wantCorrected)
+    return { merged, corrected: after };
   const singletonOverruled = rules.overruled || memory.overruled || userMemory.overruled || userVoice.overruled;
   if (overruledEntries.length === 0 && files.overruled.length === 0 && !singletonOverruled) {
-    return after;
+    return { merged, corrected: after };
   }
   let corrected = after;
   if (rules.overruled)
@@ -26264,8 +26285,20 @@ function commitState(before, after) {
     const committed = merged.files?.[path];
     corrected = committed ? upsertFileEntry(corrected, committed).state : removeFileEntry(corrected, path).state;
   }
+  return { merged, corrected };
+}
+function commitState(before, after) {
+  const { merged, corrected } = mergeWorkspaceState(loadState(after.workspace_slug), before, after);
+  writeState(merged);
   return corrected;
 }
+function rebaseState(current, base2, next) {
+  if (next === base2)
+    return current;
+  if (current === base2)
+    return next;
+  return mergeWorkspaceState(current, base2, next, false).merged;
+}
 function upsertEntry(state, entityType, entry) {
   const bucket = state.entries[entityType] ?? {};
   const existing = bucket[entry.id];
@@ -30505,6 +30538,560 @@ function ensureGitignore(workspaceSlug) {
 function backupStamp2(d) {
   return d.toISOString().replace(/[-:.]/g, "").replace("Z", "");
 }
+// src/lib/context/observation.ts
+import {
+  closeSync as closeSync2,
+  constants as FS,
+  fstatSync,
+  lstatSync as lstatSync3,
+  openSync as openSync2,
+  readSync,
+  realpathSync as realpathSync2
+} from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { basename as basename2, dirname as dirname6, join as join8, resolve as resolve3, sep as sep4 } from "node:path";
+var OBSERVATION_MAX_BYTES = 64 * 1024 * 1024;
+var OBSERVATION_MAX_LINES = 200000;
+var READ_CHUNK = 1024 * 1024;
+var PROVENANCE_MAX = 256;
+var UNSAFE_PROVENANCE = /[\p{Cc}\p{Cf}]/u;
+function safeProvenance(v) {
+  if (typeof v !== "string" || v === "")
+    return null;
+  if (v.length > PROVENANCE_MAX)
+    return null;
+  if (UNSAFE_PROVENANCE.test(v))
+    return null;
+  return v;
+}
+var ATTACHMENT_LABELS = new Set([
+  "skill_listing",
+  "deferred_tools_delta",
+  "mcp_instructions_delta",
+  "command_permissions",
+  "agent_listing_delta",
+  "total_tokens_reminder",
+  "auto_mode",
+  "remote_session_change",
+  "file_history_snapshot"
+]);
+function isFailure(x) {
+  return x.status !== undefined;
+}
+function openSelected(selectedPath, hooks = {}) {
+  const resolved = resolve3(selectedPath);
+  let canonicalPath;
+  try {
+    canonicalPath = realpathSync2(resolved);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return { status: "absent", refusalReason: null, canonicalPath: null, indirection: false };
+    }
+    if (code === "ELOOP") {
+      return {
+        status: "refused",
+        refusalReason: "path-unresolvable",
+        canonicalPath: null,
+        indirection: true
+      };
+    }
+    return { status: "unreadable", refusalReason: null, canonicalPath: null, indirection: false };
+  }
+  const indirection = canonicalPath !== resolved;
+  let before;
+  try {
+    before = lstatSync3(canonicalPath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return { status: "absent", refusalReason: null, canonicalPath, indirection };
+    }
+    return { status: "unreadable", refusalReason: null, canonicalPath, indirection };
+  }
+  hooks.afterIdentityCheck?.();
+  let fd;
+  try {
+    fd = openSync2(canonicalPath, FS.O_RDONLY | FS.O_NOFOLLOW | FS.O_NONBLOCK);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return { status: "absent", refusalReason: null, canonicalPath, indirection };
+    }
+    if (code === "ELOOP" || code === "EMLINK") {
+      return { status: "refused", refusalReason: "target-changed", canonicalPath, indirection };
+    }
+    return { status: "unreadable", refusalReason: null, canonicalPath, indirection };
+  }
+  let after;
+  try {
+    after = fstatSync(fd);
+  } catch {
+    closeSync2(fd);
+    return { status: "unreadable", refusalReason: null, canonicalPath, indirection };
+  }
+  if (!after.isFile()) {
+    closeSync2(fd);
+    return { status: "refused", refusalReason: "not-regular-file", canonicalPath, indirection };
+  }
+  if (after.dev !== before.dev || after.ino !== before.ino) {
+    closeSync2(fd);
+    return { status: "refused", refusalReason: "target-changed", canonicalPath, indirection };
+  }
+  return { fd, canonicalPath, indirection };
+}
+function readBounded(fd, maxBytes) {
+  const hash2 = createHash2("sha256");
+  const chunks = [];
+  const buf = Buffer.allocUnsafe(READ_CHUNK);
+  let bytesRead = 0;
+  let truncated = false;
+  for (;; ) {
+    const want = Math.min(READ_CHUNK, maxBytes - bytesRead);
+    if (want <= 0) {
+      const probe2 = readSync(fd, buf, 0, 1, bytesRead);
+      truncated = probe2 > 0;
+      break;
+    }
+    const n = readSync(fd, buf, 0, want, bytesRead);
+    if (n <= 0)
+      break;
+    const slice = Buffer.from(buf.subarray(0, n));
+    hash2.update(slice);
+    chunks.push(slice);
+    bytesRead += n;
+  }
+  return {
+    text: Buffer.concat(chunks).toString("utf8"),
+    bytesRead,
+    truncated,
+    sha256: hash2.digest("hex")
+  };
+}
+var USAGE_FIELDS = [
+  ["inputTokens", ["input_tokens"]],
+  ["cacheReadTokens", ["cache_read_input_tokens"]],
+  ["cacheCreationTokens", ["cache_creation_input_tokens"]],
+  ["outputTokens", ["output_tokens"]],
+  ["cacheCreation1hTokens", ["cache_creation", "ephemeral_1h_input_tokens"]],
+  ["cacheCreation5mTokens", ["cache_creation", "ephemeral_5m_input_tokens"]]
+];
+function dig(obj, path) {
+  let cur = obj;
+  for (const key of path) {
+    if (cur === null || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+
+class UsageAccumulator {
+  byRequest = new Map;
+  sums = new Map;
+  present = new Map;
+  requests = 0;
+  countedRecords = 0;
+  duplicateRecords = 0;
+  conflictingDuplicates = 0;
+  untaggedRecords = 0;
+  recordsWithoutUsage = 0;
+  unresolvableRecords = 0;
+  add(record2) {
+    if (record2["type"] !== "assistant")
+      return;
+    const usage = dig(record2, ["message", "usage"]);
+    const hasUsage = usage !== null && typeof usage === "object";
+    if (hasUsage)
+      this.countedRecords += 1;
+    else
+      this.recordsWithoutUsage += 1;
+    const requestId = record2["requestId"];
+    if (typeof requestId !== "string" || requestId === "") {
+      if (hasUsage)
+        this.untaggedRecords += 1;
+      else
+        this.unresolvableRecords += 1;
+      return;
+    }
+    if (!this.byRequest.has(requestId)) {
+      this.byRequest.set(requestId, null);
+      this.requests += 1;
+    }
+    if (!hasUsage)
+      return;
+    const fingerprint = JSON.stringify(USAGE_FIELDS.map(([, path]) => dig(usage, path) ?? null));
+    const prior = this.byRequest.get(requestId) ?? null;
+    if (prior !== null) {
+      if (prior === fingerprint)
+        this.duplicateRecords += 1;
+      else
+        this.conflictingDuplicates += 1;
+      return;
+    }
+    this.byRequest.set(requestId, fingerprint);
+    for (const [name, path] of USAGE_FIELDS) {
+      const raw = dig(usage, path);
+      if (typeof raw !== "number" || !Number.isFinite(raw))
+        continue;
+      this.present.set(name, (this.present.get(name) ?? 0) + 1);
+      this.sums.set(name, (this.sums.get(name) ?? 0) + raw);
+    }
+  }
+  unresolved() {
+    let n = 0;
+    for (const fp of this.byRequest.values())
+      if (fp === null)
+        n += 1;
+    return n;
+  }
+  finish() {
+    if (this.countedRecords === 0 && this.recordsWithoutUsage === 0)
+      return null;
+    const unresolvedRequests = this.unresolved();
+    const incompleteFields = [];
+    const value = (name) => {
+      const present2 = this.present.get(name) ?? 0;
+      if (present2 > 0 && present2 === this.requests)
+        return this.sums.get(name) ?? 0;
+      if (present2 > 0)
+        incompleteFields.push(name);
+      return null;
+    };
+    const fields = Object.fromEntries(USAGE_FIELDS.map(([name]) => [name, value(name)]));
+    const anyFullyCovered = USAGE_FIELDS.some(([name]) => (this.present.get(name) ?? 0) > 0 && (this.present.get(name) ?? 0) === this.requests);
+    return {
+      requests: this.requests,
+      countedRecords: this.countedRecords,
+      duplicateRecords: this.duplicateRecords,
+      conflictingDuplicates: this.conflictingDuplicates,
+      untaggedRecords: this.untaggedRecords,
+      unresolvedRequests,
+      recordsWithoutUsage: this.recordsWithoutUsage,
+      unresolvableRecords: this.unresolvableRecords,
+      ...fields,
+      incompleteFields,
+      incomplete: incompleteFields.length > 0 || this.conflictingDuplicates > 0 || this.untaggedRecords > 0 || unresolvedRequests > 0 || this.unresolvableRecords > 0 || this.requests > 0 && !anyFullyCovered
+    };
+  }
+}
+function hasToolResult(content) {
+  if (!Array.isArray(content))
+    return false;
+  return content.some((b) => b !== null && typeof b === "object" && b["type"] === "tool_result");
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((b) => b !== null && typeof b === "object" && typeof b["text"] === "string" ? b["text"] : "").join("");
+}
+function payloadBytes(payload) {
+  if (payload === undefined)
+    return 0;
+  if (typeof payload === "string")
+    return Buffer.byteLength(payload, "utf8");
+  try {
+    return Buffer.byteLength(JSON.stringify(payload) ?? "", "utf8");
+  } catch {
+    return 0;
+  }
+}
+
+class DeliveryAccumulator {
+  rows = new Map;
+  pendingCommand = false;
+  bump(kind, label, bytes) {
+    const key = `${kind} ${label}`;
+    const row = this.rows.get(key) ?? { kind, label, occurrences: 0, recordedBytes: 0 };
+    row.occurrences += 1;
+    row.recordedBytes += bytes;
+    this.rows.set(key, row);
+  }
+  add(record2) {
+    const wasPending = this.pendingCommand;
+    this.pendingCommand = false;
+    const type = record2["type"];
+    if (type === "attachment") {
+      const att = record2["attachment"];
+      const rawLabel = dig(att, ["type"]);
+      const label = typeof rawLabel === "string" && ATTACHMENT_LABELS.has(rawLabel) ? rawLabel : "other";
+      this.bump("harness-listing", label, payloadBytes(att));
+      return;
+    }
+    if (type !== "user")
+      return;
+    const content = dig(record2, ["message", "content"]);
+    const bytes = payloadBytes(content);
+    const text = contentText(content);
+    if (record2["isMeta"] === true) {
+      if (wasPending)
+        this.bump("command-body", "command-body", bytes);
+      else
+        this.bump("meta-injection", "meta-injection", bytes);
+      return;
+    }
+    if (hasToolResult(content)) {
+      this.bump("tool-result", "tool-result", bytes);
+      return;
+    }
+    const opening = text.trimStart();
+    this.pendingCommand = opening.startsWith("<command-message>") || opening.startsWith("<command-name>");
+    this.bump("user-turn", "user-turn", bytes);
+  }
+  finish() {
+    return [...this.rows.values()].sort((a, b) => b.recordedBytes - a.recordedBytes || a.label.localeCompare(b.label));
+  }
+}
+
+class BindingAccumulator {
+  sessionIds = new Set;
+  versions = new Set;
+  cwds = new Set;
+  branches = new Set;
+  first = null;
+  last = null;
+  rejected = 0;
+  add(record2) {
+    const str2 = (k) => {
+      const raw = record2[k];
+      const safe = safeProvenance(raw);
+      if (safe === null && typeof raw === "string" && raw !== "")
+        this.rejected += 1;
+      return safe;
+    };
+    const sid = str2("sessionId");
+    if (sid !== null)
+      this.sessionIds.add(sid);
+    const ver = str2("version");
+    if (ver !== null)
+      this.versions.add(ver);
+    const cwd = str2("cwd");
+    if (cwd !== null)
+      this.cwds.add(cwd);
+    const branch = str2("gitBranch");
+    if (branch !== null)
+      this.branches.add(branch);
+    const ts = str2("timestamp");
+    if (ts !== null) {
+      if (this.first === null || ts < this.first)
+        this.first = ts;
+      if (this.last === null || ts > this.last)
+        this.last = ts;
+    }
+  }
+  finish(workspaceMirrorDir) {
+    const only = (s) => s.size === 1 ? [...s][0] : null;
+    const cwd = only(this.cwds);
+    const consistent = this.sessionIds.size === 1 && this.versions.size === 1 && this.cwds.size === 1;
+    return {
+      sessionId: only(this.sessionIds),
+      runtimeVersion: only(this.versions),
+      cwd,
+      gitBranch: only(this.branches),
+      firstTimestamp: this.first,
+      lastTimestamp: this.last,
+      distinctSessionIds: this.sessionIds.size,
+      consistent,
+      scope: deriveScope(cwd, workspaceMirrorDir),
+      rejectedFields: this.rejected
+    };
+  }
+}
+function canonicalise(p) {
+  const full = resolve3(p);
+  let cur = full;
+  const tail = [];
+  for (;; ) {
+    try {
+      const real = realpathSync2(cur);
+      return tail.length === 0 ? real : join8(real, ...tail.slice().reverse());
+    } catch {
+      const parent = dirname6(cur);
+      if (parent === cur)
+        return full;
+      tail.push(basename2(cur));
+      cur = parent;
+    }
+  }
+}
+function deriveScope(cwd, workspaceMirrorDir) {
+  if (cwd === null || workspaceMirrorDir === undefined)
+    return "unknown";
+  const ws = canonicalise(workspaceMirrorDir);
+  const here = canonicalise(cwd);
+  if (here === ws)
+    return "root";
+  if (here.startsWith(ws.endsWith(sep4) ? ws : ws + sep4))
+    return "below-root";
+  return "outside";
+}
+function limitsFor(obs) {
+  const limits = [
+    {
+      id: "observation-not-attributable",
+      what: "which source contributed which tokens is not recoverable from this artefact: the standing context arrives as one aggregate in the first request's cache fields, with no per-source breakdown. The remainder is unattributable, not zero",
+      owner: "not exposed by the measured artefact, runtime and this adapter; further effective-loading work stays with S2/E15 and the packaged half"
+    },
+    {
+      id: "observation-interval",
+      what: "this covers only the interval actually read from the selected file, identified by its byte boundary and digest. A live session keeps growing, so the same path measured later is a different interval",
+      owner: "the reader who selected the file; re-run to extend it"
+    },
+    {
+      id: "observation-inventory-not-contemporaneous",
+      what: "the source inventory above is what is on disk NOW. It is not evidence that those files existed, or had those sizes, during the observed interval",
+      owner: "E15, which compares arms rather than inventories"
+    },
+    {
+      id: "observation-compaction",
+      what: "resume, clear and compaction are not detected and were not demonstrated in any measured sample, so a compacted session may be reported as one continuous interval",
+      owner: "a later S2/E15 lane with a purpose-built compacted session"
+    },
+    {
+      id: "observation-delivery-cause",
+      what: "a command body is labelled only when an invocation marker precedes it; an uncorrelated meta-injection's cause is not established. And a recorded delivery proves delivery happened, never that a body is not loaded by some other route",
+      owner: "a later S2 lane, if per-route delivery proof is wanted"
+    }
+  ];
+  if (obs.binding.rejectedFields > 0) {
+    limits.push({
+      id: "observation-provenance-refused",
+      what: "one or more session/runtime/directory values in the file carried control characters or exceeded the length cap and were refused rather than printed, so they read as unknown above",
+      owner: "the reader who selected the file"
+    });
+  }
+  if (obs.indirection) {
+    limits.push({
+      id: "observation-path-indirection",
+      what: "the selected path resolved through a link; the canonical path above is what was read",
+      owner: "the reader who selected the file"
+    });
+  }
+  if (!obs.binding.consistent) {
+    limits.push({
+      id: "observation-binding-inconsistent",
+      what: "session id, runtime version or working directory is missing or varies across records, so this observation is NOT attributed to the workspace inventory and is reported separately",
+      owner: "select a single-session transcript to attribute it"
+    });
+  }
+  if (obs.binding.scope === "below-root") {
+    limits.push({
+      id: "observation-scope-unsupported",
+      what: "the observed session ran below the workspace root, and the inventory's scoped-load class is not resolved per session, so its scoped sources are not matched to this observation",
+      owner: "a later S2 lane, if per-scope resolution is wanted"
+    });
+  }
+  return limits;
+}
+function emptyBinding(workspaceMirrorDir) {
+  return new BindingAccumulator().finish(workspaceMirrorDir);
+}
+function shell(selectedPath, status, refusalReason, canonicalPath, indirection, opts, extras = {}) {
+  const base2 = {
+    status,
+    refusalReason,
+    selectedPath,
+    canonicalPath,
+    indirection,
+    bytesRead: extras.bytesRead ?? 0,
+    sha256: extras.sha256 ?? null,
+    lines: extras.lines ?? { total: 0, parsed: 0, malformed: 0, truncated: false, cutFinalLine: false },
+    binding: emptyBinding(opts.workspaceMirrorDir),
+    usage: null,
+    deliveries: []
+  };
+  return { ...base2, limits: limitsFor(base2), complete: false };
+}
+function buildObservation(selectedPath, opts = {}) {
+  const maxBytes = opts.maxBytes ?? OBSERVATION_MAX_BYTES;
+  const maxLines = opts.maxLines ?? OBSERVATION_MAX_LINES;
+  const opened = openSelected(selectedPath, opts.openHooks ?? {});
+  if (isFailure(opened)) {
+    return shell(selectedPath, opened.status, opened.refusalReason, opened.canonicalPath, opened.indirection, opts);
+  }
+  let read;
+  try {
+    read = readBounded(opened.fd, maxBytes);
+  } catch {
+    return shell(selectedPath, "unreadable", null, opened.canonicalPath, opened.indirection, opts);
+  } finally {
+    try {
+      closeSync2(opened.fd);
+    } catch {}
+  }
+  const pieces = read.text.split(`
+`);
+  if (pieces.length > 0 && pieces[pieces.length - 1] === "")
+    pieces.pop();
+  let cutFinalLine = false;
+  let truncated = read.truncated;
+  if (read.truncated && pieces.length > 0 && !read.text.endsWith(`
+`)) {
+    pieces.pop();
+    cutFinalLine = true;
+  }
+  if (pieces.length > maxLines) {
+    pieces.length = maxLines;
+    truncated = true;
+  }
+  const nonBlank = pieces.filter((l) => l.trim() !== "");
+  if (nonBlank.length === 0) {
+    return shell(selectedPath, truncated ? "read" : "empty", null, opened.canonicalPath, opened.indirection, opts, {
+      bytesRead: read.bytesRead,
+      sha256: read.sha256,
+      lines: { total: 0, parsed: 0, malformed: 0, truncated, cutFinalLine }
+    });
+  }
+  const usage = new UsageAccumulator;
+  const deliveries = new DeliveryAccumulator;
+  const binding = new BindingAccumulator;
+  let parsed = 0;
+  let malformed = 0;
+  for (const line of nonBlank) {
+    let record2;
+    try {
+      record2 = JSON.parse(line);
+    } catch {
+      malformed += 1;
+      continue;
+    }
+    if (record2 === null || typeof record2 !== "object" || Array.isArray(record2)) {
+      malformed += 1;
+      continue;
+    }
+    parsed += 1;
+    const rec = record2;
+    binding.add(rec);
+    usage.add(rec);
+    deliveries.add(rec);
+  }
+  const lines = {
+    total: nonBlank.length,
+    parsed,
+    malformed,
+    truncated,
+    cutFinalLine
+  };
+  const status = parsed === 0 ? "malformed" : "read";
+  const finishedUsage = status === "read" ? usage.finish() : null;
+  const base2 = {
+    status,
+    refusalReason: null,
+    selectedPath,
+    canonicalPath: opened.canonicalPath,
+    indirection: opened.indirection,
+    bytesRead: read.bytesRead,
+    sha256: read.sha256,
+    lines,
+    binding: binding.finish(opts.workspaceMirrorDir),
+    usage: finishedUsage,
+    deliveries: status === "read" ? deliveries.finish() : []
+  };
+  const complete = status === "read" && malformed === 0 && !truncated && !cutFinalLine && (finishedUsage === null || !finishedUsage.incomplete);
+  return { ...base2, limits: limitsFor(base2), complete };
+}
 
 // src/lib/context/context-account.ts
 function localRow(workspaceSlug) {
@@ -30709,13 +31296,13 @@ function collectExternalSources() {
 var STANDING_LIMITS = [
   {
     id: "observed-loading",
-    what: "what a session ACTUALLY loaded is not observed. Everything above is bytes on disk and the hook's own rendered output",
-    owner: "a later S2 lane: a bounded, explicit observation import (the transcript carries per-turn usage; no adapter is built)"
+    what: "what a session ACTUALLY loaded is not observed here. Everything above is bytes on disk and the hook's own rendered output",
+    owner: "pass `--observed <transcript.jsonl>` to measure one selected session's recorded delivery. Per-source attribution stays unavailable even then"
   },
   {
     id: "usage",
-    what: "tokens, cached and billed usage are not measured. The CLI has no token accounting of any kind",
-    owner: "the same later S2 lane, with the desktop half for effective-context diagnostics"
+    what: "tokens, cached and billed usage are not measured here",
+    owner: "pass `--observed <transcript.jsonl>` for one session's recorded per-request usage; the packaged/desktop half of effective-context diagnostics is still open"
   },
   {
     id: "user-level-config",
@@ -30767,7 +31354,11 @@ function buildContextAccount(workspaceSlug, deps = {}) {
     collectExternalSources()
   ];
   const sources = parts.flatMap((p) => p.sources);
-  const limits = [...parts.flatMap((p) => p.limits), ...STANDING_LIMITS];
+  const limits = [
+    ...parts.flatMap((p) => p.limits),
+    ...STANDING_LIMITS,
+    ...deps.observation?.limits ?? []
+  ];
   const refusedFeedingHook = sources.filter((s) => s.status === "refused" && (s.route === "hook-injection" || s.path === VOICE_FILENAME));
   if (refusedFeedingHook.length > 0) {
     limits.unshift({
@@ -30805,6 +31396,7 @@ function buildContextAccount(workspaceSlug, deps = {}) {
     observedLoadedBytes: null,
     estimatedTokens: null,
     conditionalStanding,
+    observation: deps.observation ?? null,
     limits
   };
 }
@@ -31059,13 +31651,92 @@ function renderAccount(out, account) {
       out.info(`    · ${a}`);
     out.info("");
   }
+  if (account.observation !== null)
+    renderObservation(out, account.observation);
   out.info("Not measured here");
-  out.info("    Observed loading: not observed. Tokens and billed usage: not measured.");
+  if (account.observation === null) {
+    out.info("    Observed loading: not observed. Tokens and billed usage: not measured.");
+  } else {
+    out.info("    Observed above is ONE selected session's recorded delivery and usage. No token is attributed to any file.");
+  }
   for (const l of account.limits) {
     out.info(`    · ${l.what}`);
     out.info(`      owed to: ${l.owner}`);
   }
 }
+var REFUSAL_PROSE = {
+  "not-regular-file": "not a regular file",
+  "target-changed": "the file opened was not the file checked — refused rather than measured",
+  "path-unresolvable": "the path could not be resolved"
+};
+var STATUS_PROSE = {
+  absent: "not there",
+  unreadable: "could not be read",
+  empty: "no records",
+  malformed: "records present, none parsed — NOT a measured zero"
+};
+function renderObservation(out, obs) {
+  const head = obs.complete ? "Observed" : "Observed (PARTIAL)";
+  if (obs.status !== "read") {
+    const why = REFUSAL_PROSE[obs.refusalReason ?? ""] ?? STATUS_PROSE[obs.status] ?? obs.status;
+    out.info(`${head}    ${obs.selectedPath}`);
+    out.info(`    ${why}. Nothing was measured, and that is not a zero.`);
+    if (obs.bytesRead > 0 || obs.lines.total > 0) {
+      out.info(`    ${fmt(obs.bytesRead)} bytes read · ${fmt(obs.lines.total)} records seen` + (obs.lines.malformed > 0 ? ` · ${fmt(obs.lines.malformed)} malformed` : "") + (obs.lines.truncated ? " · stopped at the read bound" : "") + (obs.sha256 !== null ? ` · sha256 ${obs.sha256.slice(0, 16)}` : ""));
+    }
+    out.info("");
+    return;
+  }
+  const b = obs.binding;
+  out.info(`${head}    ${fmt(obs.bytesRead)} bytes read from the selected transcript`);
+  if (obs.canonicalPath !== null && obs.indirection) {
+    out.info(`    resolved through a link to ${obs.canonicalPath}`);
+  }
+  out.info(`    session ${b.sessionId ?? "unknown"} · runtime ${b.runtimeVersion ?? "unknown"} · scope ${b.scope}`);
+  out.info(`    interval ${b.firstTimestamp ?? "unknown"} .. ${b.lastTimestamp ?? "unknown"} · sha256 ${obs.sha256?.slice(0, 16) ?? "unknown"}`);
+  out.info(`    ${fmt(obs.lines.parsed)} of ${fmt(obs.lines.total)} records parsed` + (obs.lines.malformed > 0 ? ` · ${fmt(obs.lines.malformed)} malformed` : "") + (obs.lines.truncated ? " · stopped at the read bound" : "") + (obs.lines.cutFinalLine ? " · final record severed by the bound" : ""));
+  if (b.rejectedFields > 0) {
+    out.info(`    ${fmt(b.rejectedFields)} provenance value(s) in the file were refused as unsafe or over-long and read as unknown above.`);
+  }
+  if (!b.consistent) {
+    out.info("    NOT attributed to this workspace: session, runtime or directory is missing or varies across records.");
+  }
+  out.info("");
+  const u = obs.usage;
+  if (u === null) {
+    out.info("  Usage — no record carried a usage object. Unknown, not zero.");
+  } else {
+    const n = (v) => v === null ? "unknown" : fmt(v);
+    out.info(`  Usage over ${fmt(u.requests)} requests, from ${fmt(u.countedRecords)} usage-bearing records` + (u.duplicateRecords > 0 ? ` (${fmt(u.duplicateRecords)} repeated the same usage)` : ""));
+    out.info(`    fresh input   ${n(u.inputTokens)} tokens`);
+    out.info(`    cache read    ${n(u.cacheReadTokens)} tokens`);
+    out.info(`    cache written ${n(u.cacheCreationTokens)} tokens`);
+    out.info(`    output        ${n(u.outputTokens)} tokens`);
+    if (u.conflictingDuplicates > 0) {
+      out.info(`    ⚠ ${fmt(u.conflictingDuplicates)} request(s) reported conflicting usage; the figures above are incomplete`);
+    }
+    if (u.untaggedRecords > 0) {
+      out.info(`    ⚠ ${fmt(u.untaggedRecords)} record(s) carried usage with no request id; excluded, because they cannot be shown independent`);
+    }
+    if (u.unresolvedRequests > 0) {
+      out.info(`    ⚠ ${fmt(u.unresolvedRequests)} of ${fmt(u.requests)} request(s) carried no usage record, so what they cost is unknown — not zero`);
+    }
+    if (u.unresolvableRecords > 0) {
+      out.info(`    ⚠ ${fmt(u.unresolvableRecords)} record(s) had neither usage nor a request id; nothing can name or resolve them`);
+    }
+    if (u.incompleteFields.length > 0) {
+      out.info(`    ⚠ not every request reported: ${u.incompleteFields.join(", ")}`);
+    }
+  }
+  out.info("");
+  if (obs.deliveries.length > 0) {
+    out.info("  Recorded deliveries — payload bytes as stored, not injected or billed bytes");
+    for (const d of obs.deliveries) {
+      out.info(`    ${d.kind.padEnd(16)} ${d.label.padEnd(24)} ${String(d.occurrences).padStart(4)}x  ${fmt(d.recordedBytes)} bytes`);
+    }
+    out.info("");
+  }
+}
 async function runContext(args, deps = {}) {
   const out = new Output({ sink: deps.sink, noColor: deps.noColor });
   const config2 = (deps.loadConfigFn ?? loadConfig)();
@@ -31079,7 +31750,20 @@ async function runContext(args, deps = {}) {
     out.error(`Workspace "${slug}" not found. Run \`plinth login --workspace ${slug}\` first.`);
     return { exitCode: 1 };
   }
+  let observation = null;
+  if (args.observed !== undefined && args.observed !== "") {
+    let mirrorDir;
+    try {
+      mirrorDir = workspaceMirrorPath(slug);
+    } catch {
+      mirrorDir = undefined;
+    }
+    observation = (deps.buildObservationFn ?? buildObservation)(args.observed, {
+      workspaceMirrorDir: mirrorDir
+    });
+  }
   const account = buildContextAccount(slug, {
+    observation,
     hook: deps.hook ?? (() => defaultHook(slug)),
     listMemberCommands: deps.listMemberCommands,
     readStoreModes: deps.readStoreModes ?? readMemoryStoreModesNoWrite
@@ -31110,6 +31794,11 @@ var contextCommand = defineCommand({
       description: "Emit the account as JSON",
       required: false
     },
+    observed: {
+      type: "string",
+      description: "Path to ONE session transcript (.jsonl) to measure recorded delivery and usage from. Explicit: nothing is discovered or crawled, and no token is attributed to any file",
+      required: false
+    },
     "no-color": {
       type: "boolean",
       description: "Disable ANSI colour output",
@@ -31117,7 +31806,7 @@ var contextCommand = defineCommand({
     }
   },
   async run({ args }) {
-    const result = await runContext({ workspace: args.workspace, json: args.json === true }, { noColor: noColorFromArgs(args) });
+    const result = await runContext({ workspace: args.workspace, json: args.json === true, observed: args.observed }, { noColor: noColorFromArgs(args) });
     if (result.exitCode !== 0)
       process.exit(result.exitCode);
   }
@@ -31484,14 +32173,14 @@ var loginCommand = defineCommand({
 // src/lib/memory-gate/log.ts
 import {
   appendFileSync,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   mkdirSync as mkdirSync8,
-  openSync as openSync2,
+  openSync as openSync3,
   readFileSync as readFileSync12,
-  readSync,
+  readSync as readSync2,
   statSync as statSync3
 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/lib/sessions/registry.ts
 import {
@@ -31503,7 +32192,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename as basename2, dirname as dirname6, join as join8 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join9 } from "node:path";
 var SessionRecordSchema = exports_external.object({
   version: exports_external.literal(1),
   session_id: exports_external.string().min(1),
@@ -31524,13 +32213,13 @@ function sessionsDir(workspaceSlug) {
   if (!isSafeSegment(workspaceSlug)) {
     throw new Error(`Refusing unsafe workspace slug: ${workspaceSlug}`);
   }
-  return join8(plinthHome(), workspaceSlug, "sessions");
+  return join9(plinthHome(), workspaceSlug, "sessions");
 }
 function sessionRecordPath(workspaceSlug, sessionId) {
   if (!isSafeSegment(sessionId)) {
     throw new Error(`Refusing unsafe session id: ${sessionId}`);
   }
-  return join8(sessionsDir(workspaceSlug), `${sessionId}.json`);
+  return join9(sessionsDir(workspaceSlug), `${sessionId}.json`);
 }
 function registerSession(input) {
   const startTime = (input.startTimeFn ?? readPidStartTime)(input.pid);
@@ -31553,7 +32242,7 @@ function registerSession(input) {
 }
 var tmpCounter = 0;
 function writeRecordAtomic(target, record2) {
-  const dir = dirname6(target);
+  const dir = dirname7(target);
   mkdirSync7(dir, { recursive: true, mode: 448 });
   const tmp = `${target}.${process.pid}.${tmpCounter++}.tmp`;
   sweepDeadTmpFiles(dir, target);
@@ -31569,7 +32258,7 @@ function writeRecordAtomic(target, record2) {
   }
 }
 function sweepDeadTmpFiles(dir, target) {
-  const prefix = `${basename2(target)}.`;
+  const prefix = `${basename3(target)}.`;
   let names;
   try {
     names = readdirSync5(dir);
@@ -31586,7 +32275,7 @@ function sweepDeadTmpFiles(dir, target) {
     if (pid === process.pid || isPidAlive(pid))
       continue;
     try {
-      unlinkSync6(join8(dir, name));
+      unlinkSync6(join9(dir, name));
     } catch {}
   }
 }
@@ -31651,7 +32340,7 @@ function listSessions(workspaceSlug, deps = {}) {
   for (const name of names) {
     if (!name.endsWith(".json"))
       continue;
-    const path3 = join8(sessionsDir(workspaceSlug), name);
+    const path3 = join9(sessionsDir(workspaceSlug), name);
     const record2 = readSessionRecord(path3);
     if (!record2) {
       continue;
@@ -31710,10 +32399,10 @@ function memoryGateDir(workspaceSlug) {
   if (!isSafeSegment(workspaceSlug)) {
     throw new Error(`Refusing unsafe workspace slug: ${workspaceSlug}`);
   }
-  return join9(plinthHome(), "_memory_gate", workspaceSlug);
+  return join10(plinthHome(), "_memory_gate", workspaceSlug);
 }
 function memoryGateLogPath(workspaceSlug) {
-  return join9(memoryGateDir(workspaceSlug), "log.jsonl");
+  return join10(memoryGateDir(workspaceSlug), "log.jsonl");
 }
 function buildDecisionRecord(input) {
   const final = input.decision === "accept" ? input.proposed : input.decision === "reject" ? null : input.final ?? null;
@@ -31746,13 +32435,13 @@ function endsMidLine(path3) {
   }
   if (size === 0)
     return false;
-  const fd = openSync2(path3, "r");
+  const fd = openSync3(path3, "r");
   try {
     const last = Buffer.alloc(1);
-    readSync(fd, last, 0, 1, size - 1);
+    readSync2(fd, last, 0, 1, size - 1);
     return last[0] !== 10;
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 function appendMemoryGateRecord(workspaceSlug, record2) {
@@ -33017,10 +33706,10 @@ import { existsSync as existsSync9, readFileSync as readFileSync26, statSync as
 
 // src/lib/daemon-log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 var DEFAULT_DAEMON_LOG_MAX_BYTES = 5000000;
 function daemonLogPath() {
-  return join10(plinthHome(), "daemon.log");
+  return join11(plinthHome(), "daemon.log");
 }
 function daemonLogMaxBytes() {
   const raw = process.env.PLINTH_DAEMON_LOG_MAX_BYTES;
@@ -33042,7 +33731,7 @@ class DaemonLog {
     this.now = opts.now ?? (() => new Date);
     this.maxBytes = opts.maxBytes ?? daemonLogMaxBytes();
     try {
-      mkdirSync9(dirname7(this.path), { recursive: true });
+      mkdirSync9(dirname8(this.path), { recursive: true });
     } catch {}
     try {
       this.bytesWritten = statSync4(this.path).size;
@@ -33081,7 +33770,7 @@ class DaemonLog {
 // src/lib/destructive-gate.ts
 var import_gray_matter7 = __toESM(require_gray_matter(), 1);
 import { readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
-import { basename as basename3 } from "node:path";
+import { basename as basename4 } from "node:path";
 var GUTTING_RATIO_DEFAULT = 0.5;
 var GUTTING_MIN_PRIOR_BYTES = 200;
 function envFloat(name, def) {
@@ -33146,7 +33835,7 @@ function classifyDestructive(event, entityType, state, deps = {}) {
     return null;
   }
   const liveInode = statInode(event.absolutePath);
-  const slug = basename3(event.absolutePath, ".md");
+  const slug = basename4(event.absolutePath, ".md");
   const entry2 = (liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined) ?? getEntryBySlug(state, entityType, slug);
   if (!entry2)
     return null;
@@ -33261,18 +33950,18 @@ import { readFileSync as readFileSync18 } from "node:fs";
 
 // src/lib/conflicts.ts
 import { mkdirSync as mkdirSync10, readdirSync as readdirSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname9, join as join12 } from "node:path";
 function conflictsRoot(workspaceSlug) {
-  return join11(plinthHome(), "_conflicts", workspaceSlug);
+  return join12(plinthHome(), "_conflicts", workspaceSlug);
 }
 function conflictFilePath(args) {
   const { workspaceSlug, entityType, entitySlug, timestamp, side } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  return join11(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.${side}.md`);
+  return join12(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.${side}.md`);
 }
 function stashConflict(args) {
   const target = conflictFilePath(args);
-  mkdirSync10(dirname8(target), { recursive: true, mode: 448 });
+  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
   writeFileSync7(target, args.contents, { mode: 384 });
   return target;
 }
@@ -33280,11 +33969,11 @@ function fileConflictPath(args) {
   const { workspaceSlug, relPath, timestamp, side } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
   const safe = relPath.replace(/[/\\]/g, "__");
-  return join11(conflictsRoot(workspaceSlug), `files.${safe}.${iso}.${side}`);
+  return join12(conflictsRoot(workspaceSlug), `files.${safe}.${iso}.${side}`);
 }
 function stashFileConflict(args) {
   const target = fileConflictPath(args);
-  mkdirSync10(dirname8(target), { recursive: true, mode: 448 });
+  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
   writeFileSync7(target, args.bytes, { mode: 384 });
   return target;
 }
@@ -33317,7 +34006,7 @@ function listConflictStashes(workspaceSlug) {
   }
   const out = [];
   for (const file2 of names) {
-    const absPath = join11(dir, file2);
+    const absPath = join12(dir, file2);
     let st;
     try {
       st = statSync6(absPath);
@@ -33346,9 +34035,9 @@ function listConflictStashes(workspaceSlug) {
 import { readFileSync as readFileSync15, statSync as statSync7 } from "node:fs";
 
 // src/lib/files/content-hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function sha256Bytes(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
+  return createHash3("sha256").update(bytes).digest("hex");
 }
 
 // src/lib/files/mime.ts
@@ -33668,8 +34357,8 @@ class PerIdMutex {
 
 // src/lib/push.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
-import { basename as basename4, relative as relative5 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
+import { basename as basename5, relative as relative5 } from "node:path";
 
 // src/lib/frontmatter-id.ts
 var import_gray_matter8 = __toESM(require_gray_matter(), 1);
@@ -33856,6 +34545,10 @@ function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor,
 }
 
 // src/lib/push.ts
+var DELETE_DECLINED_PATH_EXISTS = "the file is on disk again — a newer write owns this row";
+function deleteDeclinedSentence(relPath) {
+  return `Not deleted: ${relPath} is on disk again, so the row was left alone. If you meant to delete it, remove the file and it will be retried.`;
+}
 function normaliseWireBody(body) {
   if (body === undefined)
     return;
@@ -34150,7 +34843,7 @@ async function pushFile(args) {
     const rel = relative5(workspaceMirrorPath(workspaceSlug), absolutePath);
     parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
   } catch {}
-  const slugFromPath = parsedSlug ?? basename4(absolutePath, ".md");
+  const slugFromPath = parsedSlug ?? basename5(absolutePath, ".md");
   const slug = identity === "path" ? slugFromPath : slugFromFm ?? slugFromPath;
   if (!slug) {
     return {
@@ -34233,15 +34926,16 @@ async function reconcileContextDocConflict(args) {
     now,
     output
   } = args;
+  const base2 = args.state;
   let state = args.state;
   const existingSlug = existing.slug;
   const existingId = existing.id;
   let fileSlug;
   try {
     const rel = relative5(workspaceMirrorPath(workspaceSlug), absolutePath);
-    fileSlug = strategy.parseMirrorPath(rel)?.slug ?? basename4(absolutePath, ".md");
+    fileSlug = strategy.parseMirrorPath(rel)?.slug ?? basename5(absolutePath, ".md");
   } catch {
-    fileSlug = basename4(absolutePath, ".md");
+    fileSlug = basename5(absolutePath, ".md");
   }
   if (fileSlug !== existingSlug) {
     const stashPath = stashConflict({
@@ -34282,7 +34976,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: fileSlug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: base2
     };
   }
   const stashPreLandCloudCopy = () => stashConflict({
@@ -34344,7 +35039,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: updated.slug,
         stashPath: preLandStash
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.code === 404) {
@@ -34402,7 +35098,8 @@ async function reconcileContextDocConflict(args) {
         entitySlug: fileSlug,
         stashPath
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.reason === "context_doc_conflict") {
@@ -34430,10 +35127,11 @@ async function runPushUpsert(args) {
     const hashBody = hashableBody(strategy, bodyMarkdown);
     const newBodyHash = stableHash(hashBody);
     const newFrontmatterHash = stableHash({ ...userFm, ...lifted.topLevel });
-    const liveEntry = getEntry(args.state, strategy.type, args.stateEntry.id) ?? args.stateEntry;
+    const snapshotEntry = getEntry(args.state, strategy.type, args.stateEntry.id) ?? args.stateEntry;
+    const liveEntry = committedEntryIfNewer(args.workspaceSlug, strategy.type, snapshotEntry) ?? snapshotEntry;
     const bodyChanged = newBodyHash !== liveEntry.body_hash;
     const frontmatterChanged = newFrontmatterHash !== liveEntry.frontmatter_hash;
-    let workingState = args.state;
+    let workingState = liveEntry === snapshotEntry ? args.state : upsertEntry(args.state, strategy.type, liveEntry).state;
     if (fm["id"] === undefined && workingState.frontmatter_id_backfill_version !== undefined) {
       const cleared = clearFrontmatterIdBackfillMarker(workingState);
       if (cleared.changed) {
@@ -34442,6 +35140,69 @@ async function runPushUpsert(args) {
         } catch {}
       }
     }
+    const wireProjection = (md) => {
+      try {
+        const p = import_gray_matter10.default(md);
+        const f = p.data ?? {};
+        const l = splitUserFrontmatter(strategy, f);
+        const u = userFrontmatter(strategy, l.frontmatter);
+        return stableHash({
+          body: strategy.bodyToWire(p.content),
+          frontmatter: { ...u, ...l.topLevel }
+        });
+      } catch {
+        return null;
+      }
+    };
+    if (liveEntry !== snapshotEntry) {
+      let onDisk = null;
+      try {
+        onDisk = readFileSync17(args.absolutePath, "utf8");
+      } catch {
+        onDisk = null;
+      }
+      if (onDisk !== null && onDisk !== args.raw) {
+        let disk = null;
+        try {
+          disk = computeMirrorHashes(strategy, onDisk);
+        } catch {
+          disk = null;
+        }
+        if (disk !== null && disk.bodyHash === liveEntry.body_hash && disk.frontmatterHash === liveEntry.frontmatter_hash) {
+          const ours = wireProjection(args.raw);
+          const theirs = wireProjection(onDisk);
+          if (ours !== null && theirs !== null && ours === theirs) {
+            return {
+              outcome: {
+                kind: "noop",
+                entityType: strategy.type,
+                entitySlug: liveEntry.slug
+              },
+              state: workingState,
+              base: workingState
+            };
+          }
+          const stashPath2 = stashConflict({
+            workspaceSlug: args.workspaceSlug,
+            entityType: strategy.type,
+            entitySlug: liveEntry.slug,
+            timestamp: args.now(),
+            contents: args.raw,
+            side: "local"
+          });
+          return {
+            outcome: {
+              kind: "conflict",
+              entityType: strategy.type,
+              entitySlug: liveEntry.slug,
+              stashPath: stashPath2
+            },
+            state: workingState,
+            base: workingState
+          };
+        }
+      }
+    }
     if (!bodyChanged && !frontmatterChanged) {
       return {
         outcome: {
@@ -34449,7 +35210,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: workingState
+        state: workingState,
+        base: workingState
       };
     }
     const wireBodyFields = bodyChanged ? strategy.bodyToWire(bodyMarkdown) : undefined;
@@ -34468,7 +35230,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: persistEntry(workingState, strategy.type, updated)
+        state: persistEntry(workingState, strategy.type, updated),
+        base: workingState
       };
     }
     const mergedTopLevel = split || wireBodyFields?.topLevel ? {
@@ -34504,7 +35267,8 @@ async function runPushUpsert(args) {
           fields,
           pushed: false
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     let patchResult = await patchEntity({
@@ -34577,7 +35341,8 @@ async function runPushUpsert(args) {
             fields,
             pushed: true
           },
-          state: nextState2
+          state: nextState2,
+          base: workingState
         };
       }
       return {
@@ -34586,7 +35351,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: updated.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (patchResult.code === 404) {
@@ -34596,7 +35362,8 @@ async function runPushUpsert(args) {
           entityType: strategy.type,
           entitySlug: liveEntry.slug
         },
-        state: workingState
+        state: workingState,
+        base: workingState
       };
     }
     if (patchResult.reason === "slug_conflict") {
@@ -34666,7 +35433,8 @@ async function runPushUpsert(args) {
         entitySlug: liveEntry.slug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -34685,6 +35453,7 @@ async function reconcileTaskConflict(args) {
     now,
     output
   } = args;
+  const base2 = args.state;
   let state = args.state;
   const stashLocalSide = () => stashConflict({
     workspaceSlug,
@@ -34717,7 +35486,8 @@ async function reconcileTaskConflict(args) {
         entitySlug: liveEntry.slug,
         stashPath: stashPath2
       },
-      state
+      state,
+      base: base2
     };
   }
   let cloudRow = null;
@@ -34735,7 +35505,8 @@ async function reconcileTaskConflict(args) {
         entityType: strategy.type,
         entitySlug: liveEntry.slug
       },
-      state
+      state,
+      base: base2
     };
   }
   const stashCloudSide = () => stashConflict({
@@ -34775,7 +35546,8 @@ async function reconcileTaskConflict(args) {
         entitySlug: patchResult.doc.slug,
         stashPath: stashPath2
       },
-      state
+      state,
+      base: base2
     };
   }
   if (patchResult.code === 404) {
@@ -34786,7 +35558,8 @@ async function reconcileTaskConflict(args) {
         entityType: strategy.type,
         entitySlug: liveEntry.slug
       },
-      state
+      state,
+      base: base2
     };
   }
   const stashPath = stashLocalSide();
@@ -34809,7 +35582,8 @@ async function reconcileTaskConflict(args) {
       entitySlug: liveEntry.slug,
       stashPath
     },
-    state
+    state,
+    base: base2
   };
 }
 function writeCreatedIdBack(args) {
@@ -34920,7 +35694,8 @@ async function runPushCreate(args) {
             fields,
             pushed: true
           },
-          state: nextState2
+          state: nextState2,
+          base: args.state
         };
       }
       return {
@@ -34929,7 +35704,8 @@ async function runPushCreate(args) {
           entityType: strategy.type,
           entitySlug: doc2.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: args.state
       };
     }
     if (createResult.reason === "context_doc_conflict") {
@@ -34978,7 +35754,8 @@ async function runPushCreate(args) {
         entitySlug: args.slug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: args.state
     };
   });
 }
@@ -34997,7 +35774,7 @@ async function runPushDelete(args) {
       const rel = relative5(workspaceMirrorPath(args.workspaceSlug), args.absolutePath);
       parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
     } catch {}
-    const lookupSlug = parsedSlug ?? basename4(args.absolutePath, ".md");
+    const lookupSlug = parsedSlug ?? basename5(args.absolutePath, ".md");
     const entry2 = getEntryBySlug(args.state, strategy.type, lookupSlug);
     if (entry2) {
       id = entry2.id;
@@ -35012,12 +35789,31 @@ async function runPushDelete(args) {
         absolutePath: args.absolutePath,
         reason: "untracked file — no cloud row to delete"
       },
-      state: args.state
+      state: args.state,
+      base: args.state
     };
   }
   return args.mutex.run(id, async () => {
-    const live = getEntry(args.state, strategy.type, id) ?? null;
+    const snapshot = getEntry(args.state, strategy.type, id) ?? null;
+    const live = snapshot ? committedEntryIfNewer(args.workspaceSlug, strategy.type, snapshot) ?? snapshot : null;
+    if (existsSync4(args.absolutePath)) {
+      args.output?.log(entityDeleteSuppressedLine({
+        entityType: strategy.type,
+        slug,
+        reason: "path_exists"
+      }));
+      return {
+        outcome: {
+          kind: "ignored",
+          absolutePath: args.absolutePath,
+          reason: DELETE_DECLINED_PATH_EXISTS
+        },
+        state: args.state,
+        base: args.state
+      };
+    }
     const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const workingState = live && live !== snapshot ? upsertEntry(args.state, strategy.type, live).state : args.state;
     const result = await deleteEntity({
       strategy,
       baseUrl: args.baseUrl,
@@ -35027,7 +35823,7 @@ async function runPushDelete(args) {
       fetchImpl: args.fetchImpl
     });
     if (result.ok) {
-      const nextState2 = dropEntry(args.state, strategy.type, id);
+      const nextState2 = dropEntry(workingState, strategy.type, id);
       args.output?.log(`[DELETE entityType=${strategy.type} slug=${slug} id=${id}]`);
       return {
         outcome: {
@@ -35035,11 +35831,12 @@ async function runPushDelete(args) {
           entityType: strategy.type,
           entitySlug: slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (result.code === 404) {
-      const nextState2 = dropEntry(args.state, strategy.type, id);
+      const nextState2 = dropEntry(workingState, strategy.type, id);
       args.output?.log(`[DELETE entityType=${strategy.type} slug=${slug} id=${id} note=already_absent]`);
       return {
         outcome: {
@@ -35047,7 +35844,8 @@ async function runPushDelete(args) {
           entityType: strategy.type,
           entitySlug: slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     const nextState = await pullAndWriteMirror({
@@ -35069,7 +35867,8 @@ async function runPushDelete(args) {
         entitySlug: slug,
         stashPath: ""
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -35096,13 +35895,15 @@ async function pushRename(args) {
   let toSlug;
   try {
     const rel = relative5(workspaceMirrorPath(workspaceSlug), toPath);
-    toSlug = strategy.parseMirrorPath(rel)?.slug ?? basename4(toPath, ".md");
+    toSlug = strategy.parseMirrorPath(rel)?.slug ?? basename5(toPath, ".md");
   } catch {
-    toSlug = basename4(toPath, ".md");
+    toSlug = basename5(toPath, ".md");
   }
   return mutex.run(id, async () => {
-    const live = getEntry(state, entityType, id);
+    const snapshot = getEntry(state, entityType, id);
+    const live = snapshot ? committedEntryIfNewer(workspaceSlug, entityType, snapshot) ?? snapshot : undefined;
     const effectiveExpected = live?.updated_at ?? expectedUpdatedAt;
+    const workingState = live && live !== snapshot ? upsertEntry(state, entityType, live).state : state;
     let patchResult = await patchEntity({
       strategy,
       baseUrl,
@@ -35162,7 +35963,7 @@ async function pushRename(args) {
           updated.body_len = renameHashBody.length;
         } catch {}
       }
-      const nextState2 = persistEntry(state, entityType, updated);
+      const nextState2 = persistEntry(workingState, entityType, updated);
       output?.log(`[RENAME entityType=${entityType} fromSlug=${fromSlug} toSlug=${doc2.slug} id=${doc2.id}]`);
       return {
         outcome: {
@@ -35171,13 +35972,15 @@ async function pushRename(args) {
           fromSlug,
           toSlug: doc2.slug
         },
-        state: nextState2
+        state: nextState2,
+        base: workingState
       };
     }
     if (patchResult.code === 404) {
       return {
         outcome: { kind: "not_found", entityType, entitySlug: fromSlug },
-        state
+        state: workingState,
+        base: workingState
       };
     }
     if (patchResult.reason === "slug_conflict") {
@@ -35199,7 +36002,7 @@ async function pushRename(args) {
         baseUrl,
         pat,
         id: patchResult.existing.id,
-        state,
+        state: workingState,
         fetchImpl,
         echo,
         output,
@@ -35225,7 +36028,8 @@ async function pushRename(args) {
           toSlug,
           stashPath: stashPath2
         },
-        state: finalState
+        state: finalState,
+        base: workingState
       };
     }
     let contents = "";
@@ -35246,7 +36050,7 @@ async function pushRename(args) {
       baseUrl,
       pat,
       id,
-      state,
+      state: workingState,
       fetchImpl,
       echo,
       output,
@@ -35259,7 +36063,8 @@ async function pushRename(args) {
         entitySlug: fromSlug,
         stashPath
       },
-      state: nextState
+      state: nextState,
+      base: workingState
     };
   });
 }
@@ -35295,13 +36100,14 @@ async function applyBatch(batch, deps, mutex) {
         await applyFileOp(op, deps);
         continue;
       }
+      const base2 = deps.getState();
       const result = await pushFile({
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         absolutePath: opPath(deps.workspaceSlug, op),
         entityType: op.entityType,
-        state: deps.getState(),
+        state: base2,
         exists: op.kind === "overwrite",
         unlinkContext: op.kind === "delete" ? { id: op.id, slug: op.slug, updated_at: op.updated_at } : null,
         deps: {
@@ -35312,7 +36118,10 @@ async function applyBatch(batch, deps, mutex) {
           echo: deps.echo
         }
       });
-      deps.setState(result.state);
+      deps.applyState(result.base ?? base2, result.state);
+      if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+        deps.output?.warn(deleteDeclinedSentence(opPath(deps.workspaceSlug, op)));
+      }
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       deps.output?.warn(`Apply failed for ${opLabel(op)}: ${msg} (left for the next pull to reconcile).`);
@@ -35322,27 +36131,29 @@ async function applyBatch(batch, deps, mutex) {
 async function applyFileOp(op, deps) {
   const fileDeps = { fetchImpl: deps.fetchImpl, now: deps.now, output: deps.output };
   if (op.kind === "delete") {
+    const base3 = deps.getState();
     const result2 = await pushFilesDelete({
       workspaceSlug: deps.workspaceSlug,
       baseUrl: deps.baseUrl,
       pat: deps.pat,
       relPath: op.path,
-      state: deps.getState(),
+      state: base3,
       deps: fileDeps
     });
-    deps.setState(result2.state);
+    deps.applyState(base3, result2.state);
     return;
   }
+  const base2 = deps.getState();
   const result = await pushFilesUpsert({
     workspaceSlug: deps.workspaceSlug,
     baseUrl: deps.baseUrl,
     pat: deps.pat,
     absolutePath: filesSubtreePath(deps.workspaceSlug, op.path),
     relPath: op.path,
-    state: deps.getState(),
+    state: base2,
     deps: fileDeps
   });
-  deps.setState(result.state);
+  deps.applyState(base2, result.state);
 }
 async function discardBatchOps(batch, deps) {
   for (const op of batch.ops) {
@@ -35371,19 +36182,20 @@ async function discardBatchOps(batch, deps) {
           });
         }
       }
+      const base2 = deps.getState();
       const next = await pullAndWriteMirror({
         strategy,
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         id: op.id,
-        state: deps.getState(),
+        state: base2,
         fetchImpl: deps.fetchImpl,
         echo: deps.echo,
         output: deps.output,
         now: deps.now
       });
-      deps.setState(next);
+      deps.applyState(base2, next);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       deps.output?.warn(`Discard restore failed for ${opLabel(op)}: ${msg} (the next pull will reconcile).`);
@@ -35407,17 +36219,18 @@ async function discardFileOp(op, deps) {
       side: "local"
     });
   }
+  const base2 = deps.getState();
   const next = await restoreFileFromCloud({
     workspaceSlug: deps.workspaceSlug,
     baseUrl: deps.baseUrl,
     pat: deps.pat,
     id: op.id,
     relPath: op.path,
-    state: deps.getState(),
+    state: base2,
     fetchImpl: deps.fetchImpl,
     output: deps.output
   });
-  deps.setState(next);
+  deps.applyState(base2, next);
 }
 function opPath(workspaceSlug, op) {
   try {
@@ -35430,7 +36243,7 @@ function opPath(workspaceSlug, op) {
 }
 
 // src/lib/files/classify.ts
-import { relative as relative6, sep as sep4 } from "node:path";
+import { relative as relative6, sep as sep5 } from "node:path";
 var FILES_SUBTREE = "files";
 function classifyFilesPath(args) {
   let root;
@@ -35440,20 +36253,20 @@ function classifyFilesPath(args) {
     return null;
   }
   const rel = relative6(root, args.absolutePath);
-  if (rel.startsWith("..") || rel.startsWith(sep4))
+  if (rel.startsWith("..") || rel.startsWith(sep5))
     return null;
-  const prefix = FILES_SUBTREE + sep4;
+  const prefix = FILES_SUBTREE + sep5;
   if (!rel.startsWith(prefix))
     return null;
   const sub = rel.slice(prefix.length);
   if (sub.length === 0)
     return null;
-  const posix = sep4 === "/" ? sub : sub.split(sep4).join("/");
+  const posix = sep5 === "/" ? sub : sub.split(sep5).join("/");
   return validateFilesRelPath(posix) ? { relPath: posix } : null;
 }
 
 // src/lib/memory-facts/sync.ts
-import { isAbsolute as isAbsolute2, relative as relative7, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute2, relative as relative7, sep as sep6 } from "node:path";
 
 // src/lib/memory-facts/api.ts
 var FactCommonSchema = exports_external.object({
@@ -35774,7 +36587,7 @@ function classifyMemoryFactPath(args) {
   const rel = relative7(root, args.absolutePath);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel))
     return null;
-  const mirrorRel = `${MEMORY_FACTS_DIR}/${rel.split(sep5).join("/")}`;
+  const mirrorRel = `${MEMORY_FACTS_DIR}/${rel.split(sep6).join("/")}`;
   return { relPath: mirrorRel, fact: parseMemoryFactRelPath(mirrorRel) };
 }
 function classifyMemoryFactEvent(args) {
@@ -35933,7 +36746,7 @@ class FileDestructiveGate {
 import { readFileSync as readFileSync19, statSync as statSync10 } from "node:fs";
 
 // src/lib/unsynced.ts
-import { join as join12, relative as relative8 } from "node:path";
+import { join as join13, relative as relative8 } from "node:path";
 var RECORDABLE_REASONS = new Set([
   "rate_limit",
   "server",
@@ -35978,7 +36791,7 @@ function recordFileUnsynced(args) {
   });
 }
 async function drainUnsyncedOps(args) {
-  const { workspaceSlug, baseUrl, pat, getState, setState, fetchImpl, mutex, output, echo } = args;
+  const { workspaceSlug, baseUrl, pat, getState, applyState, fetchImpl, mutex, output, echo } = args;
   const now = args.now ?? (() => new Date);
   const ops = listUnsynced(getState());
   let attempted = 0;
@@ -35989,51 +36802,59 @@ async function drainUnsyncedOps(args) {
     const before = getState();
     const { state: next, changed } = removeUnsynced(before, target, path5);
     if (changed)
-      setState(commitState(before, next));
+      applyState(before, commitState(before, next));
   };
   for (const op of ops) {
     attempted += 1;
     try {
       if (op.target === "entity") {
-        const absolutePath = join12(workspaceMirrorPath(workspaceSlug), op.path);
+        const absolutePath = join13(workspaceMirrorPath(workspaceSlug), op.path);
         const classified = classifyMirrorPath({ workspaceSlug, absolutePath });
         if (!classified) {
           clear("entity", op.path);
           resolved += 1;
           continue;
         }
+        const base2 = getState();
         const result = await pushFile({
           workspaceSlug,
           baseUrl,
           pat,
           absolutePath,
           entityType: classified.entityType,
-          state: getState(),
+          state: base2,
           exists: op.op === "upsert",
           unlinkContext: null,
           deps: { fetchImpl, now, mutex, output, echo }
         });
-        setState(result.state);
+        applyState(result.base ?? base2, result.state);
+        if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+          output?.warn(deleteDeclinedSentence(op.path));
+        }
       } else {
         const absolutePath = filesSubtreePath(workspaceSlug, op.path);
-        const doFile = () => op.op === "delete" ? pushFilesDelete({
-          workspaceSlug,
-          baseUrl,
-          pat,
-          relPath: op.path,
-          state: getState(),
-          deps: { fetchImpl, now, output }
-        }) : pushFilesUpsert({
-          workspaceSlug,
-          baseUrl,
-          pat,
-          absolutePath,
-          relPath: op.path,
-          state: getState(),
-          deps: { fetchImpl, now, output }
-        });
+        let base2;
+        const doFile = () => {
+          base2 = getState();
+          return op.op === "delete" ? pushFilesDelete({
+            workspaceSlug,
+            baseUrl,
+            pat,
+            relPath: op.path,
+            state: base2,
+            deps: { fetchImpl, now, output }
+          }) : pushFilesUpsert({
+            workspaceSlug,
+            baseUrl,
+            pat,
+            absolutePath,
+            relPath: op.path,
+            state: base2,
+            deps: { fetchImpl, now, output }
+          });
+        };
         const result = mutex ? await mutex.run(`files:${op.path}`, doFile) : await doFile();
-        setState(result.state);
+        applyState(base2, result.state);
       }
       clear(op.target, op.path);
       resolved += 1;
@@ -36053,7 +36874,7 @@ async function drainUnsyncedOps(args) {
           message: cat.serverMessage,
           rejected_at: now().toISOString()
         });
-        setState(commitState(beforeReject, next2));
+        applyState(beforeReject, commitState(beforeReject, next2));
         continue;
       }
       stillFailing += 1;
@@ -36066,7 +36887,7 @@ async function drainUnsyncedOps(args) {
         last_reason: cat.reason
       });
       if (changed)
-        setState(commitState(beforeRetry, next));
+        applyState(beforeRetry, commitState(beforeRetry, next));
     }
   }
   return { attempted, resolved, stillFailing, rejected };
@@ -36240,10 +37061,10 @@ class ReaddirpStream extends Readable {
   }
   async _formatEntry(dirent, path5) {
     let entry2;
-    const basename5 = this._isDirent ? dirent.name : dirent;
+    const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename5));
-      entry2 = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
+      const fullPath = presolve(pjoin(path5, basename6));
+      entry2 = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry2[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -36770,9 +37591,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path5);
-    const basename6 = sp.basename(path5);
+    const basename7 = sp.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename6);
+    parent.add(basename7);
     const absolutePath = sp.resolve(path5);
     const options2 = {
       persistent: opts.persistent
@@ -36782,7 +37603,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
+      options2.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -36800,11 +37621,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname10 = sp.dirname(file2);
-    const basename6 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname10);
+    const dirname11 = sp.dirname(file2);
+    const basename7 = sp.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname11);
     let prevStats = stats;
-    if (parent.has(basename6))
+    if (parent.has(basename7))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -36829,9 +37650,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error52) {
-          this.fsw._remove(dirname10, basename6);
+          this.fsw._remove(dirname11, basename7);
         }
-      } else if (parent.has(basename6)) {
+      } else if (parent.has(basename7)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -36918,7 +37739,7 @@ class NodeFsHandler {
         this._addToNodeFs(path5, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -36927,7 +37748,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve4(undefined);
+        resolve5(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -37686,7 +38507,7 @@ var chokidar_default = { watch, FSWatcher };
 
 // src/lib/watcher.ts
 import { statSync as statSync9 } from "node:fs";
-import { sep as sep6 } from "node:path";
+import { sep as sep7 } from "node:path";
 
 // src/lib/rename-classifier.ts
 class RenameClassifier {
@@ -37817,7 +38638,7 @@ function watcherIgnoreMatcher(workspaceRoot) {
   return (absolutePath) => patterns.some((re) => re.test(absolutePath));
 }
 function escSep() {
-  return sep6 === "/" ? "/" : "\\\\";
+  return sep7 === "/" ? "/" : "\\\\";
 }
 
 class DebounceMap {
@@ -38345,7 +39166,9 @@ async function pushArtistMemory(args) {
   }
   const localHash = stableHash(local);
   const runPatch = async () => {
-    let base2 = args.mutex ? loadState(workspaceSlug) : state;
+    const snapshotEntry = getEntryBySlug(state, ENTITY_TYPE, slug);
+    const fresher = args.mutex && snapshotEntry ? committedEntryIfNewer(workspaceSlug, ENTITY_TYPE, snapshotEntry) : undefined;
+    let base2 = fresher ? upsertEntry(state, ENTITY_TYPE, fresher).state : state;
     const entry2 = getEntryBySlug(base2, ENTITY_TYPE, slug);
     if (!entry2)
       return { state: base2, outcome: { kind: "ignored", slug } };
@@ -41474,7 +42297,7 @@ class Semaphore {
       this.active += 1;
       return;
     }
-    await new Promise((resolve5) => this.waiters.push(resolve5));
+    await new Promise((resolve6) => this.waiters.push(resolve6));
   }
   release() {
     const next = this.waiters.shift();
@@ -41541,11 +42364,11 @@ import {
   statSync as statSync16,
   unlinkSync as unlinkSync8
 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/lib/conflicts-view.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var NO_GENERATED_MEMORY = {
   artistMemoryGenerated: () => false,
   workspaceMemoryGenerated: () => false,
@@ -41591,7 +42414,7 @@ function resolveConflictRows(workspaceSlug, stashes, generatedMemory = NO_GENERA
     if (validateFilesRelPath(rel) === null) {
       return { kind: "unsafe-path", stash };
     }
-    const abs = join15(root, "files", rel);
+    const abs = join16(root, "files", rel);
     if (hasSymlinkedComponent(workspaceSlug, abs)) {
       return { kind: "unsafe-path", stash };
     }
@@ -41724,7 +42547,7 @@ function refreshConflictsView(workspaceSlug) {
 import { existsSync as existsSync7, readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
 
 // src/lib/files/extracted-text.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var DERIVED_TEXT_VERSION = 2;
 function yamlString3(value) {
   return JSON.stringify(value);
@@ -41798,7 +42621,7 @@ ${doc2.text}
 `;
 }
 function extractedTextHash(rendered) {
-  return createHash3("sha256").update(rendered, "utf8").digest("hex");
+  return createHash4("sha256").update(rendered, "utf8").digest("hex");
 }
 
 // src/lib/files/pull.ts
@@ -42417,7 +43240,7 @@ function hasExistingContent(workspacePath) {
       if (!e.isDirectory())
         return true;
       try {
-        return readdirSync7(join16(workspacePath, e.name)).length > 0;
+        return readdirSync7(join17(workspacePath, e.name)).length > 0;
       } catch {
         return true;
       }
@@ -43221,7 +44044,7 @@ function makeWatchHandler(deps) {
     spinner,
     mutex,
     getState,
-    setState,
+    applyState,
     fetchImpl,
     now,
     output,
@@ -43231,6 +44054,10 @@ function makeWatchHandler(deps) {
     fileGate,
     isFileFrozen
   } = deps;
+  const applyFromCurrent = (update) => {
+    const base2 = getState();
+    applyState(base2, update(base2));
+  };
   const handleFilesEvent = async (relPath, absolutePath, exists) => {
     try {
       if (isFileFrozen?.(relPath))
@@ -43240,8 +44067,8 @@ function makeWatchHandler(deps) {
       } catch (err) {
         if (!(err instanceof MirrorSymlinkError))
           throw err;
-        setState(recordFileSymlinkRefused({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileSymlinkRefused({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           now: now ?? (() => new Date)
@@ -43267,15 +44094,16 @@ function makeWatchHandler(deps) {
           }
         }
         await mutex.run(`files:${relPath}`, async () => {
+          const base2 = getState();
           const result = await pushFilesDelete({
             workspaceSlug,
             baseUrl,
             pat,
             relPath,
-            state: getState(),
+            state: base2,
             deps: { fetchImpl, now, output, suppressor }
           });
-          setState(clearReportedSafeFileRejected(result.state, relPath));
+          applyState(base2, clearReportedSafeFileRejected(result.state, relPath));
           reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
         });
         return;
@@ -43300,8 +44128,8 @@ function makeWatchHandler(deps) {
           max: MAX_WORKSPACE_FILE_BYTES,
           source: "client"
         }));
-        setState(recordFileOverCap({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileOverCap({
+          state: base2,
           relPath,
           size: st.size,
           max: MAX_WORKSPACE_FILE_BYTES,
@@ -43329,17 +44157,18 @@ function makeWatchHandler(deps) {
         }
       }
       await mutex.run(`files:${relPath}`, async () => {
+        const base2 = getState();
         const result = await pushFilesUpsert({
           workspaceSlug,
           baseUrl,
           pat,
           absolutePath,
           relPath,
-          state: getState(),
+          state: base2,
           prepared: { bytes, hash: hash2, size: st.size, inode: st.ino },
           deps: { fetchImpl, now, output, suppressor }
         });
-        setState(result.outcome.kind === "over_cap" ? result.state : clearFileRejected(result.state, relPath));
+        applyState(base2, result.outcome.kind === "over_cap" ? result.state : clearFileRejected(result.state, relPath));
         reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
       });
     } catch (err) {
@@ -43347,16 +44176,16 @@ function makeWatchHandler(deps) {
       output?.log(fileFailedLine({ path: relPath, ...categorizeError(err) }));
       spinner.warn(`File push failed for files/${relPath}: ${msg}`);
       if (isRecordableFailure(err)) {
-        setState(recordFileUnsynced({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileUnsynced({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           err,
           now: now ?? (() => new Date)
         }));
       } else if (isPermanentReject(err)) {
-        setState(recordFileRejected({
-          state: getState(),
+        applyFromCurrent((base2) => recordFileRejected({
+          state: base2,
           relPath,
           op: exists ? "upsert" : "delete",
           err,
@@ -43384,17 +44213,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(WORKSPACE_RULES_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushWorkspaceRules({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportWorkspaceRulesOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -43422,17 +44252,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushWorkspaceMemory({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportWorkspaceMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -43460,17 +44291,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(USER_MEMORY_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushUserMemory({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportUserMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -43498,17 +44330,18 @@ function makeWatchHandler(deps) {
     }
     try {
       await mutex.run(VOICE_MUTEX_KEY, async () => {
+        const base2 = getState();
         const result = await pushVoice({
           workspaceSlug,
           baseUrl,
           pat,
-          state: getState(),
+          state: base2,
           fetchImpl,
           now,
           output,
           suppressor
         });
-        setState(result.state);
+        applyState(base2, result.state);
         reportVoiceOutcome(spinner, workspaceSlug, result.state, result.outcome);
       });
     } catch (err) {
@@ -43535,19 +44368,20 @@ function makeWatchHandler(deps) {
       }
     }
     try {
+      const base2 = getState();
       const result = await pushArtistMemory({
         workspaceSlug,
         baseUrl,
         pat,
         slug,
-        state: getState(),
+        state: base2,
         fetchImpl,
         now,
         output,
         suppressor,
         mutex
       });
-      setState(result.state);
+      applyState(base2, result.state);
       reportArtistMemoryOutcome(spinner, workspaceSlug, result.state, result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
@@ -43580,6 +44414,7 @@ function makeWatchHandler(deps) {
           await handle({ kind: "upsert", absolutePath: event.toPath });
           return;
         }
+        const base3 = getState();
         const result2 = await pushRename({
           workspaceSlug,
           baseUrl,
@@ -43590,7 +44425,7 @@ function makeWatchHandler(deps) {
           id: event.id,
           expectedUpdatedAt: event.expectedUpdatedAt,
           fromSlug: event.fromSlug,
-          state: getState(),
+          state: base3,
           deps: {
             fetchImpl,
             now,
@@ -43599,7 +44434,7 @@ function makeWatchHandler(deps) {
             echo: suppressor ? { watcher: "live", suppressor } : undefined
           }
         });
-        setState(result2.state);
+        applyState(base3, result2.state);
         reportOutcome(spinner, workspaceSlug, result2.state, result2.outcome);
         return;
       }
@@ -43658,8 +44493,8 @@ function makeWatchHandler(deps) {
       if (!classified) {
         const key = entitySymlinkRefusalKey({ workspaceSlug, absolutePath });
         if (key) {
-          setState(recordEntitySymlinkRefused({
-            state: getState(),
+          applyFromCurrent((base3) => recordEntitySymlinkRefused({
+            state: base3,
             mirrorRelativePath: key,
             op: event.kind === "unlink" ? "delete" : "upsert",
             now: now ?? (() => new Date)
@@ -43716,13 +44551,14 @@ function makeWatchHandler(deps) {
           return;
         }
       }
+      const base2 = getState();
       const result = await pushFile({
         workspaceSlug,
         baseUrl,
         pat,
         absolutePath,
         entityType: classified.entityType,
-        state: getState(),
+        state: base2,
         exists: event.kind === "upsert",
         unlinkContext: event.kind === "unlink" && event.stateEntry ? {
           id: event.stateEntry.id,
@@ -43738,7 +44574,7 @@ function makeWatchHandler(deps) {
           echo: suppressor ? { watcher: "live", suppressor } : undefined
         }
       });
-      setState(clearEntityRejected(result.state, workspaceSlug, absolutePath));
+      applyState(result.base ?? base2, clearEntityRejected(result.state, workspaceSlug, absolutePath));
       reportOutcome(spinner, workspaceSlug, getState(), result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
@@ -43754,8 +44590,8 @@ function makeWatchHandler(deps) {
         }));
       }
       if (classified && event.kind !== "renamed" && isRecordableFailure(err)) {
-        setState(recordEntityUnsynced({
-          state: getState(),
+        applyFromCurrent((base2) => recordEntityUnsynced({
+          state: base2,
           workspaceSlug,
           absolutePath: path5,
           op: event.kind === "unlink" ? "delete" : "upsert",
@@ -43763,8 +44599,8 @@ function makeWatchHandler(deps) {
           now: now ?? (() => new Date)
         }));
       } else if (classified && event.kind !== "renamed" && isPermanentReject(err)) {
-        setState(recordEntityRejected({
-          state: getState(),
+        applyFromCurrent((base2) => recordEntityRejected({
+          state: base2,
           workspaceSlug,
           absolutePath: path5,
           op: event.kind === "unlink" ? "delete" : "upsert",
@@ -43783,6 +44619,7 @@ function discardSink() {
 }
 async function flushHeldEntityOp(deps) {
   const now = deps.now ?? (() => new Date);
+  const base2 = deps.getState();
   try {
     const result = await pushFile({
       workspaceSlug: deps.workspaceSlug,
@@ -43790,7 +44627,7 @@ async function flushHeldEntityOp(deps) {
       pat: deps.pat,
       absolutePath: deps.op.absolutePath,
       entityType: deps.op.entityType,
-      state: deps.getState(),
+      state: base2,
       exists: deps.op.kind === "overwrite",
       unlinkContext: deps.op.kind === "delete" ? { id: deps.op.id, slug: deps.op.slug, updated_at: deps.op.updatedAt } : null,
       deps: {
@@ -43801,7 +44638,10 @@ async function flushHeldEntityOp(deps) {
         echo: deps.echo
       }
     });
-    deps.setState(result.state);
+    deps.applyState(result.base ?? base2, result.state);
+    if (result.outcome.kind === "ignored" && result.outcome.reason === DELETE_DECLINED_PATH_EXISTS) {
+      deps.spinner.warn(deleteDeclinedSentence(deps.op.absolutePath));
+    }
     reportOutcome(deps.spinner, deps.workspaceSlug, deps.getState(), result.outcome);
   } catch (err) {
     const msg = err instanceof Error ? err.message : "unknown push error";
@@ -43813,8 +44653,8 @@ async function flushHeldEntityOp(deps) {
     }));
     deps.spinner.warn(`Push failed for ${deps.op.entityType}/${deps.op.slug}: ${msg}`);
     if (isRecordableFailure(err)) {
-      deps.setState(recordEntityUnsynced({
-        state: deps.getState(),
+      deps.applyState(base2, recordEntityUnsynced({
+        state: base2,
         workspaceSlug: deps.workspaceSlug,
         absolutePath: deps.op.absolutePath,
         op: deps.op.kind === "delete" ? "delete" : "upsert",
@@ -43832,14 +44672,16 @@ async function flushHeldFileOpImpl(deps) {
     output: deps.output,
     suppressor: deps.suppressor
   };
+  let base2;
   const run = async () => {
+    base2 = deps.getState();
     try {
       const result = deps.op.kind === "delete" ? await pushFilesDelete({
         workspaceSlug: deps.workspaceSlug,
         baseUrl: deps.baseUrl,
         pat: deps.pat,
         relPath: deps.op.relPath,
-        state: deps.getState(),
+        state: base2,
         deps: fileDeps
       }) : await pushFilesUpsert({
         workspaceSlug: deps.workspaceSlug,
@@ -43847,18 +44689,18 @@ async function flushHeldFileOpImpl(deps) {
         pat: deps.pat,
         absolutePath: deps.op.absolutePath,
         relPath: deps.op.relPath,
-        state: deps.getState(),
+        state: base2,
         deps: fileDeps
       });
-      deps.setState(result.state);
+      deps.applyState(base2, result.state);
       reportFileOutcome(deps.spinner, deps.workspaceSlug, deps.getState(), result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
       deps.output?.log(fileFailedLine({ path: deps.op.relPath, ...categorizeError(err) }));
       deps.spinner.warn(`File push failed for files/${deps.op.relPath}: ${msg}`);
       if (isRecordableFailure(err)) {
-        deps.setState(recordFileUnsynced({
-          state: deps.getState(),
+        deps.applyState(base2, recordFileUnsynced({
+          state: base2,
           relPath: deps.op.relPath,
           op: deps.op.kind === "delete" ? "delete" : "upsert",
           err,
@@ -44153,8 +44995,8 @@ async function runStart(workspaceSlug, deps = {}) {
     baseUrl: entry2.api_base_url,
     pat,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -44171,8 +45013,8 @@ async function runStart(workspaceSlug, deps = {}) {
     baseUrl: entry2.api_base_url,
     pat,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -44210,8 +45052,8 @@ async function runStart(workspaceSlug, deps = {}) {
     pat,
     op,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     mutex,
     fetchImpl,
@@ -44274,8 +45116,8 @@ async function runStart(workspaceSlug, deps = {}) {
     pat,
     op,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     mutex,
     fetchImpl,
@@ -44331,8 +45173,8 @@ async function runStart(workspaceSlug, deps = {}) {
     spinner,
     mutex,
     getState: () => state,
-    setState: (s) => {
-      state = s;
+    applyState: (base2, next) => {
+      state = rebaseState(state, base2, next);
     },
     fetchImpl,
     now: deps.now,
@@ -44397,8 +45239,8 @@ async function runStart(workspaceSlug, deps = {}) {
             baseUrl: entry2.api_base_url,
             pat,
             getState: () => state,
-            setState: (s) => {
-              state = s;
+            applyState: (base2, next) => {
+              state = rebaseState(state, base2, next);
             },
             fetchImpl,
             now: deps.now,
@@ -44415,8 +45257,8 @@ async function runStart(workspaceSlug, deps = {}) {
             baseUrl: entry2.api_base_url,
             pat,
             getState: () => state,
-            setState: (s) => {
-              state = s;
+            applyState: (base2, next) => {
+              state = rebaseState(state, base2, next);
             },
             fetchImpl,
             now: deps.now,
@@ -44431,58 +45273,70 @@ async function runStart(workspaceSlug, deps = {}) {
             spinner.warn(`${redriven.rejected} write${redriven.rejected === 1 ? "" : "s"} permanently rejected — see \`plinth status\``);
             spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
           }
-          const rulesRecon = await mutex.run(WORKSPACE_RULES_MUTEX_KEY, () => reconcileWorkspaceRules({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (rulesRecon.state !== state)
-            state = rulesRecon.state;
+          let rulesBase = state;
+          const rulesRecon = await mutex.run(WORKSPACE_RULES_MUTEX_KEY, () => {
+            rulesBase = state;
+            return reconcileWorkspaceRules({
+              workspaceSlug: slug,
+              baseUrl: entry2.api_base_url,
+              pat,
+              state: rulesBase,
+              fetchImpl,
+              now: deps.now,
+              output: out,
+              suppressor
+            });
+          });
+          state = rebaseState(state, rulesBase, rulesRecon.state);
           reportSingletonReconcile(spinner, slug, state, WORKSPACE_RULES_FILENAME, rulesRecon.outcome);
-          const memoryRecon = await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, () => reconcileWorkspaceMemory({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (memoryRecon.state !== state)
-            state = memoryRecon.state;
+          let memoryBase = state;
+          const memoryRecon = await mutex.run(WORKSPACE_MEMORY_MUTEX_KEY, () => {
+            memoryBase = state;
+            return reconcileWorkspaceMemory({
+              workspaceSlug: slug,
+              baseUrl: entry2.api_base_url,
+              pat,
+              state: memoryBase,
+              fetchImpl,
+              now: deps.now,
+              output: out,
+              suppressor
+            });
+          });
+          state = rebaseState(state, memoryBase, memoryRecon.state);
           reportSingletonReconcile(spinner, slug, state, WORKSPACE_MEMORY_FILENAME, memoryRecon.outcome);
-          const userMemoryRecon = await mutex.run(USER_MEMORY_MUTEX_KEY, () => reconcileUserMemory({
-            workspaceSlug: slug,
-            baseUrl: entry2.api_base_url,
-            pat,
-            state,
-            fetchImpl,
-            now: deps.now,
-            output: out,
-            suppressor
-          }));
-          if (userMemoryRecon.state !== state)
-            state = userMemoryRecon.state;
-          reportSingletonReconcile(spinner, slug, state, USER_MEMORY_FILENAME, userMemoryRecon.outcome);
-          try {
-            const voiceRecon = await mutex.run(VOICE_MUTEX_KEY, () => reconcileVoice({
+          let userMemoryBase = state;
+          const userMemoryRecon = await mutex.run(USER_MEMORY_MUTEX_KEY, () => {
+            userMemoryBase = state;
+            return reconcileUserMemory({
               workspaceSlug: slug,
               baseUrl: entry2.api_base_url,
               pat,
-              state,
+              state: userMemoryBase,
               fetchImpl,
               now: deps.now,
               output: out,
               suppressor
-            }));
-            if (voiceRecon.state !== state)
-              state = voiceRecon.state;
+            });
+          });
+          state = rebaseState(state, userMemoryBase, userMemoryRecon.state);
+          reportSingletonReconcile(spinner, slug, state, USER_MEMORY_FILENAME, userMemoryRecon.outcome);
+          try {
+            let voiceBase = state;
+            const voiceRecon = await mutex.run(VOICE_MUTEX_KEY, () => {
+              voiceBase = state;
+              return reconcileVoice({
+                workspaceSlug: slug,
+                baseUrl: entry2.api_base_url,
+                pat,
+                state: voiceBase,
+                fetchImpl,
+                now: deps.now,
+                output: out,
+                suppressor
+              });
+            });
+            state = rebaseState(state, voiceBase, voiceRecon.state);
             reportSingletonReconcile(spinner, slug, state, VOICE_FILENAME, voiceRecon.outcome);
             const reconWarning = voiceMalformedWarning(state, slug);
             if (reconWarning)
@@ -44490,19 +45344,19 @@ async function runStart(workspaceSlug, deps = {}) {
           } catch (err) {
             out.log(`[VOICE_RECONCILE_FAILED ${categorizeError(err).reason}]`);
           }
+          const memBase = state;
           const memRecon = await reconcileArtistMemory({
             workspaceSlug: slug,
             baseUrl: entry2.api_base_url,
             pat,
-            state,
+            state: memBase,
             fetchImpl,
             now: deps.now,
             output: out,
             suppressor,
             mutex
           });
-          if (memRecon.state !== state)
-            state = memRecon.state;
+          state = rebaseState(state, memBase, memRecon.state);
           if (memRecon.pushed > 0) {
             spinner.success(`↑ synced ${memRecon.pushed} memory file${memRecon.pushed === 1 ? "" : "s"}`);
             spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
@@ -44596,12 +45450,12 @@ async function runStart(workspaceSlug, deps = {}) {
       try {
         await Promise.race([
           watcher.drainPending().then(() => Promise.all([gate.drain(), fileGate.drain()])),
-          new Promise((resolve5) => setTimeout(() => resolve5(-1), SHUTDOWN_DRAIN_TIMEOUT_MS))
+          new Promise((resolve6) => setTimeout(() => resolve6(-1), SHUTDOWN_DRAIN_TIMEOUT_MS))
         ]);
       } finally {
         await Promise.race([
           watcher.stop(),
-          new Promise((resolve5) => setTimeout(resolve5, SHUTDOWN_DRAIN_TIMEOUT_MS))
+          new Promise((resolve6) => setTimeout(resolve6, SHUTDOWN_DRAIN_TIMEOUT_MS))
         ]);
         clearDaemonPid(slug);
         releaseDaemonLock(lockHandle);
@@ -45157,11 +46011,11 @@ function assessContextWalls(workspaceSlug, deps = {}) {
 // src/lib/build-stamp.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync10, mkdirSync as mkdirSync11, readFileSync as readFileSync27, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { dirname as dirname12, join as join18 } from "node:path";
 import { fileURLToPath } from "node:url";
 var BUILD_STAMP_FILENAME = "build-stamp.json";
 function stampPath(distDir) {
-  return join17(distDir, BUILD_STAMP_FILENAME);
+  return join18(distDir, BUILD_STAMP_FILENAME);
 }
 function readHead(repoDir) {
   try {
@@ -45192,9 +46046,9 @@ function readBuildStamp(distDir) {
 function findRepoRoot(fromDir) {
   let dir = fromDir;
   for (;; ) {
-    if (existsSync10(join17(dir, ".git")))
+    if (existsSync10(join18(dir, ".git")))
       return dir;
-    const parent = dirname11(dir);
+    const parent = dirname12(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -45218,7 +46072,7 @@ function checkBuildStaleness(deps = {}) {
   const metaUrl = deps.metaUrl ?? import.meta.url;
   let distDir;
   try {
-    distDir = dirname11(fileURLToPath(metaUrl));
+    distDir = dirname12(fileURLToPath(metaUrl));
   } catch {
     return { kind: "unknown" };
   }
@@ -45242,7 +46096,7 @@ function checkBuildStaleness(deps = {}) {
 
 // src/lib/memory-links.ts
 import { readFileSync as readFileSync28 } from "node:fs";
-import { relative as relative15, sep as sep7 } from "node:path";
+import { relative as relative15, sep as sep8 } from "node:path";
 var MEMORY_FILE_RE = /^(workspace-memory\.md|user-memory\.md|artists\/[^/]+\/memory\.md|memory\/[^/]+\.md|memory\/private\/[^/]+\.md)$/i;
 function scanMemoryLinks(deps) {
   const listFiles = deps.listFiles ?? ((r) => walkSubtreeFiles(r, isVcsInternal));
@@ -45255,7 +46109,7 @@ function scanMemoryLinks(deps) {
   } catch {
     return { scanned: 0, unreadable: [], dead: [] };
   }
-  const relPaths = absPaths.map((p) => relative15(root, p).split(sep7).join("/"));
+  const relPaths = absPaths.map((p) => relative15(root, p).split(sep8).join("/"));
   const artists = buildArtistIndex(relPaths, root, (abs) => readFile(abs));
   const dead = [];
   const unreadable = [];
@@ -46321,7 +47175,7 @@ async function callVoiceGate(req) {
 }
 
 // src/lib/voice-gate/attempts.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync30,
@@ -46329,7 +47183,7 @@ import {
   unlinkSync as unlinkSync9,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 var MAX_REGENS = 2;
 var ENTRY_TTL_MS = 24 * 60 * 60 * 1000;
 var AttemptEntrySchema = exports_external.object({
@@ -46342,13 +47196,13 @@ var AttemptsFileSchema = exports_external.object({
   entries: exports_external.record(exports_external.string(), AttemptEntrySchema)
 });
 function attemptsDir(workspaceSlug) {
-  return join18(plinthHome(), "_voice_gate", workspaceSlug);
+  return join19(plinthHome(), "_voice_gate", workspaceSlug);
 }
 function attemptsPath(workspaceSlug) {
-  return join18(attemptsDir(workspaceSlug), "attempts.json");
+  return join19(attemptsDir(workspaceSlug), "attempts.json");
 }
 function attemptKey(identity) {
-  return createHash4("sha256").update(identity, "utf8").digest("hex").slice(0, 32);
+  return createHash5("sha256").update(identity, "utf8").digest("hex").slice(0, 32);
 }
 function emptyFile() {
   return { version: 1, entries: {} };
@@ -46520,7 +47374,7 @@ function denyUngated(detail) {
 // src/lib/voice-gate/payload.ts
 import { readFileSync as readFileSync31, statSync as statSync20 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute4, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute4, resolve as resolve6 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
 var HELPER_BASENAME = "push_gmail_draft.py";
 var DRAFT_FLAGS = ["--to", "--body-file", "--body-stdin"];
@@ -46714,13 +47568,13 @@ function applyCd(tokens, state) {
     return { dir: expanded, known: true };
   if (!state.known)
     return state;
-  return { dir: resolve5(state.dir, expanded), known: true };
+  return { dir: resolve6(state.dir, expanded), known: true };
 }
 function expandHome(path5) {
   if (path5 === "~")
     return homedir2();
   if (path5.startsWith("~/"))
-    return resolve5(homedir2(), path5.slice(2));
+    return resolve6(homedir2(), path5.slice(2));
   return path5;
 }
 function classifyHelperSegment(tokens, dirState, readBodyFile) {
@@ -46746,7 +47600,7 @@ function classifyHelperSegment(tokens, dirState, readBodyFile) {
       unreadable: `the draft push uses a relative \`--body-file\` (${bodyFile}) after a \`cd\` ` + `the voice gate cannot resolve, so it cannot tell which file ships. Pass an ` + `absolute \`--body-file\` path.`
     };
   }
-  const resolved = isAbsolute4(expanded) ? expanded : resolve5(dirState.dir, expanded);
+  const resolved = isAbsolute4(expanded) ? expanded : resolve6(dirState.dir, expanded);
   let body;
   try {
     body = readBodyFile(resolved);