@pasko70/pibo 2.2.5 → 2.4.0

package/dist/debug/agents.js

@@ -0,0 +1,391 @@
+import { normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationText, } from "../subagents/observations.js";
+import { createDebugPayloadStore, hydrateDebugEventRow } from "./persisted-payloads.js";
+import { eventAttributes, eventPayload } from "./payloads.js";
+import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+import { resolveDebugStore } from "./stores.js";
+export async function runDebugAgentsCli(args) {
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        printDebugAgentsDiscovery();
+        return;
+    }
+    const parentPiboSessionId = args[0];
+    const command = args[1];
+    if (!command || command === "--help" || command === "-h") {
+        printDebugAgentsDiscovery(parentPiboSessionId);
+        return;
+    }
+    if (command !== "list" && command !== "observe") {
+        throw new Error(`Unknown pibo debug agents command "${command}". Run pibo debug agents ${parentPiboSessionId} --help.`);
+    }
+    if (args.slice(2).some((arg) => arg === "--help" || arg === "-h")) {
+        printDebugAgentsCommandHelp(parentPiboSessionId, command);
+        return;
+    }
+    const parsed = parseAgentDebugOptions(args.slice(2));
+    validateAgentDebugOptions(command, parsed);
+    const store = resolveDebugStore("pibo-data");
+    if (command === "list") {
+        const agents = inspectDebugAgentList(parentPiboSessionId, store, {
+            name: parsed.names[0],
+            status: parsed.status,
+        });
+        if (parsed.json)
+            console.log(JSON.stringify({ parentPiboSessionId, agents }, null, 2));
+        else
+            console.log(formatDebugAgentList(parentPiboSessionId, agents));
+        return;
+    }
+    const result = inspectDebugAgentObservations(parentPiboSessionId, store, {
+        agentIds: parsed.agentIds.length ? parsed.agentIds : undefined,
+        names: parsed.names.length ? parsed.names : undefined,
+        threadKeys: parsed.threadKeys.length ? parsed.threadKeys : undefined,
+        eventTypes: parsed.eventTypes.length ? parsed.eventTypes : undefined,
+        kinds: parsed.kinds.length ? parsed.kinds : undefined,
+        since: parsed.since,
+        until: parsed.until,
+        textContains: parsed.textContains,
+        afterSequence: parsed.afterSequence,
+        order: parsed.order,
+        limit: parsed.limit,
+        includeDetails: parsed.details,
+    });
+    if (parsed.json)
+        console.log(JSON.stringify(result, null, 2));
+    else
+        console.log(formatDebugAgentObservations(result));
+}
+export function inspectDebugAgentList(parentPiboSessionId, store, options = {}) {
+    if (!store.exists)
+        throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        return readOwnedAgents(db, parentPiboSessionId)
+            .filter((agent) => !options.name || agent.name === options.name)
+            .filter((agent) => !options.status || agent.status === options.status);
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+export function inspectDebugAgentObservations(parentPiboSessionId, store, input = {}) {
+    if (!store.exists)
+        throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        const order = normalizePiboAgentObservationOrder(input.order);
+        const limit = normalizePiboAgentObservationLimit(input.limit);
+        const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
+        const since = parsePiboAgentObservationTimestamp(input.since, "since");
+        const until = parsePiboAgentObservationTimestamp(input.until, "until");
+        if (since !== undefined && until !== undefined && since > until)
+            throw new Error("Agent observation since must not be after until.");
+        const owned = readOwnedAgents(db, parentPiboSessionId);
+        const ownedById = new Map(owned.map((agent) => [agent.agentId, agent]));
+        for (const agentId of input.agentIds ?? []) {
+            if (!ownedById.has(agentId))
+                throw new Error(`Agent "${agentId}" is not owned by Pibo session "${parentPiboSessionId}".`);
+        }
+        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
+        const names = input.names ? new Set(input.names) : undefined;
+        const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
+        const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
+        const kinds = input.kinds ? new Set(input.kinds) : undefined;
+        const payloadStore = createDebugPayloadStore(db, store);
+        const clauses = ["s.parent_id = ?", "s.channel = 'pibo.subagents'", "s.kind = 'subagent'", "s.deleted_at IS NULL"];
+        const values = [parentPiboSessionId];
+        if (afterSequence !== undefined) {
+            clauses.push("e.stream_id > ?");
+            values.push(afterSequence);
+        }
+        const scanOrder = afterSequence !== undefined ? "ASC" : order.toUpperCase();
+        const statement = db.prepare(`
+			SELECT e.stream_id, e.session_id, e.session_sequence, e.event_id, e.type, e.created_at,
+				e.payload_ref, e.preview_text, e.attributes_json, s.profile, s.metadata_json
+			FROM event_log e
+			JOIN sessions s ON s.id = e.session_id
+			WHERE ${clauses.join(" AND ")}
+			ORDER BY e.stream_id ${scanOrder}
+		`);
+        const textContains = input.textContains?.toLowerCase();
+        const matches = [];
+        for (const rawRow of statement.iterate(...values)) {
+            const agent = ownedById.get(rawRow.session_id ?? "");
+            if (!agent)
+                continue;
+            if (agentIds && !agentIds.has(agent.agentId))
+                continue;
+            if (names && !names.has(agent.name))
+                continue;
+            if (threadKeys && (!agent.threadKey || !threadKeys.has(agent.threadKey)))
+                continue;
+            if (eventTypes && !eventTypes.has(rawRow.type))
+                continue;
+            const kind = piboAgentObservationKind(rawRow.type);
+            if (kinds && !kinds.has(kind))
+                continue;
+            const createdAt = Date.parse(rawRow.created_at);
+            if (since !== undefined && createdAt < since)
+                continue;
+            if (until !== undefined && createdAt > until)
+                continue;
+            const row = hydrateDebugEventRow(rawRow, payloadStore);
+            const attributes = eventAttributes(row);
+            const payload = { ...attributes, ...eventPayload(row) };
+            const source = debugAgentObservationSource(row, attributes);
+            const text = piboAgentObservationText(source);
+            if (textContains && !(text ?? "").toLowerCase().includes(textContains))
+                continue;
+            const role = piboAgentObservationRole(source);
+            matches.push({
+                streamId: row.stream_id,
+                createdAt: row.created_at,
+                agentId: agent.agentId,
+                name: agent.name,
+                ...(agent.threadKey ? { threadKey: agent.threadKey } : {}),
+                eventType: row.type,
+                kind,
+                ...(role ? { role } : {}),
+                ...(text ? { text } : {}),
+                ...(typeof payload.toolName === "string" ? { toolName: payload.toolName } : {}),
+                ...(typeof payload.toolCallId === "string" ? { toolCallId: payload.toolCallId } : {}),
+                ...(row.type === "tool_execution_finished" ? { isError: payload.isError === true } : row.type === "session_error" ? { isError: true } : {}),
+                ...(input.includeDetails === true ? { details: piboAgentObservationDetails(debugAgentObservationDetails(row, payload)) } : {}),
+            });
+            if (matches.length > limit)
+                break;
+        }
+        const truncated = matches.length > limit;
+        const observations = matches.slice(0, limit);
+        if (afterSequence !== undefined && order === "desc")
+            observations.reverse();
+        return {
+            parentPiboSessionId,
+            filters: {
+                ...input,
+                ...(afterSequence !== undefined ? { afterSequence } : {}),
+                order,
+                limit,
+                includeDetails: input.includeDetails === true,
+            },
+            observations,
+            nextAfterSequence: observations.reduce((maximum, observation) => Math.max(maximum, observation.streamId), afterSequence ?? 0),
+            truncated,
+        };
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+function readOwnedAgents(db, parentPiboSessionId) {
+    const rows = db.prepare(`
+		SELECT id, profile, status, metadata_json, active_model_json, created_at, updated_at
+		FROM sessions
+		WHERE parent_id = ? AND channel = 'pibo.subagents' AND kind = 'subagent' AND deleted_at IS NULL
+		ORDER BY updated_at DESC
+	`).all(parentPiboSessionId);
+    return rows.map((row) => {
+        const metadata = parseObject(row.metadata_json);
+        const killed = metadata.agentStatus === "killed";
+        return {
+            agentId: row.id,
+            name: typeof metadata.subagentName === "string" ? metadata.subagentName : row.profile,
+            profile: row.profile,
+            ...(typeof metadata.threadKey === "string" ? { threadKey: metadata.threadKey } : {}),
+            status: killed ? "killed" : isRunningStatus(row.status) ? "running" : "idle",
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            ...(row.active_model_json ? { activeModel: JSON.parse(row.active_model_json) } : {}),
+        };
+    });
+}
+function debugAgentObservationSource(row, attributes) {
+    const inlinePayload = attributes.inlinePayload;
+    const source = {
+        eventType: row.type,
+        fallbackText: row.preview_text ?? row.type,
+        ...(typeof attributes.source === "string" ? { source: attributes.source } : {}),
+    };
+    if (row.type === "message_queued" || row.type === "message_steered" || row.type === "message_started") {
+        source.text = typeof attributes.inlineText === "string" ? attributes.inlineText : row.preview_text ?? undefined;
+    }
+    else if (row.type === "assistant_message" || row.type === "assistant_delta" || row.type === "thinking_delta" || row.type === "thinking_finished") {
+        source.text = typeof inlinePayload === "string" ? inlinePayload : row.preview_text ?? undefined;
+    }
+    else if (row.type === "session_error") {
+        source.error = attributes.error;
+    }
+    else if (row.type === "tool_call" || row.type === "tool_execution_started") {
+        source.args = inlinePayload;
+    }
+    else if (row.type === "tool_execution_updated") {
+        source.partialResult = inlinePayload;
+    }
+    else if (row.type === "tool_execution_finished" || row.type === "execution_result" || row.type === "compaction_end") {
+        source.result = inlinePayload;
+    }
+    if (row.type === "execution_result")
+        source.action = attributes.action;
+    if (row.type === "compaction_start" || row.type === "compaction_end")
+        source.reason = attributes.reason;
+    if (row.type === "subagent_session")
+        source.subagentName = attributes.subagentName;
+    return source;
+}
+function debugAgentObservationDetails(row, payload) {
+    return {
+        type: row.type,
+        ...(row.session_id ? { piboSessionId: row.session_id } : {}),
+        ...(row.event_id ? { eventId: row.event_id } : {}),
+        ...payload,
+    };
+}
+function parseObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isRunningStatus(status) {
+    return ["running", "streaming", "queued", "starting", "waiting", "blocked", "retrying"].includes(status);
+}
+function formatDebugAgentList(parentPiboSessionId, agents) {
+    if (agents.length === 0)
+        return `parent: ${parentPiboSessionId}\nagents: 0`;
+    return [
+        `parent: ${parentPiboSessionId}`,
+        "agentId\tname\tprofile\tthreadKey\tstatus\tupdatedAt",
+        ...agents.map((agent) => `${agent.agentId}\t${agent.name}\t${agent.profile}\t${agent.threadKey ?? ""}\t${agent.status}\t${agent.updatedAt}`),
+        `agents: ${agents.length}`,
+    ].join("\n");
+}
+function formatDebugAgentObservations(result) {
+    if (result.observations.length === 0)
+        return `parent: ${result.parentPiboSessionId}\nobservations: 0\nnextAfterSequence: ${result.nextAfterSequence}`;
+    return [
+        `parent: ${result.parentPiboSessionId}`,
+        "streamId\tcreatedAt\tagentId\tname\teventType\tkind\ttext",
+        ...result.observations.map((observation) => `${observation.streamId}\t${observation.createdAt}\t${observation.agentId}\t${observation.name}\t${observation.eventType}\t${observation.kind}\t${(observation.text ?? "").replaceAll("\n", "\\n")}`),
+        `observations: ${result.observations.length}${result.truncated ? " (limited)" : ""}`,
+        `nextAfterSequence: ${result.nextAfterSequence}`,
+    ].join("\n");
+}
+function printDebugAgentsDiscovery(parentPiboSessionId = "<parent-session-id>") {
+    console.log(`pibo debug agents - inspect delegated child agents
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} <command>
+
+Commands:
+  list      List child agents owned by the parent session.
+  observe   Read persisted child-agent observations.
+
+Next:
+  pibo debug agents ${parentPiboSessionId} list --help
+  pibo debug agents ${parentPiboSessionId} observe --help
+`);
+}
+function printDebugAgentsCommandHelp(parentPiboSessionId, command) {
+    if (command === "list") {
+        console.log(`pibo debug agents ${parentPiboSessionId} list
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} list [--name name] [--status running|idle|killed] [--json]
+
+Filters use exact values. The command inspects only direct pibo.subagents children owned by the parent session.`);
+        return;
+    }
+    console.log(`pibo debug agents ${parentPiboSessionId} observe
+
+Usage:
+  pibo debug agents ${parentPiboSessionId} observe [--agent-id ps_...] [--name name] [--thread-key key]
+    [--event-type type] [--kind message|thinking|tool|error|lifecycle|event]
+    [--since iso] [--until iso] [--contains text] [--after-sequence n]
+    [--order asc|desc] [--limit 1..200] [--details] [--json]
+
+Repeat --agent-id, --name, --thread-key, --event-type, or --kind for OR within that field.
+Different fields combine with AND. With --after-sequence, pages always consume the oldest unseen rows;
+--order desc reverses only the returned page, so nextAfterSequence remains safe for polling.`);
+}
+function parseAgentDebugOptions(args) {
+    const parsed = { json: false, details: false, agentIds: [], names: [], threadKeys: [], eventTypes: [], kinds: [] };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            parsed.json = true;
+            continue;
+        }
+        if (arg === "--details") {
+            parsed.details = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value)
+            throw new Error(`${arg} requires a value`);
+        if (arg === "--agent-id")
+            parsed.agentIds.push(value);
+        else if (arg === "--name")
+            parsed.names.push(value);
+        else if (arg === "--thread-key")
+            parsed.threadKeys.push(value);
+        else if (arg === "--event-type")
+            parsed.eventTypes.push(value);
+        else if (arg === "--kind") {
+            if (!["message", "thinking", "tool", "error", "lifecycle", "event"].includes(value))
+                throw new Error(`Invalid --kind "${value}"`);
+            parsed.kinds.push(value);
+        }
+        else if (arg === "--status") {
+            if (!["running", "idle", "killed"].includes(value))
+                throw new Error(`Invalid --status "${value}"`);
+            parsed.status = value;
+        }
+        else if (arg === "--since")
+            parsed.since = value;
+        else if (arg === "--until")
+            parsed.until = value;
+        else if (arg === "--contains")
+            parsed.textContains = value;
+        else if (arg === "--after-sequence")
+            parsed.afterSequence = parseNonNegativeInteger(value, arg);
+        else if (arg === "--order") {
+            if (value !== "asc" && value !== "desc")
+                throw new Error(`Invalid --order "${value}"`);
+            parsed.order = value;
+        }
+        else if (arg === "--limit")
+            parsed.limit = normalizePiboAgentObservationLimit(parseNonNegativeInteger(value, arg));
+        else
+            throw new Error(`Unknown pibo debug agents option "${arg}"`);
+        index += 1;
+    }
+    return parsed;
+}
+function validateAgentDebugOptions(command, parsed) {
+    if (command === "list") {
+        if (parsed.names.length > 1)
+            throw new Error("pibo debug agents list accepts at most one --name value");
+        if (parsed.details || parsed.agentIds.length > 0 || parsed.threadKeys.length > 0 || parsed.eventTypes.length > 0
+            || parsed.kinds.length > 0 || parsed.since !== undefined || parsed.until !== undefined
+            || parsed.textContains !== undefined || parsed.afterSequence !== undefined || parsed.order !== undefined
+            || parsed.limit !== undefined)
+            throw new Error("Unsupported option for pibo debug agents list. Run the list command with --help.");
+        return;
+    }
+    if (parsed.status !== undefined)
+        throw new Error("--status is supported only by pibo debug agents list");
+}
+function parseNonNegativeInteger(value, option) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new Error(`${option} requires a non-negative integer`);
+    return parsed;
+}

