@zswarm/core 0.2.6 → 0.2.7

package/dist/harness.d.ts

@@ -1,6 +1,17 @@
 export type SubmitStrategy = "auto" | "double-enter";
+/**
+ * How to ask a harness to quit its own UI. A slash command is typed and
+ * submitted; keys are sent raw. `null` means the restart op falls back to
+ * Ctrl+C instead of guessing.
+ */
+export type HarnessExitRecipe = {
+    /** A command line to type into the harness composer, e.g. "/exit". */
+    command?: string;
+    /** Raw keys to send, e.g. ["Ctrl c"]. */
+    keys?: readonly string[];
+};
 export type HarnessProfile = {
-    /** Stable id: "codex" | "cursor" | "opencode" | "gemini" | "pi" | "unknown" */
+    /** Stable id: "codex" | "cursor" | "opencode" | "gemini" | "pi" | "claude" | "unknown" */
     name: string;
     /** What `send` should do when the caller did not pass submit= explicitly. */
     submit: SubmitStrategy;
@@ -19,6 +30,12 @@ export type HarnessProfile = {
      * these against the trailing lines to avoid treating a busy pane as idle.
      */
     busy: readonly RegExp[];
+    /** Program to type in a shell pane to relaunch this harness; null when unknown. */
+    launch: string | null;
+    /** How to ask the harness to quit; null falls back to Ctrl+C. */
+    exit: HarnessExitRecipe | null;
+    /** Trailing lines showing the harness finished starting and is ready for input. */
+    ready: readonly RegExp[];
 };
 /**
  * Identify the harness from a pane's command and title, case-insensitively.
@@ -35,7 +52,15 @@ export declare function resolveHarness(pane: {
  */
 export declare function queuedPrompt(screen: string, profile: HarnessProfile): boolean;
 /**
- * Does this screen's trailing lines show the harness actively working? Only
+ * The busy marker regex a screen shows on its trailing lines, or null. Only
  * the last few lines count: a quoted marker in scrollback is not a live turn.
  */
+export declare function busyMarker(screen: string, profile: HarnessProfile): RegExp | null;
+/** Does this screen's trailing lines show the harness actively working? */
 export declare function busyPrompt(screen: string, profile: HarnessProfile): boolean;
+/**
+ * Does this screen's trailing lines show the harness ready for input? An empty
+ * ready set is unknown, never a match: a profile that never declared a marker
+ * must not make the restart op wait forever.
+ */
+export declare function readyPrompt(screen: string, profile: HarnessProfile): boolean;

package/dist/harness.js

@@ -5,6 +5,7 @@ const PROFILES = [
     { name: "opencode", command: ["opencode"], title: ["agent-opencode"] },
     { name: "gemini", command: ["agy", "gemini"], title: ["agent-gemini"] },
     { name: "pi", command: ["pi"], title: ["agent-pi"] },
+    { name: "claude", command: ["claude"], title: ["agent-claude"] },
 ];
 /**
  * Only codex needs a second Enter to submit: its composer keeps the pasted
@@ -17,6 +18,7 @@ const SUBMIT = {
     opencode: "auto",
     gemini: "auto",
     pi: "auto",
+    claude: "auto",
 };
 /**
  * Prompt shapes any CLI can show, so every profile carries these as a base.
@@ -50,6 +52,7 @@ const WAITING = {
         /Accept this file edit\?/i,
     ],
     pi: GENERIC_WAITING,
+    claude: [...GENERIC_WAITING, /Do you want to (?:proceed|continue)\?/i],
 };
 /**
  * Queued-message hints seen live. Claude Code prints
@@ -68,6 +71,7 @@ const QUEUED = {
     opencode: GENERIC_QUEUED,
     gemini: GENERIC_QUEUED,
     pi: GENERIC_QUEUED,
+    claude: GENERIC_QUEUED,
 };
 /**
  * Busy (working) markers seen live. OpenCode draws a progress bar of filled
@@ -80,6 +84,47 @@ const BUSY = {
     opencode: [/[■⬝]{4,}/],
     gemini: [],
     pi: [],
+    claude: [/esc to interrupt/i],
+};
+/**
+ * Program to type in a shell pane to start this harness. The first entry of the
+ * harness's command needle is the executable a shell would accept.
+ */
+const LAUNCH = {
+    codex: "codex",
+    cursor: "cursor-agent",
+    opencode: "opencode",
+    gemini: "agy",
+    pi: "pi",
+    claude: "claude",
+};
+/**
+ * How to ask a harness to quit its own UI. `/exit` is documented for OpenCode
+ * and Claude Code; the rest have no equally reliable in-band quit, so they carry
+ * `null` and the restart op falls back to Ctrl+C (twice) after a bounded wait.
+ */
+const EXIT = {
+    codex: null,
+    cursor: null,
+    opencode: { command: "/exit" },
+    gemini: null,
+    pi: null,
+    claude: { command: "/exit" },
+};
+/**
+ * A trailing line that means the harness finished starting and accepts input.
+ * OpenCode's idle screen pins its composer placeholder ("Ask anything…") and
+ * footer ("ctrl+p commands"); Claude Code pins "? for shortcuts". The profiles
+ * whose composer is not known well enough carry `[]`, and the restart op then
+ * falls back to waiting for the screen to settle instead of guessing.
+ */
+const READY = {
+    codex: [],
+    cursor: [],
+    opencode: [/ask anything/i, /ctrl\+p commands/i],
+    gemini: [],
+    pi: [],
+    claude: [/\? for shortcuts/i, /bypass permissions on/i],
 };
 const UNKNOWN = {
     name: "unknown",
@@ -87,6 +132,9 @@ const UNKNOWN = {
     waiting: GENERIC_WAITING,
     queued: GENERIC_QUEUED,
     busy: [/esc to interrupt/i],
+    launch: null,
+    exit: null,
+    ready: [],
 };
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -137,6 +185,9 @@ export function resolveHarness(pane) {
         waiting: WAITING[name],
         queued: QUEUED[name],
         busy: BUSY[name],
+        launch: LAUNCH[name],
+        exit: EXIT[name],
+        ready: READY[name],
     };
 }
 /**
@@ -148,12 +199,27 @@ export function queuedPrompt(screen, profile) {
     return profile.queued.some((re) => lines.some((line) => re.test(line)));
 }
 /**
- * Does this screen's trailing lines show the harness actively working? Only
+ * The busy marker regex a screen shows on its trailing lines, or null. Only
  * the last few lines count: a quoted marker in scrollback is not a live turn.
  */
+export function busyMarker(screen, profile) {
+    const lines = trailingLines(screen);
+    return profile.busy.find((re) => lines.some((line) => re.test(line))) ?? null;
+}
+/** Does this screen's trailing lines show the harness actively working? */
 export function busyPrompt(screen, profile) {
+    return busyMarker(screen, profile) !== null;
+}
+/**
+ * Does this screen's trailing lines show the harness ready for input? An empty
+ * ready set is unknown, never a match: a profile that never declared a marker
+ * must not make the restart op wait forever.
+ */
+export function readyPrompt(screen, profile) {
+    if (profile.ready.length === 0)
+        return false;
     const lines = trailingLines(screen);
-    return profile.busy.some((re) => lines.some((line) => re.test(line)));
+    return profile.ready.some((re) => lines.some((line) => re.test(line)));
 }
 /** The six last non-empty, right-trimmed lines of a screen, CR stripped. */
 function trailingLines(screen) {

package/dist/host/cli.js

@@ -114,7 +114,7 @@ function leaseTable(leases) {
     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", "--leases", "--cancel-all", "--json", "--queue", "--force"]);
+    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--leases", "--cancel-all", "--json", "--queue", "--force", "--if-idle"]);
     const run = str(flags["--run"]);
     if (run)
         return runRelayDir(run);
@@ -182,6 +182,7 @@ async function relay(argv) {
         foreground: flags["--foreground"] === true,
         queue: flags["--queue"] === true,
         force: flags["--force"] === true,
+        ifIdle: flags["--if-idle"] === true,
     }));
 }
 async function host(argv) {
@@ -245,12 +246,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] [--queue] [--force] [--foreground]",
+            "             [--timeout-min 240] [--max-age MIN] [--queue] [--force] [--foreground] [--if-idle]",
             "      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",
             "      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",
