behavior-wrapped 0.8.14 → 0.9.1

package/server/launcher.mjs

@@ -25,14 +25,32 @@ const portArg = process.argv.find((arg) => arg.startsWith("--port="));
 const port = Number(portArg?.split("=")[1] || 4317);
 const configuredIdleMs = Number(process.env.BEHAVIOR_WRAPPED_HELPER_IDLE_MS);
 const helperIdleMs = Number.isFinite(configuredIdleMs) && configuredIdleMs >= 100 ? configuredIdleMs : 5 * 60 * 1_000;
-let catalog = await loadCatalog();
+const configuredTestCatalogDelayMs = process.env.NODE_ENV === "test" ? Number(process.env.BEHAVIOR_WRAPPED_TEST_CATALOG_DELAY_MS) : 0;
+const testCatalogDelayMs = Number.isFinite(configuredTestCatalogDelayMs) && configuredTestCatalogDelayMs > 0 ? configuredTestCatalogDelayMs : 0;
+let catalog = null;
+let catalogPromise = null;
 
 async function loadCatalog() {
+  if (testCatalogDelayMs) await new Promise((resolve) => setTimeout(resolve, testCatalogDelayMs));
   const found = await discoverAllSessionsAsync(demo ? { claudeRoot: fixtureRoot, coworkRoot: coworkFixtureRoot, codexRoots: [codexFixtureRoot], cache: false } : undefined);
   if (demo) found.sessions = found.sessions.map((session, index) => ({ ...session, synthetic: true, label: `Demo session ${index + 1}` }));
   return found;
 }
 
+async function catalogForRequest({ refresh = false } = {}) {
+  if (refresh || !catalogPromise) {
+    const loading = loadCatalog();
+    catalogPromise = loading;
+    try {
+      catalog = await loading;
+    } catch (error) {
+      if (catalogPromise === loading) catalogPromise = null;
+      throw error;
+    }
+  }
+  return catalogPromise;
+}
+
 function securityHeaders(extra = {}) {
   return {
     "X-Content-Type-Options": "nosniff",
@@ -71,23 +89,24 @@ function readBody(request, maximumBytes = 1_000_000) {
   });
 }
 
