@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/extension/delegation-bridges.ts

@@ -0,0 +1,59 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  normalizeSubagentParamsLike,
+  type createSubagentExecutor,
+} from "../runs/foreground/subagent-executor.ts";
+import type { IntercomEventBus } from "../shared/types.ts";
+import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.ts";
+import { registerSlashSubagentBridge } from "../slash/slash-bridge.ts";
+
+interface DelegationBridges {
+  readonly slash: ReturnType<typeof registerSlashSubagentBridge>;
+  readonly template: ReturnType<typeof registerPromptTemplateDelegationBridge>;
+}
+
+/** Translate the two existing event protocols into the canonical application invocation. */
+export function registerDelegationBridges(input: {
+  readonly events: IntercomEventBus;
+  readonly getContext: () => ExtensionContext | null;
+  readonly executor: Readonly<ReturnType<typeof createSubagentExecutor>>;
+}): DelegationBridges {
+  const slash = registerSlashSubagentBridge({
+    events: input.events,
+    getContext: input.getContext,
+    execute: (request) => input.executor.execute(request),
+  });
+  const template = registerPromptTemplateDelegationBridge({
+    events: input.events,
+    getContext: input.getContext,
+    execute: async ({ request, signal, ctx, onUpdate }) => {
+      const params =
+        request.tasks !== undefined && request.tasks.length > 0
+          ? {
+              tasks: request.tasks,
+              context: request.context,
+              cwd: request.cwd,
+              worktree: request.worktree,
+              async: false,
+              clarify: false,
+            }
+          : {
+              agent: request.agent,
+              task: request.task,
+              context: request.context,
+              cwd: request.cwd,
+              model: request.model,
+              async: false,
+              clarify: false,
+            };
+      return input.executor.execute({
+        toolCallId: request.requestId,
+        params: normalizeSubagentParamsLike(params),
+        signal,
+        onUpdate,
+        ctx,
+      });
+    },
+  });
+  return { slash, template };
+}

package/src/extension/doctor.ts

@@ -1,171 +1,207 @@
 import * as fs from "node:fs";
+import type { ReadonlyInput } from "../shared/types/inputs.ts";
+import { errorMessage } from "../shared/unknown.ts";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { VERSION as PI_VERSION, getPackageDir } from "@earendil-works/pi-coding-agent";
+import { VERSION as PI_SDK_VERSION, getPackageDir } from "@earendil-works/pi-coding-agent";
 import { EXTENSION_BUILD } from "./build-info.ts";
 import { discoverAgentsAll, type AgentSource } from "../agents/agents.ts";
 import { discoverAvailableSkills, type SkillSource } from "../agents/skills.ts";
 import {
-	ASYNC_DIR,
-	CHAIN_RUNS_DIR,
-	RESULTS_DIR,
-	TEMP_ROOT_DIR,
-	type ExtensionConfig,
-	type SubagentState,
-	type SubagentIntercomConnection,
+  ASYNC_DIR,
+  CHAIN_RUNS_DIR,
+  RESULTS_DIR,
+  TEMP_ROOT_DIR,
+  type ExtensionConfig,
+  type SubagentState,
+  type SubagentIntercomConnection,
 } from "../shared/types.ts";
 
 interface DoctorReportInput {
-	cwd: string;
-	nativeSessionCwd?: string;
-	config: ExtensionConfig;
-	state: SubagentState;
-	requestedSessionDir?: string;
-	currentSessionFile?: string | null;
-	currentSessionId?: string | null;
-	orchestratorTarget?: string;
-	connection?: SubagentIntercomConnection;
-	sessionError?: string;
-	expandTilde?: (value: string) => string;
-	projectTrusted?: boolean;
+  cwd: string;
+  nativeSessionCwd?: string;
+  config: ExtensionConfig;
+  state: Pick<SubagentState, "currentSessionId">;
+  requestedSessionDir?: string;
+  currentSessionFile?: string | null;
+  currentSessionId?: string | null;
+  orchestratorTarget?: string;
+  connection?: SubagentIntercomConnection;
+  sessionError?: string;
+  expandTilde?: (value: string) => string;
+  projectTrusted?: boolean;
 }
 
