@adhdev/daemon-core 0.9.82-rc.328 → 0.9.82-rc.329

package/dist/index.js

@@ -313,10 +313,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "38ede5a48ea8a2e21b5ea014880b9af37c6e3537" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "38ede5a4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.328" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-19T13:57:32.496Z" : void 0);
+  const commit = readInjected(true ? "9277ba79593a0feae0e17de0204856825a199ebe" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "9277ba79" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.329" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-19T15:56:44.269Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -327,6 +327,247 @@ var init_build_info = __esm({
   }
 });
 
+// src/git/change-impact-config.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0);
+}
+function validateTarget(value, key, errors) {
+  if (!isRecord(value)) {
+    errors.push(`impactTargets.${key} must be an object`);
+    return void 0;
+  }
+  const { recommendedCommand } = value;
+  if (typeof recommendedCommand !== "string" || !recommendedCommand.length) {
+    errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+    return void 0;
+  }
+  for (const k of Object.keys(value)) {
+    if (k !== "recommendedCommand") errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+  }
+  return { recommendedCommand };
+}
+function validateChangeImpactConfig(raw, source = "inline") {
+  const errors = [];
+  if (!isRecord(raw)) {
+    return { valid: false, errors: [`${source}: config must be an object`] };
+  }
+  const config = {};
+  if (raw.daemonRuntimePackages !== void 0) {
+    if (isStringArray(raw.daemonRuntimePackages)) config.daemonRuntimePackages = [...raw.daemonRuntimePackages];
+    else errors.push("daemonRuntimePackages must be an array of non-empty strings");
+  }
+  if (raw.webOnlyPackages !== void 0) {
+    if (isStringArray(raw.webOnlyPackages)) config.webOnlyPackages = [...raw.webOnlyPackages];
+    else errors.push("webOnlyPackages must be an array of non-empty strings");
+  }
+  if (raw.nonRuntimeRootFilePatterns !== void 0) {
+    if (isStringArray(raw.nonRuntimeRootFilePatterns)) config.nonRuntimeRootFilePatterns = [...raw.nonRuntimeRootFilePatterns];
+    else errors.push("nonRuntimeRootFilePatterns must be an array of non-empty strings");
+  }
+  if (raw.impactTargets !== void 0) {
+    if (!isRecord(raw.impactTargets)) {
+      errors.push("impactTargets must be an object");
+    } else {
+      const targets = {};
+      for (const key of Object.keys(raw.impactTargets)) {
+        if (key !== "daemon" && key !== "web" && key !== "none") {
+          errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+          continue;
+        }
+        const target = validateTarget(raw.impactTargets[key], key, errors);
+        if (target) targets[key] = target;
+      }
+      if (Object.keys(targets).length) config.impactTargets = targets;
+    }
+  }
+  for (const key of Object.keys(raw)) {
+    if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key)) {
+      errors.push(`unknown config key '${key}'`);
+    }
+  }
+  return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
+}
+function parseConfigText(path42, text) {
+  if (/\.json$/i.test(path42)) return JSON.parse(text);
+  return yaml.load(text);
+}
+function loadChangeImpactConfig(repoRoot) {
+  for (const relative5 of CHANGE_IMPACT_CONFIG_LOCATIONS) {
+    const configPath = (0, import_path.join)(repoRoot, relative5);
+    if (!(0, import_fs.existsSync)(configPath)) continue;
+    try {
+      const text = (0, import_fs.readFileSync)(configPath, "utf-8");
+      let mtimeMs = 0;
+      try {
+        mtimeMs = (0, import_fs.statSync)(configPath).mtimeMs;
+      } catch {
+        mtimeMs = text.length;
+      }
+      const parsed = parseConfigText(configPath, text);
+      const validation = validateChangeImpactConfig(parsed, relative5);
+      if (!validation.valid) {
+        return {
+          source: relative5,
+          sourceType: "invalid",
+          path: configPath,
+          error: validation.errors.join("; "),
+          sourceKey: `invalid:${configPath}:${mtimeMs}`
+        };
+      }
+      return {
+        config: validation.config,
+        source: relative5,
+        sourceType: "repo_file",
+        path: configPath,
+        sourceKey: `file:${configPath}:${mtimeMs}`
+      };
+    } catch (error) {
+      return {
+        source: relative5,
+        sourceType: "invalid",
+        path: configPath,
+        error: error?.message || String(error),
+        sourceKey: `error:${configPath}`
+      };
+    }
+  }
+  return {
+    source: "unavailable",
+    sourceType: "unavailable",
+    error: `No change-impact config found. Checked: ${CHANGE_IMPACT_CONFIG_LOCATIONS.join(", ")}`,
+    sourceKey: "unavailable"
+  };
+}
+function globToRegExp(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        out += ".*";
+        i++;
+        if (pattern[i + 1] === "/") i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else if (".+^${}()|[]\\".includes(ch)) {
+      out += "\\" + ch;
+    } else {
+      out += ch;
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function listPackageDirs(packagesRoot) {
+  try {
+    return (0, import_fs.readdirSync)(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function suggestChangeImpactConfig(repoRoot) {
+  const notes = [];
+  const daemon = /* @__PURE__ */ new Set();
+  const web = /* @__PURE__ */ new Set();
+  const unclassified = [];
+  const roots = ["packages", (0, import_path.join)("oss", "packages")];
+  for (const rel of roots) {
+    const packagesRoot = (0, import_path.join)(repoRoot, rel);
+    if (!(0, import_fs.existsSync)(packagesRoot)) continue;
+    for (const name of listPackageDirs(packagesRoot)) {
+      if (/(^web[-.]|[-.]web$)/i.test(name) || /dashboard|frontend|ui$/i.test(name)) {
+        web.add(name);
+      } else {
+        daemon.add(name);
+      }
+    }
+  }
+  const daemonRuntimePackages = [...daemon].sort();
+  const webOnlyPackages = [...web].sort();
+  if (!daemonRuntimePackages.length && !webOnlyPackages.length) {
+    notes.push("No packages/ or oss/packages/ directories found \u2014 defaulting to an empty draft you should fill in by hand.");
+  } else {
+    if (daemonRuntimePackages.length) notes.push(`Classified ${daemonRuntimePackages.length} package(s) as daemon-runtime (change \u2192 rebuild/redeploy + restart).`);
+    if (webOnlyPackages.length) notes.push(`Classified ${webOnlyPackages.length} web-* package(s) as web-only (change \u2192 web redeploy, no daemon restart).`);
+    notes.push("Heuristic only: confirm each package actually matches its bucket before saving.");
+  }
+  const nonRuntimeRootFilePatterns = [
+    "*.md",
+    "docs/**",
+    "LICENSE",
+    "LICENSE.*",
+    ".gitignore"
+  ];
+  notes.push("nonRuntimeRootFilePatterns lists root files that demonstrably cannot change daemon runtime behavior; extend with your repo markers.");
+  const suggestedConfig = {
+    ...daemonRuntimePackages.length ? { daemonRuntimePackages } : {},
+    ...webOnlyPackages.length ? { webOnlyPackages } : {},
+    nonRuntimeRootFilePatterns,
+    impactTargets: {
+      daemon: { recommendedCommand: "rebuild + redeploy the daemon, then restart it" },
+      web: { recommendedCommand: "redeploy the web app (no daemon restart required)" },
+      none: { recommendedCommand: "no action required" }
+    }
+  };
+  return {
+    suggestedConfig,
+    notes,
+    discoveredPackages: { daemon: daemonRuntimePackages, web: webOnlyPackages, unclassified }
+  };
+}
+var import_fs, import_path, yaml, CHANGE_IMPACT_CONFIG_LOCATIONS, CHANGE_IMPACT_CONFIG_SCHEMA;
+var init_change_impact_config = __esm({
+  "src/git/change-impact-config.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    yaml = __toESM(require("js-yaml"));
+    CHANGE_IMPACT_CONFIG_LOCATIONS = [
+      ".adhdev/change-impact.json",
+      ".adhdev/change-impact.yaml",
+      ".adhdev/change-impact.yml",
+      ".adhdev/repo-mesh-change-impact.json",
+      ".adhdev/repo-mesh-change-impact.yaml",
+      ".adhdev/repo-mesh-change-impact.yml"
+    ];
+    CHANGE_IMPACT_CONFIG_SCHEMA = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      title: "ADHDev Change Impact Config",
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        daemonRuntimePackages: { type: "array", items: { type: "string", minLength: 1 } },
+        webOnlyPackages: { type: "array", items: { type: "string", minLength: 1 } },
+        nonRuntimeRootFilePatterns: { type: "array", items: { type: "string", minLength: 1 } },
+        impactTargets: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            daemon: { $ref: "#/$defs/target" },
+            web: { $ref: "#/$defs/target" },
+            none: { $ref: "#/$defs/target" }
+          }
+        }
+      },
+      $defs: {
+        target: {
+          type: "object",
+          additionalProperties: false,
+          required: ["recommendedCommand"],
+          properties: {
+            recommendedCommand: { type: "string", minLength: 1 }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/git/git-status.ts
 function isTransientGitFailure(error) {
   return error.reason === "timeout" || error.reason === "git_command_failed";
@@ -402,16 +643,34 @@ async function collectGitRepoStatus(repo, includeSubmodules, lastCheckedAt, opti
     ...daemonBuildBehind ? { daemonBuildBehind } : {}
   };
 }
-function isNonRuntimeRootFile(file) {
+function resolveChangeImpactPolicy(config) {
+  const daemonRuntimePackages = new Set(
+    config?.daemonRuntimePackages && config.daemonRuntimePackages.length ? config.daemonRuntimePackages : DEFAULT_DAEMON_RUNTIME_PACKAGES
+  );
+  const webOnlyPackages = new Set(
+    config?.webOnlyPackages && config.webOnlyPackages.length ? config.webOnlyPackages : DEFAULT_WEB_ONLY_PACKAGES
+  );
+  const nonRuntimeRootFilePatterns = (config?.nonRuntimeRootFilePatterns || []).map(globToRegExp);
+  const impactTargets = {
+    daemon: config?.impactTargets?.daemon ?? DEFAULT_IMPACT_TARGETS.daemon,
+    web: config?.impactTargets?.web ?? DEFAULT_IMPACT_TARGETS.web,
+    none: config?.impactTargets?.none ?? DEFAULT_IMPACT_TARGETS.none
+  };
+  return { daemonRuntimePackages, webOnlyPackages, nonRuntimeRootFilePatterns, impactTargets };
+}
+function isNonRuntimeRootFile(file, policy) {
   const base = file.slice(file.lastIndexOf("/") + 1);
   if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
   if (/(?:^|\/)docs\//i.test(file)) return true;
   if (/^(?:README|CHANGELOG|LICENSE|NOTICE|AUTHORS|CONTRIBUTING|CODEOWNERS)(?:\.[A-Za-z0-9]+)?$/i.test(base)) {
     return true;
   }
+  for (const re of policy.nonRuntimeRootFilePatterns) {
+    if (re.test(file)) return true;
+  }
   return false;
 }
-async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
+async function classifyDaemonBuildChange(repoPath, buildCommit, options, policy) {
   try {
     const diff = await runGit(repoPath, ["diff", "--name-only", `${buildCommit}..HEAD`], options);
     const files = diff.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
@@ -423,21 +682,47 @@ async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
     for (const file of files) {
       const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
       if (!match) {
-        if (!isNonRuntimeRootFile(file)) sawRuntimeAmbiguousNonPackage = true;
+        if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
         continue;
       }
       pkgs.add(match[1]);
     }
     const affectedPackages = [...pkgs].sort();
-    const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
+    const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
     return { isDaemonAffecting: !allBenign, affectedPackages };
   } catch {
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
 }
+function resolveChangeImpactConfigForRepo(repoRoot, options) {
+  if (options.changeImpactConfig === null) {
+    return { config: null, sourceKey: "forced-default" };
+  }
+  if (options.changeImpactConfig !== void 0) {
+    let key = "injected";
+    try {
+      key = `injected:${JSON.stringify(options.changeImpactConfig)}`;
+    } catch {
+    }
+    return { config: options.changeImpactConfig, sourceKey: key };
+  }
+  if (!repoRoot) {
+    return { config: null, sourceKey: "no-repo-root" };
+  }
+  const loaded = loadChangeImpactConfig(repoRoot);
+  const cached2 = changeImpactConfigCache.get(repoRoot);
+  if (cached2 && cached2.sourceKey === loaded.sourceKey) {
+    return { config: cached2.config, sourceKey: loaded.sourceKey };
+  }
+  const config = loaded.sourceType === "repo_file" ? loaded.config ?? null : null;
+  changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config });
+  return { config, sourceKey: loaded.sourceKey };
+}
 async function detectDaemonBuildBehind(repo, submodules, options) {
   const build = options.daemonBuildInfo ?? getDaemonBuildInfo();
   if (!build.commit || build.commit === "unknown") return void 0;
+  const { config, sourceKey: configKey } = resolveChangeImpactConfigForRepo(repo.repoRoot, options);
+  const policy = resolveChangeImpactPolicy(config);
   const scopes = [
     { scope: "root", repoPath: repo.repoRoot || repo.workspace }
   ];
@@ -451,11 +736,15 @@ async function detectDaemonBuildBehind(repo, submodules, options) {
       const head = headResult.stdout.trim();
       if (!head || head === build.commit) continue;
       await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
-      const { isDaemonAffecting, affectedPackages } = await classifyDaemonBuildChange(
-        repoPath,
-        build.commit,
-        options
-      );
+      const evalKey = `${repoPath}\0${build.commit}\0${head}\0${configKey}`;
+      let evaluated = changeImpactEvalCache.get(evalKey);
+      if (!evaluated) {
+        evaluated = await classifyDaemonBuildChange(repoPath, build.commit, options, policy);
+        changeImpactEvalCache.set(evalKey, evaluated);
+      }
+      const { isDaemonAffecting, affectedPackages } = evaluated;
+      const kind = isDaemonAffecting ? "daemon" : affectedPackages.length > 0 ? "web" : "none";
+      const target = policy.impactTargets[kind];
       const scopeLabel = scope === "root" ? "workspace" : scope;
       const benignDetail = affectedPackages.length > 0 ? `only web packages changed (${affectedPackages.join(", ")})` : "only non-runtime files changed (markers/docs)";
       const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but ${benignDetail}. Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
@@ -466,6 +755,8 @@ async function detectDaemonBuildBehind(repo, submodules, options) {
         scope,
         isDaemonAffecting,
         ...affectedPackages && affectedPackages.length > 0 ? { affectedPackages } : {},
+        recommendedAction: kind,
+        recommendedCommand: target.recommendedCommand,
         warning
       };
     } catch {
@@ -729,14 +1020,17 @@ async function enrichSubmoduleWorktreeStatus(repo, submodule, options) {
     submodule.error = formatGitError(error);
   }
 }
-var lastKnownGoodStatus, DAEMON_RUNTIME_PACKAGES, WEB_ONLY_PACKAGES;
+var lastKnownGoodStatus, changeImpactEvalCache, changeImpactConfigCache, DEFAULT_DAEMON_RUNTIME_PACKAGES, DEFAULT_WEB_ONLY_PACKAGES, DEFAULT_IMPACT_TARGETS;
 var init_git_status = __esm({
   "src/git/git-status.ts"() {
     "use strict";
     init_git_executor();
     init_build_info();
+    init_change_impact_config();
     lastKnownGoodStatus = /* @__PURE__ */ new Map();
-    DAEMON_RUNTIME_PACKAGES = /* @__PURE__ */ new Set([
+    changeImpactEvalCache = /* @__PURE__ */ new Map();
+    changeImpactConfigCache = /* @__PURE__ */ new Map();
+    DEFAULT_DAEMON_RUNTIME_PACKAGES = [
       "daemon-core",
       "daemon-standalone",
       "session-host-core",
@@ -746,13 +1040,24 @@ var init_git_status = __esm({
       "terminal-mux-cli",
       "ghostty-vt-node",
       "mcp-server"
-    ]);
-    WEB_ONLY_PACKAGES = /* @__PURE__ */ new Set([
+    ];
+    DEFAULT_WEB_ONLY_PACKAGES = [
       "web-core",
       "web-standalone",
       "web-devconsole",
       "terminal-render-web"
-    ]);
+    ];
+    DEFAULT_IMPACT_TARGETS = {
+      daemon: {
+        recommendedCommand: "Redeploy + restart the daemon (a local dist rebuild alone does not update a cloud daemon)."
+      },
+      web: {
+        recommendedCommand: "Redeploy the web app (no daemon restart required)."
+      },
+      none: {
+        recommendedCommand: "No action required."
+      }
+    };
   }
 });
 
@@ -1311,25 +1616,25 @@ function ensureMachineId(config) {
 }
 function getConfigDir() {
   const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : (0, import_path.join)((0, import_os.homedir)(), ".adhdev");
-  if (!(0, import_fs.existsSync)(dir)) {
-    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  const dir = override && override.trim() ? override.trim() : (0, import_path2.join)((0, import_os.homedir)(), ".adhdev");
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
   }
   return dir;
 }
 function getDaemonDataDir() {
-  const dir = (0, import_path.join)(getConfigDir(), "daemon");
-  if (!(0, import_fs.existsSync)(dir)) {
-    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path2.join)(getConfigDir(), "daemon");
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
   }
   return dir;
 }
 function getConfigPath() {
-  return (0, import_path.join)(getConfigDir(), "config.json");
+  return (0, import_path2.join)(getConfigDir(), "config.json");
 }
 function migrateStateToStateFile(raw) {
-  const statePath = (0, import_path.join)(getConfigDir(), "state.json");
-  if ((0, import_fs.existsSync)(statePath)) return;
+  const statePath = (0, import_path2.join)(getConfigDir(), "state.json");
+  if ((0, import_fs2.existsSync)(statePath)) return;
   const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
   const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
   const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
@@ -1349,11 +1654,11 @@ function migrateStateToStateFile(raw) {
     sessionReads: mergedReads,
     sessionReadMarkers: cleanedMarkers
   };
-  (0, import_fs.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_fs.existsSync)(configPath)) {
+  if (!(0, import_fs2.existsSync)(configPath)) {
     const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
     try {
       saveConfig(initialized.config);
@@ -1362,7 +1667,7 @@ function loadConfig() {
     return initialized.config;
   }
   try {
-    const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
+    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
@@ -1384,12 +1689,12 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
   const normalized = normalizeConfig(config);
-  if (!(0, import_fs.existsSync)(dir)) {
-    (0, import_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
-  (0, import_fs.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs2.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
   try {
-    (0, import_fs.chmodSync)(configPath, 384);
+    (0, import_fs2.chmodSync)(configPath, 384);
   } catch {
   }
 }
@@ -1416,13 +1721,13 @@ function isSetupComplete() {
 function resetConfig() {
   saveConfig({ ...DEFAULT_CONFIG });
 }
-var import_os, import_path, import_fs, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
+var import_os, import_path2, import_fs2, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
 var init_config = __esm({
   "src/config/config.ts"() {
     "use strict";
     import_os = require("os");
-    import_path = require("path");
-    import_fs = require("fs");
+    import_path2 = require("path");
+    import_fs2 = require("fs");
     import_crypto = require("crypto");
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
@@ -1541,13 +1846,13 @@ __export(mesh_config_exports, {
   updateNode: () => updateNode
 });
 function getMeshConfigPath() {
-  return (0, import_path2.join)(getConfigDir(), "meshes.json");
+  return (0, import_path3.join)(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
   const path42 = getMeshConfigPath();
-  if (!(0, import_fs2.existsSync)(path42)) return { meshes: [] };
+  if (!(0, import_fs3.existsSync)(path42)) return { meshes: [] };
   try {
-    const raw = JSON.parse((0, import_fs2.readFileSync)(path42, "utf-8"));
+    const raw = JSON.parse((0, import_fs3.readFileSync)(path42, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -1597,7 +1902,7 @@ function normalizeCapabilityTags(value) {
 }
 function saveMeshConfig(config) {
   const path42 = getMeshConfigPath();
-  (0, import_fs2.writeFileSync)(path42, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs3.writeFileSync)(path42, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function normalizeRepoIdentity(remoteUrl) {
   let identity = remoteUrl.trim();
@@ -1957,12 +2262,12 @@ function updateNode(meshId, nodeId, opts) {
   saveMeshConfig(config);
   return node;
 }
-var import_fs2, import_path2, import_crypto3, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES;
+var import_fs3, import_path3, import_crypto3, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_fs3 = require("fs");
+    import_path3 = require("path");
     import_crypto3 = require("crypto");
     init_config();
     init_repo_mesh_types();
@@ -2259,41 +2564,41 @@ function isIntentionalCleanupStopEntry(entry) {
   return payload.intentional === true && (payload.reason === "operator_cleanup" || payload.intentionalStopReason === "operator_cleanup" || payload.source === "mesh_cleanup_sessions" || payload.source === "mesh_remove_node");
 }
 function getLedgerDir() {
-  const dir = (0, import_path3.join)(getConfigDir(), LEDGER_DIR_NAME);
-  if (!(0, import_fs3.existsSync)(dir)) {
-    (0, import_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = (0, import_path4.join)(getConfigDir(), LEDGER_DIR_NAME);
+  if (!(0, import_fs4.existsSync)(dir)) {
+    (0, import_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path3.join)(getLedgerDir(), `${safe}.jsonl`);
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path3.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path3.join)(getLedgerDir(), `${safe}.archive.jsonl`);
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path3.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path3.join)(getLedgerDir(), `${safe}.archived-counts.json`);
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while ((0, import_fs3.existsSync)(getRotatedArchivePath(meshId, index))) {
+  while ((0, import_fs4.existsSync)(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
   if (index > 5) index = 5;
   try {
-    (0, import_fs3.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
+    (0, import_fs4.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}
 `);
@@ -2301,9 +2606,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path42 = getArchivedCountsPath(meshId);
-  if (!(0, import_fs3.existsSync)(path42)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!(0, import_fs4.existsSync)(path42)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse((0, import_fs3.readFileSync)(path42, "utf-8"));
+    return JSON.parse((0, import_fs4.readFileSync)(path42, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -2319,7 +2624,7 @@ function updateArchivedCounts(meshId, archived) {
   counts.totalArchived += archived.length;
   counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    (0, import_fs3.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+    (0, import_fs4.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 }
@@ -2342,7 +2647,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs3.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!(0, import_fs4.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -2357,11 +2662,11 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if ((0, import_fs3.existsSync)(archivePath) && (0, import_fs3.statSync)(archivePath).size > 50 * 1024 * 1024) {
+    if ((0, import_fs4.existsSync)(archivePath) && (0, import_fs4.statSync)(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs3.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs4.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
     updateArchivedCounts(meshId, archive);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger archive write failed for mesh ${meshId}: ${e?.message || e}
@@ -2370,7 +2675,7 @@ function compactLedger(meshId) {
   }
   try {
     const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-    (0, import_fs3.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs4.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger compaction rewrite failed for mesh ${meshId}: ${e?.message || e}
@@ -2507,9 +2812,9 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if ((0, import_fs3.existsSync)(filePath)) {
+  if ((0, import_fs4.existsSync)(filePath)) {
     try {
-      const stat2 = (0, import_fs3.statSync)(filePath);
+      const stat2 = (0, import_fs4.statSync)(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
         rotateLedgerFile(meshId, filePath);
       } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -2534,7 +2839,7 @@ function appendLedgerEntry(meshId, partial) {
   }
   try {
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs3.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+    (0, import_fs4.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     meshLedgerEvents.emit("append", meshId, entry);
     return entry;
@@ -2593,7 +2898,7 @@ function appendRemoteLedgerEntries(meshId, entries) {
   }
   try {
     const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs3.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs4.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     for (const entry of validEntries) {
       meshLedgerEvents.emit("append", meshId, entry);
@@ -2605,10 +2910,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs3.existsSync)(filePath)) return [];
+  if (!(0, import_fs4.existsSync)(filePath)) return [];
   let content;
   try {
-    content = (0, import_fs3.readFileSync)(filePath, "utf-8");
+    content = (0, import_fs4.readFileSync)(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -2869,24 +3174,24 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while ((0, import_fs3.existsSync)(getRotatedPath(meshId, index))) {
+  while ((0, import_fs4.existsSync)(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
   if (index > 10) index = 10;
   try {
-    (0, import_fs3.renameSync)(currentPath, getRotatedPath(meshId, index));
+    (0, import_fs4.renameSync)(currentPath, getRotatedPath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger rotation failed for mesh ${meshId}: ${e?.message || e}. File will continue to grow.
 `);
   }
 }
-var import_fs3, import_path3, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
+var import_fs4, import_path4, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path3 = require("path");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
     import_crypto4 = require("crypto");
     init_config();
     import_events = require("events");
@@ -3554,32 +3859,32 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return (0, import_path4.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return (0, import_path5.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
-  const nextPath = (0, import_path4.join)(dir, "mesh-runtime.db");
-  if ((0, import_fs4.existsSync)(nextPath)) return nextPath;
-  const legacyPath = (0, import_path4.join)(dir, "beads.db");
-  if (!(0, import_fs4.existsSync)(legacyPath)) return nextPath;
+  const nextPath = (0, import_path5.join)(dir, "mesh-runtime.db");
+  if ((0, import_fs5.existsSync)(nextPath)) return nextPath;
+  const legacyPath = (0, import_path5.join)(dir, "beads.db");
+  if (!(0, import_fs5.existsSync)(legacyPath)) return nextPath;
   try {
-    (0, import_fs4.renameSync)(legacyPath, nextPath);
+    (0, import_fs5.renameSync)(legacyPath, nextPath);
     for (const suffix of ["-wal", "-shm"]) {
       const legacyCompanion = `${legacyPath}${suffix}`;
-      if ((0, import_fs4.existsSync)(legacyCompanion)) {
-        (0, import_fs4.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
+      if ((0, import_fs5.existsSync)(legacyCompanion)) {
+        (0, import_fs5.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
       }
     }
   } catch {
   }
   return nextPath;
 }
-var import_fs4, import_path4, import_module, import_meta, DatabaseCtor, MeshRuntimeStore;
+var import_fs5, import_path5, import_module, import_meta, DatabaseCtor, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path4 = require("path");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
     import_module = require("module");
     init_mesh_ledger();
     init_mesh_work_queue();
@@ -3595,8 +3900,8 @@ var init_mesh_runtime_store = __esm({
       static WAL_MAX_BYTES = 50 * 1024 * 1024;
       // 50 MB
       constructor(dbPath) {
-        const dir = (0, import_path4.dirname)(dbPath);
-        if (!(0, import_fs4.existsSync)(dir)) (0, import_fs4.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path5.dirname)(dbPath);
+        if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3851,8 +4156,8 @@ var init_mesh_runtime_store = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!(0, import_fs4.existsSync)(walPath)) return;
-          const size = (0, import_fs4.statSync)(walPath).size;
+          if (!(0, import_fs5.existsSync)(walPath)) return;
+          const size = (0, import_fs5.statSync)(walPath).size;
           if (size < _MeshRuntimeStore.WAL_MAX_BYTES) return;
           process.stderr.write(
             `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint
@@ -3868,9 +4173,9 @@ var init_mesh_runtime_store = __esm({
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
         const path42 = legacyQueuePath(meshId);
-        if (!(0, import_fs4.existsSync)(path42)) return;
+        if (!(0, import_fs5.existsSync)(path42)) return;
         try {
-          const entries = JSON.parse((0, import_fs4.readFileSync)(path42, "utf-8"));
+          const entries = JSON.parse((0, import_fs5.readFileSync)(path42, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -7434,8 +7739,8 @@ function formatCompletionMetadata(event) {
 function buildMeshSystemMessage(args) {
   const metadata = formatCompletionMetadata(args.metadataEvent);
   if (args.event === "agent:generating_completed") {
-    if (args.metadataEvent.source === "long_generating_reconciliation") {
-      return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The long-generating monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
+    if (args.metadataEvent.source === "no_progress_reconciliation") {
+      return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
     }
     const reviewNote = args.metadataEvent.reviewRecommended === true ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
     return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;
@@ -7474,7 +7779,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     }
     return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
   }
-  if (args.event === "monitor:long_generating") {
+  if (args.event === "monitor:no_progress") {
     return `[System] ${args.nodeLabel} is still reported as generating after a long interval${metadata}. Wait for pendingCoordinatorEvents or a completion/status event; if the user explicitly asks for status, make one bounded status check and then wait again.`;
   }
   if (args.event === "worktree_bootstrap_complete") {
@@ -7613,9 +7918,9 @@ function getPendingEventsPath(meshId, coordinatorDaemonId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   if (coordinatorDaemonId) {
     const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return (0, import_path8.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return (0, import_path9.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return (0, import_path8.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return (0, import_path9.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -7624,9 +7929,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path42 of paths) {
-    if (!(0, import_fs8.existsSync)(path42)) continue;
+    if (!(0, import_fs9.existsSync)(path42)) continue;
     try {
-      const raw = (0, import_fs8.readFileSync)(path42, "utf-8");
+      const raw = (0, import_fs9.readFileSync)(path42, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -7701,11 +8006,11 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path42) {
   try {
-    if (!(0, import_fs8.existsSync)(path42)) return;
-    if ((0, import_fs8.statSync)(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs8.readFileSync)(path42, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs9.existsSync)(path42)) return;
+    if ((0, import_fs9.statSync)(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs9.readFileSync)(path42, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
-    (0, import_fs8.writeFileSync)(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs9.writeFileSync)(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -7734,7 +8039,7 @@ function queuePendingMeshCoordinatorEvent(event) {
     }
     const path42 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
     trimPendingEventsIfNeeded(path42);
-    (0, import_fs8.appendFileSync)(path42, JSON.stringify(event) + "\n", "utf-8");
+    (0, import_fs9.appendFileSync)(path42, JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -7744,20 +8049,20 @@ function queuePendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path42) {
   const tmpPath = `${path42}.draining`;
   try {
-    (0, import_fs8.renameSync)(path42, tmpPath);
+    (0, import_fs9.renameSync)(path42, tmpPath);
   } catch {
     return null;
   }
   try {
-    const content = (0, import_fs8.readFileSync)(tmpPath, "utf-8");
+    const content = (0, import_fs9.readFileSync)(tmpPath, "utf-8");
     try {
-      (0, import_fs8.unlinkSync)(tmpPath);
+      (0, import_fs9.unlinkSync)(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      (0, import_fs8.unlinkSync)(tmpPath);
+      (0, import_fs9.unlinkSync)(tmpPath);
     } catch {
     }
     return null;
@@ -7766,16 +8071,16 @@ function atomicDrainFile(path42) {
 function selectiveDrainFile(path42, predicate) {
   const tmpPath = `${path42}.draining`;
   try {
-    (0, import_fs8.renameSync)(path42, tmpPath);
+    (0, import_fs9.renameSync)(path42, tmpPath);
   } catch {
     return [];
   }
   let content;
   try {
-    content = (0, import_fs8.readFileSync)(tmpPath, "utf-8");
+    content = (0, import_fs9.readFileSync)(tmpPath, "utf-8");
   } catch {
     try {
-      (0, import_fs8.unlinkSync)(tmpPath);
+      (0, import_fs9.unlinkSync)(tmpPath);
     } catch {
     }
     return [];
@@ -7798,12 +8103,12 @@ function selectiveDrainFile(path42, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      (0, import_fs8.writeFileSync)(path42, keptLines.join("\n") + "\n", "utf-8");
+      (0, import_fs9.writeFileSync)(path42, keptLines.join("\n") + "\n", "utf-8");
     }
-    (0, import_fs8.unlinkSync)(tmpPath);
+    (0, import_fs9.unlinkSync)(tmpPath);
   } catch {
     try {
-      if ((0, import_fs8.existsSync)(tmpPath) && !(0, import_fs8.existsSync)(path42)) (0, import_fs8.renameSync)(tmpPath, path42);
+      if ((0, import_fs9.existsSync)(tmpPath) && !(0, import_fs9.existsSync)(path42)) (0, import_fs9.renameSync)(tmpPath, path42);
     } catch {
     }
     return [];
@@ -7897,18 +8202,18 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path42 of paths) {
-    if ((0, import_fs8.existsSync)(path42)) try {
-      (0, import_fs8.unlinkSync)(path42);
+    if ((0, import_fs9.existsSync)(path42)) try {
+      (0, import_fs9.unlinkSync)(path42);
     } catch {
     }
   }
 }
-var import_fs8, import_path8, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs9, import_path9, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path8 = require("path");
+    import_fs9 = require("fs");
+    import_path9 = require("path");
     import_crypto7 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -8264,7 +8569,7 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
   });
   return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };
 }
-function buildLongGeneratingCompletionReconciliation(args) {
+function buildNoProgressCompletionReconciliation(args) {
   const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
   const providerType = readNonEmptyString2(args.metadataEvent.providerType);
@@ -8283,8 +8588,8 @@ function buildLongGeneratingCompletionReconciliation(args) {
       providerType,
       providerSessionId,
       finalSummary,
-      source: "long_generating_reconciliation",
-      reconciledFromEvent: "monitor:long_generating",
+      source: "no_progress_reconciliation",
+      reconciledFromEvent: "monitor:no_progress",
       timestamp: args.metadataEvent.timestamp ?? Date.now(),
       completionDiagnostic: {
         ...completionDiagnostic || {},
@@ -8300,7 +8605,7 @@ function buildLongGeneratingCompletionReconciliation(args) {
   if (!terminal) return null;
   return {
     ...args.metadataEvent,
-    source: "long_generating_terminal_ledger_suppression",
+    source: "no_progress_terminal_ledger_suppression",
     terminalLedgerKind: terminal.kind,
     terminalLedgerAt: terminal.timestamp
   };
@@ -8740,7 +9045,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path11.isAbsolute(expanded) ? expanded : path11.resolve(expanded);
-    return (0, import_fs9.existsSync)(candidate) ? candidate : null;
+    return (0, import_fs10.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
@@ -8750,7 +9055,7 @@ async function resolveDetectionPath(command, whichCmd) {
   const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
   if (whichResult) return whichResult.split("\n")[0];
   const resolved = findBinary(command);
-  if (path11.isAbsolute(resolved) && (0, import_fs9.existsSync)(resolved)) return resolved;
+  if (path11.isAbsolute(resolved) && (0, import_fs10.existsSync)(resolved)) return resolved;
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
@@ -8845,14 +9150,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process, os6, path11, import_fs9;
+var import_child_process, os6, path11, import_fs10;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
     import_child_process = require("child_process");
     os6 = __toESM(require("os"));
     path11 = __toESM(require("path"));
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     init_provider_cli_shared();
   }
 });
@@ -9151,7 +9456,7 @@ function hasRecentIntentionalCleanupStop(meshId, sessionId, nodeId) {
   return false;
 }
 function shouldSuppressIntentionalCleanupStop(args) {
-  if (args.event !== "agent:stopped" && args.event !== "monitor:long_generating") return false;
+  if (args.event !== "agent:stopped" && args.event !== "monitor:no_progress") return false;
   if (isIntentionalCleanupStopMetadata(args.metadataEvent)) return true;
   return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
@@ -9367,7 +9672,7 @@ function resolveAutoFastForwardPolicy(mesh) {
 function sessionStateLooksActive(state) {
   const status = readNonEmptyString2(state?.status).toLowerCase();
   const chatStatus = readNonEmptyString2(state?.activeChat?.status).toLowerCase();
-  const active = /* @__PURE__ */ new Set(["generating", "streaming", "long_generating", "working", "starting", "waiting_approval"]);
+  const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
   return active.has(status) || active.has(chatStatus);
 }
 function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
@@ -9887,7 +10192,7 @@ async function maybeAutoFastForwardIdleNode(components, args) {
   const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
   const workspace = readNonEmptyString2(node?.workspace);
   if (!workspace) return;
-  if (!(0, import_fs10.existsSync)(workspace)) return;
+  if (!(0, import_fs11.existsSync)(workspace)) return;
   const policy = resolveAutoFastForwardPolicy(mesh);
   if (!policy.enabled) return;
   if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
@@ -9981,24 +10286,24 @@ function injectMeshSystemMessage(components, args) {
     LOG.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
     return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
   }
-  if (args.event === "monitor:long_generating") {
-    const reconciledCompletion = buildLongGeneratingCompletionReconciliation({
+  if (args.event === "monitor:no_progress") {
+    const reconciledCompletion = buildNoProgressCompletionReconciliation({
       meshId: args.meshId,
       nodeId: args.nodeId,
       nodeLabel: args.nodeLabel,
       metadataEvent: args.metadataEvent,
       sourceInstanceId: args.sourceInstanceId
     });
-    if (reconciledCompletion?.source === "long_generating_reconciliation") {
-      LOG.info("MeshEvents", `Reconciled long-generating monitor to completion for session ${eventSessionId || "(unknown session)"}`);
+    if (reconciledCompletion?.source === "no_progress_reconciliation") {
+      LOG.info("MeshEvents", `Reconciled no-progress monitor to completion for session ${eventSessionId || "(unknown session)"}`);
       return injectMeshSystemMessage(components, {
         ...args,
         event: "agent:generating_completed",
         metadataEvent: reconciledCompletion
       });
     }
-    if (reconciledCompletion?.source === "long_generating_terminal_ledger_suppression") {
-      LOG.info("MeshEvents", `Suppressed long-generating monitor because terminal ledger evidence already exists for session ${eventSessionId || "(unknown session)"}`);
+    if (reconciledCompletion?.source === "no_progress_terminal_ledger_suppression") {
+      LOG.info("MeshEvents", `Suppressed no-progress monitor because terminal ledger evidence already exists for session ${eventSessionId || "(unknown session)"}`);
       return {
         success: true,
         forwarded: 0,
@@ -10040,7 +10345,7 @@ function injectMeshSystemMessage(components, args) {
         const terminalFinalSummary = readNonEmptyString2(terminal.payload.finalSummary);
         const eventProviderSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
         const eventFinalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
-        if (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId || terminalFinalSummary && terminalFinalSummary === eventFinalSummary || args.metadataEvent.source === "long_generating_reconciliation") {
+        if (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId || terminalFinalSummary && terminalFinalSummary === eventFinalSummary || args.metadataEvent.source === "no_progress_reconciliation") {
           LOG.info("MeshEvents", `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
           return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
         }
@@ -10479,11 +10784,11 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs10, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
+var import_fs11, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
-    import_fs10 = require("fs");
+    import_fs11 = require("fs");
     init_config();
     init_mesh_config();
     init_cli_detector();
@@ -10519,7 +10824,7 @@ var init_mesh_events_coordinator = __esm({
       "agent:waiting_approval",
       "agent:stopped",
       "agent:ready",
-      "monitor:long_generating",
+      "monitor:no_progress",
       "refine:accepted",
       "refine:completed",
       "refine:failed",
@@ -10530,7 +10835,7 @@ var init_mesh_events_coordinator = __esm({
       "agent:generating_completed": "task_completed",
       "agent:waiting_approval": "task_approval_needed",
       "agent:stopped": "task_failed",
-      "monitor:long_generating": "task_stalled"
+      "monitor:no_progress": "task_stalled"
     };
     MESH_FORCE_INJECT_EVENTS = /* @__PURE__ */ new Set([
       "agent:generating_completed",
@@ -12678,7 +12983,7 @@ function resolveWin32GlobalBin(trimmed) {
     if (!dir) continue;
     for (const ext of WIN_EXEC_EXT) {
       const full = path18.join(dir, trimmed + ext);
-      if ((0, import_fs13.existsSync)(full)) return full;
+      if ((0, import_fs14.existsSync)(full)) return full;
     }
   }
   return null;
@@ -12687,7 +12992,7 @@ function resolveWin32Executable(command) {
   if (process.platform !== "win32") return command;
   const trimmed = (command || "").trim();
   if (!trimmed) return command;
-  if (path18.isAbsolute(trimmed) && (0, import_fs13.existsSync)(trimmed)) return trimmed;
+  if (path18.isAbsolute(trimmed) && (0, import_fs14.existsSync)(trimmed)) return trimmed;
   try {
     const out = (0, import_child_process4.execFileSync)("where", [trimmed], {
       encoding: "utf8",
@@ -12704,12 +13009,12 @@ function resolveWin32Executable(command) {
   if (globalBin) return globalBin;
   return command;
 }
-var import_child_process4, import_fs13, path18, DIRECT_EXEC_EXT, WIN_EXEC_EXT;
+var import_child_process4, import_fs14, path18, DIRECT_EXEC_EXT, WIN_EXEC_EXT;
 var init_resolve_executable = __esm({
   "src/cli-adapters/resolve-executable.ts"() {
     "use strict";
     import_child_process4 = require("child_process");
-    import_fs13 = require("fs");
+    import_fs14 = require("fs");
     path18 = __toESM(require("path"));
     DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
     WIN_EXEC_EXT = [".exe", ".com", ".cmd", ".bat"];
@@ -15677,7 +15982,7 @@ ${lastSnapshot}`;
         };
         if (parsedSessionStatus === "idle" && hasFinalAssistant(parsedStatusBeforeSend)) return null;
         if (this.engine.currentStatus === "generating") return "current_status_generating";
-        if (parsedSessionStatus === "generating" || parsedSessionStatus === "long_generating") {
+        if (parsedSessionStatus === "generating" || parsedSessionStatus === "no_progress" || parsedSessionStatus === "long_generating") {
           const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
           const parsedHasActionableModal = Boolean(
             parsedModal && Array.isArray(parsedModal.buttons) && parsedModal.buttons.some((candidate) => typeof candidate === "string" && candidate.trim())
@@ -15754,7 +16059,7 @@ ${lastSnapshot}`;
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === "string" ? String(parsedStatusBeforeSend.status) : "";
-        if (!allowInputDuringGeneration && (parsedSessionStatus === "generating" || parsedSessionStatus === "long_generating")) {
+        if (!allowInputDuringGeneration && (parsedSessionStatus === "generating" || parsedSessionStatus === "no_progress" || parsedSessionStatus === "long_generating")) {
           const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
           const parsedHasActionableModal = Boolean(
             parsedModal && Array.isArray(parsedModal.buttons) && parsedModal.buttons.some((candidate) => typeof candidate === "string" && candidate.trim())
@@ -17264,6 +17569,8 @@ __export(index_exports, {
   AcpProviderInstance: () => AcpProviderInstance,
   AgentStreamPoller: () => AgentStreamPoller,
   BUILTIN_CHAT_MESSAGE_KINDS: () => BUILTIN_CHAT_MESSAGE_KINDS,
+  CHANGE_IMPACT_CONFIG_LOCATIONS: () => CHANGE_IMPACT_CONFIG_LOCATIONS,
+  CHANGE_IMPACT_CONFIG_SCHEMA: () => CHANGE_IMPACT_CONFIG_SCHEMA,
   CHAT_MESSAGE_ACTIVITY_SOURCES: () => CHAT_MESSAGE_ACTIVITY_SOURCES,
   CHAT_MESSAGE_AUDIENCES: () => CHAT_MESSAGE_AUDIENCES,
   CHAT_MESSAGE_INTERNAL_SOURCES: () => CHAT_MESSAGE_INTERNAL_SOURCES,
@@ -17454,6 +17761,7 @@ __export(index_exports, {
   getSessionHostSurfaceKind: () => getSessionHostSurfaceKind,
   getSessionRecoveryContext: () => getSessionRecoveryContext,
   getWorkspaceState: () => getWorkspaceState,
+  globToRegExp: () => globToRegExp,
   handleGitCommand: () => handleGitCommand,
   hasCdpManager: () => hasCdpManager,
   hasPendingDependents: () => hasPendingDependents,
@@ -17487,6 +17795,7 @@ __export(index_exports, {
   listMeshMissionSummaries: () => listMeshMissionSummaries,
   listMeshes: () => listMeshes,
   listWorktrees: () => listWorktrees,
+  loadChangeImpactConfig: () => loadChangeImpactConfig,
   loadConfig: () => loadConfig,
   loadMeshCoordinatorRegistry: () => loadMeshCoordinatorRegistry,
   loadMeshRefineConfig: () => loadMeshRefineConfig,
@@ -17581,6 +17890,7 @@ __export(index_exports, {
   spawnDetachedDaemonUpgradeHelper: () => spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport: () => startDaemonDevSupport,
   startLocalIpcServer: () => startLocalIpcServer,
+  suggestChangeImpactConfig: () => suggestChangeImpactConfig,
   suggestMeshRefineConfig: () => suggestMeshRefineConfig,
   summarizeGitStatus: () => summarizeGitStatus,
   summarizeMeshAsyncRefineJobs: () => summarizeMeshAsyncRefineJobs,
@@ -17597,6 +17907,7 @@ __export(index_exports, {
   updateTaskStatus: () => updateTaskStatus,
   upsertMeshMission: () => upsertMeshMission,
   upsertSavedProviderSession: () => upsertSavedProviderSession,
+  validateChangeImpactConfig: () => validateChangeImpactConfig,
   validateCliProviderManifest: () => validateCliProviderManifest,
   validateFsmSpec: () => validateFsmSpec,
   validateMeshRefineConfig: () => validateMeshRefineConfig,
@@ -17966,6 +18277,7 @@ init_repo_mesh_types();
 // src/git/index.ts
 init_git_executor();
 init_git_status();
+init_change_impact_config();
 init_git_diff();
 
 // src/git/git-summary.ts
@@ -19259,18 +19571,18 @@ init_mesh_task_stats();
 init_mesh_review_inbox();
 
 // src/mesh/coordinator-registry.ts
-var import_path5 = require("path");
-var import_fs5 = require("fs");
+var import_path6 = require("path");
+var import_fs6 = require("fs");
 init_config();
 var _registry = /* @__PURE__ */ new Map();
 function getRegistryPath() {
-  return (0, import_path5.join)(getDaemonDataDir(), "mesh-coordinators.json");
+  return (0, import_path6.join)(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
   const path42 = getRegistryPath();
-  if (!(0, import_fs5.existsSync)(path42)) return;
+  if (!(0, import_fs6.existsSync)(path42)) return;
   try {
-    const raw = JSON.parse((0, import_fs5.readFileSync)(path42, "utf-8"));
+    const raw = JSON.parse((0, import_fs6.readFileSync)(path42, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -19283,7 +19595,7 @@ function loadMeshCoordinatorRegistry() {
 }
 function saveRegistry() {
   try {
-    (0, import_fs5.writeFileSync)(
+    (0, import_fs6.writeFileSync)(
       getRegistryPath(),
       JSON.stringify([..._registry.values()], null, 2),
       { encoding: "utf-8", mode: 384 }
@@ -19318,9 +19630,9 @@ function listCoordinatorsForWorkspace(workspace) {
 }
 
 // src/mesh/refine-config.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
-var yaml = __toESM(require("js-yaml"));
+var import_fs7 = require("fs");
+var import_path7 = require("path");
+var yaml2 = __toESM(require("js-yaml"));
 var MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
 var MESH_REFINE_CONFIG_LOCATIONS = [
   ".adhdev/refine.json",
@@ -19461,7 +19773,7 @@ function normalizeMeshCommandConfig(entry, source) {
     }
   };
 }
-var isRecord = isMeshConfigRecord;
+var isRecord2 = isMeshConfigRecord;
 function validateMeshRefineConfig(config, source = "inline") {
   const errors = [];
   const bootstrapCommands = [];
@@ -19469,14 +19781,14 @@ function validateMeshRefineConfig(config, source = "inline") {
   const rejectedCommands = [];
   const deprecationWarnings = [];
   let bootstrapMode = "inherit";
-  if (!isRecord(config)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
+  if (!isRecord2(config)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
   if (config.version !== 1) errors.push("version must be 1");
   if (config.allowAutoPublishSubmoduleMainCommits !== void 0 && typeof config.allowAutoPublishSubmoduleMainCommits !== "boolean") {
     errors.push("allowAutoPublishSubmoduleMainCommits must be a boolean when provided");
   }
   const validation = config.validation;
-  if (validation !== void 0 && !isRecord(validation)) errors.push("validation must be an object");
-  const rawBootstrapMode = isRecord(validation) ? validation.bootstrap : void 0;
+  if (validation !== void 0 && !isRecord2(validation)) errors.push("validation must be an object");
+  const rawBootstrapMode = isRecord2(validation) ? validation.bootstrap : void 0;
   if (rawBootstrapMode !== void 0) {
     if (rawBootstrapMode === "inherit" || rawBootstrapMode === "skip") {
       bootstrapMode = rawBootstrapMode;
@@ -19484,8 +19796,8 @@ function validateMeshRefineConfig(config, source = "inline") {
       errors.push("validation.bootstrap must be 'inherit' or 'skip' when provided");
     }
   }
-  const rawCommands = isRecord(validation) ? validation.commands : void 0;
-  const rawBootstrapCommands = isRecord(validation) ? validation.bootstrapCommands : void 0;
+  const rawCommands = isRecord2(validation) ? validation.commands : void 0;
+  const rawBootstrapCommands = isRecord2(validation) ? validation.bootstrapCommands : void 0;
   if (rawCommands !== void 0 && !Array.isArray(rawCommands)) errors.push("validation.commands must be an array");
   if (rawBootstrapCommands !== void 0 && !Array.isArray(rawBootstrapCommands)) errors.push("validation.bootstrapCommands must be an array");
   if (Array.isArray(rawBootstrapCommands) && rawBootstrapCommands.length > 0) {
@@ -19508,9 +19820,9 @@ function validateMeshRefineConfig(config, source = "inline") {
   if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
   return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
 }
-function parseConfigText(path42, text) {
+function parseConfigText2(path42, text) {
   if (/\.json$/i.test(path42)) return JSON.parse(text);
-  return yaml.load(text);
+  return yaml2.load(text);
 }
 function loadMeshRefineConfig(mesh, workspace) {
   const policy = mesh?.policy && typeof mesh.policy === "object" && !Array.isArray(mesh.policy) ? mesh.policy : {};
@@ -19521,10 +19833,10 @@ function loadMeshRefineConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
   }
   for (const relative5 of MESH_REFINE_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path6.join)(workspace, relative5);
-    if (!(0, import_fs6.existsSync)(configPath)) continue;
+    const configPath = (0, import_path7.join)(workspace, relative5);
+    if (!(0, import_fs7.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText(configPath, (0, import_fs6.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText2(configPath, (0, import_fs7.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshRefineConfig(parsed, relative5);
       if (!validation.valid) return { source: relative5, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative5, sourceType: "repo_file", path: configPath };
@@ -19540,20 +19852,20 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse((0, import_fs6.readFileSync)((0, import_path6.join)(workspace, "package.json"), "utf-8"));
-    return isRecord(parsed?.scripts) ? parsed.scripts : {};
+    const parsed = JSON.parse((0, import_fs7.readFileSync)((0, import_path7.join)(workspace, "package.json"), "utf-8"));
+    return isRecord2(parsed?.scripts) ? parsed.scripts : {};
   } catch {
     return {};
   }
 }
 function collectProjectContextSuggestions(mesh) {
   const commands = mesh?.projectContext?.commands;
-  if (!isRecord(commands)) return [];
+  if (!isRecord2(commands)) return [];
   const suggestions = [];
   for (const category of MESH_REFINE_VALIDATION_CATEGORIES) {
     const entries = Array.isArray(commands[category]) ? commands[category] : [];
     for (const entry of entries) {
-      if (isRecord(entry) && typeof entry.command === "string") suggestions.push({ command: entry.command, category });
+      if (isRecord2(entry) && typeof entry.command === "string") suggestions.push({ command: entry.command, category });
     }
   }
   return suggestions;
@@ -19617,12 +19929,12 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
 }
 
 // src/mesh/worktree-bootstrap-config.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var import_node_child_process3 = require("child_process");
 var import_node_crypto2 = require("crypto");
 var import_node_util3 = require("util");
-var yaml2 = __toESM(require("js-yaml"));
+var yaml3 = __toESM(require("js-yaml"));
 var MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
   ".adhdev/worktree_bootstrap.json",
   ".adhdev/worktree_bootstrap.yaml",
@@ -19667,9 +19979,9 @@ var MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA = {
 var DEFAULT_TIMEOUT_MS2 = 12e4;
 var DEFAULT_OUTPUT_LIMIT_BYTES = 128 * 1024;
 var OUTPUT_SUMMARY_CHARS = 2e3;
-function parseConfigText2(path42, text) {
+function parseConfigText3(path42, text) {
   if (/\.json$/i.test(path42)) return JSON.parse(text);
-  return yaml2.load(text);
+  return yaml3.load(text);
 }
 function truncateOutput(value) {
   const text = typeof value === "string" ? value : value == null ? "" : String(value);
@@ -19709,10 +20021,10 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.worktreeBootstrapConfig", sourceType: "mesh_policy" };
   }
   for (const relative5 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path7.join)(workspace, relative5);
-    if (!(0, import_fs7.existsSync)(configPath)) continue;
+    const configPath = (0, import_path8.join)(workspace, relative5);
+    if (!(0, import_fs8.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, (0, import_fs7.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText3(configPath, (0, import_fs8.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshWorktreeBootstrapConfig(parsed, relative5);
       if (!validation.valid) return { source: relative5, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative5, sourceType: "repo_file", path: configPath };
@@ -19725,9 +20037,9 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
 function computeStaleInputsDigest(workspace, staleInputs) {
   const digest = {};
   for (const relative5 of staleInputs ?? []) {
-    const filePath = (0, import_path7.join)(workspace, relative5);
+    const filePath = (0, import_path8.join)(workspace, relative5);
     try {
-      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs7.readFileSync)(filePath)).digest("hex");
+      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs8.readFileSync)(filePath)).digest("hex");
     } catch {
       digest[relative5] = "absent";
     }
@@ -19797,10 +20109,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs7.existsSync)((0, import_path7.join)(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs8.existsSync)((0, import_path8.join)(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs7.existsSync)((0, import_path7.join)(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs8.existsSync)((0, import_path8.join)(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -19808,7 +20120,7 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
         return state;
       }
     }
-    const cwd = command.cwd ? (0, import_path7.resolve)(workspace, command.cwd) : workspace;
+    const cwd = command.cwd ? (0, import_path8.resolve)(workspace, command.cwd) : workspace;
     const startedAt = Date.now();
     state.lastCommand = command.displayCommand;
     try {
@@ -20047,8 +20359,8 @@ var P2pRelayFailureError = class extends Error {
 };
 
 // src/config/state-store.ts
-var import_fs11 = require("fs");
-var import_path9 = require("path");
+var import_fs12 = require("fs");
+var import_path10 = require("path");
 init_config();
 var DEFAULT_STATE = {
   recentActivity: [],
@@ -20062,7 +20374,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path9.join)(getConfigDir(), "state.json");
+  return (0, import_path10.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -20098,11 +20410,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs11.existsSync)(statePath)) {
+  if (!(0, import_fs12.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs11.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs12.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -20111,7 +20423,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs11.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs12.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -20120,7 +20432,7 @@ function resetState() {
 // src/detection/ide-detector.ts
 var import_child_process2 = require("child_process");
 var import_util = require("util");
-var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var import_os2 = require("os");
 var path13 = __toESM(require("path"));
 
@@ -20201,7 +20513,7 @@ function findCliCommand(command) {
   if (path13.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path13.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path13.isAbsolute(candidate) ? candidate : path13.resolve(candidate);
-    return (0, import_fs12.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs13.existsSync)(resolved) ? resolved : null;
   }
   const isWin = (0, import_os2.platform)() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -20211,8 +20523,8 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path13.join(p, trimmed + ext);
       try {
-        if ((0, import_fs12.existsSync)(fullPath)) {
-          const stat2 = (0, import_fs12.statSync)(fullPath);
+        if ((0, import_fs13.existsSync)(fullPath)) {
+          const stat2 = (0, import_fs13.statSync)(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -20230,9 +20542,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs12.existsSync)(resolved)) return resolved;
+      if ((0, import_fs13.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs12.existsSync)(normalized)) return normalized;
+      if ((0, import_fs13.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -20246,7 +20558,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os30 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs12.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs13.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os30 === "win32") {
       const { dirname: dirname17 } = await import("path");
@@ -20259,7 +20571,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs12.existsSync)(c)) {
+        if ((0, import_fs13.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -21804,8 +22116,8 @@ init_contracts();
 // src/providers/status-monitor.ts
 var DEFAULT_MONITOR_CONFIG = {
   approvalAlert: true,
-  longGeneratingAlert: true,
-  longGeneratingThresholdSec: 180,
+  noProgressAlert: true,
+  noProgressThresholdSec: 180,
   // 3 minutes
   alertCooldownSec: 60
   // 1 minute cooldown
@@ -21814,7 +22126,7 @@ var StatusMonitor = class {
   config;
   lastAlertTime = /* @__PURE__ */ new Map();
   generatingStartTimes = /* @__PURE__ */ new Map();
-  longGeneratingAlerted = /* @__PURE__ */ new Map();
+  noProgressAlerted = /* @__PURE__ */ new Map();
   lastProgressFingerprint = /* @__PURE__ */ new Map();
   lastProgressChangeAt = /* @__PURE__ */ new Map();
   constructor(config) {
@@ -21832,7 +22144,7 @@ var StatusMonitor = class {
    * Check status transition → return notification event array.
    * Called from each onTick() or detectStatusTransition().
    */
-  check(agentKey, status, now, progressFingerprint) {
+  check(agentKey, status, now, progressFingerprint, approvalPending) {
     const events = [];
     if (this.config.approvalAlert && status === "waiting_approval") {
       if (this.shouldAlert(agentKey + ":approval", now)) {
@@ -21845,9 +22157,16 @@ var StatusMonitor = class {
       }
     }
     if (status === "generating" || status === "streaming") {
+      if (approvalPending) {
+        this.generatingStartTimes.set(agentKey, now);
+        this.lastProgressFingerprint.set(agentKey, progressFingerprint ?? "");
+        this.lastProgressChangeAt.set(agentKey, now);
+        this.noProgressAlerted.set(agentKey, false);
+        return events;
+      }
       if (!this.generatingStartTimes.has(agentKey)) {
         this.generatingStartTimes.set(agentKey, now);
-        this.longGeneratingAlerted.set(agentKey, false);
+        this.noProgressAlerted.set(agentKey, false);
         const initialFingerprint = progressFingerprint ?? "";
         this.lastProgressFingerprint.set(agentKey, initialFingerprint);
         this.lastProgressChangeAt.set(agentKey, now);
@@ -21857,17 +22176,17 @@ var StatusMonitor = class {
       if (previousFingerprint !== currentFingerprint) {
         this.lastProgressFingerprint.set(agentKey, currentFingerprint);
         this.lastProgressChangeAt.set(agentKey, now);
-        this.longGeneratingAlerted.set(agentKey, false);
+        this.noProgressAlerted.set(agentKey, false);
       }
-      if (this.config.longGeneratingAlert) {
+      if (this.config.noProgressAlert) {
         const progressChangedAt = this.lastProgressChangeAt.get(agentKey) || this.generatingStartTimes.get(agentKey);
         const elapsedSec = Math.round((now - progressChangedAt) / 1e3);
-        const alreadyAlerted = this.longGeneratingAlerted.get(agentKey) === true;
-        if (elapsedSec > this.config.longGeneratingThresholdSec && !alreadyAlerted) {
-          if (this.shouldAlert(agentKey + ":long_gen", now)) {
-            this.longGeneratingAlerted.set(agentKey, true);
+        const alreadyAlerted = this.noProgressAlerted.get(agentKey) === true;
+        if (elapsedSec > this.config.noProgressThresholdSec && !alreadyAlerted) {
+          if (this.shouldAlert(agentKey + ":no_progress", now)) {
+            this.noProgressAlerted.set(agentKey, true);
             events.push({
-              type: "monitor:long_generating",
+              type: "monitor:no_progress",
               agentKey,
               elapsedSec,
               timestamp: now,
@@ -21878,7 +22197,7 @@ var StatusMonitor = class {
       }
     } else {
       this.generatingStartTimes.delete(agentKey);
-      this.longGeneratingAlerted.delete(agentKey);
+      this.noProgressAlerted.delete(agentKey);
       this.lastProgressFingerprint.delete(agentKey);
       this.lastProgressChangeAt.delete(agentKey);
     }
@@ -21897,7 +22216,7 @@ var StatusMonitor = class {
   reset(agentKey) {
     if (agentKey) {
       this.generatingStartTimes.delete(agentKey);
-      this.longGeneratingAlerted.delete(agentKey);
+      this.noProgressAlerted.delete(agentKey);
       this.lastProgressFingerprint.delete(agentKey);
       this.lastProgressChangeAt.delete(agentKey);
       for (const k of this.lastAlertTime.keys()) {
@@ -21905,7 +22224,7 @@ var StatusMonitor = class {
       }
     } else {
       this.generatingStartTimes.clear();
-      this.longGeneratingAlerted.clear();
+      this.noProgressAlerted.clear();
       this.lastProgressFingerprint.clear();
       this.lastProgressChangeAt.clear();
       this.lastAlertTime.clear();
@@ -23728,8 +24047,8 @@ var ExtensionProviderInstance = class {
     this.settings = context.settings || {};
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
   }
   async onTick() {
@@ -23820,8 +24139,8 @@ var ExtensionProviderInstance = class {
     this.settings = { ...this.settings, ...newSettings };
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
   }
   /** Query UUID instanceId */
@@ -23881,7 +24200,8 @@ var ExtensionProviderInstance = class {
       phase: agentStatus === "idle" && (previousStatus === "generating" || previousStatus === "waiting_approval") ? "turn_completed" : "immediate"
     });
     const agentKey = `${this.type}:ext`;
-    const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
+    const approvalPending = agentStatus === "waiting_approval";
+    const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint, approvalPending);
     for (const me of monitorEvents) {
       this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
     }
@@ -24096,7 +24416,7 @@ init_contracts();
 var CHAT_CONTRACT_VERSION_V1 = "1.0";
 
 // src/providers/read-chat-contract.ts
-var VALID_STATUSES = ["idle", "generating", "waiting_approval", "error", "panel_hidden", "starting", "streaming", "long_generating"];
+var VALID_STATUSES = ["idle", "generating", "waiting_approval", "error", "panel_hidden", "starting", "streaming", "no_progress", "long_generating"];
 var VALID_ROLES = ["user", "assistant", "system", "human"];
 var VALID_BUBBLE_STATES = ["draft", "streaming", "final", "removed"];
 var VALID_TURN_STATUSES = ["open", "waiting_approval", "complete", "error"];
@@ -24363,8 +24683,8 @@ var IdeProviderInstance = class {
     this.settings = context.settings || {};
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
   }
   async onTick() {
@@ -24491,8 +24811,8 @@ var IdeProviderInstance = class {
     this.settings = { ...this.settings, ...newSettings };
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
   }
   // ─── Extension manage ─────────────────────────────
@@ -24623,7 +24943,7 @@ var IdeProviderInstance = class {
       const persistedMessages = chat.messages || messages;
       if (persistedMessages.length > 0) {
         let toSave = persistedMessages;
-        if (chat.status === "generating" || chat.status === "long_generating") {
+        if (chat.status === "generating" || chat.status === "no_progress" || chat.status === "long_generating") {
           const lastIdx = toSave.length - 1;
           if (lastIdx >= 0 && toSave[lastIdx].role === "assistant") {
             toSave = toSave.slice(0, lastIdx);
@@ -24693,7 +25013,8 @@ var IdeProviderInstance = class {
     if (rawAgentStatus === "waiting_approval" && autoApproveActive && !this.autoApproveBusy) {
       this.autoApproveViaScript(chatData);
     }
-    const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
+    const approvalPending = rawAgentStatus === "waiting_approval";
+    const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint, approvalPending);
     for (const me of monitorEvents) {
       this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
     }
@@ -27250,7 +27571,7 @@ function normalizeReadChatCommandStatus(status, activeModal) {
   }
 }
 function isGeneratingLikeStatus(status) {
-  return status === "generating" || status === "streaming" || status === "long_generating" || status === "starting";
+  return status === "generating" || status === "streaming" || status === "no_progress" || status === "long_generating" || status === "starting";
 }
 function hasVisibleAssistantMessage(messages) {
   if (!Array.isArray(messages)) return false;
@@ -31283,7 +31604,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
 var os19 = __toESM(require("os"));
 var path26 = __toESM(require("path"));
 var crypto5 = __toESM(require("crypto"));
-var import_fs14 = require("fs");
+var import_fs15 = require("fs");
 var import_child_process6 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
@@ -33928,7 +34249,7 @@ function hasNonEmptyCliModalButtons(activeModal) {
   return Array.isArray(buttons) && buttons.some((button) => String(button || "").trim().length > 0);
 }
 function isCliGeneratingLikeStatus(status) {
-  return status === "generating" || status === "streaming" || status === "long_generating" || status === "starting";
+  return status === "generating" || status === "streaming" || status === "no_progress" || status === "long_generating" || status === "starting";
 }
 function buildCliStructuredInputPrompt(input, options = {}) {
   const promptParts = [];
@@ -34130,8 +34451,8 @@ var CliProviderInstance = class _CliProviderInstance {
     this.adapter.updateRuntimeSettings?.(this.settings);
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
     if (context.serverConn) {
       this.adapter.setServerConn(context.serverConn);
@@ -34278,7 +34599,7 @@ var CliProviderInstance = class _CliProviderInstance {
     if (parsedMessages.length > 0) {
       const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
       let messagesToSave = parsedMessages;
-      if (!suppressStaleParsedBusyStatus && (parsedChatStatus === "generating" || parsedChatStatus === "long_generating")) {
+      if (!suppressStaleParsedBusyStatus && (parsedChatStatus === "generating" || parsedChatStatus === "no_progress" || parsedChatStatus === "long_generating")) {
         const lastIdx = messagesToSave.length - 1;
         if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === "assistant") {
           messagesToSave = messagesToSave.slice(0, lastIdx);
@@ -34406,8 +34727,8 @@ var CliProviderInstance = class _CliProviderInstance {
     this.adapter.updateRuntimeSettings?.(this.settings);
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
   }
   /**
@@ -35139,10 +35460,11 @@ var CliProviderInstance = class _CliProviderInstance {
       phase: newStatus === "idle" && (previousStatus === "generating" || previousStatus === "waiting_approval") ? "turn_completed" : "immediate"
     });
     const agentKey = `${this.type}:cli`;
-    const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+    const approvalPending = rawStatus === "waiting_approval";
+    const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint, approvalPending);
     const monitorParsedStatus = parsedStatus;
     for (const me of monitorEvents) {
-      if (me.type === "monitor:long_generating" && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages) && !this.hasAdapterPendingResponse() && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)) {
+      if (me.type === "monitor:no_progress" && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages) && !this.hasAdapterPendingResponse() && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)) {
         this.pushEvent({
           event: "agent:generating_completed",
           chatTitle,
@@ -35153,7 +35475,7 @@ var CliProviderInstance = class _CliProviderInstance {
             providerType: this.type,
             sessionId: this.instanceId,
             providerSessionId: this.providerSessionId || null,
-            reconciliationReason: "long_generating_monitor_final_summary",
+            reconciliationReason: "no_progress_monitor_final_summary",
             finalAssistantPresent: true
           }
         });
@@ -35830,8 +36152,8 @@ var AcpProviderInstance = class {
     this.settings = context.settings || {};
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
     await this.spawnAgent();
   }
@@ -36127,8 +36449,8 @@ var AcpProviderInstance = class {
     this.settings = { ...this.settings, ...newSettings };
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
-      longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-      longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+      noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+      noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180
     });
     this.log.info(`[${this.type}] Settings updated: ${Object.keys(newSettings).join(", ")}`);
   }
@@ -36835,7 +37157,8 @@ ${rawInput}` : rawInput;
       this.lastStatus = newStatus;
     }
     const agentKey = `${this.type}:acp`;
-    const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+    const approvalPending = newStatus === "waiting_approval";
+    const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint, approvalPending);
     for (const me of monitorEvents) {
       this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
     }
@@ -36897,7 +37220,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs14.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs15.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -36909,7 +37232,7 @@ function commandExists(command) {
     return false;
   }
 }
-var BUSY_AGENT_STATUSES = /* @__PURE__ */ new Set(["generating", "running", "streaming", "starting", "busy", "waiting", "waiting_approval", "long_generating"]);
+var BUSY_AGENT_STATUSES = /* @__PURE__ */ new Set(["generating", "running", "streaming", "starting", "busy", "waiting", "waiting_approval", "no_progress", "long_generating"]);
 var ZERO_MESSAGE_STARTING_SEND_WAIT_MS = 2e3;
 function normalizeAgentStatus(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -37033,10 +37356,10 @@ function hasConfigOverride(args, key) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path26.join(os19.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  (0, import_fs14.mkdirSync)(baseDir, { recursive: true });
+  (0, import_fs15.mkdirSync)(baseDir, { recursive: true });
   const workspaceHash = crypto5.createHash("sha256").update(path26.resolve(workspace || os19.tmpdir())).digest("hex").slice(0, 16);
   const filePath = path26.join(baseDir, `${workspaceHash}.json`);
-  (0, import_fs14.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  (0, import_fs15.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -41774,6 +42097,7 @@ function getAvailableIdeIds() {
 init_config();
 init_cli_detector();
 init_git_status();
+init_change_impact_config();
 init_dist();
 init_logger();
 
@@ -41922,7 +42246,7 @@ function getRecentCommands(count = 50) {
 cleanOldFiles();
 
 // src/commands/router.ts
-var yaml3 = __toESM(require("js-yaml"));
+var yaml4 = __toESM(require("js-yaml"));
 init_logger();
 
 // src/logging/log-tail-reader.ts
@@ -42308,8 +42632,8 @@ function buildPreviewFreshness(repoRoot) {
 init_mesh_refine_status();
 
 // src/mesh/mesh-init.ts
-var import_fs15 = require("fs");
-var import_path10 = require("path");
+var import_fs16 = require("fs");
+var import_path11 = require("path");
 var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
 var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
 var CANDIDATE_STALE_INPUTS = [
@@ -42323,22 +42647,22 @@ var CANDIDATE_STALE_INPUTS = [
   "requirements.txt"
 ];
 function writeConfigFile(workspace, relativePath, config) {
-  const target = (0, import_path10.join)(workspace, relativePath);
-  (0, import_fs15.mkdirSync)((0, import_path10.dirname)(target), { recursive: true });
-  (0, import_fs15.writeFileSync)(target, `${JSON.stringify(config, null, 2)}
+  const target = (0, import_path11.join)(workspace, relativePath);
+  (0, import_fs16.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
+  (0, import_fs16.writeFileSync)(target, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
   return target;
 }
 function suggestMeshWorktreeBootstrapConfig(workspace) {
   const commands = [];
-  const hasPackageJson = (0, import_fs15.existsSync)((0, import_path10.join)(workspace, "package.json"));
-  const hasNpmLock = (0, import_fs15.existsSync)((0, import_path10.join)(workspace, "package-lock.json"));
+  const hasPackageJson = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package.json"));
+  const hasNpmLock = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
   if (hasPackageJson) {
     commands.push(
       hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
     );
   }
-  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => (0, import_fs15.existsSync)((0, import_path10.join)(workspace, relative5)));
+  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => (0, import_fs16.existsSync)((0, import_path11.join)(workspace, relative5)));
   if (!commands.length) {
     return { commands, staleInputs };
   }
@@ -42406,7 +42730,7 @@ function runMeshInit(mesh, workspace, detected, options = {}) {
 }
 function applyConfigSuggestion(input) {
   const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-  const absolute = (0, import_path10.join)(workspace, relativePath);
+  const absolute = (0, import_path11.join)(workspace, relativePath);
   if (existing !== void 0 && !overwrite) {
     return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
   }
@@ -43131,7 +43455,7 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 init_mesh_work_queue();
 init_repo_mesh_types();
 var import_os3 = require("os");
-var import_path11 = require("path");
+var import_path12 = require("path");
 var fs26 = __toESM(require("fs"));
 var import_node_child_process6 = require("child_process");
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
@@ -44604,14 +44928,14 @@ function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
     const baseCommit = readTreeObject(repoRoot, baseHead, path42);
     const branchCommit = readTreeObject(repoRoot, branchHead, path42);
     if (!baseCommit || !branchCommit) return false;
-    return isSubmoduleFastForward((0, import_path11.resolve)(repoRoot, path42), baseCommit, branchCommit);
+    return isSubmoduleFastForward((0, import_path12.resolve)(repoRoot, path42), baseCommit, branchCommit);
   });
 }
 function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
   const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path42) => {
     const baseCommit = readTreeObject(repoRoot, baseHead, path42);
     const branchCommit = readTreeObject(repoRoot, branchHead, path42);
-    const submoduleRepoPath = (0, import_path11.resolve)(repoRoot, path42);
+    const submoduleRepoPath = (0, import_path12.resolve)(repoRoot, path42);
     const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
     return { path: path42, baseCommit, branchCommit, fastForward };
   });
@@ -44666,7 +44990,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
     if (!tree) return void 0;
     const updates = paths.map((path42) => `160000 commit ${placeholderCommit}	${path42}`).join("\n");
     if (!updates) return tree;
-    const tmpIndex = (0, import_path11.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+    const tmpIndex = (0, import_path12.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
       (0, import_node_child_process6.execFileSync)("git", ["read-tree", tree], { cwd: repoRoot, env, stdio: "ignore" });
@@ -44741,7 +45065,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
     if (!contentTree) return void 0;
     const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
     if (!updates) return contentTree;
-    const tmpIndex = (0, import_path11.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+    const tmpIndex = (0, import_path12.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
       (0, import_node_child_process6.execFileSync)("git", ["read-tree", contentTree], { cwd: repoRoot, env, stdio: "ignore" });
@@ -44879,7 +45203,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return match ? { commit: match[1], path: match[2] } : null;
     }).filter((entry) => !!entry);
     for (const gitlink of gitlinks) {
-      const submodulePath = (0, import_path11.resolve)(repoRoot, gitlink.path);
+      const submodulePath = (0, import_path12.resolve)(repoRoot, gitlink.path);
       const entry = {
         path: gitlink.path,
         commit: gitlink.commit,
@@ -44907,7 +45231,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             try {
               const imported = await importCommitFromWorktreeSubmodule(
                 submodulePath,
-                (0, import_path11.resolve)(options.worktreeRoot, gitlink.path),
+                (0, import_path12.resolve)(options.worktreeRoot, gitlink.path),
                 gitlink.commit
               );
               if (imported) {
@@ -45119,19 +45443,19 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     ...extras
   });
   const isPackageManagerValidation = (candidate) => {
-    const command = (0, import_path11.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+    const command = (0, import_path12.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs26.existsSync((0, import_path11.join)(cwd, "package.json"))) return false;
-    if (fs26.existsSync((0, import_path11.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs26.existsSync((0, import_path11.join)(cwd, lock)));
+    if (!fs26.existsSync((0, import_path12.join)(cwd, "package.json"))) return false;
+    if (fs26.existsSync((0, import_path12.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs26.existsSync((0, import_path12.join)(cwd, lock)));
   };
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
     for (const candidate of selection.bootstrapCommands) {
       const startedAt = Date.now();
-      const cwd = candidate.cwd ? (0, import_path11.resolve)(workspace, candidate.cwd) : workspace;
+      const cwd = candidate.cwd ? (0, import_path12.resolve)(workspace, candidate.cwd) : workspace;
       const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
       try {
         const result = await execFileAsync4(candidate.command, candidate.args, {
@@ -45159,7 +45483,7 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path11.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path12.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
     if (!bootstrapProvidedDependencies && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
@@ -45205,7 +45529,7 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
   return summary;
 }
 function loadYamlModule() {
-  return yaml3;
+  return yaml4;
 }
 function getMcpServersKey(format) {
   return format === "hermes_config_yaml" ? "mcp_servers" : "mcpServers";
@@ -45222,13 +45546,13 @@ function serializeMeshCoordinatorMcpConfig(config, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path11.join)((0, import_os3.homedir)(), ".hermes");
+  return explicitHome || (0, import_path12.join)((0, import_os3.homedir)(), ".hermes");
 }
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
-  const sourceConfigPath = (0, import_path11.join)(sourceHome, "config.yaml");
+  const sourceConfigPath = (0, import_path12.join)(sourceHome, "config.yaml");
   if (!fs26.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if ((0, import_path11.resolve)(sourceConfigPath) === (0, import_path11.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if ((0, import_path12.resolve)(sourceConfigPath) === (0, import_path12.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   const parsed = parseMeshCoordinatorMcpConfig(fs26.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -45262,10 +45586,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if ((0, import_path11.resolve)(sourceHome) === (0, import_path11.resolve)(targetHome)) return;
+  if ((0, import_path12.resolve)(sourceHome) === (0, import_path12.resolve)(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
-    const sourcePath = (0, import_path11.join)(sourceHome, fileName);
-    const targetPath = (0, import_path11.join)(targetHome, fileName);
+    const sourcePath = (0, import_path12.join)(sourceHome, fileName);
+    const targetPath = (0, import_path12.join)(targetHome, fileName);
     if (!fs26.existsSync(sourcePath)) continue;
     try {
       fs26.copyFileSync(sourcePath, targetPath);
@@ -45767,7 +46091,7 @@ var DaemonCommandRouter = class {
     }
     const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
     const normalizePath = (value) => {
-      const resolved = (0, import_path11.resolve)(value);
+      const resolved = (0, import_path12.resolve)(value);
       try {
         return fs26.realpathSync(resolved);
       } catch {
@@ -48947,6 +49271,42 @@ ${hintLines.join("\n")}` : "",
           note: "Suggestions are heuristic scaffold only; Refinery will not execute them until saved into repo mesh/refine config."
         };
       }
+      case "get_mesh_change_impact_config_schema": {
+        return {
+          success: true,
+          schema: CHANGE_IMPACT_CONFIG_SCHEMA,
+          locations: CHANGE_IMPACT_CONFIG_LOCATIONS,
+          sourceOfTruth: "repo change-impact config",
+          heuristicRole: "suggestions_only_not_execution_path",
+          note: "Declarative config only \u2014 JSON/YAML are parsed but never executed. Defines which package/file changes require a daemon rebuild/restart vs. a web-only redeploy vs. nothing."
+        };
+      }
+      case "validate_mesh_change_impact_config": {
+        const workspace = typeof args?.workspace === "string" ? args.workspace : process.cwd();
+        if (args?.config !== void 0) {
+          const validation = validateChangeImpactConfig(args.config, "inline");
+          return { success: validation.valid, source: "inline", sourceType: "mesh_policy", ...validation };
+        }
+        const loaded = loadChangeImpactConfig(workspace);
+        if (loaded.sourceType === "repo_file") {
+          const validation = validateChangeImpactConfig(loaded.config, loaded.source);
+          return { success: validation.valid, ...loaded, ...validation };
+        }
+        return {
+          success: false,
+          ...loaded,
+          valid: false,
+          errors: [loaded.error || "repo change-impact config unavailable"]
+        };
+      }
+      case "suggest_mesh_change_impact_config": {
+        const workspace = typeof args?.workspace === "string" ? args.workspace : process.cwd();
+        return {
+          success: true,
+          ...suggestChangeImpactConfig(workspace),
+          note: "Suggestions are heuristic scaffold only; the draft must be reviewed and saved into repo change-impact config before it takes effect. Nothing is executed."
+        };
+      }
       case "mesh_init": {
         const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
         const mesh = args?.inlineMesh || {};
@@ -49738,7 +50098,7 @@ ${ptyResult.output.slice(-2e3)}`);
               };
             }
             if (cliType === "codex-cli") {
-              const repoMcpConfigPath = (0, import_path11.join)(workspace, ".mcp.json");
+              const repoMcpConfigPath = (0, import_path12.join)(workspace, ".mcp.json");
               if (fs26.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
@@ -49863,7 +50223,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync45, readFileSync: readFileSync36, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+          const { existsSync: existsSync46, readFileSync: readFileSync37, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
           const { dirname: dirname17 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -49906,14 +50266,14 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync45(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync46(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname17(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync36(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync37(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -50412,7 +50772,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync45 } = await import("fs");
+          const { existsSync: existsSync46 } = await import("fs");
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -50431,7 +50791,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync45(workspace)) continue;
+            if (!workspace || !existsSync46(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -50605,7 +50965,7 @@ var DaemonStatusReporter = class {
       case "agent:waiting_approval":
       case "agent:generating_completed":
       case "agent:stopped":
-      case "monitor:long_generating":
+      case "monitor:no_progress":
         return value;
       default:
         return null;
@@ -51150,7 +51510,7 @@ var ProviderStreamAdapter = class {
       }
       const validated = validateReadChatResultPayload(data, `${this.agentType} readChat`);
       const validatedStatus = validated.status;
-      const streamStatus = validatedStatus === "generating" || validatedStatus === "long_generating" ? "streaming" : validatedStatus;
+      const streamStatus = validatedStatus === "generating" || validatedStatus === "no_progress" || validatedStatus === "long_generating" ? "streaming" : validatedStatus;
       const state = {
         agentType: this.agentType,
         agentName: this.agentName,
@@ -59069,6 +59429,8 @@ var V1_CONTRACT_VERSION = "1.0.0";
   AcpProviderInstance,
   AgentStreamPoller,
   BUILTIN_CHAT_MESSAGE_KINDS,
+  CHANGE_IMPACT_CONFIG_LOCATIONS,
+  CHANGE_IMPACT_CONFIG_SCHEMA,
   CHAT_MESSAGE_ACTIVITY_SOURCES,
   CHAT_MESSAGE_AUDIENCES,
   CHAT_MESSAGE_INTERNAL_SOURCES,
@@ -59259,6 +59621,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   getSessionHostSurfaceKind,
   getSessionRecoveryContext,
   getWorkspaceState,
+  globToRegExp,
   handleGitCommand,
   hasCdpManager,
   hasPendingDependents,
@@ -59292,6 +59655,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   listMeshMissionSummaries,
   listMeshes,
   listWorktrees,
+  loadChangeImpactConfig,
   loadConfig,
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
@@ -59386,6 +59750,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport,
   startLocalIpcServer,
+  suggestChangeImpactConfig,
   suggestMeshRefineConfig,
   summarizeGitStatus,
   summarizeMeshAsyncRefineJobs,
@@ -59402,6 +59767,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   updateTaskStatus,
   upsertMeshMission,
   upsertSavedProviderSession,
+  validateChangeImpactConfig,
   validateCliProviderManifest,
   validateFsmSpec,
   validateMeshRefineConfig,