@sebastianandreasson/pi-autonomous-agents 0.15.0 → 0.15.2

package/README.md

@@ -82,6 +82,14 @@ Start from [templates/pi.config.example.json](./templates/pi.config.example.json
 
 Request telemetry is enabled by default for SDK runs. `pi-harness` writes a managed Pi extension package under `.pi/extensions/pi-harness-request-telemetry/` in the consuming repo, with a `package.json` manifest and `index.mjs` shim that Pi auto-discovers on the next resource reload. Disable that with `PI_REQUEST_TELEMETRY_ENABLED=0` or `"piRequestTelemetryEnabled": false`.
 
+By default the extension now stores compact request telemetry only:
+- `requests.jsonl` with exact request totals and summarized tool/file attribution
+- `spans.jsonl` with byte counts and attribution metadata, but not full prompt text
+
+Verbose hook traces and raw span text are opt-in for debugging:
+- `PI_REQUEST_TELEMETRY_STORE_HOOKS=1` or `"piRequestTelemetryStoreHooks": true`
+- `PI_REQUEST_TELEMETRY_STORE_SPAN_TEXT=1` or `"piRequestTelemetryStoreSpanText": true`
+
 ## CLI
 
 ```bash

package/docs/PI_REQUEST_TELEMETRY_EXTENSION.md

@@ -4,14 +4,28 @@ This document describes the repo-local Pi extension prototype under [pi-extensio
 
 In normal `pi-harness` SDK runs, this extension is auto-enabled by installing a managed extension package under `.pi/extensions/pi-harness-request-telemetry/` in the consuming repo before Pi reloads resources. That package contains a `package.json` Pi manifest plus the generated `index.mjs` shim. Opt out with `PI_REQUEST_TELEMETRY_ENABLED=0` or `"piRequestTelemetryEnabled": false`.
 
+The default storage mode is compact:
+
+- `requests.jsonl` is always kept
+- `spans.jsonl` keeps attribution metadata and byte counts, but not full prompt text
+- `hooks.jsonl` is disabled by default
+
+Enable deeper debug capture only when needed:
+
+- `PI_REQUEST_TELEMETRY_STORE_HOOKS=1` or `"piRequestTelemetryStoreHooks": true`
+- `PI_REQUEST_TELEMETRY_STORE_SPAN_TEXT=1` or `"piRequestTelemetryStoreSpanText": true`
+
 The purpose of this extension is to gather request-level data directly from Pi extension hooks before we decide whether to patch `@mariozechner/pi-coding-agent` or `pi-ai`.
 
 ## Produced Artifacts
 
-- `pi-output/request-telemetry/hooks.jsonl`
 - `pi-output/request-telemetry/requests.jsonl`
 - `pi-output/request-telemetry/spans.jsonl`
 
+Optional when hook tracing is enabled:
+
+- `pi-output/request-telemetry/hooks.jsonl`
+
 These artifacts are intentionally separate from the existing `pi-output/token-usage/*` files.
 
 `token-usage` remains the harness-level normalized output.
@@ -109,7 +123,7 @@ Interpretation:
 - `message_end`
 - `turn_end`
 
-Use it to debug request association problems or confirm whether Pi emitted provider-boundary hooks for a specific run.
+Use it to debug request association problems or confirm whether Pi emitted provider-boundary hooks for a specific run. This file is off by default because it grows quickly and is only useful for telemetry debugging.
 
 ## Span Artifact Schema
 
@@ -131,6 +145,9 @@ Each row in `spans.jsonl` contains one extracted prompt span:
 - `primaryPath`
 - `charCount`
 - `byteCount`
+
+Optional only when raw span text capture is enabled:
+
 - `text`
 - `preview`
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sebastianandreasson/pi-autonomous-agents",
   "private": false,
-  "version": "0.15.0",
+  "version": "0.15.2",
   "type": "module",
   "description": "Portable unattended PI harness for developer/tester/visual-review loops.",
   "license": "MIT",

package/pi-extensions/request-telemetry/README.md

@@ -4,10 +4,13 @@ This is a repo-local Pi extension prototype for capturing lower-level request te
 
 It writes:
 
-- `pi-output/request-telemetry/hooks.jsonl`
 - `pi-output/request-telemetry/requests.jsonl`
 - `pi-output/request-telemetry/spans.jsonl`
 
+Optional when debug tracing is enabled:
+
+- `pi-output/request-telemetry/hooks.jsonl`
+
 The goal is to capture exact request boundaries and exact prompt composition before deciding whether we need to patch `pi-mono` itself.
 
 ## What It Captures
@@ -20,12 +23,16 @@ The goal is to capture exact request boundaries and exact prompt composition bef
 - provider payload summary from `before_provider_request`
 - response status and headers from `after_provider_response`
 - final assistant-message usage if Pi exposes it on `message.usage`
-- lifecycle hook traces in `hooks.jsonl` so you can debug request association
 - `spanSource` on each request so consumers can distinguish:
   - `provider_payload`
   - `context`
   - `session_history`
 
+Default storage is compact:
+
+- `spans.jsonl` keeps attribution metadata and byte counts, not full prompt text
+- `hooks.jsonl` is off by default because it is mainly for telemetry debugging
+
 ## What It Does Not Claim Yet
 
 - exact per-file token spend
@@ -50,6 +57,13 @@ Disable that path with:
 - `PI_REQUEST_TELEMETRY_ENABLED=0`
 - `"piRequestTelemetryEnabled": false` in `pi.config.json`
 
+Enable deeper telemetry capture only when needed:
+
+- `PI_REQUEST_TELEMETRY_STORE_HOOKS=1`
+- `"piRequestTelemetryStoreHooks": true`
+- `PI_REQUEST_TELEMETRY_STORE_SPAN_TEXT=1`
+- `"piRequestTelemetryStoreSpanText": true`
+
 ## Running It From This Repo
 
 Use the extension file directly:

package/pi-extensions/request-telemetry/index.mjs

@@ -5,11 +5,13 @@ import {
   appendRequestTelemetryArtifacts,
   collectMessageSpans,
   collectProviderPayloadSpans,
+  collectToolHookSpans,
   deriveToolPaths,
   extractMessagesFromProviderPayload,
   extractUsageFromMessage,
   getRequestTelemetryPaths,
   readRequestTelemetryContextFromEnv,
+  readRequestTelemetryStorageOptionsFromEnv,
   summarizeProviderPayload,
   summarizeRequestSpans,
 } from '../../src/pi-request-telemetry.mjs'
@@ -49,6 +51,7 @@ function createTurnState({ turnIndex = 0, startedAt = '', model = '' } = {}) {
     contextMessageCount: 0,
     contextSpanCount: 0,
     lastAssistantMessage: null,
+    recentToolEvents: [],
   }
 }
 
@@ -118,6 +121,55 @@ function mergeSpanSummary(requestState) {
   }
 }
 
+function getSpanSignal(requestState) {
+  const spans = Array.isArray(requestState?.spans) ? requestState.spans : []
+  let toolSpanCount = 0
+
+  for (const span of spans) {
+    const kind = String(span?.spanKind ?? '').trim()
+    if (kind === 'tool_call' || kind === 'tool_result') {
+      toolSpanCount += 1
+    }
+  }
+
+  return {
+    spanCount: spans.length,
+    toolSpanCount,
+    toolNameCount: requestState?.toolNames?.size ?? 0,
+    fileCount: requestState?.files?.size ?? 0,
+  }
+}
+
+function shouldPreferSnapshot(currentState, candidateState) {
+  const current = getSpanSignal(currentState)
+  const candidate = getSpanSignal(candidateState)
+
+  const currentHasToolContext = current.toolSpanCount > 0 || current.toolNameCount > 0 || current.fileCount > 0
+  const candidateHasToolContext = candidate.toolSpanCount > 0 || candidate.toolNameCount > 0 || candidate.fileCount > 0
+
+  if (candidateHasToolContext && !currentHasToolContext) {
+    return true
+  }
+
+  if (candidate.fileCount !== current.fileCount) {
+    return candidate.fileCount > current.fileCount
+  }
+
+  if (candidate.toolSpanCount !== current.toolSpanCount) {
+    return candidate.toolSpanCount > current.toolSpanCount
+  }
+
+  if (candidate.toolNameCount !== current.toolNameCount) {
+    return candidate.toolNameCount > current.toolNameCount
+  }
+
+  if (current.spanCount === 0 && candidate.spanCount > 0) {
+    return true
+  }
+
+  return false
+}
+
 function applyAssistantMessage(requestState, message) {
   requestState.provider = String(message?.provider ?? requestState.provider ?? '').trim()
   requestState.model = String(message?.model ?? requestState.model ?? '').trim()
@@ -133,6 +185,7 @@ function applyAssistantMessage(requestState, message) {
 
 export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
   const artifacts = getRequestTelemetryPaths({ cwd })
+  const storage = readRequestTelemetryStorageOptionsFromEnv()
   const state = {
     sessionId: randomUUID(),
     currentModel: '',
@@ -164,6 +217,10 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
   }
 
   function trace(type, detail = {}) {
+    if (!storage.storeHooks) {
+      return Promise.resolve()
+    }
+
     state.hookSequence += 1
     const activeRequest = getLatestPendingRequest()
     const currentTurn = state.currentTurn
@@ -277,6 +334,32 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
     return false
   }
 
+  function applyToolHookSnapshot(requestState) {
+    const currentTurn = getCurrentTurn()
+    const toolEvents = Array.isArray(currentTurn.recentToolEvents) ? currentTurn.recentToolEvents : []
+    if (toolEvents.length === 0) {
+      return false
+    }
+
+    const spans = collectToolHookSpans({
+      requestId: requestState.requestId,
+      sessionId: requestState.sessionId,
+      turnIndex: requestState.turnIndex,
+      toolEvents,
+    })
+    if (spans.length === 0) {
+      return false
+    }
+
+    applySpanSnapshot(requestState, {
+      messages: [],
+      spans,
+      source: 'tool_hooks',
+    })
+    mergeSpanSummary(requestState)
+    return true
+  }
+
   function createProviderRequest(overrides = {}) {
     const currentTurn = getCurrentTurn()
     return createRequestState({
@@ -289,6 +372,23 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
     })
   }
 
+  function createComparableRequestState(baseState) {
+    return createRequestState({
+      sessionId: baseState.sessionId,
+      turnIndex: baseState.turnIndex,
+      startedAt: baseState.startedAt,
+      model: baseState.model,
+      metadata: {
+        runId: baseState.runId,
+        iteration: baseState.iteration,
+        phase: baseState.phase,
+        role: baseState.role,
+        kind: baseState.kind,
+        task: baseState.task,
+      },
+    })
+  }
+
   function createFallbackRequest() {
     const requestState = createProviderRequest()
 
@@ -345,6 +445,8 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
         ...requestState.usage,
       },
       spans: requestState.spans,
+    }, {
+      includeSpanText: storage.storeSpanText,
     })
   }
 
@@ -416,11 +518,57 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
     })
 
     pi.on('before_provider_request', (event) => {
+      const currentTurn = getCurrentTurn()
       const requestState = createProviderRequest()
-      if (!applyProviderPayloadSnapshot(requestState, event?.payload) && !applyContextSnapshot(requestState)) {
+      const providerApplied = applyProviderPayloadSnapshot(requestState, event?.payload)
+
+      const contextCandidate = createComparableRequestState(requestState)
+      const contextApplied = applyContextSnapshot(contextCandidate)
+      if (contextApplied && shouldPreferSnapshot(requestState, contextCandidate)) {
+        requestState.contextMessages = contextCandidate.contextMessages
+        requestState.spans = contextCandidate.spans
+        requestState.spanSource = contextCandidate.spanSource
+        requestState.contextMessageCount = contextCandidate.contextMessageCount
+        requestState.spanCount = contextCandidate.spanCount
+        requestState.textChars = contextCandidate.textChars
+        requestState.textBytes = contextCandidate.textBytes
+        requestState.toolNames = contextCandidate.toolNames
+        requestState.files = contextCandidate.files
+      }
+
+      const sessionHistoryCandidate = createComparableRequestState(requestState)
+      const sessionHistoryApplied = applySessionHistorySnapshot(sessionHistoryCandidate)
+      if (sessionHistoryApplied && shouldPreferSnapshot(requestState, sessionHistoryCandidate)) {
+        requestState.contextMessages = sessionHistoryCandidate.contextMessages
+        requestState.spans = sessionHistoryCandidate.spans
+        requestState.spanSource = sessionHistoryCandidate.spanSource
+        requestState.contextMessageCount = sessionHistoryCandidate.contextMessageCount
+        requestState.spanCount = sessionHistoryCandidate.spanCount
+        requestState.textChars = sessionHistoryCandidate.textChars
+        requestState.textBytes = sessionHistoryCandidate.textBytes
+        requestState.toolNames = sessionHistoryCandidate.toolNames
+        requestState.files = sessionHistoryCandidate.files
+      }
+
+      const toolHookCandidate = createComparableRequestState(requestState)
+      const toolHookApplied = applyToolHookSnapshot(toolHookCandidate)
+      if (toolHookApplied && shouldPreferSnapshot(requestState, toolHookCandidate)) {
+        requestState.contextMessages = toolHookCandidate.contextMessages
+        requestState.spans = toolHookCandidate.spans
+        requestState.spanSource = toolHookCandidate.spanSource
+        requestState.contextMessageCount = toolHookCandidate.contextMessageCount
+        requestState.spanCount = toolHookCandidate.spanCount
+        requestState.textChars = toolHookCandidate.textChars
+        requestState.textBytes = toolHookCandidate.textBytes
+        requestState.toolNames = toolHookCandidate.toolNames
+        requestState.files = toolHookCandidate.files
+      }
+
+      if (!providerApplied && requestState.spans.length === 0 && !contextApplied && !sessionHistoryApplied && !toolHookApplied) {
         applySessionHistorySnapshot(requestState)
       }
       state.pendingRequests.push(requestState)
+      currentTurn.recentToolEvents = []
 
       void trace('before_provider_request', {
         requestId: requestState.requestId,
@@ -448,15 +596,28 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
     })
 
     pi.on('tool_execution_start', (event) => {
+      const currentTurn = getCurrentTurn()
       const toolCallId = String(event?.toolCallId ?? '').trim()
       const toolName = String(event?.toolName ?? '').trim()
       const paths = deriveToolPaths(toolName, event?.args)
       if (toolCallId !== '') {
         state.toolCallIndex.set(toolCallId, { toolName, paths })
       }
+      currentTurn.recentToolEvents = [
+        ...(currentTurn.recentToolEvents ?? []).filter((item) => String(item?.toolCallId ?? '') !== toolCallId),
+        {
+          toolCallId,
+          toolName,
+          args: event?.args,
+          details: undefined,
+          content: [],
+          timestamp: new Date().toISOString(),
+        },
+      ]
     })
 
     pi.on('tool_result', (event) => {
+      const currentTurn = getCurrentTurn()
       const toolCallId = String(event?.toolCallId ?? '').trim()
       if (toolCallId === '') {
         return
@@ -475,6 +636,17 @@ export function createRequestTelemetryExtension({ cwd = process.cwd() } = {}) {
         toolName: current.toolName,
         paths: [...new Set([...current.paths, ...resultPaths])],
       })
+      currentTurn.recentToolEvents = [
+        ...(currentTurn.recentToolEvents ?? []).filter((item) => String(item?.toolCallId ?? '') !== toolCallId),
+        {
+          toolCallId,
+          toolName: current.toolName,
+          args: event?.input,
+          details: event?.details,
+          content: Array.isArray(event?.content) ? event.content : [],
+          timestamp: new Date().toISOString(),
+        },
+      ]
     })
 
     pi.on('message_end', async (event) => {

package/src/index.mjs

@@ -31,12 +31,14 @@ export {
   appendRequestTelemetryArtifacts,
   collectMessageSpans,
   collectProviderPayloadSpans,
+  compactRequestSpanRecord,
   createEmptyRequestTelemetryBreakdown,
   createEmptyRequestUsage,
   deriveRequestTelemetryAnalytics,
   deriveRequestTelemetryBreakdown,
   deriveToolPaths,
   readRequestTelemetryContextFromEnv,
+  readRequestTelemetryStorageOptionsFromEnv,
   readRequestTelemetryRecords,
   extractMessagesFromProviderPayload,
   extractUsageFromMessage,

package/src/pi-client.mjs

@@ -234,6 +234,8 @@ async function runSdkTransportTurn({ config, model, sessionId, sessionFile, prom
       thinking: config.piThinking,
       noExtensions: config.piNoExtensions,
       requestTelemetryEnabled: config.piRequestTelemetryEnabled,
+      requestTelemetryStoreHooks: config.piRequestTelemetryStoreHooks,
+      requestTelemetryStoreSpanText: config.piRequestTelemetryStoreSpanText,
       noSkills: config.piNoSkills,
       noPromptTemplates: config.piNoPromptTemplates,
       noThemes: config.piNoThemes,

package/src/pi-config.mjs

@@ -266,6 +266,8 @@ export function loadConfig(mode = 'once') {
     piThinking: readString('PI_THINKING', file.piThinking, ''),
     piNoExtensions: readBool('PI_NO_EXTENSIONS', file.piNoExtensions, false),
     piRequestTelemetryEnabled: readBool('PI_REQUEST_TELEMETRY_ENABLED', file.piRequestTelemetryEnabled, true),
+    piRequestTelemetryStoreHooks: readBool('PI_REQUEST_TELEMETRY_STORE_HOOKS', file.piRequestTelemetryStoreHooks, false),
+    piRequestTelemetryStoreSpanText: readBool('PI_REQUEST_TELEMETRY_STORE_SPAN_TEXT', file.piRequestTelemetryStoreSpanText, false),
     piNoSkills: readBool('PI_NO_SKILLS', file.piNoSkills, false),
     piNoPromptTemplates: readBool('PI_NO_PROMPT_TEMPLATES', file.piNoPromptTemplates, false),
     piNoThemes: readBool('PI_NO_THEMES', file.piNoThemes, true),

package/src/pi-history.mjs

@@ -24,6 +24,7 @@ export function collectHistoryTargets(config) {
     config.lastIterationSummaryFile,
     config.tokenUsageEventsFile,
     config.tokenUsageSummaryFile,
+    path.join(config.cwd, 'pi-output/request-telemetry'),
     config.piRuntimeDir,
     config.visualFeedbackFile,
     config.testerFeedbackFile,

package/src/pi-request-telemetry.mjs

@@ -12,6 +12,10 @@ export const REQUEST_TELEMETRY_ENV_KEYS = Object.freeze({
   kind: 'PI_REQUEST_KIND',
   task: 'PI_REQUEST_TASK',
 })
+export const REQUEST_TELEMETRY_STORAGE_ENV_KEYS = Object.freeze({
+  storeHooks: 'PI_REQUEST_TELEMETRY_STORE_HOOKS',
+  storeSpanText: 'PI_REQUEST_TELEMETRY_STORE_SPAN_TEXT',
+})
 
 const scriptDir = path.dirname(fileURLToPath(import.meta.url))
 const packageRoot = path.resolve(scriptDir, '..')
@@ -94,6 +98,24 @@ function asObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
 }
 
+function parseBooleanFlag(value, fallback = false) {
+  if (value === undefined || value === null || value === '') {
+    return fallback
+  }
+  if (typeof value === 'boolean') {
+    return value
+  }
+
+  const normalized = String(value).trim().toLowerCase()
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') {
+    return true
+  }
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') {
+    return false
+  }
+  return fallback
+}
+
 function createBucketMap() {
   return new Map()
 }
@@ -279,6 +301,13 @@ export function readRequestTelemetryContextFromEnv(env = process.env) {
   }
 }
 
+export function readRequestTelemetryStorageOptionsFromEnv(env = process.env) {
+  return {
+    storeHooks: parseBooleanFlag(env?.[REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeHooks], false),
+    storeSpanText: parseBooleanFlag(env?.[REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeSpanText], false),
+  }
+}
+
 export function normalizeRequestUsage(value) {
   if (!value || typeof value !== 'object') {
     return createEmptyRequestUsage()
@@ -427,6 +456,84 @@ function parseStructuredTextArray(items) {
   return parts
 }
 
+function normalizeProviderToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls)) {
+    return []
+  }
+
+  const parts = []
+  for (const item of toolCalls) {
+    const object = asObject(item)
+    const functionObject = asObject(object.function)
+    const id = normalizeString(object.id ?? object.call_id, '')
+    const name = normalizeString(
+      functionObject.name
+      ?? object.name,
+      ''
+    )
+    const argumentsValue = parseJsonLikeString(
+      functionObject.arguments
+      ?? object.arguments
+    )
+
+    if (name === '' && id === '' && argumentsValue === undefined) {
+      continue
+    }
+
+    parts.push({
+      type: 'toolCall',
+      id,
+      name,
+      arguments: argumentsValue,
+    })
+  }
+
+  return parts
+}
+
+function normalizeMessageContent(content) {
+  if (typeof content === 'string') {
+    return [{ type: 'text', text: content }]
+  }
+
+  if (Array.isArray(content)) {
+    return parseStructuredTextArray(content)
+  }
+
+  return []
+}
+
+function normalizeProviderRoleMessage(object) {
+  const role = normalizeString(object.role, '')
+  if (role === '') {
+    return null
+  }
+
+  if (role === 'tool') {
+    return {
+      role: 'toolResult',
+      toolCallId: normalizeString(object.tool_call_id ?? object.call_id ?? object.id, ''),
+      toolName: normalizeString(object.name, ''),
+      details: object,
+      content: [{
+        type: 'text',
+        text: typeof object.content === 'string' ? object.content : safeJson(object.content),
+      }],
+    }
+  }
+
+  const content = normalizeMessageContent(object.content)
+  const toolCalls = normalizeProviderToolCalls(object.tool_calls)
+
+  return {
+    role,
+    content: [...content, ...toolCalls],
+    toolCallId: normalizeString(object.toolCallId ?? object.tool_call_id ?? object.call_id, ''),
+    toolName: normalizeString(object.toolName ?? object.name, ''),
+    details: object.details,
+  }
+}
+
 function convertProviderInputItemToMessage(item) {
   const object = asObject(item)
 
@@ -470,20 +577,7 @@ function convertProviderInputItemToMessage(item) {
   }
 
   if (object.role) {
-    if (typeof object.content === 'string') {
-      return {
-        role: normalizeString(object.role, ''),
-        content: [{ type: 'text', text: object.content }],
-      }
-    }
-
-    return {
-      role: normalizeString(object.role, ''),
-      content: parseStructuredTextArray(object.content),
-      toolCallId: normalizeString(object.toolCallId, ''),
-      toolName: normalizeString(object.toolName, ''),
-      details: object.details,
-    }
+    return normalizeProviderRoleMessage(object)
   }
 
   const normalized = normalizeTextPart(object)
@@ -505,6 +599,22 @@ export function extractMessagesFromProviderPayload(payload) {
 
   if (Array.isArray(object.messages)) {
     return object.messages
+      .map((item) => {
+        if (typeof item === 'string') {
+          return {
+            role: 'user',
+            content: [{ type: 'text', text: item }],
+          }
+        }
+        if (!item || typeof item !== 'object') {
+          return null
+        }
+        if (item.role) {
+          return normalizeProviderRoleMessage(asObject(item))
+        }
+        return convertProviderInputItemToMessage(item)
+      })
+      .filter((message) => normalizeString(message?.role, '') !== '')
   }
 
   if (typeof object.input === 'string') {
@@ -562,6 +672,17 @@ export function normalizeRequestSpanRecord(record) {
   }
 }
 
+export function compactRequestSpanRecord(record, { includeText = false, includePreview = false } = {}) {
+  const normalized = normalizeRequestSpanRecord(record)
+  if (!includeText) {
+    delete normalized.text
+  }
+  if (!includeText || !includePreview) {
+    delete normalized.preview
+  }
+  return normalized
+}
+
 export function createEmptyRequestTelemetryBreakdown() {
   return createEmptyBreakdownShape('request_telemetry')
 }
@@ -724,6 +845,84 @@ export function collectProviderPayloadSpans({
   }
 }
 
+function joinToolContentText(content = []) {
+  if (!Array.isArray(content)) {
+    return ''
+  }
+
+  return content
+    .map((item) => {
+      const object = asObject(item)
+      if (normalizeString(object.type, '') === 'text') {
+        return String(object.text ?? '')
+      }
+      return ''
+    })
+    .filter(Boolean)
+    .join('\n')
+}
+
+export function collectToolHookSpans({
+  requestId = '',
+  sessionId = '',
+  turnIndex = 0,
+  toolEvents = [],
+  timestamp = now(),
+} = {}) {
+  const spans = []
+
+  for (let index = 0; index < (Array.isArray(toolEvents) ? toolEvents.length : 0); index += 1) {
+    const event = asObject(toolEvents[index])
+    const toolCallId = normalizeString(event.toolCallId, '')
+    const toolName = normalizeString(event.toolName, '')
+    const args = parseJsonLikeString(event.args ?? event.input)
+    const details = parseJsonLikeString(event.details)
+    const contentText = joinToolContentText(event.content)
+    const detailText = safeJson(details)
+    const resultText = [contentText, detailText].filter(Boolean).join('\n')
+    const paths = normalizeStringList([
+      ...deriveToolPaths(toolName, args),
+      ...deriveToolPaths(toolName, details),
+    ])
+    const base = createSpanBase({
+      requestId,
+      sessionId,
+      turnIndex,
+      timestamp: event.timestamp ?? timestamp,
+      role: 'toolResult',
+      messageIndex: index,
+      spanIndex: 0,
+      source: 'tool_hooks',
+    })
+
+    if (args !== undefined) {
+      spans.push(createTextSpan(base, {
+        spanIndex: 0,
+        spanKind: 'tool_call',
+        toolCallId,
+        toolName,
+        paths,
+        primaryPath: paths[0] ?? '',
+        text: safeJson(args),
+      }))
+    }
+
+    if (resultText !== '' || details !== undefined || Array.isArray(event.content)) {
+      spans.push(createTextSpan(base, {
+        spanIndex: args !== undefined ? 1 : 0,
+        spanKind: 'tool_result',
+        toolCallId,
+        toolName,
+        paths,
+        primaryPath: paths[0] ?? '',
+        text: resultText,
+      }))
+    }
+  }
+
+  return spans
+}
+
 export function summarizeRequestSpans(spans = []) {
   const toolNames = new Set()
   const files = new Set()
@@ -915,12 +1114,14 @@ async function readJsonlRecords(filePath, normalize) {
   }
 }
 
-export async function ensureRequestTelemetryFiles(paths) {
-  const hooksFile = String(paths?.hooksFile ?? '').trim()
-  const requestsFile = String(paths?.requestsFile ?? '').trim()
-  const spansFile = String(paths?.spansFile ?? '').trim()
+export async function ensureRequestTelemetryFiles(paths, options = {}) {
+  const targets = [
+    options?.includeHooks === true ? String(paths?.hooksFile ?? '').trim() : '',
+    options?.includeRequests !== false ? String(paths?.requestsFile ?? '').trim() : '',
+    options?.includeSpans !== false ? String(paths?.spansFile ?? '').trim() : '',
+  ]
 
-  for (const filePath of [hooksFile, requestsFile, spansFile]) {
+  for (const filePath of targets) {
     if (filePath === '') {
       continue
     }
@@ -952,16 +1153,28 @@ export async function appendRequestTelemetryHook(paths, event) {
     detail: asObject(event?.detail),
   }
 
-  await ensureRequestTelemetryFiles(paths)
+  await ensureRequestTelemetryFiles(paths, {
+    includeHooks: true,
+    includeRequests: false,
+    includeSpans: false,
+  })
   await fs.appendFile(hooksFile, `${JSON.stringify(normalizedEvent)}\n`, 'utf8')
   return normalizedEvent
 }
 
-export async function appendRequestTelemetryArtifacts(paths, { request, spans = [] } = {}) {
+export async function appendRequestTelemetryArtifacts(paths, { request, spans = [] } = {}, options = {}) {
   const normalizedRequest = normalizeRequestTelemetryRecord(request)
-  const normalizedSpans = (Array.isArray(spans) ? spans : []).map((span) => normalizeRequestSpanRecord(span))
+  const normalizedSpans = (Array.isArray(spans) ? spans : [])
+    .map((span) => compactRequestSpanRecord(span, {
+      includeText: options?.includeSpanText === true,
+      includePreview: options?.includeSpanPreview === true,
+    }))
 
-  await ensureRequestTelemetryFiles(paths)
+  await ensureRequestTelemetryFiles(paths, {
+    includeHooks: false,
+    includeRequests: String(paths?.requestsFile ?? '').trim() !== '',
+    includeSpans: String(paths?.spansFile ?? '').trim() !== '' && normalizedSpans.length > 0,
+  })
 
   if (String(paths?.requestsFile ?? '').trim() !== '') {
     await fs.appendFile(paths.requestsFile, `${JSON.stringify(normalizedRequest)}\n`, 'utf8')

package/src/pi-sdk-turn.mjs

@@ -1,5 +1,6 @@
 import path from 'node:path'
 import process from 'node:process'
+import { setMaxListeners } from 'node:events'
 import { pathToFileURL } from 'node:url'
 import {
   formatHeartbeatReason,
@@ -15,6 +16,7 @@ import {
 } from './pi-token-analysis.mjs'
 import {
   REQUEST_TELEMETRY_ENV_KEYS,
+  REQUEST_TELEMETRY_STORAGE_ENV_KEYS,
   ensureBundledRequestTelemetryExtension,
   readRequestTelemetryContextFromEnv,
 } from './pi-request-telemetry.mjs'
@@ -123,6 +125,10 @@ function addTokenUsage(total, value) {
 
 function applyRequestTelemetryEnv(request) {
   const previous = readRequestTelemetryContextFromEnv()
+  const previousStorage = {
+    storeHooks: String(process.env[REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeHooks] ?? '').trim(),
+    storeSpanText: String(process.env[REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeSpanText] ?? '').trim(),
+  }
   const nextValues = {
     [REQUEST_TELEMETRY_ENV_KEYS.runId]: String(process.env.PI_RUN_ID ?? '').trim(),
     [REQUEST_TELEMETRY_ENV_KEYS.iteration]: Number.isFinite(Number(request?.metadata?.iteration))
@@ -132,6 +138,8 @@ function applyRequestTelemetryEnv(request) {
     [REQUEST_TELEMETRY_ENV_KEYS.role]: String(request?.role ?? '').trim(),
     [REQUEST_TELEMETRY_ENV_KEYS.kind]: String(request?.kind ?? '').trim(),
     [REQUEST_TELEMETRY_ENV_KEYS.task]: String(request?.task ?? '').trim(),
+    [REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeHooks]: request?.requestTelemetryStoreHooks === true ? '1' : '0',
+    [REQUEST_TELEMETRY_STORAGE_ENV_KEYS.storeSpanText]: request?.requestTelemetryStoreSpanText === true ? '1' : '0',
   }
 
   for (const [key, value] of Object.entries(nextValues)) {
@@ -151,9 +159,28 @@ function applyRequestTelemetryEnv(request) {
       }
       process.env[key] = previousValue
     }
+
+    for (const [field, key] of Object.entries(REQUEST_TELEMETRY_STORAGE_ENV_KEYS)) {
+      const previousValue = String(previousStorage?.[field] ?? '').trim()
+      if (previousValue === '') {
+        delete process.env[key]
+        continue
+      }
+      process.env[key] = previousValue
+    }
   }
 }
 
+function relaxAbortSignalListenerLimit(signal) {
+  if (!signal || typeof signal !== 'object') {
+    return
+  }
+
+  try {
+    setMaxListeners(0, signal)
+  } catch {}
+}
+
 function deriveTokenAttributionKind({ activeToolName, pendingToolNames, pendingFiles, lastAssistantActivity }) {
   if (String(activeToolName ?? '').trim() !== '') {
     return 'tool_running'
@@ -484,6 +511,7 @@ export async function runSdkTurnWithPi(pi, request) {
   let tokenUsageEvents = 0
   let tokenUsage = createEmptyTokenUsage()
   let lastAssistantActivity = ''
+  let abortSignalLimitRelaxed = false
   const pendingToolNames = new Set()
   const pendingFiles = new Set()
   const events = []
@@ -569,6 +597,10 @@ export async function runSdkTurnWithPi(pi, request) {
       lastEventAt = Date.now()
 
       if (event.type === 'agent_start') {
+        if (!abortSignalLimitRelaxed) {
+          relaxAbortSignalListenerLimit(session?.agent?.signal)
+          abortSignalLimitRelaxed = true
+        }
         agentStarted = true
         emitLiveFeed(request, {
           type: 'agent_start',

package/templates/pi.config.example.json

@@ -9,6 +9,8 @@
   "largeSpecWarningLines": 300,
   "piModel": "local/text-model",
   "piRequestTelemetryEnabled": true,
+  "piRequestTelemetryStoreHooks": false,
+  "piRequestTelemetryStoreSpanText": false,
   "models": {
     "local/text-model": {
       "baseUrl": "http://localhost:8000/v1",