@fitchmultz/pi-subagents 0.49.0 → 0.50.0

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

@@ -1,220 +0,0 @@
-import * as path from "node:path";
-import type { ReadonlyDeep } from "type-fest";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import type {
-  RunnerSubagentStep,
-  AsyncStatus,
-  ModelAttempt,
-  TokenUsage,
-} from "../../shared/types.ts";
-import type { RunSingleStepResult } from "./runner-contract.ts";
-
-export function pendingRunnerStep(task: ReadonlyDeep<RunnerSubagentStep>): RunnerStatusStep {
-  return {
-    agent: task.agent,
-    phase: task.phase,
-    label: task.label,
-    outputName: task.outputName,
-    structured: task.structured,
-    status: "pending",
-    ...(task.sessionFile !== undefined && task.sessionFile.length > 0
-      ? { sessionFile: task.sessionFile }
-      : {}),
-    skills: task.skills?.slice(),
-    model: task.model,
-    thinking: task.thinking,
-    attemptedModels: pendingModelCandidates(task),
-    recentTools: [],
-    recentOutput: [],
-  };
-}
-
-function pendingModelCandidates(task: ReadonlyDeep<RunnerSubagentStep>): string[] | undefined {
-  const candidates = task.modelCandidates;
-  if (candidates !== undefined && candidates.length > 0) {
-    return [...candidates];
-  }
-  if (task.model !== undefined && task.model.length > 0) {
-    return [task.model];
-  }
-  return;
-}
-
-export function tokenUsageFromAttempts(
-  attempts: readonly ReadonlyDeep<ModelAttempt>[] | undefined,
-): TokenUsage | null {
-  if (!attempts || attempts.length === 0) {
-    return null;
-  }
-  let input = 0;
-  let output = 0;
-  for (const attempt of attempts) {
-    input += attempt.usage?.input ?? 0;
-    output += attempt.usage?.output ?? 0;
-  }
-  const total = input + output;
-  return total > 0 ? { input, output, total } : null;
-}
-
-export function appendRecentStepOutput(step: RunnerStatusStep, lines: readonly string[]): void {
-  const nonEmpty = lines.filter((line) => line.trim().length > 0);
-  if (nonEmpty.length === 0) {
-    return;
-  }
-  step.recentOutput ??= [];
-  step.recentOutput.push(...nonEmpty);
-  if (step.recentOutput.length > 50) {
-    step.recentOutput.splice(0, step.recentOutput.length - 50);
-  }
-}
-
-export function clearStepCurrentActivity(step: RunnerStatusStep): void {
-  step.currentTool = undefined;
-  step.currentToolArgs = undefined;
-  step.currentToolStartedAt = undefined;
-  step.currentPath = undefined;
-}
-
-export function resetStepLiveDetail(step: RunnerStatusStep): void {
-  clearStepCurrentActivity(step);
-  step.recentTools = [];
-  step.recentOutput = [];
-}
-
-export function markStepPaused(step: RunnerStatusStep, now: number): void {
-  step.status = "paused";
-  step.activityState = undefined;
-  clearStepCurrentActivity(step);
-  step.startedAt ??= now;
-  step.endedAt = now;
-  step.durationMs = now - step.startedAt;
-  step.lastActivityAt = now;
-  step.exitCode = 0;
-}
-
-export type RunnerStatusStep = Omit<
-  NonNullable<AsyncStatus["steps"]>[number],
-  "recentTools" | "recentOutput"
-> & {
-  exitCode?: number | null;
-  recentTools?: Array<{ readonly tool: string; readonly args: string; readonly endMs: number }>;
-  recentOutput?: string[];
-};
-
-export type RunnerStatusPayload = Omit<
-  AsyncStatus,
-  "steps" | "parallelGroups" | "pid" | "cwd" | "currentStep" | "chainStepCount" | "lastUpdate"
-> & {
-  pid: number;
-  cwd: string;
-  currentStep: number;
-  chainStepCount: number;
-  parallelGroups: Array<{ start: number; count: number; stepIndex: number }>;
-  steps: RunnerStatusStep[];
-  lastUpdate: number;
-  artifactsDir?: string;
-  shareUrl?: string;
-  gistUrl?: string;
-  shareError?: string;
-};
-
-export function runnerResultStatus(
-  result: ReadonlyDeep<RunSingleStepResult>,
-): RunnerStatusStep["status"] {
-  if (result.interrupted === true) {
-    return "paused";
-  }
-  if (result.exitCode !== 0) {
-    return "failed";
-  }
-  return result.acceptance?.status === "blocked" ? "blocked" : "complete";
-}
-
-export function runnerResultEvent(result: ReadonlyDeep<RunSingleStepResult>): string {
-  const status = runnerResultStatus(result);
-  return status === "complete" ? "subagent.step.completed" : `subagent.step.${status}`;
-}
-
-interface StepStart {
-  readonly asyncDir: string;
-  readonly sequential?: boolean;
-  readonly resetTiming?: boolean;
-  readonly index: number;
-}
-
-/** Mutates only the live step owned by this status boundary; callers publish after transition. */
-export function startRunnerStep(
-  statusPayload: RunnerStatusPayload,
-  task: ReadonlyDeep<RunnerSubagentStep>,
-  input: StepStart,
-): number {
-  const startedAt = Date.now();
-  const step = statusPayload.steps[input.index];
-  statusPayload.currentStep = input.index;
-  step.status = "running";
-  step.activityState = undefined;
-  resetStepLiveDetail(step);
-  step.startedAt = startedAt;
-  if (input.sequential === true) {
-    statusPayload.activityState = undefined;
-    step.skills = task.skills?.slice();
-  } else {
-    step.error = undefined;
-  }
-  if (input.resetTiming === true) {
-    step.endedAt = undefined;
-    step.durationMs = undefined;
-  }
-  step.lastActivityAt = startedAt;
-  statusPayload.outputFile = path.join(input.asyncDir, `output-${input.index}.log`);
-  statusPayload.lastActivityAt = startedAt;
-  statusPayload.lastUpdate = startedAt;
-  return startedAt;
-}
-
-interface StepFinish {
-  readonly startedAt: number;
-  readonly sequential?: boolean;
-  readonly index: number;
-}
-
-export function finishRunnerStep(
-  statusPayload: RunnerStatusPayload,
-  result: ReadonlyDeep<RunSingleStepResult>,
-  input: StepFinish,
-): number {
-  const endedAt = Date.now();
-  const step = statusPayload.steps[input.index];
-  Object.assign(step, {
-    status: runnerResultStatus(result),
-    endedAt,
-    durationMs: endedAt - input.startedAt,
-    exitCode: result.exitCode,
-    agentProcessExit: result.agentProcessExit,
-    model: result.model,
-    thinking: resolveEffectiveThinking(result.model, step.thinking),
-    attemptedModels: result.attemptedModels,
-    modelAttempts: result.modelAttempts,
-    error: result.error,
-    structuredOutput: result.structuredOutput,
-    structuredOutputPath: result.structuredOutputPath,
-    structuredOutputSchemaPath: result.structuredOutputSchemaPath,
-    acceptance: result.acceptance,
-    resourceLimitExceeded: result.resourceLimitExceeded,
-  });
-  clearStepCurrentActivity(step);
-  const tokens = tokenUsageFromAttempts(result.modelAttempts);
-  if (tokens !== null || input.sequential !== true) {
-    step.tokens = tokens ?? undefined;
-    statusPayload.totalTokens = statusPayload.steps.reduce(
-      (total, candidate) => ({
-        input: total.input + (candidate.tokens?.input ?? 0),
-        output: total.output + (candidate.tokens?.output ?? 0),
-        total: total.total + (candidate.tokens?.total ?? 0),
-      }),
-      { input: 0, output: 0, total: 0 },
-    );
-  }
-  statusPayload.lastUpdate = endedAt;
-  return endedAt;
-}

