@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/runs/shared/subagent-control.ts

@@ -1,352 +0,0 @@
-import type {
-  ActivityState,
-  ControlEvent,
-  ControlEventType,
-  ControlNotificationChannel,
-  ResolvedControlConfig,
-  ReadonlyAsyncStatus,
-} from "../../shared/types.ts";
-
-import { formatRunAction } from "../../shared/status-format.ts";
-import { readStatus } from "../../shared/utils.ts";
-import { getRunMetadataDir } from "./supervisor-questions.ts";
-
-export function isObsoleteIdleNotice(details: {
-  readonly event: ControlEvent;
-  readonly asyncDir?: string;
-}): boolean {
-  const event = details.event;
-  if (event.reason !== "idle" || event.supervisorQuestion) {
-    return false;
-  }
-  let status;
-  try {
-    status = readStatus(details.asyncDir ?? getRunMetadataDir(event.runId));
-  } catch {
-    // Without readable terminal evidence, retain the actionable notice.
-    return false;
-  }
-  if (!status || status.runId !== event.runId) {
-    return false;
-  }
-  return (
-    ["complete", "failed", "blocked", "paused"].includes(status.state) ||
-    hasTerminalChild(status, event.index)
-  );
-}
-
-function hasTerminalChild(status: ReadonlyAsyncStatus, index: number | undefined): boolean {
-  if (index === undefined) {
-    return false;
-  }
-  const child = status.steps?.[index];
-  return (
-    child !== undefined &&
-    ["complete", "completed", "failed", "blocked", "paused", "timed-out"].includes(child.status)
-  );
-}
-
-const CONTROL_EVENT_TYPES: readonly ControlEventType[] = ["needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS: readonly ControlNotificationChannel[] = [
-  "event",
-  "async",
-  "intercom",
-];
-const DEFAULT_NOTIFY_ON: readonly ControlEventType[] = ["needs_attention"];
-
-export const DEFAULT_CONTROL_CONFIG: ResolvedControlConfig = {
-  enabled: true,
-  needsAttentionAfterMs: 10 * 60_000,
-  failedToolAttemptsBeforeAttention: 3,
-  notifyOn: DEFAULT_NOTIFY_ON,
-  notifyChannels: CONTROL_NOTIFICATION_CHANNELS,
-};
-
-function parsePositiveInt(value: unknown): number | undefined {
-  if (typeof value !== "number") {
-    return undefined;
-  }
-  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
-    return undefined;
-  }
-  return value;
-}
-
-function parseControlList<T extends string>(
-  value: unknown,
-  allowed: readonly T[],
-): T[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  if (value.length === 0) {
-    return [];
-  }
-  const entries: readonly unknown[] = value;
-  const parsed = entries.filter(
-    (entry): entry is T =>
-      typeof entry === "string" && allowed.some((candidate) => candidate === entry),
-  );
-  return parsed.length > 0 ? Array.from(new Set(parsed)) : undefined;
-}
-
-export interface ControlConfigInput {
-  readonly enabled?: boolean;
-  readonly needsAttentionAfterMs?: unknown;
-  readonly failedToolAttemptsBeforeAttention?: unknown;
-  readonly notifyOn?: unknown;
-  readonly notifyChannels?: unknown;
-}
-
-function parsedControlConfig(config: ControlConfigInput | undefined) {
-  const input = config ?? {};
-  return {
-    enabled: input.enabled,
-    needsAttentionAfterMs: parsePositiveInt(input.needsAttentionAfterMs),
-    failedToolAttemptsBeforeAttention: parsePositiveInt(input.failedToolAttemptsBeforeAttention),
-    notifyOn: parseControlList(input.notifyOn, CONTROL_EVENT_TYPES),
-    notifyChannels: parseControlList(input.notifyChannels, CONTROL_NOTIFICATION_CHANNELS),
-  };
-}
-function controlThresholds(
-  global: Partial<
-    Pick<ResolvedControlConfig, "needsAttentionAfterMs" | "failedToolAttemptsBeforeAttention">
-  >,
-  override: Partial<
-    Pick<ResolvedControlConfig, "needsAttentionAfterMs" | "failedToolAttemptsBeforeAttention">
-  >,
-) {
-  return {
-    needsAttentionAfterMs:
-      override.needsAttentionAfterMs ??
-      global.needsAttentionAfterMs ??
-      DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs,
-    failedToolAttemptsBeforeAttention:
-      override.failedToolAttemptsBeforeAttention ??
-      global.failedToolAttemptsBeforeAttention ??
-      DEFAULT_CONTROL_CONFIG.failedToolAttemptsBeforeAttention,
-  };
-}
-
-export function resolveControlConfig(
-  globalConfig?: ControlConfigInput,
-  overrideConfig?: ControlConfigInput,
-): ResolvedControlConfig {
-  const global = parsedControlConfig(globalConfig);
-  const override = parsedControlConfig(overrideConfig);
-  const notifyOn = override.notifyOn ?? global.notifyOn ?? DEFAULT_CONTROL_CONFIG.notifyOn;
-  const notifyChannels =
-    override.notifyChannels ?? global.notifyChannels ?? DEFAULT_CONTROL_CONFIG.notifyChannels;
-  return {
-    enabled: override.enabled ?? global.enabled ?? DEFAULT_CONTROL_CONFIG.enabled,
-    ...controlThresholds(global, override),
-    notifyOn: [...notifyOn],
-    notifyChannels: [...notifyChannels],
-  };
-}
-
-export function deriveActivityState(input: {
-  readonly config: ResolvedControlConfig;
-  readonly startedAt: number;
-  readonly lastActivityAt?: number;
-  readonly now?: number;
-}): ActivityState | undefined {
-  if (!input.config.enabled) {
-    return undefined;
-  }
-  const now = input.now ?? Date.now();
-  const lastActivity = input.lastActivityAt ?? input.startedAt;
-  const ageMs = Math.max(0, now - lastActivity);
-  return ageMs > input.config.needsAttentionAfterMs ? "needs_attention" : undefined;
-}
-
-type ControlEventInput = Omit<ControlEvent, "type" | "ts" | "message" | "reason"> & {
-  readonly type?: ControlEventType;
-  readonly ts?: number;
-  readonly message?: string;
-  readonly reason?: ControlEvent["reason"];
-  readonly lastActivityAt?: number;
-};
-
-function controlObservation(
-  input: ControlEventInput,
-  elapsedSeconds: number | undefined,
-): string | undefined {
-  if (input.currentTool !== undefined && input.currentTool !== "") {
-    const duration =
-      input.currentToolDurationMs === undefined
-        ? ""
-        : ` for ${Math.floor(input.currentToolDurationMs / 1000)}s`;
-    const elapsed =
-      elapsedSeconds === undefined ? "" : `; no observed output/events for ${elapsedSeconds}s`;
-    return `${input.currentTool} still active${duration}${elapsed}`;
-  }
-  return elapsedSeconds === undefined ? undefined : `no observed activity for ${elapsedSeconds}s`;
-}
-function controlSignal(input: ControlEventInput): string {
-  const question = input.supervisorQuestion;
-  if (!question) {
-    return `${input.agent} needs attention`;
-  }
-  return question.state === "awaiting_input"
-    ? `Waiting for supervisor input (question ${question.questionId})`
-    : `Supervisor answer saved for question ${question.questionId}; delivery unconfirmed`;
-}
-function controlMetrics(
-  input: ControlEventInput,
-  elapsedMs: number | undefined,
-): Partial<ControlEvent> {
-  return {
-    ...(input.turns !== undefined ? { turns: input.turns } : {}),
-    ...(input.tokens !== undefined ? { tokens: input.tokens } : {}),
-    ...(input.toolCount !== undefined ? { toolCount: input.toolCount } : {}),
-    ...(input.currentToolDurationMs !== undefined
-      ? { currentToolDurationMs: input.currentToolDurationMs }
-      : {}),
-    ...(elapsedMs !== undefined ? { elapsedMs } : {}),
-  };
-}
-function controlContext(input: ControlEventInput): Partial<ControlEvent> {
-  return {
-    ...((input.currentTool ?? "") !== "" ? { currentTool: input.currentTool } : {}),
-    ...((input.currentPath ?? "") !== "" ? { currentPath: input.currentPath } : {}),
-    ...((input.recentFailureSummary ?? "") !== ""
-      ? { recentFailureSummary: input.recentFailureSummary }
-      : {}),
-    ...(input.supervisorQuestion ? { supervisorQuestion: input.supervisorQuestion } : {}),
-  };
-}
-
-function controlElapsed(input: ControlEventInput, ts: number): number | undefined {
-  return (
-    input.elapsedMs ??
-    (input.lastActivityAt !== undefined ? Math.max(0, ts - input.lastActivityAt) : undefined)
-  );
-}
-export function buildControlEvent(input: ControlEventInput): ControlEvent {
-  const ts = input.ts ?? Date.now();
-  const elapsedMs = controlElapsed(input, ts);
-  const observation = controlObservation(
-    input,
-    elapsedMs === undefined ? undefined : Math.floor(elapsedMs / 1000),
-  );
-  const message =
-    input.message ??
-    `${controlSignal(input)}${observation === undefined ? "" : ` (${observation})`}`;
-  return {
-    type: input.type ?? "needs_attention",
-    ...(input.from !== undefined ? { from: input.from } : {}),
-    to: input.to,
-    ts,
-    runId: input.runId,
-    agent: input.agent,
-    ...(input.index !== undefined ? { index: input.index } : {}),
-    message,
-    reason: input.reason ?? "idle",
-    ...controlMetrics(input, elapsedMs),
-    ...controlContext(input),
-  };
-}
-
-export { shouldNotifyControlEvent, controlNotificationKey } from "./control-event-policy.ts";
-export { claimControlNotification } from "./control-notification-owner.ts";
-
-function failureNotice(event: ControlEvent, childIntercomTarget: string | undefined): string {
-  return [
-    `Subagent failed: ${event.agent}`,
-    `Run: ${event.runId}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-    `Signal: ${event.message}`,
-    "Next: read the output artifact or session from the subagent result, then retry with a more explicit implementation prompt or handle the fix directly.",
-    childIntercomTarget !== undefined && childIntercomTarget !== ""
-      ? `Run intercom target (may be inactive): ${childIntercomTarget}`
-      : undefined,
-  ]
-    .filter((line): line is string => line !== undefined)
-    .join("\n");
-}
-
-function questionNotice(event: ControlEvent, childSafe: boolean): string[] {
-  const question = event.supervisorQuestion;
-  if (!question) {
-    return [];
-  }
-  return [
-    `Question ID: ${question.questionId}`,
-    question.state === "answer_pending"
-      ? "The saved answer has not been confirmed delivered. Inspect the child and retry the same answer; do not assume it resumed."
-      : "Answer the saved question so the child can continue.",
-    `Questions: ${formatRunAction("questions", event.runId, {}, childSafe)}`,
-    `Answer: ${formatRunAction("answer", event.runId, { questionId: question.questionId, message: question.answer ?? "..." }, childSafe)}`,
-  ];
-}
-
-function liveNotice(
-  event: ControlEvent,
-  childIntercomTarget: string | undefined,
-  childSafe: boolean,
-): string[] {
-  const nudgeCommand = formatRunAction(
-    "nudge",
-    event.runId,
-    {
-      ...(event.index !== undefined ? { index: event.index } : {}),
-      message:
-        "What are you blocked on? Reply with the smallest next step, or state the exact decision you need.",
-    },
-    childSafe,
-  );
-  const ask =
-    childIntercomTarget !== undefined && childIntercomTarget !== ""
-      ? `Ask (blocking wait only; parent must remain alive): intercom({ action: "ask", to: "${childIntercomTarget}", delivery: "steer", message: "What are you blocked on? Reply with the smallest next step, or state the exact decision you need." })`
-      : "Ask (blocking wait only): no child message route registered";
-  return [
-    event.reason === "idle" && (event.currentTool ?? "") !== ""
-      ? "Hint: Inspect command progress. A long-running tool may still be running or hung; elapsed time alone does not prove either."
-      : "Hint: Inspect status first unless the run is clearly blocked.",
-    `Nudge (preferred live coordination): ${nudgeCommand}`,
-    ask,
-  ];
-}
-
-export function formatControlNoticeMessage(
-  event: ControlEvent,
-  childIntercomTarget?: string,
-  childSafe = false,
-): string {
-  if (event.reason === "completion_guard") {
-    return failureNotice(event, childIntercomTarget);
-  }
-  return [
-    `Subagent needs attention: ${event.agent}`,
-    `Run: ${event.runId}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-    `Signal: ${event.message}`,
-    (event.recentFailureSummary ?? "") !== ""
-      ? `Recent failures: ${event.recentFailureSummary ?? ""}`
-      : undefined,
-    ...(event.supervisorQuestion
-      ? questionNotice(event, childSafe)
-      : liveNotice(event, childIntercomTarget, childSafe)),
-    `Status: ${formatRunAction("status", event.runId, {}, childSafe)}`,
-    `${childSafe ? "Interrupt" : "Stop"}: ${formatRunAction("interrupt", event.runId, {}, childSafe)}`,
-  ]
-    .filter((line): line is string => line !== undefined)
-    .join("\n");
-}
-
-export function formatControlIntercomMessage(
-  event: ControlEvent,
-  childIntercomTarget?: string,
-  childSafe = false,
-): string {
-  const statusLabel =
-    event.reason === "completion_guard" ? "subagent failed" : "subagent needs attention";
-  return [
-    statusLabel,
-    "",
-    event.reason === "completion_guard"
-      ? `${event.agent} failed in run ${event.runId}.`
-      : `${event.agent} needs attention in run ${event.runId}.`,
-    "",
-    formatControlNoticeMessage(event, childIntercomTarget, childSafe),
-  ].join("\n");
-}

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -1,119 +0,0 @@
-import * as fs from "node:fs";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { SUBAGENT_FANOUT_CHILD_ENV } from "./child-route-env.ts";
-import { setPromptSection } from "../../shared/prompt-sections.ts";
-import { loadConfig } from "../../extension/config.ts";
-import { registerChildExecutionCwd } from "./child-execution-cwd.ts";
-import {
-  STRUCTURED_OUTPUT_CAPTURE_ENV,
-  STRUCTURED_OUTPUT_SCHEMA_ENV,
-  assertJsonSchemaObject,
-} from "./structured-output.ts";
-import { registerChildStructuredTool } from "./child-structured-tool.ts";
-import { ChildNativeObservation } from "./child-native-observation.ts";
-import { stripParentOnlySubagentMessages } from "./child-context-filter.ts";
-import { nonempty } from "./child-presence.ts";
-
-const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "PI_SUBAGENT_INHERIT_PROJECT_CONTEXT";
-const SUBAGENT_INHERIT_SKILLS_ENV = "PI_SUBAGENT_INHERIT_SKILLS";
-export const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "PI_SUBAGENT_INTERCOM_SESSION_NAME";
-
-const STRUCTURED_OUTPUT_INSTRUCTIONS = [
-  "This subagent step has a strict structured output contract.",
-  "Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
-  "Do not rely on prose-only completion; if you do not call `structured_output`, the parent will fail this step.",
-].join("\n");
-
-const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
-  "You are a child subagent, not the parent orchestrator.",
-  "The parent session owns delegation, orchestration, review fanout, and follow-up worker launches.",
-  "Ignore prior parent-only orchestration instructions in inherited conversation history.",
-  "Do not propose or run subagents. Complete only your assigned role-specific task with the tools available to you.",
-  "If you need to edit files, call the actual edit/write tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
-].join("\n");
-
-const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
-  "You are a child subagent with delegation enabled for your assigned task.",
-  "You may delegate useful helper work within that task when it saves time or improves quality, using the available delegation tools.",
-  "You remain responsible for your assigned result. The original parent owns integration, review synthesis, and final delivery.",
-  "Do not broaden the assigned scope or repeat approval requests for already-authorized work.",
-  "The native allowSubagents and maxSubagentDepth settings still apply.",
-  "If you need to edit files, call the actual edit/write tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
-].join("\n");
-
-function readBooleanEnv(name: string): boolean | undefined {
-  const value = process.env[name];
-  return value === undefined ? undefined : value !== "0";
-}
-
-export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
-  registerChildExecutionCwd(pi);
-  const observation = new ChildNativeObservation();
-  pi.on("session_start", (_event, ctx) => observation.start(ctx));
-  pi.on("message_end", (event) => observation.message(event.message.role));
-  pi.on("turn_end", (_event, ctx) => observation.publish(ctx, "turn", pi));
-  pi.on("agent_settled", (_event, ctx) => observation.publish(ctx, "settled", pi));
-  const structuredOutputPath = process.env[STRUCTURED_OUTPUT_CAPTURE_ENV];
-  const structuredSchemaPath = process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
-  if (nonempty(structuredOutputPath) && nonempty(structuredSchemaPath)) {
-    const schema: unknown = JSON.parse(fs.readFileSync(structuredSchemaPath, "utf-8"));
-    assertJsonSchemaObject(schema);
-    registerChildStructuredTool(pi, {
-      schema,
-      schemaPath: structuredSchemaPath,
-      outputPath: structuredOutputPath,
-    });
-    pi.on("session_start", () => {
-      pi.setActiveTools([...new Set([...pi.getActiveTools(), "structured_output"])]);
-    });
-  }
-
-  pi.on("context", (event) => {
-    // Filtering changes the provider prefix, never the saved journal. Fanout children
-    // need their own nested calls/results on later turns and resumes, so retain tool history.
-    const messages = stripParentOnlySubagentMessages(
-      event.messages,
-      readBooleanEnv(SUBAGENT_FANOUT_CHILD_ENV) === true,
-    );
-    if (messages === undefined) {
-      return;
-    }
-    return { messages };
-  });
-
-  pi.on("before_agent_start", (event) => {
-    const intercomSessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
-    if (nonempty(intercomSessionName)) {
-      pi.setSessionName(intercomSessionName);
-    }
-
-    const inheritProjectContext = readBooleanEnv(SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV);
-    const inheritSkills = readBooleanEnv(SUBAGENT_INHERIT_SKILLS_ENV);
-    const fanoutChild = readBooleanEnv(SUBAGENT_FANOUT_CHILD_ENV);
-    if (
-      inheritProjectContext === undefined &&
-      inheritSkills === undefined &&
-      fanoutChild === undefined
-    ) {
-      return;
-    }
-    const options = event.systemPromptOptions;
-    // --no-skills/--no-context-files govern discovery. Keep explicitly selected
-    // skill bodies and context intact; never parse the rendered prompt to remove resources.
-    options.skills = options.skills.filter((skill) => skill.name !== "pi-subagents");
-    setPromptSection(
-      options,
-      "subagent_role",
-      fanoutChild === true
-        ? `${CHILD_FANOUT_BOUNDARY_INSTRUCTIONS}\n${
-            loadConfig().compactChildTools === false
-              ? "Use subagent({action:'list'}) to discover agents before delegation."
-              : "Use load_subagent({advanced:false}), then agent_runs({action:'profiles'}) to discover agents, delegate for ordinary work, and load_subagent for advanced workflows."
-          }`
-        : CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS,
-    );
-    if (nonempty(structuredOutputPath)) {
-      setPromptSection(options, "subagent_output", STRUCTURED_OUTPUT_INSTRUCTIONS);
-    }
-  });
-}

