@zswarm/core 0.2.2 → 0.2.3

package/dist/ops/delivery.js

@@ -1,5 +1,35 @@
-import { resolveHarness } from "../harness.js";
+import { queuedPrompt, resolveHarness } from "../harness.js";
 import { isTrue, numberArg } from "./util.js";
+/** Fixed send windows before adaptive scaling; explicit flags always win. */
+export const SEND_BUDGETS = {
+    /** Pause before checking the paste landed. */
+    settleMs: 300,
+    /** Pane-lookup retry window for an absent pane. */
+    observeMs: 1_000,
+    /** The scaled window never exceeds this multiple of the default. */
+    maxScale: 5,
+    /** A first Zellij call at or under this many ms is not "slow". */
+    slowMs: 1_000,
+    settleMaxMs: 5_000,
+    observeMaxMs: 30_000,
+};
+/**
+ * Scale the fixed settle/observe windows by how slow the send's first Zellij
+ * call was. A call under `slowMs` keeps the defaults; five seconds or more pins
+ * the 5x cap. Explicit `--settle-ms` / `--observe-ms` are returned as given,
+ * and a scaled value is capped by the call's own timeout so it cannot outlast
+ * the observation budget.
+ */
+export function scaleBudgets(input) {
+    const raw = input.firstCallMs > SEND_BUDGETS.slowMs ? input.firstCallMs / SEND_BUDGETS.slowMs : 1;
+    const scale = Math.min(SEND_BUDGETS.maxScale, Math.max(1, raw));
+    const scaled = (base, hardMax) => Math.max(1, Math.floor(Math.min(base * scale, hardMax, input.timeoutMs)));
+    return {
+        settleMs: input.settleMs !== undefined ? Math.min(input.settleMs, SEND_BUDGETS.settleMaxMs) : scaled(SEND_BUDGETS.settleMs, SEND_BUDGETS.settleMaxMs),
+        observeMs: input.observeMs !== undefined ? Math.min(input.observeMs, SEND_BUDGETS.observeMaxMs) : scaled(SEND_BUDGETS.observeMs, SEND_BUDGETS.observeMaxMs),
+        scale,
+    };
+}
 /** Cursor / Claude leave this in scrollback after a successful submit. */
 const PASTE_MARKER = "[Pasted text";
 const SENDER_LABEL_MAX = 48;
@@ -78,44 +108,71 @@ function nonEmptyLines(screen) {
         .map((line) => line.replace(/\s+$/, ""))
         .filter((line) => line.length > 0);
 }
