npm - @pasko70/pibo - Versions diffs - 3.4.1 → 3.4.3 - Mend

@pasko70/pibo 3.4.1 → 3.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

package/dist/agent-runtime/routed-session.js +6 -1
package/dist/agent-runtimes/pi/adapter.js +4 -1
package/dist/agent-runtimes/pi/history.js +55 -1
package/dist/apps/chat/chat-settings-routes.js +10 -0
package/dist/apps/chat/data/chat-data-mappers.js +1 -1
package/dist/apps/chat/stream.js +1 -1
package/dist/apps/chat/trace-v2.js +1 -0
package/dist/apps/chat/web-app.js +2 -1
package/dist/apps/chat-ui/assets/{dist-DnZL1rRp.js → dist-B4YhOxh0.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-D0md0xIR.js → dist-BkUu8WPA.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-ERKABhp3.js → dist-C8GzUMPk.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-DHnaUMlq.js → dist-Cyb4rVa6.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-Abz605MV.js → dist-DeMKnZR8.js} +1 -1
package/dist/apps/chat-ui/assets/index-BOceJ0jM.css +1 -0
package/dist/apps/chat-ui/assets/index-Dk4mbXAB.js +228 -0
package/dist/apps/chat-ui/index.html +2 -2
package/dist/apps/chat-vscode-web/assets/index-0oTGFHni.js +43 -0
package/dist/apps/chat-vscode-web/index.html +1 -1
package/dist/auth/openai-codex-usage.js +34 -5
package/dist/core/session-router.js +95 -11
package/dist/core/user-settings.js +11 -0
package/dist/data/ingest-service.js +1 -1
package/dist/data/schema.js +10 -1
package/dist/debug/agents.js +5 -3
package/dist/gateway/server.js +1 -1
package/dist/session-ui/terminalRows.js +3 -1
package/dist/sessions/pibo-data-store.js +38 -1
package/dist/sessions/store.js +38 -0
package/dist/shared/tool-call-metrics.js +138 -0
package/dist/shared/tool-call-token-settings.js +45 -0
package/dist/shared/trace-event-projection.js +2 -0
package/dist/shared/trace-live-reducer.js +1 -0
package/dist/shared/trace-patch-nodes.js +4 -0
package/dist/subagents/context.js +2 -2
package/dist/subagents/observation-query.js +28 -1
package/dist/subagents/observations.js +8 -0
package/dist/subagents/tool.js +12 -8
package/npm-shrinkwrap.json +22 -13
package/package.json +2 -1
package/dist/apps/chat-ui/assets/index-BWVPNFjU.js +0 -228
package/dist/apps/chat-ui/assets/index-CywOD6EF.css +0 -1
package/dist/apps/chat-vscode-web/assets/index-CZmxeSn3.js +0 -43

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-CZmxeSn3.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-0oTGFHni.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/auth/openai-codex-usage.js CHANGED Viewed

@@ -1,7 +1,13 @@
+import { createHash } from "node:crypto";
 import { readPiCredential, resolvePiProviderAuth, } from "../agent-runtimes/pi/credentials.js";
 const OPENAI_CODEX_PROVIDER = "openai-codex";
 const OPENAI_CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const OPENAI_JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const USAGE_REFRESH_MS = 30_000;
+const USAGE_MAX_STALE_MS = 5 * 60_000;
+const USAGE_REQUEST_TIMEOUT_MS = 2_000;
+// One bounded, credential-scoped snapshot shared by sessions. Never retain raw credentials.
+let usageCache;
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -125,8 +131,31 @@ export async function getOpenAiCodexProviderUsageForActiveModel(activeModel) {
     if (activeModel?.provider !== OPENAI_CODEX_PROVIDER)
         return undefined;
     const credential = await readPiCredential(OPENAI_CODEX_PROVIDER);
-    if (credential?.type !== "oauth")
+    if (credential?.type !== "oauth") {
+        usageCache = undefined;
         return undefined;
+    }
+    const key = createHash("sha256").update(JSON.stringify(credential)).digest("hex");
+    if (usageCache?.key !== key)
+        usageCache = { key, refreshAfter: 0 };
+    const cache = usageCache;
+    const now = Date.now();
+    const usable = () => cache.value && Date.now() - Date.parse(cache.value.fetchedAt) < USAGE_MAX_STALE_MS
+        ? cache.value
+        : undefined;
+    if (now < cache.refreshAfter)
+        return usable();
+    cache.pending ??= fetchOpenAiCodexProviderUsage(credential.accountId)
+        .then((value) => { cache.value = value; return value; })
+        .catch(() => usable())
+        .finally(() => {
+        cache.refreshAfter = Date.now() + USAGE_REFRESH_MS;
+        cache.pending = undefined;
+    });
+    // Quota is advisory: stale-while-revalidate keeps repeat status commands local.
+    return usable() ?? await cache.pending;
+}
+async function fetchOpenAiCodexProviderUsage(storedAccountId) {
     const resolvedAuth = await resolvePiProviderAuth(OPENAI_CODEX_PROVIDER);
     const accessToken = resolvedAuth?.auth.apiKey;
     if (!accessToken)
@@ -135,13 +164,13 @@ export async function getOpenAiCodexProviderUsageForActiveModel(activeModel) {
         Authorization: `Bearer ${accessToken}`,
         "User-Agent": "codex-cli",
     };
-    const accountId = getOpenAiAccountId(accessToken, credential.accountId);
+    const accountId = getOpenAiAccountId(accessToken, storedAccountId);
     if (accountId)
         headers["ChatGPT-Account-Id"] = accountId;
-    const response = await fetch(OPENAI_CODEX_USAGE_URL, { headers });
+    const response = await fetch(OPENAI_CODEX_USAGE_URL, { headers, signal: AbortSignal.timeout(USAGE_REQUEST_TIMEOUT_MS) });
     if (!response.ok) {
-        const text = await response.text().catch(() => "");
-        throw new Error(`OpenAI Codex usage request failed: ${response.status}${text ? ` ${text}` : ""}`);
+        await response.body?.cancel();
+        throw new Error(`OpenAI Codex usage request failed: ${response.status}`);
     }
     return normalizeUsagePayload(await response.json());
 }

package/dist/core/session-router.js CHANGED Viewed

