@plinth-music/cli 0.20.0 → 0.21.0

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.0",
+  version: "0.21.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -30505,6 +30505,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 +31263,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 +31321,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 +31363,7 @@ function buildContextAccount(workspaceSlug, deps = {}) {
     observedLoadedBytes: null,
     estimatedTokens: null,
     conditionalStanding,
+    observation: deps.observation ?? null,
     limits
   };
 }
@@ -31059,13 +31618,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 +31717,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 +31761,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 +31773,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 +32140,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 +32159,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 +32180,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 +32209,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 +32225,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 +32242,7 @@ function sweepDeadTmpFiles(dir, target) {
     if (pid === process.pid || isPidAlive(pid))
       continue;
     try {
-      unlinkSync6(join8(dir, name));
+      unlinkSync6(join9(dir, name));
     } catch {}
   }
 }
@@ -31651,7 +32307,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 +32366,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 +32402,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 +33673,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 +33698,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 +33737,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 +33802,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 +33917,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 +33936,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 +33973,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 +34002,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
@@ -33669,7 +34325,7 @@ class PerIdMutex {
 // src/lib/push.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
 import { readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
-import { basename as basename4, relative as relative5 } from "node:path";
+import { basename as basename5, relative as relative5 } from "node:path";
 
 // src/lib/frontmatter-id.ts
 var import_gray_matter8 = __toESM(require_gray_matter(), 1);
@@ -34150,7 +34806,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 {
@@ -34239,9 +34895,9 @@ async function reconcileContextDocConflict(args) {
   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({
@@ -34997,7 +35653,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;
@@ -35096,9 +35752,9 @@ 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);
@@ -35430,7 +36086,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 +36096,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({
@@ -35547,6 +36203,10 @@ function isGeneratedMemoryStash(label, deps) {
 
 // src/lib/memory-facts/refuse.ts
 function refuseGeneratedMemoryEdit(args) {
+  if (args.localContent === args.canonicalBody) {
+    args.writeCanonical(args.canonicalBody);
+    return { state: args.state, stashPath: null };
+  }
   const stashPath = stashConflict({
     workspaceSlug: args.workspaceSlug,
     entityType: args.conflictEntity,
@@ -35770,7 +36430,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) {
@@ -35929,7 +36589,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",
@@ -35991,7 +36651,7 @@ async function drainUnsyncedOps(args) {
     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);
@@ -36236,10 +36896,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);
@@ -36766,9 +37426,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
@@ -36778,7 +37438,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
@@ -36796,11 +37456,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))
@@ -36825,9 +37485,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) {
@@ -36914,7 +37574,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, () => {
@@ -36923,7 +37583,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) => {
@@ -37682,7 +38342,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 {
@@ -37813,7 +38473,7 @@ function watcherIgnoreMatcher(workspaceRoot) {
   return (absolutePath) => patterns.some((re) => re.test(absolutePath));
 }
 function escSep() {
-  return sep6 === "/" ? "/" : "\\\\";
+  return sep7 === "/" ? "/" : "\\\\";
 }
 
 class DebounceMap {
@@ -38398,7 +39058,7 @@ async function pushArtistMemory(args) {
       };
       return {
         state: persistEntry2(refused.state, stamped),
-        outcome: { kind: "generated_refused", slug, stashPath: refused.stashPath }
+        outcome: refused.stashPath === null ? { kind: "noop", slug } : { kind: "generated_refused", slug, stashPath: refused.stashPath }
       };
     }
     const acked = entry2.memory_hash;
@@ -40829,7 +41489,7 @@ async function pushWorkspaceMemory(args) {
     });
     return {
       state: next2,
-      outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+      outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
     };
   }
   const gate = applySecretGate({
@@ -40897,7 +41557,7 @@ async function pushWorkspaceMemory(args) {
     });
     return {
       state: next2,
-      outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+      outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
     };
   }
   {
@@ -40946,7 +41606,7 @@ async function pushWorkspaceMemory(args) {
         });
         return {
           state: next2,
-          outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+          outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
         };
       }
     }
@@ -41221,7 +41881,7 @@ async function pushSingleton(descriptor, args) {
     const next2 = persist2(descriptor, refused.state, ackedFrom(cloud, stableHash(cloud.body_md)));
     return {
       state: next2,
-      outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+      outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
     };
   }
   let gated = state;
@@ -41284,7 +41944,7 @@ async function pushSingleton(descriptor, args) {
     const next2 = persist2(descriptor, refused.state, ackedFrom(cloud, stableHash(cloud.body_md)));
     return {
       state: next2,
-      outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+      outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
     };
   }
   {
@@ -41325,7 +41985,7 @@ async function pushSingleton(descriptor, args) {
         const next2 = persist2(descriptor, refused.state, ackedFrom(cloud, stableHash(cloud.body_md)));
         return {
           state: next2,
-          outcome: { kind: "generated_refused", stashPath: refused.stashPath }
+          outcome: refused.stashPath === null ? { kind: "noop" } : { kind: "generated_refused", stashPath: refused.stashPath }
         };
       }
     }
@@ -41470,7 +42130,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();
@@ -41537,11 +42197,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,
@@ -41587,7 +42247,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 };
     }
@@ -41720,7 +42380,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);
@@ -41794,7 +42454,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
@@ -42413,7 +43073,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;
       }
@@ -44592,12 +45252,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);
@@ -45153,11 +45813,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 {
@@ -45188,9 +45848,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;
@@ -45214,7 +45874,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" };
   }
@@ -45238,7 +45898,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));
@@ -45251,7 +45911,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 = [];
@@ -46317,7 +46977,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,
@@ -46325,7 +46985,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({
@@ -46338,13 +46998,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: {} };
@@ -46516,7 +47176,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"];
@@ -46710,13 +47370,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) {
@@ -46742,7 +47402,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);