pi-smart-compact 9.5.0 → 9.6.1

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.1";
 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))
@@ -1103,38 +1455,117 @@ function buildPathNeedles(filePath) {
   }
   return needles;
 }
-function buildUniquePathNeedles(filePath, allPaths) {
-  const normalized = allPaths.map(normalizePath);
+var MAX_INDEXED_SUFFIX_CHARS = 1024;
+function buildPathNeedleOwnershipIndex(allPaths) {
+  const owners = new Map;
+  const normalizedPaths = allPaths.map(normalizePath);
+  let hasUnindexedSuffixes = false;
+  for (const normalized of normalizedPaths) {
+    const suffixes = new Set([normalized]);
+    for (let index = 0;index < normalized.length; index++) {
+      if (normalized[index] !== "/")
+        continue;
+      if (normalized.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+        suffixes.add(normalized.slice(index + 1));
+      } else {
+        hasUnindexedSuffixes = true;
+      }
+    }
+    for (const suffix of suffixes) {
+      owners.set(suffix, (owners.get(suffix) ?? 0) + 1);
+    }
+  }
+  return { counts: owners, normalizedPaths, hasUnindexedSuffixes };
+}
+function buildUniquePathNeedlesFromIndex(filePath, owners) {
   return buildPathNeedles(filePath).filter((needle) => {
-    let owners = 0;
-    for (const candidate of normalized) {
+    if (!owners.hasUnindexedSuffixes)
+      return owners.counts.get(needle) === 1;
+    let count = 0;
+    for (const candidate of owners.normalizedPaths) {
       if (candidate === needle || candidate.endsWith("/" + needle))
-        owners++;
-      if (owners > 1)
+        count++;
+      if (count > 1)
         return false;
     }
-    return owners === 1;
+    return count === 1;
   });
 }
-function isKnownPathReference(ref, knownPaths) {
-  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
-  if (!normalizedRef)
-    return false;
+var PATH_CANDIDATE_CHAR_RE = /[\w./-]/;
+function buildKnownPathReferenceIndex(knownPaths) {
+  const segmentSuffixes = new Set;
+  const boundarySuffixes = new Set;
+  const normalizedPaths = [];
+  let hasUnindexedSuffixes = false;
+  for (const path3 of knownPaths) {
+    const normalizedPath = normalizePath(path3).replace(/^\/+/, "");
+    if (!normalizedPath)
+      continue;
+    normalizedPaths.push(normalizedPath);
+    segmentSuffixes.add(normalizedPath);
+    for (let index = 0;index < normalizedPath.length; index++) {
+      if (normalizedPath[index] === "/") {
+        if (normalizedPath.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+          segmentSuffixes.add(normalizedPath.slice(index + 1));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+      if (index > 0 && !PATH_CANDIDATE_CHAR_RE.test(normalizedPath[index - 1])) {
+        if (normalizedPath.length - index <= MAX_INDEXED_SUFFIX_CHARS) {
+          boundarySuffixes.add(normalizedPath.slice(index));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+    }
+  }
+  return {
+    segmentSuffixes,
+    sortedSegmentSuffixes: [...segmentSuffixes].sort(),
+    boundarySuffixes,
+    normalizedPaths,
+    hasUnindexedSuffixes
+  };
+}
+function matchesKnownPathReference(normalizedRef, normalizedPaths) {
   const pathShaped = normalizedRef.includes("/");
-  return knownPaths.some((path2) => {
-    const normalizedPath = normalizePath(path2).replace(/^\/+/, "");
+  return normalizedPaths.some((normalizedPath) => {
     if (normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef))
       return true;
     if (normalizedPath.endsWith(normalizedRef)) {
       const boundary = normalizedPath[normalizedPath.length - normalizedRef.length - 1];
-      if (boundary && !/[\w./-]/.test(boundary))
+      if (boundary && !PATH_CANDIDATE_CHAR_RE.test(boundary))
         return true;
     }
     if (!pathShaped)
       return false;
-    return normalizedPath.split("/").some((_, index, parts) => parts.slice(index).join("/").startsWith(normalizedRef + "/"));
+    return normalizedPath.startsWith(normalizedRef + "/") || normalizedPath.includes("/" + normalizedRef + "/");
   });
 }
+function sortedHasPrefix(values, prefix) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] < prefix)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return values[low]?.startsWith(prefix) ?? false;
+}
+function isKnownPathReferenceInIndex(ref, index) {
+  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
+  if (!normalizedRef)
+    return false;
+  if (index.segmentSuffixes.has(normalizedRef) || index.boundarySuffixes.has(normalizedRef)) {
+    return true;
+  }
+  if (normalizedRef.includes("/") && sortedHasPrefix(index.sortedSegmentSuffixes, normalizedRef + "/"))
+    return true;
+  return index.hasUnindexedSuffixes ? matchesKnownPathReference(normalizedRef, index.normalizedPaths) : false;
+}
 
 // src/domain/tool-semantics.ts
 var PATH_KEYS = [
@@ -1352,8 +1783,12 @@ function classifyToolOperation(args, toolName) {
 function stableValue(value) {
   if (Array.isArray(value))
     return value.map(stableValue);
-  if (!value || typeof value !== "object")
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableValue(item)]));
 }
 function commandIdentity(args) {
@@ -1473,15 +1908,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 +1925,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 +1947,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 +1970,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) {
@@ -1739,7 +2174,12 @@ function buildExplorationContext(report) {
 // src/utils/file-ref-detect.ts
 var CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|rb|cs|cpp|c|h|hpp|swift|kt|scala|php|css|scss|html|json|yaml|yml|toml|md|mdx|sh|sql|tf|ini|env|lock|gradle|xml)$/i;
 var VERSION_RE = /^v?\d+(?:\.\d+)+(?:[-+][\w.-]+)?$/i;
-var FILE_REF_CANDIDATE_RE = /[\w.\/-]+\.[\w]+/g;
+function isAsciiWordCode(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code === 95 || code >= 97 && code <= 122;
+}
+function isCandidateCode(code) {
+  return isAsciiWordCode(code) || code === 45 || code === 46 || code === 47;
+}
 function isLikelyFileRef(candidate) {
   if (candidate.startsWith("//") || VERSION_RE.test(candidate))
     return false;
@@ -1750,13 +2190,32 @@ function isLikelyFileRef(candidate) {
   return CODE_EXT_RE.test(candidate);
 }
 function extractFileRefs(summary) {
-  const matcher = new RegExp(FILE_REF_CANDIDATE_RE.source, FILE_REF_CANDIDATE_RE.flags);
   const refs = [];
-  for (const match of summary.matchAll(matcher)) {
-    if (/[\\/]/.test(summary[(match.index ?? 0) + match[0].length] ?? ""))
+  let cursor = 0;
+  while (cursor < summary.length) {
+    while (cursor < summary.length && !isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runStart = cursor;
+    while (cursor < summary.length && isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runEnd = cursor;
+    let extensionDot = -1;
+    for (let index = runStart + 1;index + 1 < runEnd; index++) {
+      if (summary.charCodeAt(index) === 46 && isAsciiWordCode(summary.charCodeAt(index + 1))) {
+        extensionDot = index;
+      }
+    }
+    if (extensionDot < 0)
+      continue;
+    let matchEnd = extensionDot + 2;
+    while (matchEnd < runEnd && isAsciiWordCode(summary.charCodeAt(matchEnd))) {
+      matchEnd++;
+    }
+    const candidate = summary.slice(runStart, matchEnd);
+    if (/[\\/]/.test(summary[matchEnd] ?? ""))
       continue;
-    if (isLikelyFileRef(match[0]))
-      refs.push(match[0]);
+    if (isLikelyFileRef(candidate))
+      refs.push(candidate);
   }
   return refs;
 }
@@ -1863,7 +2322,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 +2330,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 +2862,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 +3016,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 +3165,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;
@@ -4780,12 +5054,9 @@ function advance(rc, stage) {
   const marker = stage;
   const index = STAGE_ORDER.indexOf(marker);
   const record = rc;
-  const hasStageHistory = STAGE_ORDER.some((candidate) => record[candidate] === true);
-  if (hasStageHistory) {
-    for (let prior = 0;prior < index; prior++) {
-      if (record[STAGE_ORDER[prior]] !== true) {
-        throw new Error("Pipeline stage out of order: " + marker + " requires " + STAGE_ORDER[prior]);
-      }
+  for (let prior = 0;prior < index; prior++) {
+    if (record[STAGE_ORDER[prior]] !== true) {
+      throw new Error("Pipeline stage out of order: " + marker + " requires " + STAGE_ORDER[prior]);
     }
   }
   for (const field of STAGE_REQUIRED_FIELDS[marker]) {
@@ -4828,7 +5099,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 +5109,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 +5179,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 +5210,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";
@@ -6131,12 +6402,15 @@ async function showResultScreen(ctx, details, extraction, services, opts = {}) {
       c.addChild(new Text2(theme.fg("text", opts.summary), 2, 0));
       c.addChild(new Text2("", 0, 0));
     }
+    const scrollbarStyle = (text) => theme.fg("borderMuted", text);
     const scroll = new ScrollView(c, {
       follow: "none",
       primary: true,
       overscroll: "contain",
       scrollbar: "auto",
-      scrollbarStyle: (text) => theme.fg("borderMuted", text)
+      scrollbarStyle,
+      scrollbarTrackStyle: scrollbarStyle,
+      scrollbarThumbStyle: scrollbarStyle
     });
     const footer = new Container2;
     footer.addChild(new DynamicBorder2((s) => theme.fg("accent", s)));
@@ -7334,8 +7608,12 @@ function boundedExplorationValue(value, depth = 0) {
   if (typeof value === "string") {
     return value.length > TRUNC.PREVIEW_XL ? value.slice(0, TRUNC.PREVIEW_XL) + "\u2026" : value;
   }
-  if (value == null || typeof value !== "object")
+  if (value == null || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
   if (depth >= 3)
     return "[bounded]";
   if (Array.isArray(value))
@@ -7344,7 +7622,7 @@ function boundedExplorationValue(value, depth = 0) {
 }
 function serializeExplorationResult(value, scrubber) {
   const safe = boundedExplorationValue(scrubber.scrubValue(value).value);
-  const serialized = JSON.stringify(safe);
+  const serialized = JSON.stringify(safe) ?? "null";
   if (serialized.length <= MAX_EXPLORER_OUTPUT_CHARS)
     return serialized;
   let excerptChars = Math.max(0, Math.floor((MAX_EXPLORER_OUTPUT_CHARS - 160) / 2));
@@ -7993,16 +8271,75 @@ function batchFieldPattern(name) {
   let pattern = batchFieldPatterns.get(name);
   if (!pattern) {
     const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    pattern = new RegExp("\\*\\*" + escaped + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i");
+    pattern = new RegExp("(?:^|\\n)\\*\\*" + escaped + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i");
     batchFieldPatterns.set(name, pattern);
   }
   return pattern;
 }
+
+class BatchSummaryFormatError extends Error {
+  name = "BatchSummaryFormatError";
+  constructor(reason) {
+    super("Malformed batch summary response: " + reason);
+  }
+}
+var BATCH_REQUIRED_FIELDS = [
+  "Priority",
+  "Summary",
+  "Decisions",
+  "Modified",
+  "Deleted",
+  "Read"
+];
+function assertCompleteBatchResponse(stopReason, sectionMap, duplicateIds, batchSize) {
+  const reason = String(stopReason ?? "");
+  if (reason !== "stop" && reason !== "endTurn") {
+    throw new BatchSummaryFormatError("non-terminal stop reason " + (reason || "unknown"));
+  }
+  if (duplicateIds.size > 0) {
+    throw new BatchSummaryFormatError("duplicate chunk id(s): " + [...duplicateIds].sort((a, b) => a - b).join(", "));
+  }
+  const unexpected = [...sectionMap.keys()].filter((id) => id < 1 || id > batchSize);
+  if (unexpected.length > 0) {
+    throw new BatchSummaryFormatError("unexpected chunk id(s): " + unexpected.sort((a, b) => a - b).join(", "));
+  }
+  const missingSections = [];
+  for (let id = 1;id <= batchSize; id++) {
+    if (!sectionMap.has(id))
+      missingSections.push(id);
+  }
+  if (missingSections.length > 0) {
+    throw new BatchSummaryFormatError("missing chunk section(s): " + missingSections.join(", "));
+  }
+  for (let id = 1;id <= batchSize; id++) {
+    const section = sectionMap.get(id) ?? "";
+    const missingFields = BATCH_REQUIRED_FIELDS.filter((field) => !batchFieldPattern(field).test(section));
+    if (missingFields.length > 0) {
+      throw new BatchSummaryFormatError("chunk " + id + " missing field(s): " + missingFields.join(", "));
+    }
+  }
+  const missing = [];
+  for (let id = 1;id <= batchSize; id++) {
+    const section = sectionMap.get(id);
+    const summary = section?.match(batchFieldPattern("Summary"))?.[1].trim();
+    if (!summary || summary.toLowerCase() === "none")
+      missing.push(id);
+  }
+  if (missing.length > 0) {
+    throw new BatchSummaryFormatError("missing usable Summary for chunk(s): " + missing.join(", "));
+  }
+}
 function boundedToolArgs(value, depth = 0) {
   if (typeof value === "string")
     return value.length > TRUNC.DETAIL ? value.slice(0, TRUNC.DETAIL) + "\u2026" : value;
-  if (value == null || typeof value !== "object" || depth >= 2)
+  if (value == null || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
+  if (depth >= 2)
+    return "[bounded]";
   if (Array.isArray(value))
     return value.slice(0, 8).map((item) => boundedToolArgs(item, depth + 1));
   return Object.fromEntries(Object.entries(value).slice(0, 12).map(([key, item]) => [key, boundedToolArgs(item, depth + 1)]));
@@ -8316,13 +8653,19 @@ async function summarizeBatch(batch, extraction, model, auth, signal, services,
   const output = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `);
   const sectionMap = new Map;
+  const duplicateIds = new Set;
   const sections = output.split(/^### /m).filter((s) => s.trim());
   for (const sec of sections) {
     const m = sec.match(/^CHUNK\s+(\d+):\s*(.*?)\n/i);
     if (m) {
-      sectionMap.set(parseInt(m[1], 10), sec);
+      const id = parseInt(m[1], 10);
+      if (sectionMap.has(id))
+        duplicateIds.add(id);
+      else
+        sectionMap.set(id, sec);
     }
   }
+  assertCompleteBatchResponse(resp.stopReason, sectionMap, duplicateIds, batch.length);
   const result = batch.map((ch, i) => {
     const id = i + 1;
     const sec = sectionMap.get(id) ?? "";
@@ -9570,8 +9913,9 @@ function verifyFileReferences(summary, extraction, continuity, evidence, collect
     ...(continuity?.unresolvedErrors ?? []).flatMap((error2) => error2.files),
     ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
   ]));
+  const knownFileIndex = buildKnownPathReferenceIndex(knownFiles);
   for (const ref of new Set(extractFileRefs(summary))) {
-    const grounded = isKnownPathReference(ref, knownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
+    const grounded = isKnownPathReferenceInIndex(ref, knownFileIndex) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
     if (!grounded)
       addGap(accumulator, { kind: "fabricated-file", ref }, 4);
   }
@@ -9589,9 +9933,10 @@ function verifyProgressConsistency(parsed, extraction, collected, paths, accumul
     }, 12);
   }
   const doneRefs = new Set(extractFileRefs(done).map(normalizePath));
+  const modifiedPathOwners = buildPathNeedleOwnershipIndex(paths.modified);
   for (const file of extraction.modifiedFiles) {
-    const needles = buildUniquePathNeedles(file.path, paths.modified);
-    if (!needles.some((needle) => doneRefs.has(normalizePath(needle))))
+    const needles = buildUniquePathNeedlesFromIndex(file.path, modifiedPathOwners);
+    if (!needles.some((needle) => doneRefs.has(needle)))
       continue;
     const unresolved = collected.unresolved.find((error2) => {
       const firstLine = error2.message.split(/\r?\n/, 1)[0] ?? "";
@@ -11420,6 +11765,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 +12193,7 @@ function resolveGraphScope(ctx) {
   };
 }
 function registerContextTools(pi) {
+  const availability = createContextToolAvailability(pi);
   pi.registerTool({
     name: "smart_recall",
     label: "Smart Recall",
@@ -12045,6 +12404,42 @@ Paths: ` + relatedPaths.join(", ") : ""));
       }
     }
   });
+  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
@@ -13069,239 +13464,1033 @@ async function showMetricsDashboardUI(ctx, opts) {
       label: "Overview report",
       desc: entries.length + " run(s) \xB7 Data Confidence " + insights.confidence.score + "/100"
     },
-    ...hasQualityData ? [
-      {
-        view: "quality",
-        label: "Quality & confidence",
-        desc: "Verifier evidence, repair gain, and \u226585 trust target"
-      }
-    ] : [],
+    ...hasQualityData ? [
+      {
+        view: "quality",
+        label: "Quality & confidence",
+        desc: "Verifier evidence, repair gain, and \u226585 trust target"
+      }
+    ] : [],
+    {
+      view: "providers",
+      label: "Provider routes",
+      desc: insights.providers.length + " stage/provider/model comparison row(s)"
+    },
+    {
+      view: "canary",
+      label: "Canary vs stable",
+      desc: insights.canary.decision.toUpperCase() + " \xB7 " + insights.canary.dataConfidence + "% canary confidence"
+    },
+    {
+      view: "latest",
+      label: "Latest run details",
+      desc: latest ? formatMetricRunCompact(latest) : "No run recorded yet"
+    },
+    {
+      view: "session",
+      label: "Current session",
+      desc: (opts.currentSessionId ?? "unknown") + " \u2014 " + currentRuns.length + " run(s)"
+    },
+    {
+      view: "recent",
+      label: "Recent runs",
+      desc: "Last " + Math.min(entries.length, 30) + " run(s)"
+    },
+    {
+      action: "html",
+      label: "Write HTML dashboard",
+      desc: "Generate ~/.pi/agent/.cache/smart-compact-report.html"
+    }
+  ];
+  return ctx.ui.custom((tui, theme, keybindings, done) => {
+    let view = "menu";
+    let selected = 0;
+    let scroll = 0;
+    const pageLines = () => {
+      switch (view) {
+        case "overview":
+          return opts.report.split(`
+`);
+        case "quality":
+          return formatDashboardQuality(insights);
+        case "providers":
+          return formatDashboardProviders(insights);
+        case "canary":
+          return formatDashboardCanary(insights);
+        case "latest":
+          return formatRunDetails(latest, "Latest run details");
+        case "session":
+          return formatCurrentSession(entries, opts.currentSessionId);
+        case "recent":
+          return formatRecentRuns(entries);
+        case "menu":
+          return [];
+        default:
+          return [];
+      }
+    };
+    const resetPage = (nextView) => {
+      view = nextView;
+      scroll = 0;
+    };
+    const qualityStatus = () => {
+      if (!hasQualityData)
+        return theme.fg("dim", " \u2022 Quality unavailable");
+      return theme.fg(insights.quality.targetMet ? "success" : "warning", " \u2022 Quality " + insights.quality.healthScore + "/100");
+    };
+    const renderHeader = (width) => [
+      truncateToWidth3(theme.fg("accent", theme.bold("  \uD83D\uDCCA Smart Compact Dashboard")) + theme.fg("dim", "  " + entries.length + " recorded run(s)"), width),
+      truncateToWidth3(theme.fg("dim", "  session: " + (opts.currentSessionId ?? "unknown")) + theme.fg("dim", latest && Number.isFinite(latest.verificationScore) ? " \u2022 latest score " + metricScore(latest) : "") + theme.fg(insights.confidence.targetMet ? "success" : "warning", " \u2022 Data Confidence " + insights.confidence.score + "/100") + qualityStatus(), width),
+      truncateToWidth3(theme.fg("borderMuted", "\u2500".repeat(Math.max(0, width))), width)
+    ];
+    return {
+      render(width) {
+        const lines = renderHeader(width);
+        if (view === "menu") {
+          lines.push(truncateToWidth3(theme.fg("text", "  Choose what to inspect:"), width), "");
+          for (let index = 0;index < menuItems.length; index++) {
+            const item = menuItems[index];
+            const active = index === selected;
+            const label = active ? theme.fg("accent", theme.bold(item.label)) : theme.fg("text", item.label);
+            lines.push(truncateToWidth3((active ? "  \u203A " : "    ") + label, width));
+            lines.push(truncateToWidth3("      " + theme.fg(active ? "muted" : "dim", item.desc), width));
+          }
+          lines.push("", truncateToWidth3(theme.fg("dim", "  \u2191\u2193 navigate \u2022 enter open \u2022 esc/q close"), width));
+          return lines;
+        }
+        const content = pageLines();
+        const maxScroll = Math.max(0, content.length - DASHBOARD_PAGE_SIZE);
+        scroll = Math.min(scroll, maxScroll);
+        for (const line of content.slice(scroll, scroll + DASHBOARD_PAGE_SIZE)) {
+          let styled = theme.fg("text", line);
+          if (isDashboardTitleLine(line))
+            styled = theme.fg("accent", theme.bold(line));
+          else if (line.startsWith("-"))
+            styled = theme.fg("dim", line);
+          lines.push(truncateToWidth3("  " + styled, width));
+        }
+        if (content.length > DASHBOARD_PAGE_SIZE) {
+          lines.push(truncateToWidth3(theme.fg("dim", "  showing " + (scroll + 1) + "-" + Math.min(content.length, scroll + DASHBOARD_PAGE_SIZE) + " of " + content.length), width));
+        }
+        lines.push("", truncateToWidth3(theme.fg("dim", "  \u2191\u2193 scroll \u2022 pgup/pgdn page \u2022 home/end jump \u2022 b back \u2022 esc/q close"), width));
+        return lines;
+      },
+      invalidate() {},
+      handleInput(data) {
+        if (keybindings.matches(data, "tui.select.cancel") || data === "q") {
+          done(null);
+          return;
+        }
+        if (view === "menu") {
+          if (keybindings.matches(data, "tui.select.up"))
+            selected = Math.max(0, selected - 1);
+          else if (keybindings.matches(data, "tui.select.down"))
+            selected = Math.min(menuItems.length - 1, selected + 1);
+          else if (keybindings.matches(data, "tui.select.confirm")) {
+            const item = menuItems[selected];
+            if (item.action) {
+              done(item.action);
+              return;
+            }
+            if (item.view)
+              resetPage(item.view);
+          }
+        } else {
+          const maxScroll = Math.max(0, pageLines().length - DASHBOARD_PAGE_SIZE);
+          if (data === "b" || matchesKey3(data, Key3.left))
+            resetPage("menu");
+          else if (matchesKey3(data, Key3.home))
+            scroll = 0;
+          else if (matchesKey3(data, Key3.end))
+            scroll = maxScroll;
+          else if (keybindings.matches(data, "tui.select.pageUp"))
+            scroll = Math.max(0, scroll - DASHBOARD_PAGE_SIZE);
+          else if (keybindings.matches(data, "tui.select.pageDown"))
+            scroll = Math.min(maxScroll, scroll + DASHBOARD_PAGE_SIZE);
+          else if (keybindings.matches(data, "tui.select.up"))
+            scroll = Math.max(0, scroll - 1);
+          else if (keybindings.matches(data, "tui.select.down"))
+            scroll = Math.min(maxScroll, scroll + 1);
+        }
+        tui.requestRender();
+      }
+    };
+  }, {
+    overlay: true,
+    overlayOptions: { width: "80%", anchor: "center", maxHeight: "85%" }
+  });
+}
+
+// src/ui/settings-overlay.ts
+import {
+  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";
+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
+    },
     {
-      view: "providers",
-      label: "Provider routes",
-      desc: insights.providers.length + " stage/provider/model comparison row(s)"
+      id: "scrubSecrets",
+      label: "Scrub secrets",
+      description: "Redact likely credentials before model calls and memory writes.",
+      values: BOOLEAN_VALUES
     },
     {
-      view: "canary",
-      label: "Canary vs stable",
-      desc: insights.canary.decision.toUpperCase() + " \xB7 " + insights.canary.dataConfidence + "% canary confidence"
+      id: "scrubPii",
+      label: "Scrub PII",
+      description: "Redact email, phone, and payment-card shaped data.",
+      values: BOOLEAN_VALUES
     },
     {
-      view: "latest",
-      label: "Latest run details",
-      desc: latest ? formatMetricRunCompact(latest) : "No run recorded yet"
+      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
     },
     {
-      view: "session",
-      label: "Current session",
-      desc: (opts.currentSessionId ?? "unknown") + " \u2014 " + currentRuns.length + " run(s)"
+      id: "zeroCallEnabled",
+      label: "Zero-call fast path",
+      description: "Allow deterministic compaction without an LLM call.",
+      values: BOOLEAN_VALUES
     },
     {
-      view: "recent",
-      label: "Recent runs",
-      desc: "Last " + Math.min(entries.length, 30) + " run(s)"
+      id: "telemetryChannel",
+      label: "Telemetry channel",
+      description: "Tag local metrics as stable or canary.",
+      values: ["stable", "canary"]
     },
     {
-      action: "html",
-      label: "Write HTML dashboard",
-      desc: "Generate ~/.pi/agent/.cache/smart-compact-report.html"
+      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
     }
-  ];
-  return ctx.ui.custom((tui, theme, keybindings, done) => {
-    let view = "menu";
-    let selected = 0;
-    let scroll = 0;
-    const pageLines = () => {
-      switch (view) {
-        case "overview":
-          return opts.report.split(`
-`);
-        case "quality":
-          return formatDashboardQuality(insights);
-        case "providers":
-          return formatDashboardProviders(insights);
-        case "canary":
-          return formatDashboardCanary(insights);
-        case "latest":
-          return formatRunDetails(latest, "Latest run details");
-        case "session":
-          return formatCurrentSession(entries, opts.currentSessionId);
-        case "recent":
-          return formatRecentRuns(entries);
-        case "menu":
-          return [];
-        default:
-          return [];
-      }
-    };
-    const resetPage = (nextView) => {
-      view = nextView;
-      scroll = 0;
-    };
-    const qualityStatus = () => {
-      if (!hasQualityData)
-        return theme.fg("dim", " \u2022 Quality unavailable");
-      return theme.fg(insights.quality.targetMet ? "success" : "warning", " \u2022 Quality " + insights.quality.healthScore + "/100");
-    };
-    const renderHeader = (width) => [
-      truncateToWidth3(theme.fg("accent", theme.bold("  \uD83D\uDCCA Smart Compact Dashboard")) + theme.fg("dim", "  " + entries.length + " recorded run(s)"), width),
-      truncateToWidth3(theme.fg("dim", "  session: " + (opts.currentSessionId ?? "unknown")) + theme.fg("dim", latest && Number.isFinite(latest.verificationScore) ? " \u2022 latest score " + metricScore(latest) : "") + theme.fg(insights.confidence.targetMet ? "success" : "warning", " \u2022 Data Confidence " + insights.confidence.score + "/100") + qualityStatus(), width),
-      truncateToWidth3(theme.fg("borderMuted", "\u2500".repeat(Math.max(0, width))), width)
-    ];
-    return {
-      render(width) {
-        const lines = renderHeader(width);
-        if (view === "menu") {
-          lines.push(truncateToWidth3(theme.fg("text", "  Choose what to inspect:"), width), "");
-          for (let index = 0;index < menuItems.length; index++) {
-            const item = menuItems[index];
-            const active = index === selected;
-            const label = active ? theme.fg("accent", theme.bold(item.label)) : theme.fg("text", item.label);
-            lines.push(truncateToWidth3((active ? "  \u203A " : "    ") + label, width));
-            lines.push(truncateToWidth3("      " + theme.fg(active ? "muted" : "dim", item.desc), width));
-          }
-          lines.push("", truncateToWidth3(theme.fg("dim", "  \u2191\u2193 navigate \u2022 enter open \u2022 esc/q close"), width));
-          return lines;
-        }
-        const content = pageLines();
-        const maxScroll = Math.max(0, content.length - DASHBOARD_PAGE_SIZE);
-        scroll = Math.min(scroll, maxScroll);
-        for (const line of content.slice(scroll, scroll + DASHBOARD_PAGE_SIZE)) {
-          let styled = theme.fg("text", line);
-          if (isDashboardTitleLine(line))
-            styled = theme.fg("accent", theme.bold(line));
-          else if (line.startsWith("-"))
-            styled = theme.fg("dim", line);
-          lines.push(truncateToWidth3("  " + styled, width));
-        }
-        if (content.length > DASHBOARD_PAGE_SIZE) {
-          lines.push(truncateToWidth3(theme.fg("dim", "  showing " + (scroll + 1) + "-" + Math.min(content.length, scroll + DASHBOARD_PAGE_SIZE) + " of " + content.length), width));
-        }
-        lines.push("", truncateToWidth3(theme.fg("dim", "  \u2191\u2193 scroll \u2022 pgup/pgdn page \u2022 home/end jump \u2022 b back \u2022 esc/q close"), width));
-        return lines;
-      },
-      invalidate() {},
-      handleInput(data) {
-        if (keybindings.matches(data, "tui.select.cancel") || data === "q") {
-          done(null);
-          return;
-        }
-        if (view === "menu") {
-          if (keybindings.matches(data, "tui.select.up"))
-            selected = Math.max(0, selected - 1);
-          else if (keybindings.matches(data, "tui.select.down"))
-            selected = Math.min(menuItems.length - 1, selected + 1);
-          else if (keybindings.matches(data, "tui.select.confirm")) {
-            const item = menuItems[selected];
-            if (item.action) {
-              done(item.action);
-              return;
-            }
-            if (item.view)
-              resetPage(item.view);
-          }
-        } else {
-          const maxScroll = Math.max(0, pageLines().length - DASHBOARD_PAGE_SIZE);
-          if (data === "b" || matchesKey3(data, Key3.left))
-            resetPage("menu");
-          else if (matchesKey3(data, Key3.home))
-            scroll = 0;
-          else if (matchesKey3(data, Key3.end))
-            scroll = maxScroll;
-          else if (keybindings.matches(data, "tui.select.pageUp"))
-            scroll = Math.max(0, scroll - DASHBOARD_PAGE_SIZE);
-          else if (keybindings.matches(data, "tui.select.pageDown"))
-            scroll = Math.min(maxScroll, scroll + DASHBOARD_PAGE_SIZE);
-          else if (keybindings.matches(data, "tui.select.up"))
-            scroll = Math.max(0, scroll - 1);
-          else if (keybindings.matches(data, "tui.select.down"))
-            scroll = Math.min(maxScroll, scroll + 1);
-        }
-        tui.requestRender();
-      }
-    };
-  }, {
-    overlay: true,
-    overlayOptions: { width: "80%", anchor: "center", maxHeight: "85%" }
-  });
+  ]
+};
+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)]
+  }));
 }
-
-// src/ui/settings-overlay.ts
-import {
-  getSettingsListTheme
-} from "@earendil-works/pi-coding-agent";
-import {
-  Container as Container3,
-  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) {
+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 +14663,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 +14716,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 +14763,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 +14829,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 +14852,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);
     }
   };
 }
@@ -13710,19 +14945,29 @@ function smartCompactExtension(pi) {
   const settledAutoTrigger = createSettledAutoTrigger();
   const policy = createSmartCompactPolicy(pi);
   const nativeContinuity = createNativeContinuityBridge();
+  const applyFailureWrites = new Map;
   const recordApplyFailure = (pending, reason) => {
     if (!pending.metricsSnapshot)
-      return;
+      return null;
     const cancelled = reason === "aborted" || reason === "shutdown";
-    appendMetricsSnapshot(pending.sessionId, {
+    const write = appendMetricsSnapshot(pending.sessionId, {
       ...pending.metricsSnapshot,
       status: cancelled ? "cancelled" : "error",
       failureKind: cancelled ? "cancelled" : reason === "evicted" ? "internal" : "persistence",
       fallbackReason: "native-apply:" + reason
     });
+    applyFailureWrites.set(pending.runId, write);
+    write.finally(() => {
+      if (applyFailureWrites.get(pending.runId) === write) {
+        applyFailureWrites.delete(pending.runId);
+      }
+    });
+    return write;
   };
   const commitCandidates = createCompactionCommitStore({
-    onDiscard: recordApplyFailure
+    onDiscard: (pending, reason) => {
+      recordApplyFailure(pending, reason);
+    }
   });
   const onNativeApplyError = (runId) => Boolean(commitCandidates.discard(runId, "apply-error"));
   const activateOnlineDamage = (pending) => {
@@ -13747,12 +14992,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);
@@ -13890,6 +15142,24 @@ function smartCompactExtension(pi) {
     if (state)
       nativeContinuity.stage({ projectId, sessionId, branchHeadId }, renderContinuityCapsule(state));
   });
+  const compactFailedEvents = pi;
+  compactFailedEvents.on("session_compact_failed", async (event, ctx) => {
+    if (!event.fromExtension)
+      return;
+    const sessionId = resolveSessionId(ctx);
+    clearCompactProgress(ctx);
+    const reason = event.aborted ? "aborted" : "apply-error";
+    const discarded = commitCandidates.clearSession(sessionId, reason);
+    const metricWrites = discarded.flatMap((pending) => {
+      const write = applyFailureWrites.get(pending.runId);
+      return write ? [write] : [];
+    });
+    if (metricWrites.length > 0)
+      await Promise.all(metricWrites);
+    if (discarded.length > 0) {
+      warn("Discarded " + discarded.length + " staged smart compaction after native apply " + (event.aborted ? "abort" : "failure") + (event.errorMessage ? ": " + event.errorMessage : ""));
+    }
+  });
   pi.on("before_agent_start", async (_event, ctx) => {
     const scope = resolveGraphScope(ctx);
     if (!scope?.branchHeadId)
@@ -13950,7 +15220,7 @@ function smartCompactExtension(pi) {
   });
 }
 export {
-  resolveModels,
+  smartCompactExtension as default,
   findModelById,
-  smartCompactExtension as default
+  resolveModels
 };