@marcoscale98/pi-extensible-workflows 5.14.1-fork.1 → 5.19.1-fork.1

package/subagents/src/manager.ts

@@ -12,7 +12,6 @@ import {
   isThinkingLevel,
   jsonValue,
   object,
-  loadAgentDefinitions,
   loadingRegistry,
   localAgentTransport,
   resolveAgentResourcePolicy,
@@ -43,6 +42,7 @@ import {
   SerialLane,
 } from "../../src/index.js";
 import { decodeAgentDefinition, decodeWorkflowExtensions } from "../../src/decoders.js";
+import { loadAgentDefinitions } from "../../src/roles.js";
 import { atomicJson, json as readJson, processAlive } from "../../src/persistence.js";
 import { accountingValue, activityValue, legacyAccountingValue, worktreeValue } from "./decode.js";
 import {
@@ -1103,8 +1103,9 @@ class PersistentSubagentManager implements SubagentManager {
     if (request.id !== undefined) {
       const id = checkedId({ id: request.id });
       const active = this.activeRuns.get(id);
-      const status = active ? persistedStatus(active) : this.terminalSummaries.get(id) ?? await loadPersistedStatus(storageDirectory(this.dependencies), id);
-      const inspection = publicStatus(status, context.includeAttemptMetadata === true);
+      const includeActivity = context.includeActivity === true;
+      const status = active ? includeActivity ? liveStatus(active) : persistedStatus(active) : this.terminalSummaries.get(id) ?? await loadPersistedStatus(storageDirectory(this.dependencies), id);
+      const inspection = publicStatus(status, context.includeAttemptMetadata === true, includeActivity);
       if (status.state === "completed") return { ...inspection, value: await loadPersistedResult(storageDirectory(this.dependencies), id) };
       if (status.state === "failed") {
         const failure = status.error ?? await loadPersistedFailure(storageDirectory(this.dependencies), id);
@@ -1112,9 +1113,9 @@ class PersistentSubagentManager implements SubagentManager {
       }
       return inspection;
     }
-    return this.inspectList();
+    return this.inspectList(request.scope === "all" ? undefined : context.extensionContext.sessionManager.getSessionId());
   }
-  private async inspectList(): Promise<unknown> {
+  private async inspectList(sessionId: string | undefined): Promise<unknown> {
     const root = storageDirectory(this.dependencies);
     await secureDirectory(root);
     const entries = await readdir(root, { withFileTypes: true });
@@ -1126,7 +1127,7 @@ class PersistentSubagentManager implements SubagentManager {
       try {
         const active = this.activeRuns.get(entry.name);
         const status = publicStatus(active ? persistedStatus(active) : this.terminalSummaries.get(entry.name) ?? await loadPersistedStatus(root, entry.name, false));
-        if (status.startedAt === undefined) continue;
+        if (status.startedAt === undefined || (sessionId !== undefined && status.sessionId !== sessionId)) continue;
         statuses.push({ status, startedAt: status.startedAt });
       } catch (error) {
         if (error instanceof WorkflowError && (error.code === "RUN_NOT_FOUND" || error instanceof InvalidPersistedSubagentStatusError)) continue;
@@ -1159,6 +1160,20 @@ class PersistentSubagentManager implements SubagentManager {
     return publicStatus(persistedStatus(run));
   }
 
+  /** Removes a settled record for the /subagents navigator, as /workflow deletes a terminal run; not a model tool. */
+  async delete(request: Readonly<{ id: string }>): Promise<unknown> {
+    const id = checkedId(request);
+    await this.ensureInitialized();
+    const root = storageDirectory(this.dependencies);
+    const status = this.activeRuns.has(id) ? undefined : this.terminalSummaries.get(id) ?? await loadPersistedStatus(root, id, false);
+    if (status === undefined || status.state === "running") throw new WorkflowError("RUN_OWNED", `Stop subagent ${id} before deleting it`);
+    // Retained worktree metadata means cleanup failed, and the record holds what a later cleanup needs.
+    if (status.worktree !== undefined) throw new WorkflowError("WORKTREE_FAILED", `Subagent ${id} still has a worktree to clean up`);
+    await rm(runDirectory(root, id), { recursive: true, force: true });
+    this.terminalSummaries.delete(id);
+    return { id, deleted: true };
+  }
+
   async dispose(): Promise<void> {
     if (this.disposePromise) return this.disposePromise;
     this.disposePromise = (async () => {
@@ -1339,8 +1354,10 @@ class PersistentSubagentManager implements SubagentManager {
       run.disposed = true;
       this.clearSteering(run);
       await this.cleanupSessions(run, true);
-      const worktreeCleaned = await this.cleanupWorktree(run);
-      if (worktreeCleaned) await enqueueWrite(run, () => atomicJson(statusPath(run.directory), persistedStatus(run)));
+      await this.cleanupWorktree(run);
+      // A run that settled just before disposal may not have written its terminal status yet: finishTerminal returns early
+      // once the run is disposed. Left as "running" under this live process, the next manager here would never reconcile it.
+      await enqueueWrite(run, () => atomicJson(statusPath(run.directory), persistedStatus(run)));
       this.resolveTerminal(run);
       this.removeLiveRun(run);
     }
@@ -1547,14 +1564,15 @@ export function createUnavailableSubagentManager(): SubagentManager {
   };
 }
 export function createSubagentManager(dependencies: SubagentManagerDependencies = {}): SubagentManager {
-  const manager: SubagentManager = new PersistentSubagentManager(dependencies);
+  const manager = new PersistentSubagentManager(dependencies);
   return {
     run: (request, context) => manager.run(request, context),
     inspect: (request, context) => manager.inspect(request, context),
-    getAttemptActionData: (id) => manager.getAttemptActionData?.(id),
-    steer: (request, context) => manager.steer(request, context),
-    stop: (request, context) => manager.stop(request, context),
+    getAttemptActionData: (id) => manager.getAttemptActionData(id),
+    steer: (request) => manager.steer(request),
+    stop: (request) => manager.stop(request),
     retry: (request, context) => manager.retry(request, context),
-    dispose: async () => { await manager.dispose?.(); },
+    delete: (request) => manager.delete(request),
+    dispose: async () => { await manager.dispose(); },
   };
 }