@@ -7,13 +7,13 @@ import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { OutputRenderSequencer, outputRenderHighWaterStore } from "./output-render-sequence.js";
 import { normalizePiboAgentSessionName, } from "../subagents/tool.js";
 import { piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
-import { preparePiboAgentObservationQuery, selectPiboAgentObservationPage, } from "../subagents/observation-query.js";
+import { piboAgentObservationCursorScopeKey, preparePiboAgentObservationQuery, selectPiboAgentObservationPage, } from "../subagents/observation-query.js";
 import { PiboRunRegistry } from "../runs/registry.js";
 import { PiboRunCancellationError, PiboRunCancelledError, PiboRunExecutionTimeoutError, waitForRunCancellationSettlement } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
 import { createPiboSignalRegistry } from "../signals/registry.js";
 import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
-import { InMemoryPiboSessionStore, createPiboSessionId, } from "../sessions/store.js";
+import { PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES, InMemoryPiboSessionStore, createPiboSessionId, } from "../sessions/store.js";
 import { createAgentRuntimeBindingPersistence } from "../sessions/runtime-binding-persistence.js";
 import { createLegacyPiRuntimeSessionBinding, RuntimeSessionBindingConflictError, } from "../sessions/runtime-binding.js";
 import { AgentRuntimeBindingMissingError, AgentRuntimeUnavailableError } from "../agent-runtime/errors.js";
@@ -349,7 +349,9 @@ export class PiboSessionRouter {
     activeSubagentRequests = new Map();
     subagentRequestIdsByEvent = new Map();
     agentObservations = [];
+    agentObservationHighWaterByParent = new Map();
     agentObservationEvictedThroughByParent = new Map();
+    agentObservationAutoCursorFallback = new Map();
     nextAgentObservationSequence = 1;
     scheduledRunReminders = new Map();
     runReminderDeliveries = new Map();
@@ -945,16 +947,41 @@ export class PiboSessionRouter {
         const status = this.sessions.get(piboSessionId)?.getStatus();
         return status ? this.withPersistedRuntimeBinding(status) : undefined;
     }
-    async getSessionStatusSnapshot(piboSessionId) {
-        const session = await this.getOrCreateSession(piboSessionId);
+    async getSessionStatusSnapshot(piboSessionId, options) {
+        const session = options?.activate === false ? this.sessions.get(piboSessionId) : await this.getOrCreateSession(piboSessionId);
+        if (!session) {
+            this.resolvePiboSession(piboSessionId);
+            return undefined;
+        }
         try {
             return this.withPersistedRuntimeBinding(await session.getStatusSnapshot());
         }
         finally {
-            this.scheduleIdleSessionEvictionIfIdle(piboSessionId);
+            // Passive header polling must neither create nor indefinitely retain a runtime.
+            if (options?.activate !== false)
+                this.scheduleIdleSessionEvictionIfIdle(piboSessionId);
         }
     }
     async getSessionForkCandidates(piboSessionId) {
+        const canReadPersisted = () => !this.closing
+            && !this.quiescingSessions.has(piboSessionId)
+            && !this.disposingSessions.has(piboSessionId)
+            && !this.sessions.has(piboSessionId)
+            && !this.pendingSessions.has(piboSessionId);
+        if (canReadPersisted()) {
+            const record = this.resolvePiboSession(piboSessionId);
+            const binding = this.resolveSessionRuntimeBinding(record);
+            const adapter = this.resolveAgentRuntimeRegistry(binding.runtimeInstanceId).requireAgentRuntimeAdapter(binding.runtimeInstanceId);
+            if (binding.state === "bound" && adapter.descriptor.id === binding.adapterId
+                && adapter.descriptor.capabilities.lifecycle.fork && adapter.readForkCandidates) {
+                const workspace = record.workspace ?? this.options.cwd ?? getDefaultPiboWorkspace();
+                const candidates = await adapter.readForkCandidates({ binding, workspace });
+                const current = this.resolvePiboSession(piboSessionId);
+                if (candidates !== undefined && canReadPersisted() && current.workspace === record.workspace
+                    && runtimeBindingsEqual(binding, this.resolveSessionRuntimeBinding(current)))
+                    return candidates;
+            }
+        }
         const session = await this.getOrCreateSession(piboSessionId);
         try {
             return await session.getForkCandidates();
@@ -1146,7 +1173,9 @@ export class PiboSessionRouter {
             this.subagentRequestIdsByEvent.clear();
             this.outputRenderSequencer.disposeAll();
             this.agentObservations.length = 0;
+            this.agentObservationHighWaterByParent.clear();
             this.agentObservationEvictedThroughByParent.clear();
+            this.agentObservationAutoCursorFallback.clear();
             await this.telemetryWriter?.dispose();
             const lifecycleFailures = [...authDisposals, ...webAppDisposals]
                 .flatMap((result) => result.status === "rejected" ? [result.reason] : []);
@@ -1523,6 +1552,7 @@ export class PiboSessionRouter {
                 return result;
             },
             statusResources,
+            getToolMetricTokenCalculation: () => loadPiboUserSettings().toolMetrics.tokenCalculation,
         });
         this.sessions.set(piboSession.id, session);
         return session;
@@ -2098,8 +2128,18 @@ export class PiboSessionRouter {
     observeManagedAgents(parentPiboSessionId, input) {
         for (const agentId of input.agentIds ?? [])
             this.requireManagedAgent(parentPiboSessionId, agentId);
-        const query = preparePiboAgentObservationQuery(input);
+        const baseQuery = preparePiboAgentObservationQuery(input);
+        const cursorScope = piboAgentObservationCursorScopeKey(baseQuery.filters);
+        const explicitAfterSequence = input.afterSequence !== undefined;
+        const savedAfterSequence = baseQuery.cursorMode === "auto" && !explicitAfterSequence
+            ? this.getAgentObservationAutoCursor(parentPiboSessionId, cursorScope)
+            : undefined;
+        const query = savedAfterSequence === undefined
+            ? baseQuery
+            : preparePiboAgentObservationQuery({ ...input, afterSequence: savedAfterSequence });
         const observations = this.agentObservations;
+        const evictedThrough = this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0;
+        const sourceHighWater = Math.max(evictedThrough, this.agentObservationHighWaterByParent.get(parentPiboSessionId) ?? 0);
         function* ordered() {
             const start = query.scanOrder === "asc" ? 0 : observations.length - 1;
             const end = query.scanOrder === "asc" ? observations.length : -1;
@@ -2110,7 +2150,48 @@ export class PiboSessionRouter {
                     yield observation;
             }
         }
-        return selectPiboAgentObservationPage(ordered(), query, { evictedThrough: this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0 });
+        const page = selectPiboAgentObservationPage(ordered(), query, { evictedThrough });
+        if (query.cursorMode === "history")
+            return page;
+        const initialSnapshot = !explicitAfterSequence && savedAfterSequence === undefined;
+        const nextAfterSequence = initialSnapshot || !page.truncated
+            ? Math.max(page.nextAfterSequence, sourceHighWater)
+            : page.nextAfterSequence;
+        const advancedAfterSequence = this.advanceAgentObservationAutoCursor(parentPiboSessionId, cursorScope, nextAfterSequence);
+        return {
+            ...page,
+            autoCursorSequence: advancedAfterSequence,
+        };
+    }
+    getAgentObservationAutoCursor(parentPiboSessionId, cursorScope) {
+        if (this.sessionStore.getAgentObservationAutoCursor) {
+            return this.sessionStore.getAgentObservationAutoCursor(parentPiboSessionId, cursorScope);
+        }
+        return this.agentObservationAutoCursorFallback.get(JSON.stringify([parentPiboSessionId, cursorScope]));
+    }
+    advanceAgentObservationAutoCursor(parentPiboSessionId, cursorScope, sequence) {
+        if (this.sessionStore.advanceAgentObservationAutoCursor) {
+            return this.sessionStore.advanceAgentObservationAutoCursor(parentPiboSessionId, cursorScope, sequence);
+        }
+        const key = JSON.stringify([parentPiboSessionId, cursorScope]);
+        const advanced = Math.max(this.agentObservationAutoCursorFallback.get(key) ?? 0, sequence);
+        this.agentObservationAutoCursorFallback.delete(key);
+        this.agentObservationAutoCursorFallback.set(key, advanced);
+        const prefix = `${JSON.stringify([parentPiboSessionId]).slice(0, -1)},`;
+        let scopeCount = 0;
+        for (const existingKey of this.agentObservationAutoCursorFallback.keys()) {
+            if (existingKey.startsWith(prefix))
+                scopeCount += 1;
+        }
+        for (const existingKey of this.agentObservationAutoCursorFallback.keys()) {
+            if (scopeCount <= PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES)
+                break;
+            if (!existingKey.startsWith(prefix))
+                continue;
+            this.agentObservationAutoCursorFallback.delete(existingKey);
+            scopeCount -= 1;
+        }
+        return advanced;
     }
     async killManagedAgent(parentPiboSessionId, agentId) {
         const child = this.requireManagedAgent(parentPiboSessionId, agentId);
@@ -2300,16 +2381,16 @@ export class PiboSessionRouter {
             throw new Error(`Subagent "${subagent.name}" exceeded max depth ${maxDepth} from Pibo session "${parentPiboSessionId}"`);
         }
     }
-    getSubagentDepth(piboSessionId) {
+    getSubagentDepth(piboSessionId, sessionsById) {
         let depth = 0;
-        let current = this.sessionStore.get(piboSessionId);
+        let current = sessionsById ? sessionsById.get(piboSessionId) : this.sessionStore.get(piboSessionId);
         const seen = new Set();
         while (current?.parentId) {
             if (seen.has(current.parentId))
                 break;
             seen.add(current.parentId);
             depth += 1;
-            current = this.sessionStore.get(current.parentId);
+            current = sessionsById ? sessionsById.get(current.parentId) : this.sessionStore.get(current.parentId);
         }
         return depth;
     }
@@ -2412,6 +2493,7 @@ export class PiboSessionRouter {
             details: piboAgentObservationDetails(event),
         };
         this.agentObservations.push(observation);
+        this.agentObservationHighWaterByParent.set(session.parentId, Math.max(this.agentObservationHighWaterByParent.get(session.parentId) ?? 0, sequence));
         if (this.agentObservations.length > MAX_AGENT_OBSERVATIONS) {
             const evicted = this.agentObservations.splice(0, this.agentObservations.length - MAX_AGENT_OBSERVATIONS);
             for (const item of evicted) {
@@ -2567,7 +2649,9 @@ export class PiboSessionRouter {
     }
     projectKnownSessionSignals() {
         const sessions = this.sessionStore.list?.() ?? [];
-        const depthBySessionId = new Map(sessions.map((session) => [session.id, this.getSubagentDepth(session.id)]));
+        // The complete list is already loaded; avoid an additional store query for every ancestor.
+        const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+        const depthBySessionId = new Map(sessions.map((session) => [session.id, this.getSubagentDepth(session.id, sessionsById)]));
         sessions.sort((left, right) => (depthBySessionId.get(left.id) ?? 0) - (depthBySessionId.get(right.id) ?? 0));
         for (const session of sessions) {
             this.signalRegistry.project({ type: "session_created", session });

package/dist/core/user-settings.js CHANGED Viewed

@@ -4,6 +4,7 @@ import { piboHomePath } from "./pibo-home.js";
 import { sanitizePreviewServerSettings } from "./preview-server-settings.js";
 import { sanitizeTelemetryRetentionSettings } from "./telemetry-retention-settings.js";
 import { sanitizeTelemetryStaleThresholdSettings } from "./telemetry-staleness.js";
+import { DEFAULT_TOOL_METRIC_TOKEN_CALCULATION, parseToolMetricTokenCalculation, } from "../shared/tool-call-token-settings.js";
 export const DEFAULT_USER_TIMEZONE = "UTC";
 export const DEFAULT_WEB_ANNOTATIONS_TOGGLE_SHORTCUT = "Alt+Shift+A";
 export const DEFAULT_TRANSCRIPTION_PROVIDER_ID = "openai-chatgpt";
@@ -64,6 +65,15 @@ export function sanitizeSpeechSettings(value) {
         : {};
     return { providerId: sanitizeTranscriptionProviderId(raw.providerId) ?? DEFAULT_SPEECH_PROVIDER_ID };
 }
+export function sanitizeToolMetricSettings(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        tokenCalculation: parseToolMetricTokenCalculation(raw.tokenCalculation)
+            ?? DEFAULT_TOOL_METRIC_TOKEN_CALCULATION,
+    };
+}
 export function sanitizeTimezone(value) {
     if (typeof value !== "string")
         return undefined;
@@ -87,6 +97,7 @@ function sanitizeUserSettings(value) {
         shortcuts: sanitizeShortcutSettings(raw.shortcuts),
         transcription: sanitizeTranscriptionSettings(raw.transcription),
         speech: sanitizeSpeechSettings(raw.speech),
+        toolMetrics: sanitizeToolMetricSettings(raw.toolMetrics),
         previewServers: sanitizePreviewServerSettings(raw.previewServers),
         telemetryStaleThresholds: sanitizeTelemetryStaleThresholdSettings(raw.telemetryStaleThresholds),
         telemetryRetention: sanitizeTelemetryRetentionSettings(raw.telemetryRetention),

package/dist/data/ingest-service.js CHANGED Viewed

@@ -427,7 +427,7 @@ function specificAttributesForOutputEvent(event) {
     if (event.type === "tool_call")
         return { toolCallId: event.toolCallId, toolName: event.toolName, argsComplete: event.argsComplete, intent: event.intent };
     if (event.type === "tool_execution_started" || event.type === "tool_execution_updated" || event.type === "tool_execution_finished")
-        return { toolCallId: event.toolCallId, toolName: event.toolName, isError: "isError" in event ? event.isError : undefined, intent: event.intent };
+        return { toolCallId: event.toolCallId, toolName: event.toolName, isError: "isError" in event ? event.isError : undefined, intent: event.intent, toolMetrics: event.type === "tool_execution_finished" ? event.toolMetrics : undefined };
     if (event.type === "subagent_session")
         return { toolCallId: event.toolCallId, toolName: event.toolName, subagentName: event.subagentName, childPiboSessionId: event.childPiboSessionId, threadKey: event.threadKey };
     if (event.type === "execution_result")

package/dist/data/schema.js CHANGED Viewed

@@ -1,4 +1,4 @@
-export const PIBO_DATA_SCHEMA_VERSION = 8;
+export const PIBO_DATA_SCHEMA_VERSION = 9;
 const NATIVE_HISTORY_FALLBACK_SCHEMA_VERSION = 5;
 const retiredScopeColumn = ["owner", "scope"].join("_");
 const payloadTableDefinition = `
@@ -254,6 +254,15 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
 			FOREIGN KEY (parent_pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
 		);
+		CREATE TABLE IF NOT EXISTS session_agent_observation_auto_cursors (
+			parent_pibo_session_id TEXT NOT NULL,
+			cursor_scope TEXT NOT NULL,
+			sequence INTEGER NOT NULL CHECK(sequence >= 0),
+			updated_at TEXT NOT NULL,
+			PRIMARY KEY (parent_pibo_session_id, cursor_scope),
+			FOREIGN KEY (parent_pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
+		);
 		CREATE TABLE IF NOT EXISTS session_output_part_counters (
 			pibo_session_id TEXT NOT NULL,
 			event_id TEXT NOT NULL,

package/dist/debug/agents.js CHANGED Viewed

@@ -81,7 +81,7 @@ export function inspectDebugAgentObservations(parentPiboSessionId, store, input
         throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
     const db = openReadOnlyDebugDatabase(store);
     try {
-        const query = preparePiboAgentObservationQuery(input);
+        const query = preparePiboAgentObservationQuery({ ...input, cursorMode: "history" });
         const owned = readOwnedAgents(db, parentPiboSessionId);
         const ownedById = new Map(owned.map((agent) => [agent.agentId, agent]));
         for (const agentId of input.agentIds ?? []) {
@@ -287,8 +287,10 @@ Usage:
     [--order asc|desc] [--limit 1..200] [--include-tools]
     [--tool-detail summary|full] [--details] [--json]
-Default: the newest 20 completed assistant messages, with streaming deltas and tools hidden.
-Use --include-tools for compact tool calls and terminal results. Explicit --event-type or --kind
+Default: the newest 20 completed assistant messages; streaming deltas and tools are hidden.
+The CLI is stateless history inspection. Use --after-sequence for explicit incremental polling.
+Use --include-tools only for stalls, errors, or targeted diagnosis; prefer --tool-call-id when known.
+Explicit --event-type or --kind
 filters retain access to progress events. Repeat plural filters 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.

package/dist/gateway/server.js CHANGED Viewed

@@ -421,7 +421,7 @@ export class PiboGatewayServer {
             },
             rebindSessionRuntime: (piboSessionId, input) => this.requireRouter().rebindSessionRuntime(piboSessionId, input),
             getSessionRuntimeStatus: (piboSessionId) => this.requireRouter().getSessionRuntimeStatus(piboSessionId),
-            getSessionStatusSnapshot: (piboSessionId) => this.requireRouter().getSessionStatusSnapshot(piboSessionId),
+            getSessionStatusSnapshot: (piboSessionId, options) => this.requireRouter().getSessionStatusSnapshot(piboSessionId, options),
             getSessionForkCandidates: (piboSessionId) => this.requireRouter().getSessionForkCandidates(piboSessionId),
             listSessionRuntimeStatuses: () => this.requireRouter().listSessionRuntimeStatuses(),
             listRuns: (options) => this.requireRouter().listRuns(options),

package/dist/session-ui/terminalRows.js CHANGED Viewed

@@ -22,7 +22,7 @@ export function buildCompactTerminalRows(traceView, options) {
     const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
     applyCompletedTurnTiming(candidates, turnById);
     const reconciled = reconcileConceptualRowCandidates(candidates);
-    const rows = (options.toolDisplayMode ?? "default") === "default"
+    const rows = !options.debugMode && (options.toolDisplayMode ?? "default") === "default"
         ? groupRelatedToolCandidates(reconciled).map((candidate) => candidate.row)
         : reconciled.map((candidate) => candidate.row);
     return applyToolDisplayMode(rows, options.toolDisplayMode ?? "default");
@@ -165,6 +165,8 @@ function createRowCandidate(node, turnId) {
             ...candidate.row,
             id: compactTerminalRowIdentity(node),
             intent: node.intent,
+            isToolCall: node.type === "tool.call" || node.type === "tool.result" || (node.type === "agent.delegation" && Boolean(node.toolCallId)),
+            toolMetrics: node.toolMetrics,
             ...debugFields(node),
         },
     };

package/dist/sessions/pibo-data-store.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { ChatDataIngestService } from "../data/ingest-service.js";
 import { PiboDataStore } from "../data/pibo-store.js";
-import { createPiboSession, matchesFindInput, } from "./store.js";
+import { PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES, createPiboSession, matchesFindInput, } from "./store.js";
 import { createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, RuntimeSessionBindingConflictError, } from "./runtime-binding.js";
 const SESSION_SELECT = `
 	SELECT
@@ -165,6 +165,43 @@ export class PiboDataSessionStore {
             return sequence;
         });
     }
+    getAgentObservationAutoCursor(parentPiboSessionId, cursorScope) {
+        const row = this.db.prepare(`
+			SELECT sequence
+			FROM session_agent_observation_auto_cursors
+			WHERE parent_pibo_session_id = ? AND cursor_scope = ?
+		`).get(parentPiboSessionId, cursorScope);
+        return row?.sequence;
+    }
+    advanceAgentObservationAutoCursor(parentPiboSessionId, cursorScope, sequence) {
+        return this.dataStore.transaction(() => {
+            this.db.prepare(`
+				INSERT INTO session_agent_observation_auto_cursors (
+					parent_pibo_session_id, cursor_scope, sequence, updated_at
+				)
+				SELECT id, ?, ?, ? FROM sessions WHERE id = ? AND deleted_at IS NULL
+				ON CONFLICT(parent_pibo_session_id, cursor_scope) DO UPDATE SET
+					sequence = MAX(session_agent_observation_auto_cursors.sequence, excluded.sequence),
+					updated_at = CASE
+						WHEN excluded.sequence > session_agent_observation_auto_cursors.sequence THEN excluded.updated_at
+						ELSE session_agent_observation_auto_cursors.updated_at
+					END
+			`).run(cursorScope, sequence, new Date().toISOString(), parentPiboSessionId);
+            this.db.prepare(`
+				DELETE FROM session_agent_observation_auto_cursors
+				WHERE parent_pibo_session_id = ?
+					AND cursor_scope <> ?
+					AND cursor_scope NOT IN (
+						SELECT cursor_scope
+						FROM session_agent_observation_auto_cursors
+						WHERE parent_pibo_session_id = ? AND cursor_scope <> ?
+						ORDER BY updated_at DESC, cursor_scope DESC
+						LIMIT ?
+					)
+			`).run(parentPiboSessionId, cursorScope, parentPiboSessionId, cursorScope, PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES - 1);
+            return this.getAgentObservationAutoCursor(parentPiboSessionId, cursorScope) ?? sequence;
+        });
+    }
     claimOrAttachOutputPart(input) {
         return this.dataStore.transaction(() => {
             const indexAttribute = outputPartIndexAttribute(input.kind);

package/dist/sessions/store.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { createInitialRuntimeSessionBinding, createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, } from "./runtime-binding.js";
+export const PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES = 128;
 export function createPiboSessionId() {
     return `ps_${randomUUID()}`;
 }
@@ -50,6 +51,7 @@ export class InMemoryPiboSessionStore {
     byNativeSession = new Map();
     outputRenderHighWater = new Map();
     agentObservationNextSequence = new Map();
+    agentObservationAutoCursors = new Map();
     outputToolInvocationNextOrdinal = new Map();
     get(id) {
         return this.byId.get(id);
@@ -128,6 +130,34 @@ export class InMemoryPiboSessionStore {
         this.agentObservationNextSequence.set(parentPiboSessionId, sequence + 1);
         return sequence;
     }
+    getAgentObservationAutoCursor(parentPiboSessionId, cursorScope) {
+        if (!this.byId.has(parentPiboSessionId))
+            return undefined;
+        return this.agentObservationAutoCursors.get(agentObservationAutoCursorKey(parentPiboSessionId, cursorScope));
+    }
+    advanceAgentObservationAutoCursor(parentPiboSessionId, cursorScope, sequence) {
+        if (!this.byId.has(parentPiboSessionId))
+            return sequence;
+        const key = agentObservationAutoCursorKey(parentPiboSessionId, cursorScope);
+        const advanced = Math.max(this.agentObservationAutoCursors.get(key) ?? 0, sequence);
+        this.agentObservationAutoCursors.delete(key);
+        this.agentObservationAutoCursors.set(key, advanced);
+        const prefix = `${JSON.stringify([parentPiboSessionId]).slice(0, -1)},`;
+        let scopeCount = 0;
+        for (const existingKey of this.agentObservationAutoCursors.keys()) {
+            if (existingKey.startsWith(prefix))
+                scopeCount += 1;
+        }
+        for (const existingKey of this.agentObservationAutoCursors.keys()) {
+            if (scopeCount <= PIBO_AGENT_OBSERVATION_AUTO_CURSOR_MAX_SCOPES)
+                break;
+            if (!existingKey.startsWith(prefix))
+                continue;
+            this.agentObservationAutoCursors.delete(existingKey);
+            scopeCount -= 1;
+        }
+        return advanced;
+    }
     claimOutputToolInvocationOrdinal(piboSessionId, eventId, toolCallId) {
         const key = outputToolInvocationCounterKey(piboSessionId, eventId, toolCallId);
         const ordinal = this.outputToolInvocationNextOrdinal.get(key) ?? 0;
@@ -172,6 +202,11 @@ export class InMemoryPiboSessionStore {
             this.byNativeSession.delete(nativeKey);
         this.outputRenderHighWater.delete(id);
         this.agentObservationNextSequence.delete(id);
+        const observationCursorPrefix = `${JSON.stringify([id]).slice(0, -1)},`;
+        for (const key of this.agentObservationAutoCursors.keys()) {
+            if (key.startsWith(observationCursorPrefix))
+                this.agentObservationAutoCursors.delete(key);
+        }
         const counterPrefix = `${JSON.stringify([id]).slice(0, -1)},`;
         for (const key of this.outputToolInvocationNextOrdinal.keys()) {
             if (key.startsWith(counterPrefix))
@@ -213,6 +248,9 @@ function outputRenderSequenceHighWater(metadata) {
     const value = metadata?.outputRenderSequenceHighWater;
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
 }
+function agentObservationAutoCursorKey(parentPiboSessionId, cursorScope) {
+    return JSON.stringify([parentPiboSessionId, cursorScope]);
+}
 function outputToolInvocationCounterKey(piboSessionId, eventId, toolCallId) {
     return JSON.stringify([piboSessionId, eventId, toolCallId]);
 }

package/dist/shared/tool-call-metrics.js ADDED Viewed

@@ -0,0 +1,138 @@
+import { createRequire } from "node:module";
+import { DEFAULT_TOOL_METRIC_TOKEN_CALCULATION, sanitizeToolMetricTokenCalculation, toolMetricTokenBasis, } from "./tool-call-token-settings.js";
+export const MAX_TIKTOKEN_PAYLOAD_CHARACTERS = 4_000_000;
+const require = createRequire(import.meta.url);
+let activeTokenizer;
+/** Bounded structural walk; character mode never tokenizes, copies, or scans large strings. */
+export function measureToolPayloadCharacters(payload) {
+    let budget = 10_000;
+    const seen = new WeakSet();
+    function size(value, depth) {
+        if (--budget < 0 || depth > 64)
+            return NaN;
+        if (typeof value === "string")
+            return value.length;
+        if (value === null)
+            return 4;
+        if (typeof value === "boolean")
+            return value ? 4 : 5;
+        if (typeof value === "number")
+            return String(value).length;
+        if (typeof value !== "object" || seen.has(value))
+            return NaN;
+        seen.add(value);
+        let chars = 2;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                chars += size(item, depth + 1) + 1;
+                if (!Number.isFinite(chars))
+                    return NaN;
+            }
+        }
+        else {
+            const record = value;
+            if (["image", "audio", "document", "resource", "image_url"].includes(String(record.type)))
+                return NaN;
+            for (const key in record) {
+                if (--budget < 0)
+                    return NaN;
+                if (!Object.hasOwn(record, key) || record[key] === undefined)
+                    continue;
+                chars += key.length + 3 + size(record[key], depth + 1) + 1;
+                if (!Number.isFinite(chars))
+                    return NaN;
+            }
+        }
+        seen.delete(value);
+        return chars;
+    }
+    try {
+        const chars = size(payload, 0);
+        return Number.isFinite(chars) ? chars : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function estimateToolPayloadTokens(payload, calculation = DEFAULT_TOOL_METRIC_TOKEN_CALCULATION) {
+    try {
+        const normalized = sanitizeToolMetricTokenCalculation(calculation);
+        if (normalized.method === "characters") {
+            const chars = measureToolPayloadCharacters(payload);
+            if (chars === undefined)
+                return undefined;
+            const tokens = Math.ceil(chars / normalized.factor);
+            return Number.isSafeInteger(tokens) ? tokens : undefined;
+        }
+        const text = serializableToolPayloadText(payload);
+        if (text === undefined)
+            return undefined;
+        return tiktokenPayloadTokens(text, normalized.encoding);
+    }
+    catch {
+        // Diagnostics must not turn an otherwise successful tool into a failure.
+        return undefined;
+    }
+}
+export class ToolCallMetricsCollector {
+    getCalculation;
+    active = new Map();
+    constructor(getCalculation = () => DEFAULT_TOOL_METRIC_TOKEN_CALCULATION) {
+        this.getCalculation = getCalculation;
+    }
+    start(id, args, now = performance.now()) {
+        if (this.active.has(id))
+            return;
+        const calculation = this.currentCalculation();
+        this.active.set(id, {
+            startedAt: now,
+            inputTokens: estimateToolPayloadTokens(args, calculation),
+            calculation,
+        });
+    }
+    finish(id, result, now = performance.now()) {
+        const started = this.active.get(id);
+        this.active.delete(id);
+        const calculation = started?.calculation ?? this.currentCalculation();
+        // Harness result metadata is not model-visible tool output.
+        const output = result && typeof result === "object" && "content" in result
+            ? result.content : result;
+        return {
+            tokenBasis: toolMetricTokenBasis(calculation),
+            durationMs: started ? Math.max(0, now - started.startedAt) : undefined,
+            inputTokens: started?.inputTokens,
+            outputTokens: estimateToolPayloadTokens(output, calculation),
+        };
+    }
+    clear() {
+        this.active.clear();
+    }
+    currentCalculation() {
+        try {
+            return sanitizeToolMetricTokenCalculation(this.getCalculation());
+        }
+        catch {
+            return DEFAULT_TOOL_METRIC_TOKEN_CALCULATION;
+        }
+    }
+}
+function serializableToolPayloadText(payload) {
+    const measuredCharacters = measureToolPayloadCharacters(payload);
+    if (measuredCharacters === undefined || measuredCharacters > MAX_TIKTOKEN_PAYLOAD_CHARACTERS)
+        return undefined;
+    if (typeof payload === "string")
+        return payload;
+    const serialized = JSON.stringify(payload);
+    return typeof serialized === "string" && serialized.length <= MAX_TIKTOKEN_PAYLOAD_CHARACTERS
+        ? serialized
+        : undefined;
+}
+function tiktokenPayloadTokens(text, encoding) {
+    if (activeTokenizer?.encoding !== encoding) {
+        activeTokenizer?.tokenizer.free();
+        const tiktoken = require("tiktoken");
+        activeTokenizer = { encoding, tokenizer: tiktoken.get_encoding(encoding) };
+    }
+    const tokens = activeTokenizer.tokenizer.encode_ordinary(text).length;
+    return Number.isSafeInteger(tokens) ? tokens : undefined;
+}