@zswarm/core 0.2.6 → 0.2.8

package/dist/ops/delivery.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -20,19 +21,26 @@ export declare const SEND_BUDGETS: {
     readonly settleMs: 300;
     /** Pane-lookup retry window for an absent pane. */
     readonly observeMs: 1000;
+    /**
+     * Base window that polls the pane for positive evidence before any negative
+     * verdict; scaled up for slow panes and capped by `confirmMaxMs`.
+     */
+    readonly confirmMs: 1000;
     /** The scaled window never exceeds this multiple of the default. */
     readonly maxScale: 5;
     /** A first Zellij call at or under this many ms is not "slow". */
     readonly slowMs: 1000;
     readonly settleMaxMs: 5000;
     readonly observeMaxMs: 30000;
+    readonly confirmMaxMs: 15000;
 };
 /**
- * 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.
+ * Scale the fixed settle/observe/confirm 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. `confirmMs` is always scaled (no explicit
+ * flag) and capped by both `confirmMaxMs` and the call timeout.
  */
 export declare function scaleBudgets(input: {
     firstCallMs: number;
@@ -42,6 +50,7 @@ export declare function scaleBudgets(input: {
 }): {
     settleMs: number;
     observeMs: number;
+    confirmMs: number;
     scale: number;
 };
 export type SenderSource = "arg" | "env" | "title" | "default";
@@ -78,7 +87,8 @@ export declare function attachKnownSender(args: Record<string, unknown>, env: No
 export declare function bodyText(client: ZellijClient, args: Record<string, unknown>, body: string): string;
 /**
  * Caller `submit=` always wins. With none given, the pane's harness picks
- * auto vs double-enter (codex needs two Enters; the rest submit on one).
+ * auto vs double-enter (codex needs two Enters; the rest submit on one). An
+ * explicit `--harness` overrides the pane-inferred profile.
  */
 export declare function resolveSubmitMode(args: Record<string, unknown>, pane: {
     command?: string | null;
@@ -107,6 +117,20 @@ export declare function composerHolds(screen: string, body: string): boolean;
 export declare function classifySubmit(before: string, after: string, body: string, opts?: {
     queued?: (screen: string) => boolean;
 }): Submitted;
+/**
+ * Press Enter once and report whether the body submitted, without pasting.
+ * The restart op uses this to re-ask a still-held composer; a failed dump is
+ * unverified, never a negative verdict.
+ */
+export declare function submitAfterEnter(client: ZellijClient, input: {
+    session: string;
+    paneId: string;
+    body: string;
+    before: string;
+    clock: Clock;
+    settleMs: number;
+    profile: HarnessProfile;
+}): Promise<Submitted>;
 /** Paste a body into one pane and record the attempt. */
 export declare function deliverTo(client: ZellijClient, state: StateStore, args: Record<string, unknown>, input: {
     session: string;

package/dist/ops/delivery.js

@@ -1,24 +1,33 @@
-import { queuedPrompt, resolveHarness } from "../harness.js";
-import { isTrue, numberArg } from "./util.js";
+import { busyMarker, queuedPrompt, resolveHarness } from "../harness.js";
+import { isTrue, numberArg, optionalString } 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,
+    /**
+     * Base window that polls the pane for positive evidence before any negative
+     * verdict; scaled up for slow panes and capped by `confirmMaxMs`.
+     */
+    confirmMs: 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,
+    confirmMaxMs: 15_000,
 };
+/** Upper bound on confirm polls, so a pinned deadline cannot spin forever. */
+const MAX_CONFIRM_POLLS = 40;
 /**
- * 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.
+ * Scale the fixed settle/observe/confirm 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. `confirmMs` is always scaled (no explicit
+ * flag) and capped by both `confirmMaxMs` and the call timeout.
  */
 export function scaleBudgets(input) {
     const raw = input.firstCallMs > SEND_BUDGETS.slowMs ? input.firstCallMs / SEND_BUDGETS.slowMs : 1;
@@ -27,6 +36,7 @@ export function scaleBudgets(input) {
     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),
+        confirmMs: scaled(SEND_BUDGETS.confirmMs, SEND_BUDGETS.confirmMaxMs),
         scale,
     };
 }
@@ -91,7 +101,8 @@ export function bodyText(client, args, body) {
 }
 /**
  * Caller `submit=` always wins. With none given, the pane's harness picks
- * auto vs double-enter (codex needs two Enters; the rest submit on one).
+ * auto vs double-enter (codex needs two Enters; the rest submit on one). An
+ * explicit `--harness` overrides the pane-inferred profile.
  */
 export function resolveSubmitMode(args, pane) {
     const raw = args.submit;
@@ -99,7 +110,7 @@ export function resolveSubmitMode(args, pane) {
         return raw;
     if (raw !== undefined && raw !== null && raw !== "")
         return "auto";
-    return resolveHarness(pane).submit;
+    return resolveHarness(pane, optionalString(args.harness)).submit;
 }
 function nonEmptyLines(screen) {
     return screen
@@ -205,7 +216,7 @@ async function dumpOrNull(client, session, paneId) {
     }
 }
 async function verifySubmit(client, input) {
-    const { session, paneId, body, mode, settleMs, clock, before, queued } = input;
+    const { session, paneId, body, mode, settleMs, confirmMs, clock, before, profile, queued } = input;
     const classify = (base, screen) => classifySubmit(base, screen, body, { queued });
     if (mode === "none")
         return "unverified";
@@ -232,24 +243,58 @@ async function verifySubmit(client, input) {
         verdict = classify(before, rescued);
         if (verdict === true || verdict === "queued")
             return verdict;
-        if (verdict === false)
-            return false;
     }
-    // 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 verdict;
-    if (composerHolds(after, body) && !composerHolds(later, body))
-        return true;
-    return classify(before, later);
+    // Nothing conclusive yet: a freshly restarted agent can redraw slowly, so poll
+    // for the whole scaled confirm window before any negative verdict. Positive
+    // evidence is new output, a queue hint, the harness's busy marker, or the body
+    // leaving a composer it was sitting in.
+    const pollMs = Math.min(Math.max(settleMs * 2, 500), 1_000);
+    const deadline = clock.now() + confirmMs;
+    for (let polls = 0; polls < MAX_CONFIRM_POLLS && clock.now() < deadline; polls++) {
+        await clock.sleep(Math.min(pollMs, Math.max(0, deadline - clock.now())));
+        const later = await dumpOrNull(client, session, paneId);
+        if (later === null)
+            continue; // unreadable pane: keep polling
+        const seen = classify(before, later);
+        if (seen === true || seen === "queued")
+            return seen;
+        if (busyMarker(later, profile))
+            return true;
+        if (composerHolds(after, body) && !composerHolds(later, body))
+            return true;
+        verdict = seen;
+    }
+    // An unknown harness has no reliable busy marker, so an unchanged screen is
+    // not proof the body never arrived; a false not-delivered would make the
+    // caller resend the whole message. A known harness's not-delivered is now
+    // backed by the whole window.
+    if (verdict === "not-delivered" && profile.name === "unknown")
+        return "unverified";
+    return verdict;
+}
+/**
+ * Press Enter once and report whether the body submitted, without pasting.
+ * The restart op uses this to re-ask a still-held composer; a failed dump is
+ * unverified, never a negative verdict.
+ */
+export async function submitAfterEnter(client, input) {
+    const { session, paneId, body, before, clock, settleMs, profile } = input;
+    await client.sendKeys({ session, paneId, keys: ["Enter"] });
+    await clock.sleep(settleMs);
+    const screen = await dumpOrNull(client, session, paneId);
+    if (screen === null)
+        return "unverified";
+    return classifySubmit(before, screen, body, {
+        queued: (s) => queuedPrompt(s, profile),
+    });
 }
 /** 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, firstCallMs = 0, timeoutMs = 30_000 } = input;
     const from = senderLabel(args);
+    const override = optionalString(args.harness);
     const mode = resolveSubmitMode(args, pane);
-    const profile = resolveHarness(pane);
+    const profile = resolveHarness(pane, override);
     const queued = (screen) => queuedPrompt(screen, profile);
     const explicitSettle = args.settleMs !== undefined && args.settleMs !== null && args.settleMs !== "";
     const budgets = scaleBudgets({
@@ -258,6 +303,7 @@ export async function deliverTo(client, state, args, input) {
         settleMs: explicitSettle ? numberArg(args, "settleMs", SEND_BUDGETS.settleMs, { min: 50, max: SEND_BUDGETS.settleMaxMs }) : undefined,
     });
     const settleMs = budgets.settleMs;
+    const confirmMs = budgets.confirmMs;
     const confirmOnce = isTrue(args.confirm);
     try {
         let before = null;
@@ -276,8 +322,10 @@ export async function deliverTo(client, state, args, input) {
             body,
             mode,
             settleMs,
+            confirmMs,
             clock,
             before,
+            profile,
             queued,
         });
         // Opt-in confirm. A second paste is only safe on positive evidence the
@@ -293,8 +341,10 @@ export async function deliverTo(client, state, args, input) {
                     body,
                     mode,
                     settleMs,
+                    confirmMs,
                     clock,
                     before: retryBefore,
+                    profile,
                     queued,
                 });
             }

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;
+}, harness?: 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, harness) {
+    return busyMarker(screen, resolveHarness(pane, harness))?.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, optionalString(args.harness));
+                        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,59 @@
+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;
+/** Settle after the rescue Enter before re-reading the composer, matching the relay. */
+export declare const SUBMIT_ENTER_SETTLE_MS = 800;
+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>;