@zswarm/core 0.2.8 → 0.3.0

package/dist/host/cli.js

@@ -244,11 +244,11 @@ const COMMANDS = {
     crew: {
         usage: [
             "zswarm crew up <session> --layout L.kdl [--config C.kdl] [--env-file F] [--first-pane NAME] [--run-as USER]",
-            "                                  keep the session running from its layout (service + 2-min watchdog;",
-            "                                  on Windows: Scheduled Tasks under \\zswarm\\ + an attached client window)",
+            "                                  start the session from its layout now and at boot/logon; nothing restarts",
+            "                                  it by itself (on Windows: a Scheduled Task under \\zswarm\\ + an attached client window)",
             "zswarm crew status <session> [--run-as USER]   services, session, panes",
             "zswarm crew down <session> [--run-as USER]     remove the services and kill the session",
-            "zswarm crew start|check <session>              what the service and the watchdog run",
+            "zswarm crew start <session>                    what the service runs; also brings a crew back by hand",
             "zswarm crew client <session>                   what the minimized console window runs (Windows)",
             "--run-as installs for another account and is Linux/macOS only; a Windows crew runs as the signed-in user",
         ].join("\n"),

package/dist/host/crew-windows.d.ts

@@ -3,14 +3,15 @@
  *
  * A background Zellij session started with `zellij attach --create-background`
  * on Windows renders empty pane grids and drops pasted input, because nothing
- * is attached in a real console. The fix is two Scheduled Tasks under
+ * is attached in a real console. The fix is one Scheduled Task under
  * `\zswarm\` plus a minimized attached-client console window:
  *
- *   zswarm-crew-<session>        starts the session (interactive, highest)
- *   zswarm-crew-<session>-watch  `crew check` every two minutes, so the crew
- *                                restarts only when the session or its first
- *                                layout pane is gone, and the client window is
- *                                reopened when it is gone but the session lives
+ *   zswarm-crew-<session>        starts the session (interactive, highest) at
+ *                                logon and on `crew up`
+ *
+ * There is no watchdog: a crew that dies stays down until someone restarts it
+ * (`zswarm crew start <session>`). Older versions registered a
+ * `zswarm-crew-<session>-watch` task; `crew up` and `crew down` remove it.
  *
  * This module is pure PowerShell text (unit-tested by text) plus thin async
  * wrappers. It deliberately mirrors `buildServeTaskScript` in
@@ -20,8 +21,6 @@
  */
 /** Scheduled-task folder every crew task lives in. */
 export declare const CREW_TASK_FOLDER = "\\zswarm\\";
-/** Watchdog cadence, matching the Linux/macOS `crew-<s>-watch` timer. */
-export declare const CREW_WATCH_MINUTES = 2;
 export type PowerShellResult = {
     code: number;
     stdout: string;
@@ -31,14 +30,15 @@ export type PowerShellExec = (script: string, options: {
     timeoutMs: number;
     signal?: AbortSignal;
 }) => Promise<PowerShellResult>;
+/** `legacyWatch`: the watchdog task older versions registered, removed on sight. */
 export type CrewTaskNames = {
     folder: string;
     start: string;
-    watch: string;
+    legacyWatch: string;
 };
 export type CrewTaskState = {
-    /** Which of the two crew tasks this is. */
-    name: "start" | "watch";
+    /** The crew's task. */
+    name: "start";
     /** Task name only, e.g. `zswarm-crew-crew`. */
     task: string;
     /** `\zswarm\zswarm-crew-crew`. */
@@ -74,8 +74,6 @@ export declare function crewTaskCommand(input: {
 export declare function buildCrewTaskScript(action: "register" | "inspect" | "start" | "unregister", params: {
     session: string;
     startCommand?: string;
-    watchCommand?: string;
-    intervalMinutes?: number;
 }): string;
 /**
  * The command line the client window runs. The marker is both the window title
@@ -111,8 +109,6 @@ export declare function inspectCrewTasks(input: {
 export declare function installCrewTasks(input: {
     session: string;
     startCommand: string;
-    watchCommand: string;
-    intervalMinutes?: number;
     runPowerShell: PowerShellExec;
     timeoutMs?: number;
     signal?: AbortSignal;

package/dist/host/crew-windows.js

@@ -6,14 +6,15 @@ import { encodePowerShellCommand } from "../zellij/ipc.js";
  *
  * A background Zellij session started with `zellij attach --create-background`
  * on Windows renders empty pane grids and drops pasted input, because nothing
- * is attached in a real console. The fix is two Scheduled Tasks under
+ * is attached in a real console. The fix is one Scheduled Task under
  * `\zswarm\` plus a minimized attached-client console window:
  *
- *   zswarm-crew-<session>        starts the session (interactive, highest)
- *   zswarm-crew-<session>-watch  `crew check` every two minutes, so the crew
- *                                restarts only when the session or its first
- *                                layout pane is gone, and the client window is
- *                                reopened when it is gone but the session lives
+ *   zswarm-crew-<session>        starts the session (interactive, highest) at
+ *                                logon and on `crew up`
+ *
+ * There is no watchdog: a crew that dies stays down until someone restarts it
+ * (`zswarm crew start <session>`). Older versions registered a
+ * `zswarm-crew-<session>-watch` task; `crew up` and `crew down` remove it.
  *
  * This module is pure PowerShell text (unit-tested by text) plus thin async
  * wrappers. It deliberately mirrors `buildServeTaskScript` in
@@ -23,11 +24,9 @@ import { encodePowerShellCommand } from "../zellij/ipc.js";
  */
 /** Scheduled-task folder every crew task lives in. */
 export const CREW_TASK_FOLDER = "\\zswarm\\";
-/** Watchdog cadence, matching the Linux/macOS `crew-<s>-watch` timer. */
-export const CREW_WATCH_MINUTES = 2;
 /** Same shape the `zswarm crew` session validator uses; duplicated to avoid a cycle. */
 const CREW_SESSION = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-/** Overall helper deadline when `timeoutMs` is omitted. Registering two tasks is two calls. */
+/** Overall helper deadline when `timeoutMs` is omitted. */
 const DEFAULT_CREW_TIMEOUT_MS = 20_000;
 function checkSession(session) {
     const text = session?.trim() ?? "";
@@ -39,7 +38,7 @@ function checkSession(session) {
 /** `zswarm-crew-<session>`: task names, and the client window's title marker. */
 export function crewTaskNames(session) {
     const start = `zswarm-crew-${checkSession(session)}`;
-    return { folder: CREW_TASK_FOLDER, start, watch: `${start}-watch` };
+    return { folder: CREW_TASK_FOLDER, start, legacyWatch: `${start}-watch` };
 }
 /** The token that proves a console window is this crew's client: its title and
  *  the string in its launcher's command line. */
@@ -166,13 +165,11 @@ export function buildCrewTaskScript(action, params) {
         // Base64 UTF-8 round-trip, exactly like serve's register: neither the
         // command nor its quoting ever appears in the script text.
         const startB64 = Buffer.from(params.startCommand ?? "", "utf8").toString("base64");
-        const watchB64 = Buffer.from(params.watchCommand ?? "", "utf8").toString("base64");
-        const interval = Math.max(1, Math.floor(params.intervalMinutes ?? CREW_WATCH_MINUTES));
         return [
             PS_PREAMBLE,
             `$cmd = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${startB64}'))`,
             `$startName = '${names.start}'`,
-            `$watchName = '${names.watch}'`,
+            `$watchName = '${names.legacyWatch}'`,
             "$identity = Get-ZswarmIdentity",
             "foreach ($name in @($startName, $watchName)) {",
             "  try {",
@@ -187,15 +184,23 @@ export function buildCrewTaskScript(action, params) {
             // and its Zellij console window.
             "$principal = New-ScheduledTaskPrincipal -UserId $userId -LogonType Interactive -RunLevel Highest",
             "$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable",
-            "$startAction = New-ScheduledTaskAction -Execute 'cmd.exe' -Argument ('/c ' + $cmd)",
+            // A console program started by an Interactive task gets a visible console
+            // window. Run the action under a headless console host instead (the
+            // client window the crew opens on purpose is a separate Start-Process
+            // and keeps its own).
+            "$startAction = New-ScheduledTaskAction -Execute 'conhost.exe' -Argument ('--headless cmd.exe /c ' + $cmd)",
             "$startTrigger = New-ScheduledTaskTrigger -AtLogOn -User $userId",
             `Register-ScheduledTask -TaskName $startName -TaskPath '${CREW_TASK_FOLDER}' -Action $startAction -Principal $principal -Trigger $startTrigger -Settings $settings -Force | Out-Null`,
-            `$cmd = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${watchB64}'))`,
-            "$watchAction = New-ScheduledTaskAction -Execute 'cmd.exe' -Argument ('/c ' + $cmd)",
-            // A once-trigger with a long repetition is the supported way to run an
-            // interval task for a user; an AtLogOn trigger would only run once.
-            `$watchTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes ${interval}) -RepetitionDuration (New-TimeSpan -Days 3650)`,
-            `Register-ScheduledTask -TaskName $watchName -TaskPath '${CREW_TASK_FOLDER}' -Action $watchAction -Principal $principal -Trigger $watchTrigger -Settings $settings -Force | Out-Null`,
+            // The watchdog task of older versions goes: the crew no longer has one.
+            "$removedWatch = $false",
+            "try {",
+            "  [void](Get-ZswarmTask $watchName)",
+            `  try { Stop-ScheduledTask -TaskName $watchName -TaskPath '${CREW_TASK_FOLDER}' } catch { if (-not (Test-ZswarmMissing $_)) { throw } }`,
+            `  Unregister-ScheduledTask -TaskName $watchName -TaskPath '${CREW_TASK_FOLDER}' -Confirm:$false`,
+            "  $removedWatch = $true",
+            "} catch {",
+            "  if (-not (Test-ZswarmMissing $_)) { throw }",
+            "}",
             "Write-ZswarmJson @{",
             "  registered = $true",
             "  userId = $userId",
@@ -204,7 +209,7 @@ export function buildCrewTaskScript(action, params) {
             "  runLevel = 'Highest'",
             `  folder = '${CREW_TASK_FOLDER}'`,
             "  startTask = $startName",
-            "  watchTask = $watchName",
+            "  removedLegacyWatch = $removedWatch",
             "}",
         ].join("\n");
     }
@@ -213,10 +218,9 @@ export function buildCrewTaskScript(action, params) {
         return [
             PS_PREAMBLE,
             `$startName = '${names.start}'`,
-            `$watchName = '${names.watch}'`,
             `$marker = '${marker}'`,
             "$tasks = @{}",
-            "foreach ($pair in @(@{ key = 'start'; name = $startName }, @{ key = 'watch'; name = $watchName })) {",
+            "foreach ($pair in @(@{ key = 'start'; name = $startName })) {",
             "  try {",
             "    $task = Get-ZswarmTask $pair.name",
             "  } catch {",
@@ -246,7 +250,6 @@ export function buildCrewTaskScript(action, params) {
             psClientPidLine(marker),
             "Write-ZswarmJson @{",
             "  start = $tasks['start']",
-            "  watch = $tasks['watch']",
             "  clientPresent = ($clientPids.Count -gt 0)",
             "  clientPids = @($clientPids)",
             "  clientCount = $clientPids.Count",
@@ -257,8 +260,7 @@ export function buildCrewTaskScript(action, params) {
         return [
             PS_PREAMBLE,
             `$startName = '${names.start}'`,
-            `$watchName = '${names.watch}'`,
-            "foreach ($name in @($startName, $watchName)) {",
+            "foreach ($name in @($startName)) {",
             "  try {",
             "    $task = Get-ZswarmTask $name",
             "    [void](Assert-ZswarmCurrentOwner $task)",
@@ -267,13 +269,14 @@ export function buildCrewTaskScript(action, params) {
             "    if (-not (Test-ZswarmMissing $_)) { throw }",
             "  }",
             "}",
-            "Write-ZswarmJson @{ started = $true; startTask = $startName; watchTask = $watchName }",
+            "Write-ZswarmJson @{ started = $true; startTask = $startName }",
         ].join("\n");
     }
     return [
         PS_PREAMBLE,
         `$startName = '${names.start}'`,
-        `$watchName = '${names.watch}'`,
+        // Also the watchdog task older versions registered.
+        `$watchName = '${names.legacyWatch}'`,
         "foreach ($name in @($startName, $watchName)) {",
         "  try {",
         "    $task = Get-ZswarmTask $name",
@@ -468,10 +471,7 @@ export async function inspectCrewTasks(input) {
         ? data.clientCount
         : pids.length;
     return {
-        tasks: [
-            asTaskState("start", names.start, data.start),
-            asTaskState("watch", names.watch, data.watch),
-        ],
+        tasks: [asTaskState("start", names.start, data.start)],
         client: {
             present: data.clientPresent === true,
             pid: pids.length > 0 ? pids[0] : null,
@@ -482,18 +482,11 @@ export async function inspectCrewTasks(input) {
 export async function installCrewTasks(input) {
     const session = checkSession(input.session);
     const names = crewTaskNames(session);
-    const intervalMinutes = Math.max(1, Math.floor(input.intervalMinutes ?? CREW_WATCH_MINUTES));
     const timeoutMs = crewTimeout(input.timeoutMs);
-    const script = buildCrewTaskScript("register", {
-        session,
-        startCommand: input.startCommand,
-        watchCommand: input.watchCommand,
-        intervalMinutes,
-    });
-    await crewRun(input.runPowerShell, script, timeoutMs, input.signal);
-    // Start both now, the way the Linux oneshot unit is started on install: the
-    // start task builds the session and opens the client window; the watchdog's
-    // first run is a no-op while that session is healthy.
+    const script = buildCrewTaskScript("register", { session, startCommand: input.startCommand });
+    const registered = await crewRun(input.runPowerShell, script, timeoutMs, input.signal);
+    // Start it now, the way the Linux oneshot unit is started on install: the
+    // start task builds the session and opens the client window.
     await crewRun(input.runPowerShell, buildCrewTaskScript("start", { session }), timeoutMs, input.signal);
     const inspected = await inspectCrewTasks({
         session,
@@ -504,11 +497,11 @@ export async function installCrewTasks(input) {
     return {
         lines: [
             `${names.folder}${names.start} registered and started`,
-            `${names.folder}${names.watch} registered and started`,
+            ...(registered.removedLegacyWatch === true ? [`${names.folder}${names.legacyWatch} (old watchdog) removed`] : []),
         ],
         notes: [
             "A Windows scheduled task runs in the signed-in interactive desktop session, so the crew needs a logged-in user: a logoff ends the client window and the session it renders.",
-            `The start task builds the session and keeps an attached client window titled ${names.start}; the watchdog runs crew check every ${intervalMinutes} minute(s) and reopens that window when it is gone.`,
+            `The start task builds the session and keeps an attached client window titled ${names.start}. Nothing restarts the crew by itself: if the session or that window goes, run zswarm crew start ${session}.`,
         ],
         tasks: inspected.tasks,
         client: inspected.client,
@@ -527,7 +520,7 @@ export async function removeCrewTasks(input) {
         signal: input.signal,
     });
     return {
-        lines: [`${names.folder}${names.start} removed`, `${names.folder}${names.watch} removed`],
+        lines: [`${names.folder}${names.start} removed`],
         tasks: inspected.tasks,
     };
 }

package/dist/host/crew.d.ts

@@ -1,6 +1,6 @@
+import { type LogEntry } from "../state.js";
 import { type PowerShellExec } from "./crew-windows.js";
 import { type Runner, type ServiceAccount, type ServiceHost, type ServiceSpec } from "./services.js";
-export declare const CREW_WATCH_SEC = 120;
 export type CrewDeps = {
     env?: NodeJS.ProcessEnv;
     /** The crew directory; defaults to ~/.zswarm/crews/<session>. */
@@ -22,8 +22,8 @@ export type CrewDeps = {
     }>>;
     sleep?: (ms: number) => Promise<void>;
     log?: (line: string) => void;
-    /** Restarts a systemd user unit (the watchdog on Linux); injected in tests. */
-    restartUnit?: (unit: string) => number;
+    /** Appends to zswarm's op log (~/.zswarm/log.jsonl); injected in tests. */
+    record?: (entry: LogEntry) => void;
     /** The account the crew runs for; injected in tests (a win32 account cannot run real tasks in CI). */
     account?: ServiceAccount;
     /** Runs the crew's scheduled-task PowerShell on Windows; injected in tests. */
@@ -43,12 +43,12 @@ export type CrewDeps = {
         close: (session: string) => Promise<number[]>;
     };
 };
-/** Env the Linux watchdog unit carries: restart this unit instead of starting Zellij itself. */
-export declare const CREW_UNIT_ENV = "ZSWARM_CREW_UNIT";
 export declare function checkCrewSession(session: string | undefined): string;
 export declare function crewDir(account: ServiceAccount, session: string, env?: NodeJS.ProcessEnv): string;
 /** The first `pane ... name="X"` in a KDL layout: the pane whose presence proves the layout took. */
 export declare function firstLayoutPane(kdl: string): string | undefined;
+/** Every named `pane` in a layout, in order (comments skipped). */
+export declare function layoutPaneNames(kdl: string): string[];
 /** KEY=VALUE lines (optional `export`, quotes, comments) into an object. */
 export declare function parseEnvFile(text: string): Record<string, string>;
 /** Start the session from its layout and prove the first pane exists; up to three tries. */
@@ -60,7 +60,11 @@ export declare function crewStart(session: string, deps?: CrewDeps): Promise<num
  * session render — a background-only session leaves pane grids empty.
  */
 export declare function crewClient(session: string, deps?: CrewDeps): number;
-/** Watchdog: restart the session if its server died or its first pane is gone. */
+/**
+ * `crew check` was the watchdog's command. The watchdog is gone; this stays a
+ * harmless no-op so a timer or task left by an older version does not fail
+ * every two minutes before `crew up` or `crew down` removes it.
+ */
 export declare function crewCheck(session: string, deps?: CrewDeps): Promise<number>;
 export type CrewUpInput = {
     session: string;

package/dist/host/crew.js

@@ -4,7 +4,7 @@ import { dirname, posix, win32 } 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 { resolveZellijBinary } from "../zellij/binary.js";
 import { closeCrewClient, crewClientCommand, crewClientMarker, crewTaskCommand, defaultPowerShellExec, ensureCrewClient, inspectCrewTasks, installCrewTasks, removeCrewTasks, } from "./crew-windows.js";
 import { defaultRunner, ensureAccountDir, installServices, removeServices, serviceAccount, serviceStates, writeAccountFile, writeSecretFile, } from "./services.js";
@@ -15,27 +15,28 @@ const { join } = posix;
  * `zswarm crew`: keep a Zellij session built from a layout running on a host.
  *
  *   up      copy the layout (and optional config and env file) into
- *           ~/.zswarm/crews/<session>/, install a oneshot service that starts
- *           the session and a watchdog that restarts it every two minutes if
- *           its server died or its layout did not take
+ *           ~/.zswarm/crews/<session>/ and install a oneshot service that
+ *           starts the session (at boot/logon and now)
  *   start   what the service runs: start the session, prove the first layout
- *           pane exists, retry up to three times
- *   check   what the watchdog runs: start again only if needed
+ *           pane exists, retry up to three times; also the way to bring a
+ *           crew back by hand
  *   status  services, session and panes
- *   down    remove the services and kill the session
+ *   down    remove the service and kill the session
  *
- * On Windows there is no systemd or launchd: `up` registers two Scheduled
- * Tasks under `\zswarm\` (a start task and a two-minute watchdog running
- * `crew check`) and the start path keeps an attached client in a minimized
- * console window, because a background-only Windows session renders empty
- * panes and drops pasted input.
+ * There is no watchdog: nothing restarts a crew by itself. Older versions
+ * installed a `crew-<session>-watch` timer/job/task running `crew check`;
+ * `up` and `down` remove it, and `check` is a no-op until they have.
+ *
+ * On Windows there is no systemd or launchd: `up` registers a Scheduled
+ * Task under `\zswarm\` and the start path keeps an attached client in a
+ * minimized console window, because a background-only Windows session renders
+ * empty panes and drops pasted input.
  *
  * Zellij now and then starts `attach --create-background --layout` as a
  * plain one-pane session; the first-pane check is what catches that.
  */
 const SESSION = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const FOREIGN_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin";
-export const CREW_WATCH_SEC = 120;
 /** The Windows client window: real PowerShell, or the test seam. */
 function windowsClient(deps, env) {
     if (deps.client)
@@ -55,8 +56,6 @@ function windowsClient(deps, env) {
 function taskStateView(task) {
     return { name: task.name, unit: task.path, state: task.state, active: task.active };
 }
-/** Env the Linux watchdog unit carries: restart this unit instead of starting Zellij itself. */
-export const CREW_UNIT_ENV = "ZSWARM_CREW_UNIT";
 export function checkCrewSession(session) {
     const s = session?.trim() ?? "";
     if (!SESSION.test(s))
@@ -84,6 +83,50 @@ export function firstLayoutPane(kdl) {
     }
     return undefined;
 }
+/** Every named `pane` in a layout, in order (comments skipped). */
+export function layoutPaneNames(kdl) {
+    const out = [];
+    for (const line of kdl.split("\n")) {
+        const code = line.replace(/\/\/.*$/, "");
+        if (!/^\s*pane\b/.test(code))
+            continue;
+        const m = /\bname\s*=?\s*"([^"]+)"/.exec(code);
+        if (m)
+            out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * Did the session take its layout? `foreign`: it has panes, but none carries a
+ * name from the layout, so Zellij built it from something else (usually a saved
+ * session of the same name it resurrected). Recreating would only repeat that.
+ * A single unnamed pane is the plain shell of a layout that did not load yet.
+ */
+function checkLayout(panes, first, names) {
+    const titles = panes.map((p) => p.title);
+    const seen = `${titles.length} pane(s)${titles.length ? `: ${titles.slice(0, 8).join(", ")}${titles.length > 8 ? ", ..." : ""}` : ""}`;
+    if (titles.includes(first))
+        return { state: "ok", seen };
+    if (titles.length > 1 && !titles.some((t) => names.includes(t)))
+        return { state: "foreign", seen };
+    return { state: "missing", seen };
+}
+function foreignLayoutHint(session) {
+    return (`Zellij restored a different layout for ${session}: a saved or still-running session holds that name ` +
+        `(on Windows often a renamed session whose server kept its old name). Stop the server that holds it ` +
+        `(a zellij.exe --server process), run \`zellij delete-session ${session}\`, then \`zswarm crew start ${session}\``);
+}
+function crewRecorder(deps, env) {
+    const record = deps.record ?? ((entry) => createStateStore({ env }).appendLog(entry));
+    return (session, ok, detail) => {
+        try {
+            record({ at: Date.now(), op: "crew", session, ok, detail });
+        }
+        catch {
+            // The log is an aid, never a reason to fail the crew.
+        }
+    };
+}
 /** KEY=VALUE lines (optional `export`, quotes, comments) into an object. */
 export function parseEnvFile(text) {
     const out = {};
@@ -159,13 +202,15 @@ export async function crewStart(session, deps = {}) {
     const panes = deps.panes ?? defaultPanes;
     const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const log = deps.log ?? ((line) => process.stdout.write(`${new Date().toISOString()} ${line}\n`));
+    const record = crewRecorder(deps, env0);
+    const names = layoutPaneNames(readFileSync(crewFile(dir, files.layout), "utf8"));
     const config = files.config ? ["--config", crewFile(dir, files.config)] : [];
     if (account.platform === "win32") {
         // Windows: a session created with `attach --create-background` renders
         // empty panes and drops pasted input, so the session is created BY an
         // attached client instead — a minimized console window running
         // `zellij --layout ... attach --create`, which `crew client` starts. That
-        // window is also what the watchdog reopens when it dies.
+        // window is what `crew start` reopens when it is gone.
         const client = windowsClient(deps, env);
         for (let attempt = 1; attempt <= 3; attempt++) {
             zellij(["delete-session", session], env); // clears only a dead session of this name
@@ -175,16 +220,25 @@ export async function crewStart(session, deps = {}) {
             for (let i = 0; i < 30 && !(await sessions(env)).includes(session); i++)
                 await sleep(1_000);
             await sleep(3_000);
-            if ((await panes(session, env)).some((p) => p.title === files.first)) {
+            const check = checkLayout(await panes(session, env), files.first, names);
+            if (check.state === "ok") {
                 log(`session ${session} up in window ${crewClientMarker(session)} (attempt ${attempt})`);
                 return 0;
             }
-            log(`session ${session} came up without its layout (attempt ${attempt}); recreating`);
             zellij(["kill-session", session], env);
             await client.close(session);
+            if (check.state === "foreign") {
+                const why = `stopped: came up with ${check.seen}, none from its layout. ${foreignLayoutHint(session)}`;
+                log(`session ${session} ${why}`);
+                record(session, false, `killed session; ${why}`);
+                return 1;
+            }
+            log(`session ${session} came up without its layout (attempt ${attempt}, ${check.seen}); recreating`);
+            record(session, false, `killed session: came up without its layout (attempt ${attempt}, ${check.seen}; expected ${files.first})`);
             await sleep(1_000);
         }
         log(`session ${session} never took its layout`);
+        record(session, false, "start failed: never took its layout after 3 attempts");
         return 1;
     }
     for (let attempt = 1; attempt <= 3; attempt++) {
@@ -193,15 +247,24 @@ export async function crewStart(session, deps = {}) {
         for (let i = 0; i < 20 && !(await sessions(env)).includes(session); i++)
             await sleep(500);
         await sleep(2_000);
-        if ((await panes(session, env)).some((p) => p.title === files.first)) {
+        const check = checkLayout(await panes(session, env), files.first, names);
+        if (check.state === "ok") {
             log(`session ${session} up with its layout (attempt ${attempt})`);
             return 0;
         }
-        log(`session ${session} came up without its layout (attempt ${attempt}); recreating`);
         zellij(["kill-session", session], env);
+        if (check.state === "foreign") {
+            const why = `stopped: came up with ${check.seen}, none from its layout. ${foreignLayoutHint(session)}`;
+            log(`session ${session} ${why}`);
+            record(session, false, `killed session; ${why}`);
+            return 1;
+        }
+        log(`session ${session} came up without its layout (attempt ${attempt}, ${check.seen}); recreating`);
+        record(session, false, `killed session: came up without its layout (attempt ${attempt}, ${check.seen}; expected ${files.first})`);
         await sleep(1_000);
     }
     log(`session ${session} never took its layout`);
+    record(session, false, "start failed: never took its layout after 3 attempts");
     return 1;
 }
 /**
@@ -243,36 +306,15 @@ export function crewClient(session, deps = {}) {
         process.stdout.write(`\u001b]0;${crewClientMarker(session)}\u0007`);
     return (deps.zellij ?? defaultZellijInteractive)(args, env).status;
 }
-/** Watchdog: restart the session if its server died or its first pane is gone. */
+/**
+ * `crew check` was the watchdog's command. The watchdog is gone; this stays a
+ * harmless no-op so a timer or task left by an older version does not fail
+ * every two minutes before `crew up` or `crew down` removes it.
+ */
 export async function crewCheck(session, deps = {}) {
-    const env0 = deps.env ?? process.env;
-    const account = deps.account ?? serviceAccount(undefined);
-    const dir = deps.dir ?? crewDir(account, checkCrewSession(session), env0);
-    const files = readCrewFiles(dir);
-    const env = crewEnv(dir, files, env0);
-    const sessions = deps.sessions ?? defaultSessions;
-    const panes = deps.panes ?? defaultPanes;
     const log = deps.log ?? ((line) => process.stdout.write(`${new Date().toISOString()} ${line}\n`));
-    if ((await sessions(env)).includes(session) && (await panes(session, env)).some((p) => p.title === files.first)) {
-        if (account.platform === "win32") {
-            // The session surviving is not enough on Windows: without the attached
-            // client window its panes render empty, so the watchdog reopens it.
-            const opened = await windowsClient(deps, env).ensure(session);
-            if (opened.opened)
-                log(`client window reopened for ${session}`);
-        }
-        return 0;
-    }
-    log(`session ${session} is gone or lost its layout; restarting`);
-    (deps.zellij ?? defaultZellij)(["kill-session", session], env);
-    const unit = env0[CREW_UNIT_ENV]?.trim();
-    if (unit) {
-        // Under systemd a server started here would live in the watchdog's cgroup
-        // and die when this check exits; the crew unit owns the session instead.
-        const restart = deps.restartUnit ?? ((u) => spawnSync("systemctl", ["--user", "restart", u], { stdio: "inherit" }).status ?? 1);
-        return restart(unit);
-    }
-    return await crewStart(session, deps);
+    log(`crew check ${checkCrewSession(session)}: the crew watchdog was removed; run zswarm crew up ${session} again to drop its old task`);
+    return 0;
 }
 /** A file inside a crew dir, which is a Windows path for a win32 account. */
 function crewFile(dir, name) {
@@ -325,17 +367,12 @@ export function crewServiceSpecs(input) {
             // kills the session itself.
             killMode: "process",
         },
-        {
-            name: `crew-${session}-watch`,
-            description: `zswarm crew: restart session ${session} if it died`,
-            kind: "interval",
-            intervalSec: CREW_WATCH_SEC,
-            argv: [...cli, "check", session],
-            env: account.platform === "linux" ? { ...base, [CREW_UNIT_ENV]: `zswarm-crew-${session}.service` } : base,
-            workingDir: account.home,
-        },
     ];
 }
+/** The watchdog unit older versions installed; removed by `crew up` and `crew down`. */
+function legacyWatchSpec(session) {
+    return { name: `crew-${session}-watch`, kind: "interval" };
+}
 export async function crewUp(input) {
     const env = input.env ?? process.env;
     const run = input.run ?? defaultRunner;
@@ -364,14 +401,13 @@ export async function crewUp(input) {
     // crew.json is written last, so a half-copied crew never starts.
     (input.writeMeta ?? writeSecretFile)(account, crewFile(dir, "crew.json"), `${JSON.stringify(files, null, 1)}\n`);
     if (account.platform === "win32") {
-        // Windows has no systemd/launchd: two Scheduled Tasks (a start task and a
-        // two-minute watchdog) plus the minimized client window the start task
-        // opens, because a background-only session renders empty panes.
+        // Windows has no systemd/launchd: a Scheduled Task plus the minimized
+        // client window it opens, because a background-only session renders empty
+        // panes.
         const taskEnv = crewTaskEnv(env);
         const installed = await installCrewTasks({
             session,
             startCommand: crewTaskCommand({ launch, mode: "start", session, env: taskEnv }),
-            watchCommand: crewTaskCommand({ launch, mode: "check", session, env: taskEnv }),
             runPowerShell: input.runPowerShell ?? defaultPowerShellExec,
         });
         const states = installed.tasks.map(taskStateView);
@@ -389,6 +425,8 @@ export async function crewUp(input) {
         };
     }
     const specs = crewServiceSpecs({ account, session, launch, env });
+    // Quietly drop the watchdog an older version installed.
+    removeServices({ account, run, fs: input.fs }, [legacyWatchSpec(session)]);
     const done = installServices({ account, run, fs: input.fs }, specs);
     const states = serviceStates({ account, run }, specs);
     return {
@@ -469,6 +507,7 @@ export async function crewDown(input) {
     }
     const specs = crewServiceSpecs({ account, session, launch: { execPath: "", scriptPath: "" }, env });
     const lines = removeServices({ account, run, fs: input.fs }, specs);
+    removeServices({ account, run, fs: input.fs }, [legacyWatchSpec(session)]);
     // The Zellij server belongs to the account: kill it as that user.
     const zellij = env.ZSWARM_BIN?.trim() || "zellij";
     const kill = account.foreign

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { createExec, NOT_FOUND_EXIT, type ExecFn, type ExecOptions, type ExecRes
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, type GitClient, type GitClientOptions, type Worktree, } from "./git.js";
 export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, type ZellijExecFn, type ZellijExecResult, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, type ZellijPane, } from "./zellij/panes.js";
-export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, type ZellijSession, type ZellijSessionResolve, } from "./zellij/session.js";
+export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, resolveSelfSession, type ZellijSession, type ZellijSessionResolve, } from "./zellij/session.js";
 export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PaneDirection, type PipeInput, type ScrollbackRequest, type WaitRequest, } from "./zellij/args.js";
 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";
@@ -36,6 +36,7 @@ export { HOST_COMMANDS, hostUsage, parseHostArgs, runHostCommand } from "./host/
 export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, type ServeServiceInput, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, type Runner, type ServiceAccount, type ServiceHost, type ServiceKind, type ServiceSpec, type ServiceState, } from "./host/services.js";
-export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, type CrewDeps, type CrewUpInput, } from "./host/crew.js";
+export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, layoutPaneNames, parseEnvFile, type CrewDeps, type CrewUpInput, } from "./host/crew.js";
 export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, type RelayAdminDeps, type RelayCancelResult, type RelayConfig, type RelayDeps, type RelayJob, type RelayJobRunner, type RelayRow, type RelayStartInput, type RelayStatus, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, type HostCheck, type HostDoctorInput, type HostInstallInput, type SshRunner, } from "./host/host.js";
+export { isSelfPane } from "./ops/guards.js";

package/dist/index.js

@@ -4,7 +4,7 @@ export { createExec, NOT_FOUND_EXIT, } from "./exec.js";
 export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, } from "./git.js";
 export { expandHomePath, looksLikeZswarmBinary, isZellijVersionOutput, resolveZellijBinary, resetZellijIdentityCache, sanitizeZellijEnv, validateSshDestination, validateSshMode, } from "./zellij/binary.js";
 export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
-export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
+export { liveSessionNames, parseCreatedAge, parseSessionList, resolveSelfPaneId, resolveSelfSession, } from "./zellij/session.js";
 export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, waitPayload, } from "./zellij/args.js";
 export { busPluginUrl, busToPanes, isBusPluginPane, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, } from "./zellij/bus.js";
 export { busSnapshot, closeBusPluginPanes, planBus, resetBusCache, } from "./ops/bus.js";
@@ -34,6 +34,7 @@ export { HOST_COMMANDS, hostUsage, parseHostArgs, runHostCommand } from "./host/
 export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, } from "./host/services.js";
-export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, } from "./host/crew.js";
+export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, layoutPaneNames, parseEnvFile, } from "./host/crew.js";
 export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, } from "./host/host.js";
+export { isSelfPane } from "./ops/guards.js";

package/dist/ops/broadcast.d.ts

@@ -17,7 +17,7 @@ export type Skipped = {
  * Pick the panes a broadcast should reach: an explicit comma list, a tab, or
  * every terminal pane — then drop the ones it must not write to.
  */
-export declare function selectTargets(client: ZellijClient, panes: ZellijPane[], args: Record<string, unknown>): {
+export declare function selectTargets(client: ZellijClient, panes: ZellijPane[], args: Record<string, unknown>, session?: string | null): {
     targets: ZellijPane[];
     skipped: Skipped[];
 };

package/dist/ops/broadcast.js

@@ -1,6 +1,7 @@
 import { ZellijError } from "../errors.js";
 import { assertPaneAllowed } from "../policy.js";
 import { deliverTo, selfPaneTitle, withSenderLabel } from "./delivery.js";
+import { isSelfPane } from "./guards.js";
 import { mapPool } from "./status.js";
 import { isTrue, optionalString } from "./util.js";
 /**
@@ -13,7 +14,7 @@ export const BROADCAST_CONCURRENCY = 3;
  * Pick the panes a broadcast should reach: an explicit comma list, a tab, or
  * every terminal pane — then drop the ones it must not write to.
  */
-export function selectTargets(client, panes, args) {
+export function selectTargets(client, panes, args, session) {
     const skipped = [];
     const list = optionalString(args.to);
     const tab = optionalString(args.tab);
@@ -59,7 +60,7 @@ export function selectTargets(client, panes, args) {
             skipped.push({ id: pane.id, reason: "pane_is_plugin" });
             continue;
         }
-        if (pane.id === client.selfPaneId && !isTrue(args.allowSelf)) {
+        if (isSelfPane(client, pane, session) && !isTrue(args.allowSelf)) {
             skipped.push({ id: pane.id, reason: "self_target" });
             continue;
         }
@@ -82,7 +83,7 @@ export async function broadcast(client, state, args, clock, policy, env = proces
         env,
         selfTitle: selfPaneTitle(client, panes),
     });
-    const { targets: selected, skipped } = selectTargets(client, panes, labeled);
+    const { targets: selected, skipped } = selectTargets(client, panes, labeled, session);
     // Policy narrows the selection rather than failing the whole broadcast.
     const targets = selected.filter((pane) => {
         if (!policy)

package/dist/ops/dispatch.js

@@ -396,7 +396,7 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 if (!body.trim())
                     throw new ZellijError("missing_body", "body required");
                 const { session, pane, panes, firstCallMs, timeoutMs } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
-                assertWritable(client, pane, args, "send");
+                assertWritable(client, pane, args, "send", session);
                 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
@@ -451,7 +451,7 @@ async function dispatchOperation(args, injected, deps, context, env) {
             case "keys":
             case "interrupt": {
                 const { session, pane } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
-                assertWritable(client, pane, args, op);
+                assertWritable(client, pane, args, op, session);
                 await assertExpectedScreen(client, session, pane.id, args, signal);
                 const chars = typeof args.chars === "string" ? args.chars : "";
                 if (op === "keys" && chars) {
@@ -682,7 +682,7 @@ async function dispatchOperation(args, injected, deps, context, env) {
                 const { session, pane } = await resolveTarget(client, args, state(), clock, env, policy, op, signal);
                 // Not assertWritable: closing an exited pane is the point of close.
                 assertNotPlugin(pane, "close");
-                assertNotSelf(client, pane, args, "close");
+                assertNotSelf(client, pane, args, "close", session);
                 const closed = await client.closePane({ session, paneId: pane.id });
                 state().appendLog({
                     at: clock.now(),

package/dist/ops/guards.d.ts

@@ -1,12 +1,20 @@
 import type { ZellijClient } from "../zellij/client.js";
 import type { ZellijPane } from "../zellij/panes.js";
 export declare function assertNotPlugin(pane: ZellijPane, action: string): void;
-export declare function assertNotSelf(client: ZellijClient, pane: ZellijPane, args: Record<string, unknown>, action: string): void;
+/**
+ * Is this the caller's own pane? The pane id must match AND the target session
+ * must be the caller's session when both are known: `terminal_1` in another
+ * session (or on another machine) is a different pane. A shared MCP server (one
+ * service for many clients) can carry another pane's ZELLIJ_* env, so the id
+ * alone is not proof. Unknown session: stay conservative and treat it as self.
+ */
+export declare function isSelfPane(client: Pick<ZellijClient, "selfPaneId" | "selfSession" | "remote">, pane: Pick<ZellijPane, "id">, session?: string | null): boolean;
+export declare function assertNotSelf(client: ZellijClient, pane: ZellijPane, args: Record<string, unknown>, action: string, session?: string | null): void;
 /**
  * Refuse writes that would loop back into the caller's own pane, land in a
  * dead pane, or hit a plugin pane. `allowSelf` / `force` opt out.
  */
-export declare function assertWritable(client: ZellijClient, pane: ZellijPane, args: Record<string, unknown>, action: string): void;
+export declare function assertWritable(client: ZellijClient, pane: ZellijPane, args: Record<string, unknown>, action: string, session?: string | null): void;
 /**
  * Opt-in check that the pane still looks like the intended agent, not a
  * shell that would execute the body as a command. Substring only — a regex

package/dist/ops/guards.js

@@ -5,9 +5,26 @@ export function assertNotPlugin(pane, action) {
         throw new ZellijError("pane_is_plugin", `${pane.id} is a plugin pane; ${action} targets terminal panes`);
     }
 }
-export function assertNotSelf(client, pane, args, action) {
+/**
+ * Is this the caller's own pane? The pane id must match AND the target session
+ * must be the caller's session when both are known: `terminal_1` in another
+ * session (or on another machine) is a different pane. A shared MCP server (one
+ * service for many clients) can carry another pane's ZELLIJ_* env, so the id
+ * alone is not proof. Unknown session: stay conservative and treat it as self.
+ */
+export function isSelfPane(client, pane, session) {
+    if (client.remote)
+        return false;
+    const self = client.selfPaneId;
+    if (!self || pane.id !== self)
+        return false;
+    if (client.selfSession && session && session !== client.selfSession)
+        return false;
+    return true;
+}
+export function assertNotSelf(client, pane, args, action, session) {
     const self = client.selfPaneId;
-    if (self && pane.id === self && !isTrue(args.allowSelf)) {
+    if (isSelfPane(client, pane, session) && !isTrue(args.allowSelf)) {
         throw new ZellijError("self_target", `refusing to ${action} into zswarm's own pane (${self}); pass allowSelf=true to override`);
     }
 }
@@ -15,9 +32,9 @@ export function assertNotSelf(client, pane, args, action) {
  * Refuse writes that would loop back into the caller's own pane, land in a
  * dead pane, or hit a plugin pane. `allowSelf` / `force` opt out.
  */
-export function assertWritable(client, pane, args, action) {
+export function assertWritable(client, pane, args, action, session) {
     assertNotPlugin(pane, action);
-    assertNotSelf(client, pane, args, action);
+    assertNotSelf(client, pane, args, action, session);
     if (pane.exited && !isTrue(args.force)) {
         throw new ZellijError("pane_exited", `${pane.id} has exited; pass force=true to write to it anyway`);
     }

package/dist/ops/restart.js

@@ -240,7 +240,7 @@ export async function restartPane(client, state, args, target, clock, opts = {})
         }
     }
     assertNotPlugin(observed, "restart");
-    assertNotSelf(client, observed, args, "restart");
+    assertNotSelf(client, observed, args, "restart", session);
     // A relay working the pane owns it; restarting under it would kill the task.
     const to = String(args.to ?? "").trim();
     const held = findLease(state, {
@@ -251,7 +251,8 @@ export async function restartPane(client, state, args, target, clock, opts = {})
     if (held && !isTrue(args.force)) {
         throw new ZellijError("pane_leased", `pane ${to} is leased by relay ${held.relayId} (from ${held.from}, since ${new Date(held.at).toISOString()}); pass force=true to restart it anyway`, { relayId: held.relayId, from: held.from, at: held.at, dir: held.dir });
     }
-    const profile = resolveHarness(observed);
+    // --harness names the profile for wrapper-launched panes (exit recipe, ready and busy markers).
+    const profile = resolveHarness(observed, optionalString(args.harness));
     const kind = restartPaneKind(observed);
     const handoffSelf = isTrue(args.handoffSelf);
     const supplied = typeof args.handoff === "string" && args.handoff.length > 0 ? args.handoff : null;

package/dist/zellij/client.d.ts

@@ -32,6 +32,7 @@ export type ZellijTransport = {
 export declare function createZellijClient(options?: ZellijClientOptions): {
     zellijPath: string;
     selfPaneId: string | null;
+    selfSession: string | null;
     contextKey: () => string;
     invalidateListings: (session: string) => void;
     observeManifest: (session: string, revision: string) => void;

package/dist/zellij/client.js

@@ -6,7 +6,7 @@ import { parseTabList, resolveTab } from "./tabs.js";
 import { createSshExec } from "../exec.js";
 import { DEFAULT_TIMEOUT_MS, NOT_FOUND_EXIT, defaultExec, ensureZellijProbes, identityCacheKey, resolveSshTarget, resolveZellijBinary, sanitizeZellijEnv, zellijExecDetails, zellijMissingError, } from "./binary.js";
 import { normalizePaneId, parsePaneList, resolvePane, } from "./panes.js";
-import { isZellijNoSessionsOutput, parseSessionList, resolveSelfPaneId, sessionFromEnv, sessionFromList, } from "./session.js";
+import { isZellijNoSessionsOutput, parseSessionList, resolveSelfPaneId, resolveSelfSession, sessionFromEnv, sessionFromList, } from "./session.js";
 /** Zellij wrapper with bounded caches of completed discovery observations. */
 export function createZellijClient(options = {}) {
     const env = options.env ?? process.env;
@@ -28,6 +28,8 @@ export function createZellijClient(options = {}) {
     const exec = (args, opts) => rawExec(args, { ...opts, signal: opts.signal ?? options.signal });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const selfPaneId = resolveSelfPaneId(env);
+    // Over SSH the target is another machine's Zellij: no pane there is ours.
+    const selfSession = ssh ? null : resolveSelfSession(env);
     const probeKey = JSON.stringify([identityCacheKey(zellijPath, ssh), routingEnvironment(env)]);
     const now = options.now ?? Date.now;
     const cache = options.cache instanceof ListingCache ? options.cache : sharedListings;
@@ -368,6 +370,7 @@ export function createZellijClient(options = {}) {
     return {
         zellijPath,
         selfPaneId,
+        selfSession,
         contextKey,
         invalidateListings,
         observeManifest,

package/dist/zellij/session.d.ts

@@ -19,6 +19,12 @@ export type ZellijSession = {
  * `ZSWARM_SELF_PANE` wins; Zellij exports `ZELLIJ_PANE_ID` inside a pane.
  */
 export declare function resolveSelfPaneId(env?: NodeJS.ProcessEnv): string | null;
+/**
+ * The Zellij session the caller runs in (ZSWARM_SELF_SESSION, else
+ * ZELLIJ_SESSION_NAME); null when unknown. A pane id is only "self" inside
+ * this session: terminal_1 of another session is somebody else's pane.
+ */
+export declare function resolveSelfSession(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

package/dist/zellij/session.js

@@ -13,6 +13,15 @@ export function resolveSelfPaneId(env = process.env) {
         return raw.toLowerCase();
     return null;
 }
+/**
+ * The Zellij session the caller runs in (ZSWARM_SELF_SESSION, else
+ * ZELLIJ_SESSION_NAME); null when unknown. A pane id is only "self" inside
+ * this session: terminal_1 of another session is somebody else's pane.
+ */
+export function resolveSelfSession(env = process.env) {
+    const raw = (env.ZSWARM_SELF_SESSION ?? env.ZELLIJ_SESSION_NAME ?? "").trim();
+    return raw ? raw : null;
+}
 const AGE_UNITS = [
     [/^years?$|^yrs?$|^y$/, 31_536_000],
     [/^months?$|^mons?$|^mo$/, 2_592_000],

package/package.json

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