canopy-ui 0.6.3 → 0.7.0

package/src/chat/sessionReducer.test.ts

@@ -617,7 +617,7 @@ describe("the dialog an agent is blocked on", () => {
     expect(after.menu).toBeUndefined();
   });
 
-  it("is cleared by a later activity frame that has no menu", () => {
+  it("is cleared by a later activity frame that says the agent is not waiting", () => {
     const blocked = sessionReducer(makeState(), {
       event: "session.activity",
       data: { state: "blocked", menu: MENU },
@@ -625,4 +625,105 @@ describe("the dialog an agent is blocked on", () => {
     const idle = sessionReducer(blocked, { event: "session.activity", data: { state: "idle" } });
     expect(idle.menu).toBeUndefined();
   });
+
+  it("survives a blocked frame that carries no menu", () => {
+    // The hook path reports `blocked` WITHOUT a menu — it deliberately does not
+    // read the screen (#510: doing so stole emdash's focus). Treating that as a
+    // retraction would erase a menu the snapshot or the session report had
+    // already supplied, which is every menu we now have.
+    const blocked = sessionReducer(makeState(), {
+      event: "session.activity",
+      data: { state: "blocked", menu: MENU },
+    });
+    const again = sessionReducer(blocked, { event: "session.activity", data: { state: "blocked" } });
+    expect(again.menu?.question).toBe("Do you want to proceed?");
+  });
+
+  it("arrives in the connect snapshot, not only in a live frame", () => {
+    // THE fix for "when I click on the session I don't see the menu". Activity
+    // frames are view-only and reach a client only if it was connected when
+    // they fired; you open the session precisely because it stopped.
+    const state = sessionReducer(makeState(), {
+      event: "session.state",
+      data: makeState({ activity: "blocked", menu: MENU }),
+    });
+    expect(state.menu?.question).toBe("Do you want to proceed?");
+  });
+
+  it("appears while you are already watching, via its own frame", () => {
+    const state = sessionReducer(makeState(), {
+      event: "session.menu",
+      data: { menu: MENU },
+    });
+    expect(state.menu?.options).toHaveLength(2);
+  });
+
+  it("is retracted when somebody answers at the keyboard", () => {
+    // `menu: null` from the session report. Buttons that outlive their dialog
+    // press a number into what is now an ordinary prompt, where the agent reads
+    // a bare "1" as an instruction.
+    const blocked = sessionReducer(makeState(), {
+      event: "session.menu",
+      data: { menu: MENU },
+    });
+    const cleared = sessionReducer(blocked, { event: "session.menu", data: { menu: null } });
+    expect(cleared.menu).toBeUndefined();
+  });
+
+  it("keeps an option's description, which is often the whole difference", () => {
+    const state = sessionReducer(makeState(), {
+      event: "session.menu",
+      data: {
+        menu: {
+          question: "How should the run proceed?",
+          options: [
+            { number: 1, label: "Proceed to Phase 4", description: "nothing reaches a real LLO" },
+            { number: 2, label: "Stop the run here", description: "end at the Phase 3 boundary" },
+          ],
+        },
+      },
+    });
+    expect(state.menu?.options[0].description).toContain("real LLO");
+  });
+});
+
+describe("session.stop — whether the stop actually landed", () => {
+  const base = (over: Partial<SessionState> = {}): SessionState => ({
+    messages: [],
+    active_draft: null,
+    participants: [],
+    presence_user_ids: [],
+    current_user_id: 1,
+    ...over,
+  });
+
+  it("records a requested stop without claiming it worked", () => {
+    const out = sessionReducer(base(), {
+      event: "session.stop",
+      data: { state: "requested" },
+    } as WsEvent);
+    expect(out.stopState).toBe("requested");
+  });
+
+  it("keeps the agent WORKING when the stop failed", () => {
+    // The whole point of a separate axis. A failed stop leaves the agent running,
+    // and both facts have to survive together — collapsing them into `activity`
+    // loses whichever one loses the race, and it was always the stop.
+    const out = sessionReducer(base({ activity: "working" }), {
+      event: "session.stop",
+      data: { state: "failed" },
+    } as WsEvent);
+    expect(out.stopState).toBe("failed");
+    expect(out.activity).toBe("working");
+  });
+
+  it("a new turn clears a stale stop outcome", () => {
+    // "your stop did not take" pinned over fresh work is a warning about
+    // something the human has already moved on from.
+    const out = sessionReducer(base({ stopState: "failed" }), {
+      event: "chat.stream_start",
+      data: { message_id: "m1" },
+    } as WsEvent);
+    expect(out.stopState).toBeUndefined();
+  });
 });

package/src/chat/sessionReducer.ts

@@ -28,6 +28,12 @@ const UNBLOCKING_FRAMES = new Set([
 ]);
 
 export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState {
+  if (frame.event === "chat.stream_start" || frame.event === "draft.committed") {
+    // A new turn is starting, so the previous turn's stop outcome is history —
+    // leaving "your stop did not take" pinned over fresh work would be a stale
+    // warning about something the human has already moved on from.
+    prev = { ...prev, stopState: undefined };
+  }
   if (prev.activity === "blocked" && UNBLOCKING_FRAMES.has(frame.event)) {
     // Dropping the menu with the state matters as much as the state itself —
     // the dialog is gone, and buttons that answer a gone dialog send a stray
@@ -71,10 +77,33 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
     }
 
     case "session.activity":
-      // The menu is cleared unless this frame carries one: a stale dialog is
-      // worse than none, because its buttons would answer a prompt that is no
-      // longer on screen.
-      return { ...prev, activity: frame.data.state, menu: frame.data.menu };
+      // A frame that says the agent is NOT waiting retracts the menu — a stale
+      // dialog is worse than none, because its buttons would answer a prompt
+      // that is no longer on screen.
+      //
+      // A `blocked` frame that carries no menu does NOT, and that asymmetry is
+      // load-bearing. The hook path reports `blocked` without one on purpose
+      // (#510 — reading the screen stole emdash's focus), so treating a bare
+      // `blocked` as a retraction would erase every menu the snapshot and the
+      // session report supply, which is now all of them.
+      if (frame.data.state !== "blocked") {
+        return { ...prev, activity: frame.data.state, menu: undefined };
+      }
+      return { ...prev, activity: "blocked", menu: frame.data.menu ?? prev.menu };
+
+    case "session.stop":
+      // Independent of `activity` on purpose. A stop that FAILED leaves the agent
+      // working, and both facts have to be sayable at once: "it is still going"
+      // AND "your stop did not take". Collapsing them loses whichever one loses
+      // the race, and it was always the second — which is how a dead Stop button
+      // stayed invisible.
+      return { ...prev, stopState: frame.data.state };
+
+    case "session.menu":
+      // The authoritative producer: the session report re-derives the dialog
+      // from the transcript every ~10s and pushes only the edges. `null` is the
+      // retraction, and has to be honoured — somebody answered at the keyboard.
+      return { ...prev, menu: frame.data.menu ?? undefined };
 
     case "chat.user_message": {
       // Someone typed into emdash, OR into this page. Both reach here, and that
@@ -341,7 +370,23 @@ export function sessionReducer(prev: SessionState, frame: WsEvent): SessionState
     case "presence.joined": {
       const ids = new Set(prev.presence_user_ids);
       ids.add(frame.data.user_id);
-      return { ...prev, presence_user_ids: [...ids] };
+      // Adopt the joiner into `participants` too. The presence ROW renders
+      // participants filtered by presence, so an id with no matching
+      // participant is invisible — which is what made a first-time joiner
+      // unseeable by everyone already in the room until they reloaded.
+      // `participant` is optional (an older server may not send it); without
+      // it this degrades to exactly the previous behaviour rather than
+      // inventing a nameless entry.
+      const joined = frame.data.participant;
+      const known = joined
+        ? prev.participants.some((p) => p.user_id === joined.user_id)
+        : true;
+      return {
+        ...prev,
+        presence_user_ids: [...ids],
+        participants:
+          joined && !known ? [...prev.participants, joined] : prev.participants,
+      };
     }
 
     case "presence.left":