@zswarm/core 0.1.0

package/dist/ops/panes.js

@@ -0,0 +1,111 @@
+import { ZellijError } from "../errors.js";
+import { dumpMaxChars, optionalString, truncateDumpText } from "./util.js";
+async function session(client, args) {
+    const resolved = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
+    return resolved.session;
+}
+/**
+ * Give a pane (or its tab) a stable name, so peers can be addressed as
+ * `reviewer` instead of whatever id Zellij handed out.
+ */
+export async function renameTarget(client, args) {
+    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), tabKey);
+        const renamed = await client.renameTab({
+            session: sess,
+            tabId: tab.id,
+            name,
+        });
+        return {
+            ok: true,
+            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), to);
+    await client.renamePane({ session: sess, paneId: pane.id, name });
+    return {
+        ok: true,
+        data: { session: sess, to: pane.id, was: pane.title, name },
+    };
+}
+export async function focusTarget(client, args) {
+    const to = optionalString(args.to);
+    if (!to)
+        throw new ZellijError("missing_peer", "to required");
+    const sess = await session(client, args);
+    const pane = client.resolvePane(await client.listPanes(sess), to);
+    // Zellij exits non-zero when asked to focus the already-focused pane.
+    if (pane.focused) {
+        return {
+            ok: true,
+            data: {
+                session: sess,
+                focused: pane.id,
+                title: pane.title,
+                already: true,
+            },
+        };
+    }
+    const focused = await client.focusPane({ session: sess, paneId: pane.id });
+    return {
+        ok: true,
+        data: { session: sess, focused: focused.paneId, title: pane.title },
+    };
+}
+export async function listTabsOp(client, args) {
+    const sess = await session(client, args);
+    const tabs = await client.listTabs(sess);
+    return {
+        ok: true,
+        data: {
+            session: sess,
+            tabs: tabs.map((t) => ({
+                id: t.id,
+                name: t.name,
+                panes: t.panes,
+                active: t.active,
+                layout: t.layout,
+            })),
+        },
+    };
+}
+/** The session's current layout as KDL — a spawnable description of the crew. */
+export async function dumpLayoutOp(client, args) {
+    const sess = await session(client, args);
+    const layout = await client.dumpLayout(sess);
+    const max = dumpMaxChars(args);
+    const clipped = truncateDumpText(layout, max, "head");
+    return {
+        ok: true,
+        data: {
+            session: sess,
+            layout: clipped.text,
+            truncated: clipped.truncated,
+            chars: clipped.chars,
+        },
+    };
+}
+/** Collapse several peers into one stack so a big crew stays readable. */
+export async function stackTargets(client, args) {
+    const list = optionalString(args.to);
+    if (!list)
+        throw new ZellijError("missing_peer", "to (comma list) required");
+    const sess = await session(client, args);
+    const panes = await client.listPanes(sess);
+    const ids = list
+        .split(",")
+        .map((k) => k.trim())
+        .filter(Boolean)
+        .map((key) => client.resolvePane(panes, key).id);
+    const unique = [...new Set(ids)];
+    const stacked = await client.stackPanes({ session: sess, paneIds: unique });
+    return { ok: true, data: { session: sess, stacked: stacked.paneIds } };
+}

package/dist/ops/review.d.ts

@@ -0,0 +1,9 @@
+import { type GitClient } from "../git.js";
+import type { Clock, OpsResult } from "./types.js";
+/** Show what a peer worktree changed vs HEAD (untracked included). */
+export declare function peerDiff(git: GitClient, args: Record<string, unknown>): Promise<OpsResult>;
+/**
+ * Commit all changes in a peer worktree so the pane can close and resume.
+ * A clean tree is success with committed:false, nothingToCommit:true.
+ */
+export declare function peerCheckpoint(git: GitClient, args: Record<string, unknown>, clock: Clock): Promise<OpsResult>;

package/dist/ops/review.js

