@pasko70/pibo 3.0.0 → 3.0.2

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

@@ -79,6 +79,7 @@ function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
             eventId: typeof event.runId === "string" ? event.runId : undefined,
             toolCallId: event.toolCallId,
             toolName: event.toolName,
+            toolInvocationOrdinal: validOrdinal(event.toolInvocationOrdinal) ? event.toolInvocationOrdinal : undefined,
             args: event.args,
             ...(event.intent ? { intent: event.intent } : {}),
         };
@@ -94,6 +95,7 @@ function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
                 eventId,
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
+                toolInvocationOrdinal: validOrdinal(event.toolInvocationOrdinal) ? event.toolInvocationOrdinal : undefined,
                 args: event.args,
                 partialResult: event.partialResult,
                 ...(event.intent ? { intent: event.intent } : {}),
@@ -104,6 +106,7 @@ function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
                 eventId,
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
+                toolInvocationOrdinal: validOrdinal(event.toolInvocationOrdinal) ? event.toolInvocationOrdinal : undefined,
                 args: event.args,
                 argsComplete: Boolean(event.argsComplete),
                 ...(event.intent ? { intent: event.intent } : {}),
@@ -117,6 +120,7 @@ function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
             eventId: typeof event.runId === "string" ? event.runId : undefined,
             toolCallId: event.toolCallId,
             toolName: event.toolName,
+            toolInvocationOrdinal: validOrdinal(event.toolInvocationOrdinal) ? event.toolInvocationOrdinal : undefined,
             result: event.result,
             isError: Boolean(event.isError),
             ...(event.intent ? { intent: event.intent } : {}),
@@ -140,6 +144,12 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
     const streamFrameIndex = typeof streamEvent.streamFrameIndex === "number" ? streamEvent.streamFrameIndex : undefined;
     const liveReplayId = typeof streamEvent.liveReplayId === "number" && Number.isFinite(streamEvent.liveReplayId) ? streamEvent.liveReplayId : undefined;
     const sequence = nextSequence();
+    const renderSequence = validSequence(streamEvent.renderSequence)
+        ? streamEvent.renderSequence
+        : validSequence(payload.renderSequence) ? payload.renderSequence : undefined;
+    const positionedPayload = renderSequence !== undefined && payload.renderSequence === undefined
+        ? { ...payload, renderSequence }
+        : payload;
     return {
         id: typeof streamEvent.streamId === "number"
             ? `stream:${streamEvent.streamId}:${streamFrameIndex ?? "raw"}:${type}`
@@ -150,15 +160,22 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
                     : `live:${sequence}:${type}`,
         piboSessionId,
         eventSequence: sequence,
+        renderSequence,
         streamId: typeof streamEvent.streamId === "number" ? streamEvent.streamId : undefined,
         streamFrameIndex,
         traceSource: "live",
-        eventId: typeof payload.eventId === "string" ? payload.eventId : undefined,
+        eventId: typeof positionedPayload.eventId === "string" ? positionedPayload.eventId : undefined,
         type,
         createdAt: streamEventCreatedAt(streamEvent) ?? now(),
-        payload,
+        payload: positionedPayload,
     };
 }
