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

package/dist/src/subagent-manager-handle.d.ts

@@ -0,0 +1,4 @@
+import type { SubagentManager } from "../subagents/src/contracts.js";
+export declare function setSubagentManager(manager: SubagentManager | undefined): void;
+export declare function getSubagentManager(): SubagentManager | undefined;
+export declare function clearSubagentManager(manager: SubagentManager): void;

package/dist/src/subagent-manager-handle.js

@@ -0,0 +1,6 @@
+const SUBAGENT_MANAGER_KEY = Symbol.for("pi-extensible-workflows.subagent-manager");
+const globalSubagentManagers = globalThis;
+export function setSubagentManager(manager) { globalSubagentManagers[SUBAGENT_MANAGER_KEY] = manager; }
+export function getSubagentManager() { return globalSubagentManagers[SUBAGENT_MANAGER_KEY]; }
+export function clearSubagentManager(manager) { if (globalSubagentManagers[SUBAGENT_MANAGER_KEY] === manager)
+    globalSubagentManagers[SUBAGENT_MANAGER_KEY] = undefined; }

package/dist/src/tool-timing.d.ts

@@ -0,0 +1,12 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+export declare const TOOL_TIMING_ENTRY_TYPE = "pi-workflows:tool-timing";
+export interface ToolTimingEntry {
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly durationMs: number;
+    readonly isError: boolean;
+}
+export declare const TOOL_TIMING_EXTENSION: ExtensionFactory;
+export declare function createToolTimingExtension(clock?: () => number): ExtensionFactory;

package/dist/src/tool-timing.js

@@ -0,0 +1,33 @@
+export const TOOL_TIMING_ENTRY_TYPE = "pi-workflows:tool-timing";
+// Bound unfinished executions so missing end events cannot grow session state indefinitely.
+const toolTimingExtension = (pi, clock = Date.now) => {
+    const MAX_ACTIVE_TOOL_TIMINGS = 400;
+    const starts = new Map();
+    pi.on("tool_execution_start", (event) => {
+        if (!starts.has(event.toolCallId) && starts.size >= MAX_ACTIVE_TOOL_TIMINGS)
+            return;
+        starts.set(event.toolCallId, { toolName: event.toolName, startedAt: clock() });
+    });
+    pi.on("tool_execution_end", (event) => {
+        const started = starts.get(event.toolCallId);
+        if (started === undefined)
+            return;
+        starts.delete(event.toolCallId);
+        const completedAt = clock();
+        pi.appendEntry("pi-workflows:tool-timing", {
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            startedAt: started.startedAt,
+            completedAt,
+            durationMs: Math.max(0, completedAt - started.startedAt),
+            isError: event.isError,
+        });
+    });
+    pi.on("session_shutdown", () => { starts.clear(); });
+};
+export const TOOL_TIMING_EXTENSION = toolTimingExtension;
+export function createToolTimingExtension(clock = Date.now) {
+    if (clock === Date.now)
+        return TOOL_TIMING_EXTENSION;
+    return (pi) => { toolTimingExtension(pi, clock); };
+}

package/dist/src/trajectory-contracts.d.ts

@@ -0,0 +1,8 @@
+export type TrajectoryAction = "checkpoint-approve" | "checkpoint-reject" | "pause" | "resume" | "steer" | "stop" | "retry" | "share";
+export type TrajectoryTarget = {
+    kind: "run" | "subagent";
+    id: string;
+};
+export declare function isTrajectoryAction(value: unknown): value is TrajectoryAction;
+export declare function isTrajectoryTarget(value: unknown): value is TrajectoryTarget;
+export declare function trajectoryActionError(action: TrajectoryAction, target: TrajectoryTarget): string | undefined;

package/dist/src/trajectory-contracts.js

@@ -0,0 +1,9 @@
+const TRAJECTORY_ACTIONS = ["checkpoint-approve", "checkpoint-reject", "pause", "resume", "steer", "stop", "retry", "share"];
+export function isTrajectoryAction(value) { return typeof value === "string" && TRAJECTORY_ACTIONS.includes(value); }
+export function isTrajectoryTarget(value) {
+    const target = value;
+    return typeof value === "object" && value !== null && !Array.isArray(value) && (target.kind === "run" || target.kind === "subagent") && typeof target.id === "string" && target.id.length >= 1 && target.id.length <= 200;
+}
+export function trajectoryActionError(action, target) {
+    return target.kind === "subagent" && (action === "checkpoint-approve" || action === "checkpoint-reject" || action === "pause" || action === "resume" || action === "share") ? `Trajectory action ${action} is not supported for subagent targets` : target.kind === "run" && action === "steer" ? "Trajectory action steer is not supported for run targets" : undefined;
+}

