@bli-cockpit/cli 0.2.290 → 0.2.292

package/dist/adapters/raw-evidence-transcript-file.js

@@ -67,6 +67,13 @@ export async function collectOneEvidenceFile(collection, options) {
         markCapApplied(collection, options.kind, "max_file_bytes");
         return skip("file_too_large");
     }
+    // A zero-byte transcript (a subagent sidecar opened and never written) has nothing to preserve. Staging it made a
+    // 0-byte object the uploader refuses with `empty_file` on every tick, forever, and the fleet board read that
+    // permanent refusal as a stuck object (RED). Like an empty git diff it is not a gap; the line says it was seen.
+    if (read.byteLength === 0) {
+        console.error("[raw-evidence] empty transcript not staged, there is nothing in it to preserve", JSON.stringify({ reason: "empty_file", kind: options.kind, byte_size: 0 }));
+        return true;
+    }
     let prepared;
     try {
         prepared = await prepareTranscriptForUpload(collection, options, names, read.source);

package/dist/agent-plugins-converge.js

@@ -113,7 +113,12 @@ async function convergeHost(host, reading, entry, options, now) {
     if (reading.installed) {
         // Installed by us or by hand: a failure remembered from before is spent.
         delete entry.last_reason;
-        const due = options.refresh && msSince(entry.last_refresh_at, now) >= PLUGIN_REFRESH_EVERY_MS;
+        // A failed refresh waits out the six-hour retry window, not a whole day: it
+        // never counts as the day's refresh, so a machine (or a Boat template
+        // snapshot) that failed once is not left on an old version (BLI-24352).
+        const due = options.refresh
+            && msSince(entry.last_refresh_at, now) >= PLUGIN_REFRESH_EVERY_MS
+            && msSince(entry.last_refresh_failed_at, now) >= PLUGIN_RETRY_AFTER_FAILURE_MS;
         if (!due)
             return { host, status: "already_installed", reason: "installed", quiet: true };
         return refreshHost(host, reading, entry, options, now);
@@ -166,17 +171,31 @@ async function installHost(host, reading, entry, options, now) {
     console.error("[agent-plugins] plugin installed", JSON.stringify({ reason: "installed", host }));
     return { host, status: "installed", reason: "installed", quiet: false };
 }
-/** The daily refresh. A failure here never un-installs anything; the next try is tomorrow's. */
+/**
+ * The daily refresh. A failure here never un-installs anything and never counts
+ * as the day's refresh: `last_refresh_at` stays on the last clean one and the
+ * next try is after the six-hour retry window (BLI-24352).
+ */
 async function refreshHost(host, reading, entry, options, now) {
-    entry.last_refresh_at = now.toISOString();
+    const failed = (reason) => {
+        entry.last_refresh_failed_at = now.toISOString();
+        entry.last_refresh_reason = reason;
+    };
     const binary = await locateHostBinary(host, options.homeDir, options);
     if (!binary) {
-        console.error("[agent-plugins] host program not found for the daily refresh", JSON.stringify({ reason: "binary_missing", host }));
+        failed("binary_missing");
+        console.error("[agent-plugins] host program not found for the daily refresh", JSON.stringify({ reason: "binary_missing", host, retry_after_hours: PLUGIN_RETRY_AFTER_FAILURE_MS / 3_600_000 }));
         return { host, status: "already_installed", reason: "refresh_skipped_binary_missing", quiet: true };
     }
     const failure = await runSteps(host, binary, stepsFor(host, reading, true), options);
-    if (failure)
+    if (failure) {
+        failed(failure);
+        console.error("[agent-plugins] daily refresh failed; the installed plugin stays and the refresh is retried after the failure window", JSON.stringify({ reason: `refresh_failed_${failure}`, host, retry_after_hours: PLUGIN_RETRY_AFTER_FAILURE_MS / 3_600_000 }));
         return { host, status: "already_installed", reason: `refresh_failed_${failure}`, quiet: false };
+    }
+    entry.last_refresh_at = now.toISOString();
+    delete entry.last_refresh_failed_at;
+    delete entry.last_refresh_reason;
     console.error("[agent-plugins] plugin refreshed", JSON.stringify({ reason: "refreshed", host }));
     return { host, status: "refreshed", reason: "refreshed", quiet: false };
 }

package/dist/commands/books-usage.js

@@ -1,6 +1,7 @@
 /** `cockpit books` usage text (BLI-23711), in its own module so the help table can print it without loading the command. */
 export const BOOKS_USAGE = [
-    "Usage: cockpit books list [--json]",
+    "Usage: cockpit books list [--json] (includes archived books, marked archived)",
+    "       cockpit books archive <book> [--restore] [--json] (founders; nothing deleted)",
     "       cockpit books create <book> --title \"<title>\" [--json]                      (founders)",
     "       cockpit books members list|add|remove <book> [<email or user id>] [--edit] [--json]   (founders)",
     "       cockpit books ls <book> <collection> [--after <doc_id>] [--limit <1-500>] [--deleted] [--json]",

package/dist/commands/books.js

@@ -4,7 +4,7 @@ import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { BOOKS_USAGE } from "./books-usage.js";
 import { optionalNonEmpty, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
 export { BOOKS_USAGE };
-const ACTIONS = ["list", "create", "members", "ls", "get", "put", "delete", "batch", "export", "import"];
+const ACTIONS = ["list", "archive", "create", "members", "ls", "get", "put", "delete", "batch", "export", "import"];
 const BODY_MAX_CHARS = 4_000_000;
 function usage() {
     throw new Error(BOOKS_USAGE);
@@ -21,7 +21,7 @@ function wholeNumber(raw, min, max) {
 }
 export function parseBooksArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--title", "--edit", "--after", "--limit", "--deleted", "--merge", "--version", "--data", "--json", "--home", "--dashboard-url"],
+        allowedFlags: ["--restore", "--title", "--edit", "--after", "--limit", "--deleted", "--merge", "--version", "--data", "--json", "--home", "--dashboard-url"],
         valueFlags: ["--title", "--after", "--limit", "--version", "--data", "--home", "--dashboard-url"],
     });
     const [action, ...rest] = values.positionals;
@@ -30,7 +30,7 @@ export function parseBooksArgs(args) {
     const flags = values.flags;
     const has = (flag) => flags.has(flag) || values.booleans.has(flag);
     const allowOnly = (...allowed) => {
-        for (const flag of ["--title", "--edit", "--after", "--limit", "--deleted", "--merge", "--version", "--data"])
+        for (const flag of ["--restore", "--title", "--edit", "--after", "--limit", "--deleted", "--merge", "--version", "--data"])
             if (has(flag) && !allowed.includes(flag))
                 usage();
     };
@@ -47,6 +47,11 @@ export function parseBooksArgs(args) {
                 usage();
             allowOnly();
             return command;
+        case "archive":
+            if (rest.length !== 1)
+                usage();
+            allowOnly("--restore");
+            return { ...command, book: rest[0], restore: values.booleans.has("--restore") };
         case "create": {
             const title = optionalNonEmpty(flags.get("--title"));
             if (rest.length !== 1 || !title)
@@ -137,10 +142,13 @@ export async function runBooks(command, io) {
                 if (books.length === 0)
                     writeLine(io.stdout, "No books you can open.");
                 for (const b of books)
-                    writeLine(io.stdout, `${b.id}\t${b.access}${b.founder ? " (founder)" : ""}\t${b.title}`);
+                    writeLine(io.stdout, `${b.id}\t${b.access}${b.founder ? " (founder)" : ""}\t${b.title}${b.archived_at ? " (archived)" : ""}`);
                 return 0;
             }
             break;
+        case "archive":
+            answer = await booksRequest(door, "POST", `/api/books/${book}/archive`, "archive", { archived: !command.restore });
+            break;
         case "create":
             answer = await booksRequest(door, "POST", "/api/books", "create", { id: command.book, title: command.title });
             break;

package/dist/commands/codex-hooks-trust-choice.js

@@ -0,0 +1,51 @@
+/**
+ * The person's answer to "Auto-trust the BLI Memory hooks in Codex?"
+ * (BLI-24349), kept so a "no" is never asked again.
+ *
+ * `<state_dir>/codex-hooks-trust.json`, one small object. Only a "no" changes
+ * behaviour (the question is not asked again); a "yes" is recorded for the
+ * operator reading the machine, since the system hooks file itself is what
+ * proves the yes. `cockpit doctor --trust-codex-hooks` is how a person who
+ * said no changes their mind.
+ *
+ * A file that will not read or parse counts as no answer: asking again is the
+ * harmless direction for a question whose default is yes.
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const CODEX_HOOKS_TRUST_CHOICE_FILE = "codex-hooks-trust.json";
+const SCHEMA = "codex-hooks-trust.v1";
+function choiceFile(paths) {
+    return path.join(paths.state_dir, CODEX_HOOKS_TRUST_CHOICE_FILE);
+}
+export async function readCodexHooksTrustChoice(paths) {
+    let raw;
+    try {
+        raw = await readFile(choiceFile(paths), "utf8");
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return { choice: null, reason: "choice_absent" };
+        console.error("[codex-hooks-trust] choice file unreadable; treating as no answer", JSON.stringify({ reason: "choice_unreadable", error_code: code ?? "unknown" }));
+        return { choice: null, reason: "choice_unreadable" };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.schema === SCHEMA && (parsed.choice === "declined" || parsed.choice === "trusted")) {
+            return { choice: parsed.choice, reason: "choice_read" };
+        }
+    }
+    catch {
+        // fall through to the named reason below
+    }
+    console.error("[codex-hooks-trust] choice file does not parse; treating as no answer", JSON.stringify({ reason: "choice_unreadable", byte_size: raw.length }));
+    return { choice: null, reason: "choice_unreadable" };
+}
+export async function writeCodexHooksTrustChoice(paths, choice, via, now = new Date()) {
+    const file = choiceFile(paths);
+    await mkdir(paths.state_dir, { recursive: true });
+    const staged = `${file}.${process.pid}.tmp`;
+    await writeFile(staged, `${JSON.stringify({ schema: SCHEMA, choice, via, at: now.toISOString() }, null, 2)}\n`, "utf8");
+    await rename(staged, file);
+}

package/dist/commands/codex-hooks-trust-prompt.js

@@ -0,0 +1,172 @@
+/**
+ * "Auto-trust the BLI Memory hooks in Codex? [Y/n]" (BLI-24349).
+ *
+ * Codex skips a hook from a person's own `~/.codex/hooks.json` until they
+ * trust it in `/hooks`, and asks again whenever the hook changes. On
+ * 2026-11-04 three of eight reporting machines were stuck there. This is the
+ * one question that ends it: a yes puts the four BLI Memory hooks in Codex's
+ * system folder, where Codex runs them as managed hooks with no trust step
+ * (`codex-managed-hooks.ts` has the proof), and takes the user-scope copy out
+ * so nothing runs twice.
+ *
+ * Rules (Edward, 2026-11-04):
+ *  - Default yes: Enter or y trusts.
+ *  - Asked only when a person is plainly there (same test as the BLI Memory
+ *    question: stdin and stdout are terminals, no `--json`, not the scheduled
+ *    tick, not `--check`/`--dry-run`, not CI). Every other run never prompts
+ *    and never changes trust; the receipt keeps saying `needs_trust`.
+ *  - A no is remembered and not asked again. `cockpit doctor
+ *    --trust-codex-hooks` is the yes without the question, for a person who
+ *    changes their mind.
+ *  - The elevation (one sudo on macOS, one UAC prompt on Windows) happens only
+ *    after a yes.
+ *  - Every branch logs one reason label: `trusted_by_prompt`, `declined`,
+ *    `non_interactive_skip`, `elevation_refused`, `write_failed:<reason>`,
+ *    plus the no-question ones (`already_managed`, `already_trusted`,
+ *    `declined_before`, `not_needed:<why>`, `unclear_answer`).
+ */
+import os from "node:os";
+import { readLine, writeLine } from "./cli-io.js";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { isMemoryCaptureOff } from "../memory-capture-choice.js";
+import { parseYesNo } from "../yes-no.js";
+import { memoryChoicePromptBlocker } from "./memory-capture-prompt.js";
+import { codexSystemHooksFile, defaultCodexElevationRunner, readCodexManagedHooks, writeCodexManagedHooks, } from "./codex-managed-hooks.js";
+import { expectedCodexTrustRows, installCodexMemoryHooks, readCodexHookTrustFromDisk, } from "./memory-install-codex-hooks.js";
+import { readCodexHooksTrustChoice, writeCodexHooksTrustChoice } from "./codex-hooks-trust-choice.js";
+import { defaultMemoryFileIo } from "./memory-install-files.js";
+import { resolveMemoryConfig } from "./memory-install-config.js";
+export const CODEX_HOOKS_TRUST_QUESTION = "Auto-trust the BLI Memory hooks in Codex? [Y/n] ";
+export const CODEX_HOOKS_TRUST_FLAG = "--trust-codex-hooks";
+/**
+ * The whole question, start to finish. Never throws: a doctor run is never
+ * lost to it. Returns the reason label it logged.
+ */
+export async function settleCodexHooksTrust(io, options, deps = {}) {
+    try {
+        const outcome = await decide(io, options, deps);
+        console.error("[codex-hooks-trust] settled", JSON.stringify({ reason: outcome }));
+        return outcome;
+    }
+    catch (error) {
+        const outcome = "write_failed:step_threw";
+        console.error("[codex-hooks-trust] settled", JSON.stringify({ reason: outcome, error_name: error instanceof Error ? error.name : typeof error }));
+        return outcome;
+    }
+}
+async function decide(io, options, deps) {
+    // First, and before anything is read: a run with nobody at the keyboard
+    // never prompts and never changes trust. The receipt carries the state.
+    const blocker = memoryChoicePromptBlocker(io, options);
+    if (blocker) {
+        console.error("[codex-hooks-trust] not asked; nobody at a terminal", JSON.stringify({ reason: "non_interactive_skip", blocker }));
+        return "non_interactive_skip";
+    }
+    const homeDir = options.homeDir ?? os.homedir();
+    const paths = getCollectorRuntimePaths(homeDir);
+    const platform = deps.platform ?? process.platform;
+    const fileIo = deps.io ?? defaultMemoryFileIo();
+    const off = await (deps.memoryOff ?? (() => isMemoryCaptureOff(paths, { fetch: io.fetch })))();
+    if (off)
+        return "not_needed:memory_off";
+    const config = await (deps.resolveConfig ?? (() => defaultResolveConfig(io, options, platform)))();
+    if (!config)
+        return "not_needed:bin_missing";
+    const trust = await readCodexHookTrustFromDisk({ homeDir, io: fileIo });
+    if (trust.feature === "disabled")
+        return "not_needed:hooks_disabled_in_config";
+    const file = deps.systemHooksFile ?? codexSystemHooksFile(platform, io.env ?? process.env);
+    const managed = await readCodexManagedHooks({ config, io: fileIo, file });
+    if (managed.state === "current")
+        return "already_managed";
+    // A machine somebody already trusted in /hooks runs the hooks today. The
+    // question is for untrusted machines (and a stale managed copy).
+    if (managed.state !== "stale" && trust.trustedRows >= expectedCodexTrustRows(config))
+        return "already_trusted";
+    if (!options.trustCodexHooks) {
+        const choice = await readCodexHooksTrustChoice(paths);
+        if (choice.choice === "declined") {
+            writeLine(io.stdout, `Codex hooks: not auto-trusted (you said no earlier). \`cockpit doctor ${CODEX_HOOKS_TRUST_FLAG}\` trusts them.`);
+            return "declined_before";
+        }
+        const answer = await ask(io, managed.state === "stale");
+        if (answer === "unclear") {
+            writeLine(io.stdout, "No answer recorded; the next `cockpit doctor` asks again.");
+            return "unclear_answer";
+        }
+        if (answer === "no") {
+            await recordChoice(paths, "declined", "prompt");
+            writeLine(io.stdout, `OK, not trusted. Codex skips the BLI Memory hooks until they are trusted; this is not asked again. ` +
+                `Change your mind: cockpit doctor ${CODEX_HOOKS_TRUST_FLAG} (or trust them in Codex's /hooks).`);
+            return "declined";
+        }
+    }
+    writeLine(io.stdout, platform === "win32"
+        ? `Windows may ask once for administrator permission to write ${file}.`
+        : `This writes ${file}; your computer asks for your password once (sudo).`);
+    const written = await writeCodexManagedHooks({
+        config,
+        io: fileIo,
+        file,
+        platform,
+        elevate: deps.elevate ?? defaultCodexElevationRunner(),
+    });
+    if (written.outcome === "elevation_refused") {
+        writeLine(io.stdout, "Not trusted: the administrator step was cancelled. The next `cockpit doctor` asks again.");
+        return "elevation_refused";
+    }
+    if (written.outcome === "write_failed") {
+        writeLine(io.stdout, `Not trusted: the system hooks file could not be written (${written.reason}). Fallback: trust them in Codex's /hooks.`);
+        return written.reason;
+    }
+    // The system copy carries the hooks now; take the user copy out so nothing runs twice.
+    const userCopy = await installCodexMemoryHooks({ homeDir, config, dryRun: false, io: fileIo, systemHooksFile: file });
+    if (userCopy.status === "failed") {
+        console.error("[codex-hooks-trust] system copy written; user copy not removed", JSON.stringify({ reason: userCopy.reason }));
+    }
+    await recordChoice(paths, "trusted", options.trustCodexHooks ? "flag" : "prompt");
+    writeLine(io.stdout, "Codex hooks: trusted. Codex now runs the BLI Memory hooks as managed hooks, with no /hooks review.");
+    return options.trustCodexHooks ? "trusted_by_flag" : "trusted_by_prompt";
+}
+async function ask(io, stale) {
+    writeLine(io.stdout, stale
+        ? "BLI Memory's Codex hooks changed since they were trusted on this machine. Yes updates the trusted copy."
+        : "Codex will not run BLI Memory's hooks (recall and save) until they are trusted. Yes trusts them for this machine, once.");
+    let verdict = parseYesNo(await readLine(io, CODEX_HOOKS_TRUST_QUESTION), { emptyIsYes: true });
+    if (verdict === "unclear") {
+        verdict = parseYesNo(await readLine(io, `Please answer y or n. ${CODEX_HOOKS_TRUST_QUESTION}`), { emptyIsYes: true });
+    }
+    return verdict;
+}
+async function recordChoice(paths, choice, via) {
+    try {
+        await writeCodexHooksTrustChoice(paths, choice, via);
+    }
+    catch (error) {
+        // The trust itself (or the "no") already happened; only the memory of it is lost.
+        console.error("[codex-hooks-trust] answer not saved", JSON.stringify({ reason: "choice_write_failed", choice, error_name: error instanceof Error ? error.name : typeof error }));
+    }
+}
+async function defaultResolveConfig(io, options, platform) {
+    const resolved = await resolveMemoryConfig({
+        kind: "memory",
+        action: "status",
+        ...(options.homeDir ? { homeDir: options.homeDir } : {}),
+        ...(options.dashboardUrl ? { dashboardUrl: options.dashboardUrl } : {}),
+        dryRun: false,
+        json: false,
+    }, io, platform, {});
+    return resolved.config;
+}
+/** What `cockpit doctor` calls: its own flags mapped onto the question's options. */
+export function settleDoctorCodexHooksTrust(command, io) {
+    return settleCodexHooksTrust(io, {
+        json: command.json,
+        ...(command.homeDir ? { homeDir: command.homeDir } : {}),
+        ...(command.automaticTick ? { automaticTick: true } : {}),
+        dryRun: command.dryRun,
+        ...(command.checkOnly ? { checkOnly: true } : {}),
+        dashboardUrl: command.dashboardUrl,
+        ...(command.trustCodexHooks ? { trustCodexHooks: true } : {}),
+    });
+}

package/dist/commands/codex-managed-hooks.js

@@ -0,0 +1,226 @@
+/**
+ * BLI Memory's Codex hooks as MANAGED hooks (BLI-24349).
+ *
+ * Codex will not run a hook from a person's own `~/.codex/hooks.json` until
+ * they trust it in `/hooks`, and asks again whenever the hook text changes.
+ * Hooks in Codex's SYSTEM config folder are different: Codex marks them
+ * "managed, trusted by policy" and runs them with no review at all.
+ *
+ *   macOS (and any Unix)  /etc/codex/hooks.json
+ *   Windows               %ProgramData%\OpenAI\Codex\hooks.json
+ *
+ * ## Proven, not assumed (2026-11-04, Codex CLI 0.166.0)
+ *
+ * On a Linux box signed in with a personal ChatGPT account (plan `pro`, no
+ * Business workspace), with no `[hooks.state]` row anywhere, Codex's own
+ * `hooks/list` reported hooks in `/etc/codex/hooks.json` as `source: system,
+ * isManaged: true, trustStatus: managed`, and a real turn fired session-start,
+ * prompt and stop. The source agrees: `hook_metadata_for_config_layer_source`
+ * in openai/codex `codex-rs/hooks/src/engine/discovery.rs` maps the system
+ * config layer to `(HookSource::System, true)`, and nothing on that path reads
+ * the account. Windows was NOT run on a real machine (the test VM was out of
+ * reach); its folder comes from `windows_codex_system_dir` in
+ * `codex-rs/config/src/loader/mod.rs` (known folder ProgramData). Receipts:
+ * the BLI-24349 ticket comments and `docs/runbooks/codex-hooks-trust.md`.
+ *
+ * ## Why `hooks.json`, not `requirements.toml`
+ *
+ * Hooks in `requirements.toml` are managed too, but a broken write to that file
+ * stops Codex from starting at all ("failed to parse requirements layer",
+ * exit 1). A broken system `hooks.json` costs one warning line and the turn
+ * still runs. `requirements.toml` is also the admin policy file an
+ * organisation's device management owns; this module never touches it, and
+ * never sets `allow_managed_hooks_only` (that would switch off a person's own
+ * hooks).
+ *
+ * ## The write
+ *
+ * The system folder belongs to the administrator, so the write is tried as
+ * the person first (works on Windows when ProgramData lets users create
+ * folders, which is its default) and elevated only when that is refused:
+ * one `sudo` on macOS, one UAC prompt on Windows. Only our hook groups are
+ * replaced; anything else in the file survives, exactly like the user-scope
+ * writer (`applyHookGroups`). The result is read back off disk before it
+ * counts (BLI-2541).
+ */
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { applyHookGroups, hookGroupsMatch, ourHookCount, parseJsonRecord, serializeJson, } from "./memory-install-claude.js";
+/**
+ * Moves the system folder somewhere else. The test suite sets it
+ * (`vitest.setup.ts`) so no test ever reads or elevates into the real
+ * `/etc/codex` or ProgramData, the same guard it keeps on HOME. Read from the
+ * process too, because callers inject a trimmed `env` for other reasons.
+ */
+export const CODEX_SYSTEM_DIR_ENV = "COCKPIT_CODEX_SYSTEM_DIR";
+/** Codex's system config folder on this platform. */
+export function codexSystemDir(platform, env = process.env) {
+    const override = (env[CODEX_SYSTEM_DIR_ENV] ?? process.env[CODEX_SYSTEM_DIR_ENV] ?? "").trim();
+    if (override)
+        return override;
+    if (platform === "win32") {
+        const programData = (env["ProgramData"] ?? env["PROGRAMDATA"] ?? "").trim() || "C:\\ProgramData";
+        return path.win32.join(programData, "OpenAI", "Codex");
+    }
+    return "/etc/codex";
+}
+/** `/etc/codex/hooks.json`, or `%ProgramData%\OpenAI\Codex\hooks.json` on Windows. */
+export function codexSystemHooksFile(platform, env = process.env) {
+    const dir = codexSystemDir(platform, env);
+    if ((env[CODEX_SYSTEM_DIR_ENV] ?? process.env[CODEX_SYSTEM_DIR_ENV] ?? "").trim())
+        return path.join(dir, "hooks.json");
+    return platform === "win32" ? path.win32.join(dir, "hooks.json") : path.posix.join(dir, "hooks.json");
+}
+/** An injected override (null = do not look) or this platform's system hooks file. */
+export function codexSystemHooksFileFor(override, platform, env) {
+    return override !== undefined ? override : codexSystemHooksFile(platform, env ?? process.env);
+}
+export async function readCodexManagedHooks(options) {
+    let raw;
+    try {
+        raw = await options.io.readText(options.file);
+    }
+    catch {
+        return { state: "unreadable", file: options.file };
+    }
+    if (raw === null || !raw.trim())
+        return { state: "absent", file: options.file };
+    const root = parseJsonRecord(raw);
+    if (!root)
+        return { state: "unreadable", file: options.file };
+    if (hookGroupsMatch(root, options.config.hooks))
+        return { state: "current", file: options.file };
+    return { state: ourHookCount(root) > 0 ? "stale" : "absent", file: options.file };
+}
+/**
+ * Puts our four hooks into the system file. Never throws.
+ *
+ * Order: read what is there (refuse to replace a file that will not parse,
+ * same rule as every other config we touch), merge our groups in, try the
+ * write as the person, elevate only on a permission refusal, read back.
+ */
+export async function writeCodexManagedHooks(options) {
+    const { file } = options;
+    let raw;
+    try {
+        raw = await options.io.readText(file);
+    }
+    catch (error) {
+        // Reading a world-readable file failed for a reason other than "absent".
+        return { outcome: "write_failed", reason: `write_failed:${errorCode(error, "read_failed")}`, file };
+    }
+    const existing = raw === null || !raw.trim() ? {} : parseJsonRecord(raw);
+    if (!existing) {
+        // Somebody else's system hooks file that does not parse: not ours to replace.
+        return { outcome: "write_failed", reason: "write_failed:system_file_unparseable", file };
+    }
+    if (hookGroupsMatch(existing, options.config.hooks)) {
+        return { outcome: "written", reason: "already_current", file };
+    }
+    const contents = serializeJson(applyHookGroups(structuredClone(existing), options.config.hooks), raw ?? "");
+    let reason = "wrote_direct";
+    try {
+        await options.io.writeText(file, contents);
+    }
+    catch (error) {
+        const code = errorCode(error, "write_error");
+        if (code !== "EACCES" && code !== "EPERM") {
+            return { outcome: "write_failed", reason: `write_failed:${code}`, file };
+        }
+        console.error("[codex-hooks-trust] the system hooks folder needs an administrator; asking the OS once", JSON.stringify({ reason: "elevation_needed", platform: options.platform, error_code: code }));
+        const elevated = await elevatedCopy({ ...options, contents });
+        if (elevated.status === "refused")
+            return { outcome: "elevation_refused", reason: "elevation_refused", file };
+        if (elevated.status === "failed")
+            return { outcome: "write_failed", reason: `write_failed:${elevated.reason}`, file };
+        reason = "wrote_elevated";
+    }
+    // BLI-2541: what the disk holds, not what we sent.
+    const stored = await readCodexManagedHooks({ config: options.config, io: options.io, file });
+    if (stored.state !== "current") {
+        return { outcome: "write_failed", reason: "write_failed:read_back_mismatch", file };
+    }
+    return { outcome: "written", reason, file };
+}
+async function elevatedCopy(options) {
+    let stagingDir = null;
+    try {
+        stagingDir = await mkdtemp(path.join(options.tempDir ?? os.tmpdir(), "cockpit-codex-hooks-"));
+        const stagedFile = path.join(stagingDir, `hooks.${randomBytes(4).toString("hex")}.json`);
+        await writeFile(stagedFile, options.contents, "utf8");
+        const pathApi = options.platform === "win32" ? path.win32 : path.posix;
+        return await options.elevate({
+            platform: options.platform,
+            stagedFile,
+            targetDir: pathApi.dirname(options.file),
+            targetFile: options.file,
+        });
+    }
+    catch (error) {
+        return { status: "failed", reason: errorCode(error, "staging_failed") };
+    }
+    finally {
+        if (stagingDir)
+            await rm(stagingDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+/**
+ * The real elevation: `sudo` on macOS, UAC on Windows. Both talk to the person
+ * directly (sudo reads the password from the terminal, UAC is its own secure
+ * desktop), so nothing secret ever passes through this process.
+ */
+export function defaultCodexElevationRunner(spawn = spawnSync) {
+    return async (request) => (request.platform === "win32" ? elevateWindows(request, spawn) : elevateUnix(request, spawn));
+}
+function elevateUnix(request, spawn) {
+    // `sudo -v` is the one password prompt; a wrong password three times, Ctrl-C
+    // or a machine where this person is not an administrator all end here.
+    const validate = spawn("sudo", ["-v"], { stdio: ["inherit", "inherit", "inherit"], windowsHide: true });
+    if (validate.error)
+        return { status: "failed", reason: errorCode(validate.error, "sudo_unavailable") };
+    if (validate.status !== 0)
+        return { status: "refused" };
+    // `-n`: the credential is cached now, so this never prompts a second time.
+    // Paths travel as arguments, never spliced into the script.
+    const copy = spawn("sudo", ["-n", "/bin/sh", "-c", 'mkdir -p "$1" && cp "$2" "$3" && chmod 644 "$3"', "sh", request.targetDir, request.stagedFile, request.targetFile], { stdio: ["ignore", "inherit", "inherit"], windowsHide: true });
+    if (copy.error)
+        return { status: "failed", reason: errorCode(copy.error, "sudo_copy_failed") };
+    return copy.status === 0 ? { status: "ok" } : { status: "failed", reason: `elevated_exit_${copy.status ?? "signal"}` };
+}
+/** Windows exit code for "the operation was cancelled by the user" (UAC "No"). */
+const ERROR_CANCELLED = 1223;
+function elevateWindows(request, spawn) {
+    const inner = codexWindowsElevatedScript(request);
+    const encoded = Buffer.from(inner, "utf16le").toString("base64");
+    const outer = "try { $p = Start-Process -FilePath 'powershell.exe' -Verb RunAs -Wait -PassThru -WindowStyle Hidden " +
+        `-ArgumentList @('-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-EncodedCommand','${encoded}'); exit $p.ExitCode } ` +
+        `catch { exit ${ERROR_CANCELLED} }`;
+    const result = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", outer], {
+        stdio: ["ignore", "ignore", "ignore"],
+        windowsHide: true,
+    });
+    if (result.error)
+        return { status: "failed", reason: errorCode(result.error, "powershell_unavailable") };
+    if (result.status === ERROR_CANCELLED)
+        return { status: "refused" };
+    return result.status === 0 ? { status: "ok" } : { status: "failed", reason: `elevated_exit_${result.status ?? "signal"}` };
+}
+/** The script the elevated PowerShell runs. Exported for its test; paths are single-quoted literals. */
+export function codexWindowsElevatedScript(request) {
+    const quote = (value) => `'${value.replace(/'/gu, "''")}'`;
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `New-Item -ItemType Directory -Force -Path ${quote(request.targetDir)} | Out-Null`,
+        `Copy-Item -LiteralPath ${quote(request.stagedFile)} -Destination ${quote(request.targetFile)} -Force`,
+        "exit 0",
+    ].join("; ");
+}
+/** A short, charset-safe code for a failure: `EACCES`, `ENOENT`, or the fallback. */
+function errorCode(error, fallback) {
+    const code = error?.code;
+    const raw = typeof code === "string" && code.trim() ? code : fallback;
+    return raw.replace(/[^A-Za-z0-9_.-]/gu, "_").slice(0, 40);
+}

package/dist/commands/doctor-report.js

@@ -1,4 +1,4 @@
-import { CODEX_HOOKS_TRUST_GUIDE_URL, setupReceiptPieces } from "@bli-cockpit/telemetry-core";
+import { codexHooksTrustAction, setupReceiptPieces } from "@bli-cockpit/telemetry-core";
 import { redactedHealthDetail } from "../health-detail.js";
 import { setupReceiptBlock } from "./setup-receipt-lines.js";
 export function ok(id, code, message) {
@@ -194,7 +194,7 @@ export function doctorNeedsPerson(rows, receipt) {
             const step = key === "device" || key === "browser" ? "authed" : key === "collector.autostart" ? "autostart-alive" : "memory-registered";
             if (piece.status !== "needs_trust" && items.some((item) => item.step === step))
                 continue;
-            items.push({ step: key, reason: piece.reason ?? piece.status, action: piece.status === "needs_trust" ? `Open Codex and run /hooks to trust the installed hooks. Step by step: ${CODEX_HOOKS_TRUST_GUIDE_URL}` : defaults[step] });
+            items.push({ step: key, reason: piece.reason ?? piece.status, action: piece.status === "needs_trust" ? codexHooksTrustAction(piece.reason) : defaults[step] });
         }
     }
     return items;

package/dist/commands/doctor-update.js

@@ -80,6 +80,8 @@ export function reexecDoctor(command, io) {
         args.push("--no-usage-telemetry");
     if (command.noMemory)
         args.push("--no-memory");
+    if (command.trustCodexHooks)
+        args.push("--trust-codex-hooks");
     if (command.homeDir)
         args.push("--home", command.homeDir);
     if (command.backfillBudgetSeconds)

package/dist/commands/doctor.js

@@ -1,6 +1,7 @@
 import { checkSlackConnected } from "./doctor-slack.js";
 import { checkUsageTelemetry, fixUsageTelemetry } from "./doctor-usage-telemetry.js";
 import { settleDoctorMemoryChoice } from "./memory-capture-prompt.js";
+import { settleDoctorCodexHooksTrust } from "./codex-hooks-trust-prompt.js";
 import { reportIgnoredOptOuts } from "../capture-opt-outs.js";
 import { checkShelfRouting, fixShelfRouting } from "./doctor-shelf.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, LOCAL_COLLECTOR_VERSION } from "../local-state.js";
@@ -105,6 +106,7 @@ export async function runDoctorWithDeps(command, io, deps) {
         console.error("[doctor] row done", JSON.stringify({ row: invariant.id, elapsed_ms: rowCheckMs + fixMs, check_ms: rowCheckMs, fix_ms: fixMs, verdict: row.status, reason: row.code }));
         rows.push(row);
     }
+    await (deps.settleCodexHooksTrust ?? ((c) => settleDoctorCodexHooksTrust(c.command, c.io)))(context); // BLI-24349: after memory-registered, before the re-read
     // Re-read host state after repairs. Sync is proven by its upload receipts;
     // re-running its diagnostic would always request a new upload by design.
     if (!diagnoseOnly) {

package/dist/commands/local-args-collector-setup.js

@@ -96,6 +96,7 @@ const DOCTOR_ALLOWED_FLAGS = [
     "--no-repair",
     "--no-usage-telemetry",
     "--no-memory",
+    "--trust-codex-hooks",
     "--lock-wait",
     "--backfill-budget",
     "--json",
@@ -143,6 +144,7 @@ export function parseDoctorArgs(alias, args) {
         kind: "doctor",
         noUsageTelemetry: values.booleans.has("--no-usage-telemetry"),
         noMemory: values.booleans.has("--no-memory"),
+        trustCodexHooks: values.booleans.has("--trust-codex-hooks"),
         checkOnly: values.booleans.has("--check") || values.booleans.has("--no-repair"),
         // Absent stays absent (BLI-11101): `doctor-budget.ts` owns the defaults,
         // and `--json` without either flag runs under one bounded budget.

package/dist/commands/local-args-collector-status.js

@@ -191,11 +191,13 @@ export function parseMemoryArgs(args) {
             throw new Error("memory log takes one reason or --reason-stdin, never --dry-run");
         if (verdict !== "win" && verdict !== "loss" && verdict !== "noise")
             throw new Error("memory log needs win|loss|noise");
-        if (store !== "bli" && store !== "supermemory" && store !== "both")
-            throw new Error("memory log needs --store bli|supermemory|both");
+        // BLI-24380: BLI Memory is the only store, so --store is optional (bli). The retired
+        // `supermemory` and `both` still parse; runMemoryLog logs them as retired, never an error.
+        if (store !== undefined && store !== "bli" && store !== "supermemory" && store !== "both")
+            throw new Error("memory log --store takes bli (the only store)");
         if (!reasonStdin && !reason.trim())
             throw new Error("memory log needs a reason");
-        return { kind: "memory-log", verdict, store, reason, reasonStdin, homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")), json: values.booleans.has("--json") };
+        return { kind: "memory-log", verdict, store: store ?? "bli", reason, reasonStdin, homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")), json: values.booleans.has("--json") };
     }
     if (values.flags.has("--store") || values.booleans.has("--reason-stdin"))
         throw new Error("--store and --reason-stdin require memory log");

package/dist/commands/local-help-commands-tower.js

@@ -480,7 +480,8 @@ export const TOWER_COMMAND_HELP = [
             "log appends an opinion to ~/.codex/AGENT-EXPERIENCE.md and posts it to Tower.",
             "Use --reason-stdin instead of a quoted reason; --json reports shipped status.",
             "Reasons: one line, max 500 characters; no prompts, memory bodies or secrets.",
-            "Markers: [bli] = BLI Memory, ◪ = Supermemory, [bli]+◪ = both.",
+            "--store is optional: bli (BLI Memory) is the only store. The retired supermemory and both",
+            "values are accepted and logged as retired: both records as bli, supermemory records nothing.",
             "Offline entries stay queued; the next collector sync retries with the same ID.",
         ],
     ],

package/dist/commands/local-help-commands.js

@@ -23,7 +23,7 @@ import { TOWER_COMMAND_HELP } from "./local-help-commands-tower.js";
 import { TOWER_OPS_COMMAND_HELP } from "./local-help-commands-tower-ops.js";
 /** One manual per collector command; the Tower nouns are spread in from their own file. */
 const COMMAND_HELP = new Map([
-    ["books", [BOOKS_USAGE, "Client Books: each engagement's record (timeline, actions, documents, meetings, ...). A member of a book reads it; a member with edit access, or a founder, writes it; only founders create books and manage members. put without --merge replaces the record's data; --merge changes only the fields given. --version <n> makes a write conditional: refused as version_conflict when someone changed the record since you read version n (0 = must not exist yet). delete is soft. export writes <dir>/<collection>/<doc_id>.json; import reads that layout and writes 50 records per batch. MCP twins: books_list, books_create, books_members, books_read, books_write, books_batch. Docs: docs/architecture/client-books.md."]],
+    ["books", [BOOKS_USAGE, "Client Books: each engagement's record (timeline, actions, documents, meetings, ...). A member of a book reads it; a member with edit access, or a founder, writes it; only founders create books and manage members. put without --merge replaces the record's data; --merge changes only the fields given. --version <n> makes a write conditional: refused as version_conflict when someone changed the record since you read version n (0 = must not exist yet). delete is soft. export writes <dir>/<collection>/<doc_id>.json; import reads that layout and writes 50 records per batch. archive hides a book from the Client Books page; archive --restore returns it; nothing is deleted. list marks archived books. MCP twins: books_list, books_archive, books_create, books_members, books_read, books_write, books_batch. Docs: docs/architecture/client-books.md."]],
     ["glossary", ["Usage: cockpit glossary list|add <wrong> --to <name>|remove <wrong> [--json]", "Quote phrases. Removing a form prevents future corrections of it."]],
     ["skills", ["Usage: cockpit skills library [--weeks <1-52>] [--json] | cockpit skills refresh [--weeks <1-104>] [--json]", "The Skill Library: every agent skill and command our GitHub repos define (name, description, repo, path, versions) with weekly use by person, from the sessions Tower already collects. Uses that match no scanned skill are listed as unmatched, never dropped. The first line is the coverage: repos scanned, skills, invocations matched of total. You see your own usage; Vee, Jeetesh and Ed see everyone's except a founder's. refresh scans the repos and recomputes the weekly totals now (super_admin only; a stale library also refreshes itself when read). MCP twins: skills_library, skills_refresh. Web: TEAM > Skills."]],
     ["push", ["Usage: cockpit push status | test [--dashboard-url <url>] [--json]", "Phone notifications. status lists your saved devices and whether the server has its push keys; test sends a test push to every saved device. Turn a phone on from Settings on the phone."]],
@@ -105,7 +105,7 @@ const COMMAND_HELP = new Map([
     [
         "doctor",
         [
-            "Usage: cockpit doctor [--workspace <path>] [--check | --no-repair] [--no-usage-telemetry] [--no-memory] [--lock-wait <seconds>] [--backfill-budget <seconds>] [--json]",
+            "Usage: cockpit doctor [--workspace <path>] [--check | --no-repair] [--no-usage-telemetry] [--no-memory] [--trust-codex-hooks] [--lock-wait <seconds>] [--backfill-budget <seconds>] [--json]",
             "",
             "Diagnose, repair, and verify this machine.",
             "Repairs CLI, background sync, sign-in, roots, memory and hooks, agent rules, catch-up, uploads, and cleanup.",
@@ -113,6 +113,7 @@ const COMMAND_HELP = new Map([
             "--no-usage-telemetry switches off Claude Code and Codex usage export, including later doctor runs.",
             "--no-memory turns BLI Memory off on this machine (same as `cockpit memory off`), including later runs and the background sync.",
             "In a terminal, the first doctor or onboard asks once whether BLI Memory may save your sessions; `cockpit memory on|off` changes the answer.",
+            "In a terminal, doctor also asks once \"Auto-trust the BLI Memory hooks in Codex? [Y/n]\" while Codex has not trusted them; yes (the default) writes them to Codex's system hooks folder with one sudo or Windows administrator prompt, so Codex never asks again. A no is remembered; --trust-codex-hooks trusts them without the question. Background and --json runs never ask.",
             "--check or --no-repair diagnoses without repairs. --dry-run previews repairs.",
             "--backfill-budget defaults to 900 seconds; catch-up repeats chunks until complete, with progress every 30 seconds.",
             "Doctor never waits for the background sync: a running sync is reported as running (with how long ago it started) and doctor finishes; a sync that stopped responding or made no progress for 15 minutes is ended and doctor carries on. --lock-wait is accepted and changes nothing. Progress prints at most every 30 seconds and says what changed.",

package/dist/commands/local-help.js

@@ -152,7 +152,7 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit serve [--port <port>] [--workspace <path>]",
     "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
     "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
-    "  cockpit memory [search \"<question>\"|save|update <id>|forget <id>|profile|on|off|install|uninstall|status|log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"] [--container <tag>] [--limit <n>] [--no-recent] [--include-originals|--no-originals] [--include-source|--no-source] [--custom-id <id>] [--extract] [--content-stdin] [--reason <label>] [--file <path>] [--dashboard-url <url>] [--dry-run] [--json]",
+    "  cockpit memory [search \"<question>\"|save|update <id>|forget <id>|profile|on|off|install|uninstall|status|log <win|loss|noise> [--store bli] \"<reason>\"] [--container <tag>] [--limit <n>] [--no-recent] [--include-originals|--no-originals] [--include-source|--no-source] [--custom-id <id>] [--extract] [--content-stdin] [--reason <label>] [--file <path>] [--dashboard-url <url>] [--dry-run] [--json]",
     "  cockpit clean [--dry-run] [--all-committed] [--reconcile] [--dashboard-url <url>] [--json]",
     "  cockpit sources check [--reconcile] [--older-than <days>] [--dashboard-url <url>] [--json]",
     "  cockpit docs [list|tree|read <id|slug>|create --title <t>|update <id>|delete <id|slug>|trash|versions <id|slug>|restore <id>] [--parent <id>|root|--clear-parent] [--query <text> [--word]] [--limit <n>] [--visibility org|private] [--file <path>|--body-stdin] [--allow-empty] [--dashboard-url <url>] [--json]",

package/dist/commands/memory-install-codex-hooks.js

@@ -38,7 +38,16 @@
  *     `needs_trust` exists to name — and it is the one step an intern has to
  *     do by hand.
  *
- * ## What is NOT verified
+ * ## Managed hooks (BLI-24349)
+ *
+ * Doctor's "Auto-trust the BLI Memory hooks in Codex?" puts the same hooks in
+ * Codex's SYSTEM folder (`codex-managed-hooks.ts`), where Codex runs them with
+ * no trust step. When that copy is there, the installer below takes the
+ * user-scope copy OUT instead of writing it (nothing runs twice), and the
+ * inspector reports the system file. Proven on a real Codex 0.166.0 run; see
+ * that module's header.
+ *
+ * ## What is NOT verified (user-scope route)
  *
  * Nobody has yet trusted these hooks on a real machine, so the wiring past the
  * write is unproven end to end: the file shape, the event names and the trust
@@ -59,14 +68,36 @@
  * A gauge that can only be too pessimistic is the right way round for this one.
  */
 import path from "node:path";
-import { applyHookGroups, applyJsonTarget, hookGroupsMatch, inspectJsonTarget, ourHookCount, } from "./memory-install-claude.js";
+import { applyHookGroups, applyJsonTarget, hookGroupsMatch, inspectJsonTarget, ourHookCount, parseJsonRecord, serializeJson, stripOurHooks, } from "./memory-install-claude.js";
+import { codexSystemHooksFile, readCodexManagedHooks, } from "./codex-managed-hooks.js";
 export function codexHooksFile(homeDir) {
     return path.join(homeDir, ".codex", "hooks.json");
 }
 export function codexConfigTomlFile(homeDir) {
     return path.join(homeDir, ".codex", "config.toml");
 }
+function systemHooksFileFor(options) {
+    return options.systemHooksFile === undefined ? codexSystemHooksFile(process.platform) : options.systemHooksFile;
+}
+/** The managed reading, or null when nobody asked to look. Never throws. */
+export async function readCodexManagedHooksFor(options) {
+    const file = systemHooksFileFor(options);
+    if (!file)
+        return null;
+    return readCodexManagedHooks({ config: options.config, io: options.io, file });
+}
 export async function installCodexMemoryHooks(options) {
+    // BLI-24349: once the hooks live in Codex's system folder (managed, run
+    // with no trust step), a user-scope copy would make every hook run twice
+    // the day somebody also trusts it in /hooks. So the user copy is taken out
+    // instead of written, and the target names the system file. A STALE
+    // system copy is treated the same way: the old managed hooks keep running,
+    // and doctor asks once to refresh them (the receipt says `needs_trust`,
+    // reason `managed_hooks_stale`).
+    const managed = await readCodexManagedHooksFor(options);
+    if (managed && (managed.state === "current" || managed.state === "stale")) {
+        return stripUserScopeCopy(options, managed);
+    }
     return applyJsonTarget({
         target: "codex_hooks",
         file: codexHooksFile(options.homeDir),
@@ -76,6 +107,15 @@ export async function installCodexMemoryHooks(options) {
     });
 }
 export async function inspectCodexMemoryHooks(options) {
+    const managed = await readCodexManagedHooksFor(options);
+    if (managed && (managed.state === "current" || managed.state === "stale")) {
+        return {
+            target: "codex_hooks",
+            status: "installed",
+            reason: managed.state === "current" ? "managed_by_system" : "managed_hooks_stale",
+            path: managed.file,
+        };
+    }
     return inspectJsonTarget({
         target: "codex_hooks",
         file: codexHooksFile(options.homeDir),
@@ -84,6 +124,59 @@ export async function inspectCodexMemoryHooks(options) {
         matches: (root) => hookGroupsMatch(root, options.config.hooks),
     });
 }
+/**
+ * Takes OUR groups out of `~/.codex/hooks.json` (a person's own hooks stay),
+ * because the system copy now carries them. Same read-back rule as every
+ * other write here.
+ */
+async function stripUserScopeCopy(options, managed) {
+    const reason = managed.state === "current" ? "managed_by_system" : "managed_hooks_stale";
+    const file = codexHooksFile(options.homeDir);
+    let raw;
+    try {
+        raw = await options.io.readText(file);
+    }
+    catch (error) {
+        return { target: "codex_hooks", status: "failed", reason: "user_copy_unreadable", path: file, detail: error instanceof Error ? error.name : "unknown" };
+    }
+    const root = raw === null || !raw.trim() ? null : parseJsonRecord(raw);
+    if (!root || ourHookCount(root) === 0) {
+        return { target: "codex_hooks", status: "already", reason, path: managed.file };
+    }
+    if (options.dryRun) {
+        return { target: "codex_hooks", status: "would_install", reason: "dry_run", path: file, detail: "would remove the user-scope copy; the system copy carries the hooks" };
+    }
+    const next = removeOurGroups(structuredClone(root));
+    try {
+        await options.io.writeText(file, serializeJson(next, raw ?? ""));
+    }
+    catch (error) {
+        return { target: "codex_hooks", status: "failed", reason: "user_copy_write_failed", path: file, detail: error instanceof Error ? error.name : "unknown" };
+    }
+    const storedRaw = await options.io.readText(file);
+    const stored = storedRaw === null ? null : parseJsonRecord(storedRaw);
+    if (!stored || ourHookCount(stored) > 0) {
+        return { target: "codex_hooks", status: "failed", reason: "read_back_mismatch", path: file, detail: "the user-scope copy is still there after the write" };
+    }
+    console.error("[codex-hooks-trust] user-scope copy removed; Codex runs the system copy", JSON.stringify({ reason: "user_copy_removed", managed_state: managed.state }));
+    return { target: "codex_hooks", status: "installed", reason, path: managed.file, detail: "user-scope copy removed" };
+}
+function removeOurGroups(root) {
+    const hooks = root["hooks"];
+    if (!hooks || typeof hooks !== "object" || Array.isArray(hooks))
+        return root;
+    const record = hooks;
+    for (const [event, groups] of Object.entries(record)) {
+        if (!Array.isArray(groups))
+            continue;
+        const kept = stripOurHooks(groups).groups;
+        if (kept.length === 0)
+            delete record[event];
+        else
+            record[event] = kept;
+    }
+    return root;
+}
 /**
  * Reads the trust state out of `~/.codex/config.toml` WITHOUT parsing the
  * whole file.

package/dist/commands/memory-install-receipt.js

@@ -86,6 +86,18 @@ function judgeCodexHooks(input, reasons) {
         reasons[key] = "hooks_disabled_in_config";
         return "unsupported";
     }
+    // BLI-24349: hooks in Codex's system folder are managed and run with no
+    // trust step. `ok` carries its reason so the board can say HOW it is ok.
+    if (input.codexManaged === "current") {
+        reasons[key] = "managed_by_system";
+        return "ok";
+    }
+    if (input.codexManaged === "stale") {
+        // The old managed copy may still run, but not today's hooks; doctor asks
+        // once to refresh it, so the action is the same as an untrusted machine's.
+        reasons[key] = "managed_hooks_stale";
+        return "needs_trust";
+    }
     const target = input.targets.find((entry) => entry.target === "codex_hooks");
     if (!target) {
         reasons[key] = input.binFound ? "target_not_checked" : "bin_missing";
@@ -105,7 +117,11 @@ function judgeCodexHooks(input, reasons) {
     if (input.codexTrust.trustedRows >= input.expectedTrustRows)
         return "ok";
     reasons[key] =
-        input.codexTrust.disabledRows > 0 ? "trust_rows_disabled" : "no_trust_rows";
+        input.codexTrust.disabledRows > 0
+            ? "trust_rows_disabled"
+            : input.codexTrustDeclined
+                ? "trust_declined"
+                : "no_trust_rows";
     return "needs_trust";
 }
 /**

package/dist/commands/memory-install-report.js

@@ -3,7 +3,7 @@
  * one outcome, and rendering that outcome for a log line or a terminal.
  * Sibling of `memory-install.ts`, named in its header.
  */
-import { CODEX_HOOKS_TRUST_GUIDE_URL, memoryInstallGaps } from "@bli-cockpit/telemetry-core";
+import { codexHooksTrustAction, memoryInstallGaps } from "@bli-cockpit/telemetry-core";
 import { memoryDaemonLine } from "./memory-daemon-probe.js";
 import { memoryReceiptLine } from "./memory-install-receipt.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
@@ -102,9 +102,10 @@ export function memoryOutcomeLines(outcome) {
     // The trust step is the one thing a person has to do by hand, so it is said
     // here in words rather than left as a status word they have to look up.
     if (outcome.receipt.codex.hooks === "needs_trust") {
-        lines.push("  Codex will NOT run these hooks until you trust them: open Codex in any folder, " +
-            "run /hooks, and trust every bli-memory entry. One time, per machine. " +
-            `Step by step, with pictures: ${CODEX_HOOKS_TRUST_GUIDE_URL}`);
+        lines.push(`  Codex will NOT run these hooks until they are trusted. ${codexHooksTrustAction(outcome.receipt.reasons?.["codex.hooks"])}`);
+    }
+    if (outcome.receipt.codex.hooks === "ok" && outcome.receipt.reasons?.["codex.hooks"] === "managed_by_system") {
+        lines.push("  Codex runs these hooks from its system hooks folder (managed), so no /hooks trust step is needed.");
     }
     if (outcome.receipt.codex.hooks === "unsupported") {
         lines.push("  Codex hooks are turned off in your ~/.codex/config.toml ([features] hooks = false), " +

package/dist/commands/memory-install.js

@@ -52,7 +52,9 @@ import { removeMemoryIntegration } from "./memory-uninstall.js";
 import { readEffectiveMemoryCapture, readMemoryCaptureChoice, writeMemoryCaptureChoice } from "../memory-capture-choice.js";
 import { envWithNodeRuntimeOnPath } from "../scheduled-self-update.js";
 import { probeMemoryDaemon } from "./memory-daemon-probe.js";
-import { expectedCodexTrustRows, readCodexHookTrustFromDisk, } from "./memory-install-codex-hooks.js";
+import { expectedCodexTrustRows, readCodexHookTrustFromDisk, readCodexManagedHooksFor, } from "./memory-install-codex-hooks.js";
+import { codexSystemHooksFileFor } from "./codex-managed-hooks.js";
+import { readCodexHooksTrustChoice } from "./codex-hooks-trust-choice.js";
 import { buildMemoryInstallReceipt, writeMemoryReceiptFile, } from "./memory-install-receipt.js";
 import { getCollectorRuntimePaths } from "../local-state.js";
 import { aggregate, logMemoryOutcome, memoryOutcomeLines, resolveDashboardUrl } from "./memory-install-report.js";
@@ -128,8 +130,9 @@ export async function installMemoryIntegration(command, io, deps = {}) {
     const targets = [resolved.binTarget];
     // `no_bin_no_write`: with no resolved server there is nothing safe to
     // register, so not one file is opened. The bin target carries the reason.
+    const systemHooksFile = codexSystemHooksFileFor(deps.codexSystemHooksFile, platform, io.env);
     if (resolved.config) {
-        const host = { homeDir, config: resolved.config, dryRun: command.dryRun, io: fileIo };
+        const host = { homeDir, config: resolved.config, dryRun: command.dryRun, io: fileIo, systemHooksFile };
         targets.push(...(await installClaudeMemoryIntegration(host)));
         targets.push(...(await installCodexMemoryIntegration(host)));
     }
@@ -142,7 +145,7 @@ export async function installMemoryIntegration(command, io, deps = {}) {
     const outcome = {
         action: "install",
         ...(capture.ignored ? { opt_out_ignored: "opt_out_ignored_not_founder" } : {}),
-        ...(await readBackOutcome(targets, resolved, homeDir, fileIo)),
+        ...(await readBackOutcome(targets, resolved, homeDir, fileIo, systemHooksFile)),
     };
     logMemoryOutcome(outcome, platform);
     // The heartbeat reads the cache, not the machine — see the receipt module's
@@ -223,7 +226,10 @@ async function installWhileOptedOut(command, io, deps, scope) {
     return outcome;
 }
 /** What both `install` and `status` report once the targets are known: their verdict and the receipt. */
-async function readBackOutcome(targets, resolved, homeDir, fileIo) {
+async function readBackOutcome(targets, resolved, homeDir, fileIo, systemHooksFile) {
+    // BLI-24349: the managed copy and the person's "no" both shape `codex.hooks`.
+    const managed = resolved.config ? await readCodexManagedHooksFor({ config: resolved.config, io: fileIo, systemHooksFile }) : null;
+    const choice = await readCodexHooksTrustChoice(getCollectorRuntimePaths(homeDir));
     return {
         ...aggregate(targets),
         config_source: resolved.source,
@@ -235,6 +241,8 @@ async function readBackOutcome(targets, resolved, homeDir, fileIo) {
             binFound: resolved.config !== null,
             codexTrust: await codexTrustFor(homeDir, fileIo),
             expectedTrustRows: resolved.config ? expectedCodexTrustRows(resolved.config) : 0,
+            codexManaged: managed?.state ?? null,
+            codexTrustDeclined: choice.choice === "declined",
         }),
     };
 }
@@ -274,8 +282,9 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
     // Without a resolved server there is no shape to compare the stored config
     // against, so `status` says the one true thing — the server is not here —
     // rather than reporting four targets against a shape we invented.
+    const systemHooksFile = codexSystemHooksFileFor(deps.codexSystemHooksFile, platform, io.env);
     if (resolved.config) {
-        const host = { homeDir, config: resolved.config, io: fileIo };
+        const host = { homeDir, config: resolved.config, io: fileIo, systemHooksFile };
         targets.push(...(await inspectClaudeMemoryIntegration(host)));
         targets.push(...(await inspectCodexMemoryIntegration(host)));
     }
@@ -302,7 +311,7 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
         // bounded, it opens nothing but a local socket, and a machine without one
         // is reported as exactly that rather than as a problem.
         daemon: await probeMemoryDaemon({ ...(homeDir ? { homeDir } : {}) }),
-        ...(await readBackOutcome(targets, resolved, homeDir, fileIo)),
+        ...(await readBackOutcome(targets, resolved, homeDir, fileIo, systemHooksFile)),
     };
     // `status` is a pure read and its reading is exactly as good as an install's
     // — both re-parse the stored files — so it refreshes the cache too. A person

package/dist/commands/memory-log.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { appendExperience, drainExperiences, shipExperience, validateExperience } from "@bli-cockpit/telemetry-core/memory-experience";
+import { appendExperience, drainExperiences, normaliseExperienceStore, shipExperience, validateExperience } from "@bli-cockpit/telemetry-core/memory-experience";
 import { readPipedText, writeLine } from "./cli-io.js";
 import { callTower, openTower } from "./tower-command.js";
 function sender(command, io) {
@@ -25,7 +25,18 @@ export async function runMemoryLog(command, io) {
         ? (await readPipedText(io.stdin, { maxChars: 1002 })).trim()
         : command.reason;
     validateExperience(command.store, command.verdict, reason);
-    const entry = await appendExperience({ store: command.store, verdict: command.verdict, reason }, {
+    // BLI-24380: BLI Memory is the only store. A retired store is accepted and
+    // logged (the normaliser logs the line); `supermemory` records nothing.
+    const store = normaliseExperienceStore(command.store);
+    if (store.store === null) {
+        const receipt = { ok: true, recorded: false, reason: store.reason, given: store.given };
+        writeLine(io.stderr, `[memory experience] not recorded ${JSON.stringify(receipt)}`);
+        writeLine(io.stdout, command.json
+            ? JSON.stringify(receipt)
+            : "Not recorded: Supermemory is retired (store_retired). BLI Memory is the only store; use --store bli.");
+        return 0;
+    }
+    const entry = await appendExperience({ store: store.store, verdict: command.verdict, reason }, {
         homeDir: command.homeDir,
         agent: "cockpit",
         project: path.basename(process.cwd()),

package/dist/commands/memory-map.js

@@ -14,7 +14,7 @@ export async function runMemoryMap(door) {
     if (!answer.ok)
         return failAgentDoor(door, "[memory map cli]", answer.reason, answer.detail);
     const body = answer.body;
-    writeLine(door.io.stderr, `[memory map cli] answered ${JSON.stringify({ reason: body.capped ? "capped" : "exhausted", examined: body.examined, total: body.total })}`);
+    writeLine(door.io.stderr, `[memory map cli] answered ${JSON.stringify({ reason: body.capped ? "capped" : "exhausted", examined: body.examined, total: body.total, total_source: body.totalSource ?? null })}`);
     if (door.json)
         return emitAgentDoor(door, body);
     for (const project of body.projects) {
@@ -22,7 +22,11 @@ export async function runMemoryMap(door) {
         for (const topic of project.topics)
             writeLine(door.io.stdout, `  ${topic.label}: ${topic.count}${topic.averageImportance === null ? " (unscored)" : ` (importance ${Math.round(topic.averageImportance)}/100)`}`);
     }
-    writeLine(door.io.stdout, `${body.examined} of ${body.total} visible memories counted; as of ${body.computedAt}.${body.capped ? " Scan capped at 10,000." : ""}`);
+    // BLI-24124: the total is the stored count with its time, or the rows read when none is stored (an older server sends neither field).
+    // BLI-24122: a server that sends `words` is printed as-is, so the page, this command and MCP say one thing.
+    const totalAge = body.totalSource === "stored_count" && body.totalAsOf ? ` Total counted ${body.totalAsOf}.`
+        : body.totalSource === "rows_read" ? " No stored total yet, so the total is the memories read." : "";
+    writeLine(door.io.stdout, body.words ?? `${body.total.toLocaleString("en-US")} visible memories; the map draws ${body.examined.toLocaleString("en-US")} of them; as of ${body.computedAt}.${totalAge}`);
     if (!body.projects.length)
         writeLine(door.io.stdout, "No project knowledge yet.");
     return 0;

package/dist/commands/memory-verb-list.js

@@ -55,7 +55,7 @@ const VERB_LIST_LINES = [
     "  cockpit memory status [--json]                read the stored config back",
     "",
     "The experience log:",
-    "  cockpit memory log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"",
+    "  cockpit memory log <win|loss|noise> [--store bli] \"<reason>\"",
     "",
     "Search: --limit caps the MEMORIES (default 5, at most 20). Up to 3 Tower pages and",
     "tickets ride beside them whatever --limit says; for more, use `cockpit search`.",

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.290");
+    writeLine(io?.stdout ?? process.stdout, "0.2.292");
     return 0;
   }
 

package/dist/commands/setup-receipt-lines.js

@@ -9,7 +9,7 @@
  * refusal that does not say what to do next is half a message. Every gap here
  * gets ONE command or ONE click, never a paragraph and never "see the docs".
  */
-import { CODEX_HOOKS_TRUST_GUIDE_URL, setupPieceMark, setupReceiptLine, setupReceiptPieces, } from "@bli-cockpit/telemetry-core";
+import { codexHooksTrustAction, setupPieceMark, setupReceiptLine, setupReceiptPieces, } from "@bli-cockpit/telemetry-core";
 /** Cached host facts are old after the same seven-day window as their readers. */
 const OLD_READING_MS = 7 * 24 * 60 * 60 * 1000;
 /** The one fix for each piece, by key. Present for every key the block prints. */
@@ -40,12 +40,6 @@ const REASON_FIXES = {
 };
 /** Codex hooks a person switched OFF is a decision, not a fault. */
 const UNSUPPORTED_FIX = "Switched off in your own config; nothing to do.";
-/**
- * The one exception to "a gap gets a command": Codex hooks that are installed
- * and waiting to be trusted are finished by a PERSON, in the Codex UI, and no
- * command we could print would do it.
- */
-const NEEDS_TRUST_FIX = `Open Codex and press \`/hooks\` to trust them (once, ~15s). Step by step: ${CODEX_HOOKS_TRUST_GUIDE_URL}`;
 /**
  * The block a terminal prints: the one line, then one fix per gap, then
  * nothing. A fully connected machine gets one line and no advice — a receipt
@@ -81,7 +75,7 @@ export function setupReceiptText(reading, options = {}) {
 }
 function fixFor(key, piece) {
     if (piece.status === "needs_trust")
-        return NEEDS_TRUST_FIX;
+        return codexHooksTrustAction(piece.reason);
     if (piece.status === "unsupported")
         return UNSUPPORTED_FIX;
     if (piece.status === "unknown") {

package/dist/raw-evidence-staging.js

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { bookkeepingRead, bookkeepingWrite } from "./bookkeeping-session.js";
 import { describeError, isMissingFileFailure } from "./health-detail.js";
+import { dropEmptyObjectRecords } from "./raw-evidence-stuck-summary.js";
 /**
  * Durable local state for raw-evidence STAGING and DELIVERY ATTEMPTS.
  *
@@ -29,7 +30,7 @@ import { describeError, isMissingFileFailure } from "./health-detail.js";
 // BLI-4022. The stuck/held summary moved to its own sibling so this file
 // stays under the readability band; it is still importable from here,
 // which is the address every caller already knows.
-export { summarizeStuckEvidence, } from "./raw-evidence-stuck-summary.js";
+export { summarizeStuckEvidence } from "./raw-evidence-stuck-summary.js";
 export const RAW_EVIDENCE_STAGING_FILENAME = "raw-evidence-staging.json";
 /**
  * Backoff schedule for an object whose delivery keeps failing.
@@ -75,6 +76,7 @@ async function readStagingFromDisk(stateDir) {
         const raw = JSON.parse(await fs.readFile(rawEvidenceStagingStatePath(stateDir), "utf8"));
         const state = parseStagingState(raw);
         resetStorage403ForEncoding(state);
+        dropEmptyObjectRecords(state);
         return state;
     }
     catch (error) {

package/dist/raw-evidence-stuck-summary.js

@@ -72,4 +72,29 @@ function summarizeLiveDeliveryAttempts(entries, ghostCount, now) {
         held_next_attempt_at: heldNextAttemptAt,
         held_last_reason: heldOldest?.last_reason ?? null,
     };
+}
+/**
+ * Forget the zero-byte objects an older collector staged. It offered them on every tick and the uploader refused each
+ * one with `empty_file`, which no retry can fix, so the fleet board read one as a stuck object for days (RED). The
+ * collector no longer stages an empty transcript (`adapters/raw-evidence-transcript-file.ts`); this clears what already
+ * sits in the history so the machine stops reporting it. The empty file itself is left for the ordinary staging prune.
+ */
+export function dropEmptyObjectRecords(state) {
+    let dropped = 0;
+    for (const [hash, entry] of Object.entries(state.staged)) {
+        if (entry.byte_size !== 0)
+            continue;
+        delete state.staged[hash];
+        dropped += 1;
+    }
+    for (const [hash, entry] of Object.entries(state.delivery_attempts)) {
+        if (entry.last_reason !== "empty_file")
+            continue;
+        delete state.delivery_attempts[hash];
+        dropped += 1;
+    }
+    if (dropped > 0) {
+        console.error("[raw-evidence-staging] empty objects forgotten, nothing in them can be delivered", JSON.stringify({ reason: "empty_file_records_dropped", records_dropped: dropped }));
+    }
+    return dropped;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.290",
+  "version": "0.2.292",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.89",
-    "@bli-cockpit/mcp": "0.1.176",
-    "@bli-cockpit/telemetry-core": "0.1.95",
+    "@bli-cockpit/memory-mcp": "0.1.90",
+    "@bli-cockpit/mcp": "0.1.177",
+    "@bli-cockpit/telemetry-core": "0.1.96",
     "unpdf": "1.8.1"
   },
   "repository": {