Rank annotated action references by numeric similarity

src/agent-session.ts

@@ -4,6 +4,32 @@ import { env } from "./config.js";
 type ActionResult = { id: string; label: string; rawAnalytics?: Record<string, unknown>; inActionMetrics?: { name: string; value: unknown; unit?: string }[] };
 type SessionResult = { id: string; playerId: string; actions: ActionResult[] };
 
+function numericMetrics(action: ActionResult) {
+  const values = new Map<string, number>();
+  const metrics = [...Object.entries(action.rawAnalytics ?? {}).map(([name, value]) => ({ name, value })), ...(action.inActionMetrics ?? [])];
+  for (const metric of metrics) {
+    const name = metric.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (!name || name === "ballspeed" || /frames?$/.test(name)) continue;
+    if (typeof metric.value === "number" && Number.isFinite(metric.value)) values.set(name, metric.value);
+  }
+  return values;
+}
+
+export function actionDistance(current: ActionResult, reference: ActionResult) {
+  const target = numericMetrics(current);
+  const values = numericMetrics(reference);
+  if (!target.size) return null;
+  let error = 0;
+  let shared = 0;
+  for (const [name, value] of target) {
+    const other = values.get(name);
+    if (other === undefined) { error++; continue; }
+    error += ((value - other) / Math.max(Math.abs(value), Math.abs(other), 1)) ** 2;
+    shared++;
+  }
+  return shared ? Math.sqrt(error / target.size) : null;
+}
+
 function ageContext(profile: Record<string, unknown>) {
   const value = profile.bdate;
   if (typeof value !== "string") return profile;
@@ -28,6 +54,61 @@ export async function analysisResults(sessionId: string, userId: string, isAdmin
   return await response.json() as SessionResult;
 }
 
+export async function actionReferences(db: SupabaseClient, current: ActionResult, actionType: string, currentSession?: SessionResult) {
+  const closest = [];
+  if (!numericMetrics(current).size) return [];
+  const referenceResults = new Map<string, ActionResult[] | null>();
+  if (currentSession) referenceResults.set(currentSession.id, currentSession.actions);
+  for (let from = 0; ; from += 100) {
+    const { data: examples, error: examplesError } = await db.from("annotations")
+      .select("action_id,score,annotations_notes!inner(note),actions!inner(action_id,session_id,type,sessions!inner(user_id,player_id,players!inner(gender,bdate,height,weight,position)))")
+      .eq("actions.type", actionType)
+      .neq("action_id", current.id)
+      .order("action_id").range(from, from + 99);
+    if (examplesError) throw new Error(`Unable to load human annotations: ${examplesError.message}`);
+    const referenceRows = (examples ?? []).filter((row: any) =>
+      (row.annotations_notes ?? []).some((note: { note: string }) => typeof note.note === "string" && note.note.trim().length > 0))
+      .map((row: any) => ({ ...row, actions: Array.isArray(row.actions) ? row.actions[0] : row.actions }));
+    const sessions = new Map<string, string>();
+    for (const row of referenceRows) {
+      const related = row.actions;
+      if (related?.session_id && related.sessions?.user_id && !referenceResults.has(related.session_id)) {
+        sessions.set(related.session_id, related.sessions.user_id);
+      }
+    }
+    const pending = [...sessions];
+    for (let offset = 0; offset < pending.length; offset += 5) {
+      await Promise.all(pending.slice(offset, offset + 5).map(async ([id, ownerId]) => {
+        try {
+          const result = await analysisResults(id, ownerId);
+          referenceResults.set(id, result.actions.map(({ id, label, rawAnalytics, inActionMetrics }) => ({ id, label, rawAnalytics, inActionMetrics })));
+        } catch (error) {
+          referenceResults.set(id, null);
+          console.warn("Skipping unavailable annotation reference results", { sessionId: id, error });
+        }
+      }));
+    }
+    for (const row of referenceRows) {
+      const related = row.actions;
+      const refPlayerValue = related?.sessions?.players;
+      const rawPlayer = Array.isArray(refPlayerValue) ? refPlayerValue[0] : refPlayerValue;
+      const refPlayer = rawPlayer ? ageContext(rawPlayer as Record<string, unknown>) : rawPlayer;
+      const refActions = related?.session_id ? referenceResults.get(related.session_id) : undefined;
+      const refAction = refActions?.find((item) => item.id === row.action_id);
+      if (!related || !refPlayer || !refAction || refAction.label.toLowerCase() !== actionType.toLowerCase()) continue;
+      const distance = actionDistance(current, refAction);
+      if (distance === null) continue;
+      closest.push({ distance, reference: { session_id: related.session_id, action_id: row.action_id, action_type: related.type, player: refPlayer,
+        results: { metrics: refAction.inActionMetrics ?? [], analytics: refAction.rawAnalytics ?? {} },
+        score: row.score, notes: (row.annotations_notes ?? []).map((note: { note: string }) => note.note).filter((note: string) => typeof note === "string" && note.trim()) } });
+    }
+    closest.sort((a, b) => a.distance - b.distance || a.reference.action_id.localeCompare(b.reference.action_id));
+    closest.splice(5);
+    if ((examples ?? []).length < 100) break;
+  }
+  return closest.map((item) => item.reference);
+}
+
 export async function generateSessionFeedback(db: SupabaseClient, sessionId: string, userId: string) {
   if (!env.AGENT_API_URL || !env.AGENT_API_KEY) throw new Error("Agent service is not configured");
   const { data: session, error: sessionError } = await db.from("sessions")
@@ -38,11 +119,6 @@ export async function generateSessionFeedback(db: SupabaseClient, sessionId: str
   const player = rawPlayer ? ageContext(rawPlayer as Record<string, unknown>) : rawPlayer;
   if (!player) throw new Error("Session player context is missing");
   const result = await analysisResults(sessionId, userId);
-  const { data: ownedSessions, error: ownedSessionsError } = await db.from("sessions")
-    .select("session_id").eq("user_id", userId);
-  if (ownedSessionsError) throw new Error(`Unable to load owned session references: ${ownedSessionsError.message}`);
-  const ownedSessionIds = (ownedSessions ?? []).map((row) => row.session_id);
-  if (!ownedSessionIds.length) return;
   const actionResults = new Map(result.actions.map((action) => [action.id, action]));
   const { data: currentActions, error: actionsError } = await db.from("actions")
     .select("action_id,type").eq("session_id", sessionId);
@@ -52,32 +128,7 @@ export async function generateSessionFeedback(db: SupabaseClient, sessionId: str
   for (const action of currentActions ?? []) {
     const current = actionResults.get(action.action_id);
     if (!current) continue;
-    const { data: examples, error: examplesError } = await db.from("annotations")
-      .select("action_id,score,annotations_notes(note),actions!inner(action_id,session_id,type,sessions!inner(player_id,players!inner(gender,bdate,height,weight,position)))")
-      .eq("actions.type", action.type)
-      .in("actions.session_id", ownedSessionIds)
-      .neq("action_id", action.action_id)
-      .limit(5);
-    if (examplesError) throw new Error(`Unable to load human annotations: ${examplesError.message}`);
-    const referenceRows = (examples ?? []).filter((row: any) =>
-      row.score !== null || (row.annotations_notes ?? []).some((note: { note: string }) => typeof note.note === "string" && note.note.trim().length > 0));
-    const referenceSessionIds = [...new Set(referenceRows.map((row: any) => row.actions?.session_id).filter(Boolean))] as string[];
-    const referenceResults = new Map<string, SessionResult>();
-    await Promise.all(referenceSessionIds.map(async (id) => {
-      try { referenceResults.set(id, await analysisResults(id, userId)); }
-      catch (error) { console.warn("Skipping unavailable annotation reference results", { sessionId: id, error }); }
-    }));
-    const references = referenceRows.flatMap((row: any) => {
-      const related = Array.isArray(row.actions) ? row.actions[0] : row.actions;
-      const refPlayerValue = related?.sessions?.players;
-      const refPlayer = refPlayerValue ? ageContext(refPlayerValue as Record<string, unknown>) : refPlayerValue;
-      const refSession = related?.session_id ? referenceResults.get(related.session_id) : undefined;
-      const refAction = refSession?.actions.find((item) => item.id === row.action_id);
-      if (!related || !refPlayer || !refAction) return [];
-      return [{ action_id: row.action_id, action_type: related.type, player: refPlayer,
-        results: { metrics: refAction.inActionMetrics ?? [], analytics: refAction.rawAnalytics ?? {} },
-        score: row.score, notes: (row.annotations_notes ?? []).map((note: { note: string }) => note.note) }];
-    });
+    const references = await actionReferences(db, current, action.type, result);
     actions.push({ action_id: action.action_id, action_type: action.type,
       results: { metrics: current.inActionMetrics ?? [], analytics: current.rawAnalytics ?? {} }, references });
   }

src/server.ts

@@ -9,7 +9,7 @@ import { pipeline } from "node:stream/promises";
 import { z } from "zod";
 import { authPublicOrigin, env } from "./config.js";
 import { analysisRouter } from "./analysis.js";
-import { analysisResults, generateSessionFeedback } from "./agent-session.js";
+import { actionReferences, analysisResults, generateSessionFeedback } from "./agent-session.js";
 import { authenticatedUser, clearPasswordRecoveryCookie, clearSessionCookies, hasPasswordRecoveryCookie, safeRedirect, setPasswordRecoveryCookie, setSessionCookies } from "./auth.js";
 import { hashPassword, oauthClient, supabaseAdmin, supabaseAuth, syncProfile, userHasPassword, userPayload } from "./supabase.js";
 import { registerProfileImageRoutes } from "./profile-images.js";
@@ -831,8 +831,10 @@ app.post("/api/agent/chat", async (req, res, next) => {
         const results = await analysisResults(input.sessionId, current.user.id, isAdmin);
         const measured = results.actions.find((item) => item.id === input.actionId);
         if (!measured) return res.status(404).json({ error: "Analysis results for this action are unavailable." });
+        const references = await actionReferences(supabaseAdmin, measured, action.type, results);
         context.action = { ...action,
           results: { metrics: measured.inActionMetrics ?? [], analytics: measured.rawAnalytics ?? {} },
+          references,
           feedback: (feedback ?? []).map((row) => row.feedback) };
       }
     }

tests/agent-chat.test.ts

@@ -5,27 +5,59 @@ import { createServer, type IncomingHttpHeaders } from "node:http";
 import type { AddressInfo } from "node:net";
 import { test } from "node:test";
 
-test("action chat sends current measurements on every message and preserves access checks", { timeout: 30_000 }, async () => {
+test("action chat sends measurements and annotated references on every message and preserves access checks", { timeout: 30_000 }, async () => {
   const owner = "11111111-1111-4111-8111-111111111111";
   const other = "22222222-2222-4222-8222-222222222222";
   const sessionId = "33333333-3333-4333-8333-333333333333";
   const actionId = "44444444-4444-4444-8444-444444444444";
   const otherActionId = "55555555-5555-4555-8555-555555555555";
+  const referenceSessionId = "77777777-7777-4777-8777-777777777777";
+  const foreignSessionId = "88888888-8888-4888-8888-888888888888";
   const analytics = { foot_region: "Toe", active_foot_speed: 1232.04, standing_foot_contact_seconds: 0,
-    minimum_knee_angle: null, future_metric: false };
+    ball_speed: 1303.31, touch_frame: 766, minimum_knee_angle: null, future_metric: false };
   const measured = { id: actionId, label: "Pass", rawAnalytics: analytics,
     inActionMetrics: Object.entries(analytics).map(([name, value]) => ({ name, value, unit: name === "active_foot_speed" ? "cm/s" : "" })) };
-  const otherMeasured = { id: otherActionId, label: "Shoot", rawAnalytics: { ball_speed: 1303.31 },
-    inActionMetrics: [{ name: "Ball Speed", value: 1303.31, unit: "cm/s" }] };
+  const otherMeasured = { id: otherActionId, label: "Shoot", rawAnalytics: { ball_speed: 1303.31, active_foot_speed: 1232.04 },
+    inActionMetrics: [{ name: "Ball Speed", value: 1303.31, unit: "cm/s" }, { name: "Active Foot Speed", value: 1232.04, unit: "cm/s" }] };
   let role = "user";
   let sessionOwner = owner;
   let resultsAvailable = true;
   let analysisStatus = 200;
   let analysisReads = 0;
   let analysisHeaders: IncomingHttpHeaders = {};
+  let savedFeedbackAvailable = false;
+  let referencesAvailable = true;
+  let annotationsFail = false;
+  let referenceResultsAvailable = true;
+  let referenceReads = 0;
+  let mutations = 0;
+  const referenceAnalytics = { active_foot: "left", ball_speed: 1303.31, active_foot_speed: 1232.04, standing_foot_contact_seconds: 0, touch_frame: 999999 };
+  const offsets: Record<string, number> = { "00-blank": 0, "02-reference": 0, "00-foreign": 5, "03-reference": 300,
+    "04-reference": 200, "05-reference": 100, "06-reference": 50, "07-reference": 20, "08-reference": 10, "zz-late": 1, "zz-wrong-report": 0 };
+  const referenceUsers = new Set<string>();
+  const reference = (id: string, type = "Pass", userId = owner, score: number | null = 7, notes = ["Reference coach note."]) => ({
+    action_id: id, score, annotations_notes: notes.map((note) => ({ note })),
+    actions: { action_id: id, session_id: userId === owner ? referenceSessionId : foreignSessionId, type,
+      sessions: { user_id: userId, players: { gender: "female", bdate: "2000-01-01", height: 170, weight: 65, position: "Forward" } } },
+  });
+  const examples = [reference(actionId), reference("00-foreign", "Pass", other, null), reference("shoot-reference", "Shoot"),
+    reference("00-blank", "Pass", owner, null, ["  "]), reference("01-empty"), reference("01-missing"),
+    reference("02-reference", "Pass", owner, 0, []), reference("03-reference", "Pass", owner, null),
+    ...Array.from({ length: 5 }, (_, index) => reference(`${String(index + 4).padStart(2, "0")}-reference`)),
+    ...Array.from({ length: 110 }, (_, index) => reference(`far-${String(index).padStart(3, "0")}`)),
+    reference("zz-late", "Pass", other, 0), reference("zz-no-common"), reference("zz-wrong-report")];
+  const referenceReport = (item: ReturnType<typeof reference>) => {
+    const rawAnalytics: Record<string, unknown> = item.action_id === "01-empty" ? {} : item.action_id === "zz-no-common" ? { unrelated_metric: 42 }
+      : { ...referenceAnalytics, active_foot_speed: referenceAnalytics.active_foot_speed + (offsets[item.action_id] ?? 500) };
+    return { id: item.action_id, label: item.action_id === "zz-wrong-report" ? "Shoot" : item.actions.type, rawAnalytics,
+      inActionMetrics: Object.entries(rawAnalytics).map(([name, value]) => ({ name, value, unit: "" })) };
+  };
+  type Reference = { session_id: string; action_id: string; action_type: string; player: { gender: string }; score: number | null; notes: string[];
+    results: { metrics: unknown[]; analytics: unknown } };
   type ChatPayload = { actions: unknown[]; message: string; history: unknown[];
-    context: { action?: { action_id: string; results: { metrics: unknown[]; analytics: unknown }; feedback: string[]; annotations: unknown }; actions?: unknown[] } };
+    context: { action?: { action_id: string; results: { metrics: unknown[]; analytics: unknown }; references: Reference[]; feedback: string[]; annotations: unknown }; actions?: unknown[] } };
   const chats: ChatPayload[] = [];
+  const generations: { actions: { action_id: string; references: Reference[] }[] }[] = [];
   const upstream = createServer(async (req, res) => {
     const url = new URL(req.url!, "http://stub");
     res.setHeader("Content-Type", "application/json");
@@ -36,24 +68,54 @@ test("action chat sends current measurements on every message and preserves acce
       res.statusCode = analysisStatus;
       return res.end(JSON.stringify({ id: sessionId, actions: resultsAvailable ? [otherMeasured, measured] : [] }));
     }
+    if ([`/api/sessions/${referenceSessionId}`, `/api/sessions/${foreignSessionId}`].includes(url.pathname)) {
+      referenceReads++;
+      const id = url.pathname.split("/").at(-1);
+      const expectedOwner = id === referenceSessionId ? owner : other;
+      referenceUsers.add(String(req.headers["x-sporalize-user-id"]));
+      if (req.headers["x-sporalize-user-id"] !== expectedOwner) {
+        res.statusCode = 403;
+        return res.end("{}");
+      }
+      res.statusCode = referenceResultsAvailable ? 200 : 503;
+      return res.end(JSON.stringify({ id, actions: examples.filter((item) => item.action_id !== "01-missing" && item.actions.session_id === id).map(referenceReport) }));
+    }
     if (url.pathname === "/api/chat") {
       let body = "";
       for await (const chunk of req) body += chunk;
       chats.push(JSON.parse(body));
       return res.end(JSON.stringify({ reply: "Measured coaching reply." }));
     }
+    if (url.pathname === "/api/session/generate") {
+      let body = "";
+      for await (const chunk of req) body += chunk;
+      const input = JSON.parse(body);
+      generations.push(input);
+      return res.end(JSON.stringify({ actions: input.actions.map((action: { action_id: string }) => ({ action_id: action.action_id, feedback: ["Generated feedback."] })), session_feedback: ["Session summary."] }));
+    }
     const table = url.pathname.split("/").at(-1);
+    if (req.method !== "GET") { mutations++; return res.end("[]"); }
+    if (table === "annotations" && annotationsFail) {
+      res.statusCode = 400;
+      return res.end(JSON.stringify({ message: "Annotations unavailable." }));
+    }
     let rows: Record<string, unknown>[] = table === "users" ? [{ user_id: owner, account_role: role }]
       : table === "users_subscriptions" ? [{ user_id: owner, subscription_id: "plan", startdate: "2000-01-01", enddate: "2099-01-01", plan: { subscription_id: "plan" } }]
-      : table === "sessions" ? [{ session_id: sessionId, user_id: sessionOwner, name: "Practice", players: { fname: "Player" } }]
-      : table === "actions" ? [actionId, otherActionId].map((id) => ({ action_id: id, session_id: sessionId, type: "Pass", start_frame: 750, end_frame: 780,
+      : table === "sessions" ? [{ session_id: sessionId, user_id: sessionOwner, name: "Practice", players: { fname: "Player", gender: "male", bdate: "2000-01-01" } }]
+      : table === "actions" ? [actionId, otherActionId].map((id) => ({ action_id: id, session_id: sessionId, type: id === actionId ? "Pass" : "Shoot", start_frame: 750, end_frame: 780,
         annotations: [{ score: 7, annotations_notes: [{ note: "Coach note." }] }] }))
-      : table === "actions_feedbacks" ? [{ action_id: actionId, feedback: "Saved action evaluation." }]
+      : table === "annotations" ? referencesAvailable ? examples : []
+      : table === "actions_feedbacks" ? savedFeedbackAvailable ? [{ action_id: actionId, feedback: "Saved action evaluation." }] : []
       : table === "sessions_feedbacks" ? [{ session_id: sessionId, feedback: "Saved session evaluation." }] : [];
+    const value = (row: Record<string, unknown>, key: string): unknown => key.split(".").reduce<unknown>((item, part) => (item as Record<string, unknown> | undefined)?.[part], row);
     for (const [key, filter] of url.searchParams) {
-      if (filter.startsWith("eq.")) rows = rows.filter((row) => String(row[key]) === filter.slice(3));
+      if (filter.startsWith("eq.")) rows = rows.filter((row) => String(value(row, key)) === filter.slice(3));
+      if (filter.startsWith("neq.")) rows = rows.filter((row) => String(value(row, key)) !== filter.slice(4));
     }
-    res.end(JSON.stringify(rows));
+    if (url.searchParams.get("order") === "action_id.asc") rows = [...rows].sort((a, b) => String(a.action_id).localeCompare(String(b.action_id)));
+    const from = Number(url.searchParams.get("offset") ?? 0);
+    const limit = Number(url.searchParams.get("limit") ?? rows.length);
+    res.end(JSON.stringify(rows.slice(from, from + limit)));
   });
   upstream.listen(0, "127.0.0.1");
   await once(upstream, "listening");
@@ -90,21 +152,39 @@ test("action chat sends current measurements on every message and preserves acce
     assert.equal((await request(selected)).status, 200);
     assert.equal(analysisReads, 1);
     assert.deepEqual(chats[0].context.action?.results, { metrics: measured.inActionMetrics, analytics });
-    assert.deepEqual(chats[0].context.action?.feedback, ["Saved action evaluation."]);
+    assert.deepEqual(chats[0].context.action?.feedback, []);
+    const expectedReferences = ["zz-late", "00-foreign", "08-reference", "07-reference", "06-reference"];
+    assert.deepEqual(chats[0].context.action?.references.map((item) => item.action_id), expectedReferences);
+    assert.ok(chats[0].context.action?.references.every((item) => item.action_type === "Pass" && item.player.gender === "female"));
+    const nearest = referenceReport(examples.find((item) => item.action_id === "zz-late")!);
+    assert.deepEqual(chats[0].context.action?.references[0].results, { metrics: nearest.inActionMetrics, analytics: nearest.rawAnalytics });
+    assert.equal(chats[0].context.action?.references[0].session_id, foreignSessionId, "comparisons include other accounts with their real session IDs");
+    assert.equal(chats[0].context.action?.references[0].score, 0);
+    assert.equal(chats[0].context.action?.references[1].score, null);
+    assert.deepEqual(chats[0].context.action?.references[1].notes, ["Reference coach note."]);
+    assert.equal(referenceReads, 2, "each session is fetched once across all candidate pages");
+    assert.deepEqual(referenceUsers, new Set([owner, other]));
     assert.deepEqual(chats[0].context.action?.annotations, [{ score: 7, annotations_notes: [{ note: "Coach note." }] }]);
     assert.equal(analysisHeaders["x-sporalize-user-id"], owner);
     assert.equal(analysisHeaders["x-sporalize-proxy-secret"], "x".repeat(32));
     assert.equal(analysisHeaders["x-sporalize-admin"], undefined);
 
-    analytics.active_foot_speed = 1500.123456;
-    measured.inActionMetrics.find((metric) => metric.name === "active_foot_speed")!.value = analytics.active_foot_speed;
+    analytics.ball_speed = 1500.123456;
+    measured.inActionMetrics.find((metric) => metric.name === "ball_speed")!.value = analytics.ball_speed;
+    savedFeedbackAvailable = true;
+    referenceAnalytics.ball_speed = 1400.75;
     const history = [{ role: "user", content: "Explain these measurements." }, { role: "assistant", content: "Previous reply." }];
     assert.equal((await request({ ...selected, message: "What changed?", history })).status, 200);
     assert.equal(analysisReads, 2);
     assert.deepEqual(chats[1].context.action?.results, { metrics: measured.inActionMetrics, analytics });
+    assert.deepEqual(chats[1].context.action?.feedback, ["Saved action evaluation."]);
+    const updatedNearest = referenceReport(examples.find((item) => item.action_id === "zz-late")!);
+    assert.deepEqual(chats[1].context.action?.references[0].results, { metrics: updatedNearest.inActionMetrics, analytics: updatedNearest.rawAnalytics });
+    assert.equal(referenceReads, 4, "each message gets current reference measurements");
     assert.deepEqual(chats[1].history, history);
     assert.equal((await request({ sessionId, actionId: otherActionId })).status, 200);
     assert.deepEqual(chats[2].context.action?.results, { metrics: otherMeasured.inActionMetrics, analytics: otherMeasured.rawAnalytics });
+    assert.deepEqual(chats[2].context.action?.references.map((item) => item.action_id), ["shoot-reference"]);
 
     const chatCount = chats.length;
     const readCount = analysisReads;
@@ -120,6 +200,22 @@ test("action chat sends current measurements on every message and preserves acce
     role = "user";
     sessionOwner = owner;
 
+    referencesAvailable = false;
+    assert.equal((await request(selected)).status, 200);
+    assert.deepEqual(chats.at(-1)?.context.action?.references, []);
+    referencesAvailable = true;
+    referenceResultsAvailable = false;
+    const readsBeforeMissing = referenceReads;
+    assert.equal((await request(selected)).status, 200);
+    assert.deepEqual(chats.at(-1)?.context.action?.references, []);
+    assert.equal(referenceReads, readsBeforeMissing + 2, "unavailable reference results are not retried for each candidate page");
+    referenceResultsAvailable = true;
+    const chatsBeforeFailure = chats.length;
+    annotationsFail = true;
+    assert.equal((await request(selected)).status, 500);
+    assert.equal(chats.length, chatsBeforeFailure, "a DB failure must not be presented as an empty search");
+    annotationsFail = false;
+
     const successfulChats = chats.length;
     resultsAvailable = false;
     assert.equal((await request(selected)).status, 404);
@@ -134,6 +230,30 @@ test("action chat sends current measurements on every message and preserves acce
     assert.equal((await request({})).status, 200);
     assert.equal(analysisReads, failedReads, "general and session chats do not need action measurements");
     assert.equal(chats.at(-1)?.context.action, undefined);
+    assert.equal(mutations, 0, "chat must not save or replace feedback");
+
+    analysisStatus = 200;
+    resultsAvailable = true;
+    Object.assign(process.env, { FRONTEND_URL: origin, BACKEND_URL: origin, SUPABASE_URL: upstreamOrigin,
+      SUPABASE_ANON_KEY: "test-anon", SUPABASE_SERVICE_ROLE_KEY: "test-service", ANALYSIS_API_URL: upstreamOrigin,
+      ANALYSIS_PROXY_SECRET: "x".repeat(32), AGENT_API_URL: upstreamOrigin, AGENT_API_KEY: "a".repeat(32), HF_TOKEN: "" });
+    const { createClient } = await import("@supabase/supabase-js");
+    const { actionDistance, generateSessionFeedback } = await import("../src/agent-session.js");
+    const sample = (rawAnalytics: Record<string, unknown>) => ({ id: "sample", label: "Pass", rawAnalytics });
+    assert.equal(actionDistance(sample({ speed: 0, touch_frame: 1 }), sample({ speed: 0, touch_frame: 9999 })), 0);
+    assert.equal(actionDistance(sample({ missing: null, flag: false, region: "Toe" }), sample({ speed: 0 })), null);
+    assert.equal(actionDistance(sample({ speed: 10 }), sample({ speed: "10" })), null);
+    assert.equal(actionDistance(sample({ speed: 10 }), sample({ unrelated: 10 })), null);
+    assert.ok(actionDistance(sample({ speed: 1000, angle: 100 }), sample({ speed: 1010, angle: 101 }))!
+      < actionDistance(sample({ speed: 1000, angle: 100 }), sample({ speed: 1000 }))!, "missing values must not outrank complete close measurements");
+    assert.equal(actionDistance(sample({ ball_speed: 10, touch_frame: 1 }), sample({ ball_speed: 9999, touch_frame: 9999 })), null);
+    assert.equal(actionDistance(sample({ active_foot_speed: 10, ball_speed: 10, touch_frame: 1 }), { id: "metric", label: "Pass",
+      inActionMetrics: [{ name: "Active Foot Speed", value: 10 }, { name: "Ball Speed", value: 9999 }, { name: "Touch Frame", value: 9999 }] }), 0);
+    const db = createClient(upstreamOrigin, "test-service", { auth: { persistSession: false } });
+    await generateSessionFeedback(db, sessionId, owner);
+    assert.deepEqual(generations[0].actions.find((item) => item.action_id === actionId)?.references.map((item) => item.action_id), expectedReferences);
+    assert.deepEqual(generations[0].actions.find((item) => item.action_id === otherActionId)?.references.map((item) => item.action_id), ["shoot-reference"]);
+    assert.equal(mutations, 6, "automatic generation still persists feedback for both actions and the session");
   } finally {
     if (child.exitCode === null && child.signalCode === null) {
       const exited = once(child, "exit");