canopy-ui 0.14.0 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopy-ui",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "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,12 @@ 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;
   /** 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,53 @@ 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");
+  });
 });

package/src/chat/turnStatus.ts

@@ -95,9 +95,21 @@ 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;
@@ -139,7 +151,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: