@op1/threads 0.1.3 → 0.1.5

package/README.md

@@ -35,7 +35,11 @@ threads_spawn({
 })
 ```
 
-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.
+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.
+
+Both the parent and managed workers can use native `subagent` for bounded tasks and role-specific reviews. The parent can mix direct subagent calls with managed threads. Each worker can work directly or delegate within its brief and inherited permissions, then review the results and submit its own combined report.
+
+The parent writes the `task` brief. The plugin appends an explicit reminder that native delegation is optional and that workers cannot call `threads_spawn`. Include the worker's delegation budget in the brief. Use `No children` only when the task requires it, since that also rules out native subagents.
 
 ## Tools
 
@@ -78,6 +82,8 @@ Plugin option `maxWorkers` defaults to 4 and accepts integers from 1 through 32.
 
 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.
 
+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.
+
 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.
 
 The coordinator can call `threads_hide` when a worker is no longer needed. Hiding preserves the conversation and report, survives restarts, and does not free an admission slot. `/threads` restores hidden workers and keeps them visible for inspection. A valid `threads_send` follow-up also restores its worker. Visibility overrides belong to the original report message ID, so recreating a deleted worker cannot inherit its hidden state.

package/index.ts

@@ -38,7 +38,7 @@ export default Plugin.define({
       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.",
+          "Delegate a task to a top-level worker in an existing absolute directory. Both you and the worker may use native subagent when useful. Include any delegation limits in task. Workers cannot call threads_spawn. Reuse key only for identical requests.",
         input: Spawn,
         output: WorkerView,
         options: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op1/threads",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Visible top-level worker sessions for OpenCode V2, with native tabs and durable reports.",
   "type": "module",
   "main": "./index.ts",
@@ -32,6 +32,9 @@
     "@opencode/schema": "2.0.3",
     "zod": "4.1.8"
   },
+  "peerDependencies": {
+    "solid-js": ">=1.9.0"
+  },
   "devDependencies": {
     "@types/bun": "1.4.0",
     "solid-js": "1.9.9",

package/skills/managed-sessions/SKILL.md

@@ -5,22 +5,30 @@ description: Spawn and monitor visible top-level OpenCode workers with op-thread
 
 # Managed sessions
 
-Choose the delegation mode before launching work.
+Choose the delegation mode for each task. The parent can mix both modes in the same run.
 
 - 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.
+Both the parent and managed workers may use native `subagent` when useful. Delegation is optional. Managed workers cannot create further managed workers. Count both modes and workers' native subagents against the active protocol's delegation budget. 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`.
+3. Call `threads_spawn` with `key`, `title`, `directory`, and `task`. Include the goal, scope, relevant context, constraints, delegation allowance, 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.
 
+## Write the delegation allowance
+
+The parent writes `task`; the plugin appends worker instructions. Give workers the option to delegate without requiring a sub-coordinator role. Include this allowance and the worker's share of the remaining delegation budget:
+
+> You may work directly or use native `subagent` for bounded tasks and reviews when useful. Pass your scope and constraints to subagents, review their results, and resolve outstanding work before calling `threads_report` yourself.
+
+Use a no-delegation restriction only for a task-specific reason or an explicit user constraint, and state the reason. Being a managed worker or having bounded scope does not by itself make the worker a leaf. To limit managed-thread nesting, say `Do not call threads_spawn` rather than `No children`.
+
 ## Coordinate
 
 - Use `threads_list` for a progress snapshot when making a scheduling or delivery decision.
@@ -32,10 +40,12 @@ An identical spawn key retries the original admission. Different work requires a
 
 ## 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.
+The worker reviews its subagents' results and resolves outstanding work before calling `threads_report` with a combined verdict, concise summary, and concrete evidence, then stops. Native subagents return results to the worker. 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
 
+Managed tab titles start with `[Main]` for the coordinator or `[Worker]` for the worker. The TUI applies these prefixes to saved titles while preserving the rest of the name.
+
 The TUI plugin opens managed workers as ordinary tabs without changing focus. Workers with `PASS` or `PASS WITH NOTES` reports hide automatically once inactive. Failed, inconclusive, and unreported workers stay visible until the coordinator hides them. Running, selected, and attention-needed tabs stay open. Use `/threads` to restore hidden tabs for inspection. Sending a valid follow-up also restores that worker. Reports are delivered silently to the coordinator and remain available through `threads_list`.

package/src/threads.ts