package/dist/src/trajectory-host-handle.d.ts

@@ -0,0 +1,12 @@
+import type { TrajectoryPublisherInput } from "./trajectory.js";
+export type TrajectoryPublisherProvider = (context: unknown) => TrajectoryPublisherInput;
+export type TrajectoryHost = {
+    open(provider: TrajectoryPublisherProvider, context: unknown): Promise<void>;
+    autoAttach(provider: TrajectoryPublisherProvider, context: {
+        hasUI: boolean;
+    }): void;
+    close(): Promise<void>;
+};
+export declare function setTrajectoryHost(host: TrajectoryHost | undefined): void;
+export declare function getTrajectoryHost(): TrajectoryHost | undefined;
+export declare function clearTrajectoryHost(host: TrajectoryHost): void;

package/dist/src/trajectory-host-handle.js

@@ -0,0 +1,6 @@
+const TRAJECTORY_HOST_KEY = Symbol.for("pi-extensible-workflows.trajectory-host");
+const globalTrajectoryHosts = globalThis;
+export function setTrajectoryHost(host) { globalTrajectoryHosts[TRAJECTORY_HOST_KEY] = host; }
+export function getTrajectoryHost() { return globalTrajectoryHosts[TRAJECTORY_HOST_KEY]; }
+export function clearTrajectoryHost(host) { if (globalTrajectoryHosts[TRAJECTORY_HOST_KEY] === host)
+    globalTrajectoryHosts[TRAJECTORY_HOST_KEY] = undefined; }

package/dist/src/trajectory.d.ts

