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

package/dist/index.mjs

@@ -1053,6 +1053,7 @@ function addNode(meshId, opts) {
     isLocalWorktree: opts.isLocalWorktree,
     worktreeBranch: opts.worktreeBranch,
     clonedFromNodeId: opts.clonedFromNodeId,
+    worktreeBootstrap: opts.worktreeBootstrap,
     role: opts.role
   };
   mesh.nodes.push(node);
@@ -1079,6 +1080,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;
@@ -1291,8 +1293,8 @@ __export(mesh_ledger_exports, {
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice
 });
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync as statSync2, renameSync } from "fs";
-import { join as join6 } from "path";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2, renameSync } from "fs";
+import { join as join7 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -1301,19 +1303,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 = join6(getConfigDir(), LEDGER_DIR_NAME);
-  if (!existsSync6(dir)) {
+  const dir = join7(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync7(dir)) {
     mkdirSync3(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.jsonl`);
+  return join7(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join7(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -1435,7 +1437,7 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if (existsSync6(filePath)) {
+  if (existsSync7(filePath)) {
     try {
       const stat2 = statSync2(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
@@ -1502,10 +1504,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerEntries(meshId, opts) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync6(filePath)) return [];
+  if (!existsSync7(filePath)) return [];
   let content;
   try {
-    content = readFileSync4(filePath, "utf-8");
+    content = readFileSync5(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1677,7 +1679,7 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while (existsSync6(getRotatedPath(meshId, index))) {
+  while (existsSync7(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
@@ -1702,8 +1704,8 @@ var init_mesh_ledger = __esm({
 });
 
 // src/mesh/beads-db.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
 import { createRequire } from "module";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
@@ -1715,7 +1717,7 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return join7(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return join8(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 var DatabaseCtor, BeadsDB;
 var init_beads_db = __esm({
@@ -1728,7 +1730,7 @@ var init_beads_db = __esm({
       migratedMeshIds = /* @__PURE__ */ new Set();
       constructor(dbPath) {
         const dir = dirname2(dbPath);
-        if (!existsSync7(dir)) mkdirSync4(dir, { recursive: true });
+        if (!existsSync8(dir)) mkdirSync4(dir, { recursive: true });
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("synchronous = NORMAL");
@@ -1738,7 +1740,7 @@ var init_beads_db = __esm({
       }
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _BeadsDB(join7(getLedgerDir(), "beads.db"));
+          this.instance = new _BeadsDB(join8(getLedgerDir(), "beads.db"));
         }
         return this.instance;
       }
@@ -1779,9 +1781,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 (!existsSync7(path28)) return;
+        if (!existsSync8(path28)) return;
         try {
-          const entries = JSON.parse(readFileSync5(path28, "utf-8"));
+          const entries = JSON.parse(readFileSync6(path28, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -2120,7 +2122,7 @@ var init_mesh_work_queue = __esm({
 import { exec } from "child_process";
 import * as os2 from "os";
 import * as path8 from "path";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -2144,24 +2146,24 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return existsSync8(candidate) ? candidate : null;
+    return existsSync9(candidate) ? candidate : null;
   }
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const child = 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) {
@@ -2531,10 +2533,10 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-import { appendFileSync as appendFileSync2, existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
-import { join as join10 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11 } from "path";
 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();
@@ -2543,9 +2545,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) {
@@ -2561,10 +2563,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 [
@@ -2585,7 +2587,7 @@ function hasPendingCoordinatorEventDuplicate(event) {
 }
 function getPendingEventsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join11(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function queuePendingMeshCoordinatorEvent(event) {
   try {
@@ -2607,9 +2609,9 @@ function queuePendingMeshCoordinatorEvent(event) {
 function drainPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return [];
   const path28 = getPendingEventsPath(meshId);
-  if (!existsSync10(path28)) return [];
+  if (!existsSync11(path28)) return [];
   try {
-    const raw = readFileSync6(path28, "utf-8");
+    const raw = readFileSync7(path28, "utf-8");
     try {
       unlinkSync2(path28);
     } catch {
@@ -2628,9 +2630,9 @@ function drainPendingMeshCoordinatorEvents(meshId) {
 function getPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return [];
   const path28 = getPendingEventsPath(meshId);
-  if (!existsSync10(path28)) return [];
+  if (!existsSync11(path28)) return [];
   try {
-    const raw = readFileSync6(path28, "utf-8");
+    const raw = readFileSync7(path28, "utf-8");
     return raw.split("\n").filter(Boolean).flatMap((line) => {
       try {
         return [JSON.parse(line)];
@@ -2645,7 +2647,7 @@ function getPendingMeshCoordinatorEvents(meshId) {
 function clearPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return;
   const path28 = getPendingEventsPath(meshId);
-  if (existsSync10(path28)) try {
+  if (existsSync11(path28)) try {
     unlinkSync2(path28);
   } catch {
   }
@@ -2653,7 +2655,7 @@ function clearPendingMeshCoordinatorEvents(meshId) {
 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) {
@@ -3093,10 +3095,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);
@@ -3117,10 +3119,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);
@@ -5209,7 +5211,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(
@@ -6436,7 +6438,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 ? (() => {
@@ -6533,13 +6535,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;
@@ -6697,17 +6699,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);
         });
@@ -8057,10 +8059,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;
   }
@@ -8070,6 +8079,7 @@ async function gitCheckpoint(workspace, message, includeUntracked) {
     isGitRepo: true,
     commit: commitSha,
     message: fullMsg,
+    status: "created",
     lastCheckedAt: Date.now()
   };
 }
@@ -8773,6 +8783,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" } }
             }
           }
@@ -8790,6 +8801,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" } }
             }
           }
@@ -8798,7 +8810,7 @@ var MESH_REFINE_CONFIG_SCHEMA = {
     }
   }
 };
-function isRecord(value) {
+function isMeshConfigRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function tokenizeCommandString(command) {
@@ -8813,8 +8825,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();
@@ -8841,7 +8853,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 {
@@ -8853,10 +8868,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 = [];
@@ -8875,14 +8892,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);
     });
@@ -8994,6 +9011,190 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
   };
 }
 
+// src/mesh/worktree-bootstrap-config.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { join as join6, resolve as pathResolve } from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import * as yaml2 from "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 = join6(workspace, relative3);
+    if (!existsSync6(configPath)) continue;
+    try {
+      const parsed = parseConfigText2(configPath, readFileSync4(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 = promisify3(execFile3);
+  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 ? pathResolve(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) {
@@ -9645,6 +9846,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();
@@ -9762,8 +10091,8 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { join as join12 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -9776,7 +10105,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join11(getConfigDir(), "state.json");
+  return join12(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -9812,11 +10141,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync11(statePath)) {
+  if (!existsSync12(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync7(statePath, "utf-8");
+    const raw = readFileSync8(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -9833,11 +10162,11 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { exec as exec2 } from "child_process";
-import { promisify as promisify3 } from "util";
-import { existsSync as existsSync12, statSync as statSync4 } from "fs";
+import { promisify as promisify4 } from "util";
+import { existsSync as existsSync13, statSync as statSync4 } from "fs";
 import { platform as platform2, homedir as homedir5 } from "os";
 import * as path10 from "path";
-var execAsync2 = promisify3(exec2);
+var execAsync2 = promisify4(exec2);
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -9859,7 +10188,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join(homedir5(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return existsSync12(resolved) ? resolved : null;
+    return existsSync13(resolved) ? resolved : null;
   }
   const isWin = platform2() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -9869,7 +10198,7 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path10.join(p, trimmed + ext);
       try {
-        if (existsSync12(fullPath)) {
+        if (existsSync13(fullPath)) {
           const stat2 = statSync4(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
@@ -9899,9 +10228,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync12(resolved)) return resolved;
+      if (existsSync13(resolved)) return resolved;
     } else {
-      if (existsSync12(normalized)) return normalized;
+      if (existsSync13(normalized)) return normalized;
     }
   }
   return null;
@@ -9915,7 +10244,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync12(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync13(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -9928,7 +10257,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync12(c)) {
+        if (existsSync13(c)) {
           resolvedCli = c;
           break;
         }
@@ -9956,8 +10285,8 @@ init_cli_detector();
 // src/system/host-memory.ts
 import * as os4 from "os";
 import { exec as exec3 } from "child_process";
-import { promisify as promisify4 } from "util";
-var execAsync3 = promisify4(exec3);
+import { promisify as promisify5 } from "util";
+var execAsync3 = promisify5(exec3);
 var cachedDarwinAvail = null;
 var darwinMemoryInterval = null;
 async function updateDarwinMemoryCache() {
@@ -10244,7 +10573,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());
@@ -10260,16 +10589,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([]);
       });
     });
   }
@@ -10309,7 +10638,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());
@@ -10320,7 +10649,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 || ""));
@@ -10339,25 +10668,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);
       });
     });
   }
@@ -10368,7 +10697,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       this.ws = new WebSocket(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -10378,17 +10707,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") {
@@ -10411,7 +10740,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve16(false);
+        resolve17(false);
       });
     });
   }
@@ -10425,7 +10754,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 WebSocket(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -10435,16 +10764,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 {
           }
@@ -10464,31 +10793,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)) {
@@ -10528,11 +10857,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 !== WebSocket.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)) {
@@ -10781,7 +11110,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) => {
@@ -10790,7 +11119,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 {
           }
@@ -10991,14 +11320,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== WebSocket.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
@@ -11030,10 +11359,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)) {
@@ -16135,7 +16464,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;
@@ -16358,16 +16687,39 @@ function hasOverlappingVisibleConversationText(nativeMessages, ptyMessages) {
   return false;
 }
 function hasSafeNativeHistoryMapping(args) {
+  const isCoordinatorTranscript = args.nativeMessages.some((m) => {
+    const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+    return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat") || text.includes("mesh_launch_session");
+  });
   const explicitSessionId = String(args.historySessionId || args.providerSessionId || "").trim();
   if (explicitSessionId) {
     const messageSessionIds = args.nativeMessages.map((message) => typeof message?.historySessionId === "string" ? message.historySessionId.trim() : "").filter(Boolean);
-    if (messageSessionIds.length === 0) return true;
-    return messageSessionIds.some((id) => id === explicitSessionId);
+    if (messageSessionIds.length > 0) {
+      return messageSessionIds.some((id) => id === explicitSessionId);
+    }
+    if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+      const ptyHasCoordinator = args.ptyMessages.some((m) => {
+        const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+        return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat");
+      });
+      if (!ptyHasCoordinator) {
+        return false;
+      }
+    }
   }
   const workspace = String(args.workspace || "").trim();
   if (!workspace) return false;
   const workspaceMatches = args.nativeMessages.some((message) => String(message?.workspace || "").trim() === workspace);
   if (!workspaceMatches) return false;
+  if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+    const ptyHasCoordinator = args.ptyMessages.some((m) => {
+      const text = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content || "");
+      return text.includes("mesh_send_task") || text.includes("mesh_status") || text.includes("mesh_read_chat");
+    });
+    if (!ptyHasCoordinator) {
+      return false;
+    }
+  }
   if (!args.requireWorkspaceContentOverlap) return true;
   return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
 }
@@ -16922,7 +17274,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;
 }
@@ -16930,7 +17282,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);
@@ -18819,7 +19171,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");
         }
       }
@@ -19508,7 +19860,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,
@@ -19520,9 +19872,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 });
             }
           });
         });
@@ -19540,15 +19892,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);
@@ -19562,7 +19914,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,
@@ -19574,9 +19926,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 });
             }
           });
         });
@@ -19598,7 +19950,7 @@ init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 
@@ -19820,7 +20172,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`);
 }
@@ -20197,7 +20549,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");
       }
     }
