@ian-pascoe/pi-minimal-subagents 0.5.0 → 0.6.1

package/README.md

@@ -40,6 +40,43 @@ Configure the extension in Pi's standard settings files:
 
 Project values override global values. Run `/reload` after editing either file.
 
+## Subagent Access
+
+`minimalSubagents.enabled` controls whether the six Root Agent Coordinator
+Tools start active. It defaults to `true`; a trusted project value overrides
+the global value.
+
+```json
+{
+  "minimalSubagents": {
+    "enabled": false
+  }
+}
+```
+
+Use `/subagents` to inspect or change access without editing JSON:
+
+```text
+/subagents
+/subagents status
+/subagents enable|disable|reset
+/subagents enable|disable|reset --global
+/subagents enable|disable|reset --project
+```
+
+Bare `/subagents` means `status`. Unscoped changes apply to the selected
+session-tree branch. `reset` removes that override and follows project, global,
+then the built-in default. Scoped changes update both the selected branch and
+the chosen settings file; project changes require a trusted project. A malformed
+settings file is left unchanged and reported with its path.
+
+Disabling Subagent Access removes all six Coordinator Tools from the Root
+Agent while preserving unrelated tools. It does not cancel or alter existing
+Child Agents, their Launch Contracts or fanout capability, Coordination Message
+delivery, or terminal-result delivery. Reload and resume preserve the selected
+branch override, `/tree` restores the newly selected branch, forks inherit the
+source branch, and a new branch without an override follows settings.
+
 ## Model roles
 
 `minimalSubagents.modelRoles` gives the parent agent advisory names for
@@ -141,7 +178,15 @@ lists: `"read"` grants `read`, `grep`, `find`, and `ls`; `"modify"` adds
 named ordinary tool and does not expand a preset. Coordinator tools are
 injected separately according to delegation and must not appear in `tools`;
 misuse returns an actionable error. Use the string preset when a child needs
-the complete read-only discovery bundle.
+the complete read-only discovery bundle. Child sessions load the Root Agent's
+configured settings and extensions, excluding the recursive
+`pi-minimal-subagents` entrypoint. Project Context controls only project-scoped
+AGENTS instructions and skills; omitting it retains user instructions and
+skills plus project settings, extensions, providers, and tools. A configured
+`pi-codex-conversion` adapter replaces a complete granted tool group only; a
+read-only child retains Pi's read tools instead of gaining an arbitrary shell.
+Status reports effective adapter tools while the Launch Contract continues to
+record the originally granted capability names.
 
 `agent_message` reports whether a message was delivered through an active
 parent wait, queued for the recipient, or failed. `subagent_wait` can return an
@@ -203,6 +248,18 @@ source file; it never substitutes the source session's newer head.
 
 ## Status and TUI
 
+In TUI mode, `/subagents status` opens a live read-only hierarchy. Rows begin
+collapsed; use Up/Down to select, Enter to expand Recent Activity, the configured
+tool-expansion key to reveal tool output, page keys to scroll, and Escape to
+close. Expanded activity uses Pi's transcript components, updates once per
+second, remains bounded, and omits images. The header reports the effective
+access source, authored settings, direct running/idle counts, and actual
+Coordinator Tool activation. Partial external activation is reported as
+`N/6 active`; status does not repair it.
+
+RPC mode receives a concise status notification. JSON and print modes produce
+no observer-only output.
+
 Visible Child Agent rows show the canonical `provider/model:thinking` Runtime
 Profile. Status uses the live Runtime Profile while a runtime exists and falls
 back to the immutable Launch Contract otherwise. Live changes are observational:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "private": false,
   "description": "Persistent nested subagents with bounded delegation for Pi",
   "keywords": [
@@ -30,6 +30,12 @@
     "access": "public",
     "provenance": true
   },
+  "dependencies": {
+    "proper-lockfile": "^4.1.2"
+  },
+  "devDependencies": {
+    "@types/proper-lockfile": "^4.1.4"
+  },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",

package/skills/pi-minimal-subagents/SKILL.md

@@ -1,15 +1,16 @@
 ---
 name: pi-minimal-subagents
