pi-smart-compact 9.5.0 → 9.6.0

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 
 // src/constants.ts
-var VERSION = "9.5.0";
+var VERSION = "9.6.0";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -48,6 +48,32 @@ var PROFILES = {
     batchMaxTokens: 18000
   }
 };
+var PROFILE_NUMERIC_BOUNDS = {
+  summaryBudgetTokens: [256, 1e5],
+  keepRecentTokens: [1000, 500000],
+  minChunkTokens: [100, 1e5],
+  maxChunkTokens: [500, 200000],
+  singlePassMaxTokens: [1000, 500000],
+  batchMaxTokens: [1000, 500000]
+};
+var CONFIG_NUMERIC_LIMITS = {
+  minContextPercent: { min: 0, max: 100, integer: false },
+  autoTriggerTimeoutMs: { min: 1000, max: 300000, integer: true },
+  maxLlmCalls: { min: 0, max: 100, integer: true },
+  maxLlmInputTokens: { min: 0, max: 1e6, integer: true },
+  codexMaxCallMs: {
+    min: 5000,
+    max: 300000,
+    integer: true,
+    zeroOrRange: true
+  },
+  maxLatencyMs: {
+    min: 5000,
+    max: 600000,
+    integer: true,
+    zeroOrRange: true
+  }
+};
 var DEFAULT_CONFIG = {
   mode: "auto",
   profile: "balanced",
@@ -315,102 +341,283 @@ var EXPLORER_SYSTEM_PROMPT = `You are a conversation analyst. You have determini
 ` + '{"boundaries":[{"afterIndex":N,"topic":"...","priority":"critical|high|normal|low","confidence":0.0-1.0}],"mainGoal":"...","sessionType":"implementation|review|debugging|discussion","enrichedConstraints":[...],"crossReferences":[...],"statusAssessment":{"done":[...],"inProgress":[...],"blocked":[...]},"criticalContext":[...],"keyDecisions":[...]}';
 
 // src/utils/config.ts
+import fs2 from "fs";
+
+// src/infra/fs.ts
 import fs from "fs";
+import fsp from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+
+// src/utils/logger.ts
+var DEBUG = process.env.DEBUG?.includes("smart-compact") ?? false;
+function warn(msg, err) {
+  const detail = err instanceof Error ? err.message : err ?? "";
+  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
+}
+function error(msg, err) {
+  const detail = err instanceof Error ? err.message + `
+` + err.stack : err ?? "";
+  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
+}
+function info(msg, ...args) {
+  console.error(LOG_PREFIX + " [info] " + msg, ...args);
+}
+function debug(msg, ...args) {
+  if (DEBUG)
+    console.error(LOG_PREFIX + " [debug] " + msg, ...args);
+}
+function debugError(msg, err) {
+  if (DEBUG)
+    error(msg, err);
+}
+
+// src/infra/fs.ts
+var LOCK_RETRY_MS = 25;
+var LOCK_MAX_RETRIES = 80;
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.chmodSync(dir, 448);
+}
+async function ensureDirAsync(dir) {
+  await fsp.mkdir(dir, { recursive: true, mode: 448 });
+  await fsp.chmod(dir, 448);
+}
+function tempPath(target) {
+  return target + ".tmp." + process.pid + "." + crypto.randomBytes(4).toString("hex");
+}
+function atomicWriteFileSync(target, data) {
+  ensureDir(path.dirname(target));
+  const tmp = tempPath(target);
+  try {
+    fs.writeFileSync(tmp, data, { mode: 384 });
+    fs.chmodSync(tmp, 384);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {}
+    throw e;
+  }
+}
+async function atomicWriteFile(target, data) {
+  await ensureDirAsync(path.dirname(target));
+  const tmp = tempPath(target);
+  try {
+    await fsp.writeFile(tmp, data, { mode: 384 });
+    await fsp.chmod(tmp, 384);
+    await fsp.rename(tmp, target);
+  } catch (e) {
+    try {
+      await fsp.unlink(tmp);
+    } catch {}
+    throw e;
+  }
+}
+function tryAcquireLock(target) {
+  const lockDir = target + ".lock";
+  const ownerFile = path.join(lockDir, "owner");
+  const token = process.pid + ":" + crypto.randomBytes(8).toString("hex");
+  try {
+    fs.mkdirSync(lockDir, { mode: 448 });
+  } catch (error2) {
+    if (error2?.code === "EEXIST")
+      return null;
+    throw new Error("Failed to acquire lock for " + target, { cause: error2 });
+  }
+  try {
+    fs.writeFileSync(ownerFile, token, { mode: 384, flag: "wx" });
+  } catch (error2) {
+    try {
+      fs.rmSync(lockDir, { recursive: true, force: true });
+    } catch {}
+    throw new Error("Failed to acquire lock for " + target, { cause: error2 });
+  }
+  return () => {
+    try {
+      if (fs.readFileSync(ownerFile, "utf8") === token) {
+        fs.rmSync(lockDir, { recursive: true });
+      }
+    } catch {}
+  };
+}
+function acquireLockSync(target) {
+  const release = tryAcquireLock(target);
+  if (!release)
+    throw new Error("Lock busy for " + target);
+  return release;
+}
+async function acquireLock(target) {
+  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
+    const release = tryAcquireLock(target);
+    if (release)
+      return release;
+    const delay = Promise.withResolvers();
+    setTimeout(delay.resolve, LOCK_RETRY_MS);
+    await delay.promise;
+  }
+  throw new Error("Timed out acquiring lock for " + target);
+}
+async function appendLineLockedAsync(target, line, maxBytes) {
+  await ensureDirAsync(path.dirname(target));
+  const payload = Buffer.from(line.endsWith(`
+`) ? line : line + `
+`);
+  if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
+    throw new Error("maxBytes must be a positive safe integer");
+  }
+  if (maxBytes !== undefined && payload.length > maxBytes) {
+    throw new Error("Log entry exceeds retention cap for " + target);
+  }
+  const release = await acquireLock(target);
+  try {
+    let stat = null;
+    try {
+      stat = await fsp.stat(target);
+    } catch (error2) {
+      if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "ENOENT")
+        throw error2;
+    }
+    if (maxBytes !== undefined && stat && stat.size + payload.length > maxBytes) {
+      const retainedLength = Math.min(stat.size, Math.max(0, maxBytes - payload.length));
+      const buffer = Buffer.allocUnsafe(retainedLength);
+      if (retainedLength > 0) {
+        const handle = await fsp.open(target, "r");
+        try {
+          await handle.read(buffer, 0, retainedLength, stat.size - retainedLength);
+        } finally {
+          await handle.close();
+        }
+      }
+      let tail = buffer.toString("utf8");
+      if (retainedLength < stat.size) {
+        const firstNewline = tail.indexOf(`
+`);
+        tail = firstNewline >= 0 ? tail.slice(firstNewline + 1) : "";
+      }
+      await atomicWriteFile(target, tail);
+    }
+    await fsp.appendFile(target, payload, { mode: 384 });
+    await fsp.chmod(target, 384);
+  } finally {
+    release();
+  }
+}
+function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
+  if (limit <= 0 || !fs.existsSync(target))
+    return [];
+  const stat = fs.statSync(target);
+  const length = Math.min(stat.size, maxBytes);
+  const buffer = Buffer.alloc(length);
+  const fd = fs.openSync(target, "r");
+  try {
+    fs.readSync(fd, buffer, 0, length, stat.size - length);
+  } finally {
+    fs.closeSync(fd);
+  }
+  let text = buffer.toString("utf8");
+  if (stat.size > length) {
+    const newline = text.indexOf(`
+`);
+    text = newline >= 0 ? text.slice(newline + 1) : "";
+  }
+  const values = [];
+  for (const line of text.split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      values.push(JSON.parse(line));
+    } catch {}
+  }
+  return values.slice(-limit);
+}
+function readJsonSync(target) {
+  try {
+    if (!fs.existsSync(target))
+      return null;
+    const raw = fs.readFileSync(target, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    warn("readJsonSync failed for " + target, e);
+    return null;
+  }
+}
+function writeJsonSync(target, value, pretty = false) {
+  atomicWriteFileSync(target, pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value));
+}
 
 // src/infra/paths.ts
