@henryqw/pi-subagent 27.8.0 → 27.10.0

package/README.md

@@ -136,6 +136,8 @@ Use isolated mode for checked implementation. An isolated request has one durabl
 
 Workers use Main's pinned committed branch, HEAD, and tree, not staged, unstaged, or untracked edits. Branch or HEAD changes block new waves. Candidates must be committed with no tracked or untracked changes. Ignored generated files permit candidacy but prevent automatic cleanup.
 
+New isolated worktree names use the request and task IDs, plus an identity suffix. Integration names use the request ID and `integration-<generation>`. Herdr workspace and tab labels show the worker worktree name. Names do not use goals or requirements. Saved worktrees and labels keep their exact names for recovery and cleanup.
+
 Keep the durable ID; Main can work or end its turn without polling. Inspect ready candidates with `subagent_status`.
 
 - `subagent_stage` stages exact candidates while siblings run; resolve conflicts in the integration checkout.
@@ -155,9 +157,17 @@ The extension sends follow-ups when a candidate becomes ready, a worker needs at
 
 Open `/subagent` to browse direct work on this session branch and isolated requests in the current canonical Git checkout, including other sessions. The menu groups rows under **Direct**, **Isolated**, and **Orphaned** headers. Each isolated row shows the request ID, the status, and a short goal summary. **Refresh** or a header reloads saved status without recovery or mutation. Invalid state IDs stay preserved with a warning. Direct recovery remains available outside Git or without isolated inventory.
 
+Before the menu opens, and after each **Refresh**, a **Current subagent work** report shows which subagents are working. The extension calculates it from local and saved evidence without a model call. Without interactive UI, `/subagent` sends this report before the request list.
+
+A direct workflow is working only when this Pi process owns it and has a running worker. Direct work with a delivered result shows its outcome under **Completed / history** and is not in the report. Other recorded-only direct work shows as unverified. An isolated request is working only when its status is active and a live run holds the repository lease. Without a live lease, an active request shows as interrupted; run `/subagent recover`.
+
 Each row starts with a status symbol: `●` active, `✓` completed, `⚠` needs attention, `✗` failed. In the terminal UI, `/subagent` reports (Roles, details, reviews, and results) show as colored transcript entries. The model does not get these entries. In RPC mode, they show as notifications. Without interactive UI, they show as plain text messages.
 
-Requests whose parent checkout was removed show in the **Orphaned · parent checkout removed** group from any checkout of the same repository. Every isolated request, including an orphaned request, has **Close and delete worktrees (discard work)**. Select it to review owned resources and confirm deletion. **This permanently deletes committed, uncommitted, and ignored content in the listed checkouts.** Cancel makes no change.
+Requests whose parent checkout was removed show in the **Orphaned · parent checkout removed** group from any checkout of the same repository. Saved `running` or `pending` states show as `saved running · unverified` or `saved pending · unverified`, not as live work. The report lists them under **Unverified**. This does not prove completion.
+
+Both isolated groups hide terminal requests by default: `completed`, `aborted`, `final_failed`, and `superseded`. Select **Completed / history** to see them. Requests with retained resources or unresolved recovery stay visible. This filter does not delete saved records. Without interactive UI, the request list includes history.
+
+Every isolated request, including an orphaned request, has **Close and delete worktrees (discard work)**. Select it to review owned resources and confirm deletion. **This permanently deletes committed, uncommitted, and ignored content in the listed checkouts.** Cancel makes no change.
 
 Select **Select multiple…** to apply one action to many rows. Select a row to mark it `[x]` or clear it, or use **Select all** or **Clear**, then select **Continue**. The next menu shows only the actions that apply. **Close and delete worktrees (discard work)** applies to isolated requests. **Close/cancel-and-release ALL owned workers** applies to direct workflows that can close. Each request shows its review, then one confirmation covers all of them.
 

package/dist/git-runtime.d.ts

@@ -46,6 +46,7 @@ export declare class CheckedGitRuntime implements GitRuntime, TaskCandidateInspe
         root: string;
     }, context: OperationContext): Promise<WorkspaceIdentity>;
     allocateWorktree(input: {
+        requestId: string;
         root: string;
         baseRoot?: string;
         intent: WorktreeAllocationIntent;

package/dist/git-runtime.js

@@ -111,7 +111,7 @@ export class CheckedGitRuntime {
                 if (!sameIdentity(current, input.attempt.waveBase)) {
                     throw new Error("Recorded wave snapshot drifted after worktree preparation and before git worktree add.");
                 }
-            });
+            }, [input.requestId, input.task.id]);
             if (!created)
                 return { kind: "worktree", outcome: "absent", failure: "Git worktree allocation requires a committed repository." };
             const worktree = cloneWorktree(created);

package/dist/herdr-runtime.d.ts

@@ -24,7 +24,7 @@ export interface HerdrHostRuntimeOptions {
     lsofCommand?: string;
     executionBudget?: () => Omit<EphemeralSubagentExecutionBudget, "startedAt">;
 }
