@brutalsystems/muster 0.7.21 → 0.8.0

package/README.md

@@ -114,6 +114,15 @@ enabled. Use Muster's normalized permission flags. Prompt strings are always
 passed as one literal argument. Codex and Claude launches and OpenCode tasks put
 that value after `--`; OpenCode sessions use the dedicated `--prompt` value.
 
+A tmux session is stopped after 30 minutes with no pane activity. Set
+`--idle-timeout 2h` to lengthen it, `--idle-timeout off` to disable it for one
+launch, or `[session] idle_timeout` in `config.toml` to change the default for
+every launch. `--ttl` adds a hard ceiling regardless of activity, for a session
+that looks busy only because something is looping inside it. A session with a
+client attached is never stopped. The limit applies to tmux sessions only: pty
+and macos-terminal sessions die with the process that launched them, and a task
+ends when its prompt does.
+
 OpenCode inherits the provider and model definitions from its normal user and
 project configuration, so configured local OpenAI-compatible providers such as
 `coldfire-local/qwen3-30b-a3b` remain available. Muster never rewrites those

package/dist/config.js

@@ -52,6 +52,15 @@ export const requesterEnrolmentSchema = z
     profile: z.string().min(1),
 })
     .strict();
+/** Raw strings, not parsed durations: a bad value in config.toml must fail with
+ *  the same message a bad flag does, and that parser lives in one place. */
+const sessionSectionSchema = z
+    .object({
+    idle_timeout: z.string().min(1).optional(),
+    ttl: z.string().min(1).optional(),
+})
+    .strict()
+    .default({});
 export const configSchema = z
     .object({
     host: z.enum(["auto", "tmux", "pty", "macos-terminal"]).default("auto"),
@@ -75,6 +84,7 @@ export const configSchema = z
     default_plugins: z.array(pluginName).default([]),
     plugins: z.record(pluginName, pluginSchema).default({}),
     opencode: openCodeSectionSchema,
+    session: sessionSectionSchema,
     allow_dangerous_flags: z.boolean().default(false),
     requester_profiles: z
         .record(z.string().regex(/^[a-zA-Z0-9_-]+$/), requesterProfileSchema)

package/dist/duration.js

@@ -0,0 +1,19 @@
+const UNITS = { s: 1, m: 60, h: 3600 };
+/**
+ * `90s`, `30m`, `4h`, or `off`.
+ *
+ * A bare number is refused rather than assigned a unit: guessing seconds turns
+ * `--ttl 30` into half a minute and reaps a session the caller meant to keep
+ * for half an hour. Zero and negative are refused for the same reason — they
+ * would read as "reap immediately", which no caller types on purpose.
+ */
+export function parseDuration(value, label) {
+    const raw = value.trim();
+    if (raw.toLowerCase() === "off")
+        return "off";
+    const match = /^(\d+)([smh])$/.exec(raw);
+    const seconds = match ? Number(match[1]) * UNITS[match[2]] : 0;
+    if (!match || seconds <= 0)
+        throw new Error(`${label} must be a duration like 90s, 30m, 4h, or off (got ${JSON.stringify(value)})`);
+    return seconds;
+}

package/dist/format.js

@@ -54,6 +54,17 @@ function recordHuman(record, color) {
             : record.model_source === "config"
                 ? " (configured default)"
                 : ""}`));
+    // Rendered from seconds rather than rounded to minutes: parseDuration accepts
+    // 45s, and "1m" for a 45s limit misreports it.
+    const duration = (seconds) => seconds % 3600 === 0
+        ? `${seconds / 3600}h`
+        : seconds % 60 === 0
+            ? `${seconds / 60}m`
+            : `${seconds}s`;
+    if (record.idle_timeout)
+        lines.push(field("Idle timeout", duration(record.idle_timeout)));
+    if (record.ttl)
+        lines.push(field("TTL", duration(record.ttl)));
     if (record.mcp)
         lines.push(field("MCP", record.mcp.length ? record.mcp.map(clean).join(", ") : "none"));
     for (const warning of record.mcp_warnings ?? [])

package/dist/guard.js

@@ -5,6 +5,7 @@ import { isAbsolute, relative, resolve } from "node:path";
 import { mcpName, claudeMcpConfig } from "./mcp.js";
 import { pluginName } from "./plugins.js";
 import { RequesterConfigError } from "./requester-policy.js";
+import { parseDuration } from "./duration.js";
 export const runSchema = z
     .object({
     runtime: z.enum(["codex", "claude", "opencode"]),
@@ -25,6 +26,8 @@ export const runSchema = z
     mcp: z.array(mcpName).optional(),
     plugin: z.array(pluginName).optional(),
     model: z.string().min(1).optional(),
+    idleTimeout: z.string().min(1).optional(),
+    ttl: z.string().min(1).optional(),
     project: z
         .string()
         .regex(/^[a-zA-Z0-9_-]+$/)
@@ -152,6 +155,11 @@ export function paramsFingerprint(req, permissions, mcp, plugins) {
         // already running under account-a, reported as success. A reused key
         // with different parameters must be refused, not answered.
         req.identity ?? null,
+        // A reused key whose lifecycle differs must be refused, not answered:
+        // handing back a 30m session to a caller that asked for `off` gives it
+        // a session that dies underneath it.
+        req.idleTimeout ?? null,
+        req.ttl ?? null,
         req.args,
     ]))
         .digest("hex");
@@ -240,6 +248,46 @@ const RUNTIME_OPTIONS = {
         consumed: [],
     },
 };
+/** 30 minutes. Long enough that a trust prompt or a coffee does not cost a
+ *  session; short enough that an orphan dies within the hour. */
+export const DEFAULT_IDLE_TIMEOUT = 1800;
+/**
+ * Flag, then config, then the built-in default; `off` disables at any level.
+ *
+ * Only a tmux session can honour a lifecycle: pty and macos-terminal die with
+ * their parent and a task is not a session at all. An explicit request there is
+ * refused, but a CONFIGURED default is silently skipped — refusing that would
+ * break every pty launch the moment someone sets a default.
+ *
+ * `reapable` comes from the caller, not from `req.host`, because the host that
+ * runs is `req.host ?? config.host` with `auto` resolving to whichever driver
+ * is available. Deciding from `req.host` here would accept `--idle-timeout`
+ * under `host = "pty"` in config and then never arm it.
+ */
+export function resolveLifecycle(req, config, reapable) {
+    const one = (flag, configured, label, fallback) => {
+        // `off` asks for nothing, so it is accepted even where a lifecycle cannot
+        // be honoured: a wrapper that always passes it defensively must still be
+        // able to launch a pty session.
+        if (flag !== undefined && !reapable && flag.trim().toLowerCase() !== "off")
+            throw new Error(`${label} applies to tmux sessions, which outlive the process that ` +
+                `launched them; this launch is ${req.kind === "task" ? "a task" : `hosted on ${req.host ?? "the configured host"}`}`);
+        const chosen = flag !== undefined
+            ? parseDuration(flag, label)
+            : configured !== undefined
+                ? parseDuration(configured, label)
+                : undefined;
+        if (!reapable)
+            return null;
+        if (chosen === undefined)
+            return fallback;
+        return chosen === "off" ? null : chosen;
+    };
+    return {
+        idleTimeout: one(req.idleTimeout, config.session.idle_timeout, "--idle-timeout", DEFAULT_IDLE_TIMEOUT),
+        ttl: one(req.ttl, config.session.ttl, "--ttl", null),
+    };
+}
 export function runtimeArgs(req) {
     const result = [];
     const { forwarded, consumed } = RUNTIME_OPTIONS[req.runtime];

package/dist/help.js

@@ -59,6 +59,14 @@ export const COMMANDS = [
                 "--model MODEL",
                 "model for the launch: a bare id for claude and codex, PROVIDER/MODEL for opencode",
             ],
+            [
+                "--idle-timeout DURATION",
+                "stop a tmux session after this much inactivity; 30m by default, off to disable",
+            ],
+            [
+                "--ttl DURATION",
+                "stop a tmux session this long after launch, whatever its state",
+            ],
             [
                 "--request-key KEY",
                 "name the request; sending it again returns the same launch",

package/dist/hosts/tmux.js

@@ -21,6 +21,23 @@ const FIELD = "|";
 export const LAUNCH_FORMAT = `#{window_id}${FIELD}#{pane_pid}`;
 export const LIST_FORMAT = `#{window_id}${FIELD}#{pane_pid}${FIELD}#{session_name}${FIELD}#{window_name}`;
 export const CLEANUP_FORMAT = `#{window_id}${FIELD}#{pane_start_command}`;
+/** `window_activity`, never `session_activity`: the latter does not advance for
+ *  a detached session, and every muster session is detached. */
+export const SESSION_STATE_FORMAT = `#{window_activity}${FIELD}#{session_created}${FIELD}#{session_attached}${FIELD}#{session_last_attached}`;
+export function parseSessionState(row, now) {
+    const [activity, created, attached, lastAttached] = row.trim().split(FIELD);
+    if (!/^\d+$/.test(activity ?? "") || !/^\d+$/.test(created ?? ""))
+        return null;
+    // Attaching and detaching does not advance `window_activity`, so a session
+    // someone read for ten minutes and left would be reaped on the next poll.
+    // tmux reports 0 for never-attached, which must not read as 1970.
+    const seen = Math.max(Number(activity), /^\d+$/.test(lastAttached ?? "") ? Number(lastAttached) : 0);
+    return {
+        idle: now - seen,
+        age: now - Number(created),
+        attached: Number(attached ?? 0) > 0,
+    };
+}
 export function parseWindowRow(output) {
     const [hostRef, pid] = output.trim().split(FIELD);
     if (!hostRef || !/^@\d+$/.test(hostRef) || !Number(pid))
@@ -69,6 +86,36 @@ export class TmuxHost {
     capabilities() {
         return { watchable: true, attachable: true, survivesParentExit: true };
     }
+    /** Null when the window is gone — the caller stops rather than guesses. */
+    async sessionState(hostRef) {
+        try {
+            const row = await this.call([
+                "display-message",
+                "-p",
+                "-t",
+                hostRef,
+                SESSION_STATE_FORMAT,
+            ]);
+            return parseSessionState(row, Math.floor(Date.now() / 1000));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Run `argv` in the background after `seconds`, scheduled by the tmux server
+     * itself. This is what lets a lifecycle outlive every muster process: nothing
+     * of ours is running between the call and the job.
+     */
+    async schedule(seconds, argv) {
+        await this.call([
+            "run-shell",
+            "-b",
+            "-d",
+            String(Math.max(1, Math.round(seconds))),
+            argv.map((a) => `'${a.replaceAll("'", `'\\''`)}'`).join(" "),
+        ]);
+    }
     async launch(opts) {
         const dir = await mkdtemp(join(tmpdir(), "muster-host-"));
         const file = join(dir, "launch.json");

package/dist/mcp-tools.js

@@ -82,6 +82,14 @@ export const MCP_TOOLS = [
                     minLength: 1,
                     description: "Model for the launch. A bare model id for claude and codex; PROVIDER/MODEL for opencode, where it overrides the configured [opencode] model. Recorded on the run and reported by `list`.",
                 },
+                idleTimeout: {
+                    type: "string",
+                    description: "Stop this tmux session after the given inactivity, as 90s/30m/4h, or 'off'. Defaults to 30m. Refused for tasks and for pty or macos-terminal hosts, which do not outlive their parent.",
+                },
+                ttl: {
+                    type: "string",
+                    description: "Stop this tmux session the given duration after launch regardless of activity, as 90s/30m/4h, or 'off'. Off by default.",
+                },
                 identity: {
                     type: "string",
                     pattern: "^[a-zA-Z0-9_-]+$",

package/dist/muster.js

@@ -166,6 +166,11 @@ async function main() {
                 "no-mcp": { type: "boolean" },
                 plugin: { type: "string", multiple: true },
                 model: { type: "string" },
+                "idle-timeout": { type: "string" },
+                ttl: { type: "string" },
+                socket: { type: "string" },
+                home: { type: "string" },
+                "stop-now": { type: "boolean" },
                 "no-plugin": { type: "boolean" },
                 "request-key": { type: "string" },
                 project: { type: "string" },
@@ -175,7 +180,23 @@ async function main() {
                 interactive: { type: "boolean" },
             },
         });
-        const { format = "json", "no-mcp": noMcp, "no-plugin": noPlugin, "request-key": requestKey, ...values } = parsed;
+        const { format = "json", "no-mcp": noMcp, "no-plugin": noPlugin, "request-key": requestKey, "idle-timeout": idleTimeout, socket, home: homeFlag, "stop-now": stopNow, ...values } = parsed;
+        // Guarded like --request-key and --no-mcp below: a flag that applies to one
+        // command and is silently ignored elsewhere misleads, and --home silently
+        // reading the real registry is the one that would mislead most.
+        for (const [name, value] of [
+            ["--idle-timeout", idleTimeout],
+            ["--ttl", values.ttl],
+        ])
+            if (value !== undefined && command !== "run")
+                throw new Error(`${name} applies only to run`);
+        for (const [name, value] of [
+            ["--socket", socket],
+            ["--home", homeFlag],
+            ["--stop-now", stopNow],
+        ])
+            if (value !== undefined && command !== "reap-check")
+                throw new Error(`${name} applies only to reap-check`);
         if (requestKey !== undefined && command !== "run")
             throw new Error("--request-key applies only to run");
         if (noMcp !== undefined && command !== "run")
@@ -206,6 +227,7 @@ async function main() {
                 runtime,
                 ...values,
                 ...(requestKey === undefined ? {} : { requestKey }),
+                ...(idleTimeout === undefined ? {} : { idleTimeout }),
                 args,
             });
             print(record);
@@ -305,6 +327,24 @@ async function main() {
             else
                 process.stdout.write(await muster.output(id));
         }
+        else if (command === "reap-check") {
+            // Hidden: armed by muster itself as a tmux job, never typed by a person.
+            // NOTE: `Muster.create()` above already ran against the REAL home before
+            // this dispatch. Harmless (nothing is owned, so `close()` stops nothing)
+            // but it means a broken ~/.muster/config.toml would fail every poll.
+            // Left as-is: moving that create changes every command's startup.
+            if (positionals.length !== 1 || !socket)
+                throw new Error("reap-check requires --socket and one launch id");
+            const { reapCheck } = await import("./reap.js");
+            await reapCheck({
+                home: homeFlag ?? musterHome(),
+                socket,
+                ...(stopNow ? { stopNow: true } : {}),
+                launchId: positionals[0],
+                // The exact command that was armed, so a re-arm reproduces itself.
+                argv: [...process.argv],
+            });
+        }
         else
             throw new Error(topLevelHelp());
     }

package/dist/reap.js

@@ -0,0 +1,131 @@
+import { Registry } from "./registry.js";
+const MIN_POLL = 30, MAX_POLL = 300;
+/**
+ * Derived from the SHORTER active expiry: a 4h idle timeout paired with a 2m
+ * ttl must not poll on the 4h scale, or the ttl overshoots by minutes.
+ */
+export function pollInterval(lifecycle) {
+    const limits = [lifecycle.idleTimeout, lifecycle.ttl].filter((v) => typeof v === "number");
+    if (!limits.length)
+        return MAX_POLL;
+    return Math.min(MAX_POLL, Math.max(MIN_POLL, Math.floor(Math.min(...limits) / 6)));
+}
+/**
+ * `stop` means stop polling and leave the session alone; `reap` means stop the
+ * session. An entry with no recorded lifecycle — one written before the field
+ * existed — decides nothing, because absent must never read as zero.
+ */
+export function decide(entry, state) {
+    // Only TERMINAL statuses stop the chain. `starting` is what every healthy
+    // launch is when the job is first armed, and `unknown` is a diagnosis in
+    // progress, not a death — treating either as terminal loses the reaper.
+    if (["stopped", "exited", "failed"].includes(entry.status))
+        return { action: "stop" };
+    const idleTimeout = entry.idleTimeout ?? null, ttl = entry.ttl ?? null;
+    if (idleTimeout === null && ttl === null)
+        return { action: "stop" };
+    // The window is gone: something else already ended it, and re-arming would
+    // leave a job polling a session that does not exist.
+    if (!state)
+        return { action: "stop" };
+    const seconds = pollInterval({ idleTimeout, ttl });
+    // Checked before either expiry: killing a session someone is looking at is
+    // the worst thing this feature could do.
+    if (state.attached)
+        return { action: "rearm", seconds };
+    if (idleTimeout !== null && state.idle >= idleTimeout)
+        return { action: "reap" };
+    if (ttl !== null && state.age >= ttl)
+        return { action: "reap" };
+    return { action: "rearm", seconds };
+}
+/**
+ * One poll, run as a detached tmux job.
+ *
+ * The stop is handed to a SEPARATE detached process rather than performed
+ * here, and that is the whole point: this job is a child of the tmux server,
+ * and stopping the last session on that server makes the server exit and take
+ * this process with it — mid-stop. What is lost is everything after the
+ * process-tree teardown: the `status: "stopped"` write, the launch-log event,
+ * and the removal of the per-launch identity copy, which holds a copied
+ * credential. The row is then swept to `exited` by the registry's own liveness
+ * check, so it even looks like a crash rather than a reap.
+ */
+export async function reapCheck(opts) {
+    const rearm = async (seconds) => {
+        const schedule = opts.schedule ??
+            (async (s, argv) => {
+                const { TmuxHost } = await import("./hosts/tmux.js");
+                await new TmuxHost(opts.socket).schedule(s, argv);
+            });
+        await schedule(seconds, opts.argv);
+        return { action: "rearm", seconds };
+    };
+    try {
+        if (opts.stopNow) {
+            await stopSession(opts.home, opts.socket, opts.launchId);
+            return { action: "reap" };
+        }
+        const entries = await (opts.readEntries
+            ? opts.readEntries()
+            : new Registry(opts.home).all());
+        const entry = entries.find((e) => e.launchId === opts.launchId);
+        if (!entry || !entry.hostRef)
+            return { action: "stop" };
+        const state = opts.state !== undefined
+            ? opts.state
+            : await (async () => {
+                const { TmuxHost } = await import("./hosts/tmux.js");
+                return new TmuxHost(opts.socket).sessionState(entry.hostRef);
+            })();
+        const decision = decide(entry, state);
+        if (decision.action === "rearm")
+            return await rearm(decision.seconds);
+        if (decision.action === "reap") {
+            const [exec, script] = opts.argv;
+            if (!exec || !script)
+                return { action: "stop" };
+            const spawnFn = opts.spawn ??
+                ((e, args) => {
+                    // Detached and unref'd so it survives the tmux server exiting as the
+                    // session it is stopping goes away.
+                    void import("node:child_process").then(({ spawn }) => spawn(e, args, { detached: true, stdio: "ignore" }).unref());
+                });
+            spawnFn(exec, [...opts.argv.slice(1), "--stop-now"]);
+        }
+        return decision;
+    }
+    catch {
+        // A transient failure — a registry lock collision, a momentarily
+        // unreadable config — must not permanently disarm the session. Only a
+        // decision that means stop, stops. If even re-arming fails, there is
+        // nothing left to try.
+        try {
+            return await rearm(MAX_POLL);
+        }
+        catch {
+            return { action: "stop" };
+        }
+    }
+}
+async function stopSession(home, socket, launchId) {
+    const { TmuxHost } = await import("./hosts/tmux.js");
+    const { Muster } = await import("./run.js");
+    // The socket is passed explicitly: Muster.create() would otherwise build its
+    // drivers from MUSTER_TMUX_SERVER, and a mismatch makes stopEntry find no
+    // matching hostRef and fall through to killing the process tree blind. The
+    // whole reason --socket exists is that the registry records a window id, not
+    // the socket it lives on.
+    const muster = await Muster.create({
+        home,
+        drivers: [new TmuxHost(socket)],
+    });
+    try {
+        const entry = (await new Registry(home).all()).find((e) => e.launchId === launchId);
+        if (entry)
+            await muster.stop(entry.id);
+    }
+    finally {
+        await muster.close();
+    }
+}

package/dist/run.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { loadConfig } from "./config.js";
-import { runSchema, agentBaseEnv, assertAllowedWorkspace, assertLevelExclusive, resolveModel, launchArgs, launchEnv, paramsFingerprint, resolvePermissions, runtimeArgs, } from "./guard.js";
+import { runSchema, agentBaseEnv, assertAllowedWorkspace, assertLevelExclusive, resolveLifecycle, resolveModel, launchArgs, launchEnv, paramsFingerprint, resolvePermissions, runtimeArgs, } from "./guard.js";
 import { enforcementGrade } from "./enforcement.js";
 import { LOCAL } from "./requester.js";
 import { assertEnforcementMeetsMinimum, assertLevelWithinCeiling, assertMayAct, resolveIdentityForRequest, resolveRequesterPolicy, RequesterPolicyRefusal, } from "./requester-policy.js";
@@ -28,6 +28,7 @@ import { allocateLoopbackPort, OpenCodeHttp } from "./opencode-http.js";
 import { assertOpenCodeVersion, openCodeMcpNames, openCodeSessionLaunch, openCodeTaskLaunch, } from "./opencode-policy.js";
 import { assignNames, resolvePeer, runtimeName, } from "./naming.js";
 import { selectMcp, prepareMcp, mcpEnvironment } from "./mcp.js";
+import { pollInterval } from "./reap.js";
 import { selectPlugins } from "./plugins.js";
 function taskHandle(entry, pid) {
     return {
@@ -251,6 +252,12 @@ export class Muster {
             await assertClaudePolicy(this.hostEnv);
         if (req.runtime === "opencode")
             await assertOpenCodeVersion(this.hostEnv, "1.18.31", Date.now() + 4000);
+        // After the driver, not beside resolveModel: the host that runs is
+        // `req.host ?? config.host` with `auto` resolving to whatever is available,
+        // so only the selected driver knows whether a lifecycle can be honoured.
+        // Deciding from `req.host` accepts --idle-timeout under `host = "pty"` in
+        // config and then never arms it.
+        const lifecycle = resolveLifecycle(effective, this.config, req.kind === "session" && typeof driver?.schedule === "function");
         const { entry: reservation, deduped } = await this.registry.reserve({
             runtime: req.runtime,
             kind: req.kind,
@@ -259,6 +266,8 @@ export class Muster {
             enforcement,
             model: model?.model ?? null,
             modelSource: model?.source ?? null,
+            idleTimeout: lifecycle.idleTimeout,
+            ttl: lifecycle.ttl,
             // Recorded here rather than only at the patch below, because `list`
             // now publishes it: an entry that dies between this line and that one
             // would otherwise report no identity, which reads as "ran on the
@@ -438,6 +447,28 @@ export class Muster {
                 host: driver.id,
                 hostRef: launched.hostRef,
             });
+            // Armed only once hostRef exists: the job addresses the window, and a job
+            // armed before the window is recorded would poll a target the registry
+            // cannot name. `schedule` is optional on the host interface, so pty and
+            // macos-terminal opt out by not implementing it.
+            if (driver?.schedule && (lifecycle.idleTimeout ?? lifecycle.ttl))
+                await driver
+                    .schedule(pollInterval(lifecycle), [
+                    process.execPath,
+                    // ../dist/muster.js, not ./muster.js: this resolves from src/run.ts
+                    // under vitest as well as from dist/run.js in the package, landing
+                    // on <root>/dist either way. Same idiom as the tmux bootstrap.
+                    fileURLToPath(new URL("../dist/muster.js", import.meta.url)),
+                    "reap-check",
+                    "--home",
+                    this.home,
+                    "--socket",
+                    driver.server ?? "muster",
+                    entry.launchId,
+                ])
+                    // A lifecycle that cannot be armed must not fail the launch: the
+                    // session is up and usable, and the orphan risk is what we had before.
+                    .catch(() => { });
             let diagnostic = req.runtime === "claude"
                 ? "no Claude session registry found (check terminal for workspace trust or login prompts)"
                 : req.runtime === "opencode"
@@ -543,6 +574,10 @@ export class Muster {
                             // Same reason, for the same pair of records.
                             model: model?.model ?? null,
                             model_source: model?.source ?? null,
+                            ...(lifecycle.idleTimeout
+                                ? { idle_timeout: lifecycle.idleTimeout }
+                                : {}),
+                            ...(lifecycle.ttl ? { ttl: lifecycle.ttl } : {}),
                             attach_hint: driver.attachHint(launched.hostRef),
                         };
                         if (req.open) {
@@ -890,6 +925,8 @@ export class Muster {
                     ...(e.model !== undefined
                         ? { model: e.model, model_source: e.modelSource ?? null }
                         : {}),
+                    ...(e.idleTimeout ? { idle_timeout: e.idleTimeout } : {}),
+                    ...(e.ttl ? { ttl: e.ttl } : {}),
                     id: e.id,
                     runtime: e.peer?.runtime ?? e.runtime,
                     state: e.status === "running" ? (e.peer?.state ?? "idle") : e.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "0.7.21",
+  "version": "0.8.0",
   "description": "Launch instructed, reachable local agent sessions",
   "type": "module",
   "engines": {