@op1/threads 0.1.6 → 0.1.8

package/README.md

@@ -1,6 +1,6 @@
 # @op1/threads
 
-Managed top-level worker sessions for OpenCode 2.0.3. The server entrypoint is `index.ts`; the terminal entrypoint is `tui.ts`.
+Managed top-level worker sessions for OpenCode 2.0.7. The server entrypoint is `index.ts`; the terminal entrypoint is `tui.ts`.
 
 ## Install
 
@@ -58,7 +58,7 @@ All fields are strings except `evidence`, which is an array of strings. Verdicts
 
 `directory` must exist and be absolute. Without `agent`, the worker inherits the coordinator's active agent and resolved model, with agent permissions followed by session permissions.
 
-Set `agent` to use a configured profile, such as `agent: "vera-core"` for a VERA workstream or `agent: "vera-auditor-readonly"` for an independent review. The plugin resolves the profile in the assigned directory. OpenCode supplies its system prompt and step limit. The profile's model and variant take precedence; a profile without a model inherits the coordinator's resolved model. Explicit selection supports `primary`, `all`, and `subagent` profiles on OpenCode 2.0.3.
+Set `agent` to use a configured profile, such as `agent: "vera-core"` for a VERA workstream or `agent: "vera-auditor-readonly"` for an independent review. The plugin resolves the profile in the assigned directory. OpenCode supplies its system prompt and step limit. The profile's model and variant take precedence; a profile without a model inherits the coordinator's resolved model. Explicit selection supports `primary`, `all`, and `subagent` profiles on OpenCode 2.0.7.
 
 Explicit selection requires the caller's ordered agent and session rules to allow `subagent` for that exact agent ID. A matching `deny` or `ask` rejects the request before creation. OpenCode's plugin API cannot request approval for an input-dependent agent ID.
 
@@ -90,9 +90,13 @@ Plugin option `maxWorkers` defaults to 4 and accepts integers from 1 through 32.
 
 ## Terminal and RPC
 
-The terminal synchronizes workers before opening native tabs without changing focus. A TUI memory index survives plugin reloads and respects manually closed tabs. `/threads` explicitly reopens workers for open coordinator tabs. A new TUI recovers workers from durable storage. Closing the TUI does not interrupt workers.
+The terminal synchronizes workers before opening native tabs without changing focus. A TUI memory index survives plugin reloads and respects manually closed native tabs. Conversations closed through Activity stay dismissed across restarts. `/threads` explicitly reopens workers for open coordinator tabs, including workers dismissed through Activity. A new TUI recovers the other workers from durable storage. Closing the TUI does not interrupt workers.
 
-Managed tabs use saved title prefixes: `[Main]` for the coordinator and `[Worker]` for each managed worker. Labels appear when the TUI discovers the relationship, including existing threads. The rest of the title stays editable; renaming a managed conversation reapplies its role prefix. Unrelated sessions keep their titles. OpenCode's native tab API has no separate badge field, so the prefixes also appear in session history.
+Activity shows Main and Worker roles as row subtitles. It omits a leading `[Main] ` or `[Worker] ` from known managed titles, including closed history rows and prefixes reapplied by older clients. Managed identity comes from the worker RPC, including lookups for loaded history conversations whose workers are on older pages. Unrelated prefixed titles remain unchanged.
+
+For open managed tabs, the TUI also removes one legacy prefix from the fresh saved title. The remainder stays unchanged, and empty remainders are not saved. A durable client-storage marker makes this saved-title cleanup one-shot per session. Later intentional prefixed renames remain in saved history, while Activity omits the redundant role label from its display.
+
+When upgrading, restart all existing TUIs. Older 0.1.7 clients still write role prefixes and can reapply them after cleanup.
 
 Workers with `PASS` or `PASS WITH NOTES` reports hide automatically once idle. This also applies to reports saved before upgrading. Unreported workers and `FAIL` or `INCONCLUSIVE` reports stay visible. The selected tab, running workers, and tabs needing input stay open until they are inactive.
 