-import path from "path";
+import path2 from "path";
 import os from "os";
 function home() {
   const configured = process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
   return configured || os.homedir();
 }
 function piAgentDir() {
-  return path.join(home(), ".pi", "agent");
+  return path2.join(home(), ".pi", "agent");
 }
 function cacheDir() {
-  return path.join(piAgentDir(), ".cache");
+  return path2.join(piAgentDir(), ".cache");
 }
 function smartCompactCacheDir() {
-  return path.join(cacheDir(), "smart-compact");
+  return path2.join(cacheDir(), "smart-compact");
 }
 function projectFingerprintDir() {
-  return path.join(smartCompactCacheDir(), "projects");
+  return path2.join(smartCompactCacheDir(), "projects");
 }
 function compactionStateDir() {
-  return path.join(smartCompactCacheDir(), "states");
+  return path2.join(smartCompactCacheDir(), "states");
 }
 function sessionsDir() {
-  return path.join(piAgentDir(), "sessions");
+  return path2.join(piAgentDir(), "sessions");
 }
 function settingsFile() {
-  return path.join(piAgentDir(), "settings.json");
+  return path2.join(piAgentDir(), "settings.json");
 }
 function defaultBackupDir() {
-  return path.join(piAgentDir(), "compact-backups");
+  return path2.join(piAgentDir(), "compact-backups");
 }
 function metricsLogFile() {
-  return path.join(cacheDir(), "compact-metrics.jsonl");
+  return path2.join(cacheDir(), "compact-metrics.jsonl");
 }
 function runLocksDir() {
-  return path.join(smartCompactCacheDir(), "run-locks");
+  return path2.join(smartCompactCacheDir(), "run-locks");
 }
 function nativeContinuityDir() {
-  return path.join(smartCompactCacheDir(), "native-continuity");
+  return path2.join(smartCompactCacheDir(), "native-continuity");
 }
 function contextGraphFile() {
-  return path.join(smartCompactCacheDir(), "context-graph.sqlite");
+  return path2.join(smartCompactCacheDir(), "context-graph.sqlite");
 }
 function damageReportsFile() {
-  return path.join(smartCompactCacheDir(), "damage-reports.jsonl");
+  return path2.join(smartCompactCacheDir(), "damage-reports.jsonl");
 }
 function extractionCacheFile(sessionId) {
-  return path.join(cacheDir(), EXTRACTION_CACHE_PREFIX + sessionId.replace(/[^a-zA-Z0-9-]/g, "_") + ".json");
+  return path2.join(cacheDir(), EXTRACTION_CACHE_PREFIX + sessionId.replace(/[^a-zA-Z0-9-]/g, "_") + ".json");
 }
 function projectFingerprintFile(projectId) {
-  return path.join(projectFingerprintDir(), projectId + ".json");
+  return path2.join(projectFingerprintDir(), projectId + ".json");
 }
 function compactionStateFile(projectId) {
-  return path.join(compactionStateDir(), projectId.replace(/[^a-zA-Z0-9_-]/g, "_") + ".json");
+  return path2.join(compactionStateDir(), projectId.replace(/[^a-zA-Z0-9_-]/g, "_") + ".json");
 }
 function legacyScopedCompactionStateFile(projectId, sessionId) {
   const project = projectId.replace(/[^a-zA-Z0-9_-]/g, "_");
   const session = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path.join(compactionStateDir(), project, session + ".json");
+  return path2.join(compactionStateDir(), project, session + ".json");
 }
 function scopedCompactionStateFile(projectId, sessionId, branchHeadId) {
   const project = projectId.replace(/[^a-zA-Z0-9_-]/g, "_");
   const session = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
   const branch = branchHeadId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path.join(compactionStateDir(), project, session, branch + ".json");
+  return path2.join(compactionStateDir(), project, session, branch + ".json");
 }
 function remediationHintsFile(projectId) {
-  return path.join(smartCompactCacheDir(), "remediation-" + projectId + ".json");
+  return path2.join(smartCompactCacheDir(), "remediation-" + projectId + ".json");
 }
 function metricsDashboardFile() {
-  return path.join(cacheDir(), "smart-compact-report.html");
-}
-
-// src/utils/logger.ts
-var DEBUG = process.env.DEBUG?.includes("smart-compact") ?? false;
-function warn(msg, err) {
-  const detail = err instanceof Error ? err.message : err ?? "";
-  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
-}
-function error(msg, err) {
-  const detail = err instanceof Error ? err.message + `
-` + err.stack : err ?? "";
-  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
-}
-function info(msg, ...args) {
-  console.error(LOG_PREFIX + " [info] " + msg, ...args);
-}
-function debug(msg, ...args) {
-  if (DEBUG)
-    console.error(LOG_PREFIX + " [debug] " + msg, ...args);
-}
-function debugError(msg, err) {
-  if (DEBUG)
-    error(msg, err);
+  return path2.join(cacheDir(), "smart-compact-report.html");
 }
 
 // src/utils/config.ts
@@ -456,14 +663,116 @@ var PROFILE_NUMERIC_KEYS = [
   "singlePassMaxTokens",
   "batchMaxTokens"
 ];