@@ -0,0 +1,108 @@
+import { ZellijError } from "../errors.js";
+import { normalizeRepoPath, } from "../git.js";
+import { dumpMaxChars, isTrue, optionalString } from "./util.js";
+function findByPath(trees, path) {
+    const wanted = normalizeRepoPath(path);
+    return trees.find((t) => normalizeRepoPath(t.path) === wanted) ?? null;
+}
+function findByBranch(trees, branch) {
+    const matches = trees.filter((t) => t.branch === branch);
+    if (matches.length === 0) {
+        throw new ZellijError("worktree_not_found", `no worktree for ${branch}`);
+    }
+    if (matches.length > 1) {
+        throw new ZellijError("worktree_ambiguous", `multiple worktrees on branch ${branch}; pass path=`);
+    }
+    return matches[0];
+}
+/**
+ * Resolve the peer working directory: args.path, else the worktree on
+ * args.branch, else args.cwd, else process.cwd().
+ */
+async function resolvePeerDir(git, args) {
+    const pathArg = optionalString(args.path);
+    const branchArg = optionalString(args.branch);
+    const cwd = optionalString(args.cwd) ?? process.cwd();
+    if (pathArg) {
+        const root = await git.repoRoot(pathArg);
+        const match = findByPath(await git.listWorktrees(root), pathArg);
+        return { path: match?.path ?? pathArg, branch: match?.branch ?? null };
+    }
+    if (branchArg) {
+        const root = await git.repoRoot(cwd);
+        const match = findByBranch(await git.listWorktrees(root), branchArg);
+        return { path: match.path, branch: match.branch };
+    }
+    const root = await git.repoRoot(cwd);
+    const match = findByPath(await git.listWorktrees(root), cwd);
+    return { path: match?.path ?? cwd, branch: match?.branch ?? null };
+}
+/** Show what a peer worktree changed vs HEAD (untracked included). */
+export async function peerDiff(git, args) {
+    const { path, branch } = await resolvePeerDir(git, args);
+    const max = dumpMaxChars(args);
+    const statOnly = isTrue(args.stat);
+    const stat = await git.diffStat(path);
+    if (statOnly) {
+        return {
+            ok: true,
+            data: {
+                path,
+                branch,
+                stat,
+                patch: "",
+                truncated: false,
+                chars: 0,
+            },
+        };
+    }
+    const { patch, truncated, chars } = await git.diffPatch(path, max);
+    return {
+        ok: true,
+        data: { path, branch, stat, patch, truncated, chars },
+    };
+}
+/**
+ * Commit all changes in a peer worktree so the pane can close and resume.
+ * A clean tree is success with committed:false, nothingToCommit:true.
+ */
+export async function peerCheckpoint(git, args, clock) {
+    const { path, branch } = await resolvePeerDir(git, args);
+    const message = optionalString(args.message) ??
+        `zswarm checkpoint ${new Date(clock.now()).toISOString()}`;
+    if (!(await git.isDirty(path))) {
+        const sha = await git.headSha(path);
+        return {
+            ok: true,
+            data: {
+                path,
+                branch,
+                sha,
+                committed: false,
+                nothingToCommit: true,
+            },
+        };
+    }
+    let sha;
+    try {
+        sha = await git.commitAll(path, message);
+    }
+    catch (err) {
+        // git's own message here is long and buried; name the actual fix.
+        const text = err instanceof Error ? err.message : String(err);
+        if (/Author identity unknown|unable to auto-detect email/i.test(text)) {
+            throw new ZellijError("git_identity", "git has no author identity on this machine; set user.name and user.email (git config --global), or export GIT_AUTHOR_NAME/GIT_AUTHOR_EMAIL and GIT_COMMITTER_NAME/GIT_COMMITTER_EMAIL before checkpointing");
+        }
+        throw err;
+    }
+    return {
+        ok: true,
+        data: {
+            path,
+            branch,
+            sha,
+            committed: true,
+            nothingToCommit: false,
+        },
+    };
+}

package/dist/ops/signals.d.ts