@@ -21598,13 +21950,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);
         });
@@ -22215,7 +22567,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync16(expandExecutable(trimmed));
+    return existsSync17(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -22313,7 +22665,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 {
@@ -24386,8 +24738,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;
@@ -24405,7 +24757,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",
@@ -24423,7 +24775,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", () => {
@@ -24432,7 +24784,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);
@@ -24496,7 +24848,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"));
@@ -24516,7 +24868,7 @@ var ProviderLoader = class _ProviderLoader {
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve16();
+            resolve17();
           });
           ws.on("error", reject);
         });
@@ -25019,10 +25371,10 @@ function findMacAppProcessPids(psOutput, appPaths) {
 
 // src/launch.ts
 async function execQuiet(command, options = {}) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     exec4(command, options, (error, stdout) => {
-      if (error) return resolve16("");
-      resolve16(stdout.toString());
+      if (error) return resolve17("");
+      resolve17(stdout.toString());
     });
   });
 }
@@ -25103,17 +25455,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) => {
@@ -25122,16 +25474,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);
     });
   });
 }
@@ -25606,12 +25958,12 @@ cleanOldFiles();
 
 // src/commands/router.ts
 init_logger();
-import * as yaml2 from "js-yaml";
+import * as yaml3 from "js-yaml";
 
 // src/commands/mesh-coordinator.ts
 import { createHash as createHash3 } from "crypto";
 import * as os17 from "os";
