@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-PXRCXGLK.js

@@ -0,0 +1,1865 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ensureYaziProfile,
+  yaziProfileDir
+} from "./chunk-U26XXPJS.js";
+import {
+  namingCompatibilityEnvironment
+} from "./chunk-O63U2I6I.js";
+import {
+  describeResolution,
+  resolveToolBinary,
+  toolStatus
+} from "./chunk-53OXPRI6.js";
+import {
+  findPinnedTool
+} from "./chunk-2EMLKSCX.js";
+import {
+  clioCacheDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  resolvePackageRoot
+} from "./chunk-ZPST2KQO.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/mux/index.ts
+init_esm_shims();
+
+// src/domains/mux/extension.ts
+init_esm_shims();
+
+// src/domains/mux/contract.ts
+init_esm_shims();
+
+// src/domains/mux/dock-controller.ts
+init_esm_shims();
+var DOCK_SPECS = {
+  workers: { slot: "workers", direction: "right", defaultShare: 0.34, minCells: 48 },
+  files: { slot: "files", direction: "down", defaultShare: 0.3, minCells: 12 }
+};
+var DOCK_MAX_SHARE = 0.5;
+var SHARE_EPSILON = 0.02;
+function ratioForDockShare(share) {
+  return 1 - share;
+}
+function clampDockShare(share) {
+  if (!Number.isFinite(share) || share <= 0) return DOCK_SPECS.workers.defaultShare;
+  return Math.min(DOCK_MAX_SHARE, share);
+}
+function axisCells(rect, spec) {
+  return spec.direction === "right" ? rect.width : rect.height;
+}
+function deriveSplitPath(root, anchorPaneId, dockPaneId) {
+  const contains = (node, paneId) => {
+    if (node.type === "pane") return node.paneId === paneId;
+    return contains(node.first, paneId) || contains(node.second, paneId);
+  };
+  const walk = (node, path) => {
+    if (node.type !== "split") return null;
+    const dockFirst = contains(node.first, dockPaneId);
+    const dockSecond = contains(node.second, dockPaneId);
+    const anchorFirst = contains(node.first, anchorPaneId);
+    const anchorSecond = contains(node.second, anchorPaneId);
+    if (dockFirst && anchorSecond) return { path, dockIsSecond: false, direction: node.direction };
+    if (dockSecond && anchorFirst) return { path, dockIsSecond: true, direction: node.direction };
+    if (dockFirst && anchorFirst) return walk(node.first, [...path, false]);
+    if (dockSecond && anchorSecond) return walk(node.second, [...path, true]);
+    return null;
+  };
+  return walk(root, []);
+}
+function containsRect(outer, inner) {
+  return outer.x <= inner.x && outer.y <= inner.y && outer.x + outer.width >= inner.x + inner.width && outer.y + outer.height >= inner.y + inner.height;
+}
+function observedDockShare(geometry, spec, anchorPaneId, dockPaneId) {
+  const anchor = geometry.panes.find((pane) => pane.paneId === anchorPaneId);
+  const dock = geometry.panes.find((pane) => pane.paneId === dockPaneId);
+  if (!anchor || !dock) return null;
+  let separating = null;
+  for (const split of geometry.splits) {
+    if (!containsRect(split.rect, anchor.rect) || !containsRect(split.rect, dock.rect)) continue;
+    if (!separating || split.rect.width * split.rect.height < separating.rect.width * separating.rect.height) {
+      separating = split;
+    }
+  }
+  if (!separating || separating.direction !== spec.direction) return null;
+  const dockIsSecond = spec.direction === "right" ? dock.rect.x > anchor.rect.x : dock.rect.y > anchor.rect.y;
+  return dockIsSecond ? 1 - separating.ratio : separating.ratio;
+}
+function planDockOpen(anchorRect, spec, requestedShare) {
+  const axis = axisCells(anchorRect, spec);
+  if (axis * DOCK_MAX_SHARE < spec.minCells) {
+    return {
+      refused: `the ${spec.slot} dock needs ${spec.minCells} cells and at most half of ${axis} is available`
+    };
+  }
+  const share = Math.max(clampDockShare(requestedShare ?? spec.defaultShare), spec.minCells / axis);
+  return { direction: spec.direction, ratio: ratioForDockShare(share), share };
+}
+function createDockController(options) {
+  const { client, anchorPaneId } = options;
+  const log = options.log ?? (() => void 0);
+  const bySlot = /* @__PURE__ */ new Map();
+  const applyShare = async (state, share) => {
+    const tree = await client.layoutExport({ tabId: state.tabId });
+    const derived = deriveSplitPath(tree.root, anchorPaneId, state.paneId);
+    if (!derived) {
+      log("debug", `mux ${state.slot} dock split path is gone from ${state.tabId}; leaving layout alone`);
+      return false;
+    }
+    if (derived.direction !== DOCK_SPECS[state.slot].direction) {
+      log("debug", `mux ${state.slot} dock split runs ${derived.direction}; declining the wrong-axis resize`);
+      return false;
+    }
+    const ratio = derived.dockIsSecond ? ratioForDockShare(share) : share;
+    await client.layoutSetSplitRatio({ tabId: state.tabId, path: derived.path, ratio });
+    state.targetShare = share;
+    state.lastAppliedShare = share;
+    return true;
+  };
+  return {
+    states() {
+      return [...bySlot.values()].map((state) => ({ ...state }));
+    },
+    stateFor(slot) {
+      const state = bySlot.get(slot);
+      return state ? { ...state } : null;
+    },
+    async open(slot, openOptions = {}) {
+      const existing = bySlot.get(slot);
+      if (existing) {
+        return { paneId: existing.paneId, tabId: existing.tabId, workspaceId: "" };
+      }
+      const spec = DOCK_SPECS[slot];
+      const geometry = await client.paneLayout(anchorPaneId);
+      const anchorRect = geometry.panes.find((pane2) => pane2.paneId === anchorPaneId)?.rect;
+      if (!anchorRect) {
+        openOptions.onRefused?.(`no anchor geometry for ${anchorPaneId}; check the pane host layout before trying again`);
+        log("debug", `mux ${slot} dock open found no anchor rect for ${anchorPaneId}`);
+        return null;
+      }
+      const plan = planDockOpen(anchorRect, spec, openOptions.share);
+      if ("refused" in plan) {
+        openOptions.onRefused?.(`${plan.refused}; enlarge the anchor pane before trying again`);
+        log("info", `mux ${slot} dock refused: ${plan.refused}`);
+        return null;
+      }
+      const pane = await client.paneSplit({
+        direction: plan.direction,
+        targetPaneId: anchorPaneId,
+        ratio: plan.ratio,
+        focus: false,
+        ...openOptions.cwd !== void 0 ? { cwd: openOptions.cwd } : {},
+        ...openOptions.env ? { env: openOptions.env } : {}
+      });
+      const state = {
+        slot,
+        paneId: pane.paneId,
+        tabId: pane.tabId,
+        targetShare: plan.share,
+        lastAppliedShare: plan.share
+      };
+      bySlot.set(slot, state);
+      try {
+        const after = await client.paneLayout(anchorPaneId);
+        const dockRect = after.panes.find((entry) => entry.paneId === pane.paneId)?.rect;
+        if (dockRect && axisCells(dockRect, spec) < spec.minCells) {
+          const anchorAfter = after.panes.find((entry) => entry.paneId === anchorPaneId)?.rect;
+          const total = anchorAfter ? axisCells(anchorAfter, spec) + axisCells(dockRect, spec) : 0;
+          if (total > 0) await applyShare(state, Math.min(DOCK_MAX_SHARE, spec.minCells / total));
+        }
+      } catch (error) {
+        log("debug", `mux ${slot} dock converge skipped: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+    },
+    adopt(slot, ref) {
+      const spec = DOCK_SPECS[slot];
+      bySlot.set(slot, {
+        slot,
+        paneId: ref.paneId,
+        tabId: ref.tabId,
+        // The surviving pane's actual share is adopted lazily by the next
+        // layout observation; until then the default is the best guess.
+        targetShare: spec.defaultShare,
+        lastAppliedShare: spec.defaultShare
+      });
+    },
+    async resize(slot, share) {
+      const state = bySlot.get(slot);
+      if (!state) return false;
+      return await applyShare(state, Math.max(clampDockShare(share), 0.01));
+    },
+    noteLayoutUpdated(geometry) {
+      for (const state of bySlot.values()) {
+        if (state.tabId !== geometry.tabId) continue;
+        const observed = observedDockShare(geometry, DOCK_SPECS[state.slot], anchorPaneId, state.paneId);
+        if (observed === null) continue;
+        if (Math.abs(observed - state.targetShare) <= SHARE_EPSILON) continue;
+        if (Math.abs(observed - state.lastAppliedShare) <= SHARE_EPSILON) continue;
+        log("debug", `mux ${state.slot} dock resized by the user to ${(observed * 100).toFixed(0)}%`);
+        state.targetShare = observed;
+        state.lastAppliedShare = observed;
+      }
+    },
+    notePaneGone(paneId) {
+      for (const [slot, state] of bySlot) {
+        if (state.paneId === paneId) bySlot.delete(slot);
+      }
+    },
+    notePaneMoved(previousPaneId, paneId, tabId) {
+      for (const state of bySlot.values()) {
+        if (state.paneId !== previousPaneId) continue;
+        state.paneId = paneId;
+        state.tabId = tabId;
+      }
+    },
+    paneIds() {
+      return [...bySlot.values()].map((state) => state.paneId);
+    },
+    clear() {
+      bySlot.clear();
+    }
+  };
+}
+
+// src/domains/mux/pane-registry.ts
+init_esm_shims();
+function createPaneRegistry() {
+  const byPane = /* @__PURE__ */ new Map();
+  return {
+    record(entry) {
+      byPane.set(entry.ref.paneId, entry);
+    },
+    byPaneId(paneId) {
+      return byPane.get(paneId) ?? null;
+    },
+    byPurpose(purpose) {
+      let newest = null;
+      for (const entry of byPane.values()) {
+        if (entry.purpose === purpose) newest = entry;
+      }
+      return newest;
+    },
+    owns(paneId) {
+      return byPane.has(paneId);
+    },
+    forget(paneId) {
+      const entry = byPane.get(paneId);
+      if (!entry) return null;
+      byPane.delete(paneId);
+      return entry;
+    },
+    reconcile(livePaneIds) {
+      const live = new Set(livePaneIds);
+      const dropped = [];
+      for (const [paneId, entry] of byPane) {
+        if (!live.has(paneId)) dropped.push(entry);
+      }
+      for (const entry of dropped) byPane.delete(entry.ref.paneId);
+      return dropped;
+    },
+    list() {
+      return [...byPane.values()];
+    },
+    clear() {
+      byPane.clear();
+    }
+  };
+}
+function paneRecord(ref, fields) {
+  return {
+    ref,
+    purpose: fields.purpose,
+    label: fields.label,
+    openedAt: fields.openedAt,
+    ...fields.adopted === true ? { adopted: true } : {}
+  };
+}
+
+// src/domains/mux/protocol.ts
+init_esm_shims();
+var MUX_METHOD_MIN_PROTOCOL = {
+  "notification.show": 17,
+  "pane.rename": 17,
+  "pane.focus": 17,
+  "pane.zoom": 17,
+  "layout.export": 17,
+  "layout.set_split_ratio": 17,
+  "worktree.list": 10,
+  "worktree.create": 10,
+  "worktree.open": 10,
+  "worktree.remove": 10
+};
+function muxSupportsMethod(server, method) {
+  if (server === null) return false;
+  return server.protocol >= MUX_METHOD_MIN_PROTOCOL[method];
+}
+
+// src/domains/mux/types.ts
+init_esm_shims();
+var MuxError = class extends Error {
+  kind;
+  /** The server's raw error code, when the failure came back over the wire. */
+  wireCode;
+  method;
+  constructor(kind, message, options = {}) {
+    super(message);
+    this.name = "MuxError";
+    this.kind = kind;
+    this.wireCode = options.wireCode ?? null;
+    this.method = options.method ?? null;
+  }
+};
+var MuxRequestTimeout = class extends MuxError {
+  timeoutMs;
+  constructor(method, timeoutMs) {
+    super("timeout", `mux request ${method} timed out after ${timeoutMs}ms`, { method });
+    this.name = "MuxRequestTimeout";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var ERROR_KIND_BY_WIRE_CODE = {
+  agent_blocked: "agent_blocked",
+  agent_prompt_stalled: "agent_prompt_stalled",
+  feature_disabled: "feature_disabled",
+  invalid_params: "invalid_params",
+  invalid_request: "invalid_params",
+  not_found: "not_found"
+};
+function muxErrorKind(wireCode) {
+  const mapped = ERROR_KIND_BY_WIRE_CODE[wireCode];
+  if (mapped) return mapped;
+  if (wireCode.endsWith("_not_found")) return "not_found";
+  if (wireCode.startsWith("invalid_")) return "invalid_params";
+  return "unknown";
+}
+
+// src/domains/mux/contract.ts
+var METADATA_SOURCE = "clio-coder:mux";
+var SELF_AGENT_SOURCE = "clio-coder:coder";
+var OWNER_TOKEN_KEY = "clio_coder_owner";
+var OWNER_TOKEN_VALUE = "clio-coder:mux";
+var LEGACY_OWNER_TOKEN_KEY = "clio_owner";
+var LEGACY_OWNER_TOKEN_VALUE = "clio:mux";
+var TOKEN_VALUE_MAX = 80;
+var DEGRADE_COOLDOWN_MS = 5e3;
+function shellQuote(argv) {
+  return argv.map((arg) => `'${arg.replaceAll("'", `'\\''`)}'`).join(" ");
+}
+function token(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value.length > TOKEN_VALUE_MAX ? value.slice(0, TOKEN_VALUE_MAX) : value;
+}
+function hasOwnedPaneToken(tokens) {
+  return tokens[OWNER_TOKEN_KEY] === OWNER_TOKEN_VALUE || tokens[LEGACY_OWNER_TOKEN_KEY] === LEGACY_OWNER_TOKEN_VALUE;
+}
+function createMuxRuntime(options) {
+  const { detection, client } = options;
+  const log = options.log ?? (() => void 0);
+  const now = options.now ?? Date.now;
+  const registry = createPaneRegistry();
+  const anchorPaneId = detection.self.paneId;
+  const docks = client !== null && anchorPaneId !== null && muxSupportsMethod(detection.server, "layout.export") ? createDockController({ client, anchorPaneId, log }) : null;
+  let healthy = client !== null;
+  let probeHealthAt = 0;
+  let stopped = false;
+  let subscription = null;
+  const paneGoneHandlers = /* @__PURE__ */ new Set();
+  const degrade = (what, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const transport = error instanceof MuxError && (error.kind === "transport" || error.kind === "timeout");
+    if (transport) {
+      healthy = false;
+      probeHealthAt = now() + DEGRADE_COOLDOWN_MS;
+    }
+    log(transport ? "warning" : "debug", `mux ${what} failed: ${message}`);
+  };
+  const usable = () => {
+    if (stopped || client === null || detection.mode === "none") return false;
+    return healthy || now() >= probeHealthAt;
+  };
+  const attempt = async (what, run, fallback, onError) => {
+    if (!usable() || client === null) return fallback;
+    try {
+      const value = await run(client);
+      healthy = true;
+      return value;
+    } catch (error) {
+      degrade(what, error);
+      onError?.(error);
+      return fallback;
+    }
+  };
+  const tagOwner = async (live, paneId, tokens, title) => {
+    await live.paneReportMetadata({
+      paneId,
+      source: METADATA_SOURCE,
+      ...title === void 0 ? {} : { title },
+      tokens: {
+        [OWNER_TOKEN_KEY]: OWNER_TOKEN_VALUE,
+        [LEGACY_OWNER_TOKEN_KEY]: LEGACY_OWNER_TOKEN_VALUE,
+        ...tokens
+      }
+    });
+  };
+  const onEvent = (event) => {
+    if (event.kind === "layout.updated") {
+      docks?.noteLayoutUpdated(event.geometry);
+      return;
+    }
+    if (event.kind === "pane.moved") {
+      const held = registry.forget(event.previousPaneId);
+      if (held) {
+        registry.record({ ...held, ref: { paneId: event.paneId, tabId: event.tabId, workspaceId: event.workspaceId } });
+        docks?.notePaneMoved(event.previousPaneId, event.paneId, event.tabId);
+      }
+      return;
+    }
+    docks?.notePaneGone(event.paneId);
+    const dropped = registry.forget(event.paneId);
+    if (dropped) {
+      log("debug", `mux pane ${event.paneId} left on ${event.kind}; dropped from the registry`);
+      for (const handler of paneGoneHandlers) {
+        try {
+          handler(dropped);
+        } catch (error) {
+          log("debug", `mux pane-gone handler threw: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  };
+  const contract = {
+    mode: detection.mode,
+    available() {
+      return usable();
+    },
+    detection() {
+      return detection;
+    },
+    async openUtilityPane(request) {
+      const report = (failure) => {
+        try {
+          request.onFailure?.(failure);
+        } catch {
+        }
+      };
+      const dockSlot = request.dock?.slot;
+      if (dockSlot && docks) {
+        const existing = docks.stateFor(dockSlot);
+        const held = existing ? registry.byPaneId(existing.paneId) : null;
+        if (held) return held.ref;
+      }
+      return await attempt(
+        "openUtilityPane",
+        async (live) => {
+          let ref;
+          if (request.dock && docks) {
+            const placed = await docks.open(request.dock.slot, {
+              onRefused: (message) => report({ source: "local", message }),
+              ...request.dock.share === void 0 ? {} : { share: request.dock.share },
+              cwd: request.cwd,
+              ...request.env ? { env: request.env } : {}
+            });
+            if (placed === null) return null;
+            ref = placed;
+          } else {
+            const anchor = anchorPaneId ?? (await live.paneCurrent()).paneId;
+            const pane = await live.paneSplit({
+              direction: request.direction ?? "right",
+              targetPaneId: anchor,
+              cwd: request.cwd,
+              focus: false,
+              ...request.env ? { env: request.env } : {}
+            });
+            ref = { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+          }
+          const purpose = request.purpose ?? "utility";
+          registry.record(paneRecord(ref, { purpose, label: request.label, openedAt: now() }));
+          const title = request.title;
+          const titleSupported = title !== void 0 && muxSupportsMethod(detection.server, "pane.rename");
+          if (titleSupported) {
+            try {
+              await live.paneRename(ref.paneId, title);
+            } catch {
+            }
+          }
+          await tagOwner(live, ref.paneId, { role: token(purpose) }, titleSupported ? title : void 0);
+          if (request.argv.length > 0) {
+            const redirect = request.stdoutPath ? ` > ${shellQuote([request.stdoutPath])}` : "";
+            await live.paneSendText(ref.paneId, `exec ${shellQuote(request.argv)}${redirect}
+`);
+          }
+          return ref;
+        },
+        null,
+        (error) => {
+          if (error instanceof MuxError) {
+            report({
+              source: "mux",
+              kind: error.kind,
+              wireCode: error.wireCode,
+              method: error.method,
+              message: error.message
+            });
+          } else {
+            report({ source: "local", message: error instanceof Error ? error.message : String(error) });
+          }
+        }
+      );
+    },
+    async closePane(paneId) {
+      if (!registry.owns(paneId)) return false;
+      return await attempt(
+        "closePane",
+        async (live) => {
+          await live.paneClose(paneId);
+          registry.forget(paneId);
+          docks?.notePaneGone(paneId);
+          return true;
+        },
+        false
+      );
+    },
+    async adoptPane(request) {
+      const existing = registry.byPurpose(request.purpose);
+      if (existing) return existing.ref;
+      return await attempt(
+        "adoptPane",
+        async (live) => {
+          const snapshot = await live.snapshot();
+          for (const pane of snapshot.panes) {
+            if (!hasOwnedPaneToken(pane.tokens)) continue;
+            if (pane.tokens.role !== request.purpose) continue;
+            if (registry.owns(pane.paneId)) continue;
+            if (detection.self.workspaceId !== null && pane.workspaceId !== detection.self.workspaceId) continue;
+            const ref = { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+            registry.record(
+              paneRecord(ref, { purpose: request.purpose, label: request.label, openedAt: now(), adopted: true })
+            );
+            if (request.dock && docks) docks.adopt(request.dock, ref);
+            log("info", `mux adopted a ${request.purpose} pane left open by a previous session`);
+            return ref;
+          }
+          return null;
+        },
+        null
+      );
+    },
+    async focusPane(paneId) {
+      if (!registry.owns(paneId)) return false;
+      if (!muxSupportsMethod(detection.server, "pane.focus")) return false;
+      return await attempt(
+        "focusPane",
+        async (live) => {
+          await live.paneFocus(paneId);
+          return true;
+        },
+        false
+      );
+    },
+    async zoomPane(paneId, mode) {
+      if (!registry.owns(paneId)) return false;
+      if (!muxSupportsMethod(detection.server, "pane.zoom")) return false;
+      return await attempt(
+        "zoomPane",
+        async (live) => {
+          const result = await live.paneZoom(paneId, mode);
+          return result.changed;
+        },
+        false
+      );
+    },
+    async focusSelf() {
+      if (anchorPaneId === null || !muxSupportsMethod(detection.server, "pane.focus")) return false;
+      return await attempt(
+        "focusSelf",
+        async (live) => {
+          await live.paneFocus(anchorPaneId);
+          return true;
+        },
+        false
+      );
+    },
+    async unzoomSelf() {
+      if (anchorPaneId === null || !muxSupportsMethod(detection.server, "pane.zoom")) return false;
+      return await attempt(
+        "unzoomSelf",
+        async (live) => {
+          const result = await live.paneZoom(anchorPaneId, "off");
+          return result.changed;
+        },
+        false
+      );
+    },
+    async resizeDock(slot, share) {
+      if (!docks) return false;
+      return await attempt("resizeDock", () => docks.resize(slot, share), false);
+    },
+    docks() {
+      return docks?.states() ?? [];
+    },
+    async notify(request) {
+      if (!muxSupportsMethod(detection.server, "notification.show")) {
+        log("debug", `mux notify skipped, server protocol is below the notification.show floor: ${request.title}`);
+        return;
+      }
+      await attempt(
+        "notify",
+        async (live) => {
+          const result = await live.notificationShow({
+            title: request.title,
+            ...request.body ? { body: request.body } : {},
+            ...request.sound ? { sound: request.sound } : {}
+          });
+          if (!result.shown) log("debug", `mux notify not shown (${result.reason}): ${request.title}`);
+          return void 0;
+        },
+        void 0
+      );
+    },
+    async worktreeCreate(request) {
+      if (!muxSupportsMethod(detection.server, "worktree.create")) {
+        log("debug", "mux worktree.create skipped, server protocol is below the worktree floor");
+        return null;
+      }
+      return await attempt("worktreeCreate", (live) => live.worktreeCreate(request), null);
+    },
+    async worktreeRemove(workspaceId, removeOptions = {}) {
+      if (!muxSupportsMethod(detection.server, "worktree.remove")) {
+        log("debug", "mux worktree.remove skipped, server protocol is below the worktree floor");
+        return false;
+      }
+      return await attempt(
+        "worktreeRemove",
+        async (live) => {
+          await live.worktreeRemove(workspaceId, removeOptions);
+          return true;
+        },
+        false
+      );
+    },
+    onPaneGone(handler) {
+      paneGoneHandlers.add(handler);
+      return () => {
+        paneGoneHandlers.delete(handler);
+      };
+    },
+    list() {
+      return registry.list();
+    },
+    async reportSelf(report) {
+      const paneId = detection.self.paneId;
+      if (detection.mode !== "guest" || !paneId) return false;
+      return await attempt(
+        "reportSelf",
+        async (live) => {
+          await live.paneReportAgent({
+            paneId,
+            source: SELF_AGENT_SOURCE,
+            agent: "clio-coder",
+            state: report.state,
+            ...report.message ? { message: report.message } : {}
+          });
+          if (report.tokens || report.stateLabels || report.ttlMs !== void 0) {
+            await live.paneReportMetadata({
+              paneId,
+              source: METADATA_SOURCE,
+              ...report.tokens ? { tokens: report.tokens } : {},
+              ...report.stateLabels ? { stateLabels: report.stateLabels } : {},
+              ...report.ttlMs !== void 0 ? { ttlMs: report.ttlMs } : {}
+            });
+          }
+          return true;
+        },
+        false
+      );
+    },
+    async shutdown() {
+      if (stopped) return;
+      stopped = true;
+      subscription?.close();
+      subscription = null;
+      paneGoneHandlers.clear();
+      if (client && docks) {
+        for (const paneId of docks.paneIds()) {
+          await client.paneClose(paneId).catch(() => void 0);
+          registry.forget(paneId);
+        }
+        docks.clear();
+      }
+      if (client) await client.close().catch(() => void 0);
+    }
+  };
+  const start = async () => {
+    if (detection.mode === "none" || client === null) return;
+    try {
+      const kinds = ["pane.closed", "pane.exited"];
+      if (docks) kinds.push("pane.moved", "layout.updated");
+      subscription = await client.subscribe(kinds, onEvent, {
+        onResync: (snapshot) => {
+          const dropped = registry.reconcile(snapshot.panes.map((pane) => pane.paneId));
+          for (const record2 of dropped) docks?.notePaneGone(record2.ref.paneId);
+          if (dropped.length > 0) {
+            log("info", `mux reconciled ${dropped.length} pane(s) closed while the socket was down`);
+          }
+        }
+      });
+    } catch (error) {
+      degrade("event subscription", error);
+    }
+  };
+  return { contract, start, stop: contract.shutdown, registry };
+}
+
+// src/domains/mux/detect.ts
+init_esm_shims();
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/domains/mux/socket-client.ts
+init_esm_shims();
+import * as net from "node:net";
+var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
+var DEFAULT_CONNECT_TIMEOUT_MS = 2e3;
+var DEFAULT_BACKOFF = { initialDelayMs: 250, maxDelayMs: 5e3, factor: 2 };
+var MAX_LINE_BYTES = 8 * 1024 * 1024;
+function connectSocket(socketPath, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect({ path: socketPath });
+    socket.setNoDelay(true);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new MuxError("transport", `mux socket connect to ${socketPath} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    const settle = (error) => {
+      clearTimeout(timer);
+      socket.removeListener("connect", onConnect);
+      socket.removeListener("error", onError);
+      if (error) {
+        socket.destroy();
+        reject(new MuxError("transport", `mux socket connect to ${socketPath} failed: ${error.message}`));
+        return;
+      }
+      resolve(socket);
+    };
+    const onConnect = () => settle(null);
+    const onError = (error) => settle(error);
+    socket.once("connect", onConnect);
+    socket.once("error", onError);
+  });
+}
+function readJsonLines(socket, onValue, onOverflow) {
+  let buffer = "";
+  socket.setEncoding("utf8");
+  socket.on("data", (chunk) => {
+    buffer += chunk;
+    if (buffer.length > MAX_LINE_BYTES) {
+      buffer = "";
+      onOverflow();
+      return;
+    }
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (line.length > 0) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          parsed = null;
+        }
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          onValue(parsed);
+        }
+      }
+      newline = buffer.indexOf("\n");
+    }
+  });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function requireString(source, key, context) {
+  const value = source[key];
+  if (typeof value !== "string") {
+    throw new MuxError("protocol", `mux ${context} response is missing string field ${key}`);
+  }
+  return value;
+}
+function optionalString(source, key) {
+  const value = source[key];
+  return typeof value === "string" ? value : null;
+}
+function stringMap(value) {
+  const source = asRecord(value);
+  if (!source) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(source)) {
+    if (typeof entry === "string") out[key] = entry;
+  }
+  return out;
+}
+var AGENT_STATES = /* @__PURE__ */ new Set(["idle", "working", "blocked", "done", "unknown"]);
+function readAgentState(value) {
+  return typeof value === "string" && AGENT_STATES.has(value) ? value : "unknown";
+}
+function readPane(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux pane response is not an object");
+  const revision = source.revision;
+  return {
+    paneId: requireString(source, "pane_id", "pane"),
+    tabId: requireString(source, "tab_id", "pane"),
+    workspaceId: requireString(source, "workspace_id", "pane"),
+    focused: source.focused === true,
+    agentState: readAgentState(source.agent_status),
+    revision: typeof revision === "number" ? revision : 0,
+    label: optionalString(source, "label"),
+    title: optionalString(source, "title"),
+    cwd: optionalString(source, "cwd"),
+    agent: optionalString(source, "agent"),
+    tokens: stringMap(source.tokens)
+  };
+}
+function readTab(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux tab response is not an object");
+  const number = source.number;
+  const paneCount = source.pane_count;
+  return {
+    tabId: requireString(source, "tab_id", "tab"),
+    workspaceId: requireString(source, "workspace_id", "tab"),
+    number: typeof number === "number" ? number : 0,
+    label: optionalString(source, "label") ?? "",
+    focused: source.focused === true,
+    paneCount: typeof paneCount === "number" ? paneCount : 0,
+    agentState: readAgentState(source.agent_status)
+  };
+}
+function readWorktree(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux worktree response is not an object");
+  return {
+    path: requireString(source, "path", "worktree"),
+    branch: optionalString(source, "branch"),
+    isBare: source.is_bare === true,
+    isDetached: source.is_detached === true,
+    isPrunable: source.is_prunable === true,
+    isLinkedWorktree: source.is_linked_worktree === true,
+    openWorkspaceId: optionalString(source, "open_workspace_id"),
+    label: optionalString(source, "label") ?? ""
+  };
+}
+function readWorktreeSource(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux worktree source response is not an object");
+  return {
+    repoKey: requireString(source, "repo_key", "worktree source"),
+    repoName: requireString(source, "repo_name", "worktree source"),
+    repoRoot: requireString(source, "repo_root", "worktree source"),
+    sourceCheckoutPath: requireString(source, "source_checkout_path", "worktree source"),
+    sourceWorkspaceId: optionalString(source, "source_workspace_id")
+  };
+}
+function readArray(source, key) {
+  const value = source[key];
+  return Array.isArray(value) ? value : [];
+}
+function readServerInfo(source) {
+  const protocol = source.protocol;
+  return {
+    version: optionalString(source, "version") ?? "",
+    protocol: typeof protocol === "number" ? protocol : 0
+  };
+}
+function readSnapshot(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux snapshot response is not an object");
+  return {
+    server: readServerInfo(source),
+    focusedPaneId: optionalString(source, "focused_pane_id"),
+    focusedTabId: optionalString(source, "focused_tab_id"),
+    focusedWorkspaceId: optionalString(source, "focused_workspace_id"),
+    panes: readArray(source, "panes").map(readPane),
+    tabs: readArray(source, "tabs").map(readTab)
+  };
+}
+function requireNumber(source, key, context) {
+  const value = source[key];
+  if (typeof value !== "number") {
+    throw new MuxError("protocol", `mux ${context} response is missing number field ${key}`);
+  }
+  return value;
+}
+function readRect(value, context) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", `mux ${context} rect is not an object`);
+  return {
+    x: requireNumber(source, "x", context),
+    y: requireNumber(source, "y", context),
+    width: requireNumber(source, "width", context),
+    height: requireNumber(source, "height", context)
+  };
+}
+function readSplitDirection(value, context) {
+  if (value === "right" || value === "down") return value;
+  throw new MuxError("protocol", `mux ${context} split direction is not right/down`);
+}
+function readTabGeometry(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux layout snapshot is not an object");
+  return {
+    workspaceId: requireString(source, "workspace_id", "layout"),
+    tabId: requireString(source, "tab_id", "layout"),
+    zoomed: source.zoomed === true,
+    area: readRect(source.area, "layout"),
+    focusedPaneId: optionalString(source, "focused_pane_id"),
+    panes: readArray(source, "panes").map((entry) => {
+      const pane = asRecord(entry);
+      if (!pane) throw new MuxError("protocol", "mux layout pane entry is not an object");
+      return {
+        paneId: requireString(pane, "pane_id", "layout pane"),
+        focused: pane.focused === true,
+        rect: readRect(pane.rect, "layout pane")
+      };
+    }),
+    splits: readArray(source, "splits").map((entry) => {
+      const split = asRecord(entry);
+      if (!split) throw new MuxError("protocol", "mux layout split entry is not an object");
+      return {
+        direction: readSplitDirection(split.direction, "layout"),
+        ratio: requireNumber(split, "ratio", "layout split"),
+        rect: readRect(split.rect, "layout split")
+      };
+    })
+  };
+}
+function readLayoutNode(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux layout node is not an object");
+  if (source.type === "pane") {
+    return { type: "pane", paneId: optionalString(source, "pane_id"), label: optionalString(source, "label") };
+  }
+  if (source.type === "split") {
+    return {
+      type: "split",
+      direction: readSplitDirection(source.direction, "layout tree"),
+      ratio: requireNumber(source, "ratio", "layout tree split"),
+      first: readLayoutNode(source.first),
+      second: readLayoutNode(source.second)
+    };
+  }
+  throw new MuxError("protocol", "mux layout node has an unknown type");
+}
+function readLayoutTree(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux layout tree is not an object");
+  return {
+    workspaceId: requireString(source, "workspace_id", "layout tree"),
+    tabId: requireString(source, "tab_id", "layout tree"),
+    zoomed: source.zoomed === true,
+    focusedPaneId: optionalString(source, "focused_pane_id"),
+    root: readLayoutNode(source.root)
+  };
+}
+var PANE_LEAVE_KIND_BY_WIRE = {
+  pane_closed: "pane.closed",
+  pane_exited: "pane.exited"
+};
+function readEvent(line) {
+  const wireKind = line.event;
+  if (typeof wireKind !== "string") return null;
+  const data = asRecord(line.data);
+  if (!data) return null;
+  const leaveKind = PANE_LEAVE_KIND_BY_WIRE[wireKind];
+  if (leaveKind) {
+    const paneId = data.pane_id;
+    const workspaceId = data.workspace_id;
+    if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
+    return { kind: leaveKind, paneId, workspaceId };
+  }
+  if (wireKind === "pane_moved") {
+    const pane = asRecord(data.pane);
+    const previousPaneId = data.previous_pane_id;
+    if (!pane || typeof previousPaneId !== "string") return null;
+    const paneId = pane.pane_id;
+    const tabId = pane.tab_id;
+    const workspaceId = pane.workspace_id;
+    if (typeof paneId !== "string" || typeof tabId !== "string" || typeof workspaceId !== "string") return null;
+    return { kind: "pane.moved", paneId, previousPaneId, tabId, workspaceId };
+  }
+  if (wireKind === "layout_updated") {
+    try {
+      return { kind: "layout.updated", geometry: readTabGeometry(data.layout) };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function params(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function createMuxClient(options) {
+  const socketPath = options.socketPath;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const backoff = options.backoff ?? DEFAULT_BACKOFF;
+  const log = options.log ?? (() => void 0);
+  let disposed = false;
+  let nextId = 0;
+  let reachable = false;
+  let serverInfo = null;
+  let snapshotCache = null;
+  let connectFailures = 0;
+  let retryAt = 0;
+  const delayFor = (failures) => Math.min(backoff.maxDelayMs, backoff.initialDelayMs * backoff.factor ** Math.max(0, failures - 1));
+  const call = async (method, callParams, timeoutMs) => {
+    if (disposed) throw new MuxError("transport", "mux client is closed");
+    const waitMs = retryAt - Date.now();
+    if (waitMs > 0) {
+      throw new MuxError("transport", `mux socket ${socketPath} is in backoff for another ${waitMs}ms`);
+    }
+    let socket;
+    try {
+      socket = await connectSocket(socketPath, connectTimeoutMs);
+    } catch (error) {
+      connectFailures += 1;
+      retryAt = Date.now() + delayFor(connectFailures);
+      reachable = false;
+      throw error;
+    }
+    connectFailures = 0;
+    retryAt = 0;
+    nextId += 1;
+    const id = `clio-${nextId}`;
+    const budget = timeoutMs ?? requestTimeoutMs;
+    try {
+      const result = await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (settle) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          socket.destroy();
+          settle();
+        };
+        const timer = setTimeout(() => finish(() => reject(new MuxRequestTimeout(method, budget))), budget);
+        timer.unref?.();
+        readJsonLines(
+          socket,
+          (line) => {
+            const responseId = line.id;
+            if (typeof responseId !== "string") return;
+            const error = asRecord(line.error);
+            if (responseId !== id && !(responseId === "" && error)) return;
+            if (error) {
+              const code = typeof error.code === "string" ? error.code : void 0;
+              const message = typeof error.message === "string" ? error.message : "no failure message was supplied by the pane host";
+              finish(
+                () => reject(
+                  new MuxError(muxErrorKind(code ?? "unknown"), message, {
+                    ...code === void 0 ? {} : { wireCode: code },
+                    method
+                  })
+                )
+              );
+              return;
+            }
+            finish(() => resolve(line.result));
+          },
+          () => finish(() => reject(new MuxError("protocol", `mux ${method} response line was oversized`, { method })))
+        );
+        socket.on(
+          "error",
+          (error) => finish(() => reject(new MuxError("transport", `mux request ${method} failed: ${error.message}`, { method })))
+        );
+        socket.on(
+          "close",
+          () => finish(() => reject(new MuxError("transport", `mux request ${method} lost its connection`, { method })))
+        );
+        socket.write(`${JSON.stringify({ id, method, params: callParams })}
+`, (error) => {
+          if (!error) return;
+          finish(
+            () => reject(new MuxError("transport", `mux request ${method} failed to write: ${error.message}`, { method }))
+          );
+        });
+      });
+      reachable = true;
+      return result;
+    } catch (error) {
+      if (error instanceof MuxError && error.kind === "transport") reachable = false;
+      throw error;
+    }
+  };
+  const callObject = async (method, callParams, timeoutMs) => {
+    const result = asRecord(await call(method, callParams, timeoutMs));
+    if (!result) throw new MuxError("protocol", `mux ${method} returned a non-object result`, { method });
+    return result;
+  };
+  const snapshot = async () => {
+    const result = await callObject("session.snapshot", {});
+    const parsed = readSnapshot(result.snapshot);
+    snapshotCache = parsed;
+    serverInfo = parsed.server;
+    return parsed;
+  };
+  const subscribe = async (kinds, handler, subscribeOptions = {}) => {
+    let closed = false;
+    let socket = null;
+    let retryTimer = null;
+    let failures = 0;
+    const scheduleReopen = () => {
+      if (closed || disposed) return;
+      failures += 1;
+      const delay = delayFor(failures);
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        void open(true);
+      }, delay);
+      retryTimer.unref?.();
+    };
+    const open = async (isReconnect) => {
+      if (closed || disposed) return;
+      let stream;
+      try {
+        stream = await connectSocket(socketPath, connectTimeoutMs);
+      } catch (error) {
+        log("debug", `mux event stream connect failed: ${error instanceof Error ? error.message : String(error)}`);
+        scheduleReopen();
+        return;
+      }
+      if (closed || disposed) {
+        stream.destroy();
+        return;
+      }
+      socket = stream;
+      let acknowledged = false;
+      readJsonLines(
+        stream,
+        (line) => {
+          if (!acknowledged && typeof line.id === "string") {
+            acknowledged = true;
+            failures = 0;
+            if (isReconnect) {
+              void snapshot().then(
+                (fresh) => subscribeOptions.onResync?.(fresh),
+                (error) => log("debug", `mux snapshot re-bootstrap failed: ${error instanceof Error ? error.message : String(error)}`)
+              );
+            }
+            return;
+          }
+          const event = readEvent(line);
+          if (event) handler(event);
+        },
+        () => stream.destroy()
+      );
+      const onGone = () => {
+        if (socket !== stream) return;
+        socket = null;
+        stream.destroy();
+        scheduleReopen();
+      };
+      stream.on("error", onGone);
+      stream.on("close", onGone);
+      stream.write(
+        `${JSON.stringify({
+          id: `clio-sub-${kinds.join("+")}`,
+          method: "events.subscribe",
+          params: { subscriptions: kinds.map((kind) => ({ type: kind })) }
+        })}
+`
+      );
+    };
+    await open(false);
+    return {
+      close() {
+        closed = true;
+        if (retryTimer) clearTimeout(retryTimer);
+        retryTimer = null;
+        socket?.destroy();
+        socket = null;
+      }
+    };
+  };
+  return {
+    socketPath,
+    connected() {
+      return reachable;
+    },
+    server() {
+      return serverInfo;
+    },
+    cachedSnapshot() {
+      return snapshotCache;
+    },
+    async ping(pingOptions = {}) {
+      const result = await callObject("ping", {}, pingOptions.timeoutMs);
+      const info = readServerInfo(result);
+      serverInfo = info;
+      return info;
+    },
+    snapshot,
+    async paneCurrent(callerPaneId) {
+      const result = await callObject("pane.current", params({ caller_pane_id: callerPaneId }));
+      return readPane(result.pane);
+    },
+    async paneList(workspaceId) {
+      const result = await callObject("pane.list", params({ workspace_id: workspaceId }));
+      return readArray(result, "panes").map(readPane);
+    },
+    async paneSplit(request) {
+      const result = await callObject(
+        "pane.split",
+        params({
+          direction: request.direction,
+          target_pane_id: request.targetPaneId,
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          env: request.env,
+          focus: request.focus ?? false,
+          ratio: request.ratio
+        })
+      );
+      return readPane(result.pane);
+    },
+    async paneRename(paneId, label) {
+      await call("pane.rename", { pane_id: paneId, label });
+    },
+    async paneClose(paneId) {
+      await call("pane.close", { pane_id: paneId });
+    },
+    async paneLayout(paneId) {
+      const result = await callObject("pane.layout", params({ pane_id: paneId }));
+      return readTabGeometry(result.layout);
+    },
+    async paneFocus(paneId) {
+      await call("pane.focus", { pane_id: paneId });
+    },
+    async paneZoom(paneId, mode) {
+      const result = await callObject("pane.zoom", { pane_id: paneId, mode });
+      const zoom = asRecord(result.zoom);
+      if (!zoom) throw new MuxError("protocol", "mux pane.zoom returned no zoom result");
+      return { changed: zoom.changed === true, focusChanged: zoom.focus_changed === true };
+    },
+    async layoutExport(request = {}) {
+      const result = await callObject("layout.export", params({ tab_id: request.tabId, pane_id: request.paneId }));
+      return readLayoutTree(result.layout);
+    },
+    async layoutSetSplitRatio(request) {
+      const result = await callObject(
+        "layout.set_split_ratio",
+        params({ tab_id: request.tabId, pane_id: request.paneId, path: [...request.path], ratio: request.ratio })
+      );
+      return readLayoutTree(result.layout);
+    },
+    async worktreeList(request = {}) {
+      const result = await callObject("worktree.list", params({ workspace_id: request.workspaceId, cwd: request.cwd }));
+      return { source: readWorktreeSource(result.source), worktrees: readArray(result, "worktrees").map(readWorktree) };
+    },
+    async worktreeCreate(request) {
+      const result = await callObject(
+        "worktree.create",
+        params({
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          branch: request.branch,
+          base: request.base,
+          path: request.path,
+          label: request.label,
+          focus: request.focus ?? false
+        })
+      );
+      const workspace = asRecord(result.workspace);
+      if (!workspace) throw new MuxError("protocol", "mux worktree.create returned no workspace");
+      return {
+        workspaceId: requireString(workspace, "workspace_id", "workspace"),
+        tab: readTab(result.tab),
+        rootPane: readPane(result.root_pane),
+        worktree: readWorktree(result.worktree)
+      };
+    },
+    async worktreeOpen(request) {
+      const result = await callObject(
+        "worktree.open",
+        params({
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          branch: request.branch,
+          path: request.path,
+          label: request.label,
+          focus: request.focus ?? false
+        })
+      );
+      const workspace = asRecord(result.workspace);
+      if (!workspace) throw new MuxError("protocol", "mux worktree.open returned no workspace");
+      return {
+        workspaceId: requireString(workspace, "workspace_id", "workspace"),
+        tab: readTab(result.tab),
+        rootPane: readPane(result.root_pane),
+        worktree: readWorktree(result.worktree),
+        alreadyOpen: result.already_open === true
+      };
+    },
+    async worktreeRemove(workspaceId, removeOptions = {}) {
+      const result = await callObject("worktree.remove", {
+        workspace_id: workspaceId,
+        force: removeOptions.force ?? false
+      });
+      return {
+        workspaceId: requireString(result, "workspace_id", "worktree.remove"),
+        path: requireString(result, "path", "worktree.remove"),
+        forced: result.forced === true
+      };
+    },
+    async paneSendText(paneId, text) {
+      await call("pane.send_text", { pane_id: paneId, text });
+    },
+    async paneReportAgent(request) {
+      await call(
+        "pane.report_agent",
+        params({
+          pane_id: request.paneId,
+          source: request.source,
+          agent: request.agent,
+          state: request.state,
+          message: request.message
+        })
+      );
+    },
+    async paneReportMetadata(request) {
+      await call(
+        "pane.report_metadata",
+        params({
+          pane_id: request.paneId,
+          source: request.source,
+          agent: request.agent,
+          title: request.title,
+          display_agent: request.displayAgent,
+          tokens: request.tokens,
+          state_labels: request.stateLabels,
+          ttl_ms: request.ttlMs
+        })
+      );
+    },
+    async notificationShow(request) {
+      const result = await callObject(
+        "notification.show",
+        params({ title: request.title, body: request.body, sound: request.sound })
+      );
+      return {
+        shown: result.shown === true,
+        reason: optionalString(result, "reason") ?? (result.shown === true ? "shown" : "unknown")
+      };
+    },
+    subscribe,
+    async close() {
+      disposed = true;
+      reachable = false;
+    }
+  };
+}
+
+// src/domains/mux/detect.ts
+var PING_TIMEOUT_MS = 1e3;
+function herdrConfigDir(env) {
+  const xdg = env.XDG_CONFIG_HOME;
+  if (typeof xdg === "string" && xdg.length > 0) return join(xdg, "herdr");
+  const home = typeof env.HOME === "string" && env.HOME.length > 0 ? env.HOME : homedir();
+  return join(home, ".config", "herdr");
+}
+function resolveSocketCandidates(env) {
+  const candidates = [];
+  const explicit = env.HERDR_SOCKET_PATH;
+  if (typeof explicit === "string" && explicit.length > 0) candidates.push(explicit);
+  const configDir = herdrConfigDir(env);
+  const session = env.HERDR_SESSION;
+  if (typeof session === "string" && session.length > 0) {
+    candidates.push(join(configDir, "sessions", session, "herdr.sock"));
+  }
+  candidates.push(join(configDir, "herdr.sock"));
+  return [...new Set(candidates)];
+}
+function readSelfLocation(env) {
+  const read = (key) => {
+    const value = env[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+  };
+  return {
+    workspaceId: read("HERDR_WORKSPACE_ID"),
+    tabId: read("HERDR_TAB_ID"),
+    paneId: read("HERDR_PANE_ID")
+  };
+}
+function none(reason, candidates = [], refused = false) {
+  return {
+    mode: "none",
+    socketPath: null,
+    server: null,
+    self: { workspaceId: null, tabId: null, paneId: null },
+    candidates,
+    reason,
+    refused
+  };
+}
+async function detectMux(options = {}) {
+  const env = options.env ?? process.env;
+  const enabled = options.enabled ?? "auto";
+  const log = options.log ?? (() => void 0);
+  if (enabled === "off") {
+    return { detection: none("panes are turned off"), client: null };
+  }
+  if (enabled === "embedded") {
+    const reason = "embedded pane hosting is not implemented; use auto or guest";
+    log("warning", reason);
+    return { detection: none(reason, [], true), client: null };
+  }
+  if (env.HERDR_ENV !== "1") {
+    return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };
+  }
+  const candidates = resolveSocketCandidates(env);
+  const openClient = options.openClient ?? ((socketPath) => createMuxClient({ socketPath, log }));
+  const pingTimeoutMs = options.pingTimeoutMs ?? PING_TIMEOUT_MS;
+  for (const socketPath of candidates) {
+    const client = openClient(socketPath);
+    try {
+      const server = await client.ping({ timeoutMs: pingTimeoutMs });
+      return {
+        detection: {
+          mode: "guest",
+          socketPath,
+          server,
+          self: readSelfLocation(env),
+          candidates,
+          reason: `guest mode on ${socketPath} (herdr ${server.version}, protocol ${server.protocol})`,
+          refused: false
+        },
+        client
+      };
+    } catch (error) {
+      log("debug", `mux ping ${socketPath} failed: ${error instanceof Error ? error.message : String(error)}`);
+      await client.close().catch(() => void 0);
+    }
+  }
+  return {
+    detection: none(
+      candidates.length > 0 ? `no herdr socket answered a ping: tried ${candidates.join(", ")}` : "no herdr socket candidates resolved",
+      candidates
+    ),
+    client: null
+  };
+}
+
+// src/domains/mux/extension.ts
+async function createMuxBundle(_context, options = {}) {
+  const log = options.log ?? (() => void 0);
+  const { detection, client } = await detectMux({
+    ...options.enabled ? { enabled: options.enabled } : {},
+    ...options.env ? { env: options.env } : {},
+    log
+  });
+  log(
+    detection.refused ? "warning" : detection.mode === "none" ? "debug" : "info",
+    detection.refused ? `panes refused: ${detection.reason}` : `mux mode ${detection.mode}: ${detection.reason}`
+  );
+  const runtime = createMuxRuntime({ detection, client, log });
+  const extension = {
+    async start() {
+      await runtime.start();
+    },
+    async stop() {
+      await runtime.stop();
+    }
+  };
+  return { extension, contract: runtime.contract };
+}
+
+// src/domains/mux/manifest.ts
+init_esm_shims();
+var MuxManifest = {
+  name: "mux",
+  dependsOn: []
+};
+
+// src/domains/mux/viewer-command.ts
+init_esm_shims();
+import { join as join2 } from "node:path";
+function clioCliEntryPath() {
+  return join2(resolvePackageRoot(), "dist/cli/index.js");
+}
+function watchViewerCommand(selectionPath, options = {}) {
+  const layout = options.dirs === void 0 ? [] : [
+    "--config-dir",
+    options.dirs.config,
+    "--data-dir",
+    options.dirs.data,
+    "--state-dir",
+    options.dirs.state,
+    "--cache-dir",
+    options.dirs.cache
+  ];
+  return [
+    options.execPath ?? process.execPath,
+    options.entryPath ?? clioCliEntryPath(),
+    "fleet",
+    "view",
+    ...layout,
+    "--watch",
+    selectionPath
+  ];
+}
+
+// src/domains/mux/yazi/event-stream.ts
+init_esm_shims();
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+var YAZI_STREAM_POLL_MS = 250;
+var YAZI_STREAM_MAX_BYTES = 1024 * 1024;
+var YAZI_PICK_EVENT = "clio-coder-pick";
+var LEGACY_YAZI_PICK_EVENT = "clio-pick";
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseYaziEventLine(line) {
+  const first = line.indexOf(",");
+  const second = first < 0 ? -1 : line.indexOf(",", first + 1);
+  const third = second < 0 ? -1 : line.indexOf(",", second + 1);
+  if (first <= 0 || second <= first + 1 || third <= second + 1) return null;
+  const kind = line.slice(0, first);
+  if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) return null;
+  const receiver = line.slice(first + 1, second);
+  const sender = line.slice(second + 1, third);
+  try {
+    const body = JSON.parse(line.slice(third + 1));
+    if (kind === "cd") {
+      if (!record(body) || typeof body.url !== "string") return null;
+      const tab = body.tab;
+      if (typeof tab !== "number" && typeof tab !== "string") return null;
+      return { kind, receiver, sender, tab: String(tab), cwd: body.url };
+    }
+    if (!Array.isArray(body) || !body.every((value) => typeof value === "string")) return null;
+    return { kind: YAZI_PICK_EVENT, receiver, sender, values: body };
+  } catch {
+    return null;
+  }
+}
+function createYaziEventStream(options) {
+  const log = options.log ?? (() => void 0);
+  const now = options.now ?? Date.now;
+  const maxBytes = options.maxBytes ?? YAZI_STREAM_MAX_BYTES;
+  let offset = 0;
+  let carry = "";
+  let decoder = new StringDecoder("utf8");
+  let stopped = false;
+  let polling = false;
+  let interval = null;
+  let settleDone = () => {
+  };
+  const done = new Promise((resolve) => {
+    settleDone = resolve;
+  });
+  const state = {
+    bytesRead: 0,
+    linesRead: 0,
+    malformedLines: 0,
+    lastLineAt: null,
+    stopReason: null
+  };
+  const stop = (reason = "stopped") => {
+    if (stopped) return;
+    stopped = true;
+    state.stopReason = reason;
+    if (interval) clearInterval(interval);
+    interval = null;
+    log(reason === "size-cap" ? "warning" : "debug", `yazi event stream stopped (${reason}): ${options.path}`);
+    settleDone(reason);
+  };
+  const poll = async () => {
+    if (stopped || polling) return;
+    polling = true;
+    try {
+      if (!await options.isAlive()) {
+        stop("pane-gone");
+        return;
+      }
+      const stat = statSync(options.path, { throwIfNoEntry: false });
+      if (!stat?.isFile()) {
+        stop("file-missing");
+        return;
+      }
+      if (stat.size > maxBytes) {
+        stop("size-cap");
+        return;
+      }
+      if (stat.size < offset) {
+        offset = 0;
+        carry = "";
+        decoder = new StringDecoder("utf8");
+      }
+      const remaining = stat.size - offset;
+      if (remaining <= 0) return;
+      const bytes = Buffer.allocUnsafe(remaining);
+      const fd = openSync(options.path, "r");
+      let read = 0;
+      try {
+        read = readSync(fd, bytes, 0, remaining, offset);
+      } finally {
+        closeSync(fd);
+      }
+      offset += read;
+      state.bytesRead += read;
+      const complete = `${carry}${decoder.write(bytes.subarray(0, read))}`.split("\n");
+      carry = complete.pop() ?? "";
+      for (const raw of complete) {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line.length === 0) continue;
+        const kind = line.slice(0, line.indexOf(","));
+        if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) continue;
+        const event = parseYaziEventLine(line);
+        if (!event) {
+          state.malformedLines += 1;
+          continue;
+        }
+        state.linesRead += 1;
+        state.lastLineAt = now();
+        try {
+          options.onEvent(event);
+        } catch (error) {
+          log("warning", `yazi event consumer failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    } finally {
+      polling = false;
+    }
+  };
+  if (options.autoStart !== false) {
+    interval = setInterval(() => void poll(), options.pollMs ?? YAZI_STREAM_POLL_MS);
+    interval.unref();
+    void poll();
+  }
+  return { poll, stop, stats: () => ({ ...state }), done };
+}
+
+// src/domains/mux/yazi/session.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+function resolveYaziBinaries() {
+  const entry = findPinnedTool("yazi");
+  const status = entry ? toolStatus(entry) : null;
+  return {
+    yaziPath: status?.resolution.binaryPath ?? null,
+    yaPath: resolveToolBinary("ya").binaryPath,
+    missingYaziDetail: status ? describeResolution(status) : "yazi is not in the pinned tool registry"
+  };
+}
+function runYa(file, args, env) {
+  return new Promise((resolve) => {
+    const child = spawn(file, args, { env: { ...env }, stdio: "ignore" });
+    child.once("error", () => resolve(false));
+    child.once("exit", (code) => resolve(code === 0));
+  });
+}
+function readOptional(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+var YAZI_STALE_TRANSPORT_MS = 24 * 60 * 60 * 1e3;
+function sweepStaleTransportFiles(sessionsDir, now = Date.now()) {
+  let removed = 0;
+  let entries;
+  try {
+    entries = readdirSync(sessionsDir);
+  } catch {
+    return 0;
+  }
+  for (const name of entries) {
+    if (!/\.(stream|chooser|cwd)$/u.test(name)) continue;
+    const path = join3(sessionsDir, name);
+    try {
+      if (now - statSync2(path).mtimeMs > YAZI_STALE_TRANSPORT_MS) {
+        rmSync(path, { force: true });
+        removed += 1;
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+async function createYaziSession(options) {
+  const binaries = (options.resolveBinaries ?? resolveYaziBinaries)();
+  if (!binaries.yaziPath) {
+    return { status: "missing-binary", binary: "yazi", detail: binaries.missingYaziDetail };
+  }
+  if (options.profileMode === "managed" && !binaries.yaPath) {
+    return {
+      status: "missing-binary",
+      binary: "ya",
+      detail: "the Yazi helper `ya` is not available; install the complete pinned Yazi tool"
+    };
+  }
+  const cacheDir = options.cacheDir ?? clioCacheDir();
+  const sessionId = options.sessionId ?? randomUUID();
+  const sessionsDir = join3(cacheDir, "yazi", "sessions");
+  mkdirSync(sessionsDir, { recursive: true });
+  sweepStaleTransportFiles(sessionsDir);
+  const managedProfile = options.profileMode === "managed" ? (options.ensureProfile ?? ensureYaziProfile)({
+    yaPath: binaries.yaPath,
+    yaziPath: binaries.yaziPath,
+    profileDir: yaziProfileDir(cacheDir)
+  }) : null;
+  if (options.profileMode === "managed" && !managedProfile) {
+    return { status: "profile-error", reason: "Clio could not generate a valid managed Yazi profile" };
+  }
+  const streamPath = join3(sessionsDir, `${sessionId}.stream`);
+  const chooserPath = join3(sessionsDir, `${sessionId}.chooser`);
+  const cwdPath = join3(sessionsDir, `${sessionId}.cwd`);
+  const token2 = options.mode === "companion" ? options.pickToken ?? randomUUID() : null;
+  const env = {
+    ...managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {},
+    ...token2 ? namingCompatibilityEnvironment("CLIO_CODER_YAZI_PICK_TOKEN", "CLIO_YAZI_PICK_TOKEN", token2) : {}
+  };
+  let argv;
+  let stdoutPath;
+  if (options.mode === "companion") {
+    writeFileSync(streamPath, "");
+    argv = [
+      binaries.yaziPath,
+      "--local-events",
+      `cd,${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`,
+      "--remote-events",
+      `${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`
+    ];
+    stdoutPath = streamPath;
+  } else {
+    writeFileSync(chooserPath, "");
+    writeFileSync(cwdPath, "");
+    argv = [binaries.yaziPath, options.cwd, "--chooser-file", chooserPath, "--cwd-file", cwdPath];
+  }
+  const removeTransportFiles = () => {
+    for (const path of [streamPath, chooserPath, cwdPath]) rmSync(path, { force: true });
+  };
+  const pane = await options.mux.openUtilityPane({
+    argv,
+    cwd: options.cwd,
+    label: "files",
+    title: "files",
+    // The files dock: split down from the anchor at the configured share.
+    // Degrades to a plain split inside the contract when the layout tier is
+    // absent.
+    dock: { slot: "files", ...options.dockShare === void 0 ? {} : { share: options.dockShare } },
+    ...Object.keys(env).length > 0 ? { env } : {},
+    ...stdoutPath ? { stdoutPath } : {}
+  });
+  if (!pane) {
+    removeTransportFiles();
+    return { status: "unavailable", reason: "the pane host refused to open the files pane" };
+  }
+  let paneCwd = options.cwd;
+  let instanceId = null;
+  let stream = null;
+  let chooserTimer = null;
+  let stopped = false;
+  const alive = () => options.mux.list().some((record2) => record2.ref.paneId === pane.paneId);
+  const stop = (reason) => {
+    if (stopped) return;
+    stopped = true;
+    if (chooserTimer) clearInterval(chooserTimer);
+    chooserTimer = null;
+    options.onStopped?.(reason);
+    removeTransportFiles();
+  };
+  if (options.mode === "companion") {
+    stream = createYaziEventStream({
+      path: streamPath,
+      isAlive: alive,
+      ...options.pollMs !== void 0 ? { pollMs: options.pollMs } : {},
+      ...options.log ? { log: options.log } : {},
+      onEvent: (event) => {
+        if (event.kind === "cd") {
+          paneCwd = event.cwd;
+          instanceId = event.sender;
+        }
+        options.onEvent(event);
+      }
+    });
+    void stream.done.then((reason) => {
+      stop(reason);
+    });
+  } else {
+    const pollChooser = () => {
+      if (stopped || alive()) return;
+      const raw = readOptional(chooserPath);
+      const cwd = readOptional(cwdPath).trim() || paneCwd;
+      paneCwd = cwd;
+      const paths = raw.length === 0 ? [] : raw.split("\n").filter((path) => path.length > 0);
+      options.onChooser({ paths, cwd });
+      stop("pane-gone");
+    };
+    chooserTimer = setInterval(pollChooser, options.pollMs ?? YAZI_STREAM_POLL_MS);
+    chooserTimer.unref();
+  }
+  const session = {
+    mode: options.mode,
+    pane,
+    token: token2,
+    profile: managedProfile,
+    snapshot: () => ({
+      mode: options.mode,
+      paneId: pane.paneId,
+      paneCwd,
+      instanceId,
+      lastLineAt: stream?.stats().lastLineAt ?? null,
+      streamPath: options.mode === "companion" ? streamPath : null,
+      chooserPath: options.mode === "chooser" ? chooserPath : null
+    }),
+    async pushCwd(cwd) {
+      if (!instanceId || !binaries.yaPath) return false;
+      const pushed = await (options.runYa ?? runYa)(binaries.yaPath, ["emit-to", instanceId, "cd", cwd], {
+        ...process.env,
+        ...managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {}
+      });
+      return pushed;
+    },
+    async close() {
+      stream?.stop();
+      stop("stopped");
+      await options.mux.closePane(pane.paneId);
+    }
+  };
+  return { status: "opened", session };
+}
+
+// src/domains/mux/index.ts
+function createMuxDomainModule(options) {
+  return {
+    manifest: MuxManifest,
+    createExtension: (context) => createMuxBundle(context, options)
+  };
+}
+
+export {
+  MUX_METHOD_MIN_PROTOCOL,
+  resolveSocketCandidates,
+  detectMux,
+  watchViewerCommand,
+  resolveYaziBinaries,
+  createYaziSession,
+  createMuxDomainModule
+};
+//# sourceMappingURL=chunk-PXRCXGLK.js.map