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

package/dist/index.mjs

@@ -308,10 +308,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "993e3922de8abe554822450e2b4c26c2c9f5f64a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "993e3922" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.327" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-19T12:31:25.870Z" : 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;
 }
@@ -322,6 +322,247 @@ var init_build_info = __esm({
   }
 });
 
+// src/git/change-impact-config.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import * as yaml from "js-yaml";
+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 = join(repoRoot, relative5);
+    if (!existsSync(configPath)) continue;
+    try {
+      const text = readFileSync(configPath, "utf-8");
+      let mtimeMs = 0;
+      try {
+        mtimeMs = 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 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", join("oss", "packages")];
+  for (const rel of roots) {
+    const packagesRoot = join(repoRoot, rel);
+    if (!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 CHANGE_IMPACT_CONFIG_LOCATIONS, CHANGE_IMPACT_CONFIG_SCHEMA;
+var init_change_impact_config = __esm({
+  "src/git/change-impact-config.ts"() {
+    "use strict";
+    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";
@@ -397,16 +638,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);
@@ -418,21 +677,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 }
   ];
@@ -446,11 +731,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.`;
@@ -461,6 +750,8 @@ async function detectDaemonBuildBehind(repo, submodules, options) {
         scope,
         isDaemonAffecting,
         ...affectedPackages && affectedPackages.length > 0 ? { affectedPackages } : {},
+        recommendedAction: kind,
+        recommendedCommand: target.recommendedCommand,
         warning
       };
     } catch {
@@ -724,14 +1015,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",
@@ -741,13 +1035,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."
+      }
+    };
   }
 });
 
@@ -1035,7 +1340,7 @@ __export(git_worktree_exports, {
 });
 import * as path4 from "path";
 import { mkdir } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 function resolveWorktreePath(repoRoot, meshName, branch) {
@@ -1047,7 +1352,7 @@ function resolveWorktreePath(repoRoot, meshName, branch) {
 async function createWorktree(opts) {
   const { repoRoot, branch, baseBranch, meshName } = opts;
   const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
-  if (existsSync(targetDir)) {
+  if (existsSync2(targetDir)) {
     throw new Error(`Worktree target directory already exists: ${targetDir}`);
   }
   await mkdir(path4.dirname(targetDir), { recursive: true });
@@ -1066,7 +1371,7 @@ async function createWorktree(opts) {
   } catch (error) {
     const stderr = typeof error.stderr === "string" ? error.stderr : "";
     if (/already exists/i.test(stderr)) {
-      if (existsSync(targetDir)) {
+      if (existsSync2(targetDir)) {
         throw new Error(`Worktree target directory was created concurrently: ${targetDir}`);
       }
       throw new Error(`Branch '${branch}' already exists or is checked out in another worktree`);
@@ -1080,7 +1385,7 @@ async function createWorktree(opts) {
   };
 }
 async function removeWorktree(repoRoot, worktreePath, opts = {}) {
-  if (!existsSync(worktreePath)) {
+  if (!existsSync2(worktreePath)) {
     await pruneWorktrees(repoRoot);
     return { success: true, removedPath: worktreePath };
   }
@@ -1214,8 +1519,8 @@ __export(config_exports, {
   updateConfig: () => updateConfig
 });
 import { homedir } from "os";
-import { join as join2 } from "path";
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync, chmodSync } from "fs";
 import { randomUUID } from "crypto";
 function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
   if (providerSourceMode === "normal" || providerSourceMode === "no-upstream") {
@@ -1310,25 +1615,25 @@ function ensureMachineId(config) {
 }
 function getConfigDir() {
   const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : join2(homedir(), ".adhdev");
-  if (!existsSync2(dir)) {
+  const dir = override && override.trim() ? override.trim() : join3(homedir(), ".adhdev");
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getDaemonDataDir() {
-  const dir = join2(getConfigDir(), "daemon");
-  if (!existsSync2(dir)) {
+  const dir = join3(getConfigDir(), "daemon");
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getConfigPath() {
-  return join2(getConfigDir(), "config.json");
+  return join3(getConfigDir(), "config.json");
 }
 function migrateStateToStateFile(raw) {
-  const statePath = join2(getConfigDir(), "state.json");
-  if (existsSync2(statePath)) return;
+  const statePath = join3(getConfigDir(), "state.json");
+  if (existsSync3(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 : {};
@@ -1352,7 +1657,7 @@ function migrateStateToStateFile(raw) {
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
     try {
       saveConfig(initialized.config);
@@ -1361,7 +1666,7 @@ function loadConfig() {
     return initialized.config;
   }
   try {
-    const raw = readFileSync(configPath, "utf-8");
+    const raw = readFileSync2(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
@@ -1383,7 +1688,7 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
   const normalized = normalizeConfig(config);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
   writeFileSync(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
@@ -1535,17 +1840,17 @@ __export(mesh_config_exports, {
   updateMesh: () => updateMesh,
   updateNode: () => updateNode
 });
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 import { createHash, randomBytes, randomUUID as randomUUID3 } from "crypto";
 function getMeshConfigPath() {
-  return join4(getConfigDir(), "meshes.json");
+  return join5(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
   const path42 = getMeshConfigPath();
-  if (!existsSync4(path42)) return { meshes: [] };
+  if (!existsSync5(path42)) return { meshes: [] };
   try {
-    const raw = JSON.parse(readFileSync2(path42, "utf-8"));
+    const raw = JSON.parse(readFileSync3(path42, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -2248,8 +2553,8 @@ __export(mesh_ledger_exports, {
   readLedgerSlice: () => readLedgerSlice,
   readLedgerSliceFromStore: () => readLedgerSliceFromStore
 });
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync as statSync2, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -2258,35 +2563,35 @@ 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 = join6(getConfigDir(), LEDGER_DIR_NAME);
-  if (!existsSync5(dir)) {
+  const dir = join7(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync6(dir)) {
     mkdirSync3(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.jsonl`);
+  return join7(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join7(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.archive.jsonl`);
+  return join7(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return join7(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.archived-counts.json`);
+  return join7(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while (existsSync5(getRotatedArchivePath(meshId, index))) {
+  while (existsSync6(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
@@ -2300,9 +2605,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path42 = getArchivedCountsPath(meshId);
-  if (!existsSync5(path42)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!existsSync6(path42)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse(readFileSync4(path42, "utf-8"));
+    return JSON.parse(readFileSync5(path42, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -2341,7 +2646,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync5(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!existsSync6(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -2356,7 +2661,7 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if (existsSync5(archivePath) && statSync2(archivePath).size > 50 * 1024 * 1024) {
+    if (existsSync6(archivePath) && statSync3(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
@@ -2506,9 +2811,9 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if (existsSync5(filePath)) {
+  if (existsSync6(filePath)) {
     try {
-      const stat2 = statSync2(filePath);
+      const stat2 = statSync3(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
         rotateLedgerFile(meshId, filePath);
       } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -2604,10 +2909,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync5(filePath)) return [];
+  if (!existsSync6(filePath)) return [];
   let content;
   try {
-    content = readFileSync4(filePath, "utf-8");
+    content = readFileSync5(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -2868,7 +3173,7 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while (existsSync5(getRotatedPath(meshId, index))) {
+  while (existsSync6(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
@@ -3539,8 +3844,8 @@ var init_mesh_work_queue = __esm({
 });
 
 // src/mesh/mesh-runtime-store.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync2, statSync as statSync3 } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync2, statSync as statSync4 } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
 import { createRequire } from "module";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
@@ -3552,19 +3857,19 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return join7(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return join8(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
-  const nextPath = join7(dir, "mesh-runtime.db");
-  if (existsSync6(nextPath)) return nextPath;
-  const legacyPath = join7(dir, "beads.db");
-  if (!existsSync6(legacyPath)) return nextPath;
+  const nextPath = join8(dir, "mesh-runtime.db");
+  if (existsSync7(nextPath)) return nextPath;
+  const legacyPath = join8(dir, "beads.db");
+  if (!existsSync7(legacyPath)) return nextPath;
   try {
     renameSync2(legacyPath, nextPath);
     for (const suffix of ["-wal", "-shm"]) {
       const legacyCompanion = `${legacyPath}${suffix}`;
-      if (existsSync6(legacyCompanion)) {
+      if (existsSync7(legacyCompanion)) {
         renameSync2(legacyCompanion, `${nextPath}${suffix}`);
       }
     }
@@ -3590,7 +3895,7 @@ var init_mesh_runtime_store = __esm({
       // 50 MB
       constructor(dbPath) {
         const dir = dirname2(dbPath);
-        if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+        if (!existsSync7(dir)) mkdirSync4(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -3845,8 +4150,8 @@ var init_mesh_runtime_store = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!existsSync6(walPath)) return;
-          const size = statSync3(walPath).size;
+          if (!existsSync7(walPath)) return;
+          const size = statSync4(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
@@ -3862,9 +4167,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 (!existsSync6(path42)) return;
+        if (!existsSync7(path42)) return;
         try {
-          const entries = JSON.parse(readFileSync5(path42, "utf-8"));
+          const entries = JSON.parse(readFileSync6(path42, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -5705,10 +6010,10 @@ __export(mesh_coordinator_exports, {
   stripCoordinatorWrapperFile: () => stripCoordinatorWrapperFile
 });
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import * as os4 from "os";
 import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from "@adhdev/session-host-core";
-import { basename as basename2, isAbsolute as isAbsolute4, join as join9, resolve as resolve7 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute4, join as join10, resolve as resolve7 } from "path";
 function isHermesProvider(provider, cliType) {
   const type = cliType?.trim() || provider?.type?.trim() || "";
   return type === HERMES_CLI_TYPE;
@@ -5728,7 +6033,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join9(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join10(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -5875,14 +6180,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve7(workspace || os4.tmpdir())}`;
   const hash = createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  return join9(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join10(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os4.homedir();
-  if (trimmed.startsWith("~/")) return join9(os4.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join10(os4.homedir(), trimmed.slice(2));
   if (isAbsolute4(trimmed)) return trimmed;
-  return join9(workspace, trimmed);
+  return join10(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const directEntryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -5953,7 +6258,7 @@ function applyInjectionRule(systemPrompt, injection, ctx) {
     }
     case "context_file": {
       if (!injection.path) return {};
-      const target = isAbsolute4(injection.path) ? injection.path : join9(ctx.workspace, injection.path);
+      const target = isAbsolute4(injection.path) ? injection.path : join10(ctx.workspace, injection.path);
       const wrapper = injection.wrapper && injection.wrapper.includes("{prompt}") ? injection.wrapper : "{prompt}";
       const managedNote = "> _Managed by adhdev mesh coordinator \u2014 do not hand-edit this block. Changes inside the sentinels are overwritten on next coordinator launch._";
       const promptWithNote = `${managedNote}
@@ -5962,8 +6267,8 @@ ${systemPrompt}`;
       const rendered = wrapper.replace(/\{prompt\}/g, promptWithNote);
       const sentinel = wrapper.split("{prompt}")[0].trim();
       try {
-        if (existsSync8(target)) {
-          const existing = readFileSync6(target, "utf-8");
+        if (existsSync9(target)) {
+          const existing = readFileSync7(target, "utf-8");
           if (sentinel && existing.includes(sentinel)) {
             const closing = wrapper.split("{prompt}")[1]?.trim();
             const safeOpen = sentinel.replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -5993,8 +6298,8 @@ function stripCoordinatorWrapperFile(filePath) {
   const OPEN = "<!-- adhdev-mesh-coordinator-prompt -->";
   const CLOSE = "<!-- /adhdev-mesh-coordinator-prompt -->";
   try {
-    if (!existsSync8(filePath)) return;
-    const existing = readFileSync6(filePath, "utf-8");
+    if (!existsSync9(filePath)) return;
+    const existing = readFileSync7(filePath, "utf-8");
     const openIdx = existing.indexOf(OPEN);
     if (openIdx < 0) return;
     const closeIdx = existing.indexOf(CLOSE, openIdx);
@@ -6970,6 +7275,410 @@ var init_dist = __esm({
   }
 });
 
+// src/mesh/mesh-active-work.ts
+function readString6(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function summarizeMessage(message) {
+  const oneLine2 = message.replace(/\s+/g, " ").trim();
+  const title = oneLine2.length > 96 ? `${oneLine2.slice(0, 93)}...` : oneLine2;
+  return { title: title || "(untitled task)", summary: oneLine2 };
+}
+function elapsedSince(value, now) {
+  const started = value ? new Date(value).getTime() : Number.NaN;
+  return Number.isFinite(started) ? Math.max(0, now - started) : 0;
+}
+function sessionStatusFromNodes(nodes, nodeId, sessionId) {
+  if (!Array.isArray(nodes)) return {};
+  if (!nodeId) return { staleReason: "direct task has no node id" };
+  const node = nodes.find((item) => meshNodeIdMatches(item, nodeId));
+  if (!node) return { staleReason: "direct task node is no longer in the live mesh" };
+  if (!sessionId) return {};
+  const candidates = [];
+  for (const value of [
+    node.sessions,
+    node.activeSessions,
+    node.active_sessions,
+    node.activeSessionDetails,
+    node.active_session_details,
+    node.sessionDetails,
+    node.session_details,
+    node.lastProbe?.sessions,
+    node.last_probe?.sessions,
+    node.lastProbe?.status?.sessions,
+    node.last_probe?.status?.sessions
+  ]) {
+    if (Array.isArray(value)) candidates.push(...value);
+  }
+  for (const value of [node.activeSession, node.active_session, node.currentSession, node.current_session, node.runtimeSession, node.runtime_session, node.session]) {
+    if (value && typeof value === "object") candidates.push(value);
+  }
+  const session = candidates.find((item) => {
+    if (typeof item === "string") return item === sessionId;
+    const id = readString6(item?.id) || readString6(item?.sessionId) || readString6(item?.session_id) || readString6(item?.runtimeSessionId) || readString6(item?.instanceId);
+    return id === sessionId;
+  });
+  if (!session) return { staleReason: "direct task session is not present in live session records" };
+  if (typeof session === "string") return {};
+  const raw = `${readString6(session.status) || ""} ${readString6(session.lifecycle) || ""} ${readString6(session.state) || ""} ${readString6(session.activeChat?.status) || ""}`.toLowerCase();
+  if (raw.includes("approval")) return { status: "awaiting_approval" };
+  if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return { status: "generating" };
+  if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return { status: "failed" };
+  if (raw.includes("idle") || raw.includes("waiting_input") || raw.includes("ready")) return { status: "idle" };
+  return {};
+}
+function isDirectDispatch(entry) {
+  if (entry.kind !== "task_dispatched") return false;
+  const payload = entry.payload || {};
+  if (payload.source === "direct") return true;
+  const via = readString6(payload.via);
+  return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== "queue");
+}
+function directDispatchTaskId(entry) {
+  return readString6(entry.payload?.taskId) || entry.id;
+}
+function terminalMatchesDispatch(terminal, dispatch, taskId) {
+  const terminalTaskId = readString6(terminal.payload?.taskId);
+  if (terminalTaskId && terminalTaskId === taskId) return true;
+  if (terminalTaskId && terminalTaskId !== taskId) return false;
+  if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
+  return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
+}
+function statusFromTerminal(entry) {
+  if (entry.kind === "task_approval_needed") return "awaiting_approval";
+  if (entry.kind === "task_completed") return "idle";
+  return "failed";
+}
+function buildMeshActiveWorkSummary(activeWork) {
+  const statusCounts = {
+    pending: 0,
+    assigned: 0,
+    generating: 0,
+    idle: 0,
+    failed: 0,
+    awaiting_approval: 0
+  };
+  const sourceCounts = { queue: 0, direct: 0 };
+  for (const item of activeWork) {
+    sourceCounts[item.source] += 1;
+    statusCounts[item.status] += 1;
+  }
+  const staleDirectCount = activeWork.filter((item) => item.source === "direct" && item.staleReason).length;
+  const staleDirectUnacknowledgedCount = activeWork.filter((item) => item.source === "direct" && item.staleDispatchUnacknowledged).length;
+  return {
+    totalActiveCount: activeWork.length,
+    queueActiveCount: sourceCounts.queue,
+    directActiveCount: sourceCounts.direct,
+    awaitingApprovalCount: statusCounts.awaiting_approval,
+    generatingCount: statusCounts.generating,
+    failedCount: statusCounts.failed,
+    idleCount: statusCounts.idle,
+    sourceCounts,
+    statusCounts,
+    staleDirectCount,
+    ...staleDirectUnacknowledgedCount > 0 ? { staleDirectUnacknowledgedCount } : {},
+    ...staleDirectCount > 0 ? { staleDirectNote: "Stale direct records are orphaned ledger entries whose node/session no longer exists. They are historical recovery evidence only \u2014 not active or unresolved work. The queue (source: queue) is authoritative for pending/assigned tasks." } : {}
+  };
+}
+function buildMeshActiveWork(opts) {
+  const now = opts.now ?? Date.now();
+  const records = [];
+  const staleDirectWork = [];
+  const terminalDirectWork = [];
+  for (const task of opts.queue || []) {
+    if (task.status !== "pending" && task.status !== "assigned") continue;
+    const { title, summary: summary2 } = summarizeMessage(task.message || "");
+    records.push({
+      taskId: task.id,
+      source: "queue",
+      status: task.status,
+      nodeId: task.assignedNodeId || task.targetNodeId,
+      sessionId: task.assignedSessionId || task.targetSessionId,
+      taskTitle: title,
+      taskSummary: summary2,
+      message: task.message,
+      taskMode: task.taskMode,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      dispatchedAt: task.dispatchTimestamp,
+      elapsedMs: elapsedSince(task.dispatchTimestamp || task.createdAt, now)
+    });
+  }
+  if (opts.directDispatches !== void 0) {
+    const dbTaskIds = new Set(opts.directDispatches.map((d) => d.taskId));
+    for (const dispatch of opts.directDispatches) {
+      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId ?? void 0, dispatch.sessionId ?? void 0);
+      const dbStatus = dispatch.status;
+      const isTerminal = dbStatus === "completed" || dbStatus === "failed" || dbStatus === "stale";
+      const status = isTerminal ? dbStatus === "completed" ? "idle" : "failed" : live.status || (dbStatus === "acked" ? "generating" : "assigned");
+      const isNoTransition = !isTerminal && !live.status;
+      const isIdleUnacknowledged = status === "idle" && !isTerminal;
+      const ledgerOnlyStaleReason = !isTerminal && (isIdleUnacknowledged || isNoTransition || dispatch.dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
+      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
+      const { title, summary: summary2 } = summarizeMessage(dispatch.message || "");
+      const record = {
+        taskId: dispatch.taskId,
+        source: "direct",
+        status,
+        nodeId: dispatch.nodeId ?? void 0,
+        sessionId: dispatch.sessionId ?? void 0,
+        providerType: dispatch.providerType ?? void 0,
+        taskTitle: title,
+        taskSummary: summary2,
+        message: dispatch.message,
+        taskMode: dispatch.taskMode ?? void 0,
+        createdAt: dispatch.dispatchedAt,
+        updatedAt: dispatch.updatedAt,
+        dispatchedAt: dispatch.dispatchedAt,
+        elapsedMs: elapsedSince(dispatch.dispatchedAt, now),
+        terminal: isTerminal,
+        terminalKind: isTerminal ? dbStatus === "completed" ? "task_completed" : "task_failed" : void 0,
+        terminalAt: isTerminal ? dispatch.updatedAt : void 0,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
+      };
+      if (isTerminal) {
+        terminalDirectWork.push(record);
+        if (opts.includeTerminalDirect !== true) continue;
+      }
+      if ((live.staleReason || ledgerOnlyStaleReason) && !isTerminal) {
+        staleDirectWork.push(record);
+        continue;
+      }
+      records.push(record);
+    }
+    const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
+    for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+      const taskId = directDispatchTaskId(dispatch);
+      if (dbTaskIds.has(taskId)) continue;
+      const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
+      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
+      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+      const status = terminalStatus || live.status || "assigned";
+      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
+      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
+      const isNoTransition = !terminalStatus && !live.status;
+      const isIdleUnacknowledged = status === "idle";
+      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
+      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
+      const { title, summary: summary2 } = summarizeMessage(message);
+      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
+      const record = {
+        taskId,
+        source: "direct",
+        status,
+        nodeId: dispatch.nodeId,
+        sessionId: dispatch.sessionId,
+        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+        taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
+        message,
+        taskMode: readString6(dispatch.payload?.taskMode),
+        createdAt: dispatch.timestamp,
+        updatedAt: terminal?.timestamp || dispatch.timestamp,
+        dispatchedAt: dispatch.timestamp,
+        elapsedMs: elapsedSince(dispatch.timestamp, now),
+        terminal: terminalRow,
+        terminalKind: terminal?.kind,
+        terminalAt: terminal?.timestamp,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
+      };
+      if (terminalRow) {
+        terminalDirectWork.push(record);
+        if (opts.includeTerminalDirect !== true) continue;
+      }
+      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+        staleDirectWork.push(record);
+        continue;
+      }
+      records.push(record);
+    }
+  } else {
+    const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
+    for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+      const taskId = directDispatchTaskId(dispatch);
+      const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
+      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
+      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+      const status = terminalStatus || live.status || "assigned";
+      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
+      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
+      const isNoTransition = !terminalStatus && !live.status;
+      const isIdleUnacknowledged = status === "idle";
+      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
+      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
+      const { title, summary: summary2 } = summarizeMessage(message);
+      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
+      const record = {
+        taskId,
+        source: "direct",
+        status,
+        nodeId: dispatch.nodeId,
+        sessionId: dispatch.sessionId,
+        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+        taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
+        message,
+        taskMode: readString6(dispatch.payload?.taskMode),
+        createdAt: dispatch.timestamp,
+        updatedAt: terminal?.timestamp || dispatch.timestamp,
+        dispatchedAt: dispatch.timestamp,
+        elapsedMs: elapsedSince(dispatch.timestamp, now),
+        terminal: terminalRow,
+        terminalKind: terminal?.kind,
+        terminalAt: terminal?.timestamp,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
+      };
+      if (terminalRow) {
+        terminalDirectWork.push(record);
+        if (opts.includeTerminalDirect !== true) continue;
+      }
+      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+        staleDirectWork.push(record);
+        continue;
+      }
+      records.push(record);
+    }
+  }
+  records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  staleDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  terminalDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  const summary = buildMeshActiveWorkSummary(records);
+  summary.staleDirectCount = staleDirectWork.length;
+  const unacknowledgedCount = staleDirectWork.filter((r) => r.staleDispatchUnacknowledged).length;
+  if (unacknowledgedCount > 0) {
+    summary.staleDirectUnacknowledgedCount = unacknowledgedCount;
+  }
+  const staleDirectWorkNote = staleDirectWork.length > 0 ? unacknowledgedCount > 0 && unacknowledgedCount === staleDirectWork.length ? `${unacknowledgedCount} direct dispatch(es) were not acknowledged by the target session \u2014 the session received the agent_command but never transitioned to generating. This is a fresh dispatch failure, not historical noise. Recovery: launch a fresh session on the same node and retry the task, or use mesh_enqueue_task for queue-based assignment.` : unacknowledgedCount > 0 ? `${unacknowledgedCount} of ${staleDirectWork.length} stale direct record(s) are fresh unacknowledged dispatch failures (session still live but never transitioned to generating); the rest are orphaned historical entries whose node/session no longer exists. Fresh unacknowledged dispatches need recovery: launch a fresh session and retry. Orphaned entries are historical evidence only \u2014 not active or unresolved work.` : "These are orphaned ledger entries whose original node or session no longer exists in the live mesh. They are historical/recovery evidence only \u2014 not active or unresolved work. Do not treat staleDirectCount as a status mismatch; use the queue (source: queue) as authoritative for pending/assigned tasks." : void 0;
+  if (staleDirectWorkNote) {
+    summary.staleDirectNote = staleDirectWorkNote;
+  }
+  return { activeWork: records, staleDirectWork, staleDirectWorkNote, terminalDirectWork, summary };
+}
+function classifyStaleDirectForPrune(record, opts = {}) {
+  if (record.staleDispatchUnacknowledged === true) return "preserve_unacknowledged";
+  if (record.terminal === true) return opts.includeTerminal ? "prunable_terminal" : "preserve_active";
+  if (record.staleReason && PRUNABLE_ORPHAN_STALE_REASONS.has(record.staleReason)) return "prunable_orphan";
+  return "preserve_active";
+}
+function pruneStaleDirectDispatches(opts) {
+  const now = opts.now ?? Date.now();
+  const includeTerminal = opts.includeTerminal === true;
+  const execute = opts.execute === true;
+  const minAgeMs = Math.max(0, opts.minAgeMs ?? 0);
+  const activeWorkEvidence = buildMeshActiveWork({
+    meshId: opts.meshId,
+    queue: opts.queue,
+    ledgerEntries: opts.ledgerEntries,
+    directDispatches: opts.directDispatches,
+    nodes: opts.nodes,
+    now,
+    includeTerminalDirect: includeTerminal
+  });
+  const candidates = [
+    ...activeWorkEvidence.staleDirectWork,
+    ...includeTerminal ? activeWorkEvidence.terminalDirectWork : []
+  ];
+  const storeTaskIds = new Set(opts.directDispatches.map((d) => d.taskId));
+  const prunable = [];
+  const skippedTooYoung = [];
+  const preservedUnacknowledged = [];
+  const preservedLedgerOnly = [];
+  const preservedNotOrphan = [];
+  for (const record of candidates) {
+    const classification = classifyStaleDirectForPrune(record, { includeTerminal });
+    if (classification === "preserve_unacknowledged") {
+      preservedUnacknowledged.push(record);
+      continue;
+    }
+    if (classification === "preserve_active") {
+      preservedNotOrphan.push(record);
+      continue;
+    }
+    if (!storeTaskIds.has(record.taskId)) {
+      preservedLedgerOnly.push(record);
+      continue;
+    }
+    if (minAgeMs > 0) {
+      const ageRef = record.dispatchedAt || record.createdAt;
+      const ageMs = elapsedSince(ageRef, now);
+      if (ageMs < minAgeMs) {
+        skippedTooYoung.push(record);
+        continue;
+      }
+    }
+    prunable.push(record);
+  }
+  let prunedCount = 0;
+  if (execute && prunable.length) {
+    prunedCount = deleteDirectDispatchesByTaskId(opts.meshId, prunable.map((r) => r.taskId));
+    appendLedgerEntry(opts.meshId, {
+      kind: "direct_dispatch_pruned",
+      payload: {
+        source: opts.source || "prune_stale_direct",
+        prunedCount,
+        taskIds: prunable.map((r) => r.taskId),
+        reasons: Array.from(new Set(prunable.map((r) => r.staleReason || (r.terminal ? "terminal" : "unknown"))))
+      }
+    });
+  }
+  return {
+    mode: execute ? "execute" : "dry_run",
+    includeTerminal,
+    candidateCount: candidates.length,
+    prunable,
+    prunedCount,
+    skippedTooYoung,
+    preservedUnacknowledged,
+    preservedLedgerOnly,
+    preservedNotOrphan
+  };
+}
+function buildCompactStaleDirectWorkSummary(staleDirectWork, opts = {}) {
+  const sampleLimit = Math.max(0, Math.min(10, Math.floor(opts.sampleLimit ?? 3)));
+  const reasonCounts = {};
+  for (const entry of staleDirectWork) {
+    const reason = entry.staleReason || "unknown";
+    reasonCounts[reason] = (reasonCounts[reason] || 0) + 1;
+  }
+  return {
+    count: staleDirectWork.length,
+    sampleLimit,
+    sample: staleDirectWork.slice(0, sampleLimit).map((entry) => ({
+      taskId: entry.taskId,
+      status: entry.status,
+      nodeId: entry.nodeId,
+      sessionId: entry.sessionId,
+      taskTitle: entry.taskTitle,
+      createdAt: entry.createdAt,
+      staleReason: entry.staleReason
+    })),
+    reasonCounts,
+    detailHint: opts.detailHint || "Stale direct records are historical recovery evidence only. Use mesh_task_history for full ledger details, or request includeStaleDirectWorkDetails when supported by the caller.",
+    ...opts.note ? { note: opts.note } : {}
+  };
+}
+var DIRECT_DISPATCH_VIA, TERMINAL_LEDGER_KINDS, PRUNABLE_ORPHAN_STALE_REASONS;
+var init_mesh_active_work = __esm({
+  "src/mesh/mesh-active-work.ts"() {
+    "use strict";
+    init_mesh_ledger();
+    init_mesh_work_queue();
+    init_dist();
+    DIRECT_DISPATCH_VIA = /* @__PURE__ */ new Set(["p2p_direct", "local_direct", "mesh_send_task"]);
+    TERMINAL_LEDGER_KINDS = /* @__PURE__ */ new Set(["task_completed", "task_failed", "task_stalled"]);
+    PRUNABLE_ORPHAN_STALE_REASONS = /* @__PURE__ */ new Set([
+      "direct task node is no longer in the live mesh",
+      "direct task session is not present in live session records",
+      "direct task has no node id"
+    ]);
+  }
+});
+
 // src/mesh/mesh-events-utils.ts
 function readNonEmptyString2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -7024,8 +7733,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}`;
@@ -7064,7 +7773,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") {
@@ -7142,8 +7851,8 @@ var init_mesh_events_utils = __esm({
 });
 
 // src/mesh/mesh-events-pending.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync12, readFileSync as readFileSync10, renameSync as renameSync4, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync13, readFileSync as readFileSync11, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   const raw = Array.isArray(coordinatorDaemonId) ? coordinatorDaemonId : coordinatorDaemonId != null ? [coordinatorDaemonId] : [];
@@ -7206,9 +7915,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 join13(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return join14(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return join13(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join14(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -7217,9 +7926,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path42 of paths) {
-    if (!existsSync12(path42)) continue;
+    if (!existsSync13(path42)) continue;
     try {
-      const raw = readFileSync10(path42, "utf-8");
+      const raw = readFileSync11(path42, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -7294,9 +8003,9 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path42) {
   try {
-    if (!existsSync12(path42)) return;
-    if (statSync5(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = readFileSync10(path42, "utf-8").split("\n").filter(Boolean);
+    if (!existsSync13(path42)) return;
+    if (statSync6(path42).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = readFileSync11(path42, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
     writeFileSync6(path42, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
@@ -7342,7 +8051,7 @@ function atomicDrainFile(path42) {
     return null;
   }
   try {
-    const content = readFileSync10(tmpPath, "utf-8");
+    const content = readFileSync11(tmpPath, "utf-8");
     try {
       unlinkSync2(tmpPath);
     } catch {
@@ -7365,7 +8074,7 @@ function selectiveDrainFile(path42, predicate) {
   }
   let content;
   try {
-    content = readFileSync10(tmpPath, "utf-8");
+    content = readFileSync11(tmpPath, "utf-8");
   } catch {
     try {
       unlinkSync2(tmpPath);
@@ -7396,7 +8105,7 @@ function selectiveDrainFile(path42, predicate) {
     unlinkSync2(tmpPath);
   } catch {
     try {
-      if (existsSync12(tmpPath) && !existsSync12(path42)) renameSync4(tmpPath, path42);
+      if (existsSync13(tmpPath) && !existsSync13(path42)) renameSync4(tmpPath, path42);
     } catch {
     }
     return [];
@@ -7490,7 +8199,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path42 of paths) {
-    if (existsSync12(path42)) try {
+    if (existsSync13(path42)) try {
       unlinkSync2(path42);
     } catch {
     }
@@ -7854,7 +8563,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);
@@ -7873,8 +8582,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 || {},
@@ -7890,7 +8599,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
   };
@@ -8313,7 +9022,7 @@ var init_provider_cli_shared = __esm({
 import { exec } from "child_process";
 import * as os6 from "os";
 import * as path11 from "path";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -8337,7 +9046,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path11.isAbsolute(expanded) ? expanded : path11.resolve(expanded);
-    return existsSync13(candidate) ? candidate : null;
+    return existsSync14(candidate) ? candidate : null;
   }
   return null;
 }
@@ -8347,7 +9056,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) && existsSync13(resolved)) return resolved;
+  if (path11.isAbsolute(resolved) && existsSync14(resolved)) return resolved;
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
@@ -8692,7 +9401,7 @@ var init_mesh_unresolved_forward_outbox = __esm({
 });
 
 // src/mesh/mesh-events-coordinator.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 function resolveCoordinatorDrainDaemonIds(components) {
   const ids = /* @__PURE__ */ new Set();
   const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
@@ -8744,7 +9453,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);
 }
@@ -8960,7 +9669,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) {
@@ -9480,7 +10189,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 (!existsSync14(workspace)) return;
+  if (!existsSync15(workspace)) return;
   const policy = resolveAutoFastForwardPolicy(mesh);
   if (!policy.enabled) return;
   if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
@@ -9574,24 +10283,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,
@@ -9633,7 +10342,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 };
         }
@@ -10111,7 +10820,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",
@@ -10122,7 +10831,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",
@@ -10775,6 +11484,14 @@ var init_chat_message_normalization = __esm({
 });
 
 // src/mesh/mesh-reconcile-loop.ts
+function resolveAutoPruneMinAgeMs() {
+  const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 60 * 6e4 && parsed <= 30 * 24 * 60 * 6e4) return parsed;
+  }
+  return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+}
 function resolveReconcileIntervalMs() {
   const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
   if (raw) {
@@ -10886,6 +11603,18 @@ async function runMeshReconcileTick(components) {
       LOG.warn("MeshReconcile", `Completion reconcile failed for mesh ${mesh.id}: ${e?.message || e}`);
     }
   }
+  {
+    const minAgeMs = resolveAutoPruneMinAgeMs();
+    for (const mesh of listMeshes()) {
+      const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+      if (!daemonHostsMesh(mesh, selfIds)) continue;
+      try {
+        await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+      } catch (e) {
+        LOG.warn("MeshReconcile", `Auto-prune stale direct failed for mesh ${mesh.id}: ${e?.message || e}`);
+      }
+    }
+  }
   const coordinators = findLiveCoordinators(components);
   if (coordinators.length === 0) {
     return;
@@ -11068,6 +11797,68 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     }
   }
 }
+async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs) {
+  const directDispatches = getActiveDirectDispatches(mesh.id);
+  if (directDispatches.length === 0) return;
+  const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+  const result = pruneStaleDirectDispatches({
+    meshId: mesh.id,
+    queue: getQueue(mesh.id),
+    ledgerEntries: readLedgerEntries(mesh.id, { tail: 500 }),
+    directDispatches,
+    nodes: liveNodes,
+    execute: true,
+    minAgeMs,
+    source: "daemon_reconcile_auto_prune"
+  });
+  if (result.prunedCount > 0) {
+    LOG.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
+  }
+}
+async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId) {
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  return Promise.all(mesh.nodes.map(async (node) => {
+    const nodeDaemonId = readNonEmptyString2(node.daemonId);
+    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || localDaemonId !== void 0 && nodeDaemonId === localDaemonId;
+    let statusResult;
+    try {
+      if (isLocalNode) {
+        statusResult = await components.commandHandler.handle("get_status_metadata", {});
+      } else if (dispatchMeshCommand) {
+        statusResult = await dispatchMeshCommand(nodeDaemonId, "get_status_metadata", {});
+      } else {
+        return node;
+      }
+    } catch {
+      return node;
+    }
+    const sessions = extractStatusMetadataSessions(statusResult);
+    return sessions.length > 0 ? { ...node, sessions } : node;
+  }));
+}
+function extractStatusMetadataSessions(raw) {
+  let cursor = raw;
+  for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
+    const record = cursor;
+    const status = record.status && typeof record.status === "object" ? record.status : void 0;
+    if (status && Array.isArray(status.sessions)) return status.sessions;
+    if (Array.isArray(record.sessions)) return record.sessions;
+    if (record.payload && typeof record.payload === "object") {
+      cursor = record.payload;
+      continue;
+    }
+    if (record.result && typeof record.result === "object") {
+      cursor = record.result;
+      continue;
+    }
+    if (record.data && typeof record.data === "object") {
+      cursor = record.data;
+      continue;
+    }
+    break;
+  }
+  return [];
+}
 function extractPendingEvents(raw) {
   if (Array.isArray(raw)) return raw;
   if (raw && typeof raw === "object") {
@@ -11105,7 +11896,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -11118,9 +11909,12 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_unresolved_forward_outbox();
     init_mesh_events_utils();
     init_mesh_work_queue();
+    init_mesh_ledger();
+    init_mesh_active_work();
     init_mesh_events_stale();
     init_chat_message_normalization();
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
+    DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
   }
 });
 
@@ -12172,7 +12966,7 @@ var init_terminal_screen = __esm({
 
 // src/cli-adapters/resolve-executable.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import * as path18 from "path";
 function resolveWin32GlobalBin(trimmed) {
   if (path18.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\")) {
@@ -12188,7 +12982,7 @@ function resolveWin32GlobalBin(trimmed) {
     if (!dir) continue;
     for (const ext of WIN_EXEC_EXT) {
       const full = path18.join(dir, trimmed + ext);
-      if (existsSync21(full)) return full;
+      if (existsSync22(full)) return full;
     }
   }
   return null;
@@ -12197,7 +12991,7 @@ function resolveWin32Executable(command) {
   if (process.platform !== "win32") return command;
   const trimmed = (command || "").trim();
   if (!trimmed) return command;
-  if (path18.isAbsolute(trimmed) && existsSync21(trimmed)) return trimmed;
+  if (path18.isAbsolute(trimmed) && existsSync22(trimmed)) return trimmed;
   try {
     const out = execFileSync("where", [trimmed], {
       encoding: "utf8",
@@ -15183,7 +15977,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())
@@ -15260,7 +16054,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())
@@ -17123,6 +17917,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
@@ -18417,17 +19212,17 @@ init_mesh_review_inbox();
 
 // src/mesh/coordinator-registry.ts
 init_config();
-import { join as join10 } from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 var _registry = /* @__PURE__ */ new Map();
 function getRegistryPath() {
-  return join10(getDaemonDataDir(), "mesh-coordinators.json");
+  return join11(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
   const path42 = getRegistryPath();
-  if (!existsSync9(path42)) return;
+  if (!existsSync10(path42)) return;
   try {
-    const raw = JSON.parse(readFileSync7(path42, "utf-8"));
+    const raw = JSON.parse(readFileSync8(path42, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -18475,9 +19270,9 @@ function listCoordinatorsForWorkspace(workspace) {
 }
 
 // src/mesh/refine-config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join11 } from "path";
-import * as yaml from "js-yaml";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join12 } from "path";
+import * as yaml2 from "js-yaml";
 var MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
 var MESH_REFINE_CONFIG_LOCATIONS = [
   ".adhdev/refine.json",
@@ -18618,7 +19413,7 @@ function normalizeMeshCommandConfig(entry, source) {
     }
   };
 }
-var isRecord = isMeshConfigRecord;
+var isRecord2 = isMeshConfigRecord;
 function validateMeshRefineConfig(config, source = "inline") {
   const errors = [];
   const bootstrapCommands = [];
@@ -18626,14 +19421,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;
@@ -18641,8 +19436,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) {
@@ -18665,9 +19460,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 : {};
@@ -18678,10 +19473,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 = join11(workspace, relative5);
-    if (!existsSync10(configPath)) continue;
+    const configPath = join12(workspace, relative5);
+    if (!existsSync11(configPath)) continue;
     try {
-      const parsed = parseConfigText(configPath, readFileSync8(configPath, "utf-8"));
+      const parsed = parseConfigText2(configPath, readFileSync9(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 };
@@ -18697,20 +19492,20 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse(readFileSync8(join11(workspace, "package.json"), "utf-8"));
-    return isRecord(parsed?.scripts) ? parsed.scripts : {};
+    const parsed = JSON.parse(readFileSync9(join12(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;
@@ -18774,12 +19569,12 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
 }
 
 // src/mesh/worktree-bootstrap-config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join12, resolve as pathResolve } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { join as join13, resolve as pathResolve } from "path";
 import { execFile as execFile3 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { promisify as promisify3 } from "util";
-import * as yaml2 from "js-yaml";
+import * as yaml3 from "js-yaml";
 var MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
   ".adhdev/worktree_bootstrap.json",
   ".adhdev/worktree_bootstrap.yaml",
@@ -18824,9 +19619,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);
@@ -18866,10 +19661,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 = join12(workspace, relative5);
-    if (!existsSync11(configPath)) continue;
+    const configPath = join13(workspace, relative5);
+    if (!existsSync12(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, readFileSync9(configPath, "utf-8"));
+      const parsed = parseConfigText3(configPath, readFileSync10(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 };
@@ -18882,9 +19677,9 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
 function computeStaleInputsDigest(workspace, staleInputs) {
   const digest = {};
   for (const relative5 of staleInputs ?? []) {
-    const filePath = join12(workspace, relative5);
+    const filePath = join13(workspace, relative5);
     try {
-      digest[relative5] = createHash3("sha256").update(readFileSync9(filePath)).digest("hex");
+      digest[relative5] = createHash3("sha256").update(readFileSync10(filePath)).digest("hex");
     } catch {
       digest[relative5] = "absent";
     }
@@ -18954,10 +19749,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync11(join12(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync12(join13(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => existsSync11(join12(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => existsSync12(join13(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -19087,331 +19882,7 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 
 // src/index.ts
 init_mesh_work_queue();
-
-// src/mesh/mesh-active-work.ts
-init_dist();
-var DIRECT_DISPATCH_VIA = /* @__PURE__ */ new Set(["p2p_direct", "local_direct", "mesh_send_task"]);
-var TERMINAL_LEDGER_KINDS = /* @__PURE__ */ new Set(["task_completed", "task_failed", "task_stalled"]);
-function readString6(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function summarizeMessage(message) {
-  const oneLine2 = message.replace(/\s+/g, " ").trim();
-  const title = oneLine2.length > 96 ? `${oneLine2.slice(0, 93)}...` : oneLine2;
-  return { title: title || "(untitled task)", summary: oneLine2 };
-}
-function elapsedSince(value, now) {
-  const started = value ? new Date(value).getTime() : Number.NaN;
-  return Number.isFinite(started) ? Math.max(0, now - started) : 0;
-}
-function sessionStatusFromNodes(nodes, nodeId, sessionId) {
-  if (!Array.isArray(nodes)) return {};
-  if (!nodeId) return { staleReason: "direct task has no node id" };
-  const node = nodes.find((item) => meshNodeIdMatches(item, nodeId));
-  if (!node) return { staleReason: "direct task node is no longer in the live mesh" };
-  if (!sessionId) return {};
-  const candidates = [];
-  for (const value of [
-    node.sessions,
-    node.activeSessions,
-    node.active_sessions,
-    node.activeSessionDetails,
-    node.active_session_details,
-    node.sessionDetails,
-    node.session_details,
-    node.lastProbe?.sessions,
-    node.last_probe?.sessions,
-    node.lastProbe?.status?.sessions,
-    node.last_probe?.status?.sessions
-  ]) {
-    if (Array.isArray(value)) candidates.push(...value);
-  }
-  for (const value of [node.activeSession, node.active_session, node.currentSession, node.current_session, node.runtimeSession, node.runtime_session, node.session]) {
-    if (value && typeof value === "object") candidates.push(value);
-  }
-  const session = candidates.find((item) => {
-    if (typeof item === "string") return item === sessionId;
-    const id = readString6(item?.id) || readString6(item?.sessionId) || readString6(item?.session_id) || readString6(item?.runtimeSessionId) || readString6(item?.instanceId);
-    return id === sessionId;
-  });
-  if (!session) return { staleReason: "direct task session is not present in live session records" };
-  if (typeof session === "string") return {};
-  const raw = `${readString6(session.status) || ""} ${readString6(session.lifecycle) || ""} ${readString6(session.state) || ""} ${readString6(session.activeChat?.status) || ""}`.toLowerCase();
-  if (raw.includes("approval")) return { status: "awaiting_approval" };
-  if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return { status: "generating" };
-  if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return { status: "failed" };
-  if (raw.includes("idle") || raw.includes("waiting_input") || raw.includes("ready")) return { status: "idle" };
-  return {};
-}
-function isDirectDispatch(entry) {
-  if (entry.kind !== "task_dispatched") return false;
-  const payload = entry.payload || {};
-  if (payload.source === "direct") return true;
-  const via = readString6(payload.via);
-  return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== "queue");
-}
-function directDispatchTaskId(entry) {
-  return readString6(entry.payload?.taskId) || entry.id;
-}
-function terminalMatchesDispatch(terminal, dispatch, taskId) {
-  const terminalTaskId = readString6(terminal.payload?.taskId);
-  if (terminalTaskId && terminalTaskId === taskId) return true;
-  if (terminalTaskId && terminalTaskId !== taskId) return false;
-  if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
-  return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
-}
-function statusFromTerminal(entry) {
-  if (entry.kind === "task_approval_needed") return "awaiting_approval";
-  if (entry.kind === "task_completed") return "idle";
-  return "failed";
-}
-function buildMeshActiveWorkSummary(activeWork) {
-  const statusCounts = {
-    pending: 0,
-    assigned: 0,
-    generating: 0,
-    idle: 0,
-    failed: 0,
-    awaiting_approval: 0
-  };
-  const sourceCounts = { queue: 0, direct: 0 };
-  for (const item of activeWork) {
-    sourceCounts[item.source] += 1;
-    statusCounts[item.status] += 1;
-  }
-  const staleDirectCount = activeWork.filter((item) => item.source === "direct" && item.staleReason).length;
-  const staleDirectUnacknowledgedCount = activeWork.filter((item) => item.source === "direct" && item.staleDispatchUnacknowledged).length;
-  return {
-    totalActiveCount: activeWork.length,
-    queueActiveCount: sourceCounts.queue,
-    directActiveCount: sourceCounts.direct,
-    awaitingApprovalCount: statusCounts.awaiting_approval,
-    generatingCount: statusCounts.generating,
-    failedCount: statusCounts.failed,
-    idleCount: statusCounts.idle,
-    sourceCounts,
-    statusCounts,
-    staleDirectCount,
-    ...staleDirectUnacknowledgedCount > 0 ? { staleDirectUnacknowledgedCount } : {},
-    ...staleDirectCount > 0 ? { staleDirectNote: "Stale direct records are orphaned ledger entries whose node/session no longer exists. They are historical recovery evidence only \u2014 not active or unresolved work. The queue (source: queue) is authoritative for pending/assigned tasks." } : {}
-  };
-}
-function buildMeshActiveWork(opts) {
-  const now = opts.now ?? Date.now();
-  const records = [];
-  const staleDirectWork = [];
-  const terminalDirectWork = [];
-  for (const task of opts.queue || []) {
-    if (task.status !== "pending" && task.status !== "assigned") continue;
-    const { title, summary: summary2 } = summarizeMessage(task.message || "");
-    records.push({
-      taskId: task.id,
-      source: "queue",
-      status: task.status,
-      nodeId: task.assignedNodeId || task.targetNodeId,
-      sessionId: task.assignedSessionId || task.targetSessionId,
-      taskTitle: title,
-      taskSummary: summary2,
-      message: task.message,
-      taskMode: task.taskMode,
-      createdAt: task.createdAt,
-      updatedAt: task.updatedAt,
-      dispatchedAt: task.dispatchTimestamp,
-      elapsedMs: elapsedSince(task.dispatchTimestamp || task.createdAt, now)
-    });
-  }
-  if (opts.directDispatches !== void 0) {
-    const dbTaskIds = new Set(opts.directDispatches.map((d) => d.taskId));
-    for (const dispatch of opts.directDispatches) {
-      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId ?? void 0, dispatch.sessionId ?? void 0);
-      const dbStatus = dispatch.status;
-      const isTerminal = dbStatus === "completed" || dbStatus === "failed" || dbStatus === "stale";
-      const status = isTerminal ? dbStatus === "completed" ? "idle" : "failed" : live.status || (dbStatus === "acked" ? "generating" : "assigned");
-      const isNoTransition = !isTerminal && !live.status;
-      const isIdleUnacknowledged = status === "idle" && !isTerminal;
-      const ledgerOnlyStaleReason = !isTerminal && (isIdleUnacknowledged || isNoTransition || dispatch.dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
-      const { title, summary: summary2 } = summarizeMessage(dispatch.message || "");
-      const record = {
-        taskId: dispatch.taskId,
-        source: "direct",
-        status,
-        nodeId: dispatch.nodeId ?? void 0,
-        sessionId: dispatch.sessionId ?? void 0,
-        providerType: dispatch.providerType ?? void 0,
-        taskTitle: title,
-        taskSummary: summary2,
-        message: dispatch.message,
-        taskMode: dispatch.taskMode ?? void 0,
-        createdAt: dispatch.dispatchedAt,
-        updatedAt: dispatch.updatedAt,
-        dispatchedAt: dispatch.dispatchedAt,
-        elapsedMs: elapsedSince(dispatch.dispatchedAt, now),
-        terminal: isTerminal,
-        terminalKind: isTerminal ? dbStatus === "completed" ? "task_completed" : "task_failed" : void 0,
-        terminalAt: isTerminal ? dispatch.updatedAt : void 0,
-        staleReason: live.staleReason || ledgerOnlyStaleReason,
-        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-      };
-      if (isTerminal) {
-        terminalDirectWork.push(record);
-        if (opts.includeTerminalDirect !== true) continue;
-      }
-      if ((live.staleReason || ledgerOnlyStaleReason) && !isTerminal) {
-        staleDirectWork.push(record);
-        continue;
-      }
-      records.push(record);
-    }
-    const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-    const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-    for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-      const taskId = directDispatchTaskId(dispatch);
-      if (dbTaskIds.has(taskId)) continue;
-      const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-      const status = terminalStatus || live.status || "assigned";
-      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-      const isNoTransition = !terminalStatus && !live.status;
-      const isIdleUnacknowledged = status === "idle";
-      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-      const { title, summary: summary2 } = summarizeMessage(message);
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
-      const record = {
-        taskId,
-        source: "direct",
-        status,
-        nodeId: dispatch.nodeId,
-        sessionId: dispatch.sessionId,
-        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-        taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-        message,
-        taskMode: readString6(dispatch.payload?.taskMode),
-        createdAt: dispatch.timestamp,
-        updatedAt: terminal?.timestamp || dispatch.timestamp,
-        dispatchedAt: dispatch.timestamp,
-        elapsedMs: elapsedSince(dispatch.timestamp, now),
-        terminal: terminalRow,
-        terminalKind: terminal?.kind,
-        terminalAt: terminal?.timestamp,
-        staleReason: live.staleReason || ledgerOnlyStaleReason,
-        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-      };
-      if (terminalRow) {
-        terminalDirectWork.push(record);
-        if (opts.includeTerminalDirect !== true) continue;
-      }
-      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
-        staleDirectWork.push(record);
-        continue;
-      }
-      records.push(record);
-    }
-  } else {
-    const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-    const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-    for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-      const taskId = directDispatchTaskId(dispatch);
-      const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-      const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-      const status = terminalStatus || live.status || "assigned";
-      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-      const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-      const isNoTransition = !terminalStatus && !live.status;
-      const isIdleUnacknowledged = status === "idle";
-      const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-      const { title, summary: summary2 } = summarizeMessage(message);
-      const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
-      const record = {
-        taskId,
-        source: "direct",
-        status,
-        nodeId: dispatch.nodeId,
-        sessionId: dispatch.sessionId,
-        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-        taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-        message,
-        taskMode: readString6(dispatch.payload?.taskMode),
-        createdAt: dispatch.timestamp,
-        updatedAt: terminal?.timestamp || dispatch.timestamp,
-        dispatchedAt: dispatch.timestamp,
-        elapsedMs: elapsedSince(dispatch.timestamp, now),
-        terminal: terminalRow,
-        terminalKind: terminal?.kind,
-        terminalAt: terminal?.timestamp,
-        staleReason: live.staleReason || ledgerOnlyStaleReason,
-        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-      };
-      if (terminalRow) {
-        terminalDirectWork.push(record);
-        if (opts.includeTerminalDirect !== true) continue;
-      }
-      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
-        staleDirectWork.push(record);
-        continue;
-      }
-      records.push(record);
-    }
-  }
-  records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-  staleDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-  terminalDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-  const summary = buildMeshActiveWorkSummary(records);
-  summary.staleDirectCount = staleDirectWork.length;
-  const unacknowledgedCount = staleDirectWork.filter((r) => r.staleDispatchUnacknowledged).length;
-  if (unacknowledgedCount > 0) {
-    summary.staleDirectUnacknowledgedCount = unacknowledgedCount;
-  }
-  const staleDirectWorkNote = staleDirectWork.length > 0 ? unacknowledgedCount > 0 && unacknowledgedCount === staleDirectWork.length ? `${unacknowledgedCount} direct dispatch(es) were not acknowledged by the target session \u2014 the session received the agent_command but never transitioned to generating. This is a fresh dispatch failure, not historical noise. Recovery: launch a fresh session on the same node and retry the task, or use mesh_enqueue_task for queue-based assignment.` : unacknowledgedCount > 0 ? `${unacknowledgedCount} of ${staleDirectWork.length} stale direct record(s) are fresh unacknowledged dispatch failures (session still live but never transitioned to generating); the rest are orphaned historical entries whose node/session no longer exists. Fresh unacknowledged dispatches need recovery: launch a fresh session and retry. Orphaned entries are historical evidence only \u2014 not active or unresolved work.` : "These are orphaned ledger entries whose original node or session no longer exists in the live mesh. They are historical/recovery evidence only \u2014 not active or unresolved work. Do not treat staleDirectCount as a status mismatch; use the queue (source: queue) as authoritative for pending/assigned tasks." : void 0;
-  if (staleDirectWorkNote) {
-    summary.staleDirectNote = staleDirectWorkNote;
-  }
-  return { activeWork: records, staleDirectWork, staleDirectWorkNote, terminalDirectWork, summary };
-}
-var PRUNABLE_ORPHAN_STALE_REASONS = /* @__PURE__ */ new Set([
-  "direct task node is no longer in the live mesh",
-  "direct task session is not present in live session records",
-  "direct task has no node id"
-]);
-function classifyStaleDirectForPrune(record, opts = {}) {
-  if (record.staleDispatchUnacknowledged === true) return "preserve_unacknowledged";
-  if (record.terminal === true) return opts.includeTerminal ? "prunable_terminal" : "preserve_active";
-  if (record.staleReason && PRUNABLE_ORPHAN_STALE_REASONS.has(record.staleReason)) return "prunable_orphan";
-  return "preserve_active";
-}
-function buildCompactStaleDirectWorkSummary(staleDirectWork, opts = {}) {
-  const sampleLimit = Math.max(0, Math.min(10, Math.floor(opts.sampleLimit ?? 3)));
-  const reasonCounts = {};
-  for (const entry of staleDirectWork) {
-    const reason = entry.staleReason || "unknown";
-    reasonCounts[reason] = (reasonCounts[reason] || 0) + 1;
-  }
-  return {
-    count: staleDirectWork.length,
-    sampleLimit,
-    sample: staleDirectWork.slice(0, sampleLimit).map((entry) => ({
-      taskId: entry.taskId,
-      status: entry.status,
-      nodeId: entry.nodeId,
-      sessionId: entry.sessionId,
-      taskTitle: entry.taskTitle,
-      createdAt: entry.createdAt,
-      staleReason: entry.staleReason
-    })),
-    reasonCounts,
-    detailHint: opts.detailHint || "Stale direct records are historical recovery evidence only. Use mesh_task_history for full ledger details, or request includeStaleDirectWorkDetails when supported by the caller.",
-    ...opts.note ? { note: opts.note } : {}
-  };
-}
-
-// src/index.ts
+init_mesh_active_work();
 init_mesh_refine_status();
 init_mesh_host_ownership();
 init_mesh_events();
@@ -19529,8 +20000,8 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { join as join17 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -19543,7 +20014,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join16(getConfigDir(), "state.json");
+  return join17(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -19579,11 +20050,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync15(statePath)) {
+  if (!existsSync16(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync11(statePath, "utf-8");
+    const raw = readFileSync12(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -19601,7 +20072,7 @@ function resetState() {
 // src/detection/ide-detector.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { existsSync as existsSync17, statSync as statSync7 } from "fs";
+import { existsSync as existsSync18, statSync as statSync8 } from "fs";
 import { platform as platform3, homedir as homedir8 } from "os";
 import * as path13 from "path";
 
@@ -19682,7 +20153,7 @@ function findCliCommand(command) {
   if (path13.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path13.join(homedir8(), trimmed.slice(1)) : trimmed;
     const resolved = path13.isAbsolute(candidate) ? candidate : path13.resolve(candidate);
-    return existsSync17(resolved) ? resolved : null;
+    return existsSync18(resolved) ? resolved : null;
   }
   const isWin = platform3() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -19692,8 +20163,8 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path13.join(p, trimmed + ext);
       try {
-        if (existsSync17(fullPath)) {
-          const stat2 = statSync7(fullPath);
+        if (existsSync18(fullPath)) {
+          const stat2 = statSync8(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -19711,9 +20182,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync17(resolved)) return resolved;
+      if (existsSync18(resolved)) return resolved;
     } else {
-      if (existsSync17(normalized)) return normalized;
+      if (existsSync18(normalized)) return normalized;
     }
   }
   return null;
@@ -19727,7 +20198,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os30 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync17(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync18(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os30 === "win32") {
       const { dirname: dirname17 } = await import("path");
@@ -19740,7 +20211,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync17(c)) {
+        if (existsSync18(c)) {
           resolvedCli = c;
           break;
         }
@@ -21285,8 +21756,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
@@ -21295,7 +21766,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) {
@@ -21313,7 +21784,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)) {
@@ -21326,9 +21797,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);
@@ -21338,17 +21816,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,
@@ -21359,7 +21837,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);
     }
@@ -21378,7 +21856,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()) {
@@ -21386,7 +21864,7 @@ var StatusMonitor = class {
       }
     } else {
       this.generatingStartTimes.clear();
-      this.longGeneratingAlerted.clear();
+      this.noProgressAlerted.clear();
       this.lastProgressFingerprint.clear();
       this.lastProgressChangeAt.clear();
       this.lastAlertTime.clear();
@@ -23209,8 +23687,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() {
@@ -23301,8 +23779,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 */
@@ -23362,7 +23840,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 });
     }
@@ -23577,7 +24056,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"];
@@ -23844,8 +24323,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() {
@@ -23972,8 +24451,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 ─────────────────────────────
@@ -24104,7 +24583,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);
@@ -24174,7 +24653,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 });
     }
@@ -26731,7 +27211,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;
@@ -30767,7 +31247,7 @@ init_config();
 import * as os19 from "os";
 import * as path26 from "path";
 import * as crypto5 from "crypto";
-import { existsSync as existsSync26, mkdirSync as mkdirSync12, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync12, writeFileSync as writeFileSync15 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import chalk from "chalk";
 
@@ -33409,7 +33889,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 = [];
@@ -33611,8 +34091,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);
@@ -33759,7 +34239,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);
@@ -33887,8 +34367,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
     });
   }
   /**
@@ -34620,10 +35100,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,
@@ -34634,7 +35115,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
           }
         });
@@ -35316,8 +35797,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();
   }
@@ -35613,8 +36094,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(", ")}`);
   }
@@ -36321,7 +36802,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 });
     }
@@ -36383,7 +36865,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync26(expandExecutable(trimmed));
+    return existsSync27(expandExecutable(trimmed));
   }
   try {
     execFileSync2(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -36395,7 +36877,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() : "";
@@ -41260,6 +41742,7 @@ function getAvailableIdeIds() {
 init_config();
 init_cli_detector();
 init_git_status();
+init_change_impact_config();
 init_dist();
 init_logger();
 
@@ -41409,7 +41892,7 @@ cleanOldFiles();
 
 // src/commands/router.ts
 init_logger();
-import * as yaml3 from "js-yaml";
+import * as yaml4 from "js-yaml";
 
 // src/logging/log-tail-reader.ts
 init_logger();
@@ -41710,7 +42193,7 @@ function orderMeshRefineBatchNodes(changeAreas) {
 
 // src/mesh/preview-freshness.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync35, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync27 } from "fs";
 import { resolve as resolve19 } from "path";
 var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
 function runGit2(repoRoot, args) {
@@ -41727,9 +42210,9 @@ function runGit2(repoRoot, args) {
 }
 function readRecord6(repoRoot) {
   const path42 = resolve19(repoRoot, PREVIEW_DEPLOY_RECORD);
-  if (!existsSync35(path42)) return null;
+  if (!existsSync36(path42)) return null;
   try {
-    const parsed = JSON.parse(readFileSync26(path42, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path42, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -41794,8 +42277,8 @@ function buildPreviewFreshness(repoRoot) {
 init_mesh_refine_status();
 
 // src/mesh/mesh-init.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname10, join as join39 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname10, join as join40 } from "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 = [
@@ -41809,7 +42292,7 @@ var CANDIDATE_STALE_INPUTS = [
   "requirements.txt"
 ];
 function writeConfigFile(workspace, relativePath, config) {
-  const target = join39(workspace, relativePath);
+  const target = join40(workspace, relativePath);
   mkdirSync15(dirname10(target), { recursive: true });
   writeFileSync17(target, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
@@ -41817,14 +42300,14 @@ function writeConfigFile(workspace, relativePath, config) {
 }
 function suggestMeshWorktreeBootstrapConfig(workspace) {
   const commands = [];
-  const hasPackageJson = existsSync36(join39(workspace, "package.json"));
-  const hasNpmLock = existsSync36(join39(workspace, "package-lock.json"));
+  const hasPackageJson = existsSync37(join40(workspace, "package.json"));
+  const hasNpmLock = existsSync37(join40(workspace, "package-lock.json"));
   if (hasPackageJson) {
     commands.push(
       hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
     );
   }
-  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync36(join39(workspace, relative5)));
+  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync37(join40(workspace, relative5)));
   if (!commands.length) {
     return { commands, staleInputs };
   }
@@ -41892,7 +42375,7 @@ function runMeshInit(mesh, workspace, detected, options = {}) {
 }
 function applyConfigSuggestion(input) {
   const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-  const absolute = join39(workspace, relativePath);
+  const absolute = join40(workspace, relativePath);
   if (existing !== void 0 && !overwrite) {
     return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
   }
@@ -44691,7 +45174,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";
@@ -48433,6 +48916,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 || {};
@@ -49349,7 +49868,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;
@@ -49392,14 +49911,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");
@@ -49898,7 +50417,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" };
@@ -49917,7 +50436,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 });
@@ -50091,7 +50610,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;
@@ -50636,7 +51155,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,
@@ -58476,12 +58995,12 @@ init_parse_session();
 
 // src/providers/sdk/v1/fixture-tooling/replay.ts
 init_provider_cli_shared();
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } from "fs";
 import { dirname as dirname15, resolve as resolve22 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
-import { readFileSync as readFileSync35, existsSync as existsSync44 } from "fs";
-import { resolve as resolve23, dirname as dirname16, join as join46 } from "path";
+import { readFileSync as readFileSync36, existsSync as existsSync45 } from "fs";
+import { resolve as resolve23, dirname as dirname16, join as join47 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
 init_manifest();
@@ -58561,6 +59080,8 @@ export {
   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,
@@ -58751,6 +59272,7 @@ export {
   getSessionHostSurfaceKind,
   getSessionRecoveryContext,
   getWorkspaceState,
+  globToRegExp,
   handleGitCommand,
   hasCdpManager,
   hasPendingDependents,
@@ -58784,6 +59306,7 @@ export {
   listMeshMissionSummaries,
   listMeshes,
   listWorktrees,
+  loadChangeImpactConfig,
   loadConfig,
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
@@ -58824,6 +59347,7 @@ export {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  pruneStaleDirectDispatches,
   queuePendingMeshCoordinatorEvent,
   readSession3 as readAntigravityCliSession,
   readCachedInlineMeshActiveSessionDetails,
@@ -58877,6 +59401,7 @@ export {
   spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport,
   startLocalIpcServer,
+  suggestChangeImpactConfig,
   suggestMeshRefineConfig,
   summarizeGitStatus,
   summarizeMeshAsyncRefineJobs,
@@ -58893,6 +59418,7 @@ export {
   updateTaskStatus,
   upsertMeshMission,
   upsertSavedProviderSession,
+  validateChangeImpactConfig,
   validateCliProviderManifest,
   validateFsmSpec,
   validateMeshRefineConfig,