@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-SRZOW5L2.js

@@ -1,1865 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  ensureYaziProfile,
-  yaziProfileDir
-} from "./chunk-T334FW2H.js";
-import {
-  describeResolution,
-  resolveToolBinary,
-  toolStatus
-} from "./chunk-XCUDZQLX.js";
-import {
-  findPinnedTool
-} from "./chunk-K2BLQC5E.js";
-import {
-  namingCompatibilityEnvironment
-} from "./chunk-DVNAPPXU.js";
-import {
-  resolvePackageRoot
-} from "./chunk-E3LEPLQ2.js";
-import {
-  clioCacheDir
-} from "./chunk-CTTI7G3T.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-SRZOW5L2.js.map