@event4u/agent-config 14.18.0 → 14.19.0

package/src/scripts/_lib/release_material.ts

@@ -351,6 +351,69 @@ export const MIX_RESPONSE_PLACEHOLDERS: readonly string[] = [
 export function render_mix_response(level: string): string[] {
     return [
         `> ${MIX_RESPONSE_MARKER} ${level}.`,
-        `> Next cycle ships ${MIX_RESPONSE_PLACEHOLDER}, tracked in <roadmap or issue>.`,
+        `> ${PROMISE_PHRASE} ${MIX_RESPONSE_PLACEHOLDER}, tracked in <roadmap or issue>.`,
     ];
 }
+
+/**
+ * The words that turn a governance response into a PROMISE about a later cycle.
+ *
+ * Named rather than inlined because two sides now read it: the writer emits it,
+ * and the next release reads the previous section for it to decide whether a
+ * read-back is owed. A promise nothing reads back costs nothing to restate, so
+ * it can be restated for as many cycles as there are cycles — the defect this
+ * constant exists to make addressable.
+ */
+export const PROMISE_PHRASE = 'Next cycle ships';
+
+/**
+ * The marker under which a release head answers the PREVIOUS head's promise.
+ *
+ * A named sentinel, on the same discipline as `MIX_RESPONSE_MARKER` and
+ * `DERIVED_MARKER`: a shape match over prose would accept a sentence that
+ * happens to mention last cycle and reject a reworded answer.
+ */
+export const PROMISE_READBACK_MARKER = '**Previous cycle:**';
+
+/**
+ * The three outcomes a read-back may report, and the reason there are exactly
+ * three.
+ *
+ * `shipped` and `did not ship` are the honest halves of the fact. `withdrawn`
+ * exists because a promise the project decided not to keep is a legitimate
+ * third state — but only WITH a reason, which is why the answer also has to
+ * clear a written-length floor rather than being one of these three words on
+ * its own. Without the third state the mechanism would push an author toward
+ * restating a dead promise as still-outstanding, which is the failure it is
+ * built to stop.
+ */
+export const PROMISE_OUTCOMES: readonly string[] = ['shipped', 'did not ship', 'withdrawn'];
+
+/** Every `## X.Y.Z` release version in the file, in document order (newest first). */
+export function changelog_versions(text: string): string[] {
+    const out: string[] = [];
+    for (const m of text.matchAll(/^##\s+\[?(\d+\.\d+\.\d+)\b/gmu)) {
+        out.push(m[1] as string);
+    }
+    return out;
+}
+
+/**
+ * The release published immediately before `version`, or null when there is none.
+ *
+ * Read from the CHANGELOG rather than from git tags on purpose: the promise
+ * being read back is a property of the SECTION, and a tag can exist for a
+ * version whose section was archived into `docs/archive/` under an era split —
+ * in which case there is no previous promise reachable in this file and the
+ * honest answer is that none is owed.
+ *
+ * `version` itself need not be present: a section still under authoring is
+ * named `[Unreleased]`, so the caller passes the version it is releasing and
+ * gets the newest RELEASED version that is not it.
+ */
+export function previous_changelog_version(text: string, version: string): string | null {
+    const versions = changelog_versions(text);
+    const idx = versions.indexOf(version);
+    if (idx !== -1) return versions[idx + 1] ?? null;
+    return versions[0] ?? null;
+}

package/src/scripts/_lib/runtime_journal.ts

@@ -174,6 +174,8 @@ import type { DatabaseSync } from 'node:sqlite';
 import { current_branch, git_common_dir, git_dir } from './git_common_dir.js';
 import type { TerminalState } from './outcome_envelope.js';
 import { readRunTerminalState, RUN_TERMINAL_STATES } from './outcome_vocabularies.js';
+import { addColumnIfMissing } from './sqlite_schema.js';
+import { readSurface, type Surface } from './surface.js';
 import {
     isSqliteAvailableSync,
     loadSqliteSync,
@@ -408,6 +410,14 @@ export interface JournalEvent {
     at: string;
     /** Bounded identifier: the hook or command name. Never free text. */
     capability: string;
+    /**
+     * IDE / CLI / cloud dimension of the dispatch. Closed vocabulary, and
+     * almost always `unknown`: no host observed here sends a distinguishing
+     * marker and the detector refuses to infer one. Recorded anyway because
+     * "did this come from the surface the lattice assumed" has no answer at
+     * all while the field is absent.
+     */
+    surface: Surface;
     /** Imported from `outcome_envelope.ts`; null until an episode terminates. */
     terminal_state: TerminalState | null;
     /** Repo-relative locator for the return. Never an absolute path. */
@@ -447,6 +457,7 @@ export const JOURNAL_RECORD_KEYS = Object.freeze([
     'worktree_id',
     'at',
     'capability',
+    'surface',
     'terminal_state',
     'return_ref',
     'verification_ref',
@@ -759,6 +770,7 @@ function createSchema(db: DatabaseSync): void {
             worktree_id TEXT NOT NULL,
             at TEXT NOT NULL,
             capability TEXT NOT NULL,
+            surface TEXT NOT NULL DEFAULT 'unknown',
             terminal_state TEXT,
             return_ref TEXT,
             verification_ref TEXT,
@@ -767,6 +779,9 @@ function createSchema(db: DatabaseSync): void {
             amends_seq INTEGER
         )`,
     );
+    // A pre-existing row takes the default, which is the honest value: that
+    // dispatch was never asked what surface it came from.
+    addColumnIfMissing(db, 'journal_event', 'surface', "TEXT NOT NULL DEFAULT 'unknown'");
     db.exec('CREATE INDEX IF NOT EXISTS idx_event_episode ON journal_event(repository_id, episode_id, seq)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_event_session ON journal_event(repository_id, session_id, seq)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_event_task ON journal_event(repository_id, task_id)');
@@ -984,6 +999,8 @@ export interface RecordEventInput {
     prompt_id?: string | null;
     episode_id?: string | null;
     terminal_state?: TerminalState | null;
+    /** Closed vocabulary; anything else (including absent) records `unknown`. */
+    surface?: Surface | null;
     return_ref?: string | null;
     verification_ref?: string | null;
     consumption?: Consumption | null;
@@ -1057,6 +1074,10 @@ export function recordEvent(h: JournalHandle, input: RecordEventInput): JournalE
         worktree_id,
         at,
         capability: input.capability,
+        // Tolerant by design: a surface this build cannot place is `unknown`,
+        // never a throw. The field answers "which surface" and must not be able
+        // to fail a write that would otherwise have succeeded.
+        surface: readSurface(input.surface),
         terminal_state: input.terminal_state ?? null,
         return_ref: requireRef('return_ref', input.return_ref),
         verification_ref: requireRef('verification_ref', input.verification_ref),
@@ -1070,9 +1091,9 @@ export function recordEvent(h: JournalHandle, input: RecordEventInput): JournalE
             `INSERT INTO journal_event
              (event, episode_id, session_id, task_id, prompt_id, boundary_status,
               boundary_rule_version, repository_id, worktree_id, at, capability,
-              terminal_state, return_ref, verification_ref, consumption, retain_until,
-              amends_seq)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+              surface, terminal_state, return_ref, verification_ref, consumption,
+              retain_until, amends_seq)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         )
         .run(
             row.event,
@@ -1086,6 +1107,7 @@ export function recordEvent(h: JournalHandle, input: RecordEventInput): JournalE
             row.worktree_id,
             row.at,
             row.capability,
+            row.surface,
             row.terminal_state,
             row.return_ref,
             row.verification_ref,
@@ -1111,6 +1133,7 @@ function toEvent(r: Record<string, unknown>): JournalEvent {
         worktree_id: String(r['worktree_id']),
         at: String(r['at']),
         capability: String(r['capability']),
+        surface: readSurface(r['surface']),
         // Tolerant, not a cast: a value this build cannot place reads as null.
         terminal_state: readRunTerminalState(r['terminal_state']),
         return_ref: (r['return_ref'] as string | null) ?? null,

package/src/scripts/_lib/runtime_wiring_checks.ts

@@ -28,6 +28,10 @@ import process from 'node:process';
 import { parse as parseYaml } from 'yaml';
 
 import { inheritedGitOverrides } from './repo_root.js';
+import {
+    checkHostPermissionSettings,
+    defaultHostPermissionDeps,
+} from './host_permission_checks.js';
 
 /** The verdict shape `cmd_doctor` renders. Mirrors its internal `Dict` rows. */
 export interface WiringCheck {
@@ -291,7 +295,7 @@ export function checkInheritedGitEnv(env: NodeJS.ProcessEnv = process.env): Wiri
  * two spreads.
  */
 /** The four ids, in render order. Spread into `cmd_doctor`'s two id registries. */
-export const WIRING_CHECK_IDS = ['settings-resolution', 'router-artifact', 'hook-resolution', 'inherited-git-env', 'hooks-kill-switch'] as const;
+export const WIRING_CHECK_IDS = ['settings-resolution', 'router-artifact', 'hook-resolution', 'inherited-git-env', 'hooks-kill-switch', 'host-permission-settings'] as const;
 
 
 /**
@@ -333,6 +337,7 @@ export function checkHooksDisabled(env: NodeJS.ProcessEnv = process.env): Wiring
 
 export function wiringRunners(opts: {
     packageRoot: string;
+    projectRoot: string;
     iterOverrides: () => Iterable<[string, unknown, string]>;
 }): Record<string, () => WiringCheck> {
     return {
@@ -344,6 +349,12 @@ export function wiringRunners(opts: {
         'hook-resolution': () => checkHookResolution(opts.packageRoot).check,
         'inherited-git-env': () => checkInheritedGitEnv(),
         'hooks-kill-switch': () => checkHooksDisabled(),
+        // The host's own permission settings, which decide how often a call is
+        // confirmed. It lives with this family rather than its own because
+        // `checkHookWiring` below already reads the same `~/.claude/settings.json`
+        // for the same host — the question is the same surface, one key over.
+        'host-permission-settings': () =>
+            checkHostPermissionSettings(defaultHostPermissionDeps(opts.projectRoot)),
     };
 }
 

package/src/scripts/_lib/session_register.ts

@@ -175,14 +175,19 @@ export function stop_means_session_end(platform: string | null | undefined): boo
  * Deliberately **not** derived from the frequency lattice. That instrument
  * models *slot presence*, and two hosts have a slot that never fires:
  *
- * - `cursor` — `user_prompt_submit` and `stop` are **IDE-only**; the CLI fires
- *   only shell-execution hooks (`hook_manifest.yaml:365-366`,
- *   `chat-history-platform-hooks.md:214`). The lattice has no IDE/CLI dimension,
- *   so it reports cursor covered.
+ * - `cursor` — excluded because reachability there is UNESTABLISHED, not
+ *   because it is known absent. The earlier wording asserted the CLI fires only
+ *   shell-execution hooks, sourced to a 2026-01 reading that carried no expiry
+ *   and could not be re-verified in either direction. The safe direction is the
+ *   one taken: an unverified slot must not read as covered. The lattice has no
+ *   IDE/CLI dimension of its own, so it would report cursor covered; the
+ *   envelope now carries a `surface` field (`_lib/surface.ts`) that records
+ *   which surface a dispatch came from, and it answers `unknown` on cursor
+ *   because no marker distinguishes the two.
  * - `cowork` — slots are structurally wired but lifecycle events do not fire
  *   (`hook_manifest.yaml:346-351`).
- * - `copilot` — no hook surface at all (`hook_manifest.yaml:428-429`), excluded
- *   from the join by declaration.
+ * - `copilot` — nothing bound by this package (`fallback_only: true` in the
+ *   manifest), excluded from the join by declaration.
  *
  * A session on an excluded host still *registers* if a `session_start` reaches
  * it, and simply stops being visible after its TTL. It is never reported as

package/src/scripts/_lib/sqlite_schema.ts

@@ -0,0 +1,22 @@
+/**
+ * Schema helpers for the `node:sqlite` stores in this tree.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+
+/**
+ * Add a column to an existing table when it is absent.
+ *
+ * `CREATE TABLE IF NOT EXISTS` is a no-op on a database that predates a
+ * column, so a store created by an earlier build needs the explicit add or the
+ * field is silently missing from every read.
+ *
+ * `PRAGMA table_info` rather than a catch around `ALTER TABLE`: swallowing the
+ * error would also swallow a genuine schema failure, and a store that silently
+ * fails to migrate reads exactly like one that never needed to.
+ */
+export function addColumnIfMissing(db: DatabaseSync, table: string, column: string, decl: string): void {
+    const cols = db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[];
+    if (cols.length === 0) return;
+    if (cols.some((c) => c.name === column)) return;
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${decl}`);
+}

package/src/scripts/_lib/surface.ts

@@ -0,0 +1,86 @@
+/**
+ * surface — the IDE / CLI / cloud dimension of a dispatch, as an ENVELOPE
+ * field rather than a platform key.
+ *
+ * WHY A FIELD AND NOT A PLATFORM. `_lib/session_register.ts` records that the
+ * capability lattice has no IDE/CLI dimension, which is why it reports cursor
+ * covered whether or not its per-turn slots fire there. Splitting `cursor`
+ * into `cursor-ide` / `cursor-cli` would change `--platform`, the eight
+ * platform identifiers, and every manifest row keyed on them. A field changes
+ * none of those and is still the thing `host_lowering.yaml`'s `(host, surface,
+ * slot)` key needs.
+ *
+ * WHAT THIS CAN AND CANNOT DECIDE — the honest half.
+ *
+ * `unknown` is the default and, today, very nearly the only answer. Nothing in
+ * this tree distinguishes an IDE session from a CLI one on any host: no host
+ * payload observed here carries such a marker, and inferring it from a TTY or
+ * a terminal name would be a guess wearing a function's authority — the exact
+ * move the surrounding roadmap exists to remove. So there is no `ide` or `cli`
+ * branch. When a host is observed to send a distinguishing marker, it is added
+ * to {@link CLOUD_PAYLOAD_MARKERS}'s sibling with a dated citation, and the
+ * branch arrives with the evidence rather than ahead of it.
+ *
+ * The `cloud` branch is a DECLARED VOCABULARY, not an observation. This package
+ * will honour these payload keys if a host sends one; none has been observed
+ * sending one. That distinction is the point: the mechanism is real and tested,
+ * the host claim is absent and says so.
+ */
+
+/** The closed surface vocabulary. `unknown` is the safe default. */
+export const SURFACES = ['ide', 'cli', 'cloud', 'unknown'] as const;
+export type Surface = (typeof SURFACES)[number];
+
+/**
+ * Payload keys whose truthy presence declares a background / cloud agent.
+ *
+ * Declared, not observed — see the module header. Kept as a list so a host that
+ * starts sending one needs no code change, only a citation in this comment.
+ */
+export const CLOUD_PAYLOAD_MARKERS: readonly string[] = [
+    'background_agent',
+    'is_background',
+    'isBackgroundAgent',
+];
+
+/** Explicit override, for a caller that already knows the surface. */
+export const SURFACE_ENV_VAR = 'AGENT_CONFIG_SURFACE';
+
+function _isSurface(v: unknown): v is Surface {
+    return typeof v === 'string' && (SURFACES as readonly string[]).includes(v);
+}
+
+/**
+ * Resolve the surface for one dispatch.
+ *
+ * Precedence: an explicit environment override, then a declared payload
+ * marker, then `unknown`. An unrecognised override value is ignored rather
+ * than trusted — a typo must not become a capability claim.
+ */
+export function detectSurface(
+    payload: unknown,
+    env: Record<string, string | undefined> = process.env,
+): Surface {
+    const override = env[SURFACE_ENV_VAR];
+    if (_isSurface(override)) return override;
+
+    if (typeof payload === 'object' && payload !== null && !Array.isArray(payload)) {
+        const obj = payload as Record<string, unknown>;
+        for (const key of CLOUD_PAYLOAD_MARKERS) {
+            if (obj[key]) return 'cloud';
+        }
+    }
+    return 'unknown';
+}
+
+/**
+ * Read a persisted or caller-supplied surface value.
+ *
+ * Tolerant, not a cast: an unrecognised value — a row written by a newer build,
+ * a typo, an absent field — reads as `unknown`. Same posture as
+ * `readRunTerminalState`, and for the same reason: a value this build cannot
+ * place must not fail a write or a read.
+ */
+export function readSurface(v: unknown): Surface {
+    return _isSurface(v) ? v : 'unknown';
+}

package/src/scripts/_lib/ui_authority.ts

@@ -341,3 +341,119 @@ export function operationConflicts(authority: UiAuthority, op: Operation): Confl
     }
     return out;
 }
+
+/* -------------------------------------------------------------------------- */
+/* Antipattern signal classes against the precedence list                      */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * The five classes a `design-antipatterns.md` catalog row may claim.
+ *
+ * Kept here, beside the precedence list, rather than in the catalog gate: the
+ * question "may this signal overrule what the user supplied" is a precedence
+ * question, and precedence lives in exactly one module by construction.
+ */
+export type SignalClass =
+    | 'floor'
+    | 'invariant'
+    | 'craft-presumption'
+    | 'style-preference'
+    | 'reference-constraint';
+
+/** The two classes that are opinions rather than thresholds. */
+export const SOFT_CLASSES = ['craft-presumption', 'style-preference'] as const;
+
+export interface SignalVerdict {
+    /**
+     * `blocks` — refuse the surface. `flags` — surface it as a rebuttable
+     * presumption. `yields` — say nothing: something with more authority has
+     * already decided this.
+     */
+    outcome: 'blocks' | 'flags' | 'yields';
+    /** The precedence level that outranked it, numbered as in this file's header. */
+    outranked_by: { level: number; source: ProvenanceSource; detail: string } | null;
+    reason: string;
+}
+
+/**
+ * Where a soft signal sits against the precedence list.
+ *
+ * A craft presumption is a good default and nothing more. When the run has a
+ * supplied reference (4), a coherent incumbent (5), or a project `DESIGN.md`
+ * register (6), that artifact has already decided the question the presumption
+ * would re-open, and re-opening it is the redesign-by-taste failure
+ * `design-fidelity` exists to stop.
+ *
+ * A `floor` or an `invariant` is NOT a taste call — an accessibility threshold
+ * or a structural correctness rule — so nothing on the list releases it, and a
+ * reference artifact that violates one is a finding about the reference.
+ *
+ * LEVELS 1–3 ARE DELIBERATELY NOT MECHANISED HERE. Explicit user authority, a
+ * registered hard constraint, and the surface brief all outrank a presumption a
+ * fortiori, but `Signals` carries them only as whole-surface fields
+ * (`surface_mode`, `register`, `change_intent`) with no per-pattern statement.
+ * Reading a brief's mere presence as blanket permission for every antipattern
+ * would silence the catalog on every briefed surface, which is the opposite of
+ * what those levels mean. A per-pattern override is `DESIGN.md`'s declared
+ * suppression, which is level 6 and IS handled.
+ */
+export function resolveSignal(signalClass: SignalClass, signals: Signals = {}): SignalVerdict {
+    if (signalClass === 'floor' || signalClass === 'invariant') {
+        return {
+            outcome: 'blocks',
+            outranked_by: null,
+            reason:
+                `a ${signalClass} is a threshold, not a preference — no supplied artifact releases it, `
+                + 'and an artifact that violates one is a finding about the artifact',
+        };
+    }
+
+    if (signalClass === 'reference-constraint') {
+        const present = signals.reference !== undefined || signals.design_md?.present === true;
+        return present
+            ? {
+                outcome: 'blocks',
+                outranked_by: null,
+                reason: 'the reference or DESIGN.md this constraint is bound to is present in this run, so it carries that artifact\'s own authority',
+            }
+            : {
+                outcome: 'flags',
+                outranked_by: null,
+                reason: 'the reference this constraint is bound to is not present in this run, so it has no artifact behind it',
+            };
+    }
+
+    if (signals.reference !== undefined) {
+        return {
+            outcome: 'yields',
+            outranked_by: { level: 4, source: 'reference-artifact', detail: signals.reference.path ?? signals.reference.maturity },
+            reason: `a ${signalClass} never outranks a supplied reference artifact`,
+        };
+    }
+    if (signals.incumbent?.coherent === true) {
+        return {
+            outcome: 'yields',
+            outranked_by: { level: 5, source: 'incumbent-scan', detail: 'coherent incumbent' },
+            reason: `a ${signalClass} never outranks a coherent incumbent`,
+        };
+    }
+    if (signals.design_md?.present === true) {
+        return {
+            outcome: 'yields',
+            outranked_by: { level: 6, source: 'design-md', detail: signals.design_md.register ?? 'register unstated' },
+            reason: `a ${signalClass} never outranks a project DESIGN.md register`,
+        };
+    }
+    if (signals.product_md?.present === true) {
+        return {
+            outcome: 'yields',
+            outranked_by: { level: 6, source: 'product-md', detail: signals.product_md.register ?? 'register unstated' },
+            reason: `a ${signalClass} never outranks a project PRODUCT.md register`,
+        };
+    }
+    return {
+        outcome: 'flags',
+        outranked_by: null,
+        reason: `a ${signalClass} with nothing above it on the precedence list is a rebuttable presumption`,
+    };
+}

package/src/scripts/adr/regenerate_index.ts

@@ -16,7 +16,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { readAdrAxisCells, readAdrFrontmatterScalars } from '../_lib/adr_frontmatter.js';
+import { dated_trigger_day, readAdrAxisCells, readAdrFrontmatterScalars } from '../_lib/adr_frontmatter.js';
 import { generatedByItalic } from '../_lib/generated_by.js';
 
 // ^ADR-(\d{3})-([a-z0-9-]+)\.md$
@@ -262,6 +262,41 @@ export function scanOutside(repoRoot: string, roots: readonly string[] = OUTSIDE
     return out;
 }
 
+/**
+ * The rows whose `review_trigger` opens with a calendar date.
+ *
+ * WHY THIS SECTION CARRIES THE DATE AND NOT THE FIRED/NOT-FIRED STATE
+ * ------------------------------------------------------------------
+ * `regenerate_index --check` byte-compares this file in CI
+ * (`.github/workflows/rule-backstops.yml`), so anything rendered here has to be
+ * a function of the tree alone. A `fired` / `not-fired` column would be a
+ * function of the tree AND the day, which means the index would go stale on a
+ * calendar boundary nobody committed and red every open pull request until
+ * someone regenerated it. The date is the decidable half; the reader compares
+ * it to today, and `adr_cite_check` prints the comparison for a machine.
+ */
+export interface DatedTriggerRow {
+    label: string;
+    path: string;
+    day: string;
+    decision: string;
+}
+
+export function datedTriggerRows(rows: readonly Row[]): DatedTriggerRow[] {
+    const out: DatedTriggerRow[] = [];
+    for (const r of rows) {
+        const day = dated_trigger_day(r.review_trigger ?? '');
+        if (day === null) continue;
+        out.push({
+            label: 'num' in r ? `ADR-${r.num as string}` : (r.path as string).slice(0, -3),
+            path: r.path as string,
+            day,
+            decision: r.decision ?? r.slug ?? '—',
+        });
+    }
+    return out.sort((a, b) => a.day.localeCompare(b.day) || a.label.localeCompare(b.label));
+}
+
 /** Mirror `render(num, leg)`. */
 export function render(num: Row[], leg: Row[], outside: OutsideRow[] = []): string {
     const out = [
@@ -277,6 +312,24 @@ export function render(num: Row[], leg: Row[], outside: OutsideRow[] = []): stri
     if (leg.length > 0) {
         out.push('', '## Unnumbered (legacy)', '', HEAD, ...leg.map(row));
     }
+    const dated = datedTriggerRows([...num, ...leg]);
+    if (dated.length > 0) {
+        out.push(
+            '',
+            '## Dated review triggers',
+            '',
+            'A `review_trigger` that opens with a calendar date is the one reopen condition',
+            'this repository can decide without interpreting anything, so it is listed where a',
+            'reader meets it rather than only in a command they would have to know to run.',
+            'Compare the expiry to today; `./scripts-run src/scripts/adr_cite_check <ADR-NNN>`',
+            'prints `fired` or `not-fired` for the same date. Every other trigger is semantic',
+            'and reports `indeterminate` — a trigger that merely mentions a date is not listed.',
+            '',
+            '| Expiry | # | Decision |',
+            '|---|---|---|',
+            ...dated.map((d) => `| ${d.day} | [${d.label}](${d.path}) | ${d.decision} |`),
+        );
+    }
     if (outside.length > 0) {
         out.push(
             '',