@bli-cockpit/cli 0.2.291 → 0.2.293

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/codex-revision-facts.js

@@ -0,0 +1,64 @@
+/** Compare a composite revision with the SAME line/slim/redaction rules as upload. No raw bundle or network. */
+import { createHash } from "node:crypto";
+import { findEmbeddedImages, modeDropsImages, replaceImagesWithMarkers } from "@bli-cockpit/telemetry-core";
+import { imageStateKey } from "../image-description-state.js";
+import { openCodexSessionRevision } from "../adapters/codex-session-revision.js";
+import { createSlimmer } from "../slim/slim-transcript.js";
+import { scanLines, decideLinePlan, writeLinePlan } from "../adapters/raw-evidence-sanitize-lines.js";
+export function codexRevisionFacts(paths, mode, describedKeys, slimAware) {
+    const form = async (drop) => {
+        const source = await openCodexSessionRevision(paths);
+        try {
+            const lines = { async *lines() {
+                    const slimmer = createSlimmer("codex");
+                    for await (const line of source.lines()) {
+                        if (line.start === source.length)
+                            continue;
+                        let text = new TextDecoder("utf-8", { fatal: true }).decode(line.bytes);
+                        if (drop) {
+                            const images = findEmbeddedImages(text);
+                            text = replaceImagesWithMarkers(text, images, image => describedKeys.has(imageStateKey(image.sha256))).text;
+                            text = slimmer.slimLine(text);
+                        }
+                        yield text + "\n";
+                    }
+                } };
+            const options = { redactedFields: ["codex_jsonl.body"], secretLikeFileName: false };
+            const plan = decideLinePlan(await scanLines(lines, options), options);
+            if (plan.kind === "whole_mask" || plan.kind === "guard_line")
+                return null;
+            const hash = createHash("sha256");
+            let byte_size = 0;
+            const write = async (text) => { hash.update(text); byte_size += Buffer.byteLength(text); };
+            if (plan.kind === "clean") {
+                for await (const line of lines.lines())
+                    await write(line);
+            }
+            else
+                await writeLinePlan(lines, plan, options, write);
+            await source.verifyUnchanged();
+            return { sha256: hash.digest("hex"), byte_size };
+        }
+        finally {
+            await source.close();
+        }
+    };
+    let full, slim;
+    return {
+        slimAware,
+        async rawSha256() { const source = await openCodexSessionRevision(paths); try {
+            return source.sha256;
+        }
+        finally {
+            await source.close();
+        } },
+        wholeForm: () => full ??= form(false),
+        sanitized: () => modeDropsImages(mode) ? slim ??= form(true) : full ??= form(false),
+        async slimSplit() {
+            if (!slimAware)
+                return null;
+            const [a, b] = await Promise.all([full ??= form(false), slim ??= form(true)]);
+            return a && b && a.sha256 !== b.sha256 ? { full: a, slim: b } : null;
+        },
+    };
+}

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-args-notes-targets.js

@@ -0,0 +1,35 @@
+/**
+ * The `--to` readers of `cockpit notes`: `move --to "<shelf>"` and, since BLI-24437,
+ * `correct <id> --from "<misheard>" --to "<right>" [--transcript]`. Sibling of
+ * `local-args-tower-notes.ts`, which calls both; split out so that file stays a table of contents.
+ */
+import { optionalNonEmpty } from "./local-arg-values.js";
+export function readNotesShelfTarget(action, values) {
+    const to = optionalNonEmpty(values.flags.get("--to"));
+    const clearShelf = values.booleans.has("--clear-shelf");
+    if (action !== "move")
+        return { to, clearShelf };
+    if (to && clearShelf) {
+        throw new Error("notes move accepts either --to or --clear-shelf, not both.");
+    }
+    if (!to && !clearShelf && !values.flags.get("--folder")) {
+        throw new Error('notes move needs --to "<shelf>", --clear-shelf, or --folder "<path>".');
+    }
+    return { to, clearShelf };
+}
+/** BLI-24437: `correct` needs both terms; `--from` and `--transcript` mean nothing on any other verb. */
+export function readNotesCorrection(action, values) {
+    const from = optionalNonEmpty(values.flags.get("--from"));
+    const transcript = values.booleans.has("--transcript");
+    if (action !== "correct") {
+        if (from !== undefined)
+            throw new Error("--from belongs to `cockpit notes correct <note-id> --from <term> --to <term>`.");
+        if (transcript)
+            throw new Error("--transcript belongs to `cockpit notes correct <note-id> --from <term> --to <term> --transcript`.");
+        return {};
+    }
+    if (!from || !optionalNonEmpty(values.flags.get("--to"))) {
+        throw new Error('notes correct needs --from "<misheard term>" and --to "<right term>".');
+    }
+    return { from, ...(transcript ? { transcript: true } : {}) };
+}

