@henryqw/pi-subagent 27.8.0 → 27.9.0

package/README.md

@@ -155,6 +155,10 @@ 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.

package/dist/runner.d.ts

@@ -332,6 +332,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

@@ -639,6 +639,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) {

package/docs/orchestration.md

@@ -269,7 +269,7 @@ 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.
 

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

@@ -56,6 +56,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[];
 }
@@ -291,6 +293,41 @@ 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.orphaned && (request.status === "needs_attention" || /retained/.test(request.status))) attention.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 +499,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 +511,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 +522,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" };
@@ -509,7 +551,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.9.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",