@adhdev/daemon-standalone 1.0.58-rc.45 → 1.0.58-rc.47

package/dist/index.js

@@ -31672,9 +31672,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/node_modules/b4a/index.js
+// ../daemon-core/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
+  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31830,9 +31830,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/headers.js
+// ../daemon-core/node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../../node_modules/tar-stream/headers.js"(exports2) {
+  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -32093,9 +32093,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/extract.js
+// ../daemon-core/node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32438,9 +32438,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/constants.js
+// ../daemon-core/node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32459,9 +32459,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/pack.js
+// ../daemon-core/node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32694,9 +32694,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../../node_modules/tar-stream/index.js
+// ../daemon-core/node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../../node_modules/tar-stream/index.js"(exports2) {
+  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32939,9 +32939,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../../node_modules/tar-fs/index.js
+// ../daemon-core/node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../../node_modules/tar-fs/index.js"(exports2) {
+  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f678a3c56c08e7876a714abda968b9e6a8787841" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f678a3c5" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.45" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-30T01:11:37.487Z" : void 0);
+      const commit = readInjected(true ? "f13d08263df6a24da9d6766eebfbfc7cac237235" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "f13d0826" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.47" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-30T09:04:38.562Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -41531,12 +41531,57 @@ child.on('exit', () => process.exit(0));
       const override = env2.KIMI_CODE_HOME?.trim();
       return override ? override : path11.join(os8.homedir(), ".kimi-code");
     }
