paperlint 11.1.0 → 11.1.2

package/src/submission-confirm-hook.ts

@@ -0,0 +1,330 @@
+/**
+ * The `submission-confirm` hook — no send to a venue's portal without the person's own yes.
+ * PreToolUse on `Bash` (`plugin/hooks/hooks.json`): a command that sends a submission — `paperlint
+ * submission new|update` with `--save` or `--submit`, or a request straight at a HotCRP site — gets
+ * `"permissionDecision": "ask"`, and Claude Code puts the question to the person, with the reason
+ * below, in its permission prompt. Anything else: no output.
+ *
+ * ── WHY "ask", AND WHY NOTHING TURNS IT OFF ──────────────────────────────────────
+ * The hooks reference (code.claude.com/docs/en/hooks): "`ask` prompts the user to confirm"; "A
+ * hook's `ask` also forces a permission prompt in auto mode"; the reason is "shown to the user in
+ * the permission prompt"; and decisions combine deny > defer > ask > allow, so an `allow` rule in
+ * the settings does not outvote it. An agent cannot answer the prompt, and no flag or variable of
+ * this package skips it — that is the point: the send is the person's decision, taken on the dry
+ * run's venue check (paperlint#264). The hook never denies (the person may send over a limit) and
+ * never allows (that would skip the person).
+ *
+ * ── WHAT IT SEES, AND WHAT IT IS NOT ──────────────────────────────────────────────
+ * A send is judged on the command as the shell reads it (`shellLeaves`: each simple command across
+ * `&&`, `;`, `|`, words unquoted, the commands inside a `bash -c "…"` string too), never on the raw
+ * text: `submission`, `new|update` and `--save|--submit` in one command's words, or a portal's host
+ * in any word (a HotCRP-hosted site, or a host a venue preset declares), whatever program it runs.
+ * A false ask costs one click; a missed send cannot be taken back. NOT SEEN: an upload from a script
+ * file that names the host only inside the file, or words built at run time (`$(…)`).
+ *
+ * The hook catches an agent that runs a send without asking; it is not a security boundary against
+ * an agent that deliberately disguises a send.
+ *
+ * The reason is built from the same parse and the CLI's own argument parser (`readSend`), one block
+ * per send; a send whose PDF cannot be told for certain is still asked about, and says so.
+ *
+ * ── IT FAILS TOWARD THE QUESTION ─────────────────────────────────────────────────
+ * The reason is built from files (the PDF, the build's facts); whatever goes wrong there, the ask
+ * still goes out, saying what could not be read. A payload that is not JSON is asked about.
+ *
+ * ── WHY IN-PROCESS, NOT A VIGILES PROGRAM ────────────────────────────────────────
+ * It reads the build's facts with this package's own parser and hashes the PDF; a shipped vigiles
+ * hook may import nothing but `vigiles/hook` (`src/folder-layout-hook.ts` says the rest). So
+ * `paperlint hook submission-confirm` runs it in-process (`runHook`, src/cli.ts).
+ */
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { callerPath } from "./caller-path.ts";
+import { bodyEnd } from "./domain/body-pages.ts";
+import { fieldOf } from "./domain/record.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import { messageOf } from "./domain/text.ts";
+import { factsPath, parseFactsText, type ReadFacts } from "./facts-file.ts";
+import type { Files } from "./ports/files.ts";
+import { paperPreset, type PresetDeps } from "./presets.ts";
+import { paperPdf } from "./submission.ts";
+
+/** One simple command of a command line, as a shell parser reads it (vigiles' `leafCommandsNormalized`). */
+interface ShellLeaf {
+  /** The program's basename: `/usr/bin/curl` → `curl`. */
+  readonly head: string;
+  /** The words after the program, quotes removed. */
+  readonly args: readonly string[];
+  /** Whether any of the flags `names` is on it (`--save`, `--save=x`). */
+  hasFlag(...names: readonly string[]): boolean;
+  /** The directory a wrapper (`env -C`, `sudo -D`) runs it in; null for none. */
+  readonly chdir: string | null;
+}
+
+/** What the hook reads: files, the shipped presets, and the portal hosts the project's venues declare. */
+export type ConfirmDeps = PresetDeps & {
+  /** The hosts of every venue portal paperlint knows of from `cwd`: shipped and the project's own. */
+  readonly portalHosts: (cwd: string) => readonly string[];
+  /** Every simple command of a command line, across `&&`, `;`, `|`; none when it does not parse. */
+  readonly shellLeaves: (command: string) => readonly ShellLeaf[];
+  /**
+   * The words after `submission`, read by the command's own argument parser: the paper and the
+   * `--pdf` the send names (null for the defaults), or null when they do not parse cleanly.
+   */
+  readonly readSend: (words: readonly string[]) => Send | null;
+};
+
+/** What Claude Code reads from a PreToolUse hook's stdout to ask the person first, with the reason. */
+export interface AskOutput {
+  readonly hookSpecificOutput: {
+    readonly hookEventName: "PreToolUse";
+    readonly permissionDecision: "ask";
+    readonly permissionDecisionReason: string;
+  };
+}
+
+const ask = (reason: string): AskOutput => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "ask",
+    permissionDecisionReason: reason,
+  },
+});
+
+const LAST = "Allow only if you have read the dry run's venue check.";
+
+/** The domain of HotCRP's hosted sites; a self-hosted portal is known by the host its preset declares. */
+const HOTCRP_HOSTED = "hotcrp.com";
+
+/**
+ * Every simple command the shell would run: the command line's own, and those inside a string
+ * argument (`bash -c "…"`), parsed the same way.
+ */
+function allLeaves(
+  command: string,
+  parse: ConfirmDeps["shellLeaves"],
+): readonly ShellLeaf[] {
+  const top = parse(command);
+  return [
+    ...top,
+    ...top.flatMap((l) =>
+      l.args.filter((a) => /\s/u.test(a)).flatMap((a) => allLeaves(a, parse)),
+    ),
+  ];
+}
+
+/** A `paperlint submission new|update` with `--save` or `--submit`, in the words of one command. */
+function isSend(l: ShellLeaf): boolean {
+  const at = l.args.indexOf("submission");
+  return (
+    at >= 0 &&
+    l.args.slice(at + 1).some((w) => w === "new" || w === "update") &&
+    l.hasFlag("save", "submit")
+  );
+}
+
+/** One `paperlint submission new|update` send: the paper folder and `--pdf` it names; null for the default. */
+export interface Send {
+  readonly paper: string | null;
+  readonly pdf: string | null;
+}
+
+/** Programs that change the directory the rest of the command line runs in. */
+const MOVES: ReadonlySet<string> = new Set(["cd", "pushd", "popd"]);
+
+/**
+ * Every send among the simple commands of a command line: its paper and PDF as the command's own
+ * argument parser reads them, or null where they cannot be told for certain — the words do not
+ * parse, or something before it may have changed the directory.
+ */
+function sendsIn(
+  leaves: readonly ShellLeaf[],
+  readSend: ConfirmDeps["readSend"],
+): readonly (Send | null)[] {
+  return leaves.flatMap((l, n) => {
+    const at = l.args.findIndex(
+      (x, i) =>
+        x === "submission" && /^(?:new|update)$/u.test(l.args[i + 1] ?? ""),
+    );
+    if (at < 0 || !l.hasFlag("save", "submit")) return [];
+    const moved = leaves
+      .slice(0, n + 1)
+      .some((x) => MOVES.has(x.head) || x.chdir !== null);
+    return [moved ? null : readSend(l.args.slice(at + 1))];
+  });
+}
+
+/**
+ * What the commands send: a submission through paperlint, anything that names a venue's portal — a
+ * HotCRP-hosted site, or a host a venue preset declares (`hosts`, read only when a word has a dot),
+ * whatever program it runs, as a plain case-insensitive substring of a word — or nothing. Judged on
+ * the shell's words only, never on the raw text.
+ */
+export function sendKind(
+  leaves: readonly ShellLeaf[],
+  hosts: () => readonly string[],
+): "paperlint" | "direct" | null {
+  if (leaves.some(isSend)) return "paperlint";
+  const words = leaves
+    .flatMap((l) => [l.head, ...l.args])
+    .map((w) => w.toLowerCase())
+    .filter((w) => w.includes("."));
+  if (words.length === 0) return null;
+  const known = [HOTCRP_HOSTED, ...hosts()]
+    .map((h) => h.toLowerCase())
+    .filter((h) => h !== "");
+  return words.some((w) => known.some((h) => w.includes(h))) ? "direct" : null;
+}
+
+/** The body pages the build counted: up to the references or appendix, or banal's count. */
+function bodyPages(f: ReadFacts): string {
+  const end = bodyEnd(f.text.pages, {
+    bib: f.text.bibAnchorPage,
+    appendix: f.text.appendixAnchorPage,
+  });
+  if (end.kind === "found")
+    return `body pages: ${String(end.bodyPages)} (up to the ${end.by} on page ${String(end.page)})`;
+  return f.geometry === null
+    ? "body pages: not counted (the build found no references heading and measured no geometry)"
+    : `body pages: ${String(f.geometry.body_pages)} (as banal counts them)`;
+}
+
+/** What the build's facts say about the PDF to be sent, in lines. */
+function factsLines(
+  paperDir: string,
+  sha: string | null,
+  files: Files,
+): readonly string[] {
+  const bytes = files.readBytes(callerPath(factsPath(paperDir)));
+  if (bytes === null)
+    return [
+      "no build facts (_build/paper.facts.json): the paper was not built, so the venue check did not see this PDF",
+    ];
+  const f = parseFactsText(new TextDecoder().decode(bytes));
+  if (!f.ok)
+    return [
+      `could not read the build facts (_build/paper.facts.json): ${f.error.kind === "schema" ? `schema ${f.error.got}` : f.error.why}`,
+    ];
+  const stale =
+    sha !== f.value.sha
+      ? [
+          "!! THE LAST BUILD IS NOT OF THIS PDF — the check did not see it. Rebuild (`paperlint build`) and run the dry run again.",
+        ]
+      : [];
+  return [...stale, bodyPages(f.value)];
+}
+
+/** One send, described: the paper, the PDF as the command resolves it, what the build saw. */
+function sendLines(
+  send: Send,
+  cwd: string,
+  deps: PresetDeps,
+): readonly string[] {
+  const paperDir = resolve(cwd, send.paper ?? ".");
+  const p = paperPreset(paperDir, deps);
+  const own = paperPdf(
+    paperDir,
+    p.kind === "settings-problem" ? null : p.settings,
+  );
+  const pdf = send.pdf === null ? own : resolve(cwd, send.pdf);
+  const bytes = deps.files.readBytes(callerPath(pdf));
+  const sha = bytes === null ? null : sha256Hex(bytes);
+  return [
+    `paper folder: ${send.paper ?? `${basename(paperDir)} (the current folder)`}`,
+    `PDF: ${send.pdf ?? join(send.paper ?? ".", relative(paperDir, own))}${sha === null ? " — NOT FOUND" : `, sha256 ${sha.slice(0, 12)}`}`,
+    ...factsLines(paperDir, sha, deps.files),
+  ];
+}
+
+/** A send whose PDF cannot be told for certain. */
+const UNRESOLVED =
+  "could not resolve which PDF this send uploads — check the dry run";
+
+/**
+ * Why the person is asked, for `paperlint submission` sends: each send's paper, PDF and build — every
+ * send in the command, one block each. Words the shell would expand (`$…`, backticks) are not
+ * guessed at: such a command is described as unresolved.
+ */
+export function paperlintReason(
+  command: string,
+  leaves: readonly ShellLeaf[],
+  cwd: string,
+  deps: ConfirmDeps,
+): string {
+  const sends = /[`$]/u.test(command) ? [] : sendsIn(leaves, deps.readSend);
+  const one = (x: Send | null): readonly string[] =>
+    x === null ? [UNRESOLVED] : sendLines(x, cwd, deps);
+  const blocks =
+    sends.length === 0
+      ? [UNRESOLVED]
+      : sends.length === 1
+        ? sends.flatMap(one)
+        : sends.flatMap((x, n) => [
+            `send ${String(n + 1)} of ${String(sends.length)}:`,
+            ...one(x),
+          ]);
+  return [SENDS, ...blocks, LAST].join("\n");
+}
+
+/** The ask when the hook's input cannot be read at all: it cannot tell, so the person decides. */
+export const UNREADABLE_INPUT: AskOutput = ask(
+  `paperlint could not read this command, so it cannot tell whether it sends a paper to a venue's portal. ${LAST}`,
+);
+
+const SENDS =
+  "This sends the paper to the venue's portal (paperlint submission with --save or --submit).";
+
+const DIRECT = `This command names a venue's submission portal, so it may send to it outside paperlint and its venue check. ${LAST}`;
+
+/** The payload, parsed; null when it is not JSON. */
+function parsed(stdin: string): unknown {
+  try {
+    return JSON.parse(stdin);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The hook on one payload, as Claude Code sends it on stdin: the ask, or null for a command that
+ * sends nothing. Never throws: what it cannot read, it asks about.
+ */
+export function submissionConfirm(
+  stdin: string,
+  deps: ConfirmDeps,
+): AskOutput | null {
+  const payload = parsed(stdin);
+  if (payload === null) return UNREADABLE_INPUT;
+  const raw = fieldOf(fieldOf(payload, "tool_input"), "command");
+  const command = typeof raw === "string" ? raw : "";
+  const given = fieldOf(payload, "cwd");
+  const cwd =
+    typeof given === "string" && isAbsolute(given) ? given : resolve(".");
+  const kind = kindOf(command, cwd, deps);
+  if (kind === null) return null;
+  if (kind !== "paperlint" && kind !== "direct") return ask(kind.failed);
+  if (kind === "direct") return ask(DIRECT);
+  try {
+    return ask(paperlintReason(command, deps.shellLeaves(command), cwd, deps));
+  } catch (e) {
+    return ask(
+      `${SENDS} paperlint could not say what will be sent: ${messageOf(e)}. ${LAST}`,
+    );
+  }
+}
+
+/** What the command sends, or — when reading it failed — the reason to ask anyway. */
+function kindOf(
+  command: string,
+  cwd: string,
+  deps: ConfirmDeps,
+): ReturnType<typeof sendKind> | { readonly failed: string } {
+  try {
+    return sendKind(allLeaves(command, deps.shellLeaves), () =>
+      deps.portalHosts(cwd),
+    );
+  } catch (e) {
+    return {
+      failed: `paperlint could not tell what this command sends (${messageOf(e)}). ${LAST}`,
+    };
+  }
+}

package/src/submission-fields-run.test.ts

@@ -48,7 +48,7 @@ test("update: the paper's fields are checked and sent with the change, and print
       { save: false },
     ],
   ]);
-  expect(r.out.slice(1, 4)).toStrictEqual([
+  expect(r.out.slice(2, 5)).toStrictEqual([
     'field         topics: ["Group: Topic A"]',
     'field         pc_conflicts: {"pc@example.org":"collaborator"}',
     'field         ACMCorAut: "ada@example.org"',

package/src/submission-new.test.ts

@@ -22,6 +22,7 @@ import {
   newFiles,
   WANT,
   ON_THE_SITE,
+  NO_ERRORS,
 } from "../test/submission-fixtures.ts";
 
 test("new: a dry run by default — title from \\title, abstract from \\begin{abstract} with the author's macro expanded, the declared authors, the PDF", async () => {
@@ -32,6 +33,7 @@ test("new: a dry run by default — title from \\title, abstract from \\begin{ab
   expect(r.seen[0]?.calls).toStrictEqual([["create", WANT, { save: false }]]);
   expect(r.out).toStrictEqual([
     CHECK("papers/p/paper.pdf", "the call for papers, https://example.org/cfp"),
+    NO_ERRORS,
     "title         Agents That Lie",
     "author 1      Ada Lovelace <ada@example.org>, Analytical",
     "author 2      Bob Bobson <bob@example.org>",
@@ -61,7 +63,7 @@ test("new --save: the id the portal chose is written into paperlint.json, and `s
   const r = await run({ sub: "new", save: true }, { files: fs });
   expect(r.code, r.errs.join("\n")).toBe(0);
   expect(r.seen[0]?.calls).toStrictEqual([["create", WANT, { save: true }]]);
-  expect(r.out.slice(6, 7)).toStrictEqual(["created submission 42"]);
+  expect(r.out.slice(7, 8)).toStrictEqual(["created submission 42"]);
   expect(r.out.slice(-2)).toStrictEqual([
     `recorded      "submission": { "id": 42 } in papers/p/paperlint.json`,
     `next          npx paperlint submission show papers/p — it should say "match yes"`,
@@ -499,7 +501,7 @@ test("new: no paper.tex — the PDF's Title stands in; without one either, the f
     },
   );
   expect(titled.code, titled.errs.join("\n")).toBe(0);
-  expect(titled.out[1]).toBe("title         From The PDF");
+  expect(titled.out[2]).toBe("title         From The PDF");
   const noAbstract = await run(
     { sub: "new" },
     { files: newFiles({ tex: null, facts: facts({ title: "From The PDF" }) }) },
@@ -567,3 +569,28 @@ test("a refusal at a place no file of the paper holds is named at paper.tex", as
     "the abstract, paper.tex: \\x — paperlint sends no text it would have to guess; give the abstract with --abstract <file>, a plain-text file",
   ]);
 });
+
+test("new prints the venue rules' findings on the PDF it creates the submission with; --save refuses facts that do not describe it, and creates nothing", async () => {
+  const dry = await run({ sub: "new" }, { files: newFiles({}) });
+  expect(dry.out[1]).toBe(NO_ERRORS);
+  const stale = newFiles({ facts: facts({ sha: "b".repeat(64) }) });
+  const saved = await run({ sub: "new", save: true }, { files: stale });
+  expect([saved.code, saved.seen[0]?.calls]).toStrictEqual([2, []]);
+  expect(saved.errs).toStrictEqual([
+    "refused: no build facts describe this PDF (none, unreadable, or of other bytes), so the venue rules did not see it — rebuild (`paperlint build`), run the dry run again, and read its venue check; nothing was sent",
+  ]);
+  // Where lint reports it: the paper.tex line of \documentclass.
+  expect(saved.out.slice(1, 4)).toStrictEqual([
+    "venue rules at their default options:",
+    `${PAPER}/paper.tex`,
+    "  1:2  error  _build/paper.facts.json describes a paper.pdf with another SHA-256 than the PDF being sent, so the venue checks would judge other bytes — rebuild the paper (`paperlint build`) from the source of the PDF you send  pdf/fresh",
+  ]);
+  expect(
+    JSON.parse(
+      new TextDecoder().decode(
+        stale.readBytes(absolutePath(`${PAPER}/paperlint.json`)) ??
+          new Uint8Array(),
+      ),
+    ),
+  ).toStrictEqual({ extends: "../../venue.jsonc", authors: AUTHORS });
+});

package/src/submission-show.test.ts

@@ -1,4 +1,5 @@
 /** `paperlint submission show`: what the portal holds, whether it is the local build, the deadlines in force. */
+import { join } from "node:path";
 import { expect, test } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { err, ok } from "./domain/result.ts";
@@ -20,6 +21,12 @@ import {
   run,
   STEPS,
 } from "../test/submission-fixtures.ts";
+import { frozenText } from "../test/frozen-presets.ts";
+
+/** msr FROZEN (test/frozen-presets.ts): the shipped file's deadlines are the scheduled refresh's output. */
+const frozenMsr = {
+  [join(presetsDir(), "msr.jsonc")]: frozenText("msr.jsonc"),
+};
 
 test("show: the portal from the preset, the id from the paper, the token from the site's variable", async () => {
   const r = await run({});
@@ -130,6 +137,7 @@ test("show sends nothing, so it asks for no check", async () => {
 
 test("show prints the current attempt's deadlines in force: the preset's portal readings, the paper's call readings and override over them", () => {
   const fs = memoryFiles({
+    ...frozenMsr,
     "/w/package.json": "{}",
     [`${PAPER}/paperlint.json`]: JSON.stringify({
       cycles: [
@@ -188,6 +196,7 @@ test("show prints the current attempt's deadlines in force: the preset's portal
 
 test("show, in the flat form: the deadlines in force are the preset's readings alone", () => {
   const flat = memoryFiles({
+    ...frozenMsr,
     "/w/package.json": "{}",
     [`${PAPER}/paperlint.json`]: JSON.stringify({
       extends: "paperlint:msr",

package/src/submission-update.test.ts

@@ -12,6 +12,8 @@ import {
   fakePortal,
   CHECK,
   run,
+  NO_ERRORS,
+  facts,
 } from "../test/submission-fixtures.ts";
 
 test("update: a dry run by default — the paper's PDF sent, nothing saved, exit 0", async () => {
@@ -32,6 +34,7 @@ test("update: a dry run by default — the paper's PDF sent, nothing saved, exit
   ]);
   expect(r.out).toStrictEqual([
     CHECK("papers/p/paper.pdf", "the call for papers, https://example.org/cfp"),
+    NO_ERRORS,
     "dry run — the portal checked the change and kept nothing; --save sends it for real",
     "HTTP          200",
     "valid         yes",
@@ -69,8 +72,9 @@ test("update --save --submit --abstract --pdf: all of it sent, and said to be sa
     ],
   ]);
   // Guards: the PDF that is sent is the one named, and --save is told to check it too.
-  expect(r.out.slice(0, 2)).toStrictEqual([
+  expect(r.out.slice(0, 3)).toStrictEqual([
     CHECK("other.pdf", "the call for papers, https://example.org/cfp"),
+    NO_ERRORS,
     "saved",
   ]);
 });
@@ -109,7 +113,7 @@ test("update: valid:false, or a non-2xx status, exits 1 with the portal's messag
     { portal: fakePortal({ update: invalid }) },
   );
   expect(r1.code).toBe(1);
-  expect(r1.out.slice(3)).toStrictEqual([
+  expect(r1.out.slice(4)).toStrictEqual([
     "valid         NO",
     "changes       —",
     `local PDF     papers/p/paper.pdf sha2-${HEX}`,
@@ -150,7 +154,7 @@ test("update --save that the portal withheld says so", async () => {
     { sub: "update", save: true },
     { portal: fakePortal({ update: withheld }) },
   );
-  expect(r.out[1]).toBe("SAVE WITHHELD by the portal — nothing changed");
+  expect(r.out[2]).toBe("SAVE WITHHELD by the portal — nothing changed");
 });
 
 test("update: no PDF to send, or no abstract file, is refused before the portal is asked", async () => {
@@ -164,3 +168,149 @@ test("update: no PDF to send, or no abstract file, is refused before the portal
   expect(r2.code).toBe(2);
   expect(r2.errs).toStrictEqual(["--abstract: no file at nope.txt"]);
 });
+
+// ── the venue check before a send (paperlint#264) ─────────────────────────────────────
+
+/** A paper of kind `short` (6 body pages) at a venue over AIDC, not blind, built 8 body pages long. */
+const OVER = files({
+  venue: { extends: "paperlint:aidc", blind: false },
+  paper: { extends: "../../venue.jsonc", kind: "short", submission: { id: 7 } },
+  facts: facts({ body: 8 }),
+});
+
+/** What `new` and `update` refuse a `--save` with when no build facts describe the PDF. */
+const REFUSAL =
+  "refused: no build facts describe this PDF (none, unreadable, or of other bytes), so the venue rules did not see it — rebuild (`paperlint build`), run the dry run again, and read its venue check; nothing was sent";
+
+/**
+ * The block printed for one finding on the made-up paper (no paper.tex, so line 1): what the check
+ * is — the venue rules at their default options, not the project's overrides — then lint's report.
+ */
+const LINT_BLOCK = (level: "error" | "warning", text: string): string[] => [
+  "venue rules at their default options:",
+  `${PAPER}/paper.tex`,
+  `  1:2  ${level}  ${text}`,
+  "",
+  `✖ 1 problem (${level === "error" ? "1 error, 0 warnings" : "0 errors, 1 warning"})`,
+];
+
+test("update over the page limit: the venue rules' findings on that PDF, as lint prints them, before the portal is asked; a dry run still runs", async () => {
+  const r = await run({ sub: "update" }, { files: OVER });
+  expect(r.code).toBe(0);
+  expect(r.out.slice(1, 7)).toStrictEqual([
+    ...LINT_BLOCK(
+      "error",
+      "body pages (up to the references on page 9): 8, over the limit 6 for venue/short — a desk reject; cut the text  format/page-limit",
+    ),
+    "dry run — the portal checked the change and kept nothing; --save sends it for real",
+  ]);
+  expect(r.seen[0]?.calls).toHaveLength(1);
+});
+
+test("update --save over the limit: the same findings, and the send goes ahead — the person decides on them, not the command", async () => {
+  const r = await run({ sub: "update", save: true }, { files: OVER });
+  expect([r.code, r.errs, r.out[2], r.out[6]]).toStrictEqual([
+    0,
+    [],
+    `${PAPER}/paper.tex`,
+    "saved",
+  ]);
+});
+
+test("no geometry measured: pdf/measured says the page checks did not run, so the check never reads as no errors", async () => {
+  const r = await run(
+    { sub: "update" },
+    { files: files({ facts: facts({ measured: false }) }) },
+  );
+  expect(r.out.slice(1, 6)).toStrictEqual(
+    LINT_BLOCK(
+      "warning",
+      "the build measured no page geometry (banal was not found or failed), so page size, columns, page limits and font sizes were NOT checked — run `paperlint toolchain`, then `paperlint build`  pdf/measured",
+    ),
+  );
+});
+
+test("update --save with facts about other bytes, or none: refused with exit 2 and nothing sent; the dry run prints the finding and goes on", async () => {
+  const later = files({
+    extra: { [`${PAPER}/paper.pdf`]: new TextEncoder().encode("%PDF later") },
+  });
+  const saved = await run({ sub: "update", save: true }, { files: later });
+  expect([saved.code, saved.errs, saved.seen[0]?.calls]).toStrictEqual([
+    2,
+    [REFUSAL],
+    [],
+  ]);
+  const dry = await run({ sub: "update" }, { files: later });
+  expect([dry.code, dry.errs, dry.seen[0]?.calls.length]).toStrictEqual([
+    0,
+    [],
+    1,
+  ]);
+  expect(dry.out.slice(1, 6)).toStrictEqual(
+    LINT_BLOCK(
+      "error",
+      "_build/paper.facts.json describes a paper.pdf with another SHA-256 than the PDF being sent, so the venue checks would judge other bytes — rebuild the paper (`paperlint build`) from the source of the PDF you send  pdf/fresh",
+    ),
+  );
+  const unbuilt = await run(
+    { sub: "update", save: true, submit: true },
+    { files: files({ facts: null }) },
+  );
+  expect([unbuilt.code, unbuilt.errs, unbuilt.seen[0]?.calls]).toStrictEqual([
+    2,
+    [REFUSAL],
+    [],
+  ]);
+  const broken = await run(
+    { sub: "update", save: true },
+    { files: files({ facts: "{" }) },
+  );
+  expect([broken.code, broken.errs]).toStrictEqual([2, [REFUSAL]]);
+});
+
+test("facts whose SHA-256 is the sent bytes' hold, wherever the PDF they name is — even gone from disk", async () => {
+  const gone = files({ facts: facts({ pdf: "gone.pdf" }) });
+  const r = await run({ sub: "update", save: true }, { files: gone });
+  expect([r.code, r.errs, r.out[1]]).toStrictEqual([0, [], NO_ERRORS]);
+});
+
+/** A paper whose current cycle is still porting to the venue's template, with the facts given. */
+const porting = (factsText?: string | null) =>
+  files({
+    paper: {
+      cycles: [
+        {
+          id: "venue-2027",
+          venue: { kind: "preset", extends: "../../venue.jsonc" },
+          opened: "2026-09-09",
+          phase: "porting",
+          submission: { id: 7 },
+        },
+      ],
+    },
+    ...(factsText === undefined ? {} : { facts: factsText }),
+  });
+
+test("a cycle still porting to the venue's template: no venue rule runs, and the check says so rather than no errors", async () => {
+  const r = await run({ sub: "update" }, { files: porting() });
+  expect(r.out[1]).toBe(
+    "venue rules: none run — the current cycle's phase is \"porting\", so the venue's format does not apply yet",
+  );
+});
+
+test("porting skips the venue rules, not the freshness: --save with facts about other bytes, or none, is still refused", async () => {
+  const stale = await run(
+    { sub: "update", save: true },
+    { files: porting(facts({ sha: "b".repeat(64) })) },
+  );
+  expect([stale.code, stale.errs, stale.seen[0]?.calls]).toStrictEqual([
+    2,
+    [REFUSAL],
+    [],
+  ]);
+  const unbuilt = await run(
+    { sub: "update", save: true },
+    { files: porting(null) },
+  );
+  expect([unbuilt.code, unbuilt.errs]).toStrictEqual([2, [REFUSAL]]);
+});