+/** All whitespace removed, so a body match survives a pane's line wrapping. */
+function withoutSpaces(text) {
+    return text.replace(/\s+/g, "");
+}
+/** True when `needle` appears in `text`, ignoring whitespace (wrapped panes). */
+function containsNeedle(text, needle) {
+    const wanted = withoutSpaces(needle);
+    return wanted.length > 0 && withoutSpaces(text).includes(wanted);
+}
+const ZSWARM_HEADER = /^\[zswarm from=/i;
+/**
+ * The body text to look for on screen: its first non-empty line, trimmed to 40
+ * chars. A prefix of the whole body (`body.slice(0, 40)`) can span a newline and
+ * then never matches any single screen line. A leading `[zswarm from=…]` header
+ * is skipped so we look for the caller's own first line.
+ */
+export function bodyNeedle(body) {
+    const lines = body
+        .replace(/\r/g, "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const first = lines.length > 0 && ZSWARM_HEADER.test(lines[0]) ? lines[1] : lines[0];
+    return (first ?? "").slice(0, 40);
+}
 function isPasteLine(line, needle) {
     if (line.includes(PASTE_MARKER))
         return true;
-    return needle.length > 0 && line.includes(needle);
+    return containsNeedle(line, needle);
 }
 /** True when the paste still sits in the composer (bottom of the screen). */
 export function composerHolds(screen, body) {
-    const needle = body.slice(0, 40);
+    const needle = bodyNeedle(body);
     const lines = nonEmptyLines(screen);
     const last3 = lines.slice(-3);
     const last = lines[lines.length - 1] ?? "";
     if (last.includes(PASTE_MARKER))
         return true;
-    return needle.length > 0 && last3.some((line) => line.includes(needle));
+    return containsNeedle(last3.join("\n"), needle);
 }
 /**
  * Compare the pane before vs after the paste.
  * Composer clearing (pasted text left the bottom input region) is submission.
  * `[Pasted text` in scrollback is not evidence.
+ *
+ * `not-delivered` is deliberately conservative: only when the screen is
+ * unchanged once the paste/composer itself is discounted and nothing is queued.
+ * A screen that changed while the body is gone is `unverified` — the pane may
+ * have taken the message and scrolled it away, and a false `not-delivered`
+ * makes the caller resend the whole message.
  */
-export function classifySubmit(before, after, body) {
-    const needle = body.slice(0, 40);
+export function classifySubmit(before, after, body, opts = {}) {
+    const needle = bodyNeedle(body);
     const beforeLines = nonEmptyLines(before);
     const afterLines = nonEmptyLines(after);
     const beforeNorm = beforeLines.join("\n");
-    const afterNorm = afterLines.join("\n");
     const last3 = afterLines.slice(-3);
     const last = afterLines[afterLines.length - 1] ?? "";
     const markerInLastLine = last.includes(PASTE_MARKER);
-    const bodyInLastRegion = needle.length > 0 && last3.some((line) => line.includes(needle));
+    const bodyInLastRegion = containsNeedle(last3.join("\n"), needle);
     const holds = bodyInLastRegion || markerInLastLine;
-    if (afterNorm === beforeNorm) {
-        // Marker may only count when it sits in the last-line region *and*
-        // nothing else moved — leftover scrollback must not flip the answer.
-        if (markerInLastLine)
-            return false;
-        return "unverified";
-    }
+    // The harness says it accepted the paste but queued it behind a running turn.
+    if (opts.queued?.(after))
+        return "queued";
+    // The paste is still in the composer: not submitted (Enter may rescue it).
     if (holds) {
         const withoutPaste = afterLines.filter((line) => !isPasteLine(line, needle));
         if (withoutPaste.join("\n") === beforeNorm)
@@ -128,9 +185,15 @@ export function classifySubmit(before, after, body) {
         return belowNovel.length > 0 ? true : false;
     }
     // Paste left the input region: still on screen, just not at the bottom.
-    if (needle.length > 0 && afterLines.some((line) => line.includes(needle))) {
+    if (containsNeedle(after, needle))
         return true;
-    }
+    // Nothing moved apart from the paste/composer itself and nothing is queued:
+    // positive evidence the paste never reached the pane, so a resend is safe.
+    const beforeApart = beforeLines.filter((line) => !isPasteLine(line, needle));
+    const afterApart = afterLines.filter((line) => !isPasteLine(line, needle));
+    if (afterApart.join("\n") === beforeApart.join("\n"))
+        return "not-delivered";
+    // The screen changed while the body is not visible: inconclusive, never a resend.
     return "unverified";
 }
 async function dumpOrNull(client, session, paneId) {
@@ -142,7 +205,8 @@ async function dumpOrNull(client, session, paneId) {
     }
 }
 async function verifySubmit(client, input) {
-    const { session, paneId, body, mode, settleMs, clock, before } = input;
+    const { session, paneId, body, mode, settleMs, clock, before, queued } = input;
+    const classify = (base, screen) => classifySubmit(base, screen, body, { queued });
     if (mode === "none")
         return "unverified";
     if (mode === "double-enter") {
@@ -156,47 +220,57 @@ async function verifySubmit(client, input) {
     const after = await dumpOrNull(client, session, paneId);
     if (after === null)
         return "unverified";
-    let verdict = classifySubmit(before, after, body);
-    if (verdict === true)
-        return true;
+    let verdict = classify(before, after);
+    if (verdict === true || verdict === "queued")
+        return verdict;
     if (verdict === false) {
         await client.sendKeys({ session, paneId, keys: ["Enter"] });
         await clock.sleep(settleMs);
         const rescued = await dumpOrNull(client, session, paneId);
         if (rescued === null)
             return "unverified";
-        verdict = classifySubmit(before, rescued, body);
-        if (verdict === true)
-            return true;
+        verdict = classify(before, rescued);
+        if (verdict === true || verdict === "queued")
+            return verdict;
         if (verdict === false)
             return false;
     }
-    // First look was inconclusive; TUIs often redraw after the first settle.
+    // Inconclusive or not (yet) on screen; TUIs often redraw after the first settle.
     await clock.sleep(Math.min(Math.max(settleMs * 2, 800), 5000));
     const later = await dumpOrNull(client, session, paneId);
     if (later === null)
-        return "unverified";
+        return verdict;
     if (composerHolds(after, body) && !composerHolds(later, body))
         return true;
-    return classifySubmit(before, later, body);
+    return classify(before, later);
 }
 /** Paste a body into one pane and record the attempt. */
 export async function deliverTo(client, state, args, input) {
-    const { session, pane, body, op, at, clock } = input;
+    const { session, pane, body, op, at, clock, firstCallMs = 0, timeoutMs = 30_000 } = input;
     const from = senderLabel(args);
     const mode = resolveSubmitMode(args, pane);
-    const settleMs = numberArg(args, "settleMs", 300, { min: 50, max: 5000 });
+    const profile = resolveHarness(pane);
+    const queued = (screen) => queuedPrompt(screen, profile);
+    const explicitSettle = args.settleMs !== undefined && args.settleMs !== null && args.settleMs !== "";
+    const budgets = scaleBudgets({
+        firstCallMs,
+        timeoutMs,
+        settleMs: explicitSettle ? numberArg(args, "settleMs", SEND_BUDGETS.settleMs, { min: 50, max: SEND_BUDGETS.settleMaxMs }) : undefined,
+    });
+    const settleMs = budgets.settleMs;
+    const confirmOnce = isTrue(args.confirm);
     try {
         let before = null;
         if (mode === "auto") {
             before = await dumpOrNull(client, session, pane.id);
         }
-        const delivered = await client.injectPane({
+        const paste = () => client.injectPane({
             session,
             paneId: pane.id,
             text: bodyText(client, args, body),
         });
-        const submitted = await verifySubmit(client, {
+        let delivered = await paste();
+        let submitted = await verifySubmit(client, {
             session,
             paneId: delivered.paneId,
             body,
@@ -204,7 +278,64 @@ export async function deliverTo(client, state, args, input) {
             settleMs,
             clock,
             before,
+            queued,
         });
+        // Opt-in confirm. A second paste is only safe on positive evidence the
+        // first never landed; a still-held composer gets Enter, and unverified just
+        // looks again. Never paste the body twice.
+        if (confirmOnce && mode === "auto" && submitted !== true && submitted !== "queued") {
+            if (submitted === "not-delivered") {
+                const retryBefore = await dumpOrNull(client, session, delivered.paneId);
+                delivered = await paste();
+                submitted = await verifySubmit(client, {
+                    session,
+                    paneId: delivered.paneId,
+                    body,
+                    mode,
+                    settleMs,
+                    clock,
+                    before: retryBefore,
+                    queued,
+                });
+            }
+            else if (submitted === false) {
+                // The paste is still in the composer: press Enter, never paste again.
+                await client.sendKeys({ session, paneId: delivered.paneId, keys: ["Enter"] });
+                const seen = await dumpOrNull(client, session, delivered.paneId);
+                if (seen !== null && before !== null) {
+                    submitted = classifySubmit(before, seen, body, { queued });
+                }
+            }
+            else {
+                // unverified: one more dump to report what is actually on screen.
+                const seen = await dumpOrNull(client, session, delivered.paneId);
+                if (seen !== null && before !== null) {
+                    submitted = classifySubmit(before, seen, body, { queued });
+                }
+            }
+        }
+        if (submitted === "not-delivered") {
+            state.appendLog({
+                at,
+                op,
+                session,
+                to: delivered.paneId,
+                from,
+                bytes: body.length,
+                ok: false,
+                detail: "submitted=not-delivered",
+            });
+            return {
+                to: delivered.paneId,
+                ok: false,
+                delivery: "zellij_paste",
+                submitted,
+                error: {
+                    code: "not_delivered",
+                    message: "the pane was unchanged apart from the composer after the send; the body never landed, so a resend is safe",
+                },
+            };
+        }
         state.appendLog({
             at,
             op,

package/dist/ops/dispatch.js

@@ -2,6 +2,7 @@ import { ZellijError } from "../errors.js";
 import { createGitClient } from "../git.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 +10,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";
@@ -100,7 +101,9 @@ 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", {
@@ -121,13 +124,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 +160,7 @@ 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, firstCallMs, timeoutMs };
 }
 async function dispatchOperation(args, injected, deps, context, env) {
     const op = String(args.op ?? "");
@@ -275,15 +290,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,7 +338,7 @@ 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);
                 const labeled = withSenderLabel(args, {
@@ -327,6 +352,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);
@@ -591,6 +618,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/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,25 @@ 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: "expect",

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;

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)));
@@ -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/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.
  *

package/dist/zellij/session.js

@@ -13,6 +13,34 @@ export function resolveSelfPaneId(env = process.env) {
         return raw.toLowerCase();
     return null;
 }
+const AGE_UNITS = [
+    [/^years?$|^yrs?$|^y$/, 31_536_000],
+    [/^months?$|^mons?$|^mo$/, 2_592_000],
+    [/^days?$|^d$/, 86_400],
+    [/^hours?$|^hrs?$|^h$/, 3_600],
+    [/^minutes?$|^mins?$|^m$/, 60],
+    [/^seconds?$|^secs?$|^s$/, 1],
+];
+/**
+ * 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 function parseCreatedAge(text) {
+    const re = /(\d+)\s*(years?|yrs?|y|months?|mons?|mo|days?|d|hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)/g;
+    let total = 0;
+    let found = false;
+    for (const match of String(text).toLowerCase().matchAll(re)) {
+        const unit = match[2];
+        const seconds = AGE_UNITS.find(([pattern]) => pattern.test(unit))?.[1];
+        if (seconds === undefined)
+            continue;
+        total += Number(match[1]) * seconds;
+        found = true;
+    }
+    return found ? total : null;
+}
 /**
  * Parse `list-sessions --no-formatting` output.
  *
@@ -21,9 +49,9 @@ export function resolveSelfPaneId(env = process.env) {
  */
 export function parseSessionList(stdout) {
     const sessions = [];
-    for (const raw of stdout.split(/\r?\n/)) {
+    for (const entry of stdout.split(/\r?\n/)) {
         // Drop ANSI in case a caller forgot --no-formatting.
-        const line = raw.replace(/\x1B\[[0-9;]*m/g, "").trim();
+        const line = entry.replace(/\x1B\[[0-9;]*m/g, "").trim();
         if (!line)
             continue;
         const created = line.indexOf(" [Created ");
@@ -32,15 +60,19 @@ export function parseSessionList(stdout) {
             if (!name)
                 continue;
             const suffix = line.slice(created);
+            const raw = (/\[Created ([^\]]*)\]/.exec(suffix)?.[1] ?? "").trim();
+            const age = raw ? raw.replace(/\s*ago\s*$/i, "").trim() || null : null;
             sessions.push({
                 name,
                 exited: /\(EXITED\b/i.test(suffix),
                 current: /\(current\)/i.test(suffix),
+                age,
+                ageSeconds: raw ? parseCreatedAge(raw) : null,
             });
             continue;
         }
         // Bare name from --short or a mock.
-        sessions.push({ name: line, exited: false, current: false });
+        sessions.push({ name: line, exited: false, current: false, age: null, ageSeconds: null });
     }
     return sessions;
 }

package/package.json

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