fix(crossfire): bound Jev signal sidecars

Author: Programcode

docs/architecture.md

@@ -58,7 +58,7 @@ Client-side environment selection is a developer convenience, not authorization.
 
 [`supabase/functions/ai/index.ts`](../supabase/functions/ai/index.ts) serves non-streaming structured tools and practice modes. [`supabase/functions/ai-stream/index.ts`](../supabase/functions/ai-stream/index.ts) serves Ask over server-sent events.
 
-For a validated Crossfire next turn, the server returns the reply first with a short-lived signed sidecar token. The client then requests a Jev classification of only the newest completed question-answer exchange, without reserving a second daily quota unit. The optional directness, concession, and follow-up signal is attached by turn ID to the answer; a missing, slow, forged, or failed sidecar never delays or invalidates the main reply. Draft version 1 remains compatible because turn signals are optional.
+For a validated Crossfire next turn, the server returns the reply first with a short-lived signed sidecar token. The client then requests a Jev classification of only the newest completed question-answer exchange. The token is atomically claimed through its own one-use counter, separate from the product's daily AI quota. The optional directness, concession, and follow-up signal is attached by turn ID to the answer; a missing, slow, replayed, forged, or failed sidecar never delays or invalidates the main reply. Draft version 1 remains compatible because turn signals are optional.
 
 A configured mock provider bypasses Supabase for local and test behavior. It is not authenticated backend evidence.
 

src/pages/CrossfirePage.tsx

@@ -263,21 +263,31 @@ export default function CrossfirePage() {
   const [storageError, setStorageError] = useState(false);
   const [stateOwnerId, setStateOwnerId] = useState(user?.id);
   const requestRef = useRef<AbortController | null>(null);
+  const signalRequestsRef = useRef(new Set<AbortController>());
   const shouldReduceMotion = useReducedMotion();
   const activeSourceCount = useSessionStore((session) => session.sourceLibrary.filter((source) => source.isActive).length);
   const { getFeatureConfig } = useSettingsStore();
   const modelConfig = getFeatureConfig('ask');
 
-  useEffect(() => () => requestRef.current?.abort(), []);
+  const abortSignalRequests = useCallback(() => {
+    signalRequestsRef.current.forEach((controller) => controller.abort());
+    signalRequestsRef.current.clear();
+  }, []);
+
+  useEffect(() => () => {
+    requestRef.current?.abort();
+    abortSignalRequests();
+  }, [abortSignalRequests]);
 
   useEffect(() => {
     if (stateOwnerId === user?.id) return;
     requestRef.current?.abort();
+    abortSignalRequests();
     dispatch({ type: 'state-restored', state: restoreState(user?.id, undefined) });
     setStateOwnerId(user?.id);
     setDraftTurn('');
     setFormError('');
-  }, [stateOwnerId, user?.id]);
+  }, [abortSignalRequests, stateOwnerId, user?.id]);
 
   useEffect(() => {
     if (!user?.id || stateOwnerId !== user.id) return;
@@ -322,16 +332,19 @@ export default function CrossfirePage() {
         turn: nextTurn(snapshot.turns.length + 1, 'ai', result.type, result.text),
       });
       if (result.signalToken) {
+        const signalController = new AbortController();
+        signalRequestsRef.current.add(signalController);
         void crossfireSignal({
           config: snapshot.config,
           transcript: snapshot.turns,
           reply,
           signalToken: result.signalToken,
-        }, modelConfig, { signal: controller.signal })
+        }, modelConfig, { signal: signalController.signal })
           .then((signal) => {
-            if (signal && !controller.signal.aborted) dispatch({ type: 'signal-received', signal });
+            if (signal && !signalController.signal.aborted) dispatch({ type: 'signal-received', signal });
           })
