@pasko70/pibo 2.2.4 → 2.3.0

package/dist/agent-runtime/capabilities.js

@@ -27,6 +27,9 @@ const BOOLEAN_CAPABILITY_PATHS = [
     "nativeSubagents.supported",
     "nativeSubagents.configurable",
     "nativeSubagents.enabledByDefault",
+    "tools.intentTracing.supported",
+    "tools.intentTracing.configurable",
+    "tools.intentTracing.enabledByDefault",
     "historyImport",
     "auth.status",
     "auth.cancel",
@@ -121,7 +124,7 @@ export function validateAgentRuntimeCapabilities(value) {
     if (reasoningSupported === false && Array.isArray(reasoningValues) && reasoningValues.length > 0) {
         errors.push("reasoning.values must be omitted or empty when reasoning is unsupported");
     }
-    for (const feature of ["contextDiscovery", "nativeSubagents"]) {
+    for (const feature of ["contextDiscovery", "nativeSubagents", "tools.intentTracing"]) {
         const supported = readPath(value, `${feature}.supported`);
         const configurable = readPath(value, `${feature}.configurable`);
         const enabledByDefault = readPath(value, `${feature}.enabledByDefault`);
@@ -243,6 +246,11 @@ export function createMinimalAgentRuntimeCapabilities() {
             piboManaged: unavailable,
             nativeToolInspection: unavailable,
             nativeToolYielding: unavailable,
+            intentTracing: {
+                supported: false,
+                configurable: false,
+                enabledByDefault: false,
+            },
         },
         mcp: {
             externalServers: unavailable,

package/dist/agent-runtime/context-build.js

@@ -1,4 +1,5 @@
 import { InitialSessionContext } from "../core/profiles.js";
+import { PIBO_AGENT_TOOL_NAMES, listAvailableAgents } from "../subagents/tool.js";
 export function profileWithRuntimeInstance(profile, runtimeInstanceId) {
     if (profile.runtimeInstanceId === runtimeInstanceId)
         return profile;
@@ -61,9 +62,11 @@ export function buildPortableRuntimeContextSnapshot(input) {
         },
         payloadJson: input.runtime.capabilities,
     });
-    addRuntimeContributionGroup(nodes, "tools", "Pibo Tools and Subagents", [
+    const availableAgents = listAvailableAgents(profile.subagents);
+    addRuntimeContributionGroup(nodes, "tools", "Pibo Tools and Delegated Agents", [
         ...profile.tools.filter((tool) => tool.enabled !== false).map((tool) => tool.name),
-        ...profile.subagents.filter((subagent) => subagent.enabled !== false).map((subagent) => `subagent:${subagent.name} -> ${subagent.targetProfile}`),
+        ...(availableAgents.length > 0 ? PIBO_AGENT_TOOL_NAMES : []),
+        ...availableAgents.map((agent) => `agent:${agent.name} (${agent.profile}) — ${agent.description}`),
         ...(profile.toolPackages.goalControl !== false ? ["package:pibo-goal-control"] : []),
         ...(profile.toolPackages.runControl === true ? ["package:pibo-run-control"] : []),
     ], input.runtime.capabilities.tools.piboManaged);

package/dist/agent-runtimes/codex-native/adapter.js

@@ -51,6 +51,11 @@ function codexNativeCapabilities(structuredUserInput) {
                 reason: "Stable Codex App Server 0.147.0 does not expose a complete pre-turn native-tool inventory; Pibo reports selected MCP tools immediately and harness-native tools after stable item notifications prove they are active.",
             },
             nativeToolYielding: unsupportedAgentRuntimeCapability("Codex native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
+            intentTracing: {
+                supported: false,
+                configurable: false,
+                enabledByDefault: false,
+            },
         },
         mcp: {
             externalServers: { support: "mcp", transports: ["streamable-http", "stdio"] },

package/dist/agent-runtimes/omp/adapter.js

@@ -50,6 +50,11 @@ function ompCapabilities() {
                 reason: "OMP exposes its native tool inventory via get_state.dumpTools and runtime tool_execution items; a complete pre-turn inventory is only partially exposed through RPC.",
             },
             nativeToolYielding: unsupportedAgentRuntimeCapability("OMP native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
+            intentTracing: {
+                supported: true,
+                configurable: false,
+                enabledByDefault: true,
+            },
         },
         mcp: {
             externalServers: { support: "unsupported", reason: "OMP manages its own MCP; external MCP delivery is not wired in the initial OMP adapter." },

package/dist/agent-runtimes/omp/turn.js

@@ -238,11 +238,13 @@ export class OmpRpcTurnController {
             return;
         }
         if (frame.type === "tool_execution_start") {
+            const intent = typeof frame.intent === "string" ? frame.intent.trim() : "";
             this.emit({
                 type: "tool_execution_started",
                 toolCallId: frame.toolCallId,
                 toolName: frame.toolName,
                 args: frame.args,
+                ...(intent ? { intent } : {}),
             });
             return;
         }

package/dist/agent-runtimes/pi/adapter.js

@@ -10,6 +10,7 @@ import { loadModelCatalog as loadPiModelCatalog, piAgentRuntimeModelCatalog, } f
 import { inspectPiAgentRuntimeHistory, readPiAgentRuntimeHistory, } from "./history.js";
 import { PiAgentRuntimeAuthController } from "./auth.js";
 import { importPortableHistoryIntoPi } from "./portable-history.js";
+import { piIntentTracingEnabled } from "./intent-tracing.js";
 const PI_ADAPTER_ID = "pi";
 export const PI_PROTOCOL_VERSION = "0.84.2";
 export const PI_AGENT_RUNTIME_CAPABILITIES = {
@@ -43,6 +44,11 @@ export const PI_AGENT_RUNTIME_CAPABILITIES = {
         piboManaged: { support: "direct" },
         nativeToolInspection: { support: "native" },
         nativeToolYielding: { support: "native" },
+        intentTracing: {
+            supported: true,
+            configurable: true,
+            enabledByDefault: false,
+        },
     },
     mcp: {
         externalServers: { support: "materialized", modes: ["isolated-pibo-mcp-config"] },
@@ -165,7 +171,7 @@ function nativeSessionInfoFromPi(runtimeInstanceId, info) {
         firstMessage: info.firstMessage,
     };
 }
-function semanticEventFromPibo(event) {
+export function semanticEventFromPibo(event) {
     switch (event.type) {
         case "message_started":
             return { type: "turn_started", turnId: event.eventId };
@@ -188,6 +194,7 @@ function semanticEventFromPibo(event) {
                 toolName: event.toolName,
                 args: event.args,
                 argsComplete: event.argsComplete,
+                ...(event.intent ? { intent: event.intent } : {}),
             };
         case "tool_execution_started":
             return { ...event, type: "tool_execution_started" };
@@ -519,12 +526,23 @@ class PiAgentRuntimeAdapter {
                 message: `Profile "${input.profile.profileName}" selects runtime instance "${input.profile.runtimeInstanceId}", not "${this.instanceId}".`,
             });
         }
-        if (Object.keys(input.profile.runtimeOptions).length > 0) {
+        const runtimeOptionKeys = Object.keys(input.profile.runtimeOptions);
+        for (const key of runtimeOptionKeys) {
+            if (key === "intentTracing")
+                continue;
+            diagnostics.push({
+                severity: "error",
+                code: "pi_runtime_option_unsupported",
+                message: `The Pi runtime does not accept profile option "${key}".`,
+                path: `runtimeOptions.${key}`,
+            });
+        }
+        if ("intentTracing" in input.profile.runtimeOptions && typeof input.profile.runtimeOptions["intentTracing"] !== "boolean") {
             diagnostics.push({
                 severity: "error",
-                code: "pi_runtime_options_unsupported",
-                message: "The Pi runtime does not accept adapter-specific profile options.",
-                path: "runtimeOptions",
+                code: "pi_intent_tracing_invalid",
+                message: "Pi intentTracing must be a boolean.",
+                path: "runtimeOptions.intentTracing",
             });
         }
         const profileProvidesBash = input.profile.toolPackages.runControl === true
@@ -582,14 +600,16 @@ class PiAgentRuntimeAdapter {
             throw new Error("Pi portable history import requires a new native session.");
         }
         const compatibility = input.services?.compatibility;
+        const profile = cloneProfileForPiSession(input);
+        const intentTracing = piIntentTracingEnabled(profile.runtimeOptions);
         const runtime = await createPiboRuntime({
             cwd: input.workspace,
             persistSession: compatibility?.persistSession,
-            profile: cloneProfileForPiSession(input),
+            profile,
             thinkingLevel: compatibility?.thinkingLevel,
             retryDefaults: compatibility?.retryDefaults,
             extensionFactories: compatibility?.extensionFactories,
-            subagentRunner: input.services?.subagentRunner,
+            agentsController: input.services?.agentsController,
             runToolController: input.services?.runToolController,
             runtimeToolController: input.services?.codeRuntimeToolController,
             portableTools: input.services?.portableTools,
@@ -631,6 +651,7 @@ class PiAgentRuntimeAdapter {
             metadata: {
                 ...(input.binding?.metadata ?? {}),
                 persistent: compatibility?.persistSession !== false,
+                intentTracing,
                 nativePresenceExpected: compatibility?.persistSession !== false
                     && runtime.session.sessionManager.buildSessionContext().messages.length > 0,
             },

package/dist/agent-runtimes/pi/intent-tracing.js

@@ -0,0 +1,120 @@
+export const PI_TOOL_INTENT_FIELD = "i";
+const PI_TOOL_INTENT_FALLBACK_FIELD = "__pibo_intent";
+const intentTracingSessions = new WeakMap();
+const PI_TOOL_INTENT_SCHEMA = {
+    type: "string",
+    minLength: 1,
+    description: "Capitalized 2–6-word present-participle intent describing why this tool is being called; no period.",
+};
+export function piIntentTracingEnabled(runtimeOptions) {
+    return runtimeOptions["intentTracing"] === true;
+}
+export function splitPiToolIntentArguments(value, intentField = PI_TOOL_INTENT_FIELD) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return { args: value };
+    const record = value;
+    const intentValue = record[intentField];
+    const intent = typeof intentValue === "string" && intentValue.trim() ? intentValue.trim() : undefined;
+    const { [intentField]: _intent, ...args } = record;
+    return intent ? { args, intent } : { args };
+}
+export function piToolIntentFieldForSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return PI_TOOL_INTENT_FIELD;
+    const record = schema;
+    if (record.type !== "object")
+        return PI_TOOL_INTENT_FIELD;
+    const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)
+        ? record.properties
+        : {};
+    const required = new Set(Array.isArray(record.required)
+        ? record.required.filter((name) => typeof name === "string")
+        : []);
+    const fieldIsUsed = (field) => Object.prototype.hasOwnProperty.call(properties, field) || required.has(field);
+    if (!fieldIsUsed(PI_TOOL_INTENT_FIELD))
+        return PI_TOOL_INTENT_FIELD;
+    let candidate = PI_TOOL_INTENT_FALLBACK_FIELD;
+    let suffix = 2;
+    while (fieldIsUsed(candidate))
+        candidate = `${PI_TOOL_INTENT_FALLBACK_FIELD}_${suffix++}`;
+    return candidate;
+}
+export function injectPiToolIntentSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return schema;
+    const record = schema;
+    if (record.type !== "object")
+        return schema;
+    const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)
+        ? record.properties
+        : {};
+    const intentField = piToolIntentFieldForSchema(schema);
+    const required = Array.isArray(record.required)
+        ? record.required.filter((name) => typeof name === "string" && name !== intentField)
+        : [];
+    return {
+        ...record,
+        properties: {
+            [intentField]: PI_TOOL_INTENT_SCHEMA,
+            ...properties,
+        },
+        required: [intentField, ...required],
+    };
+}
+export function piIntentTracingInstalled(session) {
+    return intentTracingSessions.has(session);
+}
+export function piToolIntentField(session, toolName) {
+    return intentTracingSessions.get(session)?.get(toolName);
+}
+export function installPiIntentTracing(session) {
+    if (intentTracingSessions.has(session))
+        return;
+    const intentFields = new Map();
+    const wrappedTools = new WeakMap();
+    const wrapActiveTools = () => {
+        session.agent.state.tools = session.agent.state.tools.map((tool) => {
+            const existing = wrappedTools.get(tool);
+            if (existing) {
+                intentFields.set(tool.name, existing.intentField);
+                return existing.tool;
+            }
+            const wrapped = wrapPiToolWithIntent(tool);
+            wrappedTools.set(tool, wrapped);
+            intentFields.set(tool.name, wrapped.intentField);
+            return wrapped.tool;
+        });
+    };
+    const setActiveToolsByName = session.setActiveToolsByName.bind(session);
+    session.setActiveToolsByName = (toolNames) => {
+        setActiveToolsByName(toolNames);
+        wrapActiveTools();
+    };
+    intentTracingSessions.set(session, intentFields);
+    wrapActiveTools();
+}
+function wrapPiToolWithIntent(tool) {
+    const prepareArguments = tool.prepareArguments;
+    const intentField = piToolIntentFieldForSchema(tool.parameters);
+    return {
+        intentField,
+        tool: {
+            ...tool,
+            parameters: injectPiToolIntentSchema(tool.parameters),
+            prepareArguments: (rawArgs) => {
+                const { args, intent } = splitPiToolIntentArguments(rawArgs, intentField);
+                const prepared = prepareArguments ? prepareArguments(args) : args;
+                if (!prepared || typeof prepared !== "object" || Array.isArray(prepared))
+                    return prepared;
+                return {
+                    ...prepared,
+                    ...(intent ? { [intentField]: intent } : {}),
+                };
+            },
+            execute: async (toolCallId, params, signal, onUpdate) => {
+                const { args } = splitPiToolIntentArguments(params, intentField);
+                return await tool.execute(toolCallId, args, signal, onUpdate);
+            },
+        },
+    };
+}

package/dist/agent-runtimes/pi/routed-session.js

@@ -6,6 +6,7 @@ import { expandInlineSkills } from "../../core/skill-expansion.js";
 import { PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE, PIBO_CONTEXT_GUARD_RESUME_PROMPT, cancelPiboAssistantContextGuardRecovery, claimPiboAssistantContextGuardRecovery, waitForPiboAssistantContextGuardRecovery, } from "../../core/context-guard.js";
 import { PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE, PIBO_PROVIDER_RECOVERY_PROMPT, PiboProviderRecoveryCancelledError, isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "../../core/provider-recovery.js";
 import { PiAgentRuntimeAuthController } from "./auth.js";
+import { piIntentTracingInstalled, piToolIntentField, splitPiToolIntentArguments } from "./intent-tracing.js";
 import { loadModelCatalog as loadPiModelCatalog } from "./model-catalog.js";
 import { PIBO_TRANSCRIPT_INTEGRITY_RESUME_MESSAGE_TYPE, PIBO_TRANSCRIPT_INTEGRITY_RESUME_PROMPT, PiboTranscriptIntegrityError, claimPiboTranscriptIntegrityContinuation, settlePiboTranscriptIntegrityContinuation, } from "../../core/transcript-integrity.js";
 const FAST_SERVICE_TIER = "priority";
@@ -175,45 +176,57 @@ function toolCallFromAssistantEvent(candidate) {
     }
     return toolCallFromMessage(candidate.message, candidate.assistantMessageEvent?.contentIndex);
 }
-function normalizeToolCallEvent(piboSessionId, candidate) {
+function normalizeToolCallEvent(piboSessionId, candidate, context) {
     if (candidate.type === "message_update" &&
         (candidate.assistantMessageEvent?.type === "toolcall_start" ||
             candidate.assistantMessageEvent?.type === "toolcall_end")) {
         const toolCall = toolCallFromAssistantEvent(candidate);
         if (!toolCall)
             return undefined;
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(toolCall.args, context.intentFieldForTool?.(toolCall.name))
+            : { args: toolCall.args };
         return {
             type: "tool_call",
             piboSessionId,
             toolCallId: toolCall.id,
             toolName: toolCall.name,
-            args: toolCall.args,
+            args,
             argsComplete: candidate.assistantMessageEvent.type === "toolcall_end",
+            ...(intent ? { intent } : {}),
         };
     }
     return undefined;
 }
-function normalizeToolExecutionEvent(piboSessionId, candidate) {
+function normalizeToolExecutionEvent(piboSessionId, candidate, context) {
     if (typeof candidate.toolCallId !== "string" || typeof candidate.toolName !== "string") {
         return undefined;
     }
     if (candidate.type === "tool_execution_start") {
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(candidate.args, context.intentFieldForTool?.(candidate.toolName))
+            : { args: candidate.args };
         return {
             type: "tool_execution_started",
             piboSessionId,
             toolCallId: candidate.toolCallId,
             toolName: candidate.toolName,
-            args: candidate.args,
+            args,
+            ...(intent ? { intent } : {}),
         };
     }
     if (candidate.type === "tool_execution_update") {
+        const { args, intent } = context?.intentTracing
+            ? splitPiToolIntentArguments(candidate.args, context.intentFieldForTool?.(candidate.toolName))
+            : { args: candidate.args };
         return {
             type: "tool_execution_updated",
             piboSessionId,
             toolCallId: candidate.toolCallId,
             toolName: candidate.toolName,
-            args: candidate.args,
+            args,
             partialResult: candidate.partialResult,
+            ...(intent ? { intent } : {}),
         };
     }
     if (candidate.type === "tool_execution_end") {
@@ -332,10 +345,10 @@ export function normalizePiEvent(piboSessionId, event, context) {
             ? { type: "thinking_finished", piboSessionId, contentIndex: messageContentIndex(candidate) }
             : { type: "thinking_finished", piboSessionId, contentIndex: messageContentIndex(candidate), text };
     }
-    const toolCallEvent = normalizeToolCallEvent(piboSessionId, candidate);
+    const toolCallEvent = normalizeToolCallEvent(piboSessionId, candidate, context);
     if (toolCallEvent)
         return toolCallEvent;
-    const toolExecutionEvent = normalizeToolExecutionEvent(piboSessionId, candidate);
+    const toolExecutionEvent = normalizeToolExecutionEvent(piboSessionId, candidate, context);
     if (toolExecutionEvent)
         return toolExecutionEvent;
     if (candidate.type === "message_end") {
@@ -553,7 +566,11 @@ export class RoutedSession {
         this.unsubscribe = session.subscribe((event) => {
             this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id });
             const model = this.runtime.session.model;
-            const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
+            const normalized = normalizePiEvent(this.piboSessionId, event, {
+                contextWindow: numberValue(model?.contextWindow),
+                intentTracing: piIntentTracingInstalled(session),
+                intentFieldForTool: (toolName) => piToolIntentField(session, toolName),
+            });
             const candidate = event && typeof event === "object" ? event : undefined;
             const assistantMessageEnded = candidate?.type === "message_end" && isAssistantMessage(candidate.message);
             const usageEvent = assistantMessageEnded ? normalizeAssistantUsageEvent(this.piboSessionId, candidate?.message) : undefined;

package/dist/agent-runtimes/pi/runtime.js

@@ -5,7 +5,7 @@ import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentS
 import { DEFAULT_BUILTIN_TOOL_NAMES, InitialSessionContext, } from "../../core/profiles.js";
 import { loadPiboModelDefaults, selectRequestedModelProfile, selectRequestedThinkingLevel } from "../../core/model-defaults.js";
 import { createDefaultPiboProfile } from "../../core/default-profile.js";
-import { createSubagentToolName, } from "../../subagents/tool.js";
+import { PIBO_AGENT_TOOL_NAMES, } from "../../subagents/tool.js";
 import { getInstalledCliToolContextFile } from "../../tools/registry.js";
 import { createCodexCompatExtension } from "../../core/codex-compat.js";
 import { createWebSearchProviderExtension, isWebSearchProviderTool } from "../../tools/web-search.js";
@@ -28,6 +28,7 @@ import { compactValidationToolResultForContext } from "../../core/test-output-co
 import { installPiboTranscriptIntegrity } from "../../core/transcript-integrity.js";
 import { normalizePiboToolDefinition, } from "../../tools/contract.js";
 import { compilePiboToolForPi } from "./tool-compiler.js";
+import { installPiIntentTracing, piIntentTracingEnabled } from "./intent-tracing.js";
 import { createPiboSessionToolDefinitions, isCodexBrowserToolProfile as isCodexBrowserTool, isEnabledCodexBrowserToolProfile as isEnabledCodexBrowserTool, isEnabledRuntimeToolProfile as isEnabledRuntimeTool, isGeneratedPiboTool, isRuntimeToolProfile as isRuntimeTool, } from "../../tools/session-tool-set.js";
 function hasOwnRetrySetting(settings, key) {
     return settings !== undefined && settings !== null && Object.prototype.hasOwnProperty.call(settings, key);
@@ -154,11 +155,20 @@ function getProfileExtensionFactories(profile, extensionFactories, contextGuardR
         ...(extensionFactories ?? []),
     ];
 }
-function createInspectionSubagentRunner() {
+function createInspectionAgentsController() {
+    const fail = () => {
+        throw new Error("Profile inspection cannot execute delegated-agent tools");
+    };
     return {
-        async runSubagent() {
-            throw new Error("Profile inspection cannot execute subagents");
-        },
+        sendMessage: fail,
+        listAgents: () => [],
+        observe: (input) => ({
+            filters: input,
+            observations: [],
+            nextAfterSequence: input.afterSequence ?? 0,
+            truncated: false,
+        }),
+        killAgent: fail,
     };
 }
 function createInspectionRunToolController() {
@@ -190,6 +200,9 @@ async function createSessionManager(cwd, profile, persistSession) {
 export async function createPiboRuntime(options = {}) {
     const cwd = options.cwd ?? getDefaultPiboWorkspace();
     const profile = options.profile ?? createDefaultPiboProfile();
+    if (profile.subagents.some((subagent) => subagent.enabled !== false) && options.subagentRunner && !options.agentsController && !options.portableTools) {
+        throw new Error("PiboRuntimeOptions.subagentRunner is retired. Provide agentsController so the runtime can expose the four pibo_agents_* management tools. The deprecated createSubagentToolDefinitions export remains available only for external legacy tool assembly.");
+    }
     const agentDir = getAgentDir();
     const sessionManager = await createSessionManager(cwd, profile, options.persistSession !== false);
     const createRuntime = async ({ cwd: runtimeCwd, agentDir: runtimeAgentDir, sessionManager: runtimeSessionManager, sessionStartEvent, }) => {
@@ -284,7 +297,7 @@ export async function createPiboRuntime(options = {}) {
             : createPiboSessionToolDefinitions({
                 profile,
                 toolContext,
-                subagentRunner: options.subagentRunner,
+                agentsController: options.agentsController,
                 runToolController: options.runToolController,
                 runtimeToolController,
                 codexBrowserController,
@@ -306,6 +319,8 @@ export async function createPiboRuntime(options = {}) {
             noTools: profile.builtinTools === "disabled" ? "builtin" : undefined,
             tools: getBuiltinToolAllowlist(profile, piboToolDefinitions),
         });
+        if (piIntentTracingEnabled(profile.runtimeOptions))
+            installPiIntentTracing(created.session);
         installPiboTranscriptIntegrity(created.session);
         installValidationOutputCompaction(created.session.agent);
         registerPiboAssistantContextGuardRecovery(created.session, contextGuardRecovery);
@@ -414,7 +429,7 @@ export async function inspectPiboProfile(options = {}) {
         persistSession: false,
         modelDefaults: {},
         activeModel: undefined,
-        subagentRunner: options.subagentRunner ?? (hasEnabledSubagents ? createInspectionSubagentRunner() : undefined),
+        agentsController: options.agentsController ?? (hasEnabledSubagents ? createInspectionAgentsController() : undefined),
         runToolController: options.runToolController ?? (hasYieldableTools ? createInspectionRunToolController() : undefined),
     });
     try {
@@ -459,14 +474,11 @@ export async function inspectPiboProfile(options = {}) {
                 registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool) || isCodexBrowserTool(tool),
                 active: activeToolNames.has(tool.name) || tool.providerTool !== undefined,
             })).concat(generatedTools),
-            subagents: profile.subagents.map((subagent) => {
-                const toolName = createSubagentToolName(subagent.name);
-                return {
-                    name: subagent.name,
-                    targetProfile: subagent.targetProfile,
-                    active: activeToolNames.has(toolName),
-                };
-            }),
+            subagents: profile.subagents.map((subagent) => ({
+                name: subagent.name,
+                targetProfile: subagent.targetProfile,
+                active: subagent.enabled !== false && activeToolNames.has(PIBO_AGENT_TOOL_NAMES[0]),
+            })),
             mcpServers: [...profile.mcpServers],
             mcpStatus: options.resources?.getInspection().mcpServers.map((server) => structuredClone(server)) ?? [],
             resourceDelivery: options.resources?.getInspection().delivery.map((report) => ({ ...report })) ?? [],
@@ -521,7 +533,7 @@ function installPiboContextGuardTuiQueueOrdering(session) {
 export async function runPiboTui(options = {}) {
     const profile = options.profile ?? createDefaultPiboProfile();
     const hasEnabledSubagents = profile.subagents.some((subagent) => subagent.enabled !== false);
-    if (hasEnabledSubagents && (!options.subagentRunner || !options.runToolController)) {
+    if (hasEnabledSubagents && (!options.agentsController || !options.runToolController)) {
         console.error(`Error: Profile "${profile.profileName}" uses subagents and requires the routed pibo runtime. ` +
             `Use "npm run tui:routed -- ${profile.profileName}" for local TUI QA.`);
         process.exitCode = 1;

package/dist/apps/chat/chat-settings-routes.js

@@ -1,7 +1,8 @@
 import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
 import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
+import { loadPiboGatewaySettings, sanitizeConcurrentYieldedRuns, updatePiboGatewaySettings, } from "../../core/gateway-settings.js";
 import { sanitizeTelemetryRetentionDays, sanitizeTelemetryRetentionSettings } from "../../core/telemetry-retention-settings.js";
-import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
+import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, sanitizeTranscriptionProviderId, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { CHAT_WEB_API_PREFIX } from "./chat-api-routes.js";
 import { normalizeBasePromptMarkdown, normalizeBasePromptMode, normalizeCompactionPromptMarkdown, normalizeCompactionPromptMode, updateChatModelDefaults, } from "./chat-request-normalizers.js";
@@ -13,6 +14,10 @@ export function chatSettingsRoute(pathname, method) {
         return { kind: "user-settings", action: "read" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/user-settings` && method === "PATCH")
         return { kind: "user-settings", action: "update" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/gateway-settings` && method === "GET")
+        return { kind: "gateway-settings", action: "read" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/gateway-settings` && method === "PATCH")
+        return { kind: "gateway-settings", action: "update" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/telemetry-retention/prune` && method === "POST")
         return { kind: "telemetry-retention", action: "prune" };
     if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "GET")
@@ -46,7 +51,13 @@ export async function handleChatSettingsRoute(input) {
         if (route.action === "read")
             return responseJson({ userSettings: loadPiboUserSettings() });
         const body = await readJsonBody(request);
-        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body)) });
+        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body, input.transcriptionProviderIds)) });
+    }
+    if (route.kind === "gateway-settings") {
+        if (route.action === "read")
+            return responseJson({ gatewaySettings: loadPiboGatewaySettings() });
+        const body = await readJsonBody(request);
+        return responseJson({ gatewaySettings: updatePiboGatewaySettings(gatewaySettingsPatch(body)) });
     }
     if (route.kind === "telemetry-retention") {
         if (!input.dataStore)
@@ -77,7 +88,25 @@ export async function handleChatSettingsRoute(input) {
     }
     return responseJson({ compactionPrompt: await savePiboCustomCompactionPrompt(normalizeCompactionPromptMarkdown(body.markdown), cwd) });
 }
-function userSettingsPatch(body) {
+function gatewaySettingsPatch(body) {
+    const patch = {};
+    if (body.maxConcurrentYieldedRuns !== undefined) {
+        const value = sanitizeConcurrentYieldedRuns(body.maxConcurrentYieldedRuns);
+        if (!value)
+            throw new PiboWebHttpError("Invalid gateway yielded-run concurrency", 400);
+        patch.maxConcurrentYieldedRuns = value;
+    }
+    if (body.sessionConcurrentYieldedRuns !== undefined) {
+        const value = sanitizeConcurrentYieldedRuns(body.sessionConcurrentYieldedRuns);
+        if (!value)
+            throw new PiboWebHttpError("Invalid session yielded-run concurrency", 400);
+        patch.sessionConcurrentYieldedRuns = value;
+    }
+    if (Object.keys(patch).length === 0)
+        throw new PiboWebHttpError("No gateway settings provided", 400);
+    return patch;
+}
+function userSettingsPatch(body, transcriptionProviderIds) {
     const patch = {};
     if (body.timezone !== undefined) {
         const timezone = sanitizeTimezone(body.timezone);
@@ -87,6 +116,18 @@ function userSettingsPatch(body) {
     }
     if (body.shortcuts !== undefined)
         patch.shortcuts = sanitizeShortcutSettings(body.shortcuts);
+    if (body.transcription !== undefined) {
+        const raw = body.transcription && typeof body.transcription === "object" && !Array.isArray(body.transcription)
+            ? body.transcription
+            : {};
+        const providerId = sanitizeTranscriptionProviderId(raw.providerId);
+        if (!providerId)
+            throw new PiboWebHttpError("Invalid transcription provider", 400);
+        if (transcriptionProviderIds && !transcriptionProviderIds.includes(providerId)) {
+            throw new PiboWebHttpError(`Unknown transcription provider "${providerId}"`, 400);
+        }
+        patch.transcription = { providerId };
+    }
     if (body.telemetryRetention !== undefined) {
         const current = loadPiboUserSettings().telemetryRetention;
         patch.telemetryRetention = {