+            "      --if-idle applies send's busy check before the lease: a harness that shows it is working fails pane_busy",
+            "      without sending; --queue then waits for the pane to go idle as well as for the lease, and --force skips the check",
             "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",

package/dist/host/relay.d.ts

@@ -108,6 +108,8 @@ export type RelayStartInput = {
     queue?: boolean;
     /** Send to a leased pane anyway; the lease is shared and noted. */
     force?: boolean;
+    /** With --if-idle, check the target harness before the lease: a visibly working pane fails pane_busy. */
+    ifIdle?: boolean;
     env?: NodeJS.ProcessEnv;
     deps?: RelayDeps;
     /** State store for the pane lease; injected in tests. */

package/dist/host/relay.js

@@ -2,7 +2,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { appendFileSync, chmodSync, copyFileSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { ZellijError } from "../errors.js";
-import { dispatchZswarm } from "../ops/dispatch.js";
+import { dispatchZswarm, paneBusyMarker } from "../ops/dispatch.js";
 import { resolveServeCliLaunch } from "../ops/serve-install.js";
 import { createStateStore, defaultStateDir } from "../state.js";
 import { findLease, leaseKey, releaseLeaseKey, takeLease } from "./lease.js";
@@ -404,15 +404,69 @@ export async function startRelay(input) {
     let how;
     const leaseNow = input.deps?.now ?? Date.now;
     const leaseSleep = input.deps?.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    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 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) {
+    /** The pane --to names, with the command/title the harness check needs. */
+    const resolveRemotePane = async () => {
+        const args = { op: "list" };
+        if (cfg.session)
+            args.session = cfg.session;
+        const res = await call(args, remote).catch((err) => ({ ok: false, error: { code: "failed", message: String(err) } }));
+        const panes = res.ok
+            ? res.data.panes ?? []
+            : [];
+        const pane = panes.find((p) => p.title === cfg.to || p.id === cfg.to);
+        return pane ? { command: pane.command, title: pane.title } : { title: cfg.to };
+    };
+    // --if-idle: the same busy check send --if-idle uses, one dump before the
+    // lease is taken. --force skips it, as it skips the lease.
+    const checkIdle = input.ifIdle === true && input.force !== true;
+    const idlePane = checkIdle ? await resolveRemotePane() : undefined;
+    /** The harness working marker one dump of the target shows, or null. */
+    const busyMarkerNow = async () => {
+        const res = await call(target({ op: "dump", to: cfg.to, max: 400 }), remote).catch((err) => ({ ok: false, error: { code: "failed", message: String(err) } }));
+        if (!res.ok)
+            return null; // cannot see the screen: the lease is the only guard
+        return paneBusyMarker(String(res.data?.text ?? ""), idlePane ?? { title: cfg.to });
+    };
+    const deadline = leaseNow() + cfg.timeoutMin * 60_000;
+    let busy = null;
+    let taken;
+    if (!input.queue) {
+        if (checkIdle) {
+            busy = await busyMarkerNow();
+            if (busy) {
+                rmSync(dir, { recursive: true, force: true });
+                throw new ZellijError("pane_busy", `pane ${cfg.to} is busy with a task (marker: ${busy}); retry when it is idle`);
+            }
+        }
+        taken = take();
+    }
+    else {
+        // --queue polls the lease and, under --if-idle, the busy marker. The lease
+        // is only taken once the pane is not visibly working.
+        let attempt;
+        for (;;) {
+            if (checkIdle)
+                busy = await busyMarkerNow();
+            attempt = busy ? undefined : take();
+            if (attempt?.ok)
+                break;
+            if (leaseNow() >= deadline)
+                break;
             await leaseSleep(Math.min(LEASE_QUEUE_POLL_MS, Math.max(1, deadline - leaseNow())));
-            taken = take();
         }
+        if (attempt?.ok)
+            taken = attempt;
+        else if (busy) {
+            rmSync(dir, { recursive: true, force: true });
+            throw new ZellijError("pane_busy", `pane ${cfg.to} is busy with a task (marker: ${busy}) and did not free before --timeout-min`);
+        }
+        else
+            taken = attempt ?? take();
     }
     if (!taken.ok) {
         rmSync(dir, { recursive: true, force: true });
@@ -423,9 +477,6 @@ export async function startRelay(input) {
     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);

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export { createZellijClient, type ZellijClient, type ZellijClientOptions, type Z
 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 { EXIT_WAIT_MS, HANDOFF_INLINE_MAX, HANDOFF_MARKER, HANDOFF_SELF_WAIT_MS, READY_SETTLE_MS, READY_STABLE_GAP_MS, READY_WAIT_MS, restartLaunchCommand, restartPane, restartPaneKind, type RestartPaneKind, type RestartStep, } from "./ops/restart.js";
+export { busyPrompt, queuedPrompt, readyPrompt, resolveHarness, type HarnessExitRecipe, type HarnessProfile, type SubmitStrategy, } from "./harness.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";
 export { resolveSshTarget } from "./zellij/binary.js";

package/dist/index.js

@@ -12,6 +12,8 @@ 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 { EXIT_WAIT_MS, HANDOFF_INLINE_MAX, HANDOFF_MARKER, HANDOFF_SELF_WAIT_MS, READY_SETTLE_MS, READY_STABLE_GAP_MS, READY_WAIT_MS, restartLaunchCommand, restartPane, restartPaneKind, } from "./ops/restart.js";
+export { busyPrompt, queuedPrompt, readyPrompt, resolveHarness, } from "./harness.js";
 export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./policy.js";
 export { buildSshRemoteCommand, createSshExec, quoteRemoteArg, shellQuote, } from "./exec.js";
 export { resolveSshTarget } from "./zellij/binary.js";

package/dist/ops/dispatch.d.ts

@@ -1,5 +1,14 @@
 import { type ZellijClient } from "../zellij/client.js";
 import type { DispatchDeps, OpsResult } from "./types.js";
+/**
+ * The harness busy marker a dumped screen shows for `pane`, or null. The one
+ * busy check behind `send --if-idle` and `relay --if-idle`; the marker names
+ * itself (its regex source) in the `pane_busy` error.
+ */
+export declare function paneBusyMarker(screen: string, pane: {
+    command?: string | null;
+    title?: string | null;
+}): string | null;
 /**
  * Per-invocation routing from `--local` / `--ssh`. `--local` clears both SSH
  * and serve (and remote IPC). `--ssh` sets the destination for this call and

package/dist/ops/dispatch.js

@@ -1,6 +1,6 @@
 import { ZellijError } from "../errors.js";
 import { createGitClient } from "../git.js";
-import { busyPrompt, resolveHarness } from "../harness.js";
+import { busyMarker, resolveHarness } from "../harness.js";
 import { findLease } from "../host/lease.js";
 import { normalizeKeys } from "../keys.js";
 import { createZellijClient } from "../zellij/client.js";
@@ -16,6 +16,7 @@ import { attachKnownSender, deliverTo, scaleBudgets, withSenderLabel, selfPaneTi
 import { assertNotPlugin, assertNotSelf, assertExpectedScreen, assertWritable, } from "./guards.js";
 import { readDeliveryLog } from "./log.js";
 import { awaitSignal, listSignals, postSignal } from "./signals.js";
+import { restartPane } from "./restart.js";
 import { spawnPane } from "./spawn.js";
 import { observationBudget } from "./observation.js";
 import { invocationContext } from "./routing.js";
@@ -30,6 +31,14 @@ import { serveCallTimeout, } from "./serve.js";
 import { doctorOp } from "./doctor.js";
 import { forwardServe } from "./serve-tunnel.js";
 import { installServeService, uninstallServeService } from "../host/serve-service.js";
+/**
+ * The harness busy marker a dumped screen shows for `pane`, or null. The one
+ * busy check behind `send --if-idle` and `relay --if-idle`; the marker names
+ * itself (its regex source) in the `pane_busy` error.
+ */
+export function paneBusyMarker(screen, pane) {
+    return busyMarker(screen, resolveHarness(pane))?.source ?? null;
+}
 /**
  * Per-invocation routing from `--local` / `--ssh`. `--local` clears both SSH
  * and serve (and remote IPC). `--ssh` sets the destination for this call and
@@ -270,6 +279,9 @@ async function dispatchOperation(args, injected, deps, context, env) {
             if (isTrue(args.clear)) {
                 const cleared = await uninstallServeLogon({
                     platform: deps.serveInstall?.platform ?? process.platform,
+                    // --session names the task to clear: its own per-session task, or the
+                    // legacy root task only when that task records the same session.
+                    session: optionalString(args.session),
                     timeoutMs,
                     signal,
                     env,
@@ -399,8 +411,11 @@ async function dispatchOperation(args, injected, deps, context, env) {
                         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`);
+                    if (screen !== null) {
+                        const marker = paneBusyMarker(screen, pane);
+                        if (marker) {
+                            throw new ZellijError("pane_busy", `pane ${to} is busy with a task (marker: ${marker}); retry when it is idle`);
+                        }
                     }
                 }
                 const labeled = withSenderLabel(args, {
@@ -652,6 +667,13 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 return await peerCheckpoint(git(), args, clock);
             case "spawn":
                 return await spawnPane(client, args, deps.git, clock, signal);
+            case "restart": {
+                const { session, pane, panes } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
+                return await restartPane(client, state(), args, { session, pane, panes }, clock, {
+                    env,
+                    signal,
+                });
+            }
             case "worktrees":
                 return await listPeerWorktrees(git(), client, args);
             case "unworktree":

package/dist/ops/restart.d.ts

@@ -0,0 +1,57 @@
+import { type HarnessProfile } from "../harness.js";
+import type { StateStore } from "../state.js";
+import type { ZellijClient } from "../zellij/client.js";
+import type { ZellijPane } from "../zellij/panes.js";
+import type { Clock, OpsResult } from "./types.js";
+/**
+ * Restart the agent in one pane, in place: same pane id, title and position.
+ *
+ * A Zellij command pane (a `command=` layout entry or `zellij run`) stays open
+ * when its command exits and offers ENTER to re-run the same command — that is
+ * the in-place relaunch. A shell pane has no such prompt, so the profile's
+ * launch command (or `--command`) is typed instead.
+ */
+/** The agent prints this once its handoff file is written. */
+export declare const HANDOFF_MARKER = "ZSWARM-HANDOFF-DONE";
+/** A handoff at or under this many chars is pasted; longer ones get a pointer. */
+export declare const HANDOFF_INLINE_MAX = 2000;
+/** Bound on waiting for a self-written handoff marker. */
+export declare const HANDOFF_SELF_WAIT_MS = 60000;
+/** Bound on waiting for the pane's command to exit before the Ctrl+C fallback. */
+export declare const EXIT_WAIT_MS = 10000;
+/** Bound on waiting for readiness after relaunch (marker or settled screen). */
+export declare const READY_WAIT_MS = 45000;
+/** Extra settle after a ready marker before the handoff is pasted. */
+export declare const READY_SETTLE_MS = 500;
+/** A screen that has not changed for this long counts as settled. */
+export declare const READY_STABLE_GAP_MS = 1000;
+/** Screen poll interval while a step waits. */
+export declare const RESTART_POLL_MS = 250;
+export type RestartPaneKind = "command" | "shell";
+export type RestartStep = {
+    step: string;
+    ok: boolean;
+    detail: string;
+    elapsedMs: number;
+};
+/**
+ * A command pane ran the agent itself, so ENTER re-runs it. A shell pane had the
+ * agent started inside a shell, so the launch command has to be typed again.
+ * A pane with no command information is treated as a shell: typing a launch
+ * command is recoverable, pressing ENTER into a live agent is not.
+ */
+export declare function restartPaneKind(pane: ZellijPane): RestartPaneKind;
+/** The command line a shell pane gets to relaunch the agent. */
+export declare function restartLaunchCommand(args: Record<string, unknown>, profile: HarnessProfile): string | null;
+/**
+ * Restart one already-resolved pane. `target` comes from dispatch's
+ * `resolveTarget`, so policy and pane lookup are shared with the other ops.
+ */
+export declare function restartPane(client: ZellijClient, state: StateStore, args: Record<string, unknown>, target: {
+    session: string;
+    pane: ZellijPane;
+    panes: ZellijPane[];
+}, clock: Clock, opts?: {
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+}): Promise<OpsResult>;