cxstatusline 0.10.1 → 0.13.0

package/dist/cxstatusline.js

@@ -27133,7 +27133,7 @@ var require_jsx_dev_runtime = __commonJS(function(exports, module) {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 
 // src/main.ts
 import { freemem, platform as platform3, totalmem } from "node:os";
@@ -56307,7 +56307,14 @@ function resolveLiveSpeedMetrics(context, windowSeconds) {
           totalTokens: 0,
           requestCount: 0
         },
-        lastActiveTimeMs: nowMs
+        lastActiveTimeMs: nowMs,
+        sessionCumulativeMetrics: {
+          totalDurationMs: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          requestCount: 0
+        }
       };
       writeCache(context.commandCacheDir, initialCache);
       return {
@@ -56329,18 +56336,29 @@ function resolveLiveSpeedMetrics(context, windowSeconds) {
     });
     let nextLastActiveMetrics = { ...cached2.lastActiveMetrics };
     let nextLastActiveTimeMs = cached2.lastActiveTimeMs;
+    let nextSessionCumulative = cached2.sessionCumulativeMetrics ? { ...cached2.sessionCumulativeMetrics } : { ...cached2.lastActiveMetrics };
     let nextLastSample = cached2.lastSample;
     if ((deltaInput > 0 || deltaOutput > 0) && elapsedSinceLastSec >= 0.2) {
       const instInput = deltaInput > 0 ? deltaInput / elapsedSinceLastSec : 0;
       const instOutput = deltaOutput > 0 ? deltaOutput / elapsedSinceLastSec : 0;
       if (instOutput <= MAX_PLAUSIBLE_OUTPUT_SPEED && instInput <= MAX_PLAUSIBLE_INPUT_SPEED) {
+        const deltaDurationMs = Math.round(elapsedSinceLastSec * 1000);
+        const validDeltaIn = Math.max(0, deltaInput);
+        const validDeltaOut = Math.max(0, deltaOutput);
         nextLastActiveMetrics = {
-          totalDurationMs: Math.round(elapsedSinceLastSec * 1000),
-          inputTokens: Math.max(0, deltaInput),
-          outputTokens: Math.max(0, deltaOutput),
-          totalTokens: Math.max(0, deltaInput) + Math.max(0, deltaOutput),
+          totalDurationMs: deltaDurationMs,
+          inputTokens: validDeltaIn,
+          outputTokens: validDeltaOut,
+          totalTokens: validDeltaIn + validDeltaOut,
           requestCount: cached2.lastActiveMetrics.requestCount + 1
         };
+        nextSessionCumulative = {
+          totalDurationMs: nextSessionCumulative.totalDurationMs + deltaDurationMs,
+          inputTokens: nextSessionCumulative.inputTokens + validDeltaIn,
+          outputTokens: nextSessionCumulative.outputTokens + validDeltaOut,
+          totalTokens: nextSessionCumulative.totalTokens + validDeltaIn + validDeltaOut,
+          requestCount: nextSessionCumulative.requestCount + 1
+        };
         nextLastActiveTimeMs = nowMs;
         nextLastSample = {
           timeMs: nowMs,
@@ -56348,13 +56366,20 @@ function resolveLiveSpeedMetrics(context, windowSeconds) {
           outputTokens: rawOutput
         };
       }
+    } else if (deltaInput === 0 && deltaOutput === 0 && (session?.run_state === "ready" || elapsedSinceLastSec >= 5)) {
+      nextLastSample = {
+        timeMs: nowMs,
+        inputTokens: rawInput,
+        outputTokens: rawOutput
+      };
     }
     const updatedCache = {
       ...cached2,
       lastSample: nextLastSample,
       samples,
       lastActiveMetrics: nextLastActiveMetrics,
-      lastActiveTimeMs: nextLastActiveTimeMs
+      lastActiveTimeMs: nextLastActiveTimeMs,
+      sessionCumulativeMetrics: nextSessionCumulative
     };
     writeCache(context.commandCacheDir, updatedCache);
     if (windowSeconds && windowSeconds > 0) {
@@ -56382,7 +56407,10 @@ function resolveLiveSpeedMetrics(context, windowSeconds) {
         requestCount: 0
       };
     }
-    if (nextLastActiveTimeMs && nowMs - nextLastActiveTimeMs <= 60000 && nextLastActiveMetrics.totalDurationMs > 0) {
+    if (nextSessionCumulative.totalDurationMs > 0) {
+      return nextSessionCumulative;
+    }
+    if (nextLastActiveMetrics.totalDurationMs > 0) {
       return nextLastActiveMetrics;
     }
     return {
@@ -59007,8 +59035,8 @@ function runRefreshCommand(cacheKey2, deps) {
   return 0;
 }
 // src/version-info.ts
-var VERSION = "0.10.1";
-var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("cb2f6799d53ce95398331bae1cea4f96d2c9641e") ? "cb2f6799d53ce95398331bae1cea4f96d2c9641e" : null;
+var VERSION = "0.13.0";
+var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("4e5293425d1f37dde096fb5a49ebfd3b67fd62bb") ? "4e5293425d1f37dde096fb5a49ebfd3b67fd62bb" : null;
 var SOURCE_DIRTY = false;
 
 // src/context.ts
@@ -59018,8 +59046,81 @@ import { fileURLToPath } from "node:url";
 
 // src/patch/preflight.ts
 import { accessSync, constants as constants2, existsSync as existsSync2, statfsSync } from "node:fs";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/patch/package-assemble.ts
+import { join as join7 } from "node:path";
+var PYTHON_CANDIDATES = ["python3.13", "python3.12", "python3.11", "python3.10", "python3"];
+var PYTHON_VERSION_CHECK = "import sys; sys.exit(sys.version_info < (3, 10))";
+function assembleArgs(input2) {
+  const args = [
+    join7(input2.upstream, "scripts", "build_codex_package.py"),
+    "--variant",
+    "codex",
+    "--target",
+    input2.target,
+    "--package-version",
+    input2.codexVersion,
+    "--entrypoint-bin",
+    input2.codex,
+    "--code-mode-host-bin",
+    input2.codeModeHost,
+    "--cargo",
+    input2.cargo,
+    "--cargo-profile",
+    "release",
+    "--package-dir",
+    input2.packageDir
+  ];
+  if (input2.bwrapBin)
+    args.push("--bwrap-bin", input2.bwrapBin);
+  if (input2.force)
+    args.push("--force");
+  return args;
+}
+function assembleEnv(input2, base2 = process.env) {
+  const keep = ["PATH", "HOME", "CARGO_HOME", "RUSTUP_HOME", "HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY", "https_proxy", "http_proxy", "no_proxy", "SSL_CERT_FILE", "RUSTC_WRAPPER", "SCCACHE_DIR"];
+  const env3 = {};
+  for (const key of keep)
+    if (base2[key] !== undefined)
+      env3[key] = base2[key];
+  env3.CODEX_REPO_ROOT = input2.upstream;
+  env3.TMPDIR = input2.tmpDir;
+  return env3;
+}
+function assemblePackage(input2, run, log) {
+  const args = assembleArgs(input2);
+  log(`$ ${[input2.python, ...args].join(" ")}`);
+  const r = run(input2.python, args, { cwd: input2.upstream, env: assembleEnv(input2) });
+  for (const line of `${r.stdout}${r.stderr}`.split(`
+`).filter(Boolean))
+    log(line);
+  if (r.status !== 0) {
+    throw new Error(`build_codex_package.py failed (exit ${String(r.status)}): ${(r.stderr || r.stdout).trim().split(`
+`).slice(-12).join(`
+`)}`);
+  }
+}
+function findPython(which, run) {
+  for (const candidate of PYTHON_CANDIDATES) {
+    const bin = which(candidate);
+    if (bin === null)
+      continue;
+    if (run(bin, ["-c", PYTHON_VERSION_CHECK]).status === 0)
+      return bin;
+  }
+  return null;
+}
+function rustcHostTarget(run) {
+  const r = run("rustc", ["-vV"]);
+  const host = /^host:\s*(\S+)\s*$/m.exec(r.stdout)?.[1];
+  if (r.status !== 0 || !host)
+    throw new Error(`rustc -vV did not report a host target: ${(r.stderr || r.stdout).trim().slice(0, 200)}`);
+  return host;
+}
+
+// src/patch/preflight.ts
 var MIN_FREE_BYTES = 20 * 1024 ** 3;
 var MIN_STAGING_FREE_BYTES = 2 * 1024 ** 3;
 var REQUIRED_TOOLCHAIN = "1.95.0";
@@ -59056,6 +59157,15 @@ function preflight(deps, shareDir) {
   const toolchain = checkToolchain(deps);
   if (!toolchain.ok)
     return toolchain;
+  if (findPython(deps.which, deps.run) === null) {
+    return no("Python >= 3.10 is not on PATH; Codex's package is assembled by upstream's Python packager", "brew install python   (or apt install python3), then reopen your shell");
+  }
+  if (process.platform === "linux" && !deps.which("bwrap")) {
+    const libcap = deps.run("pkg-config", ["--exists", "libcap"]);
+    if (!deps.which("pkg-config") || libcap.status !== 0) {
+      return no("bubblewrap is not on PATH and libcap-dev is not installed; Codex's Linux package needs one of them for its sandbox", "apt install bubblewrap   (or apt install libcap-dev pkg-config), then re-run");
+    }
+  }
   const free = deps.freeBytes(shareDir);
   if (free < MIN_FREE_BYTES) {
     return no(`${gib(free)} free at ${shareDir}; a Codex release build needs 20 GiB`, "free disk space or point XDG_DATA_HOME elsewhere");
@@ -59079,7 +59189,7 @@ function prebuiltPreflight(deps, paths) {
 }
 function whichReal(cmd) {
   for (const dir of (process.env.PATH ?? "").split(":").filter(Boolean)) {
-    const p = join7(dir, cmd);
+    const p = join8(dir, cmd);
     try {
       accessSync(p, constants2.X_OK);
       return p;
@@ -59149,8 +59259,8 @@ function realContext(env3, io) {
 }
 
 // src/patch/run.ts
-import { appendFileSync, mkdirSync as mkdirSync8, rmSync as rmSync6 } from "node:fs";
-import { join as join18 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync9, rmSync as rmSync6 } from "node:fs";
+import { join as join19 } from "node:path";
 
 // src/lock.ts
 import { closeSync, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync4, unlinkSync as unlinkSync3, writeSync } from "node:fs";
@@ -59204,11 +59314,6 @@ function acquireLock(file2, isAlive = pidAlive) {
   return null;
 }
 
-// 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"];
 var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
@@ -59258,20 +59363,95 @@ function behindWithinMinor(upstream, patched) {
 }
 
 // src/distribution/prebuilt.ts
-import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync2 } from "node:fs";
-import { join as join11 } from "node:path";
+import { chmodSync as chmodSync2, copyFileSync, mkdirSync as mkdirSync6, mkdtempSync, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync2 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/patch/generation.ts
-import { chmodSync, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, readlinkSync, realpathSync as realpathSync2, renameSync as renameSync2, rmSync, statSync, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
-import { dirname as dirname6, isAbsolute, join as join8, resolve as resolve2, sep } from "node:path";
-var INSTALLATION_FILE = "installation.json";
-var SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+import { chmodSync, cpSync, existsSync as existsSync5, lstatSync as lstatSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync2, readlinkSync, realpathSync as realpathSync2, renameSync as renameSync2, rmSync, statSync, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { dirname as dirname6, isAbsolute, join as join9, relative, resolve as resolve2, sep } from "node:path";
+
+// src/digest.ts
+import { createHash as createHash2 } from "node:crypto";
+import { createReadStream, readFileSync as readFileSync5 } from "node:fs";
 function digestOf(file2) {
   const buf = readFileSync5(file2);
   return { sha256: createHash2("sha256").update(buf).digest("hex"), size: buf.length };
 }
+
+// src/patch/generation.ts
+var INSTALLATION_FILE = "installation.json";
+var GENERATION_EXECUTABLES = ["codex", "codex-code-mode-host"];
+var GENERATION_LEGAL_FILES = ["LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"];
+var SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var ROOT_ALIAS = "codex";
+function isPackageLayout(dir) {
+  return existsSync5(join9(dir, "bin", "codex")) && existsSync5(join9(dir, "codex-package.json"));
+}
+function executablePath(dir, name) {
+  return isPackageLayout(dir) ? join9(dir, "bin", name) : join9(dir, name);
+}
+var PackageMetadata = exports_external.object({
+  version: exports_external.string(),
+  target: exports_external.string(),
+  entrypoint: exports_external.string()
+}).passthrough();
+function verifyPackage(dir, files, expect) {
+  for (const [name, want] of Object.entries(files)) {
+    const file2 = join9(dir, name);
+    let st;
+    try {
+      st = lstatSync3(file2);
+    } catch {
+      return `${name} is missing`;
+    }
+    if (!st.isFile())
+      return `${name} is not a regular file`;
+    const executable = (st.mode & 73) !== 0;
+    if (executable !== (modeFor(name) === 493))
+      return `${name} has the wrong executable bit`;
+    const got = digestOf(file2);
+    if (got.sha256 !== want.sha256 || got.size !== want.size)
+      return `${name} does not match its recorded digest`;
+  }
+  let metadata;
+  try {
+    metadata = PackageMetadata.parse(JSON.parse(readFileSync6(join9(dir, "codex-package.json"), "utf8")));
+  } catch (e) {
+    return `codex-package.json is unreadable: ${e instanceof Error ? e.message.split(`
+`)[0] : String(e)}`;
+  }
+  if (metadata.entrypoint !== "bin/codex")
+    return `codex-package.json entrypoint is ${JSON.stringify(metadata.entrypoint)}, not "bin/codex"`;
+  if (metadata.target !== expect.target)
+    return `codex-package.json target is ${metadata.target}, expected ${expect.target}`;
+  if (metadata.version !== expect.codexVersion)
+    return `codex-package.json version is ${metadata.version}, expected ${expect.codexVersion}`;
+  return null;
+}
+function packageFiles(dir) {
+  const out = {};
+  const walk = (current) => {
+    for (const name of readdirSync2(current).sort()) {
+      const path = join9(current, name);
+      const rel = relative(dir, path).split(sep).join("/");
+      const st = lstatSync3(path);
+      if (rel === INSTALLATION_FILE || rel === ROOT_ALIAS && st.isSymbolicLink())
+        continue;
+      if (st.isSymbolicLink())
+        throw new Error(`${rel} is a symbolic link; a Codex package may only contain regular files`);
+      if (st.isDirectory()) {
+        walk(path);
+        continue;
+      }
+      if (!st.isFile())
+        throw new Error(`${rel} is not a regular file`);
+      out[rel] = digestOf(path);
+    }
+  };
+  walk(dir);
+  return out;
+}
 function stamp(installedAt) {
   const parsed = new Date(installedAt);
   const when = Number.isNaN(parsed.getTime()) ? new Date : parsed;
@@ -59302,40 +59482,31 @@ function validateStaging(pair) {
   if (!SAFE_SEGMENT.test(pair.codexVersion)) {
     throw new Error(`prepared pair has an unusable codexVersion "${pair.codexVersion}"`);
   }
-  for (const name of GENERATION_EXECUTABLES) {
-    const file2 = join8(pair.directory, name);
-    if (!existsSync5(file2))
-      throw new Error(`staged pair is missing ${name}`);
-    const want = pair.provenance.executables[name];
-    const got = digestOf(file2);
-    if (got.sha256 !== want.sha256 || got.size !== want.size) {
-      throw new Error(`staged ${name} does not match its recorded digest; refusing to install it`);
-    }
-  }
+  const problem = verifyPackage(pair.directory, pair.provenance.files, { target: pair.provenance.target, codexVersion: pair.codexVersion });
+  if (problem !== null)
+    throw new Error(`staged package is not the one its provenance describes: ${problem}; refusing to install it`);
   if (pair.provenance.source === "prebuilt") {
     for (const name of GENERATION_LEGAL_FILES) {
-      if (!existsSync5(join8(pair.directory, name)))
+      if (!(name in pair.provenance.files) || !existsSync5(join9(pair.directory, name)))
         throw new Error(`prebuilt pair is missing ${name}`);
     }
   }
+  for (const name of GENERATION_EXECUTABLES) {
+    const want = pair.provenance.files[`bin/${name}`];
+    if (!want)
+      throw new Error(`staged pair is missing bin/${name}`);
+    const got = digestOf(join9(pair.directory, "bin", name));
+    if (got.sha256 !== want.sha256 || got.size !== want.size) {
+      throw new Error(`staged bin/${name} does not match its recorded digest; refusing to install it`);
+    }
+  }
 }
 function installationRecord(pair) {
   const { directory: _staging, ...record2 } = pair;
   return record2;
 }
-function copyInto(from, into, name, mode, expected) {
-  const target = join8(into, name);
-  copyFileSync(join8(from, name), target);
-  chmodSync(target, mode);
-  if (!expected)
-    return;
-  const got = digestOf(target);
-  if (got.sha256 !== expected.sha256 || got.size !== expected.size) {
-    throw new Error(`${name} did not survive the copy into the new generation intact`);
-  }
-}
 function commitJson(file2, value, rename2) {
-  const tmp = join8(dirname6(file2), `.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`);
+  const tmp = join9(dirname6(file2), `.${process.pid}.${randomBytes2(4).toString("hex")}.tmp`);
   try {
     writeFileSync2(tmp, `${JSON.stringify(value, null, 2)}
 `);
@@ -59345,27 +59516,30 @@ function commitJson(file2, value, rename2) {
     throw e;
   }
 }
-function freshDirectory(pair, paths) {
+var GENERATION_NAME = /^\d+\.\d+\.\d+-\d{8}T\d{6}-[0-9a-f]{6}$/;
+function freshName(pair, paths) {
   mkdirSync4(paths.generationsDir, { recursive: true });
   for (;; ) {
-    const dir = join8(paths.generationsDir, `${pair.codexVersion}-${stamp(pair.provenance.installedAt)}-${randomBytes2(3).toString("hex")}`);
-    if (existsSync5(dir))
-      continue;
-    mkdirSync4(dir);
-    return dir;
+    const dir = join9(paths.generationsDir, `${pair.codexVersion}-${stamp(pair.provenance.installedAt)}-${randomBytes2(3).toString("hex")}`);
+    if (!existsSync5(dir))
+      return dir;
   }
 }
 function createGeneration(pair, paths, rename2 = renameSync2) {
   validateStaging(pair);
-  const dir = freshDirectory(pair, paths);
+  const dir = freshName(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 (existsSync5(join8(pair.directory, name)))
-        copyInto(pair.directory, dir, name, 420);
-    }
-    commitJson(join8(dir, INSTALLATION_FILE), installationRecord(pair), rename2);
+    rename2(pair.directory, dir);
+  } catch (e) {
+    if (e.code !== "EXDEV")
+      throw e;
+    cpSync(pair.directory, dir, { recursive: true, verbatimSymlinks: true });
+    rmSync(pair.directory, { recursive: true, force: true });
+  }
+  try {
+    chmodSync(dir, 493);
+    symlinkSync("bin/codex", join9(dir, ROOT_ALIAS));
+    commitJson(join9(dir, INSTALLATION_FILE), installationRecord(pair), rename2);
   } catch (e) {
     rmSync(dir, { recursive: true, force: true });
     throw e;
@@ -59373,11 +59547,11 @@ function createGeneration(pair, paths, rename2 = renameSync2) {
   return dir;
 }
 function isGenerationDir(dir) {
-  return existsSync5(join8(dir, INSTALLATION_FILE)) && existsSync5(join8(dir, "codex"));
+  return existsSync5(join9(dir, INSTALLATION_FILE)) && isPackageLayout(dir);
 }
 function listGenerations(paths) {
   try {
-    return readdirSync2(paths.generationsDir).map((name) => join8(paths.generationsDir, name)).sort();
+    return readdirSync2(paths.generationsDir).map((name) => join9(paths.generationsDir, name)).sort();
   } catch {
     return [];
   }
@@ -59441,7 +59615,9 @@ var RecordSchema = exports_external.object({
     sourceCommit: exports_external.string().regex(HEX40, "sourceCommit must be 40 lowercase hex chars").nullable(),
     sourceDirty: exports_external.boolean(),
     installedAt: exports_external.string(),
-    executables: exports_external.object({ codex: DigestSchema, "codex-code-mode-host": DigestSchema }),
+    target: exports_external.string().optional(),
+    files: exports_external.record(exports_external.string(), DigestSchema).optional(),
+    executables: exports_external.object({ codex: DigestSchema, "codex-code-mode-host": DigestSchema }).optional(),
     release: exports_external.object({
       tag: exports_external.string(),
       archiveSha256: exports_external.string().regex(HEX64, "archiveSha256 must be 64 lowercase hex chars"),
@@ -59475,7 +59651,7 @@ function readInstallation(paths) {
   if (dir === null)
     return null;
   try {
-    const raw = JSON.parse(readFileSync5(join8(dir, INSTALLATION_FILE), "utf8"));
+    const raw = JSON.parse(readFileSync6(join9(dir, INSTALLATION_FILE), "utf8"));
     return checkedRecord(raw);
   } catch {
     return null;
@@ -59483,8 +59659,8 @@ function readInstallation(paths) {
 }
 
 // src/distribution/archive.ts
-import { createReadStream, createWriteStream } from "node:fs";
-import { join as join9 } from "node:path";
+import { createReadStream as createReadStream2, createWriteStream, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname7, join as join10 } from "node:path";
 import { createGunzip } from "node:zlib";
 
 // node_modules/tar/dist/esm/index.min.js
@@ -62710,13 +62886,12 @@ var To = (s3) => {
 };
 
 // src/distribution/archive.ts
-var ALLOWED = ARTIFACT_FILES;
 var EXTRACTED_TOTAL_LIMIT = 2 * 1024 * 1024 * 1024;
 var LEGAL_TOTAL_LIMIT = 16 * 1024 * 1024;
 var EXECUTABLE_MODE = 493;
 var LEGAL_MODE = 420;
 function isExecutable(name) {
-  return GENERATION_EXECUTABLES.includes(name);
+  return modeFor(name) === 493;
 }
 function quoteName(name) {
   return JSON.stringify(name.replace(/[\u0000-\u001f\u007f]/g, "?").slice(0, 120));
@@ -62724,13 +62899,13 @@ function quoteName(name) {
 function toError(cause) {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
-function rejectionReason(entry, seen, budget) {
+function rejectionReason(entry, seen, budget, expected) {
   const name = entry.path;
   if (entry.type !== "File") {
     return `archive entry ${quoteName(name)} is a ${entry.type}, not a regular file`;
   }
-  if (!ALLOWED.includes(name) || entry.header.path !== name) {
-    return `archive entry ${quoteName(name)} is not one of the five expected files`;
+  if (!Object.hasOwn(expected, name) || entry.header.path !== name) {
+    return `archive entry ${quoteName(name)} is not listed in the release manifest`;
   }
   if (seen.has(name))
     return `archive contains ${quoteName(name)} more than once`;
@@ -62739,6 +62914,9 @@ function rejectionReason(entry, seen, budget) {
   const size2 = entry.size;
   if (!Number.isSafeInteger(size2) || size2 < 0)
     return `archive entry ${quoteName(name)} declares an unusable size`;
+  if (size2 !== expected[name].size) {
+    return `archive entry ${quoteName(name)} declares ${size2} bytes but the manifest records ${expected[name].size}`;
+  }
   const executable = isExecutable(name);
   if (executable && size2 === 0)
     return `archive entry ${quoteName(name)} is an empty executable`;
@@ -62756,10 +62934,13 @@ function rejectionReason(entry, seen, budget) {
     budget.legal += size2;
   return null;
 }
-function writeEntry(entry, staging) {
+function writeEntry(entry, staging, expected) {
   const name = entry.path;
   const mode = isExecutable(name) ? EXECUTABLE_MODE : LEGAL_MODE;
-  const sink = createWriteStream(join9(staging, name), { mode, flags: "wx" });
+  const target = join10(staging, name);
+  if (name.includes("/"))
+    mkdirSync5(dirname7(target), { recursive: true });
+  const sink = createWriteStream(target, { mode, flags: "wx" });
   const done = new Promise((resolve3, reject2) => {
     sink.on("error", reject2);
     entry.on("error", reject2);
@@ -62780,11 +62961,11 @@ function writeEntry(entry, staging) {
     }
   };
 }
-function parseArchive(archivePath, staging, writes) {
+function parseArchive(archivePath, staging, writes, expected) {
   const seen = new Set;
   const budget = { total: 0, legal: 0 };
   return new Promise((resolve3, reject2) => {
-    const source = createReadStream(archivePath);
+    const source = createReadStream2(archivePath);
     const gunzip = createGunzip();
     let settled = false;
     const fail = (cause) => {
@@ -62804,14 +62985,14 @@ function parseArchive(archivePath, staging, writes) {
         entry.resume();
         return;
       }
-      const reason = rejectionReason(entry, seen, budget);
+      const reason = rejectionReason(entry, seen, budget, expected);
       if (reason !== null) {
         fail(new Error(reason));
         entry.resume();
         return;
       }
       seen.add(entry.path);
-      writes.push(writeEntry(entry, staging));
+      writes.push(writeEntry(entry, staging, expected));
     });
     parser.on("error", fail);
     gunzip.on("error", fail);
@@ -62820,7 +63001,7 @@ function parseArchive(archivePath, staging, writes) {
       if (settled)
         return;
       settled = true;
-      const missing = ALLOWED.filter((name) => !seen.has(name));
+      const missing = Object.keys(expected).filter((name) => !seen.has(name));
       if (missing.length > 0) {
         reject2(new Error(`archive is missing ${missing.join(", ")}`));
         return;
@@ -62830,10 +63011,11 @@ function parseArchive(archivePath, staging, writes) {
     source.pipe(gunzip).pipe(parser);
   });
 }
-async function extractArchive(archivePath, staging) {
+async function extractArchive(archivePath, staging, files) {
+  const expected = files;
   const writes = [];
   try {
-    await parseArchive(archivePath, staging, writes);
+    await parseArchive(archivePath, staging, writes, expected);
   } catch (e) {
     await Promise.allSettled(writes.map((w2) => w2.done));
     throw e;
@@ -62843,9 +63025,9 @@ async function extractArchive(archivePath, staging) {
 
 // src/distribution/transport.ts
 import { createHash as createHash3 } from "node:crypto";
-import { createReadStream as createReadStream2, existsSync as existsSync6, renameSync as renameSync3 } from "node:fs";
+import { createReadStream as createReadStream3, existsSync as existsSync6, renameSync as renameSync3 } from "node:fs";
 import { open as open2 } from "node:fs/promises";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 var PUBLIC_BASE = "https://github.com/adrijshikhar/cxstatusline/releases/download";
 var REPO = "adrijshikhar/cxstatusline";
 var MAX_REDIRECTS = 5;
@@ -62893,7 +63075,7 @@ function nextUrl(current, location, allowHttp, asset) {
 async function hashExistingFile(file2, maxBytes, asset) {
   const hash2 = createHash3("sha256");
   let size2 = 0;
-  for await (const chunk2 of createReadStream2(file2)) {
+  for await (const chunk2 of createReadStream3(file2)) {
     const buf = chunk2;
     size2 += buf.length;
     if (size2 > maxBytes)
@@ -63091,7 +63273,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 targetDir = dirname7(dest);
+  const targetDir = dirname8(dest);
   const result2 = ctx.run("gh", ["release", "download", tag, "--repo", REPO, "--pattern", asset, "--dir", targetDir], { timeoutMs: GH_TIMEOUT_MS });
   if (result2.status !== 0) {
     const detail = sanitize(result2.stderr || result2.stdout);
@@ -63100,7 +63282,7 @@ async function ghDownload(ctx, tag, asset, dest, maxBytes) {
     }
     throw new ReleaseUnavailableError(`release ${tag} not found or access denied: ${detail}`);
   }
-  const downloadedFile = join10(targetDir, asset);
+  const downloadedFile = join11(targetDir, asset);
   if (!existsSync6(downloadedFile) && !existsSync6(dest)) {
     throw new ReleaseUnavailableError(`release ${tag} not found or access denied: gh downloaded no ${asset}`);
   }
@@ -63120,16 +63302,9 @@ async function downloadAsset(ctx, tag, asset, dest, maxBytes, opts = {}) {
 // src/distribution/prebuilt.ts
 var MANIFEST_ASSET = "manifest.json";
 var PROBE_TIMEOUT_MS = 30000;
-function digestOf2(file2) {
-  const bytes = readFileSync6(file2);
-  return { sha256: createHash4("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) {
-  mkdirSync5(ctx.paths.libexecDir, { recursive: true });
-  const dir = mkdtempSync(join11(ctx.paths.libexecDir, prefix));
+  mkdirSync6(ctx.paths.libexecDir, { recursive: true });
+  const dir = mkdtempSync(join12(ctx.paths.libexecDir, prefix));
   chmodSync2(dir, 448);
   return dir;
 }
@@ -63153,39 +63328,29 @@ function unchangedPair(ctx, manifest, artifact, tag) {
   const directory = activeGeneration(ctx.paths);
   if (directory === null)
     return null;
-  for (const name of ARTIFACT_FILES) {
-    try {
-      if (!sameDigest(digestOf2(join11(directory, name)), artifact.files[name]))
-        return null;
-    } catch {
-      return null;
-    }
-  }
+  if (record2.provenance.files === undefined || !isPackageLayout(directory))
+    return null;
+  if (verifyPackage(directory, artifact.files, { target: codexTarget(artifact.platform), codexVersion: manifest.codexVersion }) !== null)
+    return null;
   return { directory, codexVersion: record2.codexVersion, provenance: record2.provenance };
 }
-function verifyStaged(staging, artifact) {
-  const digests = {};
-  for (const name of ARTIFACT_FILES) {
-    const got = digestOf2(join11(staging, name));
-    if (!sameDigest(got, artifact.files[name])) {
-      throw new Error(`staged ${name} does not match the release manifest sha256`);
-    }
-    digests[name] = got;
+function verifyStaged(staging, manifest, artifact) {
+  if (manifest.schema !== 3) {
+    throw new Error(`release ${releaseTag(manifest.codexVersion)} predates cxstatusline 0.11 and has not been republished yet; use --compile or wait`);
   }
-  return {
-    codex: digests.codex,
-    "codex-code-mode-host": digests["codex-code-mode-host"]
-  };
+  const problem = verifyPackage(staging, artifact.files, { target: codexTarget(artifact.platform), codexVersion: manifest.codexVersion });
+  if (problem !== null)
+    throw new Error(`staged package does not match the release manifest: ${problem}`);
 }
 function probeVersion(ctx, staging, codexVersion) {
-  const probe = ctx.run(join11(staging, "codex"), ["--version"], { timeoutMs: PROBE_TIMEOUT_MS });
+  const probe = ctx.run(join12(staging, "bin", "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}"`);
   }
 }
 function stagedPair(ctx, staging, manifest, artifact, tag) {
-  const executables = verifyStaged(staging, artifact);
+  verifyStaged(staging, manifest, artifact);
   probeVersion(ctx, staging, manifest.codexVersion);
   return {
     directory: staging,
@@ -63194,13 +63359,14 @@ function stagedPair(ctx, staging, manifest, artifact, tag) {
       source: "prebuilt",
       cxVersion: manifest.cxVersion ?? VERSION,
       platform: artifact.platform,
+      target: codexTarget(artifact.platform),
       patchVersion: manifest.patchVersion,
       patchSha256: manifest.patchSha256,
       upstreamCommit: manifest.upstreamCommit,
       sourceCommit: manifest.sourceCommit,
       sourceDirty: false,
       installedAt: ctx.now().toISOString(),
-      executables,
+      files: artifact.files,
       release: { tag, archiveSha256: artifact.sha256, manifest }
     }
   };
@@ -63210,7 +63376,7 @@ function moveFile(src, dst) {
     renameSync4(src, dst);
   } catch (e) {
     if (typeof e === "object" && e !== null && e.code === "EXDEV") {
-      copyFileSync2(src, dst);
+      copyFileSync(src, dst);
       rmSync2(src, { force: true });
     } else {
       throw e;
@@ -63219,9 +63385,9 @@ function moveFile(src, dst) {
 }
 async function stageArchive(ctx, download, manifest, artifact, tag, opts) {
   const cacheDir = ctx.paths.downloadCacheDir;
-  mkdirSync5(cacheDir, { recursive: true });
-  const partFile = join11(cacheDir, `${tag}-${artifact.filename}.part`);
-  const archive = join11(download, artifact.filename);
+  mkdirSync6(cacheDir, { recursive: true });
+  const partFile = join12(cacheDir, `${tag}-${artifact.filename}.part`);
+  const archive = join12(download, artifact.filename);
   opts.onStatus?.("download", `Downloading prebuilt archive (${artifact.filename})...`);
   const got = await downloadAsset(ctx, tag, artifact.filename, partFile, ARCHIVE_MAX_BYTES, opts);
   if (got.sha256 !== artifact.sha256 || got.size !== artifact.size) {
@@ -63233,7 +63399,7 @@ async function stageArchive(ctx, download, manifest, artifact, tag, opts) {
   const staging = privateTemp(ctx, "staging-");
   try {
     opts.onStatus?.("extract", "Extracting and verifying executables...");
-    await extractArchive(archive, staging);
+    await extractArchive(archive, staging, artifact.files);
     const pair = stagedPair(ctx, staging, manifest, artifact, tag);
     opts.onStatus?.("extract-done", "Verified executables (codex, codex-code-mode-host)");
     return pair;
@@ -63247,9 +63413,9 @@ async function preparePrebuilt(ctx, expected, opts = {}) {
   opts.onStatus?.("manifest", `Checking release ${tag} for ${expected.platform}...`);
   const download = privateTemp(ctx, "download-");
   try {
-    const manifestFile = join11(download, MANIFEST_ASSET);
+    const manifestFile = join12(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(readFileSync7(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);
@@ -63316,6 +63482,28 @@ var PLATFORMS = [
   "linux-arm64"
 ];
 var ARCHIVE_PREFIX = "cxstatusline-codex";
+function codexTarget(platform2) {
+  switch (platform2) {
+    case "darwin-arm64":
+      return "aarch64-apple-darwin";
+    case "darwin-x64":
+      return "x86_64-apple-darwin";
+    case "linux-x64":
+      return "x86_64-unknown-linux-gnu";
+    case "linux-arm64":
+      return "aarch64-unknown-linux-gnu";
+  }
+}
+var PACKAGE_PATH = /^(bin|codex-path|codex-resources)(\/[A-Za-z0-9][A-Za-z0-9._+-]*){1,4}$/;
+var PACKAGE_ROOT_FILES = ["codex-package.json", "LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"];
+var PACKAGE_MAX_FILES = 64;
+function packageRequiredFiles(platform2) {
+  const base2 = ["codex-package.json", "bin/codex", "bin/codex-code-mode-host", "codex-path/rg", "LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"];
+  return platform2.startsWith("linux-") ? [...base2, "codex-resources/bwrap"] : base2;
+}
+function modeFor(path) {
+  return /^(bin|codex-path|codex-resources)\//.test(path) ? 493 : 420;
+}
 var HEX402 = /^[0-9a-f]{40}$/;
 var HEX642 = /^[0-9a-f]{64}$/;
 var ISO_8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
@@ -63347,8 +63535,7 @@ var FileDigestSchema = exports_external.object({
   sha256: exports_external.string().regex(HEX642, "sha256 must be 64 lowercase hex chars"),
   size: exports_external.number().refine(safePositiveInt, "size must be a finite positive safe integer")
 }).strict();
-var filesShape = Object.fromEntries(ARTIFACT_FILES.map((k2) => [k2, FileDigestSchema]));
-var FilesSchema = exports_external.object(filesShape).strict();
+var FilesSchema = exports_external.record(exports_external.string(), FileDigestSchema);
 var ArtifactSchema = exports_external.object({
   platform: exports_external.enum(["darwin-arm64", "darwin-x64", "linux-x64", "linux-arm64"]),
   filename: exports_external.string(),
@@ -63357,8 +63544,8 @@ var ArtifactSchema = exports_external.object({
   files: FilesSchema
 }).strict();
 var ManifestShapeSchema = exports_external.object({
-  schema: exports_external.union([exports_external.literal(1), exports_external.literal(2)]),
-  patchVersion: exports_external.number().refine(safePositiveInt).optional(),
+  schema: exports_external.literal(3),
+  patchVersion: exports_external.number().refine(safePositiveInt),
   cxVersion: exports_external.string().optional(),
   codexVersion: exports_external.string(),
   upstreamTag: exports_external.string(),
@@ -63370,12 +63557,38 @@ var ManifestShapeSchema = exports_external.object({
   createdAt: exports_external.string().regex(ISO_8601, "createdAt must be an ISO 8601 timestamp"),
   artifacts: exports_external.array(ArtifactSchema).min(1).max(4)
 }).strict();
+function checkPackageFiles(platform2, files) {
+  const keys2 = Object.keys(files);
+  if (keys2.length > PACKAGE_MAX_FILES)
+    return `files lists more than ${PACKAGE_MAX_FILES} members`;
+  for (const key of keys2) {
+    if (!PACKAGE_PATH.test(key) && !PACKAGE_ROOT_FILES.includes(key))
+      return `files has unexpected member ${key}`;
+  }
+  for (const name of packageRequiredFiles(platform2))
+    if (!(name in files))
+      return `files is missing ${name}`;
+  const lower = new Set;
+  for (const key of keys2) {
+    const folded = key.toLowerCase();
+    if (lower.has(folded))
+      return `files has members that differ only by case: ${key}`;
+    lower.add(folded);
+    for (const other of keys2)
+      if (other !== key && other.startsWith(`${key}/`))
+        return `files member ${key} is also a directory of ${other}`;
+  }
+  return null;
+}
 function checkArtifacts(m2, expected) {
   const seen = new Set;
   for (const artifact of m2.artifacts) {
     if (seen.has(artifact.platform))
       return "duplicate platform in artifacts";
     seen.add(artifact.platform);
+    const files = checkPackageFiles(artifact.platform, artifact.files);
+    if (files)
+      return files;
     if (artifact.filename.includes("/") || artifact.filename.includes("\\") || artifact.filename.includes("..")) {
       return "artifact filename contains illegal path characters";
     }
@@ -63388,10 +63601,6 @@ function checkArtifacts(m2, expected) {
   return null;
 }
 function checkBusinessRules(m2, expected) {
-  if (m2.schema === 2 && m2.patchVersion === undefined)
-    return "patchVersion is required for schema 2";
-  if (m2.schema === 1 && m2.patchVersion !== undefined)
-    return "patchVersion requires schema 2";
   if (m2.cxVersion !== undefined && !isStableVersion(m2.cxVersion)) {
     return "cxVersion is not a valid semver";
   }
@@ -63400,10 +63609,8 @@ function checkBusinessRules(m2, expected) {
   }
   if (m2.upstreamTag !== `rust-v${m2.codexVersion}`)
     return "upstreamTag does not match codexVersion";
-  if (m2.schema === 2 && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.patch$/.test(m2.patchFile))
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.patch$/.test(m2.patchFile))
     return "patchFile must be a patch basename";
-  if (m2.schema === 1 && m2.patchFile !== `codex-${m2.codexVersion}.patch`)
-    return "patchFile does not match codexVersion";
   if (Number.isNaN(Date.parse(m2.createdAt)))
     return "createdAt is not a valid timestamp";
   return checkArtifacts(m2, expected);
@@ -63418,6 +63625,13 @@ function validateManifest(raw, expected) {
   if (!PLATFORMS.includes(expected.platform)) {
     throw new Error("validateManifest: expected release platform is not supported");
   }
+  const rawSchema = typeof raw === "object" && raw !== null ? raw.schema : undefined;
+  if (typeof rawSchema === "number" && rawSchema > 3) {
+    throw new Error(`this release needs a newer cxstatusline (manifest schema ${rawSchema}); run npm i -g cxstatusline`);
+  }
+  if (typeof rawSchema === "number" && rawSchema < 3) {
+    throw new Error(`release ${releaseTag(expected.codexVersion)} predates cxstatusline 0.11 and has not been republished yet; use --compile or wait`);
+  }
   const structural = ManifestShapeSchema.safeParse(raw);
   if (!structural.success) {
     const issue2 = structural.error.issues[0];
@@ -63431,7 +63645,7 @@ function validateManifest(raw, expected) {
 }
 
 // src/hook/install.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
 
 // src/sh.ts
 var sq = (s3) => `'${s3.replace(/'/g, `'"'"'`)}'`;
@@ -63469,7 +63683,7 @@ function readHooksFile(path) {
     return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync7(path, "utf8"));
+    raw = JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     throw new Error(`${path}: hooks.json is not valid JSON; fix it by hand before installing the hook`);
   }
@@ -63501,7 +63715,7 @@ function uninstallHook(hooksFile) {
 }
 
 // src/state.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "node:fs";
 var RELEASE_UNAVAILABLE = "release-unavailable";
 var RELEASE_RETRY_AFTER_MS = 24 * 60 * 60 * 1000;
 var DEFAULT_STATE = {
@@ -63549,7 +63763,7 @@ function readValidated(file2) {
   if (!existsSync8(file2))
     return null;
   try {
-    return validate3(JSON.parse(readFileSync8(file2, "utf8")));
+    return validate3(JSON.parse(readFileSync9(file2, "utf8")));
   } catch {
     return null;
   }
@@ -63800,8 +64014,8 @@ function promptUpdate(options) {
 import { rmSync as rmSync5 } from "node:fs";
 
 // src/codex/upstream.ts
-import { accessSync as accessSync2, constants as constants3, lstatSync as lstatSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync3, statSync as statSync2 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute2, join as join12, resolve as resolve3 } from "node:path";
+import { accessSync as accessSync2, constants as constants3, lstatSync as lstatSync4, readlinkSync as readlinkSync2, realpathSync as realpathSync3, statSync as statSync2 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join13, resolve as resolve3 } from "node:path";
 function isExecutable2(p2) {
   try {
     accessSync2(p2, constants3.X_OK);
@@ -63822,13 +64036,13 @@ function isManaged(p2, paths, isOurWrapper) {
 function inspectLauncher(paths, isOurWrapper) {
   let st2;
   try {
-    st2 = lstatSync3(paths.wrapperPath);
+    st2 = lstatSync4(paths.wrapperPath);
   } catch {
     return null;
   }
   if (st2.isSymbolicLink()) {
     const raw = readlinkSync2(paths.wrapperPath);
-    const target = isAbsolute2(raw) ? raw : resolve3(dirname8(paths.wrapperPath), raw);
+    const target = isAbsolute2(raw) ? raw : resolve3(dirname9(paths.wrapperPath), raw);
     if (isManaged(target, paths, isOurWrapper))
       return null;
     return { kind: "found", bin: target, launcher_restore: { kind: "symlink", target } };
@@ -63841,7 +64055,7 @@ function walkPath(paths, env3, isOurWrapper) {
   for (const dir of (env3.PATH ?? "").split(":").filter(Boolean)) {
     if (resolve3(dir) === resolve3(paths.binDir))
       continue;
-    const candidate = join12(dir, "codex");
+    const candidate = join13(dir, "codex");
     if (isExecutable2(candidate) && !isManaged(candidate, paths, isOurWrapper))
       return candidate;
   }
@@ -63876,17 +64090,16 @@ function preserveLauncherRestore(recorded, found) {
 }
 
 // src/patch/compile.ts
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync3, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync10, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
-import { createHash as createHash5 } from "node:crypto";
-import { join as join15 } from "node:path";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "node:fs";
+import { join as join16 } from "node:path";
 
 // src/patch/build.ts
-import { existsSync as existsSync10, lstatSync as lstatSync4, readFileSync as readFileSync9, statSync as statSync3 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync10, lstatSync as lstatSync5, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
+import { join as join15 } from "node:path";
 
 // src/patch/v8.ts
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function defaultV8Target() {
   const isArm = process.arch === "arm64";
   if (process.platform === "darwin")
@@ -63917,7 +64130,7 @@ function resolveV8Env(sourceDir, run, log) {
       RUSTY_V8_SRC_BINDING_PATH: process.env.RUSTY_V8_SRC_BINDING_PATH
     };
   }
-  const v8Script = join13(sourceDir, "scripts", "codex_package", "v8.py");
+  const v8Script = join14(sourceDir, "scripts", "codex_package", "v8.py");
   if (!existsSync9(v8Script)) {
     return {};
   }
@@ -63989,14 +64202,14 @@ function headCommit(plan, run) {
 }
 function prepareCheckout(plan, run, log) {
   const git = (step, ...args) => must(step, run, log, "git", ["-C", plan.sourceDir, ...args]);
-  if (existsSync10(join14(plan.sourceDir, ".git"))) {
+  if (existsSync10(join15(plan.sourceDir, ".git"))) {
     git("fetch", "fetch", "--tags", "--filter=blob:none", "origin");
-    const snapshot = join14(plan.sourceDir, SNAPSHOT);
-    const st2 = lstatSync4(snapshot, { throwIfNoEntry: false });
+    const snapshot = join15(plan.sourceDir, SNAPSHOT);
+    const st2 = lstatSync5(snapshot, { throwIfNoEntry: false });
     if (st2) {
       const tracked = run("git", ["-C", plan.sourceDir, "ls-files", "--error-unmatch", "--", SNAPSHOT]);
       if (tracked.status !== 0) {
-        if (!st2.isFile() || readFileSync9(snapshot, "utf8") !== SNAPSHOT_CONTENT) {
+        if (!st2.isFile() || readFileSync10(snapshot, "utf8") !== SNAPSHOT_CONTENT) {
           throw new BuildError("snapshot", `conflicting untracked snapshot ${snapshot}; move it aside before retrying`);
         }
         git("stage snapshot", "add", "--", SNAPSHOT);
@@ -64019,7 +64232,7 @@ function buildPatched(plan, run, log, which, onStatus) {
   git("apply --check", "apply", "--index", "--check", plan.patchFile);
   git("apply", "apply", "--index", plan.patchFile);
   onStatus?.("patch-done", `Applied ${patchBase} cleanly`);
-  const crateDir = join14(plan.sourceDir, "codex-rs");
+  const crateDir = join15(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();
@@ -64028,7 +64241,7 @@ function buildPatched(plan, run, log, which, onStatus) {
   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 = join14(crateDir, "target", "release", name);
+    const bin = join15(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`);
     }
@@ -64045,9 +64258,6 @@ function buildPatched(plan, run, log, which, onStatus) {
 
 // src/patch/compile.ts
 var STAGING_PREFIX = "compiled-";
-function digestOf3(file2) {
-  return { sha256: createHash5("sha256").update(readFileSync10(file2)).digest("hex"), size: statSync4(file2).size };
-}
 function platformLabel() {
   try {
     return platformFor(process.platform, process.arch);
@@ -64055,62 +64265,68 @@ function platformLabel() {
     return `${process.platform}-${process.arch}`;
   }
 }
-function stage(ctx, built) {
-  mkdirSync6(ctx.paths.libexecDir, { recursive: true });
-  const directory = mkdtempSync2(join15(ctx.paths.libexecDir, STAGING_PREFIX));
+function prepareCompiled(ctx, upstream, ref, onStatus) {
+  const patchFile = join16(ctx.patchesDir, ref.file);
+  const patchSha256 = digestOf(patchFile).sha256;
+  const built = buildPatched({ tag: ref.tag, sourceDir: ctx.paths.sourceDir, patchFile }, ctx.run, ctx.log, ctx.which, onStatus);
+  onStatus?.("stage", "Assembling the Codex package with upstream's packager...");
+  const python = findPython(ctx.which, ctx.run);
+  if (python === null)
+    throw new Error("Python >= 3.10 is required to assemble the Codex package (brew install python / apt install python3)");
+  const cargo = ctx.which("cargo");
+  if (cargo === null)
+    throw new Error("cargo is not on PATH");
+  mkdirSync7(ctx.paths.libexecDir, { recursive: true });
+  const directory = mkdtempSync2(join16(ctx.paths.libexecDir, STAGING_PREFIX));
   chmodSync3(directory, 448);
-  const sources = {
-    codex: built.codex,
-    "codex-code-mode-host": built.codexCodeModeHost
-  };
-  const executables = {};
+  const tmpDir = mkdtempSync2(join16(ctx.paths.libexecDir, "download-"));
+  chmodSync3(tmpDir, 448);
+  let target;
   try {
-    for (const name of GENERATION_EXECUTABLES) {
-      const target = join15(directory, name);
-      copyFileSync3(sources[name], target);
-      chmodSync3(target, 493);
-      executables[name] = digestOf3(target);
-    }
+    target = rustcHostTarget(ctx.run);
+    assemblePackage({
+      upstream: ctx.paths.sourceDir,
+      target,
+      codexVersion: upstream.raw,
+      codex: built.codex,
+      codeModeHost: built.codexCodeModeHost,
+      packageDir: directory,
+      python,
+      cargo,
+      bwrapBin: process.platform === "linux" ? ctx.which("bwrap") : null,
+      tmpDir,
+      force: false
+    }, ctx.run, ctx.log);
   } catch (e) {
     rmSync3(directory, { recursive: true, force: true });
     throw e;
+  } finally {
+    rmSync3(tmpDir, { recursive: true, force: true });
   }
+  const files = packageFiles(directory);
+  onStatus?.("stage-done", "Codex package assembled and verified");
   return {
     directory,
-    executables: {
-      codex: executables.codex,
-      "codex-code-mode-host": executables["codex-code-mode-host"]
-    }
-  };
-}
-function prepareCompiled(ctx, upstream, ref, onStatus) {
-  const patchFile = join15(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, 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,
     provenance: {
       source: "compiled",
       cxVersion: VERSION,
       platform: platformLabel(),
+      target,
       patchVersion: ref.patchVersion,
       patchSha256,
       upstreamCommit: built.upstreamCommit,
       sourceCommit: SOURCE_COMMIT,
       sourceDirty: SOURCE_DIRTY,
       installedAt: ctx.now().toISOString(),
-      executables: staged.executables
+      files
     }
   };
 }
 
 // src/patch/manifest.ts
 import { readFileSync as readFileSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 class ManifestError extends Error {
   name = "ManifestError";
 }
@@ -64129,7 +64345,7 @@ var isCandidate = (c) => {
   return parsed !== null && parsed.pre === null;
 };
 function loadManifest(patchesDir) {
-  const file2 = join16(patchesDir, "manifest.json");
+  const file2 = join17(patchesDir, "manifest.json");
   try {
     const raw = JSON.parse(readFileSync11(file2, "utf8"));
     const m2 = raw;
@@ -64190,9 +64406,9 @@ function isCodexVersionSupported(m2, version2) {
 }
 
 // src/patch/wrapper.ts
-import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync11, lstatSync as lstatSync5, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync12, readSync, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync4, closeSync as closeSync2, existsSync as existsSync11, lstatSync as lstatSync6, mkdirSync as mkdirSync8, openSync as openSync2, readFileSync as readFileSync12, readSync, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var WRAPPER_MARKER = "# cxstatusline-wrapper v1";
 var WRAPPER_MARKER_V2 = "# cxstatusline-wrapper v2";
 var WRAPPER_MARKERS = [WRAPPER_MARKER, WRAPPER_MARKER_V2];
@@ -64222,6 +64438,9 @@ function generationWrapperScript(currentGeneration, cxBin) {
     `CXSTATUSLINE_COMMAND=${sq(`${sq(cxBin)} render`)}`,
     "export CXSTATUSLINE_COMMAND",
     `generation=$(CDPATH= cd -P -- ${sq(currentGeneration)} && pwd -P) || exit 1`,
+    `if [ -x "$generation/bin/codex" ]; then`,
+    `  exec "$generation/bin/codex" "$@"`,
+    "fi",
     `exec "$generation/codex" "$@"`,
     ""
   ].join(`
@@ -64245,18 +64464,18 @@ function isOurWrapper(path) {
 }
 function isSymlink(p2) {
   try {
-    return lstatSync5(p2).isSymbolicLink();
+    return lstatSync6(p2).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function stageExecutable(target, write) {
-  mkdirSync7(join17(target, ".."), { recursive: true });
+  mkdirSync8(join18(target, ".."), { recursive: true });
   const tmp = `${target}.tmp-${process.pid}`;
   try {
     write(tmp);
     chmodSync4(tmp, 493);
-    if (statSync5(tmp).size === 0)
+    if (statSync4(tmp).size === 0)
       throw new Error(`${target} staged as an empty file`);
     return tmp;
   } catch (e) {
@@ -64310,7 +64529,7 @@ function preserveStockLauncher(ctx) {
 }
 function stageWrapper(paths, cxBin) {
   const want = generationWrapperScript(paths.currentGeneration, cxBin);
-  mkdirSync7(paths.binDir, { recursive: true });
+  mkdirSync8(paths.binDir, { recursive: true });
   const tmp = `${paths.wrapperPath}.tmp-${process.pid}-${randomBytes3(4).toString("hex")}`;
   try {
     writeFileSync3(tmp, want);
@@ -65048,7 +65267,7 @@ async function runUpdate(ctx, opts = {}, transport = {}) {
   return runInstall(ctx, { compile: opts.compile ?? false, codexVersion: target }, transport);
 }
 function appendLog(file2, line) {
-  mkdirSync8(join18(file2, ".."), { recursive: true });
+  mkdirSync9(join19(file2, ".."), { recursive: true });
   appendFileSync(file2, `${new Date().toISOString()} ${line}
 `);
 }
@@ -65203,9 +65422,9 @@ async function promptCodexVersion(options) {
 }
 
 // src/hook/run.ts
-import { appendFileSync as appendFileSync2, closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync10, openSync as openSync3 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname9 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 var HOOK_SOURCES = ["startup", "resume", "clear"];
 function parseHookInput(stdin) {
   try {
@@ -65298,7 +65517,9 @@ async function runHook(ctx, stdin, deps) {
   if (effectiveInstalled === null)
     return done();
   const patched = parseSemver(effectiveInstalled);
-  const drift = needsRepatch(upstream, patched, state.policy);
+  const active = activeGeneration(ctx.paths);
+  const flat = active !== null && !isPackageLayout(active);
+  const drift = needsRepatch(upstream, patched, state.policy) || flat;
   if (!drift)
     maintainWrapper(ctx, messages);
   if (drift) {
@@ -65323,7 +65544,7 @@ async function runHook(ctx, stdin, deps) {
     return done();
   if (drift) {
     deps.spawnDetached(ctx.cxBin, ["hook", "acquire"], ctx.paths.patchLog);
-    messages.push(`cxstatusline: Codex updated to ${upstream.raw} (installed pair is from ${effectiveInstalled}). Installing the new pair in the background - reopen Codex in a few minutes. Log: ${ctx.paths.patchLog}`);
+    messages.push(flat && !needsRepatch(upstream, patched, state.policy) ? `cxstatusline: this Codex was installed by an older cxstatusline; rebuilding it in the background - reopen Codex in a few minutes. Log: ${ctx.paths.patchLog}` : `cxstatusline: Codex updated to ${upstream.raw} (installed pair is from ${effectiveInstalled}). Installing the new pair in the background - reopen Codex in a few minutes. Log: ${ctx.paths.patchLog}`);
   }
   return done();
 }
@@ -65332,7 +65553,7 @@ function realHookDeps() {
     spawnDetached(cxBin, args, logFile) {
       let fd;
       try {
-        mkdirSync9(dirname9(logFile), { recursive: true });
+        mkdirSync10(dirname10(logFile), { recursive: true });
         fd = openSync3(logFile, "a");
         const child = spawn2(cxBin, args, { detached: true, stdio: ["ignore", fd, fd], env: process.env });
         child.on("error", (err) => {
@@ -65355,8 +65576,8 @@ function realHookDeps() {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync14, lstatSync as lstatSync6, readFileSync as readFileSync14, readlinkSync as readlinkSync3, readdirSync as readdirSync3 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync14, lstatSync as lstatSync7, readFileSync as readFileSync14, readlinkSync as readlinkSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/utils/format.ts
 function formatDuration2(ms2) {
@@ -65372,18 +65593,17 @@ function formatDuration2(ms2) {
 }
 
 // src/commands/doctor-generation.ts
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute3, join as join19, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, readlinkSync as readlinkSync3 } from "node:fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, join as join20, 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) {
-  return isAbsolute3(raw) ? raw : resolve4(dirname10(paths.currentGeneration), raw);
+  return isAbsolute3(raw) ? raw : resolve4(dirname11(paths.currentGeneration), raw);
 }
 function computeGenerationLine(paths, pointer) {
   const dir = activeGeneration(paths);
   if (dir !== null) {
-    if (!isGenerationDir(dir))
+    if (!isGenerationDir(dir) && !existsSync13(join20(dir, INSTALLATION_FILE)))
       return { line: line("generation", "foreign", false), dir: null };
     return { line: line("generation", dir, true), dir };
   }
@@ -65453,25 +65673,26 @@ function upstreamCommitLine(record2) {
 function digestLine(key, label, record2, dir) {
   if (!record2 || !dir)
     return line(label, NO_GENERATION, null);
-  const file2 = join19(dir, key);
+  const file2 = executablePath(dir, key);
   if (!existsSync13(file2))
     return line(label, "missing", false);
-  let buf;
+  let got;
   try {
-    buf = readFileSync13(file2);
+    got = digestOf(file2);
   } catch (e) {
     return line(label, `unreadable: ${e.message.split(`
 `)[0]}`, false);
   }
-  const got = { sha256: createHash6("sha256").update(buf).digest("hex"), size: buf.length };
-  const want = record2.provenance.executables[key];
+  const want = record2.provenance.files?.[`bin/${key}`] ?? record2.provenance.executables?.[key];
+  if (!want)
+    return line(label, "no digest recorded", false);
   const verified = got.sha256 === want.sha256 && got.size === want.size;
   return line(label, verified ? "verified" : "MISMATCH", verified);
 }
 function codexVersionLine(ctx, record2, dir) {
   if (!record2 || !dir)
     return line("codex_version", NO_GENERATION, null);
-  const bin = join19(dir, "codex");
+  const bin = executablePath(dir, "codex");
   if (!existsSync13(bin))
     return line("codex_version", "missing", false);
   let result2;
@@ -65494,9 +65715,41 @@ 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) => !existsSync13(join19(dir, f2)));
+  const missing = GENERATION_LEGAL_FILES.filter((f2) => !existsSync13(join20(dir, f2)));
   return missing.length === 0 ? line("legal", "present", true) : line("legal", `missing: ${missing.join(", ")}`, false);
 }
+var DAEMON_SINCE = parseSemver("0.156.0");
+function packageLayoutLine(record2, dir) {
+  if (!record2 || !dir)
+    return line("package_layout", NO_GENERATION, null);
+  if (!isPackageLayout(dir) || record2.provenance.files === undefined || record2.provenance.target === undefined) {
+    const parsed = parseSemver(record2.codexVersion);
+    const needed = parsed !== null && compareSemver(parsed, DAEMON_SINCE) >= 0;
+    return line("package_layout", "flat layout from an older cxstatusline: run cxstatusline upgrade", needed ? false : null);
+  }
+  const problem = verifyPackage(dir, record2.provenance.files, { target: record2.provenance.target, codexVersion: record2.codexVersion });
+  return problem === null ? line("package_layout", `ok (${record2.provenance.target})`, true) : line("package_layout", problem, false);
+}
+function daemonPackageLine(paths, record2) {
+  const current = join20(paths.codexHome, "packages", "app-server-daemon", "current");
+  let target;
+  try {
+    target = readlinkSync3(current);
+  } catch {
+    return line("daemon_package", "none", null);
+  }
+  const dir = isAbsolute3(target) ? target : resolve4(dirname11(current), target);
+  let version2 = "unknown";
+  try {
+    const meta3 = JSON.parse(readFileSync13(join20(dir, "codex-package.json"), "utf8"));
+    if (typeof meta3.version === "string")
+      version2 = meta3.version;
+  } catch {}
+  if (record2 && version2 !== "unknown" && version2 !== record2.codexVersion) {
+    return line("daemon_package", `daemon ${version2} differs from active ${record2.codexVersion} (${dir}); run codex app-server daemon restart`, false);
+  }
+  return line("daemon_package", `${version2} (${dir})`, null);
+}
 function generationDetailLines(ctx, status) {
   const { record: record2, dir } = status;
   return [
@@ -65509,7 +65762,9 @@ function generationDetailLines(ctx, status) {
     digestLine("codex", "codex_digest", record2, dir),
     digestLine("codex-code-mode-host", "host_digest", record2, dir),
     codexVersionLine(ctx, record2, dir),
-    legalLine(record2, dir)
+    legalLine(record2, dir),
+    packageLayoutLine(record2, dir),
+    daemonPackageLine(ctx.paths, record2)
   ];
 }
 function toolchainLine(ctx, source) {
@@ -65663,12 +65918,12 @@ function wrapperLine(ctx) {
   const p2 = ctx.paths.wrapperPath;
   let st2;
   try {
-    st2 = lstatSync6(p2);
+    st2 = lstatSync7(p2);
   } catch {
     return line2("wrapper", "absent");
   }
   if (st2.isSymbolicLink())
-    return line2("wrapper", `upstream symlink -> ${readlinkSync3(p2)}`);
+    return line2("wrapper", `upstream symlink -> ${readlinkSync4(p2)}`);
   return isOurWrapper(p2) ? line2("wrapper", "ours", true) : line2("wrapper", "foreign file! not ours, not a symlink", false);
 }
 function hookLine(ctx) {
@@ -65718,7 +65973,7 @@ function commandCacheLine(ctx) {
     let oldestMtime = Infinity;
     for (const f2 of entries) {
       try {
-        const st2 = lstatSync6(join20(dir, f2));
+        const st2 = lstatSync7(join21(dir, f2));
         if (st2.mtimeMs < oldestMtime)
           oldestMtime = st2.mtimeMs;
       } catch {}
@@ -65814,7 +66069,7 @@ async function doctorReport(ctx, opts) {
       return line2("drift", `behind within minor: ${patched.raw} < ${upstream.raw} (held by policy; \`patch --force\` to pick up)`);
     return line2("drift", "none", true);
   };
-  const codexTarget = await codexTargetLine(ctx, effectivePatchedFrom, opts);
+  const codexTarget2 = await codexTargetLine(ctx, effectivePatchedFrom, opts);
   const lines = [
     line2("renderer", `${ctx.cxBin} (${VERSION})`),
     line2("settings", `${ctx.paths.settingsFile} ${existsSync14(ctx.paths.settingsFile) ? "present" : "absent (written on first render)"}`),
@@ -65823,7 +66078,7 @@ async function doctorReport(ctx, opts) {
     line2("patch_version", status.record?.provenance.patchVersion === undefined ? "unknown (legacy)" : `v${status.record.provenance.patchVersion}`),
     line2("patched_from", state.patched_from ?? "never"),
     line2("policy", state.policy),
-    codexTarget,
+    codexTarget2,
     drift(),
     bookkeepingLine(state, status.record),
     wrapperLine(ctx),
@@ -65889,11 +66144,11 @@ function runPolicy(ctx, argv, io2) {
 }
 
 // src/commands/revert.ts
-import { existsSync as existsSync15, lstatSync as lstatSync7, readdirSync as readdirSync4, rmSync as rmSync7, symlinkSync as symlinkSync2 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync15, lstatSync as lstatSync8, readFileSync as readFileSync15, readdirSync as readdirSync4, readlinkSync as readlinkSync5, rmSync as rmSync7, symlinkSync as symlinkSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname12, isAbsolute as isAbsolute4, join as join22, resolve as resolve5 } from "node:path";
 function safeIsSymlink(p2) {
   try {
-    return lstatSync7(p2).isSymbolicLink();
+    return lstatSync8(p2).isSymbolicLink();
   } catch {
     return false;
   }
@@ -65919,7 +66174,7 @@ function removeGenerations(ctx, actions) {
     return;
   let removed = 0;
   for (const dir of listGenerations(ctx.paths)) {
-    if (!isGenerationDir(dir)) {
+    if (!GENERATION_NAME.test(basename2(dir)) || safeIsSymlink(dir)) {
       actions.push(`${dir} is not a cxstatusline generation; left in place`);
       continue;
     }
@@ -65937,11 +66192,32 @@ function removeStagingDebris(ctx, actions) {
     return;
   const debris = readdirSync4(libexecDir).filter((n) => OWNED_LIBEXEC_PREFIXES.some((p2) => n.startsWith(p2)));
   for (const name of debris)
-    rmSync7(join21(libexecDir, name), { recursive: true, force: true });
+    rmSync7(join22(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}`);
   }
 }
+function daemonCopyNotice(ctx, actions) {
+  const root = join22(ctx.paths.codexHome, "packages", "app-server-daemon");
+  const current = join22(root, "current");
+  let target;
+  try {
+    target = readlinkSync5(current);
+  } catch {
+    return;
+  }
+  const dir = isAbsolute4(target) ? target : resolve5(dirname12(current), target);
+  let ours = false;
+  try {
+    const record2 = JSON.parse(readFileSync15(join22(dir, INSTALLATION_FILE), "utf8"));
+    ours = typeof record2?.provenance?.cxVersion === "string";
+  } catch {
+    return;
+  }
+  if (!ours)
+    return;
+  actions.push(`the Codex daemon still runs a copy of the removed generation (${dir}); stop it and remove the copy: codex app-server daemon stop && rm -rf ${root}`);
+}
 function revertLocked(ctx) {
   const actions = [];
   let code = 0;
@@ -65964,6 +66240,7 @@ function revertLocked(ctx) {
     }
   }
   removeGenerations(ctx, actions);
+  daemonCopyNotice(ctx, actions);
   removeStagingDebris(ctx, actions);
   if (existsSync15(ctx.paths.patchedBin)) {
     rmSync7(ctx.paths.patchedBin);
@@ -67588,7 +67865,7 @@ function MainMenu({ onSelect, initialSelection = 0, hasChanges = false }) {
 // src/tui/components/PowerlineSetup.tsx
 import { existsSync as existsSync16, readdirSync as readdirSync5 } from "node:fs";
 import { homedir as homedir2, platform as platform2 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 var import_react51 = __toESM(require_react(), 1);
 
 // src/utils/powerline-settings.ts
@@ -67973,7 +68250,7 @@ function buildPowerlineSetupMenuItems(powerline) {
   ];
 }
 function detectPowerlineFont() {
-  const dirs = platform2() === "darwin" ? [join22(homedir2(), "Library", "Fonts"), "/Library/Fonts"] : platform2() === "win32" ? [join22(homedir2(), "AppData", "Local", "Microsoft", "Windows", "Fonts"), "C:\\Windows\\Fonts"] : [join22(homedir2(), ".local", "share", "fonts"), join22(homedir2(), ".fonts"), "/usr/share/fonts"];
+  const dirs = platform2() === "darwin" ? [join23(homedir2(), "Library", "Fonts"), "/Library/Fonts"] : platform2() === "win32" ? [join23(homedir2(), "AppData", "Local", "Microsoft", "Windows", "Fonts"), "C:\\Windows\\Fonts"] : [join23(homedir2(), ".local", "share", "fonts"), join23(homedir2(), ".fonts"), "/usr/share/fonts"];
   try {
     return dirs.some((dir) => existsSync16(dir) && readdirSync5(dir).some((file2) => /powerline|nerd font|meslo.*lg/i.test(file2)));
   } catch {
@@ -68494,7 +68771,7 @@ function readMemoryUsage(deps, nowMs) {
 // src/commands/update-tool.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync17, realpathSync as realpathSync4 } from "node:fs";
-import { dirname as dirname11, join as join23 } from "node:path";
+import { dirname as dirname13, join as join24 } from "node:path";
 async function defaultFetchLatestVersion() {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), 5000);
@@ -68521,12 +68798,12 @@ function detectInstallType(binaryPath = process.argv[1]) {
     try {
       resolved = realpathSync4(binaryPath);
     } catch {}
-    let dir = dirname11(resolved);
+    let dir = dirname13(resolved);
     for (let i = 0;i < 5; i++) {
-      if (existsSync17(join23(dir, ".git")) && existsSync17(join23(dir, "package.json"))) {
+      if (existsSync17(join24(dir, ".git")) && existsSync17(join24(dir, "package.json"))) {
         return { type: "git", repoDir: dir };
       }
-      const parent = dirname11(dir);
+      const parent = dirname13(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -68730,14 +69007,16 @@ async function installCommand(argv, io2, deps) {
     }
   }
   const ctx = contextFor(io2, deps);
-  if (io2.isTTY === true && !yes && !codexVersion) {
+  if (!codexVersion) {
     let manifest;
     try {
       manifest = loadManifest(ctx.patchesDir);
     } catch (e) {
-      io2.stderr(`Cannot load supported Codex versions: ${e instanceof Error ? e.message : String(e)}
+      if (io2.isTTY === true && !yes) {
+        io2.stderr(`Cannot load supported Codex versions: ${e instanceof Error ? e.message : String(e)}
 `);
-      return 1;
+        return 1;
+      }
     }
     if (manifest) {
       const supported = supportedCodexVersions(manifest);
@@ -68750,42 +69029,29 @@ async function installCommand(argv, io2, deps) {
             prebuiltVersions = undefined;
           }
         }
-        let defaultVersion;
-        try {
-          const located = upstreamFor(ctx, loadState(ctx));
-          if ("bin" in located) {
-            const upstream = readUpstreamVersion(located.bin, ctx.run);
-            if (upstream) {
-              const semverStr = `${upstream.major}.${upstream.minor}.${upstream.patch}`;
-              if (supported.includes(semverStr)) {
-                if (compile3 || !prebuiltVersions || prebuiltVersions.includes(semverStr)) {
-                  defaultVersion = semverStr;
-                }
-              }
-            }
-          }
-        } catch {}
-        if (!defaultVersion && prebuiltVersions && prebuiltVersions.length > 0) {
-          defaultVersion = supported.find((v2) => prebuiltVersions.includes(v2));
-        }
-        const prompter = deps.promptVersion ?? promptCodexVersion;
-        const result2 = await prompter({
-          supportedVersions: supported,
-          prebuiltVersions,
-          defaultVersion,
-          compile: compile3,
-          isTTY: true,
-          say: (l) => io2.stdout(`${l}
+        const defaultVersion = compile3 ? supported[0] : prebuiltVersions && prebuiltVersions.length > 0 ? supported.find((v2) => prebuiltVersions.includes(v2)) ?? supported[0] : supported[0];
+        if (io2.isTTY === true && !yes) {
+          const prompter = deps.promptVersion ?? promptCodexVersion;
+          const result2 = await prompter({
+            supportedVersions: supported,
+            prebuiltVersions,
+            defaultVersion,
+            compile: compile3,
+            isTTY: true,
+            say: (l) => io2.stdout(`${l}
 `)
-        });
-        if (result2 === null) {
-          io2.stdout(`Installation cancelled.
+          });
+          if (result2 === null) {
+            io2.stdout(`Installation cancelled.
 `);
-          return 0;
+            return 0;
+          }
+          const selection = typeof result2 === "string" ? { version: result2, compile: false } : result2;
+          codexVersion = selection.version;
+          compile3 = compile3 || selection.compile;
+        } else {
+          codexVersion = defaultVersion;
         }
-        const selection = typeof result2 === "string" ? { version: result2, compile: false } : result2;
-        codexVersion = selection.version;
-        compile3 = compile3 || selection.compile;
       }
     }
   }
@@ -68938,7 +69204,7 @@ main(argv, {
   isTTY: canPrompt(process.stdin, process.stdout),
   stdin: () => {
     try {
-      return readFileSync15(0, "utf8");
+      return readFileSync16(0, "utf8");
     } catch {
       return "";
     }