paperlint 10.4.0 → 11.0.0

package/src/cli.ts

@@ -100,10 +100,10 @@ import { texOutput } from "./adapters/tex-output/index.ts";
 import { BIB_RULE_LEVELS, bibRules } from "./bib-rules.ts";
 import { bibliographyReader } from "./references.ts";
 import { onlineReferences } from "./adapters/references/index.ts";
-import { hotcrpPortal } from "./adapters/hotcrp/index.ts";
+import { hotcrpSite } from "./adapters/hotcrp/index.ts";
 import { runSubmission } from "./submission.ts";
 import type { PortalKind, SupportedPortal } from "./domain/submission.ts";
-import type { SubmissionPortal } from "./ports/submission-portal.ts";
+import type { PortalSite } from "./ports/submission-portal.ts";
 import type { CheckReferences } from "./ports/check-references.ts";
 import {
   narrowToOwners,
@@ -234,6 +234,11 @@ const USAGE = `paperlint — machine-checkable gates for a paper kept in git
                                       into ~/.cache/paperlint/texlive (PAPERLINT_TEXLIVE_DIR overrides); a second
                                       run does nothing. --check: report what is missing, change nothing
   npx paperlint doctor                say what is actually wired — and what only LOOKS wired
+  npx paperlint submission new [paper] [--abstract <file>] [--save]
+                                      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
   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
@@ -285,13 +290,18 @@ studies:
 
 submission:
   The venue preset declares the portal — "portal": { "kind": "hotcrp", "url": "<site>" } — and the
-  paper's paperlint.json its submission there — "submission": { "id": <number> }. The token comes
-  only from the environment: HOTCRP_TOKEN (HotCRP: Account settings → Developer).
+  paper's paperlint.json its submission there — "submission": { "id": <number> }, written by new
+  — and, for new, its "authors": [{ "name", "email", "affiliation"? }]. The token comes only from
+  the environment, one variable per site: HOTCRP_TOKEN_<subdomain> on *.hotcrp.com, else
+  HOTCRP_TOKEN_<host and path> — e.g. HOTCRP_TOKEN_MSR2027 for msr2027.hotcrp.com,
+  HOTCRP_TOKEN_AIDC_SUBMIT_ACSAC_ORG for aidc.submit.acsac.org (HotCRP: Account settings →
+  Developer). A plain HOTCRP_TOKEN is not read.
   [paper]             the paper's folder; default the current directory
   --pdf <file>        the PDF to compare (show) or send (update) instead of the paper's own
-  --abstract <file>   update: a plain-text file whose text replaces the abstract
+  --abstract <file>   new, update: a plain-text file whose text is sent as the abstract
   --submit            update: mark the submission submitted
-  --save              update: really change the submission. Without it, nothing is saved
+  --save              new, update: really create or change the submission. Without it, nothing
+                      is saved
 
 lint:
   npx paperlint lint [paths…] [--fix] [--config <file.json>] [--json]
@@ -1737,7 +1747,9 @@ const SIMPLE: Readonly<
         presets: PRESET_DEPS,
         cwd,
         env: (name) => process.env[name],
-        portalFor,
+        site: portalSite,
+        latex: latexReader,
+        codec: sourcesCodec,
         log,
         err,
       },
@@ -1745,13 +1757,10 @@ const SIMPLE: Readonly<
 };
 
 /** The adapter of each portal kind — one per kind, chosen here at the root. */
-const PORTALS: Readonly<
-  Record<PortalKind, (url: string, token: string) => SubmissionPortal>
-> = {
-  hotcrp: (url, token) => hotcrpPortal({ url, token }),
+const PORTALS: Readonly<Record<PortalKind, (url: string) => PortalSite>> = {
+  hotcrp: hotcrpSite,
 };
-const portalFor = (p: SupportedPortal, token: string): SubmissionPortal =>
-  PORTALS[p.kind](p.url, token);
+const portalSite = (p: SupportedPortal): PortalSite => PORTALS[p.kind](p.url);
 
 /** banal's installer, wired from this process's environment: the composition root's work. */
 function hostBanalInstaller(): ToolInstaller {

package/src/cycle-rules.test.ts

@@ -155,8 +155,8 @@ describe("cycle/record", () => {
 
 describe("cycle/record — the deadlines, over the venue preset's readings", () => {
   it("MSR 2027 as a newcomer records the call: abstract → registration, paper → submission; the preset's portal readings are derived — silent", () => {
-    // The portal's submission (2026-10-20T04:00Z, from the preset) is earlier than the call's
-    // registration (the end of 2026-10-20 AoE): two sources disagreeing, not a typo.
+    // The portal's submission (2026-10-21T11:59:59Z, from the preset) is the end of the call's
+    // registration day (2026-10-20 AoE), before the call's submission: no contradiction.
     const fs = lint({
       cycles: [
         msr([
@@ -185,7 +185,7 @@ describe("cycle/record — the deadlines, over the venue preset's readings", ()
     });
     expect(fs.map((f) => f.messageId)).toEqual(["order"]);
     expect(fs[0]?.message).toBe(
-      'paperlint.json, cycle «msr-2027»: the call\'s "registration" (2026-10-26T11:59:59Z) is after its "submission" (2026-10-24T11:59:59Z) — a date typed wrong, or an AoE day miscounted (write a call\'s date as "YYYY-MM-DD AoE" and paperlint converts it)',
+      'paperlint.json, cycle «msr-2027»: the call\'s "registration" (2026-10-26T11:59:59Z, the call\'s reading on 2026-10-05 from https://2027.msrconf.org/track/msr-2027-technical-papers) is after its "submission" (2026-10-24T11:59:59Z, the call\'s reading on 2026-10-05 from https://2027.msrconf.org/track/msr-2027-technical-papers) — a date typed wrong, or an AoE day miscounted (write a call\'s date as "YYYY-MM-DD AoE" and paperlint converts it)',
     );
   });
 });
@@ -199,10 +199,10 @@ describe("cycle/record — a portal reading beside the preset's", () => {
             what: "submission",
             observed: [
               {
-                at: "2026-10-20T04:00:00Z",
+                at: "2026-10-21T11:59:59Z",
                 source: "portal",
                 url: "https://msr2027.hotcrp.com/deadlines",
-                read: "2026-10-01",
+                read: "2026-10-19",
               },
             ],
           },
@@ -210,7 +210,7 @@ describe("cycle/record — a portal reading beside the preset's", () => {
       ],
     });
     expect(fs.map((f) => f.message)).toEqual([
-      "paperlint.json, cycle «msr-2027»: the \"submission\" deadline records a portal reading, and the preset paperlint:msr carries the portal's reading of it (2026-10-20T04:00:00Z, read 2026-10-05) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)",
+      "paperlint.json, cycle «msr-2027»: the \"submission\" deadline records a portal reading, and the preset paperlint:msr carries it (2026-10-21T11:59:59Z, the portal's reading on 2026-10-19 from https://msr2027.hotcrp.com/deadlines — venues move dates: re-check there before relying on it) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)",
     ]);
   });
 

package/src/cycle-rules.ts

@@ -41,7 +41,11 @@ import {
   type Cycle,
   type Cycles,
 } from "./domain/cycle.ts";
-import { deadlineOrderProblems, type Reading } from "./domain/deadline.ts";
+import {
+  deadlineOrderProblems,
+  readingText,
+  type Reading,
+} from "./domain/deadline.ts";
 import { resolvePreset } from "./presets.ts";
 import { fieldOf } from "./domain/record.ts";
 import { err, ok, type Result } from "./domain/result.ts";
@@ -104,8 +108,7 @@ function presetCopies(c: Cycle, preset: PresetOfCycle): readonly Finding[] {
               id: c.id,
               what: d.what,
               preset: preset.spec,
-              at: theirs.at,
-              read: theirs.read,
+              reading: readingText(theirs),
             },
           },
         ]
@@ -190,7 +193,7 @@ const META: Readonly<Record<CycleRuleName, FolderRuleModule["meta"]>> = {
     messages: {
       broken: `${CONFIG_FILE}: {{why}}`,
       order: `${CONFIG_FILE}, cycle «{{id}}»: {{why}} — a date typed wrong, or an AoE day miscounted (write a call's date as "YYYY-MM-DD AoE" and paperlint converts it)`,
-      presetCopy: `${CONFIG_FILE}, cycle «{{id}}»: the "{{what}}" deadline records a portal reading, and the preset {{preset}} carries the portal's reading of it ({{at}}, read {{read}}) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)`,
+      presetCopy: `${CONFIG_FILE}, cycle «{{id}}»: the "{{what}}" deadline records a portal reading, and the preset {{preset}} carries it ({{reading}}) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)`,
     },
   },
   evidence: {

package/src/domain/deadline.test.ts

@@ -4,6 +4,7 @@
  */
 import { describe, expect, it } from "vitest";
 import {
+  readingText,
   deadlineOrderProblems,
   deadlinesInForce,
   instantOf,
@@ -325,8 +326,8 @@ describe("deadlineOrderProblems — within ONE source; across sources is the dis
       reading("notification", "2027-02-01T00:00:00Z"),
     ];
     expect(deadlineOrderProblems(own, preset)).toEqual([
-      'the portal\'s "notification" (2027-02-01T00:00:00Z) is after its "camera-ready" (2027-01-01T00:00:00Z)',
-      'the call\'s "registration" (2026-10-26T11:59:59Z) is after its "submission" (2026-10-24T11:59:59Z)',
+      'the portal\'s "notification" (2027-02-01T00:00:00Z, the portal\'s reading on 2026-10-05 from https://example.org/portal — venues move dates: re-check there before relying on it) is after its "camera-ready" (2027-01-01T00:00:00Z, the portal\'s reading on 2026-10-05 from https://example.org/portal — venues move dates: re-check there before relying on it)',
+      'the call\'s "registration" (2026-10-26T11:59:59Z, the call\'s reading on 2026-10-05 from https://beta2027.example.org/call) is after its "submission" (2026-10-24T11:59:59Z, the call\'s reading on 2026-10-05 from https://beta2027.example.org/call)',
     ]);
   });
 
