@henryqw/pi-subagent 26.3.0 → 26.4.0

package/README.md

@@ -6,7 +6,7 @@ Delegate work to configured Pi Roles with [Herdr](https://herdr.dev/). Authorize
 
 ## Install
 
-Requires Pi 1.1.0 or later. Development and automated checks use Pi 1.1.0. Older Pi releases are no longer supported.
+Requires Pi 1.1.0 or later in the 1.x series. Development and automated checks use Pi 1.1.0. Older Pi releases are no longer supported.
 
 ```bash
 pi install npm:@henryqw/pi-task-models
@@ -39,7 +39,7 @@ Commands are for you. Delegation and state tools and the packaged skill are for
 | `subagent_abort` | tool | Abort an isolated request only when no retained candidates or integration worktrees remain; cannot discard them. |
 | `git_read` | tool | For Role-declared children (not Main): inspect bounded local Git evidence without Bash, tests, network access, or writes. |
 | `pi-subagent` | skill | Guide Main through delegation, authorization, checks, integration, and recovery. |
-| Direct status widget (`D`) | ui | For you in the TUI: show direct worker status, Role badges, route, elapsed time, and measured session tokens. |
+| Direct status widget (`D`) | ui | For you in the TUI: show direct worker references (such as `D7.1`), status, Role badges, names, route, task elapsed time, measured session tokens, pending tools, and the latest tool's recorded time. |
 | Isolated status widget (`I`) | ui | For you in the TUI: show recorded task state, Role/model-class badges, and retained workspaces; readiness does not mean promotion. |
 
 ![Main, its coordinator extension, and a Herdr subagent through checked work, worker failure, and coordinator interruption](./docs/worker-lifecycle.svg)
@@ -50,10 +50,18 @@ The coordinator is extension code running in Main's Pi process, not another agen
 
 The TUI has two separate compact status widgets, each with one row per visible worker or task. `D` marks direct work; `I` marks isolated work. Badges such as `[S]` and `[I3]` identify the Role initial. Isolated badges also include the model class: `1` fast, `2` balanced, `3` frontier, `*` fav.
 
-The direct widget shows the launched model, thinking level, elapsed time, and measured session tokens (`— tok` until usage is available). Failed rows appear before working and completed rows. When rows overflow, `… N more` includes counts by status. The isolated widget shows the recorded task state and any retained workspace, not reliable live model, thinking, or token readings from Herdr. Attention appears before ordinary work; overflow uses `+N more · /subagent`. An aborted request with visible tasks has its own `request aborted` row and does not change their recorded statuses. A committed worker without a checked candidate can still show attention rather than readiness. Status glyphs use the active TUI theme, while the text still names the status without color.
+Each direct row starts with a saved reference such as `D7.1`. `D7` is the workflow number in this Pi session, and `.1` is the worker's position in the original request. `/subagent` uses the same reference and name; the Herdr tab label shows them at launch. Numbers continue after reload and are never reused in the session; if a session switch carries a workflow into a session that already uses its number, it gets a new number there. An existing Herdr tab keeps its original launch label. The direct widget shows the launched model, thinking level, elapsed time, and measured session tokens (`— tok` until usage is available). Failed rows appear before working and completed rows. When rows overflow, `… N more` includes counts by status. The isolated widget shows the recorded task state and any retained workspace, not reliable live model, thinking, or token readings from Herdr. Attention appears before ordinary work; overflow uses `+N more · /subagent`. An aborted request with visible tasks has its own `request aborted` row and does not change their recorded statuses. A committed worker without a checked candidate can still show attention rather than readiness. Status glyphs use the active TUI theme, while the text still names the status without color.
 
 A ready isolated candidate is **not promoted** to Main. Choose **Refresh** in `/subagent` to reload both the menu and isolated widget from saved state; it does not recover or change a request. Use `/subagent` or `subagent_status` for exact identities, failures, and recovery.
 
+### Direct tool activity
+
+Direct rows can show `pending read, bash` and `last read 125ms recorded`. Pending means Pi saved the call but has no matching result in this task's session. It does not prove that execution started. Parallel calls remain pending until their own results arrive.
+
+Recorded time comes only from the latest matched tool result's `durationMs`. It is not calculated from assistant timestamps. If the latest result has no timing, no tool time is shown, even if an earlier result had timing. Older sessions and calls rejected before execution can have no recorded time. Task elapsed time remains a separate metric.
+
+Activity uses the existing session sample and file-size cache. A partial trailing JSONL entry is ignored until it is complete. Tool names have terminal control characters removed for display. Narrow rows drop activity before other metrics to keep worker identity and failure state visible. Activity and time are display information, not proof of task completion, worker ownership, or a timeout.
+
 ### How Main routes delegation
 
 Main chooses the mode from your request; you do not need to select one. Words like “direct” and “isolated” can signal your intent, but the work determines the route. Main declares the chosen mode in every `delegate_task` call, and the extension never falls back between modes.
@@ -88,13 +96,13 @@ Chain:    { mode: "direct", chain: [{ role, name, task, ... }] }
 
 Direct tasks use the selected Role's declared tools, extensions, Skills, and MCP servers, including write-capable resources. Authorization comes from your request and Main's bounded task packet, not the Role's capabilities: name allowed paths/actions and exclusions, preserve unrelated edits and staged changes, and authorize commits or external actions explicitly. For example, a configured Git operator with `bash` can stage named pending files and commit them on the `fast` route. Read-only Roles retain their tool restrictions. Use isolated mode for a checked changeset.
 
-Direct writes affect Main's checkout immediately. No clean-checkout prerequisite, automatic checks, rollback, or isolated integration guarantee applies. Requests containing potential writers (including any extensions or MCP servers) can start only when no direct writer owns the checkout and no Main potentially-writing call is in flight there. They run their tasks serially and hold checkout admission after the initial handle returns; competing direct writers and Main writes fail until all owned workers are proved stopped. Use `mode: isolated` to keep Main free to write, with worktree checks and explicit integration instead of immediate shared-checkout changes. Pure read-only parallel requests still run concurrently. A failure in a potential-writer request stops further dispatch; an uncertain worker may still be running. Chains replace each literal `{previous}` with the preceding successful answer and stop on failure. Task outcome and worker termination are separate: after settlement the coordinator closes exact owned writer panes and releases admission only after pane absence and two empty private process-lease scans. Native `lsof` is required for this proof; no Git files, commits, or saved sessions are removed. Failure remains failure even when admission is released. If closing fails, identity changes, a leased child survives, or inspection is uncertain, admission stays held. Open `/subagent`, select the exact direct task, and choose **Close/cancel-and-release owned workers** to cancel dispatch and retry termination. The action checks session/branch/epoch and live ownership; recorded-only tasks cannot unlock anything. Resolve the reported blocker (including any surviving owned process), then repeat the same action. Restarting Pi is not termination proof. Inspect partial changes before new writes; never blindly retry a commit or delete work to recover.
+Direct writes affect Main's checkout immediately. No clean-checkout prerequisite, automatic checks, rollback, or isolated integration guarantee applies. Requests containing potential writers (including any extensions or MCP servers) can start only when no direct writer owns the checkout and no Main potentially-writing call is in flight there. They run their tasks serially and hold checkout admission after the initial handle returns; competing direct writers and Main writes fail until all owned workers are proved stopped. Use `mode: isolated` to keep Main free to write, with worktree checks and explicit integration instead of immediate shared-checkout changes. Pure read-only parallel requests still run concurrently. A failure in a potential-writer request stops further dispatch; an uncertain worker may still be running. Chains replace each literal `{previous}` with the preceding successful answer and stop on failure. Task outcome and worker termination are separate: after settlement the coordinator closes exact owned writer panes and releases admission only after pane absence and two empty private process-lease scans. Native `lsof` is required for this proof; no Git files, commits, or saved sessions are removed. Failure remains failure even when admission is released. If closing fails, identity changes, a leased child survives, or inspection is uncertain, admission stays held. Open `/subagent`, select the exact direct workflow, and choose **Close/cancel-and-release ALL owned workers in this workflow** to cancel dispatch and retry termination. It stops every owned worker of that workflow, not one selected worker. The action checks session/branch/epoch and live ownership; recorded-only tasks cannot unlock anything. Resolve the reported blocker (including any surviving owned process), then repeat the same action. Restarting Pi is not termination proof. Inspect partial changes before new writes; never blindly retry a commit or delete work to recover.
 
 If tab creation times out or returns incomplete or mismatched identity, `/subagent` retains the allocation intent: workspace, checkout, label, private lease/session paths, and any returned tab/pane IDs. No worker is started until creation identity is verified. These records are evidence, not ownership: Close is unavailable for unverified allocation, and admission remains held pending manual reconciliation against Herdr. Do not recreate a tab, guess missing IDs, or restart to bypass this blocker. A Close begun while a worker is active keeps its branch/session/epoch guards through cancellation settlement; stale dialogs cannot close panes or release admission.
 
 Potential-writer tasks must return one JSON completion object, such as `{"outcome":"succeeded","answer":"Scoped commit completed."}`. `outcome` must be `succeeded`, `failed`, or `blocked`, and `answer` must be non-empty. A normal final Pi turn is not enough: failure, blocked work, plain text, or malformed completion stops later dispatch, but admission depends on proved termination, not the reported outcome. Success is the worker's explicit report, not independent validation of its changes.
 
-The tool returns a task ID and first Herdr tab after launch, not the answer. The extension observes each worker and sends one result to Main when the workflow finishes. If Main is busy, Pi queues it after the current turn; if idle, it starts a turn. A blocked, stalled, unknown, or truncated result is not reported as success. Session switch or shutdown stops observation and preserves tab identities for recovery. Open `/subagent` on the session branch to inspect exact tabs, agents, and Pi session files, including tabs launched after the first. A recorded tab may no longer be running; locally observed work is labelled separately.
+The tool returns a task ID and first Herdr tab after launch, not the answer. The extension observes each worker and sends one result to Main when the workflow finishes. If Main is busy, Pi queues it after the current turn; if idle, it starts a turn. A blocked, stalled, unknown, or truncated result is not reported as success. Session switch or shutdown stops observation and preserves tab identities for recovery. Open `/subagent` on the session branch to inspect exact tabs, agents, and Pi session files, including tabs launched after the first. The menu has one row per workflow: a single worker shows its reference, Role, and name (`D7.1 · worker · Search audit`); a multi-worker workflow shows its reference and worker count (`D8 · 3 workers`), and selecting it lists each recorded worker by reference, Role, and name with its exact IDs. References and names help you match rows; they are never used to decide ownership. Older records without saved references show their saved allocation label or exact task ID. A `recorded only` row is not proof that its workers are running or finished; locally observed work is labelled separately.
 
 ### Isolated checked graphs
 
@@ -149,7 +157,7 @@ Completed text answers are saved independently of cleanup. Status and terminal f
 
 Isolated workers can start while Main has staged, unstaged, or untracked changes: they use only Main's pinned committed branch, HEAD, and tree. Those local edits are neither copied into worker worktrees nor stashed, staged, reset, or merged automatically. Main must remain at that committed identity while workers run; branch or HEAD drift blocks new waves. The worker produces a committed candidate without tracked or untracked changes, then runs focused preliminary checks and optional judgment. Ignored generated files do not block candidacy, but prevent automatic worktree cleanup; inspect them before deleting retained work. The runner records each ready candidate immediately but **does not integrate it automatically**. Main can inspect `subagent_status` and use `subagent_stage` to select the exact candidate in an owned integration worktree while siblings are still working; conflicts are resolved there. Stage and resolve are available during an active wave, but rejection and revision wait for the wave to settle. `subagent_integrate` can advance dependent tasks from a staged snapshot, validate the combined tip with full root checks and optional final judgment after the wave settles, and promote it to Main only after exact validation. A definitive failed combined check/review allows one committed correction in the integration checkout followed by another validation. Main must explicitly promote; promotion and cleanup never silently discard retained work.
 
-Open `/subagent` without arguments to pick work by label. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout (including requests launched in other sessions). Pick an isolated request and **Inspect status and recovery** to launch a non-focused Herdr tab with a read-only `scout` Role on the configured `fast` route. Unlike ordinary direct delegation, status inspection rejects Roles with extensions or MCP servers because their tools are not verified read-only. Its prompt contains bounded saved status (including retained paths, but not raw launch environment or session transcripts); the analysis stays in that tab and does not queue a Main turn. The tab and session file are recorded for recovery even if launch becomes uncertain. The read-only `subagent_status` tool remains Main's authority for exact identities before any stage or recovery action. If Herdr or the read-only fast route is unavailable, inspection fails without changing the request; Main can use `subagent_status`. Refresh or choose completed/history for older work. Invalid state IDs are warned about and preserved. Outside Git or when isolated inventory is unavailable, direct recovery still works. Browsing does not resume work or change resources; direct **Close/cancel-and-release** is an explicit termination action.
+Open `/subagent` without arguments to pick work by label. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout (including requests launched in other sessions). Pick an isolated request and **Inspect status and recovery** to launch a non-focused Herdr tab with a read-only `scout` Role on the configured `fast` route. Unlike ordinary direct delegation, status inspection rejects Roles with extensions or MCP servers because their tools are not verified read-only. Its prompt contains bounded saved status (including retained paths, but not raw launch environment or session transcripts); the analysis stays in that tab and does not queue a Main turn. The tab appears in the direct list with its own reference and name, such as `D9.1 · scout · Inspect <request ID>`. The tab and session file are recorded for recovery even if launch becomes uncertain. The read-only `subagent_status` tool remains Main's authority for exact identities before any stage or recovery action. If Herdr or the read-only fast route is unavailable, inspection fails without changing the request; Main can use `subagent_status`. Refresh or choose completed/history for older work. Invalid state IDs are warned about and preserved. Outside Git or when isolated inventory is unavailable, direct recovery still works. Browsing does not resume work or change resources; direct **Close/cancel-and-release** is an explicit termination action.
 
 For a locally active unsealed isolated changeset, choose **Send follow-up instructions** to open a native multiline editor; submission queues the instruction, not a completed revision. Choose **Edit queued instructions** to withdraw *all still-pending* instructions for that selected task before the editor opens. Their full text appears in FIFO order separated by blank lines. Explicit submission queues **one replacement** at the tail. Cancel leaves the withdrawn instructions removed; already-claimed instructions, initial prompts, and automatic corrections cannot be recalled. A worker may seal during editing: failed submission reopens the full submitted text for deliberate editing or copying, never automatically requeues it. Combined text above the single-instruction limit is preserved in the editor but rejected until shortened. Cancelling before withdrawal makes no change. Neither action touches Main's editor or Pi's global Option+Up queue shortcut. No-UI sessions can run `/subagent recover` or use agent tools for individual inspection and recovery.
 
@@ -229,7 +237,7 @@ Main's nested calls pass admission by their own tool names, not by script or anc
 
 To let a Role run `codemode` scripts, list `builtin:codemode` in `extensions` and `codemode` in `tools`; both are required, because the built-in registers the tool inactive and the Role tool policy activates it. `codemode` alone in `tools` fails the launch as an unavailable tool. Pi's `codemode.mode` and `codemode.inlineBudget` settings apply in the child unchanged, so the Role never forces codemode-only operation, and MCP configuration never activates `codemode` in a child. Scripts can call only the Role's active tools plus `codemode`/`deferred` extension and MCP tools; inactive base tools such as `bash` stay unreachable.
 
-The servers named in `mcps` come from the global `~/.pi/agent/mcp.json` only. In a Role that activates `codemode`, each selected server keeps its configured `exposure` and `toolExposure` (Pi's default `codemode` exposure makes tools callable from scripts without declaring them, `direct` declares them, `deferred` tools stay reachable from scripts, `hidden` tools stay unreachable), and an invalid exposure value fails the launch. In every other Role, selected servers are forced to `direct` exposure and `toolExposure` is ignored, because that child cannot reach undeclared tools. Declared tools appear to the model as `mcp__<server>__<tool>` once the server connects. Pi replaces `-` in server and tool names with `_` and appends a hash suffix when two tool names collide or a name exceeds 64 characters. Each selected entry is checked against Pi's documented `mcpServers` rules before launch, in Main and again in the child: a disabled, malformed, or unknown-transport entry, an invalid server name, two selected names that differ only in `-` and `_`, `auth.provider` over plain HTTP outside `localhost`, `127.0.0.1`, or `[::1]`, or a non-HTTPS `oauth.authServerMetadataUrl` outside those hosts fails the launch with the file path and field. The file is never modified; fix the entry or choose another server. Valid `auth`, `oauth`, and `description` fields are passed through so Pi's native provider auth and OAuth apply. `oauth.clientRegistration` must be `dcr` or `cimd`; `cimd` requires Pi 1.0.1 or later; Pi 1.0.0 rejects it before child launch. It cannot use `clientId` or `clientName`, and any `callbackUrl` must use localhost or 127.0.0.1 with path `/callback`. Project MCP overrides remain ignored: a project cannot change the Role's global server allowlist or exposure. Missing Skills, tools, MCP servers, Roles, or routes fail before productive work starts. Main-only delegation and recovery tools plus `ask_question` are excluded from children.
+The servers named in `mcps` come from the global `~/.pi/agent/mcp.json` only. In a Role that activates `codemode`, each selected server keeps its configured `exposure` and `toolExposure` (Pi's default `codemode` exposure makes tools callable from scripts without declaring them, `direct` declares them, `deferred` tools stay reachable from scripts, `hidden` tools stay unreachable), and an invalid exposure value fails the launch. In every other Role, selected servers are forced to `direct` exposure and `toolExposure` is ignored, because that child cannot reach undeclared tools. Declared tools appear to the model as `mcp__<server>__<tool>` once the server connects. Pi replaces `-` in server and tool names with `_` and appends a hash suffix when two tool names collide or a name exceeds 64 characters. Each selected entry is checked against Pi's documented `mcpServers` rules before launch, in Main and again in the child: a disabled, malformed, or unknown-transport entry, an invalid server name, two selected names that differ only in `-` and `_`, `auth.provider` over plain HTTP outside `localhost`, `127.0.0.1`, or `[::1]`, or a non-HTTPS `oauth.authServerMetadataUrl` outside those hosts fails the launch with the file path and field. The file is never modified; fix the entry or choose another server. Valid `auth`, `oauth`, and `description` fields are passed through so Pi's native provider auth and OAuth apply. `oauth.clientRegistration` must be `dcr` or `cimd`. A `cimd` entry cannot use `clientId` or `clientName`, and any `callbackUrl` must use localhost or 127.0.0.1 with path `/callback`. Project MCP overrides remain ignored: a project cannot change the Role's global server allowlist or exposure. Missing Skills, tools, MCP servers, Roles, or routes fail before productive work starts. Main-only delegation and recovery tools plus `ask_question` are excluded from children.
 
 ## API
 

package/dist/direct-herdr.d.ts

@@ -9,10 +9,23 @@ export interface DirectHandle {
     prompt: string;
     answer(maxBytes: number): Promise<string>;
     usageTokens(): Promise<number | undefined>;
+    /** Display-only activity from the last usageTokens() sample. */
+    readonly activity?: DirectToolActivity;
     cancel(): Promise<void>;
 }
 export declare function exactDirectTerminalTurn(jsonl: string, prompt: string): boolean;
 export declare function exactDirectAnswer(jsonl: string, prompt: string, maxBytes?: number, requireSuccess?: boolean): string;
+export interface DirectToolActivity {
+    pending: string[];
+    latest?: {
+        name: string;
+        durationMs?: number;
+    };
+}
+export declare function directSessionUsage(jsonl: string, prompt: string): {
+    tokens?: number;
+    activity?: DirectToolActivity;
+};
 export declare function directSessionTokens(jsonl: string, prompt: string): number | undefined;
 export type DirectTab = Pick<DirectHandle, "name" | "tabId" | "paneId" | "sessionFile"> & {
     leasePath: string;

package/dist/direct-herdr.js

@@ -101,10 +101,12 @@ export function exactDirectAnswer(jsonl, prompt, maxBytes = ANSWER_LIMIT, requir
     return completion.answer;
 }
 // Ignore a partial trailing JSONL entry while the child is writing it.
-export function directSessionTokens(jsonl, prompt) {
+export function directSessionUsage(jsonl, prompt) {
     let active = false;
     let total = 0;
     let observed = false;
+    const pending = new Map();
+    let latest;
     for (const line of jsonl.split("\n")) {
         if (!line.trim())
             continue;
@@ -115,7 +117,7 @@ export function directSessionTokens(jsonl, prompt) {
         catch {
             break;
         }
-        if (entry.type !== "message" || !entry.message || typeof entry.message !== "object")
+        if (!entry || entry.type !== "message" || !entry.message || typeof entry.message !== "object")
             continue;
         const message = entry.message;
         if (message.role === "user") {
@@ -124,18 +126,42 @@ export function directSessionTokens(jsonl, prompt) {
             if (active) {
                 total = 0;
                 observed = false;
+                pending.clear();
+                latest = undefined;
+            }
+        }
+        else if (active && message.role === "assistant") {
+            if (message.usage && typeof message.usage === "object") {
+                const usage = message.usage;
+                const values = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite];
+                if (values.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
+                    total += values.reduce((sum, value) => sum + value, 0);
+                    observed = true;
+                }
             }
+            if (Array.isArray(message.content))
+                for (const part of message.content) {
+                    if (part?.type === "toolCall" && typeof part.id === "string" && typeof part.name === "string") {
+                        pending.set(part.id, part.name);
+                    }
+                }
         }
-        else if (active && message.role === "assistant" && message.usage && typeof message.usage === "object") {
-            const usage = message.usage;
-            const values = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite];
-            if (values.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
-                total += values.reduce((sum, value) => sum + value, 0);
-                observed = true;
+        else if (active && message.role === "toolResult" && typeof message.toolCallId === "string") {
+            const name = pending.get(message.toolCallId);
+            if (name === undefined)
+                continue;
+            pending.delete(message.toolCallId);
+            latest = { name };
+            if (typeof message.durationMs === "number" && Number.isFinite(message.durationMs) && message.durationMs >= 0) {
+                latest.durationMs = message.durationMs;
             }
         }
     }
-    return observed ? total : undefined;
+    return { tokens: observed ? total : undefined,
+        activity: pending.size || latest ? { pending: [...pending.values()], latest } : undefined };
+}
+export function directSessionTokens(jsonl, prompt) {
+    return directSessionUsage(jsonl, prompt).tokens;
 }
 export class DirectAllocationError extends Error {
     allocation;
@@ -277,18 +303,21 @@ export function createDirectHerdr(pi, cwd, idleMs) {
                 if (state === "blocked" || state === "unknown")
                     throw new Error(`Herdr agent became ${state}; inspect it before retrying.`);
                 let lastUsageSize = -1;
-                let lastTokens;
+                let lastUsage = {};
                 return {
                     name, tabId, paneId, sessionFile, prompt,
+                    get activity() { return lastUsage.activity; },
                     async usageTokens() {
                         const info = await stat(sessionFile);
-                        if (info.size > SESSION_LIMIT)
+                        if (info.size > SESSION_LIMIT) {
+                            lastUsage = {};
                             return undefined;
+                        }
                         if (info.size !== lastUsageSize) {
-                            lastTokens = directSessionTokens(await readFile(sessionFile, "utf8"), prompt);
+                            lastUsage = directSessionUsage(await readFile(sessionFile, "utf8"), prompt);
                             lastUsageSize = info.size;
                         }
-                        return lastTokens;
+                        return lastUsage.tokens;
                     },
                     async answer(maxBytes) {
                         const readAnswer = async () => {

package/dist/mcp-role.d.ts

@@ -1,4 +1,4 @@
-import { type LoadedMcpConfig } from "@earendil-works/pi-coding-agent";
+import type { LoadedMcpConfig } from "@earendil-works/pi-coding-agent";
 export declare function parseRoleMcpAllowlist(value: unknown): string[];
 /**
  * Select the Role's allowlisted servers from the global `mcp.json` in Pi's native `mcpServers`
@@ -9,5 +9,4 @@ export declare function parseRoleMcpAllowlist(value: unknown): string[];
  */
 export declare function loadRoleMcpConfig(agentDir: string, allowlist: readonly string[], options?: {
     codemode: boolean;
-    piVersion?: string;
 }): LoadedMcpConfig;

package/dist/mcp-role.js

@@ -1,6 +1,5 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { VERSION } from "@earendil-works/pi-coding-agent";
 export function parseRoleMcpAllowlist(value) {
     if (typeof value !== "string")
         throw new Error("The Role MCP policy flag must contain a JSON array of MCP server names.");
@@ -72,7 +71,7 @@ const EXPOSURE_CHECKS = {
     toolExposure: [(value) => isRecord(value) && Object.values(value).every(isExposure), "an object mapping tool names to exposures"],
 };
 /** Validate one selected server against Pi's documented `mcpServers` rules; the native loader is bypassed by `loadConfig`. */
-function validateRoleMcpServer(path, name, value, codemode, piVersion) {
+function validateRoleMcpServer(path, name, value, codemode) {
     const fail = (message) => { throw new Error(`${path}: MCP server "${name}" ${message}`); };
     if (!SERVER_NAME.test(name))
         fail("has an invalid name (use letters, digits, \"_\" and \"-\").");
@@ -90,8 +89,6 @@ function validateRoleMcpServer(path, name, value, codemode, piVersion) {
             fail(`field "${field}" must be ${shape}.`);
     }
     if (http && isRecord(value.oauth) && value.oauth.clientRegistration === "cimd") {
-        if (piVersion === "1.0.0")
-            fail('field "oauth.clientRegistration" "cimd" requires Pi 1.0.1 or later; current Pi is 1.0.0.');
         if (value.oauth.clientId !== undefined || value.oauth.clientName !== undefined) {
             fail('field "oauth.clientRegistration" "cimd" cannot be combined with "oauth.clientId" or "oauth.clientName".');
         }
@@ -146,7 +143,7 @@ export function loadRoleMcpConfig(agentDir, allowlist, options = { codemode: fal
         if (clash)
             throw new Error(`${path}: Role MCP server "${name}" conflicts with "${clash}": names that differ only in "-" and "_" share one tool namespace.`);
         namespaces.set(mcpNamespace(name), name);
-        return { name, config: validateRoleMcpServer(path, name, configured[name], options.codemode, options.piVersion ?? VERSION), source: path, scope: "global" };
+        return { name, config: validateRoleMcpServer(path, name, configured[name], options.codemode), source: path, scope: "global" };
     });
     return { servers, autoEnableCodemode: false, errors: [] };
 }

package/extensions/subagent-command.ts

@@ -1,15 +1,34 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+/** Saved before launch for user matching only; never ownership or mutation authority. */
+export interface DirectDisplay {
+	/** Session-local workflow number. */
+	workflow: number;
+	/** One-based original workflow entry index. */
+	worker: number;
+	workers: number;
+	title: string;
+	role: string;
+}
+export const directRef = ({ workflow, worker }: DirectDisplay): string => `D${workflow}.${worker}`;
+
 /** Read-only branch records; the adapter groups all tabs of a direct workflow. */
 export interface DirectTask {
 	id: string;
+	/** Legacy label: saved allocation label, otherwise the exact task ID. */
 	name: string;
 	status: string;
 	canClose?: boolean;
 	recovery?: string;
-	tabs: readonly { entryId: string; name: string; tabId: string; paneId: string; sessionFile: string }[];
+	/** Recorded workers by original index; empty for legacy records. */
+	workers: readonly DirectDisplay[];
+	tabs: readonly { entryId: string; name: string; tabId: string; paneId: string; sessionFile: string; display?: DirectDisplay }[];
 }
 
+const workerLabel = (display: DirectDisplay) => `${directRef(display)} · ${display.role} · ${display.title}`;
+const directLabel = ({ name, workers: [first] }: DirectTask): string => !first ? name
+	: first.workers === 1 ? workerLabel(first) : `D${first.workflow} · ${first.workers} workers`;
+
 export interface IsolatedTask {
 	id: string;
 	name: string;
@@ -35,7 +54,7 @@ export interface SubagentCommandAdapter {
 	closeDirect(task: DirectTask, current: () => boolean): Promise<string>;
 	isolated(cwd: string, current: () => boolean): Promise<IsolatedInventory>;
 	recover(cwd: string): Promise<string>;
-	inspectInTab(root: string, requestId: string, ctx: ExtensionContext, current: () => boolean): Promise<{ tabId: string; name: string; sessionFile: string }>;
+	inspectInTab(root: string, requestId: string, ctx: ExtensionContext, current: () => boolean): Promise<{ ref: string; tabId: string; name: string; sessionFile: string }>;
 	canFollowup(root: string, requestId: string, taskId: string): boolean;
 	enqueue(root: string, requestId: string, taskId: string, text: string, current: () => boolean): string;
 	drain(root: string, requestId: string, taskId: string, current: () => boolean): readonly string[];
@@ -104,7 +123,8 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (inventory?.invalidIds.length) for (const id of inventory.invalidIds) ctx.ui.notify(`Unreadable isolated state ID: ${JSON.stringify(id)}. Preserve this file; inspect the state store before making changes.`, "warning");
 				type Selection = { kind: "direct"; task: DirectTask } | { kind: "isolated"; request: IsolatedRequest; root: string } | { kind: "refresh" } | { kind: "history" } | { kind: "close" };
 				const selections: Choice<Selection>[] = [
-					...direct.filter((task) => history || !completed(task.status)).map((task) => ({ label: `Direct · ${task.name} · ${task.status} · ${task.id}`, value: { kind: "direct" as const, task } })),
+					// One row per workflow; new records keep opaque IDs in details. Status is last so clipping preserves the reference.
+					...direct.filter((task) => history || !completed(task.status)).map((task) => ({ label: `Direct · ${directLabel(task)} · ${task.status}${task.workers.length || task.name === task.id ? "" : ` · ${task.id}`}`, value: { kind: "direct" as const, task } })),
 					...(inventory?.requests ?? []).filter((request) => history || !completed(request.status) || /retained/i.test(request.status)).map((request) => ({ label: `Isolated · ${request.name} · ${request.status} · ${request.id}`, value: { kind: "isolated" as const, request, root: inventory!.root } })),
 					{ label: "Refresh", value: { kind: "refresh" as const } },
 					{ label: history ? "Active work" : "Completed / history (including retained work)", value: { kind: "history" as const } },
@@ -121,20 +141,25 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (selected.kind === "refresh") continue;
 				if (selected.kind === "history") { history = !history; continue; }
 				if (selected.kind === "direct") {
-					ctx.ui.notify(`Direct workflow ${clean(selected.task.name)} (${JSON.stringify(selected.task.id)}) · ${clean(selected.task.status)}`, "info");
-					if (selected.task.recovery) ctx.ui.notify(clean(selected.task.recovery, 4000), "warning");
-					for (const tab of selected.task.tabs) {
-						ctx.ui.notify(`Task ${JSON.stringify(tab.entryId)} · agent ${JSON.stringify(tab.name)} · tab ${JSON.stringify(tab.tabId)} · pane ${JSON.stringify(tab.paneId)} · session ${JSON.stringify(tab.sessionFile)}`, "info");
+					const { task } = selected;
+					const label = clean(directLabel(task));
+					ctx.ui.notify(`Direct workflow ${label} · ${clean(task.status)} · ID ${JSON.stringify(task.id)}`, "info");
+					if (task.recovery) ctx.ui.notify(clean(task.recovery, 4000), "warning");
+					for (const tab of task.tabs) {
+						ctx.ui.notify(`${tab.display ? `${clean(workerLabel(tab.display))} · ` : ""}task ${JSON.stringify(tab.entryId)} · agent ${JSON.stringify(tab.name)} · tab ${JSON.stringify(tab.tabId)} · pane ${JSON.stringify(tab.paneId)} · session ${JSON.stringify(tab.sessionFile)}`, "info");
 					}
-					if (selected.task.canClose) {
-						const action = await choose(ctx, `Direct · ${clean(selected.task.name)} · ${selected.task.id}`, [
-							{ label: "Close/cancel-and-release owned workers (preserve files and commits)", value: "close" },
+					const untabbed = task.workers.filter((worker) => !task.tabs.some((tab) => tab.display?.worker === worker.worker));
+					for (const worker of untabbed) ctx.ui.notify(`${clean(workerLabel(worker))} · no verified tab recorded`, "info");
+					if (task.workers[0] && task.workers.length < task.workers[0].workers) ctx.ui.notify(`${task.workers[0].workers - task.workers.length} other worker(s) in D${task.workers[0].workflow} have no recorded tab.`, "info");
+					if (task.canClose) {
+						const action = await choose(ctx, `Direct · ${label}`, [
+							{ label: "Close/cancel-and-release ALL owned workers in this workflow (preserve files and commits)", value: "close" },
 							{ label: "Back / refresh", value: "back" },
 						]);
 						if (!valid()) return;
 						if (action === "close") {
 							try {
-								const report = await adapter.closeDirect(selected.task, current);
+								const report = await adapter.closeDirect(task, current);
 								if (valid()) ctx.ui.notify(report, "info");
 							} catch (error) { if (valid()) ctx.ui.notify(`Admission retained: ${errorText(error)}. Inspect the exact tab/session; retry Close/cancel-and-release after resolving termination.`, "error"); }
 						}
@@ -157,7 +182,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 					if (action === "inspect") {
 						try {
 							const tab = await adapter.inspectInTab(root, request.id, ctx, current);
-							if (valid()) ctx.ui.notify(`Status inspection started in Herdr tab ${tab.tabId} · agent ${tab.name} · session ${tab.sessionFile}.`, "info");
+							if (valid()) ctx.ui.notify(`Status inspection ${tab.ref} started in Herdr tab ${tab.tabId} · agent ${tab.name} · session ${tab.sessionFile}.`, "info");
 						}
 						catch (error) { if (valid()) ctx.ui.notify(`Inspection failed: ${errorText(error)}`, "error"); }
 						continue;

package/extensions/subagent.ts

@@ -6,11 +6,11 @@ import { capEphemeralSubagentOutput as capOutput, createEphemeralSubagentExecuto
 import { readSubagentConfig, resolveExecutionPolicy, type EffectiveExecutionPolicy } from "./config.ts";
 import { registerCheckoutAdmission, roleCanWrite, roleIsReadOnlyScout } from "./admission.ts";
 import { registerIsolatedExtension } from "./isolated.ts";
-import { registerSubagentCommand, type DirectTask } from "./subagent-command.ts";
+import { directRef, registerSubagentCommand, type DirectDisplay, type DirectTask } from "./subagent-command.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
 import { ENTRY_STATUS_PRESENTATION, formatWorkflowResult, type BackgroundWorkflowTransportDetails, type WorkflowTransportEntry } from "./result-transport.ts";
 import { DelegateTaskParameters, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
-import { createDirectHerdr, DirectAllocationError, type DirectAllocation, type DirectHandle, type DirectTab } from "../dist/direct-herdr.js";
+import { createDirectHerdr, DirectAllocationError, type DirectAllocation, type DirectHandle, type DirectTab, type DirectToolActivity } from "../dist/direct-herdr.js";
 import { materializeTransientLaunch } from "../dist/launch-runtime.js";
 const WIDGET_KEY = "subagent-status";
 const WIDGET_INTERVAL_MS = 1_000;
@@ -20,6 +20,7 @@ const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧",
 
 type WidgetStatus = "working" | "success" | "failure";
 type WidgetItem = {
+	ref: string;
 	role: string;
 	model: string;
 	thinkingLevel: string;
@@ -29,6 +30,7 @@ type WidgetItem = {
 	status: WidgetStatus;
 	finishedAt?: number;
 	tokens?: number;
+	activity?: DirectToolActivity;
 };
 
 function roleBadge(role: string): string {
@@ -56,6 +58,18 @@ function tokenLabel(tokens: number | undefined): string {
 	return tokens === undefined ? "— tok" : `${tokens < 1_000 ? tokens : `${(tokens / 1_000).toFixed(1).replace(/\.0$/, "")}k`} tok`;
 }
 
+function activityLabel(activity: DirectToolActivity | undefined): string | undefined {
+	if (!activity) return undefined;
+	const name = (value: string) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 40);
+	const parts: string[] = [];
+	if (activity.pending.length) parts.push(`pending ${activity.pending.map(name).join(", ")}`);
+	if (activity.latest?.durationMs !== undefined) {
+		const ms = activity.latest.durationMs;
+		parts.push(`last ${name(activity.latest.name)} ${ms < 1_000 ? `${Math.round(ms)}ms` : formatDuration(ms)} recorded`);
+	}
+	return parts.length ? parts.join(" · ") : undefined;
+}
+
 function renderWidgetRows(
 	items: WidgetItem[],
 	width: number,
@@ -68,12 +82,14 @@ function renderWidgetRows(
 		- (b.status === "failure" ? 0 : b.status === "working" ? 1 : 2));
 	const visible = ordered.slice(0, ordered.length > MAX_WIDGET_LINES ? MAX_WIDGET_LINES - 1 : MAX_WIDGET_LINES);
 	const lines = visible.map((item) => {
-		const prefix = `${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", `D ${item.role}`)} ${item.status === "working" ? "" : `${statusLabel(item.status)} · `}`;
+		const prefix = `${statusGlyph(item.status, spinnerIndex, theme)} ${theme.fg("accent", `${item.ref} ${item.role}`)} ${item.status === "working" ? "" : `${statusLabel(item.status)} · `}`;
 		const metrics = [
 			`${item.model}/${item.thinkingLevel}`,
 			tokenLabel(item.tokens),
 			formatDuration((item.finishedAt ?? now) - item.startedAt),
 		];
+		const activity = activityLabel(item.activity);
+		if (activity) metrics.push(activity); // Activity is the first metric removed on narrow rows.
 		while (metrics.length && width - visibleWidth(prefix) - visibleWidth(` · ${metrics.join(" · ")}`) < 8) {
 			if (metrics.length === 2) metrics.shift(); // Preserve measured tokens ahead of route details.
 			else metrics.pop();
@@ -111,8 +127,9 @@ function replaceRouteModel(ctx: ExtensionContext, reference: string, route: Reso
 const DIRECT_RESULT_TYPE = "subagent-direct-result";
 const DIRECT_TAB_TYPE = "subagent-direct-tab";
 const DIRECT_ALLOCATION_TYPE = "subagent-direct-allocation";
-type DirectAllocationRecord = DirectAllocation & { taskId: string; entryId: string; failure: string };
-type DirectTabRecord = DirectTab & { taskId: string; entryId: string };
+// Legacy records have no display metadata.
+type DirectAllocationRecord = DirectAllocation & { taskId: string; entryId: string; failure: string; display?: DirectDisplay };
+type DirectTabRecord = DirectTab & { taskId: string; entryId: string; display?: DirectDisplay };
 
 function boundedError(error: unknown): Error {
 	const message = capOutput(error instanceof Error ? error.message : String(error));
@@ -193,25 +210,46 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 	const directTasks = new Map<string, { controller: AbortController; settled: Promise<void>; handles: DirectHandle[]; tabs: DirectTabRecord[]; close?: (current: () => boolean) => Promise<void>; closeScope?: () => boolean; allocation?: DirectAllocationRecord; recovery?: string }>();
 	let latestCtx: ExtensionContext | undefined;
 	let sessionEpoch = 0;
+	// Shutdown still saves outgoing identities; only a session start defers records to its carry loop.
+	let directRecordEpoch = 0;
+	let directWorkflow = 0;
+	/** Saved display workflow numbers anywhere in this session, by owning task. */
+	const savedWorkflows = (ctx: ExtensionContext) => {
+		const saved = new Map<number, string>();
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type !== "custom" || (entry.customType !== DIRECT_TAB_TYPE && entry.customType !== DIRECT_ALLOCATION_TYPE)) continue;
+			const record = entry.data as DirectTabRecord | undefined;
+			if (record?.display) saved.set(record.display.workflow, record.taskId);
+		}
+		return saved;
+	};
+	// The in-memory counter also covers launches that have not saved a record yet.
+	const nextWorkflow = (ctx: ExtensionContext) => (directWorkflow = Math.max(directWorkflow, ...savedWorkflows(ctx).keys()) + 1);
 	registerSubagentCommand(pi, {
 		direct(ctx): DirectTask[] {
-			const grouped = new Map<string, DirectTask & { tabs: Array<DirectTask["tabs"][number]> }>();
+			const grouped = new Map<string, DirectTask & { workers: DirectDisplay[]; tabs: Array<DirectTask["tabs"][number]> }>();
 			for (const entry of ctx.sessionManager.getBranch()) {
-				if (entry.type === "custom" && entry.customType === DIRECT_ALLOCATION_TYPE && entry.data) {
-					const allocation = entry.data as DirectAllocationRecord;
-					grouped.set(allocation.taskId, { id: allocation.taskId, name: allocation.name,
-						status: "allocation unverified; admission retained", recovery: allocation.failure,
-						tabs: grouped.get(allocation.taskId)?.tabs ?? [] });
+				if (entry.type !== "custom" || !entry.data || (entry.customType !== DIRECT_TAB_TYPE && entry.customType !== DIRECT_ALLOCATION_TYPE)) continue;
+				const record = entry.data as DirectTabRecord | DirectAllocationRecord;
+				const local = directTasks.get(record.taskId);
+				let task = grouped.get(record.taskId);
+				if (!task) grouped.set(record.taskId, task = { id: record.taskId, name: record.taskId,
+					status: local?.recovery ? "admission retained" : local ? "observed locally" : "recorded only; not proof of running or completion",
+					...(local?.recovery ? { recovery: local.recovery } : {}), canClose: Boolean(local?.close), workers: [], tabs: [] });
+				const { display } = record;
+				if (display && !task.workers.some(({ worker }) => worker === display.worker)) task.workers.push(display);
+				if (entry.customType === DIRECT_ALLOCATION_TYPE) {
+					const { label, failure } = record as DirectAllocationRecord;
+					if (!display) task.name = label;
+					task.status = "allocation unverified; admission retained";
+					task.recovery = failure;
+					task.canClose = false;
+				} else if (!task.tabs.some(({ tabId }) => tabId === record.tabId)) {
+					const { entryId, name, tabId, paneId, sessionFile } = record as DirectTabRecord;
+					task.tabs.push({ entryId, name, tabId, paneId, sessionFile, ...(display ? { display } : {}) });
 				}
-				if (entry.type !== "custom" || entry.customType !== DIRECT_TAB_TYPE || !entry.data) continue;
-				const tab = entry.data as DirectTabRecord;
-				const local = directTasks.get(tab.taskId);
-				const existing = grouped.get(tab.taskId);
-				const record = { entryId: tab.entryId, name: tab.name, tabId: tab.tabId, paneId: tab.paneId, sessionFile: tab.sessionFile };
-				if (existing) {
-					if (!existing.tabs.some((item) => item.tabId === tab.tabId)) existing.tabs.push(record);
-				} else grouped.set(tab.taskId, { id: tab.taskId, name: tab.name, status: local?.recovery ? `admission retained: ${local.recovery}` : local ? "observed locally" : "recorded (not observed)", canClose: Boolean(local?.close), tabs: [record] });
 			}
+			for (const task of grouped.values()) task.workers.sort((a, b) => a.worker - b.worker);
 			return [...grouped.values()];
 		},
 		async closeDirect(task, current) {
@@ -230,7 +268,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			// Automatic settlement may already have proved termination and released it.
 			if (!current()) throw new Error("Direct task scope changed; reopen /subagent.");
 			if (directTasks.has(task.id)) await local.close(owned);
-			return "Owned workers stopped; checkout admission released. Dirty files, commits and session evidence preserved. Inspect changes before retrying work.";
+			return "All owned workers in this workflow stopped; checkout admission released. Dirty files, commits and session evidence preserved. Inspect changes before retrying work.";
 		},
 		isolated: isolatedSurface.inventory,
 		recover: (cwd) => isolatedSurface.recover(cwd),
@@ -245,6 +283,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			const herdr = createDirectHerdr(pi, ctx.cwd, currentPolicy().childIdleMs);
 			const controller = new AbortController();
 			const taskId = `inspect-${id}-${randomUUID()}`;
+			const display: DirectDisplay = { workflow: nextWorkflow(ctx), worker: 1, workers: 1, title: `Inspect ${id}`, role: role.name };
+			const recordEpoch = directRecordEpoch;
 			const handles: DirectHandle[] = [];
 			const tabs: DirectTabRecord[] = [];
 			let resolveSettled!: () => void;
@@ -257,10 +297,10 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				try {
 					handle = await herdr.start(
 						{ ...prepared, args: [...transient.launch.args] }, `i-${randomUUID().replaceAll("-", "").slice(0, 24)}`,
-						`Inspect ${id}`, `Analyze this saved, read-only status snapshot for request ${id}. Summarize blockers and safe next decisions; do not infer missing evidence or mutate resources. The subagent_status tool in Main remains authoritative for exact action identities.\n\n${snapshot}`,
+						`${directRef(display)} ${display.title}`, `Analyze this saved, read-only status snapshot for request ${id}. Summarize blockers and safe next decisions; do not infer missing evidence or mutate resources. The subagent_status tool in Main remains authoritative for exact action identities.\n\n${snapshot}`,
 						controller.signal, (tab) => {
-							const record = { taskId, entryId: id, ...tab };
-							pi.appendEntry(DIRECT_TAB_TYPE, record);
+							const record = { taskId, entryId: id, display, ...tab };
+							if (recordEpoch === directRecordEpoch) pi.appendEntry(DIRECT_TAB_TYPE, record);
 							tabs.push(record);
 						});
 				} catch (error) {
@@ -272,7 +312,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 					await handle.cancel();
 					throw new Error(`Session changed during inspection launch; inspect Herdr tab ${handle.tabId}.`);
 				}
-				return { tabId: handle.tabId, name: handle.name, sessionFile: handle.sessionFile };
+				return { ref: directRef(display), tabId: handle.tabId, name: handle.name, sessionFile: handle.sessionFile };
 			} finally {
 				directTasks.delete(taskId);
 				resolveSettled();
@@ -307,8 +347,9 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				samplingTokens.add(id);
 				void handle.usageTokens().then((tokens) => {
 					const item = widgetItems.get(id);
-					if (tokens !== undefined && item?.status === "working" && tokenHandles.get(id) === handle) {
+					if (item?.status === "working" && tokenHandles.get(id) === handle) {
 						item.tokens = tokens;
+						item.activity = handle.activity;
 						requestWidgetRender();
 					}
 				}).catch(() => { /* Usage is optional; never interrupt work for telemetry. */ })
@@ -333,10 +374,9 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 	const startWidgetItem = (
 		id: string,
 		taskId: string,
-		role: string,
+		display: DirectDisplay,
 		model: string,
 		thinkingLevel: string | undefined,
-		name: string,
 		ctx: ExtensionContext,
 	) => {
 		if (!ctx.hasUI) return;
@@ -349,11 +389,12 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			}
 		}
 		widgetItems.set(id, {
-			role: roleBadge(role),
+			ref: directRef(display),
+			role: roleBadge(display.role),
 			model,
 			thinkingLevel: thinkingLevel ?? "default",
 			taskId,
-			name,
+			name: display.title,
 			startedAt: Date.now(),
 			status: "working",
 		});
@@ -373,6 +414,9 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		sessionEpoch += 1;
+		directRecordEpoch += 1;
+		// Numbers are session-local; saved records rebuild the next number.
+		directWorkflow = 0;
 		if (latestCtx) {
 			const previous = [...directTasks.values()];
 			for (const { controller, handles } of previous) {
@@ -382,17 +426,30 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			await Promise.allSettled(previous.map(({ settled }) => settled));
 			// A switch discards the old session's ordinary follow-up. Carry exact
 			// recovery identities into the new branch as well as the original one.
-			const recorded = new Set(ctx.sessionManager.getBranch().flatMap((entry) =>
+			const branch = ctx.sessionManager.getBranch();
+			const recorded = new Set(branch.flatMap((entry) =>
 				entry.type === "custom" && entry.customType === DIRECT_TAB_TYPE && entry.data
 					? [(entry.data as DirectTabRecord).tabId] : []));
-			for (const { allocation } of previous) if (allocation && !ctx.sessionManager.getBranch().some((entry) =>
-				entry.type === "custom" && entry.customType === DIRECT_ALLOCATION_TYPE && (entry.data as DirectAllocationRecord)?.taskId === allocation.taskId)) {
-				pi.appendEntry(DIRECT_ALLOCATION_TYPE, allocation);
-			}
-			for (const { tabs } of previous) for (const tab of tabs) {
-				if (!recorded.has(tab.tabId)) {
-					pi.appendEntry(DIRECT_TAB_TYPE, tab);
-					recorded.add(tab.tabId);
+			for (const local of previous) {
+				const carryAllocation = local.allocation && !branch.some((entry) => entry.type === "custom"
+					&& entry.customType === DIRECT_ALLOCATION_TYPE && (entry.data as DirectAllocationRecord)?.taskId === local.allocation!.taskId);
+				const records = [...local.tabs, ...(local.allocation ? [local.allocation] : [])];
+				const display = records.find((record) => record.display)?.display;
+				const owner = display && savedWorkflows(ctx).get(display.workflow);
+				if (owner !== undefined && owner !== records[0]!.taskId) {
+					// Another workflow owns this number here; renumber display only, never exact identity.
+					const workflow = nextWorkflow(ctx);
+					const renumber = <T extends DirectTabRecord | DirectAllocationRecord>(record: T): T =>
+						record.display ? { ...record, display: { ...record.display, workflow } } : record;
+					local.tabs.splice(0, local.tabs.length, ...local.tabs.map(renumber));
+					if (local.allocation) local.allocation = renumber(local.allocation);
+				}
+				if (carryAllocation) pi.appendEntry(DIRECT_ALLOCATION_TYPE, local.allocation);
+				for (const tab of local.tabs) {
+					if (!recorded.has(tab.tabId)) {
+						pi.appendEntry(DIRECT_TAB_TYPE, tab);
+						recorded.add(tab.tabId);
+					}
 				}
 			}
 		}
@@ -445,6 +502,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 	const reportDirect = (
 		launchEpoch: number,
 		taskId: string,
+		ref: string,
 		mode: ParsedWorkflow["mode"],
 		entries: readonly WorkflowTransportEntry[],
 		tabs: readonly DirectTabRecord[],
@@ -454,8 +512,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		if (stale) return;
 		const transport = formatWorkflowResult(mode, entries);
 		const outcome: BackgroundWorkflowTransportDetails["outcome"] = transport.failed ? "failed" : "completed";
-		const content = [transport.text, ...(recovery ? [`Checkout admission retained: ${recovery}. Open /subagent, select ${taskId}, and follow its recovery guidance (Close/cancel-and-release only when offered); never blindly retry work.`] : []), ...(tabs.length ? ["Recovery (also available via /subagent):", ...tabs.map(({ taskId, entryId, name, tabId, paneId, sessionFile }) =>
-			`- ${taskId} · ${entryId} · tab ${tabId} · pane ${paneId} · agent ${name} · session ${sessionFile}`)] : [])].join("\n");
+		const content = [transport.text, ...(recovery ? [`Checkout admission retained: ${recovery}. Open /subagent, select ${ref} (${taskId}), and follow its recovery guidance (Close/cancel-and-release of all its owned workers only when offered); never blindly retry work.`] : []), ...(tabs.length ? ["Recovery (also available via /subagent):", ...tabs.map(({ taskId, entryId, name, tabId, paneId, sessionFile, display }) =>
+			`- ${display ? `${directRef(display)} · ` : ""}${taskId} · ${entryId} · tab ${tabId} · pane ${paneId} · agent ${name} · session ${sessionFile}`)] : [])].join("\n");
 		const details: BackgroundWorkflowTransportDetails & { tabs: readonly DirectTabRecord[] } = {
 			...transport.details,
 			taskId,
@@ -523,8 +581,14 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				id: entry.id, index: entry.index, name: entry.delegation.name, role: entry.delegation.role, status: "pending",
 			}]));
 			const taskId = `direct-${++directSequence}-${Date.now().toString(36)}`;
+			const workflowNumber = nextWorkflow(ctx);
+			const ref = `D${workflowNumber}`;
+			const displayOf = ({ index, delegation }: WorkflowEntry): DirectDisplay => ({
+				workflow: workflowNumber, worker: index + 1, workers: entries.length, title: delegation.name, role: delegation.role,
+			});
 			const controller = new AbortController();
 			const launchEpoch = sessionEpoch;
+			const recordEpoch = directRecordEpoch;
 			const handles: DirectHandle[] = [];
 			const tabs: DirectTabRecord[] = [];
 			const tabByEntry = new Map<string, DirectTabRecord>();
@@ -566,23 +630,24 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 					...resources.prompts.flatMap((path) => ["--prompt-template", path]),
 					...resources.themes.flatMap((path) => ["--theme", path]));
 				states.set(entry.id, { ...states.get(entry.id)!, model: modelReference(prepared.model), thinkingLevel: prepared.thinkingLevel, status: "running", assistantOutput: "" });
-				startWidgetItem(entry.id, taskId, role.name, prepared.model.id, prepared.thinkingLevel, entry.delegation.name, ctx);
+				const display = displayOf(entry);
+				startWidgetItem(entry.id, taskId, display, prepared.model.id, prepared.thinkingLevel, ctx);
 				const transient = await materializeTransientLaunch({ launch: prepared, prompt: prepared.systemPrompt,
 					promptArgIndex: prepared.promptArgIndex }, activeSignal);
 				let handle: DirectHandle;
 				try {
 					handle = await herdr.start({ ...prepared, args: [...transient.launch.args] },
-						`d-${randomUUID().replaceAll("-", "").slice(0, 24)}`, entry.delegation.name, entry.delegation.task, activeSignal, (tab) => {
-							const record = { taskId, entryId: entry.id, ...tab };
-							// Persist before agent start, including launches interrupted by a session switch.
-							pi.appendEntry(DIRECT_TAB_TYPE, record);
+						`d-${randomUUID().replaceAll("-", "").slice(0, 24)}`, `${directRef(display)} ${display.title}`, entry.delegation.task, activeSignal, (tab) => {
+							const record = { taskId, entryId: entry.id, display, ...tab };
+							// Persist before agent start, or let the new session carry the exact identity after settlement.
+							if (recordEpoch === directRecordEpoch) pi.appendEntry(DIRECT_TAB_TYPE, record);
 							tabs.push(record);
 							tabByEntry.set(entry.id, record);
 						}, writes);
 				} catch (error) {
 					if (error instanceof DirectAllocationError) {
-						local.allocation = { taskId, entryId: entry.id, ...error.allocation, failure: error.message };
-						pi.appendEntry(DIRECT_ALLOCATION_TYPE, local.allocation);
+						local.allocation = { taskId, entryId: entry.id, display, ...error.allocation, failure: error.message };
+						if (recordEpoch === directRecordEpoch) pi.appendEntry(DIRECT_ALLOCATION_TYPE, local.allocation);
 					}
 					// A failed start can still be in flight. Keep its private prompt for recovery.
 					throw new Error(`${error instanceof Error ? error.message : String(error)}. Direct Role prompt retained at ${transient.launch.args[prepared.promptArgIndex + 1]} after uncertain start.`, { cause: error });
@@ -633,7 +698,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 							const answer = await handle.answer(Math.floor(40 * 1024 / entries.length));
 							try {
 								const tokens = await handle.usageTokens();
-								if (tokens !== undefined && widgetItems.has(entry.id)) widgetItems.get(entry.id)!.tokens = tokens;
+								const item = widgetItems.get(entry.id);
+								if (item) { item.tokens = tokens; item.activity = handle.activity; }
 							} catch { /* Optional telemetry. */ }
 							states.set(entry.id, { ...states.get(entry.id)!, status: "succeeded", assistantOutput: answer });
 							finishWidgetItem(entry.id, "success");
@@ -662,12 +728,12 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 						try { await local.close!(() => directTasks.get(taskId) === local); }
 						catch { /* Retain ownership and admission for an explicit guarded retry. */ }
 					} else directTasks.delete(taskId);
-					if (!controller.signal.aborted) reportDirect(launchEpoch, taskId, workflow.mode, [...states.values()], tabs, local.recovery);
+					if (!controller.signal.aborted) reportDirect(launchEpoch, taskId, ref, workflow.mode, [...states.values()], tabs, local.recovery);
 					resolveSettled();
 				}
 			})();
 			return {
-				content: [{ type: "text" as const, text: capOutput(`Direct delegation started · ${taskId}\nHerdr tab: ${first.tabId} · pane: ${first.paneId} · agent: ${first.name}\nExact session: ${first.sessionFile}\nAll launched tabs: /subagent (on this session branch).\n${entries.length} task(s); result will arrive in one follow-up message. Direct work shares this checkout; completion is an exact answer, not checked integration. ${writes ? "Potential writers run serially; competing Pi writes stay blocked until owned workers are proved stopped. If termination is uncertain, use /subagent Close/cancel-and-release; changes are not rolled back." : "Concurrent changes may make reads stale."}`) }],
+				content: [{ type: "text" as const, text: capOutput(`Direct delegation started · ${ref} · ${taskId}\nHerdr tab: ${first.tabId} · pane: ${first.paneId} · agent: ${first.name}\nExact session: ${first.sessionFile}\nAll launched tabs: /subagent (on this session branch).\n${entries.length} task(s); result will arrive in one follow-up message. Direct work shares this checkout; completion is an exact answer, not checked integration. ${writes ? "Potential writers run serially; competing Pi writes stay blocked until owned workers are proved stopped. If termination is uncertain, use /subagent ${ref} Close/cancel-and-release (stops ALL its owned workers); changes are not rolled back." : "Concurrent changes may make reads stale."}`) }],
 				details: { taskId, mode: workflow.mode, tabId: first.tabId, sessionFile: first.sessionFile,
 					entries: entries.map(({ id, index, delegation }) => ({ id, index, name: delegation.name, role: delegation.role })) },
 			};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "26.3.0",
+  "version": "26.4.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",