@@ -100,7 +104,7 @@ The coordinator can call `threads_hide` when a worker is no longer needed. Hidin
 
 Reports reach the coordinator through silent synthetic messages. They remain available through `threads_list` and the session history without adding a notification row to the conversation. Older report notification rows remain in native history.
 
-All open native root-session tabs are automatically grouped by OpenCode project ID, including sessions not managed by this plugin. Projects follow their first appearance in the current tab order. Worktrees with the same project ID stay together.
+With Activity disabled or unable to mount, open native root-session tabs are grouped by OpenCode project ID, including sessions not managed by this plugin. This includes horizontal, narrow, and unsupported-version fallback. Projects follow their first appearance in the current tab order. Worktrees with the same project ID stay together.
 
 Within each project, running sessions and sessions waiting for input come before idle sessions. Tabs with the same priority keep their relative order. Selecting an idle tab does not reorder it. Native tab order is shared between terminals in the same directory, so sorting by each terminal's selection would make them repeatedly undo each other's moves. Idle is a display priority, not a completion verdict. Each tab with unloaded project metadata stays in its own group until that metadata becomes available. Reconciliation moves only out-of-order tabs, without changing focus or closing and reopening them to reorder. Native tabs do not support divider rows.
 
@@ -113,12 +117,70 @@ result: { workers: WorkerView[] }
 
 The input accepts at most 100 coordinator IDs. Raw HTTP RPC requests wrap the input as `{ "input": { "coordinatorIDs": ["ses_..."] } }`. Each method declares `errors: {}` and the RPC declares `events: {}`. The TUI subscribes to native session events and reconciles at most one snapshot at a time, with a three-second missed-event refresh.
 