@@ -0,0 +1,10 @@
+import type { StateStore } from "../state.js";
+import type { Clock, OpsResult } from "./types.js";
+/**
+ * Post to a channel. Counts are cumulative and survive across processes, so a
+ * 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;
+/** 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

@@ -0,0 +1,86 @@
+import { ZellijError } from "../errors.js";
+import { isTrue, numberArg, optionalString } from "./util.js";
+const AWAIT_LIMITS = {
+    pollMs: { min: 100, max: 30_000 },
+    timeoutMs: { min: 1_000, max: 900_000 },
+    count: { min: 1, max: 1_000 },
+};
+function channelOf(args) {
+    const channel = optionalString(args.channel);
+    if (!channel)
+        throw new ZellijError("missing_channel", "channel required");
+    return channel;
+}
+/**
+ * Post to a channel. Counts are cumulative and survive across processes, so a
+ * crew can rendezvous without any of them staying resident.
+ */
+export function postSignal(state, args, clock) {
+    if (isTrue(args.clear)) {
+        const channel = optionalString(args.channel);
+        state.clearSignal(channel);
+        return { ok: true, data: { cleared: channel ?? "all" } };
+    }
+    const channel = channelOf(args);
+    const posted = state.postSignal(channel, optionalString(args.payload), clock.now());
+    return {
+        ok: true,
+        data: { channel, count: posted.count, at: posted.at, payload: posted.last },
+    };
+}
+export function listSignals(state) {
+    const all = state.readSignals();
+    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)),
+        },
+    };
+}
+/** Block until a channel reaches `count` posts, or the deadline passes. */
+export async function awaitSignal(state, args, clock) {
+    const channel = channelOf(args);
+    const count = numberArg(args, "count", 1, AWAIT_LIMITS.count);
+    const pollMs = numberArg(args, "pollMs", 500, AWAIT_LIMITS.pollMs);
+    const timeoutMs = numberArg(args, "timeoutMs", 60_000, AWAIT_LIMITS.timeoutMs);
+    const started = clock.now();
+    for (;;) {
+        const current = state.readSignals()[channel];
+        const have = current?.count ?? 0;
+        const at = clock.now();
+        if (have >= count) {
+            return {
+                ok: true,
+                data: {
+                    channel,
+                    reason: "signalled",
+                    count: have,
+                    wanted: count,
+                    waitedMs: at - started,
+                    last: current?.last ?? null,
+                },
+            };
+        }
+        if (at - started >= timeoutMs) {
+            return {
+                ok: true,
+                data: {
+                    channel,
+                    reason: "timeout",
+                    count: have,
+                    wanted: count,
+                    waitedMs: at - started,
+                    last: current?.last ?? null,
+                },
+            };
+        }
+        await clock.sleep(pollMs);
+    }
+}

package/dist/ops/spawn.d.ts

@@ -0,0 +1,5 @@
+import { type GitClient } from "../git.js";
+import type { ZellijClient } from "../zellij/client.js";
+import type { OpsResult } from "./types.js";
+/** Open a new pane (or tab) and report which pane it became. */
+export declare function spawnPane(client: ZellijClient, args: Record<string, unknown>, git?: GitClient): Promise<OpsResult>;

package/dist/ops/spawn.js

