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

package/dist/index.js

@@ -30127,10 +30127,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "1a663e37a08bce5e83cc14be4663d33ad60e81c9" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "1a663e37" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:54.674Z" : 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 version2 = 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:54:01.430Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30383,6 +30383,11 @@ var require_dist3 = __commonJS({
         };
       }
     });
+    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(error48) {
       return error48.reason === "timeout" || error48.reason === "git_command_failed";
     }
@@ -30390,15 +30395,22 @@ var require_dist3 = __commonJS({
       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 (error48) {
         const gitError = error48 instanceof GitCommandError ? error48 : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 });
         if (isTransientGitFailure(gitError)) {
-          const cached3 = lastKnownGoodStatus.get(workspace);
+          const cached3 = lastKnownGoodStatus.get(cacheKey)?.status;
           if (cached3) {
             return {
               ...cached3,
@@ -30417,19 +30429,25 @@ var require_dist3 = __commonJS({
       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,
@@ -30532,25 +30550,50 @@ var require_dist3 = __commonJS({
       changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config: config2 });
       return { config: config2, 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: config2, sourceKey: configKey } = resolveChangeImpactConfigForRepo(repo.repoRoot, options);
       const policy = resolveChangeImpactPolicy(config2);
       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);
@@ -30592,6 +30635,15 @@ var require_dist3 = __commonJS({
       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 {
@@ -30601,9 +30653,12 @@ var require_dist3 = __commonJS({
       }
       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 (error48) {
         return {
@@ -30636,6 +30691,7 @@ var require_dist3 = __commonJS({
     function parsePorcelainV2Status(output) {
       const parsed = {
         branch: null,
+        headOid: null,
         upstream: null,
         ahead: 0,
         behind: 0,
@@ -30648,6 +30704,11 @@ var require_dist3 = __commonJS({
       };
       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;
@@ -30745,25 +30806,27 @@ var require_dist3 = __commonJS({
       };
     }
     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,
@@ -30777,7 +30840,7 @@ var require_dist3 = __commonJS({
           };
         })
       );
-      return entries;
+      return { submodules: entries, headOidByPath };
     }
     async function readSubmodulePaths(repo, options) {
       if (!repo.repoRoot) return [];
@@ -30834,9 +30897,13 @@ var require_dist3 = __commonJS({
         submodule.error = formatGitError(error48);
       }
     }
+    var GIT_STATUS_CACHE_TTL_MS;
     var lastKnownGoodStatus;
     var changeImpactEvalCache;
     var changeImpactConfigCache;
+    var buildBehindAncestryCache;
+    var GIT_FETCH_THROTTLE_MS;
+    var upstreamFetchedAt;
     var DEFAULT_DAEMON_RUNTIME_PACKAGES;
     var DEFAULT_WEB_ONLY_PACKAGES;
     var DEFAULT_IMPACT_TARGETS;
@@ -30846,9 +30913,13 @@ var require_dist3 = __commonJS({
         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",
@@ -32733,7 +32804,7 @@ ${error48.message || ""}`;
       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 error48 = readString3(status.error);
       const staged = readNumber(status.staged) ?? 0;
@@ -32750,7 +32821,7 @@ ${error48.message || ""}`;
         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,
@@ -34457,6 +34528,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       getQueue: () => getQueue,
       hasPendingDependents: () => hasPendingDependents,
       insertDirectDispatch: () => insertDirectDispatch,
+      isTaskReadonly: () => isTaskReadonly,
       markStaleDirectDispatches: () => markStaleDirectDispatches,
       nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
       normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
@@ -34472,6 +34544,10 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       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(
@@ -34657,13 +34733,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const normalized = value.trim();
       return MESH_TASK_MODES.includes(normalized) ? normalized : void 0;
     }
-    function validateMeshTaskModeRequest(mode, message) {
+    function validateMeshTaskModeRequest(mode, message, readonly2) {
       const taskMode = normalizeMeshTaskMode(mode);
-      if (!taskMode) {
-        return { valid: true, violations: [] };
-      }
-      if (taskMode !== "live_debug_readonly") {
-        return { valid: true, taskMode, violations: [] };
+      const isReadonly = isTaskReadonly({ readonly: readonly2, 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);
@@ -34790,7 +34864,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function enqueueTask(meshId, message, opts) {
       requireMeshHostQueueOwner(opts);
-      const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message);
+      const readonly2 = opts?.readonly === true;
+      const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message, readonly2);
       if (!modeValidation.valid) {
         throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
       }
@@ -34814,6 +34889,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           message,
           status: "pending",
           taskMode: modeValidation.taskMode,
+          ...readonly2 ? { readonly: true } : {},
           targetNodeId: opts?.targetNodeId,
           targetSessionId: opts?.targetSessionId,
           requiredTags: resolvedRequiredTags,
@@ -34832,7 +34908,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       if (!missionId) return null;
       const taskId = typeof opts.id === "string" ? opts.id.trim() : "";
       if (!taskId) return null;
-      const modeValidation = validateMeshTaskModeRequest(opts.taskMode, message);
+      const readonly2 = opts.readonly === true;
+      const modeValidation = validateMeshTaskModeRequest(opts.taskMode, message, readonly2);
       if (!modeValidation.valid) {
         throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
       }
@@ -34847,6 +34924,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           message,
           status: "assigned",
           ...modeValidation.taskMode ? { taskMode: modeValidation.taskMode } : {},
+          ...readonly2 ? { readonly: true } : {},
           missionId,
           ...opts.assignedNodeId ? { targetNodeId: opts.assignedNodeId, assignedNodeId: opts.assignedNodeId } : {},
           ...opts.assignedSessionId ? { targetSessionId: opts.assignedSessionId, assignedSessionId: opts.assignedSessionId } : {},
@@ -35839,7 +35917,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 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;
@@ -39069,7 +39147,7 @@ ${rendered}`, "utf-8");
         "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 };
       }
     });
     function readString6(value) {
@@ -39468,9 +39546,6 @@ ${rendered}`, "utf-8");
     __export2(mesh_scheduling_runtime_exports, {
       buildMeshSchedulingRuntime: () => buildMeshSchedulingRuntime
     });
-    function isReadonly(task) {
-      return task.taskMode === "live_debug_readonly";
-    }
     function isAssigned(task) {
       return task.status === "assigned";
     }
@@ -39479,8 +39554,8 @@ ${rendered}`, "utf-8");
       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();
@@ -39490,7 +39565,7 @@ ${rendered}`, "utf-8");
         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 : "";
@@ -39563,6 +39638,7 @@ ${rendered}`, "utf-8");
         "use strict";
         init_repo_mesh_types();
         init_dist();
+        init_mesh_work_queue();
       }
     });
     function readNonEmptyString2(value) {
@@ -41970,10 +42046,10 @@ Next step: ${nextStep}`;
       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);
@@ -42149,8 +42225,8 @@ Next step: ${nextStep}`;
       );
       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;
@@ -42232,7 +42308,7 @@ Next step: ${nextStep}`;
             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;
           }
@@ -42996,6 +43072,9 @@ Next step: ${nextStep}`;
       const code = "code" in error48 ? error48.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) {
@@ -43030,7 +43109,7 @@ Next step: ${nextStep}`;
       }
       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;
     }
@@ -46204,6 +46283,17 @@ ${cleanBody}`;
       }
       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}`;
     }
@@ -46780,15 +46870,42 @@ ${cleanBody}`;
     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;
@@ -46809,35 +46926,63 @@ ${cleanBody}`;
           ...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) {
+              LOG2.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) {
-            LOG2.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) {
+            LOG2.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;
           }
+          LOG2.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);
+          LOG2.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);
@@ -46855,6 +47000,12 @@ ${cleanBody}`;
           }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
           continue;
         }
+        const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+        if (reprobeStatus && reprobeStatus !== "idle") {
+          inFlightAckedHoldState.delete(synthKey);
+          LOG2.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 {
@@ -46995,8 +47146,8 @@ ${cleanBody}`;
     }
     var DEFAULT_RECONCILE_INTERVAL_MS;
     var DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
-    var REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH;
-    var inFlightIdleObservationCounts;
+    var ACKED_DEATH_CONSECUTIVE_READ_FAILURES;
+    var inFlightAckedHoldState;
     var coordinatorModalParkState;
     var heldEventLedgerRecorded;
     var ASSIGNED_STRANDED_DEADLINE_MS;
@@ -47024,8 +47175,8 @@ ${cleanBody}`;
         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;
@@ -52916,6 +53067,7 @@ ${lastSnapshot}`;
       isSessionHostLiveRuntime: () => isSessionHostLiveRuntime,
       isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot,
       isSetupComplete: () => isSetupComplete,
+      isTaskReadonly: () => isTaskReadonly,
       isUserFacingChatMessage: () => isUserFacingChatMessage,
       killIdeProcess: () => killIdeProcess,
       launchIDE: () => launchIDE,
@@ -53993,7 +54145,7 @@ ${lastSnapshot}`;
     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");
       }
@@ -82527,7 +82679,10 @@ ${mergeTreeErr?.stderr || ""}`;
       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();
@@ -82556,7 +82711,10 @@ ${mergeTreeErr?.stderr || ""}`;
         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 {