+## Activity sidebar
+
+Activity replaces the contents of the native left vertical tab rail on compatible OpenCode V2 layouts. Native tabs remain enabled and retain their layout reservation, resize handle, activity state, and session navigation. The prompt and transcript remain native OpenCode UI.
+
+Subtitles start with the project name or folder basename, followed by a distinct location or worktree basename when needed. Main and Worker labels appear only for known managed relationships; ordinary history rows show project and location without a role label.
+
+Rows are grouped in this order:
+
+- **Priority**: permission or form attention, then running work, then unread results or errors.
+- **Pinned**: pinned conversations without priority activity.
+- **Today**, **Yesterday**, recent weekdays, and older calendar dates, using the local timezone.
+
+Divider lines separate sections. Click a heading to collapse or expand its conversations; the arrow and count show its current state. Collapsed sections stay collapsed across reloads and restarts. This changes sidebar visibility without closing tabs, and `/activities` can still find conversations in collapsed sections.
+
+A session appears once. Priority takes precedence over pinning. Idle does not mean that a task passed. Open-tab status comes from the native tab API; closed history uses available native running and input-request state, without inventing a success status. Date groups use the last native execution's `time.idle`, falling back to `time.updated` for conversations without an execution. Title cleanup therefore does not move an older executed conversation into Today.
+
+Running rows use OpenCode's registered animated dot spinner. Input requests take precedence over the spinner, and it is removed when the session becomes idle.
+
+Colors follow the active theme: selected conversations and date headings use its accent, running indicators use its information color, and input requests use its warning color. Unread errors use the error color. Worker headings and pinned controls use purple, while project subtitles and inactive controls use subdued text. Blank lines separate section headings from conversations and give worker groups space above and below their heading. Long titles are truncated to keep the action buttons separate.
+
+Managed workers appear indented under their main conversation. The stack appears in **Priority** when any member is running, needs input, or has an unread result. Otherwise, a pin on any visible member places the stack in **Pinned**; date sections use the most recent member activity. Workers with an unavailable main conversation remain standalone rows.
+
+Each main conversation with workers has a **▾ Workers (N)** heading below its subtitle. Click the heading to collapse the worker list, or **▸ Workers (N)** to expand it. When the list is collapsed, the main row summarizes worker activity, with input requests taking precedence over running spinners. Collapsing keeps the workers running and their tabs open. Stack preferences survive reloads and restarts, and `/activities` still lists collapsed workers.
+
+Activity fetches the 100 most recent root sessions across projects and refreshes them in the background. Open and pinned sessions are merged into the list; older pins and known main conversations are resolved individually. Archived, deleted, and native child sessions are excluded. Closed managed workers are not reintroduced by fetched history. `/threads` restores their native tabs using the existing worker visibility rules.
+
+Left-click a row to open or focus its real session. Each row has one-click **[◇]** (pin), **[◆]** (unpin), and **[×]** (close from Activity) buttons beside its title. These controls work on both main and worker rows without selecting a background conversation. Closing removes the row and closes its native tab when open. Saved history and the pin preference remain intact. Dismissed rows stay hidden through refreshes, reloads, and restarts. Selecting a closed conversation in `/activities` restores it; `/threads` also restores dismissed managed workers. Reopening a conversation through native session navigation restores its Activity row. Right-click also opens the action menu. The mouse wheel scrolls the list, and the native rail edge remains draggable.
+
+| Command | Action |
+| --- | --- |
+| `/activity` | Toggle Activity and the native rail |
+| `/pin` | Pin or unpin the current conversation |
+| `/activities` | Choose a loaded conversation, including closed Activity rows, and restore it if needed |
+| `/activity-sections` | Choose a section to collapse or expand |
+| `/activity-threads` | Choose a managed worker stack to collapse or expand |
+| `/threads` | Restore managed worker tabs |
+
+The same actions are available in the command palette. **+ New session** dispatches OpenCode's registered `session.new` command. Pins use plugin client storage and survive TUI reloads and restarts.
+
+In `/activities`, **Ctrl+F** pins or unpins the highlighted conversation. The picker stays open and preserves your search and selection. This also works for conversations in **Priority**. **Enter** opens the highlighted conversation, and **Esc** closes the picker. The footer shows the current pin action. Configure `threads.activity.choose.pin` in `cli.json` to change the shortcut.
+
+Activity requires vertical tabs. To select the layout and disable Activity by default, configure the terminal plugin in `~/.config/opencode/cli.json`:
+
+```json
+{
+  "tabs": { "layout": "vertical" },
+  "plugins": [{ "package": "@op1/threads", "options": { "activity": false } }]
+}
+```
+
+Omit `activity` or set it to `true` to enable the sidebar. Keep the server plugin in `opencode.json`; server plugin options are not forwarded to the terminal entrypoint. For local development, replace the package name in both files with the clone's absolute path.
+
+The left rail has no public plugin slot in 2.0.7. `src/activity-rail.ts` is an internal compatibility adapter: it checks a bounded render-tree structure and unambiguous geometry, hides native children while remembering their visibility, and mounts only plugin-owned content. OpenTUI constructors are imported at the terminal entrypoint to preserve host identity. The adapter uses renderer pre-paint callbacks and resize events, not continuous tree polling or root monkeypatches. It restores native children on detach, toggle, and disposal. Compatibility depends on the detected rail structure and geometry, regardless of the OpenCode version string. Unrecognized rail structures, horizontal layouts, and narrow layouts fall back to native tabs. Activity never moves shared native tabs while mounted; native project and activity grouping resumes during fallback.
+
+`src/activity-theme.ts` accepts both `base`/`muted` and legacy `default`/`subdued` theme tokens. Missing colors use a valid fallback before reaching the renderer: assigning an undefined spinner color aborts the entire frame. Accent and worker colors follow the theme's foreground brightness rather than fixed light/dark shade numbers. If a hue lacks sufficient text contrast, Activity uses the theme's normal foreground. The `@opencode/theme` development dependency keeps the host theme types available to TypeScript. Renderer regression tests cover both token shapes and missing colors, including spinner construction and subsequent color updates.
+
 ## Verification and limits
 
-Run `bun run typecheck`, `bun test`, and `bun run verify:live`. The live check requires OpenCode 2.0.3, Python, and `uv`. It starts a separate local server, a deterministic model endpoint, and a terminal process with isolated configuration and data. It verifies actual tool calls, durable messages, permission restrictions, worker limits, deleted-worker cleanup, restart behavior, and native tab visibility, busy state, and focus.
+Run `bun run typecheck`, `bun test`, and `bun run verify:live`. The live check requires OpenCode V2, Python, and `uv`. It starts a separate local server, a deterministic model endpoint, and a terminal process with isolated configuration and data. It verifies actual tool calls, durable messages, permission restrictions, worker limits, deleted-worker cleanup, restart behavior, and native tab visibility, busy state, and focus.
 
 Run `bun run verify:tabs` to verify project grouping across real git worktrees, activity-based ordering, permission prompts, completed and resumed workers, focus preservation, and TUI reopening.
 