package/src/runs/background/runner-step-output.ts

@@ -1,156 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ReadonlyDeep } from "type-fest";
-import type { AcceptanceLedger, RunnerSubagentStep } from "../../shared/types.ts";
-import {
-  cleanupSingleOutputFile,
-  finalizeSingleOutput,
-  formatConsumedOutputReference,
-  formatSavedOutputReference,
-  type resolveSingleOutput,
-} from "../shared/single-output.ts";
-import {
-  formatUnconfirmedFinalizationOutput,
-  type resolveExecutionOutcome,
-} from "../shared/acceptance.ts";
-import type { RunSingleStepResult, SingleStepContext } from "./runner-contract.ts";
-
-interface OutputState {
-  readonly output: string;
-  readonly acceptance?: AcceptanceLedger;
-  readonly resolvedOutput: ReturnType<typeof resolveSingleOutput>;
-  readonly outcome: ReturnType<typeof resolveExecutionOutcome>;
-  readonly attemptNotes: readonly string[];
-}
-
-function decorateOutput(input: ReadonlyDeep<OutputState>): string {
-  let output = input.output;
-  const { acceptance, resolvedOutput, outcome } = input;
-  if (acceptance?.unconfirmedOutput !== undefined) {
-    const saved = resolvedOutput.savedPath;
-    const auditOutput =
-      saved !== undefined && saved.length > 0 && !resolvedOutput.writtenSnapshot
-        ? output
-        : acceptance.unconfirmedOutput;
-    output = formatUnconfirmedFinalizationOutput(auditOutput);
-  }
-  if (outcome.timedOut === true) {
-    const reason = outcome.error ?? "Timed out.";
-    const partial = output.trim();
-    output =
-      partial.length > 0 && partial !== reason
-        ? `${reason}\n\nPartial output before timeout:\n${partial}`
-        : reason;
-  }
-  return output;
-}
-
-function relocateOutput(
-  ctx: ReadonlyDeep<SingleStepContext>,
-  savedPath: string | undefined,
-  cleanup: ReadonlyDeep<ReturnType<typeof cleanupSingleOutputFile>>,
-): string | undefined {
-  const worktree = ctx.worktreePath;
-  if (
-    worktree === undefined ||
-    worktree.length === 0 ||
-    savedPath === undefined ||
-    savedPath.length === 0 ||
-    (cleanup !== undefined && cleanup.action !== "skipped")
-  ) {
-    return savedPath;
-  }
-  const relative = path.relative(worktree, savedPath);
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    return savedPath;
-  }
-  const destination = path.join(
-    path.dirname(ctx.outputFile),
-    "outputs",
-    String(ctx.flatIndex),
-    path.basename(savedPath),
-  );
-  fs.mkdirSync(path.dirname(destination), { recursive: true });
-  fs.copyFileSync(savedPath, destination);
-  return destination;
-}
-
-function outputReference(
-  savedPath: string | undefined,
-  output: string,
-  cleanup: ReturnType<typeof cleanupSingleOutputFile>,
-): ReturnType<typeof formatSavedOutputReference> | undefined {
-  if (savedPath === undefined || savedPath.length === 0) {
-    return;
-  }
-  return cleanup
-    ? formatConsumedOutputReference(savedPath, output, cleanup)
-    : formatSavedOutputReference(savedPath, output);
-}
-
-/** Consumes eligible default output or preserves it outside a worktree before that worktree is removed. */
-export function publishStepOutput(
-  step: ReadonlyDeep<RunnerSubagentStep>,
-  ctx: ReadonlyDeep<SingleStepContext>,
-  state: ReadonlyDeep<OutputState>,
-): Readonly<{
-  output: string;
-  displayOutput: string;
-  savedPath?: string;
-  cleanup: ReturnType<typeof cleanupSingleOutputFile>;
-  reference: ReturnType<typeof formatSavedOutputReference> | undefined;
-}> {
-  const output = decorateOutput(state);
-  const exitCode = state.outcome.exitCode ?? 1;
-  const originalPath = state.resolvedOutput.savedPath;
-  const shouldConsume =
-    exitCode === 0 &&
-    state.outcome.interrupted !== true &&
-    originalPath !== undefined &&
-    originalPath.length > 0 &&
-    step.outputMode !== "file-only" &&
-    step.outputPathFromAgentDefault === true;
-  const cleanup = shouldConsume ? cleanupSingleOutputFile(originalPath, output) : undefined;
-  const savedPath = relocateOutput(ctx, originalPath, cleanup);
-  const reference = outputReference(savedPath, state.resolvedOutput.fullOutput, cleanup);
-  const displayOutput = finalizeSingleOutput({
-    fullOutput:
-      state.attemptNotes.length > 0
-        ? `${state.attemptNotes.join("\n")}\n\n${output}`.trim()
-        : output,
-    outputPath: step.outputPath,
-    outputMode: step.outputMode,
-    exitCode,
-    savedPath,
-    outputReference: reference,
-    saveError: state.resolvedOutput.saveError,
-    cleanup,
-  }).displayOutput;
-  return { output, displayOutput, savedPath, cleanup, reference };
-}
-
-export function stepOutputFields(
-  step: ReadonlyDeep<RunnerSubagentStep>,
-  published: ReadonlyDeep<ReturnType<typeof publishStepOutput>>,
-  input: ReadonlyDeep<{ acceptance?: AcceptanceLedger; initialOutput: string; saveError?: string }>,
-): Pick<
-  RunSingleStepResult,
-  | "finalOutput"
-  | "initialOutput"
-  | "outputMode"
-  | "outputReference"
-  | "outputCleanup"
-  | "outputSaveError"
-  | "savedOutputPath"
-> {
-  const cleanup = published.cleanup;
-  return {
-    finalOutput: step.outputMode === "file-only" ? published.displayOutput : published.output,
-    initialOutput: input.acceptance?.finalization ? input.initialOutput : undefined,
-    outputMode: step.outputMode ?? "inline",
-    outputReference: published.reference,
-    outputCleanup: cleanup,
-    outputSaveError: input.saveError,
-    savedOutputPath: cleanup && cleanup.action !== "skipped" ? undefined : published.savedPath,
-  };
-}

