@pi-unipi/trajectory 2.10.2 → 2.11.0

package/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/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/package.json

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

package/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() ?? [];
 }

package/src/prefix-integrity.ts

@@ -0,0 +1,213 @@
+import { createHash } from "node:crypto";
+
+export type PrefixVerdict = "first_request" | "identical_retry" | "prefix_extended" | "boundary" | "violation";
+
+export interface PrefixDifference {
+  surface: "messages" | "system" | "tools" | "envelope" | "shape";
+  kind: "changed" | "inserted" | "removed" | "reordered";
+  path: string;
+  index?: number;
+  beforeFingerprint?: string;
+  afterFingerprint?: string;
+}
+
+export interface PrefixIntegrityResult {
+  epoch: number;
+  verdict: PrefixVerdict;
+  messageField: string;
+  previousItems: number;
+  currentItems: number;
+  extendedBy: number;
+  requestFingerprint: string;
+  messagesFingerprint: string;
+  systemFingerprint: string;
+  toolsFingerprint: string;
+  envelopeFingerprint: string;
+  boundaryReason?: string;
+  differences: PrefixDifference[];
+}
+
+interface RequestState {
+  requestFingerprint: string;
+  messageField: string;
+  messages: unknown[];
+  messageFingerprints: string[];
+  systemFingerprint: string;
+  toolsFingerprint: string;
+  envelopeFingerprint: string;
+}
+
+function canonicalize(value: unknown, seen = new WeakSet<object>()): unknown {
+  if (value === undefined) return { $type: "undefined" };
+  if (typeof value === "bigint") return { $type: "bigint", value: value.toString() };
+  if (typeof value === "number" && !Number.isFinite(value)) return { $type: "number", value: String(value) };
+  if (typeof value !== "object" || value === null) return value;
+  if (seen.has(value)) return { $type: "cycle" };
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.map(item => canonicalize(item, seen));
+    seen.delete(value);
+    return result;
+  }
+  if (value instanceof Uint8Array) {
+    seen.delete(value);
+    return { $type: "bytes", length: value.byteLength };
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+    result[key] = canonicalize((value as Record<string, unknown>)[key], seen);
+  }
+  seen.delete(value);
+  return result;
+}
+
+function fingerprint(value: unknown): string {
+  return createHash("sha256").update(JSON.stringify(canonicalize(value))).digest("hex").slice(0, 16);
+}
+
+function payloadObject(payload: unknown): Record<string, unknown> {
+  return payload && typeof payload === "object" && !Array.isArray(payload)
+    ? payload as Record<string, unknown>
+    : { payload };
+}
+
+function messageSequence(payload: Record<string, unknown>): { field: string; items: unknown[] } {
+  for (const field of ["messages", "input", "contents"] as const) {
+    if (Array.isArray(payload[field])) return { field, items: payload[field] as unknown[] };
+  }
+  return { field: "none", items: [] };
+}
+
+function systemSurface(payload: Record<string, unknown>, field: string, messages: unknown[]): unknown {
+  const direct = Object.fromEntries(Object.entries(payload).filter(([key]) => /^(system|instructions|developer)/i.test(key)));
+  const leading = field === "messages"
+    ? messages.filter((message) => {
+      if (!message || typeof message !== "object") return false;
+      const role = (message as Record<string, unknown>).role;
+      return role === "system" || role === "developer";
+    })
+    : [];
+  return { direct, leading };
+}
+
+function toolsSurface(payload: Record<string, unknown>): unknown {
+  return { tools: payload.tools, toolChoice: payload.tool_choice ?? payload.toolChoice };
+}
+
+function envelopeSurface(payload: Record<string, unknown>, sequenceField: string): unknown {
+  const omitted = new Set([sequenceField, "tools", "tool_choice", "toolChoice"]);
+  return Object.fromEntries(Object.entries(payload).filter(([key]) => !omitted.has(key) && !/^(system|instructions|developer)/i.test(key)));
+}
+
+function state(payload: unknown, route?: unknown): RequestState {
+  const object = payloadObject(payload);
+  const sequence = messageSequence(object);
+  const system = systemSurface(object, sequence.field, sequence.items);
+  const tools = toolsSurface(object);
+  const envelope = { route, payload: envelopeSurface(object, sequence.field) };
+  return {
+    requestFingerprint: fingerprint({ route, payload: object }),
+    messageField: sequence.field,
+    messages: sequence.items,
+    messageFingerprints: sequence.items.map(fingerprint),
+    systemFingerprint: fingerprint(system),
+    toolsFingerprint: fingerprint(tools),
+    envelopeFingerprint: fingerprint(envelope),
+  };
+}
+
+function messageDifference(previous: RequestState, current: RequestState): PrefixDifference | undefined {
+  if (previous.messageField !== current.messageField) {
+    return { surface: "shape", kind: "changed", path: "$.messageField", beforeFingerprint: fingerprint(previous.messageField), afterFingerprint: fingerprint(current.messageField) };
+  }
+  const limit = Math.min(previous.messageFingerprints.length, current.messageFingerprints.length);
+  for (let index = 0; index < limit; index++) {
+    if (previous.messageFingerprints[index] === current.messageFingerprints[index]) continue;
+    const laterIndex = current.messageFingerprints.indexOf(previous.messageFingerprints[index]!, index + 1);
+    const earlierIndex = previous.messageFingerprints.indexOf(current.messageFingerprints[index]!, index + 1);
+    return {
+      surface: "messages",
+      kind: laterIndex >= 0 || earlierIndex >= 0 ? "reordered" : "changed",
+      path: `$.${current.messageField}[${index}]`, index,
+      beforeFingerprint: previous.messageFingerprints[index], afterFingerprint: current.messageFingerprints[index],
+    };
+  }
+  if (current.messageFingerprints.length < previous.messageFingerprints.length) {
+    const index = current.messageFingerprints.length;
+    return { surface: "messages", kind: "removed", path: `$.${current.messageField}[${index}]`, index, beforeFingerprint: previous.messageFingerprints[index] };
+  }
+  return undefined;
+}
+
+export class PrefixIntegrityTracker {
+  private epoch = 0;
+  private previous: RequestState | null = null;
+  private boundaryReason: string | undefined;
+
+  reset(): void {
+    this.epoch = 0;
+    this.previous = null;
+    this.boundaryReason = undefined;
+  }
+
+  markBoundary(reason: string): void {
+    if (this.previous) this.epoch++;
+    this.previous = null;
+    this.boundaryReason = reason;
+  }
+
+  observe(payload: unknown, route?: unknown): PrefixIntegrityResult {
+    const current = state(payload, route);
+    const boundaryReason = this.boundaryReason;
+    if (!this.previous) {
+      if (this.epoch === 0) this.epoch = 1;
+      this.previous = current;
+      this.boundaryReason = undefined;
+      return {
+        epoch: this.epoch,
+        verdict: boundaryReason ? "boundary" : "first_request",
+        messageField: current.messageField,
+        previousItems: 0,
+        currentItems: current.messages.length,
+        extendedBy: current.messages.length,
+        requestFingerprint: current.requestFingerprint,
+        messagesFingerprint: fingerprint(current.messageFingerprints),
+        systemFingerprint: current.systemFingerprint,
+        toolsFingerprint: current.toolsFingerprint,
+        envelopeFingerprint: current.envelopeFingerprint,
+        ...(boundaryReason ? { boundaryReason } : {}),
+        differences: [],
+      };
+    }
+
+    const previous = this.previous;
+    const differences: PrefixDifference[] = [];
+    const messageDiff = messageDifference(previous, current);
+    if (messageDiff) differences.push(messageDiff);
+    if (previous.systemFingerprint !== current.systemFingerprint) differences.push({ surface: "system", kind: "changed", path: "$.system", beforeFingerprint: previous.systemFingerprint, afterFingerprint: current.systemFingerprint });
+    if (previous.toolsFingerprint !== current.toolsFingerprint) differences.push({ surface: "tools", kind: "changed", path: "$.tools", beforeFingerprint: previous.toolsFingerprint, afterFingerprint: current.toolsFingerprint });
+    if (previous.envelopeFingerprint !== current.envelopeFingerprint) differences.push({ surface: "envelope", kind: "changed", path: "$.envelope", beforeFingerprint: previous.envelopeFingerprint, afterFingerprint: current.envelopeFingerprint });
+
+    const verdict: PrefixVerdict = current.requestFingerprint === previous.requestFingerprint
+      ? "identical_retry"
+      : differences.length === 0
+        ? "prefix_extended"
+        : "violation";
+    const result: PrefixIntegrityResult = {
+      epoch: this.epoch,
+      verdict,
+      messageField: current.messageField,
+      previousItems: previous.messages.length,
+      currentItems: current.messages.length,
+      extendedBy: Math.max(0, current.messages.length - previous.messages.length),
+      requestFingerprint: current.requestFingerprint,
+      messagesFingerprint: fingerprint(current.messageFingerprints),
+      systemFingerprint: current.systemFingerprint,
+      toolsFingerprint: current.toolsFingerprint,
+      envelopeFingerprint: current.envelopeFingerprint,
+      differences,
+    };
+    this.previous = current;
+    return result;
+  }
+}

