@zswarm/core 0.1.5 → 0.1.7

package/README.md

@@ -27,7 +27,10 @@ const result = await dispatchZswarm({ op: "list" });
 ```
 
 `dispatchZswarm` builds a Zellij client unless you pass one. The result is
-`{ ok, data }` or `{ ok: false, error }`.
+`{ ok, data }` or `{ ok: false, error }`, with routing `context` once the
+invocation's destination is known.
+
+Spawn lifecycle, body files, guarded keys, status tabs and routing context: [crew operations](../../docs/crew-operations.md).
 
 Ops, env, and the event bus: the [zswarm README](../../README.md).
 

package/dist/exec.d.ts

@@ -1,4 +1,4 @@
-import { type RemoteShell } from "./zellij/ipc.js";
+import { type IpcDirs, type RemoteShell } from "./zellij/ipc.js";
 export type ExecResult = {
     code: number;
     stdout: string;
@@ -39,9 +39,54 @@ export declare function quoteRemoteArg(arg: string, shell: RemoteShell): string;
  * The string `ssh host <this>` runs. Tests assert this rather than spawning ssh.
  */
 export declare function buildSshRemoteCommand(target: SshTarget, args: string[], tmp: string | undefined, timeoutMs: number, socketDir?: string): string;
+/** Outcome of `ZSWARM_TMP=auto` discovery for session diagnostics. */
+export type IpcDiscoveryState = {
+    requested: string | null;
+    /** `none` = no tmp routing; `resolved`/`failed` only after an auto attempt. */
+    status: "none" | "skipped" | "resolved" | "failed" | "cancelled" | "expired";
+    tmp?: string;
+    socketDir?: string;
+};
+export type SshExecFn = ExecFn & {
+    ipcState: IpcDiscoveryState;
+    /**
+     * Resolve `ZSWARM_TMP=auto` once under this caller's budget before parallel
+     * identity/capability probes. Independent of other callers' in-flight work.
+     */
+    prepareIpc: (timeoutMs: number, signal?: AbortSignal) => Promise<IpcDirs | undefined>;
+};
+/** Positive `auto` IPC hits only; failures/cancels never enter this map. */
+export declare const DEFAULT_IPC_DISCOVERY_TTL_MS = 15000;
+export declare const DEFAULT_IPC_DISCOVERY_CACHE_LIMIT = 512;
+/** Fully scoped key so hosts / SSH bins / remote shells / users never collide. */
+export declare function ipcDiscoveryCacheKey(target: SshTarget, env?: NodeJS.ProcessEnv): string;
+/**
+ * Probe list for `ZSWARM_TMP=auto`. Known Windows (cmd / interactive / .exe)
+ * skips the Unix `ps` fallback; explicit `sh` skips PowerShell. Unknown
+ * `zellij` still tries both — a Windows host with remoteBin=zellij looks Unix.
+ */
+export declare function ipcDiscoveryProbes(target: SshTarget): string[];
+export declare function resetIpcDiscoveryCache(): void;
+/** Test helper: shrink the positive-hit TTL without exposing the map. */
+export declare function setIpcDiscoveryTtlMs(ttlMs: number): void;
+export declare function peekIpcDiscoveryCache(key: string): IpcDirs | undefined;
+/**
+ * Canonical SSH + resolved IPC namespace. Listing caches should hash this
+ * (or `ipcState.tmp` / `socketDir` after a refreshed read) so a warmed
+ * socket context matches across `createSshExec` instances.
+ */
+export declare function sshIpcContextKey(target: SshTarget, env?: NodeJS.ProcessEnv, ipc?: {
+    tmp?: string;
+    socketDir?: string;
+} | null): string;
+/** Test helper: shrink the positive-hit map so eviction is observable. */
+export declare function setIpcDiscoveryCacheLimit(limit: number): void;
+export declare function ipcDiscoveryCacheSize(): number;
 /**
  * Run the remote zellij over ssh. The whole invocation is quoted into a single
  * command string, because the remote login shell re-parses it.
  */
-export declare function createSshExec(target: SshTarget, env: NodeJS.ProcessEnv): ExecFn;
+export declare function createSshExec(target: SshTarget, env: NodeJS.ProcessEnv, options?: {
+    pinIpc?: boolean;
+}): SshExecFn;
 export declare function createExec(binPath: string, env: NodeJS.ProcessEnv): ExecFn;

package/dist/exec.js

@@ -35,21 +35,118 @@ export function buildSshRemoteCommand(target, args, tmp, timeoutMs, socketDir) {
     }
     return withTmp;
 }
-async function discoverRemoteIpc(runner, target, timeoutMs) {
+/** Positive `auto` IPC hits only; failures/cancels never enter this map. */
+export const DEFAULT_IPC_DISCOVERY_TTL_MS = 15_000;
+export const DEFAULT_IPC_DISCOVERY_CACHE_LIMIT = 512;
+const ipcDiscoveryCache = new Map();
+let ipcDiscoveryTtlMs = DEFAULT_IPC_DISCOVERY_TTL_MS;
+let ipcDiscoveryCacheLimit = DEFAULT_IPC_DISCOVERY_CACHE_LIMIT;
+const IPC_USER_ENV = [
+    "USER",
+    "USERNAME",
+    "LOGNAME",
+    "HOME",
+    "USERPROFILE",
+    "USERDOMAIN",
+    "SSH_AUTH_SOCK",
+    "PATH",
+    "Path",
+    "XDG_CONFIG_HOME",
+];
+/** Fully scoped key so hosts / SSH bins / remote shells / users never collide. */
+export function ipcDiscoveryCacheKey(target, env = {}) {
+    const requested = target.tmp?.trim() ?? "";
+    const user = IPC_USER_ENV.map((name) => env[name] ?? "");
+    return JSON.stringify([
+        target.ssh,
+        target.host,
+        target.options,
+        target.remoteBin,
+        target.remoteShell ?? "",
+        target.mode ?? "ssh",
+        requested.toLowerCase() === "auto" ? "auto" : requested,
+        user,
+    ]);
+}
+/**
+ * Probe list for `ZSWARM_TMP=auto`. Known Windows (cmd / interactive / .exe)
+ * skips the Unix `ps` fallback; explicit `sh` skips PowerShell. Unknown
+ * `zellij` still tries both — a Windows host with remoteBin=zellij looks Unix.
+ */
+export function ipcDiscoveryProbes(target) {
     const shell = inferRemoteShell({
         explicit: target.remoteShell,
         remoteBin: target.remoteBin,
         mode: target.mode,
     });
-    // `auto` has no tmp yet, so a Windows host with remoteBin=zellij still looks
-    // like Unix. Try both listings; pickIpcDirs ignores lines without --server.
-    const probes = shell === "cmd"
-        ? [windowsDiscoverRemote(), unixDiscoverRemote()]
-        : [unixDiscoverRemote(), windowsDiscoverRemote()];
+    const windows = windowsDiscoverRemote();
+    const unix = unixDiscoverRemote();
+    if (shell === "cmd")
+        return [windows];
+    if (target.remoteShell === "sh")
+        return [unix];
+    return [unix, windows];
+}
+export function resetIpcDiscoveryCache() {
+    ipcDiscoveryCache.clear();
+    ipcDiscoveryTtlMs = DEFAULT_IPC_DISCOVERY_TTL_MS;
+    ipcDiscoveryCacheLimit = DEFAULT_IPC_DISCOVERY_CACHE_LIMIT;
+}
+/** Test helper: shrink the positive-hit TTL without exposing the map. */
+export function setIpcDiscoveryTtlMs(ttlMs) {
+    ipcDiscoveryTtlMs = Math.max(0, ttlMs);
+}
+export function peekIpcDiscoveryCache(key) {
+    const entry = ipcDiscoveryCache.get(key);
+    if (!entry)
+        return undefined;
+    if (entry.expiresAt <= Date.now()) {
+        ipcDiscoveryCache.delete(key);
+        return undefined;
+    }
+    return { tmp: entry.dirs.tmp, socketDir: entry.dirs.socketDir };
+}
+/**
+ * Canonical SSH + resolved IPC namespace. Listing caches should hash this
+ * (or `ipcState.tmp` / `socketDir` after a refreshed read) so a warmed
+ * socket context matches across `createSshExec` instances.
+ */
+export function sshIpcContextKey(target, env = {}, ipc) {
+    return JSON.stringify([ipcDiscoveryCacheKey(target, env), ipc?.tmp ?? "", ipc?.socketDir ?? ""]);
+}
+/** Test helper: shrink the positive-hit map so eviction is observable. */
+export function setIpcDiscoveryCacheLimit(limit) {
+    ipcDiscoveryCacheLimit = Math.max(1, limit);
+}
+export function ipcDiscoveryCacheSize() {
+    return ipcDiscoveryCache.size;
+}
+function storeIpcDiscovery(key, dirs) {
+    ipcDiscoveryCache.delete(key);
+    ipcDiscoveryCache.set(key, {
+        dirs: { ...dirs },
+        expiresAt: Date.now() + ipcDiscoveryTtlMs,
+    });
+    while (ipcDiscoveryCache.size > ipcDiscoveryCacheLimit) {
+        ipcDiscoveryCache.delete(ipcDiscoveryCache.keys().next().value);
+    }
+}
+async function discoverRemoteIpc(runner, target, remaining, signal) {
+    const probes = ipcDiscoveryProbes(target);
     for (const probe of probes) {
+        if (signal?.aborted)
+            return undefined;
+        const left = remaining();
+        if (left <= 0)
+            return undefined;
         const result = await runner([...target.options, target.host, probe], {
-            timeoutMs,
+            timeoutMs: left,
+            signal,
         });
+        if (result.code !== 0)
+            continue;
+        if (remaining() <= 0)
+            return undefined;
         const dirs = pickIpcDirs(parseZellijServerPaths(result.stdout));
         if (dirs)
             return dirs;
@@ -60,28 +157,160 @@ async function discoverRemoteIpc(runner, target, timeoutMs) {
  * Run the remote zellij over ssh. The whole invocation is quoted into a single
  * command string, because the remote login shell re-parses it.
  */
-export function createSshExec(target, env) {
+export function createSshExec(target, env, options = {}) {
     const runner = createExec(target.ssh, env);
-    let cached;
-    async function resolveIpc(timeoutMs) {
+    const cacheKey = ipcDiscoveryCacheKey(target, env);
+    let autoFailed = false;
+    let pinnedIpc;
+    const ipcState = {
+        requested: null,
+        status: "none",
+    };
+    function adopt(dirs) {
+        if (options.pinIpc) {
+            pinnedIpc ??= { ...dirs };
+            dirs = pinnedIpc;
+        }
+        autoFailed = false;
+        ipcState.status = "resolved";
+        ipcState.tmp = dirs.tmp;
+        ipcState.socketDir = dirs.socketDir;
+        return { ...dirs };
+    }
+    /** Seed from a positive hit; unpinned execs drop resolved dirs after TTL. */
+    function refreshIpcView() {
+        const requested = target.tmp?.trim() || null;
+        ipcState.requested = requested;
+        if (!requested) {
+            ipcState.status = "none";
+            delete ipcState.tmp;
+            delete ipcState.socketDir;
+            return ipcState;
+        }
+        if (requested.toLowerCase() !== "auto") {
+            ipcState.status = "skipped";
+            ipcState.tmp = requested;
+            ipcState.socketDir = "";
+            return ipcState;
+        }
+        // A high-level client pins its namespace so pane lookup and the following
+        // write cannot switch sockets when another caller refreshes discovery.
+        if (pinnedIpc)
+            return ipcState;
+        // Diagnostics describe this exec's last attempt, not a sibling's later
+        // success. A subsequent actual invocation may adopt a positive cache hit.
+        if (autoFailed)
+            return ipcState;
+        const cached = peekIpcDiscoveryCache(cacheKey);
+        if (cached) {
+            adopt(cached);
+            return ipcState;
+        }
+        if (ipcState.status === "resolved") {
+            ipcState.status = "none";
+            delete ipcState.tmp;
+            delete ipcState.socketDir;
+        }
+        return ipcState;
+    }
+    refreshIpcView();
+    async function resolveIpc(remaining, signal) {
         const requested = target.tmp?.trim();
-        if (!requested)
+        if (!requested) {
+            ipcState.requested = null;
+            ipcState.status = "none";
             return undefined;
+        }
+        ipcState.requested = requested;
         if (requested.toLowerCase() !== "auto") {
+            ipcState.status = "skipped";
+            ipcState.tmp = requested;
+            ipcState.socketDir = "";
             return { tmp: requested, socketDir: "" };
         }
+        if (pinnedIpc)
+            return adopt(pinnedIpc);
+        const cached = peekIpcDiscoveryCache(cacheKey);
         if (cached)
-            return cached;
-        const dirs = await discoverRemoteIpc(runner, target, timeoutMs);
-        if (dirs)
-            cached = dirs;
-        return dirs;
+            return adopt(cached);
+        // Do not re-probe after a failed/expired/cancelled attempt on this exec.
+        // A later createSshExec with the same key still probes — failures are not
+        // stored, and in-flight work is never shared across callers' budgets.
+        if (autoFailed)
+            return undefined;
+        if (signal?.aborted) {
+            autoFailed = true;
+            ipcState.status = "cancelled";
+            return undefined;
+        }
+        if (remaining() <= 0) {
+            autoFailed = true;
+            ipcState.status = "expired";
+            return undefined;
+        }
+        const dirs = await discoverRemoteIpc(runner, target, remaining, signal);
+        // Another probe on this client may have pinned a namespace while we were
+        // waiting. Its first positive result wins, even if this probe failed.
+        if (pinnedIpc)
+            return adopt(pinnedIpc);
+        if (signal?.aborted) {
+            autoFailed = true;
+            ipcState.status = "cancelled";
+            return undefined;
+        }
+        if (dirs) {
+            if (remaining() <= 0) {
+                autoFailed = true;
+                ipcState.status = "expired";
+                return undefined;
+            }
+            storeIpcDiscovery(cacheKey, dirs);
+            return adopt(dirs);
+        }
+        autoFailed = true;
+        ipcState.status = remaining() <= 0 ? "expired" : "failed";
+        return undefined;
     }
-    return async (args, options) => {
-        const ipc = await resolveIpc(options.timeoutMs);
-        const remote = buildSshRemoteCommand(target, args, ipc?.tmp, options.timeoutMs, ipc?.socketDir);
-        return runner([...target.options, target.host, remote], options);
+    const exec = (async (args, options) => {
+        const deadline = Date.now() + options.timeoutMs;
+        const remaining = () => Math.max(0, deadline - Date.now());
+        const ipc = await resolveIpc(remaining, options.signal);
+        if (options.signal?.aborted) {
+            return {
+                code: -1,
+                stdout: "",
+                stderr: `${target.ssh} cancelled`,
+            };
+        }
+        const left = remaining();
+        // Do not launch the target command after the caller's budget is gone —
+        // especially after two discovery probes ate the whole timeout.
+        if (left <= 0) {
+            return {
+                code: -1,
+                stdout: "",
+                stderr: `${target.ssh} timed out after ${options.timeoutMs}ms`,
+            };
+        }
+        // auto discovery failed: still run, but callers read ipcState for reachability.
+        const remote = buildSshRemoteCommand(target, args, ipc?.tmp, left, ipc?.socketDir);
+        return runner([...target.options, target.host, remote], {
+            ...options,
+            timeoutMs: left,
+        });
+    });
+    Object.defineProperty(exec, "ipcState", {
+        enumerable: true,
+        configurable: true,
+        get() {
+            return { ...refreshIpcView() };
+        },
+    });
+    exec.prepareIpc = (timeoutMs, signal) => {
+        const deadline = Date.now() + timeoutMs;
+        return resolveIpc(() => Math.max(0, deadline - Date.now()), signal);
     };
+    return exec;
 }
 /** Read stdout until the answer is in hand, then stop caring about the child. */
 function runUntil(binPath, args, env, options) {

package/dist/harness.js

@@ -29,15 +29,20 @@ const GENERIC_WAITING = [
     /press enter to continue/i,
 ];
 /**
- * Per-harness approval UI observed in this live session. Only gemini and
- * opencode showed full-screen prompts worth naming; codex, cursor, and pi
- * show only the generic shapes so far, and unknown panes get the generic set
- * and nothing else. Mislabelling a working pane as waiting makes a dispatcher
- * type into it, so unobserved prompts stay undetected.
+ * Named approval questions complement structural menu detection in status.
+ * Keep patterns anchored: quoting a prompt in ordinary output is not a menu.
  */
 const WAITING = {
-    codex: GENERIC_WAITING,
-    cursor: GENERIC_WAITING,
+    codex: [
+        ...GENERIC_WAITING,
+        /^(?:[›❯>]\s*)?Would you like to run the following command\?/i,
+        /^(?:[›❯>]\s*)?Do you want to (?:run|allow|approve) (?:this|the) (?:command|operation|action)\?/i,
+    ],
+    cursor: [
+        ...GENERIC_WAITING,
+        /^(?:[›❯>]\s*)?(?:Run this command|Allow this command|Do you want to run this command)\?/i,
+        /^(?:[›❯>]\s*)?(?:Allow|Approve) (?:this|the) (?:tool|command|operation)(?: call)?\?/i,
+    ],
     opencode: [...GENERIC_WAITING, /Permission required/i, /Allow once/i],
     gemini: [
         ...GENERIC_WAITING,

package/dist/index.d.ts

@@ -1,25 +1,27 @@
 export { ZellijError } from "./errors.js";
+export { ListingCache } from "./zellij/cache.js";
 export { createExec, NOT_FOUND_EXIT, type ExecFn, type ExecOptions, type ExecResult, } from "./exec.js";
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, type GitClient, type GitClientOptions, type Worktree, } from "./git.js";
-export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, type ZellijExecFn, type ZellijExecResult, } from "./zellij/binary.js";
+export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, 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 { liveSessionNames, parseSessionList, resolveSelfPaneId, type ZellijSession, type ZellijSessionResolve, } from "./zellij/session.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 { createZellijClient, type ZellijClient, type ZellijClientOptions, type ZellijTransport, } from "./zellij/client.js";
 export { createStateStore, defaultStateDir, type LogEntry, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
-export { dispatchZswarm } from "./ops/dispatch.js";
+export { dispatchZswarm, resolveInvocationEnv } from "./ops/dispatch.js";
 export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, type Policy, } from "./policy.js";
-export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, type SshTarget, } from "./exec.js";
+export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, type IpcDiscoveryState, type SshExecFn, 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, 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";
-export { classify, lastLine, type PeerState } from "./ops/status.js";
+export { classify, lastLine, mapPool, peerStatus, DEFAULT_STATUS_TIMEOUT_MS, STATUS_DUMP_CONCURRENCY, type PeerState, } from "./ops/status.js";
 export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
+export type { RoutingContext } from "./ops/routing.js";
 export type { DispatchDeps, OpsResult } from "./ops/types.js";
 export { normalizeKey, normalizeKeys, tokenizeCommand } from "./keys.js";
 export { cliUsage, mcpInputSchema, parseCliArgv, MCP_TOOL_DESCRIPTION, OP_NAMES, PARAMS, TARGET_OPS, type OpName, type ParamSpec, type ParamType, } from "./schema.js";

package/dist/index.js

@@ -1,15 +1,16 @@
 export { ZellijError } from "./errors.js";
+export { ListingCache } from "./zellij/cache.js";
 export { createExec, NOT_FOUND_EXIT, } from "./exec.js";
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, } from "./git.js";
-export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, } from "./zellij/binary.js";
+export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
-export { parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
+export { liveSessionNames, parseSessionList, resolveSelfPaneId, } from "./zellij/session.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";
+export { dispatchZswarm, resolveInvocationEnv } from "./ops/dispatch.js";
 export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./policy.js";
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";
@@ -18,7 +19,7 @@ export { callServe, DEFAULT_SERVE_LISTEN, installServeLogon, isLoopbackHost, par
 export { parseTabList, resolveTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";
-export { classify, lastLine } from "./ops/status.js";
+export { classify, lastLine, mapPool, peerStatus, DEFAULT_STATUS_TIMEOUT_MS, STATUS_DUMP_CONCURRENCY, } from "./ops/status.js";
 export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
 export { normalizeKey, normalizeKeys, tokenizeCommand } from "./keys.js";
 export { cliUsage, mcpInputSchema, parseCliArgv, MCP_TOOL_DESCRIPTION, OP_NAMES, PARAMS, TARGET_OPS, } from "./schema.js";

package/dist/ops/broadcast.js

@@ -70,7 +70,7 @@ export async function broadcast(client, state, args, clock, policy, env = proces
     if (!body.trim())
         throw new ZellijError("missing_body", "body required");
     const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
-    const panes = await client.listPanes(session);
+    const panes = await client.listPanes(session, undefined, { fresh: true });
     const labeled = withSenderLabel(args, {
         env,
         selfTitle: selfPaneTitle(client, panes),

package/dist/ops/bus.d.ts

@@ -26,7 +26,10 @@ export declare function planBus(client: ZellijClient, state: StateStore, env?: N
  * --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<{
+export declare function busSnapshot(client: ZellijClient, state: StateStore, session: string, clock: Clock, env?: NodeJS.ProcessEnv, payload?: string, opts?: {
+    deadlineAt?: number;
+    signal?: AbortSignal;
+}): Promise<{
     snapshot: BusSnapshot;
     configKey: string;
 } | null>;
@@ -41,7 +44,7 @@ export declare function busSnapshot(client: ZellijClient, state: StateStore, ses
  * `dump-screen` returns them ragged. `normalizeScreen` erases exactly that
  * difference, and every caller here already normalizes before comparing.
  */
-export declare function busScreens(client: ZellijClient, state: StateStore, session: string, paneIds: string[], clock: Clock, env?: NodeJS.ProcessEnv): Promise<Map<string, string> | null>;
+export declare function busScreens(client: ZellijClient, state: StateStore, session: string, paneIds: string[], clock: Clock, env?: NodeJS.ProcessEnv, timeoutMs?: number): Promise<Map<string, string> | null>;
 /**
  * Hand the whole wait to the plugin, which holds the pipe until it resolves.
  * One process covers a minute-long wait instead of one per poll, and the plugin
@@ -56,7 +59,7 @@ export declare function busWait(client: ZellijClient, state: StateStore, session
  * `status` answers by sampling twice, without the gap between samples — but
  * 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>;
+export declare function busChanged(client: ZellijClient, state: StateStore, session: string, paneIds: string[], env?: NodeJS.ProcessEnv, timeoutMs?: number): 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. */