@cueloop/daemon 0.1.0-alpha.80 → 0.1.0-alpha.81

package/src/thread-surface-config.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadGhosttyThreadSurface, loadHerdrThreadSurface } from "./thread-surface-config";
+
+let dir: string;
+let userPath: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-config-"));
+  userPath = join(dir, "user.toml");
+});
+
+describe("personal Ghostty Thread surface config", () => {
+  test("defaults to tab and accepts pane, window, or none", () => {
+    expect(loadGhosttyThreadSurface(userPath)).toBe("tab");
+
+    for (const mode of ["pane", "window", "none"] as const) {
+      writeFileSync(userPath, `[integrations.ghostty]\nthread_surface = "${mode}"\n`);
+      expect(loadGhosttyThreadSurface(userPath)).toBe(mode);
+    }
+
+    writeFileSync(userPath, '[integrations.ghostty]\nthread_surface = "invalid"\n');
+    expect(loadGhosttyThreadSurface(userPath)).toBe("tab");
+  });
+
+  test("ignores repository config", () => {
+    const repoConfig = join(dir, "repo", ".cueloop", "config.toml");
+
+    mkdirSync(join(dir, "repo", ".cueloop"), { recursive: true });
+    writeFileSync(userPath, '[integrations.ghostty]\nthread_surface = "window"\n');
+    writeFileSync(repoConfig, '[integrations.ghostty]\nthread_surface = "none"\n');
+
+    expect(loadGhosttyThreadSurface(userPath)).toBe("window");
+  });
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("personal Herdr Thread surface config", () => {
+  test("defaults to tab and accepts pane or none", () => {
+    expect(loadHerdrThreadSurface(userPath)).toBe("tab");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "pane"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("pane");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "none"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("none");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "invalid"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("tab");
+  });
+
+  test("never reads a repository's terminal automation setting", () => {
+    const repoConfig = join(dir, "repo", ".cueloop", "config.toml");
+
+    mkdirSync(join(dir, "repo", ".cueloop"), { recursive: true });
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "pane"\n');
+    writeFileSync(repoConfig, '[integrations.herdr]\nthread_surface = "none"\n');
+
+    expect(loadHerdrThreadSurface(userPath)).toBe("pane");
+  });
+});

package/src/thread-surface-config.ts

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import * as v from "valibot";
+
+/** Placement of a cueloop Thread inside Herdr. */
+export type HerdrThreadSurface = "tab" | "pane" | "none";
+/** Placement of a cueloop Thread inside Ghostty. */
+export type GhosttyThreadSurface = "tab" | "pane" | "window" | "none";
+
+const PersonalThreadSurfaceSchema = v.object({
+  integrations: v.optional(
+    v.object({
+      herdr: v.optional(
+        v.object({
+          thread_surface: v.fallback(v.optional(v.picklist(["tab", "pane", "none"])), undefined),
+        }),
+      ),
+      ghostty: v.optional(
+        v.object({
+          thread_surface: v.fallback(
+            v.optional(v.picklist(["tab", "pane", "window", "none"])),
+            undefined,
+          ),
+        }),
+      ),
+    }),
+  ),
+});
+
+/** Read Herdr placement from the personal TOML file only; invalid values use the tab default. */
+export function loadHerdrThreadSurface(userConfigPath?: string): HerdrThreadSurface {
+  return (
+    loadPersonalThreadSurfaceConfig(userConfigPath)?.integrations?.herdr?.thread_surface ?? "tab"
+  );
+}
+
+/** Read Ghostty placement from the personal TOML file only. */
+export function loadGhosttyThreadSurface(userConfigPath?: string): GhosttyThreadSurface {
+  return (
+    loadPersonalThreadSurfaceConfig(userConfigPath)?.integrations?.ghostty?.thread_surface ?? "tab"
+  );
+}
+
+function loadPersonalThreadSurfaceConfig(userConfigPath?: string) {
+  const path =
+    userConfigPath ??
+    process.env.CUELOOP_CONFIG ??
+    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
+
+  if (!existsSync(path)) return null;
+
+  try {
+    const parsed = v.safeParse(PersonalThreadSurfaceSchema, parseToml(readFileSync(path, "utf8")));
+
+    return parsed.success ? parsed.output : null;
+  } catch {
+    return null;
+  }
+}

package/src/validate.ts

@@ -262,6 +262,7 @@ export const Params = {
     harnessSessionId: NonEmpty,
   }),
   "harness.getBinding": v.object({ bindingId: NonEmpty }),
+  "harness.bindingsForSession": v.object({ harness: NonEmpty, harnessSessionId: NonEmpty }),
   "harness.consumeApprovedRetry": v.object({
     bindingId: NonEmpty,
     messageId: NonEmpty,
@@ -286,9 +287,18 @@ export const Params = {
     author: v.optional(NonEmpty),
   }),
   "daemon.shutdown": v.object({}),
-  // herdr adapter scratch: the review's opened tab, kept off the session record.
-  "herdr.getTab": v.object({ id: SessionId }),
-  "herdr.setTab": v.object({ id: SessionId, tabId: NonEmpty, paneId: NonEmpty }),
+  // Herdr terminal handles stay outside canonical Thread records.
+  "herdr.getThreadSurface": v.object({ id: SessionId }),
+  "herdr.setThreadSurface": v.object({
+    id: SessionId,
+    tabId: NonEmpty,
+    paneId: NonEmpty,
+    mode: v.optional(v.picklist(["tab", "pane"])),
+  }),
+  "ghostty.getThreadSurface": v.object({ id: SessionId }),
+  "ghostty.setThreadSurface": v.object({ id: SessionId, terminalId: NonEmpty }),
+  "ghostty.claimThreadSurface": v.object({ id: SessionId }),
+  "ghostty.releaseThreadSurface": v.object({ id: SessionId }),
 } as const;
 
 export type MethodName = keyof typeof Params;

package/src/herdr-pane.test.ts

@@ -1,240 +0,0 @@
-/** Creation-side herdr pane opener: a stubbed herdr binary logs its argv, openHerdrPane returns the tab handle, and openHerdrPaneForReview opens+records for a new review, focuses a still-alive recorded tab, and reopens a dead one - collision-free by pane id. */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Thread } from "@cueloop/schema";
-import { openHerdrPane, openHerdrPaneForReview } from "./herdr-pane";
-import type { HerdrTabPersistence } from "./herdr-pane";
-import type { HerdrTabHandle } from "./herdr-tab-store";
-
-const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-pane-"));
-
-/**
- * A stub herdr binary. It logs argv, prints the tab-create result carrying both
- * pane_id and tab_id (herdr 0.8.2 shape), and answers `pane get` alive or dead
- * per `paneAlive` so the liveness branch can be exercised.
- */
-function makeStub(name: string, paneAlive = false) {
-  const logPath = join(dir, `${name}.log`);
-  const binPath = join(dir, `${name}.sh`);
-  const paneGet = paneAlive ? `printf '{"result":{"pane":{"pane_id":"w1:p2"}}}'` : "exit 1";
-
-  writeFileSync(
-    binPath,
-    `#!/bin/sh
-printf '%s\\n' "$*" >> "${logPath}"
-if [ "$1" = "tab" ] && [ "$2" = "create" ]; then
-  printf '{"result":{"root_pane":{"pane_id":"w1:p2","tab_id":"w1:t2"}}}'
-fi
-if [ "$1" = "pane" ] && [ "$2" = "get" ]; then ${paneGet}; fi
-exit 0
-`,
-  );
-  chmodSync(binPath, 0o755);
-
-  return { binPath, logPath };
-}
-
-function readLines(logPath: string): string[] {
-  if (!existsSync(logPath)) return [];
-
-  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
-}
-
-/** In-memory persistence double: records what openHerdrPaneForReview saves. */
-function fakePersistence(initial: HerdrTabHandle | null = null) {
-  let stored = initial;
-
-  return {
-    persistence: {
-      herdrGetTab: async () => stored,
-      herdrSetTab: async (_sessionId: string, handle: HerdrTabHandle) => {
-        stored = handle;
-      },
-    },
-    saved: () => stored,
-  };
-}
-
-function newSession(overrides: Partial<Thread> = {}): Thread {
-  return {
-    schemaVersion: "1",
-    id: "ses_new1",
-    workspace: { repoRoot: "/repo", branch: "main" },
-    artifact: { type: "plan", content: "# P", meta: { cwd: "/repo/work", title: "Rollout Plan" } },
-    revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
-    annotations: [],
-    message: null,
-    status: "pending",
-    createdAt: "now",
-    ...overrides,
-  };
-}
-
-describe("openHerdrPane", () => {
-  test("creates a focused tab, launches the review, and returns the handle", () => {
-    // Arrange
-    const stub = makeStub("open");
-
-    // Act
-    const handle = openHerdrPane({
-      sessionId: "ses_abc",
-      cwd: "/repo/work",
-      binPath: stub.binPath,
-      label: "Rollout Plan",
-    });
-
-    // Assert
-    expect(handle).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
-    expect(readLines(stub.logPath)).toEqual([
-      "tab create --cwd /repo/work --label Rollout Plan --focus",
-      "pane send-text w1:p2 cueloop ses_abc",
-      "pane send-keys w1:p2 enter",
-    ]);
-  });
-
-  test("returns null and never throws on a broken binary", () => {
-    expect(
-      openHerdrPane({
-        sessionId: "ses_abc",
-        cwd: "/repo/work",
-        binPath: join(dir, "missing-bin"),
-        label: "x",
-      }),
-    ).toBeNull();
-  });
-
-  test("returns null when tab create yields no ids - no send-text, no send-keys", () => {
-    // Arrange
-    const logPath = join(dir, "nopane.log");
-    const binPath = join(dir, "nopane.sh");
-
-    writeFileSync(
-      binPath,
-      `#!/bin/sh\nprintf '%s\\n' "$*" >> "${logPath}"\nprintf '{"result":{}}'\n`,
-    );
-    chmodSync(binPath, 0o755);
-
-    // Act
-    const handle = openHerdrPane({ sessionId: "ses_abc", cwd: "/repo/work", binPath, label: "x" });
-
-    // Assert
-    expect(handle).toBeNull();
-    expect(readLines(logPath)).toEqual(["tab create --cwd /repo/work --label x --focus"]);
-  });
-});
-
-describe("openHerdrPaneForReview", () => {
-  test("opens and records a tab for a review with no recorded tab", async () => {
-    // Arrange
-    const stub = makeStub("gated-new");
-    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
-    const store = fakePersistence(null);
-
-    // Act
-    await openHerdrPaneForReview(newSession({ id: "ses_xyz" }), store.persistence, env);
-
-    // Assert
-    expect(readLines(stub.logPath)).toEqual([
-      "tab create --cwd /repo/work --label Rollout Plan --focus",
-      "pane send-text w1:p2 cueloop ses_xyz",
-      "pane send-keys w1:p2 enter",
-    ]);
-    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
-  });
-
-  test("no-op outside herdr - no herdr process is spawned", async () => {
-    // Arrange
-    const stub = makeStub("gated-outside");
-    const store = fakePersistence(null);
-
-    // Act
-    await openHerdrPaneForReview(newSession(), store.persistence, {
-      HERDR_PANE_ID: "w1:p1",
-      HERDR_BIN_PATH: stub.binPath,
-    });
-
-    // Assert
-    expect(existsSync(stub.logPath)).toBeFalse();
-    expect(store.saved()).toBeNull();
-  });
-
-  test("focuses the recorded tab when its pane is still alive, without reopening", async () => {
-    // Arrange
-    const stub = makeStub("gated-alive", true);
-    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
-    const store = fakePersistence({ tabId: "w9:t9", paneId: "w9:p9" });
-
-    // Act
-    await openHerdrPaneForReview(newSession(), store.persistence, env);
-
-    // Assert
-    const lines = readLines(stub.logPath);
-
-    expect(lines).toContain("pane get w9:p9");
-    expect(lines).toContain("tab focus w9:t9");
-    expect(lines.some((line) => line.startsWith("tab create"))).toBeFalse();
-    expect(store.saved()).toEqual({ tabId: "w9:t9", paneId: "w9:p9" });
-  });
-
-  test("a persistence failure never escapes - review creation stays best-effort", async () => {
-    // Arrange - the daemon store rejects; the opener must still resolve quietly
-    const stub = makeStub("gated-persist-fail");
-    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
-    const persistence: HerdrTabPersistence = {
-      herdrGetTab: async () => null,
-      herdrSetTab: async () => {
-        throw new Error("disk full");
-      },
-    };
-
-    // Act & Assert - no throw
-    await openHerdrPaneForReview(newSession(), persistence, env);
-    expect(readLines(stub.logPath).some((line) => line.startsWith("tab create"))).toBeTrue();
-  });
-
-  test("a recall failure (stale daemon) still opens a fresh tab", async () => {
-    // Arrange - a daemon predating the herdr-tab primitives rejects the recall
-    const stub = makeStub("gated-recall-fail");
-    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
-    const persistence: HerdrTabPersistence = {
-      herdrGetTab: async () => {
-        throw new Error("unknown method herdr.getTab");
-      },
-      herdrSetTab: async () => {},
-    };
-
-    // Act
-    await openHerdrPaneForReview(newSession({ id: "ses_stale" }), persistence, env);
-
-    // Assert - the recall throwing must not abort the open
-    expect(readLines(stub.logPath)).toEqual([
-      "tab create --cwd /repo/work --label Rollout Plan --focus",
-      "pane send-text w1:p2 cueloop ses_stale",
-      "pane send-keys w1:p2 enter",
-    ]);
-  });
-
-  test("reopens and re-records when the recorded pane is dead", async () => {
-    // Arrange
-    const stub = makeStub("gated-dead", false);
-    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
-    const store = fakePersistence({ tabId: "old:t", paneId: "old:p" });
-
-    // Act
-    await openHerdrPaneForReview(newSession({ id: "ses_re" }), store.persistence, env);
-
-    // Assert
-    const lines = readLines(stub.logPath);
-
-    expect(lines).toContain("pane get old:p");
-    expect(lines).toContain("tab create --cwd /repo/work --label Rollout Plan --focus");
-    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
-  });
-});
-
-afterAll(() => {
-  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
-});

