canopy-ui 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopy-ui",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "license": "BSD-3-Clause",
   "type": "module",
   "repository": {

package/src/chat/protocol.ts

@@ -222,13 +222,20 @@ 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. */
   /** For `queued_behind`: what it waits behind — `session` (the previous
    *  message in this conversation) or `agent` (another turn of the same
    *  agent). Absent on an older server. */
   behind?: "session" | "agent" | null;
+  /** Why a `failed` turn failed, in the runner's words; or why a `cancelled`
+   *  one was never run (an admission rule rejected it). Null otherwise, and
+   *  for a turn someone stopped. Absent on an older server. */
   detail?: string | null;
+  /** For `waiting_runner`: its runners are PAUSED by someone, not asleep.
+   *  Absent on an older server. */
+  parked?: boolean;
+  /** For a `parked` turn: when the first of its runners resumes on its own
+   *  (ISO). Null = only a person resuming one will run it. */
+  held_until?: 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;

package/src/chat/turnStatus.test.ts

@@ -113,6 +113,25 @@ describe("turnNotice", () => {
     expect(n?.text).toContain("jj-mbp is offline");
   });
 
+  it("says a paused box is paused, and until when it holds the turn", () => {
+    const held = turnNotice(status({
+      state: "waiting_runner", stuck: true, claimed_by: null, parked: true,
+      held_until: "2026-10-12T21:00:00Z",
+    }));
+    expect(held?.text).toContain("jj-mbp is paused until");
+    expect(held?.text).toContain("It runs then.");
+    const open = turnNotice(status({ state: "waiting_runner", stuck: true, claimed_by: null, parked: true }));
+    expect(open?.text).toContain("runs only when someone resumes it");
+  });
+
+  it("says why a rejected turn was never run, and nothing for one somebody stopped", () => {
+    const rejected = turnNotice(status({
+      state: "cancelled", settled: true, detail: "jj-mbp was paused by Jonathan Jackson",
+    }));
+    expect(rejected).toMatchObject({ tone: "error", text: "Not run — jj-mbp was paused by Jonathan Jackson" });
+    expect(turnNotice(status({ state: "cancelled", settled: true, detail: null }))).toBeNull();
+  });
+
   it("reads differently for the state waiting cannot fix", () => {
     const n = turnNotice(status({ state: "unrouted", stuck: true, runners: [], claimed_by: null }));
     // Not a warning you can wait out — an error somebody has to go and fix.

package/src/chat/turnStatus.ts

@@ -108,6 +108,14 @@ export interface TurnNotice {
  * 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.
  */
+/** A resume time as the reader's local "Oct 12, 3:00 PM". */
+function formatWhen(iso: string): string {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime())
+    ? iso
+    : d.toLocaleString(undefined, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+}
+
 export function turnNotice(
   status?: TurnStatus | null,
   { latestMessageAt }: { latestMessageAt?: string | null } = {},
@@ -124,6 +132,17 @@ export function turnNotice(
   const need = status.requires?.length ? status.requires.map((r) => r.toUpperCase()).join(", ") : "";
   switch (status.state) {
     case "waiting_runner":
+      if (status.parked) {
+        return {
+          tone: "warn",
+          // Paused is somebody's decision, not a laptop lid: say whether it ends
+          // on its own.
+          text: status.held_until
+            ? `Queued — ${runners || "its runner"} is paused until ${formatWhen(status.held_until)}. It runs then.`
+            : `Queued — ${runners || "its runner"} is paused, so this runs only when someone resumes it.`,
+          offer,
+        };
+      }
       return {
         tone: "warn",
         // Names the box, because the fix is physical: go and open it.
@@ -170,6 +189,12 @@ export function turnNotice(
         text: status.detail ? `Could not finish — ${status.detail}` : "Could not finish.",
         offer: null,
       };
+    case "cancelled":
+      // Only a REJECTED turn carries a detail (an admission rule closed it before
+      // it ran); one somebody stopped needs no sentence.
+      return status.detail
+        ? { tone: "error", text: `Not run — ${status.detail}`, offer: null }
+        : null;
     case "missed":
       return { tone: "warn", text: "Missed — nothing picked it up in time.", offer: null };
     default: