@pi-unipi/unipi 2.10.2 → 2.12.0

package/packages/footer/src/tui/settings-tui.ts

@@ -50,8 +50,14 @@ const overlay = new OverlayTheme();
 
 // ─── Show the footer settings overlay ──────────────────────────────────
 
-export function showFooterSettings(ctx: ExtensionCommandContext, groups: FooterGroup[], onSettingsChanged?: () => void): void {
-  ctx.ui.custom<void>(
+/**
+ * Returns the overlay's promise so callers can run post-close actions
+ * (e.g. the glance editor swap) AFTER focus has returned to the editor —
+ * setEditorComponent() steals keyboard focus and would strand this very
+ * overlay unclosable if invoked from onSettingsChanged while it is open.
+ */
+export function showFooterSettings(ctx: ExtensionCommandContext, groups: FooterGroup[], onSettingsChanged?: () => void): Promise<void> {
+  return ctx.ui.custom<void>(
     (tui, _theme, _keybindings, done) => {
       const overlay = new FooterSettingsOverlay(groups, onSettingsChanged);
       overlay.onClose = () => done();
@@ -214,6 +220,13 @@ class FooterSettingsOverlay {
 
   private buildAppearanceList(): void {
     const items: SettingItem[] = [
+      {
+        id: "glanceMode",
+        label: "Glance Footer",
+        description: "Experimental: framed input box + session strip (replaces classic row)",
+        currentValue: this.settings.glanceMode !== false ? "on" : "off",
+        values: ["on", "off"],
+      },
       {
         id: "preset",
         label: "Preset",
@@ -352,6 +365,9 @@ class FooterSettingsOverlay {
 
   private onAppearanceChange(id: string, newValue: string): void {
     switch (id) {
+      case "glanceMode":
+        this.settings.glanceMode = newValue === "on";
+        break;
       case "preset":
         this.settings.preset = newValue;
         break;

package/packages/footer/src/types.ts

@@ -15,7 +15,9 @@ export type SegmentZone = "left" | "center" | "right";
 /** Semantic color names mapped to segment groups */
 export type SemanticColor =
   // ── Model & Identity (Left zone) ──
+  | "brand"
   | "model"
+  | "directory"
   | "path"
   | "git"
   | "gitClean"
@@ -181,6 +183,8 @@ export interface FooterSettings {
   enabled: boolean;
   /** Active preset name */
   preset: string;
+  /** Glance-style experiment: frame input box + session strip, suppress classic row */
+  glanceMode?: boolean;
   /** Separator style */
   separator: SeparatorStyle;
   /** Icon style: nerd (Nerd Font glyphs), emoji (Unicode emoji), text (plain labels) */

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Image generation and image recognition tools for the Pi coding agent",
   "type": "module",
   "main": "src/index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/kanboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Visualization layer for unipi workflow — HTTP server with htmx/Alpine.js UI, modular parsers, TUI overlay, and kanban board",
   "type": "module",
   "main": "index.ts",
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "main": "src/index.ts",
@@ -30,7 +30,7 @@
     "test": "npx tsx --test tests/**/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -39,8 +39,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "2.10.2",
-    "@pi-unipi/info-screen": "2.10.2",
+    "@pi-unipi/core": "2.12.0",
+    "@pi-unipi/info-screen": "2.12.0",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Lifecycle layer for project-level goals — MILESTONES.md tracking, session hooks, auto-sync",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2"
+    "@pi-unipi/core": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2",
+    "@pi-unipi/core": "2.12.0",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/packages/ralph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/ralph",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Long-running iterative development loops for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -31,8 +31,8 @@
     "test": "npx tsx --test reminder.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2",
-    "@pi-unipi/info-screen": "2.10.2"
+    "@pi-unipi/core": "2.12.0",
+    "@pi-unipi/info-screen": "2.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",

package/packages/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/subagents",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Subagents for UniPi — parallel execution, file locking, workflow integration",
   "type": "module",
   "main": "src/index.ts",
@@ -9,7 +9,7 @@
     "test": "npx tsx --test src/__tests__/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.10.2",
+    "@pi-unipi/core": "2.12.0",
     "@earendil-works/pi-agent-core": "^0.84.0",
     "acorn": "8.18.0"
   },

package/packages/trajectory/README.md

@@ -15,15 +15,23 @@ Typing `/unipi:trajectory` followed by a space auto-completes the available
 actions (`stop`, `off`, `toggle`), so the options are discoverable without
 reading the docs. Running it with no argument opens or reuses the server.
 
-The command starts or reuses an in-process server on `127.0.0.1:8176-8186` and opens it in the default browser. The page follows the active session every 500 ms. The server is owned by the current Pi process and is stopped on any Pi session shutdown/reload/resume/new/fork event.
+The command starts or reuses an in-process server on `127.0.0.1:8176-8186` and opens it in the default browser. The page follows the active session every 1.5 seconds, skips unchanged snapshots, and reuses an in-memory telemetry tail instead of rereading the JSONL file. The server is owned by the current Pi process and is stopped on any Pi session shutdown/reload/resume/new/fork event.
 
 ## What it shows
 
+- The exact provider-context path: user/assistant/tool messages, effective system prompt, serialized provider request, and prefix-integrity verdict
+- UniPi package operations only when they mutate context or cross an explicit context epoch boundary; UI-only hooks, registrations, notifications, command bookkeeping, and unrelated EventBus traffic are intentionally excluded from the ledger
+- A per-request prefix-integrity verdict: first request, identical retry, append-only extension, explicit lifecycle boundary, or violation
+- Exact prefix-break evidence: first changed message index/path plus independent system-prompt, tool-schema/order, route, thinking-level, and provider-envelope drift
+- Contributing UniPi package operations between the previous request and a violation
+- One-click **UniPi** and **Violations** filters, plus Trace, Integrity, and Attribution detail tabs
+- The fully assembled effective system prompt for each agent run
 - Turn-aware User, Assistant, Tool, Compaction, and Branch ledger
-- Assistant reasoning and final output
-- Tool payloads, results, errors, and measured call duration
+- Effective context messages before each model request and the final provider payload after serialization/extension rewrites
+- Assistant reasoning and final output, including streamed assistant events
+- Tool payloads, final results, errors, and measured call duration
 - Provider, model, stop reason, token usage, cache reads/writes, and cost
-- Provider, model, thinking level, request payload/options, tool schemas, response status/headers
+- Provider, model, thinking level, serialized request payload, and tool schemas
 - Exact TTFT, decoding/total request timing, and tool execution timing
 - Input/Model/Tools overview timeline with drag-to-focus
 - Search, turn folding, call folding, and a local record inspector
@@ -34,7 +42,15 @@ The server binds only to `127.0.0.1`. It reads `SessionManager.getBranch()` and
 
 Detailed telemetry is appended to `~/.unipi/trajectory/<session-id>.jsonl` with a private directory/file mode. Authorization, API-key, token, cookie, secret, password, and credential fields and credential-shaped values are recursively redacted before persistence.
 
-Detailed request fields appear when captured by the trajectory telemetry sidecar.
+Context-relevant prompt, request, package mutation, and prefix-integrity fields appear when captured by the trajectory telemetry sidecar. Stream deltas, response headers, inert hooks, and other activity that cannot affect model context are not persisted. Secret-shaped headers and values are redacted before persistence, and pathological events/read volume are bounded so debug capture cannot exhaust the Pi process.
+
+## Prefix integrity
+
+Inside one cache epoch, the previous serialized message sequence must be an exact prefix of the next request. An identical retry is also safe. Any earlier edit, removal, reorder, or middle insertion is a violation. System instructions, tool definitions/order, provider route, thinking level, and request envelope are checked independently because changes there also invalidate provider prefix caches.
+
+Compaction, tree navigation, model changes, and thinking-level changes create explicit epoch boundaries. The first request after a boundary is labeled as such; append-only enforcement resumes on the following request.
+
+Package attribution is intentionally limited to UniPi modules loaded through the all-in-one `@pi-unipi/unipi` umbrella. Standalone trajectory still captures Pi's observable hooks and requests, but cannot attribute calls made by independently loaded packages.
 
 ## Lifecycle
 
@@ -42,6 +58,6 @@ Each Pi process owns its own trajectory server. A second Pi process running `/un
 
 ## Limitations
 
-- Live transport uses 500 ms polling rather than a push stream.
-- Very large branches are rendered in one table; browser virtualization can be added if measured sessions require it.
+- Live transport uses conditional 1.5-second polling rather than a push stream.
+- Very large active branches are rendered in one table; unchanged snapshots are not rebuilt or rerendered.
 - Tool duration uses exact executor telemetry when captured and session timestamps otherwise.

package/packages/trajectory/index.ts

@@ -2,19 +2,33 @@ import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-wor
 import { registerTelemetryCapture } from "./src/capture.js";
 import { projectTrajectory } from "./src/project.js";
 import { openBrowser, TrajectoryServer } from "./src/server.js";
+import { createUnipiTracer, type UnipiTraceRecorder } from "./src/tracer.js";
+
+export { createUnipiTracer, type UnipiTraceRecorder, type UnipiTracer } from "./src/tracer.js";
 
 let server: TrajectoryServer | null = null;
 let currentContext: ExtensionContext | null = null;
+let cachedLeafId: string | null | undefined;
+let cachedTelemetryRevision = -1;
+let cachedSnapshot: ReturnType<typeof projectTrajectory> | null = null;
 
 function stopServer(): boolean {
   if (!server?.url) return false;
   server.stop();
   server = null;
+  cachedLeafId = undefined;
+  cachedTelemetryRevision = -1;
+  cachedSnapshot = null;
   return true;
 }
 
-export default function trajectory(pi: ExtensionAPI): void {
-  const readTelemetry = registerTelemetryCapture(pi);
+export interface TrajectoryOptions {
+  traceRecorder?: UnipiTraceRecorder;
+}
+
+export default function trajectory(pi: ExtensionAPI, options: TrajectoryOptions = {}): void {
+  const recorder = options.traceRecorder ?? createUnipiTracer(pi).recorder;
+  const readTelemetry = registerTelemetryCapture(pi, undefined, recorder);
 
   pi.registerCommand("unipi:trajectory", {
     description: "Open or manage UniPi's live trajectory for the current session",
@@ -54,11 +68,17 @@ export default function trajectory(pi: ExtensionAPI): void {
         server = new TrajectoryServer({
           snapshot: () => {
             const active = currentContext ?? ctx;
-            return projectTrajectory(active.sessionManager.getBranch() as SessionEntry[], {
+            const leafId = active.sessionManager.getLeafId();
+            const telemetryRevision = recorder.revision();
+            if (cachedSnapshot && cachedLeafId === leafId && cachedTelemetryRevision === telemetryRevision) return cachedSnapshot;
+            cachedLeafId = leafId;
+            cachedTelemetryRevision = telemetryRevision;
+            cachedSnapshot = projectTrajectory(active.sessionManager.getBranch() as SessionEntry[], {
               sessionId: active.sessionManager.getSessionId(),
               name: active.sessionManager.getSessionName(),
               cwd: active.cwd,
             }, readTelemetry());
+            return cachedSnapshot;
           },
         });
       }

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/trajectory",
-  "version": "2.10.2",
+  "version": "2.12.0",
   "description": "Live UniPi trajectory inspector for Pi sessions",
   "type": "module",
   "main": "index.ts",

package/packages/trajectory/src/capture.ts

@@ -1,83 +1,203 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { PrefixIntegrityTracker } from "./prefix-integrity.js";
 import { TelemetrySidecar } from "./telemetry.js";
+import type { UnipiTraceRecorder } from "./tracer.js";
 
 interface RequestState {
   id: number;
-  startedAt: number;
+  turnIndex?: number;
+  startedAt?: number;
   firstTokenAt?: number;
 }
 
+interface PendingAgent {
+  runId: number;
+}
+
 /** Register read-only observability hooks. Returned reader follows the active session. */
-export function registerTelemetryCapture(pi: ExtensionAPI): () => ReturnType<TelemetrySidecar["read"]> {
+export function registerTelemetryCapture(
+  pi: ExtensionAPI,
+  sidecarRoot?: string,
+  traceRecorder?: UnipiTraceRecorder,
+): () => ReturnType<TelemetrySidecar["read"]> {
   let sidecar: TelemetrySidecar | null = null;
   let requestSeq = 0;
+  let runSeq = 0;
   let active: RequestState | null = null;
+  let lastRequestId: number | null = null;
+  let currentTurnIndex: number | undefined;
+  let pendingAgent: PendingAgent | null = null;
+  let previousTraceCursor = 0;
+  const prefixIntegrity = new PrefixIntegrityTracker();
   const toolStarts = new Map<string, number>();
 
   const bind = (ctx: ExtensionContext) => {
-    sidecar = new TelemetrySidecar(ctx.sessionManager.getSessionId());
+    const sessionId = ctx.sessionManager.getSessionId();
+    sidecar = new TelemetrySidecar(sessionId, sidecarRoot);
+    traceRecorder?.bind(sessionId);
+    const existing = sidecar.read();
+    requestSeq = Math.max(0, ...existing.flatMap(event => typeof event.requestId === "number" ? [event.requestId] : []));
+    runSeq = Math.max(0, ...existing.flatMap(event => typeof event.runId === "number" ? [event.runId] : []));
     active = null;
+    lastRequestId = null;
+    currentTurnIndex = undefined;
+    pendingAgent = null;
+    previousTraceCursor = traceRecorder?.cursor() ?? 0;
+    prefixIntegrity.reset();
     toolStarts.clear();
   };
-  const append = (type: Parameters<TelemetrySidecar["append"]>[0]["type"], data?: unknown, extra: Record<string, unknown> = {}) => {
-    sidecar?.append({ type, at: Date.now(), ...extra, ...(data === undefined ? {} : { data }) });
+  const append = (
+    type: Parameters<TelemetrySidecar["append"]>[0]["type"],
+    data?: unknown,
+    extra: Record<string, unknown> = {},
+    at = Date.now(),
+  ) => {
+    sidecar?.append({ type, at, ...extra, ...(data === undefined ? {} : { data }) });
   };
 
+  const ensureRequest = (startedAt?: number) => {
+    if (!active) {
+      active = { id: ++requestSeq, turnIndex: currentTurnIndex, startedAt };
+    } else if (startedAt !== undefined) {
+      active.startedAt = startedAt;
+    }
+    lastRequestId = active.id;
+    return active;
+  };
+  const requestExtra = (request = active) => ({
+    ...(request?.id !== undefined ? { requestId: request.id } : lastRequestId === null ? {} : { requestId: lastRequestId }),
+    ...(request?.turnIndex !== undefined ? { turnIndex: request.turnIndex } : currentTurnIndex === undefined ? {} : { turnIndex: currentTurnIndex }),
+  });
+
+
   pi.on("session_start", (_event, ctx) => { bind(ctx); });
+  pi.on("resources_discover", () => {});
+  pi.on("session_info_changed", () => {});
+  pi.on("session_before_switch", () => {});
+  pi.on("session_before_fork", () => {});
+  pi.on("session_before_compact", () => {});
+  pi.on("session_compact", (event) => { prefixIntegrity.markBoundary(`session_compact:${event.reason}`); });
+  pi.on("session_before_tree", () => {});
+  pi.on("session_tree", () => { prefixIntegrity.markBoundary("session_tree"); });
+  pi.on("session_shutdown", () => {});
+
+  pi.on("before_agent_start", (event) => {
+    pendingAgent = { runId: ++runSeq };
+  });
+  pi.on("agent_start", (event, ctx) => {
+    active = null;
+    lastRequestId = null;
+    currentTurnIndex = undefined;
+    const runId = pendingAgent?.runId ?? ++runSeq;
+    append("system-prompt", {
+      systemPrompt: ctx.getSystemPrompt(),
+      provider: ctx.model?.provider,
+      model: ctx.model?.id,
+      thinkingLevel: ctx.thinkingLevel,
+    }, { runId });
+  });
+  pi.on("agent_end", () => {});
+  pi.on("agent_settled", () => { pendingAgent = null; });
+  pi.on("turn_start", (event) => {
+    currentTurnIndex = event.turnIndex;
+    active = {
+      id: ++requestSeq,
+      turnIndex: event.turnIndex,
+    };
+    lastRequestId = active.id;
+  });
+  pi.on("turn_end", () => {});
+
+  pi.on("context", () => { ensureRequest(); });
+  pi.on("before_provider_headers", () => { ensureRequest(); });
   pi.on("before_provider_request", (event, ctx) => {
     const startedAt = Date.now();
-    active = { id: ++requestSeq, startedAt };
+    const request = ensureRequest(startedAt);
+    const integrity = prefixIntegrity.observe(event.payload, {
+      provider: ctx.model?.provider,
+      model: ctx.model?.id,
+      api: ctx.model?.api,
+      thinkingLevel: ctx.thinkingLevel,
+    });
+    const traceCursor = traceRecorder?.cursor() ?? 0;
+    const contributingTrace = traceRecorder?.since(previousTraceCursor) ?? [];
+    previousTraceCursor = traceCursor;
+    const attributed = integrity.verdict === "violation"
+      ? contributingTrace
+          .filter(item => item.type === "unipi-trace")
+          .map(item => item.data)
+          .filter((data): data is Record<string, unknown> => Boolean(data && typeof data === "object"))
+          .filter(data => data.phase === "exit" && (
+            data.surface === "hook" && data.mutation && (data.mutation as Record<string, unknown>).changed === true ||
+            data.surface === "api" && ["sendMessage", "sendUserMessage", "setActiveTools", "setModel", "setThinkingLevel", "registerProvider", "unregisterProvider"].includes(String(data.action)) ||
+            data.surface === "context-api" && ["compact", "navigateTree", "switchSession", "newSession", "fork", "reload"].includes(String(data.action))
+          ))
+          .slice(-20)
+      : [];
+    append("prefix-integrity", {
+      ...integrity,
+      attribution: attributed.length > 0 ? attributed : undefined,
+    }, requestExtra(request));
     append("request", {
       payload: event.payload,
       provider: ctx.model?.provider,
       model: ctx.model?.id,
       thinkingLevel: ctx.thinkingLevel,
-      tools: Array.isArray((event.payload as { tools?: unknown })?.tools)
-        ? (event.payload as { tools: unknown }).tools
-        : undefined,
-    }, { requestId: active.id });
-  });
-  pi.on("after_provider_response", (event) => {
-    append("response", { status: event.status, headers: event.headers }, active ? { requestId: active.id } : {});
+    }, requestExtra(request));
   });
+  pi.on("after_provider_response", () => {});
+
+  pi.on("message_start", () => {});
   pi.on("message_update", (event) => {
-    if (!active || active.firstTokenAt !== undefined) return;
+    const request = ensureRequest();
+    if (request.firstTokenAt !== undefined) return;
     if (!["text_delta", "thinking_delta", "toolcall_delta"].includes(event.assistantMessageEvent.type)) return;
-    active.firstTokenAt = Date.now();
-    append("first-token", {
-      ttftMs: active.firstTokenAt - active.startedAt,
-      eventType: event.assistantMessageEvent.type,
-    }, { requestId: active.id });
+    request.firstTokenAt = Date.now();
+
   });
   pi.on("message_end", (event) => {
     if (event.message.role !== "assistant" || !active) return;
     const completedAt = Date.now();
     append("message-end", {
-      totalMs: completedAt - active.startedAt,
-      ttftMs: active.firstTokenAt === undefined ? undefined : active.firstTokenAt - active.startedAt,
+      totalMs: active.startedAt === undefined ? undefined : completedAt - active.startedAt,
+      ttftMs: active.startedAt === undefined || active.firstTokenAt === undefined
+        ? undefined
+        : active.firstTokenAt - active.startedAt,
       decodingMs: active.firstTokenAt === undefined ? undefined : completedAt - active.firstTokenAt,
       usage: event.message.usage,
       stopReason: event.message.stopReason,
       errorMessage: event.message.errorMessage,
-    }, { requestId: active.id });
+    }, requestExtra());
     active = null;
   });
-  pi.on("tool_execution_start", (event) => {
-    const at = Date.now();
-    toolStarts.set(event.toolCallId, at);
-    append("tool-start", { toolName: event.toolName, args: event.args }, { toolCallId: event.toolCallId });
-  });
+
+  pi.on("tool_execution_start", (event) => { toolStarts.set(event.toolCallId, Date.now()); });
+  pi.on("tool_call", () => {});
+  pi.on("tool_execution_update", () => {});
+  pi.on("tool_result", () => {});
   pi.on("tool_execution_end", (event) => {
     const at = Date.now();
     const startedAt = toolStarts.get(event.toolCallId);
     append("tool-end", {
       toolName: event.toolName,
-      result: event.result,
       isError: event.isError,
       durationMs: startedAt === undefined ? undefined : at - startedAt,
-    }, { toolCallId: event.toolCallId });
+    }, { ...requestExtra(), toolCallId: event.toolCallId });
     toolStarts.delete(event.toolCallId);
   });
 
-  return () => sidecar?.read() ?? [];
+  pi.on("model_select", (event) => {
+    if (event.previousModel && (
+      event.previousModel.provider !== event.model.provider ||
+      event.previousModel.id !== event.model.id ||
+      event.previousModel.api !== event.model.api
+    )) prefixIntegrity.markBoundary("model_select");
+  });
+  pi.on("thinking_level_select", (event) => {
+    if (event.previousLevel !== event.level) prefixIntegrity.markBoundary("thinking_level_select");
+  });
+  pi.on("user_bash", () => {});
+  pi.on("input", () => {});
+
+  return () => sidecar?.read() ?? traceRecorder?.read() ?? [];
 }