@adhdev/daemon-core 0.9.82-rc.114 → 0.9.82-rc.115

package/dist/index.js

@@ -1055,6 +1055,7 @@ function addNode(meshId, opts) {
     isLocalWorktree: opts.isLocalWorktree,
     worktreeBranch: opts.worktreeBranch,
     clonedFromNodeId: opts.clonedFromNodeId,
+    worktreeBootstrap: opts.worktreeBootstrap,
     role: opts.role
   };
   mesh.nodes.push(node);
@@ -1081,6 +1082,7 @@ function updateNode(meshId, nodeId, opts) {
   if (!node) return void 0;
   if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+  if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveMeshConfig(config);
   return node;
@@ -1302,19 +1304,19 @@ function isIntentionalCleanupStopEntry(entry) {
   return payload.intentional === true && (payload.reason === "operator_cleanup" || payload.intentionalStopReason === "operator_cleanup" || payload.source === "mesh_cleanup_sessions" || payload.source === "mesh_remove_node");
 }
 function getLedgerDir() {
-  const dir = (0, import_path4.join)(getConfigDir(), LEDGER_DIR_NAME);
-  if (!(0, import_fs4.existsSync)(dir)) {
-    (0, import_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = (0, import_path5.join)(getConfigDir(), LEDGER_DIR_NAME);
+  if (!(0, import_fs5.existsSync)(dir)) {
+    (0, import_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path4.join)(getLedgerDir(), `${safe}.jsonl`);
+  return (0, import_path5.join)(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path4.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return (0, import_path5.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -1436,9 +1438,9 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if ((0, import_fs4.existsSync)(filePath)) {
+  if ((0, import_fs5.existsSync)(filePath)) {
     try {
-      const stat2 = (0, import_fs4.statSync)(filePath);
+      const stat2 = (0, import_fs5.statSync)(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
         rotateLedgerFile(meshId, filePath);
       }
@@ -1447,7 +1449,7 @@ function appendLedgerEntry(meshId, partial) {
   }
   try {
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs4.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+    (0, import_fs5.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
     meshLedgerEvents.emit("append", meshId, entry);
     return entry;
   } catch (e) {
@@ -1492,7 +1494,7 @@ function appendRemoteLedgerEntries(meshId, entries) {
   }
   try {
     const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs4.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs5.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
     for (const entry of validEntries) {
       meshLedgerEvents.emit("append", meshId, entry);
     }
@@ -1503,10 +1505,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerEntries(meshId, opts) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs4.existsSync)(filePath)) return [];
+  if (!(0, import_fs5.existsSync)(filePath)) return [];
   let content;
   try {
-    content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+    content = (0, import_fs5.readFileSync)(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1678,22 +1680,22 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while ((0, import_fs4.existsSync)(getRotatedPath(meshId, index))) {
+  while ((0, import_fs5.existsSync)(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
   if (index > 10) index = 10;
   try {
-    (0, import_fs4.renameSync)(currentPath, getRotatedPath(meshId, index));
+    (0, import_fs5.renameSync)(currentPath, getRotatedPath(meshId, index));
   } catch {
   }
 }
-var import_fs4, import_path4, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents;
+var import_fs5, import_path5, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path4 = require("path");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
     import_crypto4 = require("crypto");
     init_config();
     import_events = require("events");
@@ -1717,14 +1719,14 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return (0, import_path5.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return (0, import_path6.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
-var import_fs5, import_path5, import_module, import_meta, DatabaseCtor, BeadsDB;
+var import_fs6, import_path6, import_module, import_meta, DatabaseCtor, BeadsDB;
 var init_beads_db = __esm({
   "src/mesh/beads-db.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path5 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     import_module = require("module");
     init_mesh_ledger();
     import_meta = {};
@@ -1733,8 +1735,8 @@ var init_beads_db = __esm({
       db;
       migratedMeshIds = /* @__PURE__ */ new Set();
       constructor(dbPath) {
-        const dir = (0, import_path5.dirname)(dbPath);
-        if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path6.dirname)(dbPath);
+        if (!(0, import_fs6.existsSync)(dir)) (0, import_fs6.mkdirSync)(dir, { recursive: true });
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("synchronous = NORMAL");
@@ -1744,7 +1746,7 @@ var init_beads_db = __esm({
       }
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _BeadsDB((0, import_path5.join)(getLedgerDir(), "beads.db"));
+          this.instance = new _BeadsDB((0, import_path6.join)(getLedgerDir(), "beads.db"));
         }
         return this.instance;
       }
@@ -1785,9 +1787,9 @@ var init_beads_db = __esm({
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
         const path28 = legacyQueuePath(meshId);
-        if (!(0, import_fs5.existsSync)(path28)) return;
+        if (!(0, import_fs6.existsSync)(path28)) return;
         try {
-          const entries = JSON.parse((0, import_fs5.readFileSync)(path28, "utf-8"));
+          const entries = JSON.parse((0, import_fs6.readFileSync)(path28, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -2146,24 +2148,24 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return (0, import_fs6.existsSync)(candidate) ? candidate : null;
+    return (0, import_fs7.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const child = (0, import_child_process.exec)(cmd, {
       encoding: "utf-8",
       timeout: timeoutMs,
       ...process.platform === "win32" ? { windowsHide: true } : {}
     }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve16(null);
+        resolve17(null);
       } else {
-        resolve16(stdout.trim());
+        resolve17(stdout.trim());
       }
     });
-    child.on("error", () => resolve16(null));
+    child.on("error", () => resolve17(null));
   });
 }
 async function detectCLIs(providerLoader, options) {
@@ -2246,14 +2248,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process, os2, path8, import_fs6;
+var import_child_process, os2, path8, import_fs7;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
     import_child_process = require("child_process");
     os2 = __toESM(require("os"));
     path8 = __toESM(require("path"));
-    import_fs6 = require("fs");
+    import_fs7 = require("fs");
   }
 });
 
@@ -2539,7 +2541,7 @@ __export(mesh_events_exports, {
   tryAssignQueueTask: () => tryAssignQueueTask
 });
 function readWorkerResultMetadata(event) {
-  return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
+  return readRecord2(event.workerResult) || readRecord2(event.meshWorkerResult) || readRecord2(event.structuredResult);
 }
 function sweepExpiredRemoteIdleSessions() {
   const now = Date.now();
@@ -2548,9 +2550,9 @@ function sweepExpiredRemoteIdleSessions() {
   }
 }
 function readRefineJobId(event) {
-  const metadata = readRecord(event.metadataEvent) || event;
-  const result = readRecord(metadata.result);
-  const refineJob = readRecord(result?.refineJob);
+  const metadata = readRecord2(event.metadataEvent) || event;
+  const result = readRecord2(metadata.result);
+  const refineJob = readRecord2(result?.refineJob);
   return readNonEmptyString2(metadata.jobId) || readNonEmptyString2(refineJob?.jobId);
 }
 function buildRefineTerminalEventFingerprint(meshId, eventName, metadataEvent) {
@@ -2566,10 +2568,10 @@ function hasPendingRefineTerminalEventDuplicate(event) {
   );
 }
 function buildPendingEventFingerprint(event) {
-  const metadata = readRecord(event.metadataEvent) || {};
+  const metadata = readRecord2(event.metadataEvent) || {};
   const sessionId = resolveEventSessionId(metadata);
   const providerSessionId = readNonEmptyString2(metadata.providerSessionId);
-  const taskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord(metadata.payload)?.taskId);
+  const taskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord2(metadata.payload)?.taskId);
   const jobId = readRefineJobId(event);
   const timestamp = metadata.timestamp !== void 0 && metadata.timestamp !== null ? String(metadata.timestamp) : "";
   return [
@@ -2590,7 +2592,7 @@ function hasPendingCoordinatorEventDuplicate(event) {
 }
 function getPendingEventsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function queuePendingMeshCoordinatorEvent(event) {
   try {
@@ -2602,7 +2604,7 @@ function queuePendingMeshCoordinatorEvent(event) {
       LOG.info("MeshEvents", `Suppressed duplicate pending ${event.event} for mesh ${event.meshId}`);
       return true;
     }
-    (0, import_fs7.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    (0, import_fs8.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -2612,11 +2614,11 @@ function queuePendingMeshCoordinatorEvent(event) {
 function drainPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return [];
   const path28 = getPendingEventsPath(meshId);
-  if (!(0, import_fs7.existsSync)(path28)) return [];
+  if (!(0, import_fs8.existsSync)(path28)) return [];
   try {
-    const raw = (0, import_fs7.readFileSync)(path28, "utf-8");
+    const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
     try {
-      (0, import_fs7.unlinkSync)(path28);
+      (0, import_fs8.unlinkSync)(path28);
     } catch {
     }
     return raw.split("\n").filter(Boolean).flatMap((line) => {
@@ -2633,9 +2635,9 @@ function drainPendingMeshCoordinatorEvents(meshId) {
 function getPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return [];
   const path28 = getPendingEventsPath(meshId);
-  if (!(0, import_fs7.existsSync)(path28)) return [];
+  if (!(0, import_fs8.existsSync)(path28)) return [];
   try {
-    const raw = (0, import_fs7.readFileSync)(path28, "utf-8");
+    const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
     return raw.split("\n").filter(Boolean).flatMap((line) => {
       try {
         return [JSON.parse(line)];
@@ -2650,15 +2652,15 @@ function getPendingMeshCoordinatorEvents(meshId) {
 function clearPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return;
   const path28 = getPendingEventsPath(meshId);
-  if ((0, import_fs7.existsSync)(path28)) try {
-    (0, import_fs7.unlinkSync)(path28);
+  if ((0, import_fs8.existsSync)(path28)) try {
+    (0, import_fs8.unlinkSync)(path28);
   } catch {
   }
 }
 function readNonEmptyString2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
-function readRecord(value) {
+function readRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function resolveEventSessionId(event, fallback) {
@@ -3098,10 +3100,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
   }
   if (args.event === "refine:completed") {
     const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
-    const result = readRecord(args.metadataEvent.result);
-    const validationSummary = readRecord(result?.validationSummary);
-    const patchEquivalence = readRecord(result?.patchEquivalence);
-    const finalConvergence = readRecord(result?.finalBranchConvergenceState);
+    const result = readRecord2(args.metadataEvent.result);
+    const validationSummary = readRecord2(result?.validationSummary);
+    const patchEquivalence = readRecord2(result?.patchEquivalence);
+    const finalConvergence = readRecord2(result?.finalBranchConvergenceState);
     const validationStatus = readNonEmptyString2(validationSummary?.status);
     const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
     const into = readNonEmptyString2(result?.into);
@@ -3122,10 +3124,10 @@ Next step: ${nextStep}`;
   }
   if (args.event === "refine:failed") {
     const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
-    const result = readRecord(args.metadataEvent.result);
-    const validationSummary = readRecord(result?.validationSummary);
-    const patchEquivalence = readRecord(result?.patchEquivalence);
-    const finalConvergence = readRecord(result?.finalBranchConvergenceState);
+    const result = readRecord2(args.metadataEvent.result);
+    const validationSummary = readRecord2(result?.validationSummary);
+    const patchEquivalence = readRecord2(result?.patchEquivalence);
+    const finalConvergence = readRecord2(result?.finalBranchConvergenceState);
     const code = readNonEmptyString2(result?.code);
     const error = readNonEmptyString2(result?.error);
     const validationStatus = readNonEmptyString2(validationSummary?.status);
@@ -3493,12 +3495,12 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs7, import_path6, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, REFINE_TERMINAL_EVENTS, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var import_fs8, import_path7, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, REFINE_TERMINAL_EVENTS, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
-    import_fs7 = require("fs");
-    import_path6 = require("path");
+    import_fs8 = require("fs");
+    import_path7 = require("path");
     init_config();
     init_mesh_config();
     init_cli_detector();
@@ -5214,7 +5216,7 @@ ${lastSnapshot}`;
               `[${this.cliType}] Waiting for interactive prompt: status=${status} stableMs=${stableMs} recentOutputMs=${recentlyOutput} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)}`
             );
           }
-          await new Promise((resolve16) => setTimeout(resolve16, 50));
+          await new Promise((resolve17) => setTimeout(resolve17, 50));
         }
         const finalScreenText = this.terminalScreen.getText() || "";
         LOG.warn(
@@ -6441,7 +6443,7 @@ ${lastSnapshot}`;
           const deadline = Date.now() + 1e4;
           while (this.startupParseGate && Date.now() < deadline) {
             this.resolveStartupState("send_wait");
-            await new Promise((resolve16) => setTimeout(resolve16, 50));
+            await new Promise((resolve17) => setTimeout(resolve17, 50));
           }
         }
         const parsedStatusBeforeSend = !allowInputDuringGeneration ? (() => {
@@ -6538,13 +6540,13 @@ ${lastSnapshot}`;
         }
         this.responseEpoch += 1;
         this.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
-        await new Promise((resolve16, reject) => {
+        await new Promise((resolve17, reject) => {
           let resolved = false;
           const completion = {
             resolveOnce: () => {
               if (resolved) return;
               resolved = true;
-              resolve16();
+              resolve17();
             },
             rejectOnce: (error) => {
               if (resolved) return;
@@ -6702,17 +6704,17 @@ ${lastSnapshot}`;
         }
       }
       waitForStopped(timeoutMs) {
-        return new Promise((resolve16) => {
+        return new Promise((resolve17) => {
           const startedAt = Date.now();
           const timer = setInterval(() => {
             if (!this.ptyProcess || this.currentStatus === "stopped") {
               clearInterval(timer);
-              resolve16(true);
+              resolve17(true);
               return;
             }
             if (Date.now() - startedAt >= timeoutMs) {
               clearInterval(timer);
-              resolve16(false);
+              resolve17(false);
             }
           }, 100);
         });
@@ -7042,6 +7044,8 @@ __export(index_exports, {
   MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
   MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA: () => MESH_REFINE_CONFIG_SCHEMA,
+  MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+  MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS: () => MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -7062,10 +7066,12 @@ __export(index_exports, {
   buildChatMessage: () => buildChatMessage,
   buildChatMessageSignature: () => buildChatMessageSignature,
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
+  buildCompactStaleDirectWorkSummary: () => buildCompactStaleDirectWorkSummary,
   buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
   buildMachineInfo: () => buildMachineInfo,
   buildMeshActiveWork: () => buildMeshActiveWork,
   buildMeshActiveWorkSummary: () => buildMeshActiveWorkSummary,
+  buildMeshAsyncRefineJobs: () => buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
@@ -7174,6 +7180,7 @@ __export(index_exports, {
   listWorktrees: () => listWorktrees,
   loadConfig: () => loadConfig,
   loadMeshRefineConfig: () => loadMeshRefineConfig,
+  loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
   loadState: () => loadState,
   logCommand: () => logCommand,
   markSetupComplete: () => markSetupComplete,
@@ -7225,6 +7232,7 @@ __export(index_exports, {
   resolveWorktreePath: () => resolveWorktreePath,
   runAsyncBatch: () => runAsyncBatch,
   runGit: () => runGit,
+  runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
   saveConfig: () => saveConfig,
   saveState: () => saveState,
   setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -7246,7 +7254,8 @@ __export(index_exports, {
   updateTaskStatus: () => updateTaskStatus,
   upsertSavedProviderSession: () => upsertSavedProviderSession,
   validateMeshRefineConfig: () => validateMeshRefineConfig,
-  validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
+  validateMeshTaskModeRequest: () => validateMeshTaskModeRequest,
+  validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
 });
 module.exports = __toCommonJS(index_exports);
 init_repo_mesh_types();
@@ -8316,10 +8325,17 @@ async function gitCheckpoint(workspace, message, includeUntracked) {
   } catch (err) {
     const output = (err?.stdout || "") + (err?.stderr || "");
     if (/nothing to commit/i.test(output)) {
-      throw new GitCommandError("nothing_to_commit", "Nothing to commit \u2014 working tree is clean.", {
-        stdout: err?.stdout,
-        stderr: err?.stderr
-      });
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        message: fullMsg,
+        status: "skipped",
+        skipped: true,
+        noop: true,
+        reason: "nothing_to_commit",
+        lastCheckedAt: Date.now()
+      };
     }
     throw err;
   }
@@ -8329,6 +8345,7 @@ async function gitCheckpoint(workspace, message, includeUntracked) {
     isGitRepo: true,
     commit: commitSha,
     message: fullMsg,
+    status: "created",
     lastCheckedAt: Date.now()
   };
 }
@@ -9032,6 +9049,7 @@ var MESH_REFINE_CONFIG_SCHEMA = {
               category: { enum: [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"] },
               cwd: { type: "string" },
               timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
+              outputLimitBytes: { type: "number", minimum: 1024, maximum: 1048576 },
               env: { type: "object", additionalProperties: { type: "string" } }
             }
           }
@@ -9049,6 +9067,7 @@ var MESH_REFINE_CONFIG_SCHEMA = {
               category: { enum: [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"] },
               cwd: { type: "string" },
               timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
+              outputLimitBytes: { type: "number", minimum: 1024, maximum: 1048576 },
               env: { type: "object", additionalProperties: { type: "string" } }
             }
           }
@@ -9057,7 +9076,7 @@ var MESH_REFINE_CONFIG_SCHEMA = {
     }
   }
 };
-function isRecord(value) {
+function isMeshConfigRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function tokenizeCommandString(command) {
@@ -9072,8 +9091,8 @@ function tokenizeCommandString(command) {
 function validateCategory(value) {
   return typeof value === "string" && [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"].includes(value) ? value : "custom";
 }
-function normalizeCommandConfig(entry, source) {
-  if (!isRecord(entry) || typeof entry.command !== "string") {
+function normalizeMeshCommandConfig(entry, source) {
+  if (!isMeshConfigRecord(entry) || typeof entry.command !== "string") {
     return { rejected: { source, reason: "validation command must be an object with a command string" } };
   }
   const commandText = entry.command.trim();
@@ -9100,7 +9119,10 @@ function normalizeCommandConfig(entry, source) {
   if (entry.timeoutMs !== void 0 && (typeof entry.timeoutMs !== "number" || !Number.isFinite(entry.timeoutMs) || entry.timeoutMs < 1e3 || entry.timeoutMs > 6e5)) {
     return { rejected: { source, command: commandText, reason: "timeoutMs must be between 1000 and 600000" } };
   }
-  if (entry.env !== void 0 && (!isRecord(entry.env) || !Object.values(entry.env).every((value) => typeof value === "string"))) {
+  if (entry.outputLimitBytes !== void 0 && (typeof entry.outputLimitBytes !== "number" || !Number.isFinite(entry.outputLimitBytes) || entry.outputLimitBytes < 1024 || entry.outputLimitBytes > 1048576)) {
+    return { rejected: { source, command: commandText, reason: "outputLimitBytes must be between 1024 and 1048576" } };
+  }
+  if (entry.env !== void 0 && (!isMeshConfigRecord(entry.env) || !Object.values(entry.env).every((value) => typeof value === "string"))) {
     return { rejected: { source, command: commandText, reason: "env must be an object of string values" } };
   }
   return {
@@ -9112,10 +9134,12 @@ function normalizeCommandConfig(entry, source) {
       source,
       ...typeof entry.cwd === "string" && entry.cwd.trim() ? { cwd: entry.cwd.trim() } : {},
       ...typeof entry.timeoutMs === "number" ? { timeoutMs: entry.timeoutMs } : {},
-      ...isRecord(entry.env) ? { env: entry.env } : {}
+      ...typeof entry.outputLimitBytes === "number" ? { outputLimitBytes: entry.outputLimitBytes } : {},
+      ...isMeshConfigRecord(entry.env) ? { env: entry.env } : {}
     }
   };
 }
+var isRecord = isMeshConfigRecord;
 function validateMeshRefineConfig(config, source = "inline") {
   const errors = [];
   const bootstrapCommands = [];
@@ -9134,14 +9158,14 @@ function validateMeshRefineConfig(config, source = "inline") {
   if (rawBootstrapCommands !== void 0 && !Array.isArray(rawBootstrapCommands)) errors.push("validation.bootstrapCommands must be an array");
   if (Array.isArray(rawBootstrapCommands)) {
     rawBootstrapCommands.forEach((entry, index) => {
-      const normalized = normalizeCommandConfig(entry, `${source}:validation.bootstrapCommands[${index}]`);
+      const normalized = normalizeMeshCommandConfig(entry, `${source}:validation.bootstrapCommands[${index}]`);
       if (normalized.command) bootstrapCommands.push(normalized.command);
       if (normalized.rejected) rejectedCommands.push(normalized.rejected);
     });
   }
   if (Array.isArray(rawCommands)) {
     rawCommands.forEach((entry, index) => {
-      const normalized = normalizeCommandConfig(entry, `${source}:validation.commands[${index}]`);
+      const normalized = normalizeMeshCommandConfig(entry, `${source}:validation.commands[${index}]`);
       if (normalized.command) commands.push(normalized.command);
       if (normalized.rejected) rejectedCommands.push(normalized.rejected);
     });
@@ -9253,6 +9277,190 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
   };
 }
 
+// src/mesh/worktree-bootstrap-config.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_node_child_process3 = require("child_process");
+var import_node_util3 = require("util");
+var yaml2 = __toESM(require("js-yaml"));
+var MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS = [
+  ".adhdev/worktree_bootstrap.json",
+  ".adhdev/worktree_bootstrap.yaml",
+  ".adhdev/worktree_bootstrap.yml",
+  ".adhdev/worktree-bootstrap.json",
+  ".adhdev/worktree-bootstrap.yaml",
+  ".adhdev/worktree-bootstrap.yml"
+];
+var MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "ADHDev Repo Mesh Worktree Bootstrap Config",
+  type: "object",
+  additionalProperties: false,
+  required: ["version"],
+  properties: {
+    version: { const: 1 },
+    enabled: { type: "boolean", default: true },
+    runOnClone: { type: "boolean", default: true },
+    required: { type: "boolean", default: true },
+    staleInputs: { type: "array", maxItems: 16, items: { type: "string", minLength: 1 } },
+    commands: {
+      type: "array",
+      minItems: 1,
+      maxItems: 4,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["command"],
+        properties: {
+          command: { type: "string", minLength: 1 },
+          args: { type: "array", items: { type: "string" } },
+          category: { enum: ["typecheck", "test", "lint", "build", "custom"] },
+          cwd: { type: "string" },
+          timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
+          outputLimitBytes: { type: "number", minimum: 1024, maximum: 1048576 },
+          env: { type: "object", additionalProperties: { type: "string" } }
+        }
+      }
+    }
+  }
+};
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+var DEFAULT_OUTPUT_LIMIT_BYTES = 128 * 1024;
+var OUTPUT_SUMMARY_CHARS = 2e3;
+function parseConfigText2(path28, text) {
+  if (/\.json$/i.test(path28)) return JSON.parse(text);
+  return yaml2.load(text);
+}
+function truncateOutput(value) {
+  const text = typeof value === "string" ? value : value == null ? "" : String(value);
+  if (text.length <= OUTPUT_SUMMARY_CHARS) return text;
+  return `${text.slice(0, OUTPUT_SUMMARY_CHARS)}
+[truncated ${text.length - OUTPUT_SUMMARY_CHARS} chars]`;
+}
+function validateMeshWorktreeBootstrapConfig(config, source = "inline") {
+  const errors = [];
+  const commands = [];
+  const rejectedCommands = [];
+  if (!isMeshConfigRecord(config)) return { valid: false, errors: ["config must be an object"], commands, rejectedCommands };
+  if (config.version !== 1) errors.push("version must be 1");
+  if (config.enabled !== void 0 && typeof config.enabled !== "boolean") errors.push("enabled must be a boolean when provided");
+  if (config.runOnClone !== void 0 && typeof config.runOnClone !== "boolean") errors.push("runOnClone must be a boolean when provided");
+  if (config.required !== void 0 && typeof config.required !== "boolean") errors.push("required must be a boolean when provided");
+  if (config.staleInputs !== void 0 && (!Array.isArray(config.staleInputs) || !config.staleInputs.every((input) => typeof input === "string" && input.trim()))) {
+    errors.push("staleInputs must be an array of non-empty strings when provided");
+  }
+  if (config.commands !== void 0 && !Array.isArray(config.commands)) errors.push("commands must be an array");
+  if (Array.isArray(config.commands)) {
+    config.commands.forEach((entry, index) => {
+      const normalized = normalizeMeshCommandConfig(entry, `${source}:commands[${index}]`);
+      if (normalized.command) commands.push(normalized.command);
+      if (normalized.rejected) rejectedCommands.push(normalized.rejected);
+    });
+  }
+  if (config.enabled !== false && config.runOnClone !== false && commands.length === 0) errors.push("commands must contain at least one command when bootstrap is enabled");
+  if (rejectedCommands.length) errors.push("one or more bootstrap commands are invalid");
+  return { valid: errors.length === 0, errors, commands, rejectedCommands };
+}
+function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
+  const inline = mesh?.worktreeBootstrapConfig || mesh?.policy?.worktreeBootstrapConfig || mesh?.policy?.worktreeBootstrap;
+  if (inline !== void 0) {
+    const validation = validateMeshWorktreeBootstrapConfig(inline, "mesh.policy.worktreeBootstrapConfig");
+    if (!validation.valid) return { source: "mesh.policy.worktreeBootstrapConfig", sourceType: "invalid", error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
+    return { config: inline, source: "mesh.policy.worktreeBootstrapConfig", sourceType: "mesh_policy" };
+  }
+  for (const relative3 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
+    const configPath = (0, import_path4.join)(workspace, relative3);
+    if (!(0, import_fs4.existsSync)(configPath)) continue;
+    try {
+      const parsed = parseConfigText2(configPath, (0, import_fs4.readFileSync)(configPath, "utf-8"));
+      const validation = validateMeshWorktreeBootstrapConfig(parsed, relative3);
+      if (!validation.valid) return { source: relative3, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
+      return { config: parsed, source: relative3, sourceType: "repo_file", path: configPath };
+    } catch (error) {
+      return { source: relative3, sourceType: "invalid", path: configPath, error: error?.message || String(error) };
+    }
+  }
+  return { source: "unavailable", sourceType: "unavailable", error: `No worktree bootstrap config found. Checked: ${MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS.join(", ")}` };
+}
+async function runMeshWorktreeBootstrap(mesh, workspace) {
+  const loaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+  if (!loaded.config) {
+    return { status: "not_configured", required: false, configSource: loaded.source, configSourceType: loaded.sourceType, error: loaded.error };
+  }
+  const required = loaded.config.required !== false;
+  if (loaded.config.enabled === false || loaded.config.runOnClone === false) {
+    return { status: "disabled", required, configSource: loaded.path || loaded.source, configSourceType: loaded.sourceType };
+  }
+  const validation = validateMeshWorktreeBootstrapConfig(loaded.config, loaded.source);
+  if (!validation.valid) {
+    return { status: "failed", required, configSource: loaded.path || loaded.source, configSourceType: "invalid", error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")), commandsRun: [] };
+  }
+  const execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+  const state = {
+    status: "running",
+    required,
+    configSource: loaded.path || loaded.source,
+    configSourceType: loaded.sourceType,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    commandsRun: [],
+    staleInputs: loaded.config.staleInputs
+  };
+  for (const command of validation.commands) {
+    const cwd = command.cwd ? (0, import_path4.resolve)(workspace, command.cwd) : workspace;
+    const startedAt = Date.now();
+    state.lastCommand = command.displayCommand;
+    try {
+      const result = await execFileAsync3(command.command, command.args, {
+        cwd,
+        encoding: "utf8",
+        timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS2,
+        maxBuffer: command.outputLimitBytes || DEFAULT_OUTPUT_LIMIT_BYTES,
+        env: { ...process.env, CI: process.env.CI || "1", ...command.env || {} },
+        windowsHide: true
+      });
+      state.commandsRun?.push({
+        command: command.command,
+        args: command.args,
+        displayCommand: command.displayCommand,
+        category: command.category,
+        source: command.source,
+        cwd,
+        passed: true,
+        durationMs: Date.now() - startedAt,
+        exitCode: 0,
+        stdout: truncateOutput(result.stdout),
+        stderr: truncateOutput(result.stderr)
+      });
+    } catch (error) {
+      const exitCode = typeof error?.code === "number" ? error.code : null;
+      state.status = "failed";
+      state.exitCode = exitCode;
+      state.error = error?.message || String(error);
+      state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      state.commandsRun?.push({
+        command: command.command,
+        args: command.args,
+        displayCommand: command.displayCommand,
+        category: command.category,
+        source: command.source,
+        cwd,
+        passed: false,
+        durationMs: Date.now() - startedAt,
+        exitCode,
+        signal: typeof error?.signal === "string" ? error.signal : null,
+        timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
+        stdout: truncateOutput(error?.stdout),
+        stderr: truncateOutput(error?.stderr || error?.message)
+      });
+      return state;
+    }
+  }
+  state.status = "ready";
+  state.exitCode = 0;
+  state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return state;
+}
+
 // src/mesh/mesh-sync.ts
 init_mesh_config();
 async function syncMeshes(transport) {
@@ -9904,6 +10112,134 @@ function buildMeshActiveWork(opts) {
   }
   return { activeWork: records, staleDirectWork, staleDirectWorkNote, terminalDirectWork, summary };
 }
+function buildCompactStaleDirectWorkSummary(staleDirectWork, opts = {}) {
+  const sampleLimit = Math.max(0, Math.min(10, Math.floor(opts.sampleLimit ?? 3)));
+  const reasonCounts = {};
+  for (const entry of staleDirectWork) {
+    const reason = entry.staleReason || "unknown";
+    reasonCounts[reason] = (reasonCounts[reason] || 0) + 1;
+  }
+  return {
+    count: staleDirectWork.length,
+    sampleLimit,
+    sample: staleDirectWork.slice(0, sampleLimit).map((entry) => ({
+      taskId: entry.taskId,
+      status: entry.status,
+      nodeId: entry.nodeId,
+      sessionId: entry.sessionId,
+      taskTitle: entry.taskTitle,
+      createdAt: entry.createdAt,
+      staleReason: entry.staleReason
+    })),
+    reasonCounts,
+    detailHint: opts.detailHint || "Stale direct records are historical recovery evidence only. Use mesh_task_history for full ledger details, or request includeStaleDirectWorkDetails when supported by the caller.",
+    ...opts.note ? { note: opts.note } : {}
+  };
+}
+
+// src/mesh/mesh-refine-status.ts
+function readString3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function eventStatus(event, fallback) {
+  if (event === "refine:accepted") return "accepted";
+  if (event === "refine:completed") return "completed";
+  if (event === "refine:failed") return "failed";
+  if (fallback === "completed" || fallback === "failed" || fallback === "accepted") return fallback;
+  return void 0;
+}
+function ledgerStatus(kind, fallback) {
+  if (kind === "task_completed") return "completed";
+  if (kind === "task_failed") return "failed";
+  if (fallback === "accepted") return "accepted";
+  return "running";
+}
+function instructionForStatus(status) {
+  if (status === "accepted") return "Refine job is accepted; wait for asyncRefineJobs or pendingCoordinatorEvents to report running/completed/failed.";
+  if (status === "running") return "Refine job is running; do not poll the ledger repeatedly. Watch asyncRefineJobs or pendingCoordinatorEvents for the terminal result.";
+  if (status === "completed") return "Refine job completed; inspect branch convergence and cleanup evidence before reporting final merge state.";
+  return "Refine job failed; inspect result/finalBranchConvergenceState in mesh_task_history, fix the blocker, then rerun mesh_refine_node when ready.";
+}
+function mergeJob(jobs, patch) {
+  const jobId = readString3(patch.jobId);
+  if (!jobId) return;
+  const previous = jobs.get(jobId);
+  const status = patch.status || previous?.status || "running";
+  const definedPatch = Object.fromEntries(
+    Object.entries(patch).filter(([, value]) => value !== void 0)
+  );
+  jobs.set(jobId, {
+    ...previous,
+    ...definedPatch,
+    jobId,
+    status,
+    instruction: instructionForStatus(status)
+  });
+}
+function buildMeshAsyncRefineJobs(args) {
+  const jobs = /* @__PURE__ */ new Map();
+  for (const entry of args.ledgerEntries || []) {
+    const payload = readRecord(entry.payload);
+    if (payload?.source !== "refine_mesh_node_async_job") continue;
+    const refineJob = readRecord(payload.refineJob);
+    const result = readRecord(payload.result);
+    const finalState = readRecord(payload.finalBranchConvergenceState) || readRecord(result?.finalBranchConvergenceState);
+    const jobId = readString3(refineJob?.jobId);
+    if (!jobId) continue;
+    const status = ledgerStatus(entry.kind, readString3(refineJob?.status));
+    mergeJob(jobs, {
+      jobId,
+      interactionId: readString3(refineJob?.interactionId),
+      status,
+      meshId: readString3(refineJob?.meshId) || args.meshId,
+      nodeId: readString3(refineJob?.nodeId) || entry.nodeId,
+      targetNodeId: readString3(refineJob?.nodeId) || entry.nodeId,
+      targetDaemonId: readString3(refineJob?.targetDaemonId),
+      workspace: readString3(refineJob?.workspace),
+      branch: readString3(result?.branch) || readString3(finalState?.branch),
+      into: readString3(result?.into) || readString3(finalState?.baseBranch),
+      startedAt: readString3(refineJob?.startedAt),
+      completedAt: readString3(refineJob?.completedAt),
+      retryOfJobId: readString3(refineJob?.retryOfJobId) || readString3(payload.retryOfJobId),
+      lastLedgerKind: entry.kind,
+      lastUpdatedAt: entry.timestamp
+    });
+  }
+  for (const event of args.pendingEvents || []) {
+    const metadata = readRecord(event.metadataEvent);
+    if (metadata?.source !== "refine_mesh_node_async_job") continue;
+    const result = readRecord(metadata.result);
+    const finalState = readRecord(result?.finalBranchConvergenceState);
+    const jobId = readString3(metadata.jobId);
+    if (!jobId) continue;
+    const status = eventStatus(event.event, readString3(metadata.status));
+    mergeJob(jobs, {
+      jobId,
+      interactionId: readString3(metadata.interactionId),
+      ...status ? { status } : {},
+      meshId: readString3(metadata.meshId) || event.meshId || args.meshId,
+      nodeId: readString3(metadata.nodeId) || event.nodeId,
+      targetNodeId: readString3(metadata.nodeId) || event.nodeId,
+      targetDaemonId: readString3(metadata.targetDaemonId),
+      workspace: readString3(metadata.workspace) || event.workspace,
+      branch: readString3(result?.branch) || readString3(finalState?.branch),
+      into: readString3(result?.into) || readString3(finalState?.baseBranch),
+      startedAt: readString3(metadata.startedAt),
+      completedAt: readString3(metadata.completedAt),
+      retryOfJobId: readString3(metadata.retryOfJobId),
+      lastEvent: event.event,
+      lastUpdatedAt: new Date(event.queuedAt).toISOString()
+    });
+  }
+  return Array.from(jobs.values()).sort((a, b) => {
+    const aTime = new Date(a.lastUpdatedAt || a.startedAt || "").getTime();
+    const bTime = new Date(b.lastUpdatedAt || b.startedAt || "").getTime();
+    return (Number.isFinite(bTime) ? bTime : 0) - (Number.isFinite(aTime) ? aTime : 0);
+  });
+}
 
 // src/index.ts
 init_mesh_host_ownership();
@@ -10020,8 +10356,8 @@ var P2pRelayFailureError = class extends Error {
 };
 
 // src/config/state-store.ts
-var import_fs8 = require("fs");
-var import_path7 = require("path");
+var import_fs9 = require("fs");
+var import_path8 = require("path");
 init_config();
 var DEFAULT_STATE = {
   recentActivity: [],
@@ -10035,7 +10371,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path7.join)(getConfigDir(), "state.json");
+  return (0, import_path8.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -10071,11 +10407,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs8.existsSync)(statePath)) {
+  if (!(0, import_fs9.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs8.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs9.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -10084,7 +10420,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs8.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs9.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -10093,7 +10429,7 @@ function resetState() {
 // src/detection/ide-detector.ts
 var import_child_process2 = require("child_process");
 var import_util = require("util");
-var import_fs9 = require("fs");
+var import_fs10 = require("fs");
 var import_os2 = require("os");
 var path10 = __toESM(require("path"));
 var execAsync2 = (0, import_util.promisify)(import_child_process2.exec);
@@ -10118,7 +10454,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return (0, import_fs9.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs10.existsSync)(resolved) ? resolved : null;
   }
   const isWin = (0, import_os2.platform)() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -10128,8 +10464,8 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path10.join(p, trimmed + ext);
       try {
-        if ((0, import_fs9.existsSync)(fullPath)) {
-          const stat2 = (0, import_fs9.statSync)(fullPath);
+        if ((0, import_fs10.existsSync)(fullPath)) {
+          const stat2 = (0, import_fs10.statSync)(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -10158,9 +10494,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs9.existsSync)(resolved)) return resolved;
+      if ((0, import_fs10.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs9.existsSync)(normalized)) return normalized;
+      if ((0, import_fs10.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -10174,7 +10510,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs9.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs10.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -10187,7 +10523,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs9.existsSync)(c)) {
+        if ((0, import_fs10.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -10503,7 +10839,7 @@ var DaemonCdpManager = class {
   * Returns multiple entries if multiple IDE windows are open on same port
   */
   static listAllTargets(port) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -10519,16 +10855,16 @@ var DaemonCdpManager = class {
               (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
             );
             const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-            resolve16(mainPages.length > 0 ? mainPages : fallbackPages);
+            resolve17(mainPages.length > 0 ? mainPages : fallbackPages);
           } catch {
-            resolve16([]);
+            resolve17([]);
           }
         });
       });
-      req.on("error", () => resolve16([]));
+      req.on("error", () => resolve17([]));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve16([]);
+        resolve17([]);
       });
     });
   }
@@ -10568,7 +10904,7 @@ var DaemonCdpManager = class {
     }
   }
   findTargetOnPort(port) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -10579,7 +10915,7 @@ var DaemonCdpManager = class {
               (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
             );
             if (pages.length === 0) {
-              resolve16(targets.find((t) => t.webSocketDebuggerUrl) || null);
+              resolve17(targets.find((t) => t.webSocketDebuggerUrl) || null);
               return;
             }
             const titleFilteredPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -10598,25 +10934,25 @@ var DaemonCdpManager = class {
                 this._targetId = selected.target.id;
               }
               this._pageTitle = selected.target.title || "";
-              resolve16(selected.target);
+              resolve17(selected.target);
               return;
             }
             if (previousTargetId) {
               this.log(`[CDP] Target ${previousTargetId} not found in page list`);
-              resolve16(null);
+              resolve17(null);
               return;
             }
             this._pageTitle = list[0]?.title || "";
-            resolve16(list[0]);
+            resolve17(list[0]);
           } catch {
-            resolve16(null);
+            resolve17(null);
           }
         });
       });
-      req.on("error", () => resolve16(null));
+      req.on("error", () => resolve17(null));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve16(null);
+        resolve17(null);
       });
     });
   }
@@ -10627,7 +10963,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       this.ws = new import_ws.default(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -10637,17 +10973,17 @@ var DaemonCdpManager = class {
         }
         this.connectBrowserWs().catch(() => {
         });
-        resolve16(true);
+        resolve17(true);
       });
       this.ws.on("message", (data) => {
         try {
           const msg = JSON.parse(data.toString());
           if (msg.id && this.pending.has(msg.id)) {
-            const { resolve: resolve17, reject } = this.pending.get(msg.id);
+            const { resolve: resolve18, reject } = this.pending.get(msg.id);
             this.pending.delete(msg.id);
             this.failureCount = 0;
             if (msg.error) reject(new Error(msg.error.message));
-            else resolve17(msg.result);
+            else resolve18(msg.result);
           } else if (msg.method === "Runtime.executionContextCreated") {
             this.contexts.add(msg.params.context.id);
           } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -10670,7 +11006,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve16(false);
+        resolve17(false);
       });
     });
   }
@@ -10684,7 +11020,7 @@ var DaemonCdpManager = class {
         return;
       }
       this.log(`[CDP] Connecting browser WS for target discovery...`);
-      await new Promise((resolve16, reject) => {
+      await new Promise((resolve17, reject) => {
         this.browserWs = new import_ws.default(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -10694,16 +11030,16 @@ var DaemonCdpManager = class {
           } catch (e) {
             this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
           }
-          resolve16();
+          resolve17();
         });
         this.browserWs.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.id && this.browserPending.has(msg.id)) {
-              const { resolve: resolve17, reject: reject2 } = this.browserPending.get(msg.id);
+              const { resolve: resolve18, reject: reject2 } = this.browserPending.get(msg.id);
               this.browserPending.delete(msg.id);
               if (msg.error) reject2(new Error(msg.error.message));
-              else resolve17(msg.result);
+              else resolve18(msg.result);
             }
           } catch {
           }
@@ -10723,31 +11059,31 @@ var DaemonCdpManager = class {
     }
   }
   getBrowserWsUrl() {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
         res.on("end", () => {
           try {
             const info = JSON.parse(data);
-            resolve16(info.webSocketDebuggerUrl || null);
+            resolve17(info.webSocketDebuggerUrl || null);
           } catch {
-            resolve16(null);
+            resolve17(null);
           }
         });
       });
-      req.on("error", () => resolve16(null));
+      req.on("error", () => resolve17(null));
       req.setTimeout(3e3, () => {
         req.destroy();
-        resolve16(null);
+        resolve17(null);
       });
     });
   }
   sendBrowser(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
       const id = this.browserMsgId++;
-      this.browserPending.set(id, { resolve: resolve16, reject });
+      this.browserPending.set(id, { resolve: resolve17, reject });
       this.browserWs.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.browserPending.has(id)) {
@@ -10787,11 +11123,11 @@ var DaemonCdpManager = class {
   }
   // ─── CDP Protocol ────────────────────────────────────────
   sendInternal(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
       if (this.ws.readyState !== import_ws.default.OPEN) return reject(new Error("WebSocket not open"));
       const id = this.msgId++;
-      this.pending.set(id, { resolve: resolve16, reject });
+      this.pending.set(id, { resolve: resolve17, reject });
       this.ws.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.pending.has(id)) {
@@ -11040,7 +11376,7 @@ var DaemonCdpManager = class {
     const browserWs = this.browserWs;
     let msgId = this.browserMsgId;
     const sendWs = (method, params = {}, sessionId) => {
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve17, reject) => {
         const mid = msgId++;
         this.browserMsgId = msgId;
         const handler = (raw) => {
@@ -11049,7 +11385,7 @@ var DaemonCdpManager = class {
             if (msg.id === mid) {
               browserWs.removeListener("message", handler);
               if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-              else resolve16(msg.result);
+              else resolve17(msg.result);
             }
           } catch {
           }
@@ -11250,14 +11586,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== import_ws.default.OPEN) {
       throw new Error("CDP not connected");
     }
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const id = getNextId();
       pendingMap.set(id, {
         resolve: (result) => {
           if (result?.result?.subtype === "error") {
             reject(new Error(result.result.description));
           } else {
-            resolve16(result?.result?.value);
+            resolve17(result?.result?.value);
           }
         },
         reject
@@ -11289,10 +11625,10 @@ var DaemonCdpManager = class {
       throw new Error("CDP not connected");
     }
     const sendViaSession = (method, params = {}) => {
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve17, reject) => {
         const pendingMap = this._browserConnected ? this.browserPending : this.pending;
         const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-        pendingMap.set(id, { resolve: resolve16, reject });
+        pendingMap.set(id, { resolve: resolve17, reject });
         ws.send(JSON.stringify({ id, sessionId, method, params }));
         setTimeout(() => {
           if (pendingMap.has(id)) {
@@ -16394,7 +16730,7 @@ function getSendChatInputEnvelope(args) {
   return normalizeInputEnvelope(args?.input ? { input: args.input } : args);
 }
 function sleep(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 async function waitOnceForFreshHermesCliStart(adapter, log) {
   if (adapter.cliType !== "hermes-cli") return;
@@ -17181,7 +17517,7 @@ function getCliVisibleTranscriptCount(adapter) {
 async function getStableExtensionBaseline(h) {
   const first = await readExtensionChatState(h);
   if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
-  await new Promise((resolve16) => setTimeout(resolve16, 150));
+  await new Promise((resolve17) => setTimeout(resolve17, 150));
   const second = await readExtensionChatState(h);
   return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
 }
@@ -17189,7 +17525,7 @@ async function verifyExtensionSendObserved(h, before) {
   const beforeCount = getStateMessageCount(before);
   const beforeSignature = getStateLastSignature(before);
   for (let attempt = 0; attempt < 12; attempt += 1) {
-    await new Promise((resolve16) => setTimeout(resolve16, 250));
+    await new Promise((resolve17) => setTimeout(resolve17, 250));
     const state = await readExtensionChatState(h);
     if (state?.status === "waiting_approval") return true;
     const afterCount = getStateMessageCount(state);
@@ -19078,7 +19414,7 @@ async function executeProviderScript(h, args, scriptName) {
         const enterCount = cliCommand.enterCount || 1;
         await adapter.writeRaw(cliCommand.text + "\r");
         for (let i = 1; i < enterCount; i += 1) {
-          await new Promise((resolve16) => setTimeout(resolve16, 50));
+          await new Promise((resolve17) => setTimeout(resolve17, 50));
           await adapter.writeRaw("\r");
         }
       }
@@ -19767,7 +20103,7 @@ var DaemonCommandHandler = class {
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(body);
-      const result = await new Promise((resolve16, reject) => {
+      const result = await new Promise((resolve17, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -19779,9 +20115,9 @@ var DaemonCommandHandler = class {
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve16(JSON.parse(data));
+              resolve17(JSON.parse(data));
             } catch {
-              resolve16({ raw: data });
+              resolve17({ raw: data });
             }
           });
         });
@@ -19799,15 +20135,15 @@ var DaemonCommandHandler = class {
     if (!providerType) return { success: false, error: "providerType required" };
     try {
       const http3 = await import("http");
-      const result = await new Promise((resolve16, reject) => {
+      const result = await new Promise((resolve17, reject) => {
         http3.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
           let data = "";
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve16(JSON.parse(data));
+              resolve17(JSON.parse(data));
             } catch {
-              resolve16({ raw: data });
+              resolve17({ raw: data });
             }
           });
         }).on("error", reject);
@@ -19821,7 +20157,7 @@ var DaemonCommandHandler = class {
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(args || {});
-      const result = await new Promise((resolve16, reject) => {
+      const result = await new Promise((resolve17, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -19833,9 +20169,9 @@ var DaemonCommandHandler = class {
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve16(JSON.parse(data));
+              resolve17(JSON.parse(data));
             } catch {
-              resolve16({ raw: data });
+              resolve17({ raw: data });
             }
           });
         });
@@ -19854,7 +20190,7 @@ var DaemonCommandHandler = class {
 var os13 = __toESM(require("os"));
 var path18 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
-var import_fs10 = require("fs");
+var import_fs11 = require("fs");
 var import_child_process5 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
@@ -20079,7 +20415,7 @@ async function waitForCliAdapterReady(adapter, options) {
     if (status === "stopped") {
       throw new Error("CLI runtime stopped before it became ready");
     }
-    await new Promise((resolve16) => setTimeout(resolve16, pollMs));
+    await new Promise((resolve17) => setTimeout(resolve17, pollMs));
   }
   throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
 }
@@ -20456,7 +20792,7 @@ var CliProviderInstance = class {
       const enterCount = cliCommand.enterCount || 1;
       await this.adapter.writeRaw(cliCommand.text + "\r");
       for (let i = 1; i < enterCount; i += 1) {
-        await new Promise((resolve16) => setTimeout(resolve16, 50));
+        await new Promise((resolve17) => setTimeout(resolve17, 50));
         await this.adapter.writeRaw("\r");
       }
     }
@@ -21852,13 +22188,13 @@ var AcpProviderInstance = class {
         }
         this.currentStatus = "waiting_approval";
         this.detectStatusTransition();
-        const approved = await new Promise((resolve16) => {
-          this.permissionResolvers.push(resolve16);
+        const approved = await new Promise((resolve17) => {
+          this.permissionResolvers.push(resolve17);
           setTimeout(() => {
-            const idx = this.permissionResolvers.indexOf(resolve16);
+            const idx = this.permissionResolvers.indexOf(resolve17);
             if (idx >= 0) {
               this.permissionResolvers.splice(idx, 1);
-              resolve16(false);
+              resolve17(false);
             }
           }, 3e5);
         });
@@ -22469,7 +22805,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs10.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs11.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process5.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -22567,7 +22903,7 @@ async function waitForZeroMessageStartingLaunch(adapter) {
   } catch {
     return false;
   }
-  await new Promise((resolve16) => setTimeout(resolve16, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
+  await new Promise((resolve17) => setTimeout(resolve17, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
   try {
     return hasZeroMessageStartingLaunch(adapter);
   } catch {
@@ -22591,10 +22927,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  (0, import_fs10.mkdirSync)(baseDir, { recursive: true });
+  (0, import_fs11.mkdirSync)(baseDir, { recursive: true });
   const workspaceHash = crypto4.createHash("sha256").update(path18.resolve(workspace || os13.tmpdir())).digest("hex").slice(0, 16);
   const filePath = path18.join(baseDir, `${workspaceHash}.json`);
-  (0, import_fs10.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  (0, import_fs11.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -24640,8 +24976,8 @@ var ProviderLoader = class _ProviderLoader {
     }
     const https = require("https");
     const { exec: exec7 } = require("child_process");
-    const { promisify: promisify6 } = require("util");
-    const execAsync5 = promisify6(exec7);
+    const { promisify: promisify7 } = require("util");
+    const execAsync5 = promisify7(exec7);
     const metaPath = path19.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
@@ -24659,7 +24995,7 @@ var ProviderLoader = class _ProviderLoader {
       return { updated: false };
     }
     try {
-      const etag = await new Promise((resolve16, reject) => {
+      const etag = await new Promise((resolve17, reject) => {
         const options = {
           method: "HEAD",
           hostname: "github.com",
@@ -24677,7 +25013,7 @@ var ProviderLoader = class _ProviderLoader {
               headers: { "User-Agent": "adhdev-launcher" },
               timeout: 1e4
             }, (res2) => {
-              resolve16(res2.headers.etag || res2.headers["last-modified"] || "");
+              resolve17(res2.headers.etag || res2.headers["last-modified"] || "");
             });
             req2.on("error", reject);
             req2.on("timeout", () => {
@@ -24686,7 +25022,7 @@ var ProviderLoader = class _ProviderLoader {
             });
             req2.end();
           } else {
-            resolve16(res.headers.etag || res.headers["last-modified"] || "");
+            resolve17(res.headers.etag || res.headers["last-modified"] || "");
           }
         });
         req.on("error", reject);
@@ -24750,7 +25086,7 @@ var ProviderLoader = class _ProviderLoader {
   downloadFile(url, destPath) {
     const https = require("https");
     const http3 = require("http");
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const doRequest = (reqUrl, redirectCount = 0) => {
         if (redirectCount > 5) {
           reject(new Error("Too many redirects"));
@@ -24770,7 +25106,7 @@ var ProviderLoader = class _ProviderLoader {
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve16();
+            resolve17();
           });
           ws.on("error", reject);
         });
@@ -25273,10 +25609,10 @@ function findMacAppProcessPids(psOutput, appPaths) {
 
 // src/launch.ts
 async function execQuiet(command, options = {}) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     (0, import_child_process6.exec)(command, options, (error, stdout) => {
-      if (error) return resolve16("");
-      resolve16(stdout.toString());
+      if (error) return resolve17("");
+      resolve17(stdout.toString());
     });
   });
 }
@@ -25357,17 +25693,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve16(false));
+    server.on("error", () => resolve17(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve16(true));
+      server.close(() => resolve17(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -25376,16 +25712,16 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve16(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve17(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve16(false);
+          resolve17(false);
         }
       });
     });
-    req.on("error", () => resolve16(false));
+    req.on("error", () => resolve17(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve16(false);
+      resolve17(false);
     });
   });
 }
@@ -25859,7 +26195,7 @@ function getRecentCommands(count = 50) {
 cleanOldFiles();
 
 // src/commands/router.ts
-var yaml2 = __toESM(require("js-yaml"));
+var yaml3 = __toESM(require("js-yaml"));
 init_logger();
 
 // src/commands/mesh-coordinator.ts
@@ -26047,6 +26383,88 @@ function resolveMcpPort(explicitPort) {
 init_mesh_events();
 init_mesh_host_ownership();
 
+// src/mesh/preview-freshness.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
+function runGit2(repoRoot, args) {
+  try {
+    return (0, import_node_child_process4.execFileSync)("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function readRecord3(repoRoot) {
+  const path28 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+  if (!(0, import_node_fs3.existsSync)(path28)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(path28, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeCommit(value) {
+  return typeof value === "string" && /^[0-9a-f]{7,40}$/i.test(value.trim()) ? value.trim() : null;
+}
+function readTargetFreshness(record, currentCommit) {
+  const targets = record?.targets && typeof record.targets === "object" && !Array.isArray(record.targets) ? record.targets : {};
+  const result = {};
+  for (const targetName of ["npm", "server", "web"]) {
+    const targetRecord = targets[targetName] && typeof targets[targetName] === "object" && !Array.isArray(targets[targetName]) ? targets[targetName] : {};
+    const commit = normalizeCommit(targetRecord.commit);
+    result[targetName] = {
+      commit,
+      deployedAt: typeof targetRecord.deployedAt === "string" ? targetRecord.deployedAt : void 0,
+      status: commit && currentCommit ? commit === currentCommit ? "fresh" : "stale" : "unknown"
+    };
+  }
+  return result;
+}
+function readCurrentMainCommit(repoRoot) {
+  const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
+  if (originMain) {
+    return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
+  }
+  const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
+  if (head) {
+    return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
+  }
+  return { currentMainCommit: null, currentMainCommitSource: "unknown" };
+}
+function buildPreviewFreshness(repoRoot) {
+  const current = readCurrentMainCommit(repoRoot);
+  const record = readRecord3(repoRoot);
+  const lastPreviewCommit = normalizeCommit(record?.lastPreviewCommit);
+  const targets = readTargetFreshness(record, current.currentMainCommit);
+  let status = "unknown";
+  let nextAction = "Run npm run deploy:preview from the current main commit, then smoke preview.";
+  if (lastPreviewCommit && current.currentMainCommit) {
+    status = lastPreviewCommit === current.currentMainCommit ? "fresh" : "stale";
+    nextAction = status === "fresh" ? "No preview deploy action needed." : "Run npm run deploy:preview from origin/main, then smoke preview.";
+  } else if (!current.currentMainCommit) {
+    nextAction = "Resolve the current main commit before judging preview freshness.";
+  }
+  return {
+    status,
+    lastPreviewCommit,
+    currentMainCommit: current.currentMainCommit,
+    currentMainCommitSource: current.currentMainCommitSource,
+    recordPath: PREVIEW_DEPLOY_RECORD,
+    lastDeployedAt: typeof record?.updatedAt === "string" ? record.updatedAt : void 0,
+    lastTarget: typeof record?.target === "string" ? record.target : void 0,
+    previewVersion: typeof record?.previewVersion === "string" ? record.previewVersion : void 0,
+    targets,
+    nextAction
+  };
+}
+
 // src/status/snapshot.ts
 var os18 = __toESM(require("os"));
 init_config();
@@ -26553,7 +26971,7 @@ async function waitForPidExit(pid, timeoutMs) {
   while (Date.now() - start < timeoutMs) {
     try {
       process.kill(pid, 0);
-      await new Promise((resolve16) => setTimeout(resolve16, 250));
+      await new Promise((resolve17) => setTimeout(resolve17, 250));
     } catch {
       return;
     }
@@ -26664,7 +27082,7 @@ async function runDaemonUpgradeHelper(payload) {
     appendUpgradeLog(installOutput.trim());
   }
   if (process.platform === "win32") {
-    await new Promise((resolve16) => setTimeout(resolve16, 500));
+    await new Promise((resolve17) => setTimeout(resolve17, 500));
     cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
     appendUpgradeLog("Post-install staging cleanup complete");
   }
@@ -26701,8 +27119,9 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 // src/commands/router.ts
 init_mesh_work_queue();
 var import_os3 = require("os");
-var import_path8 = require("path");
+var import_path9 = require("path");
 var fs11 = __toESM(require("fs"));
+var import_node_child_process5 = require("child_process");
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
   stable: "https://api.adhf.dev",
@@ -26848,7 +27267,7 @@ function buildMeshNodeDisplayLabel(node, nodeId, providerPriority) {
   const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
   if (explicit) return explicit;
   const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
-  const workspaceName = workspace ? (0, import_path8.basename)(workspace) : void 0;
+  const workspaceName = workspace ? (0, import_path9.basename)(workspace) : void 0;
   const host = readStringValue(node.machineName, node.machine_name, node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
   const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : void 0);
   const parts = [workspaceName, host, provider].filter(Boolean);
@@ -27414,6 +27833,16 @@ function finalizeMeshNodeStatus(args) {
     if (machineStatus) status.machineStatus = machineStatus;
   }
   synthesizeMeshNodeFreshnessFromConnection(status);
+  const bootstrap = readObjectRecord(node?.worktreeBootstrap);
+  if (node?.isLocalWorktree && readStringValue(bootstrap.status)) {
+    status.worktreeBootstrap = bootstrap;
+    if (bootstrap.status === "failed" && bootstrap.required !== false) {
+      status.launchReady = false;
+      status.launchBlockedReason = "worktree_bootstrap_failed";
+      status.launchBlockedMessage = readStringValue(bootstrap.error) || "Required worktree bootstrap failed; resolve it before launching an agent into this node.";
+      return;
+    }
+  }
   const connectionState = readStringValue(readObjectRecord(status.connection).state);
   status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || connectionState === "connected" || isSelfNode);
 }
@@ -27555,6 +27984,40 @@ function collectLiveMeshSessionRecords(args) {
   }
   return matches;
 }
+function buildHistoricalMeshSessions(args) {
+  const liveNodeIds = /* @__PURE__ */ new Set();
+  const liveWorkspaces = /* @__PURE__ */ new Set();
+  for (const node of args.nodes || []) {
+    const nodeId = readStringValue(node?.id, node?.nodeId);
+    const workspace = readStringValue(node?.workspace);
+    if (nodeId) liveNodeIds.add(nodeId);
+    if (workspace) liveWorkspaces.add(workspace);
+  }
+  const sessions = [];
+  for (const record of args.liveSessionRecords || []) {
+    const meta = readObjectRecord(record?.meta);
+    const recordMeshId = readStringValue(meta.meshNodeFor, meta.meshCoordinatorFor);
+    if (recordMeshId !== args.meshId) continue;
+    const recordNodeId = readStringValue(meta.meshNodeId);
+    const workspace = readStringValue(record?.workspace);
+    const removedNode = !!recordNodeId && !liveNodeIds.has(recordNodeId);
+    const orphanedWorkspace = !!workspace && !liveWorkspaces.has(workspace) && meta.meshCoordinatorFor !== args.meshId;
+    if (!removedNode && !orphanedWorkspace) continue;
+    sessions.push({
+      ...summarizeMeshSessionRecord(record),
+      classification: removedNode ? "removedNode" : "orphanedSession",
+      historical: true,
+      meshNodeId: recordNodeId || null,
+      reason: removedNode ? "Session is tagged to a mesh node that is no longer in live membership." : "Session workspace is no longer attached to a live mesh node."
+    });
+  }
+  if (sessions.length === 0) return void 0;
+  return {
+    count: sessions.length,
+    sessions: sessions.slice(0, 5),
+    instruction: "These sessions are separated from normal node activeSessions because their mesh node/workspace is no longer live. Use mesh_cleanup_sessions only if cleanup is intended."
+  };
+}
 function applyCachedInlineMeshNodeStatus(status, node, options) {
   const cachedStatus = readObjectRecord(node?.cachedStatus);
   const liveGit = buildInlineMeshTransitGitStatus(node);
@@ -27640,14 +28103,14 @@ function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
   return { enabled: false };
 }
 async function computeGitPatchId(cwd, fromRef, toRef) {
-  const { execFileSync: execFileSync3 } = await import("child_process");
-  const diff = execFileSync3("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+  const { execFileSync: execFileSync5 } = await import("child_process");
+  const diff = execFileSync5("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
     cwd,
     encoding: "utf8",
     maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
   });
   if (!diff.trim()) return "";
-  const patchId = execFileSync3("git", ["patch-id", "--stable"], {
+  const patchId = execFileSync5("git", ["patch-id", "--stable"], {
     cwd,
     input: diff,
     encoding: "utf8",
@@ -27658,8 +28121,8 @@ async function computeGitPatchId(cwd, fromRef, toRef) {
 async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync3 } = await import("child_process");
-    const git = (args) => execFileSync3("git", args, {
+    const { execFileSync: execFileSync5 } = await import("child_process");
+    const git = (args) => execFileSync5("git", args, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -27703,6 +28166,135 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
       durationMs: Date.now() - startedAt,
       error: e?.message || String(e),
       stdout: truncateValidationOutput(e?.stdout),
+      stderr: truncateValidationOutput(e?.stderr),
+      actionableHint: buildPatchEquivalenceSubmoduleConflictHint(
+        repoRoot,
+        baseHead,
+        branchHead,
+        `${e?.message || ""}
+${e?.stdout || ""}
+${e?.stderr || ""}`
+      )
+    };
+  }
+}
+function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output) {
+  if (!/(submodule|160000)/i.test(output) || !/(conflict|failed to merge)/i.test(output)) return void 0;
+  const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path28) => ({
+    path: path28,
+    baseCommit: readTreeObject(repoRoot, baseHead, path28),
+    branchCommit: readTreeObject(repoRoot, branchHead, path28)
+  }));
+  if (conflicts.length === 0) return void 0;
+  return {
+    kind: "submodule_conflict",
+    message: "Refinery could not synthesize a safe merge tree because the branch and base point the same submodule path at different commits.",
+    conflicts,
+    nextSteps: [
+      "Inspect the listed submodule path in both base and branch: baseCommit is the commit currently recorded by the base workspace, branchCommit is the commit recorded by the worktree branch.",
+      "Resolve the submodule first by checking out or creating the intended submodule commit, then commit the chosen gitlink in the root branch.",
+      "Ensure the chosen submodule commit is reachable from the configured submodule remote main branch, then rerun mesh_refine_node."
+    ]
+  };
+}
+function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
+  try {
+    const output = (0, import_node_child_process5.execFileSync)("git", ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const paths = /* @__PURE__ */ new Set();
+    for (const line of output.split("\n")) {
+      if (!line.trim()) continue;
+      const metaAndPath = line.split("	");
+      const meta = metaAndPath[0] || "";
+      const path28 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path28) continue;
+      const parts = meta.split(/\s+/);
+      if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
+        paths.add(path28);
+      }
+    }
+    return [...paths].sort();
+  } catch {
+    return [];
+  }
+}
+function readTreeObject(repoRoot, ref, path28) {
+  try {
+    const output = (0, import_node_child_process5.execFileSync)("git", ["ls-tree", ref, "--", path28], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024
+    }).trim();
+    const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
+  const startedAt = Date.now();
+  const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path28) => !(options.submoduleIgnorePaths || []).includes(path28));
+  const preStatus = await getGitRepoStatus(repoRoot, {
+    includeSubmodules: true,
+    submoduleIgnorePaths: options.submoduleIgnorePaths,
+    timeoutMs: 15e3
+  });
+  const outOfSyncPaths = (preStatus.submodules || []).filter((submodule) => submodule.dirty || submodule.outOfSync || !!submodule.error).map((submodule) => submodule.path);
+  const updatePaths = [.../* @__PURE__ */ new Set([...changedGitlinkPaths, ...outOfSyncPaths])].sort();
+  if (updatePaths.length === 0) {
+    return {
+      status: "skipped",
+      changedGitlinkPaths,
+      outOfSyncPaths,
+      updatedPaths: [],
+      verifiedPaths: [],
+      durationMs: Date.now() - startedAt,
+      reason: "no_changed_or_out_of_sync_submodules"
+    };
+  }
+  const commandArgs = ["submodule", "update", "--init", "--recursive", "--", ...updatePaths];
+  try {
+    const { execFile: execFile4 } = await import("child_process");
+    const { promisify: promisify7 } = await import("util");
+    const execFileAsync3 = promisify7(execFile4);
+    const result = await execFileAsync3("git", commandArgs, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+      timeout: 6e4
+    });
+    const postStatus = await getGitRepoStatus(repoRoot, {
+      includeSubmodules: true,
+      submoduleIgnorePaths: options.submoduleIgnorePaths,
+      timeoutMs: 15e3
+    });
+    const remaining = (postStatus.submodules || []).filter((submodule) => updatePaths.includes(submodule.path) && (submodule.dirty || submodule.outOfSync || !!submodule.error));
+    return {
+      status: remaining.length === 0 ? "passed" : "failed",
+      changedGitlinkPaths,
+      outOfSyncPaths,
+      updatedPaths: updatePaths,
+      verifiedPaths: updatePaths.filter((path28) => !remaining.some((submodule) => submodule.path === path28)),
+      durationMs: Date.now() - startedAt,
+      command: `git ${commandArgs.join(" ")}`,
+      stdout: truncateValidationOutput(result.stdout),
+      stderr: truncateValidationOutput(result.stderr),
+      ...remaining.length > 0 ? { error: `Submodule checkout remained out of sync after update: ${remaining.map((entry) => entry.path).join(", ")}` } : {}
+    };
+  } catch (e) {
+    return {
+      status: "failed",
+      changedGitlinkPaths,
+      outOfSyncPaths,
+      updatedPaths: updatePaths,
+      verifiedPaths: [],
+      durationMs: Date.now() - startedAt,
+      command: `git ${commandArgs.join(" ")}`,
+      error: e?.message || String(e),
+      stdout: truncateValidationOutput(e?.stdout),
       stderr: truncateValidationOutput(e?.stderr)
     };
   }
@@ -27711,10 +28303,10 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
   const startedAt = Date.now();
   const entries = [];
   try {
-    const { execFile: execFile3 } = await import("child_process");
-    const { promisify: promisify6 } = await import("util");
-    const execFileAsync3 = promisify6(execFile3);
-    const runGit2 = async (cwd, args) => {
+    const { execFile: execFile4 } = await import("child_process");
+    const { promisify: promisify7 } = await import("util");
+    const execFileAsync3 = promisify7(execFile4);
+    const runGit3 = async (cwd, args) => {
       const { stdout } = await execFileAsync3("git", args, {
         cwd,
         encoding: "utf8",
@@ -27725,8 +28317,8 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return String(stdout || "");
     };
     const verifyRemoteMainContainsCommit = async (submodulePath, commit, branch = "main") => {
-      await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
-      await runGit2(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
+      await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+      await runGit3(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
     };
     const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
       const refspec = `${commit}:refs/heads/${branch}`;
@@ -27742,21 +28334,21 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
     const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
       if (!fs11.existsSync(worktreeSubmodulePath)) return false;
       try {
-        await runGit2(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+        await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       } catch {
         return false;
       }
-      await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
-      await runGit2(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+      await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
+      await runGit3(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       return true;
     };
-    const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
+    const treeOutput = await runGit3(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
     const gitlinks = treeOutput.split("\0").filter(Boolean).map((record) => {
       const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record);
       return match ? { commit: match[1], path: match[2] } : null;
     }).filter((entry) => !!entry);
     for (const gitlink of gitlinks) {
-      const submodulePath = (0, import_path8.resolve)(repoRoot, gitlink.path);
+      const submodulePath = (0, import_path9.resolve)(repoRoot, gitlink.path);
       const entry = {
         path: gitlink.path,
         commit: gitlink.commit,
@@ -27776,7 +28368,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
         }
         entry.checkedLocal = true;
         try {
-          await runGit2(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+          await runGit3(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
           entry.localReachable = true;
         } catch {
           entry.localReachable = false;
@@ -27784,7 +28376,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             try {
               const imported = await importCommitFromWorktreeSubmodule(
                 submodulePath,
-                (0, import_path8.resolve)(options.worktreeRoot, gitlink.path),
+                (0, import_path9.resolve)(options.worktreeRoot, gitlink.path),
                 gitlink.commit
               );
               if (imported) {
@@ -27800,7 +28392,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
           entry.remote = "origin";
           let remoteUrl = "";
           try {
-            remoteUrl = (await runGit2(submodulePath, ["remote", "get-url", "origin"])).trim();
+            remoteUrl = (await runGit3(submodulePath, ["remote", "get-url", "origin"])).trim();
             if (!remoteUrl) throw new Error("origin remote has no URL");
             entry.remoteUrl = remoteUrl;
           } catch {
@@ -27915,9 +28507,9 @@ function buildMeshRefineValidationPlan(mesh, workspace) {
   };
 }
 async function runMeshRefineValidationGate(mesh, workspace) {
-  const { execFile: execFile3 } = await import("child_process");
-  const { promisify: promisify6 } = await import("util");
-  const execFileAsync3 = promisify6(execFile3);
+  const { execFile: execFile4 } = await import("child_process");
+  const { promisify: promisify7 } = await import("util");
+  const execFileAsync3 = promisify7(execFile4);
   const selection = resolveMeshRefineValidationPlan(mesh, workspace);
   const summary = {
     status: "skipped",
@@ -27951,24 +28543,24 @@ async function runMeshRefineValidationGate(mesh, workspace) {
     ...extras
   });
   const isPackageManagerValidation = (candidate) => {
-    const command = (0, import_path8.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+    const command = (0, import_path9.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs11.existsSync((0, import_path8.join)(cwd, "package.json"))) return false;
-    if (fs11.existsSync((0, import_path8.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs11.existsSync((0, import_path8.join)(cwd, lock)));
+    if (!fs11.existsSync((0, import_path9.join)(cwd, "package.json"))) return false;
+    if (fs11.existsSync((0, import_path9.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs11.existsSync((0, import_path9.join)(cwd, lock)));
   };
   for (const candidate of selection.bootstrapCommands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path8.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path9.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     try {
       const result = await execFileAsync3(candidate.command, candidate.args, {
         cwd,
         encoding: "utf8",
         timeout,
-        maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
+        maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
         env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} }
       });
       summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -27987,7 +28579,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path8.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path9.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     if (selection.bootstrapCommands.length === 0 && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
@@ -28007,7 +28599,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
         cwd,
         encoding: "utf8",
         timeout,
-        maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
+        maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
         env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} }
       });
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -28032,7 +28624,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   return summary;
 }
 function loadYamlModule() {
-  return yaml2;
+  return yaml3;
 }
 function getMcpServersKey(format) {
   return format === "hermes_config_yaml" ? "mcp_servers" : "mcpServers";
@@ -28049,13 +28641,13 @@ function serializeMeshCoordinatorMcpConfig(config, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path8.join)((0, import_os3.homedir)(), ".hermes");
+  return explicitHome || (0, import_path9.join)((0, import_os3.homedir)(), ".hermes");
 }
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
-  const sourceConfigPath = (0, import_path8.join)(sourceHome, "config.yaml");
+  const sourceConfigPath = (0, import_path9.join)(sourceHome, "config.yaml");
   if (!fs11.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if ((0, import_path8.resolve)(sourceConfigPath) === (0, import_path8.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if ((0, import_path9.resolve)(sourceConfigPath) === (0, import_path9.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   const parsed = parseMeshCoordinatorMcpConfig(fs11.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -28089,10 +28681,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if ((0, import_path8.resolve)(sourceHome) === (0, import_path8.resolve)(targetHome)) return;
+  if ((0, import_path9.resolve)(sourceHome) === (0, import_path9.resolve)(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
-    const sourcePath = (0, import_path8.join)(sourceHome, fileName);
-    const targetPath = (0, import_path8.join)(targetHome, fileName);
+    const sourcePath = (0, import_path9.join)(sourceHome, fileName);
+    const targetPath = (0, import_path9.join)(targetHome, fileName);
     if (!fs11.existsSync(sourcePath)) continue;
     try {
       fs11.copyFileSync(sourcePath, targetPath);
@@ -28474,7 +29066,7 @@ var DaemonCommandRouter = class {
     }
     const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
     const normalizePath = (value) => {
-      const resolved = (0, import_path8.resolve)(value);
+      const resolved = (0, import_path9.resolve)(value);
       try {
         return fs11.realpathSync(resolved);
       } catch {
@@ -28548,10 +29140,10 @@ var DaemonCommandRouter = class {
     if (metadataStatus === "merged_to_main" || metadataStatus === "cleanup_candidate") {
       return { allow: true, status: metadataStatus, source: "node_branch_convergence" };
     }
-    const { execFile: execFile3 } = await import("child_process");
-    const { promisify: promisify6 } = await import("util");
-    const execFileAsync3 = promisify6(execFile3);
-    const runGit2 = async (gitArgs, cwd) => {
+    const { execFile: execFile4 } = await import("child_process");
+    const { promisify: promisify7 } = await import("util");
+    const execFileAsync3 = promisify7(execFile4);
+    const runGit3 = async (gitArgs, cwd) => {
       const { stdout } = await execFileAsync3("git", gitArgs, {
         cwd,
         encoding: "utf8",
@@ -28563,14 +29155,14 @@ var DaemonCommandRouter = class {
     };
     let head = "";
     try {
-      head = await runGit2(["rev-parse", "HEAD"], args.workspace);
+      head = await runGit3(["rev-parse", "HEAD"], args.workspace);
     } catch (e) {
       return { allow: false, error: `could not resolve worktree HEAD: ${e?.message || e}` };
     }
     if (!head) return { allow: false, error: "worktree HEAD is empty" };
     const candidateRefs = [];
     try {
-      const defaultBranch = await runGit2(["branch", "--show-current"], args.repoRoot);
+      const defaultBranch = await runGit3(["branch", "--show-current"], args.repoRoot);
       if (defaultBranch) {
         candidateRefs.push(defaultBranch, `origin/${defaultBranch}`);
       }
@@ -28584,13 +29176,13 @@ var DaemonCommandRouter = class {
       seen.add(ref);
       let commit = "";
       try {
-        commit = await runGit2(["rev-parse", "--verify", `${ref}^{commit}`], args.repoRoot);
+        commit = await runGit3(["rev-parse", "--verify", `${ref}^{commit}`], args.repoRoot);
       } catch {
         continue;
       }
       checkedRefs.push(ref);
       try {
-        await runGit2(["merge-base", "--is-ancestor", head, commit], args.repoRoot);
+        await runGit3(["merge-base", "--is-ancestor", head, commit], args.repoRoot);
         return { allow: true, status: "merged_to_default_ref", source: "git_merge_base", ref };
       } catch {
       }
@@ -28982,9 +29574,9 @@ var DaemonCommandRouter = class {
       const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
       const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
       if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
-      const { execFile: execFile3 } = await import("child_process");
-      const { promisify: promisify6 } = await import("util");
-      const execFileAsync3 = promisify6(execFile3);
+      const { execFile: execFile4 } = await import("child_process");
+      const { promisify: promisify7 } = await import("util");
+      const execFileAsync3 = promisify7(execFile4);
       const resolveStarted = Date.now();
       const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
       const branch = branchStdout.trim();
@@ -29051,7 +29643,8 @@ var DaemonCommandRouter = class {
         equivalent: patchEquivalence.equivalent,
         expectedPatchId: patchEquivalence.expectedPatchId,
         actualPatchId: patchEquivalence.actualPatchId,
-        error: patchEquivalence.error
+        error: patchEquivalence.error,
+        actionableHint: patchEquivalence.actionableHint
       });
       if (!patchEquivalence.equivalent) {
         return {
@@ -29210,6 +29803,49 @@ var DaemonCommandRouter = class {
           }
         };
       }
+      const submoduleAlignmentStarted = Date.now();
+      const submoduleAlignment = await alignRefinerySubmodulesAfterMerge(repoRoot, baseHead, "HEAD", {
+        submoduleIgnorePaths: Array.isArray(sourceNode?.policy?.submoduleIgnorePaths) ? sourceNode.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0
+      });
+      if (submoduleAlignment.status !== "skipped") {
+        recordMeshRefineStage(refineStages, "submodule_alignment", submoduleAlignment.status, submoduleAlignmentStarted, {
+          changedGitlinkPaths: submoduleAlignment.changedGitlinkPaths,
+          outOfSyncPaths: submoduleAlignment.outOfSyncPaths,
+          updatedPaths: submoduleAlignment.updatedPaths,
+          verifiedPaths: submoduleAlignment.verifiedPaths,
+          command: submoduleAlignment.command,
+          error: submoduleAlignment.error
+        });
+      }
+      if (submoduleAlignment.status === "failed") {
+        return {
+          success: false,
+          code: "post_merge_submodule_alignment_failed",
+          error: "Refinery merge completed but post-merge submodule checkout alignment failed; run the reported git submodule update command and re-check base workspace status.",
+          merged: true,
+          branch,
+          into: baseBranch,
+          validationSummary,
+          patchEquivalence,
+          submoduleReachability,
+          submoduleAlignment,
+          mergeResult,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch: baseBranch,
+            mergedBranch: branch,
+            baseBranch,
+            merged: true,
+            removed: false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            submoduleReachability: "passed",
+            submoduleAlignment: "failed",
+            status: "post_merge_alignment_failed",
+            nextStep: submoduleAlignment.command || "Run git submodule update --init --recursive for the reported path(s), then re-check base workspace status."
+          }
+        };
+      }
       const cleanupStarted = Date.now();
       const removeResult = await this.execute("remove_mesh_node", {
         meshId,
@@ -29229,7 +29865,7 @@ var DaemonCommandRouter = class {
         appendLedgerEntry2(meshId, {
           kind: "node_removed",
           nodeId,
-          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability }
+          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability, submoduleAlignment }
         });
         recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
       } catch (e) {
@@ -29244,6 +29880,7 @@ var DaemonCommandRouter = class {
         removed: removeResult?.success !== false,
         validation: "passed",
         patchEquivalence: "passed",
+        submoduleAlignment: submoduleAlignment.status,
         status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
       };
       if (removeResult?.success === false) {
@@ -29258,6 +29895,7 @@ var DaemonCommandRouter = class {
           validationSummary,
           patchEquivalence,
           submoduleReachability,
+          submoduleAlignment,
           mergeResult,
           refineStages,
           ...ledgerError ? { ledgerError } : {},
@@ -29273,6 +29911,7 @@ var DaemonCommandRouter = class {
         validationSummary,
         patchEquivalence,
         submoduleReachability,
+        submoduleAlignment,
         mergeResult,
         refineStages,
         ...ledgerError ? { ledgerError } : {},
@@ -30355,6 +30994,12 @@ var DaemonCommandRouter = class {
           success: true,
           schema: MESH_REFINE_CONFIG_SCHEMA,
           locations: MESH_REFINE_CONFIG_LOCATIONS,
+          worktreeBootstrap: {
+            schema: MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
+            locations: MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+            sourceOfTruth: "repo worktree bootstrap config",
+            runBehavior: "When present and enabled, clone_mesh_node runs commands after submodule initialization and records status on the worktree node."
+          },
           sourceOfTruth: "repo mesh/refine config",
           heuristicRole: "suggestions_only_not_execution_path"
         };
@@ -30549,8 +31194,8 @@ var DaemonCommandRouter = class {
           const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
           if (initSubmodules) {
             try {
-              const { runGit: runGit2 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-              await runGit2(
+              const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+              await runGit3(
                 { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
                 ["submodule", "update", "--init", "--recursive"],
                 { timeoutMs: 12e4 }
@@ -30559,12 +31204,35 @@ var DaemonCommandRouter = class {
               console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
             }
           }
+          const bootstrapState = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
+          node.worktreeBootstrap = bootstrapState;
+          if (!meshRecord.inline) {
+            try {
+              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState });
+              this.invalidateAggregateMeshStatus(meshId);
+            } catch {
+            }
+          }
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
             appendLedgerEntry2(meshId, {
               kind: "node_cloned",
               nodeId: node.id,
-              payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath, submodulesInitialized: initSubmodules }
+              payload: {
+                sourceNodeId,
+                branch: result.branch,
+                worktreePath: result.worktreePath,
+                submodulesInitialized: initSubmodules,
+                worktreeBootstrap: {
+                  status: bootstrapState.status,
+                  required: bootstrapState.required,
+                  configSource: bootstrapState.configSource,
+                  configSourceType: bootstrapState.configSourceType,
+                  lastCommand: bootstrapState.lastCommand,
+                  exitCode: bootstrapState.exitCode
+                }
+              }
             });
           } catch {
           }
@@ -30572,7 +31240,8 @@ var DaemonCommandRouter = class {
             success: true,
             node,
             worktreePath: result.worktreePath,
-            branch: result.branch
+            branch: result.branch,
+            worktreeBootstrap: bootstrapState
           };
         } catch (e) {
           return { success: false, error: e.message };
@@ -30800,7 +31469,7 @@ ${block2}`);
               workspace
             };
           }
-          const { existsSync: existsSync26, readFileSync: readFileSync19, writeFileSync: writeFileSync14, copyFileSync: copyFileSync4, mkdirSync: mkdirSync18 } = await import("fs");
+          const { existsSync: existsSync28, readFileSync: readFileSync21, writeFileSync: writeFileSync14, copyFileSync: copyFileSync4, mkdirSync: mkdirSync18 } = await import("fs");
           const { dirname: dirname9 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -30843,14 +31512,14 @@ ${block2}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync26(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync28(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync19(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync21(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -30962,6 +31631,7 @@ ${block2}`);
           const queueSummary = getMeshQueueStats2(meshId);
           const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
+          const asyncRefineLedgerEntries = readLedgerEntries2(meshId, { tail: 100 });
           const ledgerSummary = getLedgerSummary2(meshId);
           const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
@@ -31224,6 +31894,20 @@ ${block2}`);
             nodeStatuses.push(status);
           }
           const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId);
+          const previewFreshness = (() => {
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs11.existsSync(candidate));
+            return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
+          })();
+          const asyncRefineJobs = buildMeshAsyncRefineJobs({
+            meshId,
+            ledgerEntries: asyncRefineLedgerEntries,
+            pendingEvents: pendingCoordinatorEvents
+          });
+          const historicalSessions = buildHistoricalMeshSessions({
+            meshId,
+            nodes: mesh.nodes || [],
+            liveSessionRecords: liveMeshSessions
+          });
           const statusResult = {
             success: true,
             meshId: mesh.id,
@@ -31255,12 +31939,15 @@ ${block2}`);
                   partialNodeFailures: effectiveDirectTruth.unavailableNodeIds
                 }
               } : {},
-              historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary"]
+              historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary", "historicalSessions"]
             },
             branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
+            ...previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {},
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary },
+            ...asyncRefineJobs.length > 0 ? { asyncRefineJobs } : {},
+            ...historicalSessions ? { historicalSessions } : {},
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}
           };
           const { pendingCoordinatorEvents: _pendingCoordinatorEvents, ...cacheableStatusResult } = statusResult;
@@ -31911,7 +32598,7 @@ var ProviderStreamAdapter = class {
     const beforeCount = this.messageCount(before);
     const beforeSignature = this.lastMessageSignature(before);
     for (let attempt = 0; attempt < 12; attempt += 1) {
-      await new Promise((resolve16) => setTimeout(resolve16, 250));
+      await new Promise((resolve17) => setTimeout(resolve17, 250));
       let state;
       try {
         state = await this.readChat(evaluate);
@@ -31933,7 +32620,7 @@ var ProviderStreamAdapter = class {
     if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
       return first;
     }
-    await new Promise((resolve16) => setTimeout(resolve16, 150));
+    await new Promise((resolve17) => setTimeout(resolve17, 150));
     const second = await this.readChat(evaluate);
     return this.messageCount(second) >= this.messageCount(first) ? second : first;
   }
@@ -32084,7 +32771,7 @@ var ProviderStreamAdapter = class {
       if (typeof data.error === "string" && data.error.trim()) return false;
     }
     for (let attempt = 0; attempt < 6; attempt += 1) {
-      await new Promise((resolve16) => setTimeout(resolve16, 250));
+      await new Promise((resolve17) => setTimeout(resolve17, 250));
       const state = await this.readChat(evaluate);
       const title = this.getStateTitle(state);
       if (this.titlesMatch(title, sessionId)) return true;
@@ -33012,13 +33699,13 @@ var VersionArchive = class {
   }
 };
 async function runCommand(cmd, timeout = 1e4) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     (0, import_child_process9.exec)(cmd, {
       encoding: "utf-8",
       timeout
     }, (error, stdout) => {
-      if (error) return resolve16(null);
-      resolve16(stdout.trim());
+      if (error) return resolve17(null);
+      resolve17(stdout.trim());
     });
   });
 }
@@ -34707,7 +35394,7 @@ function getCliTargetBundle(ctx, type, instanceId) {
   return { target, instance, adapter };
 }
 function sleep2(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
   const startedAt = Date.now();
@@ -36962,15 +37649,15 @@ var DevServer = class _DevServer {
         this.json(res, 500, { error: e.message });
       }
     });
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       this.server.listen(port, "127.0.0.1", () => {
         this.log(`Dev server listening on http://127.0.0.1:${port}`);
-        resolve16();
+        resolve17();
       });
       this.server.on("error", (e) => {
         if (e.code === "EADDRINUSE") {
           this.log(`Port ${port} in use, skipping dev server`);
-          resolve16();
+          resolve17();
         } else {
           reject(e);
         }
@@ -37052,20 +37739,20 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString().slice(0, 2e3);
       });
-      await new Promise((resolve16) => {
+      await new Promise((resolve17) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve16();
+          resolve17();
         }, 3e3);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve16();
+          resolve17();
         });
         child.stdout?.once("data", () => {
           setTimeout(() => {
             child.kill();
             clearTimeout(timer);
-            resolve16();
+            resolve17();
           }, 500);
         });
       });
@@ -37568,14 +38255,14 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString();
       });
-      await new Promise((resolve16) => {
+      await new Promise((resolve17) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve16();
+          resolve17();
         }, timeout);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve16();
+          resolve17();
         });
       });
       const elapsed = Date.now() - start;
@@ -38245,14 +38932,14 @@ data: ${JSON.stringify(msg.data)}
     res.end(JSON.stringify(data, null, 2));
   }
   async readBody(req) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       let body = "";
       req.on("data", (chunk) => body += chunk);
       req.on("end", () => {
         try {
-          resolve16(JSON.parse(body));
+          resolve17(JSON.parse(body));
         } catch {
-          resolve16({});
+          resolve17({});
         }
       });
     });
@@ -38790,7 +39477,7 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS, requiredRe
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await canConnect(endpoint, requiredRequestTypes)) return;
-    await new Promise((resolve16) => setTimeout(resolve16, STARTUP_POLL_MS));
+    await new Promise((resolve17) => setTimeout(resolve17, STARTUP_POLL_MS));
   }
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
@@ -38970,10 +39657,10 @@ async function installExtension(ide, extension) {
         const buffer = Buffer.from(await res.arrayBuffer());
         const fs17 = await import("fs");
         fs17.writeFileSync(vsixPath, buffer);
-        return new Promise((resolve16) => {
+        return new Promise((resolve17) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve16({
+            resolve17({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -38986,11 +39673,11 @@ async function installExtension(ide, extension) {
     } catch (e) {
     }
   }
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
     (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve16({
+        resolve17({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -38998,7 +39685,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve16({
+        resolve17({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -39373,6 +40060,8 @@ async function shutdownDaemonComponents(components) {
   MAX_LEDGER_SLICE_LIMIT,
   MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA,
+  MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+  MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -39393,10 +40082,12 @@ async function shutdownDaemonComponents(components) {
   buildChatMessage,
   buildChatMessageSignature,
   buildChatTailDeliverySignature,
+  buildCompactStaleDirectWorkSummary,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
   buildMeshActiveWork,
   buildMeshActiveWorkSummary,
+  buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
@@ -39505,6 +40196,7 @@ async function shutdownDaemonComponents(components) {
   listWorktrees,
   loadConfig,
   loadMeshRefineConfig,
+  loadMeshWorktreeBootstrapConfig,
   loadState,
   logCommand,
   markSetupComplete,
@@ -39556,6 +40248,7 @@ async function shutdownDaemonComponents(components) {
   resolveWorktreePath,
   runAsyncBatch,
   runGit,
+  runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
   setDebugRuntimeConfig,
@@ -39577,6 +40270,7 @@ async function shutdownDaemonComponents(components) {
   updateTaskStatus,
   upsertSavedProviderSession,
   validateMeshRefineConfig,
-  validateMeshTaskModeRequest
+  validateMeshTaskModeRequest,
+  validateMeshWorktreeBootstrapConfig
 });
 //# sourceMappingURL=index.js.map