@@ -0,0 +1,98 @@
+import { ZellijError } from "../errors.js";
+import { createGitClient } from "../git.js";
+import { tokenizeCommand } from "../keys.js";
+import { isTrue, isVerbose, optionalString, paneViewFull } from "./util.js";
+import { ensurePeerWorktree } from "./worktree.js";
+function paneDirection(value) {
+    const dir = optionalString(value);
+    if (!dir)
+        return null;
+    const lowered = dir.toLowerCase();
+    if (!["right", "left", "up", "down"].includes(lowered)) {
+        throw new ZellijError("bad_arg", "direction must be right|left|up|down");
+    }
+    return lowered;
+}
+/** Open a new pane (or tab) and report which pane it became. */
+export async function spawnPane(client, args, git) {
+    const { session } = await client.resolveSession(typeof args.session === "string" ? args.session : undefined);
+    const command = tokenizeCommand(args.command ?? args.cmd);
+    // A worktree peer works on its own branch, in its own directory.
+    const worktree = optionalString(args.worktree)
+        ? await ensurePeerWorktree(git ?? createGitClient(), args)
+        : null;
+    const cwd = worktree ? worktree.path : optionalString(args.cwd);
+    const name = optionalString(args.name) ?? worktree?.branch ?? null;
+    const closeOnExit = isTrue(args.closeOnExit);
+    const before = new Set((await client.listPanes(session)).map((p) => p.id));
+    let paneId = null;
+    let tabId = null;
+    if (isTrue(args.newTab) || args.tab === true) {
+        const created = await client.newTab({
+            session,
+            command,
+            cwd,
+            name,
+            layout: optionalString(args.layout),
+            closeOnExit,
+        });
+        tabId = created.tabId;
+    }
+    else {
+        const input = {
+            session,
+            command,
+            cwd,
+            name,
+            direction: paneDirection(args.direction),
+            floating: isTrue(args.floating),
+            closeOnExit,
+            width: optionalString(args.width),
+            height: optionalString(args.height),
+        };
+        if (typeof args.tabId === "number")
+            input.tabId = args.tabId;
+        // `tab` as a name places the pane in that tab; ids come via tabId.
+        const tabName = optionalString(args.tab);
+        if (input.tabId === undefined && tabName) {
+            input.tabId = client.resolveTab(await client.listTabs(session), tabName).id;
+        }
+        paneId = (await client.newPane(input)).paneId;
+    }
+    // new-tab reports a tab id, and a command that exits at once can vanish, so
+    // fall back to diffing the pane list against the pre-spawn snapshot.
+    const panes = await client.listPanes(session);
+    let resolvedBy = paneId
+        ? "stdout"
+        : "unresolved";
+    let pane = paneId ? (panes.find((p) => p.id === paneId) ?? null) : null;
+    if (!paneId) {
+        const fresh = panes.filter((p) => !p.isPlugin && !before.has(p.id));
+        const inTab = tabId === null ? fresh : fresh.filter((p) => p.tabId === tabId);
+        const candidates = inTab.length > 0 ? inTab : fresh;
+        if (candidates.length === 1) {
+            pane = candidates[0];
+            paneId = pane.id;
+            resolvedBy = "diff";
+        }
+    }
+    const data = {
+        session,
+        paneId,
+        resolvedBy,
+        live: pane !== null,
+        command: command.length > 0 ? command : null,
+    };
+    if (worktree) {
+        data.worktree = {
+            path: worktree.path,
+            branch: worktree.branch,
+            created: worktree.created,
+        };
+    }
+    if (tabId !== null)
+        data.tabId = tabId;
+    if (pane && isVerbose(args))
+        data.pane = paneViewFull(pane);
+    return { ok: true, data };
+}

package/dist/ops/status.d.ts

@@ -0,0 +1,36 @@
+import { type HarnessProfile } from "../harness.js";
+import type { ZellijClient } from "../zellij/client.js";
+import type { ZellijPane } from "../zellij/panes.js";
+import type { Clock, OpsResult } from "./types.js";
+/** `running` only appears when sampling is off — busy and idle are indistinguishable then. */
+export type PeerState = "busy" | "waiting" | "idle" | "exited" | "running";
+/** Pane list already in hand, so status does not re-fetch what the caller has. */
+export type StatusSource = {
+    session: string;
+    panes: ZellijPane[];
+    source: "plugin" | "zellij";
+    /**
+     * Batched screen reader. Returns null when it cannot serve the whole set, and
+     * status falls back to one `dump-screen` per pane.
+     */
+    readScreens?: (paneIds: string[]) => Promise<Map<string, string> | null>;
+    /** "Has this moved since you last asked?", answered without a sample gap. */
+    readChanged?: (paneIds: string[]) => Promise<Map<string, {
+        changed: boolean;
+        first: boolean;
+        screen: string;
+    }> | null>;
+};
+export declare function lastLine(screen: string): string;
+export declare function classify(input: {
+    exited: boolean;
+    before: string;
+    after: string;
+    /** The pane's harness; its waiting patterns name the prompts worth blocking on. */
+    profile?: HarnessProfile | null;
+}): PeerState;
+/**
+ * Sample every pane twice and say who is working, who is stuck on a prompt,
+ * and who is free — the routing question `list` cannot answer.
+ */
+export declare function peerStatus(client: ZellijClient, args: Record<string, unknown>, clock: Clock, supplied?: StatusSource | null): Promise<OpsResult>;

package/dist/ops/status.js

