@adhdev/daemon-core 0.9.82-rc.510 → 0.9.82-rc.511

package/dist/index.mjs

@@ -412,10 +412,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "9e16d8626cae0095e7ccc7dbea08afcd9505473a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "9e16d862" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.510" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-13T03:02:22.024Z" : void 0);
+  const commit = readInjected(true ? "a03f7d21a28e2337a5b4520ff313ca69d776691d" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a03f7d21" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.511" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-13T05:19:31.486Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -668,6 +668,7 @@ var init_change_impact_config = __esm({
 });
 
 // src/git/git-status.ts
+import { join as join2 } from "path";
 function statusCacheKey(workspace, options) {
   const includeSubmodules = options.includeSubmodules !== false;
   const refreshUpstream = options.refreshUpstream === true;
@@ -789,21 +790,21 @@ function isNonRuntimeRootFile(file, policy) {
 }
 function classifyChangedFileList(files, policy) {
   if (files.length === 0) {
-    return { isDaemonAffecting: true, affectedPackages: [] };
+    return { isDaemonAffecting: true, affectedPackages: [], ambiguousNonPackageFiles: [] };
   }
   const pkgs = /* @__PURE__ */ new Set();
-  let sawRuntimeAmbiguousNonPackage = false;
+  const ambiguousNonPackageFiles = [];
   for (const file of files) {
     const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
     if (!match) {
-      if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
+      if (!isNonRuntimeRootFile(file, policy)) ambiguousNonPackageFiles.push(file);
       continue;
     }
     pkgs.add(match[1]);
   }
   const affectedPackages = [...pkgs].sort();
-  const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
-  return { isDaemonAffecting: !allBenign, affectedPackages };
+  const allBenign = ambiguousNonPackageFiles.length === 0 && affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
+  return { isDaemonAffecting: !allBenign, affectedPackages, ambiguousNonPackageFiles };
 }
 async function classifyDaemonBuildChange(repoPath, buildCommit, options, policy) {
   try {
@@ -820,7 +821,82 @@ async function classifyChangedPackages(repoPath, fromRef, toRef, options = {}) {
   const policy = resolveChangeImpactPolicy(config);
   const diff = await runGit(repoPath, ["diff", "--name-only", `${fromRef}..${toRef}`], options);
   const files = diff.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-  return classifyChangedFileList(files, policy);
+  const rootVerdict = classifyChangedFileList(files, policy);
+  return refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options, policy, rootVerdict);
+}
+async function refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options, policy, rootVerdict) {
+  const strip = ({ isDaemonAffecting, affectedPackages }) => ({ isDaemonAffecting, affectedPackages });
+  const ambiguous = rootVerdict.ambiguousNonPackageFiles;
+  if (ambiguous.length === 0) return strip(rootVerdict);
+  let submodulePaths;
+  try {
+    submodulePaths = await listSubmodulePaths(repoPath, options);
+  } catch {
+    return strip(rootVerdict);
+  }
+  if (ambiguous.length === 0 || !ambiguous.every((f) => submodulePaths.has(f))) {
+    return strip(rootVerdict);
+  }
+  const submoduleAffectedPackages = [];
+  for (const subPath of ambiguous) {
+    let range;
+    try {
+      range = await resolveSubmoduleGitlinkRange(repoPath, fromRef, toRef, subPath, options);
+    } catch {
+      return strip(rootVerdict);
+    }
+    let subVerdict;
+    try {
+      subVerdict = await classifyChangedPackages(join2(repoPath, subPath), range.from, range.to, {
+        ...options,
+        // Do not force the root's injected config onto the submodule — let it resolve
+        // its own .adhdev/change-impact.* (or fall back to defaults).
+        changeImpactConfig: void 0
+      });
+    } catch {
+      return strip(rootVerdict);
+    }
+    if (subVerdict.isDaemonAffecting) {
+      return {
+        isDaemonAffecting: true,
+        affectedPackages: [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...subVerdict.affectedPackages])].sort()
+      };
+    }
+    submoduleAffectedPackages.push(...subVerdict.affectedPackages);
+  }
+  const rootPackagesBenign = rootVerdict.affectedPackages.every(
+    (p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p)
+  );
+  return {
+    isDaemonAffecting: !rootPackagesBenign,
+    affectedPackages: [.../* @__PURE__ */ new Set([...rootVerdict.affectedPackages, ...submoduleAffectedPackages])].sort()
+  };
+}
+async function listSubmodulePaths(repoPath, options) {
+  const res = await runGit(repoPath, ["config", "-f", ".gitmodules", "--get-regexp", "path"], options);
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of res.stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const idx = trimmed.indexOf(" ");
+    if (idx === -1) continue;
+    const p = trimmed.slice(idx + 1).trim();
+    if (p) paths.add(p);
+  }
+  return paths;
+}
+async function resolveSubmoduleGitlinkRange(repoPath, fromRef, toRef, subPath, options) {
+  const res = await runGit(repoPath, ["diff", `${fromRef}..${toRef}`, "--", subPath], options);
+  let from = "";
+  let to = "";
+  for (const line of res.stdout.split("\n")) {
+    const m = line.match(/^([+-])Subproject commit ([0-9a-f]{7,40})/);
+    if (!m) continue;
+    if (m[1] === "-") from = m[2];
+    else to = m[2];
+  }
+  if (!from || !to) throw new Error(`no gitlink range for submodule ${subPath}`);
+  return { from, to };
 }
 function resolveChangeImpactConfigForRepo(repoRoot, options) {
   if (options.changeImpactConfig === null) {
@@ -1532,7 +1608,7 @@ __export(config_exports, {
   updateConfig: () => updateConfig
 });
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, chmodSync } from "fs";
 import { randomUUID } from "crypto";
 function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
@@ -1630,24 +1706,24 @@ function ensureMachineId(config) {
 }
 function getConfigDir() {
   const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : join2(homedir(), ".adhdev");
+  const dir = override && override.trim() ? override.trim() : join3(homedir(), ".adhdev");
   if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getDaemonDataDir() {
-  const dir = join2(getConfigDir(), "daemon");
+  const dir = join3(getConfigDir(), "daemon");
   if (!existsSync2(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");
+  const statePath = join3(getConfigDir(), "state.json");
   if (existsSync2(statePath)) return;
   const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
   const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
@@ -3048,10 +3124,10 @@ __export(mesh_config_exports, {
   updateNode: () => updateNode
 });
 import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { randomBytes, randomUUID as randomUUID3 } from "crypto";
 function getMeshConfigPath() {
-  return join5(getConfigDir(), "meshes.json");
+  return join6(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
   const path45 = getMeshConfigPath();
@@ -4631,7 +4707,7 @@ __export(mesh_ledger_exports, {
   tombstoneOperatingNote: () => tombstoneOperatingNote
 });
 import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, statSync as statSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -4640,7 +4716,7 @@ 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 = join8(getConfigDir(), LEDGER_DIR_NAME);
+  const dir = join9(getConfigDir(), LEDGER_DIR_NAME);
   if (!existsSync7(dir)) {
     mkdirSync4(dir, { recursive: true, mode: 448 });
   }
@@ -4648,23 +4724,23 @@ function getLedgerDir() {
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join8(getLedgerDir(), `${safe}.jsonl`);
+  return join9(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join8(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join9(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join8(getLedgerDir(), `${safe}.archive.jsonl`);
+  return join9(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join8(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return join9(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join8(getLedgerDir(), `${safe}.archived-counts.json`);
+  return join9(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
@@ -6508,7 +6584,7 @@ var init_mesh_work_queue = __esm({
 
 // src/mesh/mesh-runtime-store.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname2, join as join9 } from "path";
+import { dirname as dirname2, join as join10 } from "path";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
   DatabaseCtor = loadBetterSqlite3();
@@ -6518,11 +6594,11 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return join9(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return join10(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 function cleanupStrayRootRuntimeDb(canonicalPath) {
   try {
-    const strayPath = join9(getConfigDir(), "mesh-runtime.db");
+    const strayPath = join10(getConfigDir(), "mesh-runtime.db");
     if (strayPath === canonicalPath) return;
     if (!existsSync8(strayPath)) return;
     if (statSync5(strayPath).size !== 0) return;
@@ -6540,10 +6616,10 @@ function cleanupStrayRootRuntimeDb(canonicalPath) {
 }
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
-  const nextPath = join9(dir, "mesh-runtime.db");
+  const nextPath = join10(dir, "mesh-runtime.db");
   cleanupStrayRootRuntimeDb(nextPath);
   if (existsSync8(nextPath)) return nextPath;
-  const legacyPath = join9(dir, "beads.db");
+  const legacyPath = join10(dir, "beads.db");
   if (!existsSync8(legacyPath)) return nextPath;
   try {
     renameSync3(legacyPath, nextPath);
@@ -8656,7 +8732,7 @@ var init_mesh_events_utils = __esm({
 
 // src/mesh/mesh-events-pending.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync9, readFileSync as readFileSync7, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
@@ -8879,9 +8955,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 join10(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return join11(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return join10(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join11(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -10158,7 +10234,7 @@ __export(mesh_coordinator_exports, {
 import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } 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 join11, resolve as resolve7 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute4, join as join12, resolve as resolve7 } from "path";
 function isHermesProvider(provider, cliType) {
   const type = cliType?.trim() || provider?.type?.trim() || "";
   return type === HERMES_CLI_TYPE;
@@ -10178,7 +10254,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 = join11(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join12(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -10325,14 +10401,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key2 = `${meshId || "mesh"}
 ${resolve7(workspace || os4.tmpdir())}`;
   const hash = shortHash(key2);
-  return join11(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join12(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os4.homedir();
-  if (trimmed.startsWith("~/")) return join11(os4.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join12(os4.homedir(), trimmed.slice(2));
   if (isAbsolute4(trimmed)) return trimmed;
-  return join11(workspace, trimmed);
+  return join12(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const directEntryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -10403,7 +10479,7 @@ function applyInjectionRule(systemPrompt, injection, ctx) {
     }
     case "context_file": {
       if (!injection.path) return {};
-      const target = isAbsolute4(injection.path) ? injection.path : join11(ctx.workspace, injection.path);
+      const target = isAbsolute4(injection.path) ? injection.path : join12(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}
@@ -10547,10 +10623,10 @@ var init_mesh_coordinator = __esm({
 });
 
 // src/mesh/coordinator-registry.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
 function getRegistryPath() {
-  return join12(getDaemonDataDir(), "mesh-coordinators.json");
+  return join13(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
   const path45 = getRegistryPath();
@@ -10613,7 +10689,7 @@ var init_coordinator_registry = __esm({
 
 // src/mesh/refine-config.ts
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import * as yaml2 from "js-yaml";
 function isMeshConfigRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -10741,7 +10817,7 @@ function loadMeshRefineConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
   }
   for (const relative5 of MESH_REFINE_CONFIG_LOCATIONS) {
-    const configPath = join13(workspace, relative5);
+    const configPath = join14(workspace, relative5);
     if (!existsSync12(configPath)) continue;
     try {
       const parsed = parseConfigText2(configPath, readFileSync10(configPath, "utf-8"));
@@ -10760,7 +10836,7 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse(readFileSync10(join13(workspace, "package.json"), "utf-8"));
+    const parsed = JSON.parse(readFileSync10(join14(workspace, "package.json"), "utf-8"));
     return isRecord2(parsed?.scripts) ? parsed.scripts : {};
   } catch {
     return {};
@@ -11035,7 +11111,7 @@ __export(worktree_bootstrap_config_exports, {
   validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
 });
 import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join15, resolve as pathResolve } from "path";
+import { join as join16, resolve as pathResolve } from "path";
 import { execFile as execFile3, execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { promisify as promisify3 } from "util";
@@ -11217,7 +11293,7 @@ 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 = join15(workspace, relative5);
+    const configPath = join16(workspace, relative5);
     if (!existsSync14(configPath)) continue;
     try {
       const parsed = parseConfigText3(configPath, readFileSync11(configPath, "utf-8"));
@@ -11233,7 +11309,7 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
 function computeStaleInputsDigest(workspace, staleInputs) {
   const digest = {};
   for (const relative5 of staleInputs ?? []) {
-    const filePath = join15(workspace, relative5);
+    const filePath = join16(workspace, relative5);
     try {
       digest[relative5] = createHash2("sha256").update(readFileSync11(filePath)).digest("hex");
     } catch {
@@ -11306,10 +11382,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync14(join15(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync14(join16(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => existsSync14(join15(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => existsSync14(join16(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -11446,7 +11522,7 @@ __export(mesh_json_config_exports, {
   serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold
 });
 import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import * as yaml4 from "js-yaml";
 function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -11518,7 +11594,7 @@ function loadRepoMeshJsonConfig(workspace) {
   if (cwd && cwd !== ws) bases.push(cwd);
   for (const base of bases) {
     for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
-      const configPath = join16(base, relative5);
+      const configPath = join17(base, relative5);
       if (!existsSync15(configPath)) continue;
       try {
         const parsed = parseConfigText4(configPath, readFileSync12(configPath, "utf-8"));
@@ -12748,14 +12824,19 @@ function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now =
     if (policy?.idleActiveMissionReminder === false) return false;
     const activeMissions = getMeshMissions(meshId, ["active"]);
     if (activeMissions.length === 0) return false;
+    const ledgerEntries = readLedgerEntries(meshId, { tail: 200 });
     const summary = buildMeshActiveWork({
       meshId,
       queue: getQueue(meshId),
       directDispatches: getActiveDirectDispatches(meshId),
-      ledgerEntries: readLedgerEntries(meshId, { tail: 200 }),
+      ledgerEntries,
       now
     }).summary;
     if (summary.totalActiveCount !== 0 || summary.generatingCount !== 0) return false;
+    const activeRefineJobs = summarizeMeshAsyncRefineJobs(
+      buildMeshAsyncRefineJobs({ meshId, ledgerEntries })
+    ).activeJobs;
+    if (activeRefineJobs.length > 0) return false;
     const store = MeshRuntimeStore.getInstance();
     const hash = missionSetHash(activeMissions);
     const last = store.getIdleReminderState(meshId);
@@ -12785,6 +12866,7 @@ var init_mesh_idle_reminder = __esm({
     init_mesh_work_queue();
     init_mesh_ledger();
     init_mesh_active_work();
+    init_mesh_refine_status();
     IDLE_REMINDER_DEBOUNCE_MS = 3e5;
     MISSION_LIST_CAP = 10;
   }
@@ -17259,12 +17341,12 @@ var init_mesh_unresolved_forward_outbox = __esm({
 
 // src/config/state-store.ts
 import { existsSync as existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join19(getConfigDir(), "state.json");
+  return join20(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -19582,6 +19664,17 @@ var init_snapshot = __esm({
 });
 
 // src/mesh/mesh-event-forwarding.ts
+function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
+  if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
+  if (task.status === "assigned") return true;
+  const al = task.autoLaunch;
+  if (!al) return true;
+  if (al.status === "started" || al.status === "completed") {
+    const launchedAtMs = Date.parse(al.updatedAt);
+    return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+  }
+  return true;
+}
 function resolveCoordinatorDrainDaemonIds(components) {
   const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
   const machineId = readNonEmptyString2(loadConfig().machineId);
@@ -20295,7 +20388,8 @@ function injectMeshSystemMessage(components, args) {
     }
     if (args.event === "worktree_bootstrap_complete" && bootstrapNodeId) {
       try {
-        worktreeHasQueuedTask = getQueue(args.meshId, { status: ["pending", "assigned"] }).some((task) => meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId));
+        const nowMs = Date.now();
+        worktreeHasQueuedTask = getQueue(args.meshId, { status: ["pending", "assigned"] }).some((task) => bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs));
       } catch (e) {
         LOG.warn("MeshQueue", `Failed to check queued task for ${bootstrapNodeId} (mesh ${args.meshId}): ${e?.message || e}`);
       }
@@ -42586,7 +42680,11 @@ var FsmDriver = class {
     if (!rule) return null;
     const hay = sectionText(sections, rule.section, fullScreen);
     const minCount = rule.min_count ?? 2;
-    const buttons = extractButtonsFromRule(rule, hay);
+    let buttons = extractButtonsFromRule(rule, hay);
+    if (buttons.length < minCount && rule.section) {
+      const whole = extractButtonsFromRule(rule, fullScreen);
+      if (whole.length >= minCount) buttons = whole;
+    }
     if (buttons.length < minCount) return null;
     const title = this.deriveTitle(state, sections, fullScreen);
     return { title, buttons };
@@ -55686,11 +55784,11 @@ var meshCrudHandlers = {
         MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
       } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
       const { mkdirSync: mkdirSync22, writeFileSync: writeFileSync24 } = await import("fs");
-      const { dirname: dirname17, join: join51 } = await import("path");
+      const { dirname: dirname17, join: join52 } = await import("path");
       const scaffold = buildMeshJsonConfigScaffold2(mesh);
       const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
       const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
-      const absolutePath = join51(workspace, relativePath);
+      const absolutePath = join52(workspace, relativePath);
       const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
       if (!validation.valid) {
         return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
@@ -56760,7 +56858,7 @@ init_worktree_bootstrap_config();
 init_change_impact_config();
 init_mesh_config();
 import { existsSync as existsSync39, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname11, join as join42 } from "path";
+import { dirname as dirname11, join as join43 } 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 MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
@@ -56775,7 +56873,7 @@ var CANDIDATE_STALE_INPUTS = [
   "requirements.txt"
 ];
 function writeConfigFile(workspace, relativePath, config) {
-  const target = join42(workspace, relativePath);
+  const target = join43(workspace, relativePath);
   mkdirSync15(dirname11(target), { recursive: true });
   writeFileSync18(target, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
@@ -56783,14 +56881,14 @@ function writeConfigFile(workspace, relativePath, config) {
 }
 function suggestMeshWorktreeBootstrapConfig(workspace) {
   const commands = [];
-  const hasPackageJson = existsSync39(join42(workspace, "package.json"));
-  const hasNpmLock = existsSync39(join42(workspace, "package-lock.json"));
+  const hasPackageJson = existsSync39(join43(workspace, "package.json"));
+  const hasNpmLock = existsSync39(join43(workspace, "package-lock.json"));
   if (hasPackageJson) {
     commands.push(
       hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
     );
   }
-  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync39(join42(workspace, relative5)));
+  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync39(join43(workspace, relative5)));
   if (!commands.length) {
     return { commands, staleInputs };
   }
@@ -56889,7 +56987,7 @@ function runMeshInit(mesh, workspace, detected, options = {}) {
 }
 function applyConfigSuggestion(input) {
   const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-  const absolute = join42(workspace, relativePath);
+  const absolute = join43(workspace, relativePath);
   if (existing !== void 0 && !overwrite) {
     return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
   }
@@ -70789,7 +70887,7 @@ import { dirname as dirname15, resolve as resolve23 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
 import { readFileSync as readFileSync41, existsSync as existsSync54 } from "fs";
-import { resolve as resolve24, dirname as dirname16, join as join50 } from "path";
+import { resolve as resolve24, dirname as dirname16, join as join51 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
 init_manifest();