@zswarm/core 0.4.2 → 0.6.0

package/dist/index.d.ts

@@ -5,11 +5,12 @@ export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeL
 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 { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, resolveSelfSession, 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 { assignServersToSessions, findAncestorServer, liveServers, matchServerToSession, paneMatchesId, parseServerArgs, readProcessTable, type ProcInfo, type ProcessRunner, type ReadProcessTableOptions, type ServerInfo, type SessionPanes, } from "./zellij/server-identity.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildRenameSessionArgs, 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, type ZellijTransport, } from "./zellij/client.js";
-export { createStateStore, defaultStateDir, type LeaseRecord, type LogEntry, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
+export { createZellijClient, resetSelfResolutionCache, type ZellijClient, type ZellijClientOptions, type ZellijTransport, } from "./zellij/client.js";
+export { createStateStore, defaultStateDir, type LeaseRecord, type LogEntry, type SessionAliasEntry, type SessionAliasMap, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
 export { findLease, leaseKey, leaseStale, listLeases, releaseLease, releaseLeaseKey, takeLease, type LeaseTakeInput, type LeaseTakeResult, type LeaseTarget, } from "./host/lease.js";
 export { dispatchZswarm, resolveInvocationEnv } from "./ops/dispatch.js";
 export { EXIT_WAIT_MS, HANDOFF_INLINE_MAX, HANDOFF_MARKER, HANDOFF_SELF_WAIT_MS, READY_SETTLE_MS, READY_STABLE_GAP_MS, READY_WAIT_MS, restartLaunchCommand, restartPane, restartPaneKind, type RestartPaneKind, type RestartStep, } from "./ops/restart.js";

package/dist/index.js

@@ -5,10 +5,11 @@ export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeL
 export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
 export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, resolveSelfSession, } from "./zellij/session.js";
-export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, } from "./zellij/args.js";
+export { assignServersToSessions, findAncestorServer, liveServers, matchServerToSession, paneMatchesId, parseServerArgs, readProcessTable, } from "./zellij/server-identity.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildRenameSessionArgs, 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 { createZellijClient, resetSelfResolutionCache, } from "./zellij/client.js";
 export { createStateStore, defaultStateDir, } from "./state.js";
 export { findLease, leaseKey, leaseStale, listLeases, releaseLease, releaseLeaseKey, takeLease, } from "./host/lease.js";
 export { dispatchZswarm, resolveInvocationEnv } from "./ops/dispatch.js";

package/dist/ops/delivery.d.ts

@@ -26,8 +26,12 @@ export type SenderOrigin = {
  * splittable), and the result is capped at 64 chars.
  */
 export declare function sanitizeOriginPart(raw: unknown): string | null;
-/** The origin of the caller's own process, read from its environment. */
-export declare function resolveSenderOrigin(env: NodeJS.ProcessEnv): SenderOrigin;
+/**
+ * The origin of the caller's own process, read from its environment.
+ * `session` overrides the env name when the caller has resolved the live
+ * session through the process table (a renamed session leaves the env stale).
+ */
+export declare function resolveSenderOrigin(env: NodeJS.ProcessEnv, session?: string | null): SenderOrigin;
 /**
  * The origin carried by a serve request. Only the serve worker trusts it: a
  * local caller cannot claim another pane. Missing/garbage input (an older

package/dist/ops/delivery.js

@@ -20,8 +20,12 @@ export function sanitizeOriginPart(raw) {
         ? cleaned
         : cleaned.slice(0, ORIGIN_PART_MAX).replace(/_+$/, "");
 }
-/** The origin of the caller's own process, read from its environment. */
-export function resolveSenderOrigin(env) {
+/**
+ * The origin of the caller's own process, read from its environment.
+ * `session` overrides the env name when the caller has resolved the live
+ * session through the process table (a renamed session leaves the env stale).
+ */
+export function resolveSenderOrigin(env, session) {
     const configured = env.ZSWARM_HOST;
     const host = configured === undefined
         ? sanitizeOriginPart(hostname().split(".")[0])
@@ -30,7 +34,7 @@ export function resolveSenderOrigin(env) {
             : sanitizeOriginPart(configured);
     return {
         host,
-        session: sanitizeOriginPart(resolveSelfSession(env)),
+        session: sanitizeOriginPart(session ?? resolveSelfSession(env)),
         pane: sanitizeOriginPart(resolveSelfPaneId(env)),
         via: null,
     };

package/dist/ops/dispatch.js

@@ -216,6 +216,18 @@ async function unglueScreen(client, session, pane, text, full, fromBus) {
     }
     return unfoldScreen(ansi, columns) ?? text;
 }
+/**
+ * Ops whose sender header or self-pane guard needs the caller's live session.
+ * Read-only ops never pay for that resolution.
+ */
+const SELF_SESSION_OPS = new Set([
+    "send",
+    "broadcast",
+    "keys",
+    "interrupt",
+    "close",
+    "restart",
+]);
 async function dispatchOperation(args, injected, deps, context, env) {
     const op = String(args.op ?? "");
     const verbose = isVerbose(args);
@@ -322,10 +334,20 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 manager: deps.serveTunnels,
             });
         }
-        const baseClient = injected ?? createZellijClient({ env, signal, cache: isTrue(args.fresh) ? false : undefined });
+        const baseClient = injected ??
+            createZellijClient({
+                env,
+                signal,
+                cache: isTrue(args.fresh) ? false : undefined,
+                // Rename memory so stale env names keep working across runs.
+                aliases: state(),
+            });
         const client = {
             ...baseClient,
             get transport() { return baseClient.transport; },
+            // Pass the getter through: a spread would freeze the env value and the
+            // self-pane guard would compare a stale name.
+            get selfSession() { return baseClient.selfSession; },
             async resolveSession(...input) {
                 const resolved = await baseClient.resolveSession(...input);
                 context.session = resolved.session;
@@ -333,6 +355,15 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 return resolved;
             },
         };
+        // Only ops that build a sender header or compare against the caller's own
+        // pane need the resolved self session; read-only ops must not pay a
+        // Zellij round-trip for it.
+        if (deps.viaServe !== true && SELF_SESSION_OPS.has(op) && typeof client.resolveSelf === "function") {
+            // The pane's ZELLIJ_SESSION_NAME can be stale after a rename; the header
+            // must name the live session peers can reply to.
+            const self = await client.resolveSelf();
+            args = { ...args, origin: resolveSenderOrigin(env, self) };
+        }
         switch (op) {
             case "sessions": {
                 // Resolve SSH/IPC first so a Windows interactive crew is reachable
@@ -646,7 +677,7 @@ async function dispatchOperation(args, injected, deps, context, env) {
             case "signal":
                 return postSignal(state(), args, clock);
             case "signals":
-                return listSignals(state());
+                return listSignals(state(), args);
             case "await":
                 return await awaitSignal(state(), args, clock);
             case "log":

package/dist/ops/panes.d.ts

@@ -3,7 +3,8 @@ import type { ZellijClient } from "../zellij/client.js";
 import type { OpsResult } from "./types.js";
 /**
  * Give a pane (or its tab) a stable name, so peers can be addressed as
- * `reviewer` instead of whatever id Zellij handed out.
+ * `reviewer` instead of whatever id Zellij handed out. With `sessionName`
+ * (and no `to`/`tab`) it renames the session itself instead.
  */
 export declare function renameTarget(client: ZellijClient, args: Record<string, unknown>, policy?: Policy): Promise<OpsResult>;
 export declare function focusTarget(client: ZellijClient, args: Record<string, unknown>, policy?: Policy): Promise<OpsResult>;

package/dist/ops/panes.js

@@ -7,14 +7,27 @@ async function session(client, args) {
 }
 /**
  * Give a pane (or its tab) a stable name, so peers can be addressed as
- * `reviewer` instead of whatever id Zellij handed out.
+ * `reviewer` instead of whatever id Zellij handed out. With `sessionName`
+ * (and no `to`/`tab`) it renames the session itself instead.
  */
 export async function renameTarget(client, args, policy) {
+    const sessionName = optionalString(args.sessionName);
+    const tabKey = optionalString(args.tab);
+    const to = optionalString(args.to);
+    if (sessionName && !tabKey && !to) {
+        // Renaming the session itself: resolve the old name first so a stale
+        // ZELLIJ_SESSION_NAME or alias still names the live session.
+        const resolved = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
+        const renamed = await client.renameSession({
+            session: resolved.session,
+            name: sessionName,
+        });
+        return { ok: true, data: { session: renamed.session, was: renamed.was } };
+    }
     const name = optionalString(args.name);
     if (!name)
         throw new ZellijError("missing_name", "name required");
     const sess = await session(client, args);
-    const tabKey = optionalString(args.tab);
     if (tabKey) {
         const tab = client.resolveTab(await client.listTabs(sess, undefined, { fresh: true }), tabKey);
         const renamed = await client.renameTab({
@@ -27,7 +40,6 @@ export async function renameTarget(client, args, policy) {
             data: { session: sess, tab: renamed.tabId, was: tab.name, name },
         };
     }
-    const to = optionalString(args.to);
     if (!to)
         throw new ZellijError("missing_peer", "to (or tab) required");
     const pane = client.resolvePane(await client.listPanes(sess, undefined, { fresh: true }), to);

package/dist/ops/signals.d.ts

@@ -5,6 +5,6 @@ import type { Clock, OpsResult } from "./types.js";
  * crew can rendezvous without any of them staying resident.
  */
 export declare function postSignal(state: StateStore, args: Record<string, unknown>, clock: Clock): OpsResult;
-export declare function listSignals(state: StateStore): OpsResult;
+export declare function listSignals(state: StateStore, args?: Record<string, unknown>): OpsResult;
 /** Block until a channel reaches `count` posts, or the deadline passes. */
 export declare function awaitSignal(state: StateStore, args: Record<string, unknown>, clock: Clock): Promise<OpsResult>;

package/dist/ops/signals.js

@@ -28,20 +28,33 @@ export function postSignal(state, args, clock) {
         data: { channel, count: posted.count, at: posted.at, payload: posted.last },
     };
 }
-export function listSignals(state) {
+export function listSignals(state, args = {}) {
     const all = state.readSignals();
+    const total = Object.keys(all).length;
+    const channel = optionalString(args.channel);
+    const since = optionalString(args.since);
+    const sinceAt = since ? Number(since) : null;
+    const hasLimit = args.limit !== undefined && args.limit !== null && args.limit !== "";
+    let matched = Object.entries(all).map(([name, v]) => ({
+        channel: name,
+        count: v.count,
+        at: v.at,
+        last: v.last ?? null,
+    }));
+    if (channel)
+        matched = matched.filter((c) => c.channel.startsWith(channel));
+    if (sinceAt !== null && Number.isFinite(sinceAt)) {
+        matched = matched.filter((c) => c.at >= sinceAt);
+    }
+    const matchedCount = matched.length;
+    const channels = hasLimit
+        ? matched
+            .sort((a, b) => b.at - a.at)
+            .slice(0, numberArg(args, "limit", 1, { min: 1, max: 1_000 }))
+        : matched.sort((a, b) => a.channel.localeCompare(b.channel));
     return {
         ok: true,
-        data: {
-            channels: Object.entries(all)
-                .map(([channel, v]) => ({
-                channel,
-                count: v.count,
-                at: v.at,
-                last: v.last ?? null,
-            }))
-                .sort((a, b) => a.channel.localeCompare(b.channel)),
-        },
+        data: { total, matched: matchedCount, channels },
     };
 }
 /** Block until a channel reaches `count` posts, or the deadline passes. */

package/dist/schema.js

@@ -141,8 +141,8 @@ export const PARAMS = [
         name: "channel",
         type: "string",
         flags: ["--channel"],
-        ops: ["signal", "await"],
-        description: "signal/await: channel name",
+        ops: ["signal", "await", "signals"],
+        description: "signal/await: channel name; signals: only channels whose name starts with this",
     },
     {
         name: "payload",
@@ -216,15 +216,15 @@ export const PARAMS = [
         name: "limit",
         type: "number",
         flags: ["--limit"],
-        ops: ["log"],
-        description: "log: how many entries to return (default 20)",
+        ops: ["log", "signals"],
+        description: "log: how many entries to return (default 20); signals: the N most recently updated channels",
     },
     {
         name: "since",
         type: "string",
         flags: ["--since"],
-        ops: ["log"],
-        description: "log: only entries at or after this epoch millisecond",
+        ops: ["log", "signals"],
+        description: "log: only entries at or after this epoch millisecond; signals: only channels updated at or after this epoch millisecond",
     },
     {
         name: "failed",
@@ -446,6 +446,13 @@ export const PARAMS = [
         ops: ["spawn", "rename"],
         description: "spawn: pane (or tab) name; rename: the new name",
     },
+    {
+        name: "sessionName",
+        type: "string",
+        flags: ["--session-name"],
+        ops: ["rename"],
+        description: "rename: rename the session itself to this name; the old name stays an alias so panes that still carry it keep working",
+    },
     {
         name: "submit",
         type: "string",

package/dist/state.d.ts

@@ -55,6 +55,20 @@ export type LeaseRecord = {
     /** Relays that forced through while this lease was held. */
     sharedBy?: string[];
 };
+/**
+ * What an old session name now resolves to. Zellij never updates the
+ * ZELLIJ_SESSION_NAME a pane started with, so after a rename every older pane
+ * keeps the old name; this is how zswarm maps it to the live session. The
+ * server pid pins the entry to the process that owned the old name, so a
+ * later session reusing that name does not inherit the alias.
+ */
+export type SessionAliasEntry = {
+    current: string;
+    serverPid: number | null;
+    creation: string | null;
+    at: number;
+};
+export type SessionAliasMap = Record<string, SessionAliasEntry>;
 /** How much of the end of the log `readLog` reads; older entries are not shown. */
 export declare const LOG_TAIL_BYTES: number;
 /**
@@ -78,6 +92,8 @@ export declare function createStateStore(options?: StateStoreOptions): {
     readCursor: (key: string) => string | null;
     writeCursor: (key: string, text: string) => void;
     clearCursor: (key: string) => void;
+    readSessionAliases: () => SessionAliasMap;
+    recordSessionAlias: (oldName: string, entry: SessionAliasEntry) => void;
     readBus: (session: string) => BusMarkerRecord | null;
     writeBus: (session: string, marker: BusMarkerRecord) => void;
     clearBus: (session?: string) => void;

package/dist/state.js

@@ -9,6 +9,8 @@ const CURSORS_LOCK = "cursors.lock";
 const BUS_FILE = "bus.json";
 const LEASES_FILE = "leases.json";
 const LEASES_LOCK = "leases.lock";
+const SESSION_ALIASES_FILE = "session-aliases.json";
+const SESSION_ALIASES_LOCK = "session-aliases.lock";
 /** How much of the end of the log `readLog` reads; older entries are not shown. */
 export const LOG_TAIL_BYTES = 512 * 1024;
 /**
@@ -397,6 +399,52 @@ export function createStateStore(options = {}) {
             writeJson(CURSORS_FILE, all);
         });
     }
+    function asAliasEntry(value) {
+        if (!value || typeof value !== "object")
+            return null;
+        const rec = value;
+        if (typeof rec.current !== "string" || !rec.current)
+            return null;
+        return {
+            current: rec.current,
+            serverPid: typeof rec.serverPid === "number" &&
+                Number.isInteger(rec.serverPid) &&
+                rec.serverPid > 0
+                ? rec.serverPid
+                : null,
+            creation: typeof rec.creation === "string" && rec.creation ? rec.creation : null,
+            at: typeof rec.at === "number" ? rec.at : 0,
+        };
+    }
+    function readSessionAliases() {
+        const raw = readJson(SESSION_ALIASES_FILE, {});
+        const out = {};
+        for (const [name, entry] of Object.entries(raw)) {
+            const parsed = asAliasEntry(entry);
+            if (parsed)
+                out[name] = parsed;
+        }
+        return out;
+    }
+    /**
+     * Remember `oldName -> entry.current` and repoint every existing entry whose
+     * current name was the old one, so rename chains A -> B -> C leave both A
+     * and B resolving to C.
+     */
+    function recordSessionAlias(oldName, entry) {
+        const key = oldName.trim();
+        if (!key)
+            return;
+        withFileLock(SESSION_ALIASES_LOCK, () => {
+            const all = readSessionAliases();
+            for (const [name, previous] of Object.entries(all)) {
+                if (previous.current === key)
+                    all[name] = { ...previous, current: entry.current };
+            }
+            all[key] = entry;
+            writeJson(SESSION_ALIASES_FILE, all);
+        });
+    }
     function asMarker(value) {
         if (!value || typeof value !== "object")
             return null;
@@ -495,6 +543,8 @@ export function createStateStore(options = {}) {
         readCursor,
         writeCursor,
         clearCursor,
+        readSessionAliases,
+        recordSessionAlias,
         readBus,
         writeBus,
         clearBus,

package/dist/zellij/args.d.ts

@@ -88,6 +88,8 @@ export declare function buildSendKeysArgs(session: string, paneId: string, keys:
 export declare function buildWriteCharsArgs(session: string, paneId: string, chars: string): string[];
 export declare function buildRenamePaneArgs(session: string, paneId: string, name: string): string[];
 export declare function buildRenameTabArgs(session: string, tabId: number, name: string): string[];
+/** Rename the session itself: `zellij --session <old> action rename-session <new>`. */
+export declare function buildRenameSessionArgs(session: string, name: string): string[];
 export declare function buildFocusPaneArgs(session: string, paneId: string): string[];
 export declare function buildListTabsArgs(session: string): string[];
 export declare function buildDumpLayoutArgs(session: string): string[];

package/dist/zellij/args.js

@@ -183,6 +183,10 @@ export function buildRenameTabArgs(session, tabId, name) {
         name,
     ];
 }
+/** Rename the session itself: `zellij --session <old> action rename-session <new>`. */
+export function buildRenameSessionArgs(session, name) {
+    return [...sessionPrefix(session), "action", "rename-session", name];
+}
 export function buildFocusPaneArgs(session, paneId) {
     return [
         ...sessionPrefix(session),

package/dist/zellij/client.d.ts

@@ -1,11 +1,13 @@
 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 { buildClosePaneArgs, buildDumpArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildRenameSessionArgs, 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";
 import { type SenderOrigin } from "../ops/delivery.js";
 import { type ZellijExecFn } from "./binary.js";
 import { normalizePaneId, resolvePane, type ZellijPane } from "./panes.js";
+import { type ProcInfo } from "./server-identity.js";
 import { type ZellijSession, type ZellijSessionResolve } from "./session.js";
+import type { SessionAliasEntry, SessionAliasMap } from "../state.js";
 export type ZellijClientOptions = {
     exec?: ZellijExecFn;
     zellijPath?: string;
@@ -18,7 +20,18 @@ export type ZellijClientOptions = {
     cache?: ListingCache | false;
     /** Clock for cache TTLs; process deadlines continue using wall time. */
     now?: () => number;
+    /** Rename memory (StateStore); injected by dispatch, or by tests. */
+    aliases?: {
+        readSessionAliases(): SessionAliasMap;
+        recordSessionAlias(oldName: string, entry: SessionAliasEntry): void;
+    };
+    /** Process-table snapshot override (tests); defaults to a real read. */
+    processTable?: () => ProcInfo[] | Promise<ProcInfo[]>;
+    /** Platform override (tests); defaults to process.platform. */
+    platform?: NodeJS.Platform;
 };
+/** Test helper: forget every cached self resolution (and its process table). */
+export declare function resetSelfResolutionCache(): void;
 export type ZellijTransport = {
     kind: "local" | "ssh";
     mode: "local" | "ssh" | "interactive";
@@ -33,7 +46,12 @@ export type ZellijTransport = {
 export declare function createZellijClient(options?: ZellijClientOptions): {
     zellijPath: string;
     selfPaneId: string | null;
-    selfSession: string | null;
+    /**
+     * The caller's session: the resolved live name once resolveSelf (or a
+     * self resolveSession) has run, else the raw ZELLIJ_SESSION_NAME. A getter
+     * so a rename resolution is visible to the self-pane guard.
+     */
+    readonly selfSession: string | null;
     contextKey: () => string;
     invalidateListings: (session: string) => void;
     observeManifest: (session: string, revision: string) => void;
@@ -45,6 +63,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
     }) => Promise<ZellijSession[]>;
     deleteSession: (name: string, callTimeoutMs?: number) => Promise<void>;
     resolveSession: (explicit?: string | null, callTimeoutMs?: number) => Promise<ZellijSessionResolve>;
+    resolveSelf: () => Promise<string | null>;
     listPanes: (session: string, callTimeoutMs?: number, opts?: {
         fresh?: boolean;
     }) => Promise<ZellijPane[]>;
@@ -121,6 +140,14 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         session: string;
         name: string;
     }>;
+    renameSession: (input: {
+        session: string;
+        name: string;
+        callTimeoutMs?: number;
+    }) => Promise<{
+        session: string;
+        was: string;
+    }>;
     focusPane: (input: {
         session: string;
         paneId: string;
@@ -194,5 +221,6 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
     buildClosePaneArgs: typeof buildClosePaneArgs;
     buildNewPaneArgs: typeof buildNewPaneArgs;
     buildNewTabArgs: typeof buildNewTabArgs;
+    buildRenameSessionArgs: typeof buildRenameSessionArgs;
 };
 export type ZellijClient = ReturnType<typeof createZellijClient>;