+function validSequence(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validOrdinal(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
 function streamEventCreatedAt(event) {
     if (typeof event.createdAt !== "string" || !Number.isFinite(Date.parse(event.createdAt)))
         return undefined;
@@ -180,8 +197,10 @@ function eventGroupKey(event) {
     const payload = isRecord(event.payload) ? event.payload : {};
     const piboSessionId = typeof payload.piboSessionId === "string" ? payload.piboSessionId : event.piboSessionId ?? "";
     const eventId = typeof payload.eventId === "string" ? payload.eventId : event.eventId ?? "";
-    if (typeof payload.toolCallId === "string")
-        return `${piboSessionId}:${eventId}:tool:${payload.toolCallId}`;
+    if (typeof payload.toolCallId === "string") {
+        const ordinal = typeof payload.toolInvocationOrdinal === "number" ? payload.toolInvocationOrdinal : 0;
+        return `${piboSessionId}:${eventId}:tool:${payload.toolCallId}:${ordinal}`;
+    }
     const assistantIndex = typeof payload.assistantIndex === "number" ? payload.assistantIndex : undefined;
     const thinkingIndex = typeof payload.thinkingIndex === "number" ? payload.thinkingIndex : undefined;
     const contentIndex = typeof payload.contentIndex === "number" ? payload.contentIndex : 0;

package/dist/shared/trace-nodes.js

@@ -19,41 +19,30 @@ function areTraceNodesSorted(nodes) {
     return true;
 }
 export function compareTraceNodes(left, right) {
-    if (left.orderKey && right.orderKey && left.orderKey.sourceRank === right.orderKey.sourceRank) {
-        const bySameSourceOrder = compareTraceOrder(left.orderKey, right.orderKey);
-        if (bySameSourceOrder !== 0)
-            return bySameSourceOrder;
+    if (!left.orderKey && !right.orderKey) {
+        return compareLegacyNodeFallback(left, right);
     }
-    else {
-        const bySameTurnPhase = compareSameTurnPhase(left, right);
-        if (bySameTurnPhase !== 0)
-            return bySameTurnPhase;
-    }
-    const byStartTime = compareOptionalIsoTime(left.startedAt, right.startedAt);
-    if (byStartTime !== 0)
-        return byStartTime;
     const byOrder = compareTraceOrder(left.orderKey, right.orderKey);
     if (byOrder !== 0)
         return byOrder;
     return left.id.localeCompare(right.id);
 }
-function compareSameTurnPhase(left, right) {
-    if (!left.eventId || left.eventId !== right.eventId)
-        return 0;
-    const leftPhase = left.orderKey?.phaseRank;
-    const rightPhase = right.orderKey?.phaseRank;
-    if (leftPhase === undefined || rightPhase === undefined)
-        return 0;
-    return leftPhase - rightPhase;
+function compareLegacyNodeFallback(left, right) {
+    const leftTime = validIsoTime(left.startedAt);
+    const rightTime = validIsoTime(right.startedAt);
+    if (leftTime !== rightTime) {
+        if (leftTime === undefined)
+            return 1;
+        if (rightTime === undefined)
+            return -1;
+        const byTime = leftTime.localeCompare(rightTime);
+        if (byTime !== 0)
+            return byTime;
+    }
+    return left.id.localeCompare(right.id);
 }
-function compareOptionalIsoTime(left, right) {
-    if (!left && !right)
-        return 0;
-    if (!left)
-        return 1;
-    if (!right)
-        return -1;
-    return left.localeCompare(right);
+function validIsoTime(value) {
+    return value !== undefined && Number.isFinite(Date.parse(value)) ? value : undefined;
 }
 export function flattenTraceNodes(nodes) {
     const flattened = [];

package/dist/shared/trace-order.js

@@ -18,12 +18,14 @@ export const TRACE_PHASE_RANK = {
     "assistant.message": 8,
     error: 9,
 };
-export function historyTraceOrder(historyIndex, contentPartIndex, type, source) {
+export function historyTraceOrder(historyIndex, contentPartIndex, type, source, createdAt) {
     return {
         sourceRank: TRACE_SOURCE_RANK[source],
         turnSeq: historyIndex,
         transcriptIndex: historyIndex,
+        eventSequence: source === "product-history" ? historyIndex : undefined,
         contentPartIndex,
+        chronologyMs: parseChronologyMs(createdAt),
         phaseRank: TRACE_PHASE_RANK[type],
     };
 }
@@ -78,12 +80,46 @@ export function compareTraceOrder(left, right) {
         return 1;
     if (!right)
         return -1;
-    return (left.sourceRank - right.sourceRank ||
-        left.turnSeq - right.turnSeq ||
+    const leftPosition = canonicalTracePosition(left);
+    const rightPosition = canonicalTracePosition(right);
+    return (compareOptionalChronology(left.chronologyMs, right.chronologyMs) ||
+        leftPosition - rightPosition ||
+        left.phaseRank - right.phaseRank ||
+        (left.contentPartIndex ?? 0) - (right.contentPartIndex ?? 0) ||
+        left.sourceRank - right.sourceRank ||
         (left.transcriptIndex ?? Number.MAX_SAFE_INTEGER) - (right.transcriptIndex ?? Number.MAX_SAFE_INTEGER) ||
         (left.eventSequence ?? Number.MAX_SAFE_INTEGER) - (right.eventSequence ?? Number.MAX_SAFE_INTEGER) ||
+        (left.renderSequence ?? Number.MAX_SAFE_INTEGER) - (right.renderSequence ?? Number.MAX_SAFE_INTEGER) ||
         (left.streamId ?? Number.MAX_SAFE_INTEGER) - (right.streamId ?? Number.MAX_SAFE_INTEGER) ||
         (left.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) - (right.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) ||
-        (left.contentPartIndex ?? 0) - (right.contentPartIndex ?? 0) ||
-        left.phaseRank - right.phaseRank);
+        left.turnSeq - right.turnSeq);
+}
+function parseChronologyMs(value) {
+    if (!value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function compareOptionalChronology(left, right) {
+    if (left === right)
+        return 0;
+    if (left === undefined)
+        return 1;
+    if (right === undefined)
+        return -1;
+    return left - right;
+}
+/**
+ * chronologyMs is the common cross-source domain; renderSequence supplies its
+ * immutable first-visible time for modern stream segments. This canonical
+ * position is the deterministic tie-break domain for equal/missing chronology.
+ * The comparator never selects a field based on the other operand, keeping the
+ * relation total and transitive.
+ */
+function canonicalTracePosition(order) {
+    return order.renderSequence
+        ?? order.eventSequence
+        ?? order.transcriptIndex
+        ?? order.streamId
+        ?? order.turnSeq;
 }

package/dist/shared/trace-page-merge.js

@@ -3,14 +3,7 @@ import { compareTraceOrder } from "./trace-order.js";
 export function mergeOlderTracePage(current, older) {
     if (current.piboSessionId !== older.piboSessionId)
         return current;
-    const seenRawEvents = new Set();
-    const rawEvents = [...older.rawEvents, ...current.rawEvents].filter((event) => {
-        const key = event.id || `${event.eventSequence ?? ""}:${event.type}:${event.createdAt}`;
-        if (seenRawEvents.has(key))
-            return false;
-        seenRawEvents.add(key);
-        return true;
-    });
+    const rawEvents = mergeTraceRawEvents(older.rawEvents, current.rawEvents, false);
     return {
         ...current,
         version: current.version,
@@ -30,7 +23,7 @@ export function mergeRefreshedTracePage(current, refreshed) {
     return {
         ...refreshed,
         nodes: mergeRefreshedTraceNodes(current.nodes, refreshed),
-        rawEvents: mergeTraceRawEvents(current.rawEvents, refreshed.rawEvents),
+        rawEvents: mergeTraceRawEvents(current.rawEvents, refreshed.rawEvents, true),
         beforeCursor: current.beforeCursor,
         firstEventSequence: current.firstEventSequence ?? refreshed.firstEventSequence,
         nextBeforeSequence: current.nextBeforeSequence,
@@ -121,14 +114,14 @@ function parseTimestamp(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
-function mergeTraceRawEvents(currentEvents, refreshedEvents) {
+function mergeTraceRawEvents(currentEvents, refreshedEvents, replaceCoveredTail) {
     if (!refreshedEvents.length)
-        return currentEvents;
-    const firstRefreshedSequence = refreshedEvents.reduce((first, event) => {
+        return [...currentEvents].sort(compareTraceRawEvents);
+    const firstRefreshedSequence = replaceCoveredTail ? refreshedEvents.reduce((first, event) => {
         if (event.eventSequence === undefined)
             return first;
         return first === undefined ? event.eventSequence : Math.min(first, event.eventSequence);
-    }, undefined);
+    }, undefined) : undefined;
     const byKey = new Map();
     for (const event of currentEvents) {
         if (firstRefreshedSequence !== undefined && event.eventSequence !== undefined && event.eventSequence >= firstRefreshedSequence)
@@ -137,7 +130,44 @@ function mergeTraceRawEvents(currentEvents, refreshedEvents) {
     }
     for (const event of refreshedEvents)
         byKey.set(traceRawEventKey(event), event);
-    return [...byKey.values()];
+    return [...byKey.values()].sort(compareTraceRawEvents);
+}
+function compareTraceRawEvents(left, right) {
+    const leftSequenceDomain = left.eventSequence === undefined ? 0 : 1;
+    const rightSequenceDomain = right.eventSequence === undefined ? 0 : 1;
+    return leftSequenceDomain - rightSequenceDomain
+        || (left.eventSequence !== undefined && right.eventSequence !== undefined
+            ? left.eventSequence - right.eventSequence
+            : 0)
+        || compareOptionalString(validTimestamp(left.createdAt), validTimestamp(right.createdAt))
+        || compareOptionalNumber(left.streamId, right.streamId)
+        || compareOptionalNumber(left.streamFrameIndex, right.streamFrameIndex)
+        || (left.eventSequence === undefined && right.eventSequence === undefined
+            ? compareOptionalNumber(left.renderSequence, right.renderSequence)
+            : 0)
+        || left.id.localeCompare(right.id)
+        || left.type.localeCompare(right.type);
+}
+function compareOptionalNumber(left, right) {
+    if (left === right)
+        return 0;
+    if (left === undefined)
+        return 1;
+    if (right === undefined)
+        return -1;
+    return left - right;
+}
+function compareOptionalString(left, right) {
+    if (left === right)
+        return 0;
+    if (left === undefined)
+        return 1;
+    if (right === undefined)
+        return -1;
+    return left.localeCompare(right);
+}
+function validTimestamp(value) {
+    return Number.isFinite(Date.parse(value)) ? value : undefined;
 }
 function traceRawEventKey(event) {
     return event.id || `${event.eventSequence ?? ""}:${event.type}:${event.createdAt}`;

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

@@ -51,6 +51,7 @@ function traceNodeShallowEqual(left, right) {
         left.piboSessionId === right.piboSessionId &&
         left.eventId === right.eventId &&
         left.toolCallId === right.toolCallId &&
+        left.toolInvocationOrdinal === right.toolInvocationOrdinal &&
         left.runId === right.runId &&
         left.intent === right.intent &&
         left.type === right.type &&
@@ -75,6 +76,7 @@ function traceOrderKeyEqual(left, right) {
         return false;
     return (left.sourceRank === right.sourceRank &&
         left.turnSeq === right.turnSeq &&
+        left.renderSequence === right.renderSequence &&
         left.transcriptIndex === right.transcriptIndex &&
         left.contentPartIndex === right.contentPartIndex &&
         left.eventSequence === right.eventSequence &&

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

@@ -1,3 +1,4 @@
+import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 export function mapTraceChildSessionsByParent(sessions) {
     const result = new Map();
     for (const session of sessions) {
@@ -15,7 +16,9 @@ export function mapTraceSubagentSessionLinks(events) {
         const event = storedEvent.payload;
         if (event.type !== "subagent_session" || !event.toolCallId)
             continue;
-        result.set(event.toolCallId, event.childPiboSessionId);
+        const eventId = event.eventId
+            ?? (event.renderSequence !== undefined ? `render:${event.renderSequence}` : "unscoped");
+        result.set(qualifiedToolNodeId(event.toolCallId, eventId, event.toolInvocationOrdinal ?? 0), event.childPiboSessionId);
     }
     return result;
 }

package/dist/shared/trace-tool-identity.js

@@ -1,20 +1,25 @@
-import { TRACE_RECONCILIATION_ENTRY_CAP } from "./trace-limits.js";
-const QUALIFIED_TOOL_PREFIX = "history-tool:";
+const QUALIFIED_TOOL_PREFIX = "tool-invocation:";
+const LEGACY_QUALIFIED_TOOL_PREFIX = "history-tool:";
 const TOOL_PREFIX = "tool:";
 const TOOL_INVOCATION_TAG = "event-tool";
-export function qualifiedHistoryToolNodeId(toolCallId, eventId, invocationOrdinal) {
+export function qualifiedToolNodeId(toolCallId, eventId, invocationOrdinal) {
     const projectionIdentity = JSON.stringify([TOOL_INVOCATION_TAG, eventId, invocationOrdinal]);
     return `${QUALIFIED_TOOL_PREFIX}${encodeURIComponent(JSON.stringify([toolCallId, projectionIdentity]))}`;
 }
+/** @deprecated Use qualifiedToolNodeId for every projection source. */
+export const qualifiedHistoryToolNodeId = qualifiedToolNodeId;
 export function parseTraceToolNodeIdentity(nodeId) {
     if (nodeId.startsWith(TOOL_PREFIX)) {
         const toolCallId = nodeId.slice(TOOL_PREFIX.length);
         return toolCallId ? { toolCallId } : undefined;
     }
-    if (!nodeId.startsWith(QUALIFIED_TOOL_PREFIX))
+    const qualifiedPrefix = nodeId.startsWith(QUALIFIED_TOOL_PREFIX)
+        ? QUALIFIED_TOOL_PREFIX
+        : nodeId.startsWith(LEGACY_QUALIFIED_TOOL_PREFIX) ? LEGACY_QUALIFIED_TOOL_PREFIX : undefined;
+    if (!qualifiedPrefix)
         return undefined;
     try {
-        const decoded = JSON.parse(decodeURIComponent(nodeId.slice(QUALIFIED_TOOL_PREFIX.length)));
+        const decoded = JSON.parse(decodeURIComponent(nodeId.slice(qualifiedPrefix.length)));
         if (!Array.isArray(decoded)
             || decoded.length !== 2
             || typeof decoded[0] !== "string"
@@ -28,14 +33,16 @@ export function parseTraceToolNodeIdentity(nodeId) {
             || typeof qualifier[1] !== "string"
             || qualifier[1].length === 0
             || !Number.isSafeInteger(qualifier[2])
-            || Number(qualifier[2]) < 0
-            || Number(qualifier[2]) >= TRACE_RECONCILIATION_ENTRY_CAP)
+            || Number(qualifier[2]) < 0)
             return undefined;
         const identity = {
             toolCallId: decoded[0],
             qualifier: { eventId: qualifier[1], invocationOrdinal: Number(qualifier[2]) },
         };
-        return qualifiedHistoryToolNodeId(identity.toolCallId, identity.qualifier.eventId, identity.qualifier.invocationOrdinal) === nodeId ? identity : undefined;
+        const canonicalId = qualifiedToolNodeId(identity.toolCallId, identity.qualifier.eventId, identity.qualifier.invocationOrdinal);
+        return canonicalId === nodeId || canonicalId.replace(QUALIFIED_TOOL_PREFIX, LEGACY_QUALIFIED_TOOL_PREFIX) === nodeId
+            ? identity
+            : undefined;
     }
     catch {
         return undefined;

package/dist/signals/projector.js

@@ -16,9 +16,22 @@ function runStatus(status) {
         return "error";
     return status;
 }
-function settleActiveSessionNodes(piboSessionId, context, status, terminalSource) {
+function nodeBelongsToTurn(node, turnNodeId, context) {
+    let current = node;
+    const visited = new Set();
+    while (current && !visited.has(current.id)) {
+        if (current.id === turnNodeId || current.parentNodeId === turnNodeId)
+            return true;
+        visited.add(current.id);
+        current = current.parentNodeId ? context.getNode(current.parentNodeId) : undefined;
+    }
+    return false;
+}
+function settleActiveSessionNodes(piboSessionId, context, status, terminalSource, eventId) {
+    const turnNodeId = eventId ? `turn:${piboSessionId}:${eventId}` : undefined;
     return context.getSessionNodes(piboSessionId)
         .filter((node) => node.kind !== "session" && node.kind !== "yielded_run" && isActiveSignalStatus(node.status))
+        .filter((node) => !turnNodeId || nodeBelongsToTurn(node, turnNodeId, context))
         .filter((node) => terminalSource !== "processing_stopped" || node.kind !== "turn" || node.metadata?.accepted !== true)
         .map((node) => ({
         type: "patch_node",
@@ -210,12 +223,21 @@ export const outputSignalProducer = {
             mutations.push(...settleActiveSessionNodes(piboSessionId, context, "done", "message_finished"));
         }
         if (event.type === "session_error") {
-            mutations.push({ type: "set_session_queue", piboSessionId, queuedMessages: 0 });
-            mutations.push(...settleActiveSessionNodes(piboSessionId, context, "error", "session_error"));
-            mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" } } });
+            const turnNodeId = event.eventId ? `turn:${piboSessionId}:${event.eventId}` : undefined;
+            const hasUnrelatedActiveTurn = Boolean(turnNodeId && context.getSessionNodes(piboSessionId)
+                .some((candidate) => candidate.kind === "turn" && candidate.id !== turnNodeId && isActiveSignalStatus(candidate.status)));
+            const error = { message: event.error, source: "pi" };
+            if (!hasUnrelatedActiveTurn)
+                mutations.push({ type: "set_session_queue", piboSessionId, queuedMessages: 0 });
+            mutations.push(...settleActiveSessionNodes(piboSessionId, context, "error", "session_error", hasUnrelatedActiveTurn ? event.eventId : undefined));
+            mutations.push({
+                type: "patch_node",
+                nodeId: `session:${piboSessionId}`,
+                patch: hasUnrelatedActiveTurn ? { error } : { status: "error", completedAt: context.now(), error },
+            });
             if (event.eventId) {
-                mutations.push({ type: "patch_node", nodeId: `message:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" } } });
-                mutations.push({ type: "patch_node", nodeId: `turn:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" }, metadata: { ...eventTurn?.metadata, terminalSource: "session_error" } } });
+                mutations.push({ type: "patch_node", nodeId: `message:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error } });
+                mutations.push({ type: "patch_node", nodeId: `turn:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error, metadata: { ...eventTurn?.metadata, terminalSource: "session_error" } } });
             }
         }
         return mutations;

package/dist/subagents/tool.js

@@ -77,7 +77,10 @@ export function formatAgentObservationsForModel(result) {
         const event = observation.kind === "tool"
             ? `${observation.eventType}${observation.toolName ? ` ${observation.toolName}` : ""}`
             : observation.eventType;
-        lines.push("", `#${observation.sequence} ${scope} — ${event}${observation.isError ? " [error]" : ""}`);
+        const toolCall = observation.kind === "tool" && observation.toolCallId
+            ? `; toolCallId=${observation.toolCallId}`
+            : "";
+        lines.push("", `#${observation.sequence} ${scope} — ${event}${toolCall}${observation.isError ? " [error]" : ""}`);
         if (observation.text)
             lines.push(observation.text);
     }
@@ -186,13 +189,14 @@ export function createAgentToolDefinitions(subagents, controller) {
             description: [
                 "Read completed delegated-agent messages with bounded cursor, identity, event, time, text, order, and limit filters.",
                 "Default: the newest 20 completed assistant messages, with streaming deltas and tools hidden.",
-                "Set includeTools=true to add compact tool calls and terminal results; set toolDetail=full only for bounded diagnostic inspection.",
+                "Set includeTools=true to add compact tool calls and terminal results, or pass toolCallIds to retrieve only those exact tool observations. Set toolDetail=full only for bounded diagnostic inspection.",
             ].join("\n"),
-            promptSnippet: "Observe child-agent progress through completed assistant messages. Defaults: newest 20 messages, no streaming deltas, no duplicate tool progress events, no tools. Set includeTools=true for compact tool call/result summaries, toolDetail=full for bounded raw tool text, or eventTypes/kinds for explicit progress diagnostics. Pass afterSequence from the previous result for cursor polling; cursor pages consume the oldest unseen matches even when order is desc.",
+            promptSnippet: "Observe child-agent progress through completed assistant messages. Defaults: newest 20 messages, no streaming deltas, no duplicate tool progress events, no tools. Set includeTools=true for compact tool call/result summaries, pass up to 50 exact toolCallIds to retrieve only those tool observations, use toolDetail=full for bounded raw tool text, or eventTypes/kinds for explicit progress diagnostics. Compact tool entries expose their toolCallId for follow-up queries. Pass afterSequence from the previous result for cursor polling; cursor pages consume the oldest unseen matches even when order is desc.",
             executionMode: "parallel",
             annotations: { readOnly: true },
             inputSchema: Type.Object({
                 requestIds: Type.Optional(Type.Array(Type.String({ description: "Exact yielded run/request ID" }), { maxItems: 50 })),
+                toolCallIds: Type.Optional(Type.Array(Type.String({ description: "Exact existing toolCallId. Multiple values use OR semantics and return only matching tool observations." }), { maxItems: 50 })),
                 agentIds: Type.Optional(Type.Array(Type.String({ description: "Owned child agentId" }), { maxItems: 50 })),
                 names: Type.Optional(Type.Array(piboStringEnum(names), { maxItems: 50 })),
                 threadKeys: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),

package/docs/ops/vscode-extension-release.md

@@ -151,7 +151,15 @@ The `files` whitelist in `package.json` controls what is published:
 - `docs/ops/**` — operator runbooks.
 - `README.md` and `src/mcp/LICENSE.mcp-cli`.
 
-The `.vsix` is **not** in the npm package. It lives on the GitHub Release and (after the maintainer uploads it) on the VS Code Marketplace.
+The `.vsix` is **not** in the npm package. The `package.json#files` whitelist explicitly excludes `dist/apps/vscode-artifacts/**` even when the release workflow creates the versioned VSIX and `latest.vsix` before `npm publish`. Those files remain in the workspace for GitHub Release and Marketplace upload.
+
+Verify the package boundary before publishing:
+
+```bash
+npm pack --dry-run --json --ignore-scripts | node -e 'let input=""; process.stdin.on("data", chunk => input += chunk).on("end", () => { const files = JSON.parse(input)[0].files.map(file => file.path); if (files.some(file => file.startsWith("dist/apps/vscode-artifacts/"))) process.exit(1); })'
+```
+
+The VSIX lives on the GitHub Release and (after the maintainer uploads it) on the VS Code Marketplace.
 
 ## Why the WebView bundle is in the npm package
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.0.0",
+      "version": "3.0.2",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "type": "module",
   "workspaces": [
     "packages/workflows"
@@ -8,6 +8,7 @@
   "description": "Minimal TypeScript wrapper around Pi Coding Agent.",
   "files": [
     "dist",
+    "!dist/apps/vscode-artifacts/**",
     "context",
     "skills/builtin/**",
     "docs/ops/**",