@op1/threads 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opzero1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @op1/threads
+
+Managed top-level worker sessions for OpenCode 2.0.3. The server entrypoint is `index.ts`; the terminal entrypoint is `tui.ts`.
+
+## Install
+
+Install the plugin globally:
+
+```sh
+opencode plugin add @op1/threads
+```
+
+Or add it to `plugins` in `~/.config/opencode/opencode.jsonc`:
+
+```jsonc
+{
+  "plugins": ["@op1/threads"]
+}
+```
+
+Keep the other entries in your plugin list. Open a fresh TUI to load the terminal entrypoint. Session tabs must be enabled.
+
+The `skills/managed-sessions` directory contains the VERA delegation guide. Copy or link it into `~/.config/opencode/skills/managed-sessions` to make it available to agents.
+
+For local development, clone [opzero1/threads](https://github.com/opzero1/threads), run `bun install`, and use the clone's absolute path as the plugin entry instead. The internal plugin ID remains `op-threads`, so switching between local and published installs preserves worker records.
+
+## Delegate work
+
+```text
+threads_spawn({
+  key: "review-auth",
+  title: "Review authentication",
+  directory: "/absolute/path/to/assigned-worktree",
+  task: "Review the authentication changes. Report findings and verification evidence."
+})
+```
+
+The worker opens in a native tab without taking focus. Select that tab to read its conversation. Use `threads_list` to inspect reports and `/threads` to reopen closed worker tabs. Native `subagent` remains available for bounded tasks and role-specific reviews.
+
+## Tools
+
+The native tool names use namespace `threads` and individual names `spawn`, `list`, `send`, `interrupt`, and `report`.
+
+| Tool | Input | Result |
+| --- | --- | --- |
+| `threads_spawn` | `{ key, title, directory, task }` | Worker view |
+| `threads_list` | `{}` | `{ workers: WorkerView[] }` |
+| `threads_send` | `{ workerID, key, text }` | `{ workerID, messageID }` |
+| `threads_interrupt` | `{ workerID }` | Worker view |
+| `threads_report` | `{ verdict, summary, evidence }` | `{ workerID, report }` |
+
+All fields are strings except `evidence`, which is an array of strings. Verdicts are `PASS`, `PASS WITH NOTES`, `FAIL`, and `INCONCLUSIVE`. Each tool returns JSON in native `content` and the same value in `output`.
+
+`directory` must exist and be absolute. Spawn uses native `subagent` permission gating. The worker uses the coordinator's agent and model, with resolved agent permissions followed by session permissions. Its actual tool actions still pass through native permission checks. There is no separate directory-approval flow or agent/model override.
+
+Tool identity comes from the calling session. Only the owning coordinator can send or interrupt. Only the exact original top-level worker can report. Native subagents and managed workers cannot spawn managed workers. Native `subagent` remains available.
+
+## Identity and retries
+
+The coordinator ID and spawn key determine the worker ID. Worker metadata contains `opThreads` with exactly `workerID`, `coordinatorID`, `key`, `fingerprint`, `initialMessageID`, and `reportMessageID`. There is no native `parentID`.
+
+The first create includes both message IDs. Subsequent creates adopt the original metadata returned by OpenCode. Identical spawn retries reuse the initial message ID. Changing the title, directory, or task under that key is an error. Startup never replays initial prompts.
+
+Send keys are scoped to the worker and determine a stable message ID. A retry with different text is rejected. Each worker has one task and one terminal report. Identical report retries return the original report; conflicting reports are rejected. Send clarifications within the existing task, and use a new spawn key for new work. The persisted report view is keyed by the original report message ID, so recreating a deleted worker cannot inherit an old verdict.
+
+## Worker views and limits
+
+`WorkerView` contains `workerID`, `coordinatorID`, `key`, `title`, `directory`, `outcome`, and `report`. `outcome` is the native last execution outcome, or `null` before one exists. It is not current activity. Native tabs display current busy, attention, and unread state.
+
+`report` is the explicit worker claim, or `null`. Native `succeeded` means the agent loop completed, not that the assigned task passed.
+
+Plugin option `maxWorkers` defaults to 4 and accepts integers from 1 through 32. Admission is serialized by coordinator within the loaded server process. A worker without a report continues to occupy a slot unless its native outcome is `failed` or `interrupted`. A successful run without a report does not silently free its slot.
+
+## 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 read-only RPC definition is `ThreadsRpc` in `src/rpc.ts`, with ID `threads` and method `snapshot`:
+
+```ts
+input: { coordinatorIDs: string[] }
+result: { workers: WorkerView[] }
+```
+
+The input accepts at most 100 coordinator IDs. Raw HTTP RPC requests wrap the input as `{ "input": { "coordinatorIDs": ["ses_..."] } }`. The 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.
+
+## 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.
+
+Pass an extracted package directory to test the release artifact: `bun run verify:live /absolute/path/to/package`.
+
+The native session and plugin index are separate writes. A crash after session creation but before indexing requires an explicit identical spawn retry. A crash after native report admission but before saving the report view requires an explicit report retry; the native coordinator notification remains canonical and is not duplicated. There is no custom outbox or startup task replay.
+
+Snapshots remove stale index entries for deleted sessions. Admission locking assumes one OpenCode server process. Workers that omit `threads_report` have no task verdict; their native execution outcomes remain visible separately.

package/index.ts

@@ -0,0 +1,106 @@
+import { Plugin } from "@opencode/plugin";
+import type { SessionContext } from "@opencode/plugin/promise/session";
+import { z } from "zod";
+import { Report, ThreadsRpc, WorkerView } from "./src/rpc";
+import { Interrupt, Send, Spawn, threads } from "./src/threads";
+
+export default Plugin.define({
+  id: "op-threads",
+  async setup(ctx) {
+    const limit = z
+      .number()
+      .int()
+      .min(1)
+      .max(32)
+      .default(4)
+      .parse(ctx.options.maxWorkers);
+    const workers = threads(ctx, limit);
+    const models = new Map<
+      SessionContext["sessionID"],
+      SessionContext["model"]
+    >();
+    await ctx.session.hook("context", (event) => {
+      models.set(event.sessionID, event.model);
+    });
+    await ctx.rpc.register(ThreadsRpc, {
+      snapshot: async ({ coordinatorIDs }) => ({
+        workers: (await Promise.all(coordinatorIDs.map(workers.list))).flat(),
+      }),
+    });
+    await ctx.tool.transform((editor) => {
+      editor.namespace({
+        name: "threads",
+        description: "Independent managed worker sessions",
+      });
+      editor.add({
+        name: "spawn",
+        description:
+          "Delegate a task to a top-level worker in an existing absolute directory. Reuse key only for identical requests. No managed grandchildren.",
+        input: Spawn,
+        output: WorkerView,
+        options: {
+          namespace: "threads",
+          permission: "subagent",
+          codemode: false,
+        },
+        execute: async (input, tool) => {
+          const model = models.get(tool.sessionID);
+          if (!model)
+            throw new Error("Spawn requires a resolved session context model");
+          const output = await workers.spawn(tool.sessionID, input, {
+            agent: tool.agent,
+            model,
+          });
+          return { content: JSON.stringify(output), output };
+        },
+      });
+      editor.add({
+        name: "list",
+        description:
+          "List your managed workers, last native execution outcomes, and explicit reports. Idle is not task success.",
+        input: z.object({}).strict(),
+        output: z.object({ workers: z.array(WorkerView) }),
+        options: { namespace: "threads", codemode: false },
+        execute: async (_input, tool) => {
+          const output = { workers: await workers.list(tool.sessionID) };
+          return { content: JSON.stringify(output), output };
+        },
+      });
+      editor.add({
+        name: "send",
+        description:
+          "Send a follow-up to your worker. Reuse key for an identical retry.",
+        input: Send,
+        output: z.object({ workerID: z.string(), messageID: z.string() }),
+        options: { namespace: "threads", codemode: false },
+        execute: async (input, tool) => {
+          const output = await workers.send(tool.sessionID, input);
+          return { content: JSON.stringify(output), output };
+        },
+      });
+      editor.add({
+        name: "interrupt",
+        description: "Interrupt your worker without claiming task success.",
+        input: Interrupt,
+        output: WorkerView,
+        options: { namespace: "threads", codemode: false },
+        execute: async (input, tool) => {
+          const output = await workers.interrupt(tool.sessionID, input);
+          return { content: JSON.stringify(output), output };
+        },
+      });
+      editor.add({
+        name: "report",
+        description:
+          "Report your managed task verdict and evidence to your coordinator. Identical retries return the original report; conflicting reports are rejected. Use a new spawn key for a new task.",
+        input: Report,
+        output: z.object({ workerID: z.string(), report: Report }),
+        options: { namespace: "threads", codemode: false },
+        execute: async (input, tool) => {
+          const output = await workers.report(tool.sessionID, input);
+          return { content: JSON.stringify(output), output };
+        },
+      });
+    });
+  },
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@op1/threads",
+  "version": "0.1.0",
+  "description": "Visible top-level worker sessions for OpenCode V2, with native tabs and durable reports.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./tui": "./tui.ts"
+  },
+  "files": ["index.ts", "tui.ts", "src/", "skills/"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/opzero1/threads.git"
+  },
+  "homepage": "https://github.com/opzero1/threads#readme",
+  "bugs": "https://github.com/opzero1/threads/issues",
+  "license": "MIT",
+  "keywords": ["opencode", "opencode-plugin", "agents", "threads"],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "verify:live": "uv run --with pyte python scripts/verify-live.py"
+  },
+  "dependencies": {
+    "@opencode/plugin": "2.0.3",
+    "@opencode/schema": "2.0.3",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.0",
+    "solid-js": "1.9.9",
+    "typescript": "5.9.3"
+  }
+}