package/src/project.ts

@@ -1,7 +1,7 @@
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { TelemetryEvent } from "./telemetry.js";
 
-export type TrajectoryKind = "system" | "user" | "assistant" | "tool" | "compaction" | "branch";
+export type TrajectoryKind = "system" | "unipi" | "prefix" | "user" | "assistant" | "tool" | "compaction" | "branch";
 
 export interface TrajectoryUsage {
   input?: number;
@@ -38,6 +38,13 @@ export interface TrajectoryRecord {
   request?: unknown;
   response?: unknown;
   tools?: unknown;
+  data?: unknown;
+  package?: string;
+  surface?: string;
+  phase?: string;
+  verdict?: string;
+  epoch?: number;
+  attribution?: unknown;
 }
 
 export interface TrajectorySnapshot {
@@ -165,12 +172,56 @@ export function projectTrajectory(
     }
   }
 
+  const firstEntryAt = records[0]?.timestamp ?? Date.now();
+  let syntheticSeq = -telemetry.length;
+  for (const event of telemetry) {
+    if (!["system-prompt", "unipi-trace", "prefix-integrity"].includes(event.type)) continue;
+    const data = event.data as AnyRecord | undefined;
+    // Package traces are attribution evidence, not a second activity log. Only
+    // operations that changed a provider-visible surface belong in trajectory.
+    if (event.type === "unipi-trace" && data?.affectsContext !== true) continue;
+    const traceAction = String(data?.hook ?? data?.action ?? data?.channel ?? data?.surface ?? "operation");
+    const kind: TrajectoryKind = event.type === "system-prompt" ? "system" : event.type === "unipi-trace" ? "unipi" : "prefix";
+    const title = event.type === "system-prompt"
+      ? "SYSTEM PROMPT"
+      : event.type === "unipi-trace"
+        ? `${String(data?.package ?? "unipi")} · ${traceAction}`
+        : `PREFIX · ${String(data?.verdict ?? "unknown")}`;
+    const value = event.type === "system-prompt" ? data?.systemPrompt : data;
+    records.push({
+      id: `telemetry:${event.type}:${event.at}:${syntheticSeq}`,
+      seq: syntheticSeq++,
+      turn: event.turnIndex === undefined ? null : event.turnIndex + 1,
+      step: null,
+      kind,
+      timestamp: event.at || firstEntryAt,
+      durationMs: typeof data?.durationMs === "number" ? data.durationMs : null,
+      title,
+      preview: event.type === "prefix-integrity"
+        ? `${String(data?.verdict ?? "unknown")} · epoch ${String(data?.epoch ?? "?")}${Array.isArray(data?.differences) && data.differences[0] ? ` · ${String(data.differences[0].path ?? data.differences[0].surface ?? "changed")}` : ""}`
+        : preview(event.type === "system-prompt" ? value : JSON.stringify(value ?? {})),
+      output: event.type === "system-prompt" ? value : undefined,
+      data,
+      package: typeof data?.package === "string" ? data.package : undefined,
+      surface: typeof data?.surface === "string" ? data.surface : undefined,
+      phase: typeof data?.phase === "string" ? data.phase : undefined,
+      verdict: typeof data?.verdict === "string" ? data.verdict : undefined,
+      epoch: typeof data?.epoch === "number" ? data.epoch : undefined,
+      attribution: data?.attribution,
+      isError: data?.phase === "error" || data?.verdict === "violation",
+      request: event.requestId === undefined ? undefined : { requestId: event.requestId },
+    });
+  }
+  records.sort((a, b) => a.timestamp - b.timestamp || a.seq - b.seq);
+
   const assistantRecords = records.filter(record => record.kind === "assistant");
-  const requestIds = [...new Set(telemetry.flatMap(event => event.requestId === undefined ? [] : [event.requestId]))];
-  for (const [index, requestId] of requestIds.entries()) {
-    const record = assistantRecords[index];
-    if (!record) break;
+  const requestIds = [...new Set(telemetry.flatMap(event => event.type === "request" && event.requestId !== undefined ? [event.requestId] : []))];
+  for (const requestId of requestIds) {
     const events = telemetry.filter(event => event.requestId === requestId);
+    const requestAt = events.find(event => event.type === "request")?.at ?? 0;
+    const record = assistantRecords.find(candidate => candidate.request === undefined && candidate.timestamp >= requestAt)
+      ?? assistantRecords.find(candidate => candidate.request === undefined);
+    if (!record) break;
     const request = events.find(event => event.type === "request")?.data as AnyRecord | undefined;
     const response = events.find(event => event.type === "response")?.data;
     const end = events.find(event => event.type === "message-end")?.data as AnyRecord | undefined;
@@ -188,6 +239,7 @@ export function projectTrajectory(
     const end = telemetry.find(event => event.type === "tool-end" && event.toolCallId === record.toolCallId)?.data as AnyRecord | undefined;
     if (typeof end?.durationMs === "number") record.durationMs = end.durationMs;
   }
+  records.forEach((record, index) => { record.seq = index; });
 
   return { ...meta, generatedAt: Date.now(), records };
 }