@zswarm/core 0.1.4 → 0.1.5

package/dist/exec.d.ts

@@ -16,6 +16,8 @@ export type ExecOptions = {
      * timeout.
      */
     until?: (stdout: string) => boolean;
+    /** Kill the child when aborted (MCP cancellation). */
+    signal?: AbortSignal;
 };
 export type ExecFn = (args: string[], options: ExecOptions) => Promise<ExecResult>;
 export declare const NOT_FOUND_EXIT = 127;

package/dist/exec.js

@@ -100,14 +100,25 @@ function runUntil(binPath, args, env, options) {
                 return;
             settled = true;
             clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
             child.kill();
             resolve(result);
         };
+        const onAbort = () => finish({
+            code: -1,
+            stdout,
+            stderr: `${binPath} cancelled`,
+        });
         const timer = setTimeout(() => finish({
             code: -1,
             stdout,
             stderr: `${binPath} timed out after ${options.timeoutMs}ms`,
         }), options.timeoutMs);
+        if (options.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        options.signal?.addEventListener("abort", onAbort, { once: true });
         child.on("error", (err) => {
             const missing = err.code === "ENOENT" || err.code === "ENOTDIR";
             finish({
@@ -138,6 +149,7 @@ function runToExit(binPath, args, env, options) {
             cwd: options.cwd,
             maxBuffer: 8 * 1024 * 1024,
             windowsHide: true,
+            signal: options.signal,
             env: options.env ? { ...env, ...options.env } : env,
         }, (error, stdout, stderr) => {
             const failure = error;
@@ -151,11 +163,15 @@ function runToExit(binPath, args, env, options) {
                 return;
             }
             if (failure &&
-                (failure.killed === true || typeof failure.signal === "string")) {
+                (failure.killed === true ||
+                    typeof failure.signal === "string" ||
+                    failure.name === "AbortError")) {
                 resolve({
                     code: -1,
                     stdout: String(stdout ?? ""),
-                    stderr: `${binPath} timed out after ${options.timeoutMs}ms`,
+                    stderr: failure.name === "AbortError"
+                        ? `${binPath} cancelled`
+                        : `${binPath} timed out after ${options.timeoutMs}ms`,
                 });
                 return;
             }

package/dist/index.d.ts

@@ -4,9 +4,9 @@ export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeL
 export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, type ZellijExecFn, type ZellijExecResult, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, type ZellijPane, } from "./zellij/panes.js";
 export { parseSessionList, resolveSelfPaneId, type ZellijSessionResolve, } from "./zellij/session.js";
-export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PaneDirection, type PipeInput, type ScrollbackRequest, } from "./zellij/args.js";
-export { busPluginUrl, busToPanes, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, type BusMarker, type BusPane, type BusScrollback, type BusScrollbackPane, type BusSnapshot, } from "./zellij/bus.js";
-export { busSnapshot, planBus, resetBusCache, type BusPlan, } from "./ops/bus.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PaneDirection, type PipeInput, type ScrollbackRequest, type WaitRequest, } from "./zellij/args.js";
+export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, type BusMarker, type BusPane, type BusScrollback, type BusScrollbackPane, type BusSnapshot, } from "./zellij/bus.js";
+export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, type BusPlan, } from "./ops/bus.js";
 export { createZellijClient, type ZellijClient, type ZellijClientOptions, } from "./zellij/client.js";
 export { createStateStore, defaultStateDir, type LogEntry, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
 export { dispatchZswarm } from "./ops/dispatch.js";
@@ -14,7 +14,7 @@ export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, type Policy,
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, type SshTarget, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";
 export { applyIpcTmpEnv, cmdQuote, concreteTmp, encodePowerShellCommand, inferRemoteShell, parseZellijServerPaths, pickIpcDirs, pickIpcTmp, socketDirFromServerPath, tmpFromServerPath, unixDiscoverRemote, windowsDiscoverRemote, windowsInteractiveRemote, wrapWithTmpEnv, } from "./zellij/ipc.js";
-export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
+export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, redactServeSecret, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
 export { parseTabList, resolveTab, type ZellijTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";

package/dist/index.js

@@ -4,9 +4,9 @@ export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeL
 export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
 export { parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
-export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, } from "./zellij/args.js";
-export { busPluginUrl, busToPanes, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, } from "./zellij/bus.js";
-export { busSnapshot, planBus, resetBusCache, } from "./ops/bus.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, } from "./zellij/args.js";
+export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, } from "./zellij/bus.js";
+export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, } from "./ops/bus.js";
 export { createZellijClient, } from "./zellij/client.js";
 export { createStateStore, defaultStateDir, } from "./state.js";
 export { dispatchZswarm } from "./ops/dispatch.js";
@@ -14,7 +14,7 @@ export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./po
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";
 export { applyIpcTmpEnv, cmdQuote, concreteTmp, encodePowerShellCommand, inferRemoteShell, parseZellijServerPaths, pickIpcDirs, pickIpcTmp, socketDirFromServerPath, tmpFromServerPath, unixDiscoverRemote, windowsDiscoverRemote, windowsInteractiveRemote, wrapWithTmpEnv, } from "./zellij/ipc.js";
-export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
+export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, parseListenAddress, redactServeSecret, SERVE_CALL_TIMEOUT_CAP_MS, SERVE_MAX_REQUEST_BYTES, SERVE_TASK_NAME, serveCallTimeout, serveChildEnv, serveLogonCommand, startServe, uninstallServeLogon, } from "./ops/serve.js";
 export { parseTabList, resolveTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";

package/dist/ops/bus.d.ts

@@ -1,4 +1,4 @@
-import type { Policy } from "../policy.js";
+import { type Policy } from "../policy.js";
 import type { StateStore } from "../state.js";
 import { type BusChanged, type BusSnapshot, type BusWait } from "../zellij/bus.js";
 import type { WaitRequest } from "../zellij/args.js";
@@ -15,15 +15,16 @@ export type BusPlan = {
 };
 /** Tests share a module instance; this drops what a previous case cached. */
 export declare function resetBusCache(): void;
-export declare function planBus(client: ZellijClient, state: StateStore, env?: NodeJS.ProcessEnv): BusPlan;
+export declare function planBus(client: ZellijClient, state: StateStore, env?: NodeJS.ProcessEnv, session?: string): BusPlan;
 /**
  * One pipe, one answer — or null, and the caller polls instead.
  *
- * Two things go wrong in practice. A stale instance under the same key eats the
- * message and replies with nothing, so each attempt rotates to a new key. And a
- * freshly launched instance replies before Zellij has pushed it a manifest, so
- * a not-ready answer is retried once rather than reported as an empty session.
- * If it is still cold after that, one same-title rename nudges Zellij to push.
+ * A freshly launched instance replies before Zellij has pushed it a manifest,
+ * so a not-ready answer is retried once rather than reported as an empty
+ * session. If it is still cold after that, one same-title rename nudges Zellij
+ * to push. A silent pipe used to rotate `instance=` keys, and `zellij pipe
+ * --plugin` loads a new copy for each key — that is how a dead bus became
+ * dozens of WASM panes. One remembered key, then polling.
  */
 export declare function busSnapshot(client: ZellijClient, state: StateStore, session: string, clock: Clock, env?: NodeJS.ProcessEnv, payload?: string): Promise<{
     snapshot: BusSnapshot;
@@ -56,5 +57,7 @@ export declare function busWait(client: ZellijClient, state: StateStore, session
  * relative to the previous call rather than a fixed window.
  */
 export declare function busChanged(client: ZellijClient, state: StateStore, session: string, paneIds: string[], env?: NodeJS.ProcessEnv): Promise<BusChanged | null>;
+/** Close every zswarm-bus plugin pane in this session. Best-effort per pane. */
+export declare function closeBusPluginPanes(client: ZellijClient, session: string, pluginPath: string | null): Promise<string[]>;
 /** Report on the bus, install it, or forget it. */
 export declare function busOp(client: ZellijClient, state: StateStore, args: Record<string, unknown>, clock: Clock, env?: NodeJS.ProcessEnv, policy?: Policy): Promise<OpsResult>;

package/dist/ops/bus.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { ZellijError } from "../errors.js";
-import { DEFAULT_BUS_KEY, busPluginUrl, nextConfigKey, parseBusReply, parseChangedReply, parseScrollbackReply, parseWaitReply, resolveBusPlugin, scrollbackToScreen, } from "../zellij/bus.js";
+import { loadPolicy } from "../policy.js";
+import { DEFAULT_BUS_KEY, busPluginUrl, isBusPluginPane, parseBusReply, parseChangedReply, parseScrollbackReply, parseWaitReply, resolveBusPlugin, scrollbackToScreen, } from "../zellij/bus.js";
 import { isTrue } from "./util.js";
 /**
  * Whether to ask the event-bus plugin, and what to do when it does not answer.
@@ -9,10 +10,14 @@ import { isTrue } from "./util.js";
  * prompt, because a pipe to a plugin that was never approved costs a process
  * and a timeout on every call and then falls back anyway.
  */
-/** Config keys to try before giving up; each one is a fresh pipe destination. */
-const MAX_KEY_ATTEMPTS = 3;
 /** A just-launched instance answers before Zellij has pushed it anything. */
 const COLD_RETRY_MS = 200;
+/**
+ * A marker written this recently with no live pane is an in-flight install,
+ * not a closed pane. Relaunching it is how concurrent agents used to stack
+ * copies.
+ */
+const INSTALL_IN_FLIGHT_MS = 10_000;
 /** Set once a pipe has failed, so one dead plugin costs one timeout, not many. */
 let processDisabled = null;
 /** The key that actually answered, per session, for the life of this process. */
@@ -30,8 +35,8 @@ function negative(raw) {
     const v = (raw ?? "").trim().toLowerCase();
     return v === "0" || v === "false" || v === "no" || v === "off";
 }
-export function planBus(client, state, env = process.env) {
-    const marker = state.readBus();
+export function planBus(client, state, env = process.env, session = "") {
+    const marker = session ? state.readBus(session) : null;
     // A marker can outlive the wasm it names — an upgrade renames the artifact,
     // so a remembered path that no longer exists must not shadow the current one.
     const remembered = marker && existsSync(marker.plugin) ? marker : null;
@@ -75,7 +80,9 @@ async function askOnce(client, session, url, configKey, payload) {
  * blind (ready:false, paneUpdates:0) until something moves. Renaming a pane
  * to the title it already has is an invisible change that forces the push.
  */
-async function nudgeManifest(client, session) {
+async function nudgeManifest(client, session, env) {
+    if (loadPolicy(env).readOnly)
+        return;
     const panes = await client.listPanes(session);
     const pane = panes.find((p) => !p.isPlugin && !p.exited && p.title.trim());
     if (!pane)
@@ -85,52 +92,40 @@ async function nudgeManifest(client, session) {
 /**
  * One pipe, one answer — or null, and the caller polls instead.
  *
- * Two things go wrong in practice. A stale instance under the same key eats the
- * message and replies with nothing, so each attempt rotates to a new key. And a
- * freshly launched instance replies before Zellij has pushed it a manifest, so
- * a not-ready answer is retried once rather than reported as an empty session.
- * If it is still cold after that, one same-title rename nudges Zellij to push.
+ * A freshly launched instance replies before Zellij has pushed it a manifest,
+ * so a not-ready answer is retried once rather than reported as an empty
+ * session. If it is still cold after that, one same-title rename nudges Zellij
+ * to push. A silent pipe used to rotate `instance=` keys, and `zellij pipe
+ * --plugin` loads a new copy for each key — that is how a dead bus became
+ * dozens of WASM panes. One remembered key, then polling.
  */
 export async function busSnapshot(client, state, session, clock, env = process.env, payload = "status") {
-    const plan = planBus(client, state, env);
+    const plan = planBus(client, state, env, session);
     const pluginPath = plan.plugin;
     if (!plan.enabled || !plan.url || !pluginPath)
         return null;
-    let configKey = answeredWith.get(session) ?? plan.configKey;
-    let nudged = false;
-    for (let attempt = 0; attempt < MAX_KEY_ATTEMPTS; attempt++) {
-        let snapshot = await askOnce(client, session, plan.url, configKey, payload);
-        if (snapshot && !snapshot.ready) {
-            await clock.sleep(COLD_RETRY_MS);
+    const configKey = answeredWith.get(session) ?? plan.configKey;
+    let snapshot = await askOnce(client, session, plan.url, configKey, payload);
+    if (snapshot && !snapshot.ready) {
+        await clock.sleep(COLD_RETRY_MS);
+        snapshot =
+            (await askOnce(client, session, plan.url, configKey, payload)) ??
+                snapshot;
+    }
+    if (snapshot && !snapshot.ready) {
+        try {
+            await nudgeManifest(client, session, env);
             snapshot =
                 (await askOnce(client, session, plan.url, configKey, payload)) ??
                     snapshot;
         }
-        if (snapshot && !snapshot.ready && !nudged) {
-            nudged = true;
-            try {
-                await nudgeManifest(client, session);
-                snapshot =
-                    (await askOnce(client, session, plan.url, configKey, payload)) ??
-                        snapshot;
-            }
-            catch {
-                // A failed nudge must not fail the op — the caller polls instead.
-            }
-        }
-        if (snapshot) {
-            answeredWith.set(session, configKey);
-            if (plan.installed && configKey !== plan.configKey) {
-                // Remember the rotation, so the next process starts on a live key.
-                state.writeBus({
-                    plugin: pluginPath,
-                    configKey,
-                    installedAt: clock.now(),
-                });
-            }
-            return { snapshot, configKey };
+        catch {
+            // A failed nudge must not fail the op — the caller polls instead.
         }
-        configKey = nextConfigKey(configKey);
+    }
+    if (snapshot) {
+        answeredWith.set(session, configKey);
+        return { snapshot, configKey };
     }
     processDisabled = "plugin did not answer; using zellij polling for this run";
     return null;
@@ -149,7 +144,7 @@ export async function busSnapshot(client, state, session, clock, env = process.e
 export async function busScreens(client, state, session, paneIds, clock, env = process.env) {
     if (paneIds.length < 2)
         return null;
-    const plan = planBus(client, state, env);
+    const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
     const configKey = answeredWith.get(session) ?? plan.configKey;
@@ -179,7 +174,7 @@ export async function busScreens(client, state, session, paneIds, clock, env = p
  * instance, no reply — and the caller runs its own loop.
  */
 export async function busWait(client, state, session, request, env = process.env) {
-    const plan = planBus(client, state, env);
+    const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
     const configKey = answeredWith.get(session) ?? plan.configKey;
@@ -202,7 +197,7 @@ export async function busWait(client, state, session, request, env = process.env
 export async function busChanged(client, state, session, paneIds, env = process.env) {
     if (paneIds.length === 0)
         return null;
-    const plan = planBus(client, state, env);
+    const plan = planBus(client, state, env, session);
     if (!plan.enabled || !plan.url)
         return null;
     const configKey = answeredWith.get(session) ?? plan.configKey;
@@ -217,14 +212,63 @@ export async function busChanged(client, state, session, paneIds, env = process.
         return null;
     return parsed.panes.length === paneIds.length ? parsed : null;
 }
+function installedReply(session, plugin, configKey, ready, panes, extra = {}) {
+    return {
+        ok: true,
+        data: {
+            session,
+            installed: true,
+            plugin,
+            url: busPluginUrl(plugin),
+            configKey,
+            ready,
+            panes,
+            ...extra,
+        },
+    };
+}
+async function listBusPluginPanes(client, session, pluginPath) {
+    const panes = await client.listPanes(session);
+    return panes.filter((pane) => isBusPluginPane(pane, pluginPath));
+}
+/** Close every zswarm-bus plugin pane in this session. Best-effort per pane. */
+export async function closeBusPluginPanes(client, session, pluginPath) {
+    const closed = [];
+    const panes = await listBusPluginPanes(client, session, pluginPath);
+    for (const pane of panes) {
+        try {
+            await client.closePane({ session, paneId: pane.id });
+            closed.push(pane.id);
+        }
+        catch {
+            // A pane that vanished between list and close is the desired end state.
+        }
+    }
+    return closed;
+}
 /** Report on the bus, install it, or forget it. */
 export async function busOp(client, state, args, clock, env = process.env, policy) {
+    const sessionArg = typeof args.session === "string" ? args.session : undefined;
     if (isTrue(args.clear)) {
-        state.clearBus();
+        let session = null;
+        let closed = [];
+        try {
+            session = (await client.resolveSession(sessionArg)).session;
+        }
+        catch {
+            session = sessionArg?.trim() || null;
+        }
+        if (session) {
+            closed = await closeBusPluginPanes(client, session, resolveBusPlugin(env) ?? state.readBus(session)?.plugin ?? null);
+            state.clearBus(session);
+        }
+        else {
+            state.clearBus();
+        }
         resetBusCache();
-        return { ok: true, data: { installed: false, cleared: true } };
+        return { ok: true, data: { installed: false, cleared: true, closed } };
     }
-    const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
+    const { session } = await client.resolveSession(sessionArg);
     if (isTrue(args.install)) {
         // Installing opens a pane, which a read-only crew is not allowed to do.
         if (policy?.readOnly) {
@@ -234,32 +278,31 @@ export async function busOp(client, state, args, clock, env = process.env, polic
         if (!plugin) {
             throw new ZellijError("bus_missing", "no plugin wasm found; run pnpm build:plugin or set ZSWARM_BUS_PLUGIN");
         }
-        const previous = state.readBus();
+        const previous = state.readBus(session);
         const force = isTrue(args.force);
-        // Launching again would add a second instance, so an install that is
-        // already answering is a no-op unless the caller asked for a fresh one.
         if (previous && !force) {
             const live = await busSnapshot(client, state, session, clock, env);
             if (live?.snapshot.ready) {
-                return {
-                    ok: true,
-                    data: {
-                        session,
-                        installed: true,
-                        plugin: previous.plugin,
-                        url: busPluginUrl(previous.plugin),
-                        configKey: live.configKey,
-                        ready: true,
-                        panes: live.snapshot.panes.length,
-                        note: "already installed; --force reloads under a fresh key",
-                    },
-                };
+                return installedReply(session, previous.plugin, live.configKey, true, live.snapshot.panes.length, { note: "already installed" });
+            }
+            const existing = await listBusPluginPanes(client, session, plugin);
+            if (existing.length > 0) {
+                return installedReply(session, previous.plugin, previous.configKey, false, null, {
+                    pane: existing[0]?.id ?? null,
+                    note: "already installed but not answering; approve the permission prompt in the existing pane — do not --force unless you intend to replace it",
+                });
+            }
+            if (clock.now() - previous.installedAt < INSTALL_IN_FLIGHT_MS) {
+                return installedReply(session, previous.plugin, previous.configKey, false, null, {
+                    note: "install already in flight; wait for the permission prompt rather than launching another pane",
+                });
             }
         }
-        // A reload needs a key Zellij has not already bound an instance to.
-        const configKey = force && previous
-            ? nextConfigKey(previous.configKey)
-            : (previous?.configKey ?? DEFAULT_BUS_KEY);
+        // Marker first so a concurrent install sees an in-flight write and
+        // stops. Then reap orphans so a reload cannot stack on the old copies.
+        const configKey = previous?.configKey ?? DEFAULT_BUS_KEY;
+        state.writeBus(session, { plugin, configKey, installedAt: clock.now() });
+        const closed = await closeBusPluginPanes(client, session, plugin);
         const url = busPluginUrl(plugin);
         const launched = await client.launchPlugin({
             session,
@@ -268,27 +311,17 @@ export async function busOp(client, state, args, clock, env = process.env, polic
             floating: true,
             skipCache: force,
         });
-        state.writeBus({ plugin, configKey, installedAt: clock.now() });
         resetBusCache();
         const probe = await busSnapshot(client, state, session, clock, env);
-        return {
-            ok: true,
-            data: {
-                session,
-                installed: true,
-                plugin,
-                url,
-                configKey,
-                pane: launched.paneId,
-                ready: probe?.snapshot.ready ?? false,
-                panes: probe?.snapshot.panes.length ?? null,
-                note: probe
-                    ? "bus answering; list and status use it now, and this pane can be closed"
-                    : "approve the plugin's permission prompt in the new pane, then re-run",
-            },
-        };
+        return installedReply(session, plugin, configKey, probe?.snapshot.ready ?? false, probe?.snapshot.panes.length ?? null, {
+            pane: launched.paneId,
+            closed,
+            note: probe
+                ? "bus answering; keep this floating pane open — closing it unloads the bus"
+                : "approve the plugin's permission prompt in the new pane, then re-run without --install",
+        });
     }
-    const plan = planBus(client, state, env);
+    const plan = planBus(client, state, env, session);
     const probe = plan.enabled
         ? await busSnapshot(client, state, session, clock, env)
         : null;

package/dist/ops/delivery.d.ts

@@ -40,9 +40,9 @@ export declare function withSenderLabel(args: Record<string, unknown>, opts?: {
     selfTitle?: string | null;
 }): Record<string, unknown>;
 /**
- * Before forwarding over `ZSWARM_SERVE`, keep a caller-chosen label and
- * leave `from` unset when it would default, so the Zellij-side process can
- * still fill in its own pane title.
+ * Before forwarding over `ZSWARM_SERVE`, stamp a caller-chosen label. Leaving
+ * `from` unset used to let the Zellij-side process fill in its pane title —
+ * which is the serve daemon when it runs in a pane, not the remote sender.
  */
 export declare function attachKnownSender(args: Record<string, unknown>, env: NodeJS.ProcessEnv): Record<string, unknown>;
 export declare function bodyText(client: ZellijClient, args: Record<string, unknown>, body: string): string;

package/dist/ops/delivery.js

@@ -45,19 +45,16 @@ export function withSenderLabel(args, opts = {}) {
     return { ...args, from: senderLabel(args, opts) };
 }
 /**
- * Before forwarding over `ZSWARM_SERVE`, keep a caller-chosen label and
- * leave `from` unset when it would default, so the Zellij-side process can
- * still fill in its own pane title.
+ * Before forwarding over `ZSWARM_SERVE`, stamp a caller-chosen label. Leaving
+ * `from` unset used to let the Zellij-side process fill in its pane title —
+ * which is the serve daemon when it runs in a pane, not the remote sender.
  */
 export function attachKnownSender(args, env) {
     const op = String(args.op ?? "");
     if (op !== "send" && op !== "broadcast")
         return args;
     const sender = resolveSender(args, { env });
-    if (sender.source === "arg" || sender.source === "env") {
-        return { ...args, from: sender.label };
-    }
-    return args;
+    return { ...args, from: sender.label };
 }
 export function bodyText(client, args, body) {
     return isTrue(args.raw) ? body : client.formatPeerMessage(senderLabel(args), body);

package/dist/ops/dispatch.js

@@ -17,7 +17,7 @@ import { spawnPane } from "./spawn.js";
 import { peerStatus } from "./status.js";
 import { tailPane } from "./tail.js";
 import { OP_NAMES } from "../schema.js";
-import { dumpMaxChars, fail, isTrue, isVerbose, optionalString, paneViewBus, paneViewFull, paneViewSlim, truncateDumpText, } from "./util.js";
+import { dumpMaxChars, fail, isTrue, isVerbose, optionalString, paneViewBus, paneViewFull, paneViewSlim, throwIfAborted, truncateDumpText, } from "./util.js";
 import { waitForPane } from "./wait.js";
 import { listPeerWorktrees, removePeerWorktree } from "./worktree.js";
 import { callServe, installServeLogon, serveCallTimeout, uninstallServeLogon, } from "./serve.js";
@@ -85,10 +85,23 @@ async function resolveTarget(client, args, state, clock, env, policy, op) {
 export async function dispatchZswarm(args, injected, deps = {}) {
     const op = String(args.op ?? "");
     const verbose = isVerbose(args);
+    const signal = deps.signal;
+    throwIfAborted(signal);
     const clock = {
         now: deps.now ?? (() => Date.now()),
         sleep: deps.sleep ??
-            ((ms) => new Promise((r) => setTimeout(r, ms))),
+            ((ms) => new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new ZellijError("cancelled", "operation cancelled"));
+                    return;
+                }
+                const timer = setTimeout(resolve, ms);
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(new ZellijError("cancelled", "operation cancelled"));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+            })),
     };
     // Only the worktree ops need git, so the client is built on demand.
     let gitClient = deps.git ?? null;
@@ -121,7 +134,7 @@ export async function dispatchZswarm(args, injected, deps = {}) {
         if (!injected && env.ZSWARM_SERVE?.trim()) {
             return await callServe(env.ZSWARM_SERVE.trim(), attachKnownSender(args, env), serveCallTimeout(args), env.ZSWARM_SERVE_TOKEN);
         }
-        const client = injected ?? createZellijClient({ env: deps.env });
+        const client = injected ?? createZellijClient({ env: deps.env, signal });
         switch (op) {
             case "sessions": {
                 const sessions = await client.listSessions();
@@ -278,15 +291,14 @@ export async function dispatchZswarm(args, injected, deps = {}) {
                 // no engine — and then this is the loop that runs.
                 const viaBus = isTrue(args.regex)
                     ? undefined
-                    : () => busWait(client, state(), target.session, {
+                    : (timing) => busWait(client, state(), target.session, {
                         pane: target.pane.id,
                         for: waitMode(args),
                         match: typeof args.match === "string" ? args.match : null,
                         ignoreCase: isTrue(args.ignoreCase),
-                        idleMs: Number(args.idleMs ?? 2000),
-                        timeoutMs: Number(args.timeoutMs ?? 60_000),
+                        ...timing,
                     }, deps.env);
-                return await waitForPane(client, target, args, clock, viaBus);
+                return await waitForPane(client, target, args, clock, viaBus, deps.signal);
             }
             case "status": {
                 const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);

package/dist/ops/serve.d.ts

@@ -36,6 +36,7 @@ export declare function parseServeTarget(raw: string): {
     port: number;
 };
 export declare function callServe(target: string, args: Record<string, unknown>, timeoutMs?: number, token?: string): Promise<OpsResult>;
+export declare function redactServeSecret(command: string, token: string): string;
 export declare function serveLogonCommand(execPath: string, scriptPath: string, listen: string, token?: string): string;
 export declare function installServeLogon(input: {
     listen?: string;

package/dist/ops/serve.js

@@ -252,6 +252,12 @@ export function callServe(target, args, timeoutMs = 15_000, token) {
         });
     });
 }
+export function redactServeSecret(command, token) {
+    const secret = token.trim();
+    if (!secret)
+        return command;
+    return command.split(secret).join("***");
+}
 export function serveLogonCommand(execPath, scriptPath, listen, token) {
     const launch = `"${execPath}" "${scriptPath}" serve --listen ${listen}`;
     const secret = token?.trim();
@@ -323,7 +329,7 @@ export async function installServeLogon(input) {
     if (result.code !== 0) {
         throw new ZellijError("zellij_failed", `serve --install failed: ${(result.stderr || result.stdout).trim() || "no output"}`);
     }
-    return { task: SERVE_TASK_NAME, listen: label, command };
+    return { task: SERVE_TASK_NAME, listen: label, command: redactServeSecret(command, token) };
 }
 export async function uninstallServeLogon(input = {}) {
     if ((input.platform ?? process.platform) !== "win32") {

package/dist/ops/types.d.ts

@@ -19,6 +19,8 @@ export type DispatchDeps = {
     state?: StateStore;
     policy?: Policy;
     env?: NodeJS.ProcessEnv;
+    /** MCP cancellation; aborted waits stop instead of running to timeout. */
+    signal?: AbortSignal;
 };
 export type Clock = {
     now: () => number;

package/dist/ops/util.d.ts

@@ -45,4 +45,5 @@ export declare function numberArg(args: Record<string, unknown>, key: string, fa
     min: number;
     max: number;
 }): number;
+export declare function throwIfAborted(signal?: AbortSignal): void;
 export declare function dumpMaxChars(args: Record<string, unknown>, fallback?: number): number;

package/dist/ops/util.js

@@ -73,6 +73,11 @@ export function numberArg(args, key, fallback, limits) {
     }
     return Math.min(limits.max, Math.max(limits.min, Math.floor(n)));
 }
+export function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new ZellijError("cancelled", "operation cancelled");
+    }
+}
 export function dumpMaxChars(args, fallback = DEFAULT_DUMP_MAX_CHARS) {
     if (args.max === undefined || args.max === null || args.max === "") {
         return fallback;

package/dist/ops/wait.d.ts

@@ -5,6 +5,13 @@ import type { Clock, OpsResult } from "./types.js";
 export declare function buildMatcher(args: Record<string, unknown>): ((text: string) => boolean) | null;
 /** Held-pipe wait answer, shaped by `parseWaitReply` in `zellij/bus.ts`. */
 export type { BusWait };
+/** Clamped timing the bus path must use — never the raw request numbers. */
+export type WaitBusTiming = {
+    idleMs: number;
+    timeoutMs: number;
+    pollMs: number;
+    full: boolean;
+};
 /**
  * Poll a pane's screen until it goes quiet, prints a match, or the deadline
  * passes — so callers stop re-dumping in a loop of their own.
@@ -16,4 +23,4 @@ export type { BusWait };
 export declare function waitForPane(client: ZellijClient, target: {
     session: string;
     pane: ZellijPane;
-}, args: Record<string, unknown>, clock: Clock, waitViaBus?: () => Promise<BusWait | null>): Promise<OpsResult>;
+}, args: Record<string, unknown>, clock: Clock, waitViaBus?: (timing: WaitBusTiming) => Promise<BusWait | null>, signal?: AbortSignal): Promise<OpsResult>;

package/dist/ops/wait.js

@@ -1,5 +1,5 @@
 import { ZellijError } from "../errors.js";
-import { DEFAULT_WAIT_MAX_CHARS, dumpMaxChars, isTrue, normalizeScreen, numberArg, optionalString, truncateDumpText, } from "./util.js";
+import { DEFAULT_WAIT_MAX_CHARS, dumpMaxChars, isTrue, normalizeScreen, numberArg, optionalString, throwIfAborted, truncateDumpText, } from "./util.js";
 const WAIT_DEFAULTS = {
     idleMs: 2_000,
     pollMs: 150,
@@ -56,7 +56,7 @@ function waitResult(reason, ctx) {
  * Null (plugin missing or silent) falls back to dump-screen polling. The
  * pipe's own timeout belongs to the transport; this op does not cap it.
  */
-export async function waitForPane(client, target, args, clock, waitViaBus) {
+export async function waitForPane(client, target, args, clock, waitViaBus, signal) {
     const { session, pane } = target;
     const matcher = buildMatcher(args);
     const requested = optionalString(args.for) ?? (matcher ? "match" : "idle");
@@ -72,8 +72,11 @@ export async function waitForPane(client, target, args, clock, waitViaBus) {
     const pollMs = numberArg(args, "pollMs", WAIT_DEFAULTS.pollMs, WAIT_LIMITS.pollMs);
     const timeoutMs = numberArg(args, "timeoutMs", WAIT_DEFAULTS.timeoutMs, WAIT_LIMITS.timeoutMs);
     const started = clock.now();
+    const full = isTrue(args.full);
     if (waitViaBus) {
-        const reply = await waitViaBus();
+        throwIfAborted(signal);
+        const reply = await waitViaBus({ idleMs, timeoutMs, pollMs, full });
+        throwIfAborted(signal);
         // `gone` is filtered upstream: a pane that vanished mid-wait is reported by
         // the polling path, which has the error message for it.
         if (reply && reply.reason !== "gone") {
@@ -96,6 +99,7 @@ export async function waitForPane(client, target, args, clock, waitViaBus) {
     let polls = 0;
     let changes = 0;
     for (;;) {
+        throwIfAborted(signal);
         const dumped = await client.dumpPane({
             session,
             paneId: pane.id,

package/dist/schema.js

@@ -42,6 +42,9 @@ export const TARGET_OPS = [
     "keys",
     "interrupt",
     "close",
+    "rename",
+    "focus",
+    "stack",
 ];
 export const PARAMS = [
     {
@@ -382,7 +385,7 @@ export const PARAMS = [
         name: "force",
         type: "boolean",
         flags: ["--force"],
-        description: "send/keys: write to a pane whose command has exited; unworktree: remove a busy or dirty worktree; bus: reinstall under a fresh key",
+        description: "send/keys: write to a pane whose command has exited; unworktree: remove a busy or dirty worktree; bus: close orphan bus panes and reload this session's plugin",
     },
     {
         name: "listen",
@@ -447,7 +450,7 @@ export function cliUsage() {
         const value = param.type === "boolean" ? "" : param.type === "number" ? " N" : " VALUE";
         lines.push(`  ${param.flags.join(", ").padEnd(28)}${value.trim().padEnd(6)}${param.description}`);
     }
-    lines.push("", "Guards: writes refuse zswarm's own pane (--allow-self) and exited panes (--force). --expect requires the screen to contain a substring first.", "Bus: `zswarm bus --install` once, then list and status use it now.", "Remote: ZSWARM_SSH (+ ZSWARM_TMP=auto or ZSWARM_SSH_MODE=interactive on Windows). Or run `zswarm serve --listen` next to Zellij and set ZSWARM_SERVE (+ ZSWARM_SERVE_TOKEN off loopback).", "Env: ZSWARM_BIN, ZSWARM_PATH, ZSWARM_SESSION, ZSWARM_SELF_PANE, ZSWARM_FROM, ZELLIJ_PANE_ID, ZELLIJ_SESSION_NAME, ZSWARM_BUS, ZSWARM_BUS_PLUGIN, ZSWARM_SSH, ZSWARM_TMP, ZSWARM_SSH_MODE, ZSWARM_SERVE, ZSWARM_SERVE_TOKEN", "");
+    lines.push("", "Guards: writes refuse zswarm's own pane (--allow-self) and exited panes (--force). --expect requires the screen to contain a substring first.", "Bus: `zswarm bus --install` once per Zellij session. `--force` closes orphan bus panes and reloads; do not use it as a retry.", "Remote: ZSWARM_SSH (+ ZSWARM_TMP=auto or ZSWARM_SSH_MODE=interactive on Windows). Or run `zswarm serve --listen` next to Zellij and set ZSWARM_SERVE (+ ZSWARM_SERVE_TOKEN). Serve binds loopback only and always requires a token.", "Env: ZSWARM_BIN, ZSWARM_PATH, ZSWARM_SESSION, ZSWARM_SELF_PANE, ZSWARM_FROM, ZELLIJ_PANE_ID, ZELLIJ_SESSION_NAME, ZSWARM_BUS, ZSWARM_BUS_PLUGIN, ZSWARM_SSH, ZSWARM_TMP, ZSWARM_SSH_MODE, ZSWARM_SERVE, ZSWARM_SERVE_TOKEN", "");
     return lines.join("\n");
 }
 /** Turn argv (without the op) into dispatch args, driven by PARAMS. */

package/dist/state.d.ts

@@ -19,9 +19,10 @@ export type SignalChannel = {
     last: string | null;
 };
 /**
- * Written once by `bus --install`, after the plugin's permission prompt has
- * been answered. Its presence is what lets later runs try the fast path without
- * every cold `zswarm status` paying for a pipe that was never going to answer.
+ * Written by `bus --install` per Zellij session, after the plugin's permission
+ * prompt has been answered. Its presence is what lets later runs try the fast
+ * path without every cold `zswarm status` paying for a pipe that was never
+ * going to answer.
  */
 export type BusMarkerRecord = {
     plugin: string;
@@ -44,9 +45,9 @@ export declare function createStateStore(options?: StateStoreOptions): {
     readCursor: (key: string) => string | null;
     writeCursor: (key: string, text: string) => void;
     clearCursor: (key: string) => void;
-    readBus: () => BusMarkerRecord | null;
-    writeBus: (marker: BusMarkerRecord) => void;
-    clearBus: () => void;
+    readBus: (session: string) => BusMarkerRecord | null;
+    writeBus: (session: string, marker: BusMarkerRecord) => void;
+    clearBus: (session?: string) => void;
     reset: () => void;
 };
 export type StateStore = ReturnType<typeof createStateStore>;

package/dist/state.js

@@ -10,6 +10,8 @@ const BUS_FILE = "bus.json";
 /** Keeps the log bounded without needing a rotation daemon. */
 const LOG_TAIL_BYTES = 512 * 1024;
 const LOCK_WAIT_MS = 5_000;
+/** A live pid older than this is treated as a recycle of a crashed holder. */
+const LOCK_STALE_MS = 30_000;
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -102,16 +104,24 @@ export function createStateStore(options = {}) {
         }
     }
     /**
-     * Dead pid → steal now. Empty leftover from older writers (wx with no owner
-     * bytes) → steal once mtime is older than the wait, so an in-flight create is
-     * not yanked out from under the holder.
+     * Dead pid → steal now. This process's own leftover (unlink failed, or a
+     * non-reentrant re-entry) → steal now. A live pid whose `at` is older than
+     * LOCK_STALE_MS is a recycled pid, not a holder still inside fn().
+     * Empty leftover from older writers (wx with no owner bytes) → steal once
+     * mtime is older than the wait, so an in-flight create is not yanked out
+     * from under the holder.
      * Owner is read once: a second read can see a pid that appeared after an
      * empty snapshot and would steal a live lock.
      */
     function lockIsStale(lockPath) {
         const owner = readLockOwner(lockPath);
-        if (owner)
-            return !pidAlive(owner.pid);
+        if (owner) {
+            if (owner.pid === process.pid)
+                return true;
+            if (!pidAlive(owner.pid))
+                return true;
+            return Date.now() - owner.at >= LOCK_STALE_MS;
+        }
         try {
             return Date.now() - statSync(lockPath).mtimeMs >= LOCK_WAIT_MS;
         }
@@ -162,7 +172,7 @@ export function createStateStore(options = {}) {
                 const code = err.code;
                 if (!lockBusy(code))
                     throw err;
-                if (code === "EEXIST" && lockIsStale(lockPath)) {
+                if (lockIsStale(lockPath)) {
                     unlinkLock(lockPath);
                     continue;
                 }
@@ -222,22 +232,72 @@ export function createStateStore(options = {}) {
             writeJson(CURSORS_FILE, all);
         });
     }
-    function readBus() {
-        const value = readJson(BUS_FILE, null);
-        if (!value || typeof value.plugin !== "string" || !value.plugin)
+    function asMarker(value) {
+        if (!value || typeof value !== "object")
+            return null;
+        const rec = value;
+        if (typeof rec.plugin !== "string" || !rec.plugin)
+            return null;
+        if (typeof rec.configKey !== "string" || !rec.configKey)
             return null;
-        return value;
+        return {
+            plugin: rec.plugin,
+            configKey: rec.configKey,
+            installedAt: typeof rec.installedAt === "number" ? rec.installedAt : 0,
+        };
     }
-    function writeBus(marker) {
-        writeJson(BUS_FILE, marker);
+    /**
+     * Current `{ sessions: { <name>: marker } }` plus the pre-0.1.6 flat file
+     * `{ plugin, configKey, installedAt }`, which any session may inherit until
+     * the next write namespaces it.
+     */
+    function readBusFile() {
+        const raw = readJson(BUS_FILE, null);
+        if (!raw || typeof raw !== "object")
+            return { sessions: {}, legacy: null };
+        const sessions = {};
+        if (raw.sessions && typeof raw.sessions === "object") {
+            for (const [name, marker] of Object.entries(raw.sessions)) {
+                const parsed = asMarker(marker);
+                if (parsed)
+                    sessions[name] = parsed;
+            }
+        }
+        return { sessions, legacy: asMarker(raw) };
     }
-    function clearBus() {
-        try {
-            rmSync(join(dir, BUS_FILE), { force: true });
+    function readBus(session) {
+        if (!session)
+            return null;
+        const { sessions, legacy } = readBusFile();
+        return sessions[session] ?? legacy;
+    }
+    function writeBus(session, marker) {
+        const { sessions } = readBusFile();
+        sessions[session] = marker;
+        writeJson(BUS_FILE, { sessions });
+    }
+    function clearBus(session) {
+        if (!session) {
+            try {
+                rmSync(join(dir, BUS_FILE), { force: true });
+            }
+            catch {
+                // Nothing to forget.
+            }
+            return;
         }
-        catch {
-            // Nothing to forget.
+        const { sessions } = readBusFile();
+        delete sessions[session];
+        if (Object.keys(sessions).length === 0) {
+            try {
+                rmSync(join(dir, BUS_FILE), { force: true });
+            }
+            catch {
+                // Nothing to forget.
+            }
+            return;
         }
+        writeJson(BUS_FILE, { sessions });
     }
     /** Test helper: drop everything this store wrote. */
     function reset() {

package/dist/zellij/args.d.ts

@@ -47,6 +47,8 @@ export type WaitRequest = {
     idleMs?: number;
     timeoutMs?: number;
     pollMs?: number;
+    /** Read scrollback above the viewport, matching dump --full. */
+    full?: boolean;
 };
 /**
  * `regex` is deliberately absent: the plugin has no regex engine, refuses such

package/dist/zellij/args.js

@@ -35,6 +35,7 @@ export function waitPayload(req) {
         idleMs: req.idleMs ?? 2000,
         timeoutMs: req.timeoutMs ?? 60000,
         pollMs: req.pollMs ?? 50,
+        full: req.full === true,
     });
 }
 /** Screens plus "did this move since you last asked", so status needs no gap. */

package/dist/zellij/bus.d.ts

@@ -67,6 +67,15 @@ export declare function resolveBusPlugin(env?: NodeJS.ProcessEnv): string | null
 export declare function busPluginUrl(pluginPath: string): string;
 /** zswarm-bus → zswarm-bus-2 → zswarm-bus-3: a fresh pipe destination each time. */
 export declare function nextConfigKey(key: string): string;
+/**
+ * Plugin panes belonging to this bus — never tab-bar / status-bar / room.
+ * Titles are the `file:` URL (or the wasm basename) Zellij shows for the pane.
+ */
+export declare function isBusPluginPane(pane: {
+    isPlugin?: boolean;
+    title?: string;
+    command?: string | null;
+}, pluginPath?: string | null): boolean;
 /**
  * Pull the plugin's answer out of the pipe. Zellij interleaves its own notices
  * ("Action CliPipe did not complete within 1s timeout" shows up on successful

package/dist/zellij/bus.js

@@ -140,6 +140,26 @@ export function nextConfigKey(key) {
         return `${key}-2`;
     return `${match[1]}-${Number(match[2]) + 1}`;
 }
+/**
+ * Plugin panes belonging to this bus — never tab-bar / status-bar / room.
+ * Titles are the `file:` URL (or the wasm basename) Zellij shows for the pane.
+ */
+export function isBusPluginPane(pane, pluginPath) {
+    if (!pane.isPlugin)
+        return false;
+    const hay = `${pane.title ?? ""}\n${pane.command ?? ""}`
+        .replace(/\\/g, "/")
+        .toLowerCase();
+    if (hay.includes("zswarm-bus") || hay.includes("zswarm-events"))
+        return true;
+    if (!pluginPath)
+        return false;
+    const normalized = pluginPath.replace(/\\/g, "/").toLowerCase();
+    if (normalized && hay.includes(normalized))
+        return true;
+    const base = normalized.split("/").pop();
+    return Boolean(base && hay.includes(base));
+}
 function toSnapshot(value) {
     if (value.ok !== true || !Array.isArray(value.panes))
         return null;

package/dist/zellij/client.d.ts

@@ -8,6 +8,7 @@ export type ZellijClientOptions = {
     zellijPath?: string;
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
 };
 /** Thin, stateless wrapper over the `zellij` binary. */
 export declare function createZellijClient(options?: ZellijClientOptions): {

package/dist/zellij/client.js

@@ -13,10 +13,11 @@ export function createZellijClient(options = {}) {
     const ssh = options.exec ? null : resolveSshTarget(env);
     const zellijPath = options.zellijPath ??
         (ssh ? `ssh://${ssh.host}/${ssh.remoteBin}` : resolveZellijBinary(env));
-    const exec = options.exec ??
+    const rawExec = options.exec ??
         (ssh
             ? createSshExec(ssh, sanitizeZellijEnv(env))
             : defaultExec(zellijPath, env));
+    const exec = (args, opts) => rawExec(args, { ...opts, signal: opts.signal ?? options.signal });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const selfPaneId = resolveSelfPaneId(env);
     async function run(args, label) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/core",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@zswarm/wasm": "0.1.1"
+    "@zswarm/wasm": "0.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",