+Run `bun run verify:activity` to exercise Activity enabled against an isolated instance of the installed OpenCode version. The suite clears its own `.audit/activity` artifacts, uses the deterministic model fixture, and reads actual renderer bounds through the test-only TUI probe. It checks layout, click and keyboard navigation, one-click pin and close controls, and native prompt responses. It also covers section and worker-stack collapse, aggregated worker status, title cleanup, worker restoration, fallback layouts, reloads, and restart persistence. `verify:tabs` and `verify:idle-tabs` explicitly disable Activity to inspect native ordering.
+
 Run `bun run verify:roles` to verify named profiles against the native server and deterministic model endpoint. It checks actual system prompts, model variants, native delegation, read-only execution, reporting, and role-aware retries.
 
 Run `bun run verify:idle-tabs` to open two native terminals on different idle sessions in the same directory and verify that their shared tab order stays stable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op1/threads",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Visible top-level worker sessions for OpenCode V2, with native tabs and durable reports.",
   "type": "module",
   "main": "./index.ts",
@@ -27,19 +27,27 @@
     "verify:live": "uv run --with pyte python scripts/verify-live.py",
     "verify:roles": "python3 scripts/verify-roles.py",
     "verify:idle-tabs": "uv run --with pyte python scripts/verify-idle-tabs.py",
-    "verify:tabs": "uv run --with pyte python scripts/verify-tab-groups.py"
+    "verify:tabs": "uv run --with pyte python scripts/verify-tab-groups.py",
+    "verify:activity": "uv run --with pyte python scripts/verify-activity.py"
   },
   "dependencies": {
-    "@opencode/plugin": "2.0.3",
-    "@opencode/schema": "2.0.3",
+    "@opencode/plugin": "2.0.7",
+    "@opencode/schema": "2.0.7",
+    "fuzzysort": "3.1.0",
     "zod": "4.1.8"
   },
   "peerDependencies": {
+    "@opentui/core": "0.5.10",
+    "@opentui/solid": "0.5.10",
     "solid-js": ">=1.9.0"
   },
   "devDependencies": {
+    "@opencode/theme": "2.0.12",
+    "@opentui/core": "0.5.10",
+    "@opentui/solid": "0.5.10",
     "@types/bun": "1.4.0",
-    "solid-js": "1.9.9",
+    "opentui-spinner": "0.0.7",
+    "solid-js": "1.9.12",
     "typescript": "5.9.3"
   }
 }

package/src/activity-model.ts

