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

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

@@ -24,6 +24,7 @@ export declare const SUBAGENTS_RUN_PARAMETERS: Type.TObject<{
 }>;
 export declare const SUBAGENTS_INSPECT_PARAMETERS: Type.TObject<{
     id: Type.TOptional<Type.TString>;
+    scope: Type.TOptional<Type.TUnion<[Type.TLiteral<"session">, Type.TLiteral<"all">]>>;
 }>;
 export declare const SUBAGENTS_ID_PARAMETERS: Type.TObject<{
     id: Type.TString;
@@ -38,36 +39,51 @@ export declare const SUBAGENTS_STOP_PARAMETERS: Type.TObject<{
 export declare const SUBAGENTS_RETRY_PARAMETERS: Type.TObject<{
     id: Type.TString;
 }>;
-export declare const SUBAGENTS_TOOL_SCHEMAS: {
-    readonly subagents_run: Type.TObject<{
-        prompt: Type.TString;
-        mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"background">, Type.TLiteral<"foreground">]>>;
-        label: Type.TOptional<Type.TString>;
-        model: Type.TOptional<Type.TString>;
-        tools: Type.TOptional<Type.TArray<Type.TString>>;
-        skills: Type.TOptional<Type.TArray<Type.TString>>;
-        extensions: Type.TOptional<Type.TArray<Type.TString>>;
-        contextFiles: Type.TOptional<Type.TArray<Type.TString>>;
-        role: Type.TOptional<Type.TString>;
-        worktree: Type.TOptional<Type.TString>;
-        outputSchema: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
-        retries: Type.TOptional<Type.TInteger>;
-        timeoutMs: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
-    }>;
-    readonly subagents_inspect: Type.TObject<{
-        id: Type.TOptional<Type.TString>;
-    }>;
-    readonly subagents_steer: Type.TObject<{
-        id: Type.TString;
+export declare const SUBAGENT_STATUS_OUTPUT: Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+    sessionId: Type.TOptional<Type.TString>;
+    startedAt: Type.TOptional<Type.TNumber>;
+    finishedAt: Type.TOptional<Type.TNumber>;
+    attempts: Type.TOptional<Type.TNumber>;
+    attemptDetails: Type.TOptional<Type.TArray<Type.TUnknown>>;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        branch: Type.TString;
+    }>>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TString;
         message: Type.TString;
-    }>;
-    readonly subagents_stop: Type.TObject<{
-        id: Type.TString;
-    }>;
-    readonly subagents_retry: Type.TObject<{
-        id: Type.TString;
-    }>;
-};
+    }>>;
+    progress: Type.TOptional<Type.TUnknown>;
+    value: Type.TOptional<Type.TUnknown>;
+}>;
+export declare const SUBAGENTS_INSPECT_OUTPUT: Type.TUnion<[Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+    sessionId: Type.TOptional<Type.TString>;
+    startedAt: Type.TOptional<Type.TNumber>;
+    finishedAt: Type.TOptional<Type.TNumber>;
+    attempts: Type.TOptional<Type.TNumber>;
+    attemptDetails: Type.TOptional<Type.TArray<Type.TUnknown>>;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        branch: Type.TString;
+    }>>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TString;
+        message: Type.TString;
+    }>>;
+    progress: Type.TOptional<Type.TUnknown>;
+    value: Type.TOptional<Type.TUnknown>;
+}>, Type.TArray<Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+}>>]>;
+export declare const SUBAGENTS_STEER_OUTPUT: Type.TObject<{
+    id: Type.TString;
+    accepted: Type.TBoolean;
+}>;
 export type SubagentRunRequest = Static<typeof SUBAGENTS_RUN_PARAMETERS>;
 export declare function normalizeSubagentRunRequest(value: unknown): SubagentRunRequest;
 export type SubagentInspectRequest = Static<typeof SUBAGENTS_INSPECT_PARAMETERS>;
@@ -115,6 +131,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 +177,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/contracts.js

