@zswarm/core 0.1.6 → 0.1.7

package/dist/ops/panes.js

@@ -16,7 +16,7 @@ export async function renameTarget(client, args, policy) {
     const sess = await session(client, args);
     const tabKey = optionalString(args.tab);
     if (tabKey) {
-        const tab = client.resolveTab(await client.listTabs(sess), tabKey);
+        const tab = client.resolveTab(await client.listTabs(sess, undefined, { fresh: true }), tabKey);
         const renamed = await client.renameTab({
             session: sess,
             tabId: tab.id,
@@ -30,7 +30,7 @@ export async function renameTarget(client, args, policy) {
     const to = optionalString(args.to);
     if (!to)
         throw new ZellijError("missing_peer", "to (or tab) required");
-    const pane = client.resolvePane(await client.listPanes(sess), to);
+    const pane = client.resolvePane(await client.listPanes(sess, undefined, { fresh: true }), to);
     if (policy)
         assertPaneAllowed(policy, pane, "rename");
     await client.renamePane({ session: sess, paneId: pane.id, name });
@@ -44,7 +44,7 @@ export async function focusTarget(client, args, policy) {
     if (!to)
         throw new ZellijError("missing_peer", "to required");
     const sess = await session(client, args);
-    const pane = client.resolvePane(await client.listPanes(sess), to);
+    const pane = client.resolvePane(await client.listPanes(sess, undefined, { fresh: true }), to);
     if (policy)
         assertPaneAllowed(policy, pane, "focus");
     // Zellij exits non-zero when asked to focus the already-focused pane.
@@ -104,7 +104,7 @@ export async function stackTargets(client, args, policy) {
     if (!list)
         throw new ZellijError("missing_peer", "to (comma list) required");
     const sess = await session(client, args);
-    const panes = await client.listPanes(sess);
+    const panes = await client.listPanes(sess, undefined, { fresh: true });
     const ids = list
         .split(",")
         .map((k) => k.trim())

package/dist/ops/routing.js

@@ -13,7 +13,7 @@ export function invocationContext(args, env, injected) {
         session: selected?.session ?? null,
         origin: {
             transport: injected ? "injected" : isTrue(args.local) ? "--local"
-                : optionalString(args.ssh) ? "--ssh" : serve ? "ZSWARM_SERVE"
+                : optionalString(args.ssh) ? "--ssh" : optionalString(args.serveAddress) ? "--serve" : serve ? "ZSWARM_SERVE"
                     : ssh ? "ZSWARM_SSH" : "default",
             session: selected?.source ?? "unresolved",
         },

package/dist/ops/spawn.js

@@ -27,7 +27,7 @@ export async function spawnPane(client, args, git, clock = { now: Date.now, slee
         : null;
     const cwd = worktree ? worktree.path : optionalString(args.cwd);
     const name = optionalString(args.name) ?? worktree?.branch ?? null;
-    const beforePanes = await client.listPanes(session, budget.require());
+    const beforePanes = await client.listPanes(session, budget.require(), { fresh: true });
     const before = new Set(beforePanes.map((p) => p.id));
     let paneId = null;
     let tabId = null;
@@ -49,7 +49,7 @@ export async function spawnPane(client, args, git, clock = { now: Date.now, slee
             tabId = args.tabId;
         }
         else if (tabName) {
-            tabId = client.resolveTab(await client.listTabs(session, budget.require()), tabName).id;
+            tabId = client.resolveTab(await client.listTabs(session, budget.require(), { fresh: true }), tabName).id;
         }
         else {
             // Address a tab explicitly even when no viewer is attached.
@@ -58,7 +58,7 @@ export async function spawnPane(client, args, git, clock = { now: Date.now, slee
             tabId = focused?.tabId ?? first?.tabId ?? null;
             tabSource = focused ? "focused-pane" : "first-tab";
             if (tabId === null) {
-                const tabs = await client.listTabs(session, budget.require());
+                const tabs = await client.listTabs(session, budget.require(), { fresh: true });
                 tabId = [...tabs].sort((a, b) => a.position - b.position)[0]?.id ?? null;
             }
             if (tabId === null)
@@ -83,7 +83,7 @@ export async function spawnPane(client, args, git, clock = { now: Date.now, slee
             firstRead = false;
             try {
                 const left = observeMs === 0 ? budget.require() : Math.min(budget.require(), Math.max(1, observedUntil - clock.now()));
-                const panes = await client.listPanes(session, left);
+                const panes = await client.listPanes(session, left, { fresh: true });
                 throwIfAborted(signal);
                 if (paneId) {
                     pane = panes.find((p) => p.id === paneId && !p.isPlugin) ?? null;

package/dist/ops/status.js

@@ -163,9 +163,20 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
     }
     const sampleMs = Math.max(50, requested);
     const live = targets.filter((pane) => !pane.exited);
-    if (isTrue(args.sinceLast) && supplied?.readChanged) {
+    // Explicit sampling retains its interval semantics. Ordinary status prefers
+    // one bus observation, including a single-pane crew, with no sample sleep.
+    const preferChanges = isTrue(args.sinceLast) || (args.sinceLast === undefined && args.sampleMs === undefined);
+    if (preferChanges && supplied?.readChanged) {
         const left = remaining();
-        const changed = left > 0 ? await supplied.readChanged(live.map((p) => p.id), left) : null;
+        let changed = null;
+        try {
+            changed = live.length === 0 ? new Map() : left > 0 ? await supplied.readChanged(live.map((p) => p.id), left) : null;
+        }
+        catch (err) {
+            if (isCancelledError(err) || signal?.aborted)
+                throw new ZellijError("cancelled", "operation cancelled");
+            // A missing/older bus falls back to bounded screen samples below.
+        }
         throwIfAborted(signal);
         if (changed) {
             const peers = targets
@@ -174,13 +185,9 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
                     return peerEntry(pane, "exited", "", verbose);
                 }
                 const row = changed.get(pane.id);
-                const state = !row
-                    ? "unknown"
-                    : row.changed
-                        ? "busy"
-                        : promptHolds(row?.screen ?? "", resolveHarness(pane))
-                            ? "waiting"
-                            : "idle";
+                const state = !row ? "unknown"
+                    : promptHolds(row.screen, resolveHarness(pane)) ? "waiting"
+                        : row.first ? "unknown" : row.changed ? "busy" : "idle";
                 return peerEntry(pane, state, row?.screen ?? "", verbose, {
                     ...(row?.first ? { first: true } : {}),
                 });
@@ -193,6 +200,7 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
                     source,
                     sampled: false,
                     sinceLast: true,
+                    observation: "bus-changes",
                     peers,
                     tabs: statusTabs(peers),
                     free: peers.filter((p) => p.state === "idle").map((p) => p.id),
@@ -321,6 +329,7 @@ export async function peerStatus(client, args, clock, supplied, opts = {}) {
         session,
         source,
         sampled: true,
+        observation: "samples",
         sampleMs,
         peers,
         tabs: statusTabs(peers),

package/dist/ops/worktree.js

@@ -62,7 +62,7 @@ export async function listPeerWorktrees(git, client, args) {
     let panes = [];
     try {
         const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
-        panes = await client.listPanes(session);
+        panes = await client.listPanes(session, undefined, { fresh: true });
     }
     catch {
         // Worktrees are useful to list even with no live Zellij session.
@@ -118,7 +118,7 @@ export async function removePeerWorktree(git, client, args, env = process.env) {
     let occupants = [];
     try {
         const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
-        occupants = panesIn(await client.listPanes(session), target.path);
+        occupants = panesIn(await client.listPanes(session, undefined, { fresh: true }), target.path);
     }
     catch (err) {
         // No live session means nobody is working in it. Any other failure must

package/dist/schema.js

@@ -129,13 +129,25 @@ export const PARAMS = [
         name: "sampleMs",
         type: "number",
         flags: ["--sample-ms"],
-        description: "status: gap between the two screen samples (default 400); 0 skips sampling and reports running/exited only",
+        description: "status: explicitly sample twice with this gap (fallback default 400); 0 reports running/exited only; default prefers bus changes",
     },
     {
         name: "sinceLast",
         type: "boolean",
         flags: ["--since-last"],
-        description: "status: classify by what changed since the last status call instead of sampling twice; needs the event bus, no sample gap",
+        description: "status: classify changes since the previous bus observation (default when bus available); first observation is unknown unless a prompt is recognized",
+    },
+    {
+        name: "fresh",
+        type: "boolean",
+        flags: ["--fresh"],
+        description: "bypass the short-lived session/pane/tab listing cache for this call",
+    },
+    {
+        name: "serveAddress",
+        type: "string",
+        flags: ["--serve"],
+        description: "use an existing serve endpoint (e.g. 127.0.0.1:9419 through an SSH tunnel); preferred for frequent status calls; uses ZSWARM_SERVE_TOKEN",
     },
     {
         name: "limit",
@@ -483,7 +495,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 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", "");
+    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, ZSWARM_CACHE_TTL_MS", "");
     return lines.join("\n");
 }
 /** Turn argv (without the op) into dispatch args, driven by PARAMS. */

package/dist/zellij/binary.d.ts

@@ -30,14 +30,27 @@ export declare function identityCacheKey(zellijPath: string, ssh?: {
     options: string[];
     mode?: string;
     remoteBin?: string;
+    /** SSH client binary (`SshTarget.ssh`). */
+    ssh?: string;
+    sshBin?: string;
+    remoteShell?: string;
 } | null): string;
 /**
  * Confirm the resolved binary is Zellij. Only verified identities are cached.
  * Transport timeouts leave the cache empty so a later call can retry.
  * Returns false when verification is unresolved; only true is cached.
+ * In-flight probes are never shared — each caller supplies its own timeout.
  */
-export declare function ensureZellijIdentity(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string): Promise<boolean>;
-export declare function ensureZellijCapabilities(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string): Promise<boolean>;
+export declare function ensureZellijIdentity(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function ensureZellijCapabilities(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Identity and capability are independent reads. Run them together under one
+ * remaining budget; do not share in-flight work with another caller.
+ */
+export declare function ensureZellijProbes(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<{
+    identity: boolean;
+    capabilities: boolean;
+}>;
 /** Test helper: drop cached identity/capability probes. */
 export declare function resetZellijIdentityCache(): void;
 export declare function resolveZellijBinary(env?: NodeJS.ProcessEnv): string;

package/dist/zellij/binary.js

@@ -98,26 +98,32 @@ export function isZellijVersionOutput(stdout, stderr = "") {
  */
 export function identityCacheKey(zellijPath, ssh) {
     if (!ssh)
-        return zellijPath;
-    return [
+        return JSON.stringify([zellijPath]);
+    return JSON.stringify([
         zellijPath,
         ssh.host,
         ssh.remoteBin ?? "",
         ssh.mode ?? "ssh",
-        ssh.options.join("\0"),
-    ].join("|");
+        ssh.options,
+        ssh.sshBin ?? ssh.ssh ?? "",
+        ssh.remoteShell ?? "",
+    ]);
 }
 /**
  * Confirm the resolved binary is Zellij. Only verified identities are cached.
  * Transport timeouts leave the cache empty so a later call can retry.
  * Returns false when verification is unresolved; only true is cached.
+ * In-flight probes are never shared — each caller supplies its own timeout.
  */
-export async function ensureZellijIdentity(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath) {
+export async function ensureZellijIdentity(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
     if (identityCache.has(cacheKey))
         return true;
+    if (signal?.aborted)
+        return false;
     assertZellijBinaryPath(zellijPath);
     const result = await exec(["--version"], {
         timeoutMs: Math.min(timeoutMs, 5_000),
+        signal,
     });
     const text = `${result.stdout}\n${result.stderr}`;
     if (/usage:\s*zswarm/i.test(text) || /unknown arg:/i.test(text)) {
@@ -127,6 +133,8 @@ export async function ensureZellijIdentity(exec, zellijPath, timeoutMs = 3_000,
         throw new ZellijError("zellij_missing", `zellij binary not found (${zellijPath}); install Zellij ≥ 0.42, add it to PATH, or set ZSWARM_BIN / ZSWARM_PATH`);
     }
     if (result.code === 0) {
+        if (signal?.aborted)
+            return false;
         if (isZellijVersionOutput(result.stdout, result.stderr)) {
             identityCache.add(cacheKey);
             return true;
@@ -142,11 +150,14 @@ export async function ensureZellijIdentity(exec, zellijPath, timeoutMs = 3_000,
  * Returns false when the transport cannot verify support.
  */
 const capabilityCache = new Set();
-export async function ensureZellijCapabilities(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath) {
+export async function ensureZellijCapabilities(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
     if (capabilityCache.has(cacheKey))
         return true;
+    if (signal?.aborted)
+        return false;
     const result = await exec(["list-sessions", "--help"], {
         timeoutMs: Math.min(timeoutMs, 5_000),
+        signal,
     });
     const text = `${result.stdout}\n${result.stderr}`;
     if (/usage:\s*zswarm/i.test(text)) {
@@ -159,6 +170,8 @@ export async function ensureZellijCapabilities(exec, zellijPath, timeoutMs = 3_0
     if (result.code === 0 &&
         /--no-formatting/i.test(text) &&
         /list-sessions/i.test(text)) {
+        if (signal?.aborted)
+            return false;
         capabilityCache.add(cacheKey);
         return true;
     }
@@ -168,6 +181,25 @@ export async function ensureZellijCapabilities(exec, zellijPath, timeoutMs = 3_0
     // Soft: leave unresolved on transport failure.
     return false;
 }
+/**
+ * Identity and capability are independent reads. Run them together under one
+ * remaining budget; do not share in-flight work with another caller.
+ */
+export async function ensureZellijProbes(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
+    if (signal?.aborted)
+        return { identity: false, capabilities: false };
+    const probeTimeout = Math.min(timeoutMs, 5_000);
+    // Settle both so a wrong-bin throw does not leave the other SSH probe running.
+    const settled = await Promise.allSettled([
+        ensureZellijIdentity(exec, zellijPath, probeTimeout, cacheKey, signal),
+        ensureZellijCapabilities(exec, zellijPath, probeTimeout, cacheKey, signal),
+    ]);
+    if (settled[0].status === "rejected")
+        throw settled[0].reason;
+    if (settled[1].status === "rejected")
+        throw settled[1].reason;
+    return { identity: settled[0].value, capabilities: settled[1].value };
+}
 /** Test helper: drop cached identity/capability probes. */
 export function resetZellijIdentityCache() {
     identityCache.clear();

package/dist/zellij/bus.js

@@ -74,7 +74,7 @@ export function parseChangedReply(stdout) {
             if (!row || typeof row !== "object")
                 continue;
             const p = row;
-            if (typeof p.id !== "string")
+            if (typeof p.id !== "string" || typeof p.changed !== "boolean" || typeof p.first !== "boolean" || !Array.isArray(p.viewport))
                 continue;
             panes.push({
                 id: p.id,

package/dist/zellij/cache.d.ts

@@ -0,0 +1,24 @@
+/** Short-lived, completed observations only. Never shares a caller's promise or budget. */
+export declare class ListingCache {
+    private readonly limit;
+    private entries;
+    private scopes;
+    constructor(limit?: number);
+    begin(scope: string): {
+        state: {
+            version: number;
+            revision?: string;
+        };
+        version: number;
+    };
+    get<T>(key: string, now: number): T | undefined;
+    put<T>(key: string, scope: string, ticket: ReturnType<ListingCache["begin"]>, value: T, ttl: number, now: number): void;
+    invalidate(scope: string): void;
+    observe(scope: string, revision: string): boolean;
+    clear(): void;
+}
+export declare const sharedListings: ListingCache;
+export declare function executorIdentity(exec?: object): number | null;
+/** Environment fields that select local sockets or an SSH identity/config. */
+export declare function routingEnvironment(env: NodeJS.ProcessEnv): Record<string, string | null>;
+export declare function listingTtl(env: NodeJS.ProcessEnv): number;

package/dist/zellij/cache.js

@@ -0,0 +1,90 @@
+/** Short-lived, completed observations only. Never shares a caller's promise or budget. */
+export class ListingCache {
+    limit;
+    entries = new Map();
+    scopes = new Map();
+    constructor(limit = 512) {
+        this.limit = limit;
+    }
+    begin(scope) {
+        let state = this.scopes.get(scope);
+        if (!state) {
+            state = { version: 0 };
+            this.scopes.set(scope, state);
+            if (this.scopes.size > this.limit) {
+                const oldest = this.scopes.keys().next().value;
+                this.scopes.delete(oldest);
+                for (const [key, entry] of this.entries)
+                    if (entry.scope === oldest)
+                        this.entries.delete(key);
+            }
+        }
+        return { state, version: state.version };
+    }
+    get(key, now) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (now >= entry.expiresAt) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return structuredClone(entry.value);
+    }
+    put(key, scope, ticket, value, ttl, now) {
+        // A mutation/event during this read must not resurrect an older manifest.
+        if (ttl <= 0 || this.scopes.get(scope) !== ticket.state || ticket.state.version !== ticket.version)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, { scope, value: structuredClone(value), expiresAt: now + ttl });
+        while (this.entries.size > this.limit)
+            this.entries.delete(this.entries.keys().next().value);
+    }
+    invalidate(scope) {
+        this.begin(scope).state.version++;
+        for (const [key, entry] of this.entries)
+            if (entry.scope === scope)
+                this.entries.delete(key);
+    }
+    observe(scope, revision) {
+        const { state } = this.begin(scope);
+        if (state.revision === revision)
+            return false;
+        this.invalidate(scope);
+        state.revision = revision;
+        return true;
+    }
+    clear() {
+        this.entries.clear();
+        this.scopes.clear();
+    }
+}
+export const sharedListings = new ListingCache();
+const executors = new WeakMap();
+let nextExecutor = 0;
+export function executorIdentity(exec) {
+    if (!exec)
+        return null;
+    let id = executors.get(exec);
+    if (id === undefined) {
+        id = ++nextExecutor;
+        executors.set(exec, id);
+    }
+    return id;
+}
+/** Environment fields that select local sockets or an SSH identity/config. */
+export function routingEnvironment(env) {
+    return Object.fromEntries([
+        "ZSWARM_TMP", "ZELLIJ_SOCKET_DIR", "TMPDIR", "TEMP", "TMP", "XDG_RUNTIME_DIR",
+        "HOME", "USERPROFILE", "USER", "USERNAME", "LOGNAME", "USERDOMAIN", "SSH_AUTH_SOCK",
+        "PATH", "Path", "PATHEXT", "XDG_CONFIG_HOME", "ZELLIJ_CONFIG_DIR",
+        "ZELLIJ_SESSION_NAME", "ZSWARM_SESSION",
+    ].map((key) => [key, env[key] ?? null]));
+}
+export function listingTtl(env) {
+    const value = env.ZSWARM_CACHE_TTL_MS;
+    if (value === undefined || value.trim() === "")
+        return 500;
+    const ttl = Number(value);
+    return Number.isFinite(ttl) ? Math.max(0, Math.min(5000, ttl)) : 500;
+}

package/dist/zellij/client.d.ts

@@ -1,3 +1,4 @@
+import { ListingCache } from "./cache.js";
 import { buildClosePaneArgs, buildDumpArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, type WaitRequest, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PipeInput } from "./args.js";
 import { resolveTab, type ZellijTab } from "./tabs.js";
 import { type IpcDiscoveryState } from "../exec.js";
@@ -12,6 +13,10 @@ export type ZellijClientOptions = {
     signal?: AbortSignal;
     /** Skip the one-time `zellij --version` identity probe (tests). */
     skipIdentityProbe?: boolean;
+    /** Completed listing cache shared by long-lived MCP/serve calls; false bypasses reads. */
+    cache?: ListingCache | false;
+    /** Clock for cache TTLs; process deadlines continue using wall time. */
+    now?: () => number;
 };
 export type ZellijTransport = {
     kind: "local" | "ssh";
@@ -23,16 +28,23 @@ export type ZellijTransport = {
     /** Outcome of `ZSWARM_TMP=auto` discovery when SSH routing is active. */
     ipc?: IpcDiscoveryState;
 };
-/** Thin, stateless wrapper over the `zellij` binary. */
+/** Zellij wrapper with bounded caches of completed discovery observations. */
 export declare function createZellijClient(options?: ZellijClientOptions): {
     zellijPath: string;
     selfPaneId: string | null;
+    contextKey: () => string;
+    invalidateListings: (session: string) => void;
+    observeManifest: (session: string, revision: string) => void;
     readonly transport: ZellijTransport;
     /** A `file:` plugin url only names a path on the machine running Zellij. */
     remote: boolean;
-    listSessions: (callTimeoutMs?: number) => Promise<ZellijSession[]>;
+    listSessions: (callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijSession[]>;
     resolveSession: (explicit?: string | null, callTimeoutMs?: number) => Promise<ZellijSessionResolve>;
-    listPanes: (session: string, callTimeoutMs?: number) => Promise<ZellijPane[]>;
+    listPanes: (session: string, callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijPane[]>;
     resolvePane: typeof resolvePane;
     injectPane: (input: {
         session: string;
@@ -112,7 +124,9 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         paneId: string;
         session: string;
     }>;
-    listTabs: (session: string, callTimeoutMs?: number) => Promise<ZellijTab[]>;
+    listTabs: (session: string, callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijTab[]>;
     dumpLayout: (session: string) => Promise<string>;
     stackPanes: (input: {
         session: string;