@@ -0,0 +1,152 @@
+export type ActivityItem = {
+  id: string;
+  title: string;
+  subtitle: string;
+  updated: number;
+  active: boolean;
+  attention: boolean;
+  busy: boolean;
+  unread?: "activity" | "error";
+  pinned: boolean;
+  hidden: boolean;
+  open: boolean;
+  coordinatorID?: string;
+};
+
+export type ActivityThread = {
+  item: ActivityItem;
+  children: ActivityItem[];
+  status: Pick<ActivityItem, "attention" | "busy" | "unread">;
+};
+
+export function cleanRoleTitle(title: string, managed: boolean) {
+  if (!managed) return title;
+  const remainder = title.replace(/^\[(?:Main|Worker)\] /, "");
+  return remainder.trim() ? remainder : title;
+}
+
+export function activityTime(time: {
+  idle?: number;
+  updated: number;
+  created: number;
+}) {
+  return time.idle ?? time.updated ?? time.created;
+}
+
+export function activitySubtitle(input: {
+  directory: string;
+  project?: { name?: string; canonical: string };
+  role?: "Main" | "Worker";
+}) {
+  const folder = (path: string) =>
+    path
+      .replace(/[\\/]+$/, "")
+      .split(/[\\/]/)
+      .pop() || path;
+  const location = folder(input.directory);
+  const project =
+    input.project?.name?.trim() ||
+    (input.project ? folder(input.project.canonical) : location);
+  const parts = [project];
+  if (input.role) parts.push(input.role);
+  if (
+    input.project &&
+    input.project.canonical !== input.directory &&
+    location !== project
+  )
+    parts.push(location);
+  return parts.join(" · ");
+}
+
+export function dateGroup(timestamp: number, now = new Date()) {
+  const date = new Date(timestamp);
+  const day = (value: Date) =>
+    Date.UTC(value.getFullYear(), value.getMonth(), value.getDate());
+  const age = (day(now) - day(date)) / 86400000;
+  if (age === 0) return "Today";
+  if (age === 1) return "Yesterday";
+  if (age > 1 && age < 7)
+    return date.toLocaleDateString(undefined, { weekday: "long" });
+  return date.toLocaleDateString(undefined, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  });
+}
+
+export function priority(item: ActivityItem) {
+  return item.attention ? 3 : item.busy ? 2 : item.unread ? 1 : 0;
+}
+
+function visible(item: ActivityItem) {
+  return !item.hidden || item.open || item.active || item.busy || item.attention;
+}
+
+function compare(a: ActivityItem, b: ActivityItem) {
+  return (
+    priority(b) - priority(a) ||
+    Number(b.pinned) - Number(a.pinned) ||
+    b.updated - a.updated ||
+    a.id.localeCompare(b.id)
+  );
+}
+
+export function activityGroups(items: ActivityItem[], now = new Date()) {
+  const groups = new Map<string, ActivityItem[]>();
+  const ordered = items.filter(visible).sort(compare);
+  for (const item of ordered) {
+    const key = priority(item)
+      ? "Priority"
+      : item.pinned
+        ? "Pinned"
+        : dateGroup(item.updated, now);
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
+export function activityThreads(items: ActivityItem[], now = new Date()) {
+  const available = new Map(items.filter(visible).map((item) => [item.id, item]));
+  const children = new Map<string, ActivityItem[]>();
+  const roots: ActivityItem[] = [];
+  for (const item of available.values()) {
+    const parent = item.coordinatorID
+      ? available.get(item.coordinatorID)
+      : undefined;
+    if (parent && parent.id !== item.id && !parent.coordinatorID) {
+      const siblings = children.get(parent.id) ?? [];
+      siblings.push(item);
+      children.set(parent.id, siblings);
+    } else roots.push(item);
+  }
+  const threads = new Map<string, ActivityThread>();
+  const summaries = roots.map((item) => {
+    const workers = (children.get(item.id) ?? []).sort(compare);
+    const members = [item, ...workers];
+    const status = {
+      attention: members.some((member) => member.attention),
+      busy: members.some((member) => member.busy),
+      unread: members.some((member) => member.unread === "error")
+        ? ("error" as const)
+        : members.find((member) => member.unread)?.unread,
+    };
+    threads.set(item.id, { item, children: workers, status });
+    return {
+      ...item,
+      ...status,
+      pinned: members.some((member) => member.pinned),
+      updated: Math.max(...members.map((member) => member.updated)),
+    };
+  });
+  return new Map(
+    [...activityGroups(summaries, now)].map(([name, group]) => [
+      name,
+      group.flatMap((item) => {
+        const thread = threads.get(item.id);
+        return thread ? [thread] : [];
+      }),
+    ]),
+  );
+}

package/src/activity-picker.tsx

@@ -0,0 +1,175 @@
+import type { Plugin } from "@opencode/plugin/tui";
+import type { InputRenderable, RGBA, ScrollBoxRenderable } from "@opentui/core";
+import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+import fuzzysort from "fuzzysort";
+import type { ActivityItem } from "./activity-model";
+import { themeColor, themeMuted } from "./activity-theme";
+
+type Choice = Pick<ActivityItem, "id" | "title" | "subtitle" | "pinned"> & {
+  category: string;
+  closed: boolean;
+};
+
+export function ActivityPicker(props: {
+  ctx: Plugin.Context;
+  fallbackColor: RGBA;
+  items: () => Choice[];
+  current: string | undefined;
+  pin: (id: string) => Promise<void>;
+  open: (id: string) => Promise<void>;
+}) {
+  const { ctx } = props;
+  const [query, setQuery] = createSignal("");
+  const [selectedID, setSelectedID] = createSignal(props.current);
+  const [pinning, setPinning] = createSignal(false);
+  const [height, setHeight] = createSignal(ctx.renderer.height);
+  let input: InputRenderable | undefined;
+  let scroll: ScrollBoxRenderable | undefined;
+  let closed = false;
+  const foreground = () => themeColor(ctx.theme.text, props.fallbackColor);
+  const muted = () => themeMuted(ctx.theme.text, foreground());
+  const grouped = createMemo(() => {
+    const items = query()
+      ? fuzzysort.go(query(), props.items(), {
+          keys: ["title", "category"],
+          scoreFn: (result) => result[0].score * 2 + result[1].score,
+        }).map((result) => result.obj)
+      : props.items();
+    const groups = new Map<string, Choice[]>();
+    for (const item of items) {
+      const group = groups.get(item.category) ?? [];
+      group.push(item);
+      groups.set(item.category, group);
+    }
+    return [...groups];
+  });
+  const choices = createMemo(() => grouped().flatMap(([, items]) => items));
+  const selected = () =>
+    choices().find((item) => item.id === selectedID()) ?? choices()[0];
+  const select = (index: number) => setSelectedID(choices()[index]?.id);
+  const move = (direction: number) => {
+    const items = choices();
+    if (!items.length) return;
+    const index = items.findIndex((item) => item.id === selected()?.id);
+    select((index + direction % items.length + items.length) % items.length);
+  };
+  const open = (id = selected()?.id) => {
+    if (!id) return;
+    ctx.ui.dialog.clear();
+    void props.open(id);
+  };
+  const togglePin = async () => {
+    const item = selected();
+    if (!item || pinning()) return;
+    setSelectedID(item.id);
+    setPinning(true);
+    try {
+      await props.pin(item.id);
+    } finally {
+      if (!closed) setPinning(false);
+    }
+  };
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    target: () => input,
+    priority: 100,
+    commands: [
+      { bind: "up", run: () => move(-1) },
+      { bind: "ctrl+p", run: () => move(-1) },
+      { bind: "down", run: () => move(1) },
+      { bind: "ctrl+n", run: () => move(1) },
+      { bind: "pageup", run: () => move(-10) },
+      { bind: "pagedown", run: () => move(10) },
+      { bind: "home", run: () => { select(0); } },
+      { bind: "end", run: () => { select(choices().length - 1); } },
+      { bind: "return", run: () => open() },
+      { bind: "escape", run: () => ctx.ui.dialog.clear() },
+      {
+        id: "threads.activity.choose.pin",
+        title: "Pin/unpin highlighted Activity conversation",
+        bind: "ctrl+f",
+        run: togglePin,
+      },
+    ],
+  }));
+  let scrollTo: string | undefined;
+  createEffect(() => {
+    grouped();
+    scrollTo = selected()?.id;
+  });
+  const reveal = () => {
+    if (!scrollTo || !scroll) return;
+    scroll.scrollChildIntoView(`activity-picker-row-${scrollTo}`);
+    scrollTo = undefined;
+  };
+  const resize = () => setHeight(ctx.renderer.height);
+  ctx.renderer.addPostProcessFn(reveal);
+  ctx.renderer.on("resize", resize);
+  onCleanup(() => {
+    closed = true;
+    ctx.renderer.removePostProcessFn(reveal);
+    ctx.renderer.off("resize", resize);
+  });
+  return (
+    <box id="activity-picker" paddingX={2} paddingY={1} gap={1}>
+      <text fg={foreground()}><b>Activity</b></text>
+      <input
+        id="activity-picker-search"
+        ref={(node) => { input = node; }}
+        focused
+        placeholder="Search"
+        textColor={foreground()}
+        focusedTextColor={foreground()}
+        onInput={(value) => {
+          setQuery(value);
+          setSelectedID(undefined);
+        }}
+      />
+      <scrollbox
+        ref={(node) => { scroll = node; }}
+        height={Math.max(1, Math.min(
+          choices().length + grouped().length * 2,
+          Math.floor(height() / 2) - 6,
+        ))}
+        scrollX={false}
+        scrollbarOptions={{ visible: false }}
+      >
+        <For each={grouped()}>{([category, items]) => <>
+          <text fg={muted()} marginTop={1}>{category}</text>
+          <For each={items}>{(item) => (
+            <box
+              id={`activity-picker-row-${item.id}`}
+              height={1}
+              flexShrink={0}
+              flexDirection="row"
+              backgroundColor={selected()?.id === item.id
+                ? ctx.theme.background.raised?.high ?? themeColor(ctx.theme.background, props.fallbackColor)
+                : undefined}
+              onMouseUp={(event) => {
+                event.stopPropagation();
+                if (event.button === 0) open(item.id);
+              }}
+            >
+              <text
+                id={`activity-picker-title-${item.id}`}
+                fg={foreground()}
+                width="60%"
+                wrapMode="none"
+                truncate
+              >{`${selected()?.id === item.id ? ">" : " "} ${item.pinned ? "◆" : "◇"} ${item.title}`}</text>
+              <text fg={muted()} flexGrow={1} flexShrink={1} minWidth={0} wrapMode="none" truncate>
+                {`${item.subtitle}${item.closed ? " · Closed" : ""}`}
+              </text>
+            </box>
+          )}</For>
+        </>}</For>
+        <Show when={!choices().length}>
+          <text fg={muted()}>No matching conversations</text>
+        </Show>
+      </scrollbox>
+      <text id="activity-picker-hint" fg={muted()}>
+        {`${ctx.keymap.shortcuts("threads.activity.choose.pin").join(" / ")} ${selected()?.pinned ? "Unpin" : "Pin"} · enter Open · esc Close`}
+      </text>
+    </box>
+  );
+}