@@ -384,3 +385,31 @@ describe("instantOf", () => {
     }
   });
 });
+
+describe("readingText — the one way a reading is printed", () => {
+  it("🔴 a portal's reading says when and where it was read, that venues move dates, and to re-check", () => {
+    expect(
+      readingText({
+        at: "2026-10-21T11:59:59Z",
+        source: "portal",
+        url: "https://msr2027.hotcrp.com/deadlines",
+        read: "2026-10-19",
+      }),
+    ).toBe(
+      "2026-10-21T11:59:59Z, the portal's reading on 2026-10-19 from https://msr2027.hotcrp.com/deadlines — venues move dates: re-check there before relying on it",
+    );
+  });
+
+  it("a call's reading: when and where it was read", () => {
+    expect(
+      readingText({
+        at: "2026-10-24T11:59:59Z",
+        source: "call",
+        url: "https://2027.msrconf.org/cfp",
+        read: "2026-10-05",
+      }),
+    ).toBe(
+      "2026-10-24T11:59:59Z, the call's reading on 2026-10-05 from https://2027.msrconf.org/cfp",
+    );
+  });
+});

package/src/domain/deadline.ts

@@ -75,6 +75,17 @@ export interface Observation {
   readonly read: IsoDate;
 }
 
+/**
+ * THE ONE WAY a deadline reading is printed: the instant, and where and when it was read. A portal's
+ * reading adds that venues move dates and to re-check the page before relying on it — MSR moved both
+ * its deadlines after the preset read them, and the preset kept the old ones for two weeks (#235).
+ * Used by `submission show` and the `cycle/record` messages. Pure.
+ */
+export const readingText = (o: Observation): string =>
+  o.source === "portal"
+    ? `${o.at}, the portal's reading on ${o.read} from ${o.url} — venues move dates: re-check there before relying on it`
+    : `${o.at}, the ${o.source}'s reading on ${o.read} from ${o.url}`;
+
 /** A human decision that another instant binds, with why and the file it rests on. */
 export interface Override {
   readonly at: Instant;
@@ -110,7 +121,7 @@ export interface InForce {
 
 /**
  * What a venue's portal says about its deadlines, in paperlint's words — what the scheduled refresh
- * of the shipped presets reads (`scripts/refresh-deadlines.ts`). One adapter per portal kind.
+ * of the shipped presets reads (`scripts/refresh-deadlines/`). One adapter per portal kind.
  */
 export interface PortalDeadlines {
   /** The portal's clock when it answered, Unix seconds. */
@@ -406,40 +417,51 @@ export function deadlinesInForce(
   });
 }
 
-/** One instant per kind, the earliest a layer holds for it, in the order of the kinds. */
-type Layer = readonly { readonly what: DeadlineWhat; readonly at: Instant }[];
+/** One instant per kind — and the reading it came from, an override's none. */
+type Entry = {
+  readonly what: DeadlineWhat;
+  readonly at: Instant;
+  readonly reading: Observation | null;
+};
+/** One entry per kind, the earliest a layer holds for it, in the order of the kinds. */
+type Layer = readonly Entry[];
 
 const layerOf = (entries: Layer): Layer =>
   DEADLINE_WHATS.flatMap((what) => {
-    const ats = entries.filter((e) => e.what === what).map((e) => e.at);
-    const first = ats.toSorted()[0];
-    return first === undefined ? [] : [{ what, at: first }];
+    const first = entries
+      .filter((e) => e.what === what)
+      .toSorted((a, b) => a.at.localeCompare(b.at))[0];
+    return first === undefined ? [] : [first];
   });
 
 /** The pairs of a layer out of the order registration ≤ submission ≤ resubmission < notification < camera-ready. */
 const inversions = (
   layer: Layer,
-  says: (what: DeadlineWhat, at: Instant, later: boolean) => string,
+  says: (e: Entry, later: boolean) => string,
 ): readonly string[] =>
   layer.flatMap((d, i) => {
     const before = layer[i - 1];
     return before !== undefined && before.at > d.at
-      ? [
-          `${says(before.what, before.at, false)} is after ${says(d.what, d.at, true)}`,
-        ]
+      ? [`${says(before, false)} is after ${says(d, true)}`]
       : [];
   });
 
+/** An entry's instant, with where and when it was read when it is a reading. */
+const entryText = (e: Entry): string =>
+  e.reading === null ? e.at : readingText(e.reading);
+
 const readingsOf = (
   own: readonly Deadline[],
   preset: readonly Reading[],
   source: DeadlineSource,
 ): Layer => [
-  ...preset.filter((r) => r.source === source),
+  ...preset
+    .filter((r) => r.source === source)
+    .map((r) => ({ what: r.what, at: r.at, reading: r })),
   ...own.flatMap((d) =>
     d.observed
       .filter((o) => o.source === source)
-      .map((o) => ({ what: d.what, at: o.at })),
+      .map((o) => ({ what: d.what, at: o.at, reading: o })),
   ),
 ];
 
@@ -453,20 +475,24 @@ export function deadlineOrderProblems(
   preset: readonly Reading[],
 ): readonly string[] {
   const overrides = own.flatMap((d) =>
-    d.override === null ? [] : [{ what: d.what, at: d.override.at }],
+    d.override === null
+      ? []
+      : [{ what: d.what, at: d.override.at, reading: null }],
   );
   return [
     ...inversions(
       layerOf(readingsOf(own, preset, "portal")),
-      (w, at, later) => `${later ? "its" : "the portal's"} "${w}" (${at})`,
+      (e, later) =>
+        `${later ? "its" : "the portal's"} "${e.what}" (${entryText(e)})`,
     ),
     ...inversions(
       layerOf(readingsOf(own, preset, "call")),
-      (w, at, later) => `${later ? "its" : "the call's"} "${w}" (${at})`,
+      (e, later) =>
+        `${later ? "its" : "the call's"} "${e.what}" (${entryText(e)})`,
     ),
     ...inversions(
       layerOf(overrides),
-      (w, at) => `the override of "${w}" (${at})`,
+      (e) => `the override of "${e.what}" (${entryText(e)})`,
     ),
   ];
 }

package/src/domain/decide-first.test.ts

@@ -180,6 +180,23 @@ it("a decision that names a directory is reported, and no history is judged", ()
   ]);
 });
 
