@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/runs/foreground/run-async-path.ts

@@ -1,327 +0,0 @@
-import * as path from "node:path";
-import { resolveRootSessionId } from "../../shared/session-identity.ts";
-import { toModelInfo } from "../../shared/model-info.ts";
-import { resolveStepBehavior } from "../../shared/settings.ts";
-import { normalizeSkillInput } from "../../agents/skills.ts";
-import { executeAsyncChain, executeAsyncSingle } from "../background/async-execution.ts";
-import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.ts";
-import {
-  wrapChainTasksForAgentContext,
-  wrapTaskForAgentContext,
-} from "../../shared/agent-context-policy.ts";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import {
-  type SubagentExecutionResult,
-  type AgentConfig,
-  type ChainStep,
-  type SequentialStep,
-  resolveTopLevelParallelConcurrency,
-  resolveTopLevelParallelMaxTasks,
-  resolveChildMaxSubagentDepth,
-  resolveCurrentMaxSubagentDepth,
-} from "../../shared/types.ts";
-import {
-  type ExecutionContextData,
-  type ExecutorReadDeps,
-  type TaskParam,
-  maxParallelTasksMessage,
-  resolveTopLevelOutputOverride,
-  usesAgentDefaultOutput,
-} from "./subagent-params.ts";
-import {
-  buildChainWorktreeTaskCwdError,
-  buildParallelModeError,
-  buildParallelWorktreeTaskCwdError,
-  collectChainSessionFiles,
-  findDuplicateAbsoluteParallelOutputPath,
-  findDuplicateParallelOutputPath,
-} from "./execution-input.ts";
-
-type AsyncPathDeps = Pick<ExecutorReadDeps, "pi" | "config"> & {
-  readonly state: Pick<ExecutorReadDeps["state"], "currentSessionId">;
-};
-
-type CommonLaunchOptions = Pick<
-  Parameters<typeof executeAsyncChain>[1],
-  | "ctx"
-  | "availableModels"
-  | "cwd"
-  | "maxOutput"
-  | "timeoutMs"
-  | "artifactsDir"
-  | "shareEnabled"
-  | "sessionRoot"
-  | "maxSubagentDepth"
-  | "worktreeSetupHook"
-  | "worktreeSetupHookTimeoutMs"
-  | "controlConfig"
-  | "controlIntercomTarget"
-  | "childIntercomTarget"
-  | "nestedRoute"
-  | "projectTrust"
->;
-
-/** Validate mode constraints before constructing or handing off an async launch. */
-function validateChainMode(data: ExecutionContextData): SubagentExecutionResult | undefined {
-  const { params, effectiveCwd } = data;
-  if (params.chain !== undefined && params.chain.length > 0) {
-    const error = buildChainWorktreeTaskCwdError(params.chain, effectiveCwd);
-    if (error !== undefined && error.length > 0) {
-      return {
-        content: [{ type: "text", text: error }],
-        isError: true,
-        details: { mode: "chain", results: [] },
-      };
-    }
-  }
-  return undefined;
-}
-
-function validateParallelMode(
-  data: ExecutionContextData,
-  deps: AsyncPathDeps,
-): SubagentExecutionResult | undefined {
-  const { params, effectiveCwd } = data;
-  if (params.tasks !== undefined && params.tasks.length > 0) {
-    const maxTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
-    if (params.tasks.length > maxTasks) {
-      return buildParallelModeError(maxParallelTasksMessage(maxTasks));
-    }
-    const error =
-      params.worktree === true
-        ? buildParallelWorktreeTaskCwdError(params.tasks, effectiveCwd)
-        : undefined;
-    if (error !== undefined && error.length > 0) {
-      return buildParallelModeError(error);
-    }
-  }
-  return undefined;
-}
-
-function commonLaunchOptions(data: ExecutionContextData, deps: AsyncPathDeps): CommonLaunchOptions {
-  const sessionId = deps.state.currentSessionId;
-  if (sessionId === null) {
-    throw new Error("Cannot launch an async run without an owning session.");
-  }
-  return {
-    ctx: {
-      pi: deps.pi,
-      cwd: data.ctx.cwd,
-      currentSessionId: sessionId,
-      rootSessionId: resolveRootSessionId(data.ctx.sessionManager),
-      currentModelProvider: data.ctx.model?.provider,
-      projectTrusted: data.ctx.isProjectTrusted(),
-    },
-    availableModels: data.ctx.modelRegistry.getAvailable().map(toModelInfo),
-    cwd: data.effectiveCwd,
-    maxOutput: data.params.maxOutput,
-    timeoutMs: data.foregroundTimeoutMs,
-    artifactsDir: data.artifactsEnabled ? data.artifactsDir : undefined,
-    shareEnabled: data.shareEnabled,
-    sessionRoot: data.sessionRoot,
-    maxSubagentDepth: resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth),
-    worktreeSetupHook: deps.config.worktreeSetupHook,
-    worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-    controlConfig: data.controlConfig,
-    controlIntercomTarget: data.intercomBridge.orchestratorTarget,
-    childIntercomTarget: (agent, index) => resolveSubagentIntercomTarget(data.runId, agent, index),
-    nestedRoute: data.nestedRoute,
-    projectTrust: resolveConfiguredChildProjectTrustPolicy(deps.config.projectTrust),
-  };
-}
-
-export function runAsyncPath(
-  data: ExecutionContextData,
-  deps: AsyncPathDeps,
-): SubagentExecutionResult | null {
-  const invalid = validateChainMode(data) ?? validateParallelMode(data, deps);
-  if (invalid) {
-    return invalid;
-  }
-  const common = commonLaunchOptions(data, deps);
-  const { params } = data;
-  if (params.tasks !== undefined && params.tasks.length > 0) {
-    return launchParallel(data, deps, common, params.tasks);
-  }
-  if (params.chain !== undefined && params.chain.length > 0) {
-    return launchChain(data, deps, common, params.chain);
-  }
-  if (params.agent !== undefined && params.agent.length > 0) {
-    return launchSingle(data, common, params.agent);
-  }
-  return null;
-}
-
-/** Preserve optional-property presence and agent-default output provenance for runner planning. */
-function taskOutputOptions(
-  task: TaskParam,
-  output: ReturnType<typeof resolveTopLevelOutputOverride>,
-): Pick<
-  SequentialStep,
-  | "output"
-  | "outputMode"
-  | "outputFromAgentDefault"
-  | "outputSchema"
-  | "reads"
-  | "progress"
-  | "acceptance"
-> {
-  return {
-    ...(output !== undefined ? { output } : {}),
-    ...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
-    ...(usesAgentDefaultOutput(task.output) && output !== undefined
-      ? { outputFromAgentDefault: true }
-      : {}),
-    ...(task.outputSchema !== undefined ? { outputSchema: task.outputSchema } : {}),
-    ...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
-    ...(task.progress !== undefined ? { progress: task.progress } : {}),
-    ...(task.acceptance !== undefined ? { acceptance: task.acceptance } : {}),
-  };
-}
-
-function parallelTask(
-  data: ExecutionContextData,
-  task: TaskParam,
-  profile: AgentConfig,
-  index: number,
-): SequentialStep & { readonly task: string } {
-  const output = resolveTopLevelOutputOverride({
-    requestedOutput: task.output,
-    agentDefaultOutput: profile.output,
-    artifactsDir: data.artifactsDir,
-    runId: data.runId,
-    agent: task.agent,
-    index,
-  });
-  const skill = normalizeSkillInput(task.skill);
-  return {
-    agent: task.agent,
-    task: wrapTaskForAgentContext(task.task, data.params.context, task.agent, data.agents),
-    cwd: task.cwd,
-    ...(task.model !== undefined && task.model.length > 0 ? { model: task.model } : {}),
-    ...(skill !== undefined ? { skill } : {}),
-    ...taskOutputOptions(task, output),
-  };
-}
-
-function launchParallel(
-  data: ExecutionContextData,
-  deps: AsyncPathDeps,
-  common: CommonLaunchOptions,
-  tasks: readonly TaskParam[],
-): SubagentExecutionResult {
-  const planned = tasks.map((task, index) => {
-    const profile = data.agents.find((agent) => agent.name === task.agent);
-    if (!profile) {
-      throw new Error(`Unknown agent: ${task.agent}`);
-    }
-    const step = parallelTask(data, task, profile, index);
-    return {
-      step,
-      behavior: resolveStepBehavior(profile, {
-        ...(step.output !== undefined ? { output: step.output } : {}),
-        ...(step.outputMode !== undefined ? { outputMode: step.outputMode } : {}),
-      }),
-    };
-  });
-  const parallelTasks = planned.map(({ step }) => step);
-  const behaviors = planned.map(({ behavior }) => behavior);
-  const duplicate =
-    data.params.worktree === true
-      ? findDuplicateAbsoluteParallelOutputPath({ tasks: parallelTasks, behaviors })
-      : findDuplicateParallelOutputPath({
-          tasks: parallelTasks,
-          behaviors,
-          paramsCwd: data.effectiveCwd,
-          ctxCwd: data.ctx.cwd,
-        });
-  if (duplicate !== undefined && duplicate.length > 0) {
-    return buildParallelModeError(duplicate);
-  }
-  return executeAsyncChain(data.runId, {
-    ...common,
-    agents: data.agents,
-    chain: [
-      {
-        parallel: parallelTasks,
-        concurrency: resolveTopLevelParallelConcurrency(
-          data.params.concurrency,
-          deps.config.parallel?.concurrency,
-        ),
-        worktree: data.params.worktree,
-      },
-    ],
-    resultMode: "parallel",
-    chainSkills: [],
-    sessionFilesByFlatIndex: tasks.map((_, index) => data.sessionFileForIndex(index)),
-  });
-}
-
-function launchChain(
-  data: ExecutionContextData,
-  deps: AsyncPathDeps,
-  common: CommonLaunchOptions,
-  steps: readonly ChainStep[],
-): SubagentExecutionResult {
-  const chain = wrapChainTasksForAgentContext(steps, data.params.context, data.agents);
-  return executeAsyncChain(data.runId, {
-    ...common,
-    agents: data.agents,
-    chain,
-    task: data.params.task,
-    chainDir: data.params.chainDir,
-    chainSkills: normalizeSkillInput(data.params.skill) ?? [],
-    sessionFilesByFlatIndex: collectChainSessionFiles(
-      chain,
-      data.sessionFileForIndex,
-      data.sessionFileForAgentIndex,
-      deps.config.chain?.dynamicFanout?.maxItems,
-    ),
-    dynamicFanoutMaxItems: deps.config.chain?.dynamicFanout?.maxItems,
-  });
-}
-
-function launchSingle(
-  data: ExecutionContextData,
-  common: CommonLaunchOptions,
-  agent: string,
-): SubagentExecutionResult {
-  const profile = data.agents.find((candidate) => candidate.name === agent);
-  if (!profile) {
-    return {
-      content: [{ type: "text", text: `Unknown agent: ${agent}` }],
-      isError: true,
-      details: { mode: "single", results: [] },
-    };
-  }
-  const { params } = data;
-  return executeAsyncSingle(data.runId, {
-    ...common,
-    agent,
-    agentConfig: profile,
-    task: wrapTaskForAgentContext(params.task ?? "", params.context, agent, data.agents),
-    sessionFile: data.sessionFileForIndex(0),
-    skills: normalizeSkillInput(params.skill),
-    output: resolveTopLevelOutputOverride({
-      requestedOutput: params.output,
-      agentDefaultOutput: profile.output,
-      artifactsDir: data.artifactsDir,
-      runId: data.runId,
-      agent,
-      index: 0,
-    }),
-    outputFromAgentDefault:
-      usesAgentDefaultOutput(params.output) &&
-      typeof profile.output === "string" &&
-      !path.isAbsolute(profile.output),
-    outputMode: params.outputMode ?? "inline",
-    outputSchema: params.outputSchema,
-    modelOverride: params.model,
-    maxSubagentDepth: resolveChildMaxSubagentDepth(
-      common.maxSubagentDepth,
-      profile.maxSubagentDepth,
-    ),
-    acceptance: params.acceptance,
-    progress: params.progress,
-  });
-}

