failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/src/hooks/delivery-health.ts

@@ -28,6 +28,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 import { failedDir } from "./fp-home";
+import { readCredentials } from "./fp-config";
 
 /**
  * Mirrors `POISON_SUFFIX` in `crates/fpai-collect/src/uploader.rs`. Kept as its
@@ -122,7 +123,11 @@ const EMPTY: DeliveryHealth = {
  * A missing directory is the healthy case on a machine that has never had a
  * batch refused, not an error — the collector creates it lazily.
  */
-export function deliveryHealth(home?: string, now: number = Date.now()): DeliveryHealth {
+export function deliveryHealth(
+  home?: string,
+  now: number = Date.now(),
+  connectedAt: number | undefined = home ? undefined : readCredentials().connectedAt,
+): DeliveryHealth {
   const dir = failedDir(home);
   if (!existsSync(dir)) return EMPTY;
 
@@ -144,21 +149,27 @@ export function deliveryHealth(home?: string, now: number = Date.now()): Deliver
   for (const name of entries) {
     // `.tmp` files are half-written renames, not parked batches.
     if (!name.includes(".jsonl")) continue;
-    total += 1;
-
     const parsed = parseParkedName(name);
+    let mtime: number;
+    try {
+      mtime = statSync(join(dir, name)).mtimeMs;
+    } catch {
+      continue; // Delivered or renamed during the scan.
+    }
+    if (
+      connectedAt !== undefined &&
+      parsed.clientStatus !== undefined &&
+      CREDENTIAL_STATUSES.has(parsed.clientStatus) &&
+      mtime < connectedAt
+    ) continue;
+    total += 1;
     if (parsed.clientStatus !== undefined) {
       rejected += 1;
       byStatus[parsed.clientStatus] = (byStatus[parsed.clientStatus] ?? 0) + 1;
       if (CREDENTIAL_STATUSES.has(parsed.clientStatus)) credentialRejected += 1;
     }
 
-    try {
-      const mtime = statSync(join(dir, name)).mtimeMs;
-      if (oldestMtime === undefined || mtime < oldestMtime) oldestMtime = mtime;
-    } catch {
-      // Vanished mid-scan — the collector just drained or renamed it.
-    }
+    if (oldestMtime === undefined || mtime < oldestMtime) oldestMtime = mtime;
   }
 
   return {

package/src/hooks/fp-config.ts

@@ -36,6 +36,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname } from "node:path";
+import { writeJsonAtomically } from "../../lib/atomic-write";
 import { version as cliVersion } from "../../package.json";
 import {
   LAYOUT_VERSION,
@@ -842,6 +843,8 @@ export function isAgentTraced(id: string, config: FpConfig = readConfig()): bool
 // ── credentials.json ─────────────────────────────────────────────────────────
 
 export interface FpCredentials {
+  /** Successful connection time, epoch milliseconds; resets stale refusal status. */
+  connectedAt?: number;
   cloud?: { url: string; machineId: string; token: string; machineLabel?: string };
   /**
    * Which organisation this machine's credentials report into, as the server
@@ -858,7 +861,7 @@ export interface FpCredentials {
    * the one a key pasted from the wrong org gets silently wrong. Absent against
    * a server predating introspect, and in files written by an older CLI.
    */
-  org?: { id?: string; slug?: string; name?: string };
+  org?: { id?: string; slug?: string; name?: string; since?: number };
   ingest?: { url: string; key: string };
   auth?: { baseUrl?: string; sessionToken?: string; expiresAt?: number; email?: string };
   /**
@@ -894,6 +897,7 @@ export interface JevCloudCredential {
  * only local answer to "where does this machine's data go?".
  */
 const OWNED_CREDENTIAL_KEYS: readonly (readonly string[])[] = [
+  ["connectedAt"],
   ["cloud", "url"],
   ["cloud", "machine_id"],
   ["cloud", "machine_label"],
@@ -901,6 +905,7 @@ const OWNED_CREDENTIAL_KEYS: readonly (readonly string[])[] = [
   ["org", "id"],
   ["org", "slug"],
   ["org", "name"],
+  ["org", "since"],
   ["ingest", "url"],
   ["ingest", "key"],
   ["jev", "url"],
@@ -950,6 +955,9 @@ export function projectCredentials(parsed: Record<string, unknown>): FpCredentia
     const ingest = parsed.ingest as Record<string, unknown> | undefined;
     const auth = parsed.auth as Record<string, unknown> | undefined;
     const out: FpCredentials = {};
+    if (typeof parsed.connectedAt === "number" && Number.isSafeInteger(parsed.connectedAt) && parsed.connectedAt >= 0) {
+      out.connectedAt = parsed.connectedAt;
+    }
     if (
       cloud &&
       typeof cloud.url === "string" &&
@@ -967,8 +975,10 @@ export function projectCredentials(parsed: Record<string, unknown>): FpCredentia
       // Every field independently optional: a server may send fewer than three,
       // and a partial org record is still better than none for `--status`.
       const pick = (v: unknown) => (typeof v === "string" && v ? v : undefined);
-      const built = { id: pick(org.id), slug: pick(org.slug), name: pick(org.name) };
-      if (built.id || built.slug || built.name) out.org = built;
+      const since = typeof org.since === "number" && Number.isSafeInteger(org.since) && org.since >= 0
+        ? org.since : undefined;
+      const built = { id: pick(org.id), slug: pick(org.slug), name: pick(org.name), ...(since !== undefined ? { since } : {}) };
+      if (built.id || built.slug || built.name || since !== undefined) out.org = built;
     }
     if (ingest && typeof ingest.url === "string" && typeof ingest.key === "string" && ingest.url && ingest.key) {
       out.ingest = { url: ingest.url, key: ingest.key };
@@ -997,6 +1007,7 @@ export function projectCredentials(parsed: Record<string, unknown>): FpCredentia
  */
 export function writeCredentials(creds: FpCredentials, raw?: Record<string, unknown>): void {
   const out: Record<string, unknown> = {};
+  if (creds.connectedAt !== undefined) out.connectedAt = creds.connectedAt;
   if (creds.cloud) {
     out.cloud = {
       url: creds.cloud.url,
@@ -1011,11 +1022,12 @@ export function writeCredentials(creds: FpCredentials, raw?: Record<string, unkn
   if (creds.jev) {
     out.jev = { url: creds.jev.url, key: creds.jev.key };
   }
-  if (creds.org && (creds.org.id || creds.org.slug || creds.org.name)) {
+  if (creds.org && (creds.org.id || creds.org.slug || creds.org.name || creds.org.since !== undefined)) {
     out.org = {
       ...(creds.org.id ? { id: creds.org.id } : {}),
       ...(creds.org.slug ? { slug: creds.org.slug } : {}),
       ...(creds.org.name ? { name: creds.org.name } : {}),
+      ...(creds.org.since !== undefined ? { since: creds.org.since } : {}),
     };
   }
   if (creds.auth && (creds.auth.sessionToken || creds.auth.email)) {
@@ -1041,7 +1053,7 @@ export function writeCredentials(creds: FpCredentials, raw?: Record<string, unkn
   } catch {
     // Not fatal: the file's own 0600 is the primary protection.
   }
-  writeFileSync(credentialsFile(), `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+  writeJsonAtomically(credentialsFile(), merged);
   try {
     chmodSync(credentialsFile(), 0o600);
   } catch {

package/src/hooks/fp-home.ts

@@ -141,7 +141,7 @@ export const configFile = (home?: string) => atHome(home, "config.json");
 
 export const otelAgentStateDir = (home?: string) => atHome(home, "state", "otel-agents");
 export const otelAgentStateFile = (agent: string) => {
-  if (!["claude", "codex", "gemini", "copilot"].includes(agent)) throw new Error("Unknown OTEL agent.");
+  if (!["claude", "codex", "copilot"].includes(agent)) throw new Error("Unknown OTEL agent.");
   return resolve(otelAgentStateDir(), `${agent}.json`);
 };
 export const otlpSpoolDir = (home?: string) => atHome(home, "state", "spool-otlp");

package/src/hooks/integrations.ts

@@ -26,6 +26,7 @@ import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { parseDocument, type Document } from "yaml";
 import { writeConfigFileAtomic } from "./safe-config-write";
+import { codexSystemHooksPresent, type CodexSystemHookEntry } from "./codex-system-hooks";
 import { listHermesProfiles, hermesRoot } from "../../lib/hermes-profiles";
 import { listOpenClawProfiles } from "../../lib/openclaw-profiles";
 import {
@@ -527,6 +528,9 @@ export const codex: Integration = {
   },
 
   hooksInstalledInSettings(scope, cwd) {
+    // User scope may live in Codex's system config instead (see
+    // ./codex-system-hooks): Codex runs hooks from there without trust.
+    if (scope === "user" && codexSystemHooksPresent()) return true;
     const settingsPath = this.getSettingsPath(scope, cwd);
     if (!existsSync(settingsPath)) return false;
     try {
@@ -550,6 +554,18 @@ export const codex: Integration = {
   },
 };
 
+/**
+ * failproofai's user-scope Codex hooks, as the system config holds them: the
+ * same events, commands and timeouts `codex.buildHookEntry` writes to
+ * `~/.codex/hooks.json`.
+ */
+export function codexSystemHookEntries(binaryPath: string): CodexSystemHookEntry[] {
+  return CODEX_HOOK_EVENT_TYPES.map((eventType) => {
+    const entry = codex.buildHookEntry(binaryPath, eventType, "user") as { command: string; timeout: number };
+    return { event: CODEX_EVENT_MAP[eventType as CodexHookEventType], command: entry.command, timeout: entry.timeout };
+  });
+}
+
 // ── GitHub Copilot CLI integration ──────────────────────────────────────────
 //
 // Copilot CLI accepts two hook payload formats: a camelCase native form and a

package/src/hooks/manager.ts

@@ -14,7 +14,14 @@ import { INTEGRATION_TYPES,
   type HookScope,
   type IntegrationType,
 } from "./types";
-import { claudeCode, getIntegration, settingsPathsFor, type Integration } from "./integrations";
+import { claudeCode, codexSystemHookEntries, getIntegration, settingsPathsFor, type Integration } from "./integrations";
+import {
+  CODEX_UNTRUSTED_NOTICE,
+  codexHookTrust,
+  installCodexSystemHooks,
+  removeCodexSystemHooks,
+  type CodexSystemInstall,
+} from "./codex-system-hooks";
 import { configuredCustomPolicyPaths, readMergedHooksConfig, readScopedHooksConfig, writeScopedHooksConfig, syncConventionPolicies, findProjectConfigDir } from "./hooks-config";
 import type { HooksConfig, ConventionPolicyRecord } from "./policy-types";
 import { BUILTIN_POLICIES } from "./builtin-policies";
@@ -815,8 +822,24 @@ async function installHooksImpl(
 
   // Write hooks for each selected CLI
   const writtenSettingsPaths: { cli: IntegrationType; path: string }[] = [];
+  // Why Codex's user-scope hooks went to hooks.json rather than its system config.
+  let codexFallback: CodexSystemInstall | null = null;
   for (const cliId of selectedClis) {
     const integration = getIntegration(cliId);
+    // Codex runs a hooks.json hook only once a person has trusted it, so a
+    // headless `codex exec` skips every one of ours. Its system config is
+    // trusted as managed: put user-scope hooks there whenever root allows, and
+    // take them out of hooks.json so a trusted copy does not run them twice.
+    if (cliId === "codex" && scope === "user") {
+      const placed = installCodexSystemHooks(codexSystemHookEntries(binaryPath));
+      if (placed.ok) {
+        const userPath = integration.getSettingsPath("user", cwd);
+        if (existsSync(userPath)) integration.removeHooksFromFile(userPath);
+        writtenSettingsPaths.push({ cli: cliId, path: placed.path });
+        continue;
+      }
+      codexFallback = placed;
+    }
     // Usually one path; Hermes returns one per profile (each is a separate home
     // dir with its own config.yaml, and a missed one runs unhooked in silence).
     const settingsPaths = settingsPathsFor(integration, scope, cwd);
@@ -907,6 +930,17 @@ async function installHooksImpl(
   }
   if (scope === "project") console.log(`${INDENT}This file can be committed to git: it has no machine-specific paths.`);
 
+  // Codex on hooks.json: say so when Codex will not run them yet.
+  if (codexFallback && !codexFallback.ok) {
+    if (codexFallback.reason === "conflict" || codexFallback.reason === "unreadable" || codexFallback.reason === "write-failed") {
+      console.log(
+        kit.caution(`Couldn't add the Codex hooks to ${codexFallback.path}: ${codexFallback.detail ?? codexFallback.reason}.`),
+      );
+    }
+    const trust = codexHookTrust();
+    if (trust.kind === "untrusted") for (const line of kit.notice("caution", CODEX_UNTRUSTED_NOTICE)) console.log(line);
+  }
+
   // Warn about duplicate-scope installations (Claude Code only — uses HOOK_SCOPES)
   const otherScopes = deduplicateScopes(HOOK_SCOPES, cwd).filter((s) => s !== scope);
   const duplicates = otherScopes.filter((s) => hooksInstalledInSettings(s, cwd));
@@ -1060,6 +1094,30 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
           : [];
 
     for (const s of scopesToRemove) {
+      // Codex's user-scope hooks may be in its system config (see
+      // ./codex-system-hooks). Taken out first: a machine with no hooks.json
+      // still has them there.
+      let removedFromSystem = 0;
+      if (cliId === "codex" && s === "user") {
+        const system = removeCodexSystemHooks();
+        if (system.status === "removed") {
+          removedFromSystem = system.hooks;
+          if (scope !== "all") {
+            say(screenKit(optsFor(process.stdout)).ok(`Removed ${system.hooks} failproofai ${system.hooks === 1 ? "hook" : "hooks"} from Codex's system config.`));
+            for (const line of screenKit(optsFor(process.stdout)).kv([["settings", system.path]])) say(line);
+          }
+        } else if (system.status === "failed") {
+          // Non-interactive by design (this also runs from the dashboard), so
+          // the fix is to prime sudo and come back.
+          for (const line of screenKit(optsFor(process.stdout)).notice(
+            "caution",
+            `failproofai's Codex hooks are still in ${system.path}: ${system.reason}.\n` +
+              "Run  `sudo -v`,  then this command again.",
+          )) {
+            say(line);
+          }
+        }
+      }
       // Usually one path; Hermes returns one per profile.
       const settingsPaths = settingsPathsFor(integration, s, cwd);
       // A Hermes install copies its managed plugin before updating config.yaml.
@@ -1069,6 +1127,8 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
         cliId === "hermes" ? settingsPaths : settingsPaths.filter((p) => existsSync(p));
 
       if (existing.length === 0) {
+        totalRemoved += removedFromSystem;
+        if (removedFromSystem > 0) continue;
         if (scope !== "all" && selectedClis.length === 1) {
           say(screenKit(optsFor(process.stdout)).ok("No settings file found, so there is nothing to remove."));
           nothingToReport = true;
@@ -1076,7 +1136,7 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
         continue;
       }
 
-      let removedHere = 0;
+      let removedHere = removedFromSystem;
       for (const settingsPath of existing) {
         const removed = integration.removeHooksFromFile(settingsPath);
         removedHere += removed;

package/src/hooks/otel-cli.ts

@@ -4,11 +4,11 @@ import {
   statSync, unlinkSync, writeFileSync,
 } from "node:fs";
 import { dirname } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { connect } from "node:net";
 import { readConfig, readCredentials } from "./fp-config";
-import { configFile, otelAgentStateFile, otlpHealthFile } from "./fp-home";
+import { collectorHealthFile, configFile, otelAgentStateFile, otlpHealthFile } from "./fp-home";
 import { writeConfigFileAtomic } from "./safe-config-write";
 import { agentSessionsEnabled } from "./collector-config";
 import { introspectKey } from "./cloud-introspect";
@@ -21,7 +21,6 @@ import {
 } from "./otel-writers";
 
 export const OTEL_ORG_OFF = "OTEL ingest is off for your org. An admin can turn it on in Settings → OpenTelemetry.";
-export const OTEL_WIZARD_QUESTION = "Also send OpenTelemetry from agents? (Gemini CLI, Copilot, or switch Claude Code / Codex)";
 export interface OtelResult {
   lines: string[];
   exitCode: number;
@@ -47,6 +46,7 @@ export interface OtelOptions {
   fetchImpl?: typeof fetch;
   confirm?: (question: string) => Promise<boolean>;
   onEvent?: (name: string, properties: { agent: OtelAgent; local: boolean; content: boolean }) => void | Promise<void>;
+  waitForCollector?: (generation: string, timeoutMs: number) => Promise<boolean>;
 }
 
 function rawConfig(): JsonObject {
@@ -66,6 +66,24 @@ function saveConfig(raw: JsonObject): void {
 function digest(text: string): string {
   return createHash("sha256").update(text).digest("hex");
 }
+function collectorWaitMs(): number {
+  const configured = Number(process.env.FAILPROOFAI_COLLECTOR_CONFIG_POLL_MS ?? 5000);
+  return 2 * Math.max(500, Number.isSafeInteger(configured) && configured >= 0 ? configured : 5000);
+}
+export async function waitForCollectorConfig(generation: string, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    try {
+      const health = JSON.parse(readFileSync(collectorHealthFile(), "utf8")) as JsonObject;
+      // An old deployment cannot acknowledge a newly generated token. The
+      // replacement publishes it only after the old tasks have been joined.
+      if (health.config_generation === generation && typeof health.ts === "number" &&
+          Date.now() - health.ts * 1000 < 35000) return true;
+    } catch { /* Missing health, an older daemon or a file mid-replacement. */ }
+    await new Promise(resolve => setTimeout(resolve, Math.min(100, Math.max(0, deadline - Date.now()))));
+  } while (Date.now() < deadline);
+  return false;
+}
 function privateState(agent: OtelAgent): PrivateState {
   return JSON.parse(readFileSync(otelAgentStateFile(agent), "utf8")) as PrivateState;
 }
@@ -104,7 +122,7 @@ function hasExternalOtel(agent: OtelAgent, config: JsonObject): boolean {
       return value !== undefined && value !== "none" && value !== "statsig";
     });
   }
-  return getSetting(config, agent === "gemini" ? ["telemetry", "enabled"] : ["github.copilot.chat.otel.enabled"]) === true;
+  return getSetting(config, ["github.copilot.chat.otel.enabled"]) === true;
 }
 async function defaultConfirm(question: string): Promise<boolean> {
   return await selectOne({
@@ -115,11 +133,6 @@ async function defaultConfirm(question: string): Promise<boolean> {
     ],
   }) === true;
 }
-export async function chooseWizardOtel(
-  choose: (question: string) => Promise<boolean> = defaultConfirm,
-): Promise<boolean> {
-  return choose(OTEL_WIZARD_QUESTION);
-}
 function restoreAgent(agent: OtelAgent, raw: JsonObject): void {
   const all = records(raw);
   const record = all[agent];
@@ -135,12 +148,18 @@ function restoreAgent(agent: OtelAgent, raw: JsonObject): void {
       writeConfigFileAtomic(record.file, restored, { backup: false, mode: state.originalMode });
     }
   }
-  if (record.switchedSessions) {
+  if (record.switchedSessions || agent === "codex") {
     const collector = object(raw.collector);
     const agents = object(collector.agents);
     const settings = object(agents[agent]);
-    if (record.previousSessions === undefined) delete settings.sessions;
-    else settings.sessions = record.previousSessions;
+    if (record.switchedSessions) {
+      if (record.previousSessions === undefined) delete settings.sessions;
+      else settings.sessions = record.previousSessions;
+    }
+    // Rollouts produced while OTEL owned delivery must not be uploaded again
+    // when the transcript task is restarted. Keep a cursor so later appends
+    // to those same files still flow.
+    if (agent === "codex") settings.sessions_resume_after = Date.now();
     if (Object.keys(settings).length) agents[agent] = settings;
     else delete agents[agent];
     if (Object.keys(agents).length) collector.agents = agents;
@@ -158,22 +177,26 @@ async function enableAgent(agent: OtelAgent, yes: boolean, localFlag: boolean, c
     return { lines: ["VS Code not found — skipping copilot"], exitCode: 0 };
   }
   const existing = records(raw)[agent];
-  // Gemini has no transcript source in this collector.
-  const transcriptsEnabled = agent !== "gemini" && agentSessionsEnabled(agent);
+  const transcriptsEnabled = agentSessionsEnabled(agent);
   if (!existing && transcriptsEnabled && !yes) {
     const question = `failproofai already sends ${AGENT_LABELS[agent]} sessions to Cloud. Send them with OTEL instead? Transcript upload for ${AGENT_LABELS[agent]} stops.`;
     if (!await (options.confirm ?? defaultConfirm)(question)) return { lines: [`${AGENT_LABELS[agent]} unchanged (default No).`], exitCode: 0 };
   }
-  const local = localFlag || agent === "gemini" || agent === "copilot";
+  const local = localFlag || agent === "copilot";
   const port = readConfig().collector.otlp?.port ?? 4318;
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("collector.otlp.port must be between 1 and 65535.");
   const destination = local ? `http://127.0.0.1:${port}` : origin;
   const original = existsSync(file) ? readFileSync(file, "utf8") : null;
   const parsed = parseAgentConfig(original ?? "", agent);
-  const writes = agentOtelWrites(agent, destination, key, local, content);
+  const oldState = existing ? privateState(agent) : null;
+  // Our own --no-content write is not a new user opt-out. An unchanged
+  // managed file inherits the user's original content preference.
+  const privacyConfig = oldState && original !== null && digest(original) === oldState.writtenHash
+    ? parseAgentConfig(oldState.original ?? "", agent) : parsed;
+  const writes = agentOtelWrites(agent, destination, key, local, content, privacyConfig);
+  const keptPromptPrivacy = agent === "codex" && getSetting(privacyConfig, ["otel", "log_user_prompt"]) === false;
   // Switching from Cloud to local stops owning header keys. Restore any keys
   // from an earlier enable before applying the new (header-free) write set.
-  const oldState = existing ? privateState(agent) : null;
   const released = oldState?.previous.filter(previous =>
     !writes.some(write => JSON.stringify(write.path) === JSON.stringify(previous.path))) ?? [];
   const next = editAgentConfig(original ?? "", agent, [...released, ...writes]);
@@ -217,6 +240,10 @@ async function enableAgent(agent: OtelAgent, yes: boolean, localFlag: boolean, c
   otel.agents = { ...records(raw), [agent]: record };
   raw.otel = otel;
   configureRelay(raw);
+  const waitForCollector = agent === "codex";
+  const generation = randomUUID();
+  if (waitForCollector) collector.config_generation = generation;
+  const lines: string[] = [];
   // Recovery state and one-time backup precede the first agent-file write.
   backupOnce(file, original);
   savePrivate(agent, { ...state, writtenHash: digest(next) });
@@ -224,6 +251,9 @@ async function enableAgent(agent: OtelAgent, yes: boolean, localFlag: boolean, c
     // Publish ownership BEFORE the agent settings so a killed CLI can always
     // disable/restore what it wrote, including the one-path transcript choice.
     saveConfig(raw);
+    if (waitForCollector && !await (options.waitForCollector ?? waitForCollectorConfig)(generation, collectorWaitMs())) {
+      lines.push("Warning: daemon did not confirm the collector change in time; wait for `failproofai otel status` before starting Codex to avoid duplicate uploads.");
+    }
     writeConfigFileAtomic(file, next, { backup: false, mode: 0o600 });
     // Agent files now contain a credential, even if previously world-readable.
     chmodSync(file, 0o600);
@@ -233,7 +263,8 @@ async function enableAgent(agent: OtelAgent, yes: boolean, localFlag: boolean, c
     saveConfig(previousConfig);
     throw err;
   }
-  const lines = [`${AGENT_LABELS[agent]} OTEL enabled → ${local ? "local relay" : "Cloud"} (${content ? "text capture on" : "no content"}).`];
+  lines.push(`${AGENT_LABELS[agent]} OTEL enabled → ${local ? "local relay" : "Cloud"} (${content ? "text capture on" : "no content"}).`);
+  if (keptPromptPrivacy) lines.push("Codex log_user_prompt = false kept; user prompt capture remains off.");
   if (local && !localFlag) lines.push(`${AGENT_LABELS[agent]} settings cannot carry an auth header; using the local relay automatically.`);
   if (local) lines.push("The daemon picks this up within seconds — no restart. Use `failproofai otel status` to check the relay.");
   const result = await introspectKey(origin, key, options.fetchImpl, 3000);
@@ -273,13 +304,13 @@ async function status(options: OtelOptions): Promise<OtelResult> {
     if (record && on) {
       try {
         const state = privateState(agent);
+        const original = parseAgentConfig(state.original ?? "", agent);
         const expected = parseAgentConfig(editAgentConfig(state.original ?? "", agent,
-          agentOtelWrites(agent, record.destination, credential().key, record.local, record.content)), agent);
+          agentOtelWrites(agent, record.destination, credential().key, record.local, record.content, original)), agent);
         managed = record.keys.every(k => JSON.stringify(getSetting(parsed, k.path)) === JSON.stringify(getSetting(expected, k.path)));
       } catch { /* Missing recovery state or key. */ }
     }
     const dest = record?.destination ?? getSetting(parsed, agent === "claude" ? ["env", "OTEL_EXPORTER_OTLP_ENDPOINT"] :
-      agent === "gemini" ? ["telemetry", "otlpEndpoint"] :
       agent === "copilot" ? ["github.copilot.chat.otel.otlpEndpoint"] : ["otel", "exporter", "otlp-http", "endpoint"]);
     const destination = dest ? `${record?.local ? "local relay" : "Cloud"} (${dest})` : "none";
     lines.push(`${AGENT_LABELS[agent]}: ${unreadable ? "unreadable settings" : on ? managed ? "on by failproofai" : "on, not managed" : "off"} · destination: ${destination} · org: ${org}`);

package/src/hooks/otel-writers.ts

@@ -9,10 +9,10 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { accessSync, constants, readdirSync, statSync } from "node:fs";
 
-export const OTEL_AGENTS = ["claude", "codex", "gemini", "copilot"] as const;
+export const OTEL_AGENTS = ["claude", "codex", "copilot"] as const;
 export type OtelAgent = typeof OTEL_AGENTS[number];
 export const AGENT_LABELS: Record<OtelAgent, string> = {
-  claude: "Claude Code", codex: "Codex", gemini: "Gemini CLI", copilot: "Copilot",
+  claude: "Claude Code", codex: "Codex", copilot: "Copilot",
 };
 export type JsonObject = Record<string, unknown>;
 export interface SettingWrite { path: string[]; value?: unknown }
@@ -28,6 +28,24 @@ export function agentConfigPath(agent: OtelAgent, home = homedir()): string {
     resolve(home, `.${agent}`, agent === "codex" ? "config.toml" : "settings.json");
 }
 
+/**
+ * Fixed install locations checked after PATH. A mutable seam so tests can run
+ * on a machine that really has VS Code installed: these paths are system-wide,
+ * so no temp HOME or PATH hides them.
+ */
+export const vscodeProbe = {
+  appPaths(home: string, platform: NodeJS.Platform): string[] {
+    return platform === "darwin" ? [
+      "/Applications/Visual Studio Code.app/Contents/MacOS/Electron",
+      "/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron",
+      resolve(home, "Applications/Visual Studio Code.app/Contents/MacOS/Electron"),
+    ] : platform === "win32" ? [
+      resolve(process.env.LOCALAPPDATA ?? resolve(home, "AppData/Local"), "Programs/Microsoft VS Code/Code.exe"),
+      resolve(process.env.ProgramFiles ?? "C:/Program Files", "Microsoft VS Code/Code.exe"),
+    ] : ["/usr/share/code/code", "/opt/visual-studio-code/code"];
+  },
+};
+
 export function vscodeInstalled(home = homedir(), platform = process.platform): boolean {
   const executable = (path: string) => {
     try {
@@ -38,15 +56,7 @@ export function vscodeInstalled(home = homedir(), platform = process.platform):
   const names = platform === "win32" ? ["code.cmd", "code-insiders.cmd", "Code.exe", "Code - Insiders.exe"] : ["code", "code-insiders"];
   if ((process.env.PATH ?? "").split(platform === "win32" ? ";" : ":")
     .some(dir => names.some(name => executable(resolve(dir, name))))) return true;
-  const apps = platform === "darwin" ? [
-    "/Applications/Visual Studio Code.app/Contents/MacOS/Electron",
-    "/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron",
-    resolve(home, "Applications/Visual Studio Code.app/Contents/MacOS/Electron"),
-  ] : platform === "win32" ? [
-    resolve(process.env.LOCALAPPDATA ?? resolve(home, "AppData/Local"), "Programs/Microsoft VS Code/Code.exe"),
-    resolve(process.env.ProgramFiles ?? "C:/Program Files", "Microsoft VS Code/Code.exe"),
-  ] : ["/usr/share/code/code", "/opt/visual-studio-code/code"];
-  if (apps.some(executable)) return true;
+  if (vscodeProbe.appPaths(home, platform).some(executable)) return true;
   return [".vscode", ".vscode-insiders"].some(folder => {
     try {
       return readdirSync(resolve(home, folder, "extensions"), { withFileTypes: true })
@@ -176,7 +186,7 @@ export function editAgentConfig(text: string, agent: OtelAgent, writes: SettingW
   return next;
 }
 
-export function agentOtelWrites(agent: OtelAgent, endpoint: string, key: string, local: boolean, content: boolean): SettingWrite[] {
+export function agentOtelWrites(agent: OtelAgent, endpoint: string, key: string, local: boolean, content: boolean, config: JsonObject = {}): SettingWrite[] {
   const auth = local ? {} : { Authorization: `Bearer ${key}` };
   const env: JsonObject = {
     CLAUDE_CODE_ENABLE_TELEMETRY: "1",
@@ -201,14 +211,13 @@ export function agentOtelWrites(agent: OtelAgent, endpoint: string, key: string,
       endpoint: `${endpoint}/v1/${signal}`, protocol: "json", ...(!local ? { headers: auth } : {}),
     } });
     return Object.entries({
-      exporter: exporter("logs"), trace_exporter: exporter("traces"), metrics_exporter: exporter("metrics"),
-      log_user_prompt: content,
+      // Codex conversation content lives in logs. Runtime traces have no GenAI
+      // attributes and create empty sessions; the server discards metrics.
+      exporter: exporter("logs"),
+      log_user_prompt: getSetting(config, ["otel", "log_user_prompt"]) === false ? false : content,
       log_agent_responses: content,
     }).map(([k, value]) => ({ path: ["otel", k], value }));
   }
-  if (agent === "gemini") return Object.entries({
-    enabled: true, target: "local", otlpEndpoint: endpoint, otlpProtocol: "http", logPrompts: content, useCollector: true, outfile: undefined,
-  }).map(([k, value]) => ({ path: ["telemetry", k], value }));
   return Object.entries({
     enabled: true, exporterType: "otlp-http", otlpEndpoint: endpoint, captureContent: content,
   }).map(([k, value]) => ({ path: [`github.copilot.chat.otel.${k}`], value }));

package/src/hooks/uninstall-cli.ts

@@ -47,6 +47,7 @@ import {
 import { listInstallableIds, getIntegration } from "./integrations";
 import type { IntegrationType } from "./types";
 import { removeHooks } from "./manager";
+import { CODEX_MANAGED_BEGIN, CODEX_MANAGED_END, codexSystemConfigPath, codexSystemHooksPresent } from "./codex-system-hooks";
 import { optsFor, screenKit, type RenderOpts } from "./tui";
 
 export interface UninstallOptions {
@@ -109,6 +110,8 @@ export interface UninstallResult {
 /** Everything this machine has that uninstalling would remove. */
 interface Leftovers {
   clis: IntegrationType[];
+  /** failproofai's block in Codex's system config, which only root can remove. */
+  codexSystemPath: string | null;
   servicePath: string | null;
   serviceInstalled: boolean;
   daemonConfigured: boolean;
@@ -146,6 +149,7 @@ function survey(cwd?: string): Leftovers {
   const servicePath = isDaemonSupportedPlatform() ? daemonServiceFilePath() : null;
   return {
     clis,
+    codexSystemPath: codexSystemHooksPresent() ? codexSystemConfigPath() : null,
     servicePath,
     serviceInstalled: !!servicePath && existsSync(servicePath),
     daemonConfigured,
@@ -200,6 +204,7 @@ export async function runUninstallCommand(opts: UninstallOptions = {}): Promise<
   if (found.clis.length > 0) {
     details.push(
       `Agents: ${found.clis.map((id) => getIntegration(id).displayName ?? id).join(", ")}`,
+      ...(found.codexSystemPath ? [`Codex's hooks are in ${found.codexSystemPath}, so removing them needs sudo.`] : []),
       "Also resets enabled policies, custom policy paths and policy parameters in policies-config.json.",
     );
   }
@@ -271,6 +276,22 @@ export async function runUninstallCommand(opts: UninstallOptions = {}): Promise<
     }
   }
 
+  // Asked once, up front, for everything below that needs root: the Codex
+  // block in /etc and the service. Best-effort, like the service step: a
+  // refused prompt falls through to the "still there, do this" lines.
+  const elevate = opts.elevate ?? primeElevation;
+  let elevated = false;
+  const elevateOnce = (): void => {
+    if (elevated) return;
+    elevated = true;
+    try {
+      elevate();
+    } catch {
+      // `sudo -n` in the removal fails the same way it would have anyway.
+    }
+  };
+  if (found.codexSystemPath) elevateOnce();
+
   if (found.clis.length > 0) {
     try {
       // Scope "all" and every cli that HAS entries — the same list the plan
@@ -285,6 +306,12 @@ export async function runUninstallCommand(opts: UninstallOptions = {}): Promise<
         source: "uninstall_command",
         silent: true,
       });
+      if (found.codexSystemPath && codexSystemHooksPresent()) {
+        failures.push(
+          `failproofai's Codex hooks are still in ${found.codexSystemPath}, most often because sudo was not available.\n` +
+            `Remove the lines from  \`${CODEX_MANAGED_BEGIN}\`  to  \`${CODEX_MANAGED_END}\`  as root.`,
+        );
+      }
       lines.push(kit.ok(`Removed hooks from ${many(found.clis.length, "agent")}.`));
     } catch (err) {
       failures.push(
@@ -309,13 +336,7 @@ export async function runUninstallCommand(opts: UninstallOptions = {}): Promise<
     // in front of it, which is the same reasoning `failproofai update` follows.
     // Best-effort: a refused or absent sudo still falls through to the
     // "still there, here is what to run as root" path below.
-    const elevate = opts.elevate ?? primeElevation;
-    try {
-      elevate();
-    } catch {
-      // A failed prompt is not a reason to skip the attempt; `sudo -n` inside
-      // the removal will simply fail the same way it would have anyway.
-    }
+    elevateOnce();
     // What to run as root when the removal could not elevate, and where to look.
     const byHand = (servicePath: string): string =>
       "\nRemove it as root:\n" +

package/.next/standalone/.next/server/chunks/[externals]__1_9ze9b._.js

@@ -1,3 +0,0 @@
-module.exports=[874,(e,r,o)=>{r.exports=e.x("buffer",()=>require("buffer"))},60815,e=>{e.v(e=>Promise.resolve().then(()=>e(24868)))},1457,(e,r,o)=>{r.exports=e.x("node:readline",()=>require("node:readline"))},57764,(e,r,o)=>{r.exports=e.x("node:url",()=>require("node:url"))},5365,(e,r,o)=>{r.exports=e.x("process",()=>require("process"))},92509,(e,r,o)=>{r.exports=e.x("url",()=>require("url"))}];
-
-//# sourceMappingURL=%5Bexternals%5D__1_9ze9b._.js.map