@@ -249,7 +249,7 @@ export function threads(
           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.`,
+          text: `${input.task}\n\nYou are a managed worker assigned to ${input.directory}. Work only within the assigned scope. You may use native subagent for bounded tasks or reviews when useful, within the brief's delegation limits and inherited permissions. Delegation is optional. Pass relevant context, scope, and constraints to each subagent. Do not call threads_spawn. Review your subagents' results and resolve any outstanding work before reporting. Only you call threads_report with the combined verdict, summary, and evidence; subagents return results to you. Runtime completion alone does not establish task success.`,
         });
         return view(await ctx.session.get({ sessionID: workerID }));
       });

package/tui.ts

@@ -1,16 +1,22 @@
 import { Plugin } from "@opencode/plugin/tui";
+import { createEffect } from "solid-js";
+import { z } from "zod";
 import { ThreadsRpc } from "./src/rpc";
 
+const CoordinatorRef = z.object({ coordinatorID: z.string() });
+
 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 });
+    const closing = new Set<string>();
     let stopped = false;
     let running = false;
     let reopenPending = false;
     let lastError: string | undefined;
+    let movingFrom: string | undefined;
     function groupTabs() {
       const tabs = ctx.ui.tabs.list().map((tab) => {
         const projectID = ctx.data.session.get(tab.sessionID)?.projectID;
@@ -38,9 +44,14 @@ export default Plugin.define({
           .sort((left, right) => Number(right.priority) - Number(left.priority))
           .map((tab) => tab.sessionID),
       );
+      const current = tabs.map((tab) => tab.sessionID);
+      const stamp = JSON.stringify(current);
+      if (movingFrom === stamp) return;
+      movingFrom = undefined;
       for (const [index, sessionID] of ordered.entries()) {
-        if (ctx.ui.tabs.list()[index]?.sessionID === sessionID) continue;
-        if (!ctx.ui.tabs.move(sessionID, index)) break;
+        if (current[index] === sessionID) continue;
+        if (ctx.ui.tabs.move(sessionID, index)) movingFrom = stamp;
+        break;
       }
     }
     async function reconcile(reopen = false) {
@@ -55,7 +66,14 @@ export default Plugin.define({
         const route = ctx.ui.router.current();
         const coordinatorIDs = [
           ...new Set([
-            ...ctx.ui.tabs.list().map((tab) => tab.sessionID),
+            ...ctx.ui.tabs.list().flatMap((tab) => {
+              const link = CoordinatorRef.safeParse(
+                ctx.data.session.get(tab.sessionID)?.metadata?.opThreads,
+              );
+              return link.success
+                ? [tab.sessionID, link.data.coordinatorID]
+                : [tab.sessionID];
+            }),
             ...(route.type === "session" ? [route.sessionID] : []),
           ]),
         ].slice(0, 100);
@@ -67,6 +85,8 @@ export default Plugin.define({
         for (const worker of workers) {
           if (stopped) return;
           const tab = ctx.ui.tabs.list().find((tab) => tab.sessionID === worker.workerID);
+          if (closing.has(worker.workerID) && tab) continue;
+          const closed = closing.delete(worker.workerID);
           if (
             worker.hidden &&
             !tab?.active &&
@@ -74,7 +94,10 @@ export default Plugin.define({
             !tab?.attention &&
             ctx.data.session.status(worker.workerID) !== "running"
           ) {
-            if (tab && !ctx.ui.tabs.close(worker.workerID)) continue;
+            if (tab) {
+              if (!ctx.ui.tabs.close(worker.workerID)) continue;
+              closing.add(worker.workerID);
+            }
             if (seen.workerIDs.includes(worker.workerID)) {
               updateSeen((draft) => {
                 draft.workerIDs = draft.workerIDs.filter(
@@ -84,7 +107,7 @@ export default Plugin.define({
             }
             continue;
           }
-          if (!reopen && seen.workerIDs.includes(worker.workerID)) continue;
+          if (!reopen && !closed && seen.workerIDs.includes(worker.workerID)) continue;
           await ctx.data.session.sync(worker.workerID);
           if (
             !stopped &&
@@ -96,7 +119,23 @@ export default Plugin.define({
             });
           }
         }
-        if (!stopped && ctx.ui.tabs.enabled()) groupTabs();
+        if (!stopped && ctx.ui.tabs.enabled()) {
+          const roles = new Map<string, "Main" | "Worker">();
+          for (const worker of workers) {
+            roles.set(worker.coordinatorID, "Main");
+            roles.set(worker.workerID, "Worker");
+          }
+          for (const tab of ctx.ui.tabs.list()) {
+            if (stopped) return;
+            const role = roles.get(tab.sessionID);
+            const session = ctx.data.session.get(tab.sessionID);
+            if (!role || !session?.title) continue;
+            const title = `[${role}] ${session.title.replace(/^\[(?:Main|Worker)\] /, "")}`;
+            if (title === session.title) continue;
+            await ctx.client.session.rename({ sessionID: tab.sessionID, title });
+          }
+          groupTabs();
+        }
       } finally {
         running = false;
         if (reopenPending) {
@@ -127,6 +166,10 @@ export default Plugin.define({
     const removeSlot = ctx.ui.slot({
       append: "app",
       render: () => {
+        createEffect(() => {
+          ctx.ui.tabs.list();
+          refresh();
+        });
         ctx.keymap.layer(() => ({
           mode: "global",
           commands: [