-async function chosenRecords(ids, options = {}) {
+async function chosenRecords(ids, options = {}, activeCatalog = null) {
+  const availableCatalog = activeCatalog || await catalogForRequest();
   const selected = [];
   for (const id of ids) {
-    const session = catalog.index.get(id);
+    const session = availableCatalog.index.get(id);
     if (session) selected.push({ sessionId: id, agent: session.agent, records: await readRecordsAsync(session.file, session.agent, options) });
   }
   return selected;
 }
 
-function publicCatalog() {
+function publicCatalog(availableCatalog) {
   const agentNames = supportedAgentNames(process.platform, { includeCowork: demo || process.platform === "darwin" });
   return {
-    rootAvailable: catalog.rootAvailable,
+    rootAvailable: availableCatalog.rootAvailable,
     demo,
-    projects: catalog.projects,
-    sessions: catalog.sessions.map((session, index) => ({ ...session, label: session.label || `Session ${index + 1}` })),
-    defaultRange: defaultDateRange(catalog.sessions, { days: DEFAULT_WINDOW_DAYS, anchorLatest: demo }),
+    projects: availableCatalog.projects,
+    sessions: availableCatalog.sessions.map((session, index) => ({ ...session, label: session.label || `Session ${index + 1}` })),
+    defaultRange: defaultDateRange(availableCatalog.sessions, { days: DEFAULT_WINDOW_DAYS, anchorLatest: demo }),
     agentNames,
     privacy: { canonicalDirectories: canonicalSessionDirectoryLabels(), networkRequests: "only-after-final-donation-consent" },
   };
@@ -99,10 +118,10 @@ const server = http.createServer(async (request, response) => {
     if (!new Set([`127.0.0.1:${port}`, `localhost:${port}`]).has(request.headers.host || "")) return json(response, 403, { error: "Local access only" });
     idleShutdown.touch();
     const url = new URL(request.url || "/", `http://${request.headers.host}`);
-    if (request.method === "GET" && url.pathname === "/api/health") return json(response, 200, { app: "behavior-wrapped", version: APP_VERSION, local: true, purpose: "research-donation", donationProtocol: LOCAL_DONATION_PROTOCOL, pid: process.pid, demo });
+    if (request.method === "GET" && url.pathname === "/api/health") return json(response, 200, { app: "behavior-wrapped", version: APP_VERSION, local: true, purpose: "research-donation", donationProtocol: LOCAL_DONATION_PROTOCOL, pid: process.pid, demo, catalogState: catalog ? "ready" : catalogPromise ? "loading" : "not-loaded" });
     if (request.method === "GET" && url.pathname === "/api/discover") {
-      catalog = await loadCatalog();
-      return json(response, 200, publicCatalog());
+      const availableCatalog = await catalogForRequest({ refresh: true });
+      return json(response, 200, publicCatalog(availableCatalog));
     }
     const reportMatch = url.pathname.match(/^\/api\/reports\/([A-Za-z0-9_-]{8,32})$/);
     if (request.method === "GET" && reportMatch) {
@@ -116,39 +135,43 @@ const server = http.createServer(async (request, response) => {
     if (request.method === "GET" && selectionMatch) {
       const report = loadReport(selectionMatch[1]);
       if (!report) return json(response, 404, { error: "Saved report not found" });
-      const available = new Set(catalog.sessions.map((session) => session.id));
+      const availableCatalog = await catalogForRequest();
+      const available = new Set(availableCatalog.sessions.map((session) => session.id));
       return json(response, 200, { sessionIds: (report.sessionIds || []).filter((id) => available.has(id)), localPrivateSelection: true });
     }
     const workaroundEvidenceMatch = url.pathname.match(/^\/api\/reports\/([A-Za-z0-9_-]{8,32})\/workarounds$/);
     if (request.method === "GET" && workaroundEvidenceMatch) {
       const report = loadReport(workaroundEvidenceMatch[1]);
       if (!report) return json(response, 404, { error: "Saved report not found" });
+      const availableCatalog = await catalogForRequest();
       const allowed = new Set(report.sessionIds || []);
-      const ids = [...new Set((report.workaroundReview?.occurrences || []).map((occurrence) => occurrence?.location?.sessionId).filter((id) => allowed.has(id) && catalog.index.has(id)))].slice(0, 100);
-      const records = await chosenRecords(ids, { includePrivateToolDetails: true });
-      const labels = new Map(publicCatalog().sessions.map((session) => [session.id, session]));
+      const ids = [...new Set((report.workaroundReview?.occurrences || []).map((occurrence) => occurrence?.location?.sessionId).filter((id) => allowed.has(id) && availableCatalog.index.has(id)))].slice(0, 100);
+      const records = await chosenRecords(ids, { includePrivateToolDetails: true }, availableCatalog);
+      const labels = new Map(publicCatalog(availableCatalog).sessions.map((session) => [session.id, session]));
       return json(response, 200, makeWorkaroundEvidencePreview(report, records, labels));
     }
     const interactionEvidenceMatch = url.pathname.match(/^\/api\/reports\/([A-Za-z0-9_-]{8,32})\/interactions$/);
     if (request.method === "GET" && interactionEvidenceMatch) {
       const report = loadReport(interactionEvidenceMatch[1]);
       if (!report) return json(response, 404, { error: "Saved report not found" });
+      const availableCatalog = await catalogForRequest();
       const allowed = new Set(report.sessionIds || []);
       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]));
+      const ids = [...new Set(references.map((reference) => reference?.location?.sessionId).filter((id) => allowed.has(id) && availableCatalog.index.has(id)))].slice(0, 200);
+      const records = await chosenRecords(ids, {}, availableCatalog);
+      const labels = new Map(publicCatalog(availableCatalog).sessions.map((session) => [session.id, session]));
       return json(response, 200, makeInteractionEvidencePreview(report, records, labels));
     }
     if (request.method === "POST" && url.pathname === "/api/donation-preview") {
       const body = await readBody(request);
       const report = loadReport(body.reportId);
       if (!report) return json(response, 404, { error: "Saved report not found" });
+      const availableCatalog = await catalogForRequest();
       const allowed = new Set(report.sessionIds || []);
-      const ids = Array.isArray(body.sessionIds) ? body.sessionIds.filter((id) => allowed.has(id) && catalog.index.has(id)).slice(0, 250) : [];
-      const records = await chosenRecords(ids);
+      const ids = Array.isArray(body.sessionIds) ? body.sessionIds.filter((id) => allowed.has(id) && availableCatalog.index.has(id)).slice(0, 250) : [];
+      const records = await chosenRecords(ids, {}, availableCatalog);
       if (!records.length) return json(response, 400, { error: "Choose at least one available session." });
-      const labels = new Map(publicCatalog().sessions.map((session) => [session.id, session]));
+      const labels = new Map(publicCatalog(availableCatalog).sessions.map((session) => [session.id, session]));
       const disabledRedactions = Array.isArray(body.disabledRedactions) ? body.disabledRedactions.filter((kind) => typeof kind === "string" && /^[a-z0-9-]{1,64}$/.test(kind)).slice(0, 20) : [];
       const disabledMatches = Array.isArray(body.disabledMatches) ? body.disabledMatches.filter((id) => typeof id === "string" && /^[a-f0-9]{24}$/.test(id)).slice(0, 5_000) : [];
       const unredacted = body.previewMode === "unredacted";

package/server/leaderboard.mjs

@@ -1,4 +1,5 @@
 import { BEHAVIOR_WRAPPED_ORIGIN } from "./origins.mjs";
+import { buildSessionLengthDistribution } from "./session-length-distribution.mjs";
 export const LEADERBOARD_RELAY_ORIGIN = BEHAVIOR_WRAPPED_ORIGIN;
 const REQUEST_TIMEOUT_MS = 15_000;
 const demoTokens = [820_000, 2_400_000, 8_900_000, 14_300_000, 31_000_000, 47_500_000, 83_000_000, 126_000_000, 210_000_000, 380_000_000, 620_000_000, 940_000_000];
@@ -88,7 +89,7 @@ export function syntheticLeaderboardSnapshot(aggregate, participation = null) {
     },
     session_lengths: {
       values: aggregate.session_turn_counts,
-      samples: demoSessionTurnCounts.flatMap((values, participantIndex) => values.map((value, sessionIndex) => ({ participant_id: participantIndex + 1, session_index: sessionIndex, value }))),
+      distribution: buildSessionLengthDistribution(demoSessionTurnCounts.flat()),
     },
     phrases: {
       entries: aggregate.favorite_phrase ? [{ participant_id: 1, phrase: aggregate.favorite_phrase, occurrences: aggregate.phrase_occurrences, sessions: aggregate.phrase_sessions }] : [],

package/server/phrase-card.mjs

@@ -208,6 +208,14 @@ export function buildLocalPhraseCard(candidates) {
   });
 }
 
+export async function phraseCardWithLocalFallback(candidates, judgedCard, { onFallback } = {}) {
+  try { return await judgedCard; }
+  catch (error) {
+    onFallback?.(error);
+    return buildLocalPhraseCard(candidates);
+  }
+}
+
 function timeoutMessage(error, timeoutMs) {
   if (error?.name === "TimeoutError" || error?.name === "AbortError") return new Error(`${PHRASE_JUDGE_NAME} timed out after ${Math.round(timeoutMs / 1000)} seconds.`);
   return error;

package/server/public-report-schema.mjs

@@ -19,7 +19,7 @@ function safeBreakdown(value, labelKey, countKey, allowedLabels) {
   });
 }
 
-const stockPhraseLabels = ["You're right", "Say the word", "genuinely", "one wrinkle", "load bearing", "the full picture", "delve"];
+const stockPhraseLabels = ["You're right", "Say the word", "genuinely", "one wrinkle", "load bearing", "full picture", "the full picture", "delve"];
 const allowedAgents = new Set(["claude", "cowork", "codex"]);
 
 function safeTurnCounts(value) {

package/server/session-length-distribution.mjs

@@ -0,0 +1,74 @@
+const MAX_SESSION_TURNS = 1_000_000;
+const CONTOUR_POINT_COUNT = 64;
+
+function validSessionTurns(values) {
+  return Array.isArray(values)
+    ? values.flatMap((value) => Number.isInteger(value) && value >= 1 && value <= MAX_SESSION_TURNS ? [value] : [])
+    : [];
+}
+
+function median(values) {
+  const sorted = [...values].sort((left, right) => left - right);
+  if (!sorted.length) return 0;
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+
+export function buildSessionLengthDistribution(values) {
+  const sessions = validSessionTurns(values);
+  if (!sessions.length) return { session_count: 0, median_turns: 0, min_turns: 0, max_turns: 0, points: [] };
+
+  const logs = sessions.map((value) => Math.log10(value));
+  const observedMinimum = Math.min(...logs);
+  const observedMaximum = Math.max(...logs);
+  const observedSpan = observedMaximum - observedMinimum;
+  const padding = Math.max(.12, observedSpan * .08);
+  const domainMinimum = Math.max(0, observedMinimum - padding);
+  const domainMaximum = Math.max(domainMinimum + .32, observedMaximum + padding);
+  const mean = logs.reduce((sum, value) => sum + value, 0) / logs.length;
+  const variance = logs.reduce((sum, value) => sum + (value - mean) ** 2, 0) / logs.length;
+  const deviation = Math.sqrt(variance);
+  const bandwidth = Math.max(.08, Math.min(.32, 1.06 * (deviation || .18) * logs.length ** -.2));
+  const raw = Array.from({ length: CONTOUR_POINT_COUNT }, (_, index) => {
+    const position = domainMinimum + index / (CONTOUR_POINT_COUNT - 1) * (domainMaximum - domainMinimum);
+    const density = logs.reduce((sum, value) => sum + Math.exp(-.5 * ((position - value) / bandwidth) ** 2), 0) / logs.length;
+    return { turns: 10 ** position, density };
+  });
+  const maximumDensity = Math.max(...raw.map((point) => point.density), Number.EPSILON);
+
+  return {
+    session_count: sessions.length,
+    median_turns: Number(median(sessions).toFixed(1)),
+    min_turns: Math.min(...sessions),
+    max_turns: Math.max(...sessions),
+    points: raw.map((point) => ({
+      turns: Number(point.turns.toPrecision(7)),
+      density: Number((point.density / maximumDensity).toFixed(4)),
+    })),
+  };
+}
+
+export function parseSessionLengthDistribution(value) {
+  let parsed;
+  try { parsed = typeof value === "string" ? JSON.parse(value) : value; }
+  catch { return null; }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const sessionCount = Number(parsed.session_count);
+  const medianTurns = Number(parsed.median_turns);
+  const minTurns = Number(parsed.min_turns);
+  const maxTurns = Number(parsed.max_turns);
+  if (![sessionCount, medianTurns, minTurns, maxTurns].every(Number.isFinite)) return null;
+  if (!Number.isInteger(sessionCount) || sessionCount < 0 || sessionCount > 100_000_000) return null;
+  if (sessionCount === 0) return parsed.points?.length === 0 ? { session_count: 0, median_turns: 0, min_turns: 0, max_turns: 0, points: [] } : null;
+  if (medianTurns < 1 || minTurns < 1 || maxTurns < minTurns || maxTurns > MAX_SESSION_TURNS || medianTurns > maxTurns) return null;
+  if (!Array.isArray(parsed.points) || parsed.points.length !== CONTOUR_POINT_COUNT) return null;
+  let previousTurns = 0;
+  const points = parsed.points.flatMap((point) => {
+    const turns = Number(point?.turns);
+    const density = Number(point?.density);
+    if (!Number.isFinite(turns) || turns <= previousTurns || turns < 1 || turns > MAX_SESSION_TURNS * 2 || !Number.isFinite(density) || density < 0 || density > 1) return [];
+    previousTurns = turns;
+    return [{ turns, density }];
+  });
+  return points.length === CONTOUR_POINT_COUNT ? { session_count: sessionCount, median_turns: medianTurns, min_turns: minTurns, max_turns: maxTurns, points } : null;
+}