Merge pull request #637 from hevayo/fix/635-answers-gap-meets-retry

fix(console): submitted answers count as agent work before the turn exists

Author: hevayo

apps/console/design/lexicon.md

@@ -413,6 +413,19 @@ Requirements — nothing downstream can be written before that document exists,
 a member's interview answers (plain prose, no flow) is the very one that writes it (#629). The
 moment anything exists, the silence above resumes.
 
+**"In flight" starts at the submit, not at the server.** `spec.agent` cannot see a turn before its
+row exists, and submitted interview answers take the dispatch round-trip — seconds — to become one;
+in that gap every signal above read idle and the empty workspace offered Retry against the very
+interview it could not see ([#635](https://github.com/wso2/labs-agentic-engineer/issues/635)). The
+browser that submitted holds the missing evidence — a seeded message waiting, a dispatch awaiting
+its turn id, a stream being folded — and that chain counts as agent work until the status catches
+up. It is claim-scoped, not timed — a refused send releases its claim and Retry surfaces at once —
+with one backstop: a seeded message whose consumer never opens (the one stage with no failure path
+of its own) lapses from the signal after a generous TTL, so an outage cannot pin a working state
+that hides Retry. A
+teammate's browser holds no claim for a send made elsewhere and waits on the status, as it always
+did.
+
 **The counts read the LIVE document, not the committed one.** Deleting an `*assumed*` flag clears
 the alert as you delete it; the committed copy is a collab flush behind, and on the agent's own
 edits that lag was long enough to look broken.

apps/console/src/features/agent-chat/chatStore.test.ts

@@ -16,7 +16,7 @@
  * under the License.
  */
 
-import { beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 // Node test env: the store only touches localStorage — a Map-backed stub
 // keeps the test out of jsdom.
@@ -51,6 +51,11 @@ import {
   subscribeTurnEnd,
   upsertToolMessage,
   clearFailedSends,
+  claimSendInFlight,
+  claimStreamFold,
+  hasLocalTurnActivity,
+  subscribeLocalTurnActivity,
+  SEED_ACTIVITY_TTL_MS,
 } from "./chatStore";
 
 let n = 0;
@@ -444,3 +449,112 @@ describe("clearFailedSends", () => {
     expect(getMessages(KEY)).toBe(before);
   });
 });
+
+// #635: the chain a submitted send rides from form to turn — seed waiting,
+// dispatch in flight, stream being folded. Any stage live means this browser
+// holds evidence of a turn the status endpoint may not report yet.
+describe("local turn activity", () => {
+  it("is live through each stage of a send, and collapses when the last releases", () => {
+    const key = freshKey();
+    expect(hasLocalTurnActivity(key)).toBe(false);
+
+    setPendingSeed(key, "answers");
+    expect(hasLocalTurnActivity(key)).toBe(true);
+
+    // Consumption hands over to the send claim with no dead stage between.
+    const releaseSend = claimSendInFlight(key);
+    consumePendingSeed(key);
+    expect(hasLocalTurnActivity(key)).toBe(true);
+
+    const releaseFold = claimStreamFold(key);
+    releaseSend();
+    expect(hasLocalTurnActivity(key)).toBe(true);
+
+    releaseFold();
+    expect(hasLocalTurnActivity(key)).toBe(false);
+  });
+
+  it("collapses when a send dies before a turn exists", () => {
+    const key = freshKey();
+    const release = claimSendInFlight(key);
+    expect(hasLocalTurnActivity(key)).toBe(true);
+    release();
+    expect(hasLocalTurnActivity(key)).toBe(false);
+  });
+
+  it("notifies on every edge: seed set/consumed, claim taken/released", () => {
+    const key = freshKey();
+    let fired = 0;
+    const unsubscribe = subscribeLocalTurnActivity(key, () => {
+      fired += 1;
+    });
+    setPendingSeed(key, "answers");
+    consumePendingSeed(key);
+    const release = claimSendInFlight(key);
+    release();
+    expect(fired).toBe(4);
+
+    unsubscribe();
+    setPendingSeed(key, "again");
+    expect(fired).toBe(4);
+    consumePendingSeed(key);
+  });
+
+  it("keeps distinct keys apart", () => {
+    const key1 = freshKey();
+    const key2 = freshKey();
+    const release = claimSendInFlight(key1);
+    expect(hasLocalTurnActivity(key2)).toBe(false);
+    release();
+  });
+
+  // The seed is the one stage with no failure path of its own: its consumer
+  // sits behind gates an outage can hold shut, and an unconsumed seed would
+  // pin a working state that HIDES Retry. So only the seed's contribution
+  // expires — and expiry is an edge subscribers hear about, or the pane
+  // would hold the stale state until an unrelated re-render.
+  describe("seed TTL", () => {
+    beforeEach(() => vi.useFakeTimers());
+    afterEach(() => vi.useRealTimers());
+
+    it("expires a waiting seed from the signal, and notifies the edge", () => {
+      const key = freshKey();
+      let fired = 0;
+      const unsubscribe = subscribeLocalTurnActivity(key, () => {
+        fired += 1;
+      });
+      setPendingSeed(key, "answers");
+      expect(hasLocalTurnActivity(key)).toBe(true);
+      const firedBeforeExpiry = fired;
+
+      vi.advanceTimersByTime(SEED_ACTIVITY_TTL_MS);
+      expect(hasLocalTurnActivity(key)).toBe(false);
+      expect(fired).toBe(firedBeforeExpiry + 1);
+
+      // The seed itself is untouched by the lapse — still there to consume.
+      expect(peekPendingSeed(key)).toEqual({ message: "answers", guarded: false });
+      unsubscribe();
+      consumePendingSeed(key);
+    });
+
+    it("does not expire the claims — their release paths own their end", () => {
+      const key = freshKey();
+      const release = claimSendInFlight(key);
+      vi.advanceTimersByTime(SEED_ACTIVITY_TTL_MS * 2);
+      expect(hasLocalTurnActivity(key)).toBe(true);
+      release();
+    });
+
+    it("a fresh seed restarts the clock", () => {
+      const key = freshKey();
+      setPendingSeed(key, "first");
+      vi.advanceTimersByTime(SEED_ACTIVITY_TTL_MS - 1000);
+      setPendingSeed(key, "second");
+      vi.advanceTimersByTime(2000);
+      expect(hasLocalTurnActivity(key)).toBe(true);
+      vi.advanceTimersByTime(SEED_ACTIVITY_TTL_MS);
+      expect(hasLocalTurnActivity(key)).toBe(false);
+      consumePendingSeed(key);
+    });
+  });
+});

apps/console/src/features/agent-chat/chatStore.ts

@@ -433,6 +433,7 @@ const seedListeners = new Map<string, Set<() => void>>();
  */
 export function setPendingSeed(key: string, message: string, guarded = false): void {
   pendingSeeds.set(key, { message, guarded });
+  stampSeedForActivity(key);
   for (const fn of seedListeners.get(key) ?? []) fn();
 }
 
@@ -451,6 +452,7 @@ export function consumePendingSeed(key: string): PendingSeed | null {
   const seed = pendingSeeds.get(key);
   if (seed === undefined) return null;
   pendingSeeds.delete(key);
+  clearSeedActivity(key);
   for (const fn of seedListeners.get(key) ?? []) fn();
   return seed;
 }
@@ -559,13 +561,15 @@ const inFlightSends = new Map<string, number>();
 
 function claim(counts: Map<string, number>, key: string): () => void {
   counts.set(key, (counts.get(key) ?? 0) + 1);
+  notifyLocalTurnActivity(key);
   let released = false;
   return () => {
     if (released) return; // idempotent: cleanup may run twice (StrictMode)
     released = true;
     const remaining = (counts.get(key) ?? 1) - 1;
     if (remaining <= 0) counts.delete(key);
     else counts.set(key, remaining);
+    notifyLocalTurnActivity(key);
   };
 }
 
@@ -590,5 +594,100 @@ export function claimSendInFlight(key: string): () => void {
  * is itself appending fresher content than the replace would have written.
  */
 export function canReplaceLog(key: string): boolean {
-  return !attachedFolds.has(key) && !inFlightSends.has(key);
+  return !hasLiveClaims(key);
+}
+
+/** A dispatch or fold this browser currently owns for `key` — the shared base
+ *  of `canReplaceLog` and `hasLocalTurnActivity`, so a future claim map cannot
+ *  be added to one reading and silently missed by the other. */
+function hasLiveClaims(key: string): boolean {
+  return inFlightSends.has(key) || attachedFolds.has(key);
+}
+
+// --- Local turn activity (#635) -------------------------------------------
+//
+// `spec.agent` lags a send by the dispatch round-trip: interview answers leave
+// through the seed slot the instant the question form submits, but the turn
+// carrying them has no `agent_turns` row until StartTurn answers — seconds
+// later, longer under load. In that window the status endpoint reads idle, the
+// question form is gone, and an empty project has no files, so every signal
+// the spec workspace checks said "nothing running" and it offered Retry
+// against an interview mid-flight — #629's hazard surviving as a race.
+//
+// This browser knows better. The seed slot, the send claim and the fold claim
+// chain without a gap from form-submit to the turn's terminal frame (`send()`
+// releases the send claim and takes the fold claim in one synchronous
+// continuation), and every failure path releases its claim — a refused
+// dispatch, a severed stream, a chatKey rotation. So "any of the three is
+// live" is precisely "this browser holds evidence of a turn the status
+// endpoint may not report yet". The CLAIMS need no expiry timer — the signal
+// collapses the moment a send is refused or a turn dies, letting Retry
+// surface honestly. The SEED is the one stage with no failure path of its
+// own: its sole consumer sits behind gates (the conversation id resolving,
+// the history rehydrate landing) that an outage can hold shut indefinitely,
+// and a seed nobody consumes would otherwise pin a working state that HIDES
+// Retry — strictly worse than the gap being closed. So only the seed's
+// contribution expires, on a TTL generous against a slow panel mount; the
+// seed itself stays consumable, exactly as before.
+//
+// Browser-local by nature: a teammate's browser holds no claim for a send
+// made here. Their pane recovers through the status poll as it always did —
+// this only closes the gap for the member who just submitted.
+
+const localTurnActivityListeners = new Map<string, Set<() => void>>();
+
+function notifyLocalTurnActivity(key: string): void {
+  for (const fn of localTurnActivityListeners.get(key) ?? []) fn();
+}
+
+/** How long a WAITING seed counts as turn activity. Normal consumption is
+ *  near-immediate (the panel is mounted, or mounts on the seed's own signal),
+ *  so this bounds only the pathological stall where the consumer's gates
+ *  never open. */
+export const SEED_ACTIVITY_TTL_MS = 30_000;
+
+const seedActivitySetAt = new Map<string, number>();
+const seedActivityTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function stampSeedForActivity(key: string): void {
+  seedActivitySetAt.set(key, Date.now());
+  clearTimeout(seedActivityTimers.get(key));
+  // The expiry is an EDGE subscribers must hear about — without the wake-up
+  // call, a pane holding "working" on this seed would keep it until some
+  // unrelated re-render happened to re-read the snapshot.
+  seedActivityTimers.set(
+    key,
+    setTimeout(() => {
+      seedActivityTimers.delete(key);
+      notifyLocalTurnActivity(key);
+    }, SEED_ACTIVITY_TTL_MS),
+  );
+}
+
+function clearSeedActivity(key: string): void {
+  seedActivitySetAt.delete(key);
+  clearTimeout(seedActivityTimers.get(key));
+  seedActivityTimers.delete(key);
+}
+
+/** True while THIS browser holds live evidence of a turn for `key`: a seed
+ *  waiting to send (within its TTL), a dispatch awaiting its turn id, or a
+ *  stream being folded. */
+export function hasLocalTurnActivity(key: string): boolean {
+  const setAt = pendingSeeds.has(key) ? seedActivitySetAt.get(key) : undefined;
+  const seedLive = setAt !== undefined && Date.now() - setAt < SEED_ACTIVITY_TTL_MS;
+  return seedLive || hasLiveClaims(key);
+}
+
+/** Fires on every edge of `hasLocalTurnActivity`: seed set or consumed, claim
+ *  taken or released. */
+export function subscribeLocalTurnActivity(key: string, fn: () => void): () => void {
+  const unsubscribeSeed = subscribeSeed(key, fn);
+  const set = localTurnActivityListeners.get(key) ?? new Set();
+  set.add(fn);
+  localTurnActivityListeners.set(key, set);
+  return () => {
+    unsubscribeSeed();
+    set.delete(fn);
+  };
 }

apps/console/src/features/agent-chat/useLocalTurnActivity.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { useCallback, useSyncExternalStore } from "react";
+import { chatKeyFor, hasLocalTurnActivity, subscribeLocalTurnActivity } from "./chatStore.js";
+
+/**
+ * True while THIS browser holds live evidence of a turn for the project — a
+ * seeded message waiting to send, a dispatch awaiting its turn id, or a
+ * stream being folded (#635). Covers the window where `spec.agent` still
+ * reads idle because the turn's row does not exist server-side yet, which is
+ * exactly when a surface deciding "is anything running" from status alone
+ * would wrongly offer Retry against work in flight.
+ */
+export function useLocalTurnActivity(
+  org: string,
+  projectName: string | undefined,
+): boolean {
+  const chatKey = projectName ? chatKeyFor(org, projectName) : null;
+  return useSyncExternalStore(
+    useCallback(
+      (fn: () => void) => (chatKey ? subscribeLocalTurnActivity(chatKey, fn) : () => {}),
+      [chatKey],
+    ),
+    () => (chatKey ? hasLocalTurnActivity(chatKey) : false),
+  );
+}