paperlint 11.1.1 → 11.1.2

package/src/cli.ts

@@ -70,6 +70,7 @@ import {
   pageLimitRules,
   VENUE_RULE_LEVELS,
   venueRules,
+  type VenueMessage,
 } from "./venue-rules.ts";
 import {
   FORMAT_RULE_LEVELS,
@@ -116,11 +117,13 @@ import {
   settingsProblemLine,
   presetProblemText,
   resolvePreset,
+  resolveShipped,
   shippedPresets,
   shippedSpec,
   shippedVenueNames,
   SHIPPED_PREFIX,
   type PaperPreset,
+  type Preset,
   type PresetTemplate,
 } from "./presets.ts";
 import type { ToolInstaller } from "./ports/tool-installer.ts";
@@ -181,6 +184,11 @@ import {
   folderLayoutRules,
 } from "./folder-layout-rule.ts";
 import { folderLayoutHook } from "./folder-layout-hook.ts";
+import {
+  submissionConfirm,
+  UNREADABLE_INPUT,
+} from "./submission-confirm-hook.ts";
+import { leafCommandsNormalized } from "vigiles/hook";
 import {
   REPRO_LAYOUT_RULE_LEVELS,
   reproLayoutRules,
@@ -238,7 +246,7 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       create the paper's submission on the venue's portal: the title
                                       and abstract from the build, the authors from paperlint.json,
                                       the PDF. A DRY RUN unless --save; a save records the new id in
-                                      paperlint.json
+                                      paperlint.json. Prints the venue check first, as update does
   npx paperlint submission show [paper]
                                       the paper's submission on the venue's portal: status, title,
                                       type, topics, abstract length, the PDF the portal holds, and
@@ -246,7 +254,9 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
   npx paperlint submission update [paper] [--pdf <file>] [--abstract <file>] [--submit] [--save]
                                       send the PDF (default: the paper's own), an abstract, or
                                       "submitted". A DRY RUN unless --save: the portal checks the
-                                      change and keeps nothing
+                                      change and keeps nothing. First prints what the venue rules find
+                                      in that exact PDF, as lint does; --save refuses a PDF the last
+                                      build did not measure (exit 2)
   npx paperlint submission topics [paper]
                                       the topics the venue's portal offers, against the ones its
                                       preset records; exit 1 when they differ
@@ -1237,8 +1247,42 @@ const IN_PROCESS_HOOKS: Readonly<Record<string, (io: HookIo) => number>> = {
     }
     return 0;
   },
+  // Never advisory-silent: an input it cannot read is asked about, not let through.
+  "submission-confirm": ({ stdin, out }) => {
+    const said = ((): ReturnType<typeof submissionConfirm> => {
+      try {
+        return submissionConfirm(stdin(), {
+          ...PRESET_DEPS,
+          portalHosts,
+          shellLeaves: leafCommandsNormalized,
+          readSend: submissionSend,
+        });
+      } catch {
+        return UNREADABLE_INPUT;
+      }
+    })();
+    if (said !== null) out(`${JSON.stringify(said)}\n`);
+    return 0;
+  },
 };
 
+/**
+ * The words after `submission` read by this CLI's own parser, as the command reads them: the paper
+ * and `--pdf` a send names, null for their defaults — or null when the words would not run cleanly
+ * (a flag missing its value, an unknown flag, a stray operand), so `submission-confirm` says it
+ * cannot tell rather than guess.
+ */
+export function submissionSend(
+  words: readonly string[],
+): { readonly paper: string | null; readonly pdf: string | null } | null {
+  const a = parseArgs(["submission", ...words]);
+  const clean =
+    a.missingValue === undefined &&
+    a.unknownFlag === undefined &&
+    a.paths.length <= 2;
+  return clean ? { paper: a.paths[1] ?? null, pdf: a.pdf } : null;
+}
+
 /**
  * `paperlint hook <name>` — run an editor hook. It exists for ONE thing: so that the wiring does not
  * address the runtime from the project root.
@@ -1653,17 +1697,40 @@ function paperRequirements(dir: string): TexRequirements {
  * package, so the shipped union alone would not see it.
  */
 export function toolchainTex(cwd: string): TexRequirements {
+  const chains = projectPresets(cwd).map((p) => p.tex);
+  return declaredUnion(undefined, chains).tex;
+}
+
+/** The resolved venue preset of every paper under the project's papers directories, seen from `cwd`. */
+function projectPresets(cwd: string): readonly Preset[] {
   const cfg = readConfig(parseArgs(["toolchain"]), {
     log: () => {},
     err: () => {},
     cwd,
   });
   const roots = cfg.code === undefined ? papersRoots(cfg) : [];
-  const chains = roots
+  return roots
     .flatMap((r) => papersIn(r))
     .map((dir) => paperPreset(dir, PRESET_DEPS))
-    .flatMap((p) => (p.kind === "resolved" ? [p.preset.tex] : []));
-  return declaredUnion(undefined, chains).tex;
+    .flatMap((p) => (p.kind === "resolved" ? [p.preset] : []));
+}
+
+/**
+ * The host of every venue portal paperlint knows of from `cwd` — the shipped presets', and those the
+ * project's papers extend: what `submission-confirm` asks about when a request goes straight there.
+ */
+export function portalHosts(cwd: string): readonly string[] {
+  return [...resolveShipped(PRESET_DEPS), ...projectPresets(cwd)].flatMap(
+    (p) =>
+      p.portal === null
+        ? []
+        : [
+            p.portal.url
+              .replace(/^[a-z][a-z0-9+.-]*:\/\//iu, "")
+              .split("/", 1)
+              .join(""),
+          ],
+  );
 }
 
 /**
@@ -1755,6 +1822,7 @@ const SIMPLE: Readonly<
         site: portalSite,
         latex: latexReader,
         codec: sourcesCodec,
+        lintText,
         log,
         err,
       },
@@ -2082,6 +2150,32 @@ const isEmptySet = (e: unknown): boolean => {
   );
 };
 
+/**
+ * Findings on one file, printed by the formatter `paperlint lint` prints with — what `paperlint
+ * submission` shows of the venue rules before a send, so the two read the same.
+ */
+export async function lintText(
+  file: string,
+  messages: readonly VenueMessage[],
+): Promise<string> {
+  const errorCount = messages.filter((m) => m.severity === 2).length;
+  const result: Readonly<ESLint.LintResult> = {
+    filePath: file,
+    messages: [...messages],
+    suppressedMessages: [],
+    errorCount,
+    fatalErrorCount: 0,
+    warningCount: messages.length - errorCount,
+    fixableErrorCount: 0,
+    fixableWarningCount: 0,
+    usedDeprecatedRules: [],
+  };
+  return (await new ESLint().loadFormatter(LINT_FORMAT)).format([result]);
+}
+
+/** The formatter `paperlint lint` prints with. */
+const LINT_FORMAT = "stylish";
+
 /**
  * The end of `paperlint lint`: refuse an optional rule that reached no paper, print the findings, and
  * decide the exit code. Pulled out of `run` so each question has its own function.
@@ -2125,7 +2219,7 @@ async function reportLint(
     // Missing things are printed FIRST: they explain why the report below may be suspiciously
     // short. The reverse order would read as "all clean — oh, and also this".
     if (structure.length > 0) log(formatStructure(structure));
-    const out = await (await eslint.loadFormatter("stylish")).format(results);
+    const out = await (await eslint.loadFormatter(LINT_FORMAT)).format(results);
     log(
       out.trim() ||
         (structure.length > 0

package/src/hooks-settings.harness.ts

@@ -65,9 +65,9 @@ check(
 // ── the one source: plugin/hooks/hooks.json ─────────────────────────────────────────────
 const wiring = shippedWiring();
 check(
-  "the hook names are DERIVED from hooks.json — four, in its order",
+  "the hook names are DERIVED from hooks.json — five, in its order",
   wiring.names.join() ===
-    "paper-edit-guard,paper-folder-layout,paper-skills-nudge,paper-status-gates",
+    "paper-edit-guard,submission-confirm,paper-folder-layout,paper-skills-nudge,paper-status-gates",
 );
 // ── settings written by hand: shapes Claude Code would ignore are skipped, not crashed on ──
 check(
@@ -284,7 +284,7 @@ try {
       "and names the hooks that are not wired in ANY form",
       r.status === "foreign" &&
         r.missing.join() ===
-          "paper-folder-layout,paper-skills-nudge,paper-status-gates",
+          "submission-confirm,paper-folder-layout,paper-skills-nudge,paper-status-gates",
     );
     // The control: without the check, vigiles' merge WOULD add a second copy. This is the
     // reason the check exists, measured rather than asserted.
@@ -320,13 +320,13 @@ try {
   const wiredOnce = merge({}, wiring.compiled, MANAGED_BY);
   check(
     "wired once each → ✓ wired, with the fresh-clone consequence",
-    /✓ wired — paper-edit-guard, paper-folder-layout, paper-skills-nudge, paper-status-gates, once each/.test(
+    /✓ wired — paper-edit-guard, submission-confirm, paper-folder-layout, paper-skills-nudge, paper-status-gates, once each/.test(
       doc(wiredOnce),
     ) && /cannot run until `npm install`/.test(doc(wiredOnce)),
   );
   check(
     "nothing wired → ⚠ not wired, with the remedy",
-    /⚠ not wired — none of the 4 hooks/.test(doc({})),
+    /⚠ not wired — none of the 5 hooks/.test(doc({})),
   );
   const twice = PreToolUseSettings.parse(structuredClone(wiredOnce));
   twice.hooks.PreToolUse[0]?.hooks.push({
@@ -354,7 +354,7 @@ try {
   });
   check(
     "🔴 partly wired BY HAND → the remedy is NOT `npx paperlint init`, which would refuse to write",
-    /partly wired — missing: paper-folder-layout, paper-skills-nudge, paper-status-gates/.test(
+    /partly wired — missing: submission-confirm, paper-folder-layout, paper-skills-nudge, paper-status-gates/.test(
       handPartial,
     ) && /writes nothing then/.test(handPartial),
   );

package/src/submission-confirm-hook.test.ts

@@ -0,0 +1,399 @@
+/**
+ * The `submission-confirm` hook: which commands send a submission (asked), which do not (silent), and
+ * what the person is told — including when what it reads is missing, stale or broken.
+ */
+import { expect, test } from "vitest";
+import { memoryFiles } from "./adapters/memory/index.ts";
+import type { AbsolutePath } from "./domain/paths.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import type { Files } from "./ports/files.ts";
+import { leafCommandsNormalized as shellLeaves } from "vigiles/hook";
+import { submissionSend } from "./cli.ts";
+import { presetsDir } from "./package-dirs.ts";
+import {
+  submissionConfirm as confirmWith,
+  type ConfirmDeps,
+} from "./submission-confirm-hook.ts";
+import { HEX, PDF, facts, withPresets } from "../test/submission-fixtures.ts";
+
+/** What the command sends, read through the real shell parser. */
+const kind = (command: string, hosts: () => readonly string[]) => {
+  const reason =
+    submissionConfirm(payload(command), memoryFiles({}), {
+      portalHosts: hosts,
+    })?.hookSpecificOutput.permissionDecisionReason ?? null;
+  if (reason === null) return null;
+  if (reason.startsWith(HEAD)) return "paperlint";
+  return reason.startsWith("This command names") ? "direct" : reason;
+};
+
+/** The portal hosts the project declares, in these tests: one venue on its own domain. */
+const HOSTS = ["submit.example-venue.org", "conference.org"];
+
+/** The hook over `fs` (the shipped presets readable beside it), the project declaring `HOSTS`. */
+const submissionConfirm = (
+  stdin: string,
+  fs: Files,
+  more: Partial<ConfirmDeps> = {},
+) =>
+  confirmWith(stdin, {
+    files: withPresets(fs),
+    venuesDir: presetsDir(),
+    portalHosts: () => HOSTS,
+    shellLeaves,
+    readSend: submissionSend,
+    ...more,
+  });
+
+const payload = (command: string, cwd = "/w"): string =>
+  JSON.stringify({ tool_name: "Bash", tool_input: { command }, cwd });
+
+test.each([
+  "npx paperlint submission update papers/p --save",
+  "npx paperlint submission new papers/p --save",
+  "npx paperlint submission update --submit --save papers/p",
+  "npx paperlint submission update papers/p --save=true",
+  "node node_modules/paperlint/bin/paperlint.mjs submission update papers/p --submit",
+  "pnpm exec paperlint submission new --save papers/p",
+  "HOTCRP_TOKEN_X=abc npx paperlint submission update papers/p --save",
+  "npm run build && npx paperlint submission update papers/p --save",
+  `npx paperlint "submission" 'update' papers/p "--save"`,
+  "npx paperlint --save submission update papers/p",
+  `npx paperlint submis"sion" up'date' papers/p --sa"ve"`,
+])("asked: %s", (command) => {
+  expect(kind(command, () => [])).toBe("paperlint");
+});
+
+test.each([
+  'curl -X POST -H "Authorization: bearer $HOTCRP_TOKEN" https://x.hotcrp.com/api/paper',
+  "wget --post-file=paper.pdf https://venue.hotcrp.com/api/upload",
+  "http POST https://venue.hotcrp.com/api/paper",
+  `node -e "fetch('https://venue.hotcrp.com/api/paper', { method: 'POST' })"`,
+  `python3 -c "import requests; requests.post('https://venue.hotcrp.com/api/paper')"`,
+  "curl -F file=@paper.pdf https://SUBMIT.example-venue.org/api/upload",
+  `node -e "require('https').request('https://venue.hotcrp.com/api/paper', { method: 'POST' })"`,
+  "node upload.mjs submit.example-venue.org",
+  "curl -X POST CONFERENCE.org/api/paper",
+  "echo https://venue.hotcrp.com",
+])("asked, straight at HotCRP: %s", (command) => {
+  expect(kind(command, () => HOSTS)).toBe("direct");
+});
+
+test.each([
+  "npx paperlint submission update papers/p",
+  "npx paperlint submission new papers/p",
+  "npx paperlint submission show papers/p",
+  "npx paperlint submission topics papers/p --save",
+  "grep -rn submission docs/",
+  "git log --grep submission",
+  "cat docs/submission.md",
+  "curl https://example.org/new --save-dir x",
+  "grep -rn hotcrp src/",
+  // `paperlint new` with a paper named "submission": not a send.
+  "npx paperlint new --save submission",
+  "cat src/adapters/hotcrp/index.ts",
+  "",
+  "curl https://example.org/api/paper",
+])("silent: %s", (command) => {
+  expect(kind(command, () => HOSTS)).toBe(null);
+});
+
+test("the hosts are read only for a command that makes a request: anything else pays nothing", () => {
+  const never = () => {
+    throw new Error("read the hosts for a command with no request in it");
+  };
+  expect(kind("ls -la", never)).toBe(null);
+  // An empty host would be in every command: it matches nothing.
+  expect(kind("curl https://example.org/x", () => [""])).toBe(null);
+  expect(kind("npx paperlint submission new --save", never)).toBe("paperlint");
+});
+
+test("hosts that cannot be read: a request still asks, rather than passing unseen", () => {
+  expect(
+    submissionConfirm(payload("curl https://example.org/x"), memoryFiles({}), {
+      portalHosts: () => {
+        throw new Error("broken preset");
+      },
+    }),
+  ).toStrictEqual({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "ask",
+      permissionDecisionReason:
+        "paperlint could not tell what this command sends (broken preset). Allow only if you have read the dry run's venue check.",
+    },
+  });
+});
+
+/** The made-up paper: its PDF, and its facts when given. */
+const paper = (factsText: string | null): Files =>
+  memoryFiles({
+    "/w/papers/p/paper.pdf": PDF,
+    ...(factsText === null
+      ? {}
+      : { "/w/papers/p/_build/paper.facts.json": factsText }),
+  });
+
+const reasonOf = (command: string, fs: Files, cwd = "/w"): string =>
+  submissionConfirm(payload(command, cwd), fs)?.hookSpecificOutput
+    .permissionDecisionReason ?? "(no ask)";
+
+const SEND = "npx paperlint submission update papers/p --submit --save";
+const HEAD =
+  "This sends the paper to the venue's portal (paperlint submission with --save or --submit).";
+const LAST = "Allow only if you have read the dry run's venue check.";
+
+test("the ask: the paper folder, the PDF and its sha256, the body pages the build counted, and the line to read the venue check", () => {
+  expect(submissionConfirm(payload(SEND), paper(facts()))).toStrictEqual({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "ask",
+      permissionDecisionReason: [
+        HEAD,
+        "paper folder: papers/p",
+        `PDF: papers/p/paper.pdf, sha256 ${HEX.slice(0, 12)}`,
+        "body pages: 4 (up to the references on page 5)",
+        LAST,
+      ].join("\n"),
+    },
+  });
+});
+
+test("a stale build is said loudly; no facts, broken facts and a missing PDF are said too — and every one still asks", () => {
+  expect(reasonOf(SEND, paper(facts({ sha: "b".repeat(64) })))).toBe(
+    [
+      HEAD,
+      "paper folder: papers/p",
+      `PDF: papers/p/paper.pdf, sha256 ${HEX.slice(0, 12)}`,
+      "!! THE LAST BUILD IS NOT OF THIS PDF — the check did not see it. Rebuild (`paperlint build`) and run the dry run again.",
+      "body pages: 4 (up to the references on page 5)",
+      LAST,
+    ].join("\n"),
+  );
+  expect(reasonOf(SEND, paper(null)).split("\n")[3]).toBe(
+    "no build facts (_build/paper.facts.json): the paper was not built, so the venue check did not see this PDF",
+  );
+  expect(reasonOf(SEND, paper("{")).split("\n")[3]).toMatch(
+    /^could not read the build facts \(_build\/paper\.facts\.json\): /u,
+  );
+  expect(
+    reasonOf(SEND, paper(JSON.stringify({ schema: 1 }))).split("\n")[3],
+  ).toBe("could not read the build facts (_build/paper.facts.json): schema 1");
+  expect(
+    reasonOf(
+      "npx paperlint submission update papers/p --pdf gone.pdf --save",
+      paper(facts()),
+    ).split("\n")[2],
+  ).toBe("PDF: gone.pdf — NOT FOUND");
+});
+
+test("the body pages: up to the references when the build found them, else banal's count, else not counted", () => {
+  const noHeading = (measured: boolean) =>
+    JSON.stringify({
+      ...JSON.parse(facts({ measured })),
+      pages_text: ["Only body."],
+    });
+  expect(reasonOf(SEND, paper(noHeading(true))).split("\n")[3]).toBe(
+    "body pages: 4 (as banal counts them)",
+  );
+  expect(reasonOf(SEND, paper(noHeading(false))).split("\n")[3]).toBe(
+    "body pages: not counted (the build found no references heading and measured no geometry)",
+  );
+});
+
+test("the paper and the PDF as the command names them: the current folder by default, --pdf=<file> too", () => {
+  const fs = memoryFiles({
+    "/w/papers/p/paper.pdf": PDF,
+    "/w/papers/p/out.pdf": PDF,
+  });
+  expect(
+    reasonOf("npx paperlint submission update --save", fs, "/w/papers/p")
+      .split("\n")
+      .slice(1, 3),
+  ).toStrictEqual([
+    "paper folder: p (the current folder)",
+    `PDF: paper.pdf, sha256 ${HEX.slice(0, 12)}`,
+  ]);
+  expect(
+    reasonOf(
+      "npx paperlint submission update --abstract a.txt --pdf=papers/p/out.pdf papers/p --save",
+      fs,
+    )
+      .split("\n")
+      .slice(1, 3),
+  ).toStrictEqual([
+    "paper folder: papers/p",
+    `PDF: papers/p/out.pdf, sha256 ${HEX.slice(0, 12)}`,
+  ]);
+});
+
+test("the paper's own `pdf` setting is the PDF hashed when the command names no --pdf, as the command sends it", () => {
+  const fs = memoryFiles({
+    "/w/papers/p/paperlint.json": JSON.stringify({ pdf: "out/main.pdf" }),
+    "/w/papers/p/out/main.pdf": PDF,
+  });
+  expect(reasonOf(SEND, fs).split("\n")[2]).toBe(
+    `PDF: papers/p/out/main.pdf, sha256 ${HEX.slice(0, 12)}`,
+  );
+});
+
+test("a paperlint.json that does not parse: the PDF is the default paper.pdf, and the ask still goes out", () => {
+  const fs = memoryFiles({
+    "/w/papers/p/paperlint.json": "{ nope",
+    "/w/papers/p/paper.pdf": PDF,
+  });
+  expect(reasonOf(SEND, fs).split("\n")[2]).toBe(
+    `PDF: papers/p/paper.pdf, sha256 ${HEX.slice(0, 12)}`,
+  );
+});
+
+test("a --pdf at the end with no value, which the command refuses: unresolved", () => {
+  expect(
+    reasonOf(
+      "npx paperlint submission update papers/p --save --pdf",
+      paper(facts()),
+    ),
+  ).toBe([HEAD, UNRESOLVED, LAST].join("\n"));
+});
+
+test("a command that only mentions `submission` beside a send is no second send", () => {
+  expect(
+    reasonOf(
+      "npx paperlint submission update papers/p --save; echo submission",
+      paper(facts()),
+    ).split("\n")[1],
+  ).toBe("paper folder: papers/p");
+});
+
+/** What the reason says for a send the parse cannot resolve. */
+const UNRESOLVED =
+  "could not resolve which PDF this send uploads — check the dry run";
+
+test("the send's words are read by the command's own parser: a value flag before the paper does not shift it; words it would refuse are unresolved", () => {
+  expect(
+    reasonOf(
+      "npx paperlint submission update --max-warnings 0 --config paperlint.json papers/p --save",
+      paper(facts()),
+    ).split("\n")[1],
+  ).toBe("paper folder: papers/p");
+  expect(
+    reasonOf(
+      "npx paperlint submission update papers/p --nope --save",
+      paper(null),
+    ),
+  ).toBe([HEAD, UNRESOLVED, LAST].join("\n"));
+});
+
+test("anything that may change the directory before the send makes its PDF unresolved, not guessed", () => {
+  for (const command of [
+    "cd papers/p && npx paperlint submission update --save",
+    "pushd papers/p; npx paperlint submission update --save",
+    "env -C papers/p npx paperlint submission update --save",
+  ])
+    expect(reasonOf(command, paper(facts())), command).toBe(
+      [HEAD, UNRESOLVED, LAST].join("\n"),
+    );
+});
+
+test("a quoted --pdf=<file> with a space is one word: the PDF is that file", () => {
+  const fs = memoryFiles({ "/w/final copies/paper.pdf": PDF });
+  expect(
+    reasonOf(
+      `npx paperlint submission update papers/p --pdf="final copies/paper.pdf" --save`,
+      fs,
+    ).split("\n")[2],
+  ).toBe(`PDF: final copies/paper.pdf, sha256 ${HEX.slice(0, 12)}`);
+});
+
+/** A second paper's PDF, other bytes. */
+const B = new TextEncoder().encode("%PDF b");
+
+test("every send in a chain is described, one block each", () => {
+  const fs = memoryFiles({
+    "/w/papers/a/paper.pdf": PDF,
+    "/w/papers/b/paper.pdf": B,
+  });
+  const reason = reasonOf(
+    "npx paperlint submission update papers/a --save && npx paperlint submission new papers/b --save",
+    fs,
+  ).split("\n");
+  expect(
+    reason.filter((l) => /^(?:send|paper folder|PDF)/u.test(l)),
+  ).toStrictEqual([
+    "send 1 of 2:",
+    "paper folder: papers/a",
+    `PDF: papers/a/paper.pdf, sha256 ${HEX.slice(0, 12)}`,
+    "send 2 of 2:",
+    "paper folder: papers/b",
+    `PDF: papers/b/paper.pdf, sha256 ${sha256Hex(B).slice(0, 12)}`,
+  ]);
+});
+
+test("a send whose words the shell would expand, or one inside a string, is asked about as unresolved", () => {
+  expect(
+    reasonOf('npx paperlint submission update "$P" --save', paper(null)),
+  ).toBe([HEAD, UNRESOLVED, LAST].join("\n"));
+  expect(
+    reasonOf(
+      `bash -c "npx paperlint submission update papers/p --save"`,
+      paper(null),
+    ),
+  ).toBe([HEAD, UNRESOLVED, LAST].join("\n"));
+});
+
+test("a client run by its path or quoted is a request: the program is read by its basename", () => {
+  expect(
+    kind("/usr/bin/curl -X POST https://venue.hotcrp.com/api/paper", () => []),
+  ).toBe("direct");
+  expect(
+    kind(
+      `"/usr/bin/curl" -F f=@p.pdf https://submit.example-venue.org/api`,
+      () => HOSTS,
+    ),
+  ).toBe("direct");
+});
+
+test("straight at HotCRP: asked, naming that paperlint's check is skipped", () => {
+  expect(
+    reasonOf(
+      "curl -F file=@paper.pdf https://venue.hotcrp.com/api/upload",
+      paper(null),
+    ),
+  ).toBe(
+    "This command names a venue's submission portal, so it may send to it outside paperlint and its venue check. Allow only if you have read the dry run's venue check.",
+  );
+});
+
+test("a command that sends nothing: no output at all — neither allow nor deny", () => {
+  expect(
+    submissionConfirm(
+      payload("npx paperlint submission update papers/p"),
+      paper(null),
+    ),
+  ).toBe(null);
+  expect(
+    submissionConfirm(JSON.stringify({ tool_input: {} }), paper(null)),
+  ).toBe(null);
+});
+
+test("a crash while describing the send still asks; a payload that is not JSON is asked about", () => {
+  const broken: Files = {
+    isFile: () => false,
+    readBytes: (p: AbsolutePath) => {
+      throw new Error(`disk on fire at ${p}`);
+    },
+    writeAtomic: () => undefined,
+  };
+  expect(reasonOf(SEND, broken)).toBe(
+    `${HEAD} paperlint could not say what will be sent: disk on fire at /w/papers/p/paperlint.json. ${LAST}`,
+  );
+  expect(
+    submissionConfirm(`{"tool_input": {"command": "${SEND}"`, paper(null))
+      ?.hookSpecificOutput.permissionDecision,
+  ).toBe("ask");
+  // A relative or missing cwd: the hook's own working directory.
+  expect(
+    submissionConfirm(payload(SEND, "relative"), paper(null))
+      ?.hookSpecificOutput.permissionDecision,
+  ).toBe("ask");
+});