package/src/herdr-pane.ts

@@ -1,167 +0,0 @@
-/**
- * Opens a herdr tab that renders a review, from the creation sites (the Claude
- * Code hook and `cueloop session create`) that run inside a herdr pane. On a
- * resubmit it reopens only when the recorded pane is dead, so a live tab is
- * focused rather than duplicated. Best-effort: any spawn failure is swallowed
- * and never blocks review creation; each spawn is bounded by a timeout.
- */
-
-import { detectHerdr, type HerdrEnv, type Thread } from "@cueloop/schema";
-import * as v from "valibot";
-import type { HerdrTabHandle } from "./herdr-tab-store";
-
-const HERDR_SPAWN_TIMEOUT_MS = 2000;
-const CreatedTabSchema = v.object({
-  result: v.optional(
-    v.object({
-      root_pane: v.optional(
-        v.object({ pane_id: v.optional(v.string()), tab_id: v.optional(v.string()) }),
-      ),
-    }),
-  ),
-});
-const PaneResultSchema = v.object({
-  result: v.optional(v.object({ pane: v.optional(v.unknown()) })),
-});
-
-export interface OpenHerdrPaneOptions {
-  sessionId: string;
-  cwd: string;
-  binPath: string;
-  label: string;
-}
-
-/** The daemon-side handle store, as the two methods this module needs. DaemonClient satisfies it. */
-export interface HerdrTabPersistence {
-  herdrGetTab(sessionId: string): Promise<HerdrTabHandle | null>;
-  herdrSetTab(sessionId: string, handle: HerdrTabHandle): Promise<void>;
-}
-
-/**
- * Open a focused tab and launch the review in it. `tab create` prints
- * `{ result: { root_pane: { pane_id, tab_id } } }` (herdr 0.8.2); both ids are
- * returned so a later resubmit can liveness-check and focus. Null on any
- * best-effort bail-out.
- */
-export function openHerdrPane(options: OpenHerdrPaneOptions): HerdrTabHandle | null {
-  const { sessionId, cwd, binPath, label } = options;
-
-  try {
-    const created = Bun.spawnSync(
-      [binPath, "tab", "create", "--cwd", cwd, "--label", label, "--focus"],
-      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
-    );
-
-    if (created.exitCode !== 0) return null;
-    const parsed = v.safeParse(CreatedTabSchema, JSON.parse(created.stdout.toString()));
-
-    if (!parsed.success) return null;
-    const paneId = parsed.output.result?.root_pane?.pane_id;
-    const tabId = parsed.output.result?.root_pane?.tab_id;
-
-    if (!paneId || !tabId) return null;
-    // A fresh tab hosts a plain shell, so the review is typed in like a human.
-    const typed = Bun.spawnSync([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
-      stdout: "ignore",
-      stderr: "ignore",
-      timeout: HERDR_SPAWN_TIMEOUT_MS,
-    });
-
-    if (typed.exitCode !== 0) return null;
-    const entered = Bun.spawnSync([binPath, "pane", "send-keys", paneId, "enter"], {
-      stdout: "ignore",
-      stderr: "ignore",
-      timeout: HERDR_SPAWN_TIMEOUT_MS,
-    });
-
-    return entered.exitCode === 0 ? { tabId, paneId } : null;
-  } catch {
-    return null;
-  }
-}
-
-/** True when the pane still exists (`herdr pane get` returns it). */
-function herdrPaneAlive(binPath: string, paneId: string): boolean {
-  try {
-    const got = Bun.spawnSync([binPath, "pane", "get", paneId], {
-      stdout: "pipe",
-      stderr: "ignore",
-      timeout: HERDR_SPAWN_TIMEOUT_MS,
-    });
-
-    if (got.exitCode !== 0) return false;
-    const parsed = v.safeParse(PaneResultSchema, JSON.parse(got.stdout.toString()));
-
-    return parsed.success && parsed.output.result?.pane != null;
-  } catch {
-    return false;
-  }
-}
-
-/** Bring an existing review tab to the front; best-effort. */
-function focusHerdrTab(binPath: string, tabId: string): void {
-  try {
-    Bun.spawnSync([binPath, "tab", "focus", tabId], {
-      stdout: "ignore",
-      stderr: "ignore",
-      timeout: HERDR_SPAWN_TIMEOUT_MS,
-    });
-  } catch {
-    // best-effort
-  }
-}
-
-/**
- * Ensure a herdr tab is rendering this review. Inside herdr only: focus the
- * recorded tab if its pane is still alive, otherwise open a fresh one and record
- * its handle. No-op outside herdr.
- */
-export async function openHerdrPaneForReview(
-  session: Thread,
-  persistence: HerdrTabPersistence,
-  env: HerdrEnv = process.env,
-): Promise<void> {
-  const herdr = detectHerdr(env);
-
-  if (!herdr) return;
-  const recorded = await recallHerdrTab(persistence, session.id);
-
-  if (recorded && herdrPaneAlive(herdr.binPath, recorded.paneId)) {
-    focusHerdrTab(herdr.binPath, recorded.tabId);
-
-    return;
-  }
-  const opened = openHerdrPane({
-    sessionId: session.id,
-    cwd: session.artifact.meta.cwd ?? process.cwd(),
-    binPath: herdr.binPath,
-    label: session.artifact.meta.title ?? session.id,
-  });
-
-  if (opened) await rememberHerdrTab(persistence, session.id, opened);
-}
-
-/** The recorded handle, or null on any recall failure - a stale daemon must still open a fresh tab, not abort. */
-async function recallHerdrTab(
-  persistence: HerdrTabPersistence,
-  sessionId: string,
-): Promise<HerdrTabHandle | null> {
-  try {
-    return await persistence.herdrGetTab(sessionId);
-  } catch {
-    return null;
-  }
-}
-
-/** Record the handle for later liveness checks; a store failure loses dedup, never the already-open tab. */
-async function rememberHerdrTab(
-  persistence: HerdrTabPersistence,
-  sessionId: string,
-  handle: HerdrTabHandle,
-): Promise<void> {
-  try {
-    await persistence.herdrSetTab(sessionId, handle);
-  } catch {
-    // stale daemon: the tab is already shown; only the liveness-dedup handle is lost
-  }
-}