package/skills/managed-sessions/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: Managed sessions
+description: Spawn and monitor visible top-level OpenCode workers with op-threads. Use when VERA needs independent workstreams, separate conversations, or durable workers alongside native subagents.
+---
+
+# Managed sessions
+
+Choose the delegation mode before launching work.
+
+- Use native `subagent` for a bounded task or review.
+- Use `threads_spawn` for an independent workstream with its own visible session and assigned directory.
+
+Count both modes against the active protocol's delegation budget. Managed workers can use native subagents, but cannot create further managed workers. Keep every writer in its own assigned worktree. These tools do not create worktrees.
+
+## Start work
+
+1. Confirm the `threads_spawn` tool is available. If it is unavailable, use native `subagent` or report that the plugin needs activation. Do not substitute a hidden `opencode run` process.
+2. Assign an existing absolute directory and a stable task key.
+3. Call `threads_spawn` with `key`, `title`, `directory`, and `task`. Include the goal, scope, relevant context, constraints, acceptance criteria, verification commands, and expected report in `task`.
+4. Save the returned worker session ID with the work unit.
+
+An identical spawn key retries the original admission. Different work requires a new key. A worker inherits the coordinator's agent, model, and permission constraints. It has a separate conversation, so include all context it needs in the task brief.
+
+## Coordinate
+
+- Use `threads_list` for a progress snapshot when making a scheduling or delivery decision.
+- Use `threads_send` with a stable message key for a correction or follow-up within the worker's assigned task.
+- Use `threads_interrupt` to stop that worker's execution.
+- Do not repeatedly query status while waiting. Workers report to the coordinator through OpenCode's durable inbox.
+- After a service restart, inspect existing worker IDs before deciding whether to resume them. Do not launch replacement tasks solely because a session is idle.
+
+## Finish
+
+The worker calls `threads_report` with a verdict, concise summary, and concrete evidence, then stops. Valid verdicts are `PASS`, `PASS WITH NOTES`, `FAIL`, and `INCONCLUSIVE`. Report partial work and blockers honestly.
+
+A worker report is a claim to review. Run the protocol's independent verification before marking the work unit complete. An idle session or a stopped loading indicator does not establish task success.
+
+## Visibility
+
+The TUI plugin opens managed workers as ordinary tabs without changing focus. Each tab uses OpenCode's native activity indicators. Use `/threads` to reopen managed worker tabs you closed.

