@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/{chunk-HZHHCK24.js → chunk-KKOJXO6R.js}

@@ -1,7 +1,8 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  parseTomlDocument
-} from "./chunk-LCGCVYZ4.js";
+  ensureYaziProfile,
+  yaziProfileDir
+} from "./chunk-3M6DQK6S.js";
 import {
   describeResolution,
   resolveToolBinary,
@@ -11,279 +12,217 @@ import {
   findPinnedTool
 } from "./chunk-QDC3K2U3.js";
 import {
-  readClioVersion,
+  namingCompatibilityEnvironment
+} from "./chunk-D7E7WCDF.js";
+import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
 import {
-  clioCacheDir,
-  resolveClioDirs
+  clioCacheDir
 } from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/mux/yazi/profile.ts
+// src/domains/mux/index.ts
 init_esm_shims();
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-  cpSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative } from "node:path";
 
-// src/domains/mux/yazi/theme.ts
+// src/domains/mux/extension.ts
 init_esm_shims();
 
-// src/core/theme-token-hex.ts
+// src/domains/mux/contract.ts
 init_esm_shims();
-var TOKEN_HEX = {
-  accent: "#46e5d0",
-  accentDeep: "#1fb7a6",
-  action: "#ff7e29",
-  success: "#57e389",
-  warning: "#ffb454",
-  error: "#ff5c66",
-  info: "#5ba8ff",
-  reason: "#9d8cff",
-  dim: "#6a7a85",
-  muted: "#8a99a4",
-  title: "#46e5d0",
-  frame: "#2f5d5a",
-  frameStrong: "#2aab9e"
-};
-function tokenHex(token2) {
-  return TOKEN_HEX[token2];
-}
-
-// src/domains/mux/yazi/theme.ts
-function renderYaziTheme() {
-  return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
-
-[mgr]
-cwd = { fg = "${tokenHex("accent")}" }
-find_keyword = { fg = "${tokenHex("warning")}" }
-marker_selected = { fg = "${tokenHex("success")}", bg = "${tokenHex("success")}" }
-marker_copied = { fg = "${tokenHex("accent")}", bg = "${tokenHex("accent")}" }
-marker_cut = { fg = "${tokenHex("error")}", bg = "${tokenHex("error")}" }
-border_style = { fg = "${tokenHex("frame")}" }
 
-[mode]
-normal_main = { bg = "${tokenHex("accent")}" }
-normal_alt = { fg = "${tokenHex("accent")}" }
-select_main = { bg = "${tokenHex("action")}" }
-select_alt = { fg = "${tokenHex("action")}" }
-unset_main = { bg = "${tokenHex("error")}" }
-unset_alt = { fg = "${tokenHex("error")}" }
-
-[tabs]
-active = { bg = "${tokenHex("accent")}" }
-inactive = { fg = "${tokenHex("accent")}" }
-
-[status]
-perm_sep = { fg = "${tokenHex("dim")}" }
-`;
-}
-
-// src/domains/mux/yazi/profile.ts
-var PROFILE_FILES = ["yazi.toml", "keymap.toml", "theme.toml", "init.lua"];
-var PROFILE_PLUGIN_FILES = ["main.lua", "types.lua", "LICENSE", "README.md"];
-var STAMP_FILE = "stamp.json";
-function yaziProfileDir(cacheDir = resolveClioDirs().cache) {
-  return join(cacheDir, "yazi", "profile");
-}
-function userYaziConfigDir(env = process.env, home = homedir()) {
-  const xdg = env.XDG_CONFIG_HOME;
-  return xdg && isAbsolute(xdg) ? join(xdg, "yazi") : join(home, ".config", "yazi");
-}
-function resetYaziProfile(profileDir = yaziProfileDir()) {
-  rmSync(profileDir, { recursive: true, force: true });
-}
-function defaultAssetDir() {
-  return join(resolvePackageRoot(), "src", "domains", "mux", "yazi", "assets");
-}
-function yaziPin() {
-  return findPinnedTool("yazi")?.version ?? "unknown";
-}
-function sha256(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-function filesBelow(root, current = root) {
-  const files = [];
-  for (const entry of readdirSync(current, { withFileTypes: true }).sort(
-    (left, right) => left.name.localeCompare(right.name)
-  )) {
-    const path = join(current, entry.name);
-    if (entry.isDirectory()) files.push(...filesBelow(root, path));
-    else if (entry.isFile()) files.push(relative(root, path).replaceAll("\\", "/"));
-  }
-  return files;
-}
-function hashYaziAssetTree(assetDir) {
-  const hash = createHash("sha256");
-  for (const file of filesBelow(assetDir)) {
-    hash.update(file);
-    hash.update("\0");
-    hash.update(readFileSync(join(assetDir, file)));
-    hash.update("\0");
-  }
-  return hash.digest("hex");
+// 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 shellQuote(value) {
-  return `'${value.replaceAll("'", `'\\''`)}'`;
+function clampDockShare(share) {
+  if (!Number.isFinite(share) || share <= 0) return DOCK_SPECS.workers.defaultShare;
+  return Math.min(DOCK_MAX_SHARE, share);
 }
-function renderYaziKeymap(yaPath) {
-  const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-pick --list "$CLIO_YAZI_PICK_TOKEN" %s`;
-  return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
-
-[[mgr.prepend_keymap]]
-on   = "<C-y>"
-run  = ${JSON.stringify(command)}
-desc = "Send the selection to Clio"
-`;
+function axisCells(rect, spec) {
+  return spec.direction === "right" ? rect.width : rect.height;
 }
-function expected(options) {
-  const assetDir = options.assetDir ?? defaultAssetDir();
-  const themeToml = options.themeToml ?? renderYaziTheme();
-  const yaziToml = options.yaziToml ?? readFileSync(join(assetDir, "yazi.toml"), "utf8");
-  const keymapToml = options.keymapToml ?? renderYaziKeymap(options.yaPath);
-  return {
-    dir: options.profileDir ?? yaziProfileDir(),
-    assetDir,
-    yaziToml,
-    keymapToml,
-    themeToml,
-    stamp: {
-      yaziVersion: options.yaziVersion ?? yaziPin(),
-      clioVersion: options.clioVersion ?? readClioVersion(),
-      yaPath: options.yaPath,
-      assetSha256: hashYaziAssetTree(assetDir),
-      themeSha256: sha256(themeToml)
-    }
+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);
   };
-}
-function readStamp(dir) {
-  try {
-    const value = JSON.parse(readFileSync(join(dir, STAMP_FILE), "utf8"));
-    if (typeof value.yaziVersion !== "string" || typeof value.clioVersion !== "string" || typeof value.yaPath !== "string" || typeof value.assetSha256 !== "string" || typeof value.themeSha256 !== "string") {
-      return null;
-    }
-    return value;
-  } catch {
+  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;
-  }
-}
-function sameStamp(left, right) {
-  return left !== null && left.yaziVersion === right.yaziVersion && left.clioVersion === right.clioVersion && left.yaPath === right.yaPath && left.assetSha256 === right.assetSha256 && left.themeSha256 === right.themeSha256;
-}
-function profileFilesExist(dir) {
-  return PROFILE_FILES.every((file) => statSync(join(dir, file), { throwIfNoEntry: false })?.isFile()) && PROFILE_PLUGIN_FILES.every(
-    (file) => statSync(join(dir, "plugins", "git.yazi", file), { throwIfNoEntry: false })?.isFile() === true
-  );
-}
-function inspectYaziProfile(options) {
-  const inputs = expected(options);
-  const present = statSync(inputs.dir, { throwIfNoEntry: false })?.isDirectory() === true;
-  const current = present && profileFilesExist(inputs.dir) && sameStamp(readStamp(inputs.dir), inputs.stamp);
-  return {
-    dir: inputs.dir,
-    userConfigDir: userYaziConfigDir(),
-    state: current ? "current" : present ? "stale" : "missing",
-    stamp: inputs.stamp
   };
+  return walk(root, []);
 }
-function inspectCurrentYaziProfile() {
-  return inspectYaziProfile({ yaPath: resolveToolBinary("ya").binaryPath ?? "(unresolved)" });
+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 describeYaziProfile(inspection) {
-  return `${inspection.dir} (${inspection.state}); user config ${inspection.userConfigDir} is separate and untouched`;
-}
-function parseGenerated(dir) {
-  return ["yazi.toml", "keymap.toml", "theme.toml"].every((file) => {
-    try {
-      return parseTomlDocument(readFileSync(join(dir, file), "utf8")) !== null;
-    } catch {
-      return false;
+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;
     }
-  });
-}
-var YAZI_CONFIG_ERROR_MARKERS = ["Failed to parse config", "Press <Enter> to continue with preset settings"];
-function validatesWithYazi(dir, yaziPath) {
-  const scratchHome = mkdtempSync(join(dirname(dir), ".yazi-validation-"));
-  try {
-    const result = spawnSync(yaziPath, ["--debug"], {
-      cwd: scratchHome,
-      env: {
-        ...process.env,
-        HOME: scratchHome,
-        XDG_CACHE_HOME: join(scratchHome, "cache"),
-        XDG_CONFIG_HOME: join(scratchHome, "config"),
-        YAZI_CONFIG_HOME: dir
-      },
-      encoding: "utf8",
-      timeout: 5e3
-    });
-    const output = `${result.stdout ?? ""}
-${result.stderr ?? ""}`;
-    return result.error === void 0 && result.status === 0 && YAZI_CONFIG_ERROR_MARKERS.every((marker) => !output.includes(marker));
-  } catch {
-    return false;
-  } finally {
-    rmSync(scratchHome, { recursive: true, force: true });
   }
+  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 ensureYaziProfile(options) {
-  let inputs;
-  try {
-    inputs = expected({ ...options, profileDir: options.profileDir ?? yaziProfileDir(clioCacheDir()) });
-  } catch {
-    return null;
-  }
-  if (profileFilesExist(inputs.dir) && sameStamp(readStamp(inputs.dir), inputs.stamp)) {
-    return { dir: inputs.dir, stamp: inputs.stamp };
+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`
+    };
   }
-  mkdirSync(dirname(inputs.dir), { recursive: true });
-  const staging = mkdtempSync(join(dirname(inputs.dir), ".profile-"));
-  try {
-    cpSync(join(inputs.assetDir, "init.lua"), join(staging, "init.lua"));
-    cpSync(join(inputs.assetDir, "plugins"), join(staging, "plugins"), { recursive: true });
-    writeFileSync(join(staging, "yazi.toml"), inputs.yaziToml);
-    writeFileSync(join(staging, "keymap.toml"), inputs.keymapToml);
-    writeFileSync(join(staging, "theme.toml"), inputs.themeToml);
-    writeFileSync(join(staging, STAMP_FILE), `${JSON.stringify(inputs.stamp, null, 2)}
-`);
-    if (!parseGenerated(staging) || !validatesWithYazi(staging, options.yaziPath)) {
-      rmSync(inputs.dir, { recursive: true, force: true });
-      return null;
+  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;
     }
-    rmSync(inputs.dir, { recursive: true, force: true });
-    renameSync(staging, inputs.dir);
-    return { dir: inputs.dir, stamp: inputs.stamp };
-  } catch {
-    rmSync(inputs.dir, { recursive: true, force: true });
-    return null;
-  } finally {
-    rmSync(staging, { recursive: true, force: true });
-  }
+    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) {
+        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) {
+        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/index.ts
-init_esm_shims();
-
-// src/domains/mux/extension.ts
-init_esm_shims();
-
-// src/domains/mux/contract.ts
-init_esm_shims();
-
 // src/domains/mux/pane-registry.ts
 init_esm_shims();
 function createPaneRegistry() {
@@ -343,6 +282,10 @@ 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,
@@ -393,24 +336,31 @@ function muxErrorKind(wireCode) {
 }
 
 // src/domains/mux/contract.ts
-var METADATA_SOURCE = "clio:mux";
-var SELF_AGENT_SOURCE = "clio:coder";
-var OWNER_TOKEN_KEY = "clio_owner";
-var OWNER_TOKEN_VALUE = "clio:mux";
+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 shellQuote2(argv) {
+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;
@@ -445,10 +395,27 @@ function createMuxRuntime(options) {
       paneId,
       source: METADATA_SOURCE,
       ...title === void 0 ? {} : { title },
-      tokens: { [OWNER_TOKEN_KEY]: OWNER_TOKEN_VALUE, ...tokens }
+      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`);
@@ -470,32 +437,49 @@ function createMuxRuntime(options) {
       return detection;
     },
     async openUtilityPane(request) {
+      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) => {
-          const anchor = detection.self.paneId ?? (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 } : {}
-          });
-          const ref = { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+          let ref;
+          if (request.dock && docks) {
+            const placed = await docks.open(request.dock.slot, {
+              ...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(pane.paneId, title);
+              await live.paneRename(ref.paneId, title);
             } catch {
             }
           }
-          await tagOwner(live, pane.paneId, { role: token(purpose) }, titleSupported ? title : void 0);
+          await tagOwner(live, ref.paneId, { role: token(purpose) }, titleSupported ? title : void 0);
           if (request.argv.length > 0) {
-            const redirect = request.stdoutPath ? ` > ${shellQuote2([request.stdoutPath])}` : "";
-            await live.paneSendText(pane.paneId, `exec ${shellQuote2(request.argv)}${redirect}
+            const redirect = request.stdoutPath ? ` > ${shellQuote([request.stdoutPath])}` : "";
+            await live.paneSendText(ref.paneId, `exec ${shellQuote(request.argv)}${redirect}
 `);
           }
           return ref;
@@ -510,6 +494,7 @@ function createMuxRuntime(options) {
         async (live) => {
           await live.paneClose(paneId);
           registry.forget(paneId);
+          docks?.notePaneGone(paneId);
           return true;
         },
         false
@@ -523,7 +508,7 @@ function createMuxRuntime(options) {
         async (live) => {
           const snapshot = await live.snapshot();
           for (const pane of snapshot.panes) {
-            if (pane.tokens[OWNER_TOKEN_KEY] !== OWNER_TOKEN_VALUE) continue;
+            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;
@@ -531,6 +516,7 @@ function createMuxRuntime(options) {
             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;
           }
@@ -539,6 +525,59 @@ function createMuxRuntime(options) {
         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}`);
@@ -621,15 +660,25 @@ function createMuxRuntime(options) {
       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 {
-      subscription = await client.subscribe(["pane.closed", "pane.exited"], onEvent, {
+      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`);
           }
@@ -644,8 +693,8 @@ function createMuxRuntime(options) {
 
 // src/domains/mux/detect.ts
 init_esm_shims();
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 // src/domains/mux/socket-client.ts
 init_esm_shims();
@@ -817,21 +866,118 @@ function readSnapshot(value) {
     tabs: readArray(source, "tabs").map(readTab)
   };
 }
-var EVENT_KIND_BY_WIRE = {
+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 kind = EVENT_KIND_BY_WIRE[wireKind];
-  if (!kind) return null;
   const data = asRecord(line.data);
   if (!data) return null;
-  const paneId = data.pane_id;
-  const workspaceId = data.workspace_id;
-  if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
-  return { kind, paneId, workspaceId };
+  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 = {};
@@ -1065,15 +1211,27 @@ function createMuxClient(options) {
     },
     async paneLayout(paneId) {
       const result = await callObject("pane.layout", params({ pane_id: paneId }));
-      const layout = asRecord(result.layout);
-      if (!layout) throw new MuxError("protocol", "mux pane.layout returned no layout");
-      const ids = [];
-      for (const entry of readArray(layout, "panes")) {
-        const pane = asRecord(entry);
-        const id = pane ? pane.pane_id : void 0;
-        if (typeof id === "string") ids.push(id);
-      }
-      return ids;
+      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 }));
@@ -1186,9 +1344,9 @@ function createMuxClient(options) {
 var PING_TIMEOUT_MS = 1e3;
 function herdrConfigDir(env) {
   const xdg = env.XDG_CONFIG_HOME;
-  if (typeof xdg === "string" && xdg.length > 0) return join2(xdg, "herdr");
-  const home = typeof env.HOME === "string" && env.HOME.length > 0 ? env.HOME : homedir2();
-  return join2(home, ".config", "herdr");
+  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 = [];
@@ -1197,9 +1355,9 @@ function resolveSocketCandidates(env) {
   const configDir = herdrConfigDir(env);
   const session = env.HERDR_SESSION;
   if (typeof session === "string" && session.length > 0) {
-    candidates.push(join2(configDir, "sessions", session, "herdr.sock"));
+    candidates.push(join(configDir, "sessions", session, "herdr.sock"));
   }
-  candidates.push(join2(configDir, "herdr.sock"));
+  candidates.push(join(configDir, "herdr.sock"));
   return [...new Set(candidates)];
 }
 function readSelfLocation(env) {
@@ -1213,14 +1371,15 @@ function readSelfLocation(env) {
     paneId: read("HERDR_PANE_ID")
   };
 }
-function none(reason, candidates = []) {
+function none(reason, candidates = [], refused = false) {
   return {
     mode: "none",
     socketPath: null,
     server: null,
     self: { workspaceId: null, tabId: null, paneId: null },
     candidates,
-    reason
+    reason,
+    refused
   };
 }
 async function detectMux(options = {}) {
@@ -1231,7 +1390,7 @@ async function detectMux(options = {}) {
     return { detection: none("panes are turned off"), client: null };
   }
   if (enabled === "embedded") {
-    return { detection: none("embedded mode is not implemented yet; it ships in phase 5"), client: null };
+    log("info", "interface.panes.enabled=embedded is not implemented yet; detecting a guest pane host instead");
   }
   if (env.HERDR_ENV !== "1") {
     return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };
@@ -1250,7 +1409,8 @@ async function detectMux(options = {}) {
           server,
           self: readSelfLocation(env),
           candidates,
-          reason: `guest mode on ${socketPath} (herdr ${server.version}, protocol ${server.protocol})`
+          reason: `guest mode on ${socketPath} (herdr ${server.version}, protocol ${server.protocol})`,
+          refused: false
         },
         client
       };
@@ -1276,7 +1436,10 @@ async function createMuxBundle(_context, options = {}) {
     ...options.env ? { env: options.env } : {},
     log
   });
-  log(detection.mode === "none" ? "debug" : "info", `mux mode ${detection.mode}: ${detection.reason}`);
+  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() {
@@ -1298,9 +1461,9 @@ var MuxManifest = {
 
 // src/domains/mux/viewer-command.ts
 init_esm_shims();
-import { join as join3 } from "node:path";
+import { join as join2 } from "node:path";
 function clioCliEntryPath() {
-  return join3(resolvePackageRoot(), "dist/cli/index.js");
+  return join2(resolvePackageRoot(), "dist/cli/index.js");
 }
 function watchViewerCommand(selectionPath, options = {}) {
   const layout = options.dirs === void 0 ? [] : [
@@ -1326,10 +1489,12 @@ function watchViewerCommand(selectionPath, options = {}) {
 
 // src/domains/mux/yazi/event-stream.ts
 init_esm_shims();
-import { closeSync, openSync, readSync, statSync as statSync2 } from "node:fs";
+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);
 }
@@ -1339,7 +1504,7 @@ function parseYaziEventLine(line) {
   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 !== "clio-pick") return null;
+  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 {
@@ -1351,7 +1516,7 @@ function parseYaziEventLine(line) {
       return { kind, receiver, sender, tab: String(tab), cwd: body.url };
     }
     if (!Array.isArray(body) || !body.every((value) => typeof value === "string")) return null;
-    return { kind, receiver, sender, values: body };
+    return { kind: YAZI_PICK_EVENT, receiver, sender, values: body };
   } catch {
     return null;
   }
@@ -1395,7 +1560,7 @@ function createYaziEventStream(options) {
         stop("pane-gone");
         return;
       }
-      const stat = statSync2(options.path, { throwIfNoEntry: false });
+      const stat = statSync(options.path, { throwIfNoEntry: false });
       if (!stat?.isFile()) {
         stop("file-missing");
         return;
@@ -1427,7 +1592,7 @@ function createYaziEventStream(options) {
         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 !== "clio-pick") continue;
+        if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) continue;
         const event = parseYaziEventLine(line);
         if (!event) {
           state.malformedLines += 1;
@@ -1457,8 +1622,8 @@ function createYaziEventStream(options) {
 init_esm_shims();
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+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;
@@ -1477,11 +1642,33 @@ function runYa(file, args, env) {
 }
 function readOptional(path) {
   try {
-    return readFileSync2(path, "utf8");
+    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) {
@@ -1496,8 +1683,9 @@ async function createYaziSession(options) {
   }
   const cacheDir = options.cacheDir ?? clioCacheDir();
   const sessionId = options.sessionId ?? randomUUID();
-  const sessionsDir = join4(cacheDir, "yazi", "sessions");
-  mkdirSync2(sessionsDir, { recursive: true });
+  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,
@@ -1506,33 +1694,50 @@ async function createYaziSession(options) {
   if (options.profileMode === "managed" && !managedProfile) {
     return { status: "profile-error", reason: "Clio could not generate a valid managed Yazi profile" };
   }
-  const streamPath = join4(sessionsDir, `${sessionId}.stream`);
-  const chooserPath = join4(sessionsDir, `${sessionId}.chooser`);
-  const cwdPath = join4(sessionsDir, `${sessionId}.cwd`);
+  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 ? { CLIO_YAZI_PICK_TOKEN: token2 } : {}
+    ...token2 ? namingCompatibilityEnvironment("CLIO_CODER_YAZI_PICK_TOKEN", "CLIO_YAZI_PICK_TOKEN", token2) : {}
   };
   let argv;
   let stdoutPath;
   if (options.mode === "companion") {
-    writeFileSync2(streamPath, "");
-    argv = [binaries.yaziPath, "--local-events", "cd,clio-pick", "--remote-events", "clio-pick"];
+    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 {
-    writeFileSync2(chooserPath, "");
-    writeFileSync2(cwdPath, "");
+    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: "yazi",
+    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) return { status: "unavailable", reason: "pane host refused to open yazi" };
+  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;
@@ -1545,6 +1750,7 @@ async function createYaziSession(options) {
     if (chooserTimer) clearInterval(chooserTimer);
     chooserTimer = null;
     options.onStopped?.(reason);
+    removeTransportFiles();
   };
   if (options.mode === "companion") {
     stream = createYaziEventStream({
@@ -1560,7 +1766,9 @@ async function createYaziSession(options) {
         options.onEvent(event);
       }
     });
-    void stream.done.then((reason) => stop(reason));
+    void stream.done.then((reason) => {
+      stop(reason);
+    });
   } else {
     const pollChooser = () => {
       if (stopped || alive()) return;
@@ -1618,14 +1826,8 @@ export {
   resolveSocketCandidates,
   detectMux,
   watchViewerCommand,
-  yaziProfileDir,
-  userYaziConfigDir,
-  resetYaziProfile,
-  inspectCurrentYaziProfile,
-  describeYaziProfile,
-  ensureYaziProfile,
   resolveYaziBinaries,
   createYaziSession,
   createMuxDomainModule
 };
-//# sourceMappingURL=chunk-HZHHCK24.js.map
+//# sourceMappingURL=chunk-KKOJXO6R.js.map