@adhdev/daemon-core 0.9.82-rc.406 → 0.9.82-rc.408

package/dist/index.js

@@ -399,10 +399,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "1a663e37a08bce5e83cc14be4663d33ad60e81c9" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "1a663e37" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.406" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-28T04:52:22.784Z" : void 0);
+  const commit = readInjected(true ? "b6de7b335f9b6b6bfb202135c2ae017429182efa" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "b6de7b33" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.408" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-28T07:53:15.742Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -655,6 +655,11 @@ var init_change_impact_config = __esm({
 });
 
 // src/git/git-status.ts
+function statusCacheKey(workspace, options) {
+  const includeSubmodules = options.includeSubmodules !== false;
+  const refreshUpstream = options.refreshUpstream === true;
+  return `${workspace}\0sub=${includeSubmodules ? 1 : 0}\0up=${refreshUpstream ? 1 : 0}`;
+}
 function isTransientGitFailure(error) {
   return error.reason === "timeout" || error.reason === "git_command_failed";
 }
@@ -662,15 +667,22 @@ async function getGitRepoStatus(workspace, options = {}) {
   const lastCheckedAt = Date.now();
   const includeSubmodules = options.includeSubmodules !== false;
   const effectiveOptions = options.timeoutMs === void 0 ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
+  const cacheKey = statusCacheKey(workspace, options);
+  if (!options.forceFresh) {
+    const cached3 = lastKnownGoodStatus.get(cacheKey);
+    if (cached3 && lastCheckedAt - cached3.cachedAt < GIT_STATUS_CACHE_TTL_MS) {
+      return cached3.status;
+    }
+  }
   try {
     const repo = await resolveGitRepository(workspace, effectiveOptions);
     const status = await collectGitRepoStatus(repo, includeSubmodules, lastCheckedAt, effectiveOptions);
-    lastKnownGoodStatus.set(workspace, status);
+    lastKnownGoodStatus.set(cacheKey, { status, cachedAt: lastCheckedAt });
     return status;
   } catch (error) {
     const gitError = error instanceof GitCommandError ? error : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error });
     if (isTransientGitFailure(gitError)) {
-      const cached3 = lastKnownGoodStatus.get(workspace);
+      const cached3 = lastKnownGoodStatus.get(cacheKey)?.status;
       if (cached3) {
         return {
           ...cached3,
@@ -689,19 +701,25 @@ async function collectGitRepoStatus(repo, includeSubmodules, lastCheckedAt, opti
   let upstreamProbe = getInitialUpstreamProbe(parsed);
   if (options.refreshUpstream) {
     upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
-    if (upstreamProbe.upstreamStatus === "fresh") {
+    if (upstreamProbe.upstreamStatus === "fresh" && upstreamProbe.didFetch) {
       parsed = await readPorcelainStatus(repo, options);
     }
   }
   const head = await readHead(repo, options);
   const stashCount = await readStashCount(repo, options);
   let submodules;
+  let submoduleHeadOids = /* @__PURE__ */ new Map();
   if (includeSubmodules) {
-    submodules = await getSubmoduleStatuses(repo, options);
+    const subResult = await getSubmoduleStatuses(repo, options);
+    submodules = subResult.submodules;
+    submoduleHeadOids = subResult.headOidByPath;
   }
   const submoduleDirty = (submodules || []).some((submodule) => submodule.dirty || submodule.outOfSync || !!submodule.error);
   const dirty = parsed.staged + parsed.modified + parsed.untracked + parsed.deleted + parsed.renamed > 0 || parsed.conflictFiles.length > 0 || stashCount > 0 || submoduleDirty;
-  const daemonBuildBehind = await detectDaemonBuildBehind(repo, submodules, options);
+  const daemonBuildBehind = await detectDaemonBuildBehind(repo, submodules, options, {
+    rootHeadOid: parsed.headOid,
+    submoduleHeadOids
+  });
   return {
     workspace: repo.workspace,
     repoRoot: repo.repoRoot,
@@ -804,25 +822,50 @@ function resolveChangeImpactConfigForRepo(repoRoot, options) {
   changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config });
   return { config, sourceKey: loaded.sourceKey };
 }
-async function detectDaemonBuildBehind(repo, submodules, options) {
+async function detectDaemonBuildBehind(repo, submodules, options, headOids = { rootHeadOid: null, submoduleHeadOids: /* @__PURE__ */ new Map() }) {
   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 }
+    { scope: "root", repoPath: repo.repoRoot || repo.workspace, knownHeadOid: headOids.rootHeadOid }
   ];
   for (const sub of submodules || []) {
-    if (sub.repoPath && !sub.error) scopes.push({ scope: sub.path, repoPath: sub.repoPath });
+    if (sub.repoPath && !sub.error) {
+      scopes.push({ scope: sub.path, repoPath: sub.repoPath, knownHeadOid: headOids.submoduleHeadOids.get(sub.path) ?? null });
+    }
   }
-  for (const { scope, repoPath } of scopes) {
+  for (const { scope, repoPath, knownHeadOid } of scopes) {
     try {
-      await runGit(repoPath, ["cat-file", "-e", `${build.commit}^{commit}`], options);
-      const headResult = await runGit(repoPath, ["rev-parse", "HEAD"], options);
-      const head = headResult.stdout.trim();
-      if (!head || head === build.commit) continue;
-      await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
+      let head = knownHeadOid;
+      const ancestryKey = head ? `${repoPath}::${build.commit}::${head}` : null;
+      if (ancestryKey) {
+        const cachedVerdict = buildBehindAncestryCache.get(ancestryKey);
+        if (cachedVerdict === false) continue;
+        if (cachedVerdict === void 0) {
+          if (head === build.commit) {
+            buildBehindAncestryCache.set(ancestryKey, false);
+            continue;
+          }
+          await runGit(repoPath, ["cat-file", "-e", `${build.commit}^{commit}`], options);
+          try {
+            await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
+          } catch {
+            buildBehindAncestryCache.set(ancestryKey, false);
+            continue;
+          }
+          buildBehindAncestryCache.set(ancestryKey, true);
+        }
+      } else {
+        await runGit(repoPath, ["cat-file", "-e", `${build.commit}^{commit}`], options);
+        const headResult = await runGit(repoPath, ["rev-parse", "HEAD"], options);
+        head = headResult.stdout.trim();
+        if (!head || head === build.commit) continue;
+        await runGit(repoPath, ["merge-base", "--is-ancestor", build.commit, "HEAD"], options);
+        buildBehindAncestryCache.set(`${repoPath}::${build.commit}::${head}`, true);
+      }
       const evalKey = `${repoPath}\0${build.commit}\0${head}\0${configKey}`;
+      if (!head) continue;
       let evaluated = changeImpactEvalCache.get(evalKey);
       if (!evaluated) {
         evaluated = await classifyDaemonBuildChange(repoPath, build.commit, options, policy);
@@ -864,6 +907,15 @@ async function refreshTrackedUpstream(repo, parsed, options) {
   if (!parsed.upstream || !parsed.branch) {
     return { upstreamStatus: "no_upstream" };
   }
+  const now = Date.now();
+  const lastFetch = upstreamFetchedAt.get(repo.workspace);
+  if (!options.forceFresh && lastFetch !== void 0 && now - lastFetch < GIT_FETCH_THROTTLE_MS) {
+    return {
+      upstreamStatus: "fresh",
+      upstreamFetchedAt: lastFetch,
+      didFetch: false
+    };
+  }
   const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
   if (!remoteName) {
     return {
@@ -873,9 +925,12 @@ async function refreshTrackedUpstream(repo, parsed, options) {
   }
   try {
     await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+    const fetchedAt = Date.now();
+    upstreamFetchedAt.set(repo.workspace, fetchedAt);
     return {
       upstreamStatus: "fresh",
-      upstreamFetchedAt: Date.now()
+      upstreamFetchedAt: fetchedAt,
+      didFetch: true
     };
   } catch (error) {
     return {
@@ -908,6 +963,7 @@ function formatGitError(error) {
 function parsePorcelainV2Status(output) {
   const parsed = {
     branch: null,
+    headOid: null,
     upstream: null,
     ahead: 0,
     behind: 0,
@@ -920,6 +976,11 @@ function parsePorcelainV2Status(output) {
   };
   for (const line of output.split("\n")) {
     if (!line) continue;
+    if (line.startsWith("# branch.oid ")) {
+      const oid = line.slice("# branch.oid ".length).trim();
+      parsed.headOid = oid && oid !== "(initial)" && /^[0-9a-f]{7,64}$/.test(oid) ? oid : null;
+      continue;
+    }
     if (line.startsWith("# branch.head ")) {
       const branch = line.slice("# branch.head ".length).trim();
       parsed.branch = branch && branch !== "(detached)" ? branch : null;
@@ -1017,25 +1078,27 @@ function emptyStatus(workspace, lastCheckedAt, error) {
   };
 }
 async function getSubmoduleStatuses(repo, options) {
-  if (!repo.repoRoot) return [];
+  if (!repo.repoRoot) return { submodules: [], headOidByPath: /* @__PURE__ */ new Map() };
   try {
-    const submodules = await deriveSubmoduleGitlinkStatuses(repo, options);
+    const { submodules, headOidByPath } = await deriveSubmoduleGitlinkStatuses(repo, options);
     await Promise.all(submodules.map((submodule) => enrichSubmoduleWorktreeStatus(repo, submodule, options)));
-    return submodules;
+    return { submodules, headOidByPath };
   } catch {
-    return [];
+    return { submodules: [], headOidByPath: /* @__PURE__ */ new Map() };
   }
 }
 async function deriveSubmoduleGitlinkStatuses(repo, options) {
-  if (!repo.repoRoot) return [];
+  if (!repo.repoRoot) return { submodules: [], headOidByPath: /* @__PURE__ */ new Map() };
   const paths = await readSubmodulePaths(repo, options);
   const ignoreSet = new Set(options.submoduleIgnorePaths || []);
   const lastCheckedAt = Date.now();
+  const headOidByPath = /* @__PURE__ */ new Map();
   const entries = await Promise.all(
     paths.filter((path43) => !ignoreSet.has(path43)).map(async (path43) => {
       const repoPath = repo.repoRoot + "/" + path43;
       const expected = await readGitlinkExpectedSha(repo, path43, options);
       const actual = await readSubmoduleHeadSha(repo, repoPath, options);
+      if (actual) headOidByPath.set(path43, actual);
       const outOfSync = actual === null ? true : expected !== null && expected !== actual;
       return {
         path: path43,
@@ -1049,7 +1112,7 @@ async function deriveSubmoduleGitlinkStatuses(repo, options) {
       };
     })
   );
-  return entries;
+  return { submodules: entries, headOidByPath };
 }
 async function readSubmodulePaths(repo, options) {
   if (!repo.repoRoot) return [];
@@ -1106,16 +1169,20 @@ async function enrichSubmoduleWorktreeStatus(repo, submodule, options) {
     submodule.error = formatGitError(error);
   }
 }
-var lastKnownGoodStatus, changeImpactEvalCache, changeImpactConfigCache, DEFAULT_DAEMON_RUNTIME_PACKAGES, DEFAULT_WEB_ONLY_PACKAGES, DEFAULT_IMPACT_TARGETS;
+var GIT_STATUS_CACHE_TTL_MS, lastKnownGoodStatus, changeImpactEvalCache, changeImpactConfigCache, buildBehindAncestryCache, GIT_FETCH_THROTTLE_MS, upstreamFetchedAt, 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();
+    GIT_STATUS_CACHE_TTL_MS = 1500;
     lastKnownGoodStatus = /* @__PURE__ */ new Map();
     changeImpactEvalCache = /* @__PURE__ */ new Map();
     changeImpactConfigCache = /* @__PURE__ */ new Map();
+    buildBehindAncestryCache = /* @__PURE__ */ new Map();
+    GIT_FETCH_THROTTLE_MS = 3e4;
+    upstreamFetchedAt = /* @__PURE__ */ new Map();
     DEFAULT_DAEMON_RUNTIME_PACKAGES = [
       "daemon-core",
       "daemon-standalone",
@@ -2995,7 +3062,7 @@ function normalizeGitStatus(status, node, options) {
   const repoRoot = readString3(status.repoRoot, status.repo_root, node.repoRoot, node.repo_root, status.workspace, node.workspace) || void 0;
   const submodules = readGitSubmodules(status.submodules, repoRoot);
   const upstreamStatus = readString3(status.upstreamStatus, status.upstream_status);
-  const upstreamFetchedAt = readNumber(status.upstreamFetchedAt, status.upstream_fetched_at);
+  const upstreamFetchedAt2 = readNumber(status.upstreamFetchedAt, status.upstream_fetched_at);
   const upstreamFetchError = readString3(status.upstreamFetchError, status.upstream_fetch_error);
   const error = readString3(status.error);
   const staged = readNumber(status.staged) ?? 0;
@@ -3012,7 +3079,7 @@ function normalizeGitStatus(status, node, options) {
     headMessage: readString3(status.headMessage) ?? null,
     upstream: readString3(status.upstream) ?? null,
     upstreamStatus: upstreamStatus ?? "unchecked",
-    ...upstreamFetchedAt !== void 0 ? { upstreamFetchedAt } : {},
+    ...upstreamFetchedAt2 !== void 0 ? { upstreamFetchedAt: upstreamFetchedAt2 } : {},
     ...upstreamFetchError ? { upstreamFetchError } : {},
     ahead: readNumber(status.ahead) ?? 0,
     behind: readNumber(status.behind) ?? 0,
@@ -4685,6 +4752,7 @@ __export(mesh_work_queue_exports, {
   getQueue: () => getQueue,
   hasPendingDependents: () => hasPendingDependents,
   insertDirectDispatch: () => insertDirectDispatch,
+  isTaskReadonly: () => isTaskReadonly,
   markStaleDirectDispatches: () => markStaleDirectDispatches,
   nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
   normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
@@ -4700,6 +4768,10 @@ __export(mesh_work_queue_exports, {
   updateTaskStatus: () => updateTaskStatus,
   validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
 });
+function isTaskReadonly(task) {
+  if (!task) return false;
+  return task.readonly === true || task.taskMode === "live_debug_readonly";
+}
 function hasNegationBefore(text, matchIndex) {
   const before = text.slice(0, matchIndex);
   const clauseStart = Math.max(
@@ -4885,13 +4957,11 @@ function normalizeMeshTaskMode(value) {
   const normalized = value.trim();
   return MESH_TASK_MODES.includes(normalized) ? normalized : void 0;
 }
-function validateMeshTaskModeRequest(mode, message) {
+function validateMeshTaskModeRequest(mode, message, readonly) {
   const taskMode = normalizeMeshTaskMode(mode);
-  if (!taskMode) {
-    return { valid: true, violations: [] };
-  }
-  if (taskMode !== "live_debug_readonly") {
-    return { valid: true, taskMode, violations: [] };
+  const isReadonly = isTaskReadonly({ readonly, taskMode });
+  if (!isReadonly) {
+    return taskMode ? { valid: true, taskMode, violations: [] } : { valid: true, violations: [] };
   }
   const text = message || "";
   const violations = LIVE_DEBUG_READONLY_FORBIDDEN.filter((rule) => patternHasRealMutation(rule.pattern, text)).map((rule) => rule.label);
@@ -5018,7 +5088,8 @@ function assertNoDependencyCycle(meshId, newTaskId, dependsOn) {
 }
 function enqueueTask(meshId, message, opts) {
   requireMeshHostQueueOwner(opts);
-  const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message);
+  const readonly = opts?.readonly === true;
+  const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message, readonly);
   if (!modeValidation.valid) {
     throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
   }
@@ -5042,6 +5113,7 @@ function enqueueTask(meshId, message, opts) {
       message,
       status: "pending",
       taskMode: modeValidation.taskMode,
+      ...readonly ? { readonly: true } : {},
       targetNodeId: opts?.targetNodeId,
       targetSessionId: opts?.targetSessionId,
       requiredTags: resolvedRequiredTags,
@@ -5060,7 +5132,8 @@ function recordDirectDispatchTask(meshId, message, opts) {
   if (!missionId) return null;
   const taskId = typeof opts.id === "string" ? opts.id.trim() : "";
   if (!taskId) return null;
-  const modeValidation = validateMeshTaskModeRequest(opts.taskMode, message);
+  const readonly = opts.readonly === true;
+  const modeValidation = validateMeshTaskModeRequest(opts.taskMode, message, readonly);
   if (!modeValidation.valid) {
     throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
   }
@@ -5075,6 +5148,7 @@ function recordDirectDispatchTask(meshId, message, opts) {
       message,
       status: "assigned",
       ...modeValidation.taskMode ? { taskMode: modeValidation.taskMode } : {},
+      ...readonly ? { readonly: true } : {},
       missionId,
       ...opts.assignedNodeId ? { targetNodeId: opts.assignedNodeId, assignedNodeId: opts.assignedNodeId } : {},
       ...opts.assignedSessionId ? { targetSessionId: opts.assignedSessionId, assignedSessionId: opts.assignedSessionId } : {},
@@ -6055,7 +6129,7 @@ var init_mesh_runtime_store = __esm({
             return deps.every((depId) => depStatus.get(depId) === "completed");
           };
           const nodeConflictAllows = (candidate) => {
-            if (candidate.taskMode === "live_debug_readonly") return true;
+            if (isTaskReadonly(candidate)) return true;
             return !nodeBusy;
           };
           const nodeIsWorktree = opts?.nodeIsWorktree === true;
@@ -9267,7 +9341,7 @@ var init_mesh_fast_forward = __esm({
     "use strict";
     init_git_status();
     init_git_executor();
-    STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
+    STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3, forceFresh: true };
   }
 });
 
@@ -9667,9 +9741,6 @@ var mesh_scheduling_runtime_exports = {};
 __export(mesh_scheduling_runtime_exports, {
   buildMeshSchedulingRuntime: () => buildMeshSchedulingRuntime
 });
-function isReadonly(task) {
-  return task.taskMode === "live_debug_readonly";
-}
 function isAssigned(task) {
   return task.status === "assigned";
 }
@@ -9678,8 +9749,8 @@ function buildMeshSchedulingRuntime(mesh, queue) {
   const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
   const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
   const assignedTasks = (Array.isArray(queue) ? queue : []).filter(isAssigned);
-  const activeWriteAssigned = assignedTasks.filter((t) => !isReadonly(t)).length;
-  const activeReadonlyAssigned = assignedTasks.filter(isReadonly).length;
+  const activeWriteAssigned = assignedTasks.filter((t) => !isTaskReadonly(t)).length;
+  const activeReadonlyAssigned = assignedTasks.filter(isTaskReadonly).length;
   const globalWriteCapReached = activeWriteAssigned >= maxParallelTasks;
   const globalReadonlyCapReached = activeReadonlyAssigned >= maxReadonlyParallelTasks;
   const writeAssignedByNode = /* @__PURE__ */ new Map();
@@ -9689,7 +9760,7 @@ function buildMeshSchedulingRuntime(mesh, queue) {
     const nodeId = typeof task.assignedNodeId === "string" ? task.assignedNodeId.trim() : "";
     if (!nodeId) continue;
     assignedByNode.set(nodeId, (assignedByNode.get(nodeId) ?? 0) + 1);
-    if (!isReadonly(task)) {
+    if (!isTaskReadonly(task)) {
       writeAssignedByNode.set(nodeId, (writeAssignedByNode.get(nodeId) ?? 0) + 1);
     }
     const provider = typeof task.assignedProviderType === "string" ? task.assignedProviderType : "";
@@ -9762,6 +9833,7 @@ var init_mesh_scheduling_runtime = __esm({
     "use strict";
     init_repo_mesh_types();
     init_dist();
+    init_mesh_work_queue();
   }
 });
 
@@ -12161,10 +12233,10 @@ function resolveAutoLaunchTarget(components, node) {
   return { mode: "remote", daemonId, coordinatorDaemonId };
 }
 function activeWriteAssignedCount(meshId) {
-  return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.taskMode !== "live_debug_readonly").length;
+  return getQueue(meshId, { status: ["assigned"] }).filter((task) => !isTaskReadonly(task)).length;
 }
 function activeReadonlyAssignedCount(meshId) {
-  return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.taskMode === "live_debug_readonly").length;
+  return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
 }
 function nodeHasActiveAssignment(meshId, nodeId) {
   return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
@@ -12340,8 +12412,8 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   );
   const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks, schedulingOverride?.readonlyMultiplier);
   for (const task of pending) {
-    const isReadonly2 = task.taskMode === "live_debug_readonly";
-    if (isReadonly2) {
+    const isReadonly = isTaskReadonly(task);
+    if (isReadonly) {
       if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
         markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_readonly_parallel_tasks_reached" });
         continue;
@@ -12423,7 +12495,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         sweepExpiredCooldowns();
         continue;
       }
-      if (task.taskMode !== "live_debug_readonly" && nodeHasActiveAssignment(meshId, nodeId)) {
+      if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
         markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_active_assignment", nodeId });
         continue;
       }
@@ -13171,6 +13243,9 @@ function isModuleNotFoundError(error, ref) {
   const code = "code" in error ? error.code : void 0;
   return code === "MODULE_NOT_FOUND" && message.includes(ref);
 }
+function runtimeTriplet() {
+  return `${process.platform}-${process.arch}-node${process.versions.modules}`;
+}
 function normalizeBinding(mod, ref) {
   const binding = mod?.default?.createTerminal ? mod.default : mod?.createTerminal ? mod : null;
   if (!binding) {
@@ -13205,7 +13280,7 @@ function loadGhosttyVtBinding() {
   }
   cachedBinding = null;
   cachedBindingError = new Error(
-    `ghostty-vt binding unavailable (${errors.join("; ") || "no candidates tried"})`
+    `ghostty-vt binding unavailable for runtime ${runtimeTriplet()} (${errors.join("; ") || "no candidates tried"})`
   );
   throw cachedBindingError;
 }
@@ -16371,6 +16446,17 @@ function resolveReconcileIntervalMs() {
   }
   return DEFAULT_RECONCILE_INTERVAL_MS;
 }
+function resolveTunedReconcileMs(envName, def, min, max) {
+  const raw = readNonEmptyString2(process.env[envName]);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+  }
+  return def;
+}
+function resolveAckedDeathDeadlineMs() {
+  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
+}
 function inFlightSynthKey(meshId, taskId) {
   return `${meshId}::${taskId}`;
 }
@@ -16947,15 +17033,42 @@ function unwrapReadChatPayload(raw) {
 function readChatPayloadStatus(payload) {
   return readNonEmptyString2(payload?.status).toLowerCase();
 }
+function realTerminalEmitPendingForTask(meshId, taskId) {
+  let pending;
+  try {
+    pending = getPendingMeshCoordinatorEvents(meshId);
+  } catch {
+    return false;
+  }
+  return pending.some((e) => readNonEmptyString2(e.metadataEvent?.taskId) === taskId && (e.event === "agent:generating_completed" || e.event === "agent:stopped"));
+}
+async function reprobeWorkerStatus(components, args) {
+  try {
+    if (args.isLocalNode) {
+      const r = await components.commandHandler.handle("read_chat", args.readArgs);
+      if (r && r.success === false) return null;
+      return readChatPayloadStatus(unwrapReadChatPayload(r));
+    }
+    if (components.dispatchMeshCommand) {
+      const r = await components.dispatchMeshCommand(args.nodeDaemonId, "read_chat", args.readArgs);
+      const p = unwrapReadChatPayload(r);
+      if (p && p.success === false) return null;
+      return readChatPayloadStatus(p);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
   const dispatches = getActiveDirectDispatches(mesh.id);
   if (dispatches.length === 0) return;
   const activeTaskKeys = new Set(
     dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
   );
-  for (const key of inFlightIdleObservationCounts.keys()) {
+  for (const key of inFlightAckedHoldState.keys()) {
     if (key.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key)) {
-      inFlightIdleObservationCounts.delete(key);
+      inFlightAckedHoldState.delete(key);
     }
   }
   const dispatchMeshCommand = components.dispatchMeshCommand;
@@ -16976,35 +17089,63 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
       ...node?.workspace ? { workspace: node.workspace } : {},
       ...providerType ? { agentType: providerType, providerType } : {}
     };
+    const synthKey = inFlightSynthKey(mesh.id, taskId);
+    const isAcked = dispatch.status === "acked";
     let payload = null;
+    let readFailed = false;
     try {
       if (isLocalNode) {
         const result = await components.commandHandler.handle("read_chat", readArgs);
-        if (result && result.success === false) continue;
-        payload = unwrapReadChatPayload(result);
+        if (result && result.success === false) {
+          readFailed = true;
+        } else {
+          payload = unwrapReadChatPayload(result);
+        }
       } else if (dispatchMeshCommand) {
         const result = await dispatchMeshCommand(nodeDaemonId, "read_chat", readArgs);
         payload = unwrapReadChatPayload(result);
-        if (payload && payload.success === false) continue;
+        if (payload && payload.success === false) {
+          payload = null;
+          readFailed = true;
+        }
       } else {
         continue;
       }
     } catch {
+      readFailed = true;
+    }
+    if (!payload && !readFailed) continue;
+    if (readFailed || !payload) {
+      if (isAcked) {
+        const prior = inFlightAckedHoldState.get(synthKey);
+        const failures = (prior?.consecutiveReadFailures ?? 0) + 1;
+        const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
+        inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
+        if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
+          LOG.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
+        }
+      }
       continue;
     }
-    if (!payload) continue;
-    const synthKey = inFlightSynthKey(mesh.id, taskId);
+    inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+    const nowMs = Date.now();
     if (readChatPayloadStatus(payload) !== "idle") {
-      inFlightIdleObservationCounts.delete(synthKey);
       continue;
     }
-    if (dispatch.status === "acked") {
-      const idleStreak = (inFlightIdleObservationCounts.get(synthKey) ?? 0) + 1;
-      inFlightIdleObservationCounts.set(synthKey, idleStreak);
-      if (idleStreak < REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH) {
-        LOG.info("MeshReconcile", `In-flight synth hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${idleStreak}/${REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH} consecutive tick(s) after generating_started \u2014 deferring completion synth until the idle settle is confirmed (guards against a mid-turn idle flicker pre-empting the real completion)`);
+    if (isAcked) {
+      const ackedAtMs = Date.parse(readNonEmptyString2(dispatch.updatedAt));
+      const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
+      const deathDeadlineMs = resolveAckedDeathDeadlineMs();
+      if (sinceAckMs < deathDeadlineMs) {
+        LOG.info("MeshReconcile", `Acked-hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1e3) + "s" : "\u221E"} since the generating_started ack \u2014 HOLDING synth indefinitely (worker is alive and will emit; a later real emit is idempotent). Death backstop fires at ${Math.round(deathDeadlineMs / 1e3)}s or on consecutive read failures.`);
         continue;
       }
+      LOG.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
+    }
+    if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
+      inFlightAckedHoldState.delete(synthKey);
+      LOG.info("MeshReconcile", `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued \u2014 yielding synth to the worker's own emit`);
+      continue;
     }
     const messages = Array.isArray(payload.messages) ? payload.messages : [];
     const evidence = extractFinalAssistantSummaryEvidence(messages);
@@ -17022,6 +17163,12 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
       }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
       continue;
     }
+    const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+    if (reprobeStatus && reprobeStatus !== "idle") {
+      inFlightAckedHoldState.delete(synthKey);
+      LOG.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
+      continue;
+    }
     const providerSessionId = readNonEmptyString2(payload.providerSessionId);
     const coordinatorDaemonId = selfIds.find((id) => !!id);
     try {
@@ -17160,7 +17307,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH, inFlightIdleObservationCounts, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -17182,8 +17329,8 @@ var init_mesh_reconcile_loop = __esm({
     init_chat_message_normalization();
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
     DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
-    REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH = 2;
-    inFlightIdleObservationCounts = /* @__PURE__ */ new Map();
+    ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
+    inFlightAckedHoldState = /* @__PURE__ */ new Map();
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -23075,6 +23222,7 @@ __export(index_exports, {
   isSessionHostLiveRuntime: () => isSessionHostLiveRuntime,
   isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot,
   isSetupComplete: () => isSetupComplete,
+  isTaskReadonly: () => isTaskReadonly,
   isUserFacingChatMessage: () => isUserFacingChatMessage,
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
@@ -24166,7 +24314,7 @@ function validateMutatingMessage(value) {
 async function gitCheckpoint(workspace, message, includeUntracked) {
   const repo = await resolveGitRepository(workspace);
   const repoRoot = repo.repoRoot;
-  const statusResult = await getGitRepoStatus(workspace);
+  const statusResult = await getGitRepoStatus(workspace, { forceFresh: true });
   if (statusResult.hasConflicts) {
     throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
   }
@@ -52962,7 +53110,10 @@ async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, cur
   const preStatus = await getGitRepoStatus(repoRoot, {
     includeSubmodules: true,
     submoduleIgnorePaths: options.submoduleIgnorePaths,
-    timeoutMs: 15e3
+    timeoutMs: 15e3,
+    // Decision path — the out-of-sync submodule set drives a mutating `submodule
+    // update`. Must not act on a TTL-cached status; bypass the C1 cache.
+    forceFresh: true
   });
   const outOfSyncPaths = (preStatus.submodules || []).filter((submodule) => submodule.dirty || submodule.outOfSync || !!submodule.error).map((submodule) => submodule.path);
   const updatePaths = [.../* @__PURE__ */ new Set([...changedGitlinkPaths, ...outOfSyncPaths])].sort();
@@ -52991,7 +53142,10 @@ async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, cur
     const postStatus = await getGitRepoStatus(repoRoot, {
       includeSubmodules: true,
       submoduleIgnorePaths: options.submoduleIgnorePaths,
-      timeoutMs: 15e3
+      timeoutMs: 15e3,
+      // Re-read AFTER `submodule update` mutated the tree — MUST be fresh, never the
+      // cached preStatus from moments ago (which would falsely report still-dirty).
+      forceFresh: true
     });
     const remaining = (postStatus.submodules || []).filter((submodule) => updatePaths.includes(submodule.path) && (submodule.dirty || submodule.outOfSync || !!submodule.error));
     return {
@@ -64440,6 +64594,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   isSessionHostLiveRuntime,
   isSessionHostRecoverySnapshot,
   isSetupComplete,
+  isTaskReadonly,
   isUserFacingChatMessage,
   killIdeProcess,
   launchIDE,