@adhdev/daemon-core 0.9.82-rc.464 → 0.9.82-rc.466

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "260f54788520ce6f51b44fa097d6d3ee337fe79d" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "260f5478" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.464" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-05T05:20:43.844Z" : void 0);
+  const commit = readInjected(true ? "e0f04b7d54855e0f0d5ed4200078d95596ab9f6f" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "e0f04b7d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.466" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-05T08:18:54.364Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -484,8 +484,8 @@ function validateChangeImpactConfig(raw, source = "inline") {
   }
   return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
 }
-function parseConfigText(path44, text) {
-  if (/\.json$/i.test(path44)) return JSON.parse(text);
+function parseConfigText(path45, text) {
+  if (/\.json$/i.test(path45)) return JSON.parse(text);
   return yaml.load(text);
 }
 function loadChangeImpactConfig(repoRoot) {
@@ -1099,14 +1099,14 @@ async function deriveSubmoduleGitlinkStatuses(repo, options) {
   const lastCheckedAt = Date.now();
   const headOidByPath = /* @__PURE__ */ new Map();
   const entries = await Promise.all(
-    paths.filter((path44) => !ignoreSet.has(path44)).map(async (path44) => {
-      const repoPath = repo.repoRoot + "/" + path44;
-      const expected = await readGitlinkExpectedSha(repo, path44, options);
+    paths.filter((path45) => !ignoreSet.has(path45)).map(async (path45) => {
+      const repoPath = repo.repoRoot + "/" + path45;
+      const expected = await readGitlinkExpectedSha(repo, path45, options);
       const actual = await readSubmoduleHeadSha(repo, repoPath, options);
-      if (actual) headOidByPath.set(path44, actual);
+      if (actual) headOidByPath.set(path45, actual);
       const outOfSync = actual === null ? true : expected !== null && expected !== actual;
       return {
-        path: path44,
+        path: path45,
         // Prefer the recorded gitlink SHA (matches the legacy column); fall back
         // to the checked-out SHA so the field is never empty when both are known.
         commit: expected ?? actual ?? "",
@@ -2553,12 +2553,12 @@ function readGitSubmodules(value, parentRepoRoot) {
   if (!Array.isArray(value)) return void 0;
   const submodules = value.map((entry) => {
     const submodule = readRecord(entry);
-    const path44 = readString2(submodule.path);
+    const path45 = readString2(submodule.path);
     const commit = readString2(submodule.commit);
-    const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path44);
-    if (!path44 || !commit) return null;
+    const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path45);
+    if (!path45 || !commit) return null;
     const result = {
-      path: path44,
+      path: path45,
       commit,
       dirty: readBoolean(submodule.dirty) ?? false,
       outOfSync: readBoolean(submodule.outOfSync, submodule.out_of_sync) ?? false,
@@ -2892,10 +2892,10 @@ function getMeshConfigPath() {
   return join5(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
-  const path44 = getMeshConfigPath();
-  if (!existsSync5(path44)) return { meshes: [] };
+  const path45 = getMeshConfigPath();
+  if (!existsSync5(path45)) return { meshes: [] };
   try {
-    const raw = JSON.parse(readFileSync3(path44, "utf-8"));
+    const raw = JSON.parse(readFileSync3(path45, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -2944,16 +2944,16 @@ function normalizeCapabilityTags(value) {
   return tags.length ? tags : void 0;
 }
 function saveMeshConfig(config) {
-  const path44 = getMeshConfigPath();
-  writeFileSync2(path44, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  const path45 = getMeshConfigPath();
+  writeFileSync2(path45, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function normalizeRepoIdentity(remoteUrl) {
   let identity = remoteUrl.trim();
   if (identity.startsWith("http://") || identity.startsWith("https://")) {
     try {
       const url = new URL(identity);
-      const path44 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
-      return `${url.hostname}/${path44}`;
+      const path45 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+      return `${url.hostname}/${path45}`;
     } catch {
     }
   }
@@ -4196,59 +4196,59 @@ function isMeshEventScope(value) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
-function assertCoordinatorIdentity(raw, path44) {
+function assertCoordinatorIdentity(raw, path45) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path44, "must be an object");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path45, "must be an object");
   }
   const obj = raw;
   if (!isNonEmptyString(obj.daemonId)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.daemonId`, "must be a non-empty string");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.daemonId`, "must be a non-empty string");
   }
   if (!isNonEmptyString(obj.coordinatorRunId)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.coordinatorRunId`, "must be a non-empty string");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.coordinatorRunId`, "must be a non-empty string");
   }
   const sessionId = obj.sessionId;
   if (sessionId !== void 0 && !isNonEmptyString(sessionId)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.sessionId`, "must be a non-empty string when provided");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.sessionId`, "must be a non-empty string when provided");
   }
   return sessionId !== void 0 ? { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId, sessionId } : { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId };
 }
-function assertPendingMeshCoordinatorEventV2(raw, path44 = "$") {
+function assertPendingMeshCoordinatorEventV2(raw, path45 = "$") {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path44, "must be an object");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path45, "must be an object");
   }
   const obj = raw;
   if (!isSupportedMeshProtocolVersion(obj.protocolVersion)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.protocolVersion`, `must be one of ${SUPPORTED_MESH_PROTOCOL_VERSIONS.join(", ")}`);
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.protocolVersion`, `must be one of ${SUPPORTED_MESH_PROTOCOL_VERSIONS.join(", ")}`);
   }
   if (!isNonEmptyString(obj.eventId)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.eventId`, "must be a non-empty string");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.eventId`, "must be a non-empty string");
   }
   if (!isMeshEventScope(obj.scope)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.scope`, `must be one of ${MESH_EVENT_SCOPES.join(", ")}`);
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.scope`, `must be one of ${MESH_EVENT_SCOPES.join(", ")}`);
   }
   if (!isNonEmptyString(obj.event)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.event`, "must be a non-empty string");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.event`, "must be a non-empty string");
   }
   if (!isNonEmptyString(obj.meshId)) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.meshId`, "must be a non-empty string");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.meshId`, "must be a non-empty string");
   }
-  const dispatchedBy = assertCoordinatorIdentity(obj.dispatchedBy, `${path44}.dispatchedBy`);
+  const dispatchedBy = assertCoordinatorIdentity(obj.dispatchedBy, `${path45}.dispatchedBy`);
   if (obj.scope === "unicast") {
     if (!obj.intendedFor) {
-      throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.intendedFor`, "unicast scope requires intendedFor");
+      throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.intendedFor`, "unicast scope requires intendedFor");
     }
   } else if (obj.intendedFor !== void 0) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.intendedFor`, "only unicast scope may set intendedFor");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.intendedFor`, "only unicast scope may set intendedFor");
   }
-  const intendedFor = obj.intendedFor ? assertCoordinatorIdentity(obj.intendedFor, `${path44}.intendedFor`) : void 0;
+  const intendedFor = obj.intendedFor ? assertCoordinatorIdentity(obj.intendedFor, `${path45}.intendedFor`) : void 0;
   const metadata = obj.metadataEvent && typeof obj.metadataEvent === "object" && !Array.isArray(obj.metadataEvent) ? obj.metadataEvent : null;
   if (!metadata) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.metadataEvent`, "must be an object");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.metadataEvent`, "must be an object");
   }
   const queuedAt = typeof obj.queuedAt === "number" && Number.isFinite(obj.queuedAt) ? obj.queuedAt : null;
   if (queuedAt === null) {
-    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.queuedAt`, "must be a finite number");
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path45}.queuedAt`, "must be a finite number");
   }
   return {
     event: obj.event,
@@ -4415,10 +4415,10 @@ function rotateArchiveFile(meshId, archivePath) {
   }
 }
 function readArchivedCounts(meshId) {
-  const path44 = getArchivedCountsPath(meshId);
-  if (!existsSync7(path44)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  const path45 = getArchivedCountsPath(meshId);
+  if (!existsSync7(path45)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse(readFileSync5(path44, "utf-8"));
+    return JSON.parse(readFileSync5(path45, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -5144,7 +5144,8 @@ var init_mesh_ledger = __esm({
       "task_completed",
       "task_failed",
       "task_stalled",
-      "recovery_attempted"
+      "recovery_attempted",
+      "session_auto_launch"
     ]);
     DEFAULT_LEDGER_SLICE_LIMIT = 100;
     MAX_LEDGER_SLICE_LIMIT = 500;
@@ -5637,11 +5638,11 @@ function readNodeReporter(node, key2) {
 function buildMeshNodeCapabilityTags(node, providerType) {
   const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
   const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
-  const os31 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
+  const os32 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
   const arch2 = readNodeOverride(node, "arch") ?? readNodeReporter(node, "arch") ?? process.arch;
   return normalizeMeshCapabilityTags([
     ...Array.isArray(node?.capabilities) ? node.capabilities : [],
-    `os=${os31}`,
+    `os=${os32}`,
     `arch=${arch2}`,
     ...provider ? [`provider=${provider}`] : [],
     // Worktree nodes automatically expose a "worktree=<branch>" tag so that
@@ -6594,10 +6595,10 @@ var init_mesh_runtime_store = __esm({
         this.migratedMeshIds.add(meshId);
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
-        const path44 = legacyQueuePath(meshId);
-        if (!existsSync8(path44)) return;
+        const path45 = legacyQueuePath(meshId);
+        if (!existsSync8(path45)) return;
         try {
-          const entries = JSON.parse(readFileSync6(path44, "utf-8"));
+          const entries = JSON.parse(readFileSync6(path45, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -7337,6 +7338,10 @@ var init_mesh_runtime_store = __esm({
       }
       // ── G2: Event Ledger ────────────────────────────────────────────────────
       appendLedgerEntry(entry) {
+        if (!entry.kind || !String(entry.kind).trim()) {
+          LOG.warn("MeshRuntimeStore", `Refusing to append ledger entry with empty kind for mesh ${entry.meshId} (id ${entry.id})`);
+          return;
+        }
         this.db.prepare(
           `INSERT OR IGNORE INTO mesh_event_ledger
              (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
@@ -7471,6 +7476,7 @@ var init_mesh_runtime_store = __esm({
         );
         this.db.transaction(() => {
           for (const e of entries) {
+            if (!e.kind || !String(e.kind).trim()) continue;
             const result = stmt.run(
               e.id,
               e.meshId,
@@ -7765,6 +7771,41 @@ var init_mesh_runtime_store = __esm({
           `DELETE FROM mesh_pending_events WHERE id IN (${idList.map(() => "?").join(",")})`
         ).run(...idList).changes;
       }
+      /**
+       * Retention prune for mesh_pending_events. This table has no lifecycle GC of its
+       * own: a drained row is soft-marked (drained=1) and RETAINED — deliberately, so
+       * drainedEventIdsForMesh() has a durable v2-eventId dedup baseline — and an
+       * undrained row queued for a coordinator that never returned (a dead/evicted
+       * coordinator identity) stays drained=0 forever. Both accumulate without bound
+       * (observed: tens of thousands of rows, mostly stale). This is the missing
+       * retention step. Two independent windows:
+       *
+       *   - drained rows older than `drainedOlderThanMs`: the coordinator consumed them
+       *     long ago; the only thing they still back is the eventId re-delivery guard,
+       *     which is only meaningful for the recent past (a re-delivery of a week-old
+       *     event cannot occur — its producer session is long gone). Safe to delete.
+       *   - UNDRAINED rows older than `undrainedOlderThanMs` (a much wider window):
+       *     these are orphaned events for a coordinator identity that never drained
+       *     them. Kept wide so a genuinely-offline-but-returning coordinator still
+       *     receives its backlog; only genuinely unrecoverable orphans are swept.
+       *
+       * Both windows key off `queued_at` (always present) — `drained_at` can be NULL on
+       * legacy rows. Returns the number of rows deleted. Best-effort / idempotent:
+       * running it repeatedly with nothing to prune is a cheap no-op.
+       */
+      prunePendingEvents(opts) {
+        const now = Date.now();
+        const drainedCutoff = now - Math.max(0, opts.drainedOlderThanMs);
+        const undrainedCutoff = now - Math.max(0, opts.undrainedOlderThanMs);
+        let removed = 0;
+        removed += this.db.prepare(
+          "DELETE FROM mesh_pending_events WHERE drained = 1 AND queued_at < ?"
+        ).run(drainedCutoff).changes;
+        removed += this.db.prepare(
+          "DELETE FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?"
+        ).run(undrainedCutoff).changes;
+        return removed;
+      }
     };
   }
 });
@@ -8510,8 +8551,8 @@ function resolveMeshCoordinatorSetup(options) {
   }
   const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
   if (mcpConfig.mode === "auto_import") {
-    const path44 = mcpConfig.path?.trim();
-    if (!path44) {
+    const path45 = mcpConfig.path?.trim();
+    if (!path45) {
       return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
@@ -8531,7 +8572,7 @@ function resolveMeshCoordinatorSetup(options) {
     return {
       kind: "auto_import",
       serverName,
-      configPath: resolveMcpConfigPath(path44, workspace),
+      configPath: resolveMcpConfigPath(path45, workspace),
       configFormat: mcpConfig.format,
       mcpServer
     };
@@ -8732,8 +8773,8 @@ function stripCoordinatorWrapperFile(filePath) {
     const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
     if (!remaining.trim()) {
       try {
-        const fs40 = __require("fs");
-        fs40.unlinkSync(filePath);
+        const fs41 = __require("fs");
+        fs41.unlinkSync(filePath);
       } catch {
       }
     } else {
@@ -8833,10 +8874,10 @@ function getRegistryPath() {
   return join11(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
-  const path44 = getRegistryPath();
-  if (!existsSync10(path44)) return;
+  const path45 = getRegistryPath();
+  if (!existsSync10(path45)) return;
   try {
-    const raw = JSON.parse(readFileSync8(path44, "utf-8"));
+    const raw = JSON.parse(readFileSync8(path45, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -9008,8 +9049,8 @@ function validateMeshRefineConfig(config, source = "inline") {
   if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
   return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
 }
-function parseConfigText2(path44, text) {
-  if (/\.json$/i.test(path44)) return JSON.parse(text);
+function parseConfigText2(path45, text) {
+  if (/\.json$/i.test(path45)) return JSON.parse(text);
   return yaml2.load(text);
 }
 function loadMeshRefineConfig(mesh, workspace) {
@@ -9419,8 +9460,8 @@ function isCleanIgnoringSubmoduleGitlinks(porcelain, submodulePaths) {
   const lines = porcelain.split(/\r?\n/).filter((line) => line.length > 0);
   for (const line of lines) {
     const status = line.slice(0, 2);
-    const path44 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
-    const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path44);
+    const path45 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path45);
     if (!isGitlinkPointerMove) return false;
   }
   return true;
@@ -9455,8 +9496,8 @@ function shouldDeferDispatchForBootstrap(node, nowMs = Date.now()) {
   if (node?.worktreeBootstrap?.status !== "running") return false;
   return !isWorktreeBootstrapStaleRunning(node, nowMs);
 }
-function parseConfigText3(path44, text) {
-  if (/\.json$/i.test(path44)) return JSON.parse(text);
+function parseConfigText3(path45, text) {
+  if (/\.json$/i.test(path45)) return JSON.parse(text);
   return yaml3.load(text);
 }
 function truncateOutput(value) {
@@ -9731,8 +9772,8 @@ import * as yaml4 from "js-yaml";
 function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function parseConfigText4(path44, text) {
-  if (/\.json$/i.test(path44)) return JSON.parse(text);
+function parseConfigText4(path45, text) {
+  if (/\.json$/i.test(path45)) return JSON.parse(text);
   return yaml4.load(text);
 }
 function normalizeOperatingNote(value) {
@@ -11688,10 +11729,10 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const primaryDaemonId = daemonIds[0];
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
-  for (const path44 of paths) {
-    if (!existsSync15(path44)) continue;
+  for (const path45 of paths) {
+    if (!existsSync15(path45)) continue;
     try {
-      const raw = readFileSync12(path44, "utf-8");
+      const raw = readFileSync12(path45, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -11699,7 +11740,7 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
           return [];
         }
       });
-      const filtered = primaryDaemonId && path44 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId)) : parsed;
+      const filtered = primaryDaemonId && path45 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId)) : parsed;
       events.push(...filtered);
     } catch {
     }
@@ -11764,11 +11805,26 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
   const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
   return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
-function trimPendingEventsIfNeeded(path44) {
+function prunePendingMeshCoordinatorEventsRetention() {
+  try {
+    const removed = MeshRuntimeStore.getInstance().prunePendingEvents({
+      drainedOlderThanMs: PENDING_EVENTS_DRAINED_RETENTION_MS,
+      undrainedOlderThanMs: PENDING_EVENTS_UNDRAINED_RETENTION_MS
+    });
+    if (removed > 0) {
+      LOG.info("MeshEvents", `Pruned ${removed} stale pending-event row(s) (drained >7d / undrained >30d)`);
+    }
+    return removed;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Pending-event retention prune failed: ${e?.message || e}`);
+    return 0;
+  }
+}
+function trimPendingEventsIfNeeded(path45) {
   try {
-    if (!existsSync15(path44)) return;
-    if (statSync6(path44).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = readFileSync12(path44, "utf-8").split("\n").filter(Boolean);
+    if (!existsSync15(path45)) return;
+    if (statSync6(path45).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = readFileSync12(path45, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
     const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
     for (const line of dropped) {
@@ -11801,7 +11857,7 @@ function trimPendingEventsIfNeeded(path44) {
         LOG.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
       }
     }
-    writeFileSync6(path44, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    writeFileSync6(path45, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -11809,18 +11865,24 @@ function stampPendingEventV2(event, hint) {
   if (event.protocolVersion === MESH_PROTOCOL_VERSION_V2 && readNonEmptyString2(event.eventId)) {
     return event;
   }
-  const dispatchedBy = hint?.dispatchedBy ?? coordinatorIdentityFromEmitFields({
+  const coordinatorIdentity = hint?.dispatchedBy ?? coordinatorIdentityFromEmitFields({
     daemonId: event.targetCoordinatorDaemonId,
     coordinatorRunId: hint?.coordinatorRunId,
     sessionId: event.targetCoordinatorSessionId
   });
-  const intendedFor = hint?.intendedFor ?? dispatchedBy;
+  const selfFallback = !coordinatorIdentity;
+  const dispatchedBy = coordinatorIdentity ?? coordinatorIdentityFromEmitFields({
+    daemonId: readNonEmptyString2(loadConfig().machineId)
+  });
+  const intendedFor = hint?.intendedFor ?? (selfFallback ? void 0 : coordinatorIdentity);
   const stamp = buildPendingEventEmitStamp({
     eventName: event.event,
     eventId: randomUUID8(),
     dispatchedBy,
     intendedFor,
-    scope: hint?.scope
+    // Force broadcast for the self-fallback so a unicast-defaulting terminal
+    // event isn't addressed to this daemon alone; an explicit hint still wins.
+    scope: hint?.scope ?? (selfFallback ? "broadcast" : void 0)
   });
   if (!stamp) return event;
   return {
@@ -11864,6 +11926,9 @@ function readV2EnvelopeFromWire(payload) {
 }
 function queuePendingMeshCoordinatorEvent(rawEvent, hint) {
   const event = stampPendingEventV2(rawEvent, hint);
+  return persistPendingMeshCoordinatorEvent(event);
+}
+function persistPendingMeshCoordinatorEvent(event) {
   try {
     if (hasPendingRefineTerminalEventDuplicate(event)) {
       LOG.info("MeshEvents", `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId2(event)}`);
@@ -11898,9 +11963,9 @@ function queuePendingMeshCoordinatorEvent(rawEvent, hint) {
     } catch {
     }
     try {
-      const path44 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-      trimPendingEventsIfNeeded(path44);
-      appendFileSync2(path44, JSON.stringify(event) + "\n", "utf-8");
+      const path45 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+      trimPendingEventsIfNeeded(path45);
+      appendFileSync2(path45, JSON.stringify(event) + "\n", "utf-8");
     } catch (e) {
       if (!sqliteOk) throw e;
       LOG.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
@@ -11911,10 +11976,10 @@ function queuePendingMeshCoordinatorEvent(rawEvent, hint) {
     return false;
   }
 }
-function atomicDrainFile(path44) {
-  const tmpPath = `${path44}.draining`;
+function atomicDrainFile(path45) {
+  const tmpPath = `${path45}.draining`;
   try {
-    renameSync4(path44, tmpPath);
+    renameSync4(path45, tmpPath);
   } catch {
     return null;
   }
@@ -11933,10 +11998,10 @@ function atomicDrainFile(path44) {
     return null;
   }
 }
-function selectiveDrainFile(path44, predicate) {
-  const tmpPath = `${path44}.draining`;
+function selectiveDrainFile(path45, predicate) {
+  const tmpPath = `${path45}.draining`;
   try {
-    renameSync4(path44, tmpPath);
+    renameSync4(path45, tmpPath);
   } catch {
     return [];
   }
@@ -11968,12 +12033,12 @@ function selectiveDrainFile(path44, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      writeFileSync6(path44, keptLines.join("\n") + "\n", "utf-8");
+      writeFileSync6(path45, keptLines.join("\n") + "\n", "utf-8");
     }
     unlinkSync2(tmpPath);
   } catch {
     try {
-      if (existsSync15(tmpPath) && !existsSync15(path44)) renameSync4(tmpPath, path44);
+      if (existsSync15(tmpPath) && !existsSync15(path45)) renameSync4(tmpPath, path45);
     } catch {
     }
     return [];
@@ -12014,16 +12079,16 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
     LOG.warn("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
   }
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path44 of paths) {
-    const isSharedFile = !!primaryDaemonId && path44 === getPendingEventsPath(meshId);
+  for (const path45 of paths) {
+    const isSharedFile = !!primaryDaemonId && path45 === getPendingEventsPath(meshId);
     const targets = (e) => !isSharedFile || !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId);
     if (onlyEvents) {
-      for (const event of selectiveDrainFile(path44, (e) => targets(e) && matchesFilter(e.event))) {
+      for (const event of selectiveDrainFile(path45, (e) => targets(e) && matchesFilter(e.event))) {
         pushUnique(event);
       }
       continue;
     }
-    const content = atomicDrainFile(path44);
+    const content = atomicDrainFile(path45);
     if (!content) continue;
     const parsed = content.split("\n").filter(Boolean).flatMap((line) => {
       try {
@@ -12064,9 +12129,9 @@ function retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId)
   const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
   const primaryDaemonId = daemonIds[0];
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path44 of paths) {
+  for (const path45 of paths) {
     try {
-      removed += selectiveDrainFile(path44, matchesTask).length;
+      removed += selectiveDrainFile(path45, matchesTask).length;
     } catch {
     }
   }
@@ -12118,18 +12183,19 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   } catch {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path44 of paths) {
-    if (existsSync15(path44)) try {
-      unlinkSync2(path44);
+  for (const path45 of paths) {
+    if (existsSync15(path45)) try {
+      unlinkSync2(path45);
     } catch {
     }
   }
 }
-var REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, PENDING_EVENTS_DRAINED_RETENTION_MS, PENDING_EVENTS_UNDRAINED_RETENTION_MS;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
     init_logger();
+    init_config();
     init_mesh_ledger();
     init_mesh_runtime_store();
     init_mesh_events_utils();
@@ -12165,6 +12231,8 @@ var init_mesh_events_pending = __esm({
     TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
+    PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+    PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
   }
 });
 
@@ -12802,9 +12870,9 @@ function findBinary(name) {
     for (const ext of exes) {
       const fullPath = path11.join(p, trimmed + ext);
       try {
-        const fs40 = __require("fs");
-        if (fs40.existsSync(fullPath)) {
-          const stat2 = fs40.statSync(fullPath);
+        const fs41 = __require("fs");
+        if (fs41.existsSync(fullPath)) {
+          const stat2 = fs41.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -12818,12 +12886,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path11.isAbsolute(binaryPath)) return false;
   try {
-    const fs40 = __require("fs");
-    const resolved = fs40.realpathSync(binaryPath);
+    const fs41 = __require("fs");
+    const resolved = fs41.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs40.openSync(resolved, "r");
-    fs40.readSync(fd, head, 0, 8, 0);
-    fs40.closeSync(fd);
+    const fd = fs41.openSync(resolved, "r");
+    fs41.readSync(fd, head, 0, 8, 0);
+    fs41.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -12834,12 +12902,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path11.isAbsolute(filePath)) return false;
   try {
-    const fs40 = __require("fs");
-    const resolved = fs40.realpathSync(filePath);
+    const fs41 = __require("fs");
+    const resolved = fs41.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs40.openSync(resolved, "r");
-    fs40.readSync(fd, buf, 0, 8, 0);
-    fs40.closeSync(fd);
+    const fd = fs41.openSync(resolved, "r");
+    fs41.readSync(fd, buf, 0, 8, 0);
+    fs41.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -17225,6 +17293,11 @@ function sweepExpiredRemoteIdleSessions() {
     MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
   } catch {
   }
+  const now = Date.now();
+  if (now - lastPendingEventsPruneAt >= PENDING_EVENTS_PRUNE_INTERVAL_MS) {
+    lastPendingEventsPruneAt = now;
+    prunePendingMeshCoordinatorEventsRetention();
+  }
 }
 function isIntentionalCleanupStopMetadata(event) {
   return event.intentional === true || event.intentionalStop === true || event.operatorCleanup === true || event.reason === "operator_cleanup" || event.stopReason === "operator_cleanup" || event.cleanupReason === "operator_cleanup" || event.source === "mesh_cleanup_sessions" || event.source === "mesh_remove_node";
@@ -18283,7 +18356,7 @@ function setupMeshEventForwarding(components) {
     flushPendingForMeshIdleCoordinators(components, routing.meshId);
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, lastPendingEventsPruneAt, PENDING_EVENTS_PRUNE_INTERVAL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
 var init_mesh_event_forwarding = __esm({
   "src/mesh/mesh-event-forwarding.ts"() {
     "use strict";
@@ -18310,6 +18383,8 @@ var init_mesh_event_forwarding = __esm({
     REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
     meshByWorkspaceCache = /* @__PURE__ */ new Map();
     MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
+    lastPendingEventsPruneAt = 0;
+    PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
     RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
     RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
@@ -18332,40 +18407,48 @@ var init_mesh_events_coordinator = __esm({
   }
 });
 
-// src/mesh/mesh-reconcile-loop.ts
-function resolveAutoPruneMinAgeMs() {
-  const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= 60 * 6e4 && parsed <= 30 * 24 * 60 * 6e4) return parsed;
-  }
-  return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+// src/mesh/mesh-reconcile-identity.ts
+function resolveCoordinatorDaemonIds(components) {
+  const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
+  const machineId = readNonEmptyString2(loadConfig().machineId);
+  return expandDaemonIdForms([statusInstanceId, machineId]);
 }
-function resolvePendingHeldDrainEscalateMs() {
-  return resolveTunedReconcileMs("MESH_PENDING_HELD_DRAIN_ESCALATE_MS", DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, 4e3, 5 * 6e4);
+function daemonHostsMesh(mesh, daemonIds) {
+  const host = mesh.meshHost;
+  if (!host) return true;
+  if (host.role && host.role !== "host") return false;
+  const hostDaemonId = readNonEmptyString2(host.hostDaemonId);
+  if (!hostDaemonId) return true;
+  return daemonIdListIncludes(daemonIds, hostDaemonId);
 }
-function resolveReconcileIntervalMs() {
-  const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= 1e3 && parsed <= 6e4) return parsed;
-  }
-  return DEFAULT_RECONCILE_INTERVAL_MS;
+function daemonIdListIncludes(ids, id) {
+  if (!id) return false;
+  return ids.some((candidate) => candidate === id || daemonIdsEquivalent(candidate, id));
 }
-function resolveTunedReconcileMs(envName, def, min, max) {
-  const raw = readNonEmptyString2(process.env[envName]);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+function resolveCoordinatorSelfIds(mesh, drainDaemonIds) {
+  const ids = new Set(drainDaemonIds);
+  for (const node of mesh.nodes) {
+    const nodeDaemonId = readNonEmptyString2(node.daemonId);
+    const nodeMachineId = readNonEmptyString2(node.machineId);
+    const isSelf = nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId) || nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId);
+    if (!isSelf) continue;
+    if (nodeDaemonId) ids.add(nodeDaemonId);
+    if (nodeMachineId) ids.add(nodeMachineId);
   }
-  return def;
-}
-function resolveAckedDeathDeadlineMs() {
-  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
-}
-function resolveAckedTranscriptFastTrackGraceMs() {
-  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
+  const hostDaemonId = readNonEmptyString2(mesh.meshHost?.hostDaemonId);
+  if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
+  return [...ids];
 }
+var init_mesh_reconcile_identity = __esm({
+  "src/mesh/mesh-reconcile-identity.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+    init_mesh_events_utils();
+  }
+});
+
+// src/mesh/mesh-reconcile-v2-backstop.ts
 function getMeshV2BackstopCounters() {
   return { ...meshV2BackstopCounters };
 }
@@ -18381,6 +18464,37 @@ function recordBackstopFire(kind, detail) {
     LOG.warn("MeshReconcileV2", `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 \u2014 a worker's real terminal emit was lost/late.`);
   }
 }
+var meshV2BackstopCounters;
+var init_mesh_reconcile_v2_backstop = __esm({
+  "src/mesh/mesh-reconcile-v2-backstop.ts"() {
+    "use strict";
+    init_logger();
+    meshV2BackstopCounters = {
+      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+      phase4SynthesisFired: 0,
+      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+      ackedHoldFastTrackFired: 0,
+      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+      ackedHoldDeathDeadlineFired: 0
+    };
+  }
+});
+
+// src/mesh/mesh-reconcile-acked-hold.ts
+function resolveTunedReconcileMs(envName, def, min, max) {
+  const raw = readNonEmptyString2(process.env[envName]);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+  }
+  return def;
+}
+function resolveAckedDeathDeadlineMs() {
+  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
+}
+function resolveAckedTranscriptFastTrackGraceMs() {
+  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
+}
 function inFlightSynthKey(meshId, taskId) {
   return `${meshId}::${taskId}`;
 }
@@ -18463,36 +18577,54 @@ function rehydrateAckedHoldsForMesh(meshId) {
     LOG.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
   }
 }
-function resolveCoordinatorDaemonIds(components) {
-  const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
-  const machineId = readNonEmptyString2(loadConfig().machineId);
-  return expandDaemonIdForms([statusInstanceId, machineId]);
+function collectHeldSynthKeysForMesh(meshId) {
+  const heldKeys = /* @__PURE__ */ new Set();
+  for (const key2 of inFlightAckedHoldState.keys()) {
+    if (key2.startsWith(`${meshId}::`)) heldKeys.add(key2);
+  }
+  const store = holdStore();
+  if (store) {
+    try {
+      for (const row of store.listInflightHoldsByMesh(meshId)) {
+        heldKeys.add(inFlightSynthKey(meshId, row.taskId));
+      }
+    } catch {
+    }
+  }
+  return heldKeys;
 }
-function daemonHostsMesh(mesh, daemonIds) {
-  const host = mesh.meshHost;
-  if (!host) return true;
-  if (host.role && host.role !== "host") return false;
-  const hostDaemonId = readNonEmptyString2(host.hostDaemonId);
-  if (!hostDaemonId) return true;
-  return daemonIdListIncludes(daemonIds, hostDaemonId);
+var ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes;
+var init_mesh_reconcile_acked_hold = __esm({
+  "src/mesh/mesh-reconcile-acked-hold.ts"() {
+    "use strict";
+    init_logger();
+    init_mesh_runtime_store();
+    init_mesh_events_utils();
+    ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
+    inFlightAckedHoldState = /* @__PURE__ */ new Map();
+    rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/mesh/mesh-reconcile-loop.ts
+function resolveAutoPruneMinAgeMs() {
+  const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 60 * 6e4 && parsed <= 30 * 24 * 60 * 6e4) return parsed;
+  }
+  return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
 }
-function daemonIdListIncludes(ids, id) {
-  if (!id) return false;
-  return ids.some((candidate) => candidate === id || daemonIdsEquivalent(candidate, id));
+function resolvePendingHeldDrainEscalateMs() {
+  return resolveTunedReconcileMs("MESH_PENDING_HELD_DRAIN_ESCALATE_MS", DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, 4e3, 5 * 6e4);
 }
-function resolveCoordinatorSelfIds(mesh, drainDaemonIds) {
-  const ids = new Set(drainDaemonIds);
-  for (const node of mesh.nodes) {
-    const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    const nodeMachineId = readNonEmptyString2(node.machineId);
-    const isSelf = nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId) || nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId);
-    if (!isSelf) continue;
-    if (nodeDaemonId) ids.add(nodeDaemonId);
-    if (nodeMachineId) ids.add(nodeMachineId);
+function resolveReconcileIntervalMs() {
+  const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 1e3 && parsed <= 6e4) return parsed;
   }
-  const hostDaemonId = readNonEmptyString2(mesh.meshHost?.hostDaemonId);
-  if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
-  return [...ids];
+  return DEFAULT_RECONCILE_INTERVAL_MS;
 }
 function findLiveCoordinators(components) {
   const out = [];
@@ -19258,19 +19390,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
   const activeTaskKeys = new Set(
     dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
   );
-  const heldKeys = /* @__PURE__ */ new Set();
-  for (const key2 of inFlightAckedHoldState.keys()) {
-    if (key2.startsWith(`${mesh.id}::`)) heldKeys.add(key2);
-  }
-  const store = holdStore();
-  if (store) {
-    try {
-      for (const row of store.listInflightHoldsByMesh(mesh.id)) {
-        heldKeys.add(inFlightSynthKey(mesh.id, row.taskId));
-      }
-    } catch {
-    }
-  }
+  const heldKeys = collectHeldSynthKeysForMesh(mesh.id);
   for (const key2 of heldKeys) {
     if (!activeTaskKeys.has(key2)) deleteHoldState(key2, mesh.id);
   }
@@ -19546,7 +19666,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, meshV2BackstopCounters, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -19568,20 +19688,14 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_active_work();
     init_mesh_events_stale();
     init_chat_message_normalization();
+    init_mesh_reconcile_identity();
+    init_mesh_reconcile_v2_backstop();
+    init_mesh_reconcile_acked_hold();
+    init_mesh_reconcile_v2_backstop();
+    init_mesh_reconcile_acked_hold();
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
     DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
     DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
-    ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
-    inFlightAckedHoldState = /* @__PURE__ */ new Map();
-    rehydratedHoldMeshes = /* @__PURE__ */ new Set();
-    meshV2BackstopCounters = {
-      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
-      phase4SynthesisFired: 0,
-      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
-      ackedHoldFastTrackFired: 0,
-      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
-      ackedHoldDeathDeadlineFired: 0
-    };
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -20278,7 +20392,7 @@ function getCliValidator() {
   return _cliValidator;
 }
 function formatIssue(err) {
-  const path44 = err.instancePath || "";
+  const path45 = err.instancePath || "";
   const params = err.params;
   let message = err.message || "validation failed";
   let allowed;
@@ -20296,7 +20410,7 @@ function formatIssue(err) {
   } else if (err.keyword === "type") {
     message = `must be ${params.type}`;
   }
-  return { path: path44, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
+  return { path: path45, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
 }
 function validateCliProviderManifest(manifest) {
   const validator = getCliValidator();
@@ -20591,49 +20705,49 @@ function validateFsmSpec(raw) {
   }
   return errs;
 }
-function validateCondition(c, sectionIds, path44) {
+function validateCondition(c, sectionIds, path45) {
   const errs = [];
   const w = c;
   if ("all" in w) {
-    w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path44}.all[${i}]`)));
+    w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path45}.all[${i}]`)));
     return errs;
   }
   if ("any" in w) {
-    w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path44}.any[${i}]`)));
+    w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path45}.any[${i}]`)));
     return errs;
   }
   if ("not" in w) {
-    errs.push(...validateCondition(w.not, sectionIds, `${path44}.not`));
+    errs.push(...validateCondition(w.not, sectionIds, `${path45}.not`));
     return errs;
   }
   if ("matches" in w) {
-    if (w.section && !sectionIds.has(w.section)) errs.push(`${path44}.section "${w.section}" unknown`);
+    if (w.section && !sectionIds.has(w.section)) errs.push(`${path45}.section "${w.section}" unknown`);
     try {
       new RegExp(w.matches, w.flags ?? "i");
     } catch (e) {
-      errs.push(`${path44}.matches invalid regex: ${e.message}`);
+      errs.push(`${path45}.matches invalid regex: ${e.message}`);
     }
     return errs;
   }
   if ("cursor_above" in w && "changed" in w) return errs;
   if ("elapsed_ms" in w) {
-    if (typeof w.elapsed_ms !== "number") errs.push(`${path44}.elapsed_ms must be a number`);
+    if (typeof w.elapsed_ms !== "number") errs.push(`${path45}.elapsed_ms must be a number`);
     return errs;
   }
   if ("stable_ms" in w) {
-    if (typeof w.stable_ms !== "number") errs.push(`${path44}.stable_ms must be a number`);
-    if (w.section && !sectionIds.has(w.section)) errs.push(`${path44}.section "${w.section}" unknown`);
+    if (typeof w.stable_ms !== "number") errs.push(`${path45}.stable_ms must be a number`);
+    if (w.section && !sectionIds.has(w.section)) errs.push(`${path45}.section "${w.section}" unknown`);
     if (w.ignore_lines !== void 0) {
-      if (typeof w.ignore_lines !== "string") errs.push(`${path44}.ignore_lines must be a string`);
+      if (typeof w.ignore_lines !== "string") errs.push(`${path45}.ignore_lines must be a string`);
       else try {
         new RegExp(w.ignore_lines, "m");
       } catch (e) {
-        errs.push(`${path44}.ignore_lines invalid regex: ${e.message}`);
+        errs.push(`${path45}.ignore_lines invalid regex: ${e.message}`);
       }
     }
     return errs;
   }
-  errs.push(`${path44} is not a recognized condition`);
+  errs.push(`${path45} is not a recognized condition`);
   return errs;
 }
 var init_fsm_loader = __esm({
@@ -21130,8 +21244,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs40 = __require("fs");
-            const stat2 = fs40.statSync(cwd);
+            const fs41 = __require("fs");
+            const stat2 = fs41.statSync(cwd);
             if (!stat2.isDirectory()) cwd = os14.homedir();
           } catch {
             cwd = os14.homedir();
@@ -24926,7 +25040,7 @@ __export(require_whitelist_exports, {
   registerProviderScriptRoot: () => registerProviderScriptRoot,
   unregisterProviderScriptRoot: () => unregisterProviderScriptRoot
 });
-import * as path34 from "path";
+import * as path35 from "path";
 import { createRequire as createRequire3 } from "module";
 import * as nodeFs from "fs";
 import * as nodeChildProcess from "child_process";
@@ -25067,7 +25181,7 @@ function _getRegisteredRoots() {
 }
 function canonicalize(p) {
   try {
-    const resolved = path34.resolve(p);
+    const resolved = path35.resolve(p);
     try {
       return nodeFs.realpathSync.native ? nodeFs.realpathSync.native(resolved) : nodeFs.realpathSync(resolved);
     } catch {
@@ -25087,7 +25201,7 @@ function isCallerInsideGatedRoot(callerFilename) {
   }
   for (const root of _gatedRoots) {
     if (normalized === root.rootPath) return root;
-    if (normalized.startsWith(root.rootPath + path34.sep)) return root;
+    if (normalized.startsWith(root.rootPath + path35.sep)) return root;
   }
   return null;
 }
@@ -25106,16 +25220,16 @@ function ensureInstalled() {
   };
 }
 function gatedRequire(request, parent, isMain, gated, originalLoad) {
-  if (request.startsWith("./") || request.startsWith("../") || path34.isAbsolute(request)) {
+  if (request.startsWith("./") || request.startsWith("../") || path35.isAbsolute(request)) {
     let resolved;
     try {
-      const callerRequire = parent?.filename ? createRequire3(parent.filename) : createRequire3(path34.join(gated.rootPath, "__entry__.js"));
+      const callerRequire = parent?.filename ? createRequire3(parent.filename) : createRequire3(path35.join(gated.rootPath, "__entry__.js"));
       resolved = callerRequire.resolve(request);
     } catch {
       return originalLoad.call(this, request, parent, isMain);
     }
     const resolvedCanon = canonicalize(resolved) || resolved;
-    if (!(resolvedCanon === gated.rootPath || resolvedCanon.startsWith(gated.rootPath + path34.sep))) {
+    if (!(resolvedCanon === gated.rootPath || resolvedCanon.startsWith(gated.rootPath + path35.sep))) {
       denyRequire(request, parent, `relative path escapes provider root (resolved to ${resolvedCanon})`);
     }
     return originalLoad.call(this, request, parent, isMain);
@@ -26832,17 +26946,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os31 = platform5();
+  const os32 = platform5();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os31] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os32] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os31 === "darwin") {
+    if (!resolvedCli && appPath && os32 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if (existsSync20(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os31 === "win32") {
+    if (!resolvedCli && appPath && os32 === "win32") {
       const { dirname: dirname17 } = await import("path");
       const appDir = dirname17(appPath);
       const candidates = [
@@ -26859,7 +26973,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os31 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os32 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = null;
     results.push({
       id: def.id,
@@ -36289,9 +36403,9 @@ var DaemonCommandHandler = class {
    * point at a sibling git checkout.
    */
   getUpstreamInstallRoot() {
-    const os31 = __require("os");
-    const path44 = __require("path");
-    return path44.join(os31.homedir(), ".adhdev", "providers", ".upstream");
+    const os32 = __require("os");
+    const path45 = __require("path");
+    return path45.join(os32.homedir(), ".adhdev", "providers", ".upstream");
   }
   /**
    * Download a single provider manifest from the registry and write it to
@@ -36315,8 +36429,8 @@ var DaemonCommandHandler = class {
       return { success: false, error: "invalid type" };
     }
     const https = __require("https");
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     const REGISTRY = resolveRegistryBaseUrl(loadConfig().registryUrl);
     function fetchText(url, timeoutMs) {
       return new Promise((resolve25, reject) => {
@@ -36353,12 +36467,12 @@ var DaemonCommandHandler = class {
         return { success: false, error: `checksum mismatch: expected ${meta.checksum}, got ${actualChecksum}` };
       }
       const installRoot = this.getUpstreamInstallRoot();
-      const installRootResolved = path44.resolve(installRoot);
-      const targetDir = path44.resolve(path44.join(installRoot, category, type));
-      if (!targetDir.startsWith(installRootResolved + path44.sep)) {
+      const installRootResolved = path45.resolve(installRoot);
+      const targetDir = path45.resolve(path45.join(installRoot, category, type));
+      if (!targetDir.startsWith(installRootResolved + path45.sep)) {
         return { success: false, error: "install path escaped upstream root" };
       }
-      fs40.mkdirSync(targetDir, { recursive: true });
+      fs41.mkdirSync(targetDir, { recursive: true });
       let manifestProbe = {};
       try {
         manifestProbe = JSON.parse(manifestBody);
@@ -36382,8 +36496,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         }
       }
       const targetFile = isV1 ? "provider.v1.json" : "provider.json";
-      const targetPath = path44.join(targetDir, targetFile);
-      fs40.writeFileSync(targetPath, manifestBody, "utf-8");
+      const targetPath = path45.join(targetDir, targetFile);
+      fs41.writeFileSync(targetPath, manifestBody, "utf-8");
       const manifestJson = JSON.parse(manifestBody);
       const scriptFetch = await this.fetchProviderSources(
         manifestJson,
@@ -36453,8 +36567,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const repo = source.repo;
     const ref = source.ref;
     const https = __require("https");
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     function fetchJson(url, timeoutMs) {
       return new Promise((resolve25, reject) => {
         const req = https.get(url, {
@@ -36510,9 +36624,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     }
     let fetchedCount = 0;
     const sharedDirRel = `${category}/_shared`;
-    const sharedTargetDir = path44.resolve(path44.join(targetDir, "../_shared"));
-    const installRootResolved = path44.resolve(path44.join(targetDir, "../.."));
-    if (sharedTargetDir.startsWith(installRootResolved + path44.sep)) {
+    const sharedTargetDir = path45.resolve(path45.join(targetDir, "../_shared"));
+    const installRootResolved = path45.resolve(path45.join(targetDir, "../.."));
+    if (sharedTargetDir.startsWith(installRootResolved + path45.sep)) {
       const sharedStack = [sharedDirRel];
       while (sharedStack.length) {
         const relDir = sharedStack.pop();
@@ -36535,10 +36649,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           try {
             const body = await fetchBinary(entry.download_url, 3e4);
             const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
-            const outPath = path44.resolve(path44.join(sharedTargetDir, relInside));
-            if (!outPath.startsWith(path44.resolve(sharedTargetDir) + path44.sep)) continue;
-            fs40.mkdirSync(path44.dirname(outPath), { recursive: true });
-            fs40.writeFileSync(outPath, body);
+            const outPath = path45.resolve(path45.join(sharedTargetDir, relInside));
+            if (!outPath.startsWith(path45.resolve(sharedTargetDir) + path45.sep)) continue;
+            fs41.mkdirSync(path45.dirname(outPath), { recursive: true });
+            fs41.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -36571,13 +36685,13 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           try {
             const body = await fetchBinary(entry.download_url, 3e4);
             const relInsideProvider = entry.path.startsWith(subdir + "/") ? entry.path.slice(subdir.length + 1) : entry.path;
-            const outPath = path44.resolve(path44.join(targetDir, relInsideProvider));
-            if (!outPath.startsWith(path44.resolve(targetDir) + path44.sep)) {
+            const outPath = path45.resolve(path45.join(targetDir, relInsideProvider));
+            if (!outPath.startsWith(path45.resolve(targetDir) + path45.sep)) {
               errors.push(`refusing to write outside targetDir: ${entry.path}`);
               continue;
             }
-            fs40.mkdirSync(path44.dirname(outPath), { recursive: true });
-            fs40.writeFileSync(outPath, body);
+            fs41.mkdirSync(path45.dirname(outPath), { recursive: true });
+            fs41.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -36605,19 +36719,19 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!["cli", "ide", "extension", "acp"].includes(category)) {
       return { success: false, error: `unknown category: ${category}` };
     }
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     try {
       const installRoot = this.getUpstreamInstallRoot();
-      const installRootResolved = path44.resolve(installRoot);
-      const targetDir = path44.resolve(path44.join(installRoot, category, type));
-      if (!targetDir.startsWith(installRootResolved + path44.sep)) {
+      const installRootResolved = path45.resolve(installRoot);
+      const targetDir = path45.resolve(path45.join(installRoot, category, type));
+      if (!targetDir.startsWith(installRootResolved + path45.sep)) {
         return { success: false, error: "refusing to delete outside upstream root" };
       }
-      if (!fs40.existsSync(targetDir)) {
+      if (!fs41.existsSync(targetDir)) {
         return { success: false, error: "not installed" };
       }
-      fs40.rmSync(targetDir, { recursive: true, force: true });
+      fs41.rmSync(targetDir, { recursive: true, force: true });
       if (this._ctx.providerLoader) {
         this._ctx.providerLoader.reload();
         this._ctx.providerLoader.registerToDetector();
@@ -36633,28 +36747,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
    * the UI and by the update checker.
    */
   handleListInstalledProviders(_args) {
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     const installRoot = this.getUpstreamInstallRoot();
-    if (!fs40.existsSync(installRoot)) return { success: true, providers: [] };
+    if (!fs41.existsSync(installRoot)) return { success: true, providers: [] };
     const CATEGORIES = ["cli", "ide", "extension", "acp"];
     const items = [];
     for (const category of CATEGORIES) {
-      const categoryDir = path44.join(installRoot, category);
-      if (!fs40.existsSync(categoryDir)) continue;
+      const categoryDir = path45.join(installRoot, category);
+      if (!fs41.existsSync(categoryDir)) continue;
       let entries;
       try {
-        entries = fs40.readdirSync(categoryDir);
+        entries = fs41.readdirSync(categoryDir);
       } catch {
         continue;
       }
       for (const type of entries) {
-        const v1Path = path44.join(categoryDir, type, "provider.v1.json");
-        const v0Path = path44.join(categoryDir, type, "provider.json");
-        const manifestPath = fs40.existsSync(v1Path) ? v1Path : fs40.existsSync(v0Path) ? v0Path : null;
+        const v1Path = path45.join(categoryDir, type, "provider.v1.json");
+        const v0Path = path45.join(categoryDir, type, "provider.json");
+        const manifestPath = fs41.existsSync(v1Path) ? v1Path : fs41.existsSync(v0Path) ? v0Path : null;
         if (!manifestPath) continue;
         try {
-          const m = JSON.parse(fs40.readFileSync(manifestPath, "utf-8"));
+          const m = JSON.parse(fs41.readFileSync(manifestPath, "utf-8"));
           items.push({
             type,
             category,
@@ -36765,8 +36879,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
       return { success: false, error: "name must match @[a-z0-9_-]+" };
     }
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     const { spawnSync: spawnSync2 } = __require("child_process");
     const file = ext.loadExternalSources();
     if (file.sources.some((s2) => s2.name === requestedName)) {
@@ -36775,9 +36889,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (file.sources.some((s2) => s2.url === url && s2.ref === ref)) {
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
-    const sourceDir = path44.join(ext.externalRoot(), requestedName);
-    if (!fs40.existsSync(ext.externalRoot())) fs40.mkdirSync(ext.externalRoot(), { recursive: true });
-    if (fs40.existsSync(sourceDir)) {
+    const sourceDir = path45.join(ext.externalRoot(), requestedName);
+    if (!fs41.existsSync(ext.externalRoot())) fs41.mkdirSync(ext.externalRoot(), { recursive: true });
+    if (fs41.existsSync(sourceDir)) {
       return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
     }
     const clone = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url, sourceDir], {
@@ -36787,7 +36901,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     });
     if (clone.status !== 0) {
       try {
-        fs40.rmSync(sourceDir, { recursive: true, force: true });
+        fs41.rmSync(sourceDir, { recursive: true, force: true });
       } catch {
       }
       return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || "").trim() || "unknown error"}` };
@@ -36831,15 +36945,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const name = typeof args?.name === "string" ? args.name.trim() : "";
     if (!name) return { success: false, error: "name is required" };
     const ext = (init_external_sources(), __toCommonJS(external_sources_exports));
-    const fs40 = __require("fs");
-    const path44 = __require("path");
+    const fs41 = __require("fs");
+    const path45 = __require("path");
     const file = ext.loadExternalSources();
     const match = file.sources.find((s2) => s2.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
-    const sourceDir = path44.join(ext.externalRoot(), name);
-    if (fs40.existsSync(sourceDir)) {
+    const sourceDir = path45.join(ext.externalRoot(), name);
+    if (fs41.existsSync(sourceDir)) {
       try {
-        fs40.rmSync(sourceDir, { recursive: true, force: true });
+        fs41.rmSync(sourceDir, { recursive: true, force: true });
       } catch (e) {
         return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
       }
@@ -37624,24 +37738,24 @@ var statusMetaHandlers = {
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
   list_coordinator_prompts: async (_ctx, _args) => {
-    const fs40 = await import("fs");
-    const path44 = await import("path");
-    const os31 = await import("os");
-    const dir = path44.join(os31.homedir(), ".adhdev", "coordinator-prompts");
+    const fs41 = await import("fs");
+    const path45 = await import("path");
+    const os32 = await import("os");
+    const dir = path45.join(os32.homedir(), ".adhdev", "coordinator-prompts");
     const entries = {};
     try {
-      if (fs40.existsSync(dir)) {
-        for (const name of fs40.readdirSync(dir)) {
+      if (fs41.existsSync(dir)) {
+        for (const name of fs41.readdirSync(dir)) {
           const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
           const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
           const m = matchAppend || matchOverride;
           if (!m) continue;
           const isAppend = !!matchAppend;
           const key2 = m[1];
-          const full = path44.join(dir, name);
+          const full = path45.join(dir, name);
           let content = "";
           try {
-            content = fs40.readFileSync(full, "utf8");
+            content = fs41.readFileSync(full, "utf8");
           } catch {
           }
           if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -37655,24 +37769,24 @@ var coordinatorPromptHandlers = {
     return { success: true, dir, entries };
   },
   write_coordinator_prompt: async (_ctx, args) => {
-    const fs40 = await import("fs");
-    const path44 = await import("path");
-    const os31 = await import("os");
+    const fs41 = await import("fs");
+    const path45 = await import("path");
+    const os32 = await import("os");
     const key2 = typeof args?.key === "string" ? args.key.trim() : "";
     const kind = args?.kind === "append" ? "append" : "override";
     const content = typeof args?.content === "string" ? args.content : "";
     if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
       return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
     }
-    const dir = path44.join(os31.homedir(), ".adhdev", "coordinator-prompts");
+    const dir = path45.join(os32.homedir(), ".adhdev", "coordinator-prompts");
     const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
-    const full = path44.join(dir, filename);
+    const full = path45.join(dir, filename);
     try {
-      fs40.mkdirSync(dir, { recursive: true });
+      fs41.mkdirSync(dir, { recursive: true });
       if (content.trim()) {
-        fs40.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-      } else if (fs40.existsSync(full)) {
-        fs40.unlinkSync(full);
+        fs41.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+      } else if (fs41.existsSync(full)) {
+        fs41.unlinkSync(full);
       }
       return { success: true, path: full, kind, key: key2 };
     } catch (error) {
@@ -38763,9 +38877,9 @@ init_workspaces();
 init_recent_activity();
 init_hash();
 init_coordinator_registry();
-import * as os21 from "os";
-import * as path28 from "path";
-import * as crypto5 from "crypto";
+import * as os22 from "os";
+import * as path29 from "path";
+import * as crypto6 from "crypto";
 import { existsSync as existsSync31, mkdirSync as mkdirSync13, writeFileSync as writeFileSync16 } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
 import chalk from "chalk";
@@ -38774,11 +38888,9 @@ init_summary_metadata();
 // src/providers/cli-provider-instance.ts
 init_contracts2();
 init_provider_input_support();
-import * as os20 from "os";
-import * as path26 from "path";
-import * as crypto4 from "crypto";
-import * as fs19 from "fs";
-import { createRequire as createRequire2 } from "module";
+import * as os21 from "os";
+import * as crypto5 from "crypto";
+import * as fs20 from "fs";
 init_hash();
 
 // src/providers/spec/route.ts
@@ -41982,28 +42094,11 @@ function workingDirBasename(p) {
   return (p || "").split(/[\\/]/).filter(Boolean).pop() || "session";
 }
 
-// src/providers/cli-provider-instance.ts
-var STATUS_HYDRATION_TAIL_LIMIT = 200;
-function isIdleStatus(value) {
-  const status = typeof value === "string" ? value.trim().toLowerCase() : "";
-  return !status || status === "idle" || status === "ready";
-}
-function getMessageTime(message) {
-  if (!message || typeof message !== "object") return 0;
-  const record = message;
-  const value = Number(record.receivedAt ?? record.timestamp ?? 0);
-  return Number.isFinite(value) ? value : 0;
-}
-var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
-var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
-var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4e3;
-var USER_INPUT_ACK_DEDUP_WINDOW_MS = 6e4;
-var STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12e3;
-var TERMINAL_MESH_EVENTS = /* @__PURE__ */ new Set([
-  "agent:generating_completed",
-  "agent:stopped",
-  "agent:ready"
-]);
+// src/providers/cli-provider-input-prompt.ts
+import * as os20 from "os";
+import * as path26 from "path";
+import * as crypto4 from "crypto";
+import * as fs19 from "fs";
 var IMAGE_MIME_EXTENSIONS = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
@@ -42067,19 +42162,6 @@ function cleanupStaleMaterializedImages(dir) {
   } catch {
   }
 }
-function hasNonEmptyCliModalButtons(activeModal) {
-  const buttons = activeModal?.buttons;
-  return Array.isArray(buttons) && buttons.some((button) => String(button || "").trim().length > 0);
-}
-function isCliGeneratingLikeStatus(status) {
-  return status === "generating" || status === "streaming" || status === "no_progress" || status === "long_generating" || status === "starting";
-}
-function computeTurnAnchoredDurationMs(engineTurnStartedAt, generatingStartedAt, now) {
-  const engineStart = typeof engineTurnStartedAt === "number" && Number.isFinite(engineTurnStartedAt) ? engineTurnStartedAt : 0;
-  if (engineStart > 0) return { durationMs: now - engineStart, anchor: "turn-start" };
-  if (generatingStartedAt > 0) return { durationMs: now - generatingStartedAt, anchor: "generatingStartedAt" };
-  return { durationMs: 0, anchor: "none" };
-}
 function buildCliStructuredInputPrompt(input, options = {}) {
   const promptParts = [];
   const imageRefs = [];
@@ -42117,6 +42199,9 @@ function buildCliStructuredInputPrompt(input, options = {}) {
   ].filter((value, index, values) => value.trim().length > 0 && values.indexOf(value) === index);
   return ordered.join("\n");
 }
+
+// src/providers/cli-provider-history-dedup.ts
+init_contracts2();
 function normalizePersistableCliHistoryContent(content) {
   return flattenContent(content).replace(/\s+/g, " ").trim();
 }
@@ -42148,10 +42233,37 @@ function buildIncrementalHistoryAppendMessages(previousMessages, currentMessages
   if (sharedPrefixLength === previousMessages.length) return currentMessages.slice(sharedPrefixLength);
   return currentMessages;
 }
+
+// src/providers/cli-provider-status-helpers.ts
+import * as path27 from "path";
+import { createRequire as createRequire2 } from "module";
+function isIdleStatus(value) {
+  const status = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return !status || status === "idle" || status === "ready";
+}
+function getMessageTime(message) {
+  if (!message || typeof message !== "object") return 0;
+  const record = message;
+  const value = Number(record.receivedAt ?? record.timestamp ?? 0);
+  return Number.isFinite(value) ? value : 0;
+}
+function hasNonEmptyCliModalButtons(activeModal) {
+  const buttons = activeModal?.buttons;
+  return Array.isArray(buttons) && buttons.some((button) => String(button || "").trim().length > 0);
+}
+function isCliGeneratingLikeStatus(status) {
+  return status === "generating" || status === "streaming" || status === "no_progress" || status === "long_generating" || status === "starting";
+}
+function computeTurnAnchoredDurationMs(engineTurnStartedAt, generatingStartedAt, now) {
+  const engineStart = typeof engineTurnStartedAt === "number" && Number.isFinite(engineTurnStartedAt) ? engineTurnStartedAt : 0;
+  if (engineStart > 0) return { durationMs: now - engineStart, anchor: "turn-start" };
+  if (generatingStartedAt > 0) return { durationMs: now - generatingStartedAt, anchor: "generatingStartedAt" };
+  return { durationMs: 0, anchor: "none" };
+}
 var CachedDatabaseSync = null;
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof __require === "function" ? __require : createRequire2(path26.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof __require === "function" ? __require : createRequire2(path27.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -42193,13 +42305,26 @@ async function waitForCliAdapterReady(adapter, options) {
   }
   throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
 }
+
+// src/providers/cli-provider-instance.ts
+var STATUS_HYDRATION_TAIL_LIMIT = 200;
+var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
+var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
+var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4e3;
+var USER_INPUT_ACK_DEDUP_WINDOW_MS = 6e4;
+var STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12e3;
+var TERMINAL_MESH_EVENTS = /* @__PURE__ */ new Set([
+  "agent:generating_completed",
+  "agent:stopped",
+  "agent:ready"
+]);
 var CliProviderInstance = class _CliProviderInstance {
   constructor(provider, workingDir, cliArgs = [], instanceId, transportFactory, options) {
     this.provider = provider;
     this.workingDir = workingDir;
     this.cliArgs = cliArgs;
     this.type = provider.type;
-    this.instanceId = instanceId || crypto4.randomUUID();
+    this.instanceId = instanceId || crypto5.randomUUID();
     this.presentationMode = "chat";
     this.providerSessionId = options?.providerSessionId;
     this.launchMode = options?.launchMode || "new";
@@ -42239,6 +42364,33 @@ var CliProviderInstance = class _CliProviderInstance {
    * from scratch rather than firing on a stale timestamp.
    */
   static AUTO_APPROVE_GATE_HYSTERESIS_MS = 1500;
+  /**
+   * AUTOAPPROVE-FLAP-RECUR (Fix B): extended busy-side continuity window for a
+   * DELEGATED-WORKER auto-approve episode that is genuinely still cycling.
+   *
+   * The default AUTO_APPROVE_GATE_HYSTERESIS_MS (1500) absorbs a *momentary*
+   * `generating` blip. But a delegated worker running a Bash approval observed
+   * the FSM cycle the FULL state waiting_approval → busy → waiting_approval on a
+   * 2–5s period (the button set scrolls in/out AND the modal question repaints,
+   * so the adapter genuinely reports status=generating for whole seconds between
+   * approval frames). Each busy phase outran the 1500ms hysteresis, so the
+   * settle clock was WIPED (the genuine-resolution branch), the 600ms settle
+   * window never accumulated across the flap, resolveModal never fired
+   * (resolveModal count 0), and the mask-stall clock instead tripped at 4500ms →
+   * coordinator nudge → the flap the coordinator observed.
+   *
+   * A genuine resolution and a flap both start with a busy phase; they diverge
+   * only in whether waiting_approval RETURNS. So we cannot simply lengthen the
+   * blanket hysteresis (that would make every real resolution hold the gate
+   * open for seconds). Instead this longer window applies ONLY while an active
+   * mask episode is alive (autoApproveMaskSince > 0) AND the session is a
+   * delegated worker — i.e. exactly the never-resolving-flap case. A foreground
+   * / attended session keeps the tight 1500ms window unchanged. The mask-stall
+   * bound below still caps the episode, so a worker whose approval truly never
+   * returns is surfaced to the coordinator within AUTO_APPROVE_MASK_STALL_MS
+   * rather than held forever.
+   */
+  static AUTO_APPROVE_FLAP_CONTINUITY_MS = 4e3;
   /**
    * STATUS-MISMATCH: upper bound on how long the auto-approve→`generating` SURFACE
    * mask may hide a worker's `waiting_approval` (status + activeModal) before we give
@@ -42313,9 +42465,22 @@ var CliProviderInstance = class _CliProviderInstance {
   pendingAutoApprovalSince = 0;
   autoApproveSettleTimer = null;
   // Wall-clock when auto-approve first observed status!=waiting_approval while
-  // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
+  // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS (or,
+  // for a delegated-worker flap episode, AUTO_APPROVE_FLAP_CONTINUITY_MS) so a
   // brief generating flip does not immediately wipe the settle clock.
   autoApproveInactiveSince = 0;
+  // AUTOAPPROVE-FLAP-RECUR (Fix A): wall-clock when the CURRENT waiting_approval
+  // episode last presented a concrete, captured modal (buttons.length > 0). The
+  // Claude TUI momentarily reports status=waiting_approval with activeModal=null
+  // / an empty button block while the button block scrolls out of the captured
+  // frame; the raw guard below (buttons.length===0) used to bail on that frame,
+  // never advancing the settle gate and leaving no re-check armed — so a modal
+  // that flapped modal=none ↔ N-buttons around the settle boundary never
+  // accumulated its 600ms. This tracks the last GOOD-modal frame so a short
+  // scroll-out blip is absorbed (settle keeps running against the last captured
+  // signature) while a genuinely closed modal — buttons empty continuously past
+  // the continuity window — is still recognised and resets the gate.
+  autoApproveLastModalSeenAt = 0;
   // STATUS-MISMATCH: wall-clock when the CURRENT auto-approve episode (waiting_approval
   // + shouldAutoApprove) first began wanting to mask. Unlike pendingAutoApprovalSince it
   // is NOT reset when the modal signature changes (a still-streaming/flapping prompt) and
@@ -42425,10 +42590,10 @@ var CliProviderInstance = class _CliProviderInstance {
    * Replaces the previously duplicated probeOpenCode/Codex/Goose functions.
    */
   probeSessionIdFromConfig(probe) {
-    const resolvedDbPath = probe.dbPath.replace(/^~/, os20.homedir());
+    const resolvedDbPath = probe.dbPath.replace(/^~/, os21.homedir());
     const now = Date.now();
     if (this.cachedSqliteDbMissingUntil > now) return null;
-    if (!fs19.existsSync(resolvedDbPath)) {
+    if (!fs20.existsSync(resolvedDbPath)) {
       this.cachedSqliteDbMissingUntil = now + 1e4;
       return null;
     }
@@ -43024,7 +43189,7 @@ var CliProviderInstance = class _CliProviderInstance {
     if (!isNativeSourceCanonicalHistory(this.provider.nativeHistory)) return null;
     if (this.lastExternalCompletionProbe?.sourcePath) {
       try {
-        fs19.statSync(this.lastExternalCompletionProbe.sourcePath);
+        fs20.statSync(this.lastExternalCompletionProbe.sourcePath);
       } catch {
       }
     }
@@ -43278,6 +43443,20 @@ var CliProviderInstance = class _CliProviderInstance {
   isMeshWorkerSession() {
     return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.meshNodeId || this.settings.launchedByCoordinator);
   }
+  /**
+   * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
+   * persist before the in-progress settle gate is torn down. For a delegated
+   * worker whose auto-approve episode is genuinely still cycling (mask clock
+   * alive), the FSM's full waiting_approval → busy → waiting_approval flap runs
+   * on a multi-second period, so the settle continuity window is extended to
+   * AUTO_APPROVE_FLAP_CONTINUITY_MS to bridge it (still bounded, and still capped
+   * by AUTO_APPROVE_MASK_STALL_MS). Every other case — foreground/attended
+   * session, or no active mask episode — keeps the tight default hysteresis so a
+   * genuine resolution frees the gate promptly.
+   */
+  autoApproveContinuityWindowMs() {
+    return this.autoApproveMaskSince > 0 && this.isMeshWorkerSession() ? _CliProviderInstance.AUTO_APPROVE_FLAP_CONTINUITY_MS : _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS;
+  }
   // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
   // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
   // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
@@ -43513,6 +43692,7 @@ var CliProviderInstance = class _CliProviderInstance {
       this.autoApproveInactiveSince = 0;
       this.autoApproveMaskSince = 0;
       this.stalledApprovalNudgeEpisode = 0;
+      this.autoApproveLastModalSeenAt = 0;
       if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
       this.autoApproveSettleTimer = setTimeout(() => {
         this.autoApproveSettleTimer = null;
@@ -43526,12 +43706,13 @@ var CliProviderInstance = class _CliProviderInstance {
       if (this.pendingAutoApprovalSince) {
         if (!this.autoApproveInactiveSince) this.autoApproveInactiveSince = now;
         const goneForMs = now - this.autoApproveInactiveSince;
-        if (goneForMs < _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS) {
+        const continuityMs = this.autoApproveContinuityWindowMs();
+        if (goneForMs < continuityMs) {
           if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
           this.autoApproveSettleTimer = setTimeout(() => {
             this.autoApproveSettleTimer = null;
             this.recheckAutoApproveSettled();
-          }, _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS - goneForMs + 20);
+          }, continuityMs - goneForMs + 20);
           return autoApproveActive;
         }
       }
@@ -43540,6 +43721,7 @@ var CliProviderInstance = class _CliProviderInstance {
       this.autoApproveInactiveSince = 0;
       this.autoApproveMaskSince = 0;
       this.stalledApprovalNudgeEpisode = 0;
+      this.autoApproveLastModalSeenAt = 0;
       if (this.autoApproveSettleTimer) {
         clearTimeout(this.autoApproveSettleTimer);
         this.autoApproveSettleTimer = null;
@@ -43552,8 +43734,22 @@ var CliProviderInstance = class _CliProviderInstance {
     const modal = adapterStatus.activeModal;
     const buttons = Array.isArray(modal?.buttons) ? modal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
     if (!modal || buttons.length === 0) {
+      const blipForMs = this.autoApproveLastModalSeenAt ? now - this.autoApproveLastModalSeenAt : Infinity;
+      if (this.pendingAutoApprovalSince && blipForMs < this.autoApproveContinuityWindowMs()) {
+        if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+        this.autoApproveSettleTimer = setTimeout(() => {
+          this.autoApproveSettleTimer = null;
+          this.recheckAutoApproveSettled();
+        }, this.autoApproveContinuityWindowMs() - blipForMs + 20);
+        return autoApproveActive;
+      }
+      if (blipForMs >= this.autoApproveContinuityWindowMs()) {
+        this.pendingAutoApprovalSignature = "";
+        this.pendingAutoApprovalSince = 0;
+      }
       return autoApproveActive;
     }
+    this.autoApproveLastModalSeenAt = now;
     const modalKind = typeof modal?.kind === "string" ? modal.kind : "approval";
     if (modalKind !== "approval") {
       return autoApproveActive;
@@ -43597,6 +43793,7 @@ var CliProviderInstance = class _CliProviderInstance {
     this.autoApproveInactiveSince = 0;
     this.autoApproveMaskSince = 0;
     this.stalledApprovalNudgeEpisode = 0;
+    this.autoApproveLastModalSeenAt = 0;
     if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
     this.autoApproveBusyTimer = setTimeout(() => {
       this.autoApproveBusy = false;
@@ -44242,6 +44439,8 @@ ${effect.notification.body || ""}`.trim();
     if (!this.isMeshWorkerSession()) return;
     if (adapterStatus?.status !== "waiting_approval") return;
     if (!this.autoApproveMaskStalled(now)) return;
+    const modalButtons = Array.isArray(adapterStatus.activeModal?.buttons) ? adapterStatus.activeModal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
+    if (this.pendingAutoApprovalSince && modalButtons.length > 0) return;
     if (this.stalledApprovalNudgeEpisode === this.autoApproveMaskSince) return;
     this.stalledApprovalNudgeEpisode = this.autoApproveMaskSince;
     const modal = adapterStatus.activeModal;
@@ -44557,7 +44756,7 @@ ${effect.notification.body || ""}`.trim();
     };
     addDir(this.workingDir);
     try {
-      addDir(fs19.realpathSync.native(this.workingDir));
+      addDir(fs20.realpathSync.native(this.workingDir));
     } catch {
     }
     return Array.from(dirs);
@@ -44596,7 +44795,7 @@ ${effect.notification.body || ""}`.trim();
 // src/providers/acp-provider-instance.ts
 init_contracts2();
 init_provider_input_support();
-import * as path27 from "path";
+import * as path28 from "path";
 import { Readable, Writable } from "stream";
 import { spawn as spawn2 } from "child_process";
 import {
@@ -45389,7 +45588,7 @@ var AcpProviderInstance = class {
         return b.uri ? {
           type: "resource_link",
           uri: b.uri,
-          name: path27.basename(b.uri),
+          name: path28.basename(b.uri),
           mimeType: b.mimeType,
           ...b.transcript ? { description: b.transcript } : {}
         } : { type: "text", text: b.transcript || `[Video attachment: ${b.mimeType}]` };
@@ -45861,11 +46060,11 @@ function shouldRestoreHostedRuntime(record, managerTag) {
 // src/commands/cli-manager.ts
 function isExplicitCommand(command) {
   const trimmed = command.trim();
-  return path28.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+  return path29.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
 }
 function expandExecutable(command) {
   const trimmed = command.trim();
-  return trimmed.startsWith("~") ? path28.join(os21.homedir(), trimmed.slice(1)) : trimmed;
+  return trimmed.startsWith("~") ? path29.join(os22.homedir(), trimmed.slice(1)) : trimmed;
 }
 function commandExists(command) {
   const trimmed = command.trim();
@@ -46010,10 +46209,10 @@ function hasConfigOverride(args, key2) {
   return false;
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
-  const baseDir = path28.join(os21.tmpdir(), "adhdev-delegated-agent-empty-mcp");
+  const baseDir = path29.join(os22.tmpdir(), "adhdev-delegated-agent-empty-mcp");
   mkdirSync13(baseDir, { recursive: true });
-  const workspaceHash = shortHash(path28.resolve(workspace || os21.tmpdir()));
-  const filePath = path28.join(baseDir, `${workspaceHash}.json`);
+  const workspaceHash = shortHash(path29.resolve(workspace || os22.tmpdir()));
+  const filePath = path29.join(baseDir, `${workspaceHash}.json`);
   writeFileSync16(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
@@ -46167,7 +46366,7 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
   if (!supportsExplicitSessionStart(resume)) {
     return { cliArgs: baseArgs, launchMode: "new" };
   }
-  const providerSessionId = crypto5.randomUUID();
+  const providerSessionId = crypto6.randomUUID();
   const newSessionArgs = expandResumeArgs(resume.newSessionArgs, providerSessionId);
   return {
     cliArgs: [...baseArgs || [], ...newSessionArgs || []],
@@ -46351,7 +46550,7 @@ var DaemonCliManager = class {
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
     const trimmed = (workingDir || "").trim();
     if (!trimmed) throw new Error("working directory required");
-    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os21.homedir()) : path28.resolve(trimmed);
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os22.homedir()) : path29.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const rawProvider = this.providerLoader.getByAlias(cliType);
     const provider = rawProvider ? this.providerLoader.resolve(normalizedType) || rawProvider : void 0;
@@ -46362,7 +46561,7 @@ var DaemonCliManager = class {
 Enable and detect this provider from the Machine Providers page before starting a runtime.`
       );
     }
-    const key2 = crypto5.randomUUID();
+    const key2 = crypto6.randomUUID();
     {
       const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
       if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
@@ -47203,13 +47402,13 @@ var cliAgentHandlers = {
 // src/launch.ts
 import { exec as exec4, spawn as spawn3 } from "child_process";
 import * as net from "net";
-import * as os26 from "os";
-import * as path36 from "path";
+import * as os27 from "os";
+import * as path37 from "path";
 
 // src/providers/provider-loader.ts
-import * as fs25 from "fs";
-import * as path35 from "path";
-import * as os25 from "os";
+import * as fs26 from "fs";
+import * as path36 from "path";
+import * as os26 from "os";
 import * as chokidar from "chokidar";
 init_hash();
 init_logger();
@@ -47601,13 +47800,13 @@ function validateControl(control, errors) {
 init_external_sources();
 
 // src/providers/native-history/dispatcher.ts
-import * as fs24 from "fs";
-import * as os24 from "os";
-import * as path33 from "path";
+import * as fs25 from "fs";
+import * as os25 from "os";
+import * as path34 from "path";
 
 // src/providers/native-history/claude-cli-transcript.ts
-import * as fs20 from "fs";
-import * as path29 from "path";
+import * as fs21 from "fs";
+import * as path30 from "path";
 function extractTimestampValue(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
   if (typeof value === "string") {
@@ -47620,7 +47819,7 @@ function extractTimestampValue(value) {
 }
 function statMtimeMs(filePath) {
   try {
-    return fs20.statSync(filePath).mtimeMs;
+    return fs21.statSync(filePath).mtimeMs;
   } catch {
     return 0;
   }
@@ -47690,7 +47889,7 @@ function extractUserContentParts(content) {
 function parseTranscriptFile(filePath, sessionId, workspaceFallback) {
   let raw;
   try {
-    raw = fs20.readFileSync(filePath, "utf-8");
+    raw = fs21.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -47763,10 +47962,10 @@ function parseTranscriptFile(filePath, sessionId, workspaceFallback) {
   return records;
 }
 function readSession(sessionPath) {
-  if (!sessionPath || !path29.isAbsolute(sessionPath)) return null;
-  const basename14 = path29.basename(sessionPath, ".jsonl");
+  if (!sessionPath || !path30.isAbsolute(sessionPath)) return null;
+  const basename14 = path30.basename(sessionPath, ".jsonl");
   if (!isSafeSessionId(basename14)) return null;
-  if (!fs20.existsSync(sessionPath)) return null;
+  if (!fs21.existsSync(sessionPath)) return null;
   const sourceMtimeMs = statMtimeMs(sessionPath);
   const messages = parseTranscriptFile(sessionPath, basename14);
   if (messages.length === 0) return null;
@@ -47784,8 +47983,8 @@ function readSession(sessionPath) {
 }
 
 // src/providers/native-history/codex-cli-transcript.ts
-import * as fs21 from "fs";
-import * as path30 from "path";
+import * as fs22 from "fs";
+import * as path31 from "path";
 function extractTimestampValue2(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
   if (typeof value === "string") {
@@ -47798,7 +47997,7 @@ function extractTimestampValue2(value) {
 }
 function statMtimeMs2(filePath) {
   try {
-    return fs21.statSync(filePath).mtimeMs;
+    return fs22.statSync(filePath).mtimeMs;
   } catch {
     return 0;
   }
@@ -47895,7 +48094,7 @@ function pushAssistantStandardMessage(records, sessionId, receivedAt, content, w
 }
 function readSessionMeta(filePath) {
   try {
-    const firstLine = fs21.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
+    const firstLine = fs22.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
     if (!firstLine) return null;
     const parsed = JSON.parse(firstLine);
     if (String(parsed.type ?? "") !== "session_meta") return null;
@@ -47907,7 +48106,7 @@ function readSessionMeta(filePath) {
 function parseSessionFile(filePath, sessionId, workspaceFallback) {
   let raw;
   try {
-    raw = fs21.readFileSync(filePath, "utf-8");
+    raw = fs22.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -48022,11 +48221,11 @@ function parseSessionFile(filePath, sessionId, workspaceFallback) {
   return records;
 }
 function readSession2(sessionPath) {
-  if (!sessionPath || !path30.isAbsolute(sessionPath)) return null;
-  if (!fs21.existsSync(sessionPath)) return null;
+  if (!sessionPath || !path31.isAbsolute(sessionPath)) return null;
+  if (!fs22.existsSync(sessionPath)) return null;
   const meta = readSessionMeta(sessionPath);
   const metaId = String(meta?.id ?? "").trim();
-  const basename14 = path30.basename(sessionPath, ".jsonl");
+  const basename14 = path31.basename(sessionPath, ".jsonl");
   const uuidMatch = basename14.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
   const filenameUuid2 = uuidMatch ? uuidMatch[1] : "";
   if (metaId && filenameUuid2 && metaId !== filenameUuid2) return null;
@@ -48052,9 +48251,9 @@ function readSession2(sessionPath) {
 // src/providers/native-history/antigravity-cli-transcript.ts
 init_load_better_sqlite3();
 init_logger();
-import * as fs22 from "fs";
-import * as path31 from "path";
-import * as os22 from "os";
+import * as fs23 from "fs";
+import * as path32 from "path";
+import * as os23 from "os";
 function extractTimestampValue3(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
   if (typeof value === "string") {
@@ -48067,7 +48266,7 @@ function extractTimestampValue3(value) {
 }
 function statMtimeMs3(filePath) {
   try {
-    return fs22.statSync(filePath).mtimeMs;
+    return fs23.statSync(filePath).mtimeMs;
   } catch {
     return 0;
   }
@@ -48076,13 +48275,13 @@ function isUuidLike(value) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
 function antigravityRoot() {
-  return path31.join(os22.homedir(), ".gemini", "antigravity-cli");
+  return path32.join(os23.homedir(), ".gemini", "antigravity-cli");
 }
 function historyJsonlPath() {
-  return path31.join(antigravityRoot(), "history.jsonl");
+  return path32.join(antigravityRoot(), "history.jsonl");
 }
 function brainRoot() {
-  return path31.join(antigravityRoot(), "brain");
+  return path32.join(antigravityRoot(), "brain");
 }
 function extractUserRequestContent(content) {
   const raw = content.trim();
@@ -48098,7 +48297,7 @@ function antigravityRowKind(rowType) {
 function parseBrainTranscript(filePath, sessionId, workspace) {
   let raw;
   try {
-    raw = fs22.readFileSync(filePath, "utf-8");
+    raw = fs23.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -48158,7 +48357,7 @@ function readHistoryRows() {
   const sourcePath = historyJsonlPath();
   let lines = [];
   try {
-    lines = fs22.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
+    lines = fs23.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -48206,7 +48405,7 @@ function extractStringsFromBuffer(buf) {
 function parsePbFile(filePath, sessionId) {
   let buf;
   try {
-    buf = fs22.readFileSync(filePath);
+    buf = fs23.readFileSync(filePath);
   } catch {
     return null;
   }
@@ -48376,7 +48575,7 @@ function parseConversationDb(filePath, sessionId, workspace) {
   } catch (err) {
     LOG.warn(
       "NativeHistory",
-      `antigravity .db reader could not load better-sqlite3 for ${path31.basename(filePath)}: ${err instanceof Error ? err.message : String(err)} (native binding unavailable \u2014 assistant answers in this .db will not surface)`
+      `antigravity .db reader could not load better-sqlite3 for ${path32.basename(filePath)}: ${err instanceof Error ? err.message : String(err)} (native binding unavailable \u2014 assistant answers in this .db will not surface)`
     );
     return null;
   }
@@ -48406,13 +48605,13 @@ function parseConversationDb(filePath, sessionId, workspace) {
         }
         LOG.warn(
           "NativeHistory",
-          `antigravity .db ${path31.basename(filePath)} stayed locked (SQLITE_BUSY) after ${AGY_DB_MAX_ATTEMPTS} attempts: ${err instanceof Error ? err.message : String(err)} (WAL write/checkpoint lock contention \u2014 assistant answers may transiently not surface this read)`
+          `antigravity .db ${path32.basename(filePath)} stayed locked (SQLITE_BUSY) after ${AGY_DB_MAX_ATTEMPTS} attempts: ${err instanceof Error ? err.message : String(err)} (WAL write/checkpoint lock contention \u2014 assistant answers may transiently not surface this read)`
         );
         return null;
       }
       LOG.debug(
         "NativeHistory",
-        `antigravity .db ${path31.basename(filePath)} not readable: ${err instanceof Error ? err.message : String(err)}`
+        `antigravity .db ${path32.basename(filePath)} not readable: ${err instanceof Error ? err.message : String(err)}`
       );
       return null;
     } finally {
@@ -48439,12 +48638,12 @@ function parseConversationDb(filePath, sessionId, workspace) {
           content = recovered;
           LOG.debug(
             "NativeHistory",
-            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}): user prompt absent at field 19; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
+            `antigravity .db ${path32.basename(filePath)} step ${row.idx} (type ${row.step_type}): user prompt absent at field 19; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
           );
         } else {
           LOG.debug(
             "NativeHistory",
-            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no user prompt text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}])`
+            `antigravity .db ${path32.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no user prompt text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}])`
           );
           continue;
         }
@@ -48469,12 +48668,12 @@ function parseConversationDb(filePath, sessionId, workspace) {
           content = recovered;
           LOG.debug(
             "NativeHistory",
-            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}): answer absent at field 20; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
+            `antigravity .db ${path32.basename(filePath)} step ${row.idx} (type ${row.step_type}): answer absent at field 20; recovered ${content.length} chars via printable-run fallback \u2014 possible step_payload schema drift`
           );
         } else {
           LOG.debug(
             "NativeHistory",
-            `antigravity .db ${path31.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no answer text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}], reasoningOnly=${reasoning ? "yes" : "no"})`
+            `antigravity .db ${path32.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no answer text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(",")}], reasoningOnly=${reasoning ? "yes" : "no"})`
           );
           continue;
         }
@@ -48495,13 +48694,13 @@ function parseConversationDb(filePath, sessionId, workspace) {
   return messages.length > 0 ? messages : null;
 }
 function readSession3(sessionPath, sessionId, workspace) {
-  if (!sessionPath || !path31.isAbsolute(sessionPath)) return null;
-  if (!fs22.existsSync(sessionPath)) return null;
+  if (!sessionPath || !path32.isAbsolute(sessionPath)) return null;
+  if (!fs23.existsSync(sessionPath)) return null;
   const sourceMtimeMs = statMtimeMs3(sessionPath);
   const brainRootPath = brainRoot();
-  if (sessionPath.startsWith(brainRootPath + path31.sep) && sessionPath.endsWith(".jsonl")) {
+  if (sessionPath.startsWith(brainRootPath + path32.sep) && sessionPath.endsWith(".jsonl")) {
     const relative5 = sessionPath.slice(brainRootPath.length + 1);
-    const uuidFromPath = relative5.split(path31.sep)[0];
+    const uuidFromPath = relative5.split(path32.sep)[0];
     const resolvedSessionId = sessionId || (isUuidLike(uuidFromPath) ? uuidFromPath : "");
     if (!resolvedSessionId) return null;
     const messages = parseBrainTranscript(sessionPath, resolvedSessionId, workspace);
@@ -48517,7 +48716,7 @@ function readSession3(sessionPath, sessionId, workspace) {
     };
   }
   if (sessionPath.endsWith(".db")) {
-    const dbSessionId = sessionId || path31.basename(sessionPath, ".db");
+    const dbSessionId = sessionId || path32.basename(sessionPath, ".db");
     if (!isUuidLike(dbSessionId)) return null;
     const messages = parseConversationDb(sessionPath, dbSessionId, workspace);
     if (!messages || messages.length === 0) return null;
@@ -48532,7 +48731,7 @@ function readSession3(sessionPath, sessionId, workspace) {
     };
   }
   if (sessionPath.endsWith(".pb")) {
-    const pbSessionId = sessionId || path31.basename(sessionPath, ".pb");
+    const pbSessionId = sessionId || path32.basename(sessionPath, ".pb");
     if (!isUuidLike(pbSessionId)) return null;
     const messages = parsePbFile(sessionPath, pbSessionId);
     if (!messages || messages.length === 0) return null;
@@ -48546,7 +48745,7 @@ function readSession3(sessionPath, sessionId, workspace) {
       partialReason: "antigravity_cli_pb_raw_text_extraction"
     };
   }
-  if (path31.basename(sessionPath) === "history.jsonl") {
+  if (path32.basename(sessionPath) === "history.jsonl") {
     const resolvedSessionId = sessionId || "";
     if (!resolvedSessionId || !isUuidLike(resolvedSessionId)) return null;
     const rows = readHistoryRows().filter((r) => r.conversationId === resolvedSessionId);
@@ -48594,20 +48793,20 @@ function readSession3(sessionPath, sessionId, workspace) {
 
 // src/providers/native-history/hermes-cli-transcript.ts
 init_load_better_sqlite3();
-import * as fs23 from "fs";
-import * as path32 from "path";
-import * as os23 from "os";
-var HERMES_STATE_DB = path32.join(os23.homedir(), ".hermes", "state.db");
-var HERMES_LEGACY_SESSIONS_DIR = path32.join(os23.homedir(), ".hermes", "sessions");
+import * as fs24 from "fs";
+import * as path33 from "path";
+import * as os24 from "os";
+var HERMES_STATE_DB = path33.join(os24.homedir(), ".hermes", "state.db");
+var HERMES_LEGACY_SESSIONS_DIR = path33.join(os24.homedir(), ".hermes", "sessions");
 function statMtimeMs4(p) {
   try {
-    return Math.floor(fs23.statSync(p).mtimeMs);
+    return Math.floor(fs24.statSync(p).mtimeMs);
   } catch {
     return 0;
   }
 }
 function openDb() {
-  if (!fs23.existsSync(HERMES_STATE_DB)) return null;
+  if (!fs24.existsSync(HERMES_STATE_DB)) return null;
   try {
     const Database = loadBetterSqlite3();
     return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
@@ -48703,10 +48902,10 @@ function readSession4(sessionPath, requestedSessionId) {
       }
     }
   }
-  if (!path32.isAbsolute(sessionPath) || !fs23.existsSync(sessionPath)) return null;
+  if (!path33.isAbsolute(sessionPath) || !fs24.existsSync(sessionPath)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs23.readFileSync(sessionPath, "utf8"));
+    raw = JSON.parse(fs24.readFileSync(sessionPath, "utf8"));
   } catch {
     return null;
   }
@@ -48729,7 +48928,7 @@ function readSession4(sessionPath, requestedSessionId) {
     });
   }
   if (messages.length === 0) return null;
-  const sessionId = typeof raw.session_id === "string" && raw.session_id ? raw.session_id : path32.basename(sessionPath, ".json").replace(/^session_/, "");
+  const sessionId = typeof raw.session_id === "string" && raw.session_id ? raw.session_id : path33.basename(sessionPath, ".json").replace(/^session_/, "");
   return {
     messages,
     providerSessionId: sessionId,
@@ -48759,7 +48958,7 @@ function createNativeHistoryDispatcher(reader) {
     if (!sourcePath) return null;
     if (input.forceRefresh === true || input.args?.forceRefresh === true) {
       try {
-        fs24.statSync(sourcePath);
+        fs25.statSync(sourcePath);
       } catch {
       }
     }
@@ -48796,11 +48995,11 @@ function resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs, ins
   }
 }
 function resolveClaudePath(workspace, sessionId) {
-  const dir = path33.join(os24.homedir(), ".claude", "projects", cwdAsDashes(workspace));
-  if (!fs24.existsSync(dir)) return null;
+  const dir = path34.join(os25.homedir(), ".claude", "projects", cwdAsDashes(workspace));
+  if (!fs25.existsSync(dir)) return null;
   if (sessionId) {
-    const candidate = path33.join(dir, `${sessionId}.jsonl`);
-    if (fs24.existsSync(candidate)) return candidate;
+    const candidate = path34.join(dir, `${sessionId}.jsonl`);
+    if (fs25.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -48812,7 +49011,7 @@ function resolveCodexPath(workspace, sessionId, sessionStartedAtMs) {
   return findCodexPathByRuntime(root, workspace, sessionStartedAtMs);
 }
 function findCodexPathBySessionId(root, sessionId) {
-  if (!fs24.existsSync(root)) return null;
+  if (!fs25.existsSync(root)) return null;
   const needle = sessionId.toLowerCase();
   const matches = [];
   const stack = [root];
@@ -48820,12 +49019,12 @@ function findCodexPathBySessionId(root, sessionId) {
     const current = stack.pop();
     let entries = [];
     try {
-      entries = fs24.readdirSync(current, { withFileTypes: true });
+      entries = fs25.readdirSync(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path33.join(current, entry.name);
+      const entryPath = path34.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(entryPath);
         continue;
@@ -48840,7 +49039,7 @@ function findCodexPathBySessionId(root, sessionId) {
   return matches[0]?.p ?? null;
 }
 function findCodexPathByRuntime(root, workspace, sessionStartedAtMs) {
-  if (!fs24.existsSync(root) || !workspace) return null;
+  if (!fs25.existsSync(root) || !workspace) return null;
   const workspaceResolved = resolveRealPath(workspace);
   const cutoff = Date.now() - RECENT_WINDOW_MS;
   const matches = [];
@@ -48849,12 +49048,12 @@ function findCodexPathByRuntime(root, workspace, sessionStartedAtMs) {
     const current = stack.pop();
     let entries = [];
     try {
-      entries = fs24.readdirSync(current, { withFileTypes: true });
+      entries = fs25.readdirSync(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = path33.join(current, entry.name);
+      const entryPath = path34.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(entryPath);
         continue;
@@ -48874,10 +49073,10 @@ function findCodexPathByRuntime(root, workspace, sessionStartedAtMs) {
 }
 function readCodexSessionMeta(filePath) {
   try {
-    const fd = fs24.openSync(filePath, "r");
+    const fd = fs25.openSync(filePath, "r");
     try {
       const buffer = Buffer.alloc(8192);
-      const bytes = fs24.readSync(fd, buffer, 0, buffer.length, 0);
+      const bytes = fs25.readSync(fd, buffer, 0, buffer.length, 0);
       if (bytes <= 0) return null;
       const text = buffer.subarray(0, bytes).toString("utf8");
       const firstLine = text.slice(0, text.indexOf("\n") >= 0 ? text.indexOf("\n") : text.length).trim();
@@ -48892,7 +49091,7 @@ function readCodexSessionMeta(filePath) {
         timestampMs: Number.isFinite(timestampMs) ? timestampMs : void 0
       };
     } finally {
-      fs24.closeSync(fd);
+      fs25.closeSync(fd);
     }
   } catch {
     return null;
@@ -48900,35 +49099,35 @@ function readCodexSessionMeta(filePath) {
 }
 function resolveRealPath(value) {
   try {
-    return fs24.realpathSync(value);
+    return fs25.realpathSync(value);
   } catch {
     return value;
   }
 }
 var AGY_SPAWN_CLAIM_GRACE_MS = 2e3;
 function resolveAntigravityPath(workspace, sessionId, sessionStartedAtMs, instanceId) {
-  const agyRoot = path33.join(os24.homedir(), ".gemini", "antigravity-cli");
+  const agyRoot = path34.join(os25.homedir(), ".gemini", "antigravity-cli");
   const owner = antigravityOwnerToken(workspace, sessionStartedAtMs, instanceId);
   if (sessionId && isUuidLikeSessionId2(sessionId)) {
-    const dbPath = path33.join(agyRoot, "conversations", `${sessionId}.db`);
-    if (fs24.existsSync(dbPath)) {
+    const dbPath = path34.join(agyRoot, "conversations", `${sessionId}.db`);
+    if (fs25.existsSync(dbPath)) {
       if (owner) claimAntigravityConversation(sessionId, owner);
       return dbPath;
     }
   }
-  const brainRoot2 = path33.join(agyRoot, "brain");
-  if (fs24.existsSync(brainRoot2)) {
+  const brainRoot2 = path34.join(agyRoot, "brain");
+  if (fs25.existsSync(brainRoot2)) {
     const cutoff = spawnAwareCutoff(sessionStartedAtMs);
-    const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => ({ uuid: e.name, p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+    const entries = fs25.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => ({ uuid: e.name, p: path34.join(brainRoot2, e.name), mtime: safeMtime(path34.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
     for (const e of entries) {
-      const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
-      if (fs24.existsSync(t) && safeSize(t) > 0) {
+      const t = path34.join(e.p, ".system_generated", "logs", "transcript.jsonl");
+      if (fs25.existsSync(t) && safeSize(t) > 0) {
         if (owner) claimAntigravityConversation(e.uuid, owner);
         return t;
       }
     }
   }
-  const convRoot = path33.join(agyRoot, "conversations");
+  const convRoot = path34.join(agyRoot, "conversations");
   const picked = pickUnboundConversationDb(convRoot, sessionStartedAtMs, owner);
   if (picked) {
     if (owner) claimAntigravityConversation(picked.uuid, owner);
@@ -48939,7 +49138,7 @@ function resolveAntigravityPath(workspace, sessionId, sessionStartedAtMs, instan
 function pickUnboundConversationDb(convRoot, sessionFloorMs, owner) {
   let entries = [];
   try {
-    entries = fs24.readdirSync(convRoot, { withFileTypes: true });
+    entries = fs25.readdirSync(convRoot, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -48951,7 +49150,7 @@ function pickUnboundConversationDb(convRoot, sessionFloorMs, owner) {
     if (!match || !isUuidLikeSessionId2(match[1])) continue;
     const uuid = match[1];
     if (isAntigravityConversationClaimedByOther(uuid, owner)) continue;
-    const p = path33.join(convRoot, entry.name);
+    const p = path34.join(convRoot, entry.name);
     const mtime = safeMtime(p);
     if (mtime < recencyCutoff) continue;
     candidates.push({ path: p, uuid, mtime, birth: safeBirthtime(p) });
@@ -48975,10 +49174,10 @@ function spawnAwareCutoff(sessionStartedAtMs) {
 function resolveHermesPath(workspace, sessionId) {
   void workspace;
   void sessionId;
-  const dbPath = path33.join(os24.homedir(), ".hermes", "state.db");
-  if (fs24.existsSync(dbPath)) return dbPath;
-  const dir = path33.join(os24.homedir(), ".hermes", "sessions");
-  if (!fs24.existsSync(dir)) return null;
+  const dbPath = path34.join(os25.homedir(), ".hermes", "state.db");
+  if (fs25.existsSync(dbPath)) return dbPath;
+  const dir = path34.join(os25.homedir(), ".hermes", "sessions");
+  if (!fs25.existsSync(dir)) return null;
   return newestRecentFile2(dir, /^session_.*\.json$/);
 }
 function readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid) {
@@ -49003,7 +49202,7 @@ function cwdAsDashes(cwd) {
   return cwd.replace(/\//g, "-");
 }
 function codexSessionsRoot() {
-  return path33.join(os24.homedir(), ".codex", "sessions");
+  return path34.join(os25.homedir(), ".codex", "sessions");
 }
 function isUuidLikeSessionId2(sessionId) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
@@ -49015,7 +49214,7 @@ var RECENT_WINDOW_MS = 5 * 60 * 1e3;
 function newestRecentFile2(dir, pattern) {
   try {
     const cutoff = Date.now() - RECENT_WINDOW_MS;
-    const entries = fs24.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path33.join(dir, e.name), mtime: safeMtime(path33.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+    const entries = fs25.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path34.join(dir, e.name), mtime: safeMtime(path34.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
     return entries[0]?.p ?? null;
   } catch {
     return null;
@@ -49023,14 +49222,14 @@ function newestRecentFile2(dir, pattern) {
 }
 function safeMtime(p) {
   try {
-    return Math.floor(fs24.statSync(p).mtimeMs);
+    return Math.floor(fs25.statSync(p).mtimeMs);
   } catch {
     return 0;
   }
 }
 function safeBirthtime(p) {
   try {
-    const st = fs24.statSync(p);
+    const st = fs25.statSync(p);
     const birth = Math.floor(st.birthtimeMs);
     return birth > 0 ? birth : Math.floor(st.mtimeMs);
   } catch {
@@ -49039,7 +49238,7 @@ function safeBirthtime(p) {
 }
 function safeSize(p) {
   try {
-    return fs24.statSync(p).size;
+    return fs25.statSync(p).size;
   } catch {
     return 0;
   }
@@ -49133,9 +49332,9 @@ var ProviderLoader = class _ProviderLoader {
   static siblingStderrLogged = /* @__PURE__ */ new Set();
   static looksLikeProviderRoot(candidate) {
     try {
-      if (!fs25.existsSync(candidate) || !fs25.statSync(candidate).isDirectory()) return false;
+      if (!fs26.existsSync(candidate) || !fs26.statSync(candidate).isDirectory()) return false;
       return ["ide", "extension", "cli", "acp"].some(
-        (category) => fs25.existsSync(path35.join(candidate, category))
+        (category) => fs26.existsSync(path36.join(candidate, category))
       );
     } catch {
       return false;
@@ -49143,20 +49342,20 @@ var ProviderLoader = class _ProviderLoader {
   }
   static hasProviderRootMarker(candidate) {
     try {
-      return fs25.existsSync(path35.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+      return fs26.existsSync(path36.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
     } catch {
       return false;
     }
   }
   detectDefaultUserDir() {
-    const fallback = path35.join(os25.homedir(), ".adhdev", "providers");
+    const fallback = path36.join(os26.homedir(), ".adhdev", "providers");
     const envOptIn = process.env[_ProviderLoader.SIBLING_ENV_VAR] === "1";
     const visited = /* @__PURE__ */ new Set();
     for (const start of this.probeStarts) {
-      let current = path35.resolve(start);
+      let current = path36.resolve(start);
       while (!visited.has(current)) {
         visited.add(current);
-        const siblingCandidate = path35.join(path35.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
+        const siblingCandidate = path36.join(path36.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
         if (_ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
           const hasMarker = _ProviderLoader.hasProviderRootMarker(siblingCandidate);
           if (envOptIn || hasMarker) {
@@ -49178,7 +49377,7 @@ var ProviderLoader = class _ProviderLoader {
             return { path: siblingCandidate, source };
           }
         }
-        const parent = path35.dirname(current);
+        const parent = path36.dirname(current);
         if (parent === current) break;
         current = parent;
       }
@@ -49190,11 +49389,11 @@ var ProviderLoader = class _ProviderLoader {
     this.probeStarts = options?.probeStarts ?? [process.cwd(), __dirname];
     this.registryBaseUrl = resolveRegistryBaseUrl(options?.registryUrl);
     this.providerTarballUrl = resolveProviderTarballUrl(options?.providerTarballUrl);
-    this.defaultProvidersDir = path35.join(os25.homedir(), ".adhdev", "providers");
+    this.defaultProvidersDir = path36.join(os26.homedir(), ".adhdev", "providers");
     const detected = this.detectDefaultUserDir();
     this.userDir = detected.path;
     this.userDirSource = detected.source;
-    this.upstreamDir = path35.join(this.defaultProvidersDir, ".upstream");
+    this.upstreamDir = path36.join(this.defaultProvidersDir, ".upstream");
     this.disableUpstream = false;
     this.applySourceConfig({
       userDir: options?.userDir,
@@ -49205,15 +49404,15 @@ var ProviderLoader = class _ProviderLoader {
   }
   migrateMarketplaceDirToExternal() {
     try {
-      const home = os25.homedir();
-      const oldDir = path35.join(home, ".adhdev", "marketplace");
-      const newDir = path35.join(home, ".adhdev", "external");
-      if (!fs25.existsSync(oldDir)) return;
-      if (fs25.existsSync(newDir)) {
+      const home = os26.homedir();
+      const oldDir = path36.join(home, ".adhdev", "marketplace");
+      const newDir = path36.join(home, ".adhdev", "external");
+      if (!fs26.existsSync(oldDir)) return;
+      if (fs26.existsSync(newDir)) {
         this.log(`Migration skipped: both ~/.adhdev/marketplace and ~/.adhdev/external exist (marketplace dir is now inert and can be removed manually).`);
         return;
       }
-      fs25.renameSync(oldDir, newDir);
+      fs26.renameSync(oldDir, newDir);
       this.log(`Migrated ~/.adhdev/marketplace \u2192 ~/.adhdev/external (one-time rename after provider source-layer cleanup).`);
     } catch (e) {
       this.log(`Marketplace\u2192external migration failed: ${e?.message || e}`);
@@ -49243,7 +49442,7 @@ var ProviderLoader = class _ProviderLoader {
    * Highest-priority editable overrides come first.
    */
   getProviderRoots() {
-    const externalDir = path35.join(os25.homedir(), ".adhdev", "external");
+    const externalDir = path36.join(os26.homedir(), ".adhdev", "external");
     return [this.userDir, externalDir, this.upstreamDir];
   }
   getSourceConfig() {
@@ -49271,7 +49470,7 @@ var ProviderLoader = class _ProviderLoader {
       this.userDir = detected.path;
       this.userDirSource = detected.source;
     }
-    this.upstreamDir = path35.join(this.defaultProvidersDir, ".upstream");
+    this.upstreamDir = path36.join(this.defaultProvidersDir, ".upstream");
     this.disableUpstream = this.sourceMode === "no-upstream";
     if (this.explicitProviderDir) {
       this.log(`Config 'providerDir' applied: ${this.userDir}`);
@@ -49285,7 +49484,7 @@ var ProviderLoader = class _ProviderLoader {
   * Canonical provider directory shape for a given root.
   */
   getProviderDir(root, category, type) {
-    return path35.join(root, category, type);
+    return path36.join(root, category, type);
   }
   /**
   * Canonical user override directory for a provider.
@@ -49312,7 +49511,7 @@ var ProviderLoader = class _ProviderLoader {
   resolveProviderFile(type, ...segments) {
     const dir = this.findProviderDirInternal(type);
     if (!dir) return null;
-    return path35.join(dir, ...segments);
+    return path36.join(dir, ...segments);
   }
   /**
   * Load all providers (3-tier priority)
@@ -49328,7 +49527,7 @@ var ProviderLoader = class _ProviderLoader {
     this.providers.clear();
     this.providerAvailability.clear();
     let upstreamCount = 0;
-    if (!this.disableUpstream && fs25.existsSync(this.upstreamDir)) {
+    if (!this.disableUpstream && fs26.existsSync(this.upstreamDir)) {
       upstreamCount = this.loadDir(this.upstreamDir);
       if (upstreamCount > 0) {
         this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
@@ -49336,11 +49535,11 @@ var ProviderLoader = class _ProviderLoader {
     } else if (this.disableUpstream) {
       this.log("Upstream loading disabled (sourceMode=no-upstream)");
     }
-    const externalDir = path35.join(os25.homedir(), ".adhdev", "external");
-    if (fs25.existsSync(externalDir)) {
+    const externalDir = path36.join(os26.homedir(), ".adhdev", "external");
+    if (fs26.existsSync(externalDir)) {
       const rootEntries = (() => {
         try {
-          return fs25.readdirSync(externalDir, { withFileTypes: true });
+          return fs26.readdirSync(externalDir, { withFileTypes: true });
         } catch {
           return [];
         }
@@ -49358,7 +49557,7 @@ var ProviderLoader = class _ProviderLoader {
         const ambiguousTypes = [];
         for (const sourceEntry of rootEntries) {
           if (!sourceEntry.isDirectory()) continue;
-          const sourceDir = path35.join(externalDir, sourceEntry.name);
+          const sourceDir = path36.join(externalDir, sourceEntry.name);
           const sourceLoaded = this.loadDir(sourceDir);
           if (sourceLoaded > 0) {
             totalLoaded += sourceLoaded;
@@ -49374,7 +49573,7 @@ var ProviderLoader = class _ProviderLoader {
             ambiguousTypes.push({ type, chosen: resolved.source ?? "?", candidates: resolved.candidates });
           }
           if (resolved.source && resolved.source !== "?") {
-            const sourceDir = path35.join(externalDir, resolved.source);
+            const sourceDir = path36.join(externalDir, resolved.source);
             const reloadCount = this.loadDir(sourceDir);
             if (reloadCount === 0) {
               this.log(`Active source "${resolved.source}" no longer provides ${type}`);
@@ -49389,7 +49588,7 @@ var ProviderLoader = class _ProviderLoader {
         }
       }
     }
-    if (fs25.existsSync(this.userDir)) {
+    if (fs26.existsSync(this.userDir)) {
       const userCount = this.loadDir(this.userDir, [".upstream"]);
       if (userCount > 0) {
         this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -49404,10 +49603,10 @@ var ProviderLoader = class _ProviderLoader {
    * Check if upstream directory exists and has providers.
    */
   hasUpstream() {
-    if (!fs25.existsSync(this.upstreamDir)) return false;
+    if (!fs26.existsSync(this.upstreamDir)) return false;
     try {
-      return fs25.readdirSync(this.upstreamDir).some(
-        (d) => fs25.statSync(path35.join(this.upstreamDir, d)).isDirectory()
+      return fs26.readdirSync(this.upstreamDir).some(
+        (d) => fs26.statSync(path36.join(this.upstreamDir, d)).isDirectory()
       );
     } catch {
       return false;
@@ -49905,8 +50104,8 @@ var ProviderLoader = class _ProviderLoader {
                 resolved._resolvedScriptDir = entry.scriptDir;
                 resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                 if (providerDir) {
-                  const fullDir = path35.join(providerDir, entry.scriptDir);
-                  resolved._resolvedScriptsPath = fs25.existsSync(path35.join(fullDir, "scripts.js")) ? path35.join(fullDir, "scripts.js") : fullDir;
+                  const fullDir = path36.join(providerDir, entry.scriptDir);
+                  resolved._resolvedScriptsPath = fs26.existsSync(path36.join(fullDir, "scripts.js")) ? path36.join(fullDir, "scripts.js") : fullDir;
                 }
                 matched = true;
               }
@@ -49924,8 +50123,8 @@ var ProviderLoader = class _ProviderLoader {
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
             if (providerDir) {
-              const fullDir = path35.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs25.existsSync(path35.join(fullDir, "scripts.js")) ? path35.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path36.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs26.existsSync(path36.join(fullDir, "scripts.js")) ? path36.join(fullDir, "scripts.js") : fullDir;
             }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -49942,8 +50141,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = dirOverride;
               resolved._resolvedScriptsSource = `versions:${range}`;
               if (providerDir) {
-                const fullDir = path35.join(providerDir, dirOverride);
-                resolved._resolvedScriptsPath = fs25.existsSync(path35.join(fullDir, "scripts.js")) ? path35.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path36.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs26.existsSync(path36.join(fullDir, "scripts.js")) ? path36.join(fullDir, "scripts.js") : fullDir;
               }
             }
           } else if (override.scripts) {
@@ -49959,8 +50158,8 @@ var ProviderLoader = class _ProviderLoader {
         resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
         if (providerDir) {
-          const fullDir = path35.join(providerDir, base.defaultScriptDir);
-          resolved._resolvedScriptsPath = fs25.existsSync(path35.join(fullDir, "scripts.js")) ? path35.join(fullDir, "scripts.js") : fullDir;
+          const fullDir = path36.join(providerDir, base.defaultScriptDir);
+          resolved._resolvedScriptsPath = fs26.existsSync(path36.join(fullDir, "scripts.js")) ? path36.join(fullDir, "scripts.js") : fullDir;
         }
       }
     }
@@ -49977,13 +50176,13 @@ var ProviderLoader = class _ProviderLoader {
       if (providerDir2) {
         for (const [scriptName, override] of Object.entries(base.overrides)) {
           if (!override || typeof override.path !== "string") continue;
-          const fullPath = path35.join(providerDir2, override.path);
-          if (!fs25.existsSync(fullPath)) {
+          const fullPath = path36.join(providerDir2, override.path);
+          if (!fs26.existsSync(fullPath)) {
             this.log(`  [overrides] ${base.type}: ${scriptName} path not found: ${fullPath}`);
             continue;
           }
           try {
-            registerProviderScriptRootSafely(path35.dirname(path35.dirname(providerDir2)));
+            registerProviderScriptRootSafely(path36.dirname(path36.dirname(providerDir2)));
             delete __require.cache[__require.resolve(fullPath)];
             const fn = __require(fullPath);
             const target = typeof fn === "function" ? fn : fn && fn[scriptName];
@@ -50008,25 +50207,25 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (providerDir) {
       try {
-        const fs40 = __require("fs");
-        const path44 = __require("path");
+        const fs41 = __require("fs");
+        const path45 = __require("path");
         const candidates = [];
         if (Array.isArray(base.compatibility)) {
           for (const entry of base.compatibility) {
             if (typeof entry?.spec !== "string") continue;
             const matches = !entry.ideVersion || currentVersion && this.matchesVersion(currentVersion, entry.ideVersion) || !currentVersion;
-            if (matches) candidates.push(path44.join(providerDir, entry.spec));
+            if (matches) candidates.push(path45.join(providerDir, entry.spec));
           }
         }
-        candidates.push(path44.join(providerDir, "specs", "default.json"));
-        candidates.push(path44.join(providerDir, "spec.json"));
-        const specPath = candidates.find((p) => fs40.existsSync(p));
+        candidates.push(path45.join(providerDir, "specs", "default.json"));
+        candidates.push(path45.join(providerDir, "spec.json"));
+        const specPath = candidates.find((p) => fs41.existsSync(p));
         if (specPath) {
           resolved._resolvedSpecPath = specPath;
           let specControls;
           let nh;
           try {
-            const rawSpec = JSON.parse(fs40.readFileSync(specPath, "utf8"));
+            const rawSpec = JSON.parse(fs41.readFileSync(specPath, "utf8"));
             specControls = rawSpec.control_bar;
             nh = rawSpec.native_history;
           } catch {
@@ -50057,10 +50256,10 @@ var ProviderLoader = class _ProviderLoader {
               format = `spec-${nh.source.kind}`;
               reader = (input) => executeNativeHistory(nh, input);
             } else if (nh.override_path) {
-              const overrideFile = path44.resolve(providerDir, nh.override_path);
-              if (fs40.existsSync(overrideFile)) {
+              const overrideFile = path45.resolve(providerDir, nh.override_path);
+              if (fs41.existsSync(overrideFile)) {
                 try {
-                  registerProviderScriptRootSafely(path44.dirname(path44.dirname(providerDir)));
+                  registerProviderScriptRootSafely(path45.dirname(path45.dirname(providerDir)));
                   delete __require.cache[__require.resolve(overrideFile)];
                   const mod = __require(overrideFile);
                   const fn = typeof mod === "function" ? mod : mod && typeof mod.default === "function" ? mod.default : null;
@@ -50103,16 +50302,16 @@ var ProviderLoader = class _ProviderLoader {
       this.debugLog(`[loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
     }
-    const dir = path35.join(providerDir, scriptDir);
-    if (!fs25.existsSync(dir)) {
+    const dir = path36.join(providerDir, scriptDir);
+    if (!fs26.existsSync(dir)) {
       this.debugLog(`[loadScriptsFromDir] ${type}: dir not found: ${dir}`);
       return null;
     }
-    registerProviderScriptRootSafely(path35.dirname(path35.dirname(providerDir)));
+    registerProviderScriptRootSafely(path36.dirname(path36.dirname(providerDir)));
     const cached3 = this.scriptsCache.get(dir);
     if (cached3) return cached3;
-    const scriptsJs = path35.join(dir, "scripts.js");
-    if (fs25.existsSync(scriptsJs)) {
+    const scriptsJs = path36.join(dir, "scripts.js");
+    if (fs26.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
         const loaded = __require(scriptsJs);
@@ -50133,9 +50332,9 @@ var ProviderLoader = class _ProviderLoader {
   watch() {
     this.stopWatch();
     const watchDir = (dir) => {
-      if (!fs25.existsSync(dir)) {
+      if (!fs26.existsSync(dir)) {
         try {
-          fs25.mkdirSync(dir, { recursive: true });
+          fs26.mkdirSync(dir, { recursive: true });
         } catch {
           return;
         }
@@ -50156,7 +50355,7 @@ var ProviderLoader = class _ProviderLoader {
           if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
             if (reloadTimer) clearTimeout(reloadTimer);
             reloadTimer = setTimeout(() => {
-              this.log(`File changed: ${path35.basename(filePath)}, reloading...`);
+              this.log(`File changed: ${path36.basename(filePath)}, reloading...`);
               this.reload();
             }, 300);
           }
@@ -50224,11 +50423,11 @@ var ProviderLoader = class _ProviderLoader {
     }
     this.log(`Registry sync starting (${this.registryBaseUrl})...`);
     const https = __require("https");
-    const regMetaPath = path35.join(this.upstreamDir, _ProviderLoader.REGISTRY_META_FILE);
+    const regMetaPath = path36.join(this.upstreamDir, _ProviderLoader.REGISTRY_META_FILE);
     let cachedChecksums = {};
     try {
-      if (fs25.existsSync(regMetaPath)) {
-        cachedChecksums = JSON.parse(fs25.readFileSync(regMetaPath, "utf-8")).checksums ?? {};
+      if (fs26.existsSync(regMetaPath)) {
+        cachedChecksums = JSON.parse(fs26.readFileSync(regMetaPath, "utf-8")).checksums ?? {};
       }
     } catch {
     }
@@ -50279,15 +50478,15 @@ var ProviderLoader = class _ProviderLoader {
           this.log(`\u26A0 Registry checksum mismatch for ${type}@${version} \u2014 skipping`);
           continue;
         }
-        const providerDir = path35.join(this.upstreamDir, category, type);
-        fs25.mkdirSync(providerDir, { recursive: true });
-        fs25.writeFileSync(path35.join(providerDir, "provider.json"), manifestBody, "utf-8");
+        const providerDir = path36.join(this.upstreamDir, category, type);
+        fs26.mkdirSync(providerDir, { recursive: true });
+        fs26.writeFileSync(path36.join(providerDir, "provider.json"), manifestBody, "utf-8");
         cachedChecksums[cacheKey] = checksum;
         updatedCount++;
         this.log(`\u2713 Registry updated: ${category}/${type}@${version}`);
       }
-      fs25.mkdirSync(this.upstreamDir, { recursive: true });
-      fs25.writeFileSync(regMetaPath, JSON.stringify({
+      fs26.mkdirSync(this.upstreamDir, { recursive: true });
+      fs26.writeFileSync(regMetaPath, JSON.stringify({
         checksums: cachedChecksums,
         syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
         providerCount: list.providers.length
@@ -50308,12 +50507,12 @@ var ProviderLoader = class _ProviderLoader {
     const { exec: exec7 } = __require("child_process");
     const { promisify: promisify8 } = __require("util");
     const execAsync5 = promisify8(exec7);
-    const metaPath = path35.join(this.upstreamDir, _ProviderLoader.META_FILE);
+    const metaPath = path36.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
     try {
-      if (fs25.existsSync(metaPath)) {
-        const meta = JSON.parse(fs25.readFileSync(metaPath, "utf-8"));
+      if (fs26.existsSync(metaPath)) {
+        const meta = JSON.parse(fs26.readFileSync(metaPath, "utf-8"));
         prevEtag = meta.etag || "";
         prevTimestamp = meta.timestamp || 0;
       }
@@ -50369,39 +50568,39 @@ var ProviderLoader = class _ProviderLoader {
         return { updated: false };
       }
       this.log("Downloading latest providers from GitHub...");
-      const tmpTar = path35.join(os25.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-      const tmpExtract = path35.join(os25.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+      const tmpTar = path36.join(os26.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+      const tmpExtract = path36.join(os26.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
       await this.downloadFile(tarballTarget.url, tmpTar);
-      fs25.mkdirSync(tmpExtract, { recursive: true });
+      fs26.mkdirSync(tmpExtract, { recursive: true });
       await execAsync5(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
-      const extracted = fs25.readdirSync(tmpExtract);
+      const extracted = fs26.readdirSync(tmpExtract);
       const rootDir = extracted.find(
-        (d) => fs25.statSync(path35.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+        (d) => fs26.statSync(path36.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
       );
       if (!rootDir) throw new Error("Unexpected tarball structure");
-      const sourceDir = path35.join(tmpExtract, rootDir);
+      const sourceDir = path36.join(tmpExtract, rootDir);
       const backupDir = this.upstreamDir + ".bak";
-      if (fs25.existsSync(this.upstreamDir)) {
-        if (fs25.existsSync(backupDir)) fs25.rmSync(backupDir, { recursive: true, force: true });
-        fs25.renameSync(this.upstreamDir, backupDir);
+      if (fs26.existsSync(this.upstreamDir)) {
+        if (fs26.existsSync(backupDir)) fs26.rmSync(backupDir, { recursive: true, force: true });
+        fs26.renameSync(this.upstreamDir, backupDir);
       }
       try {
         this.copyDirRecursive(sourceDir, this.upstreamDir);
         this.writeMeta(metaPath, etag || `ts-${Date.now()}`, Date.now());
-        if (fs25.existsSync(backupDir)) fs25.rmSync(backupDir, { recursive: true, force: true });
+        if (fs26.existsSync(backupDir)) fs26.rmSync(backupDir, { recursive: true, force: true });
       } catch (e) {
-        if (fs25.existsSync(backupDir)) {
-          if (fs25.existsSync(this.upstreamDir)) fs25.rmSync(this.upstreamDir, { recursive: true, force: true });
-          fs25.renameSync(backupDir, this.upstreamDir);
+        if (fs26.existsSync(backupDir)) {
+          if (fs26.existsSync(this.upstreamDir)) fs26.rmSync(this.upstreamDir, { recursive: true, force: true });
+          fs26.renameSync(backupDir, this.upstreamDir);
         }
         throw e;
       }
       try {
-        fs25.rmSync(tmpTar, { force: true });
+        fs26.rmSync(tmpTar, { force: true });
       } catch {
       }
       try {
-        fs25.rmSync(tmpExtract, { recursive: true, force: true });
+        fs26.rmSync(tmpExtract, { recursive: true, force: true });
       } catch {
       }
       const upstreamCount = this.countProviders(this.upstreamDir);
@@ -50433,7 +50632,7 @@ var ProviderLoader = class _ProviderLoader {
             reject(new Error(`HTTP ${res.statusCode}`));
             return;
           }
-          const ws = fs25.createWriteStream(destPath);
+          const ws = fs26.createWriteStream(destPath);
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
@@ -50452,22 +50651,22 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** Recursive directory copy */
   copyDirRecursive(src, dest) {
-    fs25.mkdirSync(dest, { recursive: true });
-    for (const entry of fs25.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path35.join(src, entry.name);
-      const destPath = path35.join(dest, entry.name);
+    fs26.mkdirSync(dest, { recursive: true });
+    for (const entry of fs26.readdirSync(src, { withFileTypes: true })) {
+      const srcPath = path36.join(src, entry.name);
+      const destPath = path36.join(dest, entry.name);
       if (entry.isDirectory()) {
         this.copyDirRecursive(srcPath, destPath);
       } else {
-        fs25.copyFileSync(srcPath, destPath);
+        fs26.copyFileSync(srcPath, destPath);
       }
     }
   }
   /** .meta.json save */
   writeMeta(metaPath, etag, timestamp) {
     try {
-      fs25.mkdirSync(path35.dirname(metaPath), { recursive: true });
-      fs25.writeFileSync(metaPath, JSON.stringify({
+      fs26.mkdirSync(path36.dirname(metaPath), { recursive: true });
+      fs26.writeFileSync(metaPath, JSON.stringify({
         etag,
         timestamp,
         lastCheck: new Date(timestamp).toISOString(),
@@ -50478,15 +50677,15 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** Count provider files (provider.v1.json or provider.json — at most one per dir). */
   countProviders(dir) {
-    if (!fs25.existsSync(dir)) return 0;
+    if (!fs26.existsSync(dir)) return 0;
     let count = 0;
     const scan = (d) => {
       try {
-        const entries = fs25.readdirSync(d, { withFileTypes: true });
+        const entries = fs26.readdirSync(d, { withFileTypes: true });
         const hasManifest = entries.some((e) => e.name === "provider.v1.json" || e.name === "provider.json");
         if (hasManifest) count++;
         for (const entry of entries) {
-          if (entry.isDirectory()) scan(path35.join(d, entry.name));
+          if (entry.isDirectory()) scan(path36.join(d, entry.name));
         }
       } catch {
       }
@@ -50712,13 +50911,13 @@ var ProviderLoader = class _ProviderLoader {
     if (!provider) return null;
     const cat = provider.category;
     const searchRoots = this.getProviderRoots();
-    const hasManifest = (dir) => fs25.existsSync(path35.join(dir, "provider.v1.json")) || fs25.existsSync(path35.join(dir, "provider.json"));
+    const hasManifest = (dir) => fs26.existsSync(path36.join(dir, "provider.v1.json")) || fs26.existsSync(path36.join(dir, "provider.json"));
     const readManifestType = (dir) => {
       for (const file of ["provider.v1.json", "provider.json"]) {
-        const p = path35.join(dir, file);
-        if (!fs25.existsSync(p)) continue;
+        const p = path36.join(dir, file);
+        if (!fs26.existsSync(p)) continue;
         try {
-          const data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+          const data = JSON.parse(fs26.readFileSync(p, "utf-8"));
           if (typeof data?.type === "string") return data.type;
         } catch {
         }
@@ -50726,15 +50925,15 @@ var ProviderLoader = class _ProviderLoader {
       return null;
     };
     for (const root of searchRoots) {
-      if (!fs25.existsSync(root)) continue;
+      if (!fs26.existsSync(root)) continue;
       const candidate = this.getProviderDir(root, cat, type);
       if (hasManifest(candidate)) return candidate;
-      const catDir = path35.join(root, cat);
-      if (fs25.existsSync(catDir)) {
+      const catDir = path36.join(root, cat);
+      if (fs26.existsSync(catDir)) {
         try {
-          for (const entry of fs25.readdirSync(catDir, { withFileTypes: true })) {
+          for (const entry of fs26.readdirSync(catDir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const entryDir = path35.join(catDir, entry.name);
+            const entryDir = path36.join(catDir, entry.name);
             const manifestType = readManifestType(entryDir);
             if (manifestType === type) return entryDir;
           }
@@ -50750,8 +50949,8 @@ var ProviderLoader = class _ProviderLoader {
    * (template substitution is NOT applied here — scripts.js handles that)
    */
   buildScriptWrappersFromDir(dir) {
-    const scriptsJs = path35.join(dir, "scripts.js");
-    if (fs25.existsSync(scriptsJs)) {
+    const scriptsJs = path36.join(dir, "scripts.js");
+    if (fs26.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
         return __require(scriptsJs);
@@ -50761,13 +50960,13 @@ var ProviderLoader = class _ProviderLoader {
     const toCamel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
     const result = {};
     try {
-      for (const file of fs25.readdirSync(dir)) {
+      for (const file of fs26.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path35.join(dir, file);
+        const filePath = path36.join(dir, file);
         result[scriptName] = (...args) => {
           try {
-            let content = fs25.readFileSync(filePath, "utf-8");
+            let content = fs26.readFileSync(filePath, "utf-8");
             if (args[0] && typeof args[0] === "object") {
               for (const [key2, val] of Object.entries(args[0])) {
                 let v = val;
@@ -50813,12 +51012,12 @@ var ProviderLoader = class _ProviderLoader {
    * Structure: dir/category/agent-name/provider.{json,js}
    */
   loadDir(dir, excludeDirs) {
-    if (!fs25.existsSync(dir)) return 0;
+    if (!fs26.existsSync(dir)) return 0;
     let count = 0;
     const scan = (d) => {
       let entries;
       try {
-        entries = fs25.readdirSync(d, { withFileTypes: true });
+        entries = fs26.readdirSync(d, { withFileTypes: true });
       } catch {
         return;
       }
@@ -50826,9 +51025,9 @@ var ProviderLoader = class _ProviderLoader {
       const hasJson = entries.some((e) => e.name === "provider.json");
       if (hasV1 || hasJson) {
         const manifestFile = hasV1 ? "provider.v1.json" : "provider.json";
-        const jsonPath = path35.join(d, manifestFile);
+        const jsonPath = path36.join(d, manifestFile);
         try {
-          const raw = fs25.readFileSync(jsonPath, "utf-8");
+          const raw = fs26.readFileSync(jsonPath, "utf-8");
           const mod = JSON.parse(raw);
           if (hasV1 && mod?.category === "cli") {
             try {
@@ -50866,10 +51065,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             this.log(`\u26A0 Invalid provider at ${jsonPath}: ${validation.errors.join("; ")}`);
           } else {
             const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
-            const scriptsPath = path35.join(d, "scripts.js");
-            if (!hasCompatibility && fs25.existsSync(scriptsPath)) {
+            const scriptsPath = path36.join(d, "scripts.js");
+            if (!hasCompatibility && fs26.existsSync(scriptsPath)) {
               try {
-                registerProviderScriptRootSafely(path35.dirname(path35.dirname(d)));
+                registerProviderScriptRootSafely(path36.dirname(path36.dirname(d)));
                 delete __require.cache[__require.resolve(scriptsPath)];
                 const scripts = __require(scriptsPath);
                 normalizedProvider.scripts = scripts;
@@ -50877,7 +51076,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 this.log(`\u26A0 Failed to load scripts: ${scriptsPath}: ${e.message}`);
               }
             }
-            const externalDirAbs = path35.join(os25.homedir(), ".adhdev", "external");
+            const externalDirAbs = path36.join(os26.homedir(), ".adhdev", "external");
             const layer = d.startsWith(externalDirAbs) ? "external" : d.startsWith(this.userDir) && !d.includes(".upstream") ? "user" : "upstream";
             try {
               const { inspectManifestShape: inspectManifestShape2, classifyTrust: classifyTrust2 } = (init_provider_trust(), __toCommonJS(provider_trust_exports));
@@ -50887,8 +51086,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               normalizedProvider._sourceTrust = trust;
               normalizedProvider._manifestShape = shape;
               if (layer === "external") {
-                const rel = path35.relative(externalDirAbs, d);
-                const firstSeg = rel.split(path35.sep)[0];
+                const rel = path36.relative(externalDirAbs, d);
+                const firstSeg = rel.split(path36.sep)[0];
                 if (firstSeg && firstSeg !== "..") normalizedProvider._sourceName = firstSeg;
               }
             } catch {
@@ -50912,7 +51111,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
           if (d === dir && entry.name === "examples") continue;
           if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-          scan(path35.join(d, entry.name));
+          scan(path36.join(d, entry.name));
         }
       }
     };
@@ -51110,7 +51309,7 @@ async function isCdpActive(port) {
   });
 }
 async function killIdeProcess(ideId) {
-  const plat = os26.platform();
+  const plat = os27.platform();
   const appName = getMacAppIdentifiers()[ideId];
   const winProcesses = getWinProcessNames()[ideId];
   try {
@@ -51171,7 +51370,7 @@ async function killIdeProcess(ideId) {
   }
 }
 async function isIdeRunning(ideId) {
-  const plat = os26.platform();
+  const plat = os27.platform();
   try {
     if (plat === "darwin") {
       const appName = getMacAppIdentifiers()[ideId];
@@ -51226,7 +51425,7 @@ async function isIdeRunning(ideId) {
   }
 }
 async function detectCurrentWorkspace(ideId) {
-  const plat = os26.platform();
+  const plat = os27.platform();
   if (plat === "darwin") {
     try {
       const appName = getMacAppIdentifiers()[ideId];
@@ -51241,17 +51440,17 @@ async function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs40 = __require("fs");
+      const fs41 = __require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path36.join(
-          process.env.APPDATA || path36.join(os26.homedir(), "AppData", "Roaming"),
+        const storagePath = path37.join(
+          process.env.APPDATA || path37.join(os27.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
-        if (fs40.existsSync(storagePath)) {
-          const data = JSON.parse(fs40.readFileSync(storagePath, "utf-8"));
+        if (fs41.existsSync(storagePath)) {
+          const data = JSON.parse(fs41.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -51268,7 +51467,7 @@ async function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform10 = os26.platform();
+  const platform10 = os27.platform();
   let targetIde;
   const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
@@ -51771,11 +51970,11 @@ var meshCrudHandlers = {
         MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
       } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
       const { mkdirSync: mkdirSync22, writeFileSync: writeFileSync24 } = await import("fs");
-      const { dirname: dirname17, join: join50 } = await import("path");
+      const { dirname: dirname17, join: join51 } = await import("path");
       const scaffold = buildMeshJsonConfigScaffold2(mesh);
       const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
       const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
-      const absolutePath = join50(workspace, relativePath);
+      const absolutePath = join51(workspace, relativePath);
       const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
       if (!validation.valid) {
         return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
@@ -52840,7 +53039,7 @@ init_worktree_bootstrap_config();
 init_change_impact_config();
 init_mesh_config();
 import { existsSync as existsSync38, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname11, join as join41 } from "path";
+import { dirname as dirname11, join as join42 } from "path";
 var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
 var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
 var MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
@@ -52855,7 +53054,7 @@ var CANDIDATE_STALE_INPUTS = [
   "requirements.txt"
 ];
 function writeConfigFile(workspace, relativePath, config) {
-  const target = join41(workspace, relativePath);
+  const target = join42(workspace, relativePath);
   mkdirSync15(dirname11(target), { recursive: true });
   writeFileSync18(target, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
@@ -52863,14 +53062,14 @@ function writeConfigFile(workspace, relativePath, config) {
 }
 function suggestMeshWorktreeBootstrapConfig(workspace) {
   const commands = [];
-  const hasPackageJson = existsSync38(join41(workspace, "package.json"));
-  const hasNpmLock = existsSync38(join41(workspace, "package-lock.json"));
+  const hasPackageJson = existsSync38(join42(workspace, "package.json"));
+  const hasNpmLock = existsSync38(join42(workspace, "package-lock.json"));
   if (hasPackageJson) {
     commands.push(
       hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
     );
   }
-  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync38(join41(workspace, relative5)));
+  const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => existsSync38(join42(workspace, relative5)));
   if (!commands.length) {
     return { commands, staleInputs };
   }
@@ -52969,7 +53168,7 @@ function runMeshInit(mesh, workspace, detected, options = {}) {
 }
 function applyConfigSuggestion(input) {
   const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-  const absolute = join41(workspace, relativePath);
+  const absolute = join42(workspace, relativePath);
   if (existing !== void 0 && !overwrite) {
     return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
   }
@@ -53231,7 +53430,7 @@ init_logger();
 init_mesh_host_ownership();
 init_coordinator_registry();
 import { join as pathJoin } from "path";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 init_mesh_coordinator();
 init_dist();
 var meshCoordinatorLaunchHandlers = {
@@ -53463,15 +53662,15 @@ ${ptyResult.output.slice(-2e3)}`);
         }
         if (cliType === "codex-cli") {
           const repoMcpConfigPath = pathJoin(workspace, ".mcp.json");
-          if (fs26.existsSync(repoMcpConfigPath)) {
+          if (fs27.existsSync(repoMcpConfigPath)) {
             try {
               const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                fs26.readFileSync(repoMcpConfigPath, "utf-8"),
+                fs27.readFileSync(repoMcpConfigPath, "utf-8"),
                 "claude_mcp_json"
               );
               const existingServers2 = repoMcpConfig.mcpServers;
               if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                fs26.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                fs27.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                   ...repoMcpConfig,
                   mcpServers: {
                     ...existingServers2,
@@ -53760,7 +53959,7 @@ init_dist();
 init_mesh_events();
 init_mesh_routing();
 init_mesh_host_ownership();
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import { hostname as osHostname } from "os";
 
 // src/mesh/preview-freshness.ts
@@ -53801,10 +54000,10 @@ function runGit2(repoRoot, args) {
   }
 }
 function readRecord6(repoRoot) {
-  const path44 = resolve19(repoRoot, PREVIEW_DEPLOY_RECORD);
-  if (!existsSync40(path44)) return null;
+  const path45 = resolve19(repoRoot, PREVIEW_DEPLOY_RECORD);
+  if (!existsSync40(path45)) return null;
   try {
-    const parsed = JSON.parse(readFileSync31(path44, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path45, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -54115,7 +54314,7 @@ var meshStatusHandlers = {
           }
         }
         if (workspace) {
-          if (!fs27.existsSync(workspace)) {
+          if (!fs28.existsSync(workspace)) {
             const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
             let remoteProbeApplied = false;
             if (inlineTransitGit) {
@@ -54245,7 +54444,7 @@ var meshStatusHandlers = {
         backstop: { ...getMeshV2BackstopCounters() }
       };
       const previewFreshness = (() => {
-        const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs27.existsSync(candidate));
+        const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs28.existsSync(candidate));
         return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
       })();
       const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -54445,15 +54644,15 @@ init_dist();
 init_logger();
 
 // src/logging/command-log.ts
-import * as fs28 from "fs";
-import * as path37 from "path";
-import * as os27 from "os";
-var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path37.join(os27.homedir(), ".adhdev");
-var LOG_DIR2 = path37.join(ADHDEV_HOME2, "logs");
+import * as fs29 from "fs";
+import * as path38 from "path";
+import * as os28 from "os";
+var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path38.join(os28.homedir(), ".adhdev");
+var LOG_DIR2 = path38.join(ADHDEV_HOME2, "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
-  fs28.mkdirSync(LOG_DIR2, { recursive: true });
+  fs29.mkdirSync(LOG_DIR2, { recursive: true });
 } catch {
 }
 var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -54487,19 +54686,19 @@ function getDateStr2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate2 = getDateStr2();
-var currentFile = path37.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+var currentFile = path38.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
 var writeCount2 = 0;
 function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path37.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path38.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
 function cleanOldFiles() {
   try {
-    const files = fs28.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+    const files = fs29.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
     const cutoff = /* @__PURE__ */ new Date();
     cutoff.setDate(cutoff.getDate() - MAX_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -54507,7 +54706,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs28.unlinkSync(path37.join(LOG_DIR2, file));
+          fs29.unlinkSync(path38.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -54517,14 +54716,14 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat2 = fs28.statSync(currentFile);
+    const stat2 = fs29.statSync(currentFile);
     if (stat2.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
-        fs28.unlinkSync(backup);
+        fs29.unlinkSync(backup);
       } catch {
       }
-      fs28.renameSync(currentFile, backup);
+      fs29.renameSync(currentFile, backup);
     }
   } catch {
   }
@@ -54557,14 +54756,14 @@ function logCommand(entry) {
       ...entry.error ? { err: entry.error } : {},
       ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
     });
-    fs28.appendFileSync(currentFile, line + "\n");
+    fs29.appendFileSync(currentFile, line + "\n");
   } catch {
   }
 }
 function getRecentCommands(count = 50) {
   try {
-    if (!fs28.existsSync(currentFile)) return [];
-    const content = fs28.readFileSync(currentFile, "utf-8");
+    if (!fs29.existsSync(currentFile)) return [];
+    const content = fs29.readFileSync(currentFile, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.slice(-count).map((line) => {
       try {
@@ -54592,7 +54791,7 @@ cleanOldFiles();
 // src/commands/router.ts
 init_debug_trace();
 init_mesh_host_ownership();
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 
 // src/mesh/mesh-node-identity.ts
 init_cli_detector();
@@ -54600,7 +54799,7 @@ init_git_status();
 init_dist();
 init_logger();
 init_mesh_warmup_deadline();
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 init_runtime_defaults();
 function readProviderPriorityFromPolicy(policy) {
   const record = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
@@ -54987,7 +55186,7 @@ function isDeadLocalWorktreeNode(node) {
   if (node?.isLocalWorktree !== true) return false;
   const workspace = readStringValue(node?.workspace);
   if (!workspace) return false;
-  return !fs29.existsSync(workspace);
+  return !fs30.existsSync(workspace);
 }
 function foldMeshNodeIdentityToCanonical(node) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return node;
@@ -55235,7 +55434,7 @@ function summarizeInlineMeshBranchConvergence(nodes) {
   const followUps = nodes.filter((node) => {
     if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
     const workspace = typeof node.workspace === "string" ? node.workspace : "";
-    if (workspace && !fs29.existsSync(workspace)) return false;
+    if (workspace && !fs30.existsSync(workspace)) return false;
     return true;
   }).map((node) => {
     const convergence = readObjectRecord(node.branchConvergence);
@@ -55665,7 +55864,7 @@ async function hydrateInlineMeshDirectTruth(args) {
     if (!workspace) {
       return !isSelfNode && daemonId ? { kind: "unavailable", nodeId } : { kind: "skip" };
     }
-    if (fs29.existsSync(workspace)) {
+    if (fs30.existsSync(workspace)) {
       try {
         const runLocalProbe = () => getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
         const localGit = args.probeCache ? await args.probeCache.probeLocal(workspace, runLocalProbe) : await runLocalProbe();
@@ -55812,7 +56011,7 @@ function readLiveMeshNodeWorkspace(args) {
 }
 function collectLiveMeshSessionRecords(args) {
   const nodeWorkspace = readStringValue(args.node?.workspace);
-  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs29.existsSync(nodeWorkspace);
+  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs30.existsSync(nodeWorkspace);
   const matches = args.liveSessionRecords.filter((record) => {
     const recordNodeId = readStringValue(record?.meta?.meshNodeId);
     if (recordNodeId && !daemonIdsEquivalent(recordNodeId, args.nodeId)) return false;
@@ -55839,7 +56038,7 @@ function buildHistoricalMeshSessions(args) {
     const workspace = readStringValue(node?.workspace);
     if (nodeId) liveNodeIds.add(nodeId);
     if (workspace) liveWorkspaces.add(workspace);
-    if (nodeId && node?.isLocalWorktree === true && workspace && !fs29.existsSync(workspace)) {
+    if (nodeId && node?.isLocalWorktree === true && workspace && !fs30.existsSync(workspace)) {
       missingLocalWorktreeNodeIds.add(nodeId);
     }
   }
@@ -55935,9 +56134,9 @@ import { promisify as promisify6 } from "util";
 var execFileAsync3 = promisify6(execFile4);
 var GIT = process.platform === "win32" ? resolveWin32Executable("git") : "git";
 var MAX_CHANGED_FILES2 = 500;
-function topLevel(path44) {
-  const slash = path44.indexOf("/");
-  return slash === -1 ? path44 : path44.slice(0, slash);
+function topLevel(path45) {
+  const slash = path45.indexOf("/");
+  return slash === -1 ? path45 : path45.slice(0, slash);
 }
 async function analyzeMeshRefineNodeChangeArea(args) {
   const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
@@ -56026,7 +56225,7 @@ init_refine_config();
 init_worktree_bootstrap_config();
 init_resolve_executable();
 import { basename as pathBasename, join as pathJoin2, resolve as pathResolve2 } from "path";
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import { execFileSync as execFileSync7 } from "child_process";
 var GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
 var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
@@ -56085,7 +56284,7 @@ async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
   const { execFileSync: execFileSync10 } = await import("child_process");
   const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
   if (excludePaths.length > 0) {
-    diffArgs.push("--", ".", ...excludePaths.map((path44) => `:(exclude)${path44}`));
+    diffArgs.push("--", ".", ...excludePaths.map((path45) => `:(exclude)${path45}`));
   }
   const diff = execFileSync10(GIT2, diffArgs, {
     cwd,
@@ -56286,9 +56485,9 @@ async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
         if (!trimmed) continue;
         if (trimmed.startsWith("+")) {
           const parts = trimmed.slice(1).trim().split(/\s+/);
-          const path44 = parts[1] || parts[0] || "(unknown)";
+          const path45 = parts[1] || parts[0] || "(unknown)";
           submoduleHints.push({
-            path: path44,
+            path: path45,
             reason: "submodule checked-out commit differs from the committed gitlink (pointer bump not committed on the root branch)"
           });
         }
@@ -56318,10 +56517,10 @@ async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
 }
 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((path44) => ({
-    path: path44,
-    baseCommit: readTreeObject(repoRoot, baseHead, path44),
-    branchCommit: readTreeObject(repoRoot, branchHead, path44)
+  const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path45) => ({
+    path: path45,
+    baseCommit: readTreeObject(repoRoot, baseHead, path45),
+    branchCommit: readTreeObject(repoRoot, branchHead, path45)
   }));
   if (conflicts.length === 0) return void 0;
   return {
@@ -56347,11 +56546,11 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
       if (!line.trim()) continue;
       const metaAndPath = line.split("	");
       const meta = metaAndPath[0] || "";
-      const path44 = metaAndPath[metaAndPath.length - 1]?.trim();
-      if (!path44) continue;
+      const path45 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path45) continue;
       const parts = meta.split(/\s+/);
       if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-        paths.add(path44);
+        paths.add(path45);
       }
     }
     return [...paths].sort();
@@ -56359,9 +56558,9 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
     return [];
   }
 }
-function readTreeObject(repoRoot, ref, path44) {
+function readTreeObject(repoRoot, ref, path45) {
   try {
-    const output = execFileSync7(GIT2, ["ls-tree", ref, "--", path44], {
+    const output = execFileSync7(GIT2, ["ls-tree", ref, "--", path45], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -56384,7 +56583,7 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
   if (!baseCommit || !branchCommit) return false;
   if (baseCommit === branchCommit) return true;
   try {
-    if (!fs30.existsSync(submoduleRepoPath)) return false;
+    if (!fs31.existsSync(submoduleRepoPath)) return false;
     execFileSync7(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     execFileSync7(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     execFileSync7(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
@@ -56406,12 +56605,12 @@ function readChangedPathKinds(repoRoot, fromRef, toRef) {
       if (!line.trim()) continue;
       const metaAndPath = line.split("	");
       const meta = metaAndPath[0] || "";
-      const path44 = metaAndPath[metaAndPath.length - 1]?.trim();
-      if (!path44 || seen.has(path44)) continue;
-      seen.add(path44);
+      const path45 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path45 || seen.has(path45)) continue;
+      seen.add(path45);
       const parts = meta.split(/\s+/);
       const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
-      result.push({ path: path44, isGitlink });
+      result.push({ path: path45, isGitlink });
     }
     return result;
   } catch {
@@ -56419,20 +56618,20 @@ function readChangedPathKinds(repoRoot, fromRef, toRef) {
   }
 }
 function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
-  return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path44) => {
-    const baseCommit = readTreeObject(repoRoot, baseHead, path44);
-    const branchCommit = readTreeObject(repoRoot, branchHead, path44);
+  return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path45) => {
+    const baseCommit = readTreeObject(repoRoot, baseHead, path45);
+    const branchCommit = readTreeObject(repoRoot, branchHead, path45);
     if (!baseCommit || !branchCommit) return false;
-    return isSubmoduleFastForward(pathResolve2(repoRoot, path44), baseCommit, branchCommit);
+    return isSubmoduleFastForward(pathResolve2(repoRoot, path45), baseCommit, branchCommit);
   });
 }
 function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
-  const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path44) => {
-    const baseCommit = readTreeObject(repoRoot, baseHead, path44);
-    const branchCommit = readTreeObject(repoRoot, branchHead, path44);
-    const submoduleRepoPath = pathResolve2(repoRoot, path44);
+  const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path45) => {
+    const baseCommit = readTreeObject(repoRoot, baseHead, path45);
+    const branchCommit = readTreeObject(repoRoot, branchHead, path45);
+    const submoduleRepoPath = pathResolve2(repoRoot, path45);
     const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
-    return { path: path44, baseCommit, branchCommit, fastForward };
+    return { path: path45, baseCommit, branchCommit, fastForward };
   });
   if (changedGitlinks.length === 0) {
     return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
@@ -56483,7 +56682,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       maxBuffer: 1024 * 1024
     }).trim();
     if (!tree) return void 0;
-    const updates = paths.map((path44) => `160000 commit ${placeholderCommit}	${path44}`).join("\n");
+    const updates = paths.map((path45) => `160000 commit ${placeholderCommit}	${path45}`).join("\n");
     if (!updates) return tree;
     const tmpIndex = pathJoin2(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -56501,7 +56700,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       return newTree || void 0;
     } finally {
       try {
-        fs30.rmSync(tmpIndex, { force: true });
+        fs31.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -56576,7 +56775,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
       return newTree || void 0;
     } finally {
       try {
-        fs30.rmSync(tmpIndex, { force: true });
+        fs31.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -56586,7 +56785,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
 }
 async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
   const startedAt = Date.now();
-  const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path44) => !(options.submoduleIgnorePaths || []).includes(path44));
+  const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path45) => !(options.submoduleIgnorePaths || []).includes(path45));
   const preStatus = await getGitRepoStatus(repoRoot, {
     includeSubmodules: true,
     submoduleIgnorePaths: options.submoduleIgnorePaths,
@@ -56633,7 +56832,7 @@ async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, cur
       changedGitlinkPaths,
       outOfSyncPaths,
       updatedPaths: updatePaths,
-      verifiedPaths: updatePaths.filter((path44) => !remaining.some((submodule) => submodule.path === path44)),
+      verifiedPaths: updatePaths.filter((path45) => !remaining.some((submodule) => submodule.path === path45)),
       durationMs: Date.now() - startedAt,
       command: `git ${commandArgs.join(" ")}`,
       stdout: truncateValidationOutput(result.stdout),
@@ -56688,7 +56887,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
     };
     const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-      if (!fs30.existsSync(worktreeSubmodulePath)) return false;
+      if (!fs31.existsSync(worktreeSubmodulePath)) return false;
       try {
         await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       } catch {
@@ -56712,7 +56911,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       };
       let submoduleDefaultBranch = "main";
       try {
-        if (!fs30.existsSync(submodulePath)) {
+        if (!fs31.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
           entry.publishRequired = true;
           if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -56954,9 +57153,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs30.existsSync(pathJoin2(cwd, "package.json"))) return false;
-    if (fs30.existsSync(pathJoin2(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs30.existsSync(pathJoin2(cwd, lock)));
+    if (!fs31.existsSync(pathJoin2(cwd, "package.json"))) return false;
+    if (fs31.existsSync(pathJoin2(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs31.existsSync(pathJoin2(cwd, lock)));
   };
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
@@ -58372,7 +58571,7 @@ async function startMeshRefineJob(self, meshId, nodeId, args) {
 // src/commands/router-worktree-cleanup.ts
 init_logger();
 init_dist();
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import { resolve as pathResolve3 } from "path";
 init_repo_mesh_types();
 function sessionMatchesMeshNode(self, record, node, nodeId, sessionIds) {
@@ -58385,14 +58584,14 @@ function sessionMatchesMeshNode(self, record, node, nodeId, sessionIds) {
   return false;
 }
 async function bestEffortRemoveWorktreeDir(self, dir) {
-  if (!dir || !fs31.existsSync(dir)) return { removed: true, residue: false };
+  if (!dir || !fs32.existsSync(dir)) return { removed: true, residue: false };
   const sleep3 = (ms) => new Promise((resolve25) => setTimeout(resolve25, ms));
   const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
   let lastErr;
   for (let attempt = 0; attempt < 4; attempt++) {
     try {
-      fs31.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-      if (!fs31.existsSync(dir)) return { removed: true, residue: false };
+      fs32.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      if (!fs32.existsSync(dir)) return { removed: true, residue: false };
       lastErr = new Error("directory still present after rmSync");
     } catch (e) {
       lastErr = e;
@@ -58403,7 +58602,7 @@ async function bestEffortRemoveWorktreeDir(self, dir) {
     }
     await sleep3(150 * (attempt + 1));
   }
-  return fs31.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+  return fs32.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
 }
 async function precheckLocalWorktreeRemovable(self, args) {
   const sessionPreservedNote = " The delegated session was left running (not stopped) \u2014 resolve the issue and retry mesh_remove_node.";
@@ -58416,10 +58615,10 @@ async function precheckLocalWorktreeRemovable(self, args) {
       recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
     };
   }
-  if (!fs31.existsSync(workspace)) return { ok: true };
+  if (!fs32.existsSync(workspace)) return { ok: true };
   const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
   const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
-  if (!repoRoot || !fs31.existsSync(repoRoot)) {
+  if (!repoRoot || !fs32.existsSync(repoRoot)) {
     return {
       ok: false,
       code: "mesh_worktree_cleanup_missing_source_repo",
@@ -58439,7 +58638,7 @@ async function precheckLocalWorktreeRemovable(self, args) {
   const normalizePath = (value) => {
     const resolved = pathResolve3(value);
     try {
-      return fs31.realpathSync(resolved);
+      return fs32.realpathSync(resolved);
     } catch {
       return resolved;
     }
@@ -58501,13 +58700,13 @@ async function cleanupLocalWorktreeNode(self, args) {
       recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
     };
   }
-  const worktreeExists = fs31.existsSync(workspace);
+  const worktreeExists = fs32.existsSync(workspace);
   const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
   const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
   if (!worktreeExists) {
     return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
   }
-  if (!repoRoot || !fs31.existsSync(repoRoot)) {
+  if (!repoRoot || !fs32.existsSync(repoRoot)) {
     return {
       success: false,
       code: "mesh_worktree_cleanup_missing_source_repo",
@@ -58527,7 +58726,7 @@ async function cleanupLocalWorktreeNode(self, args) {
   const normalizePath = (value) => {
     const resolved = pathResolve3(value);
     try {
-      return fs31.realpathSync(resolved);
+      return fs32.realpathSync(resolved);
     } catch {
       return resolved;
     }
@@ -59161,7 +59360,7 @@ init_logger();
 import * as yaml5 from "js-yaml";
 import { homedir as homedir26 } from "os";
 import { join as pathJoin3, resolve as pathResolve4 } from "path";
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 function loadYamlModule() {
   return yaml5;
 }
@@ -59185,9 +59384,9 @@ function resolveHermesUserHome() {
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
   const sourceConfigPath = pathJoin3(sourceHome, "config.yaml");
-  if (!fs32.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if (!fs33.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   if (pathResolve4(sourceConfigPath) === pathResolve4(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  const parsed = parseMeshCoordinatorMcpConfig(fs32.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+  const parsed = parseMeshCoordinatorMcpConfig(fs33.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
 }
@@ -59224,9 +59423,9 @@ function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   for (const fileName of [".env", "auth.json"]) {
     const sourcePath = pathJoin3(sourceHome, fileName);
     const targetPath = pathJoin3(targetHome, fileName);
-    if (!fs32.existsSync(sourcePath)) continue;
+    if (!fs33.existsSync(sourcePath)) continue;
     try {
-      fs32.copyFileSync(sourcePath, targetPath);
+      fs33.copyFileSync(sourcePath, targetPath);
     } catch (error) {
       LOG.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
     }
@@ -59618,7 +59817,7 @@ var DaemonCommandRouter = class {
       const nodeId = readInlineMeshNodeId(node);
       if (!nodeId || !tombstones.has(nodeId)) return true;
       const workspace = readStringValue(node?.workspace);
-      if (workspace && fs33.existsSync(workspace)) {
+      if (workspace && fs34.existsSync(workspace)) {
         tombstones.delete(nodeId);
         return true;
       }
@@ -61537,12 +61736,12 @@ init_io_contracts();
 init_chat_message_normalization();
 
 // src/providers/version-archive.ts
-import * as fs34 from "fs";
-import * as path38 from "path";
-import * as os28 from "os";
+import * as fs35 from "fs";
+import * as path39 from "path";
+import * as os29 from "os";
 import { platform as platform8 } from "os";
 import { exec as exec5 } from "child_process";
-var ARCHIVE_PATH = path38.join(os28.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path39.join(os29.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -61551,8 +61750,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs34.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs34.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs35.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs35.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -61589,8 +61788,8 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs34.mkdirSync(path38.dirname(ARCHIVE_PATH), { recursive: true });
-      fs34.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs35.mkdirSync(path39.dirname(ARCHIVE_PATH), { recursive: true });
+      fs35.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
@@ -61613,10 +61812,10 @@ function findBinary2(name) {
   for (const p of paths) {
     if (!p) continue;
     for (const ext of exes) {
-      const fullPath = path38.join(p, name + ext);
+      const fullPath = path39.join(p, name + ext);
       try {
-        if (fs34.existsSync(fullPath)) {
-          const stat2 = fs34.statSync(fullPath);
+        if (fs35.existsSync(fullPath)) {
+          const stat2 = fs35.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -61661,19 +61860,19 @@ async function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os28.homedir();
-      const resolved = p.replace(/\*/g, home.split(path38.sep).pop() || "");
-      if (fs34.existsSync(resolved)) return resolved;
+      const home = os29.homedir();
+      const resolved = p.replace(/\*/g, home.split(path39.sep).pop() || "");
+      if (fs35.existsSync(resolved)) return resolved;
     } else {
-      if (fs34.existsSync(p)) return p;
+      if (fs35.existsSync(p)) return p;
     }
   }
   return null;
 }
 async function getMacAppVersion(appPath) {
   if (platform8() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path38.join(appPath, "Contents", "Info.plist");
-  if (!fs34.existsSync(plistPath)) return null;
+  const plistPath = path39.join(appPath, "Contents", "Info.plist");
+  if (!fs35.existsSync(plistPath)) return null;
   const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -61699,8 +61898,8 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path38.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs34.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path39.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs35.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -61748,8 +61947,8 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 import * as http2 from "http";
-import * as fs38 from "fs";
-import * as path42 from "path";
+import * as fs39 from "fs";
+import * as path43 from "path";
 init_config();
 
 // src/daemon/scaffold-template.ts
@@ -62101,8 +62300,8 @@ init_builders();
 
 // src/daemon/dev-cdp-handlers.ts
 init_logger();
-import * as fs35 from "fs";
-import * as path39 from "path";
+import * as fs36 from "fs";
+import * as path40 from "path";
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
   const { expression, timeout, ideType } = body;
@@ -62280,18 +62479,18 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path39.join(dir, "scripts.js");
-  if (fs35.existsSync(directScripts)) {
+  const directScripts = path40.join(dir, "scripts.js");
+  if (fs36.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path39.join(dir, "scripts");
-    if (fs35.existsSync(scriptsDir)) {
-      const versions = fs35.readdirSync(scriptsDir).filter((d) => {
-        return fs35.statSync(path39.join(scriptsDir, d)).isDirectory();
+    const scriptsDir = path40.join(dir, "scripts");
+    if (fs36.existsSync(scriptsDir)) {
+      const versions = fs36.readdirSync(scriptsDir).filter((d) => {
+        return fs36.statSync(path40.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path39.join(scriptsDir, ver, "scripts.js");
-        if (fs35.existsSync(p)) {
+        const p = path40.join(scriptsDir, ver, "scripts.js");
+        if (fs36.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -62303,7 +62502,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs35.readFileSync(scriptsPath, "utf-8");
+    const source = fs36.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -63118,8 +63317,8 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-import * as fs36 from "fs";
-import * as path40 from "path";
+import * as fs37 from "fs";
+import * as path41 from "path";
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || `fixture-${Date.now()}`;
@@ -63129,15 +63328,15 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path40.join(providerDir, "fixtures");
+  return path41.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path40.join(fixtureDir, `${name}.json`);
-  if (!fs36.existsSync(filePath)) {
+  const filePath = path41.join(fixtureDir, `${name}.json`);
+  if (!fs37.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs36.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs37.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -63882,7 +64081,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs36.mkdirSync(fixtureDir, { recursive: true });
+    fs37.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -63909,8 +64108,8 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path40.join(fixtureDir, `${name}.json`);
-    fs36.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    const filePath = path41.join(fixtureDir, `${name}.json`);
+    fs37.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -63928,14 +64127,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs36.existsSync(fixtureDir)) {
+    if (!fs37.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs36.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
-      const fullPath = path40.join(fixtureDir, file);
+    const fixtures = fs37.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
+      const fullPath = path41.join(fixtureDir, file);
       try {
-        const raw = JSON.parse(fs36.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs37.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file.replace(/\.json$/i, ""),
           path: fullPath,
@@ -64068,9 +64267,9 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-import * as fs37 from "fs";
-import * as path41 from "path";
-import * as os29 from "os";
+import * as fs38 from "fs";
+import * as path42 from "path";
+import * as os30 from "os";
 import { DEFAULT_SESSION_HOST_COLS as DEFAULT_SESSION_HOST_COLS7, DEFAULT_SESSION_HOST_ROWS as DEFAULT_SESSION_HOST_ROWS7 } from "@adhdev/session-host-core";
 function getAutoImplPid(ctx) {
   const pid = ctx.autoImplProcess?.pid;
@@ -64117,38 +64316,38 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs37.existsSync(scriptsDir)) return null;
-  const versions = fs37.readdirSync(scriptsDir).filter((d) => {
+  if (!fs38.existsSync(scriptsDir)) return null;
+  const versions = fs38.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs37.statSync(path41.join(scriptsDir, d)).isDirectory();
+      return fs38.statSync(path42.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
   if (versions.length === 0) return null;
-  return path41.join(scriptsDir, versions[0]);
+  return path42.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path41.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path41.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path41.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path41.sep}`)) {
+  const canonicalUserDir = path42.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path42.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path42.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path42.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path41.basename(desiredDir) !== type) {
+  if (path42.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs37.existsSync(desiredDir)) {
-    fs37.mkdirSync(path41.dirname(desiredDir), { recursive: true });
-    fs37.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs38.existsSync(desiredDir)) {
+    fs38.mkdirSync(path42.dirname(desiredDir), { recursive: true });
+    fs38.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path41.join(desiredDir, "provider.json");
-  if (!fs37.existsSync(providerJson)) {
+  const providerJson = path42.join(desiredDir, "provider.json");
+  if (!fs38.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   return { dir: desiredDir };
@@ -64156,15 +64355,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs37.existsSync(refDir)) return {};
+  if (!refDir || !fs38.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path41.join(refDir, "scripts");
+  const scriptsDir = path42.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file of fs37.readdirSync(latestDir)) {
+  for (const file of fs38.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs37.readFileSync(path41.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs38.readFileSync(path42.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -64272,16 +64471,16 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path41.join(os29.tmpdir(), "adhdev-autoimpl");
-    if (!fs37.existsSync(tmpDir)) fs37.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path41.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs37.writeFileSync(promptFile, prompt, "utf-8");
+    const tmpDir = path42.join(os30.tmpdir(), "adhdev-autoimpl");
+    if (!fs38.existsSync(tmpDir)) fs38.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path42.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    fs38.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
     const spawn5 = agentProvider?.spawn;
     if (!spawn5?.command) {
       try {
-        fs37.unlinkSync(promptFile);
+        fs38.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -64383,7 +64582,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs37.unlinkSync(promptFile);
+          fs38.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -64427,7 +64626,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn5.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os29.platform() === "win32";
+    const isWin = os30.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     const promptMode = autoImpl?.promptMode ?? "stdin";
     const extraArgs = autoImpl?.extraArgs ?? [];
@@ -64466,7 +64665,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty = __require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os29.platform() === "win32";
+      const isWin2 = os30.platform() === "win32";
       child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: DEFAULT_SESSION_HOST_COLS7,
@@ -64609,7 +64808,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs37.unlinkSync(promptFile);
+        fs38.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -64706,7 +64905,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path41.join(providerDir, "scripts");
+  const scriptsDir = path42.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -64714,10 +64913,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file of fs37.readdirSync(latestScriptsDir)) {
+    for (const file of fs38.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs37.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+          const content = fs38.readFileSync(path42.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -64727,14 +64926,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs37.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs38.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs37.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+          const content = fs38.readFileSync(path42.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -64775,11 +64974,11 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path41.join(providerDir, "../../docs");
+  const docsDir = path42.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path41.join(docsDir, name);
-      if (fs37.existsSync(p)) return fs37.readFileSync(p, "utf-8");
+      const p = path42.join(docsDir, name);
+      if (fs38.existsSync(p)) return fs38.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -65015,7 +65214,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path41.join(providerDir, "scripts");
+  const scriptsDir = path42.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -65023,11 +65222,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file of fs37.readdirSync(latestScriptsDir)) {
+    for (const file of fs38.readdirSync(latestScriptsDir)) {
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs37.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+        const content = fs38.readFileSync(path42.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -65036,14 +65235,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs37.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs38.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs37.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+          const content = fs38.readFileSync(path42.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -65076,11 +65275,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path41.join(providerDir, "../../docs");
+  const docsDir = path42.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path41.join(docsDir, name);
-      if (fs37.existsSync(p)) return fs37.readFileSync(p, "utf-8");
+      const p = path42.join(docsDir, name);
+      if (fs38.existsSync(p)) return fs38.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -65526,8 +65725,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path44 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path44}`;
+      const path45 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path45}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -65815,12 +66014,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path42.resolve(__dirname, "../../web-devconsole/dist"),
-      path42.resolve(__dirname, "../../../web-devconsole/dist"),
-      path42.join(process.cwd(), "packages/web-devconsole/dist")
+      path43.resolve(__dirname, "../../web-devconsole/dist"),
+      path43.resolve(__dirname, "../../../web-devconsole/dist"),
+      path43.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs38.existsSync(path42.join(dir, "index.html"))) return dir;
+      if (fs39.existsSync(path43.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -65830,9 +66029,9 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path42.join(distDir, "index.html");
+    const htmlPath = path43.join(distDir, "index.html");
     try {
-      const html = fs38.readFileSync(htmlPath, "utf-8");
+      const html = fs39.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -65855,15 +66054,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path42.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path42.join(distDir, safePath);
+    const safePath = path43.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path43.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      const content = fs38.readFileSync(filePath);
-      const ext = path42.extname(filePath);
+      const content = fs39.readFileSync(filePath);
+      const ext = path43.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
       res.end(content);
@@ -65971,14 +66170,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs38.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs39.readdirSync(d, { withFileTypes: true })) {
           if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path42.join(d, entry.name), rel);
+            scan(path43.join(d, entry.name), rel);
           } else {
-            const stat2 = fs38.statSync(path42.join(d, entry.name));
+            const stat2 = fs39.statSync(path43.join(d, entry.name));
             files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
@@ -66001,16 +66200,16 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path42.resolve(dir, path42.normalize(filePath));
+    const fullPath = path43.resolve(dir, path43.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs38.existsSync(fullPath) || fs38.statSync(fullPath).isDirectory()) {
+    if (!fs39.existsSync(fullPath) || fs39.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs38.readFileSync(fullPath, "utf-8");
+    const content = fs39.readFileSync(fullPath, "utf-8");
     this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
   }
   /** POST /api/providers/:type/file — write a file { path, content } */
@@ -66026,15 +66225,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path42.resolve(dir, path42.normalize(filePath));
+    const fullPath = path43.resolve(dir, path43.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      if (fs38.existsSync(fullPath)) fs38.copyFileSync(fullPath, fullPath + ".bak");
-      fs38.mkdirSync(path42.dirname(fullPath), { recursive: true });
-      fs38.writeFileSync(fullPath, content, "utf-8");
+      if (fs39.existsSync(fullPath)) fs39.copyFileSync(fullPath, fullPath + ".bak");
+      fs39.mkdirSync(path43.dirname(fullPath), { recursive: true });
+      fs39.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -66050,9 +66249,9 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path42.join(dir, name);
-      if (fs38.existsSync(p)) {
-        const source = fs38.readFileSync(p, "utf-8");
+      const p = path43.join(dir, name);
+      if (fs39.existsSync(p)) {
+        const source = fs39.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -66071,11 +66270,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs38.existsSync(path42.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path42.join(dir, target);
+    const target = fs39.existsSync(path43.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path43.join(dir, target);
     try {
-      if (fs38.existsSync(targetPath)) fs38.copyFileSync(targetPath, targetPath + ".bak");
-      fs38.writeFileSync(targetPath, source, "utf-8");
+      if (fs39.existsSync(targetPath)) fs39.copyFileSync(targetPath, targetPath + ".bak");
+      fs39.writeFileSync(targetPath, source, "utf-8");
       this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -66219,21 +66418,21 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path42.join(targetDir, "provider.json");
-    if (fs38.existsSync(jsonPath)) {
+    const jsonPath = path43.join(targetDir, "provider.json");
+    if (fs39.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames });
-      fs38.mkdirSync(targetDir, { recursive: true });
-      fs38.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs39.mkdirSync(targetDir, { recursive: true });
+      fs39.writeFileSync(jsonPath, result["provider.json"], "utf-8");
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path42.join(targetDir, relPath);
-          fs38.mkdirSync(path42.dirname(fullPath), { recursive: true });
-          fs38.writeFileSync(fullPath, content, "utf-8");
+          const fullPath = path43.join(targetDir, relPath);
+          fs39.mkdirSync(path43.dirname(fullPath), { recursive: true });
+          fs39.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -66282,38 +66481,38 @@ var DevServer = class _DevServer {
   }
   // ─── Phase 2: Auto-Implement Backend ───
   getLatestScriptVersionDir(scriptsDir) {
-    if (!fs38.existsSync(scriptsDir)) return null;
-    const versions = fs38.readdirSync(scriptsDir).filter((d) => {
+    if (!fs39.existsSync(scriptsDir)) return null;
+    const versions = fs39.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs38.statSync(path42.join(scriptsDir, d)).isDirectory();
+        return fs39.statSync(path43.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
     }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
     if (versions.length === 0) return null;
-    return path42.join(scriptsDir, versions[0]);
+    return path43.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path42.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path42.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path42.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path42.sep}`)) {
+    const canonicalUserDir = path43.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path43.resolve(requestedDir) : canonicalUserDir;
+    const upstreamRoot = path43.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path43.sep}`)) {
       return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
-    if (path42.basename(desiredDir) !== type) {
+    if (path43.basename(desiredDir) !== type) {
       return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
     const sourceDir = this.findProviderDir(type);
     if (!sourceDir) {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
-    if (!fs38.existsSync(desiredDir)) {
-      fs38.mkdirSync(path42.dirname(desiredDir), { recursive: true });
-      fs38.cpSync(sourceDir, desiredDir, { recursive: true });
+    if (!fs39.existsSync(desiredDir)) {
+      fs39.mkdirSync(path43.dirname(desiredDir), { recursive: true });
+      fs39.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
-    const providerJson = path42.join(desiredDir, "provider.json");
-    if (!fs38.existsSync(providerJson)) {
+    const providerJson = path43.join(desiredDir, "provider.json");
+    if (!fs39.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
     return { dir: desiredDir };
@@ -67162,9 +67361,9 @@ async function listHostedCliRuntimes(endpoint) {
 
 // src/session-host/managed-host.ts
 import { execFileSync as execFileSync9, spawn as spawn4 } from "child_process";
-import * as fs39 from "fs";
-import * as os30 from "os";
-import * as path43 from "path";
+import * as fs40 from "fs";
+import * as os31 from "os";
+import * as path44 from "path";
 import {
   getDefaultSessionHostEndpoint as getDefaultSessionHostEndpoint2,
   sanitizeSpawnEnv as sanitizeSpawnEnv2
@@ -67182,24 +67381,24 @@ function createManagedSessionHost(options) {
   }
   function resolveEntry() {
     const packagedCandidates = [
-      path43.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-      path43.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+      path44.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+      path44.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
     ];
     for (const candidate of packagedCandidates) {
-      if (fs39.existsSync(candidate)) {
+      if (fs40.existsSync(candidate)) {
         return candidate;
       }
     }
     return __require.resolve("@adhdev/session-host-daemon");
   }
   function getPidFile() {
-    return path43.join(os30.homedir(), ".adhdev", `${appName}-session-host.pid`);
+    return path44.join(os31.homedir(), ".adhdev", `${appName}-session-host.pid`);
   }
   function getPid() {
     try {
       const pidFile = getPidFile();
-      if (!fs39.existsSync(pidFile)) return null;
-      const pid = Number.parseInt(fs39.readFileSync(pidFile, "utf8").trim(), 10);
+      if (!fs40.existsSync(pidFile)) return null;
+      const pid = Number.parseInt(fs40.readFileSync(pidFile, "utf8").trim(), 10);
       return Number.isFinite(pid) ? pid : null;
     } catch {
       return null;
@@ -67224,9 +67423,9 @@ function createManagedSessionHost(options) {
     let stdio = "ignore";
     let logFd = null;
     if (options.spawnStdio === "logfile") {
-      const logDir = path43.join(os30.homedir(), ".adhdev", "logs");
-      fs39.mkdirSync(logDir, { recursive: true });
-      logFd = fs39.openSync(path43.join(logDir, "session-host.log"), "a");
+      const logDir = path44.join(os31.homedir(), ".adhdev", "logs");
+      fs40.mkdirSync(logDir, { recursive: true });
+      logFd = fs40.openSync(path44.join(logDir, "session-host.log"), "a");
       stdio = ["ignore", logFd, logFd];
     }
     const child = spawn4(process.execPath, [entry], {
@@ -67238,7 +67437,7 @@ function createManagedSessionHost(options) {
     child.unref();
     if (logFd !== null) {
       try {
-        fs39.closeSync(logFd);
+        fs40.closeSync(logFd);
       } catch {
       }
     }
@@ -67247,8 +67446,8 @@ function createManagedSessionHost(options) {
     let stopped = false;
     const pidFile = getPidFile();
     try {
-      if (fs39.existsSync(pidFile)) {
-        const pid = Number.parseInt(fs39.readFileSync(pidFile, "utf8").trim(), 10);
+      if (fs40.existsSync(pidFile)) {
+        const pid = Number.parseInt(fs40.readFileSync(pidFile, "utf8").trim(), 10);
         if (Number.isFinite(pid) && pid !== process.pid && isManagedPid(pid)) {
           stopped = killPid2(pid) || stopped;
         }
@@ -67256,7 +67455,7 @@ function createManagedSessionHost(options) {
     } catch {
     } finally {
       try {
-        fs39.unlinkSync(pidFile);
+        fs40.unlinkSync(pidFile);
       } catch {
       }
     }
@@ -67442,8 +67641,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs40 = await import("fs");
-        fs40.writeFileSync(vsixPath, buffer);
+        const fs41 = await import("fs");
+        fs41.writeFileSync(vsixPath, buffer);
         return new Promise((resolve25) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           exec6(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
@@ -68042,7 +68241,7 @@ import { dirname as dirname15, resolve as resolve23 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
 import { readFileSync as readFileSync41, existsSync as existsSync54 } from "fs";
-import { resolve as resolve24, dirname as dirname16, join as join49 } from "path";
+import { resolve as resolve24, dirname as dirname16, join as join50 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
 init_manifest();