package/src/rpc.ts

@@ -0,0 +1,34 @@
+import { Rpc } from "@opencode/plugin/rpc";
+import { z } from "zod";
+
+export const Report = z
+  .object({
+    verdict: z.enum(["PASS", "PASS WITH NOTES", "FAIL", "INCONCLUSIVE"]),
+    summary: z.string().min(1),
+    evidence: z.array(z.string()),
+  })
+  .strict();
+
+export const WorkerView = z.object({
+  workerID: z.string(),
+  coordinatorID: z.string(),
+  key: z.string(),
+  title: z.string(),
+  directory: z.string(),
+  outcome: z.enum(["succeeded", "failed", "interrupted"]).nullable(),
+  report: Report.nullable(),
+});
+
+export const ThreadsRpc = Rpc.define({
+  id: "threads",
+  methods: {
+    snapshot: {
+      input: z
+        .object({ coordinatorIDs: z.array(z.string()).max(100) })
+        .strict(),
+      output: z.object({ workers: z.array(WorkerView) }),
+      errors: {},
+    },
+  },
+  events: {},
+});

package/src/threads.ts

@@ -0,0 +1,278 @@
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import type { Plugin } from "@opencode/plugin";
+import type { SessionContext } from "@opencode/plugin/promise/session";
+import type { ToolContext } from "@opencode/plugin/promise/tool";
+import { Session } from "@opencode/schema/session";
+import { SessionMessage } from "@opencode/schema/session-message";
+import { z } from "zod";
+import { Report, WorkerView } from "./rpc";
+
+const sessionID = z.string().transform((value) => Session.ID.make(value));
+const messageID = z
+  .string()
+  .transform((value) => SessionMessage.ID.make(value));
+const MissingSession = z.object({
+  _tag: z.literal("Session.NotFoundError"),
+  sessionID,
+});
+export const Link = z
+  .object({
+    workerID: sessionID,
+    coordinatorID: sessionID,
+    key: z.string().min(1),
+    fingerprint: z.string().min(1),
+    initialMessageID: messageID,
+    reportMessageID: messageID,
+  })
+  .strict();
+export const Spawn = z
+  .object({
+    key: z.string().min(1).max(200),
+    title: z.string().min(1),
+    directory: z.string().min(1),
+    task: z.string().min(1),
+  })
+  .strict();
+export const Send = z
+  .object({
+    workerID: sessionID,
+    key: z.string().min(1).max(200),
+    text: z.string().min(1),
+  })
+  .strict();
+export const Interrupt = z.object({ workerID: sessionID }).strict();
+
+const digest = (parts: string[]) =>
+  createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+export const workerIdentity = (coordinatorID: string, key: string) =>
+  Session.ID.make(`ses_${digest([coordinatorID, key]).slice(0, 32)}`);
+export const fingerprint = (input: z.infer<typeof Spawn>) =>
+  digest([input.title, input.directory, input.task]);
+
+const locks = new Map<string, Promise<void>>();
+export async function serialized<T>(
+  key: string,
+  run: () => Promise<T>,
+): Promise<T> {
+  const previous = locks.get(key) ?? Promise.resolve();
+  let release = () => {};
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  locks.set(key, current);
+  await previous;
+  try {
+    return await run();
+  } finally {
+    release();
+    if (locks.get(key) === current) locks.delete(key);
+  }
+}
+
+type NativeSession = Awaited<ReturnType<Plugin.Context["session"]["get"]>>;
+export function workerLink(
+  session: Pick<NativeSession, "id" | "parentID" | "metadata">,
+) {
+  const link = Link.parse(session.metadata?.opThreads);
+  if (
+    session.parentID !== undefined ||
+    link.workerID !== session.id ||
+    workerIdentity(link.coordinatorID, link.key) !== session.id
+  ) {
+    throw new Error("Not the original managed worker");
+  }
+  return link;
+}
+
+export function threads(
+  ctx: Pick<Plugin.Context, "session" | "agent" | "storage">,
+  limit = 4,
+) {
+  const indexKey = (link: z.infer<typeof Link>) =>
+    `workers/${link.coordinatorID}/${link.workerID}`;
+  const reportKey = (link: z.infer<typeof Link>) =>
+    `reports/${link.workerID}/${link.reportMessageID}`;
+
+  async function view(
+    session: NativeSession,
+  ): Promise<z.infer<typeof WorkerView>> {
+    const link = workerLink(session);
+    const stored = await ctx.storage.get(reportKey(link));
+    return {
+      workerID: link.workerID,
+      coordinatorID: link.coordinatorID,
+      key: link.key,
+      title: session.title ?? link.key,
+      directory: session.location.directory,
+      outcome: session.outcome ?? null,
+      report: stored === undefined ? null : Report.parse(stored),
+    };
+  }
+
+  async function list(coordinatorID: string) {
+    const workers: z.infer<typeof WorkerView>[] = [];
+    let after: string | undefined;
+    do {
+      const page = await ctx.storage.scan({
+        prefix: `workers/${Session.ID.make(coordinatorID)}/`,
+        after,
+        limit: 100,
+      });
+      for (const entry of page.entries) {
+        const link = Link.parse(entry.value);
+        if (link.coordinatorID !== coordinatorID)
+          throw new Error("Worker index ownership mismatch");
+        let session: NativeSession;
+        try {
+          session = await ctx.session.get({ sessionID: link.workerID });
+        } catch (error) {
+          const missing = MissingSession.safeParse(error);
+          if (!missing.success || missing.data.sessionID !== link.workerID)
+            throw error;
+          await ctx.storage.remove(reportKey(link));
+          await ctx.storage.remove(entry.key);
+          continue;
+        }
+        workers.push(await view(session));
+      }
+      after = page.next;
+    } while (after);
+    return workers;
+  }
+
+  async function owned(actor: string, workerID: string) {
+    const session = await ctx.session.get({ sessionID: workerID });
+    const link = workerLink(session);
+    if (link.coordinatorID !== actor)
+      throw new Error("Only the owning coordinator may control this worker");
+    return { session, link };
+  }
+
+  return {
+    list,
+    async spawn(
+      actor: string,
+      input: z.infer<typeof Spawn>,
+      runtime: Pick<ToolContext, "agent"> & Pick<SessionContext, "model">,
+    ) {
+      return serialized(actor, async () => {
+        const coordinator = await ctx.session.get({ sessionID: actor });
+        if (
+          coordinator.parentID !== undefined ||
+          coordinator.metadata?.opThreads !== undefined
+        ) {
+          throw new Error(
+            "Native subagents and managed workers cannot spawn managed workers",
+          );
+        }
+        if (
+          !isAbsolute(input.directory) ||
+          !(await stat(input.directory)).isDirectory()
+        ) {
+          throw new Error("directory must be an existing absolute directory");
+        }
+        const workerID = workerIdentity(actor, input.key);
+        const existing = await list(actor);
+        if (
+          !existing.some((worker) => worker.workerID === workerID) &&
+          existing.filter(
+            (worker) =>
+              !worker.report &&
+              worker.outcome !== "failed" &&
+              worker.outcome !== "interrupted",
+          ).length >= limit
+        ) {
+          throw new Error(`Coordinator worker limit reached (${limit})`);
+        }
+        const agent = await ctx.agent.get({
+          agentID: runtime.agent,
+          location: coordinator.location,
+        });
+        const proposed = Link.parse({
+          workerID,
+          coordinatorID: actor,
+          key: input.key,
+          fingerprint: fingerprint(input),
+          initialMessageID: SessionMessage.ID.create(),
+          reportMessageID: SessionMessage.ID.create(),
+        });
+        const session = await ctx.session.create({
+          id: workerID,
+          title: input.title,
+          location: { directory: input.directory },
+          agent: runtime.agent,
+          model: runtime.model,
+          permissions: [
+            ...agent.data.permissions,
+            ...(coordinator.permissions ?? []),
+          ],
+          metadata: { opThreads: proposed },
+        });
+        const link = workerLink(session);
+        if (
+          link.coordinatorID !== actor ||
+          link.fingerprint !== proposed.fingerprint
+        ) {
+          throw new Error(
+            "This spawn key already belongs to a different request",
+          );
+        }
+        await ctx.storage.set(indexKey(link), link);
+        await ctx.session.prompt({
+          sessionID: link.workerID,
+          id: link.initialMessageID,
+          delivery: "queue",
+          text: `${input.task}\n\nYou are a managed worker assigned to ${input.directory}. Work only within the assigned scope. Do not call threads_spawn. When finished call threads_report with verdict, summary, and evidence. Runtime completion alone does not establish task success.`,
+        });
+        return view(await ctx.session.get({ sessionID: workerID }));
+      });
+    },
+    async send(actor: string, input: z.infer<typeof Send>) {
+      await owned(actor, input.workerID);
+      const id = SessionMessage.ID.make(
+        `msg_${digest([input.workerID, "send", input.key]).slice(0, 32)}`,
+      );
+      const admitted = await ctx.session.synthetic({
+        sessionID: input.workerID,
+        id,
+        text: input.text,
+        delivery: "queue",
+        resume: true,
+      });
+      if (admitted.payload.text !== input.text)
+        throw new Error("This send key already belongs to different text");
+      return { workerID: input.workerID, messageID: admitted.id };
+    },
+    async interrupt(actor: string, input: z.infer<typeof Interrupt>) {
+      await owned(actor, input.workerID);
+      await ctx.session.interrupt({
+        sessionID: input.workerID,
+        continue: false,
+      });
+      return view(await ctx.session.get({ sessionID: input.workerID }));
+    },
+    async report(actor: string, input: z.infer<typeof Report>) {
+      const session = await ctx.session.get({ sessionID: actor });
+      const link = workerLink(session);
+      const admitted = await ctx.session.synthetic({
+        sessionID: link.coordinatorID,
+        id: link.reportMessageID,
+        text: `Managed worker ${link.workerID} (${link.key}) report:\n${JSON.stringify(input)}`,
+        metadata: { opThreadsReport: input, workerID: link.workerID },
+        description: `Worker report: ${link.key}`,
+        delivery: "queue",
+        resume: true,
+      });
+      const canonical = Report.parse(
+        admitted.payload.metadata?.opThreadsReport,
+      );
+      await ctx.storage.set(reportKey(link), canonical);
+      if (JSON.stringify(canonical) !== JSON.stringify(input)) {
+        throw new Error("This worker already has a different report. Start a new task with a new spawn key.");
+      }
+      return { workerID: link.workerID, report: canonical };
+    },
+  };
+}