package/dist/commands/local-args-tower-notes.js

@@ -7,6 +7,7 @@
  * address they have always had.
  */
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
+import { readNotesCorrection, readNotesShelfTarget } from "./local-args-notes-targets.js";
 /**
  * The notetakers `cockpit notes connect` will actually seal a key for
  * (BLI-4391). It mirrors `CONNECTABLE_NOTES_PROVIDERS` in the dashboard, and
@@ -34,7 +35,7 @@ const NOTES_ACTIONS = new Set([
     "upload",
     "paste",
     "share",
-    "unshare",
+    "unshare", "correct",
     "summarize",
     "move",
     "place",
@@ -61,7 +62,7 @@ const NOTES_ACTIONS = new Set([
 const NOTES_ACTIONS_NEEDING_A_NOTE = new Set([
     "show",
     "share",
-    "unshare",
+    "unshare", "correct",
     "summarize",
     "move",
     "place",
@@ -82,7 +83,7 @@ const NOTES_ALLOWED_FLAGS = [
     "--file",
     "--name",
     "--exclude",
-    "--to",
+    "--to", "--from", "--transcript", // BLI-24437: `correct <id> --from <term> --to <term> [--transcript]`
     "--folder",
     "--clear-shelf",
     "--apply",
@@ -122,7 +123,7 @@ const NOTES_VALUE_FLAGS = [
     "--file",
     "--name",
     "--exclude",
-    "--to",
+    "--to", "--from",
     "--folder",
     "--series",
     "--kind",
@@ -180,6 +181,7 @@ export function parseNotesArgs(args) {
         exclude: optionalNonEmpty(values.flags.get("--exclude")),
         ...(to ? { to } : {}),
         ...(clearShelf ? { clearShelf } : {}),
+        ...readNotesCorrection(action, values),
         // BLI-4058. `place` says where a note belongs; only `--apply` moves it.
         ...(values.booleans.has("--apply") ? { apply: true } : {}),
         series: optionalNonEmpty(values.flags.get("--series")),
@@ -201,7 +203,7 @@ function readNotesAction(first) {
     // almost always wants — same reasoning as bare `cockpit` running convergence.
     const action = (first === undefined ? "list" : first);
     if (!NOTES_ACTIONS.has(action)) {
-        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, summarize, move, place, accounts, connect, detach, sync, sync-status, recordings, recording, webhook, granola-status, transcription-stats, or review (and record start|stop|status|cancel, app install|uninstall|status).`);
+        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, correct, summarize, move, place, accounts, connect, detach, sync, sync-status, recordings, recording, webhook, granola-status, transcription-stats, or review (and record start|stop|status|cancel, app install|uninstall|status).`);
     }
     return action;
 }
@@ -368,19 +370,6 @@ function readNotesPaths(action, rest) {
     }
     return undefined;
 }
-function readNotesShelfTarget(action, values) {
-    const to = optionalNonEmpty(values.flags.get("--to"));
-    const clearShelf = values.booleans.has("--clear-shelf");
-    if (action !== "move")
-        return { to, clearShelf };
-    if (to && clearShelf) {
-        throw new Error("notes move accepts either --to or --clear-shelf, not both.");
-    }
-    if (!to && !clearShelf && !values.flags.get("--folder")) {
-        throw new Error('notes move needs --to "<shelf>", --clear-shelf, or --folder "<path>".');
-    }
-    return { to, clearShelf };
-}
 function readNotesMonth(action, values) {
     const month = optionalNonEmpty(values.flags.get("--month"));
     if (month === undefined)