@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/runs/background/runner-attempt.ts

@@ -1,354 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ReadonlyDeep } from "type-fest";
-import type { SingleStepContext } from "./runner-contract.ts";
-import {
-  interpretAttemptOutput,
-  formatProcessExitFailure,
-  type StepAttempt,
-  type AttemptReview,
-} from "./runner-attempt-output.ts";
-import { runPiStreaming } from "./runner-streaming.ts";
-import { captureSingleOutputSnapshot } from "../shared/single-output.ts";
-import type {
-  ToolCallSummary,
-  Usage,
-  RunnerSubagentStep as SubagentStep,
-} from "../../shared/types.ts";
-import { cleanupTempDir } from "../shared/pi-args.ts";
-import { isClaudeCodeModel } from "../shared/claude-code.ts";
-import type { createStructuredOutputRuntime } from "../shared/structured-output.ts";
-import {
-  buildChildInvocation,
-  type ChildAttemptResult,
-  type NativeAttemptSegment,
-} from "../shared/child-attempt.ts";
-import { createNativeFinalization } from "../shared/native-finalization.ts";
-import { compactForegroundResult } from "../../shared/utils.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { resolveExecutionOutcome } from "../shared/acceptance.ts";
-
-function emptyUsage(): Usage {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-interface AttemptEnvironment {
-  readonly interruptSignal: AbortSignal;
-  readonly verificationSignal: AbortSignal;
-  readonly effectiveStructuredOutput?: ReturnType<typeof createStructuredOutputRuntime>;
-  readonly sessionEnabled: boolean;
-  readonly sessionDir?: string;
-}
-
-function nativeSegmentError(
-  segment: ReadonlyDeep<NativeAttemptSegment>,
-  agent: string,
-): string | undefined {
-  const state = segment.execution;
-  if (state?.error !== undefined) {
-    return state.error;
-  }
-  if (segment.event.submission.error !== undefined) {
-    return segment.event.submission.error;
-  }
-  const exitCode = state?.exitCode ?? 0;
-  if (exitCode === 0 || state?.interrupted === true) {
-    return;
-  }
-  return formatProcessExitFailure({ agent, exitCode, durationMs: segment.durationMs });
-}
-
-function nativeSegmentState(
-  segment: ReadonlyDeep<NativeAttemptSegment>,
-  error: string | undefined,
-) {
-  const {
-    exitCode = 0,
-    interrupted,
-    timedOut,
-    resourceLimitExceeded,
-    terminalFailure,
-  } = segment.execution ?? {};
-  const submissionError = segment.event.submission.error;
-  return {
-    exitCode: error !== undefined && error.length > 0 && exitCode === 0 ? 1 : exitCode,
-    interrupted,
-    timedOut,
-    resourceLimitExceeded,
-    terminalFailure:
-      (submissionError !== undefined && submissionError.length > 0) || terminalFailure,
-  };
-}
-
-export class RunnerAttempt {
-  nativeExecution: ReadonlyDeep<ChildAttemptResult> | undefined;
-  nativeSegments: readonly ReadonlyDeep<NativeAttemptSegment>[] = [];
-  toolCount = 0;
-  readonly toolCalls: ToolCallSummary[] = [];
-  private readonly eventsPath: string;
-  private readonly step: SubagentStep;
-  private readonly ctx: ReadonlyDeep<SingleStepContext>;
-  private readonly environment: ReadonlyDeep<AttemptEnvironment>;
-
-  constructor(
-    step: SubagentStep,
-    ctx: ReadonlyDeep<SingleStepContext>,
-    environment: ReadonlyDeep<AttemptEnvironment>,
-  ) {
-    this.step = step;
-    this.ctx = ctx;
-    this.environment = environment;
-    this.eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
-  }
-
-  nativeAttempt(segment: ReadonlyDeep<NativeAttemptSegment>): StepAttempt {
-    const nativeExecution = this.nativeExecution;
-    if (nativeExecution === undefined) {
-      throw new Error("Native segment requires a finalized execution.");
-    }
-    const error = nativeSegmentError(segment, this.step.agent);
-    return {
-      ...nativeExecution,
-      ...nativeSegmentState(segment, error),
-      error,
-      messages: segment.messages,
-      usage: segment.usage,
-      durationMs: segment.durationMs,
-      finalOutput: segment.event.submission.output,
-      reportSubmission: segment.event.turn > 0 ? segment.event.submission : undefined,
-      resolvedOutput: segment.event.resolvedOutput,
-      finalization: undefined,
-    };
-  }
-
-  async run(
-    prompt: string,
-    model: string | undefined,
-    review?: ReadonlyDeep<AttemptReview>,
-  ): Promise<StepAttempt> {
-    const { step, ctx } = this;
-    const { verificationSignal, effectiveStructuredOutput } = this.environment;
-    if (verificationSignal.aborted) {
-      return this.abortedAttempt(model);
-    }
-    ctx.onAttemptStart?.({ model, thinking: resolveEffectiveThinking(model, step.thinking) });
-    const structuredRuntime = review ? review.reportRuntime : effectiveStructuredOutput;
-    const outputSnapshot = review
-      ? review.outputSnapshot
-      : captureSingleOutputSnapshot(step.outputPath);
-    if (structuredRuntime) {
-      try {
-        fs.rmSync(structuredRuntime.outputPath, { force: true });
-      } catch {
-        // readStructuredOutput reports unreadable or stale output after the attempt.
-      }
-    }
-    const nativeFinalization = this.nativeFinalization(model, review, structuredRuntime);
-    let built: ReturnType<typeof buildChildInvocation>;
-    try {
-      built = this.buildInvocation(prompt, model, {
-        review,
-        structuredRuntime,
-        nativeFinalization,
-      });
-    } catch (error) {
-      if (nativeFinalization) {
-        cleanupTempDir(path.dirname(nativeFinalization.reportRuntime.schemaPath));
-      }
-      const message =
-        error instanceof Error ? error.message : "Failed to prepare child invocation.";
-      return this.failedPreparation(model, message);
-    }
-    const runResult = await this.executeInvocation(built, {
-      model,
-      review,
-      structuredRuntime,
-      nativeFinalization,
-    });
-    const adopted = this.adoptNativeRun(runResult, nativeFinalization !== undefined);
-    return interpretAttemptOutput(step, adopted.run, {
-      model,
-      review,
-      structuredRuntime,
-      outputSnapshot,
-      initialSegment: adopted.initialSegment,
-      structuredResult: built.claudeCodeInvocation !== undefined,
-    });
-  }
-
-  private abortedAttempt(model: string | undefined): StepAttempt {
-    const outcome = resolveExecutionOutcome({
-      result: { exitCode: 1 },
-      signal: this.ctx.signal,
-      interruptSignal: this.environment.interruptSignal,
-    });
-    return {
-      stderr: "",
-      messages: [],
-      usage: emptyUsage(),
-      durationMs: 0,
-      observedCompletedMutation: false,
-      finalOutput: outcome.error ?? "Interrupted. Waiting for explicit next action.",
-      ...outcome,
-      exitCode: outcome.exitCode ?? 1,
-      model,
-      terminalFailure: true,
-      resolvedOutput: { fullOutput: "" },
-    };
-  }
-
-  private nativeFinalization(
-    model: string | undefined,
-    review: ReadonlyDeep<AttemptReview> | undefined,
-    runtime: ReadonlyDeep<AttemptEnvironment["effectiveStructuredOutput"]>,
-  ): ReturnType<typeof createNativeFinalization> | undefined {
-    const acceptance = this.step.effectiveAcceptance;
-    if (
-      this.ctx.nativeFinalization !== true ||
-      review !== undefined ||
-      isClaudeCodeModel(model) ||
-      acceptance?.explicit !== true
-    ) {
-      return;
-    }
-    return createNativeFinalization(acceptance, runtime, this.step.outputPath);
-  }
-
-  private adoptNativeRun(
-    run: ReadonlyDeep<ChildAttemptResult>,
-    enabled: boolean,
-  ): Readonly<{
-    run: ReadonlyDeep<ChildAttemptResult>;
-    initialSegment?: ReadonlyDeep<NativeAttemptSegment>;
-  }> {
-    const initialSegment = enabled ? run.finalization?.at(0) : undefined;
-    if (initialSegment === undefined) {
-      return { run };
-    }
-    this.nativeExecution = run;
-    this.nativeSegments = run.finalization?.slice(1) ?? [];
-    return { run: this.nativeAttempt(initialSegment), initialSegment };
-  }
-
-  private failedPreparation(model: string | undefined, message: string): StepAttempt {
-    return {
-      stderr: message,
-      exitCode: 1,
-      messages: [],
-      usage: emptyUsage(),
-      durationMs: 0,
-      observedCompletedMutation: false,
-      model,
-      error: message,
-      finalOutput: message,
-      terminalFailure: true,
-      resolvedOutput: { fullOutput: message },
-    };
-  }
-
-  private buildInvocation(
-    prompt: string,
-    model: string | undefined,
-    input: ReadonlyDeep<{
-      review?: AttemptReview;
-      structuredRuntime?: ReturnType<typeof createStructuredOutputRuntime>;
-      nativeFinalization?: ReturnType<typeof createNativeFinalization>;
-    }>,
-  ): ReturnType<typeof buildChildInvocation> {
-    const { step, ctx } = this;
-    const { review, structuredRuntime, nativeFinalization } = input;
-    const { sessionEnabled, sessionDir } = this.environment;
-    const sessionFile = review?.sessionFile ?? step.sessionFile;
-    return buildChildInvocation({
-      task: prompt,
-      model,
-      thinking: step.thinking,
-      sessionEnabled: review ? true : sessionEnabled,
-      sessionDir: review ? undefined : sessionDir,
-      sessionFile,
-      inheritProjectContext: step.inheritProjectContext,
-      inheritSkills: step.inheritSkills,
-      tools: step.tools,
-      allowSubagents: step.allowSubagents,
-      extensions: step.extensions,
-      systemPrompt: step.systemPrompt,
-      systemPromptMode: step.systemPromptMode,
-      mcpDirectTools: step.mcpDirectTools,
-      cwd: step.cwd ?? ctx.cwd,
-      intercomSessionName: ctx.childIntercomTarget,
-      orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
-      runId: ctx.id,
-      childAgentName: step.agent,
-      childIndex: ctx.flatIndex,
-      rootSessionId: ctx.rootSessionId,
-      parentEventSink: ctx.nestedRoute?.eventSink,
-      parentControlInbox: ctx.nestedRoute?.controlInbox,
-      parentRootRunId: ctx.nestedRoute?.rootRunId,
-      parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
-      structuredOutput: structuredRuntime,
-      projectTrust: ctx.projectTrust,
-      nativeFinalization,
-    });
-  }
-
-  private async executeInvocation(
-    built: ReadonlyDeep<ReturnType<typeof buildChildInvocation>>,
-    input: ReadonlyDeep<{
-      model?: string;
-      review?: AttemptReview;
-      structuredRuntime?: ReturnType<typeof createStructuredOutputRuntime>;
-      nativeFinalization?: ReturnType<typeof createNativeFinalization>;
-    }>,
-  ): Promise<ChildAttemptResult> {
-    const { step, ctx, eventsPath } = this;
-    const { interruptSignal } = this.environment;
-    const { args, env, tempDir, claudeCodeInvocation } = built;
-    const { model, review, structuredRuntime, nativeFinalization } = input;
-    const sessionFile = review?.sessionFile ?? step.sessionFile;
-    try {
-      return await runPiStreaming(
-        {
-          args,
-          cwd: step.cwd ?? ctx.cwd,
-          env,
-          agent: step.agent,
-          model,
-          maxSubagentDepth: step.maxSubagentDepth,
-          maxExecutionTimeMs: step.maxExecutionTimeMs,
-          maxTokens: step.maxTokens,
-          interruptSignal,
-          signal: ctx.signal,
-          claudeCodeInvocation,
-          sessionFile,
-          structuredOutput: structuredRuntime,
-          reportRuntime: review?.reportRuntime,
-          nativeFinalization,
-          onEvent: (event, result, mutation) => {
-            if (event.type === "tool_execution_start") {
-              this.toolCount++;
-            }
-            if (event.type === "message_end" && event.message?.role === "assistant") {
-              this.toolCalls.push(
-                ...(compactForegroundResult({
-                  agent: step.agent,
-                  task: step.task,
-                  exitCode: 0,
-                  usage: result.usage,
-                  messages: [event.message],
-                }).toolCalls ?? []),
-              );
-            }
-            ctx.onChildEvent?.(event, mutation);
-          },
-        },
-        review ? `${ctx.outputFile}.finalization-${review.turn}.log` : ctx.outputFile,
-        { eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent },
-      );
-    } finally {
-      cleanupTempDir(tempDir);
-      if (nativeFinalization) {
-        cleanupTempDir(path.dirname(nativeFinalization.reportRuntime.schemaPath));
-      }
-    }
-  }
-}

package/src/runs/background/runner-child-executor.ts

@@ -1,232 +0,0 @@
-import * as path from "node:path";
-import type { ReadonlyDeep } from "type-fest";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { buildControlEvent } from "../shared/subagent-control.ts";
-import { flattenSteps } from "../shared/parallel-utils.ts";
-import type { RunnerSubagentStep } from "../../shared/types.ts";
-import type { ParallelStopReason } from "../shared/workflow-policy.ts";
-import type {
-  SubagentRunConfig,
-  RunSingleStepResult,
-  SingleStepContext,
-} from "./runner-contract.ts";
-import type { RunnerMonitor } from "./runner-monitor.ts";
-import type { RunnerLifecycle } from "./runner-lifecycle.ts";
-import {
-  markStepPaused,
-  startRunnerStep,
-  finishRunnerStep,
-  runnerResultEvent,
-  tokenUsageFromAttempts,
-} from "./runner-status.ts";
-import { runSingleStep } from "./runner-step.ts";
-
-export type AsyncParallelStepResult = ReadonlyDeep<RunSingleStepResult & { skipped?: boolean }>;
-
-export interface ChildRunInput {
-  readonly task: RunnerSubagentStep;
-  readonly worktreePath?: string;
-  readonly flatIndex: number;
-  readonly interruptSignal?: AbortSignal;
-  readonly sequential?: boolean;
-  readonly item?: { readonly name: string; readonly value: unknown };
-  readonly taskCwd: string;
-  readonly sessionDir?: string;
-  readonly flatStepCount: number;
-  readonly resetTiming?: boolean;
-  readonly trackSession?: boolean;
-  readonly notifyCompletionGuard?: boolean;
-  readonly beforeFinish?: (result: ReadonlyDeep<RunSingleStepResult>) => void;
-}
-
-/** Executes one scheduled child; shared workflow policy still owns scheduling and admission. */
-export class RunnerChildExecutor {
-  latestSessionFile: string | undefined;
-  private readonly config: ReadonlyDeep<SubagentRunConfig>;
-  private readonly monitor: RunnerMonitor;
-  private readonly lifecycle: RunnerLifecycle;
-  private readonly renderTask: (
-    template: string,
-    item?: Readonly<{ name: string; value: unknown }>,
-  ) => string;
-  private readonly sessionEnabled: boolean;
-
-  constructor(
-    config: ReadonlyDeep<SubagentRunConfig>,
-    monitor: RunnerMonitor,
-    lifecycle: RunnerLifecycle,
-    renderTask: (template: string, item?: Readonly<{ name: string; value: unknown }>) => string,
-  ) {
-    this.config = config;
-    this.monitor = monitor;
-    this.lifecycle = lifecycle;
-    this.renderTask = renderTask;
-    this.sessionEnabled =
-      (config.sessionDir !== undefined && config.sessionDir.length > 0) ||
-      config.share === true ||
-      flattenSteps(config.steps).some(
-        (step) => step.sessionFile !== undefined && step.sessionFile.length > 0,
-      );
-  }
-
-  async run(input: ReadonlyDeep<ChildRunInput>): Promise<AsyncParallelStepResult> {
-    const { task, flatIndex } = input;
-    const startedAt = startRunnerStep(this.monitor.statusPayload, task, {
-      asyncDir: this.config.asyncDir,
-      index: flatIndex,
-      sequential: input.sequential,
-      resetTiming: input.resetTiming,
-    });
-    this.monitor.writeStatusPayload();
-    this.append({
-      type: "subagent.step.started",
-      ts: startedAt,
-      runId: this.config.id,
-      stepIndex: flatIndex,
-      agent: task.agent,
-    });
-    const result = await runSingleStep(
-      { ...task, task: this.renderTask(task.task, input.item) },
-      this.stepContext(input),
-    );
-    this.lifecycle.register(flatIndex, undefined);
-    if (
-      input.trackSession === true &&
-      task.sessionFile !== undefined &&
-      task.sessionFile.length > 0
-    ) {
-      this.latestSessionFile = task.sessionFile;
-    }
-    // Sequential workflow outputs must be admitted before terminal step status is published.
-    input.beforeFinish?.(result);
-    this.finish(input, result, startedAt);
-    return input.sequential === true ? result : { ...result, skipped: false };
-  }
-
-  private stepContext(input: ReadonlyDeep<ChildRunInput>): SingleStepContext {
-    const { config, monitor, lifecycle } = this;
-    const index = input.flatIndex;
-    const childTarget = monitor.childTarget(index);
-    return {
-      nativeFinalization: config.runtimeVersion === 2,
-      worktreePath: input.worktreePath,
-      cwd: input.taskCwd,
-      sessionEnabled: this.sessionEnabled,
-      sessionDir: input.sessionDir,
-      artifactsDir: config.artifactsDir,
-      id: config.id,
-      flatIndex: index,
-      flatStepCount: input.flatStepCount,
-      outputFile: path.join(config.asyncDir, `output-${index}.log`),
-      childIntercomTarget: childTarget,
-      orchestratorIntercomTarget:
-        childTarget === undefined || childTarget.length === 0
-          ? undefined
-          : config.controlIntercomTarget,
-      nestedRoute: config.nestedRoute,
-      projectTrust: config.projectTrust,
-      rootSessionId: config.rootSessionId,
-      signal: lifecycle.cancellation.signal,
-      interruptSignal: input.interruptSignal,
-      registerInterrupt: (interrupt) => {
-        lifecycle.register(index, interrupt);
-      },
-      onAttemptStart: (attempt) => {
-        monitor.updateStepModel(index, attempt.model, attempt.thinking);
-      },
-      onChildEvent: (event, mutation) => {
-        monitor.updateStepFromChildEvent(index, event, mutation);
-      },
-    };
-  }
-
-  private finish(
-    input: ReadonlyDeep<ChildRunInput>,
-    result: ReadonlyDeep<RunSingleStepResult>,
-    startedAt: number,
-  ): void {
-    const endedAt = finishRunnerStep(this.monitor.statusPayload, result, {
-      index: input.flatIndex,
-      startedAt,
-      sequential: input.sequential,
-    });
-    this.monitor.writeStatusPayload();
-    this.append({
-      type: runnerResultEvent(result),
-      ts: endedAt,
-      runId: this.config.id,
-      stepIndex: input.flatIndex,
-      agent: input.task.agent,
-      exitCode: result.exitCode,
-      durationMs: endedAt - startedAt,
-      interrupted: result.interrupted,
-      agentProcessExit: result.agentProcessExit,
-      ...(input.sequential === true
-        ? { tokens: tokenUsageFromAttempts(result.modelAttempts) }
-        : {}),
-      resourceLimitExceeded: result.resourceLimitExceeded,
-    });
-    if (input.notifyCompletionGuard === true && result.completionGuardTriggered === true) {
-      this.monitor.appendControlEvent(
-        buildControlEvent({
-          from: this.monitor.statusPayload.steps[input.flatIndex].activityState,
-          to: "needs_attention",
-          runId: this.config.id,
-          agent: input.task.agent,
-          index: input.flatIndex,
-          ts: endedAt,
-          message: `${input.task.agent} completed without making edits for an implementation task`,
-          reason: "completion_guard",
-        }),
-      );
-    }
-  }
-
-  stop(
-    task: RunnerSubagentStep,
-    index: number,
-    reason: ParallelStopReason,
-  ): AsyncParallelStepResult {
-    const now = Date.now();
-    const step = this.monitor.statusPayload.steps[index];
-    const paused = reason === "interrupted";
-    const error = `Skipped due to ${reason}`;
-    const exitCode = paused ? 0 : -1;
-    if (paused) {
-      markStepPaused(step, now);
-    } else {
-      Object.assign(step, {
-        status: "failed",
-        error,
-        startedAt: now,
-        endedAt: now,
-        durationMs: 0,
-        exitCode,
-      });
-    }
-    this.monitor.statusPayload.lastUpdate = now;
-    this.monitor.writeStatusPayload();
-    this.append({
-      type: paused ? "subagent.step.paused" : "subagent.step.failed",
-      ts: now,
-      runId: this.config.id,
-      stepIndex: index,
-      agent: task.agent,
-      exitCode,
-      interrupted: paused,
-      durationMs: 0,
-    });
-    return {
-      agent: task.agent,
-      output: error,
-      error,
-      exitCode,
-      interrupted: paused,
-      skipped: true,
-    };
-  }
-
-  private append(event: ReadonlyDeep<Record<string, unknown>>): void {
-    appendJsonl(path.join(this.config.asyncDir, "events.jsonl"), JSON.stringify(event));
-  }
-}