@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/shared/workflow-graph.ts

@@ -1,422 +0,0 @@
-import { isDynamicParallelStep, isParallelStep } from "../../shared/settings.ts";
-import type {
-  ChainStep,
-  SequentialStep,
-  DynamicParallelStep,
-  ParallelStep,
-} from "../../shared/types/workflow.ts";
-import type {
-  ReadonlyInput,
-  SingleResult,
-  SubagentRunMode,
-  WorkflowGraphNode,
-  WorkflowGraphSnapshot,
-  WorkflowNodeStatus,
-  OwnedRun,
-  ReadonlyAsyncStatus,
-} from "../../shared/types.ts";
-
-/** Pending fanouts keep their own slot until their actual children are known. */
-export function workflowAgentNodes(
-  graph: ReadonlyInput<WorkflowGraphSnapshot>,
-): ReadonlyInput<WorkflowGraphNode>[] {
-  return graph.nodes.flatMap((node) => {
-    if ((node.children?.length ?? 0) > 0) {
-      return node.children ?? [];
-    }
-    if (
-      node.kind === "dynamic-parallel-group" &&
-      node.status !== "completed" &&
-      node.status !== "complete"
-    ) {
-      return [node];
-    }
-    return node.children ?? [node];
-  });
-}
-
-export function workflowChildren(
-  children: OwnedRun["children"],
-  graph: WorkflowGraphSnapshot | undefined,
-): OwnedRun["children"] {
-  if (
-    !graph ||
-    (graph.mode !== "chain" && !children.some((child) => (child.workflowNodeId ?? "") !== ""))
-  ) {
-    return children;
-  }
-  const result: OwnedRun["children"][number][] = [];
-  for (const [index, node] of workflowAgentNodes(graph).entries()) {
-    const declared = children.find((child) => child.workflowNodeId === node.id);
-    result.push({
-      ...declared,
-      index,
-      workflowNodeId: node.id,
-      agent: node.agent ?? declared?.agent ?? "unknown",
-      ...(node.itemKey !== undefined ? { label: node.label } : {}),
-    });
-  }
-  return result;
-}
-
-/** Admit saved node identity only when it agrees with the actual child slots. */
-export function savedWorkflowNodes(
-  status: ReadonlyAsyncStatus | null | undefined,
-): readonly WorkflowGraphNode[] | undefined {
-  if (!status?.workflowGraph || status.workflowGraph.runId !== status.runId) {
-    return;
-  }
-  const nodes = workflowAgentNodes(status.workflowGraph);
-  if (
-    nodes.length !== status.steps?.length ||
-    new Set(nodes.map((node) => node.id)).size !== nodes.length
-  ) {
-    return;
-  }
-  if (
-    nodes.some(
-      (node, index) =>
-        node.id === "" ||
-        ((node.agent ?? "") !== "" && node.agent !== status.steps?.[index]?.agent),
-    )
-  ) {
-    return;
-  }
-  return nodes;
-}
-
-export interface WorkflowGraphBuildInput {
-  readonly runId: string;
-  readonly mode?: SubagentRunMode;
-  readonly steps: ReadonlyInput<ChainStep[]>;
-  readonly results?: ReadonlyInput<
-    Array<
-      Pick<
-        SingleResult,
-        "exitCode" | "detached" | "interrupted" | "timedOut" | "error" | "acceptance"
-      >
-    >
-  >;
-  readonly currentFlatIndex?: number;
-  readonly currentStepIndex?: number;
-  readonly stepStatuses?: readonly { readonly status?: string; readonly error?: string }[];
-  readonly dynamicChildren?: Readonly<Record<number, readonly DynamicChild[]>>;
-  readonly dynamicGroupStatuses?: Readonly<
-    Record<
-      number,
-      {
-        readonly status: WorkflowNodeStatus;
-        readonly error?: string;
-        readonly acceptance?: ReadonlyInput<SingleResult["acceptance"]>;
-      }
-    >
-  >;
-}
-interface DynamicChild {
-  readonly agent: string;
-  readonly label?: string;
-  readonly flatIndex: number;
-  readonly itemKey: string;
-  readonly outputName?: string;
-  readonly structured?: boolean;
-  readonly error?: string;
-}
-type ResultStatusInput = ReadonlyInput<
-  Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "timedOut" | "acceptance">
->;
-
-function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undefined {
-  switch (status) {
-    case "complete":
-    case "completed":
-      return "completed";
-    case "running":
-      return "running";
-    case "failed":
-      return "failed";
-    case "paused":
-      return "paused";
-    case "blocked":
-      return "blocked";
-    case "detached":
-      return "detached";
-    case "timed-out":
-      return "timed-out";
-    case "pending":
-      return "pending";
-    case undefined:
-      return undefined;
-    default:
-      return undefined;
-  }
-}
-
-function resultStatus(result: ResultStatusInput | undefined): WorkflowNodeStatus | undefined {
-  if (!result) {
-    return undefined;
-  }
-  if (result.detached === true) {
-    return "detached";
-  }
-  if (result.timedOut === true) {
-    return "timed-out";
-  }
-  if (result.interrupted === true) {
-    return "paused";
-  }
-  if (result.exitCode !== 0) {
-    return "failed";
-  }
-  return result.acceptance?.status === "blocked" ? "blocked" : "completed";
-}
-
-function summarizeParallelStatuses(statuses: readonly WorkflowNodeStatus[]): WorkflowNodeStatus {
-  for (const priority of [
-    "running",
-    "failed",
-    "timed-out",
-    "blocked",
-    "paused",
-    "detached",
-  ] as const) {
-    if (statuses.includes(priority)) {
-      return priority;
-    }
-  }
-  if (statuses.length > 0 && statuses.every((status) => status === "completed")) {
-    return "completed";
-  }
-  return statuses.includes("completed") ? "running" : "pending";
-}
-
-function firstLabel(...labels: readonly (string | undefined)[]): string {
-  return (
-    labels
-      .slice(0, -1)
-      .find((label) => (label?.trim().length ?? 0) > 0)
-      ?.trim() ??
-    labels.at(-1) ??
-    ""
-  );
-}
-
-function agentLabel(label: string | undefined, agent: string, fallback: string): string {
-  const trimmed = label?.trim() ?? "";
-  if (trimmed.length > 0) {
-    return trimmed;
-  }
-  return agent.length > 0 ? agent : fallback;
-}
-
-/** Owns graph assembly, phase membership, and flat-index assignment during a single snapshot. */
-class GraphBuilder {
-  private readonly nodes: WorkflowGraphNode[] = [];
-  private readonly phases: Array<{ title: string; nodeIds: string[] }> = [];
-  private flatIndex = 0;
-  private currentNodeId: string | undefined;
-  private readonly input: WorkflowGraphBuildInput;
-  constructor(input: WorkflowGraphBuildInput) {
-    this.input = input;
-  }
-
-  private status(index: number): WorkflowNodeStatus {
-    return (
-      normalizeStatus(this.input.stepStatuses?.[index]?.status) ??
-      resultStatus(this.input.results?.[index]) ??
-      (this.input.currentFlatIndex === index ? "running" : "pending")
-    );
-  }
-
-  private addPhase(phase: string | undefined, nodeId: string): void {
-    if (phase === undefined || phase.length === 0) {
-      return;
-    }
-    let group = this.phases.find((candidate) => candidate.title === phase);
-    if (!group) {
-      group = { title: phase, nodeIds: [] };
-      this.phases.push(group);
-    }
-    group.nodeIds.push(nodeId);
-  }
-
-  private observations(
-    index: number,
-    fallbackError?: string,
-  ): Pick<WorkflowGraphNode, "acceptanceStatus" | "error"> {
-    return {
-      acceptanceStatus: this.input.results?.[index]?.acceptance?.status,
-      error:
-        this.input.stepStatuses?.[index]?.error ??
-        this.input.results?.[index]?.error ??
-        fallbackError,
-    };
-  }
-
-  private trackChild(child: ReadonlyInput<WorkflowGraphNode>): void {
-    this.addPhase(child.phase, child.id);
-    if (child.status === "running" || this.input.currentFlatIndex === child.flatIndex) {
-      this.currentNodeId = child.id;
-    }
-  }
-
-  private markCurrentGroup(stepIndex: number, groupId: string): void {
-    if (this.input.currentStepIndex === stepIndex && this.currentNodeId === undefined) {
-      this.currentNodeId = groupId;
-    }
-  }
-
-  private addParallel(step: ReadonlyInput<ParallelStep>, stepIndex: number): void {
-    const groupId = `step-${stepIndex}`;
-    const children = step.parallel.map((task, taskIndex): WorkflowGraphNode => {
-      const index = this.flatIndex++;
-      const child: WorkflowGraphNode = {
-        id: `step-${stepIndex}-agent-${taskIndex}`,
-        kind: "agent",
-        agent: task.agent,
-        phase: task.phase,
-        label: agentLabel(task.label, task.agent, `Agent ${taskIndex + 1}`),
-        status: this.status(index),
-        flatIndex: index,
-        stepIndex,
-        outputName: task.as,
-        structured: Boolean(task.outputSchema),
-        ...this.observations(index),
-      };
-      this.trackChild(child);
-      return child;
-    });
-    this.markCurrentGroup(stepIndex, groupId);
-    this.nodes.push({
-      id: groupId,
-      kind: "parallel-group",
-      label:
-        step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-      status: summarizeParallelStatuses(children.map((child) => child.status)),
-      stepIndex,
-      children,
-    });
-  }
-
-  private dynamicChild(
-    step: ReadonlyInput<DynamicParallelStep>,
-    task: DynamicChild,
-    stepIndex: number,
-  ): WorkflowGraphNode {
-    return {
-      id: `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`,
-      kind: "agent",
-      agent: task.agent,
-      phase: step.parallel.phase ?? step.phase,
-      label: firstLabel(task.label, step.parallel.label, `${task.agent} ${task.itemKey}`),
-      status: this.status(task.flatIndex),
-      flatIndex: task.flatIndex,
-      stepIndex,
-      itemKey: task.itemKey,
-      outputName: task.outputName,
-      structured: task.structured,
-      ...this.observations(task.flatIndex, task.error),
-    };
-  }
-
-  private dynamicStatus(
-    children: readonly WorkflowGraphNode[],
-    stepIndex: number,
-  ): WorkflowNodeStatus {
-    const override = this.input.dynamicGroupStatuses?.[stepIndex];
-    const emptyStatus = this.input.currentStepIndex === stepIndex ? "running" : "pending";
-    return (
-      override?.status ??
-      (children.length > 0
-        ? summarizeParallelStatuses(children.map((child) => child.status))
-        : emptyStatus)
-    );
-  }
-
-  private addDynamic(step: ReadonlyInput<DynamicParallelStep>, stepIndex: number): void {
-    const groupId = `step-${stepIndex}`;
-    const materialized = this.input.dynamicChildren?.[stepIndex] ?? [];
-    const override = this.input.dynamicGroupStatuses?.[stepIndex];
-    const children = materialized.map((task) => {
-      const child = this.dynamicChild(step, task, stepIndex);
-      this.trackChild(child);
-      return child;
-    });
-    const status = this.dynamicStatus(children, stepIndex);
-    this.markCurrentGroup(stepIndex, groupId);
-    this.nodes.push({
-      id: groupId,
-      kind: "dynamic-parallel-group",
-      label: firstLabel(step.label, step.parallel.label, `Dynamic fanout (${step.collect.as})`),
-      status,
-      stepIndex,
-      outputName: step.collect.as,
-      structured: Boolean(step.collect.outputSchema),
-      acceptanceStatus: override?.acceptance?.status,
-      error: override?.error,
-      dynamic: {
-        sourceOutput: step.expand.from.output,
-        sourcePath: step.expand.from.path,
-        itemName: step.expand.item ?? "item",
-        maxItems: step.expand.maxItems,
-        collectAs: step.collect.as,
-      },
-      children,
-    });
-    if (materialized.length > 0) {
-      this.flatIndex = Math.max(
-        this.flatIndex,
-        ...materialized.map((child) => child.flatIndex + 1),
-      );
-    }
-  }
-
-  private addSequential(step: ReadonlyInput<SequentialStep>, stepIndex: number): void {
-    const index = this.flatIndex++;
-    const status = this.status(index);
-    const id = `step-${stepIndex}`;
-    this.nodes.push({
-      id,
-      kind: "step",
-      agent: step.agent,
-      phase: step.phase,
-      label: agentLabel(step.label, step.agent, `Step ${stepIndex + 1}`),
-      status,
-      flatIndex: index,
-      stepIndex,
-      outputName: step.as,
-      structured: Boolean(step.outputSchema),
-      ...this.observations(index),
-    });
-    this.addPhase(step.phase, id);
-    if (
-      status === "running" ||
-      this.input.currentFlatIndex === index ||
-      this.input.currentStepIndex === stepIndex
-    ) {
-      this.currentNodeId = id;
-    }
-  }
-
-  build(): WorkflowGraphSnapshot {
-    for (const [stepIndex, step] of this.input.steps.entries()) {
-      if (isParallelStep(step)) {
-        this.addParallel(step, stepIndex);
-      } else if (isDynamicParallelStep(step)) {
-        this.addDynamic(step, stepIndex);
-      } else {
-        this.addSequential(step, stepIndex);
-      }
-    }
-    return {
-      runId: this.input.runId,
-      mode: this.input.mode ?? "chain",
-      phases: this.phases,
-      nodes: this.nodes,
-      currentNodeId: this.currentNodeId,
-    };
-  }
-}
-
-export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): WorkflowGraphSnapshot {
-  return new GraphBuilder(input).build();
-}

package/src/runs/shared/workflow-policy.ts

@@ -1,260 +0,0 @@
-import { errorMessage } from "../../shared/unknown.ts";
-import { mapConcurrent } from "../../shared/concurrency.ts";
-import type { DynamicParallelStep } from "../../shared/types/workflow.ts";
-import type {
-  AcceptanceLedger,
-  ArtifactPaths,
-  ChainOutputMap,
-  ChainOutputMapEntry,
-  ReadonlyInput,
-} from "../../shared/types.ts";
-import { outputEntryFromResult } from "./chain-outputs.ts";
-import {
-  collectDynamicResults,
-  validateDynamicCollection,
-  type DynamicCollectedResult,
-  type DynamicMaterializedItem,
-} from "./dynamic-fanout.ts";
-import {
-  aggregateParallelOutputs,
-  FAIL_FAST_REASON,
-  type ParallelTaskResult,
-} from "./parallel-utils.ts";
-
-export interface WorkflowOutcome extends ParallelTaskResult {
-  interrupted?: boolean;
-  detached?: boolean;
-  timedOut?: boolean;
-  acceptance?: AcceptanceLedger;
-  structuredOutput?: unknown;
-  artifactPaths?: ArtifactPaths;
-  savedOutputPath?: string;
-}
-export type ParallelStopReason =
-  | "cancelled"
-  | "interrupted"
-  | "fail-fast"
-  | "detached"
-  | "timed-out";
-type ChildOutcome = ReadonlyInput<
-  Pick<WorkflowOutcome, "exitCode" | "interrupted" | "detached" | "timedOut" | "acceptance">
->;
-type WorkflowStepStatus = "completed" | "failed" | "blocked" | "paused" | "detached" | "timed-out";
-
-export function workflowChildSucceeded(result: ChildOutcome): boolean {
-  return (
-    result.exitCode === 0 &&
-    result.interrupted !== true &&
-    result.detached !== true &&
-    result.timedOut !== true &&
-    result.acceptance?.status !== "blocked"
-  );
-}
-
-function queuedStopReason(
-  signal: AbortSignal | undefined,
-  interruptSignal: AbortSignal | undefined,
-  stopped: ParallelStopReason | undefined,
-): ParallelStopReason | undefined {
-  if (signal?.aborted === true) {
-    return "cancelled";
-  }
-  return interruptSignal?.aborted === true ? "interrupted" : stopped;
-}
-
-function resultStopReason(result: ChildOutcome, failFast: boolean): ParallelStopReason | undefined {
-  if (result.detached === true) {
-    return "detached";
-  }
-  if (result.timedOut === true) {
-    return "timed-out";
-  }
-  if (
-    failFast &&
-    result.interrupted !== true &&
-    !childBlocked(result) &&
-    !workflowChildSucceeded(result)
-  ) {
-    return "fail-fast";
-  }
-  return undefined;
-}
-
-export async function runParallelTasks<T, R extends ChildOutcome>(input: {
-  readonly tasks: readonly ReadonlyInput<T>[];
-  readonly concurrency: number;
-  readonly failFast?: boolean;
-  readonly signal?: AbortSignal;
-  readonly interruptSignal?: AbortSignal;
-  readonly runTask: (
-    task: ReadonlyInput<T>,
-    index: number,
-    failFastSignal: AbortSignal,
-  ) => Promise<R>;
-  readonly stoppedTask: (task: ReadonlyInput<T>, index: number, reason: ParallelStopReason) => R;
-}): Promise<R[]> {
-  const failFast = new AbortController();
-  let stopped: ParallelStopReason | undefined;
-  return mapConcurrent(input.tasks, input.concurrency, async (task, index) => {
-    const reason = queuedStopReason(input.signal, input.interruptSignal, stopped);
-    if (reason !== undefined) {
-      return input.stoppedTask(task, index, reason);
-    }
-    const result = await input.runTask(task, index, failFast.signal);
-    // A selected-child stop must not skip independent siblings; whole-group stops use interruptSignal.
-    const nextStop = resultStopReason(result, input.failFast === true);
-    stopped ??= nextStop;
-    if (nextStop === "fail-fast") {
-      failFast.abort(FAIL_FAST_REASON);
-    }
-    return result;
-  });
-}
-
-function childBlocked(result: ChildOutcome): boolean {
-  return result.exitCode === 0 && result.acceptance?.status === "blocked";
-}
-interface StepInput {
-  readonly stepIndex: number;
-  readonly stepCount: number;
-  readonly results: readonly ReadonlyInput<WorkflowOutcome>[];
-  readonly outputNames?: readonly (string | undefined)[];
-  readonly previousOutput: string;
-  readonly parallel?: boolean;
-  readonly dynamic?: {
-    readonly step: ReadonlyInput<DynamicParallelStep>;
-    readonly items: readonly DynamicMaterializedItem[];
-  };
-}
-interface StepResult {
-  advance: boolean;
-  complete: boolean;
-  status: WorkflowStepStatus;
-  failedIndices: number[];
-  timedOutIndex: number;
-  interruptedIndex: number;
-  detachedIndex: number;
-  outputs: ChainOutputMap;
-  previousOutput: string;
-  collection?: DynamicCollectedResult[];
-  error?: string;
-}
-
-function summarizeStep(
-  results: readonly ReadonlyInput<WorkflowOutcome>[],
-): Pick<
-  StepResult,
-  "status" | "failedIndices" | "timedOutIndex" | "interruptedIndex" | "detachedIndex"
-> {
-  const timedOutIndex = results.findIndex((result) => result.timedOut === true);
-  const interruptedIndex = results.findIndex((result) => result.interrupted === true);
-  const detachedIndex = results.findIndex((result) => result.detached === true);
-  const failedIndices = results.flatMap((result, index) =>
-    !workflowChildSucceeded(result) &&
-    result.timedOut !== true &&
-    result.interrupted !== true &&
-    result.detached !== true &&
-    !childBlocked(result)
-      ? [index]
-      : [],
-  );
-  let status: WorkflowStepStatus = "completed";
-  if (failedIndices.length > 0) {
-    status = "failed";
-  } else if (timedOutIndex >= 0) {
-    status = "timed-out";
-  } else if (results.some(childBlocked)) {
-    status = "blocked";
-  } else if (interruptedIndex >= 0) {
-    status = "paused";
-  } else if (detachedIndex >= 0) {
-    status = "detached";
-  }
-  return { status, failedIndices, timedOutIndex, interruptedIndex, detachedIndex };
-}
-
-function collectStepOutput(input: StepInput): {
-  outputs: ChainOutputMap;
-  previousOutput: string;
-  collection?: DynamicCollectedResult[];
-} {
-  if (!input.dynamic) {
-    return {
-      outputs: {},
-      previousOutput:
-        input.parallel === true
-          ? aggregateParallelOutputs(input.results)
-          : (input.results[0]?.output ?? input.previousOutput),
-    };
-  }
-  const { step, items } = input.dynamic;
-  if (items.length !== input.results.length) {
-    throw new Error("Dynamic fanout did not complete every child.");
-  }
-  const collection = collectDynamicResults(step, items, input.results);
-  validateDynamicCollection(step.collect.outputSchema, collection);
-  const outputs: ChainOutputMap = {
-    [step.collect.as]: {
-      text: JSON.stringify(collection),
-      structured: collection,
-      agent: step.parallel.agent,
-      stepIndex: input.stepIndex,
-    },
-  };
-  const previousOutput =
-    items.length === 0
-      ? "Dynamic fanout produced 0 results."
-      : aggregateParallelOutputs(
-          input.results,
-          (index, agent) =>
-            `=== Dynamic Item ${index + 1} (${agent}, key ${items[index]?.key ?? index}) ===`,
-        );
-  return { outputs, previousOutput, collection };
-}
-
-function successfulNamedOutputs(input: StepInput): Record<string, ChainOutputMapEntry> {
-  const outputs: Record<string, ChainOutputMapEntry> = {};
-  for (const [index, result] of input.results.entries()) {
-    const name = input.outputNames?.[index];
-    if (workflowChildSucceeded(result) && name !== undefined && name.length > 0) {
-      Object.defineProperty(outputs, name, {
-        value: outputEntryFromResult(result, input.stepIndex),
-        enumerable: true,
-        writable: true,
-        configurable: true,
-      });
-    }
-  }
-  return outputs;
-}
-
-export function completeWorkflowStep(input: StepInput): StepResult {
-  const summary = summarizeStep(input.results);
-  let outputs = successfulNamedOutputs(input);
-  let status = summary.status;
-  let previousOutput = input.previousOutput;
-  let collection: DynamicCollectedResult[] | undefined;
-  let error: string | undefined;
-  if (status === "completed") {
-    try {
-      const collected = collectStepOutput(input);
-      outputs = { ...outputs, ...collected.outputs };
-      previousOutput = collected.previousOutput;
-      collection = collected.collection;
-    } catch (cause) {
-      error = errorMessage(cause);
-      status = "failed";
-    }
-  }
-  const advance = status === "completed";
-  return {
-    ...summary,
-    status,
-    advance,
-    complete: advance && input.stepIndex + 1 === input.stepCount,
-    outputs,
-    previousOutput,
-    collection,
-    error,
-  };
-}

package/src/runs/shared/worktree-contract.ts

@@ -1,29 +0,0 @@
-export interface WorktreeInfo {
-  readonly path: string;
-  readonly agentCwd: string;
-  readonly branch: string;
-  readonly index: number;
-  readonly syntheticPaths: readonly string[];
-}
-
-/** The run owns these resources; capture failure can forbid their cleanup. */
-export interface WorktreeSetup {
-  readonly cwd: string;
-  readonly worktrees: readonly WorktreeInfo[];
-  readonly baseCommit: string;
-  preserveOnCleanup?: boolean;
-  preservationReason?: string;
-}
-
-export interface WorktreeDiff {
-  readonly index: number;
-  readonly agent: string;
-  readonly branch: string;
-  readonly diffStat: string;
-  readonly filesChanged: number;
-  readonly insertions: number;
-  readonly deletions: number;
-  readonly patchPath: string;
-  readonly worktreePath?: string;
-  readonly captureError?: string;
-}