-description: Configure or diagnose Pi Minimal Subagents for spawn, capability, delivery, wait, restore, reload, or fork failures.
+description: Configure or diagnose Pi Minimal Subagents for Subagent Access, missing Coordinator Tools, spawn, capability, delivery, wait, restore, reload, or fork failures.
 license: MIT
 ---
 
 # Pi Minimal Subagents
 
-1. Read the relevant spawn, capability, delivery, or recovery section of [`../../README.md`](../../README.md).
-2. From the direct parent, use `subagent_status` to capture the Child Agent's Launch Contract, Runtime Profile, dependencies, result, and Recent Activity.
-3. Classify the fault as launch resolution, adjacency, ordinary-tool ceiling, delivery state, or Registry recovery.
-4. For configuration changes, identify the effective layer, make one scoped edit, validate JSON, and reload Pi.
-5. Repeat the same spawn or coordination operation. Finish when it succeeds or one named launch, adjacency, capability, delivery, or recovery boundary is evidenced.
+1. Read the relevant access, spawn, capability, delivery, or recovery section of [`../../README.md`](../../README.md).
+2. For Subagent Access or missing Root Agent Coordinator Tools, run `/subagents status` first and record the effective source plus actual active-tool count.
+3. From the direct parent, use `subagent_status` to capture the Child Agent's Launch Contract, effective tools, Runtime Profile, dependencies, result, and Recent Activity.
+4. Classify the fault as Subagent Access, launch resolution, adjacency, ordinary-tool ceiling, delivery state, or Registry recovery.
+5. For access changes, use the narrowest `/subagents enable|disable|reset` scope. For other configuration, identify the effective layer, make one scoped edit, validate JSON, and reload Pi.
+6. Repeat the same spawn or coordination operation. Finish when it succeeds or one named access, launch, adjacency, capability, delivery, or recovery boundary is evidenced.
 
 A wait timeout observes without cancelling. Tool arrays contain only ordinary tools. Cancellation preserves a Child Session; deletion removes it.

package/src/minimal-subagents-access.ts

