@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/runs/foreground/foreground-control.ts

@@ -1,342 +0,0 @@
-import * as path from "node:path";
-import { errorMessage } from "../../shared/unknown.ts";
-import { listSupervisorQuestions, readQuestionContract } from "../shared/supervisor-questions.ts";
-import { deliverSubagentIntercomMessageEvent } from "../../intercom/result-intercom.ts";
-import { resolveSubagentRunId } from "../background/run-id-resolver.ts";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.ts";
-import { ownedRunView, resolveOwnedRun } from "../shared/run-records.ts";
-import type { SubagentExecutionResult, OwnedRun, OwnedRunView } from "../../shared/types.ts";
-import type { ExecutorReadDeps, SubagentParamsLike } from "./subagent-params.ts";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.ts";
-import {
-  resolveResumeTarget,
-  resolveNestedResumeTarget,
-  type ResumeSourceTarget,
-} from "./resume-target.ts";
-import { LIVE_ACCEPTANCE_OVERRIDE_NOTICE, resumeLiveNestedRun } from "./nested-control.ts";
-import { nudgeSubagentRun } from "./run-nudge.ts";
-import { reviveSavedSubagent, type RevivalInput, type RevivalTarget } from "./saved-revival.ts";
-import { continueQuestionSession } from "./question-continuation.ts";
-
-export { writeAsyncInterruptRequest } from "../background/async-control.ts";
-export {
-  MUTATING_MANAGEMENT_ACTIONS,
-  resolveRequestedCwd,
-  nestedResolutionScopeForExecutor,
-} from "./execution-routing.ts";
-export {
-  rememberedForegroundStatusResult,
-  resolveRememberedForegroundRun,
-} from "./foreground-memory.ts";
-export { extendAsyncTimeoutResult, interruptAsyncRun } from "./run-interrupt.ts";
-export { interruptNestedRun } from "./nested-control.ts";
-export { nudgeSubagentRun } from "./run-nudge.ts";
-export { reviveSavedSubagent } from "./saved-revival.ts";
-
-type ReadResumeInput = Readonly<Omit<RevivalInput, "deps">> & { readonly deps: ExecutorReadDeps };
-type Resolution =
-  | { readonly kind: "result"; readonly result: SubagentExecutionResult }
-  | { readonly kind: "target"; readonly target: ResumeSourceTarget };
-function failure(text: string): SubagentExecutionResult {
-  return {
-    content: [{ type: "text", text }],
-    isError: true,
-    details: { mode: "management", results: [] },
-  };
-}
-function requestedOwnedId(params: SubagentParamsLike): string | undefined {
-  const id = params.id ?? params.runId;
-  return id !== undefined && id.length > 0 && (params.dir === undefined || params.dir.length === 0)
-    ? id
-    : undefined;
-}
-export function liveLaunchOverrideNotice(params: SubagentParamsLike): string | undefined {
-  if (params.acceptance !== undefined) {
-    return LIVE_ACCEPTANCE_OVERRIDE_NOTICE;
-  }
-  return [
-    params.agent,
-    params.model,
-    params.cwd,
-    params.output,
-    params.outputMode,
-    params.outputSchema,
-    params.skill,
-    params.maxOutput,
-    params.control,
-    params.artifacts,
-    params.share,
-  ].some((value) => value !== undefined)
-    ? "Launch overrides change a newly started continuation, not this live child. No launch settings were changed."
-    : undefined;
-}
-function withLiveNotice(
-  result: SubagentExecutionResult,
-  params: SubagentParamsLike,
-): SubagentExecutionResult {
-  const notice = liveLaunchOverrideNotice(params);
-  if (notice !== undefined) {
-    result.content.push({ type: "text", text: notice });
-  }
-  return result;
-}
-function normalizedFollowUp(params: SubagentParamsLike): string {
-  return (params.message ?? params.task ?? "").trim();
-}
-function usesSession(candidate: OwnedRun, deps: ExecutorReadDeps, sessionFile: string): boolean {
-  return (
-    candidate.children.some((child) => child.sessionFile === sessionFile) ||
-    deps.state.asyncJobs.get(candidate.runId)?.sessionFile === sessionFile
-  );
-}
-function nudgeContinuation(
-  input: ReadResumeInput,
-  runId: string,
-  sessionFile: string | undefined,
-): Promise<SubagentExecutionResult> | undefined {
-  if (sessionFile === undefined || sessionFile.length === 0) {
-    return;
-  }
-  for (const candidate of input.deps.state.ownedRuns?.values() ?? []) {
-    if (candidate.runId === runId) {
-      continue;
-    }
-    if (!usesSession(candidate, input.deps, sessionFile)) {
-      continue;
-    }
-    const active = ownedRunView(candidate, input.deps.state, {
-      readConfiguration: false,
-    }).children.find((child) => child.sessionFile === sessionFile && child.state === "live");
-    if (!active) {
-      continue;
-    }
-    return nudgeSubagentRun({
-      params: {
-        ...input.params,
-        dir: undefined,
-        id: candidate.runId,
-        index: active.index,
-        message: normalizedFollowUp(input.params),
-      },
-      deps: input.deps,
-      ctx: input.ctx,
-    }).then((result) => withLiveNotice(result, input.params));
-  }
-  return;
-}
-async function resumeOwned(
-  // Owned continuation may persist a new run; deps retains the actual session mutation owner.
-  input: RevivalInput,
-  owned: OwnedRun,
-): Promise<SubagentExecutionResult> {
-  const view = ownedRunView(owned, input.deps.state);
-  if (view.children.length > 1 && input.params.index === undefined) {
-    throw new Error(
-      `Run '${owned.runId}' has ${view.children.length} children. Provide index to choose one.`,
-    );
-  }
-  const child = view.children.find((entry) => entry.index === (input.params.index ?? 0));
-  if (!child) {
-    throw new Error(`Run '${owned.runId}' has no child at index ${input.params.index ?? 0}.`);
-  }
-  if (child.state === "live") {
-    return withLiveNotice(
-      await nudgeSubagentRun({
-        params: {
-          ...input.params,
-          id: owned.runId,
-          message: normalizedFollowUp(input.params),
-        },
-        deps: input.deps,
-        ctx: input.ctx,
-      }),
-      input.params,
-    );
-  }
-  const liveContinuation = nudgeContinuation(input, owned.runId, child.sessionFile);
-  if (liveContinuation) {
-    return await liveContinuation;
-  }
-  return reviveSavedSubagent(input, ownedRevivalTarget(owned, child));
-}
-function ownedRevivalTarget(
-  owned: OwnedRun,
-  child: OwnedRunView["children"][number],
-): RevivalTarget {
-  const contract = readQuestionContract(owned.runId, child.index);
-  return {
-    ...contract,
-    runId: owned.runId,
-    agent: child.agent,
-    index: child.index,
-    source: owned.source,
-    cwd: child.launch?.cwd ?? owned.cwd,
-    sessionFile: child.sessionFile,
-    effectiveAcceptance:
-      contract?.effectiveAcceptance ?? child.result?.acceptance?.effectiveAcceptance,
-    model: child.result?.model,
-  };
-}
-function trustedSessionRoots(
-  input: ReadResumeInput,
-  parentSessionFile: string | null,
-): readonly string[] {
-  const roots: string[] = [];
-  const configured = input.deps.config.defaultSessionDir;
-  if (configured !== undefined && configured.length > 0) {
-    roots.push(path.resolve(input.deps.expandTilde(configured)));
-  }
-  if (parentSessionFile !== null && parentSessionFile.length > 0) {
-    roots.push(input.deps.getSubagentSessionRoot(parentSessionFile));
-  }
-  return roots;
-}
-function resolveRequestedRun(
-  params: SubagentParamsLike,
-  deps: ExecutorReadDeps,
-): ReturnType<typeof resolveSubagentRunId> {
-  const id = params.id ?? params.runId;
-  if (id === undefined || id.length === 0) {
-    return;
-  }
-  return resolveSubagentRunId(id, {
-    state: deps.state,
-    nested: nestedResolutionScopeForExecutor(deps),
-  });
-}
-async function resolveContinuation(
-  // Resolution includes question/owned revival, whose durable updates belong to this session owner.
-  input: RevivalInput,
-  parentSessionFile: string | null,
-): Promise<Resolution> {
-  const requested = requestedOwnedId(input.params);
-  const questions =
-    requested !== undefined
-      ? listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requested).filter(
-          (question) => question.state === "awaiting_input" || question.state === "answer_pending",
-        )
-      : [];
-  if (questions.length > 0) {
-    return { kind: "result", result: continueQuestionSession(input, questions) };
-  }
-  const owned = requested !== undefined ? resolveOwnedRun(input.deps.state, requested) : undefined;
-  if (owned) {
-    return { kind: "result", result: await resumeOwned(input, owned) };
-  }
-  const resolved = resolveRequestedRun(input.params, input.deps);
-  if (resolved?.kind !== "nested") {
-    return { kind: "target", target: resolveResumeTarget(input.params, input.deps.state) };
-  }
-  if (resolved.match.run.state === "running" || resolved.match.run.state === "queued") {
-    return {
-      kind: "result",
-      result: await resumeLiveNestedRun({
-        target: resolved,
-        message: normalizedFollowUp(input.params),
-        index: input.params.index,
-        acceptanceOverrideSupplied: input.params.acceptance !== undefined,
-        pi: input.deps.pi,
-        childSafe: nestedResolutionScopeForExecutor(input.deps) !== undefined,
-      }),
-    };
-  }
-  return {
-    kind: "target",
-    target: resolveNestedResumeTarget(resolved, trustedSessionRoots(input, parentSessionFile)),
-  };
-}
-function lookupFailure(
-  // Recovery may revive a saved question; the real dependency state remains owned, not frozen.
-  input: RevivalInput,
-  error: unknown,
-): SubagentExecutionResult {
-  const message = errorMessage(error),
-    requested = requestedOwnedId(input.params);
-  const recoverable =
-    (error instanceof Error && error.message.startsWith("Async run not found.")) ||
-    message.includes("is detached for intercom coordination");
-  if (requested !== undefined && recoverable) {
-    try {
-      const questions = listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requested);
-      if (questions.length > 0) {
-        return continueQuestionSession(input, questions);
-      }
-    } catch (questionError) {
-      return failure(errorMessage(questionError));
-    }
-  }
-  return failure(message);
-}
-async function deliverLiveContinuation(
-  input: ReadResumeInput,
-  target: Extract<ResumeSourceTarget, { readonly kind: "live" }>,
-): Promise<SubagentExecutionResult> {
-  const followUp = normalizedFollowUp(input.params);
-  const delivered = await deliverSubagentIntercomMessageEvent(
-    input.deps.pi.events,
-    target.intercomTarget,
-    `Follow-up for async run ${target.runId} (${target.agent}):\n\n${followUp}`,
-    500,
-    { source: "async-resume", runId: target.runId, agent: target.agent, index: target.index },
-  );
-  if (!delivered) {
-    return failure(
-      [
-        "Async child appears live but its intercom target is not registered.",
-        `Run: ${target.runId}`,
-        `Intercom target: ${target.intercomTarget}`,
-        `Wait for completion, then retry ${formatRunAction("resume", target.runId, { message: "..." }, nestedResolutionScopeForExecutor(input.deps) !== undefined)}.`,
-      ].join("\n"),
-    );
-  }
-  const lines = [
-    "Delivered follow-up to live async child.",
-    `Run: ${target.runId}`,
-    `Intercom target: ${target.intercomTarget}`,
-  ];
-  if (input.params.acceptance !== undefined) {
-    lines.push(LIVE_ACCEPTANCE_OVERRIDE_NOTICE);
-  }
-  return {
-    content: [{ type: "text", text: lines.join("\n") }],
-    details: {
-      mode: "management",
-      results: [],
-      managementControl: buildManagementControl({
-        state: "live",
-        runId: target.runId,
-        index: target.index,
-        intercomTarget: target.intercomTarget,
-        canNudge: true,
-        canResume: true,
-        canInterrupt: true,
-      }),
-    },
-  };
-}
-/** Pending question, owned/live continuation, then saved session revival—in that order. */
-export async function resumeAsyncRun(
-  // Resume owns durable question delivery and newly launched continuation state through its helpers.
-  input: RevivalInput,
-): Promise<SubagentExecutionResult> {
-  if (normalizedFollowUp(input.params).length === 0) {
-    return failure("action='resume' requires message.");
-  }
-  const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
-  let resolution: Resolution;
-  try {
-    resolution = await resolveContinuation(input, parentSessionFile);
-  } catch (error) {
-    return lookupFailure(input, error);
-  }
-  if (resolution.kind === "result") {
-    return resolution.result;
-  }
-  const { target } = resolution;
-  if (target.kind === "live") {
-    return deliverLiveContinuation(input, target);
-  }
-  return (
-    nudgeContinuation(input, target.runId, target.sessionFile) ?? reviveSavedSubagent(input, target)
-  );
-}