-    function credentialsPath(env2) {
-      return path11.join(kimiHome(env2), "credentials", "kimi-code.json");
+    function tomlStringValue(line, key2) {
+      const escapedKey = key2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const basic = line.match(new RegExp(`^\\s*${escapedKey}\\s*=\\s*("(?:\\\\.|[^"\\\\])*")\\s*(?:#.*)?$`));
+      if (basic?.[1]) {
+        try {
+          const value = JSON.parse(basic[1]);
+          return typeof value === "string" && value.trim() ? value.trim() : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      const literal2 = line.match(new RegExp(`^\\s*${escapedKey}\\s*=\\s*'([^']*)'\\s*(?:#.*)?$`));
+      return literal2?.[1]?.trim() || void 0;
     }
-    function baseUrl4(env2) {
+    function readManagedKimiSettings(env2) {
+      let raw;
+      try {
+        raw = fs9.readFileSync(path11.join(kimiHome(env2), "config.toml"), "utf-8");
+      } catch {
+        return {};
+      }
+      let section = null;
+      const settings = {};
+      for (const line of raw.split(/\r?\n/)) {
+        const header = line.trim().match(/^\[\s*(.*?)\s*\](?:\s*#.*)?$/)?.[1];
+        if (header !== void 0) {
+          if (/^providers\s*\.\s*["']managed:kimi-code["']\s*$/.test(header)) {
+            section = "provider";
+          } else if (/^providers\s*\.\s*["']managed:kimi-code["']\s*\.\s*oauth\s*$/.test(header)) {
+            section = "oauth";
+          } else {
+            section = null;
+          }
+          continue;
+        }
+        if (section === "provider") {
+          settings.baseUrl = tomlStringValue(line, "base_url") ?? settings.baseUrl;
+        } else if (section === "oauth") {
+          settings.oauthKey = tomlStringValue(line, "key") ?? settings.oauthKey;
+        }
+      }
+      return settings;
+    }
+    function credentialsPath(env2, oauthKey) {
+      const configuredName = oauthKey?.replace(/^oauth\//, "").split("/").at(-1)?.trim();
+      const name = configuredName && configuredName !== "." && configuredName !== ".." && path11.basename(configuredName) === configuredName ? configuredName : "kimi-code";
+      return path11.join(kimiHome(env2), "credentials", `${name}.json`);
+    }
+    function baseUrl4(env2, configured) {
       const override = env2.KIMI_CODE_BASE_URL?.trim();
-      return (override ? override : DEFAULT_BASE_URL4).replace(/\/+$/, "");
+      return (override || configured || DEFAULT_BASE_URL4).replace(/\/+$/, "");
     }
     function parseCredentials3(raw) {
       let parsed;
@@ -41557,8 +41602,8 @@ child.on('exit', () => process.exit(0));
       const expiresAt = typeof expiresAtRaw === "number" && Number.isFinite(expiresAtRaw) ? expiresAtRaw : null;
       return { kind: "ok", credentials: { accessToken, expiresAt } };
     }
-    function readCredentials4(deps) {
-      const file2 = credentialsPath(deps.env);
+    function readCredentials4(deps, oauthKey) {
+      const file2 = credentialsPath(deps.env, oauthKey);
       let raw;
       try {
         raw = fs9.readFileSync(file2, "utf-8");
@@ -41683,7 +41728,8 @@ child.on('exit', () => process.exit(0));
     async function fetchKimiQuota2(overrides = {}) {
       assertInjectedNetworkFetchInTest(overrides, "fetchKimiQuota");
       const deps = resolveDeps(overrides);
-      const credentialsResult = readCredentials4(deps);
+      const settings = readManagedKimiSettings(deps.env);
+      const credentialsResult = readCredentials4(deps, settings.oauthKey);
       if (credentialsResult.kind === "missing") {
         return quotaFailure("kimi", "unavailable", "Not signed in to Kimi Code", {
           source: "oauth",
@@ -41706,7 +41752,7 @@ child.on('exit', () => process.exit(0));
         );
       }
       try {
-        const response = await deps.fetch(`${baseUrl4(deps.env)}/usages`, {
+        const response = await deps.fetch(`${baseUrl4(deps.env, settings.baseUrl)}/usages`, {
           headers: {
             Authorization: `Bearer ${credentials.accessToken}`,
             Accept: "application/json"
@@ -51820,7 +51866,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
       }
     });
     var require_canonicalize = __commonJS2({
-      "../../vendor/seqscribe/node_modules/canonicalize/lib/canonicalize.js"(exports22, module22) {
+      "../../node_modules/canonicalize/lib/canonicalize.js"(exports22, module22) {
         "use strict";
         module22.exports = function serialize(object2) {
           if (typeof object2 === "number" && isNaN(object2)) {
@@ -51930,7 +51976,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var hexes;
     var Hash;
     var init_utils = __esm2({
-      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/utils.js"() {
+      "../../node_modules/@noble/hashes/esm/utils.js"() {
         "use strict";
         hasHexBuiltin = /* @__PURE__ */ (() => (
           // @ts-ignore
@@ -51962,7 +52008,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var HashMD;
     var SHA256_IV;
     var init_md = __esm2({
-      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/_md.js"() {
+      "../../node_modules/@noble/hashes/esm/_md.js"() {
         "use strict";
         init_utils();
         HashMD = class extends Hash {
@@ -52072,7 +52118,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var SHA256;
     var sha256;
     var init_sha2 = __esm2({
-      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/sha2.js"() {
+      "../../node_modules/@noble/hashes/esm/sha2.js"() {
         "use strict";
         init_md();
         init_utils();
@@ -52218,7 +52264,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     });
     var sha2562;
     var init_sha256 = __esm2({
-      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/sha256.js"() {
+      "../../node_modules/@noble/hashes/esm/sha256.js"() {
         "use strict";
         init_sha2();
         sha2562 = sha256;
@@ -52957,7 +53003,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var HMAC;
     var hmac;
     var init_hmac = __esm2({
-      "../../vendor/seqscribe/node_modules/@noble/hashes/esm/hmac.js"() {
+      "../../node_modules/@noble/hashes/esm/hmac.js"() {
         "use strict";
         init_utils();
         HMAC = class extends Hash {
@@ -63592,8 +63638,8 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       const branch = readStringValue(node.worktreeBranch, node.worktree_branch);
       if (branch) return `\u2387 ${branch}`;
       const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
-      const basename21 = workspace ? workingDirBasename(workspace) : void 0;
-      return basename21 || (nodeId ? nodeId.slice(0, 8) : "node");
+      const basename22 = workspace ? workingDirBasename(workspace) : void 0;
+      return basename22 || (nodeId ? nodeId.slice(0, 8) : "node");
     }
     function buildMeshNodeDisplayLabel(node, nodeId, _providerPriority) {
       return buildMeshNodeMachineLabel(node, nodeId);
@@ -73985,6 +74031,96 @@ ${rendered}`, "utf-8");
           return { status: "failed", attemptId: presentation.attemptId, stage };
       }
     }
+    function pushTerminalBucket(buckets, key2, terminal) {
+      if (!key2) return;
+      let bucket2 = buckets.get(key2);
+      if (!bucket2) {
+        bucket2 = { real: [], approval: [] };
+        buckets.set(key2, bucket2);
+      }
+      (terminal.entry.kind === "task_approval_needed" ? bucket2.approval : bucket2.real).push(terminal);
+    }
+    function pushTerminalQuery(queries, key2, query) {
+      if (!key2) return;
+      const existing = queries.get(key2);
+      if (existing) existing.push(query);
+      else queries.set(key2, [query]);
+    }
+    function earlierTerminal(a, b) {
+      if (!a) return b;
+      if (!b) return a;
+      return a.order <= b.order ? a : b;
+    }
+    function buildMeshActiveWorkLedgerSnapshot(ledgerEntries, options = {}) {
+      const timestampByEntry = /* @__PURE__ */ new Map();
+      for (const entry of ledgerEntries) timestampByEntry.set(entry, new Date(entry.timestamp).getTime());
+      const entries = ledgerEntries.slice().sort((a, b) => timestampByEntry.get(a) - timestampByEntry.get(b));
+      const taskBuckets = /* @__PURE__ */ new Map();
+      const sessionBuckets = /* @__PURE__ */ new Map();
+      const nodeBuckets = /* @__PURE__ */ new Map();
+      let order = 0;
+      for (const entry of entries) {
+        if (!TERMINAL_LEDGER_KINDS.has(entry.kind) && entry.kind !== "task_approval_needed") continue;
+        const timestampMs = timestampByEntry.get(entry);
+        if (!Number.isFinite(timestampMs)) continue;
+        const indexed = { entry, timestampMs, order: order++ };
+        const taskId = readString7(entry.payload?.taskId);
+        if (taskId) {
+          pushTerminalBucket(taskBuckets, taskId, indexed);
+        } else {
+          pushTerminalBucket(sessionBuckets, readString7(entry.sessionId), indexed);
+          pushTerminalBucket(nodeBuckets, machineCoreFromDaemonId(entry.nodeId), indexed);
+        }
+      }
+      return {
+        entries,
+        matchDirectDispatchTerminals(dispatches) {
+          const sortedDispatches = dispatches.slice().sort((a, b) => timestampByEntry.get(a) - timestampByEntry.get(b));
+          const taskQueries = /* @__PURE__ */ new Map();
+          const sessionQueries = /* @__PURE__ */ new Map();
+          const nodeQueries = /* @__PURE__ */ new Map();
+          for (const dispatch of sortedDispatches) {
+            const timestampMs = timestampByEntry.get(dispatch) ?? new Date(dispatch.timestamp).getTime();
+            if (!Number.isFinite(timestampMs)) continue;
+            const query = { dispatch, timestampMs };
+            pushTerminalQuery(taskQueries, directDispatchTaskId(dispatch), query);
+            const sessionId = readString7(dispatch.sessionId);
+            if (dispatch.sessionId) pushTerminalQuery(sessionQueries, sessionId, query);
+            else pushTerminalQuery(nodeQueries, machineCoreFromDaemonId(dispatch.nodeId), query);
+          }
+          const realByDispatch = /* @__PURE__ */ new Map();
+          const approvalByDispatch = /* @__PURE__ */ new Map();
+          const resolve32 = (queries, buckets, bucketKind, output) => {
+            for (const [key2, bucketQueries] of queries) {
+              const terminals = buckets.get(key2)?.[bucketKind];
+              if (!terminals?.length) continue;
+              let cursor = 0;
+              for (const query of bucketQueries) {
+                while (cursor < terminals.length) {
+                  options.onTerminalProbe?.();
+                  if (terminals[cursor].timestampMs >= query.timestampMs) break;
+                  cursor += 1;
+                }
+                const candidate = terminals[cursor];
+                if (candidate) output.set(query.dispatch, earlierTerminal(output.get(query.dispatch), candidate));
+              }
+            }
+          };
+          resolve32(taskQueries, taskBuckets, "real", realByDispatch);
+          resolve32(sessionQueries, sessionBuckets, "real", realByDispatch);
+          resolve32(nodeQueries, nodeBuckets, "real", realByDispatch);
+          resolve32(taskQueries, taskBuckets, "approval", approvalByDispatch);
+          resolve32(sessionQueries, sessionBuckets, "approval", approvalByDispatch);
+          resolve32(nodeQueries, nodeBuckets, "approval", approvalByDispatch);
+          const result = /* @__PURE__ */ new Map();
+          for (const dispatch of sortedDispatches) {
+            const selected = realByDispatch.get(dispatch) || approvalByDispatch.get(dispatch);
+            if (selected) result.set(dispatch, selected.entry);
+          }
+          return result;
+        }
+      };
+    }
     function readString7(value) {
       return typeof value === "string" && value.trim() ? value.trim() : void 0;
     }
@@ -74056,13 +74192,6 @@ ${rendered}`, "utf-8");
     function directDispatchTaskId(entry) {
       return readString7(entry.payload?.taskId) || entry.id;
     }
-    function terminalMatchesDispatch(terminal, dispatch, taskId) {
-      const terminalTaskId = readString7(terminal.payload?.taskId);
-      if (terminalTaskId && terminalTaskId === taskId) return true;
-      if (terminalTaskId && terminalTaskId !== taskId) return false;
-      if (dispatch.sessionId && sessionIdsEquivalent(terminal.sessionId, dispatch.sessionId)) return true;
-      return Boolean(dispatch.nodeId && daemonIdsEquivalent(terminal.nodeId, dispatch.nodeId) && !dispatch.sessionId);
-    }
     function statusFromTerminal(entry) {
       if (entry.kind === "task_approval_needed") return "awaiting_approval";
       if (entry.kind === "task_question_pending") return "awaiting_choice";
@@ -74079,8 +74208,7 @@ ${rendered}`, "utf-8");
     }
     function buildLedgerDirectDispatchRecord(dispatch, ctx) {
       const taskId = directDispatchTaskId(dispatch);
-      const matching = ctx.terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).filter((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-      const terminal = matching.find((entry) => entry.kind !== "task_approval_needed") || matching[0];
+      const terminal = ctx.terminal;
       const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
       const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
       const status = terminalStatus || live.status || "assigned";
@@ -74181,6 +74309,8 @@ ${rendered}`, "utf-8");
     }
     function buildMeshActiveWork(opts) {
       const now = opts.now ?? Date.now();
+      const ledgerSnapshot = opts.ledgerSnapshot ?? buildMeshActiveWorkLedgerSnapshot(opts.ledgerEntries || []);
+      const ledgerEntries = ledgerSnapshot.entries;
       const records = [];
       const staleDirectWork = [];
       const terminalDirectWork = [];
@@ -74191,7 +74321,7 @@ ${rendered}`, "utf-8");
         const queueNodeId = task.assignedNodeId || task.targetNodeId;
         const queueSessionId = task.assignedSessionId || task.targetSessionId;
         const queueLive = task.status === "assigned" ? sessionStatusFromNodes(opts.nodes, queueNodeId ?? void 0, queueSessionId ?? void 0) : {};
-        const queueTerminalAuthority = task.status === "assigned" && hasTerminalLedgerAuthorityForTask(opts.ledgerEntries, task.id);
+        const queueTerminalAuthority = task.status === "assigned" && hasTerminalLedgerAuthorityForTask(ledgerEntries, task.id);
         let queueStatus = !queueTerminalAuthority && (queueLive.status === "awaiting_approval" || queueLive.status === "awaiting_choice" || queueLive.status === "generating") ? queueLive.status : task.status;
         const turnOverlay = task.status === "assigned" ? turnProjectionActiveWorkStatus(opts.meshId, task.id) : null;
         if (turnOverlay) queueStatus = turnOverlay.status;
@@ -74221,7 +74351,7 @@ ${rendered}`, "utf-8");
           const dbStatus = dispatch.status;
           const isTerminal = dbStatus === "completed" || dbStatus === "failed" || dbStatus === "stale";
           const turnOverlay = isTerminal ? null : turnProjectionActiveWorkStatus(opts.meshId, dispatch.taskId);
-          const directTerminalAuthority = !isTerminal && hasTerminalLedgerAuthorityForTask(opts.ledgerEntries, dispatch.taskId);
+          const directTerminalAuthority = !isTerminal && hasTerminalLedgerAuthorityForTask(ledgerEntries, dispatch.taskId);
           const liveStatus = directTerminalAuthority ? void 0 : live.status;
           const status = isTerminal ? dbStatus === "completed" ? "idle" : "failed" : turnOverlay?.status || liveStatus || (dbStatus === "acked" ? "generating" : "assigned");
           const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
@@ -74265,12 +74395,12 @@ ${rendered}`, "utf-8");
           }
           records.push(record2);
         }
-        const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-        for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+        const ledgerDispatches = ledgerEntries.filter(isDirectDispatch);
+        const terminalByDispatch = ledgerSnapshot.matchDirectDispatchTerminals(ledgerDispatches);
+        for (const dispatch of ledgerDispatches) {
           if (dbTaskIds.has(directDispatchTaskId(dispatch))) continue;
           if (queueTaskIds.has(directDispatchTaskId(dispatch))) continue;
-          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminal: terminalByDispatch.get(dispatch), nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
@@ -74282,11 +74412,11 @@ ${rendered}`, "utf-8");
           records.push(record2);
         }
       } else {
-        const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-        for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+        const ledgerDispatches = ledgerEntries.filter(isDirectDispatch);
+        const terminalByDispatch = ledgerSnapshot.matchDirectDispatchTerminals(ledgerDispatches);
+        for (const dispatch of ledgerDispatches) {
           if (queueTaskIds.has(directDispatchTaskId(dispatch))) continue;
-          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminal: terminalByDispatch.get(dispatch), nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
@@ -74328,6 +74458,7 @@ ${rendered}`, "utf-8");
         meshId: opts.meshId,
         queue: opts.queue,
         ledgerEntries: opts.ledgerEntries,
+        ledgerSnapshot: opts.ledgerSnapshot,
         directDispatches: opts.directDispatches,
         nodes: opts.nodes,
         now,
@@ -74480,13 +74611,13 @@ ${rendered}`, "utf-8");
 ${lines.join("\n")}
 The mesh has no work in flight. For each mission, decide its outcome: continue it (enqueue/dispatch the remaining work) or close it with mesh_mission_upsert(mission_id, status: "completed" | "abandoned"). Do not leave a finished mission in 'active'. This is a one-time reminder.`;
     }
-    function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now = Date.now(), instanceManager) {
+    function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now = Date.now(), instanceManager, sharedLedgerSnapshot) {
       try {
         if (!coordinator) return false;
         if (policy?.idleActiveMissionReminder === false) return false;
         const activeMissions = getMeshMissions(meshId, ["active"]);
         if (activeMissions.length === 0) return false;
-        const ledgerEntries = readLedgerEntriesByKind(meshId, [
+        const ledgerEntries = sharedLedgerSnapshot?.entries ?? readLedgerEntriesByKind(meshId, [
           "task_dispatched",
           "task_completed",
           "task_failed",
@@ -74499,6 +74630,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           queue: getQueue(meshId),
           directDispatches: getActiveDirectDispatches(meshId),
           ledgerEntries,
+          ledgerSnapshot: sharedLedgerSnapshot,
           now
         }).summary;
         if (summary.totalActiveCount !== 0 || summary.generatingCount !== 0) return false;
@@ -82142,6 +82274,25 @@ ${block2.text}`,
                 launchedByCoordinator: true,
                 autoLaunchedForQueueTaskId: task.id
               };
+              const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
+              const buildRoutingDecision = () => buildAutoLaunchRoutingDecision({
+                node,
+                meshId,
+                task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
+                resolved,
+                quotaRouting: mesh?.policy?.quotaRouting ?? null,
+                quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
+                skippedCandidates,
+                requiredTagsResult: {
+                  required: requiredTags,
+                  satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, effectiveProviderType)),
+                  missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, effectiveProviderType).includes(t))
+                },
+                effectiveModel,
+                effectiveThinkingLevel,
+                executedSlot: slotDecision.slot,
+                demotionReason
+              });
               if (launchTarget.mode === "remote") {
                 const remoteSettings = {
                   ...launchSettings,
@@ -82185,7 +82336,15 @@ ${block2.text}`,
                   await waitForRemoteSessionReady(meshId, nodeId, remoteSessionId, {
                     isReady: remoteSessionReadyProbe(meshId, nodeId, remoteSessionId)
                   }).catch(() => false);
-                  claimAfterRemoteAutoLaunch(components, meshId, nodeId, remoteSessionId, effectiveProviderType, tryAssignQueueTask);
+                  const routingDecision2 = buildRoutingDecision();
+                  claimAfterRemoteAutoLaunch(
+                    components,
+                    meshId,
+                    nodeId,
+                    remoteSessionId,
+                    effectiveProviderType,
+                    (c, m, n, s2, p) => tryAssignQueueTask(c, m, n, s2, p, routingDecision2, void 0, "auto_launch")
+                  );
                 }
                 return true;
               }
@@ -82217,25 +82376,7 @@ ${block2.text}`,
               markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: effectiveProviderType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
               logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
               await waitForLocalSessionReady(components, sessionId);
-              const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
-              const routingDecision = buildAutoLaunchRoutingDecision({
-                node,
-                meshId,
-                task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
-                resolved,
-                quotaRouting: mesh?.policy?.quotaRouting ?? null,
-                quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
-                skippedCandidates,
-                requiredTagsResult: {
-                  required: requiredTags,
-                  satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, effectiveProviderType)),
-                  missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, effectiveProviderType).includes(t))
-                },
-                effectiveModel,
-                effectiveThinkingLevel,
-                executedSlot: slotDecision.slot,
-                demotionReason
-              });
+              const routingDecision = buildRoutingDecision();
               tryAssignQueueTask(components, meshId, nodeId, sessionId, effectiveProviderType, routingDecision, void 0, "auto_launch");
               return true;
             } catch (e) {
@@ -86996,6 +87137,7 @@ ${cleanBody}`;
     }
     var DEFAULT_RECONCILE_INTERVAL_MS;
     var DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+    var DEFAULT_AUTO_PRUNE_INTERVAL_MS;
     var DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS;
     var init_mesh_reconcile_config = __esm2({
       "src/mesh/mesh-reconcile-config.ts"() {
@@ -87004,28 +87146,80 @@ ${cleanBody}`;
         init_mesh_reconcile_acked_hold();
         DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
         DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
+        DEFAULT_AUTO_PRUNE_INTERVAL_MS = 6e4;
         DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
       }
     });
+    function resolveRemotePullBackoffMs(backoffRound) {
+      const shift = Math.max(0, Math.min(backoffRound - 1, 8));
+      return Math.min(REMOTE_PULL_BACKOFF_MAX_MS, REMOTE_PULL_BACKOFF_BASE_MS * 2 ** shift);
+    }
+    function pullBackoffKey(meshId, daemonId) {
+      return `${meshId}::${canonicalDaemonId(daemonId) ?? daemonId}`;
+    }
+    function isRemotePullBackedOff(meshId, daemonId, nowMs) {
+      const state = remotePullBackoffByDaemon.get(pullBackoffKey(meshId, daemonId));
+      return !!state && nowMs < state.nextPullAtMs;
+    }
+    function noteRemotePullResult(meshId, daemonId, result, nowMs) {
+      const key2 = pullBackoffKey(meshId, daemonId);
+      if (result.received > 0) {
+        remotePullBackoffByDaemon.delete(key2);
+        return;
+      }
+      if (!result.reached) return;
+      const prev = remotePullBackoffByDaemon.get(key2);
+      const emptyRounds = (prev?.emptyRounds ?? 0) + 1;
+      const backoffRound = emptyRounds - REMOTE_PULL_EMPTY_ROUNDS_BEFORE_BACKOFF + 1;
+      remotePullBackoffByDaemon.set(key2, {
+        emptyRounds,
+        nextPullAtMs: emptyRounds >= REMOTE_PULL_EMPTY_ROUNDS_BEFORE_BACKOFF ? nowMs + resolveRemotePullBackoffMs(backoffRound) : 0
+      });
+    }
     async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDaemonIds) {
       const dispatchMeshCommand = components.dispatchMeshCommand;
       if (!dispatchMeshCommand) return;
       const meshId = mesh.id;
       const pulls = candidateDaemonIds.length > 0 ? candidateDaemonIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }];
-      await Promise.allSettled(mesh.nodes.map((node) => pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls)));
+      const uniqueNodes = [];
+      const seenDaemonIds = /* @__PURE__ */ new Set();
+      for (const node of mesh.nodes) {
+        const nodeDaemonId = readNonEmptyString(node.daemonId);
+        if (!nodeDaemonId) continue;
+        const daemonKey = canonicalDaemonId(nodeDaemonId) ?? nodeDaemonId;
+        if (seenDaemonIds.has(daemonKey)) continue;
+        seenDaemonIds.add(daemonKey);
+        uniqueNodes.push(node);
+      }
+      await Promise.allSettled(uniqueNodes.map((node) => (async () => {
+        const nodeDaemonId = readNonEmptyString(node.daemonId);
+        if (nodeDaemonId && isRemotePullBackedOff(meshId, nodeDaemonId, Date.now())) return;
+        const result = await pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls);
+        if (nodeDaemonId) noteRemotePullResult(meshId, nodeDaemonId, result, Date.now());
+      })()));
     }
-    async function pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls) {
+    async function pullPendingEventsFromNode(components, meshId, node, localDaemonId, candidateDaemonIds, pulls, opts) {
       const dispatchMeshCommand = components.dispatchMeshCommand;
-      if (!dispatchMeshCommand) return;
+      if (!dispatchMeshCommand) return NOT_REACHED;
       const nodeDaemonId = readNonEmptyString(node.daemonId);
-      if (!nodeDaemonId) return;
-      if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
-      if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
+      if (!nodeDaemonId) return NOT_REACHED;
+      if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return NOT_REACHED;
+      if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return NOT_REACHED;
       const getPeerStatus = components.getMeshPeerConnectionStatus;
       if (getPeerStatus) {
         const peerSnapshot = getPeerStatus(nodeDaemonId);
-        if (!peerSnapshot || String(peerSnapshot.state) !== "connected") return;
+        if (!peerSnapshot || String(peerSnapshot.state) !== "connected") return NOT_REACHED;
+      }
+      const throttleKey = pullBackoffKey(meshId, nodeDaemonId);
+      if (opts?.minIntervalSinceLastPullMs) {
+        const lastPullAt = lastRedrivePullAtMs.get(throttleKey);
+        if (lastPullAt !== void 0 && Date.now() - lastPullAt < opts.minIntervalSinceLastPullMs) {
+          return NOT_REACHED;
+        }
       }
+      let received = 0;
+      let completedPulls = 0;
+      if (opts?.minIntervalSinceLastPullMs) lastRedrivePullAtMs.set(throttleKey, Date.now());
       for (const pendingEventArgs of pulls) {
         let events;
         try {
@@ -87033,7 +87227,11 @@ ${cleanBody}`;
         } catch {
           break;
         }
-        const list = extractPendingEvents(events).filter((e) => readNonEmptyString(e?.meshId) === meshId);
+        const extracted = extractPendingEventsResult(events);
+        if (!extracted.confirmed) break;
+        completedPulls++;
+        received += extracted.events.length;
+        const list = extracted.events.filter((e) => readNonEmptyString(e?.meshId) === meshId);
         for (const event of list) {
           const payload = buildForwardPayloadFromPending(event);
           if (!payload.event || !payload.meshId) continue;
@@ -87043,6 +87241,7 @@ ${cleanBody}`;
           }
         }
       }
+      return { received, reached: completedPulls === pulls.length };
     }
     function unwrapReadChatPayload(raw) {
       let cursor = raw;
@@ -87150,12 +87349,13 @@ ${cleanBody}`;
       }
       return [];
     }
-    function extractPendingEvents(raw) {
+    function extractPendingEventsResult(raw) {
       let cursor = raw;
       for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
-        if (Array.isArray(cursor)) return cursor;
+        if (Array.isArray(cursor)) return { events: cursor, confirmed: true };
         const record2 = cursor;
-        if (Array.isArray(record2.events)) return record2.events;
+        if (record2.success === false) return { events: [], confirmed: false };
+        if (Array.isArray(record2.events)) return { events: record2.events, confirmed: true };
         if (record2.payload && typeof record2.payload === "object") {
           cursor = record2.payload;
           continue;
@@ -87170,7 +87370,7 @@ ${cleanBody}`;
         }
         break;
       }
-      return [];
+      return { events: [], confirmed: false };
     }
     function buildForwardPayloadFromPending(event) {
       const metadata = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
@@ -87210,6 +87410,13 @@ ${cleanBody}`;
         ...serializeV2EnvelopeToWire(event)
       };
     }
+    var REMOTE_PULL_EMPTY_ROUNDS_BEFORE_BACKOFF;
+    var REMOTE_PULL_BACKOFF_BASE_MS;
+    var REMOTE_PULL_BACKOFF_MAX_MS;
+    var REDRIVE_PULL_MIN_INTERVAL_MS;
+    var remotePullBackoffByDaemon;
+    var lastRedrivePullAtMs;
+    var NOT_REACHED;
     var init_mesh_remote_event_pull = __esm2({
       "src/mesh/mesh-remote-event-pull.ts"() {
         "use strict";
@@ -87218,6 +87425,13 @@ ${cleanBody}`;
         init_mesh_events_utils();
         init_dist();
         init_mesh_reconcile_identity();
+        REMOTE_PULL_EMPTY_ROUNDS_BEFORE_BACKOFF = 3;
+        REMOTE_PULL_BACKOFF_BASE_MS = 8e3;
+        REMOTE_PULL_BACKOFF_MAX_MS = 3e4;
+        REDRIVE_PULL_MIN_INTERVAL_MS = 2e3;
+        remotePullBackoffByDaemon = /* @__PURE__ */ new Map();
+        lastRedrivePullAtMs = /* @__PURE__ */ new Map();
+        NOT_REACHED = { received: 0, reached: false };
       }
     });
     function formatBytes(bytes) {
@@ -89658,10 +89872,18 @@ ${cleanBody}`;
         }
       }
     }
-    async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs) {
+    async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs, sharedLedgerSnapshot) {
       const directDispatches = getActiveDirectDispatches(mesh.id);
-      if (directDispatches.length === 0) return;
+      if (directDispatches.length === 0) return void 0;
       const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+      const ledgerSnapshot = sharedLedgerSnapshot ?? buildMeshActiveWorkLedgerSnapshot(readLedgerEntriesByKind(mesh.id, [
+        "task_dispatched",
+        "task_completed",
+        "task_failed",
+        "task_stalled",
+        "task_approval_needed",
+        "task_question_pending"
+      ]));
       const result = pruneStaleDirectDispatches({
         meshId: mesh.id,
         queue: getQueue(mesh.id),
@@ -89670,14 +89892,8 @@ ${cleanBody}`;
         // tail:500 window can be crowded out by unrelated mesh traffic while a still-active
         // dispatch's ledger evidence falls out of the window, risking a live dispatch being
         // misclassified as an orphan and pruned.
-        ledgerEntries: readLedgerEntriesByKind(mesh.id, [
-          "task_dispatched",
-          "task_completed",
-          "task_failed",
-          "task_stalled",
-          "task_approval_needed",
-          "task_question_pending"
-        ]),
+        ledgerEntries: ledgerSnapshot.entries,
+        ledgerSnapshot,
         directDispatches,
         nodes: liveNodes,
         execute: true,
@@ -89687,6 +89903,7 @@ ${cleanBody}`;
       if (result.prunedCount > 0) {
         LOG2.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
       }
+      return ledgerSnapshot;
     }
     async function fetchAssignedTaskChatTail(components, mesh, row, tailLimit = 10) {
       const sessionId = readNonEmptyString(row.assignedSessionId);
@@ -90639,7 +90856,8 @@ ${cleanBody}`;
                 assignedNode,
                 localDaemonId,
                 selfIds,
-                selfIds.length > 0 ? selfIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }]
+                selfIds.length > 0 ? selfIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }],
+                { minIntervalSinceLastPullMs: REDRIVE_PULL_MIN_INTERVAL_MS }
               );
             } catch {
             }
@@ -91544,6 +91762,7 @@ ${cleanBody}`;
           return void 0;
         }
       })();
+      const activeWorkLedgerSnapshots = /* @__PURE__ */ new Map();
       if (dispatchMeshCommand) {
         try {
           await retryUnresolvedDelegateForwards(components);
@@ -91701,11 +91920,16 @@ ${cleanBody}`;
       }
       {
         const minAgeMs = resolveAutoPruneMinAgeMs();
+        const nowMs = Date.now();
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
           if (!daemonHostsMesh(mesh, selfIds)) continue;
+          const lastRunAt = lastAutoPruneRunAtByMesh.get(mesh.id);
+          if (lastRunAt !== void 0 && nowMs - lastRunAt < DEFAULT_AUTO_PRUNE_INTERVAL_MS) continue;
+          lastAutoPruneRunAtByMesh.set(mesh.id, nowMs);
           try {
-            await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            const snapshot = await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            if (snapshot) activeWorkLedgerSnapshots.set(mesh.id, snapshot);
           } catch (e) {
             LOG2.warn("MeshReconcile", `Auto-prune stale direct failed for mesh ${mesh.id}: ${e?.message || e}`);
           }
@@ -91932,7 +92156,8 @@ ${cleanBody}`;
                 targetCoordinators[0].instance,
                 getMesh(meshId)?.policy,
                 void 0,
-                components.instanceManager
+                components.instanceManager,
+                activeWorkLedgerSnapshots.get(meshId)
               );
               continue;
             }
@@ -91999,6 +92224,7 @@ ${cleanBody}`;
     var lastDiskRetentionRunAt;
     var IDLE_SESSION_REAP_INTERVAL_MS;
     var lastIdleSessionReapRunAt;
+    var lastAutoPruneRunAtByMesh;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -92037,6 +92263,7 @@ ${cleanBody}`;
         init_mesh_reconcile_unresolved_forward();
         DISK_RETENTION_INTERVAL_MS2 = 60 * 60 * 1e3;
         IDLE_SESSION_REAP_INTERVAL_MS = 5 * 60 * 1e3;
+        lastAutoPruneRunAtByMesh = /* @__PURE__ */ new Map();
       }
     });
     var mesh_events_exports = {};
@@ -93797,6 +94024,14 @@ ${cleanBody}`;
               },
               description: "Template for expanding an initialModel selection into launch args. '{{model}}' is substituted with the model string (e.g. ['--model', '{{model}}'] \u2192 --model opus). Applied at launch when a model is requested for this CLI provider (MAGI kind-panel model axis). Absent \u2192 no launch-time model selection."
             },
+            modelLaunchValueMap: {
+              type: "object",
+              additionalProperties: {
+                type: "string",
+                minLength: 1
+              },
+              description: "Optional map from user-facing model labels to provider-specific CLI values used to fill {{model}} in modelLaunchArgs. A model absent from the map passes through unchanged."
+            },
             modelOptions: {
               type: "array",
               items: {
@@ -95737,6 +95972,23 @@ ${tail}`;
         DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
       }
     });
+    function sanitizeRefineGateChildEnv(env2 = process.env) {
+      const sanitized = {};
+      for (const [key2, value] of Object.entries(env2)) {
+        if (key2.startsWith(ADHDEV_ENV_PREFIX) && !REFINE_GATE_ENV_ALLOWLIST.has(key2)) continue;
+        sanitized[key2] = value;
+      }
+      return sanitized;
+    }
+    var ADHDEV_ENV_PREFIX;
+    var REFINE_GATE_ENV_ALLOWLIST;
+    var init_mesh_refine_env_sanitize = __esm2({
+      "src/mesh/mesh-refine-env-sanitize.ts"() {
+        "use strict";
+        ADHDEV_ENV_PREFIX = "ADHDEV_";
+        REFINE_GATE_ENV_ALLOWLIST = /* @__PURE__ */ new Set([]);
+      }
+    });
     function classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit) {
       if (!baseCommit || !branchCommit) return "undeterminable";
       if (baseCommit === branchCommit) return "not_diverged";
@@ -97046,7 +97298,7 @@ ${mergeTreeErr?.stderr || ""}`;
               windowsHide: true,
               timeout,
               maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
-              env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
+              env: { ...sanitizeRefineGateChildEnv(), CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
               ...spawn7.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
             });
             summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -97092,7 +97344,7 @@ ${mergeTreeErr?.stderr || ""}`;
             windowsHide: true,
             timeout,
             maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
-            env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
+            env: { ...sanitizeRefineGateChildEnv(), CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
             ...spawn7.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
           });
           summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -97154,6 +97406,7 @@ ${mergeTreeErr?.stderr || ""}`;
         import_node_child_process11 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
+        init_mesh_refine_env_sanitize();
         init_mesh_refine_gitlink_utils();
         init_mesh_refine_submodule_converge();
         init_mesh_refine_gitlink_utils();
@@ -97349,12 +97602,38 @@ ${mergeTreeErr?.stderr || ""}`;
         };
       }
     });
+    async function execChangeAreaGit(callSite, gitArgs, cwd, inputs) {
+      try {
+        return await execFileAsync6(GIT3, gitArgs, { cwd, encoding: "utf8" });
+      } catch (error48) {
+        LOG2.warn("Mesh", `[Refinery] Change-area git call failed: ${JSON.stringify({
+          callSite,
+          gitArgs,
+          cwd,
+          cwdExists: (0, import_node_fs7.existsSync)(cwd),
+          code: error48?.code ?? null,
+          syscall: error48?.syscall ?? null,
+          path: error48?.path ?? null,
+          inputs
+        })}`);
+        throw error48;
+      }
+    }
     function topLevel(path64) {
       const slash = path64.indexOf("/");
       return slash === -1 ? path64 : path64.slice(0, slash);
     }
     async function analyzeMeshRefineNodeChangeArea(args) {
-      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
+      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, repoRoot, submodulePaths } = args;
+      const diagnosticInputs = {
+        nodeId,
+        workspace,
+        repoRoot: repoRoot ?? null,
+        branch,
+        baseRef,
+        branchRef,
+        submodulePaths: [...submodulePaths]
+      };
       const base = {
         nodeId,
         workspace,
@@ -97368,21 +97647,28 @@ ${mergeTreeErr?.stderr || ""}`;
       try {
         let mergeBase = baseRef;
         try {
-          const { stdout } = await execFileAsync6(GIT3, ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
+          const { stdout } = await execChangeAreaGit(
+            "analyzeMeshRefineNodeChangeArea.mergeBase",
+            ["merge-base", baseRef, branchRef],
+            diffCwd,
+            diagnosticInputs
+          );
           const resolved = stdout.trim();
           if (resolved) mergeBase = resolved;
         } catch {
         }
-        const { stdout: countStdout } = await execFileAsync6(
-          GIT3,
+        const { stdout: countStdout } = await execChangeAreaGit(
+          "analyzeMeshRefineNodeChangeArea.aheadCount",
           ["rev-list", "--count", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
+          diffCwd,
+          { ...diagnosticInputs, mergeBase }
         );
         base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
-        const { stdout: nameStdout } = await execFileAsync6(
-          GIT3,
+        const { stdout: nameStdout } = await execChangeAreaGit(
+          "analyzeMeshRefineNodeChangeArea.changedFiles",
           ["diff", "--name-only", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
+          diffCwd,
+          { ...diagnosticInputs, mergeBase }
         );
         const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
         base.changedFiles = files;
@@ -97431,6 +97717,7 @@ ${mergeTreeErr?.stderr || ""}`;
       return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
     }
     var import_node_child_process14;
+    var import_node_fs7;
     var import_node_util7;
     var execFileAsync6;
     var GIT3;
@@ -97439,8 +97726,10 @@ ${mergeTreeErr?.stderr || ""}`;
       "src/mesh/mesh-refine-batch.ts"() {
         "use strict";
         import_node_child_process14 = require("child_process");
+        import_node_fs7 = require("fs");
         import_node_util7 = require("util");
         init_resolve_executable();
+        init_logger();
         execFileAsync6 = (0, import_node_util7.promisify)(import_node_child_process14.execFile);
         GIT3 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
         MAX_CHANGED_FILES2 = 500;
@@ -97465,7 +97754,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     async function assessScope(cwd, path64, baseRef, branchRef) {
       try {
-        if (!(0, import_node_fs7.existsSync)(cwd)) return { path: path64, verdict: "unknown", error: `path does not exist: ${cwd}` };
+        if (!(0, import_node_fs8.existsSync)(cwd)) return { path: path64, verdict: "unknown", error: `path does not exist: ${cwd}` };
         const liveBaseHead = await git2(cwd, ["rev-parse", baseRef]);
         const branchHead = await git2(cwd, ["rev-parse", branchRef]);
         if (!liveBaseHead || !branchHead) {
@@ -97558,7 +97847,7 @@ ${mergeTreeErr?.stderr || ""}`;
     var import_node_child_process15;
     var import_node_util8;
     var import_node_path5;
-    var import_node_fs7;
+    var import_node_fs8;
     var execFileAsync7;
     var GIT4;
     var init_mesh_refine_base_divergence = __esm2({
@@ -97567,7 +97856,7 @@ ${mergeTreeErr?.stderr || ""}`;
         import_node_child_process15 = require("child_process");
         import_node_util8 = require("util");
         import_node_path5 = require("path");
-        import_node_fs7 = require("fs");
+        import_node_fs8 = require("fs");
         init_resolve_executable();
         init_mesh_refine_batch();
         execFileAsync7 = (0, import_node_util8.promisify)(import_node_child_process15.execFile);
@@ -97792,7 +98081,7 @@ ${mergeTreeErr?.stderr || ""}`;
     function refineWorktreeVanishedOutcome(ctx, nextStage) {
       const workspace = ctx?.node?.workspace;
       if (typeof workspace !== "string" || !workspace) return null;
-      if ((0, import_node_fs8.existsSync)(workspace)) return null;
+      if ((0, import_node_fs9.existsSync)(workspace)) return null;
       recordMeshRefineStage(ctx.refineStages, nextStage, "failed", Date.now(), {
         workspace,
         workspaceMissing: true,
@@ -97812,12 +98101,12 @@ ${mergeTreeErr?.stderr || ""}`;
         }
       };
     }
-    var import_node_fs8;
+    var import_node_fs9;
     var REFINE_INFLIGHT_FRESHNESS_MS;
     var init_mesh_refine_inflight = __esm2({
       "src/mesh/mesh-refine-inflight.ts"() {
         "use strict";
-        import_node_fs8 = require("fs");
+        import_node_fs9 = require("fs");
         init_mesh_refine_zombie_sweep();
         init_mesh_refine_landing();
         init_mesh_refine_gates();
@@ -98644,7 +98933,7 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
       if (!node.isLocalWorktree || !node.workspace) {
         return { kind: "terminal", result: { success: false, error: `Refinery requires a local worktree node`, refineStages } };
       }
-      if (!(0, import_node_fs9.existsSync)(node.workspace)) {
+      if (!(0, import_node_fs10.existsSync)(node.workspace)) {
         recordMeshRefineStage(refineStages, "resolve_refs", "failed", Date.now(), {
           workspace: node.workspace,
           workspaceMissing: true
@@ -99876,6 +100165,7 @@ ${e?.stderr || ""}`;
           baseRef,
           branchRef,
           diffCwd: node.workspace,
+          repoRoot,
           submodulePaths: submodulePathsByRepoRoot.get(repoRoot)
         }));
       }
@@ -100349,13 +100639,13 @@ ${e?.stderr || ""}`;
       return handle;
     }
     var import_node_child_process16;
-    var import_node_fs9;
+    var import_node_fs10;
     var RETRYABLE_BASE_MOVEMENT_CODES;
     var init_router_refine = __esm2({
       "src/commands/router-refine.ts"() {
         "use strict";
         import_node_child_process16 = require("child_process");
-        import_node_fs9 = require("fs");
+        import_node_fs10 = require("fs");
         init_logger();
         init_debug_trace();
         init_dist();
@@ -117724,17 +118014,17 @@ ${marker}`,
         this.logShadowDivergence(ev);
         if (ev.fired) {
           this.commitTransition(ev.fired, now, ev);
+          this.maybeMarkReady();
           this.emitStateChanged(forceEmit);
           this.scheduleWakeForState();
           this.scheduleStallWatchdog();
-          this.maybeMarkReady();
           this.drainPendingSends();
           return;
         }
+        this.maybeMarkReady();
         this.emitStateChanged(forceEmit);
         this.scheduleWakeForState();
         this.scheduleStallWatchdog();
-        this.maybeMarkReady();
         this.drainPendingSends();
       }
       commitTransition(fired, now, ev) {
@@ -118005,7 +118295,6 @@ ${marker}`,
         if (!st) return;
         if (!st.initial && statusForState(st) === "idle") {
           this.readySeenOnce = true;
-          this.drainPendingSends();
         }
       }
       // ────────────────────────────────────────────────────────────────────
@@ -120240,17 +120529,17 @@ ${marker}`,
     }
     function readSession(sessionPath) {
       if (!sessionPath || !path40.isAbsolute(sessionPath)) return null;
-      const basename21 = path40.basename(sessionPath, ".jsonl");
-      if (!isSafeSessionId(basename21)) return null;
+      const basename22 = path40.basename(sessionPath, ".jsonl");
+      if (!isSafeSessionId(basename22)) return null;
       if (!fs33.existsSync(sessionPath)) return null;
       const sourceMtimeMs = statMtimeMs(sessionPath);
-      const { messages, usageRecords } = parseTranscriptFile(sessionPath, basename21);
+      const { messages, usageRecords } = parseTranscriptFile(sessionPath, basename22);
       if (messages.length === 0) return null;
       const firstSystem = messages.find((m) => m.kind === "session_start");
       const workspace = firstSystem?.workspace || firstSystem?.content || void 0;
       const session = {
         messages,
-        providerSessionId: basename21,
+        providerSessionId: basename22,
         source: "provider-native",
         sourcePath: sessionPath,
         sourceMtimeMs,
@@ -120259,7 +120548,7 @@ ${marker}`,
       };
       if (usageRecords.length > 0) {
         session.usage = foldUsageRecords(usageRecords, {
-          providerSessionId: basename21,
+          providerSessionId: basename22,
           agent: "claude-cli"
         });
       }
@@ -120553,8 +120842,8 @@ ${marker}`,
       if (!fs34.existsSync(sessionPath)) return null;
       const meta3 = readSessionMeta(sessionPath);
       const metaId = String(meta3?.id ?? "").trim();
-      const basename21 = path41.basename(sessionPath, ".jsonl");
-      const uuidMatch = basename21.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+      const basename22 = path41.basename(sessionPath, ".jsonl");
+      const uuidMatch = basename22.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
       const filenameUuid2 = uuidMatch ? uuidMatch[1] : "";
       if (metaId && filenameUuid2 && metaId !== filenameUuid2) return null;
       const sessionId = metaId || filenameUuid2;
@@ -123015,10 +123304,21 @@ ${text}` : text;
             ...sessionFields
           };
         }
+        const readySeen = this.driver.hasSeenReady?.();
+        if (readySeen === false) {
+          return {
+            status: "starting",
+            messages: [],
+            activeModal: null,
+            activeInteractivePrompt: this.activeInteractivePrompt,
+            fsmReadySeen: false,
+            ...sessionFields
+          };
+        }
         if (state.status === "generating") {
           return { status: "generating", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
         }
-        return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, fsmReadySeen: this.driver.hasSeenReady?.() ?? false, ...sessionFields };
+        return { status: "idle", messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, fsmReadySeen: readySeen === true, ...sessionFields };
       }
       maybeRefreshNativeHistory() {
       }
@@ -126411,7 +126711,9 @@ ${buttons.join("\n")}`;
             host.scheduleCompletedDebounceFlush(flushDelay);
           }
         } else if (newStatus === "idle" && host.lastStatus === "starting") {
-          host.emitAgentReadyOnce(chatTitle, now);
+          if (adapterStatus.fsmReadySeen !== false) {
+            host.emitAgentReadyOnce(chatTitle, now);
+          }
           if (host.startupGraceCollapseAt === null) host.startupGraceCollapseAt = now;
           host.maybeSynthesizeStartupGraceCollapse(chatTitle, now, "startup_grace_fast_collapse");
         } else if (newStatus === "error") {
@@ -130753,6 +131055,12 @@ ${rawInput}` : rawInput;
       return managedBy === managerTag;
     }
     init_auto_approve_modes();
+    function expandModelLaunchArgs(template, model, valueMap = void 0) {
+      const requested = typeof model === "string" ? model.trim() : "";
+      if (!requested || !Array.isArray(template) || template.length === 0) return void 0;
+      const mapped = typeof valueMap?.[requested] === "string" && valueMap[requested].trim() ? valueMap[requested].trim() : requested;
+      return template.map((part) => part.includes("{{model}}") ? part.split("{{model}}").join(mapped) : part);
+    }
     function isExplicitCommand(command) {
       const trimmed = command.trim();
       return path50.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
@@ -131005,11 +131313,6 @@ ${rawInput}` : rawInput;
         return expanded;
       });
     }
-    function expandModelLaunchArgs(template, model) {
-      const m = typeof model === "string" ? model.trim() : "";
-      if (!m || !Array.isArray(template) || template.length === 0) return void 0;
-      return template.map((part) => part.includes("{{model}}") ? part.split("{{model}}").join(m) : part);
-    }
     function expandThinkingLaunchArgs(template, level, levelMap) {
       const raw = typeof level === "string" ? level.trim() : "";
       if (!raw || !Array.isArray(template) || template.length === 0) return void 0;
@@ -131506,7 +131809,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const autoApproveLaunch = applyAutoApproveModeLaunchArgs(versionResolvedProvider, cliArgs, launchSettings);
         const launchProvider = autoApproveLaunch.provider || provider;
         const cliArgsWithAutoApprove = autoApproveLaunch.cliArgs;
-        const modelLaunchArgs = expandModelLaunchArgs(launchProvider?.modelLaunchArgs, initialModel);
+        const modelLaunchArgs = expandModelLaunchArgs(
+          launchProvider?.modelLaunchArgs,
+          initialModel,
+          launchProvider?.modelLaunchValueMap
+        );
         const cliArgsWithModel = modelLaunchArgs ? [...modelLaunchArgs, ...cliArgsWithAutoApprove || []] : cliArgsWithAutoApprove;
         if (initialModel && !modelLaunchArgs) {
           LOG2.warn("CLI", `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template \u2014 launching without model selection.`);
@@ -132583,6 +132890,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "details",
       "autoApproveModes",
       "modelLaunchArgs",
+      "modelLaunchValueMap",
       "modelOptions",
       "thinkingLaunchArgs",
       "thinkingLevelMap",
@@ -136828,7 +137136,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-          const { existsSync: existsSync75, readFileSync: readFileSync59, mkdirSync: mkdirSync35, writeFileSync: writeFileSync33 } = await import("fs");
+          const { existsSync: existsSync76, readFileSync: readFileSync59, mkdirSync: mkdirSync35, writeFileSync: writeFileSync33 } = await import("fs");
           const { dirname: dirname26, join: join75 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -136837,7 +137145,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
             const candidate = join75(workspace, relative8);
-            if (!existsSync75(candidate)) continue;
+            if (!existsSync76(candidate)) continue;
             try {
               const text = readFileSync59(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
@@ -139410,7 +139718,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync75, readFileSync: readFileSync59, writeFileSync: writeFileSync33, copyFileSync: copyFileSync4, mkdirSync: mkdirSync35 } = await import("fs");
+          const { existsSync: existsSync76, readFileSync: readFileSync59, writeFileSync: writeFileSync33, copyFileSync: copyFileSync4, mkdirSync: mkdirSync35 } = await import("fs");
           const { dirname: dirname26 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -139455,7 +139763,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync75(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync76(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname26(mcpConfigPath));
@@ -140273,7 +140581,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync75 } = await import("fs");
+          const { existsSync: existsSync76 } = await import("fs");
           const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -140292,7 +140600,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync75(workspace)) continue;
+            if (!workspace || !existsSync76(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -153946,10 +154254,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
     init_fsm_evaluator();
     init_fsm_loader();
     var crypto9 = __toESM2(require("crypto"));
-    var import_node_fs10 = require("fs");
+    var import_node_fs11 = require("fs");
     var import_node_path6 = require("path");
     init_provider_cli_shared();
-    var import_node_fs11 = require("fs");
+    var import_node_fs12 = require("fs");
     var import_node_path7 = require("path");
     init_manifest();
     var V1_PRIMITIVE_CATALOG = Object.freeze({