-import { isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "path";
+import { isAbsolute as isAbsolute11, join as join23, resolve as resolve13 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
 var HERMES_CLI_TYPE = "hermes-cli";
@@ -25633,7 +25985,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join22(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join23(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -25753,14 +26105,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve13(workspace || os17.tmpdir())}`;
   const hash = createHash3("sha256").update(key).digest("hex").slice(0, 16);
-  return join22(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join23(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os17.homedir();
-  if (trimmed.startsWith("~/")) return join22(os17.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join23(os17.homedir(), trimmed.slice(2));
   if (isAbsolute11(trimmed)) return trimmed;
-  return join22(workspace, trimmed);
+  return join23(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const command = resolveAdhdevCommand(options.adhdevMcpCommand);
@@ -25793,6 +26145,88 @@ function resolveMcpPort(explicitPort) {
 init_mesh_events();
 init_mesh_host_ownership();
 
+// src/mesh/preview-freshness.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync20, readFileSync as readFileSync13 } from "fs";
+import { resolve as resolve14 } from "path";
+var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
+function runGit2(repoRoot, args) {
+  try {
+    return execFileSync2("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function readRecord3(repoRoot) {
+  const path28 = resolve14(repoRoot, PREVIEW_DEPLOY_RECORD);
+  if (!existsSync20(path28)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync13(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
 init_config();
 import * as os18 from "os";
@@ -26107,7 +26541,7 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import * as fs10 from "fs";
 import * as os19 from "os";
@@ -26227,7 +26661,7 @@ function getNpmExecOptions(platform10 = process.platform) {
 }
 function execNpmCommandSync(args, options = {}, surface) {
   const execOptions = surface?.execOptions || getNpmExecOptions();
-  return execFileSync2(
+  return execFileSync3(
     surface?.npmExecutable || "npm",
     [...surface?.npmArgsPrefix || [], ...args],
     {
@@ -26240,7 +26674,7 @@ function execNpmCommandSync(args, options = {}, surface) {
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      execFileSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -26252,7 +26686,7 @@ function killPid(pid) {
 function getWindowsProcessCommandLine(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
-    const psOut = execFileSync2("powershell.exe", [
+    const psOut = execFileSync3("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-ExecutionPolicy",
@@ -26264,7 +26698,7 @@ function getWindowsProcessCommandLine(pid) {
   } catch {
   }
   try {
-    const wmicOut = execFileSync2("wmic", [
+    const wmicOut = execFileSync3("wmic", [
       "process",
       "where",
       pidFilter,
@@ -26280,7 +26714,7 @@ function getProcessCommandLine(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return null;
   if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
   try {
-    const text = execFileSync2("ps", ["-o", "command=", "-p", String(pid)], {
+    const text = execFileSync3("ps", ["-o", "command=", "-p", String(pid)], {
       encoding: "utf8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -26299,7 +26733,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;
     }
@@ -26396,7 +26830,7 @@ async function runDaemonUpgradeHelper(payload) {
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync2(
+  const installOutput = execFileSync3(
     installCommand.command,
     installCommand.args,
     {
@@ -26410,7 +26844,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");
   }
@@ -26447,8 +26881,9 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 // src/commands/router.ts
 init_mesh_work_queue();
 import { homedir as homedir19, hostname as osHostname } from "os";
-import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from "path";
+import { basename as pathBasename, join as pathJoin, resolve as pathResolve2 } from "path";
 import * as fs11 from "fs";
+import { execFileSync as execFileSync4 } from "child_process";
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
   stable: "https://api.adhf.dev",
@@ -27160,6 +27595,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);
 }
@@ -27301,6 +27746,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);
@@ -27386,14 +27865,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",
@@ -27404,8 +27883,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
@@ -27449,6 +27928,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 = execFileSync4("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 = execFileSync4("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)
     };
   }
@@ -27457,10 +28065,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",
@@ -27471,8 +28079,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}`;
@@ -27488,21 +28096,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 = pathResolve(repoRoot, gitlink.path);
+      const submodulePath = pathResolve2(repoRoot, gitlink.path);
       const entry = {
         path: gitlink.path,
         commit: gitlink.commit,
@@ -27522,7 +28130,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;
@@ -27530,7 +28138,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             try {
               const imported = await importCommitFromWorktreeSubmodule(
                 submodulePath,
-                pathResolve(options.worktreeRoot, gitlink.path),
+                pathResolve2(options.worktreeRoot, gitlink.path),
                 gitlink.commit
               );
               if (imported) {
@@ -27546,7 +28154,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 {
@@ -27661,9 +28269,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",
@@ -27707,14 +28315,14 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   };
   for (const candidate of selection.bootstrapCommands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? pathResolve2(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 }));
@@ -27733,7 +28341,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? pathResolve2(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, {
@@ -27753,7 +28361,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 }));
@@ -27778,7 +28386,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";
@@ -27801,7 +28409,7 @@ function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
   const sourceConfigPath = pathJoin(sourceHome, "config.yaml");
   if (!fs11.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if (pathResolve(sourceConfigPath) === pathResolve(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if (pathResolve2(sourceConfigPath) === pathResolve2(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 };
@@ -27835,7 +28443,7 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if (pathResolve(sourceHome) === pathResolve(targetHome)) return;
+  if (pathResolve2(sourceHome) === pathResolve2(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
     const sourcePath = pathJoin(sourceHome, fileName);
     const targetPath = pathJoin(targetHome, fileName);
@@ -28220,7 +28828,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 = pathResolve(value);
+      const resolved = pathResolve2(value);
       try {
         return fs11.realpathSync(resolved);
       } catch {
@@ -28294,10 +28902,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",
@@ -28309,14 +28917,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}`);
       }
@@ -28330,13 +28938,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 {
       }
@@ -28728,9 +29336,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();
@@ -28797,7 +29405,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 {
@@ -28956,6 +29565,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,
@@ -28975,7 +29627,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) {
@@ -28990,6 +29642,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) {
@@ -29004,6 +29657,7 @@ var DaemonCommandRouter = class {
           validationSummary,
           patchEquivalence,
           submoduleReachability,
+          submoduleAlignment,
           mergeResult,
           refineStages,
           ...ledgerError ? { ledgerError } : {},
@@ -29019,6 +29673,7 @@ var DaemonCommandRouter = class {
         validationSummary,
         patchEquivalence,
         submoduleReachability,
+        submoduleAlignment,
         mergeResult,
         refineStages,
         ...ledgerError ? { ledgerError } : {},
@@ -30101,6 +30756,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"
         };
@@ -30295,8 +30956,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 }
@@ -30305,12 +30966,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 {
           }
@@ -30318,7 +31002,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 };
@@ -30546,7 +31231,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;
@@ -30589,14 +31274,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");
@@ -30708,6 +31393,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;
@@ -30970,6 +31656,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,
@@ -31001,12 +31701,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;
@@ -31657,7 +32360,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);
@@ -31679,7 +32382,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;
   }
@@ -31830,7 +32533,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;
@@ -32758,13 +33461,13 @@ var VersionArchive = class {
   }
 };
 async function runCommand(cmd, timeout = 1e4) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     exec5(cmd, {
       encoding: "utf-8",
       timeout
     }, (error, stdout) => {
-      if (error) return resolve16(null);
-      resolve16(stdout.trim());
+      if (error) return resolve17(null);
+      resolve17(stdout.trim());
     });
   });
 }
@@ -34453,7 +35156,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();
@@ -36708,15 +37411,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);
         }
@@ -36798,20 +37501,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);
         });
       });
@@ -37314,14 +38017,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;
@@ -37991,14 +38694,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({});
         }
       });
     });
@@ -38541,7 +39244,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`);
 }
@@ -38592,7 +39295,7 @@ function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
 
 // src/installer.ts
 import { exec as exec6 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { promisify as promisify6 } from "util";
 var EXTENSION_CATALOG = [
   // AI Agent extensions
   {
@@ -38679,7 +39382,7 @@ var EXTENSION_CATALOG = [
     apiKeyName: "OpenAI/Anthropic API key"
   }
 ];
-var execAsync4 = promisify5(exec6);
+var execAsync4 = promisify6(exec6);
 async function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
@@ -38721,10 +39424,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`;
           exec6(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve16({
+            resolve17({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -38737,11 +39440,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`;
     exec6(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve16({
+        resolve17({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -38749,7 +39452,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve16({
+        resolve17({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -39123,6 +39826,8 @@ export {
   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,
@@ -39143,10 +39848,12 @@ export {
   buildChatMessage,
   buildChatMessageSignature,
   buildChatTailDeliverySignature,
+  buildCompactStaleDirectWorkSummary,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
   buildMeshActiveWork,
   buildMeshActiveWorkSummary,
+  buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
@@ -39255,6 +39962,7 @@ export {
   listWorktrees,
   loadConfig,
   loadMeshRefineConfig,
+  loadMeshWorktreeBootstrapConfig,
   loadState,
   logCommand,
   markSetupComplete,
@@ -39306,6 +40014,7 @@ export {
   resolveWorktreePath,
   runAsyncBatch,
   runGit,
+  runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
   setDebugRuntimeConfig,
@@ -39327,6 +40036,7 @@ export {
   updateTaskStatus,
   upsertSavedProviderSession,
   validateMeshRefineConfig,
-  validateMeshTaskModeRequest
+  validateMeshTaskModeRequest,
+  validateMeshWorktreeBootstrapConfig
 };
 //# sourceMappingURL=index.mjs.map