package/tui.ts

@@ -0,0 +1,110 @@
+import { Plugin } from "@opencode/plugin/tui";
+import { ThreadsRpc } from "./src/rpc";
+
+export default Plugin.define({
+  id: "op-threads",
+  setup(ctx) {
+    const rpc = ctx.client.rpc(ThreadsRpc);
+    const initial: { workerIDs: string[] } = { workerIDs: [] };
+    const [seen, updateSeen] = ctx.storage.memory("seen-workers", { initial });
+    let stopped = false;
+    let running = false;
+    let reopenPending = false;
+    let lastError: string | undefined;
+    async function reconcile(reopen = false) {
+      if (stopped || !ctx.ui.tabs.enabled()) return;
+      if (running) {
+        reopenPending ||= reopen;
+        return;
+      }
+      running = true;
+      try {
+        const route = ctx.ui.router.current();
+        const coordinatorIDs = [
+          ...new Set([
+            ...ctx.ui.tabs.list().map((tab) => tab.sessionID),
+            ...(route.type === "session" ? [route.sessionID] : []),
+          ]),
+        ].slice(0, 100);
+        if (!coordinatorIDs.length) return;
+        const { workers } = await rpc.snapshot(
+          { coordinatorIDs },
+          { location: ctx.location ?? ctx.data.location.default() },
+        );
+        for (const worker of workers) {
+          if (stopped) return;
+          if (!reopen && seen.workerIDs.includes(worker.workerID)) continue;
+          await ctx.data.session.sync(worker.workerID);
+          if (
+            !stopped &&
+            ctx.ui.tabs.open(worker.workerID) &&
+            !seen.workerIDs.includes(worker.workerID)
+          ) {
+            updateSeen((draft) => {
+              draft.workerIDs.push(worker.workerID);
+            });
+          }
+        }
+      } finally {
+        running = false;
+        if (reopenPending) {
+          reopenPending = false;
+          void reconcile(true).catch((error) =>
+            ctx.ui.toast.show({ message: String(error), variant: "error" }),
+          );
+        }
+      }
+    }
+    const refresh = () => {
+      void reconcile().then(
+        () => {
+          lastError = undefined;
+        },
+        (error: unknown) => {
+          const message = `Managed worker tabs: ${String(error)}`;
+          if (!stopped && message !== lastError)
+            ctx.ui.toast.show({ message, variant: "error" });
+          lastError = message;
+        },
+      );
+    };
+    const stopEvents = ctx.data.listen(({ details }) => {
+      if (details.type.startsWith("session.")) refresh();
+    });
+    const timer = setInterval(refresh, 3000);
+    const removeSlot = ctx.ui.slot({
+      append: "app",
+      render: () => {
+        ctx.keymap.layer(() => ({
+          mode: "global",
+          commands: [
+            {
+              id: "threads.reopen",
+              title: "Reopen managed worker tabs",
+              palette: true,
+              slash: { name: "threads" },
+              run: async () => {
+                try {
+                  await reconcile(true);
+                } catch (error) {
+                  ctx.ui.toast.show({
+                    message: String(error),
+                    variant: "error",
+                  });
+                }
+              },
+            },
+          ],
+        }));
+        return null;
+      },
+    });
+    refresh();
+    return () => {
+      stopped = true;
+      clearInterval(timer);
+      stopEvents();
+      removeSlot();
+    };
+  },
+});