@rizal72/oc-coffee 0.1.1 → 0.2.0

package/README.md

@@ -2,10 +2,7 @@
 
 Keeps the Mac awake while the agent is working, and lets it sleep between turns.
 
-A cup in the prompt footer shows the state — green while a run is active — and `/coffee` cycles the
-level.
-
-**macOS only**: it drives `caffeinate`. Elsewhere the plugin loads and the badge stays off.
+**macOS only**: it drives `caffeinate`. Elsewhere the plugin loads and the cup never lights.
 
 ## Install
 
@@ -19,7 +16,18 @@ Or by hand, one line in `~/.config/opencode/opencode.jsonc`:
 "plugins": ["@rizal72/oc-coffee"]
 ```
 
-## Use
+## TUI
+
+A cup in the prompt footer, green while a run is active and grey when idle. `/coffee` alone opens the
+menu, `/coffee display` sets a level, `/coffee status` reports.
+
+## GUI
+
+The cup becomes a pill above the composer: the level as the capsule, the four levels as its rows. Picking
+one there moves the same level the terminal shows, because both ask the server rather than their own
+screen.
+
+## How it works
 
 | level | what is blocked |
 |---|---|
@@ -28,8 +36,10 @@ Or by hand, one line in `~/.config/opencode/opencode.jsonc`:
 | `display` | idle and display sleep — `-i -d` |
 | `system` | everything, and the user is declared active — `-i -d -s -u` |
 
-The assertion lives only while a run is active: it is engaged when the agent starts and released when
-it succeeds, fails or is interrupted. It is bound to the TUI's own process (`caffeinate -w`), so it
-dies with the window however the window closes — a closed terminal cannot leave the machine awake.
+The level and the child belong to the server half: one `caffeinate` runs, however many windows are open and
+whichever client changed it. The assertion exists only while a run is active — engaged when the agent
+starts, released when it succeeds, fails or is interrupted — and the child is bound to the server's
+process (`caffeinate -w`), so it cannot outlive the thing that owns it. A closed window is not the signal;
+the end of the run is.
 
 Requires OpenCode v2 and macOS. TypeScript, no build step, no runtime dependencies.

package/dist/gui-experimental.cjs

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});let e=require("@opencode/plugin/gui"),t=require("solid-js"),n=require("@opencode/plugin/rpc");var r=[`off`,`idle`,`display`,`system`],i={off:[],idle:[`-i`],display:[`-i`,`-d`],system:[`-i`,`-d`,`-s`,`-u`]},a=e=>i[e].length===0?`no sleep prevention`:`caffeinate ${i[e].join(` `)}`,o={type:`string`,enum:r},s={type:`object`,properties:{level:o,running:{type:`number`},held:{type:`boolean`}},required:[`level`,`running`,`held`],additionalProperties:!1},c=(e,t)=>new Promise((n,r)=>{let i=setTimeout(()=>r(Error(`rpc timed out after ${t}ms`)),t);e.then(e=>{clearTimeout(i),n(e)},e=>{clearTimeout(i),r(e)})}),l=n.Rpc.define({id:`coffee`,methods:{snapshot:{input:{type:`object`,properties:{},additionalProperties:!1},output:s},set:{input:{type:`object`,properties:{level:o},required:[`level`],additionalProperties:!1},output:s}},events:{}}),u=2e3,d=15e3,f=`monitor`,p=e.Plugin.define({setup(n){let[i,o]=(0,t.createSignal)(void 0),s,p;(0,t.createEffect)(()=>{let e=n.sessions.current(),t=e?.server.id;if(s&&clearInterval(s),s=void 0,!t){o(void 0);return}let r=()=>{p!==t&&(p=t,c(e.server.client.rpc(l).snapshot({}),d).then(e=>{n.sessions.current()?.server.id===t&&o({server:t,value:e})}).catch(()=>{}).finally(()=>{p===t&&(p=void 0)}))};r(),s=setInterval(r,u)}),(0,t.onCleanup)(()=>{s&&clearInterval(s)});let m=e=>{let t=n.sessions.current();t&&c(t.server.client.rpc(l).set({level:e}),d).then(e=>o({server:t.server.id,value:e})).catch(e=>n.toast.show({title:`Coffee`,description:e instanceof Error?e.message:String(e),variant:`error`}))};n.add(e.ComposerPill,{id:`coffee`,order:5,show:e=>{let t=i();if(!t||t.server!==e.session.server.id)return;let n=t.value;return{label:n.level,icon:f,tone:n.held?`success`:void 0,title:`Coffee: sleep prevention`,rows:r.map(e=>({id:e,label:e,...e===n.level?{icon:`check`,tone:`success`}:{},detail:a(e),run:()=>m(e)}))}}})}});exports.default=p;

package/index.ts

@@ -1,11 +1,176 @@
 // oc-coffee — server half.
 //
-// Deliberately empty: everything happens in the TUI half. It exists because the loader
-// resolves a plugin directory by entry file names (`index`/`server`, `tui`, `rpc`) and a
-// missing server entry fails the whole load.
-export default {
+// The level and the assertion are one fact for the whole machine, so they live here: the server is the
+// single process every client talks to, it survives them, and it is the one that runs the turns. The
+// terminal and the window only read and write it over `rpc.ts`.
+//
+// **One process, one child.** The loader instantiates this plugin once per location — two open projects
+// mean two instances, and they do not share module scope — so the state cannot live in this closure: it
+// lives on the process, behind a symbol. The first instance to load starts it, every other instance
+// answers from it, and both clients get the same answer wherever they are.
+//
+// Counting is over **all** sessions: the assertion is machine-wide, so one session finishing must not
+// put the Mac back to sleep while another works. Subagents count too, because their work is work.
+//
+// The child is `caffeinate … -w <pid>`, bound to this process: if the server dies the work dies with
+// it, so an assertion falling with it says the truth and needs no cleanup. A level change mid-run
+// respawns the child with the new flags, which is exactly when it is wanted.
+import { execFileSync, spawn, type ChildProcess } from "node:child_process"
+
+import { Plugin } from "@opencode/plugin"
+
+import { Coffee, FLAGS, isLevel, type CoffeeSnapshot, type Level } from "./rpc.ts"
+
+const KEY = "coffee.level"
+const DEFAULT: Level = "display"
+
+/** The process-wide state. A symbol, so no other plugin's key can collide with ours. */
+const MACHINE = Symbol.for("oc-coffee.machine")
+
+/** The run's edges, and the signs of life inside one. The host renamed these once — `execution.*` became
+ *  `step.*` plus the tool events — so both shapes are watched: the cup is a view of "the agent is
+ *  working", and the names of the events that say it have already changed once. */
+const WATCHED = [
+	"session.step.started",
+	"session.step.ended",
+	"session.tool.called",
+	"session.tool.success",
+	"session.execution.started",
+	"session.execution.succeeded",
+	"session.execution.failed",
+	"session.execution.interrupted",
+	"session.deleted",
+	"session.archived",
+] as const
+
+/** A step ends before its tools run and the next one starts after them, so the turn is not a step: it is
+ *  open from the first step to the step that finishes with anything but `tool-calls`. Nothing here is
+ *  timed, which is what lets a command run for a minute without the cup dropping under it. */
+
+interface Machine {
+	readonly snapshot: () => CoffeeSnapshot
+	readonly setLevel: (next: Level) => Promise<CoffeeSnapshot>
+}
+
+const machine = (ctx: any): Promise<Machine> => ((globalThis as any)[MACHINE] ??= start(ctx))
+
+async function start(ctx: any): Promise<Machine> {
+	// macOS only: `caffeinate` is not on the PATH elsewhere, so the spawn is skipped rather than failed.
+	const supported = process.platform === "darwin"
+
+	// `-w` binds the child to the server, and the server outlives the plugin — so a child from a plugin
+	// that is gone is still there, holding the assertion with flags nothing will ever change. Reaped
+	// before any spawn: an orphan is ours by construction, its `-w` is this process.
+	try {
+		const suffix = `-w ${process.pid}`
+		const table = execFileSync("ps", ["-A", "-o", "pid=", "-o", "command="], { encoding: "utf8" })
+		for (const line of table.split("\n")) {
+			const match = /^\s*(\d+)\s+caffeinate\b.*\s-w\s+\d+\s*$/.exec(line)
+			if (!match || !line.trimEnd().endsWith(suffix)) continue
+			try {
+				process.kill(Number(match[1]), "SIGTERM")
+			} catch {}
+		}
+	} catch {}
+
+	let level: Level = DEFAULT
+	const stored = await ctx.storage.get(KEY).catch(() => undefined)
+	if (isLevel(stored)) level = stored
+
+	const running = new Set<string>()
+	let child: ChildProcess | undefined
+	/** The level the live child was spawned with, so a change can be told from a no-op. */
+	let childLevel: Level | undefined
+
+	const stop = () => {
+		const held = child
+		child = undefined
+		childLevel = undefined
+		held?.kill("SIGTERM")
+	}
+
+	// The assertion is up exactly while there is work and the level asks for it.
+	const apply = () => {
+		const wanted = supported && level !== "off" && running.size > 0
+		if (wanted && child && childLevel !== level) stop()
+		if (wanted && !child) {
+			const spawned = spawn("caffeinate", [...FLAGS[level as Exclude<Level, "off">], "-w", String(process.pid)], {
+				stdio: "ignore",
+			})
+			child = spawned
+			childLevel = level
+			spawned.on("error", () => {
+				if (child === spawned) stop()
+			})
+			spawned.on("exit", () => {
+				if (child === spawned) stop()
+			})
+		}
+		if (!wanted && child) stop()
+	}
+
+	const snapshot = (): CoffeeSnapshot => ({ level, running: running.size, held: !!child })
+
+	// A stream can end while the process lives: one hiccup used to stop the cup until the next restart, and
+	// it did so silently. So this is a loop that always comes back, with a backoff so a subscription that
+	// cannot open at all cannot spin either.
+	void (async () => {
+		let wait = 1_000
+		for (;;) {
+			try {
+				for await (const event of ctx.event.subscribe({ types: [...WATCHED] })) {
+					wait = 1_000
+					const data = (event as any).data ?? {}
+					const id = String(data.sessionID ?? "")
+					const opened = event.type === "session.step.started" || event.type === "session.execution.started"
+					const closed =
+						event.type === "session.execution.succeeded" ||
+						event.type === "session.execution.failed" ||
+						event.type === "session.execution.interrupted" ||
+						event.type === "session.deleted" ||
+						event.type === "session.archived" ||
+						(event.type === "session.step.ended" && String(data.finish ?? "") !== "tool-calls")
+					if (opened && id) running.add(id)
+					else if (closed && id) running.delete(id)
+					apply()
+				}
+			} catch (error) {
+				console.warn("oc-coffee: the event stream ended, resubscribing —", error instanceof Error ? error.message : error)
+			}
+			// The set survives a resubscribe on purpose: a stream that hiccups mid-run must not release
+			// the assertion, and over-holding is the safe direction for a keep-awake. A session that really
+			// ended still clears itself on its own `execution.*` event.
+			apply()
+			await new Promise((resolve) => setTimeout(resolve, wait))
+			wait = Math.min(wait * 2, 30_000)
+		}
+	})()
+
+	return {
+		snapshot,
+		setLevel: async (next: Level) => {
+			// Persisted first: a rejected write must leave the level it found, with no child moved.
+			await ctx.storage.set(KEY, next)
+			level = next
+			apply()
+			return snapshot()
+		},
+	}
+}
+
+export default Plugin.define({
 	id: "oc-coffee",
-	setup() {
-		// nothing to do on the server
+	async setup(ctx) {
+		const coffee = await machine(ctx)
+
+		await ctx.rpc.register(Coffee, {
+			snapshot: async (): Promise<CoffeeSnapshot> => coffee.snapshot(),
+			set: async (input: any) => {
+				if (!isLevel(input?.level)) throw new Error(`unknown coffee level: ${String(input?.level)}`)
+				return coffee.setLevel(input.level)
+			},
+		})
+		// No cleanup: the machine belongs to the process, not to a location. Disabling the plugin leaves
+		// the child until the server restarts, which is the price of one assertion for one machine.
 	},
-}
+})

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@rizal72/oc-coffee",
-	"version": "0.1.1",
+	"version": "0.2.0",
 	"type": "module",
-	"description": "Keeps the Mac awake while the agent works: cup badge in the footer, /coffee command",
+	"description": "Keeps the Mac awake while the agent works: the server owns the level, the terminal draws a cup badge, the desktop a pill",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/rizal72/opencode-plugins.git"
@@ -11,7 +11,8 @@
 	"files": [
 		"*.ts",
 		"tui.js",
-		"README.md"
+		"README.md",
+		"dist"
 	],
 	"keywords": [
 		"opencode",
@@ -24,6 +25,8 @@
 	},
 	"exports": {
 		".": "./index.ts",
-		"./tui": "./tui.js"
+		"./tui": "./tui.js",
+		"./rpc": "./rpc.ts",
+		"./gui-experimental": "./dist/gui-experimental.cjs"
 	}
 }

package/rpc.ts

@@ -0,0 +1,85 @@
+// The contract both clients read: the level is one fact for the machine, so the server owns it and
+// neither the terminal nor the window ever keeps a copy of its own.
+import { Rpc } from "@opencode/plugin/rpc"
+
+export const LEVELS = ["off", "idle", "display", "system"] as const
+
+export type Level = (typeof LEVELS)[number]
+
+export const isLevel = (value: unknown): value is Level => LEVELS.includes(value as Level)
+
+/** The `caffeinate` flags each level means. One table: the server spawns from it, the clients print it. */
+export const FLAGS: Record<Level, readonly string[]> = {
+	off: [],
+	idle: ["-i"],
+	display: ["-i", "-d"],
+	system: ["-i", "-d", "-s", "-u"],
+}
+
+/** The row's `detail`, and the command's report: the flags as they are run, or none at all. */
+export const flagsText = (level: Level): string =>
+	FLAGS[level].length === 0 ? "no sleep prevention" : `caffeinate ${FLAGS[level].join(" ")}`
+
+export const Level = {
+	type: "string",
+	enum: LEVELS,
+}
+
+const Snapshot = {
+	type: "object",
+	properties: {
+		level: Level,
+		/** Sessions executing right now, across the whole server: the assertion is machine-wide. */
+		running: { type: "number" },
+		/** Whether our own `caffeinate` is up. */
+		held: { type: "boolean" },
+	},
+	required: ["level", "running", "held"],
+	additionalProperties: false,
+} as const
+
+/** A stalled call must not freeze a widget: the rejection is the point, the timer is cleared with it. */
+export const withTimeout = <T,>(promise: Promise<T>, ms: number): Promise<T> =>
+	new Promise<T>((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(`rpc timed out after ${ms}ms`)), ms)
+		promise.then(
+			(value) => {
+				clearTimeout(timer)
+				resolve(value)
+			},
+			(error) => {
+				clearTimeout(timer)
+				reject(error)
+			},
+		)
+	})
+
+export interface CoffeeSnapshot {
+	level: Level
+	running: number
+	held: boolean
+}
+
+export const Coffee = Rpc.define({
+	id: "coffee",
+	methods: {
+		snapshot: {
+			input: { type: "object", properties: {}, additionalProperties: false },
+			output: Snapshot,
+		},
+		// The answer is the state after the write, so a click repaints without waiting for the poll.
+		set: {
+			input: {
+				type: "object",
+				properties: { level: Level },
+				required: ["level"],
+				additionalProperties: false,
+			},
+			output: Snapshot,
+		},
+	},
+	// Present (empty) on purpose: a missing events map fails the whole plugin.
+	events: {},
+})
+
+export default Coffee

package/tui.js

@@ -7,41 +7,31 @@ import { setProp as _$setProp } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
 // oc-coffee — TUI half.
 //
-// Keeps the Mac awake while the agent works, the port of pi's `pi-coffee`.
+// Keeps the Mac awake while the agent works: the port of pi's `pi-coffee`.
 //
 //   off | idle | display | system      ->  caffeinate (), (-i), (-i -d), (-i -d -s -u)
 //
-// Four cumulative levels. The assertion is held only while a run is active — engaged on
-// `session.execution.started`, released on `.succeeded` / `.failed` / `.interrupted` — so the
-// Mac sleeps normally between turns. `-w <pid>` binds the child to this process, so it dies
-// with the TUI however the TUI exits, SIGKILL included, and a closed window can never leave
-// the machine awake for ever.
+// The level and the assertion are not held here any more. They are one fact for the whole machine —
+// the desktop app is a second client, and two clients with a copy each are two answers to one
+// question — so the server owns them (`index.ts`) and this half only reads and writes them over
+// `rpc.ts`. Measured 2026-10-27: the server does receive `session.execution.started` and
+// `.succeeded`, which the 2026-10-16 note said it did not.
 //
-// The assertion lives here and not in the server because the server cannot see a run: the
-// public event stream carries only catalogue events (`model.updated`, `provider.updated`, …)
-// and there is no "session is executing" state to read. Measured 2026-10-16, including a
-// clean headless run. The TUI is the only half that knows.
+// The badge shows the level whenever it is not `off` — the setting, not the moment — and only the
+// cup lights up (green) while the assertion is up, so the state is one mark and the level stays
+// legible. `/coffee` opens the menu, `/coffee <level>` sets one, `/coffee status` reports.
 //
-// The badge shows the level whenever it is not `off` — the setting, not the moment — and only
-// the cup lights up (green) while the assertion is up, so the state is one mark and the level
-// stays legible. `/coffee` opens the menu, `/coffee <level>` sets one, `/coffee status` reports.
-// The level is persisted with the TUI's own durable storage, which replaces pi's
-// `pi-coffee.json`; there is no file of ours.
-//
-// macOS only: elsewhere the plugin stays loaded and simply never engages.
+// macOS only: elsewhere the server never spawns the child, and the badge simply never lights.
 import { Plugin } from "@opencode/plugin/tui";
-import { spawn } from "node:child_process";
 import { createRoot, createSignal } from "solid-js";
+import { Coffee, LEVELS, flagsText, isLevel, withTimeout } from "./rpc.ts";
 
 /** md-coffee_outline (U+F06CA), the glyph pi's own badge uses. */
 const CUP_GLYPH = "\u{f06ca}";
-const LEVELS = ["off", "idle", "display", "system"];
-const LEVEL_FLAGS = {
-  off: [],
-  idle: ["-i"],
-  display: ["-i", "-d"],
-  system: ["-i", "-d", "-s", "-u"]
-};
+
+/** Short: the read is a local call, and the cup must light while the agent is still working. */
+const REFRESH_MS = 2_000;
+const RPC_TIMEOUT_MS = 15_000;
 
 /** The four menu rows, the wording pi uses. */
 const LEVEL_MENU = {
@@ -54,22 +44,16 @@ const LEVEL_MENU = {
 /** Fallbacks, used only when the theme defines none of the candidates. */
 const FALLBACK_GREEN = "#3fb950";
 const FALLBACK_DIM = "#8b949e";
-function isLevel(value) {
-  return typeof value === "string" && LEVELS.includes(value);
-}
+
+/** The server's own default, so the first paint is not an empty badge; the first read replaces it. */
+const DEFAULT = {
+  level: "display",
+  running: 0,
+  held: false
+};
 export default Plugin.define({
   id: "oc-coffee.tui",
   setup(context) {
-    const supported = process.platform === "darwin";
-
-    // Durable: survives a restart and is shared by every TUI. A JSON object is what the
-    // storage takes, so the level rides in one.
-    const [stored, updateStored] = context.storage.store("coffee", {
-      initial: {
-        level: "display"
-      }
-    });
-    const level = () => isLevel(stored.level) ? stored.level : "display";
     const themeColour = (...paths) => {
       for (const path of paths) {
         let node = context.theme;
@@ -80,70 +64,38 @@ export default Plugin.define({
     };
     const GREEN = themeColour(["syntax", "string"], ["diff", "text", "added"], ["text", "feedback", "success", "base"]) ?? FALLBACK_GREEN;
     const DIM = themeColour(["text", "muted"], ["text", "faint"]) ?? FALLBACK_DIM;
-    let child = null;
-    /** Runs in flight: several sessions can execute at once, so it is a count, not a flag. */
-    let running = 0;
-    /** Reactive: the badge must repaint the moment the assertion goes up or down. A plain
-     *  variable read in the render would be read once and never again. */
-    const [active, setActive] = createRoot(() => createSignal(false));
-    function engage() {
-      if (!supported || level() === "off" || child) return;
-      const spawned = spawn("caffeinate", [...LEVEL_FLAGS[level()], "-w", String(process.pid)], {
-        stdio: "ignore"
-      });
-      child = spawned;
-      setActive(true);
-      spawned.on("error", () => {
-        if (child !== spawned) return;
-        child = null;
-        setActive(false);
-      });
-      spawned.on("exit", () => {
-        if (child !== spawned) return;
-        child = null;
-        setActive(false);
-      });
-    }
-    function release() {
-      const held = child;
-      child = null;
-      setActive(false);
-      held?.kill("SIGTERM");
+    const rpc = context.client.rpc(Coffee);
+    // Reactive: the badge must repaint when the assertion goes up or down, and that now happens in
+    // the server, so it arrives through a read rather than through a local variable.
+    const [snapshot, setSnapshot] = createRoot(() => createSignal(DEFAULT));
+    const level = () => snapshot().level;
+    const held = () => snapshot().held;
+    async function read() {
+      try {
+        const next = await withTimeout(rpc.snapshot({}), RPC_TIMEOUT_MS);
+        setSnapshot(next);
+      } catch {
+        // Keep the last good reading: a failed read says nothing about the level.
+      }
     }
 
     /** The level can only change from the command, where a failure is worth a word. */
     async function setLevel(next) {
-      const wasUp = child !== null;
-      if (wasUp) release();
-      await updateStored(draft => {
-        draft.level = next;
-      });
-      if (wasUp || running > 0) engage();
+      try {
+        // The RPC answers the state after the write, so the badge repaints without a second read.
+        setSnapshot(await rpc.set({
+          level: next
+        }));
+      } catch (error) {
+        context.ui.toast.show({
+          message: `coffee: ${error instanceof Error ? error.message : String(error)}`,
+          variant: "warning"
+        });
+      }
     }
-    const describe = () => {
-      const flags = LEVEL_FLAGS[level()];
-      const labels = flags.length === 0 ? "Sleep prevention: off" : `Sleep prevention: ${level()} (caffeinate ${flags.join(" ")})`;
-      return `${labels} — assertion ${child ? "up" : "idle"}`;
-    };
-
-    // One listener per boundary. `running` counts sessions executing right now, so the
-    // assertion is up while it is positive and the level is not `off`.
-    const stopStarted = context.data.on("session.execution.started", () => {
-      running += 1;
-      if (running === 1) engage();
-    });
-    const stopSucceeded = context.data.on("session.execution.succeeded", () => {
-      running = Math.max(0, running - 1);
-      if (running === 0) release();
-    });
-    const stopFailed = context.data.on("session.execution.failed", () => {
-      running = Math.max(0, running - 1);
-      if (running === 0) release();
-    });
-    const stopInterrupted = context.data.on("session.execution.interrupted", () => {
-      running = Math.max(0, running - 1);
-      if (running === 0) release();
-    });
+    const describe = () => `Sleep prevention: ${level() === "off" ? "off" : `${level()} (${flagsText(level())})`} — assertion ${held() ? "up" : "idle"}`;
+    void read();
+    const timer = setInterval(() => void read(), REFRESH_MS);
 
     /** Always visible, `off` included: the badge is the setting, and seeing `off` is how you
      *  know the plugin is loaded and deliberately doing nothing. (pi hides it when off; the
@@ -163,7 +115,7 @@ export default Plugin.define({
       _$setProp(_el$4, "fg", DIM);
       _$setProp(_el$4, "wrapMode", "none");
       _$insert(_el$4, level, null);
-      _$effect(_$p => _$setProp(_el$2, "fg", active() ? GREEN : DIM, _$p));
+      _$effect(_$p => _$setProp(_el$2, "fg", held() ? GREEN : DIM, _$p));
       return _el$;
     })();
     context.ui.slot({
@@ -182,6 +134,7 @@ export default Plugin.define({
           arguments: true
         },
         run: async input => {
+          await read();
           const argument = (input ?? "").trim().split(/\s+/).filter(Boolean)[0];
           if (argument === "status") {
             await context.ui.dialog.alert({
@@ -208,7 +161,7 @@ export default Plugin.define({
             title: `${CUP_GLYPH} Sleep prevention`,
             current: level(),
             options: LEVELS.map(candidate => ({
-              title: candidate === level() ? `${LEVEL_MENU[candidate]}` : LEVEL_MENU[candidate],
+              title: LEVEL_MENU[candidate],
               value: candidate
             }))
           });
@@ -221,12 +174,6 @@ export default Plugin.define({
         }
       }]
     }));
-    return () => {
-      stopStarted?.();
-      stopSucceeded?.();
-      stopFailed?.();
-      stopInterrupted?.();
-      release();
-    };
+    return () => clearInterval(timer);
   }
 });

package/vite.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from "vite"
+import { gui } from "@opencode/plugin/gui/vite"
+
+export default defineConfig({
+	plugins: [gui({ entry: "gui.tsx", outFile: "dist/gui-experimental.cjs" })],
+})