package/src/activity-rail.ts

@@ -0,0 +1,135 @@
+import type { BoxRenderable, Renderable } from "@opentui/core";
+import type { Plugin } from "@opencode/plugin/tui";
+
+// Compatibility boundary: OpenCode 2.0.7 has no public left-tab-rail slot.
+export function activityRail(
+  ctx: Plugin.Context,
+  core: Pick<
+    typeof import("@opentui/core"),
+    "BoxRenderable" | "ScrollBoxRenderable"
+  >,
+  mount: (rail: BoxRenderable) => () => void,
+) {
+  const { BoxRenderable, ScrollBoxRenderable } = core;
+  let owned:
+    | {
+        rail: BoxRenderable;
+        content: BoxRenderable;
+        restore: Map<Renderable, boolean>;
+        cleanup: () => void;
+      }
+    | undefined;
+  let enabled = true;
+  let dirty = true;
+  let geometry = "";
+  const detach = () => {
+    if (!owned) return;
+    owned.cleanup();
+    if (!owned.content.isDestroyed) owned.content.destroyRecursively();
+    for (const [child, visible] of owned.restore)
+      if (!child.isDestroyed) child.visible = visible;
+    owned = undefined;
+  };
+  const find = () => {
+    const matches: BoxRenderable[] = [];
+    const queue: { node: Renderable; depth: number }[] = [
+      { node: ctx.renderer.root, depth: 0 },
+    ];
+    let count = 0;
+    while (queue.length && count++ < 128) {
+      const entry = queue.shift();
+      if (!entry) break;
+      const children = entry.node.getChildren();
+      for (const child of children) {
+        if (
+          child instanceof BoxRenderable &&
+          child.visible &&
+          child.screenX === 0 &&
+          child.screenY === 0 &&
+          child.width >= 24 &&
+          child.width <= 60 &&
+          child.height === ctx.renderer.height &&
+          child
+            .getChildren()
+            .some((node) => node instanceof ScrollBoxRenderable) &&
+          children.filter(
+            (sibling) =>
+              sibling !== child &&
+              sibling.screenX === child.width &&
+              sibling.screenY === 0 &&
+              sibling.height === child.height &&
+              sibling.width >= 60,
+          ).length === 1
+        )
+          matches.push(child);
+        if (entry.depth < 4)
+          queue.push({ node: child, depth: entry.depth + 1 });
+      }
+    }
+    return queue.length === 0 && matches.length === 1 ? matches[0] : undefined;
+  };
+  const frame = () => {
+    if (owned?.rail.isDestroyed || owned?.content.isDestroyed) {
+      detach();
+      dirty = true;
+    }
+    const current = `${ctx.renderer.width}:${ctx.renderer.height}:${owned?.rail.width}:${owned?.rail.height}`;
+    if (current !== geometry) {
+      geometry = current;
+      dirty = true;
+    }
+    if (!dirty) return;
+    dirty = false;
+    const rail = enabled && ctx.ui.tabs.enabled() ? find() : undefined;
+    if (owned?.rail !== rail) detach();
+    if (!rail) return;
+    if (!owned) {
+      const content = new BoxRenderable(ctx.renderer, {
+        id: "op-threads-activity",
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        paddingLeft: 1,
+        paddingRight: 2,
+        flexDirection: "column",
+        onMouseDown: (event) => event.stopPropagation(),
+        onMouseUp: (event) => event.stopPropagation(),
+      });
+      rail.add(content);
+      owned = { rail, content, restore: new Map(), cleanup: mount(content) };
+    }
+    for (const child of rail.getChildren()) {
+      if (child === owned.content) continue;
+      if (!owned.restore.has(child)) owned.restore.set(child, child.visible);
+      child.visible = false;
+    }
+    for (const child of owned.restore.keys())
+      if (child.isDestroyed) owned.restore.delete(child);
+  };
+  const invalidate = () => {
+    dirty = true;
+    ctx.renderer.requestRender();
+  };
+  const beforeFrame = async () => frame();
+  ctx.renderer.setFrameCallback(beforeFrame);
+  ctx.renderer.on("resize", invalidate);
+  invalidate();
+  return {
+    invalidate,
+    enabled: () => enabled,
+    mounted: () =>
+      Boolean(owned && !owned.rail.isDestroyed && !owned.content.isDestroyed),
+    toggle(value = !enabled) {
+      enabled = value;
+      if (!enabled) detach();
+      invalidate();
+    },
+    dispose() {
+      ctx.renderer.removeFrameCallback(beforeFrame);
+      ctx.renderer.off("resize", invalidate);
+      detach();
+    },
+  };
+}

