canopy-ui 0.14.0 → 0.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopy-ui",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "repository": {
     "type": "git",

package/src/chat/ChatPanel.tsx

@@ -136,7 +136,9 @@ export function ChatPanel({
   // underneath would state the same fact twice and put a dead-end restatement
   // directly below the thing you can actually press. The fallback is for hosts
   // with no banner of their own, which is exactly the embedded widget.
-  const notice = banner ? null : turnNotice(status);
+  const latestMessageAt =
+    state.messages.length > 0 ? state.messages[state.messages.length - 1].created_at : null;
+  const notice = banner ? null : turnNotice(status, { latestMessageAt });
 
   // Sticky-bottom scroll: dep changes on (a) new message arrival and (b)
   // streaming text growth on the last message. length-only (cheap) instead

package/src/chat/protocol.ts

@@ -210,6 +210,17 @@ export interface TurnStatus {
   /** The agent is sitting on a dialog. A separate axis from `state`: a turn
    *  blocked on a question is still RUNNING as far as the turn is concerned. */
   menu_pending: boolean;
+  /** Why a `failed` turn failed, in the runner's words. Null for every other
+   *  state. Absent on an older server. */
+  detail?: string | null;
+  /** When a settled turn finished — lets the kit drop a failure the
+   *  conversation has since moved past. Absent on an older server. */
+  finished_at?: string | null;
+  /** What the conversation's host requires of the runner (e.g. `zdr`). Only
+   *  set while queued, and only when the requirement is what blocks the turn
+   *  (some runner would take it without one) — so render it as the reason.
+   *  Absent on an older server. */
+  requires?: string[];
   /** Nothing more will happen without someone asking for it. */
   settled: boolean;
   /** Nothing is moving and only a person can change that. The one question a

package/src/chat/turnStatus.test.ts

@@ -136,4 +136,65 @@ describe("turnNotice", () => {
     // An older client meeting a newer server must fall silent, not crash.
     expect(turnNotice(status({ state: "some_future_state" }))).toBeNull();
   });
+
+  it("says why a turn failed when the runner gave a reason", () => {
+    // 2026-09-27: a bare "Could not finish." hid a note that said exactly
+    // what to do.
+    const n = turnNotice(status({
+      state: "failed", settled: true,
+      detail: "Your message was not delivered: the emdash session has unsent text in its prompt.",
+    }));
+    expect(n?.tone).toBe("error");
+    expect(n?.text).toBe(
+      "Could not finish — Your message was not delivered: the emdash session has unsent text in its prompt.",
+    );
+  });
+
+  it("keeps the bare wording for a failure with no reason, or an older server", () => {
+    expect(turnNotice(status({ state: "failed", settled: true }))?.text).toBe("Could not finish.");
+    expect(turnNotice(status({ state: "failed", settled: true, detail: null }))?.text)
+      .toBe("Could not finish.");
+  });
+
+  it("drops a settled failure once the conversation has moved past it", () => {
+    // Work typed straight into the session makes messages but no Turn, so the
+    // latest Turn can be a day-old failure under a thread that is fine.
+    const failed = status({
+      state: "failed", settled: true, finished_at: "2026-09-26T22:07:07Z",
+    });
+    expect(turnNotice(failed, { latestMessageAt: "2026-09-27T17:21:38Z" })).toBeNull();
+    expect(turnNotice(status({
+      state: "lost", settled: true, finished_at: "2026-09-26T22:07:07Z",
+    }), { latestMessageAt: "2026-09-27T17:21:38Z" })).toBeNull();
+  });
+
+  it("still shows a failure that is the conversation's last word", () => {
+    const failed = status({
+      state: "failed", settled: true, finished_at: "2026-09-26T22:07:07Z",
+    });
+    expect(turnNotice(failed, { latestMessageAt: "2026-09-26T22:06:01Z" })?.tone).toBe("error");
+    expect(turnNotice(failed, { latestMessageAt: null })?.tone).toBe("error");
+    expect(turnNotice(failed)?.tone).toBe("error");
+  });
+
+  it("never lets a newer message hide a turn that is not settled", () => {
+    // A live or stuck turn is still owed something, whatever else was said.
+    const n = turnNotice(
+      status({ state: "waiting_runner", stuck: true, finished_at: "2026-09-26T22:07:07Z" }),
+      { latestMessageAt: "2026-09-27T17:21:38Z" },
+    );
+    expect(n?.tone).toBe("warn");
+  });
+});
+
+describe("turnNotice, when the conversation requires a runner flag", () => {
+  it("names the missing requirement when unrouted", () => {
+    const n = turnNotice(status({ state: "unrouted", stuck: true, runners: [], claimed_by: null, agent_slug: "ace", requires: ["zdr"] }));
+    expect(n?.text).toContain("ZDR runner");
+  });
+
+  it("names it when its runners are offline", () => {
+    const n = turnNotice(status({ state: "waiting_runner", stuck: true, runners: ["cloud-1"], claimed_by: null, requires: ["zdr"] }));
+    expect(n?.text).toContain("ZDR");
+  });
 });

package/src/chat/turnStatus.ts

@@ -95,21 +95,35 @@ export interface TurnNotice {
  * `blocked` deliberately returns null: the dialog itself is the notice, and
  * the host renders it as a menu with buttons. A sentence beside it would say
  * the same thing twice and compete with the thing you can actually press.
+ *
+ * `latestMessageAt` is the newest message on screen. A settled turn's notice
+ * is only true while that turn is the conversation's last word: work typed
+ * straight into the session makes messages but no Turn, so without this a
+ * day-old failure sat in red under a thread that was plainly working.
  */
-export function turnNotice(status?: TurnStatus | null): TurnNotice | null {
+export function turnNotice(
+  status?: TurnStatus | null,
+  { latestMessageAt }: { latestMessageAt?: string | null } = {},
+): TurnNotice | null {
   if (!status) return null;
+  if (status.settled && status.finished_at && latestMessageAt
+      && Date.parse(latestMessageAt) > Date.parse(status.finished_at)) {
+    return null;
+  }
   const offer = status.cloud_runner && status.cloud_runner_id
     ? { name: status.cloud_runner, id: status.cloud_runner_id }
     : null;
   const runners = status.runners.join(", ");
+  const need = status.requires?.length ? status.requires.map((r) => r.toUpperCase()).join(", ") : "";
   switch (status.state) {
     case "waiting_runner":
       return {
         tone: "warn",
         // Names the box, because the fix is physical: go and open it.
-        text: runners
+        text: (runners
           ? `Queued — ${runners} is offline, so nothing is working on this yet. It runs when the runner is back.`
-          : "Queued — its runner is offline, so nothing is working on this yet.",
+          : "Queued — its runner is offline, so nothing is working on this yet.")
+          + (need ? ` It needs a ${need} runner.` : ""),
         offer,
       };
     case "unrouted":
@@ -117,7 +131,9 @@ export function turnNotice(status?: TurnStatus | null): TurnNotice | null {
         tone: "error",
         // The one state waiting cannot fix, and it has to READ differently
         // from the one waiting can.
-        text: status.agent_slug
+        text: need
+          ? `Queued — this conversation needs a ${need} runner, and none of ${status.agent_slug ?? "its agent"}'s runners is declared ${need}.`
+          : status.agent_slug
           ? `Queued, but no runner is set up to run ${status.agent_slug} — nothing will pick this up until its routing is fixed.`
           : "Queued, but no runner is set up to run this — nothing will pick it up until its routing is fixed.",
         offer,
@@ -139,7 +155,14 @@ export function turnNotice(status?: TurnStatus | null): TurnNotice | null {
         offer,
       };
     case "failed":
-      return { tone: "error", text: "Could not finish.", offer: null };
+      // The reason, when the runner gave one: "failed" covers an undelivered
+      // message, a stop that did not take and a create that never rendered,
+      // and each has a different fix — which the note usually spells out.
+      return {
+        tone: "error",
+        text: status.detail ? `Could not finish — ${status.detail}` : "Could not finish.",
+        offer: null,
+      };
     case "missed":
       return { tone: "warn", text: "Missed — nothing picked it up in time.", offer: null };
     default: