behavior-wrapped 0.8.1 → 0.8.3

package/server/analysis.mjs

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
-import { safeEvidenceText, redactText } from "./privacy.mjs";
+import { safeEvidenceText, redactAggregateText, redactText } from "./privacy.mjs";
 import { isFrustratedMessage, isGratefulMessage } from "./frustration-card.mjs";
+import { estimateModelUsageCost } from "./model-pricing.mjs";
 import { displayModelName } from "./model-names.mjs";
 
 export { displayModelName } from "./model-names.mjs";
@@ -77,6 +78,90 @@ function stockPhraseCounts(texts) {
   }));
 }
 
+const instructionOpeningPattern = /^(?:please\s+)?(?:always|never|do not|don['’]t|avoid|be|check|commit|continue|focus|give|include|keep|make|only|prefer|push|remember|respond|run|show|stop|tell|use|write)\b/i;
+const userAccountabilityPattern = /\b(?:my (?:mistake|fault|bad)|i (?:was|am|got (?:that|this|it)) wrong|you (?:were|are) right|(?:i['’]m )?sorry[,—–-]? (?:i (?:was|got|missed|misunderstood|overlooked|forgot|made)|that was|you were))\b/i;
+const agentAccountabilityPattern = /\b(?:my (?:mistake|fault|error)|i (?:was|am|got (?:that|this|it)) wrong|you(?:['’]re| are| were) right|(?:i['’]m )?sorry[,—–-]? (?:i (?:was|got|missed|misunderstood|overlooked|forgot|made)|that was|you were))\b/i;
+
+function repeatedInstructions(sessionRecords) {
+  const instructions = new Map();
+  for (let sessionIndex = 0; sessionIndex < sessionRecords.length; sessionIndex++) {
+    for (const record of sessionRecords[sessionIndex].records) {
+      if (record.type !== "user" || record.isMeta) continue;
+      const cleaned = redactAggregateText(proseText(visibleText(record)));
+      if (!cleaned || /\[(?:REDACTED|REMOVED)[^\]]*\]/i.test(cleaned)) continue;
+      for (const rawClause of cleaned.split(/(?<=[.!?])\s+|[;\n]+/)) {
+        const instruction = rawClause.replace(/^[-*\d.)\s]+/, "").replace(/\s+/g, " ").trim();
+        const words = instruction.match(/\p{L}+(?:['’]\p{L}+)?/gu) || [];
+        if (words.length < 3 || words.length > 18 || instruction.length > 160 || !instructionOpeningPattern.test(instruction)) continue;
+        if (/https?:\/\/|(?:\/Users\/|\/home\/)|```|<[^>]+>|[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(instruction)) continue;
+        const key = instruction.normalize("NFKC").replace(/[’‘]/g, "'").toLocaleLowerCase().replace(/[^\p{L}'\s]/gu, "").replace(/\s+/g, " ").trim();
+        if (!key) continue;
+        const item = instructions.get(key) || { instruction, occurrences: 0, sessions: new Set() };
+        item.occurrences++;
+        item.sessions.add(sessionIndex);
+        instructions.set(key, item);
+      }
+    }
+  }
+  return [...instructions.values()]
+    .filter((item) => item.occurrences >= 2)
+    .sort((left, right) => right.sessions.size - left.sessions.size || right.occurrences - left.occurrences || left.instruction.localeCompare(right.instruction))
+    .slice(0, 4)
+    .map((item) => ({ instruction: item.instruction, occurrences: item.occurrences, distinctSessions: item.sessions.size }));
+}
+
+function permissionScore(record, agent) {
+  const mode = String(record.permissionMode || "").toLowerCase();
+  if (mode) {
+    const scores = { plan: 0, default: agent === "cowork" ? 40 : 25, acceptedits: 65, dontask: 80, bypasspermissions: 100 };
+    return scores[mode] ?? null;
+  }
+  if (agent !== "codex" || (!record.approvalPolicy && !record.sandboxPolicy)) return null;
+  const approvalScores = { untrusted: 0, "on-request": 20, "on-failure": 40, never: 60 };
+  const sandboxScores = { "read-only": 0, "workspace-write": 25, "danger-full-access": 40 };
+  const approval = approvalScores[String(record.approvalPolicy || "").toLowerCase()] ?? 0;
+  const sandbox = sandboxScores[String(record.sandboxPolicy || "").toLowerCase()] ?? 0;
+  return Math.min(100, approval + sandbox);
+}
+
+function buildTrustCurve(sessionRecords) {
+  const days = new Map();
+  let observations = 0;
+  let autonomousObservations = 0;
+  for (const { records, agent = "claude" } of sessionRecords) {
+    for (const record of records) {
+      const score = permissionScore(record, agent);
+      const timestamp = record.timestamp ? new Date(record.timestamp) : null;
+      if (score === null || !timestamp || !Number.isFinite(timestamp.getTime())) continue;
+      const date = timestamp.toISOString().slice(0, 10);
+      const item = days.get(date) || { total: 0, observations: 0 };
+      item.total += score;
+      item.observations++;
+      days.set(date, item);
+      observations++;
+      if (score >= 65) autonomousObservations++;
+    }
+  }
+  const ordered = [...days].sort((left, right) => left[0].localeCompare(right[0]));
+  if (ordered.length < 2) return null;
+  const firstDay = new Date(`${ordered[0][0]}T00:00:00.000Z`).getTime();
+  const points = ordered.map(([date, item]) => ({
+    dayOffset: Math.round((new Date(`${date}T00:00:00.000Z`).getTime() - firstDay) / 86_400_000),
+    score: Number((item.total / item.observations).toFixed(1)),
+    observations: item.observations,
+  }));
+  return {
+    points,
+    startScore: points[0].score,
+    endScore: points.at(-1).score,
+    change: Number((points.at(-1).score - points[0].score).toFixed(1)),
+    observations,
+    autonomousObservations,
+    autonomousPercentage: Number((autonomousObservations / observations * 100).toFixed(1)),
+    method: "Scores source-specific permission modes from 0 (planning/read-only with approvals) to 100 (no approvals with full access), then averages observations by day.",
+  };
+}
+
 const anomalyScripts = [
   { language: "Japanese", locale: "ja", expression: /[\p{Script=Hiragana}\p{Script=Katakana}]/gu },
   { language: "Korean", locale: "ko", expression: /\p{Script=Hangul}/gu },
@@ -251,15 +336,6 @@ function finding(kind, title, summary, method, score, evidence) {
   return { id: crypto.randomUUID(), kind, title, summary, method, confidence: confidence(score), evidence };
 }
 
-function ratesFor(model, agent) {
-  const value = String(model || "").toLowerCase();
-  if (value.includes("opus")) return { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 };
-  if (value.includes("sonnet")) return { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
-  if (value.includes("haiku")) return { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 };
-  if (agent === "codex" || value.startsWith("gpt")) return { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.125 };
-  return { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
-}
-
 function analyzeBehavior(sessionRecords) {
   const findings = [];
   for (const { sessionId, records } of sessionRecords) {
@@ -339,6 +415,7 @@ export function analyzeSessions(sessionRecords) {
   const toolCounts = new Map();
   const agentCounts = new Map(agentDefinitions.map(({ agent }) => [agent, 0]));
   const modelTokens = new Map();
+  const interruptionModels = new Map();
   const activeDays = new Set();
   let prompts = 0;
   let toolCalls = 0;
@@ -353,15 +430,20 @@ export function analyzeSessions(sessionRecords) {
   let agentResponseCount = 0;
   let frustratedMessages = 0;
   let gratefulMessages = 0;
+  let userApologies = 0;
+  let agentApologies = 0;
+  const apologyReview = { user: [], agent: [] };
+  let longestUninterruptedRun = null;
   const assistantProse = [];
   const sessionTurnCounts = [];
-  for (const { records, agent = "claude" } of sessionRecords) {
+  for (const { sessionId, records, agent = "claude" } of sessionRecords) {
     agentCounts.set(agent, (agentCounts.get(agent) || 0) + 1);
     const timestamps = records.map((r) => r.timestamp).filter(Boolean).map((value) => new Date(value).getTime()).filter(Number.isFinite);
     if (timestamps.length > 1) totalDurationMs += Math.max(...timestamps) - Math.min(...timestamps);
     let currentResponseWords = 0;
     let hasCurrentPrompt = false;
     let sessionTurns = 0;
+    let currentModel = `${agent === "codex" ? "Codex" : agent === "cowork" ? "Cowork" : "Claude"} model`;
     const finishResponse = () => {
       if (hasCurrentPrompt && currentResponseWords > 0) {
         agentResponseWords += currentResponseWords;
@@ -369,8 +451,17 @@ export function analyzeSessions(sessionRecords) {
       }
       currentResponseWords = 0;
     };
-    for (const record of records) {
+    for (const [recordIndex, record] of records.entries()) {
       const text = visibleText(record);
+      const declaredModel = record?.message?.model || record?.model;
+      if (typeof declaredModel === "string" && declaredModel) currentModel = declaredModel;
+      if (record.type === "system" && record.subtype === "turn_duration") {
+        const durationMs = Number(record.durationMs);
+        if (Number.isFinite(durationMs) && durationMs > 0 && (!longestUninterruptedRun || durationMs > longestUninterruptedRun.durationMs)) {
+          const definition = agentDefinitions.find((item) => item.agent === agent);
+          longestUninterruptedRun = { durationMs: Math.round(durationMs), agent, agentName: definition?.name || "Agent" };
+        }
+      }
       if (record.type === "user" && !record.isMeta && text) {
         finishResponse();
         hasCurrentPrompt = true;
@@ -379,14 +470,33 @@ export function analyzeSessions(sessionRecords) {
         sessionTurns++;
         if (isFrustratedMessage(text)) frustratedMessages++;
         if (isGratefulMessage(text)) gratefulMessages++;
+        if (userAccountabilityPattern.test(proseText(text))) {
+          userApologies++;
+          apologyReview.user.push({
+            candidateId: `apology-user-${userApologies}`,
+            location: { sessionId, recordIndex, timestamp: record.timestamp || null },
+          });
+        }
       } else if (record.type === "assistant" && hasCurrentPrompt && text) {
         currentResponseWords += wordCount(text);
       }
-      if (record.type === "assistant" && text) assistantProse.push(text);
+      if (record.type === "assistant" && text) {
+        assistantProse.push(text);
+        if (agentAccountabilityPattern.test(proseText(text))) {
+          agentApologies++;
+          apologyReview.agent.push({
+            candidateId: `apology-agent-${agentApologies}`,
+            location: { sessionId, recordIndex, timestamp: record.timestamp || null },
+          });
+        }
+      }
       const d = day(record.timestamp);
       if (d) activeDays.add(d);
       if (record.type === "user" && !record.isMeta && text) prompts++;
-      if (record.type === "system" && /interrupt/i.test(`${record.subtype || ""} ${record.content || ""}`)) interruptions++;
+      if ((record.type === "system" && /interrupt/i.test(`${record.subtype || ""} ${record.content || ""}`)) || record.interruptedMessageId) {
+        interruptions++;
+        interruptionModels.set(currentModel, (interruptionModels.get(currentModel) || 0) + 1);
+      }
       const usage = record?.message?.usage;
       if (usage) {
         const input = Number(usage.input_tokens) || 0;
@@ -403,8 +513,7 @@ export function analyzeSessions(sessionRecords) {
         tokenBreakdown.reasoning += reasoning;
         const model = record?.message?.model || `${agent === "codex" ? "Codex" : "Claude"} model`;
         modelTokens.set(model, (modelTokens.get(model) || 0) + recordTokens);
-        const rates = ratesFor(model, agent);
-        estimatedCostUsd += (input * rates.input + (output + reasoning) * rates.output + cacheWrite * rates.cacheWrite + cacheRead * rates.cacheRead) / 1_000_000;
+        estimatedCostUsd += estimateModelUsageCost(usage, model, agent);
       }
       for (const tool of toolUses(record)) {
         toolCalls++;
@@ -427,6 +536,9 @@ export function analyzeSessions(sessionRecords) {
     tokens: modelTokenCount,
     percentage: tokens ? Number((modelTokenCount / tokens * 100).toFixed(1)) : 0,
   }));
+  const interruptionsByModel = [...interruptionModels]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+    .map(([model, count]) => ({ model, name: displayModelName(model), count }));
   const stats = {
     sessions: totalSessions,
     activeDays: activeDays.size,
@@ -434,6 +546,7 @@ export function analyzeSessions(sessionRecords) {
     prompts,
     toolCalls,
     interruptions,
+    interruptionsByModel,
     tokens,
     tokenBreakdown,
     agentWords: agentResponseWords,
@@ -450,7 +563,15 @@ export function analyzeSessions(sessionRecords) {
       analyzedMessages: userInputCount,
       method: "Counts user messages matching conservative frustration or gratitude phrase patterns; this is an approximate tone signal, not a judgment of emotion.",
     },
+    apologyCounts: {
+      user: userApologies,
+      agent: agentApologies,
+      method: "Counts visible messages containing explicit admissions of error or fault; generic capability apologies are excluded.",
+    },
+    longestUninterruptedRun,
+    trustCurve: buildTrustCurve(sessionRecords),
     stockPhrases: stockPhraseCounts(assistantProse),
+    repeatedInstructions: repeatedInstructions(sessionRecords),
     outputLanguages: languageBreakdown(assistantProse),
     languageAnomaly: languageAnomalyBreakdown(sessionRecords),
     languageMethod: "Estimates natural-language word share in assistant text after removing fenced code, inline code, URLs, paths, and markup. Script detection and small Latin-language lexicons are approximate.",
@@ -460,9 +581,9 @@ export function analyzeSessions(sessionRecords) {
     agents,
     models,
     estimatedCostUsd: Number(estimatedCostUsd.toFixed(2)),
-    costEstimateMethod: "API-equivalent estimate using a local, inspectable model-family rate table.",
+    costEstimateMethod: "API-equivalent estimate using current standard list prices by exact model, including distinct cache-read, 5-minute cache-write, and 1-hour cache-write rates.",
   };
-  return { stats, findings: analyzeBehavior(sessionRecords) };
+  return { stats, findings: analyzeBehavior(sessionRecords), apologyReview };
 }
 
 function donationRedactionInventory(detections) {

package/server/cli.mjs

@@ -259,7 +259,7 @@ async function createWrapped() {
   const id = createReportId();
   const safeFindings = analyzed.findings.map(({ evidence, method, ...finding }) => finding);
   const hasPrivateWorkaroundEvidence = Boolean(analyzed.workaroundReview?.occurrences?.length || analyzed.workaroundReview?.borderline?.length);
-  const report = { id, createdAt: new Date().toISOString(), rangeLabel: formatRange(chosenSessions), source: formatAgentSource(chosenSessions), stats: analyzed.stats, findings: safeFindings, phraseCard: analyzed.phraseCard, interactionCard: analyzed.interactionCard, interactionReview: analyzed.interactionReview, workaroundCard: analyzed.workaroundCard, workaroundReview: analyzed.workaroundReview, sessionSummaries: analyzed.sessionSummaries || [], sessionIds: chosenSessions.map((session) => session.id), donationHelperUrl: `${baseUrl}/donate/${id}`, privacy: { shareSafe: !hasPrivateWorkaroundEvidence, containsTranscriptText: hasPrivateWorkaroundEvidence, externalTransmission: !localOnly, analysisMode: localOnly ? "local-only" : "remote", leaderboardParticipation: localOnly ? "excluded" : "included-by-default", ...(localOnly ? { transmittedData: `None; ${testMode ? "test" : "local-only"} mode stays on this device.`, externalRecipient: "None" } : { transmittedData: "redacted phrase, interaction-tone, and session-topic candidates; locally redacted context windows around explicit blockers for workaround discovery; aggregate report statistics; and a random client ID only", externalRecipient: "Behavior Wrapped relay, OpenRouter, a zero-data-retention GPT-5.6 Luna provider, and public report hosting" }) } };
+  const report = { id, createdAt: new Date().toISOString(), rangeLabel: formatRange(chosenSessions), source: formatAgentSource(chosenSessions), stats: analyzed.stats, findings: safeFindings, phraseCard: analyzed.phraseCard, interactionCard: analyzed.interactionCard, interactionReview: analyzed.interactionReview, apologyReview: analyzed.apologyReview, workaroundCard: analyzed.workaroundCard, workaroundReview: analyzed.workaroundReview, sessionSummaries: analyzed.sessionSummaries || [], sessionIds: chosenSessions.map((session) => session.id), donationHelperUrl: `${baseUrl}/donate/${id}`, privacy: { shareSafe: !hasPrivateWorkaroundEvidence, containsTranscriptText: hasPrivateWorkaroundEvidence, externalTransmission: !localOnly, analysisMode: localOnly ? "local-only" : "remote", leaderboardParticipation: localOnly ? "excluded" : "included-by-default", ...(localOnly ? { transmittedData: `None; ${testMode ? "test" : "local-only"} mode stays on this device.`, externalRecipient: "None" } : { transmittedData: "redacted phrase, interaction-tone, and session-topic candidates; locally redacted context windows around explicit blockers for workaround discovery; aggregate report statistics; and a random client ID only", externalRecipient: "Behavior Wrapped relay, OpenRouter, a zero-data-retention GPT-5.6 Luna provider, and public report hosting" }) } };
   let publicUrl = null;
   if (!localOnly) {
     progress.start("Publishing share-safe Wrapped", "strict aggregate-only schema");

package/server/discovery.mjs

@@ -126,7 +126,7 @@ function shouldKeepCoworkRecord(record, seenUuids) {
     if (seenUuids.has(record.uuid)) return false;
     seenUuids.add(record.uuid);
   }
-  return ["user", "assistant", "system"].includes(record.type);
+  return ["user", "assistant", "system", "result"].includes(record.type);
 }
 
 function coworkMetadataFromRecords(file, stat, records, metadata = readCoworkMetadata(file)) {
@@ -427,6 +427,14 @@ function normalizeCodexRecords(records, { includePrivateToolDetails = false } =
     if (record.type === "turn_context" && typeof payload.model === "string") {
       currentModel = payload.model;
       hasSeenModelContext = true;
+      const sandboxPolicy = payload.sandbox_policy?.type || payload.permission_profile?.type || (typeof payload.sandbox_policy === "string" ? payload.sandbox_policy : null);
+      if (payload.approval_policy || sandboxPolicy) normalized.push({
+        type: "system",
+        subtype: "permission_mode",
+        timestamp: record.timestamp,
+        approvalPolicy: typeof payload.approval_policy === "string" ? payload.approval_policy : null,
+        sandboxPolicy,
+      });
     } else if (record.type === "response_item" && payload.type === "message" && (payload.role === "user" || payload.role === "assistant")) {
       const content = textBlocks(payload.content);
       if (content.length) normalized.push({ type: payload.role, timestamp: record.timestamp, message: { content, ...(payload.role === "assistant" ? { model: currentModel } : {}) } });
@@ -447,8 +455,10 @@ function normalizeCodexRecords(records, { includePrivateToolDetails = false } =
       const canSummarizeRestriction = status.failed || (!status.wrapped && restrictionEligibleActions.has(semantics?.action));
       const errorSummary = canSummarizeRestriction ? restrictionErrorSummary(output) : null;
       normalized.push({ type: "user", isMeta: true, timestamp: record.timestamp, message: { content: [{ type: "tool_result", is_error: Boolean(errorSummary) || status.failed || unwrappedFailure, error_summary: errorSummary, ...(includePrivateToolDetails && output ? { content: output } : {}) }] } });
+    } else if (record.type === "event_msg" && payload.type === "task_complete" && Number(payload.duration_ms) > 0) {
+      normalized.push({ type: "system", subtype: "turn_duration", timestamp: record.timestamp, durationMs: Number(payload.duration_ms), model: currentModel });
     } else if (record.type === "event_msg" && payload.type === "turn_aborted") {
-      normalized.push({ type: "system", subtype: "interrupt", timestamp: record.timestamp, content: "interrupt" });
+      normalized.push({ type: "system", subtype: "interrupt", timestamp: record.timestamp, content: "interrupt", model: currentModel });
     } else if (record.type === "event_msg" && payload.type === "token_count" && payload.info?.total_token_usage) {
       const total = payload.info.total_token_usage;
       const usage = Object.fromEntries(Object.keys(previousUsage).map((key) => [key, Math.max(0, (Number(total[key]) || 0) - previousUsage[key])]));
@@ -477,6 +487,11 @@ function normalizeCoworkRecords(records) {
   for (const record of records) {
     if (!shouldKeepCoworkRecord(record, seenUuids)) continue;
     const timestamp = coworkRecordTimestamp(record);
+    if (record.type === "result") {
+      const durationMs = Number(record.duration_ms);
+      if (!record.is_error && record.subtype === "success" && durationMs > 0) normalized.push({ type: "system", subtype: "turn_duration", ...(timestamp ? { timestamp } : {}), durationMs, model: typeof record.model === "string" ? record.model : "Cowork model" });
+      continue;
+    }
     const message = record.message && typeof record.message === "object" ? {
       ...(record.message.content !== undefined ? { content: record.message.content } : {}),
       ...(typeof record.message.model === "string" ? { model: record.message.model } : {}),
@@ -488,6 +503,8 @@ function normalizeCoworkRecords(records) {
       ...(record.isMeta ? { isMeta: true } : {}),
       ...(record.subtype ? { subtype: record.subtype } : {}),
       ...(record.content !== undefined ? { content: record.content } : {}),
+      ...(typeof record.model === "string" ? { model: record.model } : {}),
+      ...(typeof record.permissionMode === "string" ? { permissionMode: record.permissionMode } : {}),
       ...(message ? { message } : {}),
     };
     const messageId = record.type === "assistant" && typeof record?.message?.id === "string" ? record.message.id : null;

package/server/interaction-evidence.mjs

@@ -15,12 +15,12 @@ function transcriptRole(record) {
   return record?.type === "assistant" ? "assistant" : record?.type === "user" && !record?.isMeta ? "user" : null;
 }
 
-function matchingRecordIndex(reference, records) {
+function matchingRecordIndex(reference, records, expectedRole) {
   const index = reference?.location?.recordIndex;
   if (Number.isInteger(index) && index >= 0 && index < records.length) return index;
   const timestamp = reference?.location?.timestamp;
   if (!timestamp) return null;
-  const fallback = records.findIndex((record) => record?.timestamp === timestamp && record?.type === "user" && !record?.isMeta);
+  const fallback = records.findIndex((record) => record?.timestamp === timestamp && transcriptRole(record) === expectedRole);
   return fallback >= 0 ? fallback : null;
 }
 
@@ -33,12 +33,12 @@ function adjacentMessage(records, fromIndex, direction) {
   return null;
 }
 
-function exactOccurrence(reference, index, records, metadata) {
-  const recordIndex = matchingRecordIndex(reference, records);
+function exactOccurrence(reference, index, records, metadata, expectedRole) {
+  const recordIndex = matchingRecordIndex(reference, records, expectedRole);
   if (recordIndex === null) return null;
   const record = records[recordIndex];
   const text = visibleText(record);
-  if (record?.type !== "user" || record?.isMeta || !text) return null;
+  if (transcriptRole(record) !== expectedRole || !text) return null;
   const before = adjacentMessage(records, recordIndex, -1);
   const after = adjacentMessage(records, recordIndex, 1);
   return {
@@ -50,16 +50,16 @@ function exactOccurrence(reference, index, records, metadata) {
       startedAt: metadata?.startedAt || records.find((item) => item?.timestamp)?.timestamp || null,
     },
     timestamp: record.timestamp || null,
-    messages: [before, { role: "user", text, timestamp: record.timestamp || null, highlighted: true }, after].filter(Boolean),
+    messages: [before, { role: expectedRole, text, timestamp: record.timestamp || null, highlighted: true }, after].filter(Boolean),
   };
 }
 
-function buildKind(report, kind, recordsById, metadataById) {
-  return (report?.interactionReview?.[kind] || []).slice(0, MAX_OCCURRENCES_PER_KIND).flatMap((reference, index) => {
+function buildKind(review, kind, expectedRole, recordsById, metadataById) {
+  return (review?.[kind] || []).slice(0, MAX_OCCURRENCES_PER_KIND).flatMap((reference, index) => {
     const sessionId = reference?.location?.sessionId;
     const records = recordsById.get(sessionId);
     if (!records) return [];
-    const occurrence = exactOccurrence(reference, index, records, metadataById.get(sessionId));
+    const occurrence = exactOccurrence(reference, index, records, metadataById.get(sessionId), expectedRole);
     return occurrence ? [occurrence] : [];
   });
 }
@@ -67,11 +67,13 @@ function buildKind(report, kind, recordsById, metadataById) {
 export function makeInteractionEvidencePreview(report, sessionRecords, metadataById) {
   const recordsById = new Map(sessionRecords.map((session) => [session.sessionId, session.records]));
   return {
-    format: "behavior-wrapped-interaction-evidence-v1",
+    format: "behavior-wrapped-interaction-evidence-v2",
     localPrivate: true,
     standardRedactionsApplied: false,
     reportId: report?.id,
-    frustrated: buildKind(report, "frustrated", recordsById, metadataById),
-    grateful: buildKind(report, "grateful", recordsById, metadataById),
+    frustrated: buildKind(report?.interactionReview, "frustrated", "user", recordsById, metadataById),
+    grateful: buildKind(report?.interactionReview, "grateful", "user", recordsById, metadataById),
+    userApologies: buildKind(report?.apologyReview, "user", "user", recordsById, metadataById),
+    agentApologies: buildKind(report?.apologyReview, "agent", "assistant", recordsById, metadataById),
   };
 }

package/server/launcher.mjs

@@ -107,7 +107,7 @@ const server = http.createServer(async (request, response) => {
     if (request.method === "GET" && reportMatch) {
       const report = loadReport(reportMatch[1]);
       if (!report) return json(response, 404, { error: "Saved report not found" });
-      const { sessionIds, workaroundReview, interactionReview, ...shareSafeReport } = report;
+      const { sessionIds, workaroundReview, interactionReview, apologyReview, ...shareSafeReport } = report;
       shareSafeReport.privacy = { ...shareSafeReport.privacy, shareSafe: true, containsTranscriptText: false };
       return json(response, 200, shareSafeReport);
     }
@@ -133,7 +133,7 @@ const server = http.createServer(async (request, response) => {
       const report = loadReport(interactionEvidenceMatch[1]);
       if (!report) return json(response, 404, { error: "Saved report not found" });
       const allowed = new Set(report.sessionIds || []);
-      const references = [...(report.interactionReview?.frustrated || []), ...(report.interactionReview?.grateful || [])];
+      const references = [...(report.interactionReview?.frustrated || []), ...(report.interactionReview?.grateful || []), ...(report.apologyReview?.user || []), ...(report.apologyReview?.agent || [])];
       const ids = [...new Set(references.map((reference) => reference?.location?.sessionId).filter((id) => allowed.has(id) && catalog.index.has(id)))].slice(0, 200);
       const records = await chosenRecords(ids);
       const labels = new Map(publicCatalog().sessions.map((session) => [session.id, session]));

package/server/model-pricing.mjs

@@ -0,0 +1,61 @@
+// Standard API list prices in USD per million tokens, verified 2026-08-26.
+// OpenAI: https://developers.openai.com/api/docs/models/compare
+// Anthropic: https://platform.claude.com/docs/en/about-claude/pricing
+const scaled = (value, multiplier) => Number((value * multiplier).toFixed(12));
+
+const price = (input, output, cacheRead, cacheWrite5m, cacheWrite1h) => ({
+  input,
+  output,
+  cacheRead: cacheRead ?? scaled(input, 0.1),
+  cacheWrite5m: cacheWrite5m ?? scaled(input, 1.25),
+  cacheWrite1h: cacheWrite1h ?? scaled(input, 2),
+});
+
+const modelRates = [
+  [/gpt-5\.6-sol/, price(4, 20)],
+  [/gpt-5\.6-terra/, price(2, 12)],
+  [/gpt-5\.6-luna/, price(0.2, 1.2)],
+  [/gpt-5\.5-pro/, price(30, 180, 0, 30, 30)],
+  [/gpt-5\.5/, price(5, 30)],
+  [/gpt-5\.4-pro/, price(30, 180, 0, 30, 30)],
+  [/gpt-5\.4-mini/, price(0.75, 4.5)],
+  [/gpt-5\.4-nano/, price(0.2, 1.25)],
+  [/gpt-5\.4/, price(2.5, 15)],
+  [/gpt-5\.3-codex/, price(1.75, 14)],
+  [/gpt-5\.2/, price(1.75, 14)],
+  [/(?:claude-)?(?:fable|mythos)(?:-|\s)?5/, price(10, 50)],
+  [/(?:claude-)?opus(?:-|\s)?5/, price(5, 25)],
+  [/(?:claude-)?opus(?:-|\s)?4(?:-|\s)?(?:8|7|6|5)/, price(5, 25)],
+  [/(?:claude-)?opus(?:-|\s)?4(?:-|\s)?1/, price(15, 75)],
+  [/(?:claude-)?opus(?:-|\s)?4(?:\b|-20)/, price(15, 75)],
+  [/(?:claude-)?sonnet(?:-|\s)?5/, price(2, 10)],
+  [/(?:claude-)?sonnet(?:-|\s)?4/, price(3, 15)],
+  [/(?:claude-)?haiku(?:-|\s)?4(?:-|\s)?5/, price(1, 5)],
+  [/(?:claude-)?haiku(?:-|\s)?3(?:-|\s)?5/, price(0.8, 4)],
+];
+
+export function ratesFor(model, agent) {
+  const value = String(model || "").toLowerCase();
+  const match = modelRates.find(([pattern]) => pattern.test(value));
+  if (match) return match[1];
+  return agent === "codex" || value.startsWith("gpt") ? price(2.5, 15) : price(3, 15);
+}
+
+export function estimateModelUsageCost(usage, model, agent) {
+  const input = Number(usage?.input_tokens) || 0;
+  const output = Number(usage?.output_tokens) || 0;
+  const reasoning = Number(usage?.reasoning_output_tokens) || 0;
+  const cacheRead = Number(usage?.cache_read_input_tokens) || 0;
+  const cacheWrite = Number(usage?.cache_creation_input_tokens) || 0;
+  const declared5m = Number(usage?.cache_creation?.ephemeral_5m_input_tokens) || 0;
+  const declared1h = Number(usage?.cache_creation?.ephemeral_1h_input_tokens) || 0;
+  const cacheWrite5m = declared5m + Math.max(0, cacheWrite - declared5m - declared1h);
+  const rates = ratesFor(model, agent);
+  return (
+    input * rates.input
+    + (output + reasoning) * rates.output
+    + cacheRead * rates.cacheRead
+    + cacheWrite5m * rates.cacheWrite5m
+    + declared1h * rates.cacheWrite1h
+  ) / 1_000_000;
+}

package/server/public-report-schema.mjs

@@ -36,6 +36,44 @@ function safeStockPhrases(value) {
   return stockPhraseLabels.map((phrase) => ({ phrase, count: counts.get(phrase) || 0 }));
 }
 
+function safeRepeatedInstructions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 4).flatMap((item) => {
+    const instruction = safeText(item?.instruction, 160).trim();
+    const occurrences = Math.round(safeNumber(item?.occurrences, 1_000_000));
+    const distinctSessions = Math.round(safeNumber(item?.distinctSessions, 1_000_000));
+    if (!instruction || occurrences < 2 || distinctSessions < 1 || distinctSessions > occurrences) return [];
+    if (/\[(?:REDACTED|REMOVED)[^\]]*\]|https?:\/\/|(?:\/Users\/|\/home\/)|```|<[^>]+>|[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(instruction)) return [];
+    return [{ instruction, occurrences, distinctSessions }];
+  });
+}
+
+function safeTrustCurve(value) {
+  if (!value || typeof value !== "object" || !Array.isArray(value.points)) return null;
+  let previousOffset = -1;
+  const points = value.points.slice(0, 4_000).flatMap((item) => {
+    const dayOffset = Math.round(safeNumber(item?.dayOffset, 3_650));
+    const score = safeNumber(item?.score, 100);
+    const observations = Math.round(safeNumber(item?.observations, 1_000_000));
+    if (dayOffset <= previousOffset || observations < 1) return [];
+    previousOffset = dayOffset;
+    return [{ dayOffset, score: Number(score.toFixed(1)), observations }];
+  });
+  if (points.length < 2) return null;
+  const observations = Math.round(safeNumber(value.observations, 10_000_000));
+  const autonomousObservations = Math.round(safeNumber(value.autonomousObservations, observations));
+  if (!observations || autonomousObservations > observations) return null;
+  return {
+    points,
+    startScore: points[0].score,
+    endScore: points.at(-1).score,
+    change: Number((points.at(-1).score - points[0].score).toFixed(1)),
+    observations,
+    autonomousObservations,
+    autonomousPercentage: Number((autonomousObservations / observations * 100).toFixed(1)),
+  };
+}
+
 export function sanitizePublicReport(value) {
   if (!value || typeof value !== "object" || Array.isArray(value) || !/^[A-Za-z0-9_-]{8,32}$/.test(value.id || "")) return null;
   const stats = value.stats;
@@ -52,6 +90,12 @@ export function sanitizePublicReport(value) {
   const safeTokenBreakdown = tokenBreakdown && Object.values(tokenBreakdown).reduce((sum, count) => sum + count, 0) === safeTokens ? tokenBreakdown : null;
   const safeStockPhraseCounts = safeStockPhrases(stats.stockPhrases);
   const safeSessionTurnCounts = safeTurnCounts(stats.sessionTurnCounts);
+  const runAgent = allowedAgents.has(stats.longestUninterruptedRun?.agent) ? stats.longestUninterruptedRun.agent : null;
+  const safeLongestUninterruptedRun = runAgent && safeNumber(stats.longestUninterruptedRun?.durationMs, 7 * 24 * 60 * 60 * 1000) > 0 ? {
+    durationMs: Math.round(safeNumber(stats.longestUninterruptedRun.durationMs, 7 * 24 * 60 * 60 * 1000)),
+    agent: runAgent,
+    agentName: safeText(stats.longestUninterruptedRun?.agentName, 30),
+  } : null;
   const phrase = value.phraseCard?.phrase;
   const safePhrase = typeof phrase === "string" && /^[a-z]+(?:'[a-z]+)?(?: [a-z]+(?:'[a-z]+)?){3,9}$/.test(phrase) ? {
     phrase,
@@ -90,16 +134,29 @@ export function sanitizePublicReport(value) {
       sessions: Math.round(safeNumber(stats.sessions, 1_000_000)), activeDays: Math.round(safeNumber(stats.activeDays, 1_000_000)),
       durationMinutes: Math.round(safeNumber(stats.durationMinutes)), prompts: Math.round(safeNumber(stats.prompts)), toolCalls: Math.round(safeNumber(stats.toolCalls)),
       interruptions: Math.round(safeNumber(stats.interruptions)), tokens: safeTokens, ...(safeTokenBreakdown ? { tokenBreakdown: safeTokenBreakdown } : {}), agentWords: Math.round(safeNumber(stats.agentWords)),
+      interruptionsByModel: Array.isArray(stats.interruptionsByModel) ? stats.interruptionsByModel.slice(0, 10).flatMap((item) => {
+        const model = safeText(item?.model, 80);
+        const name = safeText(item?.name, 80);
+        const count = Math.round(safeNumber(item?.count, 1_000_000));
+        return model && name && count > 0 ? [{ model, name, count }] : [];
+      }) : [],
       userWords: Math.round(safeNumber(stats.userWords)), agentUserWordRatio: safeNumber(stats.agentUserWordRatio, 10_000),
       averageAgentResponseWords: Math.round(safeNumber(stats.averageAgentResponseWords)), averageUserInputWords: Math.round(safeNumber(stats.averageUserInputWords)),
       longestSessionTurns: Math.max(0, ...safeSessionTurnCounts),
       sessionTurnCounts: safeSessionTurnCounts,
+      longestUninterruptedRun: safeLongestUninterruptedRun,
+      trustCurve: safeTrustCurve(stats.trustCurve),
       interactionTone: {
         frustratedMessages: Math.round(safeNumber(stats.interactionTone?.frustratedMessages, 1_000_000)),
         gratefulMessages: Math.round(safeNumber(stats.interactionTone?.gratefulMessages, 1_000_000)),
         analyzedMessages: Math.round(safeNumber(stats.interactionTone?.analyzedMessages, 1_000_000)),
       },
+      apologyCounts: {
+        user: Math.round(safeNumber(stats.apologyCounts?.user, 1_000_000)),
+        agent: Math.round(safeNumber(stats.apologyCounts?.agent, 1_000_000)),
+      },
       ...(safeStockPhraseCounts ? { stockPhrases: safeStockPhraseCounts } : {}),
+      repeatedInstructions: safeRepeatedInstructions(stats.repeatedInstructions),
       outputLanguages: safeBreakdown(stats.outputLanguages, "language", "words", allowedLanguages),
       languageAnomaly: safeLanguageAnomaly,
       topics: safeBreakdown(stats.topics, "topic", "tokens", new Set(["Coding", "Writing", "Personal advice", "Research & search", "Planning", "Data & analysis", "Other"])),