package/dist/debug/index.js

@@ -44,6 +44,11 @@ export async function runDebugCli(argv = process.argv) {
             await runDebugEvents(args.slice(1));
             return;
         }
+        if (args[0] === "agents") {
+            const { runDebugAgentsCli } = await import("./agents.js");
+            await runDebugAgentsCli(args.slice(1));
+            return;
+        }
         if (args[0] === "jobs") {
             await runDebugJobs(args.slice(1));
             return;
@@ -1050,6 +1055,7 @@ Commands:
   final    Show the latest assistant message
   trace    Rebuild the Chat Web trace view for one Pibo Session
   events   Inspect compact event payload fields for one Pibo Session
+  agents   Inspect delegated child agents and their persisted activity
   tool     Inspect one grouped tool call
   failures List failed tool calls and trace/session errors
   jobs     Inspect durable Pibo jobs and DLQ
@@ -1067,6 +1073,7 @@ Next:
   pibo debug messages <pibo-session-id> list
   pibo debug trace <pibo-session-id> --running-only
   pibo debug events stream --topic pibo.output
+  pibo debug agents <parent-session-id> list
   pibo debug resources --json
   pibo debug signals tree ps_...
   pibo debug telemetry sessions --active

package/dist/index.js

@@ -41,7 +41,7 @@ export { runGatewayClient } from "./gateway/client.js";
 export { LOCAL_TUI_CHANNEL_NAME, LocalRoutedTuiClient, createLocalRoutedTuiClient, createLocalRoutedTuiExtension, runLocalRoutedTui, } from "./local/tui.js";
 export { createWebHostChannel, DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT, WEB_CHANNEL_NAME } from "./web/channel.js";
 export { sendGatewayEvent, sendGatewayMessageAndWaitForReply } from "./gateway/request.js";
-export { createSubagentToolDefinitions, createSubagentToolName, } from "./subagents/tool.js";
+export { createAgentToolDefinitions, createSubagentToolDefinitions, createSubagentToolName, formatAvailableAgentsForPrompt, listAvailableAgents, PIBO_AGENT_TOOL_NAMES, } from "./subagents/tool.js";
 export { PiboSteeringUnavailableError } from "./core/events.js";
 export { RuntimeSessionBindingConflictError, RuntimeSessionBindingTransitionError, assertRuntimeSessionBindingTransition, createInitialRuntimeSessionBinding, createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, } from "./sessions/runtime-binding.js";
 export { InMemoryPiboSessionStore, createPiSessionId, createPiboSessionId, createPiboSession, } from "./sessions/store.js";

package/dist/resources/lifecycle.js

@@ -6,6 +6,8 @@ import { promisify } from "node:util";
 import { applyComputeWorkerReapPlan, buildComputeWorkerReapPlan, planReapWorkers, } from "../compute/docker.js";
 import { defaultBrowserPoolRoot, defaultBrowserUseHome, getComputeResourceHealth, parseProcessList, } from "../compute/resource-health.js";
 import { loadBrowserPoolState, reapIdleBrowserPool, } from "../tools/browser-pool.js";
+import { resolveDeploymentPoolConfig } from "../compute/pool/config.js";
+import { applyDeploymentPoolReapPlan, planDeploymentPoolReap } from "../compute/pool/service.js";
 const execFileAsync = promisify(execFile);
 export async function collectManagedBrowserPools(rootDir) {
     const records = [];
@@ -56,7 +58,7 @@ export async function getActiveResourceLeases(browserPoolRoot = defaultBrowserPo
 export async function planResourceReap(options = {}) {
     const now = options.now ?? new Date();
     const resolved = resolveReapOptions(options);
-    const [records, staleFiles, compute, health] = await Promise.all([
+    const [records, staleFiles, compute, health, deploymentPool] = await Promise.all([
         collectManagedBrowserPools(resolved.browserPoolRoot),
         planStaleCdpFiles(resolved.browserUseHome),
         planComputeReapSafely({ includeDev: resolved.includeDev, maxAgeMinutes: resolved.maxAgeMinutes, now }),
@@ -66,9 +68,10 @@ export async function planResourceReap(options = {}) {
             browserUseHome: resolved.browserUseHome,
             exemptBrowserUserDataDirs: [],
         }),
+        planDeploymentPoolReapSafely(now),
     ]);
     const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids), new Set(resolved.exemptBrowserUserDataDirs), resolved.browserUseHome);
-    return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute });
+    return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute, deploymentPool });
 }
 export function buildResourceReapPlan(input) {
     const browserItems = input.records.map((record) => buildBrowserReapPlanItem(record, input.now, input.options.idleTimeoutMinutes));
@@ -89,6 +92,7 @@ export function buildResourceReapPlan(input) {
             skipped: unmanagedBrowsers.filter((item) => item.action === "skip").length,
         },
         compute: input.compute,
+        deploymentPool: input.deploymentPool,
         worktreesPreserved: true,
     };
 }