-export declare function workspaceLabel(attempt: Pick<TaskAttempt, "correlationToken">): string;
+export declare function workspaceLabel(attempt: TaskAttempt): string;
 export declare class HerdrHostRuntime implements HostRuntime {
     private readonly inspectInFlightCandidate;
     private readonly execute;

package/dist/herdr-runtime.js

@@ -11,6 +11,7 @@ import { runProcess as defaultRunProcess } from "./process.js";
 import { EXECUTION_BUDGET_ENV } from "./ephemeral.js";
 import { assertPrivateLease, scanProcessLease } from "./process-lease.js";
 import { exactDirectTerminalTurn } from "./direct-herdr.js";
+import { READABLE_BRANCH_PATTERN } from "./worktree.js";
 const MIN_HERDR_VERSION = [0, 9, 3];
 const MIN_HERDR_PROTOCOL = 22;
 const HERDR_OPERATION_CAP_MS = 30_000;
@@ -153,10 +154,14 @@ function worktreeIntent(attempt) {
     return intent.worktree;
 }
 export function workspaceLabel(attempt) {
-    return attempt.correlationToken.slice(-6);
+    const { branch } = worktreeIntent(attempt);
+    return READABLE_BRANCH_PATTERN.test(branch) ? basename(branch) : attempt.correlationToken.slice(-6);
 }
-function expectedWorkerLabel(task) {
-    return `${task.role}/${task.modelClass}`;
+function expectedWorkerLabel(task, attempt) {
+    const { branch } = worktreeIntent(attempt);
+    return READABLE_BRANCH_PATTERN.test(branch)
+        ? `${workspaceLabel(attempt)}/${task.modelClass}`
+        : `${task.role}/${task.modelClass}`;
 }
 function expectedAgentName(token) {
     if (!CORRELATION_TOKEN_PATTERN.test(token))
@@ -187,7 +192,7 @@ function assertWorkspaceIntent(intent, attempt) {
 function assertWorkerTabIntent(intent, task, attempt) {
     const worktree = worktreeIntent(attempt);
     const workspace = ownedIntent(attempt, "workspace");
-    if (exactString(intent.label, "worker-tab label") !== expectedWorkerLabel(task)
+    if (exactString(intent.label, "worker-tab label") !== expectedWorkerLabel(task, attempt)
         || exactString(intent.workspaceId, "worker-tab workspace ID") !== workspace.workspaceId
         || exactString(intent.workspaceRootTabId, "workspace root tab ID") !== workspace.rootTabId
         || exactString(intent.workspaceRootPaneId, "workspace root pane ID") !== workspace.rootPaneId
@@ -340,7 +345,7 @@ export class HerdrHostRuntime {
             this.assertLeasePath(leasePath, input.attempt.correlationToken);
             return {
                 kind: "worker_tab",
-                label: expectedWorkerLabel(input.task),
+                label: expectedWorkerLabel(input.task, input.attempt),
                 workspaceId,
                 workspaceRootTabId: exactString(workspace.rootTabId, "owned workspace root tab ID"),
                 workspaceRootPaneId: exactString(workspace.rootPaneId, "owned workspace root pane ID"),

package/dist/integration-git.d.ts

@@ -17,7 +17,7 @@ export declare class IntegrationGit {
     /** Refresh is allowed only for the exact clean checked-out Main and a strict same-branch descendant. */
     inspectMainAdvance(root: string, from: WorkspaceIdentity, to: WorkspaceIdentity, signal: AbortSignal): Promise<void>;
     /** Persist the prepared path/branch/base before Git is allowed to create anything. */
-    allocate(root: string, childId: string, base: WorkspaceIdentity, onPrepared: (info: WorktreeInfo) => Promise<void>, signal: AbortSignal): Promise<GitOutcome<WorktreeInfo>>;
+    allocate(root: string, childId: string, base: WorkspaceIdentity, onPrepared: (info: WorktreeInfo) => Promise<void>, signal: AbortSignal, nameParts?: readonly string[]): Promise<GitOutcome<WorktreeInfo>>;
     /** Prove each recorded merge before any new merge or final gate. */
     inspectCombined(root: string, integration: WorktreeInfo, base: WorkspaceIdentity, stages: readonly StageReceipt[], signal: AbortSignal): Promise<WorkspaceIdentity>;
     /** Main's correction is one exact committed child of the checked staged tip. */

package/dist/integration-git.js

@@ -158,7 +158,7 @@ export class IntegrationGit {
         }
     }
     /** Persist the prepared path/branch/base before Git is allowed to create anything. */
-    async allocate(root, childId, base, onPrepared, signal) {
+    async allocate(root, childId, base, onPrepared, signal, nameParts) {
         if (!sameIdentity(await inspect(root, signal), base))
             return { outcome: "drift", failure: "Main drifted before integration allocation." };
         let prepared;
@@ -170,7 +170,7 @@ export class IntegrationGit {
                 await onPrepared(info);
                 if (!sameIdentity(await inspect(root, signal), base))
                     throw new Error("Main drifted before worktree add.");
-            });
+            }, nameParts);
             if (!added)
                 return { outcome: "blocked", failure: "Integration requires committed Git Main." };
             if (!sameIdentity(await inspect(root, signal), base))

package/dist/prune.d.ts

@@ -33,7 +33,7 @@ export interface PruneItem {
     ignored: readonly string[];
 }
 export interface PruneOwnership {
-    /** Every request or state that may still own a resource name (`subagent-<hex>`); unreadable state has no request. */
+    /** Every request or state that may still own an exact resource name; unreadable state has no request. */
     owners(name: string): readonly {
         label: string;
         request?: PruneRequest;

package/dist/runner.d.ts

@@ -226,6 +226,7 @@ export interface GitRuntime {
         root: string;
     }, context: OperationContext): Promise<WorkspaceIdentity>;
     allocateWorktree(input: {
+        requestId: string;
         root: string;
         baseRoot?: string;
         intent: WorktreeAllocationIntent;
@@ -332,6 +333,8 @@ export declare class IsolatedRunner {
         invalidIds: string[];
         states: RunState[];
     }>;
+    /** True while a live productive run holds this root's lease; the lease does not name its request. */
+    hasProductiveRunLease(root: string): Promise<boolean>;
     /** Classify orphaned work under the same repository lease as productive execution.
      * Status remains read-only; Main alone chooses any subsequent action. */
     recoverRepository(root: string): Promise<{

package/dist/runner.js

@@ -5,7 +5,7 @@ import { utf8Prefix } from "./ephemeral.js";
 import { createChildWorktree, finalizeChildWorktree, inspectWorktreeDirty } from "./worktree.js";
 import { runGit } from "./git-process.js";
 import { IntegrationGit } from "./integration-git.js";
-import { checkBatchPasses, CLEANUP_KINDS, isCleanCommitted, MAX_PERSISTED_RUNTIME_TEXT_BYTES, MAX_POSSIBLE_RESOURCES, parseExecuteRequest, parseIntegrationAction, integrationGenerationPasses, parseResumeRequest, parseStageRequest, reusableCheckSource, reviewEvidencePasses, sameIdentity, formatCheckCommand, stagedCheckSources, RUN_STATE_VERSION, } from "./schema.js";
+import { checkBatchPasses, CLEANUP_KINDS, isCleanCommitted, MAX_PERSISTED_RUNTIME_TEXT_BYTES, MAX_POSSIBLE_RESOURCES, parseExecuteRequest, parseIntegrationAction, integrationGenerationPasses, parseResumeRequest, parseStageRequest, reusableCheckSource, reviewEvidencePasses, sameIdentity, formatCheckCommand, stagedCheckSources, RUN_STATE_VERSION, TERMINAL_RUN_STATUSES, } from "./schema.js";
 import { FileRunStore, ProductiveRunLeaseBusyError } from "./store.js";
 const TRUNCATION_MARKER = "\n[truncated]";
 const TEXT_TASK_PROMPT_MAX_BYTES = 64 * 1024;
@@ -427,15 +427,17 @@ function correctionEligible(request, attempt) {
                 && sameIdentity(attempt.preliminaryReview.identityAfter, attempt.candidate)));
 }
 function terminal(state) {
-    return state.status === "completed" || state.status === "final_failed" || state.status === "superseded" || state.status === "aborted";
+    return TERMINAL_RUN_STATUSES.some((status) => status === state.status);
 }
-function inventoryStatus(state) {
+function inventoryStatus(state, orphaned = false) {
+    if (orphaned && ["pending", "running"].includes(state.status))
+        return `saved ${state.status} · unverified`;
     const retained = state.tasks.some((task) => task.kind === "changeset"
         ? task.attempts.some((attempt) => attempt.cleanup.some((step) => step.status !== "completed"))
         : task.attempts.some((attempt) => attempt.cleanup && attempt.cleanup.outcome !== "pruned"))
         || state.integration.generations.some((generation) => generation.cleanup?.some((step) => step.status !== "completed")
             || (generation.worktree && generation.cleanup?.every((step) => step.status === "completed") !== true));
-    return ["completed", "aborted"].includes(state.status) && retained ? `${state.status} · retained` : state.status;
+    return terminal(state) && retained ? `${state.status} · retained` : state.status;
 }
 /** Build one bounded changeset assignment. Call this before acquiring its Role launch. */
 export function buildChangesetTaskPrompt(input) {
@@ -639,6 +641,10 @@ export class IsolatedRunner {
                 })),
             })) };
     }
+    /** True while a live productive run holds this root's lease; the lease does not name its request. */
+    async hasProductiveRunLease(root) {
+        return await this.store.hasProductiveRunLease(root);
+    }
     /** Classify orphaned work under the same repository lease as productive execution.
      * Status remains read-only; Main alone chooses any subsequent action. */
     async recoverRepository(root) {
@@ -666,7 +672,7 @@ export class IsolatedRunner {
         }
         const requests = [];
         for (const request of inventory.requests) {
-            if (["pending", "running", "needs_attention", "completed · retained", "aborted · retained"].includes(request.status)) {
+            if (["pending", "running", "needs_attention"].includes(request.status) || request.status.endsWith(" · retained")) {
                 requests.push(await this.status(request.id, root));
             }
         }
@@ -679,7 +685,7 @@ export class IsolatedRunner {
         const owners = [];
         let lease;
         const request = ({ state, path }, orphaned) => ({ id: state.request.id, name: state.request.goal,
-            status: inventoryStatus(state), directory: dirname(path), root: state.root, orphaned });
+            status: inventoryStatus(state, orphaned), directory: dirname(path), root: state.root, orphaned });
         const orphans = checkouts[0] ? (await this.store.listOrphans(realpathSync.native(checkouts[0]))).states : [];
         for (const handle of orphans) {
             const { state } = handle;
@@ -1175,7 +1181,7 @@ export class IsolatedRunner {
                     };
                     generations.push(generation);
                     await this.saveProductive(handle); // Before worktree add.
-                }, context.signal));
+                }, context.signal, [action.id, `integration-${action.generation}`]));
                 if (result.outcome !== "ready") {
                     if (!generations.at(-1))
                         throw new Error("Integration allocation did not persist an owned worktree plan.");
@@ -1376,7 +1382,7 @@ export class IsolatedRunner {
                         state.integration.refresh = { from: action.expectedMain, to: action.newMain, generation: action.generation,
                             status: "unknown", failure: "Integration allocation has not been proved; retain the recorded checkout." };
                         await this.saveProductive(handle);
-                    }, context.signal));
+                    }, context.signal, [action.id, `integration-${action.generation}`]));
                 }
                 catch (error) {
                     // A prepared checkout remains recorded; no repeated allocation from this intent.
@@ -1782,7 +1788,7 @@ export class IsolatedRunner {
         const primary = await primaryCheckout(cwd);
         const { states, invalidIds } = await this.store.listOrphans(primary);
         return { invalidIds, requests: states.map((handle) => ({
-                id: handle.state.request.id, name: handle.state.request.goal, status: inventoryStatus(handle.state),
+                id: handle.state.request.id, name: handle.state.request.goal, status: inventoryStatus(handle.state, true),
                 directory: dirname(handle.path), root: handle.state.root, orphaned: true, tasks: [],
             })) };
     }
@@ -2297,6 +2303,7 @@ export class IsolatedRunner {
                 try {
                     if (intent.kind === "worktree") {
                         result = await this.callProductive(handle, scope, async (context) => await this.gitRuntime.allocateWorktree({
+                            requestId: state.request.id,
                             root: state.root,
                             ...(attempt.waveBase.head !== state.main.head ? { baseRoot: state.integration.generations.at(-1)?.worktree?.path } : {}),
                             intent,
@@ -2422,7 +2429,7 @@ export class IsolatedRunner {
                 if (worktree.baseCommit !== wave.base.head || !sameIdentity(await inspectBase({ root: baseRoot }, context), wave.base)) {
                     throw new Error("Staged dependency snapshot drifted before text worktree creation.");
                 }
-            });
+            }, [state.request.id, task.taskId, `text-${attempt.number}`]);
             if (!isolated)
                 throw new Error("Explicit isolated text work requires a Git checkout with a committed HEAD; it never falls back to Main.");
             let result;

package/dist/schema.d.ts

@@ -1791,6 +1791,8 @@ export type IntegrationCandidate = Static<typeof IntegrationCandidateSchema>;
 export type IntegrationStage = Static<typeof IntegrationStageSchema>;
 export type IntegrationGeneration = Static<typeof IntegrationGenerationSchema>;
 export type IntegrationState = Static<typeof IntegrationStateSchema>;
+declare const TerminalRunStatusSchema: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
+export declare const TERMINAL_RUN_STATUSES: readonly Static<typeof TerminalRunStatusSchema>[];
 declare const RunStateSchema: Type.TObject<{
     version: Type.TLiteral<5>;
     request: Type.TObject<{

package/dist/schema.js

@@ -412,6 +412,10 @@ export const IntegrationStateSchema = Type.Object({
         failure: OptionalRuntimeTextSchema,
     }, { additionalProperties: false })),
 }, { additionalProperties: false });
+const TerminalRunStatusSchema = Type.Union([
+    Type.Literal("completed"), Type.Literal("final_failed"), Type.Literal("superseded"), Type.Literal("aborted"),
+]);
+export const TERMINAL_RUN_STATUSES = TerminalRunStatusSchema.anyOf.map((status) => status.const);
 const RunStateSchema = Type.Object({
     version: Type.Literal(RUN_STATE_VERSION),
     request: ExecuteRequestSchema,
@@ -421,8 +425,8 @@ const RunStateSchema = Type.Object({
     requestStartMain: WorkspaceSchema,
     main: WorkspaceSchema,
     status: Type.Union([
-        Type.Literal("pending"), Type.Literal("running"), Type.Literal("needs_attention"), Type.Literal("completed"),
-        Type.Literal("final_failed"), Type.Literal("superseded"), Type.Literal("aborted"),
+        Type.Literal("pending"), Type.Literal("running"), Type.Literal("needs_attention"),
+        ...TerminalRunStatusSchema.anyOf,
     ]),
     tasks: Type.Array(TaskStateSchema, { minItems: 1, maxItems: MAX_TASKS }),
     waves: Type.Array(WaveStateSchema, { maxItems: MAX_TASKS }),

package/dist/worktree.d.ts

@@ -25,7 +25,8 @@ export type WorktreePayload = {
     dirty?: boolean;
 };
 export declare const WORKTREES_DIRNAME = ".worktrees";
-/** Branches `createChildWorktree` creates for workers and integration checkouts, at `<primary>/.worktrees/<branch basename>`. */
+export declare const READABLE_BRANCH_PATTERN: RegExp;
+/** Keep saved opaque names eligible for exact recovery and cleanup. */
 export declare const OWNED_BRANCH_PATTERN: RegExp;
 export declare class WorktreeSetupError extends Error {
     name: string;
@@ -39,7 +40,7 @@ export declare class WorktreeSetupError extends Error {
  * repository (unwritable path, stale branch, git lock) throw so an isolated
  * role never silently loses its isolation.
  */
-export declare function createChildWorktree(cwd: string, childId: string, run?: GitRunner, signal?: AbortSignal, onPrepared?: (worktree: WorktreeInfo) => Promise<void>): Promise<WorktreeInfo | undefined>;
+export declare function createChildWorktree(cwd: string, childId: string, run?: GitRunner, signal?: AbortSignal, onPrepared?: (worktree: WorktreeInfo) => Promise<void>, nameParts?: readonly string[]): Promise<WorktreeInfo | undefined>;
 export interface WorktreeDirtyInspection {
     dirty: boolean;
     failure?: string;

package/dist/worktree.js

@@ -5,8 +5,11 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { runGit } from "./git-process.js";
 export const WORKTREES_DIRNAME = ".worktrees";
 const BRANCH_NAMESPACE = "pi-subagent";
-/** Branches `createChildWorktree` creates for workers and integration checkouts, at `<primary>/.worktrees/<branch basename>`. */
-export const OWNED_BRANCH_PATTERN = new RegExp(`^${BRANCH_NAMESPACE}/subagent-[0-9a-f]{24}$`);
+const NAME_COMPONENT_LIMIT = 24;
+const NAME_LIMIT = 72;
+export const READABLE_BRANCH_PATTERN = new RegExp(`^${BRANCH_NAMESPACE}/subagent-[a-z0-9](?:[a-z0-9-]{0,${NAME_LIMIT - 2}}[a-z0-9])?-[0-9a-f]{24}$`);
+/** Keep saved opaque names eligible for exact recovery and cleanup. */
+export const OWNED_BRANCH_PATTERN = new RegExp(`${READABLE_BRANCH_PATTERN.source}|^${BRANCH_NAMESPACE}/subagent-[0-9a-f]{24}$`);
 export class WorktreeSetupError extends Error {
     name = "WorktreeSetupError";
     worktree;
@@ -16,6 +19,11 @@ export class WorktreeSetupError extends Error {
     }
 }
 const sanitizeShortId = (childId) => createHash("sha256").update(childId).digest("hex").slice(0, 24);
+function nameSlug(parts) {
+    return parts.map((part) => part.toLowerCase().replace(/[^a-z0-9]+/g, "-")
+        .slice(0, NAME_COMPONENT_LIMIT).replace(/^-+|-+$/g, "") || "task")
+        .join("-").slice(0, NAME_LIMIT).replace(/-+$/, "") || "task";
+}
 const stripGitLineEnd = (value) => value.replace(/\r?\n$/, "");
 function hasRepositoryMarker(cwd) {
     for (let directory = resolve(cwd);; directory = dirname(directory)) {
@@ -60,7 +68,7 @@ async function ensureLocalExclude(gitDir) {
  * repository (unwritable path, stale branch, git lock) throw so an isolated
  * role never silently loses its isolation.
  */
-export async function createChildWorktree(cwd, childId, run = runGit, signal, onPrepared) {
+export async function createChildWorktree(cwd, childId, run = runGit, signal, onPrepared, nameParts = [childId]) {
     const root = await run(["rev-parse", "--show-toplevel"], cwd, signal);
     signal?.throwIfAborted();
     if (root.code === -1)
@@ -130,7 +138,7 @@ export async function createChildWorktree(cwd, childId, run = runGit, signal, on
     }
     signal?.throwIfAborted();
     const worktreesRoot = join(stableRepoRoot, WORKTREES_DIRNAME);
-    const name = `subagent-${sanitizeShortId(childId)}`;
+    const name = `subagent-${nameSlug(nameParts)}-${sanitizeShortId(childId)}`;
     const branch = `${BRANCH_NAMESPACE}/${name}`;
     const path = join(worktreesRoot, name);
     const worktree = { path, cwd: join(path, relativeCwd), branch, repoRoot: stableRepoRoot, baseCommit };

package/docs/orchestration.md

@@ -194,7 +194,13 @@ Activity uses the existing session sample and file-size cache. The extension ign
 
 ## Isolated contract
 
-An isolated request has one durable ID, one goal, and 1 to 8 typed tasks:
+An isolated request has one durable ID, one goal, and 1 to 8 typed tasks.
+
+New worktrees use `.worktrees/subagent-<name>-<24hex>` and branch `pi-subagent/subagent-<name>-<24hex>`. The name uses the request and task IDs. Text tasks also include `text-<attempt>`. Integration checkouts use the request ID and `integration-<generation>`. Each name component has at most 24 characters; the full readable part has at most 72. Names use lowercase ASCII letters, digits, and hyphens. The 24-hex identity suffix keeps names distinct when readable parts are shortened or normalized.
+
+Herdr workspace labels use the worker worktree name. Worker tab labels add the model class. Names never use goals, requirements, or other free-form task text. Saved opaque worktree names and their Herdr labels stay unchanged. Resume and cleanup use the exact saved allocations; the extension does not rename existing resources.
+
+For example:
 
 ```json
 {
@@ -269,15 +275,15 @@ After readiness, use `subagent_stage revise` with the exact candidate, generatio
 
 ### Inspect and revise active work
 
-To select work by label, open `/subagent` without arguments. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout. This includes requests launched in other sessions. Select an isolated request. Then select **Inspect status and recovery**.
+To select work by label, open `/subagent` without arguments. First, a **Current subagent work** report shows the work that local and saved evidence proves is running: locally owned direct workflows with a running worker, and active isolated requests while a live run holds the repository lease. The report lists active requests without a live lease as interrupted, and recorded-only direct work as unverified. A live lease does not identify its request, so several active requests in one checkout all show as working. The menu shows direct records on this session branch and isolated requests in the current canonical Git checkout. This includes requests launched in other sessions. Select an isolated request. Then select **Inspect status and recovery**.
 
-The menu also shows requests whose saved parent checkout no longer exists, in their own **Orphaned · parent checkout removed** group. You can open this view from any checkout of the same repository. The saved worker or integration path identifies the primary repository. Orphaned requests have the same **Close and delete worktrees (discard work)** action, but no inspection or follow-up actions. The extension reads their original state directories; it does not recreate the removed parent checkout. Unreadable files stay preserved and are reported.
+The menu also shows requests whose saved parent checkout no longer exists, in their own **Orphaned · parent checkout removed** group. Saved `running` and `pending` states have a `saved` prefix and an `unverified` suffix. The report lists them under **Unverified**, never **Working**, even if the current checkout has a live lease. These labels do not change saved state or prove completion. Orphaned requests with retained resources or `needs_attention` show under **Needs attention**. You can open this view from any checkout of the same repository. The saved worker or integration path identifies the primary repository. Orphaned requests have the same **Close and delete worktrees (discard work)** action, but no inspection or follow-up actions. The extension reads their original state directories; it does not recreate the removed parent checkout. Unreadable files stay preserved and are reported.
 
 This launches a Herdr tab without focus, with the configured `scout` Role on the configured `fast` route. The tab runs a read-access task with the resources of the Role. Its prompt contains bounded saved status, including retained paths, but not the raw launch environment or session transcripts. The analysis stays in that tab and does not queue a Main turn. The tab shows in the direct list with its own reference and name, such as `D9.1 · scout · Inspect <request ID>`. The extension records the tab and session file for recovery, even if the launch becomes uncertain.
 
 Before any stage or recovery action, the read-only `subagent_status` tool stays Main's authority for exact identities. If Herdr, the `scout` Role, or the fast route is not available, inspection fails and does not change the request. Main can then use `subagent_status`.
 
-For older work, choose Refresh or completed/history. The extension shows a warning for invalid state IDs and preserves them. Direct recovery still works outside Git or when isolated inventory is not available. The browse action does not resume work or change resources. Direct **Close/cancel-and-release** is an explicit termination action.
+Both isolated groups hide terminal requests by default: `completed`, `aborted`, `final_failed`, and `superseded`. Requests with retained resources or unresolved recovery stay visible. Select **Completed / history** to see all saved requests; **Refresh** reloads the current view. The filter does not delete records. Without interactive UI, the request list includes history. The extension shows a warning for invalid state IDs and preserves them. Direct recovery still works outside Git or when isolated inventory is not available. The browse action 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. A 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 shows in FIFO order, with blank lines between them. An explicit submission queues **one replacement** at the end. If you cancel, the withdrawn instructions stay removed.
 
@@ -400,7 +406,7 @@ One confirmation permits permanent deletion of committed, uncommitted, and ignor
 
 Each resource is checked again before removal. A live productive lease or local job blocks the action. Uncertain allocations, changed branch tips, locked or redirected checkouts, and other Herdr panes inside a checkout block that resource. Initialized submodules and index flags that hide clean-state evidence also require separate inspection. If Herdr cannot be inspected, checkouts stay in place.
 
-Main cannot run inside a checkout selected for deletion. A session change stops further removal. Only this request's recorded `pi-subagent/subagent-<24hex>` branches and their exact primary `.worktrees/` paths can be removed. The primary checkout is never removed.
+Main cannot run inside a checkout selected for deletion. A session change stops further removal. Only this request's recorded `pi-subagent/subagent-<name>-<24hex>` branches, saved legacy `pi-subagent/subagent-<24hex>` branches, and their exact primary `.worktrees/` paths can be removed. The primary checkout is never removed.
 
 To close and delete many requests, select **Select multiple…** in `/subagent`, select the requests, then select **Continue** and **Close and delete worktrees (discard work)**. The command shows the review of each request. Then one confirmation covers the unblocked resource groups of all of them. The same menu can close all owned workers of each selected direct workflow that can close. The command reports the number of selected rows that the action skipped.
 
@@ -408,7 +414,7 @@ The report lists removed, skipped, and failed resources. After complete cleanup,
 
 ### Prune leftover worktrees
 
-Run `/subagent prune` to clean up leftover worker and integration checkouts under `.worktrees/`. Their branches have the name `pi-subagent/subagent-` plus 24 hex characters. The command also cleans up such branches that have no checkout. The review starts with the number of removable and blocked items. It groups the items by the exact reason that the command can remove them, or by their exact blockers, and shows each reason once. Under each reason, it identifies each item by the first 8 of its 24 hex characters. The command can remove an item only when all of these conditions are true:
+Run `/subagent prune` to clean up leftover worker and integration checkouts under `.worktrees/`. Their branches have the name `pi-subagent/subagent-<name>-<24hex>`, or the saved legacy name `pi-subagent/subagent-<24hex>`. The command also cleans up such branches that have no checkout. The review starts with the number of removable and blocked items. It groups the items by the exact reason that the command can remove them, or by their exact blockers, and shows each reason once. Under each reason, it shows the readable name, if present, and the first 8 characters of the identity suffix. The command can remove an item only when all of these conditions are true:
 
 - Its branch tip is already in Main's HEAD or in the local `origin` default-branch ref. The command does not fetch.
 - Its checkout has no tracked or untracked changes. No merge, rebase, cherry-pick, revert, or bisect is in progress.

package/extensions/isolated.ts

@@ -842,7 +842,8 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 				catch (error) { console.error("Pi Subagent workspace widget update failed.", error); }
 			}
 			const orphans = await getComponents().runner.listOrphanRequests(root);
-			return { root, requests: [...requests, ...orphans.requests], invalidIds: [...new Set([...invalidIds, ...orphans.invalidIds])] };
+			const leaseLive = await getComponents().runner.hasProductiveRunLease(root);
+			return { root, leaseLive, requests: [...requests, ...orphans.requests], invalidIds: [...new Set([...invalidIds, ...orphans.invalidIds])] };
 		},
 		async recover(cwd) {
 			const root = await lookupRoot(cwd);

package/extensions/subagent-command.ts

@@ -2,6 +2,7 @@ import { getMarkdownTheme, type ExtensionAPI, type ExtensionContext, type Theme
 import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import type { DiscardPlan } from "../dist/discard.js";
 import type { PruneItem } from "../dist/prune.js";
+import { TERMINAL_RUN_STATUSES } from "../dist/schema.js";
 import { compactCost } from "./result-transport.ts";
 
 /** Saved before launch for user matching only; never ownership or mutation authority. */
@@ -56,6 +57,8 @@ export interface IsolatedRequest {
 }
 export interface IsolatedInventory {
 	root: string;
+	/** A live productive run holds this root's lease; the lease does not name its request. */
+	leaseLive: boolean;
 	requests: readonly IsolatedRequest[];
 	invalidIds: readonly string[];
 }
@@ -190,7 +193,7 @@ const summary = (text: string, max = 60): string => {
 };
 // Identity and status first so clipping cuts only the goal summary.
 const isolatedLabel = ({ id, status, name }: IsolatedRequest): string => `${id} · ${status} · ${summary(name)}`;
-const completed = (status: string) => ["completed", "success", "failed", "failure", "aborted", "integrated"].includes(status);
+const completed = (status: string) => [...TERMINAL_RUN_STATUSES, "success", "failed", "failure", "integrated"].includes(status);
 const priority = (status: string) => /attention|blocked|retained|failed/i.test(status) ? 0 : completed(status) ? 2 : 1;
 // Recorded-only and unverified work is uncertain, not active.
 const statusTone = (status: string): Tone => /attention|blocked|retained|recorded only|unverified/i.test(status) ? "warning"
@@ -200,7 +203,7 @@ const glyph = (status: string) => TONES[statusTone(status)].glyph;
 const cleanupReport = ({ text, failed, skipped }: CleanupReport): Report => textReport(failed ? "error" : skipped ? "warning" : "success", text);
 
 const PRUNE_IGNORED_CONFIRM_CODE_POINTS = 4_000;
-const shortId = ({ branch }: PruneItem) => branch.replace(/^pi-subagent\/subagent-/, "").slice(0, 8);
+const shortId = ({ branch }: PruneItem) => branch.replace(/^pi-subagent\/subagent-/, "").replace(/([0-9a-f]{8})[0-9a-f]{16}$/, "$1");
 const NOT_SHOWN = "they are not removed in this run; run /subagent prune again after this run.";
 
 /** Fit whole item lines within `max` code points; never cut silently, and report exactly which items were shown. */
@@ -244,7 +247,7 @@ function pruneReview({ root, items }: PrunePlan): { report: Report; shown: Prune
 	const prunable = items.filter((item) => item.prunable).length;
 	const head: Report = { tone: "info", title: "Subagent prune review", sections: [{ rows: [
 		{ label: "root", value: root, code: true }, { label: "prunable", value: String(prunable) }, { label: "blocked", value: String(items.length - prunable) },
-		{ label: "IDs", value: "first 8 characters after pi-subagent/subagent-" },
+		{ label: "IDs", value: "readable name, if present, and first 8 suffix characters" },
 	] }] };
 	// Each line measures its exact Markdown, so the cap never cuts a shown item.
 	const reviewed = fitItems(reportMarkdown(head), rows, ({ section, index, row }) => index ? sectionMarkdown({ rows: [row] }) : `\n${sectionMarkdown({ ...section, rows: [row] })}`,
@@ -291,6 +294,42 @@ function directReport(task: DirectTask): Report {
 	] };
 }
 
+const WORKING_REPORT_CODE_POINTS = 4_000;
+/** Current work from local and saved evidence only. Recorded-only direct work and isolated work without a live lease never count as working. */
+export function workingReport(direct: readonly DirectTask[], inventory: IsolatedInventory | undefined): Report {
+	const working: Row[] = [];
+	const attention: Row[] = [];
+	const unverified: Row[] = [];
+	for (const task of direct) {
+		const text = `${directLabel(task)} · ${task.status}`;
+		// Read workflows list their running workers; write workflows stay observed locally until their workers are proved stopped.
+		if (task.status === "observed locally" && task.stoppable?.length !== 0) working.push({ text: task.stoppable ? `${directLabel(task)} · ${task.stoppable.length} running` : text });
+		else if (/retained|attention/.test(task.status)) attention.push({ text });
+		else if (completed(task.status)) continue;
+		else unverified.push({ text: task.status === "observed locally" ? `${text}; no running worker` : text });
+	}
+	for (const request of inventory?.requests ?? []) {
+		const active = !request.orphaned && ["pending", "running"].includes(request.status);
+		if (active && inventory!.leaseLive) working.push({ text: isolatedLabel(request) });
+		else if (active) attention.push({ text: `${isolatedLabel(request)} · interrupted; run /subagent recover` });
+		else if (request.status === "needs_attention" || /retained/.test(request.status)) attention.push({ text: isolatedLabel(request) });
+		else if (request.orphaned && /unverified/.test(request.status)) unverified.push({ text: isolatedLabel(request) });
+	}
+	const sections: Section[] = [
+		working.length ? { heading: `Working (${working.length})`, tone: "info", rows: working } : { rows: [{ text: inventory ? "No subagents are working." : "No direct subagents are working. Isolated status is unavailable." }] },
+		{ heading: `Needs attention (${attention.length})`, tone: "warning", rows: attention },
+		{ heading: `Unverified (${unverified.length})`, note: "not proof of running or completion", tone: "warning", rows: unverified },
+	];
+	const head: Report = { tone: attention.length ? "warning" : "info", title: "Current subagent work", sections: [] };
+	const items = sections.flatMap((section) => section.rows.map((row, index) => ({ section, index, row })));
+	const fitted = fitItems(reportMarkdown(head), items, ({ section, index, row }) => index ? sectionMarkdown({ rows: [row] }) : `\n${sectionMarkdown({ ...section, rows: [row] })}`,
+		WORKING_REPORT_CODE_POINTS, "open /subagent with interactive UI to see them.");
+	return { ...head, sections: [...sections.flatMap((section) => {
+		const rows = fitted.shown.filter((item) => item.section === section).map(({ row }) => row);
+		return rows.length ? [{ ...section, rows }] : [];
+	}), ...moreSection(fitted.more)] };
+}
+
 type Choice<T> = { label: string; value: T };
 async function choose<T>(ctx: ExtensionContext, title: string, items: readonly Choice<T>[]): Promise<T | undefined> {
 	// Numeric suffixes only tell duplicate labels apart. Never parse display text into an identity.
@@ -462,6 +501,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 			}
 			if (!ctx.hasUI) {
 				const inventory = await adapter.isolated(ctx.cwd, current);
+				deliver(ctx, workingReport(adapter.direct(ctx), inventory));
 				const head: Report = { tone: "info", title: "Isolated requests (report only)", sections: [] };
 				const row = (request: IsolatedRequest): Row => ({ text: `${glyph(request.status)} ${request.orphaned ? "orphaned · " : ""}${isolatedLabel(request)}` });
 				const listed = fitItems(`${reportMarkdown(head)}\n`, inventory.requests, (request) => sectionMarkdown({ rows: [row(request)] }), ROLES_REPORT_CODE_POINTS,
@@ -473,6 +513,8 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				return;
 			}
 			let history = false;
+			// The working report shows on open and on each Refresh, not after other menu actions.
+			let report = true;
 			for (;;) {
 				if (!valid()) return;
 				// Direct recovery is independent of Git and isolated config/inventory failures.
@@ -482,6 +524,8 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				try { inventory = await adapter.isolated(ctx.cwd, current); }
 				catch (error) { unavailable = errorText(error); }
 				if (!valid()) return;
+				if (report) deliver(ctx, workingReport(direct, inventory));
+				report = false;
 				if (unavailable) ctx.ui.notify(`Isolated inventory unavailable (${unavailable}). Direct branch recovery remains available; check the canonical Git checkout/configuration.`, "warning");
 				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: "many" } | { kind: "close" };
@@ -489,13 +533,13 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				const group = <T extends { status: string }>(title: string, items: readonly T[], choice: (item: T) => Choice<Selection>): Choice<Selection>[] =>
 					items.length ? [{ label: `── ${title} (${items.length}) ──`, value: { kind: "refresh" } },
 						...[...items].sort((a, b) => priority(a.status) - priority(b.status)).map(choice)] : [];
-				const requests = inventory?.requests ?? [];
+				const requests = (inventory?.requests ?? []).filter((request) => history || !completed(request.status) || /retained/i.test(request.status));
 				const isolatedChoice = (request: IsolatedRequest): Choice<Selection> => ({ label: `  ${glyph(request.status)} ${isolatedLabel(request)}`, value: { kind: "isolated", request, root: inventory!.root } });
 				// One row per workflow; new records keep opaque IDs in details. Status is last so clipping preserves the reference.
 				const directChoice = (task: DirectTask): Choice<Selection> => ({ label: `  ${glyph(task.status)} ${directLabel(task)} · ${task.status}${costSuffix(task.cost)}${task.workers.length || task.name === task.id ? "" : ` · ${task.id}`}`, value: { kind: "direct", task } });
 				const groups = [
 					group("Direct", direct.filter((task) => history || !completed(task.status)), directChoice),
-					group("Isolated", requests.filter((request) => !request.orphaned && (history || !completed(request.status) || /retained/i.test(request.status))), isolatedChoice),
+					group("Isolated", requests.filter((request) => !request.orphaned), isolatedChoice),
 					group("Orphaned · parent checkout removed", requests.filter((request) => request.orphaned), isolatedChoice),
 				].flat();
 				const rows = groups.filter(({ value }) => value.kind === "direct" || value.kind === "isolated");
@@ -509,7 +553,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (!unavailable && !direct.length && !inventory?.requests.length && !inventory?.invalidIds.length) ctx.ui.notify("No direct tasks recorded on this session branch or isolated requests in this checkout. Ask Main to start delegation.", "info");
 				const selected = await choose(ctx, history ? "Subagent · completed / history" : "Subagent · current work", selections);
 				if (!valid() || !selected || selected.kind === "close") return;
-				if (selected.kind === "refresh") continue;
+				if (selected.kind === "refresh") { report = true; continue; }
 				if (selected.kind === "history") { history = !history; continue; }
 				if (selected.kind === "many") {
 					const picked = await chooseMany(ctx, "Subagent · select work", rows.map(({ label, value }) => ({ label: label.trim(), value })), [], valid);

package/extensions/subagent.ts

@@ -300,7 +300,10 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				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",
+					status: local?.recovery ? "admission retained" : local ? "observed locally"
+						// A recovery result did not prove worker termination, so it stays visible for recovery.
+						: results.get(record.taskId)?.recovery ? "needs attention: worker termination unproved"
+						: results.get(record.taskId)?.outcome ?? "recorded only; not proof of running or completion",
 					...(results.get(record.taskId)?.cost === undefined ? {} : { cost: results.get(record.taskId)!.cost }),
 					...(local?.recovery ? { recovery: local.recovery } : {}), canClose: Boolean(local?.close),
 					...(local?.stopWorker ? { stoppable: local.stopWorker.running() } : {}), workers: [], tabs: [] });

package/package.json

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