vexp-cli 3.2.5 → 3.3.0

package/dist/codex-trust.js

@@ -0,0 +1,608 @@
+/**
+ * Does Codex run vexp's project hook? Read from Codex's own records.
+ *
+ * Codex runs a hook from a project's `.codex/hooks.json` only when two things
+ * hold, and neither is visible from the project:
+ *
+ *   1. the project is trusted: `[projects."<path>"] trust_level = "trusted"`
+ *      in `$CODEX_HOME/config.toml` (an untrusted or unknown project's layer is
+ *      loaded disabled, and its hooks are not even listed);
+ *   2. the hook itself is approved: `[hooks.state."<key>"] trusted_hash =
+ *      "sha256:..."` in the same file, where the key names the hooks.json and
+ *      the hook's position in it, and the hash is over its normalised
+ *      definition. A different hash reads as "modified" and does not run.
+ *
+ * Codex writes them when the user answers: the folder question at startup,
+ * `/hooks` in the terminal UI, or Trust in the VS Code Codex extension
+ * (Codex panel > Settings > Hooks). vexp never writes them on the user's
+ * behalf. This module only reads them, so doctor can say which step is
+ * missing, and says plainly when it cannot tell.
+ *
+ * On Windows one approval does not cover both places: the key spells the
+ * folder as the session's cwd does, and a terminal says `C:\` where the VS
+ * Code extension says `c:\` (hooks/list on codex.exe 0.155), so doctor
+ * checks the two spellings apart. Project trust can also come from config
+ * layers doctor does not read (the system config, the legacy managed
+ * config); when one exists and the user config says nothing, doctor says it
+ * cannot tell.
+ *
+ * Every rule below is from the Codex source at openai/codex c98e263
+ * (unchanged on main at b35a7af, 2026-09-25):
+ *   - key:   hooks/src/lib.rs hook_key; hooks/src/engine/discovery.rs (key_source
+ *            is the hooks.json path as displayed, spelled like the thread cwd)
+ *   - hash:  discovery.rs hook_hash + normalize_command_hook;
+ *            config/src/fingerprint.rs version_for_toml
+ *   - state: hooks/src/config_rules.rs (user layer only; keys trimmed)
+ *   - trust: config/src/loader/mod.rs decision_for_dir,
+ *            normalized_project_trust_keys, project_trust_for_lookup_key
+ *   - layers: config/src/loader/mod.rs load_config_layers_state (system
+ *            /etc/codex/config.toml, %ProgramData%\OpenAI\Codex\config.toml);
+ *            layer_io.rs managed_config_default_path (/etc/codex/managed_config.toml
+ *            on Unix only)
+ *   - flag:  features/src/legacy.rs (`codex_hooks` is the old name of `hooks`)
+ */
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+/** `$CODEX_HOME`, else `~/.codex`: where Codex keeps its user config. */
+export function codexHome(env = process.env) {
+    const fromEnv = env.CODEX_HOME?.trim();
+    return fromEnv ? fromEnv : path.join(os.homedir(), ".codex");
+}
+// ---------------------------------------------------------------------------
+// The hook's trust identity
+// ---------------------------------------------------------------------------
+/** The fields of a command handler Codex reads (hook_config.rs HookHandlerConfig::Command). */
+const HANDLER_KEYS = new Set([
+    "type",
+    "command",
+    "commandWindows",
+    "command_windows",
+    "timeout",
+    "async",
+    "statusMessage",
+    "additionalContextLimit",
+]);
+/** Codex's default additionalContext spill threshold; a limit equal to it is not hashed. */
+const DEFAULT_CONTEXT_LIMIT = 2500;
+/** JSON with every object's keys in sorted order, as serde_json writes a canonical value. */
+function canonicalJson(v) {
+    if (Array.isArray(v))
+        return `[${v.map(canonicalJson).join(",")}]`;
+    if (v && typeof v === "object") {
+        const o = v;
+        return `{${Object.keys(o)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(v);
+}
+/**
+ * The hash Codex records when the user approves a UserPromptSubmit command
+ * hook, or undefined when this handler has anything doctor cannot vouch for
+ * reproducing exactly.
+ *
+ * Codex hashes the normalised handler, not the file's text: the command the
+ * platform runs (`commandWindows`, when set, on Windows; `command` elsewhere),
+ * the timeout (600 when unset), `async`, and `statusMessage` /
+ * `additionalContextLimit` when set. `commandWindows` itself is never hashed,
+ * so adding it changes nothing off Windows.
+ */
+export function codexHookHash(handler, platform = process.platform) {
+    if (Object.keys(handler).some((k) => !HANDLER_KEYS.has(k)))
+        return undefined;
+    if (handler.type !== "command" || typeof handler.command !== "string")
+        return undefined;
+    const windowsCommand = handler.commandWindows ?? handler.command_windows;
+    if (windowsCommand !== undefined && typeof windowsCommand !== "string")
+        return undefined;
+    const command = platform === "win32" && typeof windowsCommand === "string" ? windowsCommand : handler.command;
+    if (command.trim() === "")
+        return undefined;
+    const timeout = handler.timeout ?? 600;
+    if (typeof timeout !== "number" || !Number.isSafeInteger(timeout) || timeout < 0)
+        return undefined;
+    const isAsync = handler.async ?? false;
+    if (typeof isAsync !== "boolean")
+        return undefined;
+    const normalized = { type: "command", command, timeout: Math.max(timeout, 1), async: isAsync };
+    if (handler.statusMessage !== undefined) {
+        if (typeof handler.statusMessage !== "string")
+            return undefined;
+        normalized.statusMessage = handler.statusMessage;
+    }
+    if (handler.additionalContextLimit !== undefined) {
+        const limit = handler.additionalContextLimit;
+        if (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 0)
+            return undefined;
+        if (limit !== DEFAULT_CONTEXT_LIMIT)
+            normalized.additionalContextLimit = limit;
+    }
+    const identity = { event_name: "user_prompt_submit", hooks: [normalized] };
+    return "sha256:" + crypto.createHash("sha256").update(canonicalJson(identity)).digest("hex");
+}
+/** The key of Codex's trust record for one hook: `<hooks.json>:user_prompt_submit:<group>:<handler>`. */
+export function codexHookKey(hooksJsonPath, groupIndex, handlerIndex) {
+    return `${hooksJsonPath}:user_prompt_submit:${groupIndex}:${handlerIndex}`;
+}
+// ---------------------------------------------------------------------------
+// Reading $CODEX_HOME/config.toml
+// ---------------------------------------------------------------------------
+/**
+ * A TOML reader for the parts of Codex's config doctor needs: tables, array
+ * tables, dotted and quoted keys, strings (all four forms), booleans,
+ * numbers, arrays and inline tables. It throws on anything it does not
+ * understand; a caller that catches that says "cannot tell", never guesses.
+ */
+export function parseToml(text) {
+    const root = {};
+    let current = root;
+    let i = 0;
+    const s = text.replace(/^\uFEFF/, "");
+    const fail = (msg) => {
+        const line = s.slice(0, i).split("\n").length;
+        throw new Error(`line ${line}: ${msg}`);
+    };
+    const ws = () => {
+        while (i < s.length && (s[i] === " " || s[i] === "\t"))
+            i++;
+    };
+    const wsNl = () => {
+        for (;;) {
+            ws();
+            if (s[i] === "#")
+                while (i < s.length && s[i] !== "\n")
+                    i++;
+            if (s[i] === "\n" || s[i] === "\r")
+                i++;
+            else
+                break;
+        }
+    };
+    const basic = () => {
+        i++; // opening quote
+        let out = "";
+        while (i < s.length && s[i] !== '"') {
+            if (s[i] === "\n")
+                fail("newline in a string");
+            if (s[i] !== "\\") {
+                out += s[i++];
+                continue;
+            }
+            const e = s[i + 1];
+            i += 2;
+            const simple = { b: "\b", t: "\t", n: "\n", f: "\f", r: "\r", '"': '"', "\\": "\\" };
+            if (e in simple)
+                out += simple[e];
+            else if (e === "u" || e === "U") {
+                const n = e === "u" ? 4 : 8;
+                const hex = s.slice(i, i + n);
+                if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length !== n)
+                    fail("bad unicode escape");
+                out += String.fromCodePoint(parseInt(hex, 16));
+                i += n;
+            }
+            else
+                fail(`bad escape \\${e}`);
+        }
+        if (s[i] !== '"')
+            fail("unterminated string");
+        i++;
+        return out;
+    };
+    const literal = () => {
+        const end = s.indexOf("'", i + 1);
+        if (end < 0 || s.slice(i + 1, end).includes("\n"))
+            fail("unterminated literal string");
+        const out = s.slice(i + 1, end);
+        i = end + 1;
+        return out;
+    };
+    const multiline = (quote) => {
+        i += 3;
+        if (s[i] === "\r")
+            i++;
+        if (s[i] === "\n")
+            i++;
+        let end = s.indexOf(quote, i);
+        if (end < 0)
+            fail("unterminated multi-line string");
+        // Up to two more quotes right before the closing three belong to the content.
+        for (let extra = 0; extra < 2 && s[end + 3] === quote[0]; extra++)
+            end++;
+        const raw = s.slice(i, end);
+        i = end + 3;
+        if (quote === "'''")
+            return raw;
+        return raw
+            .replace(/\\[ \t]*\r?\n\s*/g, "")
+            .replace(/\\(u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[btnfr"\\])/g, (_, e) => e.length > 1
+            ? String.fromCodePoint(parseInt(e.slice(1), 16))
+            : { b: "\b", t: "\t", n: "\n", f: "\f", r: "\r", '"': '"', "\\": "\\" }[e]);
+    };
+    const keyPart = () => {
+        ws();
+        if (s[i] === '"')
+            return basic();
+        if (s[i] === "'")
+            return literal();
+        const m = /^[A-Za-z0-9_-]+/.exec(s.slice(i, i + 256));
+        if (!m)
+            fail("expected a key");
+        i += m[0].length;
+        return m[0];
+    };
+    const keyPath = () => {
+        const parts = [keyPart()];
+        for (;;) {
+            ws();
+            if (s[i] !== ".")
+                return parts;
+            i++;
+            parts.push(keyPart());
+        }
+    };
+    const value = () => {
+        ws();
+        if (s.startsWith('"""', i))
+            return multiline('"""');
+        if (s.startsWith("'''", i))
+            return multiline("'''");
+        if (s[i] === '"')
+            return basic();
+        if (s[i] === "'")
+            return literal();
+        if (s[i] === "[") {
+            i++;
+            const arr = [];
+            for (;;) {
+                wsNl();
+                if (s[i] === "]") {
+                    i++;
+                    return arr;
+                }
+                arr.push(value());
+                wsNl();
+                if (s[i] === ",")
+                    i++;
+                else if (s[i] !== "]")
+                    fail("expected , or ] in an array");
+            }
+        }
+        if (s[i] === "{") {
+            i++;
+            const obj = {};
+            ws();
+            if (s[i] === "}") {
+                i++;
+                return obj;
+            }
+            for (;;) {
+                const k = keyPath();
+                ws();
+                if (s[i] !== "=")
+                    fail("expected = in an inline table");
+                i++;
+                assign(obj, k, value());
+                ws();
+                if (s[i] === ",")
+                    i++;
+                else if (s[i] === "}") {
+                    i++;
+                    return obj;
+                }
+                else
+                    fail("expected , or } in an inline table");
+            }
+        }
+        const m = /^[^\s,\]}#]+/.exec(s.slice(i, i + 256));
+        if (!m)
+            fail("expected a value");
+        const tok = m[0];
+        // A date-time may carry a space before its time part: keep it whole.
+        let full = tok;
+        const time = /^ \d{2}:\d{2}/.exec(s.slice(i + tok.length));
+        if (/^\d{4}-\d{2}-\d{2}$/.test(tok) && time) {
+            const rest = /^ [^\s,\]}#]+/.exec(s.slice(i + tok.length));
+            full += rest[0];
+        }
+        i += full.length;
+        if (full === "true")
+            return true;
+        if (full === "false")
+            return false;
+        const num = full.replace(/_/g, "");
+        if (/^[+-]?(\d+|0x[0-9a-fA-F]+|0o[0-7]+|0b[01]+)$/.test(num))
+            return Number(num.replace(/^\+/, ""));
+        if (/^[+-]?(\d+(\.\d+)?([eE][+-]?\d+)?|inf|nan)$/.test(num))
+            return Number(num);
+        return full; // dates and times, kept as written
+    };
+    const table = (at, keys) => {
+        let t = at;
+        for (const k of keys) {
+            let next = t[k];
+            if (Array.isArray(next))
+                next = next[next.length - 1];
+            if (next === undefined) {
+                next = {};
+                t[k] = next;
+            }
+            if (!next || typeof next !== "object" || Array.isArray(next))
+                fail(`${keys.join(".")} is not a table`);
+            t = next;
+        }
+        return t;
+    };
+    const assign = (at, keys, v) => {
+        const t = table(at, keys.slice(0, -1));
+        t[keys[keys.length - 1]] = v;
+    };
+    for (;;) {
+        wsNl();
+        if (i >= s.length)
+            return root;
+        if (s[i] === "[") {
+            const arrayTable = s[i + 1] === "[";
+            i += arrayTable ? 2 : 1;
+            const keys = keyPath();
+            ws();
+            if (!s.startsWith(arrayTable ? "]]" : "]", i))
+                fail("unterminated table header");
+            i += arrayTable ? 2 : 1;
+            if (arrayTable) {
+                const parent = table(root, keys.slice(0, -1));
+                const last = keys[keys.length - 1];
+                const list = Array.isArray(parent[last]) ? parent[last] : [];
+                const entry = {};
+                list.push(entry);
+                parent[last] = list;
+                current = entry;
+            }
+            else
+                current = table(root, keys);
+        }
+        else {
+            const keys = keyPath();
+            ws();
+            if (s[i] !== "=")
+                fail("expected =");
+            i++;
+            assign(current, keys, value());
+        }
+        ws();
+        if (s[i] === "#")
+            while (i < s.length && s[i] !== "\n")
+                i++;
+        if (i < s.length && s[i] !== "\n" && s[i] !== "\r")
+            fail("expected the end of the line");
+    }
+}
+/**
+ * Config files besides `$CODEX_HOME/config.toml` that can trust a project,
+ * as far as a file on disk shows them: the system config and, on Unix, the
+ * legacy managed config. A selected profile, the cloud bundle and macOS
+ * device profiles cannot be seen from here.
+ */
+export function codexOtherConfigLayers(platform = process.platform, env = process.env, exists = fs.existsSync) {
+    const files = platform === "win32"
+        ? [path.win32.join(env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData", "OpenAI", "Codex", "config.toml")]
+        : ["/etc/codex/config.toml", "/etc/codex/managed_config.toml"];
+    return files.filter((f) => exists(f));
+}
+/** `C:\x\` -> `c:\x` on Windows (Codex lower-cases project keys there), trailing separators and `\\?\` dropped. */
+function trustLookupKey(p, platform) {
+    let k = p.replace(/^\\\\\?\\/, "");
+    if (k.length > 1)
+        k = k.replace(/[\\/]+$/, "") || k;
+    return platform === "win32" ? k.toLowerCase() : k;
+}
+/** Codex's own verdict on vexp's hook, as far as its user config shows it. */
+export function codexHookTrust(input) {
+    const out = { hooksDisabled: false, project: "unknown", hook: "unknown" };
+    const unseen = input.otherLayers.length
+        ? `Codex also reads ${input.otherLayers.join(" and ")}, which can trust a project, and doctor does not read ${input.otherLayers.length > 1 ? "them" : "it"}`
+        : undefined;
+    if (input.userConfig === undefined) {
+        out.project = unseen ? "unknown" : "absent";
+        out.hook = "not-approved";
+        if (unseen)
+            out.why = unseen;
+        return out;
+    }
+    let cfg;
+    try {
+        cfg = parseToml(input.userConfig);
+    }
+    catch (err) {
+        out.why = `${input.userConfigPath} could not be read (${err instanceof Error ? err.message : String(err)})`;
+        return out;
+    }
+    // `hooks` is the flag's name; `codex_hooks` its old one, which counts only
+    // when the new one is not set.
+    const features = cfg.features;
+    const flag = features?.hooks !== undefined ? "hooks" : features?.codex_hooks !== undefined ? "codex_hooks" : undefined;
+    out.hooksDisabled = flag !== undefined && features?.[flag] === false;
+    if (out.hooksDisabled)
+        out.hooksDisabledBy = flag;
+    // Project trust: the first candidate with an entry decides, as in Codex,
+    // and for each an exact spelling wins over one that only matches once
+    // normalised (the first of those in key order).
+    const projects = (cfg.projects && typeof cfg.projects === "object" ? cfg.projects : {});
+    const levelOf = (key) => {
+        const v = projects[key];
+        return v && typeof v === "object" ? v.trust_level : undefined;
+    };
+    const projectEntry = (candidate) => {
+        const want = trustLookupKey(candidate, input.platform);
+        if (want in projects)
+            return want;
+        return Object.keys(projects)
+            .sort()
+            .find((k) => trustLookupKey(k, input.platform) === want);
+    };
+    for (const candidate of input.trustCandidates) {
+        const hit = projectEntry(candidate);
+        if (hit === undefined)
+            continue;
+        const level = levelOf(hit);
+        out.projectKey = hit;
+        out.project = level === "trusted" ? "trusted" : level === "untrusted" ? "untrusted" : "unknown";
+        if (out.project === "unknown")
+            out.why = `the entry for ${hit} has trust_level ${JSON.stringify(level)}, which doctor does not know`;
+        break;
+    }
+    if (!out.projectKey) {
+        out.project = unseen ? "unknown" : "absent";
+        if (unseen)
+            out.why = unseen;
+    }
+    // The hook's own record: looked up exactly, as Codex does.
+    const hash = codexHookHash(input.handler, input.platform);
+    const hooks = cfg.hooks;
+    const state = (hooks?.state && typeof hooks.state === "object" ? hooks.state : {});
+    const records = new Map();
+    for (const [k, v] of Object.entries(state)) {
+        if (v && typeof v === "object" && !Array.isArray(v))
+            records.set(k.trim(), v);
+    }
+    const stateOf = (key) => {
+        const record = records.get(key);
+        if (record?.enabled === false)
+            return "disabled";
+        if (typeof record?.trusted_hash !== "string")
+            return "not-approved";
+        if (!hash) {
+            out.why ??= "vexp's hook entry in .codex/hooks.json carries fields doctor cannot hash the way Codex does";
+            return "unknown";
+        }
+        return record.trusted_hash === hash ? "approved" : "modified";
+    };
+    const key = codexHookKey(input.hooksJsonPath, input.groupIndex, input.handlerIndex);
+    const probed = [key];
+    out.hook = stateOf(key);
+    if (input.platform === "win32" && /^[A-Za-z]:/.test(key)) {
+        const spelled = (drive) => drive + key.slice(1);
+        out.surfaces = [
+            { where: "terminal", key: spelled(key[0].toUpperCase()), hook: "unknown" },
+            { where: "vscode", key: spelled(key[0].toLowerCase()), hook: "unknown" },
+        ];
+        for (const sfc of out.surfaces) {
+            sfc.hook = stateOf(sfc.key);
+            probed.push(sfc.key);
+        }
+        out.hook = out.surfaces.find((sfc) => sfc.hook !== "approved")?.hook ?? "approved";
+    }
+    if (input.platform === "win32" && probed.every((k) => !records.has(k))) {
+        // A record under another spelling of the folder does not count for this
+        // one. Say so rather than leave the user wondering where it went.
+        out.otherSpelling = [...records.keys()].find((k) => k.toLowerCase() === key.toLowerCase());
+    }
+    return out;
+}
+/**
+ * The folders whose trust entry decides this project's in Codex: the folder
+ * holding `.codex`, then the git root (Codex's project-root marker is `.git`),
+ * then the main worktree's root. Real paths, as Codex canonicalises them.
+ */
+export function codexTrustCandidates(root, git) {
+    const out = [];
+    const add = (p) => {
+        if (!p)
+            return;
+        let real = p;
+        try {
+            real = fs.realpathSync.native(p);
+        }
+        catch {
+            /* keep as given */
+        }
+        for (const c of [real, p])
+            if (!out.includes(c))
+                out.push(c);
+    };
+    add(root);
+    add(git(["rev-parse", "--show-toplevel"]));
+    const common = git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    if (common && path.basename(common) === ".git")
+        add(path.dirname(common));
+    return out;
+}
+/** How to approve the hook in each place Codex runs it from. */
+const APPROVE_IN_VSCODE = "in the Codex extension for VS Code, open the Codex panel > Settings > Hooks and trust vexp-hint";
+const approveInTerminal = (root) => `in a terminal, run codex in ${root}, type /hooks and approve vexp-hint`;
+/** Doctor's lines for the trust verdict. */
+export function codexTrustFindings(t, root, configPath, levels) {
+    const { OK, WARN } = levels;
+    const approve = `${APPROVE_IN_VSCODE}; ${approveInTerminal(root)}`;
+    if (t.hooksDisabled) {
+        const flag = t.hooksDisabledBy ?? "hooks";
+        return [{ level: WARN, message: `Codex hooks are switched off ([features] ${flag} = false in ${configPath}): Codex runs no hook, vexp's included. Remove that line to turn them back on.` }];
+    }
+    const out = [];
+    switch (t.project) {
+        case "trusted":
+            out.push({ level: OK, message: `Codex trusts this project (${t.projectKey})` });
+            break;
+        case "untrusted":
+            out.push({
+                level: WARN,
+                message: `Codex has this project marked untrusted (${t.projectKey} in ${configPath}), so it loads none of its hooks. To change it: set trust_level = "trusted" for that entry, or delete the entry and answer the trust question the next time you start codex here.`,
+            });
+            break;
+        case "absent":
+            out.push({
+                level: WARN,
+                message: `Codex has not been told to trust this project, and it loads no project hook until it is: start codex in ${root} and answer yes when it asks whether to trust the folder.`,
+            });
+            break;
+        default:
+            out.push({ level: WARN, message: `cannot tell whether Codex trusts this project: ${t.why ?? "no reason recorded"}.` });
+    }
+    // Windows: the terminal and the VS Code extension keep separate records.
+    // When they disagree, say which place has it and how to fix the other.
+    const split = t.surfaces && new Set(t.surfaces.map((sfc) => sfc.hook)).size > 1;
+    if (split) {
+        for (const sfc of t.surfaces) {
+            const place = sfc.where === "terminal" ? "codex in a terminal" : "the Codex extension for VS Code";
+            const fix = sfc.where === "terminal" ? approveInTerminal(root) : APPROVE_IN_VSCODE;
+            if (sfc.hook === "approved")
+                out.push({ level: OK, message: `Codex has vexp's hook approved for ${place} (${sfc.key})` });
+            else if (sfc.hook === "unknown")
+                out.push({ level: WARN, message: `cannot tell whether ${place} has vexp's hook approved: ${t.why ?? "no reason recorded"}.` });
+            else
+                out.push({
+                    level: WARN,
+                    message: `vexp's hook is ${sfc.hook === "modified" ? "changed since you approved it" : sfc.hook === "disabled" ? "switched off" : "not approved"} for ${place} (${sfc.key}), which keeps its own record, so it does not run there. To fix it: ${fix}.`,
+                });
+        }
+        return out;
+    }
+    const both = t.surfaces ? " (for codex in a terminal and in the VS Code extension alike)" : "";
+    switch (t.hook) {
+        case "approved":
+            out.push({ level: OK, message: `Codex has vexp's hook approved${both} (its trust record matches the hook as written)` });
+            break;
+        case "modified":
+            out.push({
+                level: WARN,
+                message: `vexp's hook changed since you approved it in Codex, so Codex does not run it. To fix it, approve it again: ${approve}.`,
+            });
+            break;
+        case "disabled":
+            out.push({ level: WARN, message: `vexp's hook is switched off in Codex (enabled = false in ${configPath}). Turn it back on (${approve}) if you want per-prompt orientation.` });
+            break;
+        case "not-approved":
+            out.push({
+                level: WARN,
+                message: `Codex has no approval on record for vexp's hook, so it does not run it. To fix it: ${approve}.` +
+                    (t.otherSpelling ? `\n        a record exists for ${t.otherSpelling}: the same folder spelled differently, which Codex does not count for this one.` : ""),
+            });
+            break;
+        default:
+            out.push({ level: WARN, message: `cannot tell whether Codex has vexp's hook approved: ${t.why ?? "no reason recorded"}. codex's /hooks screen shows it.` });
+    }
+    return out;
+}