@@ -112,6 +116,9 @@ export async function applyResourceReapPlan(plan, dependencies = {}) {
     }
     const removedStaleFiles = await applyStaleCdpFilePlan(confirmed.staleFiles.items, dependencies.isPidAlive);
     const removedComputeWorkers = await (dependencies.applyCompute ?? applyComputeWorkerReapPlan)(confirmed.compute);
+    const deploymentPoolResult = confirmed.deploymentPool
+        ? await (dependencies.applyDeploymentPool ?? applyDeploymentPoolReapPlan)(confirmed.deploymentPool)
+        : undefined;
     return {
         applied: true,
         plan: confirmed,
@@ -119,6 +126,8 @@ export async function applyResourceReapPlan(plan, dependencies = {}) {
         terminatedUnmanagedBrowsers,
         removedStaleFiles,
         removedComputeWorkers,
+        deploymentPoolResult,
+        removedDeploymentLeases: deploymentPoolResult?.releasedLeases ?? [],
         worktreesPreserved: true,
     };
 }
@@ -287,6 +296,17 @@ export async function planComputeReapSafely(options, planCompute = planReapWorke
         return plan;
     }
 }
+async function planDeploymentPoolReapSafely(now) {
+    const config = resolveDeploymentPoolConfig();
+    if (!existsSync(config.databasePath))
+        return undefined;
+    try {
+        return await planDeploymentPoolReap({ config, now });
+    }
+    catch {
+        return undefined;
+    }
+}
 async function planStaleCdpFiles(browserUseHome, isPidAlive = defaultIsPidAlive) {
     const stateDir = join(browserUseHome, "pibo-cdp");
     let files;

package/dist/resources/reaper.js

@@ -95,6 +95,7 @@ export class ResourceReaperService {
                     unmanagedBrowsers: result.terminatedUnmanagedBrowsers.length,
                     staleFiles: result.removedStaleFiles.length,
                     computeWorkers: result.removedComputeWorkers.length,
+                    ...(result.deploymentPoolResult ? { deploymentLeases: result.removedDeploymentLeases?.length ?? 0 } : {}),
                 },
                 lastError: undefined,
             };

