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

package/dist/subagents/src/contracts.d.ts

@@ -115,6 +115,8 @@ export interface SubagentManagerContext {
     readonly extensionContext: ExtensionContext;
     readonly waitForForeground?: boolean;
     readonly includeAttemptMetadata?: boolean;
+    /** Adds the live progress and activity of an active run; tool results leave streamed activity out. */
+    readonly includeActivity?: boolean;
 }
 export interface SubagentAttemptActionData {
     readonly attempt: AgentAttemptSummary;
@@ -159,6 +161,8 @@ export interface SubagentManager {
     steer(request: Readonly<SubagentSteerRequest>, context: Readonly<SubagentManagerContext>): Promise<unknown>;
     stop(request: Readonly<SubagentIdRequest>, context: Readonly<SubagentManagerContext>): Promise<unknown>;
     retry(request: Readonly<SubagentIdRequest>, context: Readonly<SubagentManagerContext>): Promise<unknown>;
+    /** Removes a settled run record; used by the /subagents navigator only. */
+    delete?(request: Readonly<SubagentIdRequest>, context: Readonly<SubagentManagerContext>): Promise<unknown>;
     getAttemptActionData?(id: string): Readonly<SubagentAttemptActionData> | undefined;
     dispose?(): Promise<void>;
 }

package/dist/subagents/src/index.d.ts

@@ -5,7 +5,7 @@ export { attemptValue, statusValue, subagentErrorValue } from "./decode.js";
 export { createSubagentManager, createUnavailableSubagentManager } from "./manager.js";
 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">>;
 export declare function createSubagentTools(manager: SubagentManager): readonly ToolDefinition[];
 export declare function createSubagentsExtension(options?: SubagentsExtensionOptions, activeTools?: () => readonly string[], notify?: (notification: SubagentNotification) => void | Promise<void>, onStatus?: (status: Readonly<SubagentStatus>, request: Readonly<SubagentRunRequest>) => void, onResourceWarning?: (message: string) => void): SubagentsExtension;
 export declare function registerSubagentsExtension(pi: SubagentsExtensionAPI, options?: SubagentsExtensionOptions): SubagentsExtension;

package/dist/subagents/src/index.js

@@ -153,7 +153,8 @@ export function registerSubagentsExtension(pi, options = {}) {
     const onResourceWarning = sendMessage === undefined ? undefined : (message) => {
         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)

package/dist/subagents/src/manager.js

@@ -2,8 +2,9 @@ import { randomUUID } from "node:crypto";
 import { chmod, link, mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { addAccounting, deepFreeze, errorCode, errorText, finiteNumber, isNodeError, isThinkingLevel, jsonValue, object, loadAgentDefinitions, loadingRegistry, localAgentTransport, resolveAgentResourcePolicy, resolveWorkflowSettings, roleNameOf, sanitizeDisplayText, sumAccounting, structuralPath, validateModelAliasAvailability, WorkflowAgentExecutor, WorkflowError, workflowProjectSettingsPath, workflowSettingsPath, SerialLane, } from "../../src/index.js";
+import { addAccounting, deepFreeze, errorCode, errorText, finiteNumber, isNodeError, isThinkingLevel, jsonValue, object, loadingRegistry, localAgentTransport, resolveAgentResourcePolicy, resolveWorkflowSettings, roleNameOf, sanitizeDisplayText, sumAccounting, structuralPath, validateModelAliasAvailability, WorkflowAgentExecutor, WorkflowError, workflowProjectSettingsPath, workflowSettingsPath, 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 { SUBAGENT_ATTEMPT_DETAILS_LIMIT, SUBAGENT_MAX_RETRIES, SUBAGENT_SYSTEM_PROMPT_LIMIT, SUBAGENTS_TOOL_NAMES, normalizeSubagentRunRequest, } from "./contracts.js";
@@ -1144,8 +1145,9 @@ class PersistentSubagentManager {
         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") {
@@ -1208,6 +1210,21 @@ class PersistentSubagentManager {
         await this.stopRun(run, false);
         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) {
+        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() {
         if (this.disposePromise)
             return this.disposePromise;
@@ -1405,9 +1422,10 @@ class PersistentSubagentManager {
             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);
         }
@@ -1627,10 +1645,11 @@ export function createSubagentManager(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(); },
     };
 }