package/src/runs/shared/subagent-tool-loop-guard.ts

@@ -1,139 +0,0 @@
-import { createHash } from "node:crypto";
-import { stableStringify } from "./stable-value.ts";
-import { isRecord } from "../../shared/unknown.ts";
-
-const REPEATED_SUBAGENT_CALL_LIMIT = 5;
-const SUBAGENT_CALL_WINDOW_SIZE = REPEATED_SUBAGENT_CALL_LIMIT * 2 - 1;
-
-interface SubagentCallStart {
-  readonly callKey: string;
-  readonly toolName: unknown;
-  readonly failed?: boolean;
-  readonly toolCallId?: string;
-}
-
-interface ToolStart {
-  readonly toolCallId?: unknown;
-  readonly toolName: unknown;
-  readonly args: unknown;
-}
-interface ToolEnd {
-  readonly toolCallId?: unknown;
-  readonly toolName: unknown;
-  readonly isError: unknown;
-}
-export interface RepeatedSubagentCallGuardState {
-  readonly recentStarts: readonly boolean[];
-  readonly recentSubagentCalls: readonly SubagentCallStart[];
-  readonly recordStart: (input: ToolStart) => string | undefined;
-  readonly recordEnd: (input: ToolEnd) => string | undefined;
-}
-
-function subagentCallKey(toolName: unknown, args: unknown): string | undefined {
-  if (
-    (toolName !== "subagent" && toolName !== "delegate" && toolName !== "agent_runs") ||
-    !isRecord(args)
-  ) {
-    return;
-  }
-  try {
-    return createHash("sha256")
-      .update(`${toolName}:${stableStringify(args)}`)
-      .digest("hex");
-  } catch {
-    return;
-  }
-}
-
-/** The guard owns its bounded windows; callers only observe snapshots and record events. */
-class RepeatedCalls implements RepeatedSubagentCallGuardState {
-  private readonly starts: boolean[] = [];
-  private readonly calls: SubagentCallStart[] = [];
-  get recentStarts(): readonly boolean[] {
-    return this.starts;
-  }
-  get recentSubagentCalls(): readonly SubagentCallStart[] {
-    return this.calls;
-  }
-
-  readonly recordStart = (input: ToolStart): string | undefined => {
-    const args = input.args;
-    const listAction =
-      isRecord(args) &&
-      ((input.toolName === "subagent" && args.action === "list") ||
-        (input.toolName === "agent_runs" && args.action === "profiles"));
-    this.starts.push(listAction);
-    if (this.starts.length > SUBAGENT_CALL_WINDOW_SIZE) {
-      this.starts.shift();
-    }
-    this.recordCall(input);
-    const count = this.starts.filter(Boolean).length;
-    if (listAction && count >= REPEATED_SUBAGENT_CALL_LIMIT) {
-      const tool = input.toolName === "subagent" ? "subagent" : "agent_runs";
-      const action = tool === "subagent" ? "list" : "profiles";
-      return `Child appears stuck repeating ${tool}({ action: "${action}" }) ${count} times. Stopping to avoid a tool loop.`;
-    }
-    return;
-  };
-
-  private recordCall(input: ToolStart): void {
-    const callKey = subagentCallKey(input.toolName, input.args);
-    if (callKey !== undefined) {
-      this.calls.push({
-        callKey,
-        toolName: input.toolName,
-        toolCallId: typeof input.toolCallId === "string" ? input.toolCallId : undefined,
-      });
-      if (this.calls.length > SUBAGENT_CALL_WINDOW_SIZE) {
-        this.calls.shift();
-      }
-    }
-  }
-
-  readonly recordEnd = (input: ToolEnd): string | undefined => {
-    if (input.isError !== true) {
-      return;
-    }
-    const toolCallId = typeof input.toolCallId === "string" ? input.toolCallId : undefined;
-    const index = this.calls.findLastIndex(
-      (candidate) =>
-        candidate.toolName === input.toolName &&
-        candidate.failed === undefined &&
-        ((toolCallId ?? "") === "" ||
-          (candidate.toolCallId ?? "") === "" ||
-          candidate.toolCallId === toolCallId),
-    );
-    if (index < 0) {
-      return;
-    }
-    const entry = this.calls.at(index);
-    if (!entry) {
-      return;
-    }
-    this.calls[index] = { ...entry, failed: true };
-    const count = this.calls.filter(
-      (candidate) => candidate.failed === true && candidate.callKey === entry.callKey,
-    ).length;
-    if (count >= REPEATED_SUBAGENT_CALL_LIMIT) {
-      const tool = typeof input.toolName === "string" ? input.toolName : "tool";
-      return `Child appears stuck repeating the same failed ${tool} call ${count} times. Stopping to avoid a tool loop.`;
-    }
-    return;
-  };
-}
-
-export function createRepeatedSubagentCallGuardState(): RepeatedSubagentCallGuardState {
-  return new RepeatedCalls();
-}
-
-export function recordToolStartForSubagentLoopGuard(
-  input: ToolStart & { readonly state: RepeatedSubagentCallGuardState },
-): string | undefined {
-  return input.state.recordStart(input);
-}
-
-export function recordToolEndForSubagentLoopGuard(
-  input: ToolEnd & { readonly state: RepeatedSubagentCallGuardState },
-): string | undefined {
-  return input.state.recordEnd(input);
-}