package/dist/session-ui/delegation.js

@@ -16,7 +16,8 @@ export function resolveAgentDelegationStatus(childSignal, fallbackStatus = "done
 }
 export function extractAgentDelegationName(input, title, summary) {
     const record = isRecord(input) ? input : undefined;
-    const rawName = stringValue(record?.subagentName)
+    const rawName = stringValue(record?.name)
+        ?? stringValue(record?.subagentName)
         ?? subagentNameFromToolName(title)
         ?? stringValue(summary)
         ?? stringValue(title)
@@ -68,10 +69,11 @@ function subagentNameFromToolName(value) {
     const name = nonEmpty(value);
     if (!name)
         return undefined;
-    return name.replace(/^pibo_subagent_/, "");
+    return name === "pibo_agents_send_message" ? undefined : name.replace(/^pibo_subagent_/, "");
 }
 function titleCaseAgentName(value) {
     return value
+        .replace(/^pibo_agents_send_message$/, "Agent")
         .replace(/^pibo_subagent_/, "")
         .split(/[\s_-]+/)
         .filter(Boolean)

package/dist/shared/trace-async-agent-runs.js

@@ -51,10 +51,12 @@ function createAsyncAgentRunNode(parent, piboSessionId, startedAt, delegation) {
     const toolName = stringValue(run?.toolName) ?? stringValue(input.toolName) ?? delegation?.title;
     if (!toolName || !isSubagentToolName(toolName))
         return undefined;
-    const subagentName = stringValue(delegation?.summary) ?? subagentNameFromToolName(toolName);
+    const delegatedArguments = input.arguments;
+    const subagentName = stringValue(delegation?.summary)
+        ?? (isRecord(delegatedArguments) ? stringValue(delegatedArguments.name) : undefined)
+        ?? subagentNameFromToolName(toolName);
     const runId = stringValue(run?.runId);
     const runStatus = stringValue(run?.status);
-    const delegatedArguments = input.arguments;
     const completionPolicy = stringValue(run?.completionPolicy) ?? stringValue(input.completionPolicy);
     return {
         id: `${parent.id}:async-agent`,

package/dist/shared/trace-event-projection.js

@@ -947,8 +947,14 @@ function findLegacySubagentLinkTarget(nodes, update) {
 }
 function delegationAgentName(node) {
     const input = isObjectRecord(node.input) ? node.input : undefined;
-    const value = typeof input?.subagentName === "string" ? input.subagentName : node.summary ?? node.title;
-    return typeof value === "string" ? value.replace(/^pibo_subagent_/, "").trim().toLowerCase() || undefined : undefined;
+    const value = typeof input?.name === "string"
+        ? input.name
+        : typeof input?.subagentName === "string"
+            ? input.subagentName
+            : node.summary ?? node.title;
+    return typeof value === "string"
+        ? value.replace(/^pibo_agents_send_message$/, "agent").replace(/^pibo_subagent_/, "").trim().toLowerCase() || undefined
+        : undefined;
 }
 function delegationThreadKey(value) {
     if (!isObjectRecord(value) || typeof value.threadKey !== "string")

package/dist/shared/trace-subagent-links.js

@@ -22,9 +22,16 @@ export function mapTraceSubagentSessionLinks(events) {
 export function findLikelyTraceChildSession(piboSessionId, toolName, event, childByParent) {
     if (!isSubagentToolName(toolName))
         return undefined;
+    const agentName = toolEventAgentName(event);
     const candidates = childByParent
         .get(piboSessionId)
-        ?.filter((session) => session.metadata?.subagentToolName === toolName) ?? [];
+        ?.filter((session) => {
+        if (toolName === "pibo_agents_send_message") {
+            return session.metadata?.subagentToolName === toolName
+                && (!agentName || session.metadata?.subagentName === agentName);
+        }
+        return session.metadata?.subagentToolName === toolName;
+    }) ?? [];
     const threadKey = toolEventThreadKey(event);
     if (threadKey) {
         return candidates.find((session) => session.metadata?.threadKey === threadKey)?.id;
@@ -32,15 +39,21 @@ export function findLikelyTraceChildSession(piboSessionId, toolName, event, chil
     return candidates.length === 1 ? candidates[0].id : undefined;
 }
 export function isSubagentToolName(name) {
-    return name.startsWith("pibo_subagent_");
+    return name === "pibo_agents_send_message" || name.startsWith("pibo_subagent_");
 }
 export function subagentNameFromToolName(toolName) {
-    return toolName.slice("pibo_subagent_".length);
+    return toolName === "pibo_agents_send_message" ? "agent" : toolName.slice("pibo_subagent_".length);
 }
-function toolEventThreadKey(event) {
-    const args = "args" in event && event.args && typeof event.args === "object" && !Array.isArray(event.args)
+function toolEventArguments(event) {
+    return "args" in event && event.args && typeof event.args === "object" && !Array.isArray(event.args)
         ? event.args
         : undefined;
-    const threadKey = args && "threadKey" in args ? args.threadKey : undefined;
+}
+function toolEventAgentName(event) {
+    const name = toolEventArguments(event)?.name;
+    return typeof name === "string" && name.trim() ? name.trim() : undefined;
+}
+function toolEventThreadKey(event) {
+    const threadKey = toolEventArguments(event)?.threadKey;
     return typeof threadKey === "string" && threadKey.trim() ? threadKey.trim() : undefined;
 }