@zswarm/core 0.2.2 → 0.2.4

package/dist/ops/dispatch.js

@@ -1,7 +1,10 @@
 import { ZellijError } from "../errors.js";
 import { createGitClient } from "../git.js";
+import { busyPrompt, resolveHarness } from "../harness.js";
+import { findLease } from "../host/lease.js";
 import { normalizeKeys } from "../keys.js";
 import { createZellijClient } from "../zellij/client.js";
+import { parseCreatedAge } from "../zellij/session.js";
 import { assertOpAllowed, assertPaneAllowed, loadPolicy, } from "../policy.js";
 import { createStateStore } from "../state.js";
 import { busToPanes } from "../zellij/bus.js";
@@ -9,7 +12,7 @@ import { broadcast } from "./broadcast.js";
 import { busChanged, busOp, busScreens, busSnapshot, busWait, planBus } from "./bus.js";
 import { dumpLayoutOp, focusTarget, listTabsOp, renameTarget, stackTargets, } from "./panes.js";
 import { peerCheckpoint, peerDiff } from "./review.js";
-import { attachKnownSender, deliverTo, withSenderLabel, selfPaneTitle } from "./delivery.js";
+import { attachKnownSender, deliverTo, scaleBudgets, withSenderLabel, selfPaneTitle } from "./delivery.js";
 import { assertNotPlugin, assertNotSelf, assertExpectedScreen, assertWritable, } from "./guards.js";
 import { readDeliveryLog } from "./log.js";
 import { awaitSignal, listSignals, postSignal } from "./signals.js";
@@ -19,7 +22,7 @@ import { invocationContext } from "./routing.js";
 import { DEFAULT_STATUS_TIMEOUT_MS, peerStatus, } from "./status.js";
 import { tailPane } from "./tail.js";
 import { OP_NAMES } from "../schema.js";
-import { dumpMaxChars, fail, isTrue, isVerbose, numberArg, optionalString, paneViewBus, paneViewFull, paneViewSlim, throwIfAborted, truncateDumpText, } from "./util.js";
+import { dumpMaxChars, fail, isTrue, isVerbose, numberArg, optionalString, paneViewBus, paneViewFull, paneViewSlim, throwIfAborted, truncateDumpText, unfoldScreen, } from "./util.js";
 import { waitForPane } from "./wait.js";
 import { listPeerWorktrees, removePeerWorktree } from "./worktree.js";
 import { DEFAULT_SERVE_INSTALL_TIMEOUT_MS, installServeLogon, uninstallServeLogon, } from "./serve-install.js";