@@ -0,0 +1,150 @@
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+import { COORDINATOR_TOOL_NAMES } from "./minimal-subagents-capabilities.js";
+import type {
+  ResolvedSubagentAccessSettings,
+  SubagentAccessSettingsSource,
+} from "./minimal-subagents-config.js";
+
+/** Names branch-scoped Root Agent Subagent Access records. */
+export const SUBAGENT_ACCESS_ENTRY_TYPE = "minimal-subagents.access";
+
+const MAX_SUBAGENT_ACCESS_DIAGNOSTICS = 5;
+const SubagentAccessOverrideSchema = Type.Union([
+  Type.Literal("enabled"),
+  Type.Literal("disabled"),
+  Type.Literal("inherit"),
+]);
+const SubagentAccessBranchRecordSchema = Type.Object(
+  {
+    version: Type.Literal(1),
+    access: SubagentAccessOverrideSchema,
+  },
+  { additionalProperties: false },
+);
+const COORDINATOR_TOOL_NAME_SET = new Set<string>(COORDINATOR_TOOL_NAMES);
+
+/** Represents desired branch-local Subagent Access, including settings inheritance. */
+export type SubagentAccessOverride = Static<typeof SubagentAccessOverrideSchema>;
+
+/** Represents the versioned custom-entry payload persisted on a Root Agent branch. */
+export type SubagentAccessBranchRecord = Static<typeof SubagentAccessBranchRecordSchema>;
+
+/** Describes one invalid branch record skipped during Subagent Access replay. */
+export interface SubagentAccessReplayDiagnostic {
+  entryIndex: number;
+  message: string;
+}
+
+/** Contains the latest valid branch override and bounded replay diagnostics. */
+export interface ReplayedSubagentAccessBranch {
+  override: SubagentAccessOverride;
+  diagnostics: SubagentAccessReplayDiagnostic[];
+}
+
+/** Describes actual activation of the six Root Agent Coordinator Tools. */
+export interface CoordinatorToolActivation {
+  activeCount: number;
+  totalCount: number;
+  state: "enabled" | "disabled" | "partial";
+}
+
+/** Identifies the branch or settings layer that determines effective Subagent Access. */
+export type SubagentAccessSource = "branch" | SubagentAccessSettingsSource;
+
+/** Contains desired Subagent Access, authored defaults, and actual Coordinator Tool activation. */
+export interface SubagentAccessSnapshot {
+  enabled: boolean;
+  source: SubagentAccessSource;
+  branchOverride: SubagentAccessOverride;
+  globalEnabled: boolean | undefined;
+  projectEnabled: boolean | undefined;
+  coordinatorTools: CoordinatorToolActivation;
+}
+
+interface SubagentAccessEntryLike {
+  type?: string;
+  customType?: string;
+  data?: unknown;
+}
+
+/** Create the validated V1 payload appended for one branch-local access decision. */
+export function createSubagentAccessBranchRecord(
+  access: SubagentAccessOverride,
+): SubagentAccessBranchRecord {
+  return { version: 1, access };
+}
+
+/** Replay the latest valid Subagent Access record from the selected Root Agent branch. */
+export function replaySubagentAccessBranch(
+  entries: readonly SubagentAccessEntryLike[],
+  reportInvalidRecords?: (diagnostics: SubagentAccessReplayDiagnostic[]) => void,
+): ReplayedSubagentAccessBranch {
+  let override: SubagentAccessOverride = "inherit";
+  const diagnostics: SubagentAccessReplayDiagnostic[] = [];
+
+  entries.forEach((entry, entryIndex) => {
+    if (entry.type !== "custom" || entry.customType !== SUBAGENT_ACCESS_ENTRY_TYPE) return;
+    if (Value.Check(SubagentAccessBranchRecordSchema, entry.data)) {
+      override = entry.data.access;
+      return;
+    }
+    if (diagnostics.length < MAX_SUBAGENT_ACCESS_DIAGNOSTICS) {
+      diagnostics.push({
+        entryIndex,
+        message: "Subagent Access branch record is invalid and was ignored",
+      });
+    }
+  });
+
+  if (diagnostics.length > 0) reportInvalidRecords?.(diagnostics);
+  return { override, diagnostics };
+}
+
+/** Inspect actual Coordinator Tool activation without changing active tools. */
+export function inspectCoordinatorToolActivation(
+  activeToolNames: readonly string[],
+): CoordinatorToolActivation {
+  const activeCoordinatorNames = new Set(
+    activeToolNames.filter((toolName) => COORDINATOR_TOOL_NAME_SET.has(toolName)),
+  );
+  const activeCount = activeCoordinatorNames.size;
+  return {
+    activeCount,
+    totalCount: COORDINATOR_TOOL_NAMES.length,
+    state:
+      activeCount === 0
+        ? "disabled"
+        : activeCount === COORDINATOR_TOOL_NAMES.length
+          ? "enabled"
+          : "partial",
+  };
+}
+
+/** Reconcile all six Coordinator Tools while preserving unrelated active-tool order. */
+export function reconcileCoordinatorToolAccess(
+  activeToolNames: readonly string[],
+  enabled: boolean,
+): string[] {
+  const ordinaryToolNames = activeToolNames.filter(
+    (toolName) => !COORDINATOR_TOOL_NAME_SET.has(toolName),
+  );
+  return enabled ? [...ordinaryToolNames, ...COORDINATOR_TOOL_NAMES] : ordinaryToolNames;
+}
+
+/** Resolve branch state over settings and include read-only Coordinator Tool activation. */
+export function resolveSubagentAccessSnapshot(
+  settings: ResolvedSubagentAccessSettings,
+  branchOverride: SubagentAccessOverride,
+  activeToolNames: readonly string[],
+): SubagentAccessSnapshot {
+  const branchEnabled = branchOverride === "inherit" ? undefined : branchOverride === "enabled";
+  return {
+    enabled: branchEnabled ?? settings.enabled,
+    source: branchEnabled === undefined ? settings.source : "branch",
+    branchOverride,
+    globalEnabled: settings.globalEnabled,
+    projectEnabled: settings.projectEnabled,
+    coordinatorTools: inspectCoordinatorToolActivation(activeToolNames),
+  };
+}

package/src/minimal-subagents-child-resources.ts