package/src/runs/foreground/foreground-memory.ts

@@ -1,132 +0,0 @@
-import { formatRunIdAmbiguity } from "../shared/run-id-ambiguity.ts";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.ts";
-import type {
-  ReadonlyForegroundResumeRun,
-  ReadonlySubagentState,
-  SubagentExecutionResult,
-} from "../../shared/types.ts";
-
-const LATEST_ALIASES = new Set(["last", "latest"]);
-export function resolveRememberedForegroundRun(
-  requested: string | undefined,
-  state: ReadonlySubagentState,
-): ReadonlyForegroundResumeRun | undefined {
-  if (requested === undefined) {
-    return;
-  }
-  const normalized = requested.trim();
-  if (normalized.length === 0) {
-    return;
-  }
-  const runs = [...(state.foregroundRuns?.values() ?? [])];
-  if (LATEST_ALIASES.has(normalized)) {
-    return runs.sort((left, right) => right.updatedAt - left.updatedAt).at(0);
-  }
-  const direct = state.foregroundRuns?.get(normalized);
-  const matches = direct ? [direct] : runs.filter((run) => run.runId.startsWith(normalized));
-  if (matches.length > 1) {
-    throw new Error(
-      formatRunIdAmbiguity(
-        "foreground",
-        normalized,
-        matches.map((run) => run.runId),
-      ),
-    );
-  }
-  return matches.at(0);
-}
-function resumeGuidance(run: ReadonlyForegroundResumeRun, childSafe: boolean): string {
-  const child = run.children.find(
-    (entry) =>
-      entry.sessionFile !== undefined &&
-      entry.sessionFile.length > 0 &&
-      entry.status !== "detached",
-  );
-  if (!child && run.children.some((entry) => entry.status === "detached")) {
-    return `Completion unconfirmed. Check ${formatRunAction("questions", run.runId, {}, childSafe)} before continuing.`;
-  }
-  if (run.children.length === 1 && child) {
-    return `Continue: ${formatRunAction("resume", run.runId, { message: "..." }, childSafe)}`;
-  }
-  if (!child) {
-    return "Revive: unavailable; no child session file was persisted.";
-  }
-  return `Continue child: ${formatRunAction("resume", run.runId, { index: child.index, message: "..." }, childSafe)}`;
-}
-function rememberedState(
-  run: ReadonlyForegroundResumeRun,
-): "completed" | "paused" | "blocked" | "failed" | "unknown" {
-  if (run.error !== undefined && run.error.length > 0) {
-    return "failed";
-  }
-  if (run.children.some((child) => child.status === "failed" || child.status === "timed-out")) {
-    return "failed";
-  }
-  if (run.children.some((child) => child.status === "blocked")) {
-    return "blocked";
-  }
-  if (run.children.some((child) => child.status === "paused")) {
-    return "paused";
-  }
-  if (run.children.some((child) => child.status === "detached")) {
-    return "unknown";
-  }
-  return run.pausedReason !== undefined && run.pausedReason.length > 0 ? "paused" : "completed";
-}
-function compact(text: string): string {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  return normalized.length > 240 ? `${normalized.slice(0, 239)}…` : normalized;
-}
-function childLine(child: ReadonlyForegroundResumeRun["children"][number]): string {
-  const parts = [`  ${child.index + 1}. ${child.agent} ${child.status}`];
-  if (child.sessionFile !== undefined && child.sessionFile.length > 0) {
-    parts.push(`session: ${child.sessionFile}`);
-  }
-  if (child.artifactPath !== undefined && child.artifactPath.length > 0) {
-    parts.push(`artifact: ${child.artifactPath}`);
-  }
-  if (child.summary !== undefined && child.summary.length > 0) {
-    parts.push(`final: ${compact(child.summary)}`);
-  }
-  return parts.join(", ");
-}
-export function rememberedForegroundStatusResult(
-  run: ReadonlyForegroundResumeRun,
-  childSafe = false,
-): SubagentExecutionResult {
-  const state = rememberedState(run);
-  const resumable = run.children.find(
-    (child) =>
-      child.sessionFile !== undefined &&
-      child.sessionFile.length > 0 &&
-      child.status !== "detached",
-  );
-  const lines = [`Run: ${run.runId}`, "State: remembered foreground", `Outcome: ${state}`];
-  if (run.error !== undefined && run.error.length > 0) {
-    lines.push(`Error: ${run.error}`);
-  } else if (state === "paused" && run.pausedReason !== undefined && run.pausedReason.length > 0) {
-    lines.push(run.pausedReason);
-  }
-  lines.push(
-    `Mode: ${run.mode}`,
-    `Updated: ${new Date(run.updatedAt).toISOString()}`,
-    `Launch cwd: ${run.cwd}`,
-    "Children:",
-    ...run.children.map(childLine),
-    resumeGuidance(run, childSafe),
-    `Status: ${formatRunAction("status", run.runId, {}, childSafe)}`,
-  );
-  return {
-    content: [{ type: "text", text: lines.join("\n") }],
-    details: {
-      mode: "management",
-      results: [],
-      managementControl: buildManagementControl({
-        state,
-        runId: run.runId,
-        index: resumable?.index,
-        canResume: resumable !== undefined,
-      }),
-    },
-  };
-}

