pi-langfuse 1.4.1 → 1.4.2

package/index.ts

@@ -10,7 +10,7 @@
 import { basename } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-import { state, resetRunState } from "./src/state.js";
+import { state, resetRunState, runWithSession, setCurrentSession } from "./src/state.js";
 import { ensureConfig, promptForConfig, loadConfig } from "./src/config.js";
 import { shutdownRuntime } from "./src/langfuse.js";
 import { getMessageFromEvent, extractAssistantOutput } from "./src/utils.js";
@@ -51,72 +51,79 @@ export default async function (pi: ExtensionAPI) {
     },
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  const getSessionId = (ctx?: any) => {
+    try {
+      const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+      return sessionFile ? basename(sessionFile, ".jsonl") : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const withSession = <T>(ctx: any, fn: () => T): T => runWithSession(getSessionId(ctx) ?? state.currentSessionId, fn);
+
+  pi.on("session_start", async (_event, ctx) => withSession(ctx, async () => {
     state.setupAttemptedThisSession = false;
     await ensureConfig(ctx);
-    const sessionFile = ctx.sessionManager.getSessionFile();
-    if (sessionFile) {
-      state.currentSessionId = basename(sessionFile, ".jsonl");
-    }
     resetRunState();
-  });
+  }));
 
-  pi.on("model_select", async (event) => {
+  pi.on("model_select", async (event, ctx) => withSession(ctx, async () => {
     state.currentModel = event.model?.id || "";
     state.currentProvider = event.model?.provider || "";
-  });
+  }));
 
-  pi.on("before_agent_start", async (event, ctx) => {
+  pi.on("before_agent_start", async (event, ctx) => withSession(ctx, async () => {
     await startAgentRun(event, ctx);
-  });
+  }));
 
-  pi.on("agent_start", async (event, ctx) => {
+  pi.on("agent_start", async (event, ctx) => withSession(ctx, async () => {
     if (!state.agentState?.root) {
       await startAgentRun(event, ctx);
     }
-  });
+  }));
 
-  pi.on("turn_start", async (event) => {
+  pi.on("turn_start", async (event, ctx) => withSession(ctx, async () => {
     await startTurnObservation(event);
-  });
+  }));
 
-  pi.on("before_provider_request", async (event) => {
+  pi.on("before_provider_request", async (event, ctx) => withSession(ctx, async () => {
     await startGeneration(event);
-  });
+  }));
 
-  pi.on("after_provider_response", async (event) => {
+  pi.on("after_provider_response", async (event, ctx) => withSession(ctx, async () => {
     updateGenerationMetadata(event);
-  });
+  }));
 
-  pi.on("message_update", async (event) => {
+  pi.on("message_update", async (event, ctx) => withSession(ctx, async () => {
     recordTTFT(event);
     const message = getMessageFromEvent(event);
     if (message?.role === "assistant" && state.agentState) {
       state.agentState.latestAssistantOutput = extractAssistantOutput(message);
     }
-  });
+  }));
 
-  pi.on("message_end", async (event) => {
+  pi.on("message_end", async (event, ctx) => withSession(ctx, async () => {
     await finishGenerationFromMessage(event);
-  });
+  }));
 
-  pi.on("tool_execution_start", async (event) => {
+  pi.on("tool_execution_start", async (event, ctx) => withSession(ctx, async () => {
     await startToolObservation(event);
-  });
+  }));
 
-  pi.on("tool_call", async (event) => {
+  pi.on("tool_call", async (event, ctx) => withSession(ctx, async () => {
     await startToolObservation(event);
-  });
+  }));
 
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => withSession(ctx, async () => {
     await finishToolObservation(event);
-  });
+  }));
 
-  pi.on("tool_execution_end", async (event) => {
+  pi.on("tool_execution_end", async (event, ctx) => withSession(ctx, async () => {
     await finishToolObservation(event);
-  });
+  }));
 