@@ -100,18 +103,22 @@ async function resolveTarget(client, args, state, clock, env, policy, op, signal
     const to = String(args.to ?? "").trim();
     if (!to)
         throw new ZellijError("missing_peer", "to required");
-    const budget = observationBudget(clock, numberArg(args, "timeoutMs", 30_000, { min: 1, max: 900_000 }), signal);
+    const timeoutMs = numberArg(args, "timeoutMs", 30_000, { min: 1, max: 900_000 });
+    const budget = observationBudget(clock, timeoutMs, signal);
+    const explicitObserve = args.observeMs !== undefined && args.observeMs !== null && args.observeMs !== "";
     const observeMs = numberArg(args, "observeMs", 1_000, { min: 0, max: 30_000 });
     const { session } = await client.resolveSession(optionalString(args.session), budget.require());
     const bus = isVerbose(args) ? null : await busSnapshot(client, state, session, clock, env, "status", {
         deadlineAt: budget.deadline, signal,
     });
     let panes = null;
+    let fromBus = false;
     if (bus) {
         const snapshot = busToPanes(bus.snapshot);
         try {
             client.resolvePane(snapshot, to);
             panes = snapshot;
+            fromBus = true;
         }
         catch { /* An absent title/command/ID gets a fresh direct observation. */ }
     }
@@ -121,13 +128,25 @@ async function resolveTarget(client, args, state, clock, env, policy, op, signal
     let until = Number.POSITIVE_INFINITY;
     let pane;
     let fresh = isTrue(args.fresh) || Boolean(op);
+    let firstCallMs = 0;
+    let timed = false;
     for (;;) {
         const left = until === Number.POSITIVE_INFINITY || observeMs === 0
             ? budget.require()
             : Math.min(budget.require(), Math.max(1, until - clock.now()));
+        const listingStart = clock.now();
+        const wantedListing = panes === null;
         panes ??= await client.listPanes(session, left, { fresh });
-        if (until === Number.POSITIVE_INFINITY)
-            until = Math.min(budget.deadline, clock.now() + observeMs);
+        if (wantedListing && !timed) {
+            // The send's first Zellij call: a slow one scales the pane-observe and
+            // settle windows rather than making callers hand-tune --observe-ms.
+            firstCallMs = Math.max(0, clock.now() - listingStart);
+            timed = true;
+        }
+        if (until === Number.POSITIVE_INFINITY) {
+            const window = explicitObserve ? observeMs : scaleBudgets({ firstCallMs, timeoutMs }).observeMs;
+            until = Math.min(budget.deadline, clock.now() + window);
+        }
         throwIfAborted(signal);
         try {
             pane = client.resolvePane(panes, to);
@@ -145,7 +164,48 @@ async function resolveTarget(client, args, state, clock, env, policy, op, signal
     }
     if (policy && op)
         assertPaneAllowed(policy, pane, op);
-    return { session, panes, pane };
+    return { session, panes, pane, fromBus, firstCallMs, timeoutMs };
+}
+/**
+ * A pane's content width, for unfolding a glued dump. Only a bus-resolved pane
+ * reaches this: a direct listing already carried the field, and the manifest
+ * the bus pushes has no geometry. A single-line dump is the only caller.
+ */
+async function paneContentColumns(client, session, pane) {
+    const panes = await client.listPanes(session);
+    return panes.find((p) => p.id === pane.id)?.contentColumns ?? 0;
+}
+/**
+ * Zellij puts a newline before a row only when the row is marked canonical, and
+ * a full-screen TUI repaints by writing full-width rows back to back, so every
+ * row is a wrap continuation: `dump-screen` then hands back the whole viewport
+ * as one line. A pane whose rows are ended by a line feed reads normally and is
+ * left alone. The `--ansi` dump keeps the repainted rows full width, so it
+ * unfolds back into rows when it divides into the pane's column count exactly;
+ * anything else keeps the original text.
+ */
+async function unglueScreen(client, session, pane, text, full, fromBus) {
+    // The Zellij client prints the dump, so even a glued screen ends in one
+    // `println!` newline; only a newline *inside* the text separates rows.
+    const body = text.replace(/\n+$/, "");
+    if (!body || body.includes("\n"))
+        return text;
+    const columns = pane.contentColumns && pane.contentColumns > 1
+        ? pane.contentColumns
+        : fromBus
+            ? await paneContentColumns(client, session, pane)
+            : 0;
+    if (columns < 2 || body.length <= columns)
+        return text;
+    let ansi;
+    try {
+        ansi = (await client.dumpPane({ session, paneId: pane.id, full, ansi: true })).text;
+    }
+    catch {
+        // A Zellij too old for `--ansi` (or a failing call) must not break dump.
+        return text;
+    }
+    return unfoldScreen(ansi, columns) ?? text;
 }
 async function dispatchOperation(args, injected, deps, context, env) {
     const op = String(args.op ?? "");
@@ -275,15 +335,25 @@ async function dispatchOperation(args, injected, deps, context, env) {
                         ipc.status === "cancelled")) {
                     throw new ZellijError("ipc_unreachable", `ZSWARM_TMP=auto could not discover the remote Zellij IPC directory (status=${ipc.status}). Set ZSWARM_TMP to the desktop TEMP, confirm ZSWARM_SSH_MODE=interactive with a logged-on user, or use zswarm serve. Refusing to treat EXITED rows as "no live crew".`);
                 }
+                if (isTrue(args.pruneExited)) {
+                    const pruned = await pruneExitedSessions(client, listed, args);
+                    return {
+                        ok: true,
+                        data: { ...pruned, zellij: client.zellijPath, transport, filter: "exited" },
+                    };
+                }
+                const onlyExited = isTrue(args.exited);
                 const includeExited = isTrue(args.all);
-                const sessions = includeExited
-                    ? listed
-                    : listed.filter((s) => !s.exited);
+                const sessions = onlyExited
+                    ? listed.filter((s) => s.exited)
+                    : includeExited
+                        ? listed
+                        : listed.filter((s) => !s.exited);
                 const data = {
                     sessions,
                     zellij: client.zellijPath,
                     transport,
-                    filter: includeExited ? "all" : "live",
+                    filter: onlyExited ? "exited" : includeExited ? "all" : "live",
                 };
                 return { ok: true, data };
             }
@@ -313,9 +383,26 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 const body = String(args.body ?? args.text ?? "");
                 if (!body.trim())
                     throw new ZellijError("missing_body", "body required");
-                const { session, pane, panes } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
+                const { session, pane, panes, firstCallMs, timeoutMs } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
                 assertWritable(client, pane, args, "send");
                 await assertExpectedScreen(client, session, pane.id, args, signal);
+                if (isTrue(args.ifIdle)) {
+                    // Before delivery starts: a live pane lease (a relay working it) is a
+                    // hard refusal; a harness that is visibly working is the softer one.
+                    const to = String(args.to ?? "").trim();
+                    const held = findLease(state(), {
+                        serve: typeof args.serve === "string" ? args.serve : env.ZSWARM_SERVE,
+                        session,
+                        pane: to,
+                    });
+                    if (held) {
+                        throw new ZellijError("pane_leased", `pane ${to} is leased by relay ${held.relayId} (from ${held.from}, since ${new Date(held.at).toISOString()})`, { relayId: held.relayId, from: held.from, at: held.at, dir: held.dir });
+                    }
+                    const screen = await client.dumpPane({ session, paneId: pane.id }).then((res) => res.text, () => null);
+                    if (screen !== null && busyPrompt(screen, resolveHarness(pane))) {
+                        throw new ZellijError("pane_busy", `pane ${to} is busy with a task; retry when it is idle`);
+                    }
+                }
                 const labeled = withSenderLabel(args, {
                     env,
                     selfTitle: selfPaneTitle(client, panes),
@@ -327,6 +414,8 @@ async function dispatchOperation(args, injected, deps, context, env) {
                     op: "send",
                     at: clock.now(),
                     clock,
+                    firstCallMs,
+                    timeoutMs,
                 });
                 if (!result.ok && result.error) {
                     throw new ZellijError(result.error.code, result.error.message);
@@ -401,15 +490,17 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 };
             }
             case "dump": {
-                const { session, pane } = await resolveTarget(client, args, state(), clock, env, undefined, undefined, signal);
+                const { session, pane, fromBus } = await resolveTarget(client, args, state(), clock, env, undefined, undefined, signal);
+                const full = isTrue(args.full);
                 const dumped = await client.dumpPane({
                     session,
                     paneId: pane.id,
-                    full: isTrue(args.full),
+                    full,
                 });
+                const text = await unglueScreen(client, session, pane, dumped.text, full, fromBus);
                 const max = dumpMaxChars(args);
                 const keep = isTrue(args.head) ? "head" : "tail";
-                const clipped = truncateDumpText(dumped.text, max, keep);
+                const clipped = truncateDumpText(text, max, keep);
                 return {
                     ok: true,
                     data: {
@@ -591,6 +682,52 @@ async function dispatchOperation(args, injected, deps, context, env) {
         return fail(err);
     }
 }
+/** Delete EXITED sessions only: `zellij delete-session` has no --force. */
+async function pruneExitedSessions(client, listed, args) {
+    const olderThanRaw = optionalString(args.olderThan);
+    let minAge = null;
+    if (olderThanRaw) {
+        minAge = parseCreatedAge(olderThanRaw);
+        if (minAge === null) {
+            throw new ZellijError("bad_arg", `--older-than needs a duration like 7d, 12h, 30m (got ${olderThanRaw})`);
+        }
+    }
+    const dryRun = isTrue(args.dryRun);
+    const deleted = [];
+    const skipped = [];
+    for (const session of listed.filter((s) => s.exited)) {
+        const row = { name: session.name, age: session.age, ageSeconds: session.ageSeconds };
+        if (minAge !== null && (session.ageSeconds === null || session.ageSeconds < minAge)) {
+            skipped.push({
+                ...row,
+                reason: session.ageSeconds === null
+                    ? "age unknown"
+                    : `created less than ${olderThanRaw} ago`,
+            });
+            continue;
+        }
+        if (dryRun) {
+            deleted.push(row);
+            continue;
+        }
+        try {
+            await client.deleteSession(session.name);
+            deleted.push(row);
+        }
+        catch (err) {
+            skipped.push({ ...row, reason: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return {
+        pruneExited: true,
+        dryRun,
+        olderThanSeconds: minAge,
+        deleted,
+        deletedCount: deleted.length,
+        skipped,
+        skippedCount: skipped.length,
+    };
+}
 /** Shared MCP/CLI dispatch, with invocation routing on successes and failures. */
 export async function dispatchZswarm(args, injected, deps = {}) {
     try {

package/dist/ops/util.d.ts

@@ -44,6 +44,15 @@ export declare function truncateDumpText(text: string, maxChars: number, keep?:
 };
 /** Screen text with trailing blanks removed, so idle detection ignores padding. */
 export declare function normalizeScreen(text: string): string;
+/**
+ * Zellij's plain `dump-screen` puts a newline only before rows it marks
+ * canonical; a full-width repaint (a TUI) leaves every row a wrap
+ * continuation, so the whole viewport arrives as one line. The `--ansi`
+ * dump keeps those rows full width, so the text is a whole number of
+ * `columns`-wide rows once the SGR sequences are dropped. Returns null when
+ * that shape does not hold and the caller must keep the original text.
+ */
+export declare function unfoldScreen(text: string, columns: number): string | null;
 export declare function numberArg(args: Record<string, unknown>, key: string, fallback: number, limits: {
     min: number;
     max: number;

package/dist/ops/util.js

@@ -71,6 +71,30 @@ export function normalizeScreen(text) {
         .join("\n")
         .replace(/\n+$/, "");
 }
+/**
+ * Zellij's plain `dump-screen` puts a newline only before rows it marks
+ * canonical; a full-width repaint (a TUI) leaves every row a wrap
+ * continuation, so the whole viewport arrives as one line. The `--ansi`
+ * dump keeps those rows full width, so the text is a whole number of
+ * `columns`-wide rows once the SGR sequences are dropped. Returns null when
+ * that shape does not hold and the caller must keep the original text.
+ */
+export function unfoldScreen(text, columns) {
+    if (columns < 2)
+        return null;
+    const body = text.replace(/\x1b\[[0-9;]*m/g, "").replace(/\n+$/, "");
+    if (body.length === 0)
+        return null;
+    if (body.length % columns !== 0)
+        return null;
+    if (body.length / columns < 2)
+        return null;
+    const rows = [];
+    for (let i = 0; i < body.length; i += columns) {
+        rows.push(body.slice(i, i + columns).replace(/\s+$/, ""));
+    }
+    return rows.join("\n");
+}
 export function numberArg(args, key, fallback, limits) {
     const raw = args[key];
     if (raw === undefined || raw === null || raw === "")

package/dist/schema.js

@@ -72,6 +72,41 @@ export const PARAMS = [
         flags: ["--live", "--active"],
         description: "sessions: only live (non-EXITED) sessions — this is the default; use --all to include EXITED",
     },
+    {
+        name: "exited",
+        type: "boolean",
+        flags: ["--exited"],
+        cliOnly: true,
+        description: "sessions: list only EXITED (resurrectable) sessions; rows carry name, exited, age and ageSeconds",
+    },
+    {
+        name: "pruneExited",
+        type: "boolean",
+        flags: ["--prune-exited"],
+        cliOnly: true,
+        description: "sessions: delete EXITED sessions (all, or those matching --older-than) with zellij delete-session; a live session is never removed",
+    },
+    {
+        name: "olderThan",
+        type: "string",
+        flags: ["--older-than"],
+        cliOnly: true,
+        description: "sessions --prune-exited: only delete sessions created at least this long ago (e.g. 7d, 12h, 30m; default all exited)",
+    },
+    {
+        name: "dryRun",
+        type: "boolean",
+        flags: ["--dry-run"],
+        cliOnly: true,
+        description: "sessions --prune-exited: report what would be deleted without deleting",
+    },
+    {
+        name: "json",
+        type: "boolean",
+        flags: ["--json"],
+        cliOnly: true,
+        description: "sessions: rows are name, exited, age and ageSeconds; the CLI prints JSON either way",
+    },
     {
         name: "local",
         type: "boolean",
@@ -344,19 +379,31 @@ export const PARAMS = [
         type: "string",
         flags: ["--submit"],
         values: ["auto", "double-enter", "none"],
-        description: "send/broadcast: auto verifies the paste actually submitted and presses Enter again if not (default)",
+        description: 'send/broadcast: auto verifies the paste actually submitted and presses Enter again if not (default). The result reports submitted: true, "queued" (held behind a running turn), false (still in the composer), "unverified" (the screen changed but the body is not visible), or "not-delivered" (the pane was unchanged apart from the composer, so the op fails not_delivered and a resend is safe)',
     },
     {
         name: "observeMs",
         type: "number",
         flags: ["--observe-ms"],
-        description: "spawn: observe creation/alias for up to 3000ms; pane lookup: retry absence for 1000ms; 0 disables retries",
+        description: "spawn: observe creation/alias for up to 3000ms; pane lookup: retry absence for 1000ms (scaled up to 5x when the first Zellij call is slow); 0 disables retries",
     },
     {
         name: "settleMs",
         type: "number",
         flags: ["--settle-ms"],
-        description: "send/broadcast: pause before checking the paste landed (default 300)",
+        description: "send/broadcast: pause before checking the paste landed (default 300, scaled up to 5x when the first Zellij call is slow; explicit value wins)",
+    },
+    {
+        name: "confirm",
+        type: "boolean",
+        flags: ["--confirm"],
+        description: 'send/broadcast: after the send, dump once more and report what it sees; paste again only on "not-delivered" (positive evidence nothing landed), press Enter when the body is still in the composer, and never paste the body twice',
+    },
+    {
+        name: "ifIdle",
+        type: "boolean",
+        flags: ["--if-idle"],
+        description: "send: refuse a pane that a relay has leased (pane_leased) or whose harness is visibly working (pane_busy) instead of pasting into it",
     },
     {
         name: "expect",

package/dist/state.d.ts

@@ -29,6 +29,24 @@ export type BusMarkerRecord = {
     configKey: string;
     installedAt: number;
 };
+/**
+ * One held pane lease: a relay is working this target until it ends. `key`
+ * names the target (serve endpoint or local, session, pane) so two processes
+ * racing to take it are serialized by the lease lock.
+ */
+export type LeaseRecord = {
+    key: string;
+    relayId: string;
+    from: string;
+    at: number;
+    /** The relay run directory; a missing/finished one makes the lease stale. */
+    dir: string;
+    serve?: string;
+    session?: string;
+    pane: string;
+    /** Relays that forced through while this lease was held. */
+    sharedBy?: string[];
+};
 /** How much of the end of the log `readLog` reads; older entries are not shown. */
 export declare const LOG_TAIL_BYTES: number;
 /**
@@ -55,6 +73,8 @@ export declare function createStateStore(options?: StateStoreOptions): {
     readBus: (session: string) => BusMarkerRecord | null;
     writeBus: (session: string, marker: BusMarkerRecord) => void;
     clearBus: (session?: string) => void;
+    readLeases: () => Record<string, LeaseRecord>;
+    withLeases: <T>(fn: (leases: Record<string, LeaseRecord>) => T) => T;
     reset: () => void;
 };
 export type StateStore = ReturnType<typeof createStateStore>;

package/dist/state.js

@@ -7,6 +7,8 @@ const SIGNALS_LOCK = "signals.lock";
 const CURSORS_FILE = "cursors.json";
 const CURSORS_LOCK = "cursors.lock";
 const BUS_FILE = "bus.json";
+const LEASES_FILE = "leases.json";
+const LEASES_LOCK = "leases.lock";
 /** How much of the end of the log `readLog` reads; older entries are not shown. */
 export const LOG_TAIL_BYTES = 512 * 1024;
 /**
@@ -462,6 +464,22 @@ export function createStateStore(options = {}) {
         }
         writeJson(BUS_FILE, { sessions });
     }
+    function readLeases() {
+        return readJson(LEASES_FILE, {});
+    }
+    /**
+     * Atomic lease check-then-take/update. The callback mutates the map and its
+     * return value goes to the caller; the map is persisted while the state lock
+     * is held, so two processes racing to take one pane cannot both win.
+     */
+    function withLeases(fn) {
+        return withFileLock(LEASES_LOCK, () => {
+            const leases = readJson(LEASES_FILE, {});
+            const result = fn(leases);
+            writeJson(LEASES_FILE, leases);
+            return result;
+        });
+    }
     /** Test helper: drop everything this store wrote. */
     function reset() {
         rmSync(dir, { recursive: true, force: true });
@@ -480,6 +498,8 @@ export function createStateStore(options = {}) {
         readBus,
         writeBus,
         clearBus,
+        readLeases,
+        withLeases,
         reset,
     };
 }

package/dist/zellij/args.d.ts

@@ -83,7 +83,7 @@ export declare function buildLaunchPluginArgs(input: LaunchPluginInput): string[
 export declare function buildListPanesArgs(session: string): string[];
 export declare function buildPasteArgs(session: string, paneId: string, text: string): string[];
 export declare function buildSendEnterArgs(session: string, paneId: string): string[];
-export declare function buildDumpArgs(session: string, paneId: string, full?: boolean): string[];
+export declare function buildDumpArgs(session: string, paneId: string, full?: boolean, ansi?: boolean): string[];
 export declare function buildSendKeysArgs(session: string, paneId: string, keys: string[]): string[];
 export declare function buildWriteCharsArgs(session: string, paneId: string, chars: string): string[];
 export declare function buildRenamePaneArgs(session: string, paneId: string, name: string): string[];

package/dist/zellij/args.js

@@ -122,7 +122,7 @@ export function buildSendEnterArgs(session, paneId) {
         "Enter",
     ];
 }
-export function buildDumpArgs(session, paneId, full = false) {
+export function buildDumpArgs(session, paneId, full = false, ansi = false) {
     const args = [
         ...sessionPrefix(session),
         "action",
@@ -132,6 +132,8 @@ export function buildDumpArgs(session, paneId, full = false) {
     ];
     if (full)
         args.push("--full");
+    if (ansi)
+        args.push("--ansi");
     return args;
 }
 export function buildSendKeysArgs(session, paneId, keys) {

package/dist/zellij/bus.js

@@ -295,6 +295,7 @@ export function busToPanes(snapshot) {
             focused: pane.focused,
             exited: pane.exited,
             floating: false,
+            contentColumns: null,
         };
     });
 }

package/dist/zellij/client.d.ts

@@ -41,6 +41,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
     listSessions: (callTimeoutMs?: number, opts?: {
         fresh?: boolean;
     }) => Promise<ZellijSession[]>;
+    deleteSession: (name: string, callTimeoutMs?: number) => Promise<void>;
     resolveSession: (explicit?: string | null, callTimeoutMs?: number) => Promise<ZellijSessionResolve>;
     listPanes: (session: string, callTimeoutMs?: number, opts?: {
         fresh?: boolean;
@@ -58,6 +59,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         session: string;
         paneId: string;
         full?: boolean;
+        ansi?: boolean;
         timeoutMs?: number;
     }) => Promise<{
         paneId: string;

package/dist/zellij/client.js

@@ -173,6 +173,21 @@ export function createZellijClient(options = {}) {
             return parseSessionList(result.stdout);
         });
     }
+    /**
+     * Delete one session by name. No `--force`: Zellij refuses to delete a live
+     * session, so this can only remove an EXITED (resurrectable) one.
+     */
+    async function deleteSession(name, callTimeoutMs = timeoutMs) {
+        const result = await exec(["delete-session", name], { timeoutMs: callTimeoutMs });
+        if (result.code === NOT_FOUND_EXIT) {
+            throw zellijMissingError(zellijPath, result);
+        }
+        if (result.code !== 0) {
+            const detail = result.stderr.trim() || result.stdout.trim() || "no output";
+            throw new ZellijError("zellij_failed", `zellij delete-session ${name} failed (exit ${result.code}): ${detail}`, zellijExecDetails(result));
+        }
+        invalidateListings(name);
+    }
     async function resolveSession(explicit, callTimeoutMs = timeoutMs) {
         return (sessionFromEnv(env, explicit) ??
             sessionFromList(await listSessions(callTimeoutMs)));
@@ -194,7 +209,7 @@ export function createZellijClient(options = {}) {
     }
     async function dumpPane(input) {
         const paneId = normalizePaneId(input.paneId);
-        const result = await run(buildDumpArgs(input.session, paneId, input.full), "zellij action dump-screen", input.timeoutMs ?? timeoutMs);
+        const result = await run(buildDumpArgs(input.session, paneId, input.full, input.ansi), "zellij action dump-screen", input.timeoutMs ?? timeoutMs);
         return { paneId, session: input.session, text: result.stdout };
     }
     async function sendKeys(input) {
@@ -362,6 +377,7 @@ export function createZellijClient(options = {}) {
         /** A `file:` plugin url only names a path on the machine running Zellij. */
         remote: ssh !== null,
         listSessions,
+        deleteSession,
         resolveSession,
         listPanes,
         resolvePane,

package/dist/zellij/panes.d.ts

@@ -10,6 +10,7 @@ export type ZellijPane = {
     focused: boolean;
     exited: boolean;
     floating: boolean;
+    contentColumns: number | null;
 };
 export declare function normalizePaneId(raw: string, isPlugin?: boolean): string;
 /** Parse `list-panes --json` output. */

package/dist/zellij/panes.js

@@ -32,6 +32,9 @@ function parsePaneRow(row) {
         focused: row.is_focused === true,
         exited: row.exited === true,
         floating: row.is_floating === true,
+        contentColumns: typeof row.pane_content_columns === "number"
+            ? row.pane_content_columns
+            : null,
     };
 }
 /** Parse `list-panes --json` output. */

package/dist/zellij/session.d.ts

@@ -9,12 +9,23 @@ export type ZellijSession = {
     exited: boolean;
     /** True when the listing marks this session as the caller's current one. */
     current: boolean;
+    /** The printed created-duration text without the trailing "ago" (`"1month 16days 2h"`), or null. */
+    age: string | null;
+    /** That duration in seconds, or null when it cannot be read. */
+    ageSeconds: number | null;
 };
 /**
  * Pane hosting the caller, so writes can refuse to loop back into it.
  * `ZSWARM_SELF_PANE` wins; Zellij exports `ZELLIJ_PANE_ID` inside a pane.
  */
 export declare function resolveSelfPaneId(env?: NodeJS.ProcessEnv): string | null;
+/**
+ * Zellij's human created age (`"1month 16days 2h 30m 5s ago"`) as seconds.
+ * Handles the units Zellij prints (s, m, h, days, months, years, singular and
+ * plural) with or without spaces between the pairs. Returns null when no
+ * number+unit pair is present (e.g. a bare `"demo"` listing).
+ */
+export declare function parseCreatedAge(text: string): number | null;
 /**
  * Parse `list-sessions --no-formatting` output.
  *