-var PROFILE_NUMERIC_BOUNDS = {
-  summaryBudgetTokens: [256, 1e5],
-  keepRecentTokens: [1000, 500000],
-  minChunkTokens: [100, 1e5],
-  maxChunkTokens: [500, 200000],
-  singlePassMaxTokens: [1000, 500000],
-  batchMaxTokens: [1000, 500000]
-};
+function readGlobalConfigValue(configPath) {
+  assertGlobalConfigPath(configPath);
+  try {
+    const section = configuredSection(readSettingsRoot(settingsFile()));
+    validateSmartCompactConfig(section);
+    return cloneGlobalConfigValue(configPathValue(section, configPath));
+  } catch {
+    return;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneProfiles(profiles) {
+  return Object.fromEntries(VALID_PROFILES.map((name) => [name, { ...profiles[name] }]));
+}
+function cloneConfig(config) {
+  return {
+    ...config,
+    profiles: cloneProfiles(config.profiles),
+    pinPaths: [...config.pinPaths]
+  };
+}
+function defaultConfig() {
+  return cloneConfig({
+    ...DEFAULT_CONFIG,
+    backupDir: defaultBackupDir()
+  });
+}
+function cloneGlobalConfigValue(value) {
+  return Array.isArray(value) ? [...value] : value;
+}
+function readSettingsRoot(file) {
+  if (!fs2.existsSync(file))
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+  } catch {
+    throw new Error("settings.json must contain valid JSON");
+  }
+  if (!isRecord(parsed)) {
+    throw new Error("settings.json root must be an object");
+  }
+  return parsed;
+}
+function configuredSection(root) {
+  const selected = Object.hasOwn(root, CONFIG_KEY) ? root[CONFIG_KEY] : root[CONFIG_KEY_ALT] ?? {};
+  if (!isRecord(selected)) {
+    throw new Error("smartCompact must be an object");
+  }
+  return structuredClone(selected);
+}
+function deleteEmptyProfileContainers(section, profile) {
+  if (!isRecord(section.profiles))
+    return;
+  if (isRecord(section.profiles[profile])) {
+    const values = section.profiles[profile];
+    if (Object.keys(values).length === 0)
+      delete section.profiles[profile];
+  }
+  if (Object.keys(section.profiles).length === 0)
+    delete section.profiles;
+}
+function setConfigPath(section, configPath, value) {
+  const parts = configPath.split(".");
+  if (parts[0] !== "profiles") {
+    if (value === undefined)
+      delete section[configPath];
+    else
+      section[configPath] = value;
+    return;
+  }
+  const [, profile, key] = parts;
+  if (!isRecord(section.profiles))
+    section.profiles = {};
+  const profiles = section.profiles;
+  if (!isRecord(profiles[profile]))
+    profiles[profile] = {};
+  const values = profiles[profile];
+  if (value === undefined)
+    delete values[key];
+  else
+    values[key] = value;
+  deleteEmptyProfileContainers(section, profile);
+}
+function assertGlobalConfigPath(configPath) {
+  if (configPath !== "profiles" && Object.hasOwn(DEFAULT_CONFIG, configPath)) {
+    return;
+  }
+  const parts = configPath.split(".");
+  if (parts.length === 3 && parts[0] === "profiles" && VALID_PROFILES.includes(parts[1]) && PROFILE_NUMERIC_KEYS.includes(parts[2])) {
+    return;
+  }
+  throw new Error(`Unknown smartCompact setting path: ${configPath}`);
+}
+function configPathValue(section, configPath) {
+  const parts = configPath.split(".");
+  if (parts[0] !== "profiles") {
+    return section[configPath];
+  }
+  const [, profile, key] = parts;
+  if (!isRecord(section.profiles))
+    return;
+  const values = section.profiles[profile];
+  return isRecord(values) ? values[key] : undefined;
+}
+function sameJsonValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 function discard(sc, key, message) {
   warn(message);
   delete sc[key];
@@ -513,7 +822,7 @@ function validateBasicFields(sc) {
 function validateProfiles(sc) {
   if (!("profiles" in sc))
     return;
-  if (typeof sc.profiles !== "object" || sc.profiles === null || Array.isArray(sc.profiles)) {
+  if (!isRecord(sc.profiles)) {
     discard(sc, "profiles", "smart-compact config: profiles must be an object, got " + typeof sc.profiles);
     return;
   }
@@ -523,7 +832,7 @@ function validateProfiles(sc) {
       discard(profiles, profileName, "smart-compact config: ignoring unknown profile override '" + profileName + "'.");
       continue;
     }
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    if (!isRecord(value)) {
       discard(profiles, profileName, "smart-compact config: profile '" + profileName + "' must be an object.");
       continue;
     }
@@ -547,35 +856,39 @@ function validateProfiles(sc) {
     }
   }
 }
+function validNumericLimit(key, value) {
+  const limit = CONFIG_NUMERIC_LIMITS[key];
+  return Number.isFinite(value) && (!limit.integer || Number.isSafeInteger(value)) && (value >= limit.min && value <= limit.max || ("zeroOrRange" in limit) && limit.zeroOrRange && value === 0);
+}
 var NUMERIC_RULES = [
   {
     key: "autoTriggerTimeoutMs",
-    valid: (value) => Number.isFinite(value) && value >= 1000 && value <= 300000,
+    valid: (value) => validNumericLimit("autoTriggerTimeoutMs", value),
     message: (value) => "smart-compact config: autoTriggerTimeoutMs must be 1000\u2013300000, got " + value + ". Using default " + DEFAULT_CONFIG.autoTriggerTimeoutMs + "ms."
   },
   {
     key: "maxLlmCalls",
-    valid: (value) => Number.isInteger(value) && value >= 0 && value <= 100,
+    valid: (value) => validNumericLimit("maxLlmCalls", value),
     message: () => "smart-compact config: maxLlmCalls must be 0\u2013100; 0 uses the selected mode cap."
   },
   {
     key: "maxLlmInputTokens",
-    valid: (value) => Number.isInteger(value) && value >= 0 && value <= 1e6,
+    valid: (value) => validNumericLimit("maxLlmInputTokens", value),
     message: () => "smart-compact config: maxLlmInputTokens must be 0\u20131000000; 0 uses the mode cap."
   },
   {
     key: "codexMaxCallMs",
-    valid: (value) => Number.isInteger(value) && (value === 0 || value >= 5000 && value <= 300000),
+    valid: (value) => validNumericLimit("codexMaxCallMs", value),
     message: () => "smart-compact config: codexMaxCallMs must be 0 or 5000\u2013300000; 0 derives a cap from maxTokens."
   },
   {
     key: "maxLatencyMs",
-    valid: (value) => Number.isFinite(value) && (value === 0 || value >= 5000 && value <= 600000),
+    valid: (value) => validNumericLimit("maxLatencyMs", value),
     message: () => "smart-compact config: maxLatencyMs must be 0 or 5000\u2013600000; 0 means unlimited."
   },
   {
     key: "minContextPercent",
-    valid: (value) => Number.isFinite(value) && value >= 0 && value <= 100,
+    valid: (value) => validNumericLimit("minContextPercent", value),
     message: (value) => "smart-compact config: minContextPercent must be 0\u2013100, got " + value + ". Using default " + DEFAULT_CONFIG.minContextPercent + "."
   }
 ];
@@ -600,39 +913,78 @@ function validateSmartCompactConfig(sc) {
   validateProfiles(sc);
   validateLimits(sc);
 }
+async function writeGlobalConfigValue(configPath, value) {
+  assertGlobalConfigPath(configPath);
+  const file = settingsFile();
+  const release = await acquireLock(file);
+  try {
+    const root = readSettingsRoot(file);
+    const section = configuredSection(root);
+    setConfigPath(section, configPath, cloneGlobalConfigValue(value));
+    if (value === undefined && configPath === "agentToolAccess") {
+      delete section.agentToolEnabled;
+    }
+    const validated = structuredClone(section);
+    validateSmartCompactConfig(validated);
+    if (!sameJsonValue(configPathValue(validated, configPath), value)) {
+      throw new Error(`Invalid smartCompact setting: ${configPath}`);
+    }
+    root[CONFIG_KEY] = section;
+    await atomicWriteFile(file, JSON.stringify(root, null, 2) + `
+`);
+    resetConfigCache();
+    return loadConfig();
+  } finally {
+    release();
+  }
+}
 var cachedConfig = null;
 var cachedMtime = 0;
 var cachedPath = null;
+function resetConfigCache() {
+  cachedConfig = null;
+  cachedMtime = 0;
+  cachedPath = null;
+}
 function loadConfig() {
   try {
     const file = settingsFile();
-    const stat = fs.statSync(file);
+    const stat = fs2.statSync(file);
     if (cachedConfig && cachedPath === file && stat.mtimeMs === cachedMtime)
-      return cachedConfig;
-    const raw = JSON.parse(fs.readFileSync(file, "utf-8"));
-    const sc = raw[CONFIG_KEY] ?? raw[CONFIG_KEY_ALT] ?? {};
+      return cloneConfig(cachedConfig);
+    const parsed = JSON.parse(fs2.readFileSync(file, "utf-8"));
+    const raw = isRecord(parsed) ? parsed : {};
+    if (raw !== parsed) {
+      warn("smart-compact config: settings.json root must be an object.");
+    }
+    const configured = Object.hasOwn(raw, CONFIG_KEY) ? raw[CONFIG_KEY] : raw[CONFIG_KEY_ALT] ?? {};
+    const sc = isRecord(configured) ? configured : {};
+    if (sc !== configured) {
+      warn("smart-compact config: smartCompact must be an object.");
+    }
     validateSmartCompactConfig(sc);
-    const merged = { ...DEFAULT_CONFIG, ...sc };
+    const merged = { ...defaultConfig(), ...sc };
     if (!("mode" in sc) && "profile" in sc) {
       merged.mode = sc.profile === "light" ? "thorough" : sc.profile;
     }
     if (sc.profiles) {
-      merged.profiles = { ...PROFILES, ...sc.profiles };
+      const overrides = sc.profiles;
+      merged.profiles = Object.fromEntries(VALID_PROFILES.map((name) => [
+        name,
+        { ...PROFILES[name], ...overrides[name] }
+      ]));
     }
     if (!merged.backupDir)
       merged.backupDir = defaultBackupDir();
     cachedConfig = merged;
     cachedMtime = stat.mtimeMs;
     cachedPath = file;
-    return cachedConfig;
+    return cloneConfig(cachedConfig);
   } catch (error2) {
     debug("loadConfig: settings.json not found or unreadable, using defaults", error2);
-    cachedConfig = {
-      ...DEFAULT_CONFIG,
-      backupDir: defaultBackupDir()
-    };
+    cachedConfig = defaultConfig();
     cachedPath = null;
-    return cachedConfig;
+    return cloneConfig(cachedConfig);
   }
 }
 
@@ -935,17 +1287,17 @@ import fs3 from "fs";
 import path4 from "path";
 
 // src/utils/extraction.ts
-import path2 from "path";
+import path3 from "path";
 
 // src/utils/type-guards.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isTextBlock(c) {
-  return isRecord(c) && c.type === "text" && typeof c.text === "string";
+  return isRecord2(c) && c.type === "text" && typeof c.text === "string";
 }
 function isToolCallBlock(c) {
-  return isRecord(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord(c.arguments);
+  return isRecord2(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord2(c.arguments);
 }
 function getToolCallNames(content) {
   if (!Array.isArray(content))
@@ -1121,8 +1473,8 @@ function isKnownPathReference(ref, knownPaths) {
   if (!normalizedRef)
     return false;
   const pathShaped = normalizedRef.includes("/");
-  return knownPaths.some((path2) => {
-    const normalizedPath = normalizePath(path2).replace(/^\/+/, "");
+  return knownPaths.some((path3) => {
+    const normalizedPath = normalizePath(path3).replace(/^\/+/, "");
     if (normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef))
       return true;
     if (normalizedPath.endsWith(normalizedRef)) {
@@ -1473,15 +1825,15 @@ function smartKeepBoundaryCandidates(msgs, keepFromIndex, branchEntries) {
 }
 function collectToolCallIds(blocks, msgIndex, out) {
   for (const block of blocks) {
-    if (!isRecord(block) || block.type !== "toolCall")
+    if (!isRecord2(block) || block.type !== "toolCall")
       continue;
     if (typeof block.id === "string")
       out.set(block.id, msgIndex);
     const args = block.arguments;
-    if (block.name !== "multi_tool_use.parallel" || !isRecord(args) || !Array.isArray(args.tool_uses))
+    if (block.name !== "multi_tool_use.parallel" || !isRecord2(args) || !Array.isArray(args.tool_uses))
       continue;
     for (const nested of args.tool_uses) {
-      if (isRecord(nested) && typeof nested.id === "string")
+      if (isRecord2(nested) && typeof nested.id === "string")
         out.set(nested.id, msgIndex);
     }
   }
@@ -1490,7 +1842,7 @@ function buildToolCallBoundaryIndex(msgs) {
   const map = new Map;
   for (let i = 0;i < msgs.length; i++) {
     const message = msgs[i].message;
-    if (!isRecord(message) || message.role !== "assistant")
+    if (!isRecord2(message) || message.role !== "assistant")
       continue;
     const blocks = Array.isArray(message.content) ? message.content : [];
     collectToolCallIds(blocks, i, map);
@@ -1512,7 +1864,7 @@ function guardToolCallBoundary(msgs, keepFrom, tcMap = buildToolCallBoundaryInde
     changed = false;
     for (let i = adjusted;i < msgs.length; i++) {
       const message = msgs[i].message;
-      if (!isRecord(message) || message.role !== "toolResult")
+      if (!isRecord2(message) || message.role !== "toolResult")
         continue;
       const tcId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
       if (!tcId)
@@ -1535,7 +1887,7 @@ function advancePastToolCallBoundary(msgs, keepFrom, tcMap = buildToolCallBounda
     let next = adjusted;
     for (let i = adjusted;i < msgs.length; i++) {
       const message = msgs[i].message;
-      if (!isRecord(message) || message.role !== "toolResult")
+      if (!isRecord2(message) || message.role !== "toolResult")
         continue;
       const tcIdx = typeof message.toolCallId === "string" ? tcMap.get(message.toolCallId) : undefined;
       if (i === adjusted && tcIdx === undefined || tcIdx !== undefined && tcIdx < adjusted) {
@@ -1863,7 +2215,7 @@ function buildSummaryPathEvidence(paths, budgetTokens = PROFILES.balanced.summar
   const unique = Array.from(new Set(paths.filter(Boolean)));
   if (!unique.length)
     return new Map;
-  const full = unique.map((path2) => [path2, summaryPathLine(path2)]);
+  const full = unique.map((path3) => [path3, summaryPathLine(path3)]);
   const minimumPerLine = JSON.stringify("#" + "x".repeat(12)).length + 3;
   const budgetChars = Math.max(unique.length * minimumPerLine, Math.min(20000, Math.max(4000, Math.floor(budgetTokens * 2))));
   if (full.reduce((total, [, line]) => total + line.length + 3, 0) <= budgetChars) {
@@ -1871,21 +2223,21 @@ function buildSummaryPathEvidence(paths, budgetTokens = PROFILES.balanced.summar
   }
   const digests = new Map;
   const owners = new Map;
-  for (const path2 of unique) {
-    const fullDigest = createHash("sha256").update(path2).digest("base64url");
+  for (const path3 of unique) {
+    const fullDigest = createHash("sha256").update(path3).digest("base64url");
     let digest = fullDigest.slice(0, 12);
     const owner = owners.get(digest);
-    if (owner && owner !== path2) {
+    if (owner && owner !== path3) {
       digest = fullDigest;
       digests.set(owner, createHash("sha256").update(owner).digest("base64url"));
     }
-    owners.set(digest, path2);
-    digests.set(path2, digest);
+    owners.set(digest, path3);
+    digests.set(path3, digest);
   }
   const perPath = Math.max(JSON.stringify("#" + "x".repeat(12)).length, Math.floor((budgetChars - unique.length * 3) / unique.length));
-  return new Map(unique.map((path2) => [
-    path2,
-    compactPathLine(path2, perPath, digests.get(path2) ?? "")
+  return new Map(unique.map((path3) => [
+    path3,
+    compactPathLine(path3, perPath, digests.get(path3) ?? "")
   ]));
 }
 function mergeBodies(first, second) {
@@ -2403,7 +2755,7 @@ function segmentTopicsHeuristic(msgs, pc, maxSegs = 20, _tcIdx) {
   const shiftBasename = (filePath) => {
     if (!filePath)
       return null;
-    const base = path2.basename(filePath);
+    const base = path3.basename(filePath);
     return GENERIC_BASENAMES.has(base.toLowerCase()) ? null : base;
   };
   const topics = [];
@@ -2557,7 +2909,7 @@ function extractOpenLoops(msgs, extraction) {
   }));
   for (const err of extraction.errors.filter((e) => !e.resolved)) {
     const errLower = err.message.toLowerCase();
-    const errFiles = fileNeedles.filter(({ needles }) => needles.some((n) => errLower.includes(n))).map(({ path: path3 }) => path3);
+    const errFiles = fileNeedles.filter(({ needles }) => needles.some((n) => errLower.includes(n))).map(({ path: path4 }) => path4);
     loops.push({
       id: ID_PREFIX.OPEN_LOOP + ++loopId,
       type: "bugfix",
@@ -2706,191 +3058,6 @@ function extractStructured(msgs, pc, precomputedTcIdx) {
   };
 }
 
-// src/infra/fs.ts
-import fs2 from "fs";
-import fsp from "fs/promises";
-import path3 from "path";
-import crypto from "crypto";
-var LOCK_STALE_MS = 5000;
-var LOCK_RETRY_MS = 25;
-var LOCK_MAX_RETRIES = 80;
-function ensureDir(dir) {
-  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs2.chmodSync(dir, 448);
-}
-async function ensureDirAsync(dir) {
-  await fsp.mkdir(dir, { recursive: true, mode: 448 });
-  await fsp.chmod(dir, 448);
-}
-function tempPath(target) {
-  return target + ".tmp." + process.pid + "." + crypto.randomBytes(4).toString("hex");
-}
-function atomicWriteFileSync(target, data) {
-  ensureDir(path3.dirname(target));
-  const tmp = tempPath(target);
-  try {
-    fs2.writeFileSync(tmp, data, { mode: 384 });
-    fs2.renameSync(tmp, target);
-    fs2.chmodSync(target, 384);
-  } catch (e) {
-    try {
-      fs2.unlinkSync(tmp);
-    } catch {}
-    throw e;
-  }
-}
-async function atomicWriteFile(target, data) {
-  await ensureDirAsync(path3.dirname(target));
-  const tmp = tempPath(target);
-  try {
-    await fsp.writeFile(tmp, data, { mode: 384 });
-    await fsp.rename(tmp, target);
-    await fsp.chmod(target, 384);
-  } catch (e) {
-    try {
-      await fsp.unlink(tmp);
-    } catch {}
-    throw e;
-  }
-}
-function tryAcquireLock(target) {
-  const lockDir = target + ".lock";
-  for (let reclaimAttempt = 0;reclaimAttempt < 2; reclaimAttempt++) {
-    try {
-      fs2.mkdirSync(lockDir, { mode: 448 });
-      return () => {
-        try {
-          fs2.rmdirSync(lockDir);
-        } catch {}
-      };
-    } catch (error2) {
-      if (error2?.code !== "EEXIST") {
-        throw new Error("Failed to acquire lock for " + target, { cause: error2 });
-      }
-      try {
-        const stat = fs2.statSync(lockDir);
-        if (Date.now() - stat.mtimeMs <= LOCK_STALE_MS)
-          return null;
-        const stolen = lockDir + ".stale." + process.pid + "." + crypto.randomBytes(4).toString("hex");
-        fs2.renameSync(lockDir, stolen);
-        const stolenStat = fs2.statSync(stolen);
-        if (Date.now() - stolenStat.mtimeMs > LOCK_STALE_MS)
-          fs2.rmdirSync(stolen);
-        else
-          try {
-            fs2.renameSync(stolen, lockDir);
-          } catch {}
-      } catch {}
-    }
-  }
-  return null;
-}
-function acquireLockSync(target) {
-  const release = tryAcquireLock(target);
-  if (!release)
-    throw new Error("Lock busy for " + target);
-  return release;
-}
-async function acquireLock(target) {
-  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
-    const release = tryAcquireLock(target);
-    if (release)
-      return release;
-    const delay = Promise.withResolvers();
-    setTimeout(delay.resolve, LOCK_RETRY_MS);
-    await delay.promise;
-  }
-  throw new Error("Timed out acquiring lock for " + target);
-}
-async function appendLineLockedAsync(target, line, maxBytes) {
-  await ensureDirAsync(path3.dirname(target));
-  const payload = Buffer.from(line.endsWith(`
-`) ? line : line + `
-`);
-  if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
-    throw new Error("maxBytes must be a positive safe integer");
-  }
-  if (maxBytes !== undefined && payload.length > maxBytes) {
-    throw new Error("Log entry exceeds retention cap for " + target);
-  }
-  const release = await acquireLock(target);
-  try {
-    let stat = null;
-    try {
-      stat = await fsp.stat(target);
-    } catch (error2) {
-      if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "ENOENT")
-        throw error2;
-    }
-    if (maxBytes !== undefined && stat && stat.size + payload.length > maxBytes) {
-      const retainedLength = Math.min(stat.size, Math.max(0, maxBytes - payload.length));
-      const buffer = Buffer.allocUnsafe(retainedLength);
-      if (retainedLength > 0) {
-        const handle = await fsp.open(target, "r");
-        try {
-          await handle.read(buffer, 0, retainedLength, stat.size - retainedLength);
-        } finally {
-          await handle.close();
-        }
-      }
-      let tail = buffer.toString("utf8");
-      if (retainedLength < stat.size) {
-        const firstNewline = tail.indexOf(`
-`);
-        tail = firstNewline >= 0 ? tail.slice(firstNewline + 1) : "";
-      }
-      await atomicWriteFile(target, tail);
-    }
-    await fsp.appendFile(target, payload, { mode: 384 });
-    await fsp.chmod(target, 384);
-  } finally {
-    release();
-  }
-}
-function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
-  if (limit <= 0 || !fs2.existsSync(target))
-    return [];
-  const stat = fs2.statSync(target);
-  const length = Math.min(stat.size, maxBytes);
-  const buffer = Buffer.alloc(length);
-  const fd = fs2.openSync(target, "r");
-  try {
-    fs2.readSync(fd, buffer, 0, length, stat.size - length);
-  } finally {
-    fs2.closeSync(fd);
-  }
-  let text = buffer.toString("utf8");
-  if (stat.size > length) {
-    const newline = text.indexOf(`
-`);
-    text = newline >= 0 ? text.slice(newline + 1) : "";
-  }
-  const values = [];
-  for (const line of text.split(`
-`)) {
-    if (!line)
-      continue;
-    try {
-      values.push(JSON.parse(line));
-    } catch {}
-  }
-  return values.slice(-limit);
-}
-function readJsonSync(target) {
-  try {
-    if (!fs2.existsSync(target))
-      return null;
-    const raw = fs2.readFileSync(target, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    warn("readJsonSync failed for " + target, e);
-    return null;
-  }
-}
-function writeJsonSync(target, value, pretty = false) {
-  atomicWriteFileSync(target, pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value));
-}
-
 // src/utils/id-fingerprint.ts
 import crypto2 from "crypto";
 var FINGERPRINT_TAIL_LEN = 16;
@@ -4828,7 +4995,7 @@ function advancePastNonPortableToolExchanges(msgs, keepFrom, toolCallIndex) {
   const exchangeEnds = new Map;
   for (let index = keepFrom;index < msgs.length; index++) {
     const message = msgs[index].message;
-    if (!isRecord(message) || message.role !== "toolResult" || typeof message.toolCallId !== "string")
+    if (!isRecord2(message) || message.role !== "toolResult" || typeof message.toolCallId !== "string")
       continue;
     const callIndex = toolCallIndex.get(message.toolCallId);
     if (callIndex === undefined || callIndex < keepFrom)
@@ -4838,10 +5005,10 @@ function advancePastNonPortableToolExchanges(msgs, keepFrom, toolCallIndex) {
   let adjusted = keepFrom;
   for (let index = keepFrom;index < msgs.length; index++) {
     const message = msgs[index].message;
-    if (!isRecord(message))
+    if (!isRecord2(message))
       continue;
     if (message.role === "assistant" && Array.isArray(message.content)) {
-      const nonPortable = message.content.some((block) => isRecord(block) && block.type === "toolCall" && (typeof block.name !== "string" || !PORTABLE_TOOL_NAME_RE.test(block.name)));
+      const nonPortable = message.content.some((block) => isRecord2(block) && block.type === "toolCall" && (typeof block.name !== "string" || !PORTABLE_TOOL_NAME_RE.test(block.name)));
       if (nonPortable)
         adjusted = Math.max(adjusted, exchangeEnds.get(index) ?? index + 1);
     } else if (message.role === "toolResult" && typeof message.toolName === "string" && !PORTABLE_TOOL_NAME_RE.test(message.toolName)) {
@@ -4908,7 +5075,7 @@ function planCompactionWindow(input) {
   let protectedUserIndex;
   for (let index = msgs.length - 1;index >= 0; index--) {
     const message = msgs[index].message;
-    if (!isRecord(message) || message.role !== "user")
+    if (!isRecord2(message) || message.role !== "user")
       continue;
     userOrdinal++;
     protectedUserIndex = index;
@@ -4939,7 +5106,7 @@ function planCompactionWindow(input) {
   const targetAfterTokens = !force && modelContextWindow ? modelContextWindow * targetPercent / 100 : fixedContextTokens + effectiveRetentionCeiling + finalSummaryAllowance;
   let reason = "viable";
   const firstKeptMessage = msgs[keepFrom]?.message;
-  if (nonPortableTailBlocked || isRecord(firstKeptMessage) && firstKeptMessage.role === "toolResult")
+  if (nonPortableTailBlocked || isRecord2(firstKeptMessage) && firstKeptMessage.role === "toolResult")
     reason = "unsafe-tool-boundary";
   else if (keepFrom <= 0)
     reason = "no-eligible-prefix";
@@ -11420,6 +11587,19 @@ async function runSmartCompact(opts) {
   }
 }
 
+// src/app/global-settings-runtime.ts
+var POLICY_PATHS = new Set([
+  "agentToolAccess",
+  "autoTrigger",
+  "showStatus"
+]);
+function applyGlobalSettingRuntime(path14, ctx, policy, contextTools) {
+  if (POLICY_PATHS.has(path14))
+    policy.restore(ctx);
+  if (path14 === "contextGraphEnabled")
+    contextTools.apply();
+}
+
 // src/app/pending-slot.ts
 function createPendingSlot(opts) {
   const ttlMs = opts.ttlMs;
@@ -11835,6 +12015,7 @@ function resolveGraphScope(ctx) {
   };
 }
 function registerContextTools(pi) {
+  const availability = createContextToolAvailability(pi);
   pi.registerTool({
     name: "smart_recall",
     label: "Smart Recall",
@@ -12039,12 +12220,48 @@ Paths: ` + relatedPaths.join(", ") : ""));
           details: { memory, redactions: scrubber.count() }
         };
       } catch (error2) {
-        debugError("Project memory persistence failed", error2);
-        const message = scrubber.scrubText(error2 instanceof Error ? error2.message : String(error2)).value;
-        throw new Error("Project memory could not be saved: " + message);
+        debugError("Project memory persistence failed", error2);
+        const message = scrubber.scrubText(error2 instanceof Error ? error2.message : String(error2)).value;
+        throw new Error("Project memory could not be saved: " + message);
+      }
+    }
+  });
+  availability.apply();
+  pi.on("session_start", availability.apply);
+  return availability;
+}
+var CONTEXT_TOOL_NAMES = ["smart_recall", "smart_save_memory"];
+function createContextToolAvailability(pi) {
+  const hiddenByConfig = new Set;
+  let disabledByConfig = false;
+  return {
+    apply() {
+      try {
+        const enabled = loadConfig().contextGraphEnabled;
+        const active = pi.getActiveTools();
+        if (!enabled) {
+          const visibleContextTools = CONTEXT_TOOL_NAMES.filter((name) => active.includes(name));
+          for (const name of visibleContextTools)
+            hiddenByConfig.add(name);
+          disabledByConfig = true;
+          if (visibleContextTools.length > 0) {
+            pi.setActiveTools(active.filter((name) => !CONTEXT_TOOL_NAMES.includes(name)));
+          }
+          return;
+        }
+        if (disabledByConfig) {
+          const restored = [...hiddenByConfig].filter((name) => !active.includes(name));
+          if (restored.length > 0) {
+            pi.setActiveTools([...new Set([...active, ...restored])]);
+          }
+          hiddenByConfig.clear();
+          disabledByConfig = false;
+        }
+      } catch (error2) {
+        debugError("Context tool availability update failed", error2);
       }
     }
-  });
+  };
 }
 
 // src/app/model-routing.ts
@@ -13228,80 +13445,874 @@ async function showMetricsDashboardUI(ctx, opts) {
 
 // src/ui/settings-overlay.ts
 import {
-  getSettingsListTheme
+  getSettingsListTheme as getSettingsListTheme2
 } from "@earendil-works/pi-coding-agent";
+import {
+  Container as Container4,
+  SettingsList as SettingsList2,
+  Text as Text4
+} from "@earendil-works/pi-tui";
+
+// src/ui/settings-complex.ts
+import path15 from "path";
 import {
   Container as Container3,
+  Input,
+  Key as Key4,
+  matchesKey as matchesKey4,
+  SelectList as SelectList3,
   SettingsList,
   Text as Text3
 } from "@earendil-works/pi-tui";
-var INHERIT = "host default";
-var ENABLED = "enabled";
-var DISABLED = "disabled";
-function accessValue(policy) {
-  return policy.agentToolAccess === "inherit" ? INHERIT : policy.agentToolAccess;
-}
-function parseAccessValue(value) {
-  return value === INHERIT ? "inherit" : value;
-}
-function previousValue(id, policy) {
-  if (id === "agentToolAccess")
-    return accessValue(policy);
-  if (id === "showStatus")
-    return policy.showStatus ? ENABLED : DISABLED;
-  return policy.autoTrigger ? ENABLED : DISABLED;
-}
-function settingsItems(policy) {
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+var MODEL_SETTINGS = [
+  {
+    id: "summaryModel",
+    label: "Summary model",
+    description: "Model used for synthesis and verification fallback."
+  },
+  {
+    id: "segmentationModel",
+    label: "Segmentation model",
+    description: "Optional model used for transcript exploration."
+  },
+  {
+    id: "verificationModel",
+    label: "Verification model",
+    description: "Optional model used for repair after verification."
+  }
+];
+var PROFILE_NAMES = Object.keys(PROFILES);
+function numberParser(options) {
+  return (input) => {
+    const trimmed = input.trim();
+    if (!trimmed)
+      return;
+    const value = Number(trimmed);
+    const inRange = value >= options.min && value <= options.max;
+    if (!Number.isFinite(value) || options.integer !== false && !Number.isSafeInteger(value) || !inRange && !(options.zeroOrRange && value === 0)) {
+      const allowed = options.zeroOrRange ? `0 or ${options.min}\u2013${options.max}` : `${options.min}\u2013${options.max}`;
+      throw new Error(`Enter ${options.integer === false ? "a number" : "an integer"} in ${allowed}.`);
+    }
+    return value;
+  };
+}
+function scalarFormat(value) {
+  return value === undefined ? "default" : String(value);
+}
+var LIMIT_SETTINGS = [
+  {
+    id: "minContextPercent",
+    label: "Minimum context percent",
+    description: "Auto compaction starts at or above this context usage.",
+    placeholder: "0\u2013100; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.minContextPercent),
+    format: scalarFormat
+  },
+  {
+    id: "autoTriggerTimeoutMs",
+    label: "Auto-trigger timeout",
+    description: "Maximum host auto-compaction time in milliseconds.",
+    placeholder: "1000\u2013300000; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.autoTriggerTimeoutMs),
+    format: scalarFormat
+  },
+  {
+    id: "maxLlmCalls",
+    label: "Maximum LLM calls",
+    description: "Zero uses the selected mode's call cap.",
+    placeholder: "0\u2013100; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.maxLlmCalls),
+    format: scalarFormat
+  },
+  {
+    id: "maxLlmInputTokens",
+    label: "Maximum LLM input tokens",
+    description: "Zero uses the selected mode's token cap.",
+    placeholder: "0\u20131000000; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.maxLlmInputTokens),
+    format: scalarFormat
+  },
+  {
+    id: "codexMaxCallMs",
+    label: "Codex call watchdog",
+    description: "Zero derives the per-call watchdog automatically.",
+    placeholder: "0 or 5000\u2013300000; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.codexMaxCallMs),
+    format: scalarFormat
+  },
+  {
+    id: "maxLatencyMs",
+    label: "Pipeline latency limit",
+    description: "Zero disables the overall pipeline deadline.",
+    placeholder: "0 or 5000\u2013600000; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.maxLatencyMs),
+    format: scalarFormat
+  }
+];
+var PATH_SETTINGS = [
+  {
+    id: "backupDir",
+    label: "Backup directory",
+    description: "Directory for recovery Markdown files.",
+    placeholder: "Absolute path; blank uses default",
+    parse(input) {
+      const value = input.trim();
+      if (!value)
+        return;
+      if (value.includes("\x00") || /[\r\n]/.test(value)) {
+        throw new Error("Backup directory must be a single valid path.");
+      }
+      if (!path15.isAbsolute(value)) {
+        throw new Error("Backup directory must be an absolute path.");
+      }
+      return value;
+    },
+    format: scalarFormat
+  },
+  {
+    id: "pinPaths",
+    label: "Pinned paths",
+    description: "Comma-separated file paths that summaries must preserve.",
+    placeholder: "src/api.ts, docs/design.md; blank clears",
+    parse(input) {
+      const trimmed = input.trim();
+      if (!trimmed)
+        return;
+      const paths = trimmed.split(/[,\n]/).map((value) => value.trim()).filter(Boolean);
+      if (paths.some((value) => value.includes("\x00"))) {
+        throw new Error("Pinned paths cannot contain NUL characters.");
+      }
+      return [...new Set(paths)];
+    },
+    format(value) {
+      return value === undefined ? "default" : Array.isArray(value) ? value.join(", ") || "none" : String(value);
+    }
+  }
+];
+var PROFILE_FIELDS = [
+  ["summaryBudgetTokens", "Summary budget"],
+  ["keepRecentTokens", "Recent raw tail"],
+  ["minChunkTokens", "Minimum chunk"],
+  ["maxChunkTokens", "Maximum chunk"],
+  ["singlePassMaxTokens", "Single-pass limit"],
+  ["batchMaxTokens", "Batch limit"]
+];
+function profileSettings(profile) {
+  return PROFILE_FIELDS.map(([key, label]) => {
+    const [min, max] = PROFILE_NUMERIC_BOUNDS[key];
+    return {
+      id: `profiles.${profile}.${key}`,
+      label,
+      description: `${profile} profile token budget; related chunk bounds must remain consistent.`,
+      placeholder: `${min}\u2013${max}; blank uses built-in`,
+      parse: numberParser({ min, max }),
+      format: scalarFormat
+    };
+  });
+}
+function effectiveValue(config, id) {
+  const parts = id.split(".");
+  if (parts[0] !== "profiles") {
+    return config[id];
+  }
+  const [, profile, key] = parts;
+  return config.profiles[profile][key];
+}
+
+class InputSettingEditor extends Container3 {
+  requestRender;
+  save;
+  done;
+  input = new Input;
+  status = new Text3("", 0, 0);
+  saving = false;
+  pending = Promise.resolve();
+  get focused() {
+    return this.input.focused;
+  }
+  set focused(value) {
+    this.input.focused = value;
+  }
+  constructor(setting, initial, requestRender, save, done) {
+    super();
+    this.requestRender = requestRender;
+    this.save = save;
+    this.done = done;
+    this.addChild(new Text3(setting.label, 0, 0));
+    this.addChild(new Text3(setting.description, 0, 0));
+    this.addChild(new Text3(`Hint: ${setting.placeholder}`, 0, 0));
+    this.addChild(new Text3("", 0, 0));
+    this.input.setValue(initial);
+    this.input.handleInput("\x1B[F");
+    this.input.onSubmit = (value) => {
+      if (this.saving)
+        return;
+      let parsed;
+      try {
+        parsed = setting.parse(value);
+      } catch (error2) {
+        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+        this.requestRender();
+        return;
+      }
+      this.saving = true;
+      this.status.setText("Saving\u2026");
+      this.requestRender();
+      this.pending = this.save(parsed).then(() => this.done()).catch((error2) => {
+        this.saving = false;
+        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+        this.requestRender();
+      });
+    };
+    this.input.onEscape = () => {
+      if (!this.saving)
+        this.done();
+    };
+    this.addChild(this.input);
+    this.addChild(new Text3("", 0, 0));
+    this.addChild(this.status);
+    this.addChild(new Text3("Enter save \xB7 Esc cancel", 0, 0));
+  }
+  handleInput(data) {
+    this.input.handleInput(data);
+    this.requestRender();
+  }
+  settled() {
+    return this.pending;
+  }
+}
+
+class ModelSettingEditor extends Container3 {
+  requestRender;
+  search = new Input;
+  list;
+  status = new Text3("", 0, 0);
+  saving = false;
+  pending = Promise.resolve();
+  get focused() {
+    return this.search.focused;
+  }
+  set focused(value) {
+    this.search.focused = value;
+  }
+  constructor(models, selectedValue, requestRender, save, done) {
+    super();
+    this.requestRender = requestRender;
+    this.addChild(new Text3("Search provider/model", 0, 0));
+    this.addChild(this.search);
+    this.addChild(new Text3("", 0, 0));
+    this.list = new SelectList3(models, 10, {
+      selectedPrefix: (text) => text,
+      selectedText: (text) => text,
+      description: (text) => text,
+      scrollInfo: (text) => text,
+      noMatch: (text) => text
+    });
+    const selectedIndex = models.findIndex((item) => item.settingValue === selectedValue);
+    this.list.setSelectedIndex(Math.max(0, selectedIndex));
+    this.list.onSelect = (item) => {
+      if (this.saving)
+        return;
+      this.saving = true;
+      this.status.setText("Saving\u2026");
+      this.requestRender();
+      const selected = models.find((candidate) => candidate.value === item.value);
+      if (!selected)
+        return;
+      this.pending = save(selected.settingValue).then(done).catch((error2) => {
+        this.saving = false;
+        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+        this.requestRender();
+      });
+    };
+    this.list.onCancel = () => {
+      if (!this.saving)
+        done();
+    };
+    this.addChild(this.list);
+    this.addChild(this.status);
+    this.addChild(new Text3("Type to filter \xB7 Enter select \xB7 Esc cancel", 0, 0));
+  }
+  handleInput(data) {
+    if (matchesKey4(data, Key4.up) || matchesKey4(data, Key4.down) || matchesKey4(data, Key4.enter) || matchesKey4(data, Key4.escape)) {
+      this.list.handleInput(data);
+    } else {
+      this.search.handleInput(data);
+      this.list.setFilter(this.search.getValue());
+    }
+    this.requestRender();
+  }
+  settled() {
+    return this.pending;
+  }
+}
+function inputSettingsList(settings, requestRender, done, writeConfig) {
+  const config = loadConfig();
+  const items = settings.map((setting) => {
+    const override = readGlobalConfigValue(setting.id);
+    const item = {
+      id: setting.id,
+      label: setting.label,
+      description: `${setting.description} Effective global value: ${setting.format(effectiveValue(config, setting.id))}.`,
+      currentValue: setting.format(override)
+    };
+    item.submenu = (_current, close) => {
+      const persisted = readGlobalConfigValue(setting.id);
+      return new InputSettingEditor(setting, persisted === undefined ? "" : Array.isArray(persisted) ? persisted.join(", ") : String(persisted), requestRender, async (value) => {
+        const effective = await writeConfig(setting.id, value);
+        item.currentValue = setting.format(value);
+        item.description = `${setting.description} Effective global value: ${setting.format(effectiveValue(effective, setting.id))}.`;
+      }, close);
+    };
+    return item;
+  });
+  return new SettingsList(items, 9, getSettingsListTheme(), () => {}, done);
+}
+function modelSettingsItems(ctx, requestRender, writeConfig = writeGlobalConfigValue) {
+  const config = loadConfig();
+  return MODEL_SETTINGS.map((setting) => {
+    const override = readGlobalConfigValue(setting.id);
+    const current = typeof override === "string" ? override : "default";
+    const item = {
+      id: setting.id,
+      label: setting.label,
+      description: `${setting.description} Effective global value: ${String(config[setting.id])}.`,
+      currentValue: current
+    };
+    item.submenu = (_value, close) => {
+      const persisted = readGlobalConfigValue(setting.id);
+      const selectedValue = typeof persisted === "string" ? persisted : "default";
+      const effective = loadConfig();
+      item.currentValue = selectedValue;
+      item.description = `${setting.description} Effective global value: ${String(effective[setting.id])}.`;
+      const available = ctx.modelRegistry.getAvailable().map((model) => ({
+        value: `${model.provider}/${model.id} \u2014 ${model.name}`,
+        settingValue: `${model.provider}/${model.id}`,
+        label: `${model.provider}/${model.id}`,
+        description: model.name
+      })).sort((left, right) => left.value.localeCompare(right.value));
+      const choices = [
+        {
+          value: "default \u2014 use active session model",
+          settingValue: "default",
+          label: "default",
+          description: "Remove the global model override"
+        },
+        ...available
+      ];
+      if (selectedValue !== "default" && !choices.some((candidate) => candidate.settingValue === selectedValue)) {
+        choices.splice(1, 0, {
+          value: selectedValue,
+          settingValue: selectedValue,
+          label: selectedValue,
+          description: "Configured model is currently unavailable"
+        });
+      }
+      return new ModelSettingEditor(choices, selectedValue, requestRender, async (selected) => {
+        const effective2 = await writeConfig(setting.id, selected === "default" ? undefined : selected);
+        item.currentValue = selected;
+        item.description = `${setting.description} Effective global value: ${String(effective2[setting.id])}.`;
+      }, close);
+    };
+    return item;
+  });
+}
+function complexSettingsCategories(ctx, requestRender, writeConfig = writeGlobalConfigValue) {
+  return [
+    {
+      id: "models",
+      label: "Global models",
+      description: "Stage-specific model routing",
+      currentValue: "3 settings",
+      submenu: (_value, done) => new SettingsList(modelSettingsItems(ctx, requestRender, writeConfig), 7, getSettingsListTheme(), () => {}, done)
+    },
+    {
+      id: "limits",
+      label: "Global limits & performance",
+      description: "Context threshold, call budgets, and timeouts",
+      currentValue: "6 settings",
+      submenu: (_value, done) => inputSettingsList(LIMIT_SETTINGS, requestRender, done, writeConfig)
+    },
+    {
+      id: "paths",
+      label: "Global paths",
+      description: "Backup directory and pinned summary paths",
+      currentValue: "2 settings",
+      submenu: (_value, done) => inputSettingsList(PATH_SETTINGS, requestRender, done, writeConfig)
+    },
+    {
+      id: "profiles",
+      label: "Global profile budgets",
+      description: "Advanced token-budget tuning for each profile",
+      currentValue: "3 profiles",
+      submenu: (_value, done) => {
+        const profiles = PROFILE_NAMES.map((profile) => ({
+          id: profile,
+          label: profile,
+          description: `Six token-budget settings for the ${profile} profile.`,
+          currentValue: "6 settings",
+          submenu: (_current, close) => inputSettingsList(profileSettings(profile), requestRender, close, writeConfig)
+        }));
+        return new SettingsList(profiles, 7, getSettingsListTheme(), () => {}, done);
+      }
+    }
+  ];
+}
+
+// src/ui/settings-overlay.ts
+function enabled(value) {
+  return value ? "enabled" : "disabled";
+}
+
+class GlobalSettingsCoordinator {
+  writer;
+  queue = Promise.resolve();
+  confirmed = new Map;
+  confirmedConfig;
+  pending = new Map;
+  listeners = new Map;
+  constructor(writer = updateGlobalChoiceSetting) {
+    this.writer = writer;
+  }
+  display(id) {
+    return this.pending.get(id)?.display ?? choiceDisplay(readGlobalConfigValue(id));
+  }
+  subscribe(ids, listener) {
+    const registrations = [];
+    for (const id of ids) {
+      const callbacks = this.listeners.get(id) ?? new Set;
+      const callback = (state) => listener(id, state);
+      callbacks.add(callback);
+      this.listeners.set(id, callbacks);
+      registrations.push([id, callback]);
+    }
+    return () => {
+      for (const [id, callback] of registrations) {
+        const callbacks = this.listeners.get(id);
+        callbacks?.delete(callback);
+        if (callbacks?.size === 0)
+          this.listeners.delete(id);
+      }
+    };
+  }
+  submit(group, id, display, onError, onApplied = () => {}) {
+    if (this.pending.size === 0)
+      this.confirmedConfig = loadConfig();
+    if (!this.pending.has(id)) {
+      this.confirmed.set(id, choiceDisplay(readGlobalConfigValue(id)));
+    }
+    const revision = (this.pending.get(id)?.revision ?? 0) + 1;
+    this.pending.set(id, { revision, display });
+    this.queue = this.queue.then(async () => {
+      try {
+        const config = await this.writer(group, id, display);
+        await onApplied(id, config);
+        this.confirmed.set(id, display);
+        this.confirmedConfig = config;
+        if (this.pending.get(id)?.revision === revision) {
+          this.pending.delete(id);
+          this.emit(id, { display, config });
+        }
+      } catch (error2) {
+        onError(error2 instanceof Error ? error2.message : String(error2));
+        if (this.pending.get(id)?.revision === revision) {
+          this.pending.delete(id);
+          this.emit(id, {
+            display: this.confirmed.get(id) ?? "default",
+            config: this.confirmedConfig
+          });
+        }
+      }
+    });
+  }
+  settled() {
+    return this.queue;
+  }
+  emit(id, state) {
+    for (const listener of this.listeners.get(id) ?? [])
+      listener(state);
+  }
+}
+var BOOLEAN_VALUES = [true, false];
+var THINKING_VALUES = [
+  null,
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var GLOBAL_CHOICE_SETTINGS = {
+  behavior: [
+    {
+      id: "mode",
+      label: "Compaction mode",
+      description: "Default compaction strategy.",
+      values: ["auto", "fast", "balanced", "thorough"]
+    },
+    {
+      id: "profile",
+      label: "Compression profile",
+      description: "Legacy detail-budget profile.",
+      values: ["light", "balanced", "aggressive"]
+    },
+    {
+      id: "agentToolAccess",
+      label: "Agent tool access",
+      description: "Global default for agent-visible smart_compact access.",
+      values: ["inherit", "enabled", "disabled"]
+    },
+    {
+      id: "autoTrigger",
+      label: "Automatic compaction",
+      description: "Global default for pressure-triggered compaction.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "showStatus",
+      label: "Footer status",
+      description: "Global default for the Smart Compact footer indicator.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "autoTriggerStrategy",
+      label: "Trigger strategy",
+      description: "Host-native hook or settled-turn triggering.",
+      values: ["native-hook", "settled"]
+    }
+  ],
+  reasoning: [
+    {
+      id: "summaryThinkingLevel",
+      label: "Summary thinking",
+      description: "Thinking level for synthesis and repair.",
+      values: THINKING_VALUES
+    },
+    {
+      id: "segmentationThinkingLevel",
+      label: "Segmentation thinking",
+      description: "Thinking level for transcript segmentation.",
+      values: THINKING_VALUES
+    }
+  ],
+  safety: [
+    {
+      id: "backupEnabled",
+      label: "Backups",
+      description: "Write a recovery backup before applying a compacted summary.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "requireApproval",
+      label: "Require approval",
+      description: "Ask before applying manual compaction output.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "scrubSecrets",
+      label: "Scrub secrets",
+      description: "Redact likely credentials before model calls and memory writes.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "scrubPii",
+      label: "Scrub PII",
+      description: "Redact email, phone, and payment-card shaped data.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "contextGraphEnabled",
+      label: "Project memory",
+      description: "Index project context and expose recall/save tools.",
+      values: BOOLEAN_VALUES
+    }
+  ],
+  advanced: [
+    {
+      id: "focusWeighting",
+      label: "Focus weighting",
+      description: "Steer synthesis toward the current task focus.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "zeroCallEnabled",
+      label: "Zero-call fast path",
+      description: "Allow deterministic compaction without an LLM call.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "telemetryChannel",
+      label: "Telemetry channel",
+      description: "Tag local metrics as stable or canary.",
+      values: ["stable", "canary"]
+    },
+    {
+      id: "adaptiveDamageFeedback",
+      label: "Adaptive damage feedback",
+      description: "Increase preservation budgets using prior damage signals.",
+      values: BOOLEAN_VALUES
+    },
+    {
+      id: "onlineDamageMonitor",
+      label: "Online damage monitor",
+      description: "Monitor confirmed compactions for preservation damage.",
+      values: BOOLEAN_VALUES
+    }
+  ]
+};
+var GLOBAL_CHOICE_CATEGORIES = [
+  {
+    group: "behavior",
+    label: "Global behavior",
+    description: "Mode, profile, automation, and agent defaults"
+  },
+  {
+    group: "reasoning",
+    label: "Global reasoning",
+    description: "Thinking-level defaults"
+  },
+  {
+    group: "safety",
+    label: "Global safety & storage",
+    description: "Backups, approval, scrubbing, and project memory"
+  },
+  {
+    group: "advanced",
+    label: "Global advanced",
+    description: "Focus, fast path, telemetry, and damage monitoring"
+  }
+];
+function choiceDisplay(value) {
+  if (value === undefined)
+    return "default";
+  if (value === null)
+    return "provider default";
+  if (typeof value === "boolean")
+    return enabled(value);
+  return String(value);
+}
+function choiceValue(setting, display) {
+  if (display === "default")
+    return;
+  const value = setting.values.find((candidate) => choiceDisplay(candidate) === display);
+  if (value === undefined) {
+    throw new Error(`Invalid value for ${setting.id}: ${display}`);
+  }
+  return value;
+}
+function effectiveChoiceDescription(setting, config) {
+  const effective = config[setting.id];
+  return `${setting.description} Effective global value: ${choiceDisplay(effective)}.`;
+}
+function globalChoiceSettingsItems(group, config, coordinator) {
+  return GLOBAL_CHOICE_SETTINGS[group].map((setting) => ({
+    id: setting.id,
+    label: setting.label,
+    description: effectiveChoiceDescription(setting, config),
+    currentValue: coordinator?.display(setting.id) ?? choiceDisplay(readGlobalConfigValue(setting.id)),
+    values: ["default", ...setting.values.map(choiceDisplay)]
+  }));
+}
+async function updateGlobalChoiceSetting(group, id, display) {
+  const setting = GLOBAL_CHOICE_SETTINGS[group].find((candidate) => candidate.id === id);
+  if (!setting)
+    throw new Error(`Unknown global choice setting: ${id}`);
+  return writeGlobalConfigValue(setting.id, choiceValue(setting, display));
+}
+function effectiveDescription(field, policy) {
+  return field === "agentToolAccess" ? `Effective tool state: ${enabled(policy.agentToolEnabled)}` : `Effective value: ${enabled(policy[field])}`;
+}
+function sessionSettingsItems(policy) {
+  const current = policy.snapshot();
+  const overrides = policy.branchOverrides();
   return [
     {
       id: "agentToolAccess",
       label: "Agent access",
-      description: "Inherit Pi's tool selection, or explicitly enable/disable smart_compact",
-      currentValue: accessValue(policy),
-      values: [INHERIT, ENABLED, DISABLED]
+      description: effectiveDescription("agentToolAccess", current),
+      currentValue: overrides.agentToolAccess ?? "global",
+      values: ["global", "inherit", "enabled", "disabled"]
     },
     {
       id: "autoTrigger",
       label: "Automatic compaction",
-      description: "Run Smart Compact from Pi's automatic compaction lifecycle",
-      currentValue: policy.autoTrigger ? ENABLED : DISABLED,
-      values: [ENABLED, DISABLED]
+      description: effectiveDescription("autoTrigger", current),
+      currentValue: overrides.autoTrigger === undefined ? "global" : enabled(overrides.autoTrigger),
+      values: ["global", "enabled", "disabled"]
     },
     {
       id: "showStatus",
       label: "Footer status",
-      description: "Show the smart-compact policy status line in Pi's footer",
-      currentValue: policy.showStatus ? ENABLED : DISABLED,
-      values: [ENABLED, DISABLED]
+      description: effectiveDescription("showStatus", current),
+      currentValue: overrides.showStatus === undefined ? "global" : enabled(overrides.showStatus),
+      values: ["global", "enabled", "disabled"]
     }
   ];
 }
-async function showSmartCompactSettings(ctx, policy) {
-  await ctx.ui.custom((tui, theme, _keybindings, done) => {
-    const container = new Container3;
-    container.addChild(new Text3(theme.fg("accent", theme.bold("Smart Compact Settings")), 0, 0));
-    container.addChild(new Text3(theme.fg("dim", "Changes apply now and follow this session branch."), 0, 0));
-    container.addChild(new Text3(theme.fg("dim", "Manual /smart-compact stays available in every mode."), 0, 0));
-    container.addChild(new Text3("", 0, 0));
-    const list = new SettingsList(settingsItems(policy.snapshot()), 6, getSettingsListTheme(), (id, value) => {
-      const previous = policy.snapshot();
-      const result = id === "agentToolAccess" ? policy.update({ agentToolAccess: parseAccessValue(value) }, ctx) : id === "autoTrigger" ? policy.update({ autoTrigger: value === ENABLED }, ctx) : policy.update({ showStatus: value === ENABLED }, ctx);
+function policyField(id) {
+  switch (id) {
+    case "agentToolAccess":
+    case "autoTrigger":
+    case "showStatus":
+      return id;
+    default:
+      throw new Error(`Unknown session setting: ${id}`);
+  }
+}
+function updateSessionSetting(policy, ctx, id, value) {
+  const field = policyField(id);
+  if (value === "global")
+    return policy.reset(field, ctx);
+  switch (field) {
+    case "agentToolAccess":
+      if (value !== "inherit" && value !== "enabled" && value !== "disabled") {
+        throw new Error(`Invalid agent access value: ${value}`);
+      }
+      return policy.update({ agentToolAccess: value }, ctx);
+    case "autoTrigger":
+      return policy.update({ autoTrigger: value === "enabled" }, ctx);
+    case "showStatus":
+      return policy.update({ showStatus: value === "enabled" }, ctx);
+  }
+}
+function displayValue(field, policy) {
+  const override = policy.branchOverrides()[field];
+  if (override === undefined)
+    return "global";
+  if (typeof override === "boolean")
+    return enabled(override);
+  return override;
+}
+function sessionSettingsList(policy, ctx, done) {
+  const items = sessionSettingsItems(policy);
+  let list;
+  list = new SettingsList2(items, 7, getSettingsListTheme2(), (id, value) => {
+    try {
+      const result = updateSessionSetting(policy, ctx, id, value);
+      const field = policyField(id);
+      const item = items.find((candidate) => candidate.id === id);
+      if (item)
+        item.description = effectiveDescription(field, result.policy);
       if (!result.ok) {
-        list.updateValue(id, previousValue(id, previous));
         ctx.ui.notify(result.error, "error");
+        list.updateValue(id, displayValue(field, policy));
       }
-    }, () => done(undefined));
-    container.addChild(list);
-    container.addChild(new Text3("", 0, 0));
-    container.addChild(new Text3(theme.fg("dim", "\u2191\u2193 navigate \xB7 enter change \xB7 esc close"), 0, 0));
-    return {
-      render: (width) => container.render(width),
-      invalidate: () => container.invalidate(),
-      handleInput(data) {
-        list.handleInput?.(data);
-        tui.requestRender();
+    } catch (error2) {
+      ctx.ui.notify(error2 instanceof Error ? error2.message : String(error2), "error");
+      list.updateValue(id, displayValue(policyField(id), policy));
+    }
+  }, done);
+  return list;
+}
+function globalChoiceSettingsList(group, ctx, done, requestRender, coordinator, onApplied) {
+  const settings = GLOBAL_CHOICE_SETTINGS[group];
+  const items = globalChoiceSettingsItems(group, loadConfig(), coordinator);
+  let list;
+  list = new SettingsList2(items, 9, getSettingsListTheme2(), (id, display) => {
+    coordinator.submit(group, id, display, (message) => ctx.ui.notify(message, "error"), onApplied);
+  }, () => {
+    unsubscribe();
+    done();
+  });
+  const unsubscribe = coordinator.subscribe(settings.map((setting) => setting.id), (id, state) => {
+    list.updateValue(id, state.display);
+    if (state.config) {
+      for (const setting of settings) {
+        const item = items.find((candidate) => candidate.id === setting.id);
+        if (item) {
+          item.description = effectiveChoiceDescription(setting, state.config);
+        }
       }
-    };
+    }
+    requestRender();
+  });
+  return list;
+}
+function settingsCategoryItems(policy, ctx, requestRender = () => {}, coordinator = new GlobalSettingsCoordinator, onApplied = () => {}, writeConfig = writeGlobalConfigValue) {
+  return [
+    {
+      id: "session",
+      label: "Current branch",
+      description: "Agent access, automatic compaction, and footer status",
+      currentValue: "3 settings",
+      submenu: (_current, done) => sessionSettingsList(policy, ctx, done)
+    },
+    ...GLOBAL_CHOICE_CATEGORIES.map(({ group, label, description }) => ({
+      id: group,
+      label,
+      description,
+      currentValue: `${GLOBAL_CHOICE_SETTINGS[group].length} settings`,
+      submenu: (_current, done) => globalChoiceSettingsList(group, ctx, done, requestRender, coordinator, onApplied)
+    })),
+    ...complexSettingsCategories(ctx, requestRender, writeConfig)
+  ];
+}
+function createSettingsRoot(policy, ctx, onCancel, requestRender = () => {}, coordinator = new GlobalSettingsCoordinator, onApplied = () => {}, writeConfig = writeGlobalConfigValue) {
+  return new SettingsList2(settingsCategoryItems(policy, ctx, requestRender, coordinator, onApplied, writeConfig), 8, getSettingsListTheme2(), () => {}, onCancel);
+}
+function deepestFocusable(component) {
+  let current = component;
+  let focusable;
+  while (current) {
+    if (typeof current.focused === "boolean") {
+      focusable = current;
+    }
+    current = current.submenuComponent;
+  }
+  return focusable;
+}
+function createSettingsController(root, display, requestRender) {
+  let focused = false;
+  let target;
+  const syncFocus = () => {
+    const next = focused ? deepestFocusable(root) : undefined;
+    if (target !== next) {
+      if (target)
+        target.focused = false;
+      target = next;
+    }
+    if (target)
+      target.focused = focused;
+  };
+  return {
+    get focused() {
+      return focused;
+    },
+    set focused(value) {
+      focused = value;
+      syncFocus();
+    },
+    render(width) {
+      syncFocus();
+      return display.render(width);
+    },
+    handleInput(data) {
+      root.handleInput(data);
+      syncFocus();
+      requestRender();
+    },
+    invalidate: () => display.invalidate()
+  };
+}
+async function showSmartCompactSettings(ctx, policy, coordinator = new GlobalSettingsCoordinator, onApplied = () => {}) {
+  const writeConfig = async (path16, value) => {
+    const config = await writeGlobalConfigValue(path16, value);
+    await onApplied(path16, config);
+    return config;
+  };
+  await ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const root = createSettingsRoot(policy, ctx, done, () => tui.requestRender(), coordinator, onApplied, writeConfig);
+    const container = new Container4;
+    container.addChild(new Text4(theme.fg("accent", theme.bold("Smart Compact Settings")), 0, 0));
+    container.addChild(new Text4(theme.fg("dim", "Global defaults and branch-specific overrides."), 0, 0));
+    container.addChild(new Text4(theme.fg("dim", "Manual /smart-compact stays available in every mode."), 0, 0));
+    container.addChild(new Text4("", 0, 0));
+    container.addChild(root);
+    container.addChild(new Text4("", 0, 0));
+    container.addChild(new Text4(theme.fg("dim", "\u2191\u2193 navigate \xB7 enter open/change \xB7 esc back/close"), 0, 0));
+    return createSettingsController(root, container, () => tui.requestRender());
   });
 }
 
@@ -13474,6 +14485,7 @@ async function runInteractiveCompaction(ctx, config, dependencies) {
   });
 }
 function registerSmartCompactCommand(pi, dependencies) {
+  const settingsCoordinator = new GlobalSettingsCoordinator;
   pi.registerCommand("smart-compact", {
     description: "EESV smart compaction v" + VERSION + ". Usage: /smart-compact [model|settings] [mode] [flags] [--focus=topic] [--max-calls=N] [--max-input-tokens=N] [--note=text | -- text]",
     getArgumentCompletions(prefix) {
@@ -13526,7 +14538,7 @@ function registerSmartCompactCommand(pi, dependencies) {
             ctx.ui.notify("Smart Compact settings require TUI mode. Use settings.json for permanent defaults.", "warning");
             return;
           }
-          await showSmartCompactSettings(ctx, dependencies.policy);
+          await showSmartCompactSettings(ctx, dependencies.policy, settingsCoordinator, (path16) => dependencies.onGlobalSettingApplied?.(path16, ctx));
           return;
         }
         const config = loadConfig();
@@ -13573,13 +14585,34 @@ function registerSmartCompactCommand(pi, dependencies) {
 // src/app/smart-compact-policy.ts
 var SMART_COMPACT_TOOL_NAME = "smart_compact";
 var SMART_COMPACT_POLICY_ENTRY = "smart-compact-policy";
-var POLICY_VERSION = 2;
+var POLICY_VERSION = 3;
 var STATUS_KEY = "smart-compact-policy";
 function persistedPolicy(value) {
   if (typeof value !== "object" || value === null)
     return null;
   const candidate = value;
-  if (candidate.version === POLICY_VERSION && (candidate.agentToolAccess === "inherit" || candidate.agentToolAccess === "enabled" || candidate.agentToolAccess === "disabled") && typeof candidate.autoTrigger === "boolean") {
+  if (candidate.version === POLICY_VERSION && typeof candidate.overrides === "object" && candidate.overrides !== null && !Array.isArray(candidate.overrides)) {
+    const values = candidate.overrides;
+    const overrides = {};
+    if (values.agentToolAccess !== undefined) {
+      if (values.agentToolAccess !== "inherit" && values.agentToolAccess !== "enabled" && values.agentToolAccess !== "disabled") {
+        return null;
+      }
+      overrides.agentToolAccess = values.agentToolAccess;
+    }
+    if (values.autoTrigger !== undefined) {
+      if (typeof values.autoTrigger !== "boolean")
+        return null;
+      overrides.autoTrigger = values.autoTrigger;
+    }
+    if (values.showStatus !== undefined) {
+      if (typeof values.showStatus !== "boolean")
+        return null;
+      overrides.showStatus = values.showStatus;
+    }
+    return overrides;
+  }
+  if (candidate.version === 2 && (candidate.agentToolAccess === "inherit" || candidate.agentToolAccess === "enabled" || candidate.agentToolAccess === "disabled") && typeof candidate.autoTrigger === "boolean") {
     const desired = {
       agentToolAccess: candidate.agentToolAccess,
       autoTrigger: candidate.autoTrigger,
@@ -13618,13 +14651,18 @@ function statusText(policy) {
   return "smart-compact: auto off";
 }
 function createSmartCompactPolicy(pi) {
-  let current = configDefaults();
+  let overrides = {};
+  const desired = () => ({
+    ...configDefaults(),
+    ...overrides
+  });
   const effectiveToolState = () => pi.getActiveTools().includes(SMART_COMPACT_TOOL_NAME);
   const snapshot = () => ({
-    ...current,
+    ...desired(),
     agentToolEnabled: effectiveToolState()
   });
   const apply = (ctx) => {
+    const current = desired();
     const active = pi.getActiveTools();
     const hasTool = active.includes(SMART_COMPACT_TOOL_NAME);
     if (current.agentToolAccess === "enabled" && !hasTool) {
@@ -13636,45 +14674,64 @@ function createSmartCompactPolicy(pi) {
     ctx.ui.setStatus(STATUS_KEY, current.showStatus ? statusText(effective) : undefined);
     return effective;
   };
+  const restoreToolMembership = (enabled2) => {
+    const active = pi.getActiveTools();
+    const hasTool = active.includes(SMART_COMPACT_TOOL_NAME);
+    if (enabled2 && !hasTool) {
+      pi.setActiveTools([...new Set([...active, SMART_COMPACT_TOOL_NAME])]);
+    } else if (!enabled2 && hasTool) {
+      pi.setActiveTools(active.filter((name) => name !== SMART_COMPACT_TOOL_NAME));
+    }
+  };
+  const persist = (next, ctx) => {
+    const previous = overrides;
+    const previousToolEnabled = effectiveToolState();
+    overrides = next;
+    try {
+      const effective = apply(ctx);
+      pi.appendEntry(SMART_COMPACT_POLICY_ENTRY, { version: POLICY_VERSION, overrides: { ...overrides } });
+      return { ok: true, policy: effective };
+    } catch (error2) {
+      debugError("Smart Compact policy update failed", error2);
+      overrides = previous;
+      try {
+        restoreToolMembership(previousToolEnabled);
+      } catch (rollbackError) {
+        debugError("Smart Compact policy rollback failed", rollbackError);
+      }
+      const rolledBack = snapshot();
+      const previousDesired = desired();
+      ctx.ui.setStatus(STATUS_KEY, previousDesired.showStatus ? statusText(rolledBack) : undefined);
+      return {
+        ok: false,
+        policy: rolledBack,
+        error: "Smart Compact settings could not be saved; the previous policy was restored."
+      };
+    }
+  };
   return {
     snapshot,
+    branchOverrides: () => ({ ...overrides }),
     isAgentToolEnabled: effectiveToolState,
-    isAutoTriggerEnabled: () => current.autoTrigger,
+    isAutoTriggerEnabled: () => desired().autoTrigger,
     restore(ctx) {
-      current = configDefaults();
+      overrides = {};
       for (const entry of ctx.sessionManager.getBranch()) {
         if (entry.type === "custom" && entry.customType === SMART_COMPACT_POLICY_ENTRY) {
           const restored = persistedPolicy(entry.data);
           if (restored)
-            current = { ...current, ...restored };
+            overrides = restored;
         }
       }
       apply(ctx);
     },
     update(patch, ctx) {
-      const previous = current;
-      const previousActiveTools = pi.getActiveTools();
-      current = { ...current, ...patch };
-      try {
-        const effective = apply(ctx);
-        pi.appendEntry(SMART_COMPACT_POLICY_ENTRY, { version: POLICY_VERSION, ...current });
-        return { ok: true, policy: effective };
-      } catch (error2) {
-        debugError("Smart Compact policy update failed", error2);
-        current = previous;
-        try {
-          pi.setActiveTools(previousActiveTools);
-        } catch (rollbackError) {
-          debugError("Smart Compact policy rollback failed", rollbackError);
-        }
-        const rolledBack = snapshot();
-        ctx.ui.setStatus(STATUS_KEY, current.showStatus ? statusText(rolledBack) : undefined);
-        return {
-          ok: false,
-          policy: rolledBack,
-          error: "Smart Compact settings could not be saved; the previous policy was restored."
-        };
-      }
+      return persist({ ...overrides, ...patch }, ctx);
+    },
+    reset(field, ctx) {
+      const next = { ...overrides };
+      delete next[field];
+      return persist(next, ctx);
     }
   };
 }
@@ -13747,12 +14804,19 @@ function smartCompactExtension(pi) {
       return false;
     }
   };
-  registerContextTools(pi);
+  const contextToolAvailability = registerContextTools(pi);
   registerSmartCompactCommand(pi, {
     pendingRef,
     runLock: isRunning,
     onNativeApplyError,
-    policy
+    policy,
+    onGlobalSettingApplied(path16, ctx) {
+      try {
+        applyGlobalSettingRuntime(path16, ctx, policy, contextToolAvailability);
+      } catch (error2) {
+        debugError("Smart Compact runtime settings refresh failed", error2);
+      }
+    }
   });
   pi.on("session_start", (_event, ctx) => {
     policy.restore(ctx);