package/src/runs/background/runner-step-record.ts

@@ -1,76 +0,0 @@
-import * as fs from "node:fs";
-import type { ReadonlyDeep } from "type-fest";
-import type { ArtifactPaths, ModelAttempt } from "../../shared/types.ts";
-import { saveQuestionContract } from "../shared/supervisor-questions.ts";
-import type { RunSingleStepResult } from "./runner-contract.ts";
-import type { StepAttempt } from "./runner-attempt-output.ts";
-
-export function nativeResultFields(
-  execution: ReadonlyDeep<StepAttempt>,
-  attempts: readonly ReadonlyDeep<ModelAttempt>[],
-): Pick<
-  RunSingleStepResult,
-  | "accounting"
-  | "nativeSessionId"
-  | "terminalLeafId"
-  | "terminalEntryId"
-  | "auditPath"
-  | "auditSaveError"
-  | "agentProcessExit"
-> {
-  return {
-    accounting:
-      attempts.find((attempt) => attempt.accounting?.state === "incomplete")?.accounting ??
-      execution.accounting,
-    nativeSessionId: execution.nativeSessionId,
-    terminalLeafId: execution.terminalLeafId,
-    terminalEntryId: execution.terminalEntryId,
-    auditPath: execution.auditPath,
-    auditSaveError: execution.auditSaveError,
-    agentProcessExit: execution.agentProcessExit,
-  };
-}
-
-/** Publishes immutable completed-step evidence after output preservation is finished. */
-export function saveStepRecord(
-  result: ReadonlyDeep<RunSingleStepResult>,
-  input: Readonly<{ runId: string; flatIndex: number; task: string; fullOutput: string }>,
-  paths: Readonly<ArtifactPaths> | undefined,
-): void {
-  if (result.task === undefined || result.usage === undefined) {
-    throw new Error("Completed step evidence requires task and usage.");
-  }
-  if (paths) {
-    fs.writeFileSync(paths.outputPath, input.fullOutput, "utf-8");
-    fs.writeFileSync(
-      paths.metadataPath,
-      JSON.stringify(
-        {
-          runId: input.runId,
-          agent: result.agent,
-          task: input.task,
-          exitCode: result.exitCode,
-          interrupted: result.interrupted,
-          agentProcessExit: result.agentProcessExit,
-          error: result.error,
-          acceptance: result.acceptance,
-          initialOutput: result.initialOutput,
-          usage: result.usage,
-          model: result.model,
-          attemptedModels: result.attemptedModels,
-          modelAttempts: result.modelAttempts,
-          resourceLimitExceeded: result.resourceLimitExceeded,
-          skills: result.skills,
-          timestamp: Date.now(),
-        },
-        null,
-        2,
-      ),
-      "utf-8",
-    );
-  }
-  saveQuestionContract(input.runId, input.flatIndex, {
-    result: { ...result, task: result.task, usage: result.usage, finalOutput: result.finalOutput },
-    updatedAt: Date.now(),
-  });
-}

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