@@ -0,0 +1,192 @@
+import { resolveHarness } from "../harness.js";
+import { isTrue, normalizeScreen, numberArg, optionalString } from "./util.js";
+/**
+ * Legacy last-line prompt shapes for callers without a profile. A term counts
+ * only when it is a question, not chrome: a y/n form, a trailing `?`, or the
+ * canonical "press enter to continue" pause. A bare "confirm" or "continue"
+ * sits in status bars ("select  enter confirm") and must not qualify.
+ */
+const QUESTION = /(\(y\/n\)|\[y\/n\]|\(yes\/no\)|\[y\/n\/a\]|password:|passphrase:|(?:continue|proceed|overwrite|confirm)\?|press\s+enter\s+to\s+continue)/i;
+/**
+ * How many trailing non-empty lines `status` inspects for a named prompt. A
+ * full-screen TUI hides its prompt under chrome, so the last line alone is
+ * the wrong place to look — measured live, gemini's question sat 4 lines
+ * above "esc to cancel", and a six-option permission menu with wrapped
+ * lines put it 12 lines up. 24 clears the measured 12 with headroom for
+ * wider menus. Widening is safe for the named patterns because they are
+ * specific strings; the legacy last-line QUESTION fallback stays exactly
+ * where it is or it would fire on chrome.
+ */
+const PROMPT_WINDOW = 24;
+export function lastLine(screen) {
+    const lines = screen.split("\n").filter((l) => l.trim());
+    return lines.length > 0 ? lines[lines.length - 1].trim() : "";
+}
+function trailingLines(screen, n) {
+    return screen
+        .replace(/\r/g, "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-n);
+}
+/**
+ * True when the trailing window holds a named approval prompt. The profile's
+ * waiting patterns run across the window; the legacy last-line QUESTION check
+ * stays as the conservative fallback for callers without a profile. Bias is
+ * toward false negatives: a hit must be prompt UI we can name, never a bare
+ * question mark or "confirm".
+ */
+function promptHolds(screen, profile) {
+    const lines = trailingLines(screen, PROMPT_WINDOW);
+    const patterns = profile?.waiting;
+    if (patterns && patterns.length > 0) {
+        for (const line of lines) {
+            for (const re of patterns) {
+                if (re.test(line))
+                    return true;
+            }
+        }
+    }
+    return QUESTION.test(lines[lines.length - 1] ?? "");
+}
+export function classify(input) {
+    if (input.exited)
+        return "exited";
+    if (input.before !== input.after)
+        return "busy";
+    return promptHolds(input.after, input.profile) ? "waiting" : "idle";
+}
+/**
+ * Sample every pane twice and say who is working, who is stuck on a prompt,
+ * and who is free — the routing question `list` cannot answer.
+ */
+export async function peerStatus(client, args, clock, supplied) {
+    const session = supplied?.session ??
+        (await client.resolveSession(typeof args.session === "string" ? args.session : undefined)).session;
+    const panes = supplied?.panes ?? (await client.listPanes(session));
+    const source = supplied?.source ?? "zellij";
+    const only = optionalString(args.to);
+    const targets = only
+        ? [client.resolvePane(panes, only)]
+        : panes.filter((p) => !p.isPlugin);
+    // sampleMs=0 asks for the cheap answer: who is alive, from state the plugin
+    // already holds. Below that, two samples too close together read as idle.
+    const requested = numberArg(args, "sampleMs", 400, { min: 0, max: 10_000 });
+    if (requested === 0) {
+        const peers = targets
+            .map((pane) => {
+            const entry = {
+                id: pane.id,
+                title: pane.title,
+                state: pane.exited ? "exited" : "running",
+            };
+            if (isTrue(args.verbose)) {
+                entry.command = pane.command ?? null;
+                entry.cwd = pane.cwd ?? null;
+                entry.tab = pane.tabName ?? null;
+            }
+            return entry;
+        })
+            .sort((a, b) => String(a.id).localeCompare(String(b.id)));
+        // No `free`: without sampling there is no way to tell busy from idle.
+        return {
+            ok: true,
+            data: { session, source, sampled: false, sampleMs: 0, peers },
+        };
+    }
+    const sampleMs = Math.max(50, requested);
+    const live = targets.filter((pane) => !pane.exited).map((pane) => pane.id);
+    // sinceLast trades the fixed 400ms window for "moved since your last call".
+    // The plugin remembers the previous screen, so there is no gap to wait out —
+    // but ask twice in quick succession and everything reads idle.
+    if (isTrue(args.sinceLast) && supplied?.readChanged) {
+        const changed = await supplied.readChanged(live);
+        if (changed) {
+            const peers = targets
+                .map((pane) => {
+                const row = changed.get(pane.id);
+                const state = pane.exited
+                    ? "exited"
+                    : row?.changed
+                        ? "busy"
+                        : promptHolds(row?.screen ?? "", resolveHarness(pane))
+                            ? "waiting"
+                            : "idle";
+                const entry = {
+                    id: pane.id,
+                    title: pane.title,
+                    state,
+                    lastLine: lastLine(row?.screen ?? "").slice(0, 160),
+                };
+                // First sight has nothing to compare against, so idle is a guess.
+                if (row?.first)
+                    entry.first = true;
+                return entry;
+            })
+                .sort((a, b) => String(a.id).localeCompare(String(b.id)));
+            return {
+                ok: true,
+                data: {
+                    session,
+                    source,
+                    sampled: false,
+                    sinceLast: true,
+                    peers,
+                    free: peers.filter((p) => p.state === "idle").map((p) => p.id),
+                },
+            };
+        }
+    }
+    /**
+     * One batched read when the bus can serve it, otherwise a process per pane.
+     * Both paths normalize, which is what makes them comparable: the plugin pads
+     * lines to the terminal width and `dump-screen` does not.
+     */
+    const sample = async () => {
+        const batched = supplied?.readScreens
+            ? await supplied.readScreens(live)
+            : null;
+        if (batched) {
+            return new Map([...batched].map(([id, text]) => [id, normalizeScreen(text)]));
+        }
+        const screens = new Map();
+        for (const id of live) {
+            const dumped = await client.dumpPane({ session, paneId: id });
+            screens.set(id, normalizeScreen(dumped.text));
+        }
+        return screens;
+    };
+    const before = await sample();
+    await clock.sleep(sampleMs);
+    const afterScreens = await sample();
+    const peers = [];
+    for (const pane of targets) {
+        const first = before.get(pane.id) ?? "";
+        const after = pane.exited ? first : (afterScreens.get(pane.id) ?? "");
+        const state = classify({
+            exited: pane.exited,
+            before: first,
+            after,
+            profile: resolveHarness(pane),
+        });
+        const entry = {
+            id: pane.id,
+            title: pane.title,
+            state,
+            lastLine: lastLine(after).slice(0, 160),
+        };
+        if (isTrue(args.verbose)) {
+            entry.command = pane.command ?? null;
+            entry.cwd = pane.cwd ?? null;
+            entry.tab = pane.tabName ?? null;
+        }
+        peers.push(entry);
+    }
+    peers.sort((a, b) => String(a.id).localeCompare(String(b.id)));
+    const free = peers.filter((p) => p.state === "idle").map((p) => p.id);
+    return {
+        ok: true,
+        data: { session, source, sampled: true, sampleMs, peers, free },
+    };
+}

package/dist/ops/tail.d.ts

@@ -0,0 +1,19 @@
+import type { StateStore } from "../state.js";
+import type { ZellijClient } from "../zellij/client.js";
+import type { ZellijPane } from "../zellij/panes.js";
+import type { OpsResult } from "./types.js";
+/**
+ * What is new in `cur` given the previously seen screen. The viewport scrolls,
+ * so the old bottom shows up as the new top: find the longest suffix of the
+ * previous screen that still heads the current one, and return the rest.
+ */
+export declare function diffScreens(prev: string | null, cur: string): {
+    text: string;
+    reset: boolean;
+};
+export declare function cursorKey(session: string, paneId: string): string;
+/** Read only what a pane printed since the last tail. */
+export declare function tailPane(client: ZellijClient, state: StateStore, args: Record<string, unknown>, target: {
+    session: string;
+    pane: ZellijPane;
+}): Promise<OpsResult>;