pilotswarm 0.5.19 → 0.5.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.19",
+    "version": "0.5.20",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
     "type": "module",
     "license": "MIT",
@@ -78,7 +78,7 @@
         "hono": "^4.12.10",
         "ink": "^6.8.0",
         "jose": "^6.2.2",
-        "pilotswarm-sdk": "^0.5.19",
+        "pilotswarm-sdk": "^0.5.20",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

package/ui/core/src/controller.js

@@ -127,6 +127,15 @@ function classifyNavigationLoadError(error) {
     return "network";
 }
 
+// A 404/NOT_FOUND on a per-session data loop is TERMINAL: the session was
+// deleted (here or elsewhere) and every retry will 404 forever. 403 stays
+// retryable — a transient auth blip must not evict a live pane.
+function isSessionGoneError(error) {
+    const status = Number(error?.status);
+    const code = String(error?.code || "").toUpperCase();
+    return status === 404 || code === "NOT_FOUND";
+}
+
 async function loadSessionCatalogPageWindow(transport) {
     if (typeof transport.listSessionsPage !== "function") {
         return transport.listSessions();
@@ -1992,6 +2001,25 @@ export class PilotSwarmUiController {
         this.activeSessionSubscriptionId = null;
     }
 
+    /**
+     * A session no longer exists server-side (deleted locally or by another
+     * client; the server answered 404). Unbind everything referencing it so
+     * the detail/events/orchestration-stats loops stop instead of 404-spamming
+     * on every refresh tick until reload.
+     */
+    handleSessionGone(sessionId) {
+        if (!sessionId) return;
+        if (this.activeSessionSubscriptionId === sessionId) {
+            this.detachActiveSession();
+        }
+        if (this.activeSessionDetailSessionId === sessionId && this.activeSessionDetailTimer) {
+            clearTimeout(this.activeSessionDetailTimer);
+            this.activeSessionDetailTimer = null;
+            this.activeSessionDetailSessionId = null;
+        }
+        this.dispatch({ type: "sessions/gone", sessionId });
+    }
+
     detachLogStream() {
         if (this.logUnsubscribe) {
             this.logUnsubscribe();
@@ -2213,7 +2241,10 @@ export class PilotSwarmUiController {
         let newEvents;
         try {
             newEvents = await this.transport.getSessionEvents(sessionId, afterSeq, CATCH_UP_PAGE_LIMIT);
-        } catch {
+        } catch (error) {
+            if (isSessionGoneError(error)) {
+                this.handleSessionGone(sessionId);
+            }
             return null;
         }
         if (!Array.isArray(newEvents) || newEvents.length >= CATCH_UP_PAGE_LIMIT) {
@@ -2280,7 +2311,16 @@ export class PilotSwarmUiController {
         }
 
         const loadPromise = (async () => {
-            const events = await this.transport.getSessionEvents(sessionId, undefined, requestedLimit);
+            let events;
+            try {
+                events = await this.transport.getSessionEvents(sessionId, undefined, requestedLimit);
+            } catch (error) {
+                if (isSessionGoneError(error)) {
+                    this.handleSessionGone(sessionId);
+                    return null;
+                }
+                throw error;
+            }
             const history = {
                 ...buildHistoryModel(events, { requestedLimit }),
                 lastSeq: events[events.length - 1]?.seq || 0,
@@ -2403,6 +2443,10 @@ export class PilotSwarmUiController {
                 });
                 return this.getState().orchestration.bySessionId?.[sessionId] || null;
             } catch (error) {
+                if (isSessionGoneError(error)) {
+                    this.handleSessionGone(sessionId);
+                    return null;
+                }
                 this.dispatch({
                     type: "orchestration/statsError",
                     sessionId,
@@ -3440,7 +3484,16 @@ export class PilotSwarmUiController {
             return;
         }
         const afterSeq = Number(existing.lastSeq || 0);
-        const events = await this.transport.getSessionEvents(sessionId, afterSeq, 200);
+        let events = null;
+        try {
+            events = await this.transport.getSessionEvents(sessionId, afterSeq, 200);
+        } catch (error) {
+            if (isSessionGoneError(error)) {
+                this.handleSessionGone(sessionId);
+                return;
+            }
+            throw error;
+        }
         if (!Array.isArray(events) || events.length === 0) return;
         for (const event of events) {
             this.mergeSessionEvent(sessionId, event);
@@ -3481,7 +3534,16 @@ export class PilotSwarmUiController {
 
     async syncSessionDetail(sessionId) {
         if (typeof this.transport.getSession !== "function" || !sessionId) return;
-        const session = await this.transport.getSession(sessionId);
+        let session = null;
+        try {
+            session = await this.transport.getSession(sessionId);
+        } catch (error) {
+            if (isSessionGoneError(error)) {
+                this.handleSessionGone(sessionId);
+                return;
+            }
+            throw error;
+        }
         if (!session) return;
         const previousSession = this.getState().sessions.byId[sessionId] || null;
         const patch = buildSessionMergePatch(previousSession, session);
@@ -6820,6 +6882,7 @@ export class PilotSwarmUiController {
             for (const session of eligible) {
                 try {
                     await this.transport.deleteSession(session.sessionId);
+                    this.handleSessionGone(session.sessionId);
                     succeeded += 1;
                 } catch (error) {
                     failures.push(`${session.sessionId.slice(0, 8)}: ${error?.message || String(error)}`);
@@ -6925,6 +6988,7 @@ export class PilotSwarmUiController {
             return;
         }
         await this.transport.deleteSession(sessionId);
+        this.handleSessionGone(sessionId);
         this.dispatch({ type: "ui/status", text: `Deleted ${sessionId.slice(0, 8)}` });
         await this.refreshSessions();
     }

package/ui/core/src/formatting.js

@@ -100,16 +100,25 @@ export function shortModelName(model) {
     return value.includes(":") ? value.split(":").slice(1).join(":") : value;
 }
 
-export function formatTimestamp(value) {
+export function formatTimestamp(value, now = new Date()) {
     if (!value) return "";
     try {
         const date = value instanceof Date ? value : new Date(value);
-        return date.toLocaleTimeString(undefined, {
+        const time = date.toLocaleTimeString(undefined, {
             hour: "2-digit",
             minute: "2-digit",
             second: "2-digit",
             hour12: false,
         });
+        // Same-day messages show time only; anything older carries its date
+        // so a transcript spanning days stays unambiguous.
+        const sameLocalDay = date.getFullYear() === now.getFullYear()
+            && date.getMonth() === now.getMonth()
+            && date.getDate() === now.getDate();
+        if (sameLocalDay) return time;
+        const day = date.toLocaleDateString("en-GB", { month: "short", day: "numeric" });
+        const year = date.getFullYear() === now.getFullYear() ? "" : ` ${date.getFullYear()}`;
+        return `${day}${year} ${time}`;
     } catch {
         return "";
     }

package/ui/core/src/history.js

@@ -311,6 +311,13 @@ function deriveChatRole(event, fallbackRole, text) {
     return fallbackRole;
 }
 
+function sharesClientMessageId(left, right) {
+    const leftIds = Array.isArray(left?.clientMessageIds) ? left.clientMessageIds : [];
+    const rightIds = Array.isArray(right?.clientMessageIds) ? right.clientMessageIds : [];
+    if (leftIds.length === 0 || rightIds.length === 0) return null; // unknown
+    return leftIds.some((id) => rightIds.includes(id));
+}
+
 function areMessagesEquivalent(left, right) {
     if (!left || !right) return false;
     if (left.role !== right.role) return false;
@@ -319,6 +326,13 @@ function areMessagesEquivalent(left, right) {
     const rightText = comparableMessageText(right);
     if (!leftText || !rightText || leftText !== rightText) return false;
 
+    // clientMessageIds are authoritative when both sides carry them: a
+    // duroxide activity retry re-records the SAME queue message (same ids)
+    // regardless of how many seconds the retry took, while a user deliberately
+    // re-sending identical text mints fresh ids and must stay two bubbles.
+    const sharedId = sharesClientMessageId(left, right);
+    if (sharedId != null) return sharedId;
+
     const leftTime = Number(left.createdAt || 0);
     const rightTime = Number(right.createdAt || 0);
     if (left.optimistic || right.optimistic) return true;
@@ -347,7 +361,24 @@ export function dedupeChatMessages(chat = []) {
 
         const previousTime = Number(previous?.createdAt || 0);
         const currentTime = Number(message?.createdAt || 0);
-        deduped[deduped.length - 1] = currentTime >= previousTime ? message : previous;
+        const winner = currentTime >= previousTime ? message : previous;
+        // Two durable copies of the same user message = the runtime
+        // re-delivered it to the model after a mid-turn worker retry.
+        // Collapse to one bubble stamped with the LATEST delivery time and
+        // mark it so the transcript can show a redelivery glyph.
+        if (winner.role === "user" && !previous?.optimistic && !message?.optimistic) {
+            const firstDeliveredAt = Math.min(
+                Number(previous?.firstDeliveredAt || previousTime || Infinity),
+                Number(message?.firstDeliveredAt || currentTime || Infinity),
+            );
+            deduped[deduped.length - 1] = {
+                ...winner,
+                redelivered: true,
+                ...(Number.isFinite(firstDeliveredAt) ? { firstDeliveredAt } : {}),
+            };
+            continue;
+        }
+        deduped[deduped.length - 1] = winner;
     }
 
     return deduped;

package/ui/core/src/reducer.js

@@ -1027,6 +1027,32 @@ export function appReducer(state, action) {
                 },
             };
 
+        case "sessions/gone": {
+            // Terminal eviction: the server answered 404 for this session (or
+            // we just deleted it). Drop the row and release the active-session
+            // latch so panes unbind and the data loops stop retrying — the
+            // sessions/loaded active-session carve-out below would otherwise
+            // resurrect the row forever.
+            const goneId = action.sessionId;
+            if (!goneId) return state;
+            const hadRow = Boolean(state.sessions.byId[goneId]);
+            const wasActive = state.sessions.activeSessionId === goneId;
+            if (!hadRow && !wasActive) return state;
+            const byId = { ...state.sessions.byId };
+            delete byId[goneId];
+            const selectedIds = Array.isArray(state.sessions.selectedIds)
+                ? state.sessions.selectedIds.filter((id) => id !== goneId)
+                : state.sessions.selectedIds;
+            return {
+                ...state,
+                sessions: {
+                    ...state.sessions,
+                    byId,
+                    selectedIds,
+                    activeSessionId: wasActive ? null : state.sessions.activeSessionId,
+                },
+            };
+        }
         case "sessions/loaded": {
             const byId = {};
             let anyChanged = false;

package/ui/core/src/selectors.js

@@ -1396,11 +1396,13 @@ function buildChatMessagePrefix(message, options = {}) {
                 : "PilotSwarm";
 
     // Delivery glyph for user messages:
-    //   ○   pending  — client outbox, not yet durable
-    //   ✓   queued   — durably enqueued, waiting for orchestration to drain
-    //   x   cancelling — durable cancel requested, waiting for runtime outcome
-    //   x   rejected — server refused the send (authz); auto-dropped shortly
-    //   ✓✓  sent     — persisted as user.message in CMS, LLM has it
+    //   ○    pending  — client outbox, not yet durable
+    //   ✓    queued   — durably enqueued, waiting for orchestration to drain
+    //   x    cancelling — durable cancel requested, waiting for runtime outcome
+    //   x    rejected — server refused the send (authz); auto-dropped shortly
+    //   ✓✓   sent     — persisted as user.message in CMS, LLM has it
+    //   ✓✓↻  redelivered — the runtime retried the turn and re-delivered this
+    //        message to the model; timestamp shows the LATEST delivery
     let glyph = null;
     let glyphColor = null;
     if (message?.pendingPhase === "pending") {
@@ -1418,6 +1420,11 @@ function buildChatMessagePrefix(message, options = {}) {
             // may not have acted on it. Amber prohibition ("no parking") sign.
             glyph = "⊘";
             glyphColor = "yellow";
+        } else if (message?.redelivered) {
+            // Delivered twice (worker retry replayed the turn). Amber so the
+            // retry is visible without reading as a failure.
+            glyph = "✓✓↻";
+            glyphColor = "yellow";
         } else {
             // Real durable user.message in transcript — show the "sent" double-check.
             glyph = "✓✓";