-const PI_PACKAGE_DIR = getPackageDir();
+const PI_SDK_RESOURCE_DIR = getPackageDir();
 const EXTENSION_MODULE = fileURLToPath(import.meta.url);
 
 function errorText(error: unknown): string {
-	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return error instanceof Error ? `${error.name}: ${error.message}` : errorMessage(error);
 }
 
 function lineFromCheck(label: string, check: () => string): string {
-	try {
-		return check();
-	} catch (error) {
-		return `- ${label}: failed — ${errorText(error)}`;
-	}
+  try {
+    return check();
+  } catch (error) {
+    return `- ${label}: failed — ${errorText(error)}`;
+  }
 }
 
 function formatExistingDirectory(label: string, dirPath: string): string {
-	try {
-		if (!fs.existsSync(dirPath)) return `- ${label}: missing (${dirPath})`;
-		const stats = fs.statSync(dirPath);
-		if (!stats.isDirectory()) throw new Error(`not a directory: ${dirPath}`);
-		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-		return `- ${label}: ok (${dirPath})`;
-	} catch (error) {
-		return `- ${label}: failed (${dirPath}) — ${errorText(error)}`;
-	}
+  try {
+    if (!fs.existsSync(dirPath)) {
+      return `- ${label}: missing (${dirPath})`;
+    }
+    const stats = fs.statSync(dirPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`not a directory: ${dirPath}`);
+    }
+    fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+    return `- ${label}: ok (${dirPath})`;
+  } catch (error) {
+    return `- ${label}: failed (${dirPath}) — ${errorText(error)}`;
+  }
 }
 