@@ -0,0 +1,128 @@
+import { type AwaitingCheckpoint, type EffectiveSystemPrompt, type PersistedRun } from "./persistence.js";
+import type { AgentAttemptSummary, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference } from "./types.js";
+import { type SubagentProgress, type SubagentRunRequest, type SubagentStatus } from "../subagents/src/contracts.js";
+import type { TrajectoryAction, TrajectoryTarget } from "./trajectory-contracts.js";
+export declare const TRAJECTORY_MAX_TRANSCRIPT_BYTES: number;
+export type TrajectoryRun = {
+    run: PersistedRun;
+    snapshot: Readonly<LaunchSnapshot>;
+    awaiting: readonly AwaitingCheckpoint[];
+    createdAt?: string;
+    transcripts: Readonly<Record<string, readonly unknown[]>>;
+};
+export type TrajectoryTranscriptStatus = "available" | "empty" | "missing" | "failed" | "oversized" | "disconnected";
+export type TrajectoryTranscriptMetadata = {
+    readonly revision: number;
+    readonly status: TrajectoryTranscriptStatus;
+    readonly bytes?: number;
+    readonly timing?: readonly unknown[];
+};
+export type TrajectoryRunMetadata = Omit<TrajectoryRun, "transcripts"> & {
+    transcripts: Readonly<Record<string, TrajectoryTranscriptMetadata>>;
+};
+export type TrajectorySubagentArtifact = {
+    readonly truncated: true;
+    readonly path: string;
+    readonly bytes: number;
+};
+export type TrajectorySubagent = {
+    id: string;
+    sessionId: string;
+    cwd: string;
+    label?: string;
+    role?: string;
+    mode: "background" | "foreground";
+    state: SubagentStatus["state"];
+    startedAt?: number;
+    finishedAt?: number;
+    attempts?: number;
+    error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+    worktree?: {
+        readonly path: string;
+        readonly branch: string;
+    };
+    request: Readonly<SubagentRunRequest>;
+    tools: readonly string[];
+    toolDefinitions?: readonly {
+        readonly name: string;
+        readonly description: string;
+    }[];
+    model?: AgentAttemptSummary["setup"]["model"];
+    progress?: SubagentProgress;
+    attempt?: AgentAttemptSummary;
+    result?: JsonValue | TrajectorySubagentArtifact;
+    failure?: {
+        readonly code: string;
+        readonly message: string;
+    } | TrajectorySubagentArtifact;
+    transcript: readonly unknown[];
+};
+export type TrajectorySubagentMetadata = Omit<TrajectorySubagent, "transcript"> & {
+    transcript: TrajectoryTranscriptMetadata;
+};
+export type TrajectoryTranscriptRequest = {
+    readonly runId?: string;
+    readonly agentId?: string;
+    readonly subagentId?: string;
+    readonly revision?: number;
+};
+export type TrajectorySubagentSessionResolver = (subagentId: string) => WorkflowAgentSessionReference | undefined;
+export type TrajectoryTranscriptResult = {
+    readonly status: TrajectoryTranscriptStatus;
+    readonly revision: number;
+    readonly entries: readonly unknown[];
+    readonly bytes?: number;
+    readonly error?: string;
+};
+export type TrajectoryTranscriptLoader = (request: Readonly<TrajectoryTranscriptRequest>) => Promise<TrajectoryTranscriptResult>;
+export type TrajectoryRunMetadataLoader = () => Promise<readonly TrajectoryRunMetadata[]>;
+export type TrajectorySubagentMetadataLoader = () => Promise<readonly TrajectorySubagentMetadata[]>;
+export type TrajectoryPublisherMetadata = {
+    readonly runs: readonly TrajectoryRunMetadata[];
+    readonly subagents: readonly TrajectorySubagentMetadata[];
+};
+export type TrajectoryPublisherMetadataLoader = () => Promise<TrajectoryPublisherMetadata>;
+export type TrajectorySubagentLoader = () => Promise<readonly TrajectorySubagent[]>;
+export type { TrajectoryAction, TrajectoryTarget } from "./trajectory-contracts.js";
+export { isTrajectoryAction, isTrajectoryTarget, trajectoryActionError } from "./trajectory-contracts.js";
+export type TrajectoryActionRequest = {
+    action: TrajectoryAction;
+    target: TrajectoryTarget;
+    name?: string;
+    payload?: unknown;
+};
+export type TrajectoryActionResult = {
+    readonly id: string;
+    readonly state: "running";
+};
+export type TrajectoryActionHandler = (request: Readonly<TrajectoryActionRequest>) => Promise<void> | Promise<TrajectoryActionResult | undefined>;
+export type TrajectoryRunLoader = () => Promise<readonly TrajectoryRun[]>;
+export type TrajectoryPublisherInput = {
+    cwd: string;
+    sessionId: string;
+    port?: number;
+    themes: boolean;
+    loadRuns: TrajectoryRunLoader;
+    loadSubagents: TrajectorySubagentLoader;
+    loadMetadata: TrajectoryPublisherMetadataLoader;
+    loadTranscript?: TrajectoryTranscriptLoader;
+    handleAction: TrajectoryActionHandler;
+};
+export declare function applySystemPrompts(run: PersistedRun, prompts: readonly EffectiveSystemPrompt[]): PersistedRun;
+export declare function applyToolDescriptions(run: PersistedRun, catalog: ReadonlyMap<string, string>): PersistedRun;
+export declare function withPiToolDescriptions(run: PersistedRun): PersistedRun;
+export declare function withPiToolDescriptionsForTools(tools: readonly string[], cwd: string): readonly {
+    readonly name: string;
+    readonly description: string;
+}[];
+export declare function withResolvedAttemptResources(attempt: AgentAttemptSummary, cwd: string): Promise<AgentAttemptSummary>;
+export declare function withResolvedResources(run: PersistedRun, cwd: string): Promise<PersistedRun>;
+export declare function loadTrajectoryRuns(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): Promise<readonly TrajectoryRun[]>;
+export declare function createTrajectoryRunLoader(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): TrajectoryRunLoader;
+export declare function createTrajectoryRunMetadataLoader(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): TrajectoryRunMetadataLoader;
+export declare function createTrajectorySubagentMetadataLoader(cwd: string, sessionId: string, agentDir: string, overlay?: (subagent: TrajectorySubagent) => TrajectorySubagent): TrajectorySubagentMetadataLoader;
+export declare function createTrajectoryTranscriptLoader(cwd: string, sessionId: string, home: string | undefined, agentDir: string, resolveSubagentSession?: TrajectorySubagentSessionResolver): TrajectoryTranscriptLoader;
+export declare function createTrajectorySubagentLoader(cwd: string, sessionId: string, agentDir: string, overlay?: (subagent: TrajectorySubagent) => TrajectorySubagent, includeTranscript?: boolean): TrajectorySubagentLoader;