claude-use 5.0.0 → 5.0.1

package/dist/cli.cjs

@@ -285659,11 +285659,36 @@ var PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).exten
   identity: external_exports.string().min(1).optional(),
   when: WhenSchema.optional()
 });
-var HeadroomGlobalConfigSchema = external_exports.strictObject({
+var HEADROOM_MODES = ["cache", "token"];
+var HEADROOM_CCR_MODES = ["default", "lossless", "none"];
+var HEADROOM_ROLLOUT_CHANNELS = ["beta", "canary", "dev"];
+var INTERCEPT_CHANNELS = ["canary", "dev"];
+var READ_MATURATION_CHANNELS = ["beta", "dev"];
+var HeadroomGlobalConfigObjectSchema = external_exports.strictObject({
   /** Install spec handed to `uv tool install`. Defaults to HEADROOM_DEFAULT_SOURCE. */
   source: external_exports.string().min(1).optional(),
   /** How long the daemon may sit with no registered sessions before the supervisor stops it. Defaults to HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
-  idleShutdownMinutes: external_exports.number().int().positive().optional()
+  idleShutdownMinutes: external_exports.number().int().positive().optional(),
+  /** Optimisation mode, passed as `--mode`. Unset leaves headroom's own default (`cache`). */
+  mode: external_exports.enum(HEADROOM_MODES).optional(),
+  /** Keep-ratio for prose and code compression, passed as `--target-ratio`: lower is more aggressive. Unset lets headroom decide. */
+  targetRatio: external_exports.number().gt(0).max(1).optional(),
+  /** How compressed tool output stays recoverable. Unset leaves headroom's own default (`default`). */
+  ccr: external_exports.enum(HEADROOM_CCR_MODES).optional(),
+  /** Headroom's experimental release channel, exported as `HEADROOM_ROLLOUT_CHANNEL`. Required by `interceptToolResults` and `readMaturation`, which are refused without a channel that unlocks them. */
+  rolloutChannel: external_exports.enum(HEADROOM_ROLLOUT_CHANNELS).optional(),
+  /** Opt in to headroom's tool-result interceptors (`--intercept-tool-results`). Needs `rolloutChannel` canary or dev. */
+  interceptToolResults: external_exports.boolean().optional(),
+  /** Opt in to headroom's experimental read maturation (`--read-maturation`). Needs `rolloutChannel` beta or dev. */
+  readMaturation: external_exports.boolean().optional()
+});
+var HeadroomGlobalConfigSchema = HeadroomGlobalConfigObjectSchema.superRefine((config2, context) => {
+  if (config2.interceptToolResults === true && !INTERCEPT_CHANNELS.includes(config2.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["interceptToolResults"], message: "interceptToolResults needs rolloutChannel canary or dev" });
+  }
+  if (config2.readMaturation === true && !READ_MATURATION_CHANNELS.includes(config2.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
+  }
 });
 var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@eb02fa4126450c9905a49394fdec19ae2e7c9c30";
 var HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
@@ -285730,6 +285755,8 @@ var HeadroomStateSchema = external_exports.strictObject({
   version: external_exports.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
   allowlistHash: external_exports.string().optional(),
+  /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
+  settingsHash: external_exports.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
   installedSource: external_exports.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
@@ -291234,7 +291261,7 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "5.0.0",
+  version: "5.0.1",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -296096,11 +296123,41 @@ var import_node_fs14 = __toESM(require("node:fs"), 1);
 var import_node_net2 = __toESM(require("node:net"), 1);
 var import_node_child_process5 = require("node:child_process");
 
+// src/headroom/settings.ts
+var import_node_crypto12 = require("node:crypto");
+function settingsOf(config2) {
+  return {
+    ...config2.mode === void 0 ? {} : { mode: config2.mode },
+    ...config2.targetRatio === void 0 ? {} : { targetRatio: config2.targetRatio },
+    ...config2.ccr === void 0 ? {} : { ccr: config2.ccr },
+    ...config2.rolloutChannel === void 0 ? {} : { rolloutChannel: config2.rolloutChannel },
+    ...config2.interceptToolResults === void 0 ? {} : { interceptToolResults: config2.interceptToolResults },
+    ...config2.readMaturation === void 0 ? {} : { readMaturation: config2.readMaturation }
+  };
+}
+function settingsArgs(settings2) {
+  return [
+    ...settings2.mode === void 0 ? [] : ["--mode", settings2.mode],
+    ...settings2.targetRatio === void 0 ? [] : ["--target-ratio", String(settings2.targetRatio)],
+    ...settings2.ccr === "lossless" ? ["--lossless"] : [],
+    ...settings2.ccr === "none" ? ["--no-ccr"] : [],
+    ...settings2.interceptToolResults === true ? ["--intercept-tool-results"] : [],
+    ...settings2.readMaturation === true ? ["--read-maturation"] : []
+  ];
+}
+function settingsEnv(settings2) {
+  return settings2.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings2.rolloutChannel };
+}
+function hashSettings(settings2) {
+  return (0, import_node_crypto12.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings2), JSON.stringify(settingsEnv(settings2))])).digest("hex");
+}
+
 // src/headroom/supervisor.ts
 function resolveSupervisorConfig(configured) {
   return {
     source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
-    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES
+    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
+    settings: settingsOf(configured)
   };
 }
 var HEADROOM_BACKOFF_BASE_MS = 500;