package/src/activity-theme.ts

@@ -0,0 +1,49 @@
+import type { ResolvedTheme } from "@opencode/theme/tui";
+
+type Color = ResolvedTheme["text"]["base"];
+type ColorToken =
+  | { readonly base: Color | undefined }
+  | { readonly default: Color | undefined };
+type MutedToken =
+  | { readonly muted: Color | undefined }
+  | { readonly subdued: Color | undefined };
+
+export function themeColor(token: ColorToken, fallback: Color) {
+  return ("base" in token ? token.base : token.default) ?? fallback;
+}
+
+export function themeMuted(token: MutedToken, fallback: Color) {
+  return ("muted" in token ? token.muted : token.subdued) ?? fallback;
+}
+
+function luminance(color: Color) {
+  const linear = (value: number) =>
+    value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  return (
+    0.2126 * linear(color.r) +
+    0.7152 * linear(color.g) +
+    0.0722 * linear(color.b)
+  );
+}
+
+export function themeHue(
+  hue: Partial<ResolvedTheme["hue"]["accent"]> | undefined,
+  foreground: Color,
+  background: Color,
+) {
+  const target = luminance(foreground);
+  let selected = foreground;
+  let distance = Infinity;
+  for (const color of Object.values(hue ?? {})) {
+    if (!color) continue;
+    const delta = Math.abs(luminance(color) - target);
+    if (delta >= distance) continue;
+    selected = color;
+    distance = delta;
+  }
+  const light = luminance(selected);
+  const base = luminance(background);
+  const contrast =
+    (Math.max(light, base) + 0.05) / (Math.min(light, base) + 0.05);
+  return contrast >= 4.5 ? selected : foreground;
+}