@tt-a1i/openpi 0.1.0 → 0.2.0

package/extensions/shared/setup-config.ts

@@ -63,6 +63,10 @@ export type FooterLines = readonly (readonly FooterLayoutItem[])[];
 export const DETAIL_DISPLAYS = ["full", "compact"] as const;
 export type DetailDisplay = (typeof DETAIL_DISPLAYS)[number];
 
+export const CAPABILITY_DISCOVERY_MODES = ["explicit", "adaptive"] as const;
+export type CapabilityDiscoveryMode =
+  (typeof CAPABILITY_DISCOVERY_MODES)[number];
+
 /** Canonical default layout: one-line Powerline dashboard with flex alignment. */
 export const DEFAULT_FOOTER_LINES: FooterLines = [
   [
@@ -123,6 +127,9 @@ export const POST_EDIT_COMMAND_MAX_CHARS = 500;
 export const SETUP_CONFIG_CHANGED_CHANNEL = "my-pi-setup:config-changed";
 
 export interface MyPiSetupConfig {
+  readonly capabilities: {
+    readonly discovery: CapabilityDiscoveryMode;
+  };
   readonly suggestions: {
     readonly enabled: boolean;
     readonly model?: SuggestionModelConfig;
@@ -157,6 +164,7 @@ export interface MyPiSetupConfig {
 }
 
 export const DEFAULT_SETUP_CONFIG: MyPiSetupConfig = {
+  capabilities: { discovery: "explicit" },
   suggestions: { enabled: false },
   workflows: {
     concurrency: DEFAULT_WORKFLOW_CONCURRENCY,
@@ -205,6 +213,12 @@ const isFooterStyle = (value: unknown): value is FooterStyle =>
 const isFooterPreset = (value: unknown): value is FooterPreset =>
   typeof value === "string" && FOOTER_PRESETS.includes(value as FooterPreset);
 
+const isCapabilityDiscoveryMode = (
+  value: unknown,
+): value is CapabilityDiscoveryMode =>
+  typeof value === "string" &&
+  CAPABILITY_DISCOVERY_MODES.includes(value as CapabilityDiscoveryMode);
+
 export function flattenFooterItems(lines: FooterLines): readonly FooterItem[] {
   const items: FooterItem[] = [];
   const seen = new Set<FooterItem>();
@@ -401,6 +415,8 @@ function boundedInteger(value: unknown, fallback: number, maximum: number) {
 export function parseSetupConfig(value: unknown): MyPiSetupConfig {
   if (!isRecord(value)) return DEFAULT_SETUP_CONFIG;
 
+  const capabilities = isRecord(value.capabilities) ? value.capabilities : {};
+
   // `summaries` is the pre-suggestion config key. Read it once as a migration
   // source; every subsequent save writes only the canonical `suggestions` key.
   const suggestions = isRecord(value.suggestions)
@@ -430,6 +446,11 @@ export function parseSetupConfig(value: unknown): MyPiSetupConfig {
   const subagents = isRecord(value.subagents) ? value.subagents : {};
   const footer = parseUiFooter(ui);
   return {
+    capabilities: {
+      discovery: isCapabilityDiscoveryMode(capabilities.discovery)
+        ? capabilities.discovery
+        : "explicit",
+    },
     suggestions: {
       enabled: requestedEnabled && Boolean(model),
       ...(model ? { model } : {}),
@@ -929,7 +950,10 @@ export async function saveSetupConfig(config: MyPiSetupConfig) {
   });
 }
 
-export function formatSetupConfig(config = loadSetupConfig()) {
+export function formatSetupConfig(
+  config = loadSetupConfig(),
+  integrationLines: readonly string[] = [],
+) {
   const suggestionModel = config.suggestions.model;
   const suggestions =
     !config.suggestions.enabled || !suggestionModel
@@ -939,6 +963,7 @@ export function formatSetupConfig(config = loadSetupConfig()) {
     ? `on · ${config.ui.footerStyle} · ${formatFooterLines(config.ui.footerLines)}`
     : "off";
   return [
+    `Capability discovery: ${config.capabilities.discovery}`,
     suggestions,
     `Workflows: ${config.workflows.concurrency} concurrent agents · ${config.workflows.maxAgentCalls} total calls`,
     `UI: large header ${config.ui.showHeader ? "on" : "off"} · custom footer ${footer}`,
@@ -947,6 +972,7 @@ export function formatSetupConfig(config = loadSetupConfig()) {
     `Write/Edit operations: ${config.ui.fileMutationDisplay === "full" ? "expanded by default" : "folded preview (Ctrl+O expands all)"}`,
     `Post-edit command: ${config.postEdit.command ? config.postEdit.command : "off"}`,
     `Agent role models (Subagents + Workflows): ${SUBAGENT_ROLE_NAMES.map((role) => `${role} ${config.subagents.roleModels[role] ? `${config.subagents.roleModels[role].provider}/${config.subagents.roleModels[role].model}` : "inherit"}`).join(" · ")}`,
+    ...integrationLines,
   ].join("\n");
 }
 

package/extensions/shared/setup-episode-state.ts

@@ -0,0 +1,7 @@
+/** Broadcast whenever the package-owned setup episode becomes usable or ends. */
+export const OPENPI_SETUP_EPISODE_CHANNEL = "openpi:setup-episode";
+
+export interface OpenPiSetupEpisodeState {
+  /** True for both armed and actively running setup episodes. */
+  readonly active: boolean;
+}

package/extensions/shared/tool-surface.ts

@@ -0,0 +1,435 @@
+import { fileURLToPath } from "node:url";
+
+/**
+ * OpenPI-owned model tools, grouped by the extension that owns their runtime
+ * state. Ordinary parent sessions add no resident OpenPI tool. Explicit user
+ * intent can reveal the capability gateway or load one capability group;
+ * capability-owned tools remain registered but are projected only after their
+ * group is loaded. Lifecycle tools add a second resource/mode-state gate inside
+ * that loaded group.
+ */
+export const OPENPI_TOOL_SURFACE = {
+  capabilities: {
+    entry: ["openpi_load_tools"],
+    deferred: [],
+  },
+  fileSearch: {
+    entry: ["fd", "rg"],
+    deferred: [],
+  },
+  subagents: {
+    entry: ["subagent_spawn"],
+    deferred: [
+      "subagent_wait",
+      "subagent_cancel",
+      "subagent_send",
+      "subagent_check",
+      "subagent_list",
+    ],
+  },
+  workflows: {
+    entry: ["workflow"],
+    deferred: ["workflow_stop", "workflow_status"],
+  },
+  background: {
+    entry: ["bg_start"],
+    deferred: ["bg_status", "bg_list", "bg_kill", "bg_watch"],
+  },
+  tasks: {
+    entry: ["tasks_add"],
+    deferred: ["tasks_update", "tasks_list"],
+  },
+  goal: {
+    entry: ["create_goal"],
+    deferred: ["get_goal", "update_goal"],
+  },
+  interaction: {
+    entry: [],
+    deferred: ["ask_user", "human_handoff"],
+  },
+  plan: {
+    entry: [],
+    deferred: ["plan_ready"],
+  },
+  setup: {
+    entry: [],
+    deferred: ["configure_my_pi_setup"],
+  },
+  context: {
+    entry: [],
+    deferred: ["context_pivot"],
+  },
+} as const;
+
+export type OpenPiToolOwner = keyof typeof OPENPI_TOOL_SURFACE;
+
+export const OPENPI_CAPABILITY_GROUPS = {
+  search: {
+    owners: ["fileSearch"],
+    summary: "Fast structured file and content search with fd and rg.",
+  },
+  delegate: {
+    owners: ["subagents"],
+    summary: "Spawn and manage isolated in-process Pi subagents.",
+  },
+  workflow: {
+    owners: ["workflows"],
+    summary: "Run replay-safe multi-stage workflows.",
+  },
+  background: {
+    owners: ["background"],
+    summary: "Start and manage long-running background terminals.",
+  },
+  session: {
+    owners: ["tasks", "goal"],
+    summary:
+      "Track explicit session tasks and persistent user-requested goals.",
+  },
+} as const satisfies Record<
+  string,
+  { owners: readonly OpenPiToolOwner[]; summary: string }
+>;
+
+export type OpenPiCapability = keyof typeof OPENPI_CAPABILITY_GROUPS;
+
+export const OPENPI_CAPABILITY_NAMES = Object.keys(
+  OPENPI_CAPABILITY_GROUPS,
+) as OpenPiCapability[];
+
+export const DEFAULT_OPENPI_ACTIVE_TOOL_NAMES: readonly string[] = [];
+
+export const OPENPI_TOOL_SURFACE_NAMES = Object.values(
+  OPENPI_TOOL_SURFACE,
+).flatMap(({ entry, deferred }) => [...entry, ...deferred]);
+
+interface ActiveToolSurface {
+  events?: {
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: (data: unknown) => void): () => void;
+  };
+  getActiveTools(): string[];
+  getAllTools?(): {
+    name: string;
+    sourceInfo?: { path: string; source?: string };
+  }[];
+  setActiveTools(names: string[]): void;
+}
+
+interface OwnedToolPatch {
+  enable?: readonly string[];
+  disable?: readonly string[];
+}
+
+interface ToolSurfaceState {
+  loaded: Set<OpenPiCapability>;
+  desiredByOwner: Map<OpenPiToolOwner, Set<string>>;
+  sourceByOwner: Map<OpenPiToolOwner, string>;
+  managedOwners: Set<OpenPiToolOwner>;
+  knownAvailable: Set<string>;
+  subscribed: boolean;
+}
+
+const OWNER_SOURCE_PATHS = {
+  capabilities: fileURLToPath(
+    new URL("../capabilities/index.ts", import.meta.url),
+  ),
+  fileSearch: fileURLToPath(
+    new URL("../file-search/index.ts", import.meta.url),
+  ),
+  subagents: fileURLToPath(new URL("../subagents/index.ts", import.meta.url)),
+  workflows: fileURLToPath(new URL("../workflows/index.ts", import.meta.url)),
+  background: fileURLToPath(
+    new URL("../background-terminals/index.ts", import.meta.url),
+  ),
+  tasks: fileURLToPath(new URL("../tasks/index.ts", import.meta.url)),
+  goal: fileURLToPath(new URL("../goal/index.ts", import.meta.url)),
+  interaction: fileURLToPath(new URL("../ask-user/index.ts", import.meta.url)),
+  plan: fileURLToPath(new URL("../plan-mode/index.ts", import.meta.url)),
+  setup: fileURLToPath(new URL("../setup/index.ts", import.meta.url)),
+  context: fileURLToPath(new URL("../context-pivot/index.ts", import.meta.url)),
+} as const satisfies Record<OpenPiToolOwner, string>;
+
+const states = new WeakMap<object, ToolSurfaceState>();
+export const OPENPI_CAPABILITY_STATE_CHANNEL = "openpi:capability-state";
+
+function initialDesiredByOwner() {
+  return new Map<OpenPiToolOwner, Set<string>>(
+    (Object.keys(OPENPI_TOOL_SURFACE) as OpenPiToolOwner[]).map((owner) => [
+      owner,
+      new Set<string>(
+        owner === "capabilities" ? [] : OPENPI_TOOL_SURFACE[owner].entry,
+      ),
+    ]),
+  );
+}
+
+function newState(): ToolSurfaceState {
+  return {
+    loaded: new Set<OpenPiCapability>(),
+    desiredByOwner: initialDesiredByOwner(),
+    sourceByOwner: new Map<OpenPiToolOwner, string>(),
+    managedOwners: new Set<OpenPiToolOwner>(),
+    knownAvailable: new Set<string>(),
+    subscribed: false,
+  };
+}
+
+function capabilityStateFromEvent(data: unknown) {
+  if (typeof data !== "object" || data === null) return undefined;
+  const loaded = (data as { loaded?: unknown }).loaded;
+  if (!Array.isArray(loaded)) return undefined;
+  if (
+    loaded.some(
+      (name) =>
+        typeof name !== "string" ||
+        !OPENPI_CAPABILITY_NAMES.includes(name as OpenPiCapability),
+    )
+  ) {
+    return undefined;
+  }
+  return loaded as OpenPiCapability[];
+}
+
+function subscribeToCapabilityState(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+) {
+  if (
+    state.subscribed ||
+    typeof pi.events?.on !== "function" ||
+    typeof pi.events?.emit !== "function"
+  ) {
+    return;
+  }
+  state.subscribed = true;
+  pi.events.on(OPENPI_CAPABILITY_STATE_CHANNEL, (data) => {
+    const loaded = capabilityStateFromEvent(data);
+    if (!loaded) return;
+    state.loaded = new Set(loaded);
+    reconcileManagedOwners(pi, state);
+  });
+}
+
+function stateFor(pi: ActiveToolSurface) {
+  let state = states.get(pi);
+  if (!state) {
+    state = newState();
+    if (
+      typeof pi.events?.on !== "function" ||
+      typeof pi.events?.emit !== "function"
+    ) {
+      state.loaded = new Set(OPENPI_CAPABILITY_NAMES);
+    }
+    states.set(pi, state);
+  }
+  return state;
+}
+
+function capabilityForOwner(owner: OpenPiToolOwner) {
+  return OPENPI_CAPABILITY_NAMES.find((capability) =>
+    OPENPI_CAPABILITY_GROUPS[capability].owners.includes(owner as never),
+  );
+}
+
+function ownerIsVisible(state: ToolSurfaceState, owner: OpenPiToolOwner) {
+  const capability = capabilityForOwner(owner);
+  return capability === undefined || state.loaded.has(capability);
+}
+
+function ownedToolNames(owner: OpenPiToolOwner) {
+  return [
+    ...OPENPI_TOOL_SURFACE[owner].entry,
+    ...OPENPI_TOOL_SURFACE[owner].deferred,
+  ] as readonly string[];
+}
+
+function availableOwnedToolNames(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  for (const name of pi.getActiveTools()) state.knownAvailable.add(name);
+  const reportedTools = pi.getAllTools?.();
+  const owned = new Set<string>(ownedToolNames(owner));
+  if (!reportedTools || reportedTools.length === 0) {
+    return new Set([...state.knownAvailable].filter((name) => owned.has(name)));
+  }
+  if (reportedTools.every((tool) => tool.sourceInfo === undefined)) {
+    return new Set(
+      reportedTools.map(({ name }) => name).filter((name) => owned.has(name)),
+    );
+  }
+
+  const expectedSource =
+    state.sourceByOwner.get(owner) ?? OWNER_SOURCE_PATHS[owner];
+  return new Set(
+    reportedTools
+      .filter(
+        (tool) =>
+          owned.has(tool.name) && tool.sourceInfo?.path === expectedSource,
+      )
+      .map(({ name }) => name),
+  );
+}
+
+function projectedOwnerTools(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  const available = availableOwnedToolNames(pi, state, owner);
+  const owned = ownedToolNames(owner);
+  const ownedAvailable = new Set(owned.filter((name) => available.has(name)));
+  const desired = state.desiredByOwner.get(owner)!;
+  const visible = ownerIsVisible(state, owner);
+  const next = pi
+    .getActiveTools()
+    .filter(
+      (name) => !ownedAvailable.has(name) || (visible && desired.has(name)),
+    );
+  const nextSet = new Set(next);
+
+  if (visible) {
+    for (const name of owned) {
+      if (desired.has(name) && !nextSet.has(name) && available.has(name)) {
+        next.push(name);
+        nextSet.add(name);
+      }
+    }
+  }
+
+  return next;
+}
+
+function applyActiveTools(pi: ActiveToolSurface, next: string[]) {
+  const active = pi.getActiveTools();
+  if (
+    active.length === next.length &&
+    active.every((name, index) => name === next[index])
+  ) {
+    return false;
+  }
+  pi.setActiveTools(next);
+  return true;
+}
+
+function reconcileOwner(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  return applyActiveTools(pi, projectedOwnerTools(pi, state, owner));
+}
+
+function reconcileManagedOwners(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+) {
+  let changed = false;
+  for (const owner of state.managedOwners) {
+    changed = reconcileOwner(pi, state, owner) || changed;
+  }
+  return changed;
+}
+
+/** Reset one bound Pi Session to the minimal parent surface. */
+export function resetOpenPiToolSurface(
+  pi: ActiveToolSurface,
+  sourceByOwner: Readonly<Partial<Record<OpenPiToolOwner, string>>> = {},
+) {
+  const state = newState();
+  for (const [owner, source] of Object.entries(sourceByOwner)) {
+    if (source) state.sourceByOwner.set(owner as OpenPiToolOwner, source);
+  }
+  states.set(pi, state);
+  state.managedOwners.add("capabilities");
+  const changed = reconcileOwner(pi, state, "capabilities");
+  pi.events?.emit(OPENPI_CAPABILITY_STATE_CHANNEL, { loaded: [] });
+  return changed;
+}
+
+export function getLoadedOpenPiCapabilities(pi: ActiveToolSurface) {
+  return OPENPI_CAPABILITY_NAMES.filter((capability) =>
+    stateFor(pi).loaded.has(capability),
+  );
+}
+
+/**
+ * Load capability groups monotonically for this Session. There is deliberately
+ * no unload operation: a stable surface is more cache-friendly and easier for
+ * the model to reason about than tools that repeatedly disappear and return.
+ */
+export function loadOpenPiCapabilities(
+  pi: ActiveToolSurface,
+  capabilities: readonly OpenPiCapability[],
+) {
+  const invalid = capabilities.filter(
+    (capability) => !OPENPI_CAPABILITY_NAMES.includes(capability),
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown OpenPI ${invalid.length === 1 ? "capability" : "capabilities"}: ${invalid.map((name) => JSON.stringify(name)).join(", ")}.`,
+    );
+  }
+
+  const state = stateFor(pi);
+  const before = pi.getActiveTools();
+  const newlyLoaded: OpenPiCapability[] = [];
+  for (const capability of capabilities) {
+    if (!state.loaded.has(capability)) {
+      state.loaded.add(capability);
+      newlyLoaded.push(capability);
+    }
+  }
+  reconcileManagedOwners(pi, state);
+  pi.events?.emit(OPENPI_CAPABILITY_STATE_CHANNEL, {
+    loaded: getLoadedOpenPiCapabilities(pi),
+  });
+  const beforeSet = new Set(before);
+  return {
+    newlyLoaded,
+    loaded: getLoadedOpenPiCapabilities(pi),
+    activatedTools: pi.getActiveTools().filter((name) => !beforeSet.has(name)),
+  };
+}
+
+/**
+ * Record one owner's desired tools and reconcile them through both gates:
+ * capability loaded first, then the owner's authoritative resource/mode state.
+ * Foreign and Pi-native tools are always preserved from the latest active list.
+ */
+export function patchOwnedTools(
+  pi: ActiveToolSurface,
+  owner: OpenPiToolOwner,
+  patch: OwnedToolPatch,
+) {
+  const owned = [
+    ...OPENPI_TOOL_SURFACE[owner].entry,
+    ...OPENPI_TOOL_SURFACE[owner].deferred,
+  ] as readonly string[];
+  const ownedSet = new Set(owned);
+  const enable = new Set(patch.enable ?? []);
+  const disable = new Set(patch.disable ?? []);
+
+  for (const name of [...enable, ...disable]) {
+    if (!ownedSet.has(name)) {
+      throw new Error(`${owner} does not own tool ${JSON.stringify(name)}.`);
+    }
+  }
+  for (const name of enable) {
+    if (disable.has(name)) {
+      throw new Error(
+        `${owner} cannot enable and disable tool ${JSON.stringify(name)} in one patch.`,
+      );
+    }
+  }
+
+  const state = stateFor(pi);
+  state.managedOwners.add(owner);
+  if (capabilityForOwner(owner)) subscribeToCapabilityState(pi, state);
+  const desired = state.desiredByOwner.get(owner)!;
+  for (const name of enable) state.knownAvailable.add(name);
+  for (const name of disable) desired.delete(name);
+  for (const name of enable) desired.add(name);
+  return reconcileOwner(pi, state, owner);
+}

package/extensions/subagents/index.ts

@@ -65,6 +65,10 @@ import {
   hasActivity,
   unreadActivityCounts,
 } from "../shared/activity-status.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import { formatContextUtilization } from "./src/format.ts";
 import { SubagentManager, type SubagentManagerShape } from "./src/manager.ts";
 import {
@@ -198,6 +202,14 @@ export default function (pi: ExtensionAPI) {
   let requestWidgetRender: (() => void) | undefined;
   let dashboardOpen = false;
   const resultDelivery = createDeferredResultDelivery<SubagentSnapshot>();
+  const hideLifecycleTools = () =>
+    patchOwnedTools(pi, "subagents", {
+      disable: OPENPI_TOOL_SURFACE.subagents.deferred,
+    });
+  const showLifecycleTools = () =>
+    patchOwnedTools(pi, "subagents", {
+      enable: OPENPI_TOOL_SURFACE.subagents.deferred,
+    });
 
   const getRuntime = () => (runtime ??= createSubagentRuntime());
 
@@ -408,6 +420,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_start", (_event, ctx) => {
     refreshAgentTypes(ctx.cwd, ctx.isProjectTrusted());
+    hideLifecycleTools();
     sessionContext = ctx;
     settledAcknowledgedAt = 0;
     if (ctx.hasUI) ui = ctx.ui;
@@ -633,7 +646,7 @@ export default function (pi: ExtensionAPI) {
         ? planModeChildTools(declaredChildTools)
         : declaredChildTools;
       const childTools = effectiveChildToolAllowlist(requestedChildTools);
-      // Read at spawn time so `/my-pi-setup` changes affect the next child
+      // Read at spawn time so `/openpi-setup` changes affect the next child
       // without reloading this extension. Undefined preserves parent-model
       // inheritance in the backend.
       const model = selectSubagentModel(
@@ -681,6 +694,8 @@ export default function (pi: ExtensionAPI) {
         throw error;
       }
 
+      showLifecycleTools();
+
       return {
         content: [
           {

package/extensions/subagents/src/manager.ts

@@ -205,7 +205,8 @@ const makeManager = Effect.gen(function* () {
   let reservedBtw = 0;
   let disposed = false;
   let onSettled:
-    ((snap: SubagentSnapshot, consumed: boolean) => void) | undefined;
+    | ((snap: SubagentSnapshot, consumed: boolean) => void)
+    | undefined;
 
   const notify = (id?: string) => {
     const waiters = changeWaiters;
@@ -636,16 +637,17 @@ const makeManager = Effect.gen(function* () {
             pruneSettled();
           }),
         ),
-        Effect.map((): ReadonlyArray<CancelResult> =>
-          unique.map((id) => {
-            const snapshot = entries.get(id)?.snapshot;
-            return {
-              id,
-              title: snapshot?.title ?? "?",
-              status: snapshot?.status ?? "error",
-              cancelled: runningIds.includes(id),
-            };
-          }),
+        Effect.map(
+          (): ReadonlyArray<CancelResult> =>
+            unique.map((id) => {
+              const snapshot = entries.get(id)?.snapshot;
+              return {
+                id,
+                title: snapshot?.title ?? "?",
+                status: snapshot?.status ?? "error",
+                cancelled: runningIds.includes(id),
+              };
+            }),
         ),
       );
     });

package/extensions/subagents/src/prompt.ts

@@ -75,7 +75,7 @@ export const SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS = {
   workingDir:
     "Trusted working directory for the autonomous child (default: current working directory)",
   isolation:
-    'Set to "worktree" to run this child in its own git worktree on its own branch, branched from HEAD. Use it whenever children may edit the same files or stage changes concurrently — without it, parallel children share one checkout and one git index, so their edits and `git add`s overwrite each other. The child should COMMIT its work. A direct child can receive later subagent_send turns, so its checkout lives with that child Session. On retirement it is reclaimed only when a bounded inspection proves it empty; commits, dirty/untracked/ignored files, detached HEAD, timeout, or Git failure preserve it. Requires a git repository, and the checkout starts clean, so anything gitignored (build output, .env) will not be there.',
+    'Set to "worktree" for concurrent writers and tell the child to commit. Requires Git and a clean checkout. Read the subagents Skill for lifecycle, merge location, and costs.',
   model:
     'Optional model override, as "provider/model-id" or a bare id resolved against the current provider. Precedence: explicit spawn model > selected type file model > configured built-in role model > parent model. Never guess a model name.',
   reasoningEffort: