@event4u/agent-config 14.18.0 → 14.19.0

package/src/scripts/install.ts

@@ -90,6 +90,7 @@ import * as catalogue from './_lib/skill_catalogue.js';
 import { isInteractiveSession, type SessionProbe } from '../shared/interactiveContext.js';
 import * as claude_desktop_bundler from './_lib/claude_desktop_bundler.js';
 import * as claude_settings_hooks from './_lib/claude_settings_hooks.js';
+import { hostBindings } from './hooks/host_lowering.js';
 import { find_project_root_with_anchor, load_agent_settings } from './_lib/agent_settings.js';
 import {
     LEGACY_ALL,
@@ -417,7 +418,7 @@ function yamlSafeLoad(text: string): unknown {
 }
 
 // ---------------------------------------------------------------------------
-// Module-level constants (install.py:51-116)
+// Module-level constants.
 // ---------------------------------------------------------------------------
 
 const DEFAULT_PROFILE = 'balanced';
@@ -1022,14 +1023,6 @@ const AUGMENT_LEGACY_TRAMPOLINES: readonly string[] = [
     'augment-onboarding-gate.sh',
     'augment-context-hygiene.sh',
 ];
-const AUGMENT_DISPATCHER_BINDINGS: ReadonlyArray<readonly [string, string]> = [
-    ['session_start', 'SessionStart'],
-    ['session_end', 'SessionEnd'],
-    ['stop', 'Stop'],
-    ['pre_tool_use', 'PreToolUse'],
-    ['post_tool_use', 'PostToolUse'],
-];
-
 function _deploy_augment_trampoline(package_root: string, name: string, force: boolean): string | null {
     const src = path.join(package_root, 'scripts', 'hooks', name);
     if (!pathExists(src)) {
@@ -1073,8 +1066,8 @@ function ensure_augment_user_hooks(package_root: string, force: boolean): Record
     _remove_legacy_augment_trampolines();
 
     const per_event: Record<string, unknown[]> = {};
-    for (const [ac_event, native] of AUGMENT_DISPATCHER_BINDINGS) {
-        const cmd = `${dst} ${ac_event} ${native}`;
+    for (const { slot, native } of hostBindings('augment')) {
+        const cmd = `${dst} ${slot} ${native}`;
         const entry = { hooks: [{ type: 'command', command: cmd }] };
         (per_event[native] ??= []).push(entry);
     }
@@ -1130,14 +1123,6 @@ const _prune_tier_b_modules = (
 ): [number, Record<string, DeployResult>] =>
     _prune_modules_by(dr, mcp_bridge.tierBPrunePredicate(tier_b));
 
-const CURSOR_DISPATCHER_BINDINGS: ReadonlyArray<readonly [string, string]> = [
-    ['session_start', 'sessionStart'],
-    ['session_end', 'sessionEnd'],
-    ['stop', 'stop'],
-    ['user_prompt_submit', 'beforeSubmitPrompt'],
-    ['post_tool_use', 'postToolUse'],
-];
-
 function _cursor_dispatch_command(ac_event: string, native: string): string {
     // Hook-resilience shim (P1.4): missing binary → silent exit 0; a
     // present dispatcher's exit code propagates (fail_closed concerns
@@ -1152,8 +1137,8 @@ function _cursor_dispatch_command(ac_event: string, native: string): string {
 
 function ensure_cursor_bridge(project_root: string, force: boolean): Record<string, unknown>[] {
     const hooks: Record<string, unknown[]> = {};
-    for (const [ac_event, native] of CURSOR_DISPATCHER_BINDINGS) {
-        (hooks[native] ??= []).push({ command: _cursor_dispatch_command(ac_event, native) });
+    for (const { slot, native } of hostBindings('cursor')) {
+        (hooks[native] ??= []).push({ command: _cursor_dispatch_command(slot, native) });
     }
     const bridge = { version: 1, hooks };
     return merge_json_file(
@@ -1187,8 +1172,8 @@ function ensure_cursor_user_hooks(package_root: string, force: boolean): Record<
     }
 
     const hooks: Record<string, unknown[]> = {};
-    for (const [ac_event, native] of CURSOR_DISPATCHER_BINDINGS) {
-        (hooks[native] ??= []).push({ command: `${dst} ${ac_event} ${native}` });
+    for (const { slot, native } of hostBindings('cursor')) {
+        (hooks[native] ??= []).push({ command: `${dst} ${slot} ${native}` });
     }
 
     const settings_patch = { version: 1, hooks };
@@ -1200,15 +1185,6 @@ function ensure_cursor_user_hooks(package_root: string, force: boolean): Record<
     );
 }
 
-const CLINE_DISPATCHER_BINDINGS: ReadonlyArray<readonly [string, string]> = [
-    ['session_start', 'TaskStart'],
-    ['session_start', 'TaskResume'],
-    ['session_end', 'TaskComplete'],
-    ['stop', 'TaskCancel'],
-    ['user_prompt_submit', 'UserPromptSubmit'],
-    ['post_tool_use', 'PostToolUse'],
-];
-
 /** `shlex.quote` — POSIX shell single-quote escaping. */
 function shlexQuote(s: string): string {
     if (s === '') return "''";
@@ -1221,7 +1197,7 @@ function clineProjectHookBody(native_event: string, ac_event: string, workspace_
     // template uses doubled braces ({{ }}) that .format() collapses to single.
     return (
         '#!/usr/bin/env bash\n' +
-        '# Generated by event4u/agent-config install.py — DO NOT EDIT.\n' +
+        '# Generated by event4u/agent-config — DO NOT EDIT.\n' +
         `# Project-scope Cline hook for ${native_event} → agent-config ${ac_event}.\n` +
         '# Phase 7.6 (docs/contracts/hook-architecture-v1.md).\n' +
         'set -u\n' +
@@ -1249,14 +1225,14 @@ function ensure_cline_bridge(project_root: string, force: boolean): void {
 
     const workspace_quoted = shlexQuote(resolvePath(project_root));
     let written = 0;
-    for (const [ac_event, native_event] of CLINE_DISPATCHER_BINDINGS) {
-        const target = path.join(hooks_dir, native_event);
-        const body = clineProjectHookBody(native_event, ac_event, workspace_quoted);
+    for (const { slot, native } of hostBindings('cline')) {
+        const target = path.join(hooks_dir, native);
+        const body = clineProjectHookBody(native, slot, workspace_quoted);
         if (pathExists(target) && readText(target) === body && !force) {
             continue;
         }
         if (pathExists(target) && !force) {
-            skip(`.clinerules/hooks/${native_event} exists, needs update (use --force)`);
+            skip(`.clinerules/hooks/${native} exists, needs update (use --force)`);
             continue;
         }
         writeText(target, body);
@@ -1292,13 +1268,13 @@ function ensure_cline_user_hooks(package_root: string, force: boolean): void {
     }
 
     const trampoline_quoted = shlexQuote(trampoline);
-    for (const [ac_event, native_event] of CLINE_DISPATCHER_BINDINGS) {
-        const wrapper = path.join(CLINE_USER_DIR, native_event);
+    for (const { slot, native } of hostBindings('cline')) {
+        const wrapper = path.join(CLINE_USER_DIR, native);
         const body =
             '#!/usr/bin/env bash\n' +
-            '# Generated by event4u/agent-config install.py — DO NOT EDIT.\n' +
-            `# User-scope Cline hook for ${native_event} → agent-config ${ac_event}.\n` +
-            `exec ${trampoline_quoted} ${ac_event} ${native_event}\n`;
+            '# Generated by event4u/agent-config — DO NOT EDIT.\n' +
+            `# User-scope Cline hook for ${native} → agent-config ${slot}.\n` +
+            `exec ${trampoline_quoted} ${slot} ${native}\n`;
         if (pathExists(wrapper) && readText(wrapper) === body && !force) {
             continue;
         }
@@ -1307,12 +1283,6 @@ function ensure_cline_user_hooks(package_root: string, force: boolean): void {
     }
 }
 
-const WINDSURF_DISPATCHER_BINDINGS: ReadonlyArray<readonly [string, string]> = [
-    ['session_start', 'post_setup_worktree'],
-    ['user_prompt_submit', 'pre_user_prompt'],
-    ['stop', 'post_cascade_response'],
-];
-
 function _windsurf_dispatch_command(ac_event: string, native: string): string {
     // Hook-resilience shim (P1.4): missing binary → silent exit 0; a
     // present dispatcher's exit code propagates (fail_closed concerns
@@ -1327,9 +1297,9 @@ function _windsurf_dispatch_command(ac_event: string, native: string): string {
 
 function ensure_windsurf_bridge(project_root: string, force: boolean): Record<string, unknown>[] {
     const hooks: Record<string, unknown[]> = {};
-    for (const [ac_event, native] of WINDSURF_DISPATCHER_BINDINGS) {
+    for (const { slot, native } of hostBindings('windsurf')) {
         (hooks[native] ??= []).push({
-            command: _windsurf_dispatch_command(ac_event, native),
+            command: _windsurf_dispatch_command(slot, native),
             show_output: false,
         });
     }
@@ -1365,9 +1335,9 @@ function ensure_windsurf_user_hooks(package_root: string, force: boolean): Recor
     }
 
     const hooks: Record<string, unknown[]> = {};
-    for (const [ac_event, native] of WINDSURF_DISPATCHER_BINDINGS) {
+    for (const { slot, native } of hostBindings('windsurf')) {
         (hooks[native] ??= []).push({
-            command: `${dst} ${ac_event} ${native}`,
+            command: `${dst} ${slot} ${native}`,
             show_output: false,
         });
     }
@@ -1381,14 +1351,6 @@ function ensure_windsurf_user_hooks(package_root: string, force: boolean): Recor
     );
 }
 
-const GEMINI_DISPATCHER_BINDINGS: ReadonlyArray<readonly [string, string, string]> = [
-    ['session_start', 'SessionStart', ''],
-    ['session_end', 'SessionEnd', ''],
-    ['stop', 'AfterAgent', ''],
-    ['user_prompt_submit', 'BeforeAgent', ''],
-    ['post_tool_use', 'AfterTool', '.*'],
-];
-
 function _gemini_dispatch_command(ac_event: string, native: string): string {
     // Hook-resilience shim (P1.4): missing binary → silent exit 0; a
     // present dispatcher's exit code propagates (fail_closed concerns
@@ -1405,10 +1367,10 @@ function _gemini_hooks_dict(
     command_factory: (ac_event: string, native: string) => string,
 ): Record<string, unknown[]> {
     const out: Record<string, unknown[]> = {};
-    for (const [ac_event, native, matcher] of GEMINI_DISPATCHER_BINDINGS) {
+    for (const { slot, native, matcher } of hostBindings('gemini')) {
         (out[native] ??= []).push({
             matcher,
-            hooks: [{ type: 'command', command: command_factory(ac_event, native) }],
+            hooks: [{ type: 'command', command: command_factory(slot, native) }],
         });
     }
     return out;
@@ -1724,15 +1686,37 @@ function ensure_kiro_bridge(project_root: string, force: boolean): void {
 
 // --- Post-install smoke test ---
 
-const SMOKE_PROBE_EVENTS: ReadonlyArray<readonly [string, string]> = [
+/**
+ * Platforms whose bridge the smoke probe exercises, with the slot it probes.
+ *
+ * The NATIVE event is derived from `host_lowering.yaml`, never written here.
+ * The hand-written list this replaced probed `['cursor', 'beforeShellExecution']`
+ * — an event no cursor bridge has ever written — so the probe could not fail on
+ * a real binding regression, which is the only thing it exists to catch. A
+ * platform whose table row does not carry the probed slot is a hard error, not
+ * a skip: a silent skip is how the previous list stayed wrong.
+ */
+const SMOKE_PROBE_SLOTS: ReadonlyArray<readonly [string, string]> = [
     ['augment', 'session_start'],
-    ['claude', 'SessionStart'],
-    ['cursor', 'beforeShellExecution'],
+    ['claude', 'session_start'],
+    ['cursor', 'session_start'],
     ['cline', 'session_start'],
-    ['windsurf', 'post_setup_worktree'],
-    ['gemini', 'SessionStart'],
+    ['windsurf', 'session_start'],
+    ['gemini', 'session_start'],
 ];
 
+export function smokeProbeEvents(): ReadonlyArray<readonly [string, string]> {
+    return SMOKE_PROBE_SLOTS.map(([platform, slot]) => {
+        const binding = hostBindings(platform).find((b) => b.slot === slot);
+        if (binding === undefined) {
+            throw new Error(
+                `install smoke probe: host_lowering.yaml has no \`${slot}\` binding for \`${platform}\``,
+            );
+        }
+        return [platform, binding.native] as const;
+    });
+}
+
 const SMOKE_BRIDGE_PATHS: Record<string, string> = {
     augment: '.augment/settings.json',
     claude: '.claude/settings.json',
@@ -1787,7 +1771,7 @@ function _smoke_test_hooks(project_root: string, package_root: string): number {
     const skipped: string[] = [];
     const passed: string[] = [];
 
-    for (const [platform, native] of SMOKE_PROBE_EVENTS) {
+    for (const [platform, native] of smokeProbeEvents()) {
         const rel_bridge = SMOKE_BRIDGE_PATHS[platform] ?? '';
         const bridge_path = rel_bridge ? path.join(project_root, rel_bridge) : null;
         const bridge_present = Boolean(
@@ -2619,15 +2603,6 @@ function _is_agent_config_source_repo(project_root: string): [boolean, string] {
         }
     }
 
-    const installer_self = path.join(project_root, 'scripts', 'install.py');
-    try {
-        if (isFile(installer_self) && resolvePath(installer_self) === resolvePath(_HERE)) {
-            return [true, 'src/scripts/install.py (self)'];
-        }
-    } catch {
-        /* OSError → pass */
-    }
-
     return [false, ''];
 }
 
@@ -4028,7 +4003,7 @@ function _merge_tools_aliases(tools: string | null, ai: string | null): string {
     return items.length > 0 ? items.join(',') : 'all';
 }
 
-const PROG = 'install.py';
+const PROG = 'agent-config install';
 // Verbatim argparse usage block at COLUMNS=80 (captured from the .py). The
 // `--help` BODY (per-flag descriptions) is a documented divergence — argparse
 // re-wraps it to the live terminal width, which is not worth reproducing; the
@@ -5364,10 +5339,6 @@ export {
     ROOCODE_MARKER,
     ZED_MARKER,
     // ADR-200 py2ts: re-exported for test_install_snapshot.ts twin
-    CURSOR_DISPATCHER_BINDINGS,
-    CLINE_DISPATCHER_BINDINGS,
-    WINDSURF_DISPATCHER_BINDINGS,
-    GEMINI_DISPATCHER_BINDINGS,
     ensure_cursor_bridge,
     ensure_cline_bridge,
     ensure_mcp_bridge,

package/src/scripts/install_anthropic_key.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Interactive Anthropic-API-key installer for scripts/skill_trigger_eval.py.
+# Interactive Anthropic-API-key installer for src/scripts/skill_trigger_eval.ts.
 #
 # Reads the key with `read -s` so it never echoes to the terminal and
 # never lands in shell history or scrollback. Writes atomically to
@@ -7,7 +7,7 @@
 # ~/.config/agent-config/anthropic.key is read as a fallback by the
 # loaders so pre-2.4 installs keep working until the namespace shim runs.
 #
-# Contract — companion to scripts/skill_trigger_eval.py:
+# Contract — companion to src/scripts/skill_trigger_eval.ts:
 #   - File path:  $HOME/.event4u/agent-config/anthropic.key
 #   - File mode:  0600 (owner read/write only)
 #   - Key format: must start with `sk-ant-`

package/src/scripts/lint_design_antipattern_parity.ts

@@ -60,6 +60,43 @@ const STATUS_ROW = /^\|\s*((?:V|C|T|L|M|CP)\d+)\s*\|\s*([a-z-]*)\s*\|([^|]*)\|/g
 const STATUS_SECTION = /^## Detector status$([\s\S]*?)(?=^## )/m;
 const CATALOG_ID = /^\s+catalogId:\s*"([A-Z]+\d+)"/gm;
 
+/** The five classes a catalog row may claim (road-to-one-motion-authority 2.1). */
+export const CLASSES = ['floor', 'invariant', 'craft-presumption', 'style-preference', 'reference-constraint'] as const;
+/** How a fix is checked. `feel` is the perceptual mode `evidence-artifact-types.md` adds. */
+export const VERIFICATIONS = ['static', 'render', 'feel', 'judgment'] as const;
+/** Remediation names an order, worst-first, drawn from these verbs. */
+export const REMEDIATION_VERBS = ['delete', 'reduce', 'retune', 'replace'] as const;
+
+export interface CensusCells { class: string; remediation: string; verification: string }
+
+const CENSUS_ROW = /^\|\s*((?:V|C|T|L|M|CP)\d+)\s*\|(.*)$/gm;
+
+/**
+ * The three census cells per catalog entry, read from the LAST three columns.
+ *
+ * Read positionally from the end rather than by header index because the four
+ * original columns carry free prose containing pipes inside inline code, and a
+ * header-indexed read would mis-align on exactly the rows whose prose is
+ * richest. The three census cells are short closed-vocabulary tokens, so the
+ * tail of the row is the one part that parses reliably.
+ */
+export function censusCells(catalogMd: string): Map<string, CensusCells> {
+    const section = STATUS_SECTION.exec(catalogMd)?.[0] ?? '';
+    const outside = section === '' ? catalogMd : catalogMd.replace(section, '');
+    const out = new Map<string, CensusCells>();
+    for (const m of outside.matchAll(CENSUS_ROW)) {
+        const cells = (m[2] ?? '').split('|').map((c) => c.trim());
+        while (cells.length > 0 && cells[cells.length - 1] === '') cells.pop();
+        if (cells.length < 6) continue;
+        out.set(m[1] as string, {
+            class: cells[cells.length - 3] ?? '',
+            remediation: cells[cells.length - 2] ?? '',
+            verification: cells[cells.length - 1] ?? '',
+        });
+    }
+    return out;
+}
+
 /** Catalog entry ids outside the § Detector status section. */
 export function catalogEntries(catalogMd: string): string[] {
     const section = STATUS_SECTION.exec(catalogMd)?.[0] ?? '';
@@ -131,6 +168,49 @@ export function parityFindings(catalogMd: string, registryTs: string): ParityFin
         }
     }
 
+    // F — the census columns: present, non-empty, and from the closed vocabularies.
+    const census = censusCells(catalogMd);
+    for (const id of seen) {
+        const cells = census.get(id);
+        if (cells === undefined) {
+            out.push({ kind: 'missing-census', id, msg: `${id}: catalog row carries no class / remediation / verification cells` });
+            continue;
+        }
+        if (!(CLASSES as readonly string[]).includes(cells.class)) {
+            out.push({ kind: 'bad-class', id, msg: `${id}: class '${cells.class || '(empty)'}' is not one of ${CLASSES.join(', ')}` });
+        }
+        if (!(VERIFICATIONS as readonly string[]).includes(cells.verification)) {
+            out.push({ kind: 'bad-verification', id, msg: `${id}: verification '${cells.verification || '(empty)'}' is not one of ${VERIFICATIONS.join(', ')}` });
+        }
+        const verbs = cells.remediation.split('→').map((v) => v.trim()).filter((v) => v !== '');
+        if (verbs.length === 0 || !verbs.every((v) => (REMEDIATION_VERBS as readonly string[]).includes(v))) {
+            out.push({ kind: 'bad-remediation', id, msg: `${id}: remediation '${cells.remediation || '(empty)'}' is not a → order over ${REMEDIATION_VERBS.join(', ')}` });
+        }
+    }
+
+    // G — the two axes are INDEPENDENT (road-to-one-motion-authority Risk 3).
+    // Class is a property of the rule, status a property of its enforcement.
+    // A `floor` that nothing can detect is legitimately `judgment-only`, and a
+    // `style-preference` that happens to be greppable is legitimately `backed`.
+    // This gate asserts the independence positively rather than merely allowing
+    // it: a run in which class turned out to determine status would mean the
+    // second axis had collapsed into the first and is carrying no information.
+    const pairs = [...seen]
+        .map((id) => ({ cls: census.get(id)?.class ?? '', status: rows.get(id)?.status ?? '' }))
+        .filter((p) => p.cls !== '' && p.status !== '');
+    const byClass = new Map<string, Set<string>>();
+    for (const p of pairs) {
+        const set = byClass.get(p.cls) ?? new Set<string>();
+        set.add(p.status);
+        byClass.set(p.cls, set);
+    }
+    if (pairs.length > 0 && [...byClass.values()].every((statuses) => statuses.size === 1)) {
+        out.push({
+            kind: 'axes-collapsed',
+            msg: 'every class maps to exactly one status — the class column is carrying no information the status column does not already carry. Class describes the rule, status describes its enforcement; if they have become the same axis, one of them is wrong.',
+        });
+    }
+
     // C — backed set equals the registry set, both directions.
     const backed = new Set([...rows].filter(([, r]) => r.status === 'backed').map(([id]) => id));
     const registry = new Set(registryCatalogIds(registryTs));

package/src/scripts/lint_evidence_artifacts.ts

@@ -55,15 +55,38 @@ import { parseHonestNull, parseMarkerLine, parseSkipDeclaration } from './check_
 
 export const EVIDENCE_ROOT = path.join('agents', 'evidence');
 
-/** The five types the contract defines. Anything else is an error, not a warning. */
+/** The types the contract defines. Anything else is an error, not a warning. */
 export const EVIDENCE_TYPES = [
     'original-review',
     'current-binding',
     'declared-skip',
     'honest-null',
     'analysis',
+    'feel',
 ] as const;
 
+/**
+ * The closed method vocabulary a `feel` artifact must name.
+ *
+ * Closed on purpose. An evidence class nothing can emit is a vocabulary entry,
+ * not a control, and the cheapest way to satisfy a perceptual floor is to write
+ * the word "feel" and move on. Requiring one of four named methods makes the
+ * claim falsifiable: each says how the motion was actually looked at.
+ */
+export const FEEL_METHODS = ['slow-motion', 'frame-step', 'device', 'next-day'] as const;
+export type FeelMethod = (typeof FEEL_METHODS)[number];
+
+const FEEL_LINE_RE = new RegExp(
+    String.raw`^\*\*Feel:\*\*\s+(${FEEL_METHODS.join('|')})\s+[\u2014-]\s+(\S.*)$`,
+);
+
+/** The method and outcome a `feel` line declares, or `null` when it declares neither. */
+export function parseFeelLine(line: string): { method: FeelMethod; outcome: string } | null {
+    const m = FEEL_LINE_RE.exec(line.trim());
+    if (m === null) return null;
+    return { method: m[1] as FeelMethod, outcome: (m[2] ?? '').trim() };
+}
+
 export type EvidenceType = (typeof EVIDENCE_TYPES)[number];
 
 /** The explicit marker, for the two types with no pre-existing grammar. */
@@ -202,6 +225,27 @@ export function checkFiles(root: string, files: readonly string[], ledger?: Gate
             });
             continue;
         }
+        // Risk 5 of road-to-one-motion-authority: the floor is the METHOD
+        // token, not the word. An outcome of `unbacked` is legal — a
+        // perceptual check that found nothing is still a check that ran — but
+        // an absent line is not, and neither is a method outside the four.
+        if (res.type === 'feel') {
+            const declared = contents
+                .split('\n')
+                .slice(0, MARKER_SCAN_LINES)
+                .some((l) => parseFeelLine(l) !== null);
+            if (!declared) {
+                ledger?.fail(rel, 'feel artifact with no method line');
+                findings.push({
+                    file: rel,
+                    reason:
+                        'declares `evidence-type: feel` but carries no `**Feel:** <method> — <outcome>` '
+                        + `line naming one of ${FEEL_METHODS.join(' | ')}. An outcome of \`unbacked\` is legal; `
+                        + 'an absent method is not',
+                });
+                continue;
+            }
+        }
         if (res.type === null) {
             ledger?.fail(rel, 'no evidence type declared');
             findings.push({

package/src/scripts/lint_hook_manifest.ts

@@ -13,8 +13,11 @@
  *   - a platform binding referencing an unknown event
  *   - a native_event_aliases block referencing an unknown event or platform
  *   - an orphan `<platform>-dispatcher.sh` trampoline without a manifest block
+ *   - a `host_lowering.yaml` row whose `verified.expires` has passed (or which
+ *     was never verified) while it still carries a blocking binding
  *
- * Soft-warns on placeholder platform blocks and dead concerns.
+ * Soft-warns on placeholder platform blocks, dead concerns, an expired row
+ * carrying no blocking binding, and an incomplete `verified` provenance block.
  *
  * Exit codes:
  *   0 — clean (warnings allowed)
@@ -29,6 +32,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { parse as parseYaml } from "yaml";
 
 import { assertScanned, DeadScopeError } from "./_lib/scan_scope.js";
+import { asOf } from "./_lib/as_of.js";
+import { parseHostLowering, type HostLowering } from "./hooks/host_lowering.js";
 import { RE_ARM_EVENTS } from "./_lib/prefix_stable_surfaces.js";
 
 // src/scripts/lint_hook_manifest.ts → two levels up is the repo root.
@@ -44,6 +49,7 @@ const DEFAULT_MANIFEST = path.join(
   "hook_manifest.yaml",
 );
 const HOOKS_DIR = path.join(REPO_ROOT, "src", "scripts", "hooks");
+const DEFAULT_HOST_LOWERING = path.join(HOOKS_DIR, "host_lowering.yaml");
 
 // Canonical event vocabulary — keep in lock-step with
 // docs/contracts/hook-architecture-v1.md and dispatch_hook.EVENT_VOCABULARY.
@@ -635,7 +641,80 @@ export function _check_roles(
   }
 }
 
-export function lint(manifestPath: string, strict: boolean): number {
+/**
+ * A capability fact that cannot expire is a capability fact nobody re-checks.
+ *
+ * Three rounds of corrections to the same host claims is what this gate exists
+ * to stop, so the rule is mechanical rather than editorial: an unverified row —
+ * and an expired one is unverified, by the same definition `host_semantics`
+ * uses — may not carry a blocking binding. Everything softer warns, because a
+ * lapse on an advisory row must not red an unrelated pull request.
+ */
+export function _check_host_lowering(
+  tablePath: string,
+  errors: string[],
+  warnings: string[],
+  today: string = asOf().toISOString().slice(0, 10),
+): void {
+  let table: HostLowering;
+  try {
+    table = parseHostLowering(fs.readFileSync(tablePath, "utf-8"));
+  } catch (exc) {
+    errors.push(
+      `host_lowering: ${tablePath} could not be read or parsed: ` +
+        `${exc instanceof Error ? exc.message : String(exc)}`,
+    );
+    return;
+  }
+  for (const [host, surfaces] of table) {
+    for (const [surface, row] of surfaces) {
+      const blocking = [...row.slots.entries()]
+        .filter(([, s]) => s.block_exit !== null)
+        .map(([slot]) => slot);
+      const expired = row.verified !== null && row.verified.expires < today;
+      const where = `host_lowering ${host}/${surface}`;
+
+      if (row.verified === null) {
+        if (blocking.length > 0) {
+          errors.push(
+            `${where}: carries a blocking binding (${blocking.join(", ")}) with \`verified: null\`. ` +
+              "Establish the row with a live deny probe and a dated `verified` block, or set " +
+              "`block_exit: null` on those slots.",
+          );
+        }
+        continue;
+      }
+      if (expired && blocking.length > 0) {
+        errors.push(
+          `${where}: \`verified.expires\` was ${row.verified.expires} and today is ${today}, ` +
+            `while the row still carries a blocking binding (${blocking.join(", ")}). ` +
+            "Re-establish it with a live deny probe on that host and move `expires` forward, " +
+            "or set `block_exit: null` on those slots — an expired row reads as unverified.",
+        );
+      } else if (expired) {
+        warnings.push(
+          `${where}: \`verified.expires\` was ${row.verified.expires} and today is ${today}. ` +
+            "The row carries no blocking binding, so nothing is degraded; re-establish it " +
+            "before attaching one.",
+        );
+      }
+      for (const field of ["docs_at", "host_version"] as const) {
+        if (row.verified[field] === null) {
+          warnings.push(`${where}: \`verified.${field}\` is null — the row is admissible but not fully cited.`);
+        }
+      }
+    }
+  }
+}
+
+export function lint(
+  manifestPath: string,
+  strict: boolean,
+  hostLoweringPath: string = DEFAULT_HOST_LOWERING,
+  // Threaded so a fixture test can pin the day the verdict is read against.
+  // Left undefined the check resolves it through `asOf()`.
+  today?: string,
+): number {
   if (!_isFile(manifestPath)) {
     process.stderr.write(
       `lint_hook_manifest: file not found: ${manifestPath}\n`,
@@ -664,6 +743,7 @@ export function lint(manifestPath: string, strict: boolean): number {
   _check_aliases(manifest, errors);
   _check_orphan_trampolines(manifest, errors);
   _check_dead_concerns(concernNames, bound, warnings);
+  _check_host_lowering(hostLoweringPath, errors, warnings, today);
 
   for (const w of warnings) {
     process.stderr.write(`warn: ${w}\n`);
@@ -703,17 +783,21 @@ export function lint(manifestPath: string, strict: boolean): number {
 
 export function main(argv: string[]): number {
   let manifest = DEFAULT_MANIFEST;
+  let hostLowering = DEFAULT_HOST_LOWERING;
   let strict = false;
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === "--manifest") {
       manifest = argv[i + 1] ?? manifest;
       i += 1;
+    } else if (a === "--host-lowering") {
+      hostLowering = argv[i + 1] ?? hostLowering;
+      i += 1;
     } else if (a === "--strict") {
       strict = true;
     }
   }
-  return lint(manifest, strict);
+  return lint(manifest, strict, hostLowering);
 }
 
 function _isCliEntry(): boolean {