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

package/subagents/src/index.ts

@@ -23,7 +23,7 @@ export { createSubagentManager, createUnavailableSubagentManager } from "./manag
 export { createRunStoreWorktreeAdapter, defaultWorktreeHome } from "./worktree.js";
 export type { SubagentWorktreeAdapter, SubagentWorktreeContext, SubagentWorktreeHandle, SubagentWorktreeRunStore } from "./worktree.js";
 
-type SubagentsExtensionAPI = Pick<ExtensionAPI, "registerTool"> & Partial<Pick<ExtensionAPI, "getActiveTools" | "on" | "sendMessage" | "registerCommand">>;
+type SubagentsExtensionAPI = Pick<ExtensionAPI, "registerTool"> & Partial<Pick<ExtensionAPI, "getActiveTools" | "on" | "sendMessage" | "registerCommand" | "appendEntry" | "registerEntryRenderer">>;
 
 function validateSubagentRunRequest(value: unknown): SubagentRunRequest {
   return normalizeSubagentRunRequest(value);
@@ -170,7 +170,8 @@ export function registerSubagentsExtension(pi: SubagentsExtensionAPI, options: S
   const onResourceWarning = sendMessage === undefined ? undefined : (message: string): void => {
     sendMessage.call(pi, { customType: "subagents", content: `Warning: ${message}`, display: true }, { deliverAs: "steer" });
   };
-  const widget = createSubagentBackgroundWidget();
+  const appendEntry = pi.appendEntry;
+  const widget = createSubagentBackgroundWidget({ ...(appendEntry === undefined ? {} : { appendEntry: (customType, data) => { appendEntry.call(pi, customType, data); } }), ...(pi.registerEntryRenderer === undefined ? {} : { registerEntryRenderer: pi.registerEntryRenderer.bind(pi) }) });
   const extension = createSubagentsExtension(options, activeTools, notify, (status, request) => { widget.update(status, request); const registry = loadingRegistry(); if (typeof registry.observeSubagentStatus === "function") registry.observeSubagentStatus(status, request); }, onResourceWarning);
   for (const tool of extension.tools) pi.registerTool(tool);
   if (pi.registerCommand !== undefined) registerSubagentNavigator(pi.registerCommand.bind(pi), extension.manager, storageDirectory(options), options.clipboard);

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);
@@ -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(); },
   };
 }