@opencode-cockpit/shell 0.2.0 → 0.2.2

package/README.md

@@ -1,5 +1,12 @@
 # @opencode-cockpit/shell
 
+**Bay 01 of [Cockpit](https://github.com/Codestz/opencode-cockpit).**
+[Docs →](https://codestz.github.io/opencode-cockpit/shell/overview/) ·
+[Agent tools](https://codestz.github.io/opencode-cockpit/shell/tools/) ·
+[Watching health](https://codestz.github.io/opencode-cockpit/shell/watching/) ·
+[Panel and keys](https://codestz.github.io/opencode-cockpit/shell/interface/) ·
+[Configuration](https://codestz.github.io/opencode-cockpit/configuration/)
+
 [![npm](https://img.shields.io/npm/v/@opencode-cockpit/shell)](https://www.npmjs.com/package/@opencode-cockpit/shell)
 
 Background terminals for [OpenCode](https://opencode.ai) that the agent starts, waits on and
@@ -15,6 +22,10 @@ drives, and that you watch and control without leaving the chat. Part of
 - **Shells outlive OpenCode.** They run in a small daemon, `cockpitd`, shared by every OpenCode
   window and upgraded automatically when the plugin updates.
 
+![A dev server running in the shells panel](https://raw.githubusercontent.com/Codestz/opencode-cockpit/main/media/dock.gif)
+
+*Recorded from a real session, re-recorded on every release.*
+
 ## Install
 
 ```sh
@@ -74,12 +85,17 @@ A watch rule is three regexes, not a parser: `done` (a run ended), `fail` and `o
 tsc, eslint, biome, prettier, mypy, ruff, vitest, jest, mocha, bun test, deno test, pytest, rspec,
 phpunit, playwright, cypress, vite, next, nuxt, astro, angular, webpack/rspack, esbuild, tsup,
 turbo, metro, storybook, cargo, go, dotnet, gradle, maven, docker compose and terraform. Anything
-else takes its own patterns:
+else takes its own patterns, at `shell_start` or later:
 
 ```
+shell_start command="./deploy.sh" description="deploy" watch={ fail: "FAILED", ok: "SUCCEEDED", idleSeconds: 5 }
 shell_watch name="deploy" rule={ fail: "FAILED", ok: "SUCCEEDED", idleSeconds: 5 }
 ```
 
+When no preset fits and no rule is given — `sleep 300`, a plain script, anything that prints nothing
+recognizable — watching still works: the shell is watched for **dying** (preset `exit`), which is
+crash detection with no patterns to write.
+
 Things to ask:
 
 - *"Start the dev server in a background shell and wait until it's ready."*
@@ -91,9 +107,12 @@ Things to ask:
 | Key / command | Does |
 |---|---|
 | `ctrl+x o` · `/shells` | Toggle the shells panel under the chat |
+| `s` (in the console) | This conversation only, or the whole project |
 | `ctrl+x i` · `/shell` | Open the shell console |
 | `/shell-new` | Start a shell yourself |
 | `/shells-clear` | Remove finished shells |
+| `/shells-stop` | Stop the shells in view — this conversation, or the project |
+| `/shells-stop-all` | Stop every shell in the project, asking first about the ones you cannot see |
 | `/cockpit-update` | Update the plugin when a newer release exists |
 | `/shells-restart-daemon` | Restart `cockpitd` (asks first when shells are running) |
 
@@ -107,6 +126,10 @@ the program, `ctrl+]` to stop typing), `c` ctrl+c, `r` restart, `x` stop. Finish
 again, `d` remove. Always: `tab` screen or log, `/` search the log (`backspace` clears the filter),
 `?` details, `[` `]` switch shells, `D` clear finished, `esc` close.
 
+**One conversation at a time.** The panel lists the shells of the session you are in, because a
+project's shells mixed together is how it stops making sense. `s` in the console widens it to the
+whole project and back, and `shell_list` takes `session: "this" | "others" | "any"`.
+
 **Searching a long log.** In the console, `/` filters the scrollback to matching lines — keeping
 their original line numbers and highlighting the match — so a 40k-line dev server is one query away
 from the five lines you want. Filtering happens in the daemon, not the terminal.
@@ -147,11 +170,12 @@ working. (`XDG_CONFIG_HOME` is honoured for the global path.)
 | `kinds` | Extra shell categories, or overrides, as name → regex matched against the command. Drives the badges in the sidebar, panel and `shell_list`, so you can group your own stack (`e2e`, `infra`, `worker`) instead of the built-ins. |
 | `watch.presets` | Your own watch rules, or replacements for built-ins, keyed by name. A rule is `{ done?, fail?, ok?, idleSeconds?, ignoreCase? }` — patterns are regular expressions matched against each output line. The agent can then ask for `watch: "e2e"`. |
 | `watch.auto` | Attach a matching preset to every new shell without being asked. **Off by default**: watching is useful, but silently attaching rules to commands you didn't opt in surprises people. Turn it on once you trust your presets. |
+| `lifecycle` | When shells end by themselves. `onExit` (`stopMine` by default) stops this window's shells when it closes; `keep` leaves them for the next window. `orphanAfterMinutes` (60) stops a shell that no window has claimed for that long — the answer to shells running for a week. |
 | `defaults` | Applied to every shell the agent starts unless the call says otherwise: `watch` (`true` for a matching preset, or a preset name), `logFile`, `idleTimeoutSeconds`, `timeoutSeconds`, `notifyOnExit`. |
 | `notify` | What may interrupt the agent — `exit`, `watch`, and `tailLines` (output lines included in an exit message). |
 | `guidance` | The system-prompt paragraph that teaches the agent when to use shells. `false` saves ~120 tokens per request, at the cost of a model that uses shells less well. |
 | `listRunningShells` | How many running shells are listed in the system prompt each turn (~20 tokens each). `0` disables it; the agent can still call `shell_list`. |
-| `ui` | Interface only: `dockHeight`, `dockOpen`, `sidebarRows`, `historyMinutes`, `colors`, `defaultView` (`"screen"` or `"log"`), `keybinds`, `updateCheck`. |
+| `ui` | Interface only: `dockHeight`, `dockOpen` (set it and the panel always starts that way; leave it out and it starts as you last left it), `sidebarRows`, `historyMinutes`, `colors`, `defaultView` (`"screen"` or `"log"`), `keybinds`, `updateCheck`. |
 
 The same settings can go on the plugin entry instead, which is handy for one-offs and for machines
 where you'd rather keep everything in `tui.json`/`opencode.json`:

package/dist/agent/plugin.js

@@ -44,8 +44,9 @@ async function shellHooks({
   directory
 }, options) {
   const config = loadConfig(directory, options);
-  const cockpit = createClient("opencode-cockpit/server");
+  // Identifies this OpenCode window to the daemon, so shells can end with it.
   const instance = crypto.randomUUID();
+  const cockpit = createClient("opencode-cockpit/server", instance);
   const quiet = new Set();
   const userShell = process.env.SHELL && /(bash|zsh|fish|sh)$/.test(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
   const env = () => {

package/dist/agent/tools/start.js

@@ -48,7 +48,13 @@ export function shellStart(kit) {
         timeoutSeconds: z.number().positive().max(3600).default(120)
       }).optional().describe("Block until ready. Same conditions as shell_wait."),
       notifyOnExit: z.boolean().default(true).describe("Message you when the process exits"),
-      watch: z.union([z.boolean(), z.string()]).optional().describe('Watch this shell\'s health and message you only when it changes: true or "auto" picks a preset from the command, or name one (tsc, vitest, cargo…). For processes that never exit.'),
+      watch: z.union([z.boolean(), z.string(), z.object({
+        done: z.string().optional().describe("A run finished, e.g. 'Found \\d+ errors'"),
+        fail: z.string().optional(),
+        ok: z.string().optional(),
+        ignoreCase: z.boolean().optional(),
+        idleSeconds: z.number().positive().optional()
+      })]).optional().describe('Watch this shell\'s health and message you only when it changes. true or "auto" picks a preset from the command (tsc, vitest, cargo…) and falls back to reporting the process dying; a name picks that preset; an object is your own rule, e.g. { done: "\\d+ (passed|failed)", fail: "\\d+ failed" }.'),
       timeoutSeconds: z.number().int().positive().optional().describe("Stop the process after this long, busy or not. Good for bounded jobs and probes."),
       idleTimeoutSeconds: z.number().int().positive().optional().describe("Stop the process after this much silence. Never use it for dev servers, which are idle when healthy."),
       logFile: z.boolean().default(false).describe("Also write the clean log to a file, so old lines survive the in-memory buffer")
@@ -60,6 +66,9 @@ export function shellStart(kit) {
       const logFile = args.logFile ?? defaults.logFile ?? false;
       const notifyOnExit = args.notifyOnExit ?? defaults.notifyOnExit ?? true;
       const watch = args.watch ?? defaults.watch ?? (config.watch?.auto ? "auto" : undefined);
+      // Nothing should outlive the window that asked for it by more than the user allows.
+      const lifecycle = config.lifecycle ?? {};
+      const orphanMinutes = lifecycle.orphanAfterMinutes ?? 60;
       const shell = deps.shellCommand(args.command);
       const info = await client.call("shell.start", {
         command: shell.command,
@@ -78,6 +87,8 @@ export function shellStart(kit) {
         timeoutMs: seconds(args.timeoutSeconds ?? defaults.timeoutSeconds),
         idleTimeoutMs: seconds(args.idleTimeoutSeconds ?? defaults.idleTimeoutSeconds),
         logFile: logFile === true,
+        stopOnExit: (lifecycle.onExit ?? "stopMine") === "stopMine",
+        orphanAfterMs: orphanMinutes > 0 ? orphanMinutes * 60_000 : undefined,
         reuse: true
       });
       if (notifyOnExit === false) deps.quiet.add(info.id);else deps.quiet.delete(info.id);
@@ -91,11 +102,10 @@ export function shellStart(kit) {
       if (info.status === "failed") return `${header(info)}\n${describeStatus(info)}\n</shell>`;
       const lines = [info.run > 1 ? `Restarted ${info.id} (run ${info.run}): same command as an earlier finished shell in this session. Earlier output is above line ${info.lines.last}.` : `Started ${info.id}: ${args.command}`];
       if (watch) {
-        const preset = typeof watch === "string" ? watch : "auto";
         await client.call("shell.watch", {
           id: info.id,
-          ...watchArgs(preset, config)
-        }).then(watched => lines.push(`watching health (${watched.watch?.preset ?? "custom rule"}); changes will be messaged to you`)).catch(err => lines.push(`could not watch: ${err instanceof Error ? err.message : String(err)}`));
+          ...watchArgs(watch, config)
+        }).then(watched => lines.push(describeWatch(watched))).catch(err => lines.push(`could not watch: ${err instanceof Error ? err.message : String(err)}`));
       }
       if (args.waitFor) {
         const {
@@ -134,6 +144,13 @@ export function shellStart(kit) {
   });
 }
 
+/** What was actually attached: a preset, your own rule, or plain crash reporting. */
+function describeWatch(info) {
+  const preset = info.watch?.preset;
+  if (preset === "exit") return "watching: no health patterns fit this command, so you will be messaged if it dies";
+  return `watching health (${preset ?? "custom rule"}); changes will be messaged to you`;
+}
+
 /** Milliseconds from an option in seconds, or undefined when unset. */
 function seconds(value) {
   return value ? Math.round(value * 1000) : undefined;

package/dist/agent/tools/watch-args.js

@@ -1,12 +1,60 @@
+/** A backslash that JSON does not allow — `\d`, `\s`, `\(` — i.e. someone wrote a regex in here. */
+const LONE_ESCAPE = /\\(?!["\\/bfnrtu])/g;
+
 /**
- * Turns a preset name into what `shell.watch` needs. A preset defined in config is sent as an
- * explicit rule, so users can add tools or correct a built-in without touching the daemon.
+ * Rules are regexes, and a regex written inside JSON text is usually under-escaped (`"\d+ passed"`
+ * is not valid JSON). Parse it as written first, then again with those backslashes escaped, so a
+ * model's JSON does not have to be perfect for its patterns to survive.
  */
-export function watchArgs(preset, config) {
+function parseLoosely(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    try {
+      return JSON.parse(text.replace(LONE_ESCAPE, "\\\\"));
+    } catch {
+      return undefined; // not JSON at all: treated as a preset name, which says so downstream
+    }
+  }
+}
+
+/** The keys a rule may carry; anything else in an object is not a rule. */
+const RULE_KEYS = new Set(["done", "fail", "ok", "ignoreCase", "idleSeconds"]);
+
+/**
+ * Turns whatever the model passed for `watch` into what `shell.watch` needs.
+ *
+ * `true`/`"auto"` asks the daemon to pick a preset, a name picks that preset — and a preset defined
+ * in config travels as an explicit rule, so users can add tools without touching the daemon. Rule
+ * objects arrive as JSON *strings* often enough (models write one, and tool args are not always
+ * parsed the way the schema says) that a string which looks like an object is parsed rather than
+ * handed on as a preset name nobody has.
+ */
+export function watchArgs(watch, config) {
+  const rule = asWatchRule(watch);
+  if (rule) return {
+    rule
+  };
+  const preset = watch === true || watch == null ? "auto" : String(watch);
   const custom = config.watch?.presets?.[preset];
   return custom ? {
     rule: custom
   } : {
     preset
   };
+}
+
+/** A rule from an object, or from the JSON string a model sometimes writes instead. */
+export function asWatchRule(value) {
+  let candidate = value;
+  if (typeof candidate === "string") {
+    const text = candidate.trim();
+    if (!text.startsWith("{")) return undefined;
+    const parsed = parseLoosely(text);
+    if (parsed === undefined) return undefined;
+    candidate = parsed;
+  }
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return undefined;
+  const entries = Object.entries(candidate).filter(([k, v]) => RULE_KEYS.has(k) && v != null);
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }

package/dist/agent/tools/watch.js

@@ -1,13 +1,15 @@
 import { tool } from "@opencode-ai/plugin";
-import { watchArgs } from "./watch-args.js";
+import { asWatchRule, watchArgs } from "./watch-args.js";
 const WATCH = `Keep an eye on a long-running shell and be told only when its health changes.
 
 For processes that never exit (tsc --watch, vitest --watch, dev servers) this replaces re-reading
 the log: you get one message when it breaks, and one when it is fixed, and nothing while it repeats
 the same result.
 
-- preset: a named rule ("auto" picks one from the command). Presets exist for tsc, vitest, jest,
-  eslint, biome, cargo, go, gradle, pytest, vite, next, docker-compose and more.
+- preset: a named rule ("auto" picks one from the command, and falls back to reporting the process
+  dying when no patterns fit). Presets exist for tsc, vitest, jest, eslint, biome, cargo, go,
+  gradle, pytest, vite, next, docker-compose and more; "exit" watches only for the process dying,
+  which is how you get crash detection for a command that prints nothing useful.
 - rule: your own patterns when no preset fits: done (a run ended), fail, ok, idleSeconds.
 - off: stop watching.
 
@@ -56,17 +58,13 @@ export function shellWatch(kit) {
         return `${note}stopped watching ${stopped.id}`;
       }
       // A preset defined in config travels as an explicit rule; the daemon knows only the built-ins.
+      // Both arguments absorb a rule written as JSON, rather than failing on a preset name nobody has.
       const chosen = args.preset ? watchArgs(args.preset, config) : {};
+      const rule = asWatchRule(args.rule) ?? chosen.rule;
       const info = await client.call("shell.watch", {
         id,
-        preset: chosen.preset,
-        rule: args.rule ? {
-          done: args.rule.done ?? undefined,
-          fail: args.rule.fail ?? undefined,
-          ok: args.rule.ok ?? undefined,
-          ignoreCase: args.rule.ignoreCase ?? undefined,
-          idleSeconds: args.rule.idleSeconds ?? undefined
-        } : chosen.rule
+        preset: rule ? undefined : chosen.preset,
+        rule
       });
       return `${note}watching ${info.id} (${info.watch?.preset ?? "custom rule"}). You will be messaged when its health changes; no need to poll.`;
     }

package/dist/connect.js

@@ -14,13 +14,14 @@ export function daemonEntry() {
  * BUN_BE_BUN=1 so it runs on OpenCode's embedded Bun (ADR 0001). The expected build lets the
  * client replace a daemon left running from older plugin code.
  */
-export function createClient(name) {
+export function createClient(name, instance) {
   const entry = daemonEntry();
   return new CockpitClient({
     client: {
       name,
       version: pkg.version,
-      pid: process.pid
+      pid: process.pid,
+      instance
     },
     spawn: {
       entry,

package/dist/core/config.js

@@ -53,6 +53,10 @@ export function mergeConfig(base, over) {
       ...base.defaults,
       ...over.defaults
     },
+    lifecycle: {
+      ...base.lifecycle,
+      ...over.lifecycle
+    },
     notify: {
       ...base.notify,
       ...over.notify
@@ -76,7 +80,7 @@ function asConfig(input) {
   if (!input || typeof input !== "object") return {};
   const raw = input;
   const config = {};
-  for (const key of ["watch", "kinds", "defaults", "notify", "ui"]) {
+  for (const key of ["watch", "kinds", "defaults", "lifecycle", "notify", "ui"]) {
     const value = raw[key];
     if (value && typeof value === "object") Object.assign(config, {
       [key]: value

package/dist/core/format.js

@@ -16,17 +16,42 @@ export function formatLines(lines) {
   return out.join("\n");
 }
 export function describeStatus(info) {
+  const ran = () => duration((info.endedAt ?? Date.now()) - info.startedAt);
   switch (info.status) {
     case "running":
       return `running (pid ${info.pid}, up ${duration(Date.now() - info.startedAt)})`;
     case "exited":
-      return `exited with code ${info.exitCode ?? "?"} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`;
+      return info.exitCode === 0 ? `exited cleanly after ${ran()}` : `crashed with exit code ${info.exitCode ?? "?"} after ${ran()}`;
     case "killed":
-      return `killed${info.signal ? ` by ${info.signal}` : ""} after ${duration((info.endedAt ?? Date.now()) - info.startedAt)}`;
+      return `${stopPhrase(info)} after ${ran()}`;
     case "failed":
       return `failed to start: ${info.error ?? "unknown error"}`;
   }
 }
+
+/** Who ended a shell, and why — "killed by SIGTERM" alone never said which of us did it. */
+function stopPhrase(info) {
+  switch (info.stopReason) {
+    case "timeout":
+      return "stopped: hit its time limit";
+    case "idle":
+      return "stopped: no output for its idle limit";
+    case "shutdown":
+      return "stopped because the shell daemon shut down";
+    case "request":
+      return `stopped by ${actor(info.stoppedBy)}`;
+    default:
+      return info.exitCode != null && info.exitCode !== 0 ? `crashed (exit code ${info.exitCode})` : `killed${info.signal ? ` by ${info.signal}` : ""} from outside`;
+  }
+}
+
+/** Client names are wire identifiers; say them the way a person would. */
+function actor(client) {
+  if (!client) return "a request";
+  if (client.includes("tui")) return "you, from the shells panel";
+  if (client.includes("server")) return "the agent";
+  return client;
+}
 export function header(info) {
   const run = info.run > 1 ? ` run=${info.run}` : "";
   return `<shell id="${info.id}" title="${info.title.replaceAll('"', "'")}" status="${info.status}"${run}>`;

package/dist/tui/components/console.js

@@ -271,6 +271,10 @@ export function Console(props) {
       name: "cockpit.console.top",
       title: "Scroll to top",
       run: () => scroll?.scrollTo(0)
+    }, {
+      name: "cockpit.console.scope",
+      title: "This session / whole project",
+      run: () => props.store.toggleScope()
     }, {
       name: "cockpit.console.close",
       title: "Close console",
@@ -328,6 +332,10 @@ export function Console(props) {
       key: "n",
       cmd: "cockpit.console.new",
       desc: "New"
+    }, {
+      key: "s",
+      cmd: "cockpit.console.scope",
+      desc: "Scope"
     }, {
       key: "j,down",
       cmd: "cockpit.console.down",
@@ -380,6 +388,7 @@ export function Console(props) {
     if (view() !== "details") keys.push(label("/ search log", "/"));
     keys.push(label("? details", "?"));
     if (props.store.shells().length > 1) keys.push(label("[ ] switch", "[ ]"));
+    keys.push(props.store.scope() === "session" ? label("s whole project", "s project") : label("s this session", "s session"));
     if (finished() > 0) keys.push(label("D clear done", "D"));
     keys.push(label("n new", "n"), "esc");
     return keys.join(" · ");

package/dist/tui/components/dock.js

@@ -1,7 +1,7 @@
 import { effect as _$effect } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
 import { insert as _$insert } from "@opentui/solid";
 import { memo as _$memo } from "@opentui/solid";
-import { createComponent as _$createComponent } from "@opentui/solid";
 import { createTextNode as _$createTextNode } from "@opentui/solid";
 import { insertNode as _$insertNode } from "@opentui/solid";
 import { setProp as _$setProp } from "@opentui/solid";
@@ -33,15 +33,17 @@ export function Dock(props) {
       _el$2 = _$createElement("box"),
       _el$3 = _$createElement("text"),
       _el$4 = _$createElement("b"),
-      _el$7 = _$createElement("box"),
-      _el$8 = _$createElement("text");
+      _el$6 = _$createElement("text"),
+      _el$8 = _$createElement("box"),
+      _el$9 = _$createElement("text");
     _$insertNode(_el$, _el$2);
     _$setProp(_el$, "flexShrink", 0);
     _$setProp(_el$, "flexDirection", "column");
     _$setProp(_el$, "border", ["top"]);
     _$insertNode(_el$2, _el$3);
-    _$insertNode(_el$2, _el$7);
+    _$insertNode(_el$2, _el$6);
     _$insertNode(_el$2, _el$8);
+    _$insertNode(_el$2, _el$9);
     _$setProp(_el$2, "flexDirection", "row");
     _$setProp(_el$2, "gap", 1);
     _$setProp(_el$2, "paddingLeft", 1);
@@ -52,17 +54,19 @@ export function Dock(props) {
     _$insertNode(_el$3, _el$4);
     _$setProp(_el$3, "flexShrink", 0);
     _$insertNode(_el$4, _$createTextNode(`Shells`));
+    _$setProp(_el$6, "flexShrink", 0);
+    _$insert(_el$6, () => props.store.scope() === "session" ? "this session" : "project");
     _$insert(_el$2, _$createComponent(Show, {
       get when() {
         return props.store.shells().length > 0;
       },
       get fallback() {
         return (() => {
-          var _el$9 = _$createElement("text");
-          _$insertNode(_el$9, _$createTextNode(`none yet · the agent starts them, or /shell-new`));
-          _$setProp(_el$9, "wrapMode", "none");
-          _$effect(_$p => _$setProp(_el$9, "fg", theme().textMuted, _$p));
-          return _el$9;
+          var _el$0 = _$createElement("text");
+          _$insertNode(_el$0, _$createTextNode(`none yet · the agent starts them, or /shell-new`));
+          _$setProp(_el$0, "wrapMode", "none");
+          _$effect(_$p => _$setProp(_el$0, "fg", theme().textMuted, _$p));
+          return _el$0;
         })();
       },
       get children() {
@@ -73,15 +77,15 @@ export function Dock(props) {
           children: shell => {
             const active = () => props.store.selected()?.id === shell.id;
             return (() => {
-              var _el$1 = _$createElement("box"),
-                _el$10 = _$createElement("text"),
-                _el$11 = _$createTextNode(` `);
-              _$insertNode(_el$1, _el$10);
-              _$setProp(_el$1, "flexDirection", "row");
-              _$setProp(_el$1, "flexShrink", 0);
-              _$setProp(_el$1, "paddingRight", 1);
-              _$setProp(_el$1, "onMouseUp", () => active() ? props.onOpenConsole(shell.id) : props.store.select(shell.id));
-              _$insert(_el$1, _$createComponent(Badge, {
+              var _el$10 = _$createElement("box"),
+                _el$11 = _$createElement("text"),
+                _el$12 = _$createTextNode(` `);
+              _$insertNode(_el$10, _el$11);
+              _$setProp(_el$10, "flexDirection", "row");
+              _$setProp(_el$10, "flexShrink", 0);
+              _$setProp(_el$10, "paddingRight", 1);
+              _$setProp(_el$10, "onMouseUp", () => active() ? props.onOpenConsole(shell.id) : props.store.select(shell.id));
+              _$insert(_el$10, _$createComponent(Badge, {
                 get api() {
                   return props.api;
                 },
@@ -89,28 +93,28 @@ export function Dock(props) {
                 get frame() {
                   return props.store.frame();
                 }
-              }), _el$10);
-              _$insertNode(_el$10, _el$11);
-              _$setProp(_el$10, "wrapMode", "none");
-              _$insert(_el$10, (() => {
+              }), _el$11);
+              _$insertNode(_el$11, _el$12);
+              _$setProp(_el$11, "wrapMode", "none");
+              _$insert(_el$11, (() => {
                 var _c$2 = _$memo(() => !!active());
                 return () => _c$2() ? (() => {
-                  var _el$12 = _$createElement("b");
-                  _$insert(_el$12, () => truncate(shell.title, 22));
-                  return _el$12;
+                  var _el$13 = _$createElement("b");
+                  _$insert(_el$13, () => truncate(shell.title, 22));
+                  return _el$13;
                 })() : truncate(shell.title, 22);
               })(), null);
               _$effect(_p$ => {
-                var _v$6 = active() ? theme().backgroundElement : theme().backgroundPanel,
-                  _v$7 = active() ? theme().text : theme().textMuted;
-                _v$6 !== _p$.e && (_p$.e = _$setProp(_el$1, "backgroundColor", _v$6, _p$.e));
-                _v$7 !== _p$.t && (_p$.t = _$setProp(_el$10, "fg", _v$7, _p$.t));
+                var _v$7 = active() ? theme().backgroundElement : theme().backgroundPanel,
+                  _v$8 = active() ? theme().text : theme().textMuted;
+                _v$7 !== _p$.e && (_p$.e = _$setProp(_el$10, "backgroundColor", _v$7, _p$.e));
+                _v$8 !== _p$.t && (_p$.t = _$setProp(_el$11, "fg", _v$8, _p$.t));
                 return _p$;
               }, {
                 e: undefined,
                 t: undefined
               });
-              return _el$1;
+              return _el$10;
             })();
           }
         }), _$createComponent(Show, {
@@ -118,132 +122,132 @@ export function Dock(props) {
             return overflow() > 0 || props.store.showAll();
           },
           get children() {
-            var _el$6 = _$createElement("text");
-            _$setProp(_el$6, "wrapMode", "none");
-            _$setProp(_el$6, "flexShrink", 0);
-            _$setProp(_el$6, "onMouseUp", () => props.store.toggleAll());
-            _$insert(_el$6, (() => {
+            var _el$7 = _$createElement("text");
+            _$setProp(_el$7, "wrapMode", "none");
+            _$setProp(_el$7, "flexShrink", 0);
+            _$setProp(_el$7, "onMouseUp", () => props.store.toggleAll());
+            _$insert(_el$7, (() => {
               var _c$ = _$memo(() => !!props.store.showAll());
               return () => _c$() ? "▾ fewer" : `▸ ${overflow()} more`;
             })());
-            _$effect(_$p => _$setProp(_el$6, "fg", theme().textMuted, _$p));
-            return _el$6;
+            _$effect(_$p => _$setProp(_el$7, "fg", theme().textMuted, _$p));
+            return _el$7;
           }
         })];
       }
-    }), _el$7);
-    _$setProp(_el$7, "flexGrow", 1);
-    _$setProp(_el$8, "wrapMode", "none");
-    _$setProp(_el$8, "flexShrink", 0);
-    _$insert(_el$8, () => props.hint());
+    }), _el$8);
+    _$setProp(_el$8, "flexGrow", 1);
+    _$setProp(_el$9, "wrapMode", "none");
+    _$setProp(_el$9, "flexShrink", 0);
+    _$insert(_el$9, () => props.hint());
     _$insert(_el$, _$createComponent(Show, {
       get when() {
         return props.store.selected();
       },
       children: shell => [(() => {
-        var _el$13 = _$createElement("box");
-        _$setProp(_el$13, "flexGrow", 1);
-        _$setProp(_el$13, "paddingLeft", 2);
-        _$setProp(_el$13, "paddingRight", 1);
-        _$setProp(_el$13, "minHeight", 0);
-        _$setProp(_el$13, "overflow", "hidden");
-        _$setProp(_el$13, "onMouseUp", () => props.onOpenConsole(shell().id));
-        _$insert(_el$13, _$createComponent(Show, {
+        var _el$14 = _$createElement("box");
+        _$setProp(_el$14, "flexGrow", 1);
+        _$setProp(_el$14, "paddingLeft", 2);
+        _$setProp(_el$14, "paddingRight", 1);
+        _$setProp(_el$14, "minHeight", 0);
+        _$setProp(_el$14, "overflow", "hidden");
+        _$setProp(_el$14, "onMouseUp", () => props.onOpenConsole(shell().id));
+        _$insert(_el$14, _$createComponent(Show, {
           get when() {
             return bodyRuns().length > 0;
           },
           get fallback() {
             return (() => {
-              var _el$19 = _$createElement("text");
-              _$setProp(_el$19, "wrapMode", "none");
-              _$insert(_el$19, () => body() || " ");
-              _$effect(_$p => _$setProp(_el$19, "fg", theme().text, _$p));
-              return _el$19;
+              var _el$20 = _$createElement("text");
+              _$setProp(_el$20, "wrapMode", "none");
+              _$insert(_el$20, () => body() || " ");
+              _$effect(_$p => _$setProp(_el$20, "fg", theme().text, _$p));
+              return _el$20;
             })();
           },
           get children() {
-            var _el$14 = _$createElement("box");
-            _$setProp(_el$14, "flexDirection", "column");
-            _$insert(_el$14, _$createComponent(For, {
+            var _el$15 = _$createElement("box");
+            _$setProp(_el$15, "flexDirection", "column");
+            _$insert(_el$15, _$createComponent(For, {
               get each() {
                 return bodyRuns();
               },
               children: row => (() => {
-                var _el$20 = _$createElement("text"),
-                  _el$21 = _$createTextNode(` `);
-                _$insertNode(_el$20, _el$21);
-                _$setProp(_el$20, "wrapMode", "none");
-                _$insert(_el$20, _$createComponent(For, {
+                var _el$21 = _$createElement("text"),
+                  _el$22 = _$createTextNode(` `);
+                _$insertNode(_el$21, _el$22);
+                _$setProp(_el$21, "wrapMode", "none");
+                _$insert(_el$21, _$createComponent(For, {
                   each: row,
                   children: run => (() => {
-                    var _el$22 = _$createElement("span");
-                    _$insert(_el$22, () => run.text);
-                    _$effect(_$p => _$setProp(_el$22, "style", {
+                    var _el$23 = _$createElement("span");
+                    _$insert(_el$23, () => run.text);
+                    _$effect(_$p => _$setProp(_el$23, "style", {
                       fg: run.fg,
                       bg: run.bg,
                       bold: run.bold,
                       italic: run.italic
                     }, _$p));
-                    return _el$22;
+                    return _el$23;
                   })()
-                }), _el$21);
-                _$effect(_$p => _$setProp(_el$20, "fg", theme().text, _$p));
-                return _el$20;
+                }), _el$22);
+                _$effect(_$p => _$setProp(_el$21, "fg", theme().text, _$p));
+                return _el$21;
               })()
             }));
-            return _el$14;
+            return _el$15;
           }
         }));
-        return _el$13;
+        return _el$14;
       })(), (() => {
-        var _el$15 = _$createElement("box"),
-          _el$16 = _$createElement("text");
-        _$insertNode(_el$15, _el$16);
-        _$setProp(_el$15, "flexDirection", "row");
-        _$setProp(_el$15, "gap", 1);
-        _$setProp(_el$15, "paddingLeft", 2);
-        _$setProp(_el$15, "flexShrink", 0);
-        _$setProp(_el$15, "height", 1);
-        _$setProp(_el$15, "overflow", "hidden");
-        _$setProp(_el$16, "wrapMode", "none");
+        var _el$16 = _$createElement("box"),
+          _el$17 = _$createElement("text");
+        _$insertNode(_el$16, _el$17);
+        _$setProp(_el$16, "flexDirection", "row");
+        _$setProp(_el$16, "gap", 1);
+        _$setProp(_el$16, "paddingLeft", 2);
         _$setProp(_el$16, "flexShrink", 0);
-        _$insert(_el$16, () => statusDetail(shell(), props.store.now()));
-        _$insert(_el$15, _$createComponent(Show, {
+        _$setProp(_el$16, "height", 1);
+        _$setProp(_el$16, "overflow", "hidden");
+        _$setProp(_el$17, "wrapMode", "none");
+        _$setProp(_el$17, "flexShrink", 0);
+        _$insert(_el$17, () => statusDetail(shell(), props.store.now()));
+        _$insert(_el$16, _$createComponent(Show, {
           get when() {
             return watchLabel(shell());
           },
           get children() {
-            var _el$17 = _$createElement("text");
-            _$setProp(_el$17, "wrapMode", "none");
-            _$setProp(_el$17, "flexShrink", 0);
-            _$insert(_el$17, () => watchLabel(shell()));
-            _$effect(_$p => _$setProp(_el$17, "fg", watchColor(theme(), shell()), _$p));
-            return _el$17;
+            var _el$18 = _$createElement("text");
+            _$setProp(_el$18, "wrapMode", "none");
+            _$setProp(_el$18, "flexShrink", 0);
+            _$insert(_el$18, () => watchLabel(shell()));
+            _$effect(_$p => _$setProp(_el$18, "fg", watchColor(theme(), shell()), _$p));
+            return _el$18;
           }
         }), null);
-        _$insert(_el$15, _$createComponent(Show, {
+        _$insert(_el$16, _$createComponent(Show, {
           get when() {
             return _$memo(() => kindOf(shell()) === "fail")() && shell().summary;
           },
           get fallback() {
             return (() => {
-              var _el$23 = _$createElement("text");
-              _$setProp(_el$23, "wrapMode", "none");
-              _$insert(_el$23, () => truncate(`$ ${displayCommand(shell())}`, Math.max(20, dims().width - 40)));
-              _$effect(_$p => _$setProp(_el$23, "fg", theme().textMuted, _$p));
-              return _el$23;
+              var _el$24 = _$createElement("text");
+              _$setProp(_el$24, "wrapMode", "none");
+              _$insert(_el$24, () => truncate(`$ ${displayCommand(shell())}`, Math.max(20, dims().width - 40)));
+              _$effect(_$p => _$setProp(_el$24, "fg", theme().textMuted, _$p));
+              return _el$24;
             })();
           },
           get children() {
-            var _el$18 = _$createElement("text");
-            _$setProp(_el$18, "wrapMode", "none");
-            _$insert(_el$18, () => truncate(`${shell().summary}`, Math.max(20, dims().width - 40)));
-            _$effect(_$p => _$setProp(_el$18, "fg", theme().error, _$p));
-            return _el$18;
+            var _el$19 = _$createElement("text");
+            _$setProp(_el$19, "wrapMode", "none");
+            _$insert(_el$19, () => truncate(`${shell().summary}`, Math.max(20, dims().width - 40)));
+            _$effect(_$p => _$setProp(_el$19, "fg", theme().error, _$p));
+            return _el$19;
           }
         }), null);
-        _$effect(_$p => _$setProp(_el$16, "fg", kindColor(theme(), kindOf(shell())), _$p));
-        return _el$15;
+        _$effect(_$p => _$setProp(_el$17, "fg", kindColor(theme(), kindOf(shell())), _$p));
+        return _el$16;
       })()]
     }), null);
     _$effect(_p$ => {
@@ -251,19 +255,22 @@ export function Dock(props) {
         _v$2 = theme().border,
         _v$3 = theme().backgroundPanel,
         _v$4 = theme().text,
-        _v$5 = theme().textMuted;
+        _v$5 = theme().textMuted,
+        _v$6 = theme().textMuted;
       _v$ !== _p$.e && (_p$.e = _$setProp(_el$, "height", _v$, _p$.e));
       _v$2 !== _p$.t && (_p$.t = _$setProp(_el$, "borderColor", _v$2, _p$.t));
       _v$3 !== _p$.a && (_p$.a = _$setProp(_el$, "backgroundColor", _v$3, _p$.a));
       _v$4 !== _p$.o && (_p$.o = _$setProp(_el$3, "fg", _v$4, _p$.o));
-      _v$5 !== _p$.i && (_p$.i = _$setProp(_el$8, "fg", _v$5, _p$.i));
+      _v$5 !== _p$.i && (_p$.i = _$setProp(_el$6, "fg", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = _$setProp(_el$9, "fg", _v$6, _p$.n));
       return _p$;
     }, {
       e: undefined,
       t: undefined,
       a: undefined,
       o: undefined,
-      i: undefined
+      i: undefined,
+      n: undefined
     });
     return _el$;
   })();

package/dist/tui/dialogs.js

@@ -89,7 +89,8 @@ export function newShell(api, store, open) {
         cwd: store.project(),
         title: command.slice(0, 60),
         owner: {
-          project: store.project()
+          project: store.project(),
+          session: store.session()
         },
         reuse: true
       }).then(info => {
@@ -135,6 +136,52 @@ export function restartDaemon(api, store) {
     onCancel: () => api.ui.dialog.clear()
   }));
 }
+
+/**
+ * Stopping shells in bulk. Two commands rather than one, because "everything I can see" and
+ * "everything, including what I cannot" are different intentions — and the second one asks first.
+ */
+export function stopShells(api, store, reach) {
+  const list = (reach === "view" ? store.shells() : store.all()).filter(s => s.status === "running");
+  if (list.length === 0) {
+    api.ui.toast({
+      title: "Shells",
+      message: "Nothing is running.",
+      duration: 3000
+    });
+    return;
+  }
+  const stop = () => {
+    api.ui.dialog.clear();
+    void Promise.all(list.map(shell => store.client.call("shell.stop", {
+      id: shell.id,
+      graceMs: 2000
+    }).catch(() => {}))).then(() => {
+      void store.refresh();
+      api.ui.toast({
+        title: "Shells",
+        message: `Stopped ${list.length} shell${list.length === 1 ? "" : "s"}.`,
+        duration: 4000
+      });
+    });
+  };
+
+  // Shells from other conversations are the ones you are not looking at; say so before killing them.
+  const elsewhere = reach === "project" ? list.length - store.shells().filter(s => s.status === "running").length : 0;
+  if (elsewhere <= 0) {
+    stop();
+    return;
+  }
+  const DialogConfirm = api.ui.DialogConfirm;
+  api.ui.dialog.replace(() => _$createComponent(DialogConfirm, {
+    title: "Stop every shell in this project?",
+    get message() {
+      return `${list.length} running · ${elsewhere} from other conversations.`;
+    },
+    onConfirm: stop,
+    onCancel: () => api.ui.dialog.clear()
+  }));
+}
 export function pickShell(api, store, open) {
   const DialogSelect = api.ui.DialogSelect;
   const shells = order(store.shells());

package/dist/tui/index.js

@@ -11,7 +11,7 @@ import { loadConfig } from "../core/config.js";
 import { Console } from "./components/console.js";
 import { Dock } from "./components/dock.js";
 import { SidebarShells } from "./components/sidebar.js";
-import { announceUpdate, newShell, offerUpdate, pickShell, restartDaemon } from "./dialogs.js";
+import { announceUpdate, newShell, offerUpdate, pickShell, restartDaemon, stopShells } from "./dialogs.js";
 import { createShellStore } from "./state/store.js";
 const DEFAULT_KEYS = {
   "cockpit.shells.dock": "<leader>o",
@@ -55,7 +55,10 @@ const shellTui = async (api, rawOptions, meta) => {
     ...DEFAULT_KEYS,
     ...options.keybinds
   });
-  const [dockOpen, setDockOpen] = createSignal(api.kv.get("cockpit.dock.open", options.dockOpen ?? false));
+
+  // An explicit `ui.dockOpen` says how the panel should start; without one, whatever you last left
+  // it as. Remembered state that overrides a written setting is a setting that appears to do nothing.
+  const [dockOpen, setDockOpen] = createSignal(options.dockOpen ?? api.kv.get("cockpit.dock.open", false));
   const toggleDock = () => {
     const next = !dockOpen();
     setDockOpen(next);
@@ -107,6 +110,20 @@ const shellTui = async (api, rawOptions, meta) => {
       namespace: "palette",
       slashName: "shell-new",
       run: () => newShell(api, store, openConsole)
+    }, {
+      name: "cockpit.shells.stop",
+      title: "Stop the shells in view",
+      category: "Shells",
+      namespace: "palette",
+      slashName: "shells-stop",
+      run: () => stopShells(api, store, "view")
+    }, {
+      name: "cockpit.shells.stopAll",
+      title: "Stop every shell in this project",
+      category: "Shells",
+      namespace: "palette",
+      slashName: "shells-stop-all",
+      run: () => stopShells(api, store, "project")
     }, {
       name: "cockpit.shells.clear",
       title: "Clear finished shells",

package/dist/tui/lib/view.js

@@ -81,13 +81,29 @@ export function statusDetail(s, now) {
     case "done":
       return `took ${ran} · ${ago}`;
     case "stop":
-      return `stopped after ${ran} · ${ago}`;
+      return `${stopWord(s)} after ${ran} · ${ago}`;
     case "fail":
       if (s.status === "failed") return "could not start";
       return `exit ${s.exitCode ?? "?"} after ${ran} · ${ago}`;
   }
 }
 
+/** Why it stopped, in one word, because the panel has room for exactly that. */
+function stopWord(s) {
+  switch (s.stopReason) {
+    case "timeout":
+      return "timed out";
+    case "idle":
+      return "idle-stopped";
+    case "shutdown":
+      return "daemon stopped it";
+    case "request":
+      return s.stoppedBy?.includes("tui") ? "you stopped it" : "agent stopped it";
+    default:
+      return "stopped";
+  }
+}
+
 /** Short health label for a watched shell, e.g. "tsc ✗" — empty when nothing is watching it. */
 export function watchLabel(s) {
   const watch = s.watch;

package/dist/tui/state/store.js

@@ -2,6 +2,9 @@ import { existsSync } from "node:fs";
 import { createEffect, createMemo, createRoot, createSignal, on, onCleanup } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { order, partition } from "../lib/view.js";
+
+/** A project's shells outnumber a conversation's, and mixing them is how the panel gets confusing. */
+
 export function createShellStore(api, client, options = {}) {
   return createRoot(dispose => {
     const [state, setState] = createStore({
@@ -12,7 +15,12 @@ export function createShellStore(api, client, options = {}) {
     const [frame, setFrame] = createSignal(0);
     const [selectedId, setSelectedId] = createSignal();
     const [showAll, setShowAll] = createSignal(api.kv.get("cockpit.shells.showAll", false));
+    const [scope, setScope] = createSignal(api.kv.get("cockpit.shells.scope", options.scope ?? "session"));
     const project = () => api.state.path.directory;
+    const session = () => {
+      const route = api.route.current;
+      return route.name === "session" ? route.params.sessionID : undefined;
+    };
     const historyMs = (options.historyMinutes ?? 30) * 60_000;
     const refresh = async () => {
       try {
@@ -53,7 +61,13 @@ export function createShellStore(api, client, options = {}) {
       const ordered = order(state.list);
       return ordered.find(s => s.id === selectedId()) ?? ordered[0];
     });
-    const folded = createMemo(() => partition(state.list, {
+    /** Everything the daemon knows about this project, narrowed to what the panel is about. */
+    const inScope = createMemo(() => {
+      const current = session();
+      if (scope() === "project" || !current) return state.list;
+      return state.list.filter(shell => shell.owner.session === current);
+    });
+    const folded = createMemo(() => partition(inScope(), {
       showAll: showAll(),
       historyMs,
       now: now(),
@@ -62,7 +76,15 @@ export function createShellStore(api, client, options = {}) {
     return {
       client,
       project,
-      shells: () => state.list,
+      session,
+      scope,
+      toggleScope() {
+        const next = scope() === "session" ? "project" : "session";
+        setScope(next);
+        api.kv.set("cockpit.shells.scope", next);
+      },
+      shells: () => inScope(),
+      all: () => state.list,
       visible: () => folded().visible,
       hidden: () => folded().hidden,
       showAll,
@@ -79,7 +101,7 @@ export function createShellStore(api, client, options = {}) {
       // Cycles every shell in the project: folding only exists to keep the sidebar short, and a
       // shell you cannot reach from the console would be a trap.
       step(delta) {
-        const list = order(state.list);
+        const list = order(inScope());
         if (list.length === 0) return;
         const index = Math.max(0, list.findIndex(s => s.id === pick()?.id));
         const next = list[(index + delta + list.length) % list.length];
@@ -135,7 +157,9 @@ export function useScreen(store, id) {
     current = next;
     setScreen(undefined);
     if (!next) return;
-    const info = store.shells().find(s => s.id === next);
+    // Not store.shells(): that is narrowed to the current conversation, and the selected shell may
+    // sit outside it. A missing offset here is what used to ask the daemon for bytes past the end.
+    const info = store.all().find(s => s.id === next);
     void store.client.call("shell.attach", {
       id: next,
       fromOffset: info?.bytes ?? Number.MAX_SAFE_INTEGER

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/shell",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Background shells for OpenCode: the agent starts, waits on and drives PTYs; you watch them in a docked TUI panel",
   "type": "module",
   "license": "MIT",
@@ -51,9 +51,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/client": "0.2.0",
-    "@opencode-cockpit/daemon": "0.2.0",
-    "@opencode-cockpit/protocol": "0.2.0",
+    "@opencode-cockpit/client": "0.2.2",
+    "@opencode-cockpit/daemon": "0.2.2",
+    "@opencode-cockpit/protocol": "0.2.2",
     "@opencode-ai/plugin": "1.18.31"
   },
   "devDependencies": {

package/types/agent/tools/watch-args.d.ts

@@ -1,10 +1,18 @@
 import type { WatchRule } from "@opencode-cockpit/protocol/shell";
 import type { CockpitConfig } from "../../core/config.ts";
-/**
- * Turns a preset name into what `shell.watch` needs. A preset defined in config is sent as an
- * explicit rule, so users can add tools or correct a built-in without touching the daemon.
- */
-export declare function watchArgs(preset: string, config: CockpitConfig): {
+export type WatchRequest = {
     preset?: string;
     rule?: WatchRule;
 };
+/**
+ * Turns whatever the model passed for `watch` into what `shell.watch` needs.
+ *
+ * `true`/`"auto"` asks the daemon to pick a preset, a name picks that preset — and a preset defined
+ * in config travels as an explicit rule, so users can add tools without touching the daemon. Rule
+ * objects arrive as JSON *strings* often enough (models write one, and tool args are not always
+ * parsed the way the schema says) that a string which looks like an object is parsed rather than
+ * handed on as a preset name nobody has.
+ */
+export declare function watchArgs(watch: unknown, config: CockpitConfig): WatchRequest;
+/** A rule from an object, or from the JSON string a model sometimes writes instead. */
+export declare function asWatchRule(value: unknown): WatchRule | undefined;

package/types/connect.d.ts

@@ -6,4 +6,4 @@ export declare function daemonEntry(): string;
  * BUN_BE_BUN=1 so it runs on OpenCode's embedded Bun (ADR 0001). The expected build lets the
  * client replace a daemon left running from older plugin code.
  */
-export declare function createClient(name: string): CockpitClient;
+export declare function createClient(name: string, instance?: string): CockpitClient;

package/types/core/config.d.ts

@@ -20,12 +20,23 @@ export interface CockpitConfig {
     kinds?: Record<string, string>;
     /** Applied to every shell the agent starts, unless the call says otherwise. */
     defaults?: {
-        watch?: boolean | string;
+        /** true/"auto", a preset name, or your own rule. */
+        watch?: boolean | string | WatchRule;
         logFile?: boolean;
         idleTimeoutSeconds?: number;
         timeoutSeconds?: number;
         notifyOnExit?: boolean;
     };
+    /** When shells end by themselves. */
+    lifecycle?: {
+        /**
+         * What happens to this window's shells when it closes. `stopMine` stops them, `keep` leaves
+         * them running for the next window — which is how shells survive an OpenCode restart.
+         */
+        onExit?: "stopMine" | "keep";
+        /** Stop a shell after this long with no window of its own connected. `0` never does. */
+        orphanAfterMinutes?: number;
+    };
     /** What is allowed to interrupt the agent. */
     notify?: {
         exit?: boolean;

package/types/tui/dialogs.d.ts

@@ -7,4 +7,9 @@ export declare function announceUpdate(api: TuiPluginApi, meta: TuiPluginMeta, c
 export declare function offerUpdate(api: TuiPluginApi, meta: TuiPluginMeta, current: string): void;
 export declare function newShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void): void;
 export declare function restartDaemon(api: TuiPluginApi, store: ShellStore): void;
+/**
+ * Stopping shells in bulk. Two commands rather than one, because "everything I can see" and
+ * "everything, including what I cannot" are different intentions — and the second one asks first.
+ */
+export declare function stopShells(api: TuiPluginApi, store: ShellStore, reach: "view" | "project"): void;
 export declare function pickShell(api: TuiPluginApi, store: ShellStore, open: (id?: string) => void): void;

package/types/tui/lib/view.d.ts

@@ -39,6 +39,8 @@ export declare function partition(list: readonly ShellInfo[], opts: PartitionOpt
         signal?: string | undefined;
         error?: string | undefined;
         summary?: string | undefined;
+        stopReason?: "idle" | "request" | "shutdown" | "timeout" | undefined;
+        stoppedBy?: string | undefined;
         startedAt: number;
         endedAt?: number | undefined;
         cols: number;

package/types/tui/state/store.d.ts

@@ -5,13 +5,20 @@ import { type Accessor } from "solid-js";
 export interface ShellStore {
     client: CockpitClient;
     project: () => string;
-    /** Every shell in the project, unordered. */
+    /** Shells the panel is about: the current conversation, or the project. */
     shells: Accessor<ShellInfo[]>;
+    /** Every shell in the project, whatever the panel is showing. */
+    all: Accessor<ShellInfo[]>;
     /** Ordered and folded for display: running, recent failures, plus the selection. */
     visible: Accessor<ShellInfo[]>;
     hidden: Accessor<ShellInfo[]>;
     showAll: Accessor<boolean>;
     toggleAll(): void;
+    /** Which shells the panel is about: the conversation you are in, or the whole project. */
+    scope: Accessor<Scope>;
+    toggleScope(): void;
+    /** The session the interface is currently showing, when it is showing one. */
+    session: Accessor<string | undefined>;
     connected: Accessor<boolean>;
     now: Accessor<number>;
     /** Spinner frame index; advances only while something is running. */
@@ -23,9 +30,13 @@ export interface ShellStore {
     clearFinished(): Promise<number>;
     dispose(): void;
 }
+/** A project's shells outnumber a conversation's, and mixing them is how the panel gets confusing. */
+export type Scope = "session" | "project";
 export interface StoreOptions {
     /** Failures stay in the default view this long after they end. */
     historyMinutes?: number;
+    /** What the panel lists by default. */
+    scope?: Scope;
 }
 export declare function createShellStore(api: TuiPluginApi, client: CockpitClient, options?: StoreOptions): ShellStore;
 /**