-function formatSourceCounts(counts: Record<AgentSource, number>): string {
-	return `builtin ${counts.builtin}, package ${counts.package}, user ${counts.user}, project ${counts.project}`;
+function formatSourceCounts(counts: Readonly<Record<AgentSource, number>>): string {
+  return `builtin ${counts.builtin}, package ${counts.package}, user ${counts.user}, project ${counts.project}`;
 }
 
-function formatSkillSourceCounts(skills: Array<{ source: SkillSource }>): string {
-	const counts = new Map<SkillSource, number>();
-	for (const skill of skills) counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
-	const ordered: SkillSource[] = [
-		"project",
-		"project-settings",
-		"project-package",
-		"user",
-		"user-settings",
-		"user-package",
-		"extension",
-		"builtin",
-		"unknown",
-	];
-	const parts = ordered
-		.map((source) => `${source} ${counts.get(source) ?? 0}`)
-		.filter((part) => !part.endsWith(" 0"));
-	return parts.length > 0 ? parts.join(", ") : "none";
+function formatSkillSourceCounts(skills: ReadonlyArray<{ readonly source: SkillSource }>): string {
+  const counts = new Map<SkillSource, number>();
+  for (const skill of skills) {
+    counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
+  }
+  const ordered: SkillSource[] = [
+    "project",
+    "project-settings",
+    "project-package",
+    "user",
+    "user-settings",
+    "user-package",
+    "extension",
+    "builtin",
+    "unknown",
+  ];
+  const parts = ordered
+    .map((source) => `${source} ${counts.get(source) ?? 0}`)
+    .filter((part) => !part.endsWith(" 0"));
+  return parts.length > 0 ? parts.join(", ") : "none";
 }
 
-function formatConfiguredSessionDir(input: DoctorReportInput): string {
-	if (input.requestedSessionDir) {
-		return path.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
-	}
-	if (input.config.defaultSessionDir) {
-		return path.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
-	}
-	return "not configured";
+function formatConfiguredSessionDir(input: ReadonlyInput<DoctorReportInput>): string {
+  const dir = input.requestedSessionDir ?? "";
+  const configured = dir.length > 0 ? dir : (input.config.defaultSessionDir ?? "");
+  if (configured.length > 0) {
+    return path.resolve(input.expandTilde?.(configured) ?? configured);
+  }
+  return "not configured";
 }
 
-function formatSessionLines(input: DoctorReportInput): string[] {
-	const sessionFile = input.currentSessionFile ?? null;
-	const lines = [
-		lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
-		`- current session file: ${sessionFile ?? "not available"}`,
-		`- current session dir: ${sessionFile ? path.dirname(sessionFile) : "not available"}`,
-		`- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
-	];
-	if (input.sessionError) lines.push(`- session manager: failed — ${input.sessionError}`);
-	return lines;
+function formatSessionLines(input: ReadonlyInput<DoctorReportInput>): string[] {
+  const sessionFile = input.currentSessionFile ?? null;
+  const lines = [
+    lineFromCheck(
+      "configured session dir",
+      () => `- configured session dir: ${formatConfiguredSessionDir(input)}`,
+    ),
+    `- current session file: ${sessionFile ?? "not available"}`,
+    `- current session dir: ${sessionFile !== null && sessionFile.length > 0 ? path.dirname(sessionFile) : "not available"}`,
+    `- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
+  ];
+  if (input.sessionError !== undefined && input.sessionError.length > 0) {
+    lines.push(`- session manager: failed — ${input.sessionError}`);
+  }
+  return lines;
 }
 
-function formatDiscovery(input: DoctorReportInput): string[] {
-	return [
-		lineFromCheck("agents/chains", () => {
-			const discovered = discoverAgentsAll(input.cwd, { projectTrusted: input.projectTrusted ?? true });
-			const agentCounts = {
-				builtin: discovered.builtin.length,
-				package: discovered.package.length,
-				user: discovered.user.length,
-				project: discovered.project.length,
-			};
-			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>((counts, chain) => {
-				counts[chain.source] += 1;
-				return counts;
-			}, { builtin: 0, package: 0, user: 0, project: 0 });
-			return [
-				`- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
-				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
-			].join("\n");
-		}),
-		lineFromCheck("skills", () => {
-			const skills = discoverAvailableSkills(input.cwd, { projectTrusted: input.projectTrusted ?? true });
-			return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
-		}),
-	];
+function formatDiscovery(input: ReadonlyInput<DoctorReportInput>): string[] {
+  return [
+    lineFromCheck("agents/chains", () => {
+      const discovered = discoverAgentsAll(input.cwd, {
+        projectTrusted: input.projectTrusted ?? true,
+      });
+      const agentCounts = {
+        builtin: discovered.builtin.length,
+        package: discovered.package.length,
+        user: discovered.user.length,
+        project: discovered.project.length,
+      };
+      const chainCounts = { builtin: 0, package: 0, user: 0, project: 0 };
+      for (const chain of discovered.chains) {
+        chainCounts[chain.source] += 1;
+      }
+      return [
+        `- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
+        `- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
+      ].join("\n");
+    }),
+    lineFromCheck("skills", () => {
+      const skills = discoverAvailableSkills(input.cwd, {
+        projectTrusted: input.projectTrusted ?? true,
+      });
+      return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
+    }),
+  ];
 }
 
-function formatIntercomSection(input: DoctorReportInput): string[] {
-	return [
-		`- bridge: ${input.connection ? "responding" : "unavailable (no live health response)"}`,
-		`- connection: ${input.connection?.status ?? "unknown"}${input.connection?.reason ? ` — ${input.connection.reason}` : ""}`,
-		`- broker session id: ${input.connection?.sessionId ?? "not available"}`,
-		`- orchestrator target: ${input.orchestratorTarget?.trim() || "not available"}`,
-	];
+function connectionStatus(
+  connection: Readonly<SubagentIntercomConnection> | undefined,
+  reason: string,
+): string {
+  return `${connection?.status ?? "unknown"}${reason.length > 0 ? ` — ${reason}` : ""}`;
 }
 
-export function buildDoctorReport(input: DoctorReportInput): string {
-	const lines = [
-		"Subagents doctor report",
-		"",
-		"Runtime",
-		`- Native session cwd: ${input.nativeSessionCwd ?? input.cwd}`,
-		...(input.nativeSessionCwd && input.nativeSessionCwd !== input.cwd ? [`- Requested cwd: ${input.cwd}`] : []),
-		`- Node: ${process.version}`,
-		`- process: ${process.pid} (${process.execPath})`,
-		`- loaded Pi version: ${PI_VERSION}`,
-		`- Pi package directory: ${PI_PACKAGE_DIR} (Pi resource path; may be overridden)`,
-		"- native queue contract: not verified (version alone does not identify fork patches)",
-		`- loaded pi-subagents build: ${EXTENSION_BUILD.version && EXTENSION_BUILD.sha256 ? `${EXTENSION_BUILD.version} (runtime SHA-256 ${EXTENSION_BUILD.sha256})` : "unknown (unbuilt source)"}`,
-		`- extension module: ${EXTENSION_MODULE}`,
-		"- async support: available (Node >=24)",
-		...formatSessionLines(input),
-		"",
-		"Filesystem",
-		formatExistingDirectory("temp root", TEMP_ROOT_DIR),
-		formatExistingDirectory("async runs", ASYNC_DIR),
-		formatExistingDirectory("results", RESULTS_DIR),
-		formatExistingDirectory("chain runs", CHAIN_RUNS_DIR),
-		"",
-		"Discovery",
-		...formatDiscovery(input),
-		"",
-		"Intercom",
-		...formatIntercomSection(input),
-	];
-	return lines.join("\n");
+function formatIntercomSection(input: ReadonlyInput<DoctorReportInput>): string[] {
+  const reason = input.connection?.reason ?? "";
+  const target = input.orchestratorTarget?.trim() ?? "";
+  return [
+    `- bridge: ${input.connection ? "responding" : "unavailable (no live health response)"}`,
+    `- connection: ${connectionStatus(input.connection, reason)}`,
+    `- broker session id: ${input.connection?.sessionId ?? "not available"}`,
+    `- orchestrator target: ${target.length > 0 ? target : "not available"}`,
+  ];
+}
+
+function formatBuild(): string {
+  const { version, sha256 } = EXTENSION_BUILD;
+  return version !== undefined && sha256 !== undefined && version.length > 0 && sha256.length > 0
+    ? `${version} (runtime SHA-256 ${sha256})`
+    : "unknown (unbuilt source)";
+}
+
+export function buildDoctorReport(input: ReadonlyInput<DoctorReportInput>): string {
+  const lines = [
+    "Subagents doctor report",
+    "",
+    "Runtime",
+    `- Native session cwd: ${input.nativeSessionCwd ?? input.cwd}`,
+    ...(input.nativeSessionCwd !== undefined &&
+    input.nativeSessionCwd.length > 0 &&
+    input.nativeSessionCwd !== input.cwd
+      ? [`- Requested cwd: ${input.cwd}`]
+      : []),
+    `- Node: ${process.version}`,
+    `- process: ${process.pid} (${process.execPath})`,
+    `- imported Pi SDK version: ${PI_SDK_VERSION} (not proof of the executing CLI version)`,
+    `- Pi SDK resource directory: ${PI_SDK_RESOURCE_DIR} (may be overridden; not executable provenance)`,
+    "- native queue contract: not verified (version alone does not identify fork patches)",
+    `- loaded pi-subagents build: ${formatBuild()}`,
+    `- extension module: ${EXTENSION_MODULE}`,
+    "- async support: available (Node >=24)",
+    ...formatSessionLines(input),
+    "",
+    "Filesystem",
+    formatExistingDirectory("temp root", TEMP_ROOT_DIR),
+    formatExistingDirectory("async runs", ASYNC_DIR),
+    formatExistingDirectory("results", RESULTS_DIR),
+    formatExistingDirectory("chain runs", CHAIN_RUNS_DIR),
+    "",
+    "Discovery",
+    ...formatDiscovery(input),
+    "",
+    "Intercom",
+    ...formatIntercomSection(input),
+  ];
+  return lines.join("\n");
 }

package/src/extension/everyday-schemas.ts

@@ -0,0 +1,252 @@
+import { Type } from "../shared/native-typebox.ts";
+import { DelegateAcceptance } from "./acceptance-schema.ts";
+import { HistoryQueryFields, TaskItem, requiredObject } from "./schema-overrides.ts";
+
+export const DelegateParams = Type.Object(
+  {
+    agent: TaskItem.properties.agent,
+    task: TaskItem.properties.task,
+    label: TaskItem.properties.label,
+    cwd: TaskItem.properties.cwd,
+    model: TaskItem.properties.model,
+    context: Type.Optional(
+      Type.Enum(["fresh", "fork"] as const, {
+        type: "string",
+        description: "Override the profile's context policy.",
+      }),
+    ),
+    async: Type.Optional(
+      Type.Boolean({ description: "Background by default; false waits for the result." }),
+    ),
+    worktree: Type.Optional(
+      Type.Boolean({
+        description:
+          "Isolate this writer in a Git worktree; return its patch. Requires a clean checkout.",
+      }),
+    ),
+    output: TaskItem.properties.output,
+    acceptance: Type.Optional(DelegateAcceptance),
+  },
+  { additionalProperties: false },
+);
+
+export const AgentRunsValidationParams = Type.Object(
+  {
+    action: Type.Enum(
+      [
+        "list",
+        "inspect",
+        "history",
+        "search",
+        "nudge",
+        "stop",
+        "continue",
+        "profiles",
+        "questions",
+        "answer",
+        "review",
+      ] as const,
+      { type: "string" },
+    ),
+    id: Type.Optional(Type.String({ minLength: 1, description: "Run ID or unambiguous prefix." })),
+    questionId: Type.Optional(
+      Type.String({
+        minLength: 1,
+        description: "Durable supervisor question ID for exact questions lookup or answer.",
+      }),
+    ),
+    async: Type.Optional(
+      Type.Boolean({
+        description: "Continue/answer: false waits for the actual continuation result.",
+      }),
+    ),
+    index: Type.Optional(
+      Type.Integer({ minimum: 0, description: "Child index for a multi-child run." }),
+    ),
+    message: Type.Optional(
+      Type.String({
+        minLength: 1,
+        description:
+          "Guidance, follow-up, answer, or optional parent-only review note. Review notes are not sent to the child; put actionable instructions in continue/nudge. Only continue/answer can start a saved child.",
+      }),
+    ),
+    decision: Type.Optional(
+      Type.Enum(["accepted", "needs_changes"] as const, {
+        type: "string",
+        description:
+          "Parent-only review outcome; not sent to the child. Separate from execution and runtime acceptance checks.",
+      }),
+    ),
+    offset: Type.Optional(
+      Type.Integer({
+        minimum: 0,
+        description: "List/questions offset; history is retained regardless of page size.",
+      }),
+    ),
+    limit: Type.Optional(
+      Type.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Results per list/questions/search/history page (default 20; history 100).",
+      }),
+    ),
+    ...HistoryQueryFields,
+    full: Type.Optional(
+      Type.Boolean({
+        description:
+          "Inspect only: include the full task and saved launch configuration. Default is a concise report; stored data is unchanged.",
+      }),
+    ),
+    agent: Type.Optional(
+      Type.String({
+        minLength: 1,
+        description:
+          "List/search: filter by child agent. Continue/answer: adopt this current profile, including model, thinking and fallbacks; a separate model override wins. Otherwise keep saved settings. Required for old runs without a saved profile.",
+      }),
+    ),
+    model: TaskItem.properties.model,
+    cwd: TaskItem.properties.cwd,
+    output: TaskItem.properties.output,
+    acceptance: TaskItem.properties.acceptance,
+  },
+  {
+    additionalProperties: false,
+    allOf: [
+      {
+        if: {
+          properties: {
+            action: {
+              enum: ["inspect", "history", "nudge", "stop", "continue", "answer", "review"],
+            },
+          },
+        },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("id"),
+      },
+      {
+        if: { properties: { action: { enum: ["search"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("query"),
+      },
+      {
+        if: { properties: { action: { enum: ["nudge", "continue", "answer"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("message"),
+      },
+      {
+        if: { properties: { action: { enum: ["answer"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("questionId"),
+      },
+      {
+        if: { properties: { action: { enum: ["review"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("decision"),
+      },
+      {
+        if: {
+          anyOf: [
+            requiredObject("async"),
+            requiredObject("model"),
+            requiredObject("cwd"),
+            requiredObject("output"),
+            requiredObject("acceptance"),
+          ],
+        },
+
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["continue", "answer"] } } },
+      },
+      {
+        if: requiredObject("agent"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list", "search", "continue", "answer"] } } },
+      },
+      {
+        if: requiredObject("offset"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list", "questions"] } } },
+      },
+      {
+        if: requiredObject("limit"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list", "questions", "history", "search"] } } },
+      },
+      {
+        if: requiredObject("cursor"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list", "history", "search"] } } },
+      },
+      {
+        if: requiredObject("sort"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list", "search"] } } },
+      },
+      { not: { anyOf: [requiredObject("cursor", "offset"), requiredObject("cursor", "before")] } },
+      {
+        if: { allOf: [{ properties: { action: { enum: ["search"] } } }, requiredObject("index")] },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: requiredObject("id"),
+      },
+      {
+        if: { anyOf: [requiredObject("state"), requiredObject("text")] },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["list"] } } },
+      },
+      {
+        if: requiredObject("query"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["search"] } } },
+      },
+      {
+        if: requiredObject("before"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["history"] } } },
+      },
+      {
+        if: { properties: { action: { enum: ["list"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { sort: { enum: ["attention", "newest", "oldest"] } } },
+      },
+      {
+        if: { properties: { action: { enum: ["search"] } } },
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { sort: { enum: ["relevance", "newest"] } } },
+      },
+      {
+        if: requiredObject("decision"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["review"] } } },
+      },
+      {
+        if: requiredObject("full"),
+        // JSON Schema's non-callable consequence keyword is not a Promise method.
+        // oxlint-disable-next-line unicorn/no-thenable
+        then: { properties: { action: { enum: ["inspect"] } } },
+      },
+    ],
+  },
+);
+
+export const AgentRunsParams = Type.Object(
+  { ...AgentRunsValidationParams.properties, acceptance: Type.Optional(DelegateAcceptance) },
+  { additionalProperties: false },
+);