-  pi.on("turn_end", async (event) => {
+  pi.on("turn_end", async (event, ctx) => withSession(ctx, async () => {
     state.turnCount++;
     const message = getMessageFromEvent(event);
     if (message?.role === "assistant") {
@@ -124,16 +131,16 @@ export default async function (pi: ExtensionAPI) {
       await finishGenerationFromMessage(event);
     }
     finishTurnObservation(event);
-  });
+  }));
 
-  pi.on("agent_end", async (event) => {
+  pi.on("agent_end", async (event, ctx) => withSession(ctx, async () => {
     await finishAgentRun(event);
     setTimeout(() => {
       shutdownRuntime().catch((error) => {
         console.warn("📊 Langfuse: Deferred shutdown failed", error);
       });
     }, 0);
-  });
+  }));
 
   const handleSessionInterruption = (reason: string) => {
     if (state.agentState?.root) {
@@ -143,15 +150,21 @@ export default async function (pi: ExtensionAPI) {
     resetRunState();
   };
 
-  pi.on("session_before_switch", async () => {
-    handleSessionInterruption("Session switched");
+  pi.on("session_before_switch", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (sessionId) {
+      setCurrentSession(sessionId);
+    }
   });
 
-  pi.on("session_before_fork", async () => {
-    handleSessionInterruption("Session forked");
+  pi.on("session_before_fork", async (_event, ctx) => {
+    const sessionId = getSessionId(ctx);
+    if (sessionId) {
+      setCurrentSession(sessionId);
+    }
   });
 
-  pi.on("session_compact", async (event) => {
+  pi.on("session_compact", async (event, ctx) => withSession(ctx, async () => {
     if (state.agentState?.root) {
       const parent = state.agentState.activeTurn ?? state.agentState.root;
       try {
@@ -169,10 +182,10 @@ export default async function (pi: ExtensionAPI) {
         // ignore
       }
     }
-  });
+  }));
 
-  pi.on("session_shutdown", async () => {
+  pi.on("session_shutdown", async (_event, ctx) => withSession(ctx, async () => {
     handleSessionInterruption("Session shutdown before agent completed");
     await shutdownRuntime();
-  });
+  }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-langfuse",
-	"version": "1.4.1",
+	"version": "1.4.2",
 	"description": "Langfuse extension for Pi coding agent",
 	"repository": {
 		"type": "git",
@@ -12,6 +12,16 @@
 	"homepage": "https://github.com/gooyoung/pi-langfuse#readme",
 	"type": "module",
 	"main": "index.ts",
+	"files": [
+		"index.ts",
+		"src/",
+		"types/",
+		"README.md",
+		"README_CN.md",
+		"image.png",
+		"skills-lock.json",
+		"tsconfig.json"
+	],
 	"scripts": {
 		"typecheck": "tsc --noEmit"
 	},

package/src/state.ts

@@ -1,38 +1,141 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import type { Config, AgentState } from "./types.js";
 
+export interface SessionRunState {
+  currentModel: string;
+  currentProvider: string;
+  agentState: AgentState | null;
+  toolCallCount: number;
+  errorCount: number;
+  turnCount: number;
+}
+
+const DEFAULT_SESSION_ID = "__pi_langfuse_default_session__";
+
+let activeSessionId = DEFAULT_SESSION_ID;
+const sessionScope = new AsyncLocalStorage<string>();
+
+function createSessionRunState(): SessionRunState {
+  return {
+    currentModel: "",
+    currentProvider: "",
+    agentState: null,
+    toolCallCount: 0,
+    errorCount: 0,
+    turnCount: 0,
+  };
+}
+
+function normalizeSessionId(sessionId?: string) {
+  return sessionId || DEFAULT_SESSION_ID;
+}
+
+function getActiveSessionId() {
+  return sessionScope.getStore() ?? activeSessionId;
+}
+
+export function getSessionRunState(sessionId = getActiveSessionId()): SessionRunState {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  let sessionState = state.sessionStates.get(normalizedSessionId);
+  if (!sessionState) {
+    sessionState = createSessionRunState();
+    state.sessionStates.set(normalizedSessionId, sessionState);
+  }
+  return sessionState;
+}
+
+export function setCurrentSession(sessionId?: string) {
+  activeSessionId = normalizeSessionId(sessionId);
+  getSessionRunState(activeSessionId);
+}
+
+export function runWithSession<T>(sessionId: string | undefined, fn: () => T): T {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  setCurrentSession(normalizedSessionId);
+  return sessionScope.run(normalizedSessionId, fn);
+}
+
 export const state = {
   config: null as Config | null,
   setupAttemptedThisSession: false,
-  
-  currentSessionId: "",
-  currentModel: "",
-  currentProvider: "",
-  agentState: null as AgentState | null,
-  
-  // Evaluation tracking state
-  toolCallCount: 0,
-  errorCount: 0,
-  turnCount: 0,
+  sessionStates: new Map<string, SessionRunState>(),
+
+  get currentSessionId() {
+    const sessionId = getActiveSessionId();
+    return sessionId === DEFAULT_SESSION_ID ? "" : sessionId;
+  },
+  set currentSessionId(sessionId: string) {
+    setCurrentSession(sessionId);
+  },
+
+  get currentModel() {
+    return getSessionRunState().currentModel;
+  },
+  set currentModel(model: string) {
+    getSessionRunState().currentModel = model;
+  },
+
+  get currentProvider() {
+    return getSessionRunState().currentProvider;
+  },
+  set currentProvider(provider: string) {
+    getSessionRunState().currentProvider = provider;
+  },
+
+  get agentState() {
+    return getSessionRunState().agentState;
+  },
+  set agentState(agentState: AgentState | null) {
+    getSessionRunState().agentState = agentState;
+  },
+
+  get toolCallCount() {
+    return getSessionRunState().toolCallCount;
+  },
+  set toolCallCount(toolCallCount: number) {
+    getSessionRunState().toolCallCount = toolCallCount;
+  },
+
+  get errorCount() {
+    return getSessionRunState().errorCount;
+  },
+  set errorCount(errorCount: number) {
+    getSessionRunState().errorCount = errorCount;
+  },
+
+  get turnCount() {
+    return getSessionRunState().turnCount;
+  },
+  set turnCount(turnCount: number) {
+    getSessionRunState().turnCount = turnCount;
+  },
 };
 
-export function resetRunState() {
-  state.agentState = null;
-  state.toolCallCount = 0;
-  state.errorCount = 0;
-  state.turnCount = 0;
-  state.currentModel = "";
-  state.currentProvider = "";
+export function resetRunState(sessionId = getActiveSessionId()) {
+  state.sessionStates.set(normalizeSessionId(sessionId), createSessionRunState());
 }
 
-export function computeEvaluationScores() {
-  const toolSuccessRate = state.toolCallCount > 0 ? (state.toolCallCount - state.errorCount) / state.toolCallCount : 1;
-  const sessionHadErrors = state.errorCount > 0;
+export function clearAllSessionStates() {
+  state.sessionStates.clear();
+  activeSessionId = DEFAULT_SESSION_ID;
+  getSessionRunState();
+}
+
+export function computeEvaluationScores(sessionId = getActiveSessionId()) {
+  const sessionState = getSessionRunState(sessionId);
+  const toolSuccessRate =
+    sessionState.toolCallCount > 0
+      ? (sessionState.toolCallCount - sessionState.errorCount) / sessionState.toolCallCount
+      : 1;
+  const sessionHadErrors = sessionState.errorCount > 0;
 
   return {
-    tool_call_count: state.toolCallCount,
-    turn_count: state.turnCount,
-    total_tool_errors: state.errorCount,
+    tool_call_count: sessionState.toolCallCount,
+    turn_count: sessionState.turnCount,
+    total_tool_errors: sessionState.errorCount,
     tool_success_rate: toolSuccessRate,
     session_had_errors: sessionHadErrors ? 1 : 0,
   };
 }
+
+getSessionRunState();

package/.agents/skills/langfuse/SKILL.md

@@ -1,140 +0,0 @@
----
-name: langfuse
-description: Interact with Langfuse and access its documentation. Use when needing to (1) query or modify Langfuse data programmatically via the CLI — traces, prompts, datasets, scores, sessions, and any other API resource, (2) look up Langfuse documentation, concepts, integration guides, or SDK usage, or (3) understand how any Langfuse feature works. This skill covers CLI-based API access (via npx) and multiple documentation retrieval methods.
-allowed-tools:
-  - WebFetch(domain:langfuse.com)
-  - Bash(curl *langfuse.com/*)
-  - Bash(npx langfuse-cli api __schema *)
-  - Bash(npx langfuse-cli api * --help *)
-  - Bash(npx langfuse-cli api * list *)
-  - Bash(npx langfuse-cli api * get *)
-  - Bash(bunx langfuse-cli api __schema *)
-  - Bash(bunx langfuse-cli api * --help *)
-  - Bash(bunx langfuse-cli api * list *)
-  - Bash(bunx langfuse-cli api * get *)
----
-
-# Langfuse
-
-This skill helps you use Langfuse effectively across all common workflows: instrumenting applications, migrating prompts, debugging traces, and accessing data programmatically.
-
-## Core Principles
-
-Follow these principles for ALL Langfuse work:
-
-1. **Documentation First**: NEVER implement based on memory. Always fetch current docs before writing code (Langfuse updates frequently) See the section below on how to access documentation.
-2. **CLI for Data Access**: Use `langfuse-cli` when querying/modifying Langfuse data. See the section below on how to use the CLI. 
-3. **Best Practices by Use Case**: Check the relevant reference file below for use-case-specific guidelines before implementing
-4. **Use latest Langfuse versions**: Unless the user specified otherwise or there's a good reason, always use the latest version of Langfuse SDKs/APIs.
-
-
-## Use case specific references
-
-- instrumenting an existing function/application: references/instrumentation.md
-- migrating prompts from a codebase into Langfuse: references/prompt-migration.md
-- capturing user feedback (thumbs, ratings, implicit signals) as scores on traces: references/user-feedback.md
-- further tips on using the Langfuse CLI: references/cli.md
-- upgrading or migrating Langfuse SDKs to the latest version: references/sdk-upgrade.md
-- systematic error analysis — reading traces, building failure taxonomy, deciding what to fix: references/error-analysis.md
-- submitting feedback about this skill: references/skill-feedback.md
-
-## 1. Langfuse API via CLI
-
-Use the `langfuse-cli` to interact with the full Langfuse REST API from the command line. Run via npx (no install required):
-
-Start by discovering the schema and available arguments:
-
-```bash
-# Discover all available resources
-npx langfuse-cli api __schema
-
-# List actions for a resource
-npx langfuse-cli api <resource> --help
-
-# Show args/options for a specific action
-npx langfuse-cli api <resource> <action> --help
-```
-
-### Credentials
-
-Set environment variables before making calls:
-
-```bash
-export LANGFUSE_PUBLIC_KEY=pk-lf-...
-export LANGFUSE_SECRET_KEY=sk-lf-...
-export LANGFUSE_HOST=https://cloud.langfuse.com # example for EU cloud. For US cloud it's us.cloud.langfuse.com, and can also be a self-hosted URL. The server must always be specified in order to access Langfuse.
-```
-
-If not set, ask the user to set them in their shell or a `.env` file (do not ask them to paste keys into chat for security reasons). Keys are found in Langfuse UI → Settings → API Keys.
-
-### Detailed CLI Reference
-
-For common workflows, tips, and full usage patterns, see [references/cli.md](references/cli.md).
-
-## 2. Langfuse Documentation
-
-Three methods to access Langfuse docs, in order of preference. **Always prefer your application's native web fetch and search tools** (e.g., `WebFetch`, `WebSearch`, `mcp_fetch`, etc.) over `curl` when available. The URLs and patterns below work with any fetching method — the `curl` examples are just illustrative.
-
-### 2a. Documentation Index (llms.txt)
-
-Fetch the full index of all documentation pages:
-
-```bash
-curl -s https://langfuse.com/llms.txt
-```
-
-Returns a structured list of every doc page with titles and URLs. Use this to discover the right page for a topic, then fetch that page directly.
-
-Alternatively, you can start on `https://langfuse.com/docs` and explore the site to find the page you need.
-
-### 2b. Fetch Individual Pages as Markdown
-
-Any page listed in llms.txt can be fetched as markdown by appending `.md` to its path or by using `Accept: text/markdown` in the request headers. Use this when you know which page contains the information needed. Returns clean markdown with code examples and configuration details.
-
-```bash
-curl -s "https://langfuse.com/docs/observability/overview.md"
-curl -s "https://langfuse.com/docs/observability/overview" -H "Accept: text/markdown"
-```
-
-### 2c. Search Documentation
-
-When you need to find information across all docs and github issues/discussions without knowing the specific page:
-
-```bash
-curl -s "https://langfuse.com/api/search-docs?query=<url-encoded-query>"
-```
-
-Example:
-
-```bash
-curl -s "https://langfuse.com/api/search-docs?query=How+do+I+trace+LangGraph+agents"
-```
-
-Returns a JSON response with:
-
-- `query`: the original query
-- `answer`: a JSON string containing an array of matching documents, each with:
-  - `url`: link to the doc page
-  - `title`: page title
-  - `source.content`: array of relevant text excerpts from the page
-
-Search is a great fallback if you cannot find the relevant pages or need more context. Especially useful when debugging issues as all GitHub Issues and Discussions are also indexed. Responses can be large — extract only the relevant portions.
-
-### Documentation Workflow
-
-1. Start with **llms.txt** to orient — scan for relevant page titles
-2. **Fetch specific pages** when you identify the right one
-3. Fall back to **search** when the topic is unclear and you want more context
-
-## Skill Feedback
-
-When the user expresses that something about this skill is not working as expected, gives incorrect guidance, is missing information, or could be improved — offer to submit feedback to the Langfuse skill maintainers. This includes when:
-
-- The skill gave wrong or outdated instructions
-- A workflow didn't produce the expected result
-- The user wishes the skill covered something it doesn't
-- The user explicitly says something like "this should work differently" or "this is wrong"
-
-**Do NOT trigger this** for issues with Langfuse itself (the product) — only for issues with this skill's instructions and behavior.
-
-When triggered, follow the process in [references/skill-feedback.md](references/skill-feedback.md).

package/.agents/skills/langfuse/references/cli.md

@@ -1,51 +0,0 @@
-# Langfuse CLI Reference
-
-Documentation: https://langfuse.com/docs/api-and-data-platform/features/cli
-
-## Install
-
-```bash
-# Run directly (recommended)
-npx langfuse-cli api <resource> <action>
-bunx langfuse-cli api <resource> <action>
-
-# Or install globally
-npm i -g langfuse-cli
-langfuse api <resource> <action>
-```
-
-## Discovery
-
-```bash
-# List all resources and auth info
-langfuse api __schema
-
-# List actions for a resource
-langfuse api <resource> --help
-
-# Show args/options for a specific action
-langfuse api <resource> <action> --help
-
-# Preview the curl command without executing
-langfuse api <resource> <action> --curl
-```
-
-## Credentials
-
-Set environment variables:
-
-```bash
-export LANGFUSE_PUBLIC_KEY=pk-lf-...
-export LANGFUSE_SECRET_KEY=sk-lf-...
-export LANGFUSE_HOST=https://cloud.langfuse.com  
-```
-
-## Tips
-
-- Use `--json` for machine-readable JSON output
-- Use `--curl` to preview the HTTP request without executing
-- Pagination: use `--limit` and `--page` on list endpoints
-- All list commands support filtering — check `<resource> <action> --help` for available options
-- Prefer `observations-v2s` over `observations` — the v2 endpoint returns richer data
-- Prefer `metrics-v2s` over `metrics` — the v2 endpoint returns richer data
-- Prefer `score-v2s` over `scores` — the v1 `scores` resource only supports create/delete; use `score-v2s` for list and get operations

package/.agents/skills/langfuse/references/error-analysis.md

@@ -1,100 +0,0 @@
----
-name: langfuse-error-analysis
-description: Deep-dive error analysis of an LLM pipeline or AI application using Langfuse traces.
-  Use this skill whenever the user wants to understand why their AI system is producing
-  bad outputs, where their pipeline is failing, how to categorise or label failures,
-  what to prioritise fixing, or how to set up evaluators. Also trigger for "review my
-  traces", "my outputs look wrong", "help me debug my LLM app", "I want to analyse
-  errors", "build a failure taxonomy", "what's going wrong with my pipeline", or any
-  request to systematically inspect, annotate, or score Langfuse traces. If the user
-  is trying to understand or improve the quality of an AI system's outputs, use this skill.
----
-
-# Error Analysis
-
-## Primary Guide
-
-**1. Fetch the guide in this blogpost**
-
-https://langfuse.com/guides/cookbook/error-analysis-llm-applications.md
-
-If fetch is not available query for langfuse.com error analysis guide
-
-Read it in full. It defines the authoritative 5-step process (sample selection → open coding → clustering → labelling → deciding what to fix).
-
-**2. Guide the user through this step by step**
-
-You as a coding agent and the user go through this together to perform a full error analysis with their data in langfuse. Do everything you can achieve via CLI (look up traces, create annotation queues, ...) for the user. Provide them with direct links to UI wherever their action is required. Be proactive and narrate what is going on for the user. 
-
-## Rules CRITICAL
-Use Langfuse CLI wherever possible
-Use charts where possible to display data
-
----
-
-## Langfuse Implementation Notes
-
-The guide describes the process. These notes cover the Langfuse-specific API and CLI mechanics required to execute it.
-
-### Credentials
-
-```bash
-echo $LANGFUSE_PUBLIC_KEY   # pk-lf-...
-echo $LANGFUSE_SECRET_KEY   # sk-lf-...
-echo $LANGFUSE_HOST         # https://cloud.langfuse.com (EU), https://us.cloud.langfuse.com (US), https://jp.cloud.langfuse.com (JP) or self-hosted
-```
-
-If not set, check `.env` in the project root: `export $(grep -v '^#' .env | xargs)`. If `LANGFUSE_BASE_URL` is used instead of `LANGFUSE_HOST`, run `export LANGFUSE_HOST="$LANGFUSE_BASE_URL"`.
-
-```bash
-AUTH=$(echo -n "${LANGFUSE_PUBLIC_KEY}:${LANGFUSE_SECRET_KEY}" | base64)
-
-# Verify before proceeding
-STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
-  -H "Authorization: Basic $AUTH" \
-  "${LANGFUSE_HOST}/api/public/projects")
-echo "Auth check: $STATUS"
-```
-
-If status is not `200`, stop and ask the user to check their credentials and host before continuing.
-
-### Annotation target: OBSERVATION not TRACE
-
-> **CRITICAL:** In OpenTelemetry-instrumented apps, trace-level `input`/`output` can be null — content lives in a GENERATION observation. Always add `objectType: OBSERVATION` pointing to the GENERATION observation ID to annotation queues. Adding `objectType: TRACE` shows nothing in the UI.
-
-### Annotation queues
-
-> **CRITICAL:** Queues cannot be updated or deleted after creation. Create score configs first, then the queue with all config IDs. To add new configs later, create a new queue.
-
-
-**Always give the user a direct link immediately after creating a queue:**
-
-| Host | URL pattern |
-|------|-------------|
-| EU cloud | `https://cloud.langfuse.com/project/<projectId>/annotation-queues/<queueId>` |
-| US cloud | `https://us.cloud.langfuse.com/project/<projectId>/annotation-queues/<queueId>` |
-| Self-hosted | `<LANGFUSE_HOST>/project/<projectId>/annotation-queues/<queueId>` |
-
-Instruction to give: *"Please open code the first ~50 examples. For each trace, write what you observe in the `open_coding` field (describe behaviour, don't diagnose root causes), then set `pass_fail_assessment` to Pass or Fail."*
-
-
-### Prompt fixes
-
-When a category warrants a prompt fix, always offer the user two options:
-1. Create it as a versioned prompt in Langfuse (tracked, usable via the prompt API)
-2. Draft the specific text change for them to review and apply
-
-### Setup evaluators
-
-When a category warrants an evaluator setup, propose the type of evaluator and offer to set it up for user via CLI
-
-
-### Common gotchas
-
-| Mistake | Fix |
-|---------|-----|
-| `objectType: TRACE` in queue | Use `objectType: OBSERVATION` with GENERATION obs ID |
-| Creating score config without checking existing | `GET /api/public/score-configs` first; can't delete |
-| Queue created before score configs | Create configs → collect IDs → create queue |
-| `--limit` > 100 on traces list | API hard cap; paginate with `--page` |
-| No rate limiting on queue item creation | `sleep 0.4` between calls to avoid 429 |