@hawkeyexl/manni 2.5.1 → 2.6.0

package/dist/{chunk-NFCH7HCA.js → chunk-TQUTQD7J.js}

@@ -71,7 +71,7 @@ import {
   withValueAt,
   writeEncryptionKey,
   writeFileAtomic
-} from "./chunk-22WVCFP4.js";
+} from "./chunk-5RJVKWFZ.js";
 
 // src/meta/core/reencrypt.ts
 import { extname } from "node:path";
@@ -185,10 +185,12 @@ __export(cite_exports, {
   GIT_UNAVAILABLE_HISTORY: () => GIT_UNAVAILABLE_HISTORY,
   MARKER_JSON: () => MARKER_JSON,
   MAX_MARKERS_PER_PAGE: () => MAX_MARKERS_PER_PAGE,
+  MAX_PAGE_COMMITS: () => MAX_PAGE_COMMITS,
   MAX_RANGE_LINES: () => MAX_RANGE_LINES,
   MOVE_BUDGET_BYTES: () => MOVE_BUDGET_BYTES,
   MOVE_WINDOW_LINES: () => MOVE_WINDOW_LINES,
   ManifestSet: () => ManifestSet,
+  PAGE_HISTORY_UNAVAILABLE: () => PAGE_HISTORY_UNAVAILABLE,
   RULE_ID_PREFIX: () => RULE_ID_PREFIX,
   SRC_PATTERN: () => SRC_PATTERN,
   anchoredLines: () => anchoredLines,
@@ -198,9 +200,12 @@ __export(cite_exports, {
   buildSourceIndex: () => buildSourceIndex,
   checkCitations: () => checkCitations,
   citationInputs: () => citationInputs,
+  claimDiff: () => claimDiff,
   claimEnd: () => claimEnd,
+  claimHistory: () => claimHistory,
   claimLine: () => claimLine,
   claimMessageFor: () => claimMessageFor,
+  claimWords: () => claimWords,
   classifyCitation: () => classifyCitation,
   detectEol: () => detectEol,
   duplicateJoinRefusal: () => duplicateJoinRefusal,
@@ -218,6 +223,7 @@ __export(cite_exports, {
   hashLines: () => hashLines,
   hashRange: () => hashRange2,
   historyOf: () => historyOf,
+  holdsWords: () => holdsWords,
   insertStatementBefore: () => insertStatementBefore,
   insideFence: () => insideFence,
   isBoundLine: () => isBoundLine,
@@ -258,6 +264,8 @@ __export(cite_exports, {
   readSource: () => readSource,
   reencryptCitationEntries: () => reencryptCitationEntries,
   reencryptCitations: () => reencryptCitations,
+  refineClaim: () => refineClaim,
+  refusalLine: () => refusalLine,
   removalLine: () => removalLine,
   removeFrontmatterCitations: () => removeFrontmatterCitations,
   removeLine: () => removeLine,
@@ -276,6 +284,9 @@ __export(cite_exports, {
   runCheck: () => runCheck,
   runRemove: () => runRemove,
   runUpdate: () => runUpdate,
+  runsHolding: () => runsHolding,
+  sentencesOf: () => sentencesOf,
+  sharesSentence: () => sharesSentence,
   shiftedEntries: () => shiftedEntries,
   shortCommit: () => shortCommit,
   shortLine: () => shortLine,
@@ -292,6 +303,7 @@ __export(cite_exports, {
   splitLines: () => splitLines,
   splitUnit: () => splitUnit,
   statementForms: () => statementForms,
+  stripMarkers: () => stripMarkers,
   toBodyLines: () => toBodyLines,
   toFileLines: () => toFileLines,
   toValidationResult: () => toValidationResult,
@@ -313,6 +325,7 @@ var CITE_RULES = [
   "source-missing",
   "claim-moved",
   "claim-moved-ambiguous",
+  "claim-reanchored",
   "claim-changed",
   "marker-orphan",
   "marker-invalid",
@@ -348,6 +361,7 @@ var DEFAULT_SEVERITY = {
   "source-missing": "error",
   "claim-moved": "notice",
   "claim-moved-ambiguous": "warning",
+  "claim-reanchored": "notice",
   "claim-changed": "warning",
   "marker-orphan": "error",
   "marker-invalid": "error",
@@ -1734,6 +1748,10 @@ function gitClient(root) {
   };
   const available = () => once("available", async () => (await run2(root, ["rev-parse", "--show-toplevel"])).ok);
   const failed = (verb, outcome) => new CiteError(`git ${verb} failed: ${outcome.stderr.trim() || outcome.message}`);
+  const shallow = () => once("shallow", async () => {
+    const out = await run2(root, ["rev-parse", "--is-shallow-repository"]);
+    return out.ok && out.stdout.trim() === "true";
+  });
   const hasCommit = (commit) => once(`has\0${commit}`, async () => {
     const out = await run2(root, ["rev-parse", "--verify", "--quiet", "--end-of-options", `${commit}^{commit}`]);
     if (out.ok) return true;
@@ -1771,10 +1789,34 @@ function gitClient(root) {
       const out = await run2(root, ["diff", "--end-of-options", commit, "--", path]);
       if (!out.ok) throw failed("diff", out);
       return out.stdout;
+    }),
+    pageCommits: (path, cap) => once(`commits\0${String(cap)}\0${path}`, async () => {
+      if (!await available()) return { commits: [], shallow: false, truncated: false };
+      const out = await run2(root, [
+        "log",
+        `--format=%H${UNIT}%s`,
+        "--topo-order",
+        `-n${String(cap + 1)}`,
+        "HEAD",
+        "--",
+        path
+      ]);
+      if (!out.ok) throw failed("log", out);
+      const commits = [];
+      for (const line of out.stdout.split(/\r?\n/)) {
+        if (line === "") continue;
+        const at2 = line.indexOf(UNIT);
+        if (at2 === -1) continue;
+        commits.push({ sha: line.slice(0, at2), subject: line.slice(at2 + 1) });
+      }
+      const truncated = commits.length > cap;
+      return { commits: commits.slice(0, cap), shallow: await shallow(), truncated };
     })
   };
 }
-var GIT_UNAVAILABLE_HISTORY = "git is not available here, so citations are checked without history: no never-true, no diffs, no commit subjects.";
+var UNIT = "";
+var GIT_UNAVAILABLE_HISTORY = "git is not available here, so citations are checked without history: no never-true, no reanchored claims, no diffs, no commit subjects.";
+var PAGE_HISTORY_UNAVAILABLE = "the page history ends before the pin held; use fetch-depth: 0 to tell reanchored claims from changed ones";
 var GIT_UNAVAILABLE_COMMIT = "git is not available here, so the citation records no commit.";
 function noGit() {
   return {
@@ -1783,10 +1825,293 @@ function noGit() {
     lsFiles: () => Promise.resolve([]),
     showFile: () => Promise.resolve({ missing: "commit" }),
     subjectsSince: () => Promise.resolve([]),
-    diffSince: () => Promise.resolve("")
+    diffSince: () => Promise.resolve(""),
+    pageCommits: () => Promise.resolve({ commits: [], shallow: false, truncated: false })
   };
 }
 
+// src/cite/core/history.ts
+var MAX_PAGE_COMMITS = 256;
+function stripMarkers(lines, format) {
+  return lines.filter((line) => !isMarkerLine(line, format));
+}
+function claimWords(lines, format) {
+  return stripMarkers(lines, format).join(" ").replace(/\s+/g, " ").trim();
+}
+function sentencesOf(text) {
+  return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.replace(/\s+/g, " ").trim().toLowerCase()).filter((sentence) => sentence !== "");
+}
+function sharesSentence(a, b) {
+  const left = new Set(sentencesOf(a));
+  return sentencesOf(b).some((sentence) => left.has(sentence));
+}
+function holdsWords(outer, inner) {
+  if (inner === "") return true;
+  if (outer === inner) return true;
+  if (outer.startsWith(`${inner} `)) return true;
+  if (outer.endsWith(` ${inner}`)) return true;
+  return outer.includes(` ${inner} `);
+}
+function runsHolding(lines, format, bodyLine, inner) {
+  if (inner === "") return [];
+  let text = "";
+  const at2 = [];
+  for (let n = Math.max(bodyLine, 1); n <= lines.length; n++) {
+    const line = lines[n - 1] ?? "";
+    if (isMarkerLine(line, format)) continue;
+    const words = line.replace(/\s+/g, " ").trim();
+    if (words === "") continue;
+    if (text !== "") {
+      text += " ";
+      at2.push(n);
+    }
+    for (let i = 0; i < words.length; i++) at2.push(n);
+    text += words;
+  }
+  const out = [];
+  let from = 0;
+  for (; ; ) {
+    const found = text.indexOf(inner, from);
+    if (found === -1) break;
+    from = found + 1;
+    const before = found === 0 ? " " : text[found - 1];
+    const afterAt = found + inner.length;
+    const after = afterAt === text.length ? " " : text[afterAt];
+    if (before !== " " || after !== " ") continue;
+    const start = at2[found];
+    const end = at2[afterAt - 1];
+    if (start === void 0 || end === void 0) continue;
+    if (!out.some((span) => span.start === start && span.end === end)) out.push({ start, end });
+  }
+  return out.filter(
+    (span) => !out.some(
+      (other) => (other.start !== span.start || other.end !== span.end) && other.start >= span.start && other.end <= span.end
+    )
+  );
+}
+function bounds(line) {
+  return line === void 0 || line.trim() === "" || ANY_FENCE.test(line);
+}
+function pinOf2(lines, span) {
+  if (span.start < 1 || span.end > lines.length || span.end < span.start) return void 0;
+  return hashLines(lines.slice(span.start - 1, span.end).join("\n"));
+}
+function readThen(input, text) {
+  const then = readPage(input.page.file, text, { format: input.page.format });
+  const lines = splitLines(then.content);
+  if (input.entry.citation.claim?.lines !== void 0) return { page: then, lines };
+  const id = input.entry.citation.id;
+  if (id === void 0) return void 0;
+  const marker = then.statements.find(
+    (statement) => statement.payload.kind === "ref" && statement.payload.id === id
+  );
+  if (marker === void 0) return void 0;
+  return { page: then, lines, marker };
+}
+function anchorHeldAt(input, then) {
+  const pin = input.entry.citation.claim?.integrity;
+  if (pin === void 0) return { kind: "absent" };
+  const was = {
+    citation: input.entry.citation,
+    origin: input.entry.origin,
+    ...then.marker === void 0 ? {} : { marker: then.marker }
+  };
+  const split = then.marker === void 0 ? void 0 : misplacedMarkerAt(then.page, then.lines, then.marker.line, was);
+  const end = claimEnd(then.page, was, then.lines, split);
+  if (end === null || end.status !== "current" && end.status !== "moved") {
+    return { kind: "absent" };
+  }
+  for (const spec of [end.fileLines, end.newFileLines]) {
+    const span = spec === void 0 ? void 0 : parseLines(spec);
+    if (span !== void 0 && pinOf2(then.lines, span) === pin) {
+      return { kind: "found", span, lines: then.lines.slice(span.start - 1, span.end) };
+    }
+  }
+  if (split !== void 0) {
+    const text = unitText(then.lines, split);
+    if (hashLines(text.join("\n")) === pin) {
+      return { kind: "found", span: movedUnit(split), lines: text };
+    }
+  }
+  return { kind: "absent" };
+}
+function windowHeldAt(input, then) {
+  const pin = input.entry.citation.claim?.integrity;
+  const marker = then.marker;
+  if (pin === void 0 || marker === void 0) return { kind: "absent" };
+  if (input.entry.citation.quote === true) return { kind: "absent" };
+  const lines = then.lines;
+  let stop = marker.line;
+  for (let n = marker.line + 1; n <= lines.length; n++) {
+    if (bounds(lines[n - 1])) break;
+    stop = n;
+  }
+  const starts = [marker.line];
+  for (let n = marker.line + 1; n <= stop; n++) {
+    const line = lines[n - 1] ?? "";
+    if (line.trim() === "" || isMarkerLine(line, then.page.format)) continue;
+    starts.push(n);
+  }
+  for (const start of starts) {
+    for (let end = start; end <= stop; end++) {
+      if (pinOf2(lines, { start, end }) === pin) {
+        return { kind: "found", span: { start, end }, lines: lines.slice(start - 1, end) };
+      }
+    }
+  }
+  return { kind: "absent" };
+}
+async function stillWritten(input, commit, pageText) {
+  const pin = input.entry.citation.claim?.integrity;
+  if (pin === void 0) return { stop: true, born: true };
+  const manifest = input.manifest;
+  if (manifest !== void 0) {
+    const shown = await input.git.showFile(commit, manifest);
+    const held2 = "text" in shown && shown.text.includes(pin);
+    return { stop: !held2, born: !held2 };
+  }
+  const held = pageText.includes(pin);
+  return { stop: false, born: !held };
+}
+async function claimHistory(input) {
+  const { git, path } = input;
+  if (git.pageCommits === void 0) return { kind: "none" };
+  if (!await git.available()) return { kind: "none" };
+  const cap = input.cap ?? MAX_PAGE_COMMITS;
+  const history = await git.pageCommits(path, cap);
+  const { commits } = history;
+  if (commits.length === 0) return { kind: "none" };
+  const format = input.page.format;
+  const baselineAt = (index, then, found) => {
+    if (found.kind !== "found") return { kind: "none" };
+    const commit = commits[index];
+    if (commit === void 0) return { kind: "none" };
+    return {
+      kind: "baseline",
+      commit: commit.sha,
+      commitsSince: commits.slice(0, index).map((c) => c.subject),
+      words: claimWords(found.lines, format),
+      pageWords: claimWords(then.lines.slice(then.page.bodyLine - 1), format),
+      lines: found.lines,
+      at: spellLines(found.span)
+    };
+  };
+  const examined = [];
+  let ended = "cap";
+  let born = false;
+  for (let i = 0; i < commits.length; i++) {
+    const commit = commits[i];
+    if (commit === void 0) continue;
+    const shown = await git.showFile(commit.sha, path);
+    if (!("text" in shown)) {
+      ended = shown.missing === "commit" ? "unavailable" : "birth";
+      break;
+    }
+    const then = readThen(input, shown.text);
+    if (then === void 0) {
+      ended = "birth";
+      break;
+    }
+    examined.push(then);
+    const found = anchorHeldAt(input, then);
+    if (found.kind === "found") return baselineAt(i, then, found);
+    const written = await stillWritten(input, commit.sha, shown.text);
+    if (written.born) born = true;
+    if (written.stop) {
+      ended = "birth";
+      break;
+    }
+  }
+  for (const [i, then] of examined.entries()) {
+    const found = windowHeldAt(input, then);
+    if (found.kind === "found") return baselineAt(i, then, found);
+  }
+  if (ended === "birth" || born) return { kind: "none" };
+  if (ended === "unavailable") return { kind: "unavailable" };
+  return history.truncated || history.shallow ? { kind: "unavailable" } : { kind: "none" };
+}
+function claimDiff(input) {
+  const a = input.was.lines;
+  const b = input.now.lines;
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) {
+    tail++;
+  }
+  const out = [
+    `--- ${input.file}@${shortCommit(input.commit)}:${input.was.at}`,
+    `+++ ${input.file}:${input.now.at}`
+  ];
+  for (const line of a.slice(0, head)) out.push(` ${line}`);
+  for (const line of a.slice(head, a.length - tail)) out.push(`-${line}`);
+  for (const line of b.slice(head, b.length - tail)) out.push(`+${line}`);
+  for (const line of a.slice(a.length - tail)) out.push(` ${line}`);
+  return out.join("\n");
+}
+function refineClaim(input) {
+  const { claim, history, entry, page, lines } = input;
+  if (history.kind === "unavailable") return { ...claim, historyAvailable: false };
+  if (history.kind === "none") return claim;
+  const format = page.format;
+  const base = {
+    ...claim,
+    commitSha: history.commit,
+    historyAvailable: true,
+    commitsSince: history.commitsSince,
+    baselineText: history.lines
+  };
+  const withDiff = (end, now2) => {
+    const diff = claimDiff({
+      file: page.file,
+      commit: history.commit,
+      was: { at: history.at, lines: history.lines },
+      now: now2
+    });
+    return { ...end, diff };
+  };
+  if (entry.citation.quote === true) {
+    const now2 = claim.text ?? [];
+    const same = stripMarkers(now2, format).join("\n") === stripMarkers(history.lines, format).join("\n");
+    const at2 = claim.fileLines ?? history.at;
+    return withDiff(same ? { ...base, status: "reanchored" } : base, { at: at2, lines: now2 });
+  }
+  if (entry.citation.claim?.lines === void 0) {
+    const now2 = claim.text ?? [];
+    const w12 = claimWords(now2, format);
+    const at2 = claim.fileLines ?? history.at;
+    const held = holdsWords(w12, history.words) && holdsWords(history.pageWords, w12);
+    return withDiff(held ? { ...base, status: "reanchored" } : base, { at: at2, lines: now2 });
+  }
+  const runs = runsHolding(lines, format, page.bodyLine, history.words);
+  const [only] = runs;
+  if (runs.length > 1) {
+    return {
+      ...claim,
+      status: "moved-ambiguous",
+      candidates: runs.map((span) => spellLines(toBodyLines(span, page.bodyLine))),
+      candidateFileLines: runs.map(spellLines)
+    };
+  }
+  if (only === void 0) {
+    return withDiff(base, { at: claim.fileLines ?? history.at, lines: claim.text ?? [] });
+  }
+  const now = lines.slice(only.start - 1, only.end);
+  const w1 = claimWords(now, format);
+  if (!holdsWords(history.pageWords, w1)) {
+    return withDiff(base, { at: claim.fileLines ?? history.at, lines: claim.text ?? [] });
+  }
+  return withDiff(
+    {
+      ...base,
+      status: "reanchored",
+      newLines: spellLines(toBodyLines(only, page.bodyLine)),
+      newFileLines: spellLines(only)
+    },
+    { at: spellLines(only), lines: now }
+  );
+}
+
 // src/cite/core/classify.ts
 async function historyOf(git, commit, path, range, pin, key, budget) {
   const shown = await git.showFile(commit, path);
@@ -2437,13 +2762,37 @@ function claimMessageFor(result) {
         id,
         `the claim at ${at(where ?? "?")} now appears at lines ${listOf(claim.candidateFileLines ?? [])}.`
       );
+    case "reanchored": {
+      const since = claim.commitSha === void 0 ? "" : ` since ${short(claim.commitSha)}`;
+      const to = claim.newFileLines === void 0 ? "" : `, to ${at(claim.newFileLines)}`;
+      return named2(
+        id,
+        `the claim at ${at(where ?? "?")} was reanchored${since}${to}. Its words are unchanged.`
+      );
+    }
     case "changed":
-      return where === void 0 ? named2(id, "the claim has no lines and no marker names the entry, so its pin anchors nothing.") : named2(id, `the claim at ${at(where)} has changed since it was pinned.`);
+      if (where === void 0) {
+        return named2(
+          id,
+          "the claim has no lines and no marker names the entry, so its pin anchors nothing."
+        );
+      }
+      return named2(id, `the claim at ${at(where)} has ${claimChange(claim)}`);
     case "current":
     case "skipped":
       return "";
   }
 }
+function claimChange(claim) {
+  if (claim.historyAvailable === false) {
+    return "changed since it was pinned (history unavailable; fetch-depth: 0).";
+  }
+  if (claim.commitSha === void 0) return "changed since it was pinned.";
+  const at2 = short(claim.commitSha);
+  const since = claim.commitsSince ?? [];
+  const count = since.length === 0 ? "uncommitted" : plural(since.length, "commit");
+  return `changed since ${at2}, ${count}.`;
+}
 function misplacedMessageFor(id, marker) {
   const place = marker.block ? `above the block at line ${String(marker.place)}` : `above line ${String(marker.place)}`;
   return named2(
@@ -2656,6 +3005,7 @@ async function checkCitations(page, opts) {
   const read = readPage(page.file, page.content, readOptions);
   const severity = resolveSeverity(opts.severity);
   const client = opts.gitClient ?? gitClient(opts.root);
+  const pageGit = opts.pageGitClient ?? (opts.pageRoot === void 0 || opts.pageRoot === opts.root ? client : gitClient(opts.pageRoot));
   const checkSources = opts.checkSources !== false;
   const lines = splitLines(read.content);
   const results = [];
@@ -2679,7 +3029,10 @@ async function checkCitations(page, opts) {
   const misplacedAt = new Map(misplaced.map((found) => [found.line, found]));
   for (const entry of read.citations) {
     const split = entry.marker === void 0 ? void 0 : misplacedAt.get(entry.marker.line);
-    const claim = claimEnd(read, entry, lines, split);
+    const claim = await withClaimHistory(
+      { page: read, entry, claim: claimEnd(read, entry, lines, split), lines },
+      { path: read.file, git: pageGit, ...opts.pageCommitCap === void 0 ? {} : { cap: opts.pageCommitCap }, ...opts.owned === void 0 ? {} : { manifest: opts.owned.file } }
+    );
     const source = classifyOpts === void 0 ? skippedSource(entry) : await classifyCitation(entry, classifyOpts);
     const result = {
       citation: entry.citation,
@@ -2731,8 +3084,15 @@ async function checkCitations(page, opts) {
     }
   }
   findings.push(...findingsFor(results, severity));
-  const wantsHistory = checkSources && read.citations.some(({ citation }) => citation.source["commit-sha"] !== void 0);
-  if (wantsHistory && !await client.available()) notices.push(GIT_UNAVAILABLE_HISTORY);
+  const wantsSourceHistory = checkSources && read.citations.some(({ citation }) => citation.source["commit-sha"] !== void 0);
+  const wantsClaimHistory = results.some((r) => r.claim?.status === "changed");
+  if (wantsSourceHistory && !await client.available()) notices.push(GIT_UNAVAILABLE_HISTORY);
+  else if (wantsClaimHistory && !await pageGit.available()) {
+    notices.push(GIT_UNAVAILABLE_HISTORY);
+  }
+  if (results.some((r) => r.claim?.historyAvailable === false)) {
+    notices.push(PAGE_HISTORY_UNAVAILABLE);
+  }
   const unavailable = results.find((r) => r.source.historyAvailable === false);
   if (unavailable?.source.commitSha !== void 0) {
     notices.push(
@@ -2752,6 +3112,14 @@ async function checkCitations(page, opts) {
     notices
   };
 }
+async function withClaimHistory(now, read) {
+  const { claim } = now;
+  if (claim === null || claim.status !== "changed") return claim;
+  if (read.path === STDIN_LABEL) return claim;
+  const input = { page: now.page, entry: now.entry, claim, ...read };
+  const history = await claimHistory(input);
+  return refineClaim({ ...input, lines: now.lines, history });
+}
 function skippedSource(entry) {
   const { source } = entry.citation;
   const out = { src: spellSource(source), status: "skipped" };
@@ -3090,12 +3458,15 @@ async function prepareRun(opts, action, verb, sources = {}) {
   });
   assertNonEmpty({ files, inputs: fileInputs, usingStdin, allowEmpty, exclude, exts, gitignoreSkipped, action });
   const git = opts.gitClient ?? gitClient(run3.root);
+  const pageGit = opts.pageGitClient ?? (run3.base === run3.root ? git : gitClient(run3.base));
   const pageOptions = {
     root: run3.root,
     checkSources,
     key: run3.key,
     severity: config?.severity,
-    gitClient: git
+    gitClient: git,
+    pageRoot: run3.base,
+    pageGitClient: pageGit
   };
   if (checkSources) pageOptions.sourceIndex = await sourceIndexFor(run3.root, git);
   const sidecars2 = await sidecarsFor(run3);
@@ -3721,6 +4092,12 @@ function settles(plan) {
       return "marker-misplaced";
     case "claim-reanchored":
       return "claim-moved";
+    case "claim-words-held":
+      return "claim-reanchored";
+    // A refused claim leaves nothing written, but its finding is the row the
+    // refusal prints, so it is not also reported as skipped.
+    case "claim-replaced":
+      return "claim-changed";
     // A shifted entry was `current`, so it had no finding to settle.
     case "claim-shifted":
       return "";
@@ -3734,6 +4111,15 @@ function apply(content, format, plan) {
       return spliceEntryField(content, format, index, ["claim", "lines"], plan.lines);
     case "claim-reanchored":
       return spliceEntryField(content, format, index, ["claim", "integrity"], plan.pin);
+    case "claim-words-held": {
+      let out = spliceEntryField(content, format, index, ["claim", "integrity"], plan.pin);
+      if (plan.lines !== void 0) {
+        out = spliceEntryField(out, format, index, ["claim", "lines"], plan.lines);
+      }
+      return out;
+    }
+    // Nothing is written for a refused claim; the report is the whole of it.
+    case "claim-replaced":
     // The move is a page rewrite, applied to the whole page before any splice.
     case "marker-moved":
       return content;
@@ -3782,6 +4168,15 @@ function applyToEntry(entry, plan) {
       claim.integrity = plan.pin;
       return true;
     }
+    case "claim-words-held": {
+      const claim = end("claim");
+      if (claim === void 0) return false;
+      claim.integrity = plan.pin;
+      if (plan.lines !== void 0) claim.lines = plan.lines;
+      return true;
+    }
+    // Nothing is written for a refused claim.
+    case "claim-replaced":
     // The page holds the marker, so the manifest has nothing to change.
     case "marker-moved":
       return true;
@@ -3854,6 +4249,37 @@ function rewriteOf(plan) {
         newLines: plan.now
       };
     }
+    case "claim-words-held": {
+      const was = citation.claim?.integrity ?? "";
+      const out = {
+        ...base,
+        end: "claim",
+        reason: "re-anchored",
+        status: "reanchored",
+        from: was,
+        to: plan.pin,
+        fromPin: was,
+        toPin: plan.pin,
+        fromLines: plan.fromLines,
+        toLines: plan.toLines,
+        at: plan.at
+      };
+      if (plan.commitSha !== void 0) out.commitSha = plan.commitSha;
+      return out;
+    }
+    case "claim-replaced":
+      return {
+        ...base,
+        end: "claim",
+        reason: "replaced",
+        status: "changed",
+        from: plan.pin,
+        to: plan.would,
+        fromPin: plan.pin,
+        toPin: plan.would,
+        at: plan.at,
+        commitSha: plan.commitSha
+      };
     case "claim-shifted":
       return {
         ...base,
@@ -3880,14 +4306,22 @@ function rewriteOf(plan) {
         ...base,
         end: "claim",
         reason: "accepted",
-        status: "changed",
+        // A bypassed guard reads `replaced`, so the log shows that the line
+        // held other text and a named accept took it anyway.
+        status: plan.replaced === true ? "replaced" : "changed",
         from: was,
         to: plan.pin,
         fromPin: was,
         toPin: plan.pin,
         at: plan.unit.lines.start,
-        text: normalizeWhitespace(plan.unit.text.join("\n"))
+        text: quoted(plan.unit.text)
       };
+      const stored = plan.result.claim?.fileLines;
+      const now = spellLines(plan.unit.lines);
+      if (stored !== void 0 && stored !== now) {
+        out.fromLines = stored;
+        out.toLines = now;
+      }
       const markerLine = plan.markerLine ?? (plan.result.anchor === "marker" ? plan.result.markerLine : void 0);
       if (markerLine !== void 0) out.markerLine = markerLine;
       return out;
@@ -3910,6 +4344,18 @@ function rewriteOf(plan) {
     }
   }
 }
+function replacementAt(claim, text, format) {
+  const was = claim.baselineText;
+  const commit = claim.commitSha;
+  if (was === void 0 || commit === void 0) return void 0;
+  if (sharesSentence(claimWords(was, format), claimWords(text, format))) return void 0;
+  return commit;
+}
+var QUOTE_CAP = 200;
+function quoted(text) {
+  const all = normalizeWhitespace(text.join("\n"));
+  return all.length <= QUOTE_CAP ? all : `${all.slice(0, QUOTE_CAP)}\u2026`;
+}
 function named3(id, text) {
   return id === void 0 ? text : `${id}: ${text}`;
 }
@@ -4064,6 +4510,25 @@ async function runUpdate(opts) {
         });
       }
     }
+    if (result.anchor !== "marker" && claim !== null && claim.status === "reanchored" && claim.newLines !== void 0) {
+      const at2 = parseLines(claim.newLines);
+      const file = at2 === void 0 ? void 0 : toFileLines(at2, page.bodyLine);
+      const pin = file === void 0 ? void 0 : pinOfLines(lines, file);
+      const to = file === void 0 ? void 0 : { start: lineNow(file.start), end: lineNow(file.end) };
+      if (file !== void 0 && to !== void 0 && pin !== void 0 && to.end - to.start === file.end - file.start) {
+        const plan = {
+          kind: "claim-words-held",
+          result,
+          pin,
+          at: to.start,
+          fromLines: claim.fileLines ?? "",
+          toLines: spellLines(to),
+          lines: lineSpec(toBodyLines(to, page.bodyLine))
+        };
+        if (claim.commitSha !== void 0) plan.commitSha = claim.commitSha;
+        out.push(plan);
+      }
+    }
     if (result.source.status === "moved" && result.source.newLines !== void 0) {
       const at2 = parseLines(result.source.newLines);
       if (at2 !== void 0 && result.source.newSrc !== void 0) {
@@ -4085,15 +4550,28 @@ async function runUpdate(opts) {
           why: `Not re-pinned: the ${unit.kind} ${wide}.`
         });
       } else if (unit !== void 0 && pin !== void 0 && (!wantsBlock || unit.kind === "block")) {
-        const plan = { kind: "claim-accepted", result, unit, pin };
-        if (entry.citation.claim?.lines !== void 0) {
-          const body = toBodyLines(unit.lines, page.bodyLine);
-          const recorded = parseLines(entry.citation.claim.lines);
-          if (recorded === void 0 || recorded.start !== body.start || recorded.end !== body.end) {
-            plan.lines = lineSpec(body);
+        const replaced = replacementAt(claim, unit.text, page.format);
+        if (replaced !== void 0 && only === void 0) {
+          out.push({
+            kind: "claim-replaced",
+            result,
+            at: unit.lines.start,
+            commitSha: replaced,
+            pin: entry.citation.claim?.integrity ?? "",
+            would: pin
+          });
+        } else {
+          const plan = { kind: "claim-accepted", result, unit, pin };
+          if (replaced !== void 0) plan.replaced = true;
+          if (entry.citation.claim?.lines !== void 0) {
+            const body = toBodyLines(unit.lines, page.bodyLine);
+            const recorded = parseLines(entry.citation.claim.lines);
+            if (recorded === void 0 || recorded.start !== body.start || recorded.end !== body.end) {
+              plan.lines = lineSpec(body);
+            }
           }
+          out.push(plan);
         }
-        out.push(plan);
       }
     }
     if (result.source.status === "changed" || result.source.status === "never-true") {
@@ -4127,6 +4605,7 @@ async function runUpdate(opts) {
     });
     const lines = splitLines(content);
     const rewritten2 = [];
+    const refused = [];
     const settled = /* @__PURE__ */ new Set();
     const declined = /* @__PURE__ */ new Map();
     const markers = decideMarkers({ page, report, lines, accept, only });
@@ -4165,6 +4644,7 @@ async function runUpdate(opts) {
         const now = anchoredNow(after, format, afterLines, lineNow(marker.line), quote);
         const status = result.claim.status;
         if (now !== void 0 && now.pin !== recorded) {
+          const unitText2 = afterLines.slice(now.span.start - 1, now.span.end);
           if (status === "moved" || status === "current" && move !== void 0) {
             plans.push({
               kind: "claim-reanchored",
@@ -4173,6 +4653,17 @@ async function runUpdate(opts) {
               held: result.claim.fileLines ?? "",
               now: spellLines(now.span)
             });
+          } else if (status === "reanchored") {
+            const held = {
+              kind: "claim-words-held",
+              result,
+              pin: now.pin,
+              at: now.span.start,
+              fromLines: result.claim.fileLines ?? "",
+              toLines: spellLines(now.span)
+            };
+            if (result.claim.commitSha !== void 0) held.commitSha = result.claim.commitSha;
+            plans.push(held);
           } else if (status === "changed" && accept) {
             const kind = quote ? "block" : "paragraph";
             const wide = tooWide(now.span);
@@ -4182,17 +4673,24 @@ async function runUpdate(opts) {
                 why: `Not re-pinned: the ${kind} ${wide}.`
               });
             } else {
-              plans.push({
-                kind: "claim-accepted",
-                result,
-                pin: now.pin,
-                markerLine: lineNow(marker.line),
-                unit: {
-                  lines: now.span,
-                  kind,
-                  text: afterLines.slice(now.span.start - 1, now.span.end)
+              const replaced = replacementAt(result.claim, unitText2, format);
+              plans.push(
+                replaced === void 0 || only !== void 0 ? {
+                  kind: "claim-accepted",
+                  result,
+                  pin: now.pin,
+                  markerLine: lineNow(marker.line),
+                  unit: { lines: now.span, kind, text: unitText2 },
+                  ...replaced === void 0 ? {} : { replaced: true }
+                } : {
+                  kind: "claim-replaced",
+                  result,
+                  at: now.span.start,
+                  commitSha: replaced,
+                  pin: recorded,
+                  would: now.pin
                 }
-              });
+              );
             }
           }
         }
@@ -4217,6 +4715,11 @@ async function runUpdate(opts) {
         }
       }
       for (const plan of plans) {
+        if (plan.kind === "claim-replaced") {
+          refused.push(rewriteOf(plan));
+          settled.add(`${String(result.origin.index)}\0${settles(plan)}`);
+          continue;
+        }
         if (plan.kind === "marker-moved") {
         } else if (result.origin.kind === "manifest") {
           const held = entries?.[result.origin.index];
@@ -4273,7 +4776,7 @@ async function runUpdate(opts) {
       }
       writes.record(path, label, content);
     }
-    const out = { file: label, rewritten: rewritten2, skipped: skipped2, diff, written };
+    const out = { file: label, rewritten: rewritten2, refused, skipped: skipped2, diff, written };
     if (path === void 0) out.content = after;
     pages.push(out);
     return report;
@@ -4303,8 +4806,10 @@ async function runUpdate(opts) {
   );
   sayNotices(reports, opts.onNotice, reminted && !await git.available() ? [GIT_UNAVAILABLE_COMMIT] : []);
   const rewritten = pages.reduce((n, page) => n + citationsIn(page.rewritten), 0);
-  const skipped = pages.reduce((n, page) => n + page.skipped.length, 0);
-  const undone = pages.some((page) => page.skipped.some((finding2) => finding2.severity === "error"));
+  const skipped = pages.reduce((n, page) => n + page.skipped.length + page.refused.length, 0);
+  const undone = pages.some(
+    (page) => page.refused.length > 0 || page.skipped.some((finding2) => finding2.severity === "error")
+  );
   return {
     pages,
     rewritten,
@@ -4505,11 +5010,27 @@ function claimColumn(result) {
       status = `moved, ${plural2(at2.length, "candidate")} (${at2.join(", ")})`;
       break;
     }
+    case "reanchored": {
+      const since = claim.commitSha === void 0 ? "" : ` since ${shortCommit(claim.commitSha)}`;
+      const to = claim.newFileLines === void 0 ? "" : ` -> :${claim.newFileLines}`;
+      status = `reanchored${since}${to}`;
+      break;
+    }
+    case "changed":
+      status = changedText(claim);
+      break;
     default:
       status = claim.status;
   }
   return where === "" ? status : `${where} ${status}`;
 }
+function changedText(claim) {
+  if (claim.historyAvailable === false) return "changed (history unavailable; fetch-depth: 0)";
+  if (claim.commitSha === void 0) return "changed";
+  const since = claim.commitsSince ?? [];
+  const count = since.length === 0 ? "uncommitted" : plural2(since.length, "commit");
+  return `changed since ${shortCommit(claim.commitSha)}, ${count}`;
+}
 function sourceColumn(result, opts, dim) {
   const { source } = result;
   const src = shortSrc(source.src);
@@ -4530,10 +5051,19 @@ function diffLines(result, dim) {
   return out;
 }
 function claimLines(result, dim) {
-  const text = result.claim?.text ?? [];
-  const shown = text.slice(0, DIFF_LINE_CAP);
+  const claim = result.claim;
+  const diff = claim?.diff;
+  if (claim === null || diff === void 0 || diff === "") {
+    return capped(claim?.text ?? [], dim);
+  }
+  const out = [];
+  for (const subject of claim.commitsSince ?? []) out.push(dim(`        ${subject}`));
+  return [...out, ...capped(diff.split(/\r?\n/), dim)];
+}
+function capped(lines, dim) {
+  const shown = lines.slice(0, DIFF_LINE_CAP);
   const out = shown.map((line) => dim(`        ${line}`));
-  const more = text.length - shown.length;
+  const more = lines.length - shown.length;
   if (more > 0) out.push(dim(`        \u2026 (${plural2(more, "more line")})`));
   return out;
 }
@@ -4598,7 +5128,9 @@ function renderCheckPretty(run3, opts) {
       }
       if (opts.showDiff) {
         if (own.some((f) => f.rule === "source-changed")) under.push(...diffLines(result, c.dim));
-        if (own.some((f) => f.rule === "claim-changed")) under.push(...claimLines(result, c.dim));
+        if (own.some((f) => f.rule === "claim-changed" || f.rule === "claim-reanchored")) {
+          under.push(...claimLines(result, c.dim));
+        }
       }
       const forgivenEnd = own.length > 0 && live.length === 0 ? c.dim(" (baselined)") : "";
       rows.push({
@@ -4672,6 +5204,18 @@ function widening(held, now) {
   if (parts.length === 0) return ", which held a marker line";
   return `, ${parts.join(" and ")} newly pinned`;
 }
+function widened(rewrite) {
+  return rewrite.fromLines !== void 0 && rewrite.toLines !== void 0 && rewrite.fromLines !== rewrite.toLines;
+}
+function movedSpan(rewrite) {
+  if (widened(rewrite)) return `lines ${rewrite.fromLines ?? ""} -> ${rewrite.toLines ?? ""}`;
+  const at2 = rewrite.toLines ?? rewrite.fromLines ?? String(rewrite.at ?? 0);
+  return `at ${spellAtSpec(at2)}`;
+}
+function refusalLine(rewrite) {
+  const at2 = shortCommit(rewrite.commitSha ?? "");
+  return `claim at ${spellAtSpec(String(rewrite.at ?? 0))} skipped: that line now holds different text than the claim at ${at2}. Re-add it with cite add.`;
+}
 function rewriteLine(rewrite) {
   const word = rewrite.from.includes("-") ? "lines" : "line";
   const status = rewrite.status === "never-true" ? "never true" : rewrite.status;
@@ -4681,6 +5225,10 @@ function rewriteLine(rewrite) {
   if (rewrite.reason === "shifted") {
     return `claim ${word} ${rewrite.from} -> ${rewrite.to} (shifted by a marker)`;
   }
+  if (rewrite.reason === "re-anchored" && rewrite.status === "reanchored") {
+    const since = rewrite.commitSha === void 0 ? "" : ` since ${shortCommit(rewrite.commitSha)}`;
+    return `claim ${movedSpan(rewrite)} re-pinned (reanchored; words unchanged${since})`;
+  }
   if (rewrite.reason === "re-anchored") {
     const held = rewrite.lines ?? "";
     const now = rewrite.newLines ?? "";
@@ -4690,6 +5238,9 @@ function rewriteLine(rewrite) {
     return rewrite.end === "claim" ? `claim ${word} ${rewrite.from} -> ${rewrite.to} (moved)` : `source ${shortSrc(rewrite.from)} -> ${shortSrc(rewrite.to)} (moved)`;
   }
   if (rewrite.end === "claim") {
+    if (widened(rewrite)) {
+      return `claim ${movedSpan(rewrite)} re-pinned (${status}; now "${rewrite.text ?? ""}")`;
+    }
     const where = rewrite.markerLine === void 0 ? `line ${String(rewrite.at ?? 0)}` : `marker line ${String(rewrite.markerLine)}`;
     return `claim at ${where} re-pinned (${status}; now "${rewrite.text ?? ""}")`;
   }
@@ -4711,6 +5262,10 @@ function renderUpdatePretty(run3, opts) {
       const label = rewrite.id ?? `#${String(rewrite.index)}`;
       lines.push(`${page.file}: ${c.cyan(label)} ${rewriteLine(rewrite)}`);
     }
+    for (const rewrite of page.refused) {
+      const label = rewrite.id ?? `#${String(rewrite.index)}`;
+      lines.push(`${page.file}: ${c.cyan(label)} ${refusalLine(rewrite)}`);
+    }
     for (const finding2 of page.skipped) {
       const mark = severityMark(finding2.severity, c);
       lines.push(
@@ -4799,6 +5354,10 @@ function publicCitation(result) {
     if (result.claim.fileLines !== void 0) claim.fileLines = result.claim.fileLines;
     if (result.claim.newLines !== void 0) claim.newLines = result.claim.newLines;
     if (result.claim.candidates !== void 0) claim.candidates = result.claim.candidates;
+    if (result.claim.commitSha !== void 0) claim.commitSha = result.claim.commitSha;
+    if (result.claim.historyAvailable !== void 0) {
+      claim.historyAvailable = result.claim.historyAvailable;
+    }
   }
   return {
     ...result.citation.id === void 0 ? {} : { id: result.citation.id },
@@ -4819,9 +5378,11 @@ function renderRemoveJson(run3) {
   return JSON.stringify(run3, null, 2);
 }
 function renderUpdateJson(run3) {
+  const strip = (rows) => rows.map(({ markerLine: _pretty, ...rewrite }) => rewrite);
   const pages = run3.pages.map((page) => ({
     ...page,
-    rewritten: page.rewritten.map(({ markerLine: _pretty, ...rewrite }) => rewrite)
+    rewritten: strip(page.rewritten),
+    refused: strip(page.refused)
   }));
   return JSON.stringify({ ...run3, pages }, null, 2);
 }
@@ -5315,4 +5876,4 @@ export {
   runKeyRotate,
   runKeySet
 };
-//# sourceMappingURL=chunk-NFCH7HCA.js.map
+//# sourceMappingURL=chunk-TQUTQD7J.js.map