package/src/herdr-tab-store.ts

@@ -1,66 +0,0 @@
-/**
- * herdr adapter scratch, kept out of the core session record: the tab cueloop
- * opened to render each review, keyed by session id. One JSON map, atomic write.
- * The core `Thread` never mentions herdr; this side-store is the whole
- * leak boundary.
- */
-
-import { readFileSync, renameSync, writeFileSync } from "node:fs";
-import * as v from "valibot";
-import { herdrTabsPath } from "./paths";
-
-/** The tab and its root pane: pane id checks liveness, tab id focuses it. */
-export interface HerdrTabHandle {
-  tabId: string;
-  paneId: string;
-}
-
-const HerdrTabHandleSchema = v.object({
-  tabId: v.string(),
-  paneId: v.string(),
-});
-const HerdrTabsSchema = v.record(v.string(), v.unknown());
-
-export class HerdrTabStore {
-  private tabs = new Map<string, HerdrTabHandle>();
-  private readonly path: string;
-
-  constructor(home: string) {
-    this.path = herdrTabsPath(home);
-    this.load();
-  }
-
-  private load(): void {
-    try {
-      const parsed = v.parse(HerdrTabsSchema, JSON.parse(readFileSync(this.path, "utf8")));
-
-      for (const [sessionId, value] of Object.entries(parsed)) {
-        const handle = v.safeParse(HerdrTabHandleSchema, value);
-
-        if (handle.success) this.tabs.set(sessionId, handle.output);
-      }
-    } catch {
-      // absent, unreadable, or malformed: start empty - a stale tab just reopens on resubmit
-    }
-  }
-
-  private persist(): void {
-    const tempPath = this.path + ".tmp";
-
-    writeFileSync(tempPath, JSON.stringify(Object.fromEntries(this.tabs), null, 2));
-    renameSync(tempPath, this.path);
-  }
-
-  get(sessionId: string): HerdrTabHandle | null {
-    return this.tabs.get(sessionId) ?? null;
-  }
-
-  set(sessionId: string, handle: HerdrTabHandle): void {
-    this.tabs.set(sessionId, handle);
-    this.persist();
-  }
-
-  delete(sessionId: string): void {
-    if (this.tabs.delete(sessionId)) this.persist();
-  }
-}