@@ -0,0 +1,102 @@
+import { dirname } from "node:path";
+import { DefaultResourceLoader, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { canonicalPath } from "./minimal-subagents-paths.js";
+import type { ProjectContextMode } from "./minimal-subagents-types.js";
+
+export interface ChildResourceLoaderOptions {
+  cwd: string;
+  agentDir: string;
+  projectContext: ProjectContextMode;
+  extensionEntrypoint: string;
+  systemPromptBlock: string;
+  settingsManager?: SettingsManager;
+}
+
+function createDefaultChildResourceLoaderOptions(
+  input: ChildResourceLoaderOptions,
+): ConstructorParameters<typeof DefaultResourceLoader>[0] {
+  const extensionEntrypoint = canonicalPath(input.extensionEntrypoint);
+  return {
+    cwd: input.cwd,
+    agentDir: input.agentDir,
+    settingsManager: input.settingsManager,
+    noExtensions: false,
+    noContextFiles: false,
+    noSkills: false,
+    noPromptTemplates: false,
+    extensionsOverride: (base) => ({
+      ...base,
+      extensions: base.extensions.filter(
+        (extension) => canonicalPath(extension.resolvedPath) !== extensionEntrypoint,
+      ),
+      errors: base.errors.filter((error) => canonicalPath(error.path) !== extensionEntrypoint),
+    }),
+    appendSystemPromptOverride: (base) => [...base, input.systemPromptBlock],
+  };
+}
+
+class ChildResourceLoader extends DefaultResourceLoader {
+  private readonly omitProjectContext: boolean;
+  private readonly userContextDirectory: string;
+  private readonly userSkillLoader: DefaultResourceLoader | undefined;
+
+  constructor(input: ChildResourceLoaderOptions) {
+    super(createDefaultChildResourceLoaderOptions(input));
+    this.omitProjectContext = input.projectContext === "omit";
+    this.userContextDirectory = canonicalPath(input.agentDir);
+    this.userSkillLoader = this.omitProjectContext
+      ? new DefaultResourceLoader({
+          cwd: input.cwd,
+          agentDir: input.agentDir,
+          settingsManager: SettingsManager.create(input.cwd, input.agentDir, {
+            projectTrusted: false,
+          }),
+          noExtensions: true,
+          noContextFiles: true,
+          noPromptTemplates: true,
+          noThemes: true,
+        })
+      : undefined;
+  }
+
+  override async reload(...parameters: Parameters<DefaultResourceLoader["reload"]>): Promise<void> {
+    await super.reload(...parameters);
+    await this.userSkillLoader?.reload();
+  }
+
+  override extendResources(paths: Parameters<DefaultResourceLoader["extendResources"]>[0]): void {
+    super.extendResources(paths);
+    const skillPaths = paths.skillPaths?.filter(({ metadata }) => metadata.scope !== "project");
+    if (skillPaths && skillPaths.length > 0) this.userSkillLoader?.extendResources({ skillPaths });
+  }
+
+  override getAgentsFiles(): ReturnType<DefaultResourceLoader["getAgentsFiles"]> {
+    const base = super.getAgentsFiles();
+    if (!this.omitProjectContext) return base;
+    return {
+      agentsFiles: base.agentsFiles.filter(
+        ({ path }) => canonicalPath(dirname(path)) === this.userContextDirectory,
+      ),
+    };
+  }
+
+  override getSkills(): ReturnType<DefaultResourceLoader["getSkills"]> {
+    const base = super.getSkills();
+    if (!this.omitProjectContext) return base;
+    const skills = base.skills.filter((skill) => skill.sourceInfo.scope !== "project");
+    const skillNames = new Set(skills.map((skill) => skill.name));
+    for (const skill of this.userSkillLoader?.getSkills().skills ?? []) {
+      if (skillNames.has(skill.name)) continue;
+      skills.push(skill);
+      skillNames.add(skill.name);
+    }
+    return { skills, diagnostics: base.diagnostics };
+  }
+}
+
+/** Load Child Agent runtime resources while applying its Project Context choice. */
+export function createChildResourceLoader(
+  input: ChildResourceLoaderOptions,
+): DefaultResourceLoader {
+  return new ChildResourceLoader(input);
+}

package/src/minimal-subagents-command.ts

@@ -0,0 +1,63 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+const SUBAGENTS_COMMAND_USAGE =
+  "Usage: /subagents [status | enable|disable|reset [--global|--project]]";
+
+/** A parsed `/subagents` command accepted by the finite user-facing grammar. */
+export type SubagentsCommand =
+  | { readonly action: "status" }
+  | {
+      readonly action: "enable" | "disable" | "reset";
+      readonly scope: "session" | "global" | "project";
+    };
+
+/** The parse result keeps invalid command input out of lifecycle policy. */
+export type ParseSubagentsCommandResult =
+  | { readonly ok: true; readonly command: SubagentsCommand }
+  | { readonly ok: false; readonly message: string };
+
+const SUBAGENTS_COMMAND_COMPLETION_DETAILS = [
+  ["status", "Show live Child Agent status"],
+  ["enable", "Enable for this branch"],
+  ["enable --global", "Enable by default globally"],
+  ["enable --project", "Enable by default for this project"],
+  ["disable", "Disable for this branch"],
+  ["disable --global", "Disable by default globally"],
+  ["disable --project", "Disable by default for this project"],
+  ["reset", "Follow settings for this branch"],
+  ["reset --global", "Remove the global default"],
+  ["reset --project", "Remove the project default"],
+] as const;
+
+const COMMAND_COMPLETIONS: readonly AutocompleteItem[] = SUBAGENTS_COMMAND_COMPLETION_DETAILS.map(
+  ([value, description]) => ({ value, label: value, description }),
+);
+
+/** Parse the exact `/subagents` argument grammar without accepting extra operands. */
+export function parseSubagentsCommandArguments(input: string): ParseSubagentsCommandResult {
+  const normalized = input.trim().replace(/\s+/g, " ");
+  if (normalized === "" || normalized === "status") {
+    return { ok: true, command: { action: "status" } };
+  }
+
+  const [action, flag, ...extra] = normalized.split(" ");
+  if (
+    extra.length > 0 ||
+    (action !== "enable" && action !== "disable" && action !== "reset") ||
+    (flag !== undefined && flag !== "--global" && flag !== "--project")
+  ) {
+    return { ok: false, message: SUBAGENTS_COMMAND_USAGE };
+  }
+  return {
+    ok: true,
+    command: {
+      action,
+      scope: flag === "--global" ? "global" : flag === "--project" ? "project" : "session",
+    },
+  };
+}
+
+/** Complete only command tails that the strict `/subagents` parser accepts. */
+export function completeSubagentsCommandArguments(prefix: string): AutocompleteItem[] {
+  return COMMAND_COMPLETIONS.filter((completion) => completion.value.startsWith(prefix));
+}

package/src/minimal-subagents-config.ts

@@ -12,10 +12,12 @@ const SettingsDocumentSchema = Type.Object({
   minimalSubagents: Type.Optional(JsonValueSchema),
 });
 const MinimalSubagentsSettingsSchema = Type.Object({
+  enabled: Type.Optional(JsonValueSchema),
   maxSubagentDepth: Type.Optional(JsonValueSchema),
   modelRoles: Type.Optional(JsonValueSchema),
 });
 const JsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
+const EnabledSettingSchema = Type.Boolean();
 const PositiveSafeIntegerSchema = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
 const MaxSubagentDepthSettingSchema = Type.Union([PositiveSafeIntegerSchema, Type.Null()]);
 const ShorthandModelRoleSchema = Type.String();
@@ -39,9 +41,21 @@ export interface MinimalSubagentsModelRole {
   hint?: string;
 }
 
+/** Identifies the authored settings layer that determines Subagent Access. */
+export type SubagentAccessSettingsSource = "project" | "global" | "default";
+
+/** Contains effective and authored Subagent Access settings for one Root Agent session. */
+export interface ResolvedSubagentAccessSettings {
+  enabled: boolean;
+  source: SubagentAccessSettingsSource;
+  globalEnabled: boolean | undefined;
+  projectEnabled: boolean | undefined;
+}
+
 /** Contains the validated minimal subagents settings used by one extension session. */
 export interface ResolvedMinimalSubagentsConfig {
   maxSubagentDepth: number;
+  subagentAccess: ResolvedSubagentAccessSettings;
   modelRoles: MinimalSubagentsModelRole[];
   warnings: string[];
 }
@@ -53,6 +67,7 @@ interface MinimalSubagentsSettingsDocument {
 interface MinimalSubagentsConfigInput {
   globalSettings: MinimalSubagentsSettingsDocumentInput;
   projectSettings: MinimalSubagentsSettingsDocumentInput;
+  projectTrusted?: boolean;
   eligibleModelIds: readonly string[];
 }
 
@@ -62,6 +77,7 @@ type MinimalSubagentsSettingsDocumentInput = PiSettingsDocument | MinimalSubagen
 interface MinimalSubagentsSettingsReader {
   getGlobalSettings(): MinimalSubagentsSettingsDocumentInput;
   getProjectSettings(): MinimalSubagentsSettingsDocumentInput;
+  isProjectTrusted?(): boolean;
 }
 
 type SettingsScope = "global" | "project";
@@ -72,6 +88,7 @@ interface ScopedSettingValue {
 }
 
 interface ParsedMinimalSubagentsSettings {
+  enabled?: boolean;
   maxSubagentDepth?: MaxSubagentDepthWireValue;
   modelRoles?: ModelRolesWireValue;
 }
@@ -136,6 +153,13 @@ function readMinimalSubagentsSettings(
   if (minimalSubagents === undefined) return {};
   if (Value.Check(MinimalSubagentsSettingsSchema, minimalSubagents)) {
     const parsed: ParsedMinimalSubagentsSettings = {};
+    if (minimalSubagents.enabled !== undefined) {
+      if (Value.Check(EnabledSettingSchema, minimalSubagents.enabled)) {
+        parsed.enabled = minimalSubagents.enabled;
+      } else {
+        warnings.push(`${scope} minimalSubagents.enabled: expected a boolean`);
+      }
+    }
     if (minimalSubagents.maxSubagentDepth !== undefined) {
       parsed.maxSubagentDepth = parseMaxSubagentDepthWireValue(minimalSubagents.maxSubagentDepth);
     }
@@ -295,6 +319,20 @@ function parseModelRoles(
   return roles;
 }
 
+function resolveSubagentAccessSettings(
+  globalEnabled: boolean | undefined,
+  projectEnabled: boolean | undefined,
+): ResolvedSubagentAccessSettings {
+  const source =
+    projectEnabled !== undefined ? "project" : globalEnabled !== undefined ? "global" : "default";
+  return {
+    enabled: projectEnabled ?? globalEnabled ?? true,
+    source,
+    globalEnabled,
+    projectEnabled,
+  };
+}
+
 function resolveMaxSubagentDepth(
   globalValue: MaxSubagentDepthWireValue | undefined,
   projectValue: MaxSubagentDepthWireValue | undefined,
@@ -323,7 +361,10 @@ export function resolveMinimalSubagentsConfig(
 ): ResolvedMinimalSubagentsConfig {
   const warnings: string[] = [];
   const globalConfig = readMinimalSubagentsSettings(input.globalSettings, "global", warnings);
-  const projectConfig = readMinimalSubagentsSettings(input.projectSettings, "project", warnings);
+  const projectConfig =
+    input.projectTrusted === false
+      ? {}
+      : readMinimalSubagentsSettings(input.projectSettings, "project", warnings);
   const maxSubagentDepth = resolveMaxSubagentDepth(
     globalConfig.maxSubagentDepth,
     projectConfig.maxSubagentDepth,
@@ -337,6 +378,7 @@ export function resolveMinimalSubagentsConfig(
 
   return {
     maxSubagentDepth,
+    subagentAccess: resolveSubagentAccessSettings(globalConfig.enabled, projectConfig.enabled),
     modelRoles: parseModelRoles(modelRoleEntries, input.eligibleModelIds, warnings),
     warnings,
   };
@@ -350,6 +392,7 @@ export function resolveMinimalSubagentsSettings(
   return resolveMinimalSubagentsConfig({
     globalSettings: settings.getGlobalSettings(),
     projectSettings: settings.getProjectSettings(),
+    projectTrusted: settings.isProjectTrusted?.() ?? true,
     eligibleModelIds,
   });
 }