+it("a decision behind a linked directory is reported with the link, and no history is judged", () => {
+  // Guards: git records a path through a link as what lies behind the link.
+  expect(
+    judgeOrder({
+      ...STUDY,
+      facts: { kind: "linked", link: "repro/P1-S01-x/sub" },
+    }),
+  ).toEqual([
+    {
+      problem: "decision-linked",
+      id: "P1-S01",
+      file: "repro/P1-S01-x/decision.md",
+      link: "repro/P1-S01-x/sub",
+    },
+  ]);
+});
+
 const PAGE =
   "\nRule repro/outputs-before-decision: https://github.com/zernie/paperlint/blob/main/docs/rules/repro/outputs-before-decision.md";
 
@@ -192,6 +209,12 @@ const ALL: readonly OrderFinding[] = [
     glob: "**/*.md",
   },
   { problem: "decision-deleted", id: "P1-S01", file: "repro/d.md" },
+  {
+    problem: "decision-not-file",
+    id: "P1-S01",
+    file: "repro/p",
+    what: "special file",
+  },
   {
     problem: "decision-not-file",
     id: "P1-S01",
@@ -204,6 +227,12 @@ const ALL: readonly OrderFinding[] = [
     file: "repro/l.md",
     what: "symbolic link",
   },
+  {
+    problem: "decision-linked",
+    id: "P1-S01",
+    file: "repro/sub/d.md",
+    link: "repro/sub",
+  },
   { problem: "no-history", id: "P1-S01", why: "git is not installed" },
   { problem: "shallow", id: "P1-S01" },
   {
@@ -240,10 +269,14 @@ it("each finding's message: what is wrong, what to do, the rule's page", () => {
       PAGE,
     "The decision of `P1-S01`, `repro/d.md`, was committed and then deleted: it is not in HEAD, so the study has no decision its outputs could follow. What to do: restore the decision file as it was decided and commit it — never write a new one after the outputs; if the decision no longer holds, declare the study `exploratory` with the reason." +
       PAGE,
+    "The decision of `P1-S01`, `repro/p`, is a special file, not a file: git tracks only regular files, so no order can be read from it. What to do: name the decision file itself in `mode.decision.file`." +
+      PAGE,
     "The decision of `P1-S01`, `repro/d`, is a directory, not a file: git answers for a directory with the commits of anything under it, so no order can be read from it. What to do: name the decision file itself in `mode.decision.file`." +
       PAGE,
     "The decision of `P1-S01`, `repro/l.md`, is a symbolic link, not a file: git records the link, not the file it points to, so no order can be read from it. What to do: name the decision file itself in `mode.decision.file`." +
       PAGE,
+    "The decision of `P1-S01`, `repro/sub/d.md`, passes through the symbolic link `repro/sub`: git records the link, not the files behind it, so no order can be read from it. What to do: name a decision file that lies in real directories in `mode.decision.file`." +
+      PAGE,
     "`P1-S01` is decided before its run, and git's history is the proof of that order, but git could not answer: git is not installed. What to do: lint the paper inside its git repository, with git installed." +
       PAGE,
     "`P1-S01` is decided before its run, and this clone is shallow: every file's first commit is the clone's first, so the order of decision and outputs cannot be read. What to do: fetch the whole history (`git fetch --unshallow`; in GitHub Actions, `actions/checkout` with `fetch-depth: 0`)." +

package/src/domain/decide-first.ts

@@ -23,7 +23,7 @@ import {
 } from "./study-mode.ts";
 
 /** What a decision path names on disk when it is no file git can vouch for. */
-export type NotAFile = "directory" | "symbolic link";
+export type NotAFile = "directory" | "symbolic link" | "special file";
 
 /** A commit, and its committer date (ISO 8601 with its offset). */
 export interface CommitAt {
@@ -54,6 +54,8 @@ export interface FirstCommit extends CommitAt {
  */
 export type OrderFacts =
   | { readonly kind: "not-a-file"; readonly what: NotAFile }
+  /** The decision's path passes through a symbolic link above the file (`link`: the first, relative to the paper). */
+  | { readonly kind: "linked"; readonly link: string }
   | { readonly kind: "unknown"; readonly why: string }
   /** A shallow clone: every file's first commit is the clone's first, so no order can be read. */
   | { readonly kind: "shallow" }
@@ -97,6 +99,12 @@ export type OrderFinding =
       readonly file: string;
       readonly what: NotAFile;
     }
+  | {
+      readonly problem: "decision-linked";
+      readonly id: string;
+      readonly file: string;
+      readonly link: string;
+    }
   | {
       readonly problem: "no-history";
       readonly id: string;
@@ -188,6 +196,10 @@ const historyFindings = (s: DecideFirstStudy): readonly OrderFinding[] => {
       return [
         { problem: "decision-not-file", id: s.id, file, what: s.facts.what },
       ];
+    case "linked":
+      return [
+        { problem: "decision-linked", id: s.id, file, link: s.facts.link },
+      ];
     case "unknown":
       return [{ problem: "no-history", id: s.id, why: s.facts.why }];
     case "shallow":
@@ -212,6 +224,7 @@ const NOT_A_FILE: Readonly<Record<NotAFile, string>> = {
   directory:
     "git answers for a directory with the commits of anything under it",
   "symbolic link": "git records the link, not the file it points to",
+  "special file": "git tracks only regular files",
 };
 
 const short = (c: CommitAt): string => `${c.commit.slice(0, 12)} (${c.date})`;
@@ -225,6 +238,8 @@ const HEADS: {
     `The decision of \`${f.id}\`, \`${f.file}\`, was committed and then deleted: it is not in HEAD, so the study has no decision its outputs could follow. What to do: restore the decision file as it was decided and commit it — never write a new one after the outputs; if the decision no longer holds, declare the study \`exploratory\` with the reason.`,
   "decision-not-file": (f) =>
     `The decision of \`${f.id}\`, \`${f.file}\`, is a ${f.what}, not a file: ${NOT_A_FILE[f.what]}, so no order can be read from it. What to do: name the decision file itself in \`mode.decision.file\`.`,
+  "decision-linked": (f) =>
+    `The decision of \`${f.id}\`, \`${f.file}\`, passes through the symbolic link \`${f.link}\`: git records the link, not the files behind it, so no order can be read from it. What to do: name a decision file that lies in real directories in \`mode.decision.file\`.`,
   "no-history": (f) =>
     `\`${f.id}\` is decided before its run, and git's history is the proof of that order, but git could not answer: ${f.why}. What to do: lint the paper inside its git repository, with git installed.`,
   shallow: (f) =>

package/src/domain/index-columns.test.ts

@@ -82,11 +82,11 @@ const NINE_AT: IndexInput = {
   ]),
   history: new Map([
     [
-      "P1-S01",
+      "P1-S01-hint/plan.json",
       { kind: "read", decision: D, decisionDeleted: false, firstOutput: A },
     ],
     [
-      "P1-S02",
+      "P1-S02-s/plan.json",
       {
         kind: "read",
         decision: null,
@@ -94,7 +94,7 @@ const NINE_AT: IndexInput = {
         firstOutput: null,
       },
     ],
-    ["P1-S04", { kind: "unread", why: "shallow clone" }],
+    ["P1-S04-s/plan.json", { kind: "unread", why: "shallow clone" }],
   ]),
 };
 
@@ -124,7 +124,7 @@ describe("the mode columns of the index", () => {
       plans,
       history: new Map([
         [
-          "P1-S01",
+          "P1-S01-s/plan.json",
           {
             kind: "read",
             decision: D,
@@ -151,6 +151,49 @@ describe("the mode columns of the index", () => {
   });
 });
 
+it("two rows of one id each show their own history, keyed by folder and plan", () => {
+  const r: StudyRegistry = {
+    prefix: "P1",
+    studies: [row(1, { folder: "P1-S01-a" }), row(1, { folder: "P1-S01-b" })],
+  };
+  const at: IndexInput = {
+    plans: new Map([
+      ["P1-S01-a/plan.json", plan(DECIDED)],
+      ["P1-S01-b/plan.json", plan(DECIDED)],
+    ]),
+    history: new Map([
+      [
+        "P1-S01-a/plan.json",
+        { kind: "read", decision: D, decisionDeleted: false, firstOutput: A },
+      ],
+      [
+        "P1-S01-b/plan.json",
+        {
+          kind: "read",
+          decision: null,
+          decisionDeleted: false,
+          firstOutput: null,
+        },
+      ],
+    ]),
+  };
+  // Guards: keyed by id, the second row's history was shown on both rows (the later one wins).
+  expect(
+    studyIndex(r, at)
+      .split("\n")
+      .slice(2)
+      .map((l) =>
+        l
+          .split("|")
+          .slice(6, 9)
+          .map((c) => c.trim()),
+      ),
+  ).toEqual([
+    ["decide_before_run", "dddddddddddd 2026-10-14", "aaaaaaaaaaaa 2026-10-16"],
+    ["decide_before_run", "not committed", "none"],
+  ]);
+});
+
 it("a decision committed and since deleted shows its commit, and that it is gone", () => {
   // Guards: the Methods sentence must not cite a decision that no longer stands.
   expect(
@@ -181,6 +224,7 @@ describe("indexHistory", () => {
       indexHistory(study({ kind: "unknown", why: "not a repository" })),
       indexHistory(study({ kind: "shallow" })),
       indexHistory(study({ kind: "not-a-file", what: "directory" })),
+      indexHistory(study({ kind: "linked", link: "repro/sub" })),
       indexHistory(
         study({
           kind: "read",
@@ -204,6 +248,7 @@ describe("indexHistory", () => {
       { kind: "unread", why: "git could not answer" },
       { kind: "unread", why: "shallow clone" },
       { kind: "unread", why: "the decision is a directory" },
+      { kind: "unread", why: "the decision is behind a symbolic link" },
       { kind: "read", decision: D, decisionDeleted: false, firstOutput: A },
       {
         kind: "read",

package/src/domain/index-columns.ts

@@ -85,6 +85,8 @@ export const indexHistory = (s: DecideFirstStudy): IndexHistory => {
   switch (s.facts.kind) {
     case "not-a-file":
       return { kind: "unread", why: `the decision is a ${s.facts.what}` };
+    case "linked":
+      return { kind: "unread", why: "the decision is behind a symbolic link" };
     case "unknown":
       return { kind: "unread", why: "git could not answer" };
     case "shallow":

package/src/domain/portal-token.test.ts

@@ -0,0 +1,55 @@
+/** Which token a portal command uses: the site's variable only, a lone site-less one refused by name. */
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { hostOf, lookUpToken } from "./portal-token.ts";
+
+const NAMES = { variable: "HOTCRP_TOKEN_MSR2027", siteLess: "HOTCRP_TOKEN" };
+
+test("hostOf: the URL's host; a text that is no URL stands for itself", () => {
+  assert.equal(
+    hostOf("https://msr2027.hotcrp.com/deadlines"),
+    "msr2027.hotcrp.com",
+  );
+  assert.equal(hostOf("msr2027.hotcrp.com"), "msr2027.hotcrp.com");
+});
+
+test("lookUpToken: the site's variable set → its token, trimmed, and its name", () => {
+  const env: Record<string, string> = {
+    HOTCRP_TOKEN_MSR2027: " hct_site \n",
+    HOTCRP_TOKEN: "hct_other",
+  };
+  assert.deepEqual(
+    lookUpToken(NAMES, (n) => env[n]),
+    {
+      ok: true,
+      value: { variable: "HOTCRP_TOKEN_MSR2027", token: "hct_site" },
+    },
+  );
+});
+
+test("🔴 lookUpToken: only the site-less variable set → refused by name, never used", () => {
+  const env: Record<string, string> = { HOTCRP_TOKEN: "hct_other" };
+  assert.deepEqual(
+    lookUpToken(NAMES, (n) => env[n]),
+    {
+      ok: false,
+      error: {
+        kind: "site-less",
+        variable: "HOTCRP_TOKEN_MSR2027",
+        siteLess: "HOTCRP_TOKEN",
+      },
+    },
+  );
+});
+
+test("lookUpToken: neither set, or only blanks → missing, naming the site's variable", () => {
+  const blank: Record<string, string> = {
+    HOTCRP_TOKEN_MSR2027: "  ",
+    HOTCRP_TOKEN: "",
+  };
+  for (const read of [() => undefined, (n: string) => blank[n]])
+    assert.deepEqual(lookUpToken(NAMES, read), {
+      ok: false,
+      error: { kind: "missing", variable: "HOTCRP_TOKEN_MSR2027" },
+    });
+});