package/src/runs/foreground/invocation-context.ts

@@ -1,88 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
-import { providerQualifiedModelId, toModelInfo } from "../../shared/model-info.ts";
-import { collectInvocationAgentNames } from "../../shared/settings.ts";
-import {
-  buildFlatAgentNameResolver,
-  invocationUsesForkContext,
-  resolveAgentContext,
-  validateForkContextModelPolicy,
-} from "../../shared/agent-context-policy.ts";
-import { resolveModelCandidate } from "../shared/model-fallback.ts";
-import type { AgentConfig, ModelInfo, SubagentExecutionResult } from "../../shared/types.ts";
-import type { ExecutorReadDeps, SubagentParamsLike } from "./subagent-params.ts";
-import { toExecutionErrorResult } from "./execution-input.ts";
-
-export interface AgentInvocation {
-  readonly agents: readonly AgentConfig[];
-  readonly discovered: readonly AgentConfig[];
-  readonly context: SubagentParamsLike["context"];
-  readonly resolveContextForAgent: (name: string | undefined) => "fresh" | "fork";
-  readonly resolveContextForIndex: (index?: number) => "fresh" | "fork";
-}
-/** Resolve profiles and fork policy without owning journals, session directories, or launch state. */
-export function discoverInvocation(
-  params: SubagentParamsLike,
-  cwd: string,
-  ctx: ExtensionContext,
-  deps: Readonly<Pick<ExecutorReadDeps, "discoverAgents">>,
-): AgentInvocation {
-  const inherited = providerQualifiedModelId(ctx.model?.provider, ctx.model?.id);
-  const discovered = deps
-    .discoverAgents(cwd, resolveExecutionAgentScope(params.agentScope), {
-      projectTrusted: ctx.isProjectTrusted(),
-    })
-    .agents.map((agent) => inheritModel(agent, inherited));
-  const context = invocationUsesForkContext(
-    params.context,
-    collectInvocationAgentNames(params),
-    discovered,
-  )
-    ? "fork"
-    : undefined;
-  const atIndex = buildFlatAgentNameResolver(params);
-  const forAgent = (name: string | undefined) =>
-    resolveAgentContext(params.context, name, discovered);
-  const agents: AgentConfig[] = [];
-  for (const agent of discovered) {
-    agents.push({ ...agent, defaultContext: forAgent(agent.name) });
-  }
-  return {
-    agents,
-    discovered,
-    context,
-    resolveContextForAgent: forAgent,
-    resolveContextForIndex: (index) => forAgent(atIndex(index ?? 0)),
-  };
-}
-function inheritModel(agent: AgentConfig, model: string | undefined): AgentConfig {
-  if (
-    (agent.model !== undefined && agent.model.length > 0) ||
-    model === undefined ||
-    model.length === 0
-  ) {
-    return agent;
-  }
-  return { ...agent, model };
-}
-export function validateInvocationForkModel(
-  params: SubagentParamsLike,
-  agents: AgentInvocation,
-  ctx: ExtensionContext,
-): SubagentExecutionResult | undefined {
-  if (agents.context !== "fork") {
-    return;
-  }
-  let available: readonly ModelInfo[];
-  try {
-    available = ctx.modelRegistry.getAvailable().map(toModelInfo);
-  } catch (error) {
-    return toExecutionErrorResult(params, error, agents.context);
-  }
-  const invalid = validateForkContextModelPolicy(params, agents.discovered, (model) =>
-    resolveModelCandidate(model, available, ctx.model?.provider),
-  );
-  return invalid !== undefined && invalid.length > 0
-    ? toExecutionErrorResult(params, new Error(invalid), agents.context)
-    : undefined;
-}