@@ -296193,8 +296250,9 @@ function compareVersions2(a2, b) {
   return 0;
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
-async function runSupervisor(config2, ports, options = {}) {
+async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs16, paths } = ports;
+  let config2 = initialConfig;
   const previousState = readHeadroomState(fs16, paths.headroomStateFile);
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
@@ -296236,6 +296294,7 @@ async function runSupervisor(config2, ports, options = {}) {
   }
   let headroomPid;
   let runningHash;
+  let runningSettingsHash;
   let consecutiveFailures = 0;
   let idleSince;
   let ticks = 0;
@@ -296244,6 +296303,8 @@ async function runSupervisor(config2, ports, options = {}) {
       return HEADROOM_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
+    config2 = ports.readConfig();
+    const settingsHash = hashSettings(config2.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs16, paths.headroomSessionsDir, ports.isRunning);
@@ -296253,6 +296314,7 @@ async function runSupervisor(config2, ports, options = {}) {
         ports.log(`claude-use headroom supervisor: headroom pid ${String(headroomPid)} died`);
         headroomPid = void 0;
         runningHash = void 0;
+        runningSettingsHash = void 0;
         writeHeadroomState(fs16, paths.headroomStateFile, {
           supervisorPid: ports.ownPid,
           version: version2,
@@ -296268,12 +296330,13 @@ async function runSupervisor(config2, ports, options = {}) {
       }
       const previousSticky = lastPort;
       const port = lastPort !== void 0 && await ports.isPortFree(lastPort) ? lastPort : await ports.freePort();
-      const pid = ports.spawnHeadroom(port, allowlist);
+      const pid = ports.spawnHeadroom(port, allowlist, config2.settings);
       const ready = await waitUntilReady(ports, port);
       if (ready) {
         consecutiveFailures = 0;
         headroomPid = pid;
         runningHash = allowlistHash;
+        runningSettingsHash = settingsHash;
         lastPort = port;
         if (previousSticky !== void 0 && port !== previousSticky) {
           ports.log(
@@ -296286,6 +296349,7 @@ async function runSupervisor(config2, ports, options = {}) {
           port,
           version: version2,
           allowlistHash,
+          settingsHash,
           installedSource: config2.source,
           ...sticky()
         });
@@ -296302,12 +296366,13 @@ async function runSupervisor(config2, ports, options = {}) {
         continue;
       }
     } else {
-      if (runningHash !== allowlistHash || installedSource !== config2.source) {
+      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config2.source) {
         if (listSessions(fs16, paths.headroomSessionsDir).length === 0) {
           ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
           runningHash = void 0;
+          runningSettingsHash = void 0;
           continue;
         }
       }
@@ -296357,6 +296422,7 @@ async function waitUntilReady(ports, port) {
 function collectHeadroomStatus(fsPort, paths, isRunning) {
   const state = readHeadroomState(fsPort, paths.headroomStateFile) ?? {};
   const allowlist = currentHeadroomAllowlist(fsPort, paths);
+  const settings2 = settingsOf(readGlobalConfig(paths)?.headroom ?? {});
   return {
     state,
     supervisorAlive: state.supervisorPid !== void 0 && isRunning(state.supervisorPid),
@@ -296367,6 +296433,8 @@ function collectHeadroomStatus(fsPort, paths, isRunning) {
     })),
     allowlist,
     allowlistDrifted: state.allowlistHash !== void 0 && state.allowlistHash !== hashAllowlist(allowlist),
+    settings: settings2,
+    settingsDrifted: state.settingsHash !== void 0 && state.settingsHash !== hashSettings(settings2),
     logPath: paths.headroomLogPath,
     logExists: fsPort.readFileUtf8(paths.headroomLogPath) !== void 0
   };
@@ -296389,6 +296457,9 @@ function formatHeadroomStatus(status) {
   }
   const drift = status.allowlistDrifted ? " (DRIFTED: current provider files differ from the running daemon's allowlist; a restart is pending)" : "";
   lines.push(`allowlist: ${status.allowlist.join(", ")}${drift}`);
+  const configured = Object.entries(status.settings).map(([name, value]) => `${name} ${String(value)}`);
+  const settingsDrift = status.settingsDrifted ? " (DRIFTED: the configured settings differ from the running daemon's; a restart is pending)" : "";
+  lines.push(`settings: ${configured.length === 0 ? "headroom defaults" : configured.join(", ")}${settingsDrift}`);
   if (status.sessions.length === 0) {
     lines.push("sessions: none");
   } else {
@@ -296425,11 +296496,12 @@ var READY_FETCH_TIMEOUT_MS = 2e3;
 function headroomPidRunning(pid) {
   return !exitedHeadroom.has(pid) && realIsProcessRunning(pid);
 }
-function headroomSpawnEnv(parentEnv, allowlist) {
+function headroomSpawnEnv(parentEnv, allowlist, settings2) {
   return {
     ...parentEnv,
     HEADROOM_ALLOWED_BASE_URLS: allowlist.join(","),
-    HEADROOM_HTTP2: parentEnv.HEADROOM_HTTP2 ?? "0"
+    HEADROOM_HTTP2: parentEnv.HEADROOM_HTTP2 ?? "0",
+    ...settingsEnv(settings2)
   };
 }
 function realSupervisorPorts(paths) {
@@ -296447,14 +296519,15 @@ function realSupervisorPorts(paths) {
     isRunning: headroomPidRunning,
     freePort: realFreePort,
     isPortFree: realIsPortFree,
-    spawnHeadroom: (port, allowlist) => {
+    readConfig: () => resolveSupervisorConfig(readGlobalConfig(paths)?.headroom ?? {}),
+    spawnHeadroom: (port, allowlist, settings2) => {
       import_node_fs14.default.mkdirSync(paths.logsDir, { recursive: true });
       const logFd = import_node_fs14.default.openSync(paths.headroomLogPath, "a");
       try {
-        const child = (0, import_node_child_process5.spawn)("headroom", ["proxy", "--host", "127.0.0.1", "--port", String(port)], {
+        const child = (0, import_node_child_process5.spawn)("headroom", ["proxy", "--host", "127.0.0.1", "--port", String(port), ...settingsArgs(settings2)], {
           detached: true,
           stdio: ["ignore", logFd, logFd],
-          env: headroomSpawnEnv(process.env, allowlist)
+          env: headroomSpawnEnv(process.env, allowlist, settings2)
         });
         if (child.pid === void 0) {
           throw new Error("spawning headroom returned no pid");
@@ -296625,10 +296698,10 @@ function buildProgram(deps) {
 
 // src/runClaude.ts
 var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 
 // src/launcher.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var import_node_path29 = __toESM(require("node:path"), 1);
 
 // src/launcher/cliOverride.ts
@@ -296768,6 +296841,15 @@ function buildFlagArgs(flags) {
 function buildArgv(params) {
   return [...params.toolFlags, ...params.extraFlags, ...params.passthrough];
 }
+var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "::1"];
+function isLoopbackUrl(baseUrl) {
+  const host = new URL(baseUrl).hostname.replace(/^\[|\]$/g, "");
+  return LOOPBACK_HOSTS.some((loopback) => loopback === host);
+}
+function withLoopbackHosts(existing) {
+  const listed = (existing ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+  return [...listed, ...LOOPBACK_HOSTS.filter((host) => !listed.includes(host))].join(",");
+}
 function buildEnv(params) {
   const env = { ...params.baseEnv };
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
@@ -296779,6 +296861,10 @@ function buildEnv(params) {
     const providerEnv = params.provider.definition.env ?? {};
     providerCustomHeaders = providerEnv.ANTHROPIC_CUSTOM_HEADERS;
     env.ANTHROPIC_BASE_URL = params.provider.baseUrl;
+    if (isLoopbackUrl(params.provider.baseUrl)) {
+      env.NO_PROXY = withLoopbackHosts(params.baseEnv.NO_PROXY);
+      env.no_proxy = withLoopbackHosts(params.baseEnv.no_proxy);
+    }
     env.CLAUDE_USE_PROVIDER = params.provider.definition.displayName;
     for (const [key, value] of Object.entries(providerEnv)) {
       env[key] = value;
@@ -297067,7 +297153,7 @@ function runLauncher(params) {
     ...identityCredential === void 0 ? {} : { identityCredential },
     ...frontDoor === void 0 ? {} : { frontdoor: frontDoor },
     ...headroom === void 0 ? {} : { headroom },
-    sessionId: (0, import_node_crypto12.randomUUID)()
+    sessionId: (0, import_node_crypto13.randomUUID)()
   });
   const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
   if (releases.length === 0) {
@@ -297119,7 +297205,7 @@ function buildFarmRuntime(paths) {
         ...cliOverride === void 0 ? {} : { cliOverride }
       }).input,
       now: () => Date.now(),
-      uniqueSuffix: `${String(process.pid)}.${(0, import_node_crypto13.randomUUID)()}`,
+      uniqueSuffix: `${String(process.pid)}.${(0, import_node_crypto14.randomUUID)()}`,
       // Zombie-aware on purpose: a previous launcher that crashed out of a resync without releasing the lock may sit unreaped, still answering signal 0 as alive, and must read as a dead holder so this launch takes the lock over instead of timing out.
       lock: { pid: process.pid, isRunning: realIsProcessRunning, sleep: realSleepSync }
     },

package/dist/index.cjs

@@ -224,11 +224,36 @@ var PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).exten
   identity: import_zod.z.string().min(1).optional(),
   when: WhenSchema.optional()
 });
-var HeadroomGlobalConfigSchema = import_zod.z.strictObject({
+var HEADROOM_MODES = ["cache", "token"];
+var HEADROOM_CCR_MODES = ["default", "lossless", "none"];
+var HEADROOM_ROLLOUT_CHANNELS = ["beta", "canary", "dev"];
+var INTERCEPT_CHANNELS = ["canary", "dev"];
+var READ_MATURATION_CHANNELS = ["beta", "dev"];
+var HeadroomGlobalConfigObjectSchema = import_zod.z.strictObject({
   /** Install spec handed to `uv tool install`. Defaults to HEADROOM_DEFAULT_SOURCE. */
   source: import_zod.z.string().min(1).optional(),
   /** How long the daemon may sit with no registered sessions before the supervisor stops it. Defaults to HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
-  idleShutdownMinutes: import_zod.z.number().int().positive().optional()
+  idleShutdownMinutes: import_zod.z.number().int().positive().optional(),
+  /** Optimisation mode, passed as `--mode`. Unset leaves headroom's own default (`cache`). */
+  mode: import_zod.z.enum(HEADROOM_MODES).optional(),
+  /** Keep-ratio for prose and code compression, passed as `--target-ratio`: lower is more aggressive. Unset lets headroom decide. */
+  targetRatio: import_zod.z.number().gt(0).max(1).optional(),
+  /** How compressed tool output stays recoverable. Unset leaves headroom's own default (`default`). */
+  ccr: import_zod.z.enum(HEADROOM_CCR_MODES).optional(),
+  /** Headroom's experimental release channel, exported as `HEADROOM_ROLLOUT_CHANNEL`. Required by `interceptToolResults` and `readMaturation`, which are refused without a channel that unlocks them. */
+  rolloutChannel: import_zod.z.enum(HEADROOM_ROLLOUT_CHANNELS).optional(),
+  /** Opt in to headroom's tool-result interceptors (`--intercept-tool-results`). Needs `rolloutChannel` canary or dev. */
+  interceptToolResults: import_zod.z.boolean().optional(),
+  /** Opt in to headroom's experimental read maturation (`--read-maturation`). Needs `rolloutChannel` beta or dev. */
+  readMaturation: import_zod.z.boolean().optional()
+});
+var HeadroomGlobalConfigSchema = HeadroomGlobalConfigObjectSchema.superRefine((config, context) => {
+  if (config.interceptToolResults === true && !INTERCEPT_CHANNELS.includes(config.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["interceptToolResults"], message: "interceptToolResults needs rolloutChannel canary or dev" });
+  }
+  if (config.readMaturation === true && !READ_MATURATION_CHANNELS.includes(config.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
+  }
 });
 var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@eb02fa4126450c9905a49394fdec19ae2e7c9c30";
 var HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
@@ -2531,6 +2556,8 @@ var HeadroomStateSchema = import_zod4.z.strictObject({
   version: import_zod4.z.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
   allowlistHash: import_zod4.z.string().optional(),
+  /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
+  settingsHash: import_zod4.z.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
   installedSource: import_zod4.z.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
@@ -2749,11 +2776,41 @@ function ensureHeadroom(params) {
   }
 }
 
+// src/headroom/settings.ts
+var import_node_crypto4 = require("node:crypto");
+function settingsOf(config) {
+  return {
+    ...config.mode === void 0 ? {} : { mode: config.mode },
+    ...config.targetRatio === void 0 ? {} : { targetRatio: config.targetRatio },
+    ...config.ccr === void 0 ? {} : { ccr: config.ccr },
+    ...config.rolloutChannel === void 0 ? {} : { rolloutChannel: config.rolloutChannel },
+    ...config.interceptToolResults === void 0 ? {} : { interceptToolResults: config.interceptToolResults },
+    ...config.readMaturation === void 0 ? {} : { readMaturation: config.readMaturation }
+  };
+}
+function settingsArgs(settings) {
+  return [
+    ...settings.mode === void 0 ? [] : ["--mode", settings.mode],
+    ...settings.targetRatio === void 0 ? [] : ["--target-ratio", String(settings.targetRatio)],
+    ...settings.ccr === "lossless" ? ["--lossless"] : [],
+    ...settings.ccr === "none" ? ["--no-ccr"] : [],
+    ...settings.interceptToolResults === true ? ["--intercept-tool-results"] : [],
+    ...settings.readMaturation === true ? ["--read-maturation"] : []
+  ];
+}
+function settingsEnv(settings) {
+  return settings.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings.rolloutChannel };
+}
+function hashSettings(settings) {
+  return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
+}
+
 // src/headroom/supervisor.ts
 function resolveSupervisorConfig(configured) {
   return {
     source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
-    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES
+    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
+    settings: settingsOf(configured)
   };
 }
 var HEADROOM_BACKOFF_BASE_MS = 500;
@@ -2816,8 +2873,9 @@ function compareVersions(a, b) {
   return 0;
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
-async function runSupervisor(config, ports, options = {}) {
+async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs2, paths } = ports;
+  let config = initialConfig;
   const previousState = readHeadroomState(fs2, paths.headroomStateFile);
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
@@ -2859,6 +2917,7 @@ async function runSupervisor(config, ports, options = {}) {
   }
   let headroomPid;
   let runningHash;
+  let runningSettingsHash;
   let consecutiveFailures = 0;
   let idleSince;
   let ticks = 0;
@@ -2867,6 +2926,8 @@ async function runSupervisor(config, ports, options = {}) {
       return HEADROOM_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
+    config = ports.readConfig();
+    const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
@@ -2876,6 +2937,7 @@ async function runSupervisor(config, ports, options = {}) {
         ports.log(`claude-use headroom supervisor: headroom pid ${String(headroomPid)} died`);
         headroomPid = void 0;
         runningHash = void 0;
+        runningSettingsHash = void 0;
         writeHeadroomState(fs2, paths.headroomStateFile, {
           supervisorPid: ports.ownPid,
           version,
@@ -2891,12 +2953,13 @@ async function runSupervisor(config, ports, options = {}) {
       }
       const previousSticky = lastPort;
       const port = lastPort !== void 0 && await ports.isPortFree(lastPort) ? lastPort : await ports.freePort();
-      const pid = ports.spawnHeadroom(port, allowlist);
+      const pid = ports.spawnHeadroom(port, allowlist, config.settings);
       const ready = await waitUntilReady(ports, port);
       if (ready) {
         consecutiveFailures = 0;
         headroomPid = pid;
         runningHash = allowlistHash;
+        runningSettingsHash = settingsHash;
         lastPort = port;
         if (previousSticky !== void 0 && port !== previousSticky) {
           ports.log(
@@ -2909,6 +2972,7 @@ async function runSupervisor(config, ports, options = {}) {
           port,
           version,
           allowlistHash,
+          settingsHash,
           installedSource: config.source,
           ...sticky()
         });
@@ -2925,12 +2989,13 @@ async function runSupervisor(config, ports, options = {}) {
         continue;
       }
     } else {
-      if (runningHash !== allowlistHash || installedSource !== config.source) {
+      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
         if (listSessions(fs2, paths.headroomSessionsDir).length === 0) {
           ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
           runningHash = void 0;
+          runningSettingsHash = void 0;
           continue;
         }
       }

package/dist/index.mjs

@@ -155,11 +155,36 @@ var PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).exten
   identity: z.string().min(1).optional(),
   when: WhenSchema.optional()
 });
-var HeadroomGlobalConfigSchema = z.strictObject({
+var HEADROOM_MODES = ["cache", "token"];
+var HEADROOM_CCR_MODES = ["default", "lossless", "none"];
+var HEADROOM_ROLLOUT_CHANNELS = ["beta", "canary", "dev"];
+var INTERCEPT_CHANNELS = ["canary", "dev"];
+var READ_MATURATION_CHANNELS = ["beta", "dev"];
+var HeadroomGlobalConfigObjectSchema = z.strictObject({
   /** Install spec handed to `uv tool install`. Defaults to HEADROOM_DEFAULT_SOURCE. */
   source: z.string().min(1).optional(),
   /** How long the daemon may sit with no registered sessions before the supervisor stops it. Defaults to HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
-  idleShutdownMinutes: z.number().int().positive().optional()
+  idleShutdownMinutes: z.number().int().positive().optional(),
+  /** Optimisation mode, passed as `--mode`. Unset leaves headroom's own default (`cache`). */
+  mode: z.enum(HEADROOM_MODES).optional(),
+  /** Keep-ratio for prose and code compression, passed as `--target-ratio`: lower is more aggressive. Unset lets headroom decide. */
+  targetRatio: z.number().gt(0).max(1).optional(),
+  /** How compressed tool output stays recoverable. Unset leaves headroom's own default (`default`). */
+  ccr: z.enum(HEADROOM_CCR_MODES).optional(),
+  /** Headroom's experimental release channel, exported as `HEADROOM_ROLLOUT_CHANNEL`. Required by `interceptToolResults` and `readMaturation`, which are refused without a channel that unlocks them. */
+  rolloutChannel: z.enum(HEADROOM_ROLLOUT_CHANNELS).optional(),
+  /** Opt in to headroom's tool-result interceptors (`--intercept-tool-results`). Needs `rolloutChannel` canary or dev. */
+  interceptToolResults: z.boolean().optional(),
+  /** Opt in to headroom's experimental read maturation (`--read-maturation`). Needs `rolloutChannel` beta or dev. */
+  readMaturation: z.boolean().optional()
+});
+var HeadroomGlobalConfigSchema = HeadroomGlobalConfigObjectSchema.superRefine((config, context) => {
+  if (config.interceptToolResults === true && !INTERCEPT_CHANNELS.includes(config.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["interceptToolResults"], message: "interceptToolResults needs rolloutChannel canary or dev" });
+  }
+  if (config.readMaturation === true && !READ_MATURATION_CHANNELS.includes(config.rolloutChannel ?? "")) {
+    context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
+  }
 });
 var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@eb02fa4126450c9905a49394fdec19ae2e7c9c30";
 var HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
@@ -2462,6 +2487,8 @@ var HeadroomStateSchema = z4.strictObject({
   version: z4.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
   allowlistHash: z4.string().optional(),
+  /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
+  settingsHash: z4.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
   installedSource: z4.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
@@ -2680,11 +2707,41 @@ function ensureHeadroom(params) {
   }
 }
 
+// src/headroom/settings.ts
+import { createHash as createHash2 } from "node:crypto";
+function settingsOf(config) {
+  return {
+    ...config.mode === void 0 ? {} : { mode: config.mode },
+    ...config.targetRatio === void 0 ? {} : { targetRatio: config.targetRatio },
+    ...config.ccr === void 0 ? {} : { ccr: config.ccr },
+    ...config.rolloutChannel === void 0 ? {} : { rolloutChannel: config.rolloutChannel },
+    ...config.interceptToolResults === void 0 ? {} : { interceptToolResults: config.interceptToolResults },
+    ...config.readMaturation === void 0 ? {} : { readMaturation: config.readMaturation }
+  };
+}
+function settingsArgs(settings) {
+  return [
+    ...settings.mode === void 0 ? [] : ["--mode", settings.mode],
+    ...settings.targetRatio === void 0 ? [] : ["--target-ratio", String(settings.targetRatio)],
+    ...settings.ccr === "lossless" ? ["--lossless"] : [],
+    ...settings.ccr === "none" ? ["--no-ccr"] : [],
+    ...settings.interceptToolResults === true ? ["--intercept-tool-results"] : [],
+    ...settings.readMaturation === true ? ["--read-maturation"] : []
+  ];
+}
+function settingsEnv(settings) {
+  return settings.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings.rolloutChannel };
+}
+function hashSettings(settings) {
+  return createHash2("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
+}
+
 // src/headroom/supervisor.ts
 function resolveSupervisorConfig(configured) {
   return {
     source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
-    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES
+    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
+    settings: settingsOf(configured)
   };
 }
 var HEADROOM_BACKOFF_BASE_MS = 500;
@@ -2747,8 +2804,9 @@ function compareVersions(a, b) {
   return 0;
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
-async function runSupervisor(config, ports, options = {}) {
+async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs2, paths } = ports;
+  let config = initialConfig;
   const previousState = readHeadroomState(fs2, paths.headroomStateFile);
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
@@ -2790,6 +2848,7 @@ async function runSupervisor(config, ports, options = {}) {
   }
   let headroomPid;
   let runningHash;
+  let runningSettingsHash;
   let consecutiveFailures = 0;
   let idleSince;
   let ticks = 0;
@@ -2798,6 +2857,8 @@ async function runSupervisor(config, ports, options = {}) {
       return HEADROOM_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
+    config = ports.readConfig();
+    const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
@@ -2807,6 +2868,7 @@ async function runSupervisor(config, ports, options = {}) {
         ports.log(`claude-use headroom supervisor: headroom pid ${String(headroomPid)} died`);
         headroomPid = void 0;
         runningHash = void 0;
+        runningSettingsHash = void 0;
         writeHeadroomState(fs2, paths.headroomStateFile, {
           supervisorPid: ports.ownPid,
           version,
@@ -2822,12 +2884,13 @@ async function runSupervisor(config, ports, options = {}) {
       }
       const previousSticky = lastPort;
       const port = lastPort !== void 0 && await ports.isPortFree(lastPort) ? lastPort : await ports.freePort();
-      const pid = ports.spawnHeadroom(port, allowlist);
+      const pid = ports.spawnHeadroom(port, allowlist, config.settings);
       const ready = await waitUntilReady(ports, port);
       if (ready) {
         consecutiveFailures = 0;
         headroomPid = pid;
         runningHash = allowlistHash;
+        runningSettingsHash = settingsHash;
         lastPort = port;
         if (previousSticky !== void 0 && port !== previousSticky) {
           ports.log(
@@ -2840,6 +2903,7 @@ async function runSupervisor(config, ports, options = {}) {
           port,
           version,
           allowlistHash,
+          settingsHash,
           installedSource: config.source,
           ...sticky()
         });
@@ -2856,12 +2920,13 @@ async function runSupervisor(config, ports, options = {}) {
         continue;
       }
     } else {
-      if (runningHash !== allowlistHash || installedSource !== config.source) {
+      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
         if (listSessions(fs2, paths.headroomSessionsDir).length === 0) {
           ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
           runningHash = void 0;
+          runningSettingsHash = void 0;
           continue;
         }
       }

package/dist/types/config/schema.d.ts

@@ -559,6 +559,28 @@ export declare const PortableConfigSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type PortableConfig = z.infer<typeof PortableConfigSchema>;
+declare const HeadroomGlobalConfigSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    idleShutdownMinutes: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        cache: "cache";
+        token: "token";
+    }>>;
+    targetRatio: z.ZodOptional<z.ZodNumber>;
+    ccr: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        none: "none";
+        lossless: "lossless";
+    }>>;
+    rolloutChannel: z.ZodOptional<z.ZodEnum<{
+        beta: "beta";
+        canary: "canary";
+        dev: "dev";
+    }>>;
+    interceptToolResults: z.ZodOptional<z.ZodBoolean>;
+    readMaturation: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type HeadroomGlobalConfig = z.infer<typeof HeadroomGlobalConfigSchema>;
 /**
  * The default `headroom.source` install spec: the ExaDev headroom repository, with the `proxy` extra that provides the `headroom proxy` entry point. Pinned to a full commit SHA (the fork's `exadev-per-session-savings-1` tag), because a branch name can be rebased or deleted and would change or break every fresh install; bump it deliberately when the fork's per-session savings work changes. Kept here rather than in the supervisor because it is the schema's own documented default, referenced by `HeadroomGlobalConfigSchema`'s field docs.
  */
@@ -608,6 +630,23 @@ export declare const GlobalConfigSchema: z.ZodObject<{
     headroom: z.ZodOptional<z.ZodObject<{
         source: z.ZodOptional<z.ZodString>;
         idleShutdownMinutes: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            cache: "cache";
+            token: "token";
+        }>>;
+        targetRatio: z.ZodOptional<z.ZodNumber>;
+        ccr: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            none: "none";
+            lossless: "lossless";
+        }>>;
+        rolloutChannel: z.ZodOptional<z.ZodEnum<{
+            beta: "beta";
+            canary: "canary";
+            dev: "dev";
+        }>>;
+        interceptToolResults: z.ZodOptional<z.ZodBoolean>;
+        readMaturation: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
     frontdoor: z.ZodOptional<z.ZodObject<{
         idleShutdownMinutes: z.ZodOptional<z.ZodNumber>;

package/dist/types/headroom/settings.d.ts

@@ -0,0 +1,13 @@
+import type { HeadroomGlobalConfig } from "../config/schema";
+/** The token-saving settings of the `headroom` config block, without its install and lifecycle fields (`source`, `idleShutdownMinutes`). */
+export type HeadroomSettings = Pick<HeadroomGlobalConfig, "mode" | "targetRatio" | "ccr" | "rolloutChannel" | "interceptToolResults" | "readMaturation">;
+/** Picks the settings out of a headroom config block, leaving unset fields unset. */
+export declare function settingsOf(config: Readonly<HeadroomGlobalConfig>): HeadroomSettings;
+/**
+ * The `headroom proxy` arguments the settings ask for, after the supervisor's own `--host` and `--port`. Only settings that are set produce a flag, so an empty settings object leaves headroom on its own defaults. `ccr: "default"` is headroom's default and likewise adds nothing.
+ */
+export declare function settingsArgs(settings: Readonly<HeadroomSettings>): string[];
+/** The environment the settings add to the daemon's: only the rollout channel, which headroom reads from `HEADROOM_ROLLOUT_CHANNEL` and has no flag for. */
+export declare function settingsEnv(settings: Readonly<HeadroomSettings>): Record<string, string>;
+/** A stable hash of the settings, so drift detection compares one short string against what the running daemon was started with. The same settings hash the same whatever order the config file wrote its keys in. */
+export declare function hashSettings(settings: Readonly<HeadroomSettings>): string;

package/dist/types/headroom/state.d.ts

@@ -13,6 +13,7 @@ export declare const HeadroomStateSchema: z.ZodObject<{
     lastPort: z.ZodOptional<z.ZodNumber>;
     version: z.ZodOptional<z.ZodString>;
     allowlistHash: z.ZodOptional<z.ZodString>;
+    settingsHash: z.ZodOptional<z.ZodString>;
     installedSource: z.ZodOptional<z.ZodString>;
     lastError: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/types/headroom/supervisor.d.ts

@@ -1,4 +1,6 @@
+import { type HeadroomGlobalConfig } from "../config/schema";
 import type { LayoutPaths } from "../paths";
+import { type HeadroomSettings } from "./settings";
 import { type HeadroomFs } from "./state";
 /** Everything the supervisor needs to run the daemon, resolved from the global config and the filesystem before it starts. */
 export interface HeadroomSupervisorConfig {
@@ -6,12 +8,11 @@ export interface HeadroomSupervisorConfig {
     readonly source: string;
     /** `headroom.idleShutdownMinutes`, already defaulted. */
     readonly idleShutdownMinutes: number;
+    /** The token-saving settings (`mode`, `targetRatio`, `ccr`, the rollout channel and its opt-ins), as configured; unset fields leave headroom on its own defaults. */
+    readonly settings: HeadroomSettings;
 }
 /** How the supervisor resolves the configured source against its defaults. */
-export declare function resolveSupervisorConfig(configured: {
-    readonly source?: string;
-    readonly idleShutdownMinutes?: number;
-}): HeadroomSupervisorConfig;
+export declare function resolveSupervisorConfig(configured: Readonly<HeadroomGlobalConfig>): HeadroomSupervisorConfig;
 /**
  * Every effect the supervisor performs, injected so the whole lifecycle is testable against fakes: no real process, port, clock, or HTTP call ever happens in a unit test.
  */
@@ -35,7 +36,9 @@ export interface SupervisorPorts {
     /**
      * Starts `headroom proxy` bound to `port` with the given allowlist, returning its pid. Output goes to the daemon log. The implementation must keep the ChildProcess handle and attach an exit listener (detaching the process is fine; unref'ing a child you still need events from is not, since without the listener nothing reaps it and it lingers as a zombie).
      */
-    readonly spawnHeadroom: (port: number, allowlist: readonly string[]) => number;
+    readonly spawnHeadroom: (port: number, allowlist: readonly string[], settings: Readonly<HeadroomSettings>) => number;
+    /** Reads the headroom config block as it stands on disk now. The supervisor calls it every tick, so a changed `source` or setting is noticed while the daemon runs and applied by the same quiet-registry restart an allowlist change gets. */
+    readonly readConfig: () => HeadroomSupervisorConfig;
     /** Stops a process the supervisor owns, escalating SIGTERM to SIGKILL on a bounded timeout (see `stopSupervisedProcess`). */
     readonly stopProcess: (pid: number) => void;
     /** True once `GET /readyz` on the port succeeds. */
@@ -97,6 +100,6 @@ export declare const HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
  *
  * Every effect flows through `ports`, so the whole loop is unit-testable with a fake clock, filesystem, and processes. The loop awaits its sleeps, which in the real implementation run on a timer: between ticks the event loop turns, the spawned child's exit event is delivered (and the child thereby reaped), and the next tick's liveness check reads the truth.
  */
-export declare function runSupervisor(config: HeadroomSupervisorConfig, ports: SupervisorPorts, options?: RunSupervisorOptions): Promise<number>;
+export declare function runSupervisor(initialConfig: HeadroomSupervisorConfig, ports: SupervisorPorts, options?: RunSupervisorOptions): Promise<number>;
 /** The allowlist as it stands right now: every provider's upstream (the front door's origin for a codex provider, which headroom forwards codex traffic back to) plus Claude Code's own API. */
 export declare function currentHeadroomAllowlist(fs: HeadroomFs, paths: LayoutPaths): readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",