-          .catch((): void => {});
+          .catch((): void => {})
+          .finally(() => signalRequestsRef.current.delete(signalController));
       }
     } catch (error) {
       if (controller.signal.aborted) return;
@@ -445,6 +458,7 @@ export default function CrossfirePage() {
 
   const restart = () => {
     requestRef.current?.abort();
+    abortSignalRequests();
     if (user?.id) clearCrossfireDraft(user.id);
     dispatch({ type: 'session-reset' });
     setDraftTurn('');

src/test/pages/CrossfirePage.test.tsx

@@ -5,7 +5,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 const mocks = vi.hoisted(() => ({
   userId: 'user-a',
   crossfire: vi.fn<() => Promise<unknown>>(() => new Promise(() => undefined)),
-  crossfireSignal: vi.fn<() => Promise<unknown>>(() => Promise.resolve(undefined)),
+  crossfireSignal: vi.fn<(input: unknown, config: unknown, options: { signal?: AbortSignal }) => Promise<unknown>>(() => Promise.resolve(undefined)),
 }));
 
 vi.mock('@/lib/supabase/AuthProvider', () => ({
@@ -158,4 +158,34 @@ describe('CrossfirePage', () => {
     expect(screen.getByText('What is the mechanism?').closest('article')).not.toHaveTextContent('Direct answer');
     expect(answer.closest('article')?.querySelector('[aria-label*="82%"]')).not.toBeNull();
   });
+
+  it('keeps a delayed coaching signal alive while the next turn runs', async () => {
+    let resolveSignal: (value: unknown) => void = () => undefined;
+    let sidecarSignal: AbortSignal | undefined;
+    mocks.crossfire
+      .mockResolvedValueOnce({ type: 'answer', text: 'First bounded answer.', signalToken: 'token-1' })
+      .mockResolvedValueOnce({ type: 'answer', text: 'Second bounded answer.' });
+    mocks.crossfireSignal.mockImplementationOnce((_input, _config, options) => {
+      sidecarSignal = options.signal;
+      return new Promise((resolve) => {
+        resolveSignal = resolve;
+      });
+    });
+    renderPage();
+    fireEvent.change(screen.getByTestId('crossfire-resolution'), { target: { value: 'Resolved: test' } });
+    fireEvent.change(screen.getByTestId('crossfire-argument'), { target: { value: 'Case text' } });
+    fireEvent.click(screen.getByTestId('start-crossfire'));
+
+    fireEvent.change(screen.getByTestId('crossfire-input'), { target: { value: 'First question?' } });
+    fireEvent.click(screen.getByTestId('submit-turn'));
+    const firstAnswer = await screen.findByText('First bounded answer.');
+
+    fireEvent.change(screen.getByTestId('crossfire-input'), { target: { value: 'Second question?' } });
+    fireEvent.click(screen.getByTestId('submit-turn'));
+    expect(await screen.findByText('Second bounded answer.')).toBeInTheDocument();
+    expect(sidecarSignal?.aborted).toBe(false);
+
+    resolveSignal({ answerTurnId: 'T2', answerQuality: 'direct', answerQualityConfidence: 0.91, concession: 'none', concessionConfidence: 0.88, followUpOpportunity: 0.76 });
+    await waitFor(() => expect(firstAnswer.closest('article')).toHaveTextContent('Direct answer'));
+  });
 });

supabase/functions/ai/handler-research.test.ts

@@ -452,8 +452,17 @@ Deno.test("Crossfire returns newest-exchange signals without making them a reply
   const originalFetch = globalThis.fetch;
   let decisionFails = false;
   let decisionCalls = 0;
+  const claimedSignalKeys = new Set<string>();
   globalThis.fetch = (async (input: Request | URL | string, init?: RequestInit) => {
     const url = new URL(input instanceof Request ? input.url : String(input));
+    if (url.origin === "https://supabase.test" && url.pathname.includes("/rest/v1/rpc/consume_daily_quota")) {
+      const body = JSON.parse(String(init?.body ?? "{}")) as { p_quota_key?: string };
+      if (body.p_quota_key?.startsWith("crossfire_signal:")) {
+        const allowed = !claimedSignalKeys.has(body.p_quota_key);
+        claimedSignalKeys.add(body.p_quota_key);
+        return jsonResponse([{ allowed, current_count: 1 }]);
+      }
+    }
     const supabaseResponse = supabaseTestResponse(url);
     if (supabaseResponse) return supabaseResponse;
     if (url.href === "https://openrouter.ai/api/v1/chat/completions") {
@@ -512,6 +521,8 @@ Deno.test("Crossfire returns newest-exchange signals without making them a reply
     const questionSignal = await requestSignal("question-ai", questionTranscript, questionAiPayload.output as { type: "answer"; text: string }, questionAiPayload.signalToken);
     const questionSignalPayload = await questionSignal.json() as { output?: { signal?: { answerTurnId?: string; answerQuality?: string } } };
     if (questionSignalPayload.output?.signal?.answerTurnId !== "T2" || questionSignalPayload.output.signal.answerQuality !== "direct") throw new Error(`question-ai signal missing: ${JSON.stringify(questionSignalPayload)}`);
+    const replayedSignal = await requestSignal("question-ai", questionTranscript, questionAiPayload.output as { type: "answer"; text: string }, questionAiPayload.signalToken);
+    if (replayedSignal.status !== 409 || Number(decisionCalls) !== 1) throw new Error("replayed Crossfire signal token reached Jev");
     const forgedSignal = await requestSignal("question-ai", questionTranscript, questionAiPayload.output as { type: "answer"; text: string }, "forged-token");
     if (forgedSignal.status !== 403) throw new Error("forged Crossfire signal token was accepted");
 
@@ -522,12 +533,21 @@ Deno.test("Crossfire returns newest-exchange signals without making them a reply
     const aiQuestionsUser = await request("ai-questions-user", answerTranscript, "question");
     const aiQuestionsPayload = await aiQuestionsUser.json() as { output?: { type?: string; text?: string }; signalToken?: string };
     if (aiQuestionsUser.status !== 200 || aiQuestionsPayload.output?.type !== "question" || !aiQuestionsPayload.signalToken) throw new Error(`ai-questions-user reply missing: ${JSON.stringify(aiQuestionsPayload)}`);
-    const answerSignal = await requestSignal("ai-questions-user", answerTranscript, aiQuestionsPayload.output as { type: "question"; text: string }, aiQuestionsPayload.signalToken);
-    const answerSignalPayload = await answerSignal.json() as { output?: { signal?: { answerTurnId?: string; concession?: string } } };
+    const decisionCallsBeforeReplayRace = decisionCalls;
+    const racedSignals = await Promise.all(Array.from({ length: 4 }, () => requestSignal("ai-questions-user", answerTranscript, aiQuestionsPayload.output as { type: "question"; text: string }, aiQuestionsPayload.signalToken!)));
+    if (racedSignals.filter((response) => response.status === 200).length !== 1 || racedSignals.filter((response) => response.status === 409).length !== 3) {
+      throw new Error(`concurrent signal token claim was not atomic: ${racedSignals.map((response) => response.status).join(",")}`);
+    }
+    if (decisionCalls !== decisionCallsBeforeReplayRace + 1) throw new Error("concurrent Crossfire signal replays reached Jev");
+    const answerSignalPayload = await racedSignals.find((response) => response.status === 200)!.json() as { output?: { signal?: { answerTurnId?: string; concession?: string } } };
     if (answerSignalPayload.output?.signal?.answerTurnId !== "T2" || answerSignalPayload.output.signal.concession !== "implicit") throw new Error(`ai-questions-user signal missing: ${JSON.stringify(answerSignalPayload)}`);
 
     decisionFails = true;
-    const fallback = await requestSignal("question-ai", questionTranscript, questionAiPayload.output as { type: "answer"; text: string }, questionAiPayload.signalToken);
+    const fallbackTranscript = [{ id: "T1", sequence: 1, speaker: "user", kind: "question", text: "What is the fallback evidence?", createdAt: 3 }];
+    const fallbackReply = await request("question-ai", fallbackTranscript, "answer");
+    const fallbackReplyPayload = await fallbackReply.json() as { output?: { type: "answer"; text: string }; signalToken?: string };
+    if (!fallbackReplyPayload.output || !fallbackReplyPayload.signalToken) throw new Error("fallback Crossfire reply token missing");
+    const fallback = await requestSignal("question-ai", fallbackTranscript, fallbackReplyPayload.output, fallbackReplyPayload.signalToken);
     const fallbackPayload = await fallback.json() as { output?: { signal?: unknown } };
     if (fallback.status !== 200 || fallbackPayload.output?.signal !== undefined) throw new Error(`failed optional signal returned invalid output: ${JSON.stringify(fallbackPayload)}`);
   } finally {

supabase/functions/ai/index.ts

@@ -769,6 +769,18 @@ async function verifyCrossfireSignalToken(userId: string, input: CrossfireSignal
   return mismatch === 0;
 }
 
+async function claimCrossfireSignalToken(userId: string, input: CrossfireSignalInput): Promise<boolean> {
+  const tokenMac = input.signalToken.split(".")[1];
+  const { data, error } = await supabase.rpc("consume_daily_quota", {
+    p_user_id: userId,
+    p_limit: 1,
+    p_quota_key: `crossfire_signal:${tokenMac}`,
+  });
+  if (error) throw error;
+  const row = Array.isArray(data) ? data[0] : data;
+  return Boolean(row?.allowed);
+}
+
 function boundCrossfireSources(value: unknown, enabled: boolean): { value: PromptSource[]; truncated: boolean } | { error: string } {
   if (!enabled || value === undefined || value === null) return { value: [], truncated: false };
   if (!Array.isArray(value)) return { error: "sources must be an array when Source Library is enabled" };
@@ -1223,6 +1235,15 @@ export async function handleRequest(req: Request): Promise<Response> {
   if (crossfireInput?.operation === "signal") {
     if (await checkUserBanned(userId)) return badRequest("Your account has been suspended. Please contact support.", corsHeaders, 403);
     if (!(await verifyCrossfireSignalToken(userId, crossfireInput))) return badRequest("Invalid or expired Crossfire signal token", corsHeaders, 403);
+    try {
+      // A token-specific counter atomically bounds replays without consuming the product's AI quota.
+      if (!(await claimCrossfireSignalToken(userId, crossfireInput))) {
+        return badRequest("Crossfire signal token has already been used", corsHeaders, 409);
+      }
+    } catch (error) {
+      log(requestId, "ERROR", "Crossfire signal token claim failed", { error: error instanceof Error ? error.message : "Unknown error" });
+      return badRequest("Unable to verify Crossfire signal token", corsHeaders, 500);
+    }
     const evaluated = await evaluateCrossfireExchange({
       transcript: crossfireInput.transcript,
       reply: crossfireInput.reply,