@@ -1,150 +0,0 @@
-import type { ReadonlyDeep } from "type-fest";
-import { findLatestSessionFile } from "../../shared/utils.ts";
-import { runModelAttempts, sumAttemptUsage } from "../shared/model-fallback.ts";
-import { recordRun } from "../shared/run-history.ts";
-import { resolveExecutionOutcome, type evaluateRunAcceptance } from "../shared/acceptance.ts";
-import type { RunnerSubagentStep } from "../../shared/types.ts";
-import { RunnerAttempt } from "./runner-attempt.ts";
-import { RunnerFinalization } from "./runner-finalization.ts";
-import type { StepAttempt } from "./runner-attempt-output.ts";
-import type { RunSingleStepResult, SingleStepContext } from "./runner-contract.ts";
-import { prepareRunnerStep, type PreparedRunnerStep } from "./runner-prepare-step.ts";
-import { publishStepOutput, stepOutputFields } from "./runner-step-output.ts";
-import { nativeResultFields, saveStepRecord } from "./runner-step-record.ts";
-
-interface StepExecution {
-  readonly runner: RunnerAttempt;
-  readonly finalization: RunnerFinalization;
-  readonly initial: StepAttempt;
-  readonly attemptedModels: readonly string[];
-  readonly attemptNotes: readonly string[];
-  readonly acceptance: Awaited<ReturnType<typeof evaluateRunAcceptance>> | undefined;
-  readonly outcome: ReturnType<typeof resolveExecutionOutcome>;
-  readonly sessionFile?: string;
-}
-
-async function executePreparedStep(
-  prepared: PreparedRunnerStep,
-  ctx: ReadonlyDeep<SingleStepContext>,
-): Promise<StepExecution> {
-  const {
-    step,
-    interruptSignal,
-    verificationSignal,
-    structuredRuntime,
-    sessionDir,
-    sessionEnabled,
-  } = prepared;
-  const runner = new RunnerAttempt(step, ctx, {
-    interruptSignal,
-    verificationSignal,
-    effectiveStructuredOutput: structuredRuntime,
-    sessionEnabled,
-    sessionDir,
-  });
-  const candidates = step.modelCandidates;
-  const series = await runModelAttempts({
-    candidates: candidates !== undefined && candidates.length > 0 ? candidates : [step.model],
-    signal: verificationSignal,
-    runAttempt: (model) => runner.run(prepared.task, model),
-  });
-  const sessionFile =
-    step.sessionFile ??
-    (sessionDir !== undefined && sessionDir.length > 0
-      ? (findLatestSessionFile(sessionDir) ?? undefined)
-      : undefined);
-  const finalization = new RunnerFinalization(step, runner, series.result, {
-    sessionFile,
-    cwd: step.cwd ?? ctx.cwd,
-    signal: verificationSignal,
-    structuredRuntime,
-    modelAttempts: series.modelAttempts,
-  });
-  const acceptance = await finalization.evaluate();
-  const outcome = finalization.includePreviousFailure(
-    resolveExecutionOutcome({
-      result: finalization.execution,
-      acceptance,
-      signal: ctx.signal,
-      interruptSignal,
-    }),
-  );
-  return {
-    runner,
-    finalization,
-    initial: series.result,
-    attemptedModels: series.attemptedModels,
-    attemptNotes: series.notes,
-    acceptance,
-    outcome,
-    sessionFile,
-  };
-}
-
-/** Runs fallback attempts, acceptance review and output preservation in that order. */
-export async function runSingleStep(
-  input: RunnerSubagentStep,
-  ctx: ReadonlyDeep<SingleStepContext>,
-): Promise<RunSingleStepResult> {
-  const startedAt = Date.now();
-  if (ctx.signal?.aborted === true) {
-    return { agent: input.agent, output: "", exitCode: 1, error: "Subagent cancelled." };
-  }
-  const prepared = prepareRunnerStep(input, ctx);
-  const execution = await executePreparedStep(prepared, ctx);
-  const { initial, finalization, runner, attemptedModels, outcome, acceptance, sessionFile } =
-    execution;
-  const { step } = prepared;
-  const published = publishStepOutput(step, ctx, {
-    output: finalization.output,
-    acceptance,
-    resolvedOutput: finalization.resolvedOutput,
-    outcome,
-    attemptNotes: execution.attemptNotes,
-  });
-  const exitCode = outcome.exitCode ?? 1;
-  const usage = sumAttemptUsage(finalization.modelAttempts);
-  const progressSummary = {
-    toolCount: runner.toolCount,
-    tokens: usage.input + usage.output,
-    durationMs: Date.now() - startedAt,
-  };
-  const result: RunSingleStepResult = {
-    ...nativeResultFields(finalization.execution, finalization.modelAttempts),
-    agent: step.agent,
-    output: published.displayOutput,
-    exitCode,
-    error: outcome.error,
-    usage,
-    timedOut: outcome.timedOut,
-    task: step.task,
-    skills: step.skills,
-    ...stepOutputFields(step, published, {
-      acceptance,
-      initialOutput: finalization.initialOutput,
-      saveError: finalization.resolvedOutput.saveError,
-    }),
-    toolCalls: runner.toolCalls.length > 0 ? runner.toolCalls : undefined,
-    progressSummary,
-    sessionFile,
-    intercomTarget: ctx.childIntercomTarget,
-    model: initial.model,
-    attemptedModels: attemptedModels.length > 0 ? [...attemptedModels] : undefined,
-    modelAttempts: finalization.modelAttempts,
-    artifactPaths: prepared.artifactPaths,
-    interrupted: outcome.interrupted,
-    completionGuardTriggered: initial.completionGuardTriggered,
-    structuredOutput: finalization.structuredOutput,
-    structuredOutputPath: prepared.structuredRuntime?.outputPath,
-    structuredOutputSchemaPath: prepared.structuredRuntime?.schemaPath,
-    acceptance,
-    resourceLimitExceeded: outcome.resourceLimitExceeded,
-  };
-  recordRun(step.agent, step.task, exitCode, progressSummary.durationMs);
-  saveStepRecord(
-    result,
-    { runId: ctx.id, flatIndex: ctx.flatIndex, task: prepared.task, fullOutput: published.output },
-    prepared.artifactPaths,
-  );
-  return result;
-}