package/src/runs/foreground/run-interrupt.ts

@@ -1,202 +0,0 @@
-import * as path from "node:path";
-import {
-  writeAsyncControlRequest,
-  writeAsyncInterruptRequest,
-} from "../background/async-control.ts";
-import { questionProcessAlive, readRunJson } from "../shared/supervisor-questions.ts";
-import { readStatus } from "../../shared/utils.ts";
-import { resolveOwnedRun } from "../shared/run-records.ts";
-import { buildManagementControl } from "../../shared/status-format.ts";
-import { errorMessage, isRecord } from "../../shared/unknown.ts";
-import type {
-  ReadonlySubagentState,
-  SubagentState,
-  SubagentExecutionResult,
-  ReadonlyAsyncStatus,
-} from "../../shared/types.ts";
-
-interface InterruptTarget {
-  readonly asyncId: string;
-  readonly asyncDir: string;
-}
-interface TimedTarget extends InterruptTarget {
-  readonly updatedAt: number;
-}
-function requestedTarget(state: ReadonlySubagentState, runId: string): InterruptTarget | undefined {
-  const direct = state.asyncJobs.get(runId);
-  if (direct) {
-    return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
-  }
-  const owned = resolveOwnedRun(state, runId);
-  return owned?.asyncDir !== undefined && owned.asyncDir.length > 0
-    ? { asyncId: owned.runId, asyncDir: owned.asyncDir }
-    : undefined;
-}
-function newestTrackedTarget(state: ReadonlySubagentState): TimedTarget | undefined {
-  let newest: TimedTarget | undefined;
-  for (const job of state.asyncJobs.values()) {
-    if (job.status !== "running") {
-      continue;
-    }
-    const updatedAt = job.updatedAt ?? 0;
-    if (!newest || updatedAt > newest.updatedAt) {
-      newest = { asyncId: job.asyncId, asyncDir: job.asyncDir, updatedAt };
-    }
-  }
-  return newest;
-}
-function ownedProducerAlive(run: { readonly asyncDir: string; readonly pid?: number }): boolean {
-  const status = readStatus(run.asyncDir);
-  if (status) {
-    return status.state === "running" || status.state === "queued";
-  }
-  return run.pid !== undefined && run.pid !== 0 && questionProcessAlive({ pid: run.pid });
-}
-function newestOwnedTarget(
-  state: ReadonlySubagentState,
-  tracked: TimedTarget | undefined,
-): TimedTarget | undefined {
-  let newest = tracked;
-  for (const run of state.ownedRuns?.values() ?? []) {
-    const dir = run.asyncDir;
-    if (dir === undefined || dir.length === 0 || (newest && run.startedAt <= newest.updatedAt)) {
-      continue;
-    }
-    if (ownedProducerAlive({ asyncDir: dir, pid: run.pid })) {
-      newest = { asyncId: run.runId, asyncDir: dir, updatedAt: run.startedAt };
-    }
-  }
-  return newest;
-}
-export function getAsyncInterruptTarget(
-  state: ReadonlySubagentState,
-  runId?: string,
-): InterruptTarget | undefined {
-  if (runId !== undefined && runId.length > 0) {
-    return requestedTarget(state, runId);
-  }
-  const newest = newestOwnedTarget(state, newestTrackedTarget(state));
-  return newest ? { asyncId: newest.asyncId, asyncDir: newest.asyncDir } : undefined;
-}
-function failure(text: string): SubagentExecutionResult {
-  return {
-    content: [{ type: "text", text }],
-    isError: true,
-    details: { mode: "management", results: [] },
-  };
-}
-function extendable(target: InterruptTarget): boolean {
-  const status = readStatus(target.asyncDir);
-  if (status) {
-    return (
-      status.runtimeVersion === 2 &&
-      status.state === "running" &&
-      status.timedOut !== true &&
-      (status.timeoutAt ?? 0) !== 0
-    );
-  }
-  const launch = readRunJson(path.join(target.asyncDir, "launch.json"));
-  return (
-    isRecord(launch) &&
-    launch.runtimeVersion === 2 &&
-    typeof launch.timeoutMs === "number" &&
-    Number.isFinite(launch.timeoutMs) &&
-    launch.timeoutMs > 0
-  );
-}
-export function extendAsyncTimeoutResult(
-  state: ReadonlySubagentState,
-  runId: string | undefined,
-  extendMs: number,
-): SubagentExecutionResult {
-  const target = getAsyncInterruptTarget(state, runId);
-  if (!target || !extendable(target)) {
-    return failure("No live run with an extendable timeout was found. No extension was requested.");
-  }
-  try {
-    writeAsyncControlRequest(target.asyncDir, target.asyncId, "extend", { extendMs });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Requested ${extendMs}ms more for run ${target.asyncId}. Inspect status for the owner's updated deadline.`,
-        },
-      ],
-      details: {
-        mode: "management",
-        results: [],
-        managementControl: buildManagementControl({
-          state: "live",
-          runId: target.asyncId,
-          canInterrupt: true,
-          canExtend: true,
-        }),
-      },
-    };
-  } catch (error) {
-    return failure(errorMessage(error));
-  }
-}
-function runningChild(status: ReadonlyAsyncStatus, index: number): boolean {
-  return Number.isSafeInteger(index) && index >= 0 && status.steps?.at(index)?.status === "running";
-}
-function selectedChildError(
-  status: ReadonlyAsyncStatus,
-  id: string,
-  index: number | undefined,
-): string | undefined {
-  if (index === undefined) {
-    return;
-  }
-  if (status.indexedControl !== true && (status.steps?.length ?? 0) > 1) {
-    return "This older runner does not support selected-child stop. No stop was sent; whole-run stop remains an explicit separate action.";
-  }
-  if (!runningChild(status, index)) {
-    return `Async run ${id} has no running child at index ${index}. No siblings were stopped.`;
-  }
-  return;
-}
-export function interruptAsyncRun(
-  // This control boundary owns the tracked job activity reset after publishing a stop request.
-  state: SubagentState,
-  runId: string | undefined,
-  index?: number,
-): SubagentExecutionResult | null {
-  const target = getAsyncInterruptTarget(state, runId);
-  if (!target) {
-    return null;
-  }
-  const status = readStatus(target.asyncDir);
-  if (!status || status.runId !== target.asyncId || status.state !== "running") {
-    return failure(
-      `No running async run with a matching control channel was found for '${runId ?? "current"}'.`,
-    );
-  }
-  const invalid = selectedChildError(status, target.asyncId, index);
-  if (invalid !== undefined) {
-    return failure(invalid);
-  }
-  try {
-    writeAsyncInterruptRequest(target.asyncDir, target.asyncId, index);
-    const tracked = state.asyncJobs.get(target.asyncId);
-    if (tracked) {
-      tracked.activityState = undefined;
-      tracked.updatedAt = Date.now();
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Interrupt requested for async run ${target.asyncId}${index !== undefined ? ` child ${index} only` : ""}. Agent and command exit are not yet confirmed.`,
-        },
-      ],
-      details: {
-        mode: "management",
-        results: [],
-        managementControl: buildManagementControl({ state: "live", runId: target.asyncId }),
-      },
-    };
-  } catch (error) {
-    return failure(`Failed to interrupt async run ${target.asyncId}: ${errorMessage(error)}`);
-  }
-}