@@ -33,6 +33,7 @@ export const SUBAGENTS_RUN_PARAMETERS = Type.Object({
 }, { additionalProperties: false });
 export const SUBAGENTS_INSPECT_PARAMETERS = Type.Object({
     id: Type.Optional(Type.String({ description: "Subagent ID; omit to list ordered run summaries" })),
+    scope: Type.Optional(Type.Union([Type.Literal("session"), Type.Literal("all")], { description: "List scope when id is omitted: session (default) lists runs from the current Pi session; all lists every stored run" })),
 }, { additionalProperties: false });
 export const SUBAGENTS_ID_PARAMETERS = Type.Object({
     id: Type.String({ description: "Subagent ID" }),
@@ -47,13 +48,23 @@ export const SUBAGENTS_STOP_PARAMETERS = Type.Object({
 export const SUBAGENTS_RETRY_PARAMETERS = Type.Object({
     id: Type.String({ description: "Failed or stopped subagent ID to retry" }),
 }, { additionalProperties: false });
-export const SUBAGENTS_TOOL_SCHEMAS = {
-    subagents_run: SUBAGENTS_RUN_PARAMETERS,
-    subagents_inspect: SUBAGENTS_INSPECT_PARAMETERS,
-    subagents_steer: SUBAGENTS_STEER_PARAMETERS,
-    subagents_stop: SUBAGENTS_STOP_PARAMETERS,
-    subagents_retry: SUBAGENTS_RETRY_PARAMETERS,
-};
+// Structured results codemode scripts receive instead of the JSON text; nested records stay loose so they cannot drift from persistence.
+export const SUBAGENT_STATUS_OUTPUT = Type.Object({
+    id: Type.String(),
+    state: Type.String(),
+    sessionId: Type.Optional(Type.String()),
+    startedAt: Type.Optional(Type.Number()),
+    finishedAt: Type.Optional(Type.Number()),
+    attempts: Type.Optional(Type.Number()),
+    attemptDetails: Type.Optional(Type.Array(Type.Unknown())),
+    worktree: Type.Optional(Type.Object({ path: Type.String(), branch: Type.String() })),
+    error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String() })),
+    progress: Type.Optional(Type.Unknown()),
+    value: Type.Optional(Type.Unknown()),
+});
+// One run when id is given, otherwise the ordered run summaries; the summaries stay short in the codemode description.
+export const SUBAGENTS_INSPECT_OUTPUT = Type.Union([SUBAGENT_STATUS_OUTPUT, Type.Array(Type.Object({ id: Type.String(), state: Type.String() }))]);
+export const SUBAGENTS_STEER_OUTPUT = Type.Object({ id: Type.String(), accepted: Type.Boolean() });
 export function normalizeSubagentRunRequest(value) {
     if (!Value.Check(SUBAGENTS_RUN_PARAMETERS, value))
         throw new WorkflowError("INVALID_METADATA", "Invalid subagents_run parameters");

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" | "getAllTools" | "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

@@ -1,12 +1,12 @@
 import { join } from "node:path";
 import { defineTool, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Value } from "typebox/value";
-import { WorkflowError, loadingRegistry } from "../../src/index.js";
+import { WorkflowError, loadCodemodeToolsSetting, loadingRegistry, reachableTools, workflowToolExposure } from "../../src/index.js";
 import { clearSubagentManager, setSubagentManager } from "../../src/subagent-manager-handle.js";
 import { createSubagentManager } from "./manager.js";
 import { registerSubagentNavigator } from "./navigator.js";
 import { createSubagentBackgroundWidget, renderSubagentCall, renderSubagentControlCall, renderSubagentControlResult, renderSubagentInspectCall, renderSubagentInspectResult, renderSubagentResult } from "./view.js";
-import { normalizeSubagentRunRequest, SUBAGENTS_ID_PARAMETERS, SUBAGENTS_INSPECT_PARAMETERS, SUBAGENTS_RETRY_PARAMETERS, SUBAGENTS_RUN_PARAMETERS, SUBAGENTS_STEER_PARAMETERS, SUBAGENTS_STOP_PARAMETERS, } from "./contracts.js";
+import { normalizeSubagentRunRequest, SUBAGENT_STATUS_OUTPUT, SUBAGENTS_ID_PARAMETERS, SUBAGENTS_INSPECT_OUTPUT, SUBAGENTS_INSPECT_PARAMETERS, SUBAGENTS_RETRY_PARAMETERS, SUBAGENTS_RUN_PARAMETERS, SUBAGENTS_STEER_OUTPUT, SUBAGENTS_STEER_PARAMETERS, SUBAGENTS_STOP_PARAMETERS, } from "./contracts.js";
 export * from "./contracts.js";
 export { attemptValue, statusValue, subagentErrorValue } from "./decode.js";
 export { createSubagentManager, createUnavailableSubagentManager } from "./manager.js";
@@ -41,7 +41,7 @@ function serialize(value) {
     }
 }
 function toolResult(value) {
-    return { content: [{ type: "text", text: serialize(value) }], details: value };
+    return { content: [{ type: "text", text: serialize(value) }], details: value, structuredContent: value };
 }
 function managerContext(toolCallId, signal, onUpdate, context) {
     return {
@@ -63,6 +63,7 @@ export function createSubagentTools(manager) {
                 "Do not poll a running ID; use subagents_inspect({ id }) when you need its current status or terminal result.",
             ],
             parameters: SUBAGENTS_RUN_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.run(validateSubagentRunRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -72,8 +73,9 @@ export function createSubagentTools(manager) {
         defineTool({
             name: "subagents_inspect",
             label: "Subagents Inspect",
-            description: "Inspect durable subagent runs. Omit id for ordered run summaries, or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
+            description: "Inspect durable subagent runs. Omit id for ordered run summaries of the current session (scope all for every session), or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
             parameters: SUBAGENTS_INSPECT_PARAMETERS,
+            outputSchema: SUBAGENTS_INSPECT_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.inspect(validateSubagentInspectRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -85,6 +87,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Steer",
             description: "Send a message to a running subagent. The message is queued safely if its steering handler is not ready; settled runs cannot be steered.",
             parameters: SUBAGENTS_STEER_PARAMETERS,
+            outputSchema: SUBAGENTS_STEER_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.steer(validateSubagentSteerRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -96,6 +99,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Stop",
             description: "Stop one running subagent, abort its active session, persist state \"stopped\", and clean its worktree without affecting sibling runs.",
             parameters: SUBAGENTS_STOP_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.stop(validateSubagentIdRequest(params, "subagents_stop"), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -107,6 +111,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Retry",
             description: "Start a fresh run from a failed or stopped subagent's persisted request. The new run gets a new ID and preserves its original background or foreground mode.",
             parameters: SUBAGENTS_RETRY_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.retry(validateSubagentIdRequest(params, "subagents_retry"), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -145,7 +150,8 @@ export function createSubagentsExtension(options = {}, activeTools, notify, onSt
 }
 export function registerSubagentsExtension(pi, options = {}) {
     const getActiveTools = pi.getActiveTools;
-    const activeTools = getActiveTools === undefined ? undefined : () => getActiveTools.call(pi);
+    const getAllTools = pi.getAllTools;
+    const activeTools = getActiveTools === undefined ? undefined : () => reachableTools({ getActiveTools: () => getActiveTools.call(pi), ...(getAllTools === undefined ? {} : { getAllTools: () => getAllTools.call(pi) }) });
     const sendMessage = pi.sendMessage;
     const notify = sendMessage === undefined ? undefined : (notification) => {
         sendMessage.call(pi, { customType: "subagents", content: notificationContent(notification), display: true, details: notification }, { deliverAs: "steer", triggerTurn: true });
@@ -153,11 +159,13 @@ 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);
+    const codemodeTools = loadCodemodeToolsSetting(options.managerDependencies?.agentDir);
     for (const tool of extension.tools)
-        pi.registerTool(tool);
+        pi.registerTool({ ...tool, ...workflowToolExposure(tool.name, codemodeTools) });
     if (pi.registerCommand !== undefined)
         registerSubagentNavigator(pi.registerCommand.bind(pi), extension.manager, storageDirectory(options), options.clipboard);
     if (pi.on !== undefined) {

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") {
@@ -1154,9 +1156,9 @@ class PersistentSubagentManager {
             }
             return inspection;
         }
-        return this.inspectList();
+        return this.inspectList(request.scope === "all" ? undefined : context.extensionContext.sessionManager.getSessionId());
     }
-    async inspectList() {
+    async inspectList(sessionId) {
         const root = storageDirectory(this.dependencies);
         await secureDirectory(root);
         const entries = await readdir(root, { withFileTypes: true });
@@ -1170,7 +1172,7 @@ class PersistentSubagentManager {
             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)
+                if (status.startedAt === undefined || (sessionId !== undefined && status.sessionId !== sessionId))
                     continue;
                 statuses.push({ status, startedAt: status.startedAt });
             }
@@ -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(); },
     };
 }