cxstatusline 0.1.1 → 0.3.0

package/dist/cxstatusline.js

@@ -54793,7 +54793,7 @@ class SessionNameWidget {
 }
 // src/utils/terminal.ts
 import { execSync } from "child_process";
-var __dirname = "/Users/nemesis/Projects/my-projects/cxstatusline/src/utils";
+var __dirname = "/Users/runner/work/cxstatusline/cxstatusline/src/utils";
 function probeTerminalWidth() {
   const overrideRaw = process.env.CCSTATUSLINE_WIDTH;
   if (overrideRaw) {
@@ -57046,10 +57046,9 @@ async function runRender(stdin, deps) {
 `, code: 2 };
   }
 }
-
 // src/version-info.ts
-var VERSION = "0.1.1";
-var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("5a03216d4eae4d4565273e8206845658706dcb6b") ? "5a03216d4eae4d4565273e8206845658706dcb6b" : null;
+var VERSION = "0.3.0";
+var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("238a373fb9c429871859ab99d013fa69b456b23b") ? "238a373fb9c429871859ab99d013fa69b456b23b" : null;
 var SOURCE_DIRTY = false;
 
 // src/context.ts
@@ -57163,11 +57162,12 @@ function realContext(env3, io) {
   const deps = realDeps();
   const sccache = deps.which("sccache");
   const run = (cmd, args, opts) => {
+    const baseEnv = opts?.env ? { ...process.env, ...opts.env } : process.env;
     const r = spawnSync2(cmd, args, {
       encoding: "utf8",
       cwd: opts?.cwd,
       stdio: opts?.interactive ? "inherit" : "pipe",
-      env: sccache && cmd === "cargo" ? { ...process.env, RUSTC_WRAPPER: sccache } : process.env,
+      env: sccache && cmd === "cargo" ? { ...baseEnv, RUSTC_WRAPPER: sccache } : baseEnv,
       maxBuffer: 64 * 1024 * 1024,
       ...opts?.timeoutMs === undefined ? {} : { timeout: opts.timeoutMs, killSignal: "SIGKILL" }
     });
@@ -57190,7 +57190,7 @@ function realContext(env3, io) {
 
 // src/patch/run.ts
 import { appendFileSync, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/lock.ts
 import { closeSync, existsSync as existsSync4, mkdirSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
@@ -57244,89 +57244,10 @@ function acquireLock(file2, isAlive = pidAlive) {
   return null;
 }
 
-// src/hook/install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
-
-// src/atomic.ts
-import { mkdirSync as mkdirSync2, renameSync, writeFileSync } from "node:fs";
-import { randomBytes } from "node:crypto";
-import { dirname as dirname5, join as join5 } from "node:path";
-function writeFileAtomic(file2, text) {
-  mkdirSync2(dirname5(file2), { recursive: true });
-  const tmp = join5(dirname5(file2), `.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
-  writeFileSync(tmp, text);
-  renameSync(tmp, file2);
-}
-
-// src/sh.ts
-var sq = (s) => `'${s.replace(/'/g, `'"'"'`)}'`;
-
-// src/hook/install.ts
-var HOOK_STATUS_MESSAGE = "cxstatusline: checking Codex version";
-var HOOK_TIMEOUT_SEC = 10;
-var hookCommand = (cxBin) => `${sq(cxBin)} hook`;
-function hookEntry(cxBin) {
-  return { hooks: [{ type: "command", command: hookCommand(cxBin), timeout: HOOK_TIMEOUT_SEC, statusMessage: HOOK_STATUS_MESSAGE }] };
-}
-var isOurGroup = (g) => g.hooks.some((h) => h.statusMessage === HOOK_STATUS_MESSAGE);
-var sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-function mergeHook(file2, cxBin) {
-  const base2 = file2 ?? { hooks: {} };
-  const entry = hookEntry(cxBin);
-  const groups = base2.hooks.SessionStart ?? [];
-  const idx = groups.findIndex(isOurGroup);
-  if (idx !== -1 && sameJson(groups[idx], entry))
-    return { file: base2, changed: false };
-  const next = idx === -1 ? [...groups, entry] : groups.map((g, i) => i === idx ? entry : g);
-  return { file: { ...base2, hooks: { ...base2.hooks, SessionStart: next } }, changed: true };
-}
-function removeHook(file2) {
-  const groups = file2.hooks.SessionStart ?? [];
-  const kept = groups.filter((g) => !isOurGroup(g));
-  if (kept.length === groups.length)
-    return { file: file2, changed: false };
-  const { SessionStart: _dropped, ...rest2 } = file2.hooks;
-  const hooks = kept.length === 0 ? rest2 : { ...rest2, SessionStart: kept };
-  return { file: { ...file2, hooks }, changed: true };
-}
-function readHooksFile(path) {
-  if (!existsSync5(path))
-    return null;
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync3(path, "utf8"));
-  } catch {
-    throw new Error(`${path}: hooks.json is not valid JSON; fix it by hand before installing the hook`);
-  }
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-    throw new Error(`${path}: hooks.json must be a JSON object`);
-  const o = raw;
-  if (o.hooks !== undefined && (typeof o.hooks !== "object" || o.hooks === null))
-    throw new Error(`${path}: "hooks" must be an object`);
-  return { ...raw, hooks: o.hooks ?? {} };
-}
-function installHook(hooksFile, cxBin) {
-  const { file: file2, changed } = mergeHook(readHooksFile(hooksFile), cxBin);
-  if (!changed)
-    return "unchanged";
-  writeFileAtomic(hooksFile, `${JSON.stringify(file2, null, 2)}
-`);
-  return "added";
-}
-function uninstallHook(hooksFile) {
-  const current = readHooksFile(hooksFile);
-  if (!current)
-    return "absent";
-  const { file: file2, changed } = removeHook(current);
-  if (!changed)
-    return "absent";
-  writeFileAtomic(hooksFile, `${JSON.stringify(file2, null, 2)}
-`);
-  return "removed";
-}
-
-// src/state.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+// src/distribution/files.ts
+var GENERATION_EXECUTABLES = ["codex", "codex-code-mode-host"];
+var GENERATION_LEGAL_FILES = ["LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"];
+var ARTIFACT_FILES = [...GENERATION_EXECUTABLES, ...GENERATION_LEGAL_FILES];
 
 // src/version.ts
 var POLICIES = ["every", "stable-minors", "manual"];
@@ -57376,173 +57297,19 @@ function behindWithinMinor(upstream, patched) {
   return upstream.major === patched.major && upstream.minor === patched.minor && upstream.pre === null && compareSemver(upstream, patched) === 1;
 }
 
-// src/state.ts
-var RELEASE_UNAVAILABLE = "release-unavailable";
-var RELEASE_RETRY_AFTER_MS = 24 * 60 * 60 * 1000;
-var DEFAULT_STATE = {
-  version: 1,
-  policy: "stable-minors",
-  patched_from: null,
-  upstream_bin: null,
-  launcher_restore: null,
-  last_attempt: null
-};
-var BACKUP_SUFFIX = ".bak";
-var isObj2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var strOrNull = (v) => v === null || typeof v === "string" ? v : undefined;
-function restore(v) {
-  if (v === null)
-    return null;
-  if (!isObj2(v))
-    return;
-  if (v.kind === "none")
-    return { kind: "none" };
-  if (v.kind === "symlink" && typeof v.target === "string")
-    return { kind: "symlink", target: v.target };
-  return;
-}
-function attempt2(v) {
-  if (v === null)
-    return null;
-  if (!isObj2(v) || typeof v.at !== "string" || typeof v.ok !== "boolean" || typeof v.version !== "string")
-    return;
-  return typeof v.reason === "string" ? { at: v.at, ok: v.ok, version: v.version, reason: v.reason } : { at: v.at, ok: v.ok, version: v.version };
-}
-function validate3(raw) {
-  if (!isObj2(raw) || raw.version !== 1)
-    return null;
-  const policy = POLICIES.includes(String(raw.policy)) ? raw.policy : undefined;
-  const patched_from = strOrNull(raw.patched_from);
-  const upstream_bin = strOrNull(raw.upstream_bin);
-  const launcher_restore = restore(raw.launcher_restore);
-  const last_attempt = attempt2(raw.last_attempt);
-  if (policy === undefined || patched_from === undefined || upstream_bin === undefined || launcher_restore === undefined || last_attempt === undefined)
-    return null;
-  return { version: 1, policy, patched_from, upstream_bin, launcher_restore, last_attempt };
-}
-function readValidated(file2) {
-  if (!existsSync6(file2))
-    return null;
-  try {
-    return validate3(JSON.parse(readFileSync4(file2, "utf8")));
-  } catch {
-    return null;
-  }
-}
-function readState(file2) {
-  if (!existsSync6(file2) && !existsSync6(`${file2}${BACKUP_SUFFIX}`)) {
-    return { state: DEFAULT_STATE, corrupt: false };
-  }
-  const primary = readValidated(file2);
-  if (primary)
-    return { state: primary, corrupt: false };
-  const backup = readValidated(`${file2}${BACKUP_SUFFIX}`);
-  return backup ? { state: backup, corrupt: true } : { state: DEFAULT_STATE, corrupt: true };
-}
-function writeState(file2, state) {
-  const text = `${JSON.stringify(state, null, 2)}
-`;
-  writeFileAtomic(file2, text);
-  writeFileAtomic(`${file2}${BACKUP_SUFFIX}`, text);
-}
-
-// src/patch/acquire.ts
-import { rmSync as rmSync5 } from "node:fs";
-
-// src/codex/upstream.ts
-import { accessSync as accessSync2, constants as constants3, lstatSync, readlinkSync, realpathSync as realpathSync2, statSync } from "node:fs";
-import { dirname as dirname6, isAbsolute, join as join6, resolve as resolve2 } from "node:path";
-function isExecutable(p) {
-  try {
-    accessSync2(p, constants3.X_OK);
-    return statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function isManaged(p, paths, isOurWrapper) {
-  if (resolve2(p) === resolve2(paths.patchedBin) || isOurWrapper(p))
-    return true;
-  try {
-    return realpathSync2(p) === realpathSync2(paths.patchedBin);
-  } catch {
-    return false;
-  }
-}
-function inspectLauncher(paths, isOurWrapper) {
-  let st;
-  try {
-    st = lstatSync(paths.wrapperPath);
-  } catch {
-    return null;
-  }
-  if (st.isSymbolicLink()) {
-    const raw = readlinkSync(paths.wrapperPath);
-    const target = isAbsolute(raw) ? raw : resolve2(dirname6(paths.wrapperPath), raw);
-    if (isManaged(target, paths, isOurWrapper))
-      return null;
-    return { kind: "found", bin: target, launcher_restore: { kind: "symlink", target } };
-  }
-  if (isOurWrapper(paths.wrapperPath))
-    return null;
-  return { kind: "foreign", path: paths.wrapperPath };
-}
-function walkPath(paths, env3, isOurWrapper) {
-  for (const dir of (env3.PATH ?? "").split(":").filter(Boolean)) {
-    if (resolve2(dir) === resolve2(paths.binDir))
-      continue;
-    const candidate = join6(dir, "codex");
-    if (isExecutable(candidate) && !isManaged(candidate, paths, isOurWrapper))
-      return candidate;
-  }
-  return null;
-}
-function resolveUpstream(paths, env3, isOurWrapper, savedBin) {
-  const launcher = inspectLauncher(paths, isOurWrapper);
-  if (launcher)
-    return launcher;
-  const current = walkPath(paths, env3, isOurWrapper);
-  const bin = current ?? (savedBin && isExecutable(savedBin) && !isManaged(savedBin, paths, isOurWrapper) ? savedBin : null);
-  return bin ? { kind: "found", bin, launcher_restore: { kind: "none" } } : { kind: "not-found" };
-}
-function describeLookup(l) {
-  switch (l.kind) {
-    case "found":
-      return l.bin;
-    case "foreign":
-      return `${l.path} is a real file we did not write; refusing to overwrite it`;
-    case "not-found":
-      return "no upstream Codex found (nothing named codex on PATH outside ~/.local/bin, and the launcher there is not a symlink)";
-  }
-}
-function readUpstreamVersion(bin, run) {
-  const r = run(bin, ["--version"]);
-  if (r.status !== 0)
-    return null;
-  return parseCodexVersionOutput(r.stdout);
-}
-function preserveLauncherRestore(recorded, found) {
-  return found.kind === "symlink" ? found : recorded ?? found;
-}
-
-// src/distribution/files.ts
-var GENERATION_EXECUTABLES = ["codex", "codex-code-mode-host"];
-var GENERATION_LEGAL_FILES = ["LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"];
-var ARTIFACT_FILES = [...GENERATION_EXECUTABLES, ...GENERATION_LEGAL_FILES];
-
 // src/distribution/prebuilt.ts
 import { createHash as createHash3 } from "node:crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // src/patch/generation.ts
-import { chmodSync, copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync, readlinkSync as readlinkSync2, realpathSync as realpathSync3, renameSync as renameSync2, rmSync, statSync as statSync2, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { createHash, randomBytes as randomBytes2 } from "node:crypto";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join7, resolve as resolve3, sep } from "node:path";
+import { chmodSync, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, readlinkSync, realpathSync as realpathSync2, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { dirname as dirname5, isAbsolute, join as join5, resolve as resolve2, sep } from "node:path";
 var INSTALLATION_FILE = "installation.json";
 var SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
 function digestOf(file2) {
-  const buf = readFileSync5(file2);
+  const buf = readFileSync3(file2);
   return { sha256: createHash("sha256").update(buf).digest("hex"), size: buf.length };
 }
 function stamp(installedAt) {
@@ -57554,10 +57321,10 @@ function nearestExisting2(p) {
   let cur = p;
   for (;; ) {
     try {
-      statSync2(cur);
+      statSync(cur);
       return cur;
     } catch {
-      const parent = dirname7(cur);
+      const parent = dirname5(cur);
       if (parent === cur)
         return cur;
       cur = parent;
@@ -57566,7 +57333,7 @@ function nearestExisting2(p) {
 }
 function realish(p) {
   const near = nearestExisting2(p);
-  return realpathSync3(near) + resolve3(p).slice(resolve3(near).length);
+  return realpathSync2(near) + resolve2(p).slice(resolve2(near).length);
 }
 function insideGenerationsRoot(paths, candidate) {
   return realish(candidate).startsWith(`${realish(paths.generationsDir)}${sep}`);
@@ -57576,8 +57343,8 @@ function validateStaging(pair) {
     throw new Error(`prepared pair has an unusable codexVersion "${pair.codexVersion}"`);
   }
   for (const name of GENERATION_EXECUTABLES) {
-    const file2 = join7(pair.directory, name);
-    if (!existsSync7(file2))
+    const file2 = join5(pair.directory, name);
+    if (!existsSync5(file2))
       throw new Error(`staged pair is missing ${name}`);
     const want = pair.provenance.executables[name];
     const got = digestOf(file2);
@@ -57587,7 +57354,7 @@ function validateStaging(pair) {
   }
   if (pair.provenance.source === "prebuilt") {
     for (const name of GENERATION_LEGAL_FILES) {
-      if (!existsSync7(join7(pair.directory, name)))
+      if (!existsSync5(join5(pair.directory, name)))
         throw new Error(`prebuilt pair is missing ${name}`);
     }
   }
@@ -57597,8 +57364,8 @@ function installationRecord(pair) {
   return record2;
 }
 function copyInto(from, into, name, mode, expected) {
-  const target = join7(into, name);
-  copyFileSync(join7(from, name), target);
+  const target = join5(into, name);
+  copyFileSync(join5(from, name), target);
   chmodSync(target, mode);
   if (!expected)
     return;
@@ -57608,9 +57375,9 @@ function copyInto(from, into, name, mode, expected) {
   }
 }
 function commitJson(file2, value, rename2) {
-  const tmp = join7(dirname7(file2), `.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`);
+  const tmp = join5(dirname5(file2), `.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
   try {
-    writeFileSync2(tmp, `${JSON.stringify(value, null, 2)}
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
 `);
     rename2(tmp, file2);
   } catch (e) {
@@ -57619,26 +57386,26 @@ function commitJson(file2, value, rename2) {
   }
 }
 function freshDirectory(pair, paths) {
-  mkdirSync3(paths.generationsDir, { recursive: true });
+  mkdirSync2(paths.generationsDir, { recursive: true });
   for (;; ) {
-    const dir = join7(paths.generationsDir, `${pair.codexVersion}-${stamp(pair.provenance.installedAt)}-${randomBytes2(3).toString("hex")}`);
-    if (existsSync7(dir))
+    const dir = join5(paths.generationsDir, `${pair.codexVersion}-${stamp(pair.provenance.installedAt)}-${randomBytes(3).toString("hex")}`);
+    if (existsSync5(dir))
       continue;
-    mkdirSync3(dir);
+    mkdirSync2(dir);
     return dir;
   }
 }
-function createGeneration(pair, paths, rename2 = renameSync2) {
+function createGeneration(pair, paths, rename2 = renameSync) {
   validateStaging(pair);
   const dir = freshDirectory(pair, paths);
   try {
     for (const name of GENERATION_EXECUTABLES)
       copyInto(pair.directory, dir, name, 493, pair.provenance.executables[name]);
     for (const name of GENERATION_LEGAL_FILES) {
-      if (existsSync7(join7(pair.directory, name)))
+      if (existsSync5(join5(pair.directory, name)))
         copyInto(pair.directory, dir, name, 420);
     }
-    commitJson(join7(dir, INSTALLATION_FILE), installationRecord(pair), rename2);
+    commitJson(join5(dir, INSTALLATION_FILE), installationRecord(pair), rename2);
   } catch (e) {
     rmSync(dir, { recursive: true, force: true });
     throw e;
@@ -57646,24 +57413,24 @@ function createGeneration(pair, paths, rename2 = renameSync2) {
   return dir;
 }
 function isGenerationDir(dir) {
-  return existsSync7(join7(dir, INSTALLATION_FILE)) && existsSync7(join7(dir, "codex"));
+  return existsSync5(join5(dir, INSTALLATION_FILE)) && existsSync5(join5(dir, "codex"));
 }
 function listGenerations(paths) {
   try {
-    return readdirSync(paths.generationsDir).map((name) => join7(paths.generationsDir, name)).sort();
+    return readdirSync(paths.generationsDir).map((name) => join5(paths.generationsDir, name)).sort();
   } catch {
     return [];
   }
 }
 function readPointer(paths) {
   try {
-    return readlinkSync2(paths.currentGeneration);
+    return readlinkSync(paths.currentGeneration);
   } catch {
     return null;
   }
 }
-function swapPointer(paths, target, rename2 = renameSync2) {
-  const staged = `${paths.currentGeneration}.${randomBytes2(4).toString("hex")}`;
+function swapPointer(paths, target, rename2 = renameSync) {
+  const staged = `${paths.currentGeneration}.${randomBytes(4).toString("hex")}`;
   symlinkSync(target, staged);
   try {
     rename2(staged, paths.currentGeneration);
@@ -57672,7 +57439,7 @@ function swapPointer(paths, target, rename2 = renameSync2) {
     throw e;
   }
 }
-function restorePointer(paths, previous, rename2 = renameSync2) {
+function restorePointer(paths, previous, rename2 = renameSync) {
   if (previous === null) {
     rmSync(paths.currentGeneration, { force: true });
     return;
@@ -57683,11 +57450,11 @@ function activeGeneration(paths) {
   const target = readPointer(paths);
   if (target === null)
     return null;
-  const abs = isAbsolute2(target) ? target : resolve3(dirname7(paths.currentGeneration), target);
+  const abs = isAbsolute(target) ? target : resolve2(dirname5(paths.currentGeneration), target);
   if (!insideGenerationsRoot(paths, abs))
     return null;
   try {
-    return statSync2(abs).isDirectory() ? abs : null;
+    return statSync(abs).isDirectory() ? abs : null;
   } catch {
     return null;
   }
@@ -57745,7 +57512,7 @@ function readInstallation(paths) {
   if (dir === null)
     return null;
   try {
-    const raw = JSON.parse(readFileSync5(join7(dir, INSTALLATION_FILE), "utf8"));
+    const raw = JSON.parse(readFileSync3(join5(dir, INSTALLATION_FILE), "utf8"));
     return checkedRecord(raw);
   } catch {
     return null;
@@ -57754,7 +57521,7 @@ function readInstallation(paths) {
 
 // src/distribution/archive.ts
 import { createReadStream, createWriteStream } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join6 } from "node:path";
 import { createGunzip } from "node:zlib";
 
 // node_modules/tar/dist/esm/index.min.js
@@ -60985,7 +60752,7 @@ var EXTRACTED_TOTAL_LIMIT = 2 * 1024 * 1024 * 1024;
 var LEGAL_TOTAL_LIMIT = 16 * 1024 * 1024;
 var EXECUTABLE_MODE = 493;
 var LEGAL_MODE = 420;
-function isExecutable2(name) {
+function isExecutable(name) {
   return GENERATION_EXECUTABLES.includes(name);
 }
 function quoteName(name) {
@@ -61009,7 +60776,7 @@ function rejectionReason(entry, seen, budget) {
   const size2 = entry.size;
   if (!Number.isSafeInteger(size2) || size2 < 0)
     return `archive entry ${quoteName(name)} declares an unusable size`;
-  const executable = isExecutable2(name);
+  const executable = isExecutable(name);
   if (executable && size2 === 0)
     return `archive entry ${quoteName(name)} is an empty executable`;
   const mode = entry.mode ?? entry.header.mode ?? 0;
@@ -61028,9 +60795,9 @@ function rejectionReason(entry, seen, budget) {
 }
 function writeEntry(entry, staging) {
   const name = entry.path;
-  const mode = isExecutable2(name) ? EXECUTABLE_MODE : LEGAL_MODE;
-  const sink = createWriteStream(join8(staging, name), { mode, flags: "wx" });
-  const done = new Promise((resolve4, reject2) => {
+  const mode = isExecutable(name) ? EXECUTABLE_MODE : LEGAL_MODE;
+  const sink = createWriteStream(join6(staging, name), { mode, flags: "wx" });
+  const done = new Promise((resolve3, reject2) => {
     sink.on("error", reject2);
     entry.on("error", reject2);
     sink.on("finish", () => {
@@ -61038,7 +60805,7 @@ function writeEntry(entry, staging) {
         reject2(new Error(`archive entry ${quoteName(name)} ended after ${sink.bytesWritten} of ${entry.size} bytes`));
         return;
       }
-      resolve4();
+      resolve3();
     });
     entry.pipe(sink);
   });
@@ -61053,7 +60820,7 @@ function writeEntry(entry, staging) {
 function parseArchive(archivePath, staging, writes) {
   const seen = new Set;
   const budget = { total: 0, legal: 0 };
-  return new Promise((resolve4, reject2) => {
+  return new Promise((resolve3, reject2) => {
     const source = createReadStream(archivePath);
     const gunzip = createGunzip();
     let settled = false;
@@ -61095,7 +60862,7 @@ function parseArchive(archivePath, staging, writes) {
         reject2(new Error(`archive is missing ${missing.join(", ")}`));
         return;
       }
-      resolve4();
+      resolve3();
     });
     source.pipe(gunzip).pipe(parser);
   });
@@ -61113,9 +60880,9 @@ async function extractArchive(archivePath, staging) {
 
 // src/distribution/transport.ts
 import { createHash as createHash2 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync8 } from "node:fs";
+import { createReadStream as createReadStream2, existsSync as existsSync6 } from "node:fs";
 import { open as open2 } from "node:fs/promises";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 var PUBLIC_BASE = "https://github.com/adrijshikhar/cxstatusline/releases/download";
 var REPO = "adrijshikhar/cxstatusline";
 var MAX_REDIRECTS = 5;
@@ -61157,7 +60924,7 @@ function nextUrl(current, location, allowHttp, asset) {
   }
   return resolved.toString();
 }
-async function streamToFile(response, dest, maxBytes, asset) {
+async function streamToFile(response, dest, maxBytes, asset, onProgress) {
   const declared = response.headers.get("content-length");
   const expected = declared === null ? null : Number(declared);
   if (expected !== null && (!Number.isSafeInteger(expected) || expected < 0 || expected > maxBytes)) {
@@ -61180,6 +60947,7 @@ async function streamToFile(response, dest, maxBytes, asset) {
         throw new Error(`${asset} is larger than the ${maxBytes}-byte limit`);
       hash2.update(value);
       await handle.write(value);
+      onProgress?.(size2, expected);
     }
   } finally {
     await handle.close();
@@ -61210,7 +60978,7 @@ async function httpDownload(start, asset, dest, maxBytes, opts) {
       return "not-found";
     if (!response.ok)
       throw new Error(`download of ${asset} failed with HTTP ${response.status}`);
-    return await streamToFile(response, dest, maxBytes, asset);
+    return await streamToFile(response, dest, maxBytes, asset, opts.onProgress);
   }
   throw new Error(`download of ${asset} exceeded ${MAX_REDIRECTS} redirects`);
 }
@@ -61230,7 +60998,7 @@ async function ghDownload(ctx, tag, asset, dest, maxBytes) {
   if (ctx.which("gh") === null) {
     throw new GhMissingError(`${asset} is not public for release ${tag} and GitHub CLI (gh) is not installed`);
   }
-  const result2 = ctx.run("gh", ["release", "download", tag, "--repo", REPO, "--pattern", asset, "--dir", dirname8(dest)], { timeoutMs: GH_TIMEOUT_MS });
+  const result2 = ctx.run("gh", ["release", "download", tag, "--repo", REPO, "--pattern", asset, "--dir", dirname6(dest)], { timeoutMs: GH_TIMEOUT_MS });
   if (result2.status !== 0) {
     const detail = sanitize(result2.stderr || result2.stdout);
     if (/auth|logged in|log in|login|credential/i.test(detail)) {
@@ -61238,7 +61006,7 @@ async function ghDownload(ctx, tag, asset, dest, maxBytes) {
     }
     throw new ReleaseUnavailableError(`release ${tag} not found or access denied: ${detail}`);
   }
-  if (!existsSync8(dest))
+  if (!existsSync6(dest))
     throw new ReleaseUnavailableError(`release ${tag} not found or access denied: gh downloaded no ${asset}`);
   return await hashFile(dest, maxBytes, asset);
 }
@@ -61254,15 +61022,15 @@ async function downloadAsset(ctx, tag, asset, dest, maxBytes, opts = {}) {
 var MANIFEST_ASSET = "manifest.json";
 var PROBE_TIMEOUT_MS = 30000;
 function digestOf2(file2) {
-  const bytes = readFileSync6(file2);
+  const bytes = readFileSync4(file2);
   return { sha256: createHash3("sha256").update(bytes).digest("hex"), size: bytes.length };
 }
 function sameDigest(a, b2) {
   return a.sha256 === b2.sha256 && a.size === b2.size;
 }
 function privateTemp(ctx, prefix) {
-  mkdirSync4(ctx.paths.libexecDir, { recursive: true });
-  const dir = mkdtempSync(join9(ctx.paths.libexecDir, prefix));
+  mkdirSync3(ctx.paths.libexecDir, { recursive: true });
+  const dir = mkdtempSync(join7(ctx.paths.libexecDir, prefix));
   chmodSync2(dir, 448);
   return dir;
 }
@@ -61288,7 +61056,7 @@ function unchangedPair(ctx, manifest, artifact, tag) {
     return null;
   for (const name of ARTIFACT_FILES) {
     try {
-      if (!sameDigest(digestOf2(join9(directory, name)), artifact.files[name]))
+      if (!sameDigest(digestOf2(join7(directory, name)), artifact.files[name]))
         return null;
     } catch {
       return null;
@@ -61299,7 +61067,7 @@ function unchangedPair(ctx, manifest, artifact, tag) {
 function verifyStaged(staging, artifact) {
   const digests = {};
   for (const name of ARTIFACT_FILES) {
-    const got = digestOf2(join9(staging, name));
+    const got = digestOf2(join7(staging, name));
     if (!sameDigest(got, artifact.files[name])) {
       throw new Error(`staged ${name} does not match the release manifest sha256`);
     }
@@ -61311,7 +61079,7 @@ function verifyStaged(staging, artifact) {
   };
 }
 function probeVersion(ctx, staging, codexVersion) {
-  const probe = ctx.run(join9(staging, "codex"), ["--version"], { timeoutMs: PROBE_TIMEOUT_MS });
+  const probe = ctx.run(join7(staging, "codex"), ["--version"], { timeoutMs: PROBE_TIMEOUT_MS });
   const reported = sanitize((probe.stdout || probe.stderr).slice(0, 512));
   if (probe.status !== 0 || reported !== `codex-cli ${codexVersion}`) {
     throw new Error(`staged codex reported version "${reported}" instead of "codex-cli ${codexVersion}"`);
@@ -61338,15 +61106,20 @@ function stagedPair(ctx, staging, manifest, artifact, tag) {
   };
 }
 async function stageArchive(ctx, download, manifest, artifact, tag, opts) {
-  const archive = join9(download, artifact.filename);
+  const archive = join7(download, artifact.filename);
+  opts.onStatus?.("download", `Downloading prebuilt archive (${artifact.filename})...`);
   const got = await downloadAsset(ctx, tag, artifact.filename, archive, ARCHIVE_MAX_BYTES, opts);
   if (got.sha256 !== artifact.sha256 || got.size !== artifact.size) {
     throw new Error(`${artifact.filename} does not match the release manifest sha256`);
   }
+  opts.onStatus?.("download-done", `Downloaded ${artifact.filename}`);
   const staging = privateTemp(ctx, "staging-");
   try {
+    opts.onStatus?.("extract", "Extracting and verifying executables...");
     await extractArchive(archive, staging);
-    return stagedPair(ctx, staging, manifest, artifact, tag);
+    const pair = stagedPair(ctx, staging, manifest, artifact, tag);
+    opts.onStatus?.("extract-done", "Verified executables (codex, codex-code-mode-host)");
+    return pair;
   } catch (e) {
     rmSync2(staging, { recursive: true, force: true });
     throw e;
@@ -61354,12 +61127,14 @@ async function stageArchive(ctx, download, manifest, artifact, tag, opts) {
 }
 async function preparePrebuilt(ctx, expected, opts = {}) {
   const tag = releaseTag(expected.cxVersion, expected.codexVersion);
+  opts.onStatus?.("manifest", `Checking release ${tag} for ${expected.platform}...`);
   const download = privateTemp(ctx, "download-");
   try {
-    const manifestFile = join9(download, MANIFEST_ASSET);
+    const manifestFile = join7(download, MANIFEST_ASSET);
     await downloadAsset(ctx, tag, MANIFEST_ASSET, manifestFile, MANIFEST_MAX_BYTES, opts);
-    const manifest = validateManifest(JSON.parse(readFileSync6(manifestFile, "utf8")), expected);
+    const manifest = validateManifest(JSON.parse(readFileSync4(manifestFile, "utf8")), expected);
     const artifact = artifactFor(manifest, expected);
+    opts.onStatus?.("manifest-done", `Found release for Codex ${manifest.codexVersion} (${artifact.platform})`);
     const unchanged = unchangedPair(ctx, manifest, artifact, tag);
     if (unchanged !== null)
       return { kind: "unchanged", pair: unchanged };
@@ -61474,67 +61249,354 @@ function validateManifest(raw, expected) {
   return structural.data;
 }
 
-// src/patch/compile.ts
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
-import { createHash as createHash4 } from "node:crypto";
-import { join as join11 } from "node:path";
-
-// src/patch/build.ts
-import { existsSync as existsSync9, lstatSync as lstatSync2, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
-import { join as join10 } from "node:path";
-
-class BuildError extends Error {
-  step;
-  name = "BuildError";
-  constructor(step, detail) {
-    super(`${step}: ${detail.trim() || "failed"}`);
-    this.step = step;
+// src/codex/upstream.ts
+import { accessSync as accessSync2, constants as constants3, lstatSync, readlinkSync as readlinkSync2, realpathSync as realpathSync3, statSync as statSync2 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+function isExecutable2(p2) {
+  try {
+    accessSync2(p2, constants3.X_OK);
+    return statSync2(p2).isFile();
+  } catch {
+    return false;
   }
 }
-var REPO2 = "https://github.com/openai/codex";
-var SNAPSHOT = "codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__footer__tests__cxstatusline_block_preserves_instruction_footer.snap";
-var SNAPSHOT_CONTENT = [
-  "---",
-  "source: tui/src/bottom_pane/footer.rs",
-  "expression: terminal.backend()",
-  "---",
-  ...["status-0", "status-1", "status-2", "esc esc to edit previous message"].map((s3) => `"  ${s3.padEnd(78)}"`),
-  ""
-].join(`
-`);
-var TARGETS = ["codex", "codex-code-mode-host"];
-var HEX403 = /^[0-9a-f]{40}$/;
-function must(step, run, log, cmd, args, cwd2) {
-  log(`$ ${[cmd, ...args].join(" ")}`);
-  const r = run(cmd, args, cwd2 ? { cwd: cwd2 } : undefined);
-  for (const line of `${r.stdout}${r.stderr}`.split(`
-`).filter(Boolean))
-    log(line);
-  if (r.status !== 0)
-    throw new BuildError(step, r.stderr || r.stdout);
-}
-function runFocusedTests(run, log, which, crateDir) {
-  if (which("just")) {
-    log("running the focused Rust tests with just");
-    must("just test", run, log, "just", ["test", "--release", "-p", "codex-tui", "cxstatusline", "--retries", "0"], crateDir);
-    return;
+function isManaged(p2, paths, isOurWrapper) {
+  if (resolve3(p2) === resolve3(paths.patchedBin) || isOurWrapper(p2))
+    return true;
+  try {
+    return realpathSync3(p2) === realpathSync3(paths.patchedBin);
+  } catch {
+    return false;
   }
-  log("just is not on PATH; running the focused Rust tests with cargo");
-  must("cargo test", run, log, "cargo", ["test", "--release", "-p", "codex-tui", "cxstatusline"], crateDir);
 }
-function headCommit(plan, run) {
-  const r = run("git", ["-C", plan.sourceDir, "rev-parse", "HEAD"]);
-  const commit = r.stdout.trim();
-  if (r.status !== 0 || !HEX403.test(commit)) {
-    throw new BuildError("rev-parse", `${plan.sourceDir} did not report a commit for ${plan.tag}`);
+function inspectLauncher(paths, isOurWrapper) {
+  let st2;
+  try {
+    st2 = lstatSync(paths.wrapperPath);
+  } catch {
+    return null;
   }
-  return commit;
-}
-function prepareCheckout(plan, run, log) {
+  if (st2.isSymbolicLink()) {
+    const raw = readlinkSync2(paths.wrapperPath);
+    const target = isAbsolute2(raw) ? raw : resolve3(dirname7(paths.wrapperPath), raw);
+    if (isManaged(target, paths, isOurWrapper))
+      return null;
+    return { kind: "found", bin: target, launcher_restore: { kind: "symlink", target } };
+  }
+  if (isOurWrapper(paths.wrapperPath))
+    return null;
+  return { kind: "foreign", path: paths.wrapperPath };
+}
+function walkPath(paths, env3, isOurWrapper) {
+  for (const dir of (env3.PATH ?? "").split(":").filter(Boolean)) {
+    if (resolve3(dir) === resolve3(paths.binDir))
+      continue;
+    const candidate = join8(dir, "codex");
+    if (isExecutable2(candidate) && !isManaged(candidate, paths, isOurWrapper))
+      return candidate;
+  }
+  return null;
+}
+function resolveUpstream(paths, env3, isOurWrapper, savedBin) {
+  const launcher = inspectLauncher(paths, isOurWrapper);
+  if (launcher)
+    return launcher;
+  const current = walkPath(paths, env3, isOurWrapper);
+  const bin = current ?? (savedBin && isExecutable2(savedBin) && !isManaged(savedBin, paths, isOurWrapper) ? savedBin : null);
+  return bin ? { kind: "found", bin, launcher_restore: { kind: "none" } } : { kind: "not-found" };
+}
+function describeLookup(l) {
+  switch (l.kind) {
+    case "found":
+      return l.bin;
+    case "foreign":
+      return `${l.path} is a real file we did not write; refusing to overwrite it`;
+    case "not-found":
+      return "no upstream Codex found (nothing named codex on PATH outside ~/.local/bin, and the launcher there is not a symlink)";
+  }
+}
+function readUpstreamVersion(bin, run) {
+  const r = run(bin, ["--version"]);
+  if (r.status !== 0)
+    return null;
+  return parseCodexVersionOutput(r.stdout);
+}
+function preserveLauncherRestore(recorded, found) {
+  return found.kind === "symlink" ? found : recorded ?? found;
+}
+
+// src/hook/install.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+
+// src/atomic.ts
+import { mkdirSync as mkdirSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { dirname as dirname8, join as join9 } from "node:path";
+function writeFileAtomic(file2, text) {
+  mkdirSync4(dirname8(file2), { recursive: true });
+  const tmp = join9(dirname8(file2), `.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`);
+  writeFileSync2(tmp, text);
+  renameSync2(tmp, file2);
+}
+
+// src/sh.ts
+var sq = (s3) => `'${s3.replace(/'/g, `'"'"'`)}'`;
+
+// src/hook/install.ts
+var HOOK_STATUS_MESSAGE = "cxstatusline: checking Codex version";
+var HOOK_TIMEOUT_SEC = 10;
+var hookCommand = (cxBin) => `${sq(cxBin)} hook`;
+function hookEntry(cxBin) {
+  return { hooks: [{ type: "command", command: hookCommand(cxBin), timeout: HOOK_TIMEOUT_SEC, statusMessage: HOOK_STATUS_MESSAGE }] };
+}
+var isOurGroup = (g2) => g2.hooks.some((h) => h.statusMessage === HOOK_STATUS_MESSAGE);
+var sameJson = (a, b2) => JSON.stringify(a) === JSON.stringify(b2);
+function mergeHook(file2, cxBin) {
+  const base2 = file2 ?? { hooks: {} };
+  const entry = hookEntry(cxBin);
+  const groups = base2.hooks.SessionStart ?? [];
+  const idx = groups.findIndex(isOurGroup);
+  if (idx !== -1 && sameJson(groups[idx], entry))
+    return { file: base2, changed: false };
+  const next = idx === -1 ? [...groups, entry] : groups.map((g2, i) => i === idx ? entry : g2);
+  return { file: { ...base2, hooks: { ...base2.hooks, SessionStart: next } }, changed: true };
+}
+function removeHook(file2) {
+  const groups = file2.hooks.SessionStart ?? [];
+  const kept = groups.filter((g2) => !isOurGroup(g2));
+  if (kept.length === groups.length)
+    return { file: file2, changed: false };
+  const { SessionStart: _dropped, ...rest2 } = file2.hooks;
+  const hooks = kept.length === 0 ? rest2 : { ...rest2, SessionStart: kept };
+  return { file: { ...file2, hooks }, changed: true };
+}
+function readHooksFile(path) {
+  if (!existsSync7(path))
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    throw new Error(`${path}: hooks.json is not valid JSON; fix it by hand before installing the hook`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    throw new Error(`${path}: hooks.json must be a JSON object`);
+  const o = raw;
+  if (o.hooks !== undefined && (typeof o.hooks !== "object" || o.hooks === null))
+    throw new Error(`${path}: "hooks" must be an object`);
+  return { ...raw, hooks: o.hooks ?? {} };
+}
+function installHook(hooksFile, cxBin) {
+  const { file: file2, changed } = mergeHook(readHooksFile(hooksFile), cxBin);
+  if (!changed)
+    return "unchanged";
+  writeFileAtomic(hooksFile, `${JSON.stringify(file2, null, 2)}
+`);
+  return "added";
+}
+function uninstallHook(hooksFile) {
+  const current = readHooksFile(hooksFile);
+  if (!current)
+    return "absent";
+  const { file: file2, changed } = removeHook(current);
+  if (!changed)
+    return "absent";
+  writeFileAtomic(hooksFile, `${JSON.stringify(file2, null, 2)}
+`);
+  return "removed";
+}
+
+// src/state.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+var RELEASE_UNAVAILABLE = "release-unavailable";
+var RELEASE_RETRY_AFTER_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_STATE = {
+  version: 1,
+  policy: "stable-minors",
+  patched_from: null,
+  upstream_bin: null,
+  launcher_restore: null,
+  last_attempt: null
+};
+var BACKUP_SUFFIX = ".bak";
+var isObj2 = (v2) => typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+var strOrNull = (v2) => v2 === null || typeof v2 === "string" ? v2 : undefined;
+function restore(v2) {
+  if (v2 === null)
+    return null;
+  if (!isObj2(v2))
+    return;
+  if (v2.kind === "none")
+    return { kind: "none" };
+  if (v2.kind === "symlink" && typeof v2.target === "string")
+    return { kind: "symlink", target: v2.target };
+  return;
+}
+function attempt2(v2) {
+  if (v2 === null)
+    return null;
+  if (!isObj2(v2) || typeof v2.at !== "string" || typeof v2.ok !== "boolean" || typeof v2.version !== "string")
+    return;
+  return typeof v2.reason === "string" ? { at: v2.at, ok: v2.ok, version: v2.version, reason: v2.reason } : { at: v2.at, ok: v2.ok, version: v2.version };
+}
+function validate3(raw) {
+  if (!isObj2(raw) || raw.version !== 1)
+    return null;
+  const policy = POLICIES.includes(String(raw.policy)) ? raw.policy : undefined;
+  const patched_from = strOrNull(raw.patched_from);
+  const upstream_bin = strOrNull(raw.upstream_bin);
+  const launcher_restore = restore(raw.launcher_restore);
+  const last_attempt = attempt2(raw.last_attempt);
+  if (policy === undefined || patched_from === undefined || upstream_bin === undefined || launcher_restore === undefined || last_attempt === undefined)
+    return null;
+  return { version: 1, policy, patched_from, upstream_bin, launcher_restore, last_attempt };
+}
+function readValidated(file2) {
+  if (!existsSync8(file2))
+    return null;
+  try {
+    return validate3(JSON.parse(readFileSync6(file2, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function readState(file2) {
+  if (!existsSync8(file2) && !existsSync8(`${file2}${BACKUP_SUFFIX}`)) {
+    return { state: DEFAULT_STATE, corrupt: false };
+  }
+  const primary = readValidated(file2);
+  if (primary)
+    return { state: primary, corrupt: false };
+  const backup = readValidated(`${file2}${BACKUP_SUFFIX}`);
+  return backup ? { state: backup, corrupt: true } : { state: DEFAULT_STATE, corrupt: true };
+}
+function writeState(file2, state) {
+  const text = `${JSON.stringify(state, null, 2)}
+`;
+  writeFileAtomic(file2, text);
+  writeFileAtomic(`${file2}${BACKUP_SUFFIX}`, text);
+}
+
+// src/patch/acquire.ts
+import { rmSync as rmSync5 } from "node:fs";
+
+// src/patch/compile.ts
+import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { join as join12 } from "node:path";
+
+// src/patch/build.ts
+import { existsSync as existsSync10, lstatSync as lstatSync2, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+
+// src/patch/v8.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join10 } from "node:path";
+function defaultV8Target() {
+  const isArm = process.arch === "arm64";
+  if (process.platform === "darwin")
+    return isArm ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
+  if (process.platform === "linux")
+    return isArm ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu";
+  return isArm ? "aarch64-pc-windows-msvc" : "x86_64-pc-windows-msvc";
+}
+var PYTHON_RESOLVE_SCRIPT = [
+  "import json, os, sys",
+  "repo = sys.argv[1]",
+  "target = sys.argv[2]",
+  "os.environ['CODEX_REPO_ROOT'] = repo",
+  "sys.path.insert(0, repo)",
+  "from scripts.codex_package.targets import TARGET_SPECS",
+  "from scripts.codex_package.v8 import resolve_codex_v8_cargo_env",
+  "spec = TARGET_SPECS.get(target)",
+  "if spec:",
+  "    print(json.dumps(resolve_codex_v8_cargo_env(spec)))",
+  "else:",
+  "    print('{}')"
+].join(`
+`);
+function resolveV8Env(sourceDir, run, log) {
+  if (process.env.RUSTY_V8_ARCHIVE && process.env.RUSTY_V8_SRC_BINDING_PATH) {
+    return {
+      RUSTY_V8_ARCHIVE: process.env.RUSTY_V8_ARCHIVE,
+      RUSTY_V8_SRC_BINDING_PATH: process.env.RUSTY_V8_SRC_BINDING_PATH
+    };
+  }
+  const v8Script = join10(sourceDir, "scripts", "codex_package", "v8.py");
+  if (!existsSync9(v8Script)) {
+    return {};
+  }
+  const target = defaultV8Target();
+  log(`resolving Codex V8 dependencies for ${target}...`);
+  for (const py of ["python3", "python"]) {
+    const r = run(py, ["-c", PYTHON_RESOLVE_SCRIPT, sourceDir, target], { cwd: sourceDir });
+    if (r.status === 0 && r.stdout.trim()) {
+      try {
+        const parsed = JSON.parse(r.stdout.trim());
+        if (parsed.RUSTY_V8_ARCHIVE && parsed.RUSTY_V8_SRC_BINDING_PATH) {
+          log(`using Codex V8 archive: ${parsed.RUSTY_V8_ARCHIVE}`);
+          return parsed;
+        }
+      } catch {}
+    }
+  }
+  log("warning: could not resolve Codex V8 dependencies via python; build may fail if V8 prebuilts are needed");
+  return {};
+}
+
+// src/patch/build.ts
+class BuildError extends Error {
+  step;
+  name = "BuildError";
+  constructor(step, detail) {
+    super(`${step}: ${detail.trim() || "failed"}`);
+    this.step = step;
+  }
+}
+var REPO2 = "https://github.com/openai/codex";
+var SNAPSHOT = "codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__footer__tests__cxstatusline_block_preserves_instruction_footer.snap";
+var SNAPSHOT_CONTENT = [
+  "---",
+  "source: tui/src/bottom_pane/footer.rs",
+  "expression: terminal.backend()",
+  "---",
+  ...["status-0", "status-1", "status-2", "esc esc to edit previous message"].map((s3) => `"  ${s3.padEnd(78)}"`),
+  ""
+].join(`
+`);
+var TARGETS = ["codex", "codex-code-mode-host"];
+var HEX403 = /^[0-9a-f]{40}$/;
+function must(step, run, log, cmd, args, cwd2, env3) {
+  log(`$ ${[cmd, ...args].join(" ")}`);
+  const r = run(cmd, args, { cwd: cwd2, env: env3 });
+  for (const line of `${r.stdout}${r.stderr}`.split(`
+`).filter(Boolean))
+    log(line);
+  if (r.status !== 0)
+    throw new BuildError(step, r.stderr || r.stdout);
+}
+function runFocusedTests(run, log, which, crateDir, env3) {
+  if (which("just")) {
+    log("running the focused Rust tests with just");
+    must("just test", run, log, "just", ["test", "--release", "-p", "codex-tui", "cxstatusline", "--retries", "0"], crateDir, env3);
+    return;
+  }
+  log("just is not on PATH; running the focused Rust tests with cargo");
+  must("cargo test", run, log, "cargo", ["test", "--release", "-p", "codex-tui", "cxstatusline"], crateDir, env3);
+}
+function headCommit(plan, run) {
+  const r = run("git", ["-C", plan.sourceDir, "rev-parse", "HEAD"]);
+  const commit = r.stdout.trim();
+  if (r.status !== 0 || !HEX403.test(commit)) {
+    throw new BuildError("rev-parse", `${plan.sourceDir} did not report a commit for ${plan.tag}`);
+  }
+  return commit;
+}
+function prepareCheckout(plan, run, log) {
   const git = (step, ...args) => must(step, run, log, "git", ["-C", plan.sourceDir, ...args]);
-  if (existsSync9(join10(plan.sourceDir, ".git"))) {
+  if (existsSync10(join11(plan.sourceDir, ".git"))) {
     git("fetch", "fetch", "--tags", "--filter=blob:none", "origin");
-    const snapshot = join10(plan.sourceDir, SNAPSHOT);
+    const snapshot = join11(plan.sourceDir, SNAPSHOT);
     const st2 = lstatSync2(snapshot, { throwIfNoEntry: false });
     if (st2) {
       const tracked = run("git", ["-C", plan.sourceDir, "ls-files", "--error-unmatch", "--", SNAPSHOT]);
@@ -61551,22 +61613,38 @@ function prepareCheckout(plan, run, log) {
   }
   git("checkout", "checkout", "--detach", plan.tag);
 }
-function buildPatched(plan, run, log, which) {
+function buildPatched(plan, run, log, which, onStatus) {
   const git = (step, ...args) => must(step, run, log, "git", ["-C", plan.sourceDir, ...args]);
+  onStatus?.("checkout", `Preparing checkout for ${plan.tag}...`);
   prepareCheckout(plan, run, log);
   const upstreamCommit = headCommit(plan, run);
+  onStatus?.("checkout-done", `Upstream source ready at ${upstreamCommit.slice(0, 10)}`);
+  const patchBase = plan.patchFile.split("/").pop() ?? "patch";
+  onStatus?.("patch", `Applying ${patchBase}...`);
   git("apply --check", "apply", "--index", "--check", plan.patchFile);
   git("apply", "apply", "--index", plan.patchFile);
-  const crateDir = join10(plan.sourceDir, "codex-rs");
-  must("cargo build", run, log, "cargo", ["build", "--release", "-p", "codex-cli", "--bin", "codex", "-p", "codex-code-mode-host", "--bin", "codex-code-mode-host"], crateDir);
+  onStatus?.("patch-done", `Applied ${patchBase} cleanly`);
+  const crateDir = join11(plan.sourceDir, "codex-rs");
+  const v8Env = resolveV8Env(plan.sourceDir, run, log);
+  onStatus?.("build", "Compiling release binaries (cargo build --release)... Note: this full compile typically takes 10 to 20 minutes.");
+  const buildStart = Date.now();
+  must("cargo build", run, log, "cargo", ["build", "--release", "-p", "codex-cli", "--bin", "codex", "-p", "codex-code-mode-host", "--bin", "codex-code-mode-host"], crateDir, v8Env);
+  const buildElapsed = Math.round((Date.now() - buildStart) / 1000);
+  const buildElapsedStr = buildElapsed >= 60 ? `${Math.floor(buildElapsed / 60)}m ${buildElapsed % 60}s` : `${buildElapsed}s`;
+  onStatus?.("build-done", `Release binaries compiled (codex, codex-code-mode-host in ${buildElapsedStr})`);
   const [codex, codexCodeModeHost] = TARGETS.map((name) => {
-    const bin = join10(crateDir, "target", "release", name);
-    if (!existsSync9(bin) || statSync3(bin).size === 0) {
+    const bin = join11(crateDir, "target", "release", name);
+    if (!existsSync10(bin) || statSync3(bin).size === 0) {
       throw new BuildError("cargo build", `cargo exited 0 but ${bin} is missing or empty`);
     }
     return bin;
   });
-  runFocusedTests(run, log, which, crateDir);
+  onStatus?.("test", "Running focused regression tests...");
+  const testStart = Date.now();
+  runFocusedTests(run, log, which, crateDir, v8Env);
+  const testElapsed = Math.round((Date.now() - testStart) / 1000);
+  const testElapsedStr = testElapsed >= 60 ? `${Math.floor(testElapsed / 60)}m ${testElapsed % 60}s` : `${testElapsed}s`;
+  onStatus?.("test-done", `Focused regression tests passed (in ${testElapsedStr})`);
   return { codex, codexCodeModeHost, upstreamCommit };
 }
 
@@ -61584,7 +61662,7 @@ function platformLabel() {
 }
 function stage(ctx, built) {
   mkdirSync5(ctx.paths.libexecDir, { recursive: true });
-  const directory = mkdtempSync2(join11(ctx.paths.libexecDir, STAGING_PREFIX));
+  const directory = mkdtempSync2(join12(ctx.paths.libexecDir, STAGING_PREFIX));
   chmodSync3(directory, 448);
   const sources = {
     codex: built.codex,
@@ -61593,7 +61671,7 @@ function stage(ctx, built) {
   const executables = {};
   try {
     for (const name of GENERATION_EXECUTABLES) {
-      const target = join11(directory, name);
+      const target = join12(directory, name);
       copyFileSync2(sources[name], target);
       chmodSync3(target, 493);
       executables[name] = digestOf3(target);
@@ -61610,11 +61688,13 @@ function stage(ctx, built) {
     }
   };
 }
-function prepareCompiled(ctx, upstream, ref) {
-  const patchFile = join11(ctx.patchesDir, ref.file);
+function prepareCompiled(ctx, upstream, ref, onStatus) {
+  const patchFile = join12(ctx.patchesDir, ref.file);
   const patchSha256 = digestOf3(patchFile).sha256;
-  const built = buildPatched({ tag: ref.tag, sourceDir: ctx.paths.sourceDir, patchFile }, ctx.run, ctx.log, ctx.which);
+  const built = buildPatched({ tag: ref.tag, sourceDir: ctx.paths.sourceDir, patchFile }, ctx.run, ctx.log, ctx.which, onStatus);
+  onStatus?.("stage", "Staging generation and verifying binaries...");
   const staged = stage(ctx, built);
+  onStatus?.("stage-done", "Generation staged and binaries verified");
   return {
     directory: staged.directory,
     codexVersion: upstream.raw,
@@ -61634,7 +61714,7 @@ function prepareCompiled(ctx, upstream, ref) {
 
 // src/patch/manifest.ts
 import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 class ManifestError extends Error {
   name = "ManifestError";
 }
@@ -61653,7 +61733,7 @@ var isCandidate = (c) => {
   return parsed !== null && parsed.pre === null;
 };
 function loadManifest(patchesDir) {
-  const file2 = join12(patchesDir, "manifest.json");
+  const file2 = join13(patchesDir, "manifest.json");
   try {
     const raw = JSON.parse(readFileSync9(file2, "utf8"));
     const m2 = raw;
@@ -61679,9 +61759,9 @@ function resolvePatch(m2, v2) {
 }
 
 // src/patch/wrapper.ts
-import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync10, lstatSync as lstatSync3, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync10, readSync, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync11, lstatSync as lstatSync3, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync10, readSync, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var WRAPPER_MARKER = "# cxstatusline-wrapper v1";
 var WRAPPER_MARKER_V2 = "# cxstatusline-wrapper v2";
 var WRAPPER_MARKERS = [WRAPPER_MARKER, WRAPPER_MARKER_V2];
@@ -61740,7 +61820,7 @@ function isSymlink(p2) {
   }
 }
 function stageExecutable(target, write) {
-  mkdirSync6(join13(target, ".."), { recursive: true });
+  mkdirSync6(join14(target, ".."), { recursive: true });
   const tmp = `${target}.tmp-${process.pid}`;
   try {
     write(tmp);
@@ -61757,7 +61837,7 @@ function placeExecutable(target, write) {
   renameSync3(stageExecutable(target, write), target);
 }
 function foreignLauncher(target) {
-  return existsSync10(target) && !isSymlink(target) && !isOurWrapper(target) ? `${target} is a real file we did not write (not a symlink, no cxstatusline marker); refusing to replace it. Move it aside and re-run, or point PATH at a different bin dir.` : null;
+  return existsSync11(target) && !isSymlink(target) && !isOurWrapper(target) ? `${target} is a real file we did not write (not a symlink, no cxstatusline marker); refusing to replace it. Move it aside and re-run, or point PATH at a different bin dir.` : null;
 }
 function assertLauncherReplaceable(paths) {
   const reason = foreignLauncher(paths.wrapperPath);
@@ -61895,7 +61975,7 @@ async function acquireLocked(ctx, initial2, opts, transport) {
     recordFailure(ctx, state, upstream.raw, reason);
     return { kind: "refused", reason };
   }
-  return opts.source === "compiled" ? compiledAcquisition(ctx, state, upstream) : prebuiltAcquisition(ctx, state, upstream, transport);
+  return opts.source === "compiled" ? compiledAcquisition(ctx, state, upstream, transport.onStatus) : prebuiltAcquisition(ctx, state, upstream, transport);
 }
 function install(ctx, state, upstream, source, pair) {
   try {
@@ -61910,7 +61990,7 @@ function install(ctx, state, upstream, source, pair) {
     rmSync5(pair.directory, { recursive: true, force: true });
   }
 }
-function compiledAcquisition(ctx, state, upstream) {
+function compiledAcquisition(ctx, state, upstream, onStatus) {
   let ref;
   try {
     ref = resolvePatch(loadManifest(ctx.patchesDir), upstream);
@@ -61932,7 +62012,7 @@ function compiledAcquisition(ctx, state, upstream) {
   }
   let pair;
   try {
-    pair = prepareCompiled(ctx, upstream, ref);
+    pair = prepareCompiled(ctx, upstream, ref, onStatus);
   } catch (e) {
     const reason = reasonOf(e);
     recordFailure(ctx, state, upstream.raw, reason);
@@ -62004,6 +62084,288 @@ function describeOutcome(o) {
   }
 }
 
+// src/ui/box.ts
+var symbols = {
+  ok: source_default.green("✔"),
+  warn: source_default.yellow("▲"),
+  fail: source_default.red("✖"),
+  info: source_default.cyan("ℹ"),
+  bullet: source_default.dim("●"),
+  activeBullet: source_default.green("●"),
+  dimBullet: source_default.dim("○"),
+  pointer: source_default.cyan("▸"),
+  diamond: source_default.magenta("◇")
+};
+function splitLines(lines) {
+  return lines.flatMap((l) => l.split(`
+`));
+}
+function renderBox(lines, options = {}) {
+  const border = options.borderColor ?? source_default.dim;
+  const flatLines = splitLines(lines);
+  const minWidth = options.minWidth ?? 60;
+  const contentWidth = flatLines.reduce((max2, l) => Math.max(max2, getVisibleWidth(l)), 0);
+  const titleWidth = options.title ? getVisibleWidth(options.title) + (options.badge ? getVisibleWidth(options.badge) + 2 : 0) : 0;
+  const innerWidth = Math.max(minWidth, contentWidth, titleWidth);
+  const topBorder = `${border("╭─")}${border("─".repeat(innerWidth + 2))}${border("─╮")}`;
+  const bottomBorder = `${border("╰─")}${border("─".repeat(innerWidth + 2))}${border("─╯")}`;
+  const renderedLines = [topBorder];
+  if (options.title) {
+    const title = options.title;
+    const badge = options.badge ? `  ${options.badge}` : "";
+    const headerVisible = getVisibleWidth(title) + getVisibleWidth(badge);
+    const rightPad = " ".repeat(Math.max(0, innerWidth - headerVisible));
+    renderedLines.push(`${border("│")}  ${title}${rightPad}${badge}  ${border("│")}`);
+    renderedLines.push(`${border("├─")}${border("─".repeat(innerWidth + 2))}${border("─┤")}`);
+  }
+  for (const line of flatLines) {
+    const pad3 = " ".repeat(Math.max(0, innerWidth - getVisibleWidth(line)));
+    renderedLines.push(`${border("│")}  ${line}${pad3}  ${border("│")}`);
+  }
+  renderedLines.push(bottomBorder);
+  return renderedLines.join(`
+`);
+}
+function renderHeader(title, subtitle, badge, minWidth = 68) {
+  const border = source_default.cyan;
+  const titleVis = getVisibleWidth(title);
+  const badgeVis = badge ? getVisibleWidth(badge) : 0;
+  const subVis = subtitle ? getVisibleWidth(subtitle) : 0;
+  const innerWidth = Math.max(minWidth, titleVis + (badge ? badgeVis + 4 : 0), subVis);
+  const topBorder = `${border("╭─")}${border("─".repeat(innerWidth + 2))}${border("─╮")}`;
+  const bottomBorder = `${border("╰─")}${border("─".repeat(innerWidth + 2))}${border("─╯")}`;
+  const lines = [topBorder];
+  if (badge) {
+    const space = " ".repeat(Math.max(2, innerWidth - titleVis - badgeVis));
+    lines.push(`${border("│")}  ${source_default.bold.white(title)}${space}${source_default.dim(badge)}  ${border("│")}`);
+  } else {
+    const space = " ".repeat(Math.max(0, innerWidth - titleVis));
+    lines.push(`${border("│")}  ${source_default.bold.white(title)}${space}  ${border("│")}`);
+  }
+  if (subtitle) {
+    const space = " ".repeat(Math.max(0, innerWidth - subVis));
+    lines.push(`${border("│")}  ${source_default.dim(subtitle)}${space}  ${border("│")}`);
+  }
+  lines.push(bottomBorder);
+  return lines.join(`
+`);
+}
+function renderSectionTitle(title) {
+  return `  ${symbols.pointer} ${source_default.bold.white(title)}`;
+}
+
+// src/ui/install-format.ts
+function renderInstallHeader(compile3) {
+  const subtitle = compile3 ? "Compiling patched Codex from source" : "Acquiring prebuilt statusline integration for OpenAI Codex";
+  return renderHeader("cxstatusline install", subtitle, `v${VERSION}`);
+}
+function renderInstallSuccess(opts) {
+  const sourceDesc = opts.source === "prebuilt" ? opts.reused ? "prebuilt release (reused existing generation)" : "prebuilt release" : "source build";
+  const hookDesc = `hook ${opts.hookAction} in ${opts.hookFile}`;
+  const lines = [
+    `${symbols.ok}  ${source_default.bold.green("Installation Complete")}`,
+    "",
+    `  ${source_default.dim("Codex Target:")}    ${source_default.bold.white(opts.version)}`,
+    `  ${source_default.dim("Source:")}          ${source_default.cyan(sourceDesc)}`,
+    `  ${source_default.dim("Hook:")}            ${source_default.white(hookDesc)}`,
+    "",
+    source_default.white("Start Codex once and accept the cxstatusline hook when prompted.")
+  ];
+  return renderBox(lines, { borderColor: source_default.green, minWidth: 68 });
+}
+function renderInstallHookError(opts) {
+  const lines = [
+    `${symbols.warn}  ${source_default.bold.yellow("Codex Installed (Hook Notice)")}`,
+    "",
+    `Codex ${opts.version} is installed, but the SessionStart hook could not be written: ${opts.error}`,
+    "",
+    `Fix ${opts.hookFile} by hand, then run \`cxstatusline hook install\`.`
+  ];
+  return renderBox(lines, { borderColor: source_default.yellow, minWidth: 68 });
+}
+function renderInstallFailure(outcome, advice) {
+  const desc = describeOutcome(outcome);
+  const lines = [
+    `${symbols.fail}  ${source_default.bold.red("Installation Incomplete")}`,
+    "",
+    source_default.white(desc)
+  ];
+  if (advice.length > 0) {
+    lines.push("");
+    lines.push(source_default.bold.cyan("Next Steps:"));
+    for (const a of advice) {
+      lines.push(`  ${symbols.pointer} ${a}`);
+    }
+  }
+  return renderBox(lines, { borderColor: source_default.red, minWidth: 68 });
+}
+// src/ui/progress.ts
+function formatBytes2(bytes) {
+  if (bytes <= 0)
+    return "0 B";
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function formatDurationMs(ms2) {
+  if (ms2 < 1000)
+    return `${ms2}ms`;
+  const sec = Math.round(ms2 / 1000);
+  if (sec < 60)
+    return `${(ms2 / 1000).toFixed(1)}s`;
+  const min2 = Math.floor(sec / 60);
+  const remSec = sec % 60;
+  return `${min2}m ${remSec}s`;
+}
+function renderProgressBar(ratio, width = 24) {
+  const clamped = Math.max(0, Math.min(1, Number.isFinite(ratio) ? ratio : 0));
+  const filled = Math.round(clamped * width);
+  const empty = Math.max(0, width - filled);
+  return `[${source_default.cyan("█".repeat(filled))}${source_default.dim("░".repeat(empty))}]`;
+}
+function createInstallProgressTracker(io2, baseTransport = {}) {
+  const isTTY = io2.isTTY ?? (typeof process !== "undefined" && Boolean(process.stdout?.isTTY));
+  let downloadStart = 0;
+  let lastDownloadUpdate = 0;
+  let hasProgressBar = false;
+  let lastReportedPct = -1;
+  const clearProgressLine = () => {
+    if (hasProgressBar && isTTY) {
+      io2.write("\r\x1B[2K");
+      hasProgressBar = false;
+    }
+  };
+  const onProgress = (loaded, total) => {
+    const now2 = Date.now();
+    if (!downloadStart)
+      downloadStart = now2;
+    if (isTTY && now2 - lastDownloadUpdate < 50 && total !== null && loaded < total) {
+      return;
+    }
+    lastDownloadUpdate = now2;
+    const elapsedSec = Math.max(0.001, (now2 - downloadStart) / 1000);
+    const speed = loaded / elapsedSec;
+    const speedStr = `${formatBytes2(speed)}/s`;
+    if (total !== null && total > 0) {
+      const ratio = Math.min(1, loaded / total);
+      const pct = Math.floor(ratio * 100);
+      if (isTTY) {
+        const bar = renderProgressBar(ratio, 24);
+        const loadedStr = formatBytes2(loaded);
+        const totalStr = formatBytes2(total);
+        const text = `\r    ${bar} ${source_default.bold(String(pct).padStart(3))}%  ${loadedStr} / ${totalStr} (${source_default.dim(speedStr)})`;
+        io2.write(text);
+        hasProgressBar = true;
+      } else {
+        const milestone = Math.floor(pct / 25) * 25;
+        if (milestone > lastReportedPct && milestone > 0) {
+          lastReportedPct = milestone;
+          io2.say(`    ${symbols.dimBullet} Downloaded ${milestone}% (${formatBytes2(loaded)} / ${formatBytes2(total)})`);
+        }
+      }
+    } else {
+      if (isTTY) {
+        io2.write(`\r    ${symbols.activeBullet} ${formatBytes2(loaded)} downloaded (${source_default.dim(speedStr)})`);
+        hasProgressBar = true;
+      }
+    }
+  };
+  const onStatus = (phase, message) => {
+    clearProgressLine();
+    switch (phase) {
+      case "manifest":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Release Metadata")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "manifest-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "download":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Downloading Prebuilt Archive")}`);
+        downloadStart = Date.now();
+        lastDownloadUpdate = 0;
+        lastReportedPct = -1;
+        break;
+      case "download-done":
+        clearProgressLine();
+        const duration3 = downloadStart ? ` in ${formatDurationMs(Date.now() - downloadStart)}` : "";
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}${source_default.dim(duration3)}`);
+        break;
+      case "extract":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Verification & Staging")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "extract-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "checkout":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Upstream Source")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "checkout-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "patch":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Statusline Patch")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "patch-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "build":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Compiling Release Binaries")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "build-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "test":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Regression Tests")}`);
+        io2.say(`    ${symbols.dimBullet} ${source_default.dim(message)}`);
+        break;
+      case "test-done":
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      case "stage":
+        io2.say(`
+  ${symbols.pointer} ${source_default.bold("Staging & Activation")}`);
+        io2.say(`    ${symbols.ok} ${source_default.white(message)}`);
+        break;
+      default:
+        io2.say(`    ${symbols.info} ${message}`);
+        break;
+    }
+  };
+  const transport = {
+    ...baseTransport,
+    onProgress: (loaded, total) => {
+      onProgress(loaded, total);
+      baseTransport.onProgress?.(loaded, total);
+    },
+    onStatus: (phase, msg) => {
+      onStatus(phase, msg);
+      baseTransport.onStatus?.(phase, msg);
+    }
+  };
+  return {
+    transport,
+    finish: () => {
+      clearProgressLine();
+    }
+  };
+}
+
 // src/patch/run.ts
 var REPO3 = "adrijshikhar/cxstatusline";
 function simulateDrift(ctx, version2) {
@@ -62065,51 +62427,143 @@ function report(ctx, outcome) {
     for (const line of fallbackAdvice(ctx, outcome.version))
       ctx.say(line);
 }
-function runPatch(ctx, opts) {
-  return runAcquisition(ctx, { source: "compiled", force: opts.force });
+function runPatch(ctx, opts, transport = {}) {
+  ctx.say(renderInstallHeader(true));
+  const progress = createInstallProgressTracker({
+    isTTY: process.stdout?.isTTY,
+    write: (s3) => process.stdout.write(s3),
+    say: (l) => ctx.say(l)
+  }, transport);
+  return runAcquisition(ctx, { source: "compiled", force: opts.force }, progress.transport).finally(() => {
+    progress.finish();
+  });
 }
 async function runInstall(ctx, opts, transport = {}) {
-  const outcome = await runAcquisition(ctx, { source: opts.compile ? "compiled" : "prebuilt", force: true }, transport);
-  report(ctx, outcome);
-  if (outcome.kind !== "installed")
+  ctx.say(renderInstallHeader(opts.compile));
+  const progress = createInstallProgressTracker({
+    isTTY: process.stdout?.isTTY,
+    write: (s3) => process.stdout.write(s3),
+    say: (l) => ctx.say(l)
+  }, transport);
+  let outcome;
+  try {
+    outcome = await runAcquisition(ctx, { source: opts.compile ? "compiled" : "prebuilt", force: true }, progress.transport);
+  } finally {
+    progress.finish();
+  }
+  if (outcome.kind !== "installed") {
+    const advice = outcome.kind === "unavailable" ? fallbackAdvice(ctx, outcome.version) : [];
+    ctx.say(renderInstallFailure(outcome, advice));
     return 1;
+  }
   try {
     const r = installHook(ctx.paths.hooksFile, ctx.cxBin);
-    ctx.say(`hook ${r} in ${ctx.paths.hooksFile}`);
-    if (r === "added")
-      ctx.say("Start Codex once and accept the cxstatusline hook when prompted.");
+    ctx.say(renderInstallSuccess({
+      version: outcome.version,
+      source: outcome.source,
+      reused: outcome.reused,
+      hookAction: r,
+      hookFile: ctx.paths.hooksFile
+    }));
     return 0;
   } catch (e) {
-    ctx.say(`Codex ${outcome.version} is installed, but the SessionStart hook could not be written: ${String(e)}`);
-    ctx.say(`Fix ${ctx.paths.hooksFile} by hand, then run \`cxstatusline hook install\`.`);
+    ctx.say(renderInstallHookError({
+      version: outcome.version,
+      hookFile: ctx.paths.hooksFile,
+      error: String(e)
+    }));
     return 1;
   }
 }
-async function runUpdate(ctx, transport = {}) {
+async function probeUpstreamLatest(fetchFn) {
+  try {
+    const headers = { accept: "application/vnd.github+json", "user-agent": "cxstatusline" };
+    if (process.env.GITHUB_TOKEN)
+      headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+    const res = await fetchFn("https://api.github.com/repos/openai/codex/releases/latest", {
+      headers,
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    if (typeof data.tag_name !== "string")
+      return null;
+    return data.tag_name.replace(/^rust-v/, "");
+  } catch {
+    return null;
+  }
+}
+async function probePrebuiltExists(targetCodexVersion, cxVersion, fetchFn, baseUrl) {
+  try {
+    const tag = releaseTag(cxVersion, targetCodexVersion);
+    const url2 = baseUrl ? `${baseUrl}/${tag}/manifest.json` : `https://github.com/adrijshikhar/cxstatusline/releases/download/${tag}/manifest.json`;
+    const res = await fetchFn(url2, { method: "HEAD", signal: AbortSignal.timeout(5000) });
+    return res.ok || res.status === 302 || res.status === 301;
+  } catch {
+    return false;
+  }
+}
+async function runUpdate(ctx, optsOrTransport = {}, maybeTransport) {
+  const opts = "compile" in optsOrTransport || "force" in optsOrTransport ? optsOrTransport : {};
+  const transport = "baseUrl" in optsOrTransport || "fetch" in optsOrTransport ? optsOrTransport : maybeTransport ?? {};
   const state = loadState(ctx);
   const located = upstreamFor(ctx, state);
   if ("reason" in located) {
     ctx.say(`no upstream Codex to update: ${located.reason}`);
     return 1;
   }
+  const current = readUpstreamVersion(located.bin, ctx.run);
+  const fetchFn = transport.fetch ?? fetch;
+  if (current && !opts.force && !opts.compile) {
+    const latest = await probeUpstreamLatest(fetchFn);
+    if (latest && latest !== current.raw) {
+      const available = await probePrebuiltExists(latest, VERSION, fetchFn, transport.baseUrl);
+      if (!available) {
+        ctx.say(`Warning: Upstream Codex update available: ${current.raw} -> ${latest}.`);
+        ctx.say(`However, cxstatusline has not yet published prebuilt binaries for Codex ${latest}.`);
+        ctx.say("Updating now will replace your patched launcher with stock Codex.");
+        ctx.say("");
+        ctx.say("Options:");
+        ctx.say("  - Wait until cxstatusline publishes prebuilt binaries for this version.");
+        ctx.say("  - Update and compile from source: cxstatusline update --compile");
+        ctx.say("  - Update to stock Codex anyway:   cxstatusline update --force");
+        return 1;
+      }
+    } else if (latest && latest === current.raw) {
+      ctx.say(`Codex is already at the latest version (${current.raw}).`);
+      return 0;
+    }
+  }
   ctx.say(`running upstream updater: ${located.bin} update`);
   const r = ctx.run(located.bin, ["update"], { interactive: true });
   if (r.status !== 0) {
     ctx.say(`upstream updater exited ${String(r.status)}; see its output above. Not installing.`);
     return 1;
   }
-  const outcome = await runAcquisition(ctx, { source: "prebuilt", force: true }, transport);
+  const source = opts.compile ? "compiled" : "prebuilt";
+  const progress = createInstallProgressTracker({
+    isTTY: process.stdout?.isTTY,
+    write: (s3) => process.stdout.write(s3),
+    say: (l) => ctx.say(l)
+  }, transport);
+  let outcome;
+  try {
+    outcome = await runAcquisition(ctx, { source, force: true }, progress.transport);
+  } finally {
+    progress.finish();
+  }
   report(ctx, outcome);
   return outcome.kind === "installed" ? 0 : 1;
 }
 function appendLog(file2, line) {
-  mkdirSync7(join14(file2, ".."), { recursive: true });
+  mkdirSync7(join15(file2, ".."), { recursive: true });
   appendFileSync(file2, `${new Date().toISOString()} ${line}
 `);
 }
 
 // src/hook/run.ts
-import { appendFileSync as appendFileSync2, closeSync as closeSync3, existsSync as existsSync11, mkdirSync as mkdirSync8, openSync as openSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync8, openSync as openSync3 } from "node:fs";
 import { spawn } from "node:child_process";
 import { dirname as dirname9 } from "node:path";
 var HOOK_SOURCES = ["startup", "resume", "clear"];
@@ -62147,11 +62601,11 @@ function locateUpstream(ctx, state) {
 }
 function maintainWrapper(ctx, messages) {
   if (readInstallation(ctx.paths) === null) {
-    if (!existsSync11(ctx.paths.patchedBin)) {
+    if (!existsSync12(ctx.paths.patchedBin)) {
       messages.push(`cxstatusline: the patched binary ${ctx.paths.patchedBin} is missing; Codex is running unpatched. Run \`cxstatusline install\`.`);
       return;
     }
-    if (!existsSync11(ctx.paths.patchedCodeModeHost)) {
+    if (!existsSync12(ctx.paths.patchedCodeModeHost)) {
       messages.push(`cxstatusline: the required Code Mode host ${ctx.paths.patchedCodeModeHost} is missing; run \`cxstatusline install\` to restore it.`);
       return;
     }
@@ -62248,12 +62702,12 @@ function realHookDeps() {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync13, lstatSync as lstatSync4, readFileSync as readFileSync12, readlinkSync as readlinkSync3 } from "node:fs";
+import { existsSync as existsSync14, lstatSync as lstatSync4, readFileSync as readFileSync12, readlinkSync as readlinkSync3 } from "node:fs";
 
 // src/commands/doctor-generation.ts
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute3, join as join15, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute3, join as join16, resolve as resolve4 } from "node:path";
 var line = (key, value, ok = null) => ({ key, value, ok });
 var NO_GENERATION = "n/a (no active generation)";
 function resolvePointerTarget(paths, raw) {
@@ -62298,7 +62752,9 @@ function cxVersionLine(record2) {
   if (!record2)
     return line("cx_version", NO_GENERATION, null);
   const match = record2.provenance.cxVersion === VERSION;
-  return line("cx_version", `running ${VERSION} vs installed ${record2.provenance.cxVersion}`, match);
+  if (match)
+    return line("cx_version", VERSION, true);
+  return line("cx_version", `cli ${VERSION} vs generation ${record2.provenance.cxVersion}`, false);
 }
 function releaseLine(record2) {
   if (!record2)
@@ -62330,8 +62786,8 @@ function upstreamCommitLine(record2) {
 function digestLine(key, label, record2, dir) {
   if (!record2 || !dir)
     return line(label, NO_GENERATION, null);
-  const file2 = join15(dir, key);
-  if (!existsSync12(file2))
+  const file2 = join16(dir, key);
+  if (!existsSync13(file2))
     return line(label, "missing", false);
   let buf;
   try {
@@ -62348,8 +62804,8 @@ function digestLine(key, label, record2, dir) {
 function codexVersionLine(ctx, record2, dir) {
   if (!record2 || !dir)
     return line("codex_version", NO_GENERATION, null);
-  const bin = join15(dir, "codex");
-  if (!existsSync12(bin))
+  const bin = join16(dir, "codex");
+  if (!existsSync13(bin))
     return line("codex_version", "missing", false);
   let result2;
   try {
@@ -62371,7 +62827,7 @@ function legalLine(record2, dir) {
     return line("legal", "n/a (compiled build)", null);
   if (!dir)
     return line("legal", NO_GENERATION, null);
-  const missing = GENERATION_LEGAL_FILES.filter((f2) => !existsSync12(join15(dir, f2)));
+  const missing = GENERATION_LEGAL_FILES.filter((f2) => !existsSync13(join16(dir, f2)));
   return missing.length === 0 ? line("legal", "present", true) : line("legal", `missing: ${missing.join(", ")}`, false);
 }
 function generationDetailLines(ctx, status) {
@@ -62404,11 +62860,136 @@ function bookkeepingLine(state, record2) {
 function legacyLine(paths, record2) {
   if (record2 !== null)
     return null;
-  if (!existsSync12(paths.patchedBin) && !existsSync12(paths.patchedCodeModeHost))
+  if (!existsSync13(paths.patchedBin) && !existsSync13(paths.patchedCodeModeHost))
     return null;
   return line("legacy", "legacy layout: run cxstatusline revert then cxstatusline install", false);
 }
 
+// src/commands/doctor-format.ts
+var SECTIONS = [
+  {
+    title: "Core & Environment",
+    keys: ["renderer", "settings", "platform", "toolchain"]
+  },
+  {
+    title: "Codex Integration",
+    keys: ["upstream", "wrapper", "hook", "policy", "drift"]
+  },
+  {
+    title: "Active Generation & Binaries",
+    keys: [
+      "active",
+      "generation",
+      "cx_version",
+      "release",
+      "patch",
+      "source_commit",
+      "upstream_commit",
+      "codex_digest",
+      "host_digest",
+      "codex_version",
+      "legal",
+      "bookkeeping",
+      "legacy"
+    ]
+  },
+  {
+    title: "State & Locks",
+    keys: ["state", "patched_from", "last_attempt", "lock"]
+  }
+];
+function formatValue(raw, ok) {
+  const value = String(raw ?? "");
+  if (ok === false)
+    return source_default.red(value);
+  if (value === "absent" || value === "none" || value === "never" || value.startsWith("n/a")) {
+    return source_default.dim(value);
+  }
+  if (value === "free" || value === "ours" || value === "darwin-arm64" || value === "darwin-x64") {
+    return source_default.green(value);
+  }
+  return source_default.white(value);
+}
+function statusBullet(ok) {
+  if (ok === true)
+    return symbols.ok;
+  if (ok === false)
+    return symbols.fail;
+  return symbols.dimBullet;
+}
+function renderSummary(lines) {
+  const failures = lines.filter((l) => l.ok === false);
+  const driftLine = lines.find((l) => l.key === "drift");
+  if (failures.length > 0) {
+    const count = failures.length;
+    const word = count === 1 ? "issue" : "issues";
+    const detail = driftLine && driftLine.ok === false ? "Run `cxstatusline install` to update to the current Codex version." : "Check the failed items above for instructions.";
+    return renderBox([
+      `${symbols.fail}  ${source_default.bold.red(`${count} ${word} detected`)}`,
+      `   ${source_default.dim(detail)}`
+    ], { borderColor: source_default.red, minWidth: 68 });
+  }
+  return renderBox([
+    `${symbols.ok}  ${source_default.bold.green("All systems operational")}`,
+    `   ${source_default.dim("Statusline is configured and active for OpenAI Codex.")}`
+  ], { borderColor: source_default.green, minWidth: 68 });
+}
+function singleLineSummary(text) {
+  const lines = text.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  if (lines.length <= 1)
+    return text;
+  const match = /^(failed\s+\S+\s+at\s+[0-9T:.-]+Z?):\s*(.*)/.exec(lines[0]);
+  const prefix = match ? match[1] : lines[0].split(":")[0] ?? "failed";
+  const errorLine = lines.find((l) => /^error(\[[A-Z0-9]+\])?:/i.test(l)) ?? lines.find((l) => /^failed to/i.test(l)) ?? lines.find((l) => /panic/i.test(l)) ?? lines[lines.length - 1];
+  return `${prefix}: ${errorLine}`;
+}
+function formatDiagnosticLine(item, maxKeyWidth) {
+  const bullet = statusBullet(item.ok);
+  const key = source_default.cyan(item.key.padEnd(maxKeyWidth));
+  const summary = singleLineSummary(String(item.value ?? ""));
+  const val = formatValue(summary, item.ok);
+  return `    ${bullet} ${key}  ${val}`;
+}
+function formatDoctorPretty(lines) {
+  const lineMap = new Map(lines.map((l) => [l.key, l]));
+  const seen = new Set;
+  const maxKeyWidth = lines.reduce((max2, l) => Math.max(max2, l.key.length), 0);
+  const parts = [
+    renderHeader("cxstatusline doctor", "Diagnostics & System Health", `v${VERSION}`),
+    ""
+  ];
+  for (const section of SECTIONS) {
+    const sectionLines = [];
+    for (const key of section.keys) {
+      const entry = lineMap.get(key);
+      if (entry) {
+        sectionLines.push(entry);
+        seen.add(key);
+      }
+    }
+    if (sectionLines.length === 0)
+      continue;
+    parts.push(renderSectionTitle(section.title));
+    for (const item of sectionLines) {
+      parts.push(formatDiagnosticLine(item, maxKeyWidth));
+    }
+    parts.push("");
+  }
+  const extra = lines.filter((l) => !seen.has(l.key));
+  if (extra.length > 0) {
+    parts.push(renderSectionTitle("Other Diagnostics"));
+    for (const item of extra) {
+      parts.push(formatDiagnosticLine(item, maxKeyWidth));
+    }
+    parts.push("");
+  }
+  parts.push(renderSummary(lines));
+  return `${parts.join(`
+`)}
+`;
+}
+
 // src/commands/doctor.ts
 var line2 = (key, value, ok = null) => ({ key, value, ok });
 function wrapperLine(ctx) {
@@ -62424,7 +63005,7 @@ function wrapperLine(ctx) {
   return isOurWrapper(p2) ? line2("wrapper", "ours", true) : line2("wrapper", "foreign file! not ours, not a symlink", false);
 }
 function hookLine(ctx) {
-  if (!existsSync13(ctx.paths.hooksFile))
+  if (!existsSync14(ctx.paths.hooksFile))
     return line2("hook", "absent");
   try {
     const f2 = JSON.parse(readFileSync12(ctx.paths.hooksFile, "utf8"));
@@ -62480,7 +63061,7 @@ function doctorReport(ctx) {
   };
   const lines = [
     line2("renderer", `${ctx.cxBin} (${VERSION})`),
-    line2("settings", `${ctx.paths.settingsFile} ${existsSync13(ctx.paths.settingsFile) ? "present" : "absent (written on first render)"}`),
+    line2("settings", `${ctx.paths.settingsFile} ${existsSync14(ctx.paths.settingsFile) ? "present" : "absent (written on first render)"}`),
     upstreamLine(ctx, upstreamBin, upstream?.raw ?? null, lookupNote),
     line2("state", corrupt ? `${ctx.paths.stateFile} CORRUPT (recovered from ${ctx.paths.stateBackupFile} where possible)` : ctx.paths.stateFile, corrupt ? false : null),
     line2("patched_from", state.patched_from ?? "never"),
@@ -62500,16 +63081,12 @@ function doctorReport(ctx) {
   return lines.filter((l) => l !== null);
 }
 function formatDoctor(lines) {
-  const mark = (ok) => ok === null ? " " : ok ? "✓" : "✗";
-  const width = Math.max(...lines.map((l) => l.key.length));
-  return `${lines.map((l) => `${mark(l.ok)} ${l.key.padEnd(width)}  ${l.value}`).join(`
-`)}
-`;
+  return formatDoctorPretty(lines);
 }
 
 // src/commands/revert.ts
-import { existsSync as existsSync14, lstatSync as lstatSync5, readdirSync as readdirSync2, rmSync as rmSync6, symlinkSync as symlinkSync2 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync15, lstatSync as lstatSync5, readdirSync as readdirSync2, rmSync as rmSync6, symlinkSync as symlinkSync2 } from "node:fs";
+import { join as join17 } from "node:path";
 function safeIsSymlink(p2) {
   try {
     return lstatSync5(p2).isSymbolicLink();
@@ -62530,11 +63107,11 @@ function revert(ctx) {
 }
 function removeGenerations(ctx, actions) {
   const { currentGeneration, generationsDir } = ctx.paths;
-  if (existsSync14(currentGeneration) || safeIsSymlink(currentGeneration)) {
+  if (existsSync15(currentGeneration) || safeIsSymlink(currentGeneration)) {
     rmSync6(currentGeneration, { recursive: true, force: true });
     actions.push(`removed generation pointer ${currentGeneration}`);
   }
-  if (!existsSync14(generationsDir))
+  if (!existsSync15(generationsDir))
     return;
   let removed = 0;
   for (const dir of listGenerations(ctx.paths)) {
@@ -62552,11 +63129,11 @@ function removeGenerations(ctx, actions) {
 var OWNED_LIBEXEC_PREFIXES = ["current.", "staging-", "download-", "compiled-"];
 function removeStagingDebris(ctx, actions) {
   const { libexecDir } = ctx.paths;
-  if (!existsSync14(libexecDir))
+  if (!existsSync15(libexecDir))
     return;
   const debris = readdirSync2(libexecDir).filter((n) => OWNED_LIBEXEC_PREFIXES.some((p2) => n.startsWith(p2)));
   for (const name of debris)
-    rmSync6(join16(libexecDir, name), { recursive: true, force: true });
+    rmSync6(join17(libexecDir, name), { recursive: true, force: true });
   if (debris.length > 0) {
     actions.push(`removed ${debris.length} leftover staging entr${debris.length === 1 ? "y" : "ies"} from ${libexecDir}`);
   }
@@ -62568,7 +63145,7 @@ function revertLocked(ctx) {
   if (corrupt)
     actions.push(`state.json was corrupt; used ${ctx.paths.stateBackupFile} where possible`);
   const w2 = ctx.paths.wrapperPath;
-  if (existsSync14(w2) || safeIsSymlink(w2)) {
+  if (existsSync15(w2) || safeIsSymlink(w2)) {
     if (isOurWrapper(w2)) {
       rmSync6(w2);
       actions.push(`removed wrapper ${w2}`);
@@ -62584,11 +63161,11 @@ function revertLocked(ctx) {
   }
   removeGenerations(ctx, actions);
   removeStagingDebris(ctx, actions);
-  if (existsSync14(ctx.paths.patchedBin)) {
+  if (existsSync15(ctx.paths.patchedBin)) {
     rmSync6(ctx.paths.patchedBin);
     actions.push(`removed patched binary ${ctx.paths.patchedBin}`);
   }
-  if (existsSync14(ctx.paths.patchedCodeModeHost)) {
+  if (existsSync15(ctx.paths.patchedCodeModeHost)) {
     rmSync6(ctx.paths.patchedCodeModeHost);
     actions.push(`removed Code Mode host ${ctx.paths.patchedCodeModeHost}`);
   }
@@ -64038,9 +64615,9 @@ function MainMenu({ onSelect, initialSelection = 0, hasChanges = false }) {
 }
 
 // src/tui/components/PowerlineSetup.tsx
-import { existsSync as existsSync15, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync16, readdirSync as readdirSync3 } from "node:fs";
 import { homedir as homedir2, platform as platform2 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var import_react40 = __toESM(require_react(), 1);
 
 // src/utils/powerline-settings.ts
@@ -64425,9 +65002,9 @@ function buildPowerlineSetupMenuItems(powerline) {
   ];
 }
 function detectPowerlineFont() {
-  const dirs = platform2() === "darwin" ? [join17(homedir2(), "Library", "Fonts"), "/Library/Fonts"] : platform2() === "win32" ? [join17(homedir2(), "AppData", "Local", "Microsoft", "Windows", "Fonts"), "C:\\Windows\\Fonts"] : [join17(homedir2(), ".local", "share", "fonts"), join17(homedir2(), ".fonts"), "/usr/share/fonts"];
+  const dirs = platform2() === "darwin" ? [join18(homedir2(), "Library", "Fonts"), "/Library/Fonts"] : platform2() === "win32" ? [join18(homedir2(), "AppData", "Local", "Microsoft", "Windows", "Fonts"), "C:\\Windows\\Fonts"] : [join18(homedir2(), ".local", "share", "fonts"), join18(homedir2(), ".fonts"), "/usr/share/fonts"];
   try {
-    return dirs.some((dir) => existsSync15(dir) && readdirSync3(dir).some((file2) => /powerline|nerd font|meslo.*lg/i.test(file2)));
+    return dirs.some((dir) => existsSync16(dir) && readdirSync3(dir).some((file2) => /powerline|nerd font|meslo.*lg/i.test(file2)));
   } catch {
     return false;
   }
@@ -64950,7 +65527,7 @@ var USAGE = `usage: cxstatusline [command]
   install [--compile]         install the published Codex pair (--compile builds it from source)
   patch [--force]             build and install the patched Codex from source
   patch --simulate-drift <v>  record <v> as the installed version so the next session sees drift
-  update                      run upstream's own updater, then install the pair for it
+  update [--compile|--force]  run upstream's own updater, then install the pair for it
   hook [install|uninstall]    manage the SessionStart entry; bare 'hook' is what Codex runs
   doctor                      report toolchain, drift, hook and wrapper state
   revert                      restore stock Codex; keep settings
@@ -64999,7 +65576,19 @@ async function installCommand(argv, io2, deps) {
     io2.stderr(USAGE);
     return 2;
   }
-  return runInstall(contextFor(io2, deps), { compile: flags[0] === "--compile" });
+  return runInstall(contextFor(io2, deps), { compile: flags[0] === "--compile" }, deps.transport);
+}
+async function updateCommand(argv, io2, deps) {
+  const flags = argv.slice(1);
+  const allowed = new Set(["--compile", "--force", "-y", "--yes"]);
+  if (flags.some((f2) => !allowed.has(f2))) {
+    io2.stderr(USAGE);
+    return 2;
+  }
+  return runUpdate(contextFor(io2, deps), {
+    compile: flags.includes("--compile"),
+    force: flags.includes("--force") || flags.includes("-y") || flags.includes("--yes")
+  }, deps.transport);
 }
 async function hookAcquireCommand(io2, deps) {
   const ctx = contextFor(io2, deps);
@@ -65058,7 +65647,7 @@ async function main(argv, io2, deps = {}) {
   if (cmd === "patch")
     return patchCommand(argv, io2, deps);
   if (cmd === "update")
-    return runUpdate(contextFor(io2, deps));
+    return updateCommand(argv, io2, deps);
   if (cmd === "install")
     return installCommand(argv, io2, deps);
   if (cmd === "hook" && (argv[1] === "install" || argv[1] === "uninstall")) {