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

@pasko70/pibo 3.4.1 → 3.4.2

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 (39) hide show

package/dist/agent-runtime/routed-session.js +5 -1
package/dist/agent-runtimes/pi/adapter.js +4 -1
package/dist/agent-runtimes/pi/history.js +55 -1
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-B7Ju7u08.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-ERKABhp3.js → dist-BDnWOTcs.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-D0md0xIR.js → dist-CAiO6h6z.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-Abz605MV.js → dist-CCR1HsaR.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-DHnaUMlq.js → dist-CXWLhBio.js} +1 -1
package/dist/apps/chat-ui/assets/index-0cCGS0o3.js +228 -0
package/dist/apps/chat-ui/assets/index-BMJGoyM8.css +1 -0
package/dist/apps/chat-ui/index.html +2 -2
package/dist/apps/chat-vscode-web/assets/index-BD3Ogz9Z.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 +94 -11
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 +77 -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 +2 -2
package/package.json +1 -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-BD3Ogz9Z.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] : []);
@@ -2098,8 +2127,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 +2149,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 +2380,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 +2492,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 +2648,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/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,77 @@
+/** Bounded structural walk; never tokenize, copy or scan large strings. */
+export function estimateToolPayloadTokens(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;
+            // Binary/media payloads have no meaningful character-based token count.
+            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) ? Math.ceil(chars / 4) : undefined;
+    }
+    catch {
+        // Diagnostics must not turn an otherwise successful tool into a failure.
+        return undefined;
+    }
+}
+export class ToolCallMetricsCollector {
+    active = new Map();
+    start(id, args, now = performance.now()) {
+        if (this.active.has(id))
+            return;
+        this.active.set(id, { startedAt: now, inputTokens: estimateToolPayloadTokens(args) });
+    }
+    finish(id, result, now = performance.now()) {
+        const started = this.active.get(id);
+        this.active.delete(id);
+        // Harness result metadata is not model-visible tool output.
+        const output = result && typeof result === "object" && "content" in result
+            ? result.content : result;
+        return {
+            tokenBasis: "chars/4",
+            durationMs: started ? Math.max(0, now - started.startedAt) : undefined,
+            inputTokens: started?.inputTokens,
+            outputTokens: estimateToolPayloadTokens(output),
+        };
+    }
+    clear() {
+        this.active.clear();
+    }
+}

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

@@ -626,6 +626,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 toolCallId: event.toolCallId,
                 toolInvocationOrdinal: event.toolInvocationOrdinal ?? 0,
                 intent: event.intent,
+                toolMetrics: event.type === "tool_execution_finished" ? event.toolMetrics : undefined,
                 type: subagentTool ? "agent.delegation" : "tool.call",
                 title: event.toolName,
                 status: event.type === "tool_execution_finished"
@@ -1102,6 +1103,7 @@ function thinkingEventNodeId(event) {
 function mergeToolEvent(target, update) {
     target.status = update.status;
     target.intent = update.intent ?? target.intent;
+    target.toolMetrics = update.toolMetrics ?? target.toolMetrics;
     target.summary = update.summary ?? target.summary;
     target.input = mergeDelegationInput(target, update);
     target.output = update.output ?? target.output;

package/dist/shared/trace-live-reducer.js CHANGED Viewed

@@ -122,6 +122,7 @@ function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
             toolName: event.toolName,
             toolInvocationOrdinal: validOrdinal(event.toolInvocationOrdinal) ? event.toolInvocationOrdinal : undefined,
             result: event.result,
+            toolMetrics: event.toolMetrics,
             isError: Boolean(event.isError),
             ...(event.intent ? { intent: event.intent } : {}),
         };

package/dist/shared/trace-patch-nodes.js CHANGED Viewed

@@ -60,6 +60,10 @@ function traceNodeShallowEqual(left, right) {
         left.startedAt === right.startedAt &&
         left.completedAt === right.completedAt &&
         left.durationMs === right.durationMs &&
+        left.toolMetrics?.durationMs === right.toolMetrics?.durationMs &&
+        left.toolMetrics?.inputTokens === right.toolMetrics?.inputTokens &&
+        left.toolMetrics?.outputTokens === right.toolMetrics?.outputTokens &&
+        left.toolMetrics?.tokenBasis === right.toolMetrics?.tokenBasis &&
         left.summary === right.summary &&
         left.input === right.input &&
         left.output === right.output &&

package/dist/subagents/context.js CHANGED Viewed

@@ -33,14 +33,14 @@ export function getDelegatedAgentContextFile(subagents) {
             "",
             "pibo_run_wait({ runId, timeoutMs? })       # bounded wait only; expiry does not stop the child",
             "pibo_run_status({ runId })                 # compact lifecycle state",
-            "pibo_agents_observe({ requestIds?: [runId], textContains?, textRegex?, afterSequence?, limit?, includeTools?, toolDetail?, ... })",
+            "pibo_agents_observe({ requestIds?: [runId], cursorMode?: \"auto\"|\"history\", textContains?, textRegex?, afterSequence?, limit?, includeTools?, toolDetail?, ... })",
             "pibo_run_read({ runId })                   # terminal result, including the complete final agent message",
             "pibo_run_cancel({ runId })                 # explicit request cancellation",
             "pibo_agents_list_agents({})                # available definitions and persistent child instances",
             "pibo_agents_kill({ agentId })              # terminate one persistent child session subtree",
             "```",
             "",
-            "Set `sessionName` on every send to a nonblank human-readable child title of at most 40 Unicode code points. Pibo trims surrounding whitespace and rejects missing, blank, non-string, or oversized names before creating a yielded run or child session. Reuse a stable `threadKey` to continue the same child Pibo Session; a new `sessionName` updates its title without changing identity. A wait timeout is only an orchestrator wake-up. Observe defaults to the newest 20 completed assistant messages with streaming deltas, duplicate tool progress events, and tools hidden. Use `textContains` for case-insensitive substring matching or `textRegex` for case-sensitive rg/Rust-regex matching; both must match when supplied together. Set `includeTools: true` for compact tool call/result summaries, `toolDetail: \"full\"` only for bounded diagnostics, and `limit: 50` when a larger page is necessary. Use `afterSequence` from the prior result for polling.",
+            "Set `sessionName` on every send to a nonblank human-readable child title of at most 40 Unicode code points. Pibo trims surrounding whitespace and rejects missing, blank, non-string, or oversized names before creating a yielded run or child session. Reuse a stable `threadKey` to continue the same child Pibo Session; a new `sessionName` updates its title without changing identity. A wait timeout only wakes the orchestrator. Observe uses `cursorMode: \"auto\"` by default: the first equivalent query returns the newest completed assistant messages, and later calls return only unread messages. Use `cursorMode: \"history\"` only to reread earlier observations. Streaming deltas, duplicate tool progress events, and tools are hidden by default. Inspect tools only when a child stalls, reports an error, or needs targeted diagnosis; prefer exact `toolCallIds`, then `includeTools: true`, and use `toolDetail: \"full\"` only when summaries are insufficient. Use `textContains` for case-insensitive substring matching or `textRegex` for rg/Rust-regex matching; both must match when supplied together. Text, regex, identity, and event filters create separate automatic query cursors; an explicit `afterSequence` overrides and advances the matching automatic cursor.",
             "",
             "Observe progress and decide whether to continue waiting, steer through a new message after the current turn, cancel the request, or kill the child session.",
             "",