@zswarm/core 0.2.3 → 0.2.4

package/assets/slot.py

@@ -35,6 +35,7 @@ from __future__ import annotations  # macOS ships Python 3.9
 
 import os
 import re
+import shutil
 import signal
 import subprocess
 import sys
@@ -300,6 +301,39 @@ def main(argv: list[str]) -> int:
     return run(argv, env)
 
 
+def resolve_command(
+    argv: list[str],
+    env: dict[str, str],
+    os_name: str = os.name,
+    which=shutil.which,
+) -> list[str] | str:
+    """Rewrite argv so Windows can start argv[0], including .cmd/.bat shims.
+
+    CreateProcess does not search PATH or apply PATHEXT and cannot start a
+    batch file, so `slot -- pnpm ...` died 127 even though pnpm was on PATH.
+    On Windows, resolve argv[0] with shutil.which against the child's PATH;
+    shutil.which also applies PATHEXT from the environment this process
+    inherits (slot passes that environment straight through). A .cmd/.bat shim
+    runs through the command processor with `cmd.exe /d /s /c` and MS-quoted
+    arguments -- the documented way to run a batch file, and `cmd /c` returns
+    the batch's own exit code. A resolved .exe is spawned directly. POSIX and
+    anything that does not resolve are returned unchanged, so Popen still
+    reports the same FileNotFoundError and 127 as before.
+    """
+    if os_name != "nt" or not argv:
+        return argv
+    exe = which(argv[0], path=env.get("PATH"))
+    if not exe:
+        return argv
+    if Path(exe).suffix.lower() in (".cmd", ".bat"):
+        comspec = env.get("ComSpec") or "cmd.exe"
+        # One command line, handed to CreateProcess as is: a list would be
+        # quoted again by subprocess, and cmd.exe does not understand \".
+        # With /s, cmd strips exactly the outer quote pair and runs the rest.
+        return f'"{comspec}" /d /s /c "{subprocess.list2cmdline([exe, *argv[1:]])}"'
+    return [exe, *argv[1:]]
+
+
 def run(argv: list[str], env: dict[str, str], renice: bool = True) -> int:
     """Run the command as a child and wait. The lock descriptors stay in this
     process (close-on-exec), so a daemon the command leaves behind never
@@ -310,7 +344,7 @@ def run(argv: list[str], env: dict[str, str], renice: bool = True) -> int:
         except OSError:
             pass
     try:
-        child = subprocess.Popen(argv, env=env)
+        child = subprocess.Popen(resolve_command(argv, env), env=env)
     except FileNotFoundError:
         die(f"{argv[0]}: command not found", 127)
     for sig in (signal.SIGINT, signal.SIGTERM, getattr(signal, "SIGHUP", None)):

package/dist/harness.d.ts

@@ -14,6 +14,11 @@ export type HarnessProfile = {
      * turn. `send` matches these against the trailing lines after the paste.
      */
     queued: readonly RegExp[];
+    /**
+     * A hint that the harness is actively working on a turn. `status` matches
+     * these against the trailing lines to avoid treating a busy pane as idle.
+     */
+    busy: readonly RegExp[];
 };
 /**
  * Identify the harness from a pane's command and title, case-insensitively.
@@ -29,3 +34,8 @@ export declare function resolveHarness(pane: {
  * Only the last few lines count: a quoted marker in scrollback is not a queue.
  */
 export declare function queuedPrompt(screen: string, profile: HarnessProfile): boolean;
+/**
+ * Does this screen's trailing lines show the harness actively working? Only
+ * the last few lines count: a quoted marker in scrollback is not a live turn.
+ */
+export declare function busyPrompt(screen: string, profile: HarnessProfile): boolean;

package/dist/harness.js

@@ -69,11 +69,24 @@ const QUEUED = {
     gemini: GENERIC_QUEUED,
     pi: GENERIC_QUEUED,
 };
+/**
+ * Busy (working) markers seen live. OpenCode draws a progress bar of filled
+ * and hollow squares while a turn runs; no other named harness has an equally
+ * reliable marker yet, so they rely on the lease only (`[]`).
+ */
+const BUSY = {
+    codex: [],
+    cursor: [],
+    opencode: [/[■⬝]{4,}/],
+    gemini: [],
+    pi: [],
+};
 const UNKNOWN = {
     name: "unknown",
     submit: "auto",
     waiting: GENERIC_WAITING,
     queued: GENERIC_QUEUED,
+    busy: [/esc to interrupt/i],
 };
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -118,18 +131,36 @@ export function resolveHarness(pane) {
     const name = matchCommand(pane.command) ?? matchTitle(pane.title) ?? "unknown";
     if (name === "unknown")
         return UNKNOWN;
-    return { name, submit: SUBMIT[name], waiting: WAITING[name], queued: QUEUED[name] };
+    return {
+        name,
+        submit: SUBMIT[name],
+        waiting: WAITING[name],
+        queued: QUEUED[name],
+        busy: BUSY[name],
+    };
 }
 /**
  * Does this screen's trailing lines show the harness's queued-message hint?
  * Only the last few lines count: a quoted marker in scrollback is not a queue.
  */
 export function queuedPrompt(screen, profile) {
-    const lines = screen
+    const lines = trailingLines(screen);
+    return profile.queued.some((re) => lines.some((line) => re.test(line)));
+}
+/**
+ * Does this screen's trailing lines show the harness actively working? Only
+ * the last few lines count: a quoted marker in scrollback is not a live turn.
+ */
+export function busyPrompt(screen, profile) {
+    const lines = trailingLines(screen);
+    return profile.busy.some((re) => lines.some((line) => re.test(line)));
+}
+/** The six last non-empty, right-trimmed lines of a screen, CR stripped. */
+function trailingLines(screen) {
+    return screen
         .replace(/\r/g, "")
         .split("\n")
         .map((line) => line.trimEnd())
         .filter((line) => line.length > 0)
         .slice(-6);
-    return profile.queued.some((re) => lines.some((line) => re.test(line)));
 }

package/dist/host/cli.js

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
 import { ZellijError } from "../errors.js";
+import { createStateStore } from "../state.js";
 import { crewCheck, crewDown, crewStart, crewStatus, crewUp } from "./crew.js";
 import { hostDoctor, hostInstall, hostInstallArgs, hostScriptPath } from "./host.js";
+import { listLeases } from "./lease.js";
 import { cancelAllTo, cancelRelay, listRelays, pruneRelays, runRelayDir, startRelay, waitForRelay } from "./relay.js";
 import { runSlot } from "./slot.js";
 /**
@@ -80,7 +82,7 @@ async function crew(argv) {
 }
 /** A plain-text table for `relay --list`, one row per relay. */
 function relayTable(rows) {
-    const header = ["ID", "STATE", "TO", "SESSION", "AGE", "LAST CHECK", "JOB"];
+    const header = ["ID", "STATE", "TO", "SESSION", "AGE", "LAST CHECK", "JOB", "LEASE"];
     const body = rows.map((r) => [
         r.id,
         r.state,
@@ -89,12 +91,26 @@ function relayTable(rows) {
         `${r.age}s`,
         r.lastCheck === undefined ? "-" : String(r.lastCheck),
         r.job ?? "-",
+        r.lease ? `${r.lease.relayId} (${r.lease.from})` : "-",
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
+    return [header, ...body].map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
+}
+/** A plain-text table for `relay --leases`, one row per live lease. */
+function leaseTable(leases) {
+    const header = ["KEY", "RELAY", "FROM", "PANE", "SINCE"];
+    const body = leases.map((l) => [
+        l.key,
+        l.relayId,
+        l.from,
+        l.pane,
+        new Date(l.at).toISOString(),
     ]);
     const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
     return [header, ...body].map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
 }
 async function relay(argv) {
-    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--cancel-all", "--json"]);
+    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--leases", "--cancel-all", "--json", "--queue", "--force"]);
     const run = str(flags["--run"]);
     if (run)
         return runRelayDir(run);
@@ -115,6 +131,13 @@ async function relay(argv) {
         process.stdout.write(`${relayTable(rows)}\n`);
         return 0;
     }
+    if (flags["--leases"] === true) {
+        const leases = listLeases(createStateStore());
+        if (flags["--json"] === true)
+            return json(() => ({ leases }));
+        process.stdout.write(`${leaseTable(leases)}\n`);
+        return 0;
+    }
     const cancelId = str(flags["--cancel"]);
     if (cancelId) {
         const res = cancelRelay(cancelId);
@@ -153,6 +176,8 @@ async function relay(argv) {
         timeoutMin: flags["--timeout-min"] ? Number(str(flags["--timeout-min"])) : undefined,
         maxAgeMin: flags["--max-age"] ? Number(str(flags["--max-age"])) : undefined,
         foreground: flags["--foreground"] === true,
+        queue: flags["--queue"] === true,
+        force: flags["--force"] === true,
     }));
 }
 async function host(argv) {
@@ -213,11 +238,14 @@ const COMMANDS = {
         usage: [
             "zswarm relay --to PANE --done REGEX --reply-to PANE [--serve TARGET] [--session S] [--body-file F]",
             "             [--reply-session S] [--from NAME] [--check SCRIPT] [--message TEMPLATE] [--id ID]",
-            "             [--timeout-min 240] [--max-age MIN] [--foreground]",
+            "             [--timeout-min 240] [--max-age MIN] [--queue] [--force] [--foreground]",
             "      send the body to PANE over serve (ZSWARM_SERVE / ZSWARM_SERVE_TOKEN), then a detached relay",
             "      waits for REGEX (and SCRIPT exit 0) and pastes a message into the local --reply-to pane;",
             "      --max-age (default --timeout-min + 60) is a hard end that always yields a final status",
-            "zswarm relay --list [--json]   id, state, target, session, age, last check and job per relay dir",
+            "      it leases its target pane until it ends; a second relay to a leased pane fails pane_leased",
+            "      unless --queue waits for the lease to free or --force shares it",
+            "zswarm relay --list [--json]   id, state, target, session, age, last check, job and lease per relay dir",
+            "zswarm relay --leases [--json]   live pane leases and the relay that holds each",
             "zswarm relay --cancel ID | --cancel-all --to PANE   stop the job, mark it CANCELLED, paste nothing",
             "zswarm relay --wait ID [--timeout-min 240]   block until relay ID has its message, print it (pull path)",
             "zswarm relay --prune [--days 14]   remove old relay dirs and undelivered messages",

package/dist/host/lease.d.ts

@@ -0,0 +1,68 @@
+import type { LeaseRecord, StateStore } from "../state.js";
+/**
+ * Pane leases: a relay holds one on its target pane from before it sends until
+ * it ends, so a second relay or `send --if-idle` can refuse (or wait) instead
+ * of interleaving two tasks in one agent pane.
+ *
+ * The record lives in the zswarm state dir and is only ever read or written
+ * inside `StateStore.withLeases`, whose file lock serializes check-then-take
+ * across processes. A lease whose relay directory is gone or has finished is
+ * stale and is taken over.
+ */
+export type LeaseTarget = {
+    /** The serve endpoint that owns the pane, or undefined for a local pane. */
+    serve?: string;
+    session?: string;
+    /** The pane address as `--to` gives it (id, title or command). */
+    pane: string;
+};
+export type LeaseTakeInput = {
+    relayId: string;
+    from: string;
+    at: number;
+    dir: string;
+    target: LeaseTarget;
+    /** Send anyway: add this relay to the holder's shared list. */
+    force?: boolean;
+};
+export type LeaseTakeResult = {
+    ok: true;
+    lease: LeaseRecord;
+    shared: boolean;
+} | {
+    ok: false;
+    holder: LeaseRecord;
+};
+/** The target identity: serve endpoint (or `local`), session and pane address. */
+export declare function leaseKey(target: LeaseTarget): string;
+type LeaseJob = {
+    kind?: unknown;
+    pid?: unknown;
+    label?: unknown;
+    unit?: unknown;
+};
+export type LeaseStaleDeps = {
+    now?: () => number;
+    /** Whether a launchd/systemd relay job is still loaded; injected in tests. */
+    jobRunning?: (job: LeaseJob) => boolean | undefined;
+};
+export declare function leaseStale(rec: LeaseRecord, deps?: LeaseStaleDeps): boolean;
+/** Live leases only; stale records are dropped from the store as they are seen. */
+export declare function listLeases(store: StateStore, deps?: LeaseStaleDeps): LeaseRecord[];
+/** The live lease for a target, if any. */
+export declare function findLease(store: StateStore, target: LeaseTarget, deps?: LeaseStaleDeps): LeaseRecord | undefined;
+/**
+ * Take the lease for a target. Returns the holder when a live lease is already
+ * held (caller decides: refuse, `--queue`, or `--force`). `force` shares the
+ * holder's lease by recording the new relay id.
+ */
+export declare function takeLease(store: StateStore, input: LeaseTakeInput): LeaseTakeResult;
+/**
+ * Release a target's lease. With `relayId`, the lease is dropped only when that
+ * relay is the holder; a forced relay that ends is removed from `sharedBy` and
+ * the original holder keeps the lease.
+ */
+export declare function releaseLease(store: StateStore, target: LeaseTarget, relayId?: string): boolean;
+/** `releaseLease` by the already-recorded key (the relay config stores it). */
+export declare function releaseLeaseKey(store: StateStore, key: string, relayId?: string): boolean;
+export {};

package/dist/host/lease.js

@@ -0,0 +1,138 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** The target identity: serve endpoint (or `local`), session and pane address. */
+export function leaseKey(target) {
+    return [target.serve?.trim() || "local", target.session?.trim() ?? "", target.pane.trim()].join("|");
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // ESRCH: gone. EPERM: exists, just unsignalable — still a live holder.
+        return err.code === "EPERM";
+    }
+}
+/**
+ * A lease is stale when its relay no longer runs: the run directory is gone,
+ * the relay recorded a final status or was cancelled, its message is written,
+ * or its plain detached pid is dead. (launchd/systemd jobs write a status on
+ * every final path; a killed job without one is recovered by `--cancel`.)
+ */
+/** Minutes past a relay's max age before its lease is dropped regardless. */
+const LEASE_GRACE_MIN = 5;
+/** True while a launchd label or systemd user unit is still loaded; undefined for other jobs. */
+function serviceJobRunning(job) {
+    if (job.kind === "launchd" && typeof job.label === "string") {
+        return spawnSync("launchctl", ["list", job.label], { stdio: "ignore" }).status === 0;
+    }
+    if (job.kind === "systemd" && typeof job.unit === "string") {
+        const res = spawnSync("systemctl", ["--user", "is-active", job.unit], { encoding: "utf8" });
+        return res.status === 0 && /^(active|activating|reloading)$/.test((res.stdout ?? "").trim());
+    }
+    return undefined;
+}
+export function leaseStale(rec, deps = {}) {
+    if (!rec.dir || !existsSync(rec.dir))
+        return true;
+    let cfg;
+    try {
+        cfg = JSON.parse(readFileSync(join(rec.dir, "config.json"), "utf8"));
+    }
+    catch {
+        return true;
+    }
+    if (cfg.cancelled === true || typeof cfg.status === "string")
+        return true;
+    if (existsSync(join(rec.dir, "message.txt")))
+        return true;
+    const job = cfg.job;
+    if (job && job.kind === "pid" && typeof job.pid === "number" && !pidAlive(job.pid))
+        return true;
+    // A launchd/systemd relay that is no longer loaded ended without a final
+    // status (removed by hand, killed, or the machine restarted).
+    if (job && (deps.jobRunning ?? serviceJobRunning)(job) === false)
+        return true;
+    // Backstop: a relay always ends by its max age, so its lease cannot outlive
+    // it (this also covers a pid that was reused by another process).
+    const maxAgeMin = typeof cfg.maxAgeMin === "number" ? cfg.maxAgeMin
+        : typeof cfg.timeoutMin === "number" ? cfg.timeoutMin + 60
+            : undefined;
+    if (maxAgeMin !== undefined && (deps.now ?? Date.now)() > rec.at + (maxAgeMin + LEASE_GRACE_MIN) * 60_000)
+        return true;
+    return false;
+}
+/** Live leases only; stale records are dropped from the store as they are seen. */
+export function listLeases(store, deps = {}) {
+    return store.withLeases((leases) => {
+        for (const [key, rec] of Object.entries(leases)) {
+            if (leaseStale(rec, deps))
+                delete leases[key];
+        }
+        return Object.values(leases);
+    });
+}
+/** The live lease for a target, if any. */
+export function findLease(store, target, deps = {}) {
+    const rec = store.readLeases()[leaseKey(target)];
+    return rec && !leaseStale(rec, deps) ? rec : undefined;
+}
+/**
+ * Take the lease for a target. Returns the holder when a live lease is already
+ * held (caller decides: refuse, `--queue`, or `--force`). `force` shares the
+ * holder's lease by recording the new relay id.
+ */
+export function takeLease(store, input) {
+    const key = leaseKey(input.target);
+    return store.withLeases((leases) => {
+        const held = leases[key];
+        // Staleness on the taker's clock: the new lease's `at` is its now.
+        if (held && !leaseStale(held, { now: () => input.at })) {
+            if (!input.force)
+                return { ok: false, holder: held };
+            const sharedBy = [...new Set([...(held.sharedBy ?? []), input.relayId])];
+            const shared = { ...held, sharedBy };
+            leases[key] = shared;
+            return { ok: true, lease: shared, shared: true };
+        }
+        const lease = {
+            key,
+            relayId: input.relayId,
+            from: input.from,
+            at: input.at,
+            dir: input.dir,
+            serve: input.target.serve,
+            session: input.target.session,
+            pane: input.target.pane,
+        };
+        leases[key] = lease;
+        return { ok: true, lease, shared: false };
+    });
+}
+/**
+ * Release a target's lease. With `relayId`, the lease is dropped only when that
+ * relay is the holder; a forced relay that ends is removed from `sharedBy` and
+ * the original holder keeps the lease.
+ */
+export function releaseLease(store, target, relayId) {
+    return releaseLeaseKey(store, leaseKey(target), relayId);
+}
+/** `releaseLease` by the already-recorded key (the relay config stores it). */
+export function releaseLeaseKey(store, key, relayId) {
+    return store.withLeases((leases) => {
+        const held = leases[key];
+        if (!held)
+            return false;
+        if (!relayId || held.relayId === relayId) {
+            delete leases[key];
+            return true;
+        }
+        if (held.sharedBy?.includes(relayId)) {
+            leases[key] = { ...held, sharedBy: held.sharedBy.filter((id) => id !== relayId) };
+            return true;
+        }
+        return false;
+    });
+}

package/dist/host/relay.d.ts

@@ -1,4 +1,5 @@
 import type { OpsResult } from "../ops/types.js";
+import { type StateStore } from "../state.js";
 /**
  * `zswarm relay`: hand a body to a pane on another host and tell a local pane
  * when the work is done, without anyone polling.
@@ -51,6 +52,8 @@ export type RelayConfig = {
     /** Set by `--cancel`; a late loop must not overwrite it. */
     cancelled?: boolean;
     cancelledAt?: number;
+    /** The pane lease this relay holds; released on every final status. */
+    leaseKey?: string;
 };
 export type RelayDeps = {
     /** dispatchZswarm with an env; injected in tests. */
@@ -101,8 +104,14 @@ export type RelayStartInput = {
     /** Hard cap on the relay's age; defaults to `timeoutMin` plus 60 minutes. */
     maxAgeMin?: number;
     foreground?: boolean;
+    /** Wait for a leased pane to free instead of failing. */
+    queue?: boolean;
+    /** Send to a leased pane anyway; the lease is shared and noted. */
+    force?: boolean;
     env?: NodeJS.ProcessEnv;
     deps?: RelayDeps;
+    /** State store for the pane lease; injected in tests. */
+    store?: StateStore;
     /** Starts the detached relay; injected in tests. */
     launch?: (dir: string, env: NodeJS.ProcessEnv) => string;
 };
@@ -138,6 +147,8 @@ export type RelayJobRunner = (cmd: string, args: string[]) => {
 export type RelayAdminDeps = {
     env?: NodeJS.ProcessEnv;
     now?: () => number;
+    /** State store for the pane leases; injected in tests. */
+    store?: StateStore;
     /** Runs launchctl/systemctl; injected in tests. */
     run?: RelayJobRunner;
     /** Liveness probe for a plain detached pid; injected in tests. */
@@ -160,6 +171,12 @@ export type RelayRow = {
     lastCheck?: number;
     /** The launchd label / systemd unit / pid, when the job is still loaded. */
     job?: string;
+    /** The live pane lease held for this relay's target, if any. */
+    lease?: {
+        relayId: string;
+        from: string;
+        at: number;
+    };
 };
 export type RelayCancelResult = {
     id: string;

package/dist/host/relay.js

@@ -4,7 +4,8 @@ import { basename, join } from "node:path";
 import { ZellijError } from "../errors.js";
 import { dispatchZswarm } from "../ops/dispatch.js";
 import { resolveServeCliLaunch } from "../ops/serve-install.js";
-import { defaultStateDir } from "../state.js";
+import { createStateStore, defaultStateDir } from "../state.js";
+import { findLease, leaseKey, releaseLeaseKey, takeLease } from "./lease.js";
 const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 /** Spread over about an hour: Zellij on a loaded machine can stall for minutes. */
 const DEFAULT_DELAYS = [0, 30, 60, 120, 300, 600, 900, 1500];
@@ -17,6 +18,8 @@ const CHECK_BROKEN_TRIES = 10;
 const DEFAULT_MAX_AGE_EXTRA_MIN = 60;
 /** A wait that only finds `seen` lines returns at once; poll no faster than this. */
 const STALE_MATCH_POLL_MS = 15_000;
+/** `relay --queue` re-checks a leased pane this often. */
+const LEASE_QUEUE_POLL_MS = 5_000;
 export function relaysDir(env = process.env) {
     return join(defaultStateDir(env), "relays");
 }
@@ -394,12 +397,35 @@ export async function startRelay(input) {
     // Read the body before the relay directory (and its token copy) exists.
     const body = input.bodyFile ? readFileSync(input.bodyFile, "utf8") : undefined;
     const dir = prepareRelay(cfg, { check: input.check, message: input.message }, env);
-    const call = input.deps?.call ?? ((args, e) => dispatchZswarm(args, undefined, { env: e }));
-    const remote = serveEnv(cfg, env);
-    const target = (args) => cfg.session ? { ...args, session: cfg.session } : args;
+    const store = input.store ?? createStateStore({ env });
+    const leaseTarget = { serve, session: cfg.session, pane: cfg.to };
     let sent;
     let warning;
     let how;
+    const leaseNow = input.deps?.now ?? Date.now;
+    const leaseSleep = input.deps?.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const take = () => takeLease(store, { relayId: id, from: cfg.from, at: leaseNow(), dir, target: leaseTarget, force: input.force });
+    const leaseKeyValue = leaseKey(leaseTarget);
+    let taken = take();
+    if (!taken.ok && input.queue) {
+        const deadline = leaseNow() + cfg.timeoutMin * 60_000;
+        while (!taken.ok && leaseNow() < deadline) {
+            await leaseSleep(Math.min(LEASE_QUEUE_POLL_MS, Math.max(1, deadline - leaseNow())));
+            taken = take();
+        }
+    }
+    if (!taken.ok) {
+        rmSync(dir, { recursive: true, force: true });
+        const holder = taken.holder;
+        throw new ZellijError("pane_leased", `pane ${cfg.to} is leased by relay ${holder.relayId} (from ${holder.from}, since ${new Date(holder.at).toISOString()})${input.queue ? " and did not free before --timeout-min" : "; use --queue to wait or --force to share it"}`, { relayId: holder.relayId, from: holder.from, at: holder.at, dir: holder.dir });
+    }
+    updateConfig(dir, { leaseKey: leaseKeyValue });
+    if (taken.shared) {
+        warning = `pane ${cfg.to} is already leased by relay ${taken.lease.relayId}; --force shares its lease`;
+    }
+    const call = input.deps?.call ?? ((args, e) => dispatchZswarm(args, undefined, { env: e }));
+    const remote = serveEnv(cfg, env);
+    const target = (args) => cfg.session ? { ...args, session: cfg.session } : args;
     try {
         if (body !== undefined) {
             const res = await call(target({ op: "send", to: cfg.to, body, from: cfg.from, settleMs: 800 }), remote);
@@ -418,7 +444,8 @@ export async function startRelay(input) {
                 }
             }
             if (doneLines(body, cfg.done).length > 0) {
-                warning = "--done matches a line of the body; that line is ignored while it stays on screen, so an identical done line is only seen once it scrolls off";
+                const note = "--done matches a line of the body; that line is ignored while it stays on screen, so an identical done line is only seen once it scrolls off";
+                warning = warning ? `${warning}; ${note}` : note;
             }
         }
         // Whatever already matches --done (the echoed body, an earlier task's done
@@ -431,21 +458,32 @@ export async function startRelay(input) {
             how = (input.launch ?? launchRelay)(dir, env);
     }
     catch (err) {
-        // Nothing will run from this directory: take the token copy with it.
+        // Nothing will run from this directory: take the lease and token copy with it.
+        releaseLeaseKey(store, leaseKeyValue, id);
         rmSync(dir, { recursive: true, force: true });
         throw err;
     }
     const extra = warning ? { warning } : {};
     if (input.foreground) {
-        const result = await relayLoop(dir, input.deps).finally(() => scrubRelayToken(dir));
+        const result = await relayLoop(dir, input.deps).finally(() => {
+            releaseLeaseKey(store, leaseKeyValue, id);
+            scrubRelayToken(dir);
+        });
         return { id, dir, sent: sent ?? null, ...extra, ...result };
     }
     return { id, dir, sent: sent ?? null, ...extra, relay: how };
 }
 /** What `zswarm relay --run <dir>` does inside the detached job. */
 export async function runRelayDir(dir, deps = {}) {
+    const store = createStateStore({ env: deps.env ?? process.env });
+    const releaseLease = () => {
+        const cfg = readRelayConfig(dir);
+        if (cfg?.leaseKey && cfg.id)
+            releaseLeaseKey(store, cfg.leaseKey, cfg.id);
+    };
     const stop = (sig) => () => {
         appendFileSync(join(dir, "relay.log"), `${new Date().toISOString()} relay stopped by ${sig}\n`);
+        releaseLease();
         scrubRelayToken(dir);
         process.exit(143);
     };
@@ -459,6 +497,7 @@ export async function runRelayDir(dir, deps = {}) {
         code = res.delivered ? 0 : 3;
     }
     finally {
+        releaseLease();
         scrubRelayToken(dir);
         process.off("SIGTERM", onTerm);
         process.off("SIGHUP", onHup);
@@ -613,12 +652,14 @@ function jobLoaded(job, deps, dir) {
 export function listRelays(deps = {}) {
     const env = deps.env ?? process.env;
     const now = deps.now ?? Date.now;
+    const store = deps.store ?? createStateStore({ env });
     const rows = [];
     for (const run of runDirs(relaysDir(env))) {
         const cfg = readRelayConfig(run.dir);
         if (!cfg)
             continue;
         const loaded = cfg.job ? jobLoaded(cfg.job, deps, run.dir) : false;
+        const held = findLease(store, { serve: cfg.serve, session: cfg.session, pane: cfg.to }, { now });
         rows.push({
             id: cfg.id || run.id,
             dir: run.dir,
@@ -629,6 +670,7 @@ export function listRelays(deps = {}) {
             state: relayState(run.dir, cfg),
             lastCheck: lastCheckResult(run.dir),
             ...(loaded && cfg.job ? { job: jobLabelText(cfg.job) } : {}),
+            ...(held ? { lease: { relayId: held.relayId, from: held.from, at: held.at } } : {}),
         });
     }
     return rows.sort((a, b) => b.started - a.started);
@@ -680,6 +722,9 @@ export function cancelRelay(id, deps = {}) {
                 : `${jobLabelText(cfg.job)} is no longer running this relay; nothing to stop`,
     ];
     updateConfig(match.dir, { cancelled: true, status: "CANCELLED", cancelledAt: now() });
+    if (cfg.leaseKey && releaseLeaseKey(deps.store ?? createStateStore({ env }), cfg.leaseKey, cfg.id)) {
+        actions.push(`released the pane lease for ${cfg.to}`);
+    }
     scrubRelayToken(match.dir);
     actions.push(`${id} marked CANCELLED (nothing pasted)`);
     return { id, cancelled: true, state: "cancelled", reason: `cancelled relay ${id}`, actions };

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPane
 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 LogEntry, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
+export { createStateStore, defaultStateDir, type LeaseRecord, type LogEntry, 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 { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, type Policy, } from "./policy.js";
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, type IpcDiscoveryState, type SshExecFn, type SshTarget, } from "./exec.js";
@@ -23,7 +24,7 @@ export { parseTabList, resolveTab, type ZellijTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";
 export { classify, lastLine, mapPool, peerStatus, DEFAULT_STATUS_TIMEOUT_MS, STATUS_DUMP_CONCURRENCY, type PeerState, } from "./ops/status.js";
-export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
+export { normalizeScreen, unfoldScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
 export type { RoutingContext } from "./ops/routing.js";
 export type { DispatchDeps, OpsResult, ServeInstallDeps } from "./ops/types.js";
 export { DEFAULT_DOCTOR_TIMEOUT_MS, DOCTOR_FAILED_CODE, DOCTOR_SCOPE_FIELD, DOCTOR_SCOPE_HOST, DOCTOR_TAILSCALE_MAX_MS, HOST_REPORT_INCOMPLETE_CODE, HOST_REPORT_INVALID_CODE, doctorOp, inspectDoctorHost, coverHostReport, hostDoctorRequest, isRequiredFailure, mergeHostReply, type DoctorCheck, type DoctorCheckScope, type DoctorCheckState, type DoctorReport, type DoctorRoute, type HostInspectInput, } from "./ops/doctor.js";

package/dist/index.js

@@ -10,6 +10,7 @@ export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply
 export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, } from "./ops/bus.js";
 export { createZellijClient, } 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";
 export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./policy.js";
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, } from "./exec.js";
@@ -23,7 +24,7 @@ export { parseTabList, resolveTab } from "./zellij/tabs.js";
 export { selectTargets } from "./ops/broadcast.js";
 export { diffScreens, cursorKey } from "./ops/tail.js";
 export { classify, lastLine, mapPool, peerStatus, DEFAULT_STATUS_TIMEOUT_MS, STATUS_DUMP_CONCURRENCY, } from "./ops/status.js";
-export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
+export { normalizeScreen, unfoldScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
 export { DEFAULT_DOCTOR_TIMEOUT_MS, DOCTOR_FAILED_CODE, DOCTOR_SCOPE_FIELD, DOCTOR_SCOPE_HOST, DOCTOR_TAILSCALE_MAX_MS, HOST_REPORT_INCOMPLETE_CODE, HOST_REPORT_INVALID_CODE, doctorOp, inspectDoctorHost, coverHostReport, hostDoctorRequest, isRequiredFailure, mergeHostReply, } from "./ops/doctor.js";
 export { normalizeKey, normalizeKeys, tokenizeCommand } from "./keys.js";
 export { cliUsage, mcpInputSchema, parseCliArgv, MCP_TOOL_DESCRIPTION, OP_NAMES, PARAMS, TARGET_OPS, } from "./schema.js";

package/dist/ops/dispatch.js

@@ -1,5 +1,7 @@
 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";
@@ -20,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";
@@ -110,11 +112,13 @@ async function resolveTarget(client, args, state, clock, env, policy, op, signal
         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. */ }
     }
@@ -160,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, firstCallMs, timeoutMs };
+    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 ?? "");
@@ -341,6 +386,23 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 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),
@@ -428,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: {

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

@@ -399,6 +399,12 @@ export const PARAMS = [
         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",
         type: "string",

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

@@ -59,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

@@ -209,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) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/core",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {