pilotswarm 0.5.19 → 0.5.21

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);
@@ -4589,11 +4651,16 @@ export class PilotSwarmUiController {
             type: "ui/modal",
             modal: {
                 type: "terminatePicker",
-                title: `Terminate (${shortSessionIdValue(sessionId)})`,
+                title: `Lifecycle (${shortSessionIdValue(sessionId)})`,
                 sessionId,
                 previousFocus: state.ui.focusRegion,
                 sessionTitle: String(session.title || "").trim(),
                 state: String(session.state || "").trim(),
+                // Regenerate (epoch rebirth) is a single-session, non-system,
+                // non-group action; the picker surfaces it above the terminal
+                // dispositions when the transport supports it. Service sessions
+                // (⚗ machinery, e.g. the distiller itself) are never regenerated.
+                canRegenerate: typeof this.transport.regenerateSession === "function" && !session.serviceKind,
             },
         });
     }
@@ -4615,6 +4682,8 @@ export class PilotSwarmUiController {
             await this.cancelActiveSession();
         } else if (action === "delete") {
             await this.deleteActiveSession();
+        } else if (action === "regenerate") {
+            await this.regenerateActiveSession();
         }
     }
 
@@ -5087,6 +5156,8 @@ export class PilotSwarmUiController {
                 await this.completeActiveSession("Completed by user", { confirmed: true });
             } else if (modal.action === "deleteSession") {
                 await this.deleteActiveSession({ confirmed: true });
+            } else if (modal.action === "regenerateSession") {
+                await this.regenerateActiveSession({ confirmed: true, ...(modal.extras || {}) });
             } else if (modal.action === "deleteArtifact") {
                 await this.deleteSelectedArtifact({ confirmed: true });
             }
@@ -6565,6 +6636,88 @@ export class PilotSwarmUiController {
         await this.refreshSessions();
     }
 
+    /**
+     * Regenerate the active session's context in place (epoch rebirth): archive
+     * the transcript, distill it into a resume package, and rebuild the Copilot
+     * session at the next turn boundary. NON-destructive — facts, artifacts,
+     * children, sharing, schedule, and chat history are preserved; only the
+     * LLM's working context is compacted and recreated. Enqueue-then-observe:
+     * the outcome arrives asynchronously as session.regenerate_* / epoch events.
+     */
+    /**
+     * Merge extra inputs (distilling instructions, distill mode) into the open
+     * confirm modal. The portal's regenerate confirm renders a textarea + mode
+     * select bound here; the TUI renders the same modal as a plain confirm and
+     * simply submits the defaults — graceful degradation, no TUI-side wiring.
+     */
+    updateConfirmExtras(patch) {
+        const modal = this.getState().ui.modal;
+        if (!modal || modal.type !== "confirm") return;
+        this.dispatch({
+            type: "ui/modal",
+            modal: { ...modal, extras: { ...(modal.extras || {}), ...(patch || {}) } },
+        });
+    }
+
+    async regenerateActiveSession({ confirmed = false, instructions = "", distillMode = "llm" } = {}) {
+        const state = this.getState();
+        const sessionId = state.sessions.activeSessionId;
+        if (!sessionId) return;
+        if (typeof this.transport.regenerateSession !== "function") {
+            this.dispatch({ type: "ui/status", text: "Session regeneration is not supported by this deployment" });
+            return;
+        }
+        const activeSession = state.sessions.byId[sessionId];
+        if (activeSession?.isGroup) {
+            this.dispatch({ type: "ui/status", text: "Groups are containers; regenerate sessions individually." });
+            return;
+        }
+        if (activeSession?.isSystem) {
+            this.dispatch({ type: "ui/status", text: "System sessions cannot be regenerated." });
+            return;
+        }
+        if (activeSession?.serviceKind) {
+            this.dispatch({ type: "ui/status", text: "Service sessions are runtime machinery and cannot be regenerated." });
+            return;
+        }
+        if (!confirmed) {
+            const label = activeSession?.title || sessionId.slice(0, 8);
+            this.dispatch({
+                type: "ui/modal",
+                modal: {
+                    type: "confirm",
+                    title: "Regenerate Session",
+                    message: `Regenerate context for "${label}"? The transcript is archived and distilled, then the session rebuilds fresh from it at the next turn boundary. Facts, artifacts, sub-agents, sharing, schedule, and chat history are preserved. As an operator action this overrides the rate limits (cooldown / minimum age).`,
+                    confirmLabel: "Regenerate",
+                    action: "regenerateSession",
+                    sessionId,
+                    previousFocus: state.ui.focusRegion,
+                    // Distillation inputs the portal's renderer binds via
+                    // updateConfirmExtras; plain-confirm renderers submit these
+                    // defaults untouched.
+                    extras: { instructions: "", distillMode: "llm" },
+                },
+            });
+            return;
+        }
+        try {
+            // Operator action behind a confirm — force past the soft rate limits
+            // (cooldown / min-age). Hard gates (system session, regen in flight)
+            // still apply server-side.
+            const trimmed = String(instructions || "").trim();
+            await this.transport.regenerateSession(sessionId, {
+                force: true,
+                ...(trimmed ? { instructions: trimmed.slice(0, 4000) } : {}),
+                ...(distillMode === "deterministic" ? { distillMode: "deterministic" } : {}),
+            });
+            this.dispatch({ type: "ui/status", text: `Regeneration requested for ${sessionId.slice(0, 8)} — rebuilding at the next boundary` });
+        } catch (error) {
+            this.dispatch({ type: "ui/status", text: `Regenerate failed: ${error?.message || String(error)}` });
+            return;
+        }
+        await this.refreshSessions();
+    }
+
     /**
      * Stop the active session's in-flight LLM turn without touching session
      * lifecycle. Applies to user AND system sessions; only group/container
@@ -6820,6 +6973,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 +7079,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();
     }
@@ -7140,6 +7295,9 @@ export class PilotSwarmUiController {
             case UI_COMMANDS.DELETE_SESSION:
                 await this.deleteActiveSession();
                 return;
+            case UI_COMMANDS.REGENERATE_SESSION:
+                await this.regenerateActiveSession();
+                return;
             case UI_COMMANDS.PIN_SESSION:
                 this.togglePinActiveSession();
                 return;

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

@@ -18,8 +18,46 @@ export const CHAT_HISTORY_EVENT_TYPES = [
     "user.message",
     "assistant.message",
     "system.message",
+    // Session regeneration boundary — rendered as an inline epoch divider in
+    // the transcript, so it must survive backward chat-history paging.
+    "session.epoch_committed",
+    // A refused regeneration — surfaced inline so the optimistic "regeneration
+    // accepted" ack is corrected by the real outcome (e.g. cooldown/too_young).
+    "session.regenerate_refused",
 ];
 
+// Build the inline transcript divider marking a session-regeneration epoch
+// flip (proposal M2). The epoch_committed seq IS the epoch boundary, so the
+// divider lands between the archived (old-epoch) turns and the fresh ones.
+function buildEpochDividerItem(event) {
+    const data = event?.data && typeof event.data === "object" ? event.data : {};
+    const epoch = Number.isFinite(data.toEpoch) ? data.toEpoch : (Number(data.epoch) || 0);
+    const turnsArchived = Number.isFinite(data.turnsArchived) ? data.turnsArchived : null;
+    return {
+        id: `${event.sessionId}:${event.seq}:epoch`,
+        kind: "epoch-divider",
+        role: "epoch-divider",
+        epoch,
+        turnsArchived,
+        time: formatTimestamp(event.createdAt),
+        createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+    };
+}
+
+// A refused regeneration attempt, rendered inline so the truth (e.g. cooldown,
+// too_young) corrects the optimistic "regeneration accepted" the tool returns.
+function buildRegenRefusedItem(event) {
+    const data = event?.data && typeof event.data === "object" ? event.data : {};
+    return {
+        id: `${event.sessionId}:${event.seq}:regen-refused`,
+        kind: "regen-refused",
+        role: "regen-refused",
+        reason: typeof data.reason === "string" ? data.reason : "unknown",
+        time: formatTimestamp(event.createdAt),
+        createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+    };
+}
+
 function clampHistoryItems(items, maxItems) {
     const list = Array.isArray(items) ? items.filter(Boolean) : [];
     const safeMax = Math.max(DEFAULT_HISTORY_EVENT_LIMIT, Number(maxItems) || DEFAULT_HISTORY_EVENT_LIMIT);
@@ -311,6 +349,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 +364,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 +399,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;
@@ -870,6 +939,14 @@ export function buildHistoryModel(events = [], options = {}) {
             }
             continue;
         }
+        if (event.eventType === "session.epoch_committed") {
+            chat.push(buildEpochDividerItem(event));
+            continue;
+        }
+        if (event.eventType === "session.regenerate_refused") {
+            chat.push(buildRegenRefusedItem(event));
+            continue;
+        }
         const activityItem = formatActivity(event);
         if (activityItem) activity.push(activityItem);
     }
@@ -967,6 +1044,16 @@ export function appendEventToHistory(history, event) {
         }
         return next;
     }
+    if (event.eventType === "session.epoch_committed") {
+        next.chat.push(buildEpochDividerItem(event));
+        next.chat = clampHistoryItems(next.chat, loadedEventLimit);
+        return next;
+    }
+    if (event.eventType === "session.regenerate_refused") {
+        next.chat.push(buildRegenRefusedItem(event));
+        next.chat = clampHistoryItems(next.chat, loadedEventLimit);
+        return next;
+    }
     const activityItem = formatActivity(event);
     if (activityItem) {
         next.activity.push(activityItem);

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

@@ -513,8 +513,16 @@ function canPinSessionRow(session) {
 
 function buildSelectedSessionMetaRuns(session, mode) {
     const runs = [];
+    // Live regeneration chip: the orchestration publishes regenStage in
+    // customStatus while the pipeline runs (archiving → distilling →
+    // flipping) and getSession spreads it onto the session view. Magenta to
+    // match the epoch divider; disappears when the flip lands.
+    if (typeof session?.regenStage === "string" && session.regenStage) {
+        runs.push({ text: `↻ regen:${session.regenStage}`, color: "magenta" });
+    }
     const statusLabel = getSessionRowStatusLabel(session);
     if (statusLabel) {
+        if (runs.length > 0) runs.push({ text: " · ", color: "gray" });
         runs.push({ text: statusLabel, color: sessionStatusColor(session, mode) });
     }
 
@@ -584,6 +592,10 @@ function buildSessionRowView(entry, session, state, totalDescendantCounts, visib
         prefixRuns.push({ text: "🗂  ", color: "cyan", bold: true });
     } else if (session?.isSystem) {
         prefixRuns.push({ text: "⚙ ", color: "yellow", bold: true });
+    } else if (session?.serviceKind) {
+        // Service session (tree-scoped machinery, e.g. the regen distiller):
+        // the alembic marks it as read-only distillation machinery.
+        prefixRuns.push({ text: "⚗ ", color: "magenta", bold: true });
     } else {
         const icon = sessionStatusIcon(session, mode);
         prefixRuns.push({
@@ -1396,11 +1408,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 +1432,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 = "✓✓";
@@ -2280,8 +2299,14 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     };
     const lines = [];
     for (const [index, message] of messages.entries()) {
-        const messageLines = buildChatMessageLines(message, maxWidth, buildOptions);
-        appendChatBlockLines(lines, messageLines);
+        if (message?.kind === "epoch-divider") {
+            lines.push(buildEpochDividerLine(message, maxWidth));
+        } else if (message?.kind === "regen-refused") {
+            lines.push(buildRegenRefusedLine(message, maxWidth));
+        } else {
+            const messageLines = buildChatMessageLines(message, maxWidth, buildOptions);
+            appendChatBlockLines(lines, messageLines);
+        }
         const nextMessage = messages[index + 1];
         if (
             nextMessage
@@ -2294,6 +2319,55 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     return lines.length > 0 ? lines : [{ text: "No messages yet.", color: "gray" }];
 }
 
+// A centered inline rule ("──── label ────") for transcript markers. The dash
+// runs are CAPPED (not stretched to maxWidth): the web portal wraps by pixel
+// width, and a maxWidth-long "─" run overflows a narrower pane and wraps the
+// rule mid-label. A short symmetric rule reads as a divider on every width, and
+// when the label alone will not fit it is rendered bare (wraps as plain text,
+// never as dangling dash fragments).
+function buildRuleLine(label, color, maxWidth) {
+    const safeWidth = Math.max(24, Number(maxWidth) || 80);
+    const room = safeWidth - label.length;
+    if (room < 2) return [{ text: label.trim(), color, bold: true }];
+    const perSide = Math.min(6, Math.floor(room / 2));
+    if (perSide < 1) return [{ text: label.trim(), color, bold: true }];
+    return [
+        { text: "─".repeat(perSide), color },
+        { text: label, color, bold: true },
+        { text: "─".repeat(perSide), color },
+    ];
+}
+
+// The inline transcript divider for a session-regeneration epoch flip — magenta,
+// with the new epoch and the count of archived turns (proposal M2).
+function buildEpochDividerLine(message, maxWidth) {
+    const turns = Number.isFinite(message?.turnsArchived) ? message.turnsArchived : null;
+    const label = ` ↻ context regenerated · epoch ${message?.epoch ?? "?"}`
+        + `${turns != null ? ` · ${turns} turn${turns === 1 ? "" : "s"} archived` : ""} `;
+    return buildRuleLine(label, "magenta", maxWidth);
+}
+
+// Friendly (compact) text for the orchestration's regenerate_refused reasons
+// (lifecycle.ts). Kept short so the inline rule fits on one line.
+const REGEN_REFUSED_REASONS = {
+    cooldown: "on cooldown (once per 6h)",
+    too_young: "too soon (needs 5+ turns)",
+    already_pending: "already in progress",
+    is_system: "not allowed for system sessions",
+    not_owner: "owner only",
+    not_parent: "parent only",
+};
+
+// The inline notice for a refused regeneration. Yellow (vs the magenta success
+// divider) so a no-op attempt reads as a warning, correcting the tool's
+// optimistic "regeneration accepted" acknowledgement.
+function buildRegenRefusedLine(message, maxWidth) {
+    const reason = String(message?.reason || "unknown");
+    const text = REGEN_REFUSED_REASONS[reason] || reason.replace(/_/g, " ");
+    const label = ` ↻ regeneration refused · ${text} `;
+    return buildRuleLine(label, "yellow", maxWidth);
+}
+
 export function selectOutboxOverlayLines(state, maxWidth = 80, options = {}) {
     const messages = selectActiveOutboxMessages(state);
     if (!messages || messages.length === 0) return [];
@@ -3990,7 +4064,7 @@ function buildNodeMapCell(session, brandingTitle, width, active) {
             ? canonicalSystemTitle(session, brandingTitle)
             : (session?.title || shortSessionId(session?.sessionId)))
         : shortSessionId(session?.sessionId);
-    const prefix = session?.isSystem ? "⚙ " : `${sessionStatusIcon(session) || "."} `;
+    const prefix = session?.isSystem ? "⚙ " : session?.serviceKind ? "⚗ " : `${sessionStatusIcon(session) || "."} `;
     const text = padDisplayText(`${prefix}${label}`, width);
 
     if (active) {
@@ -5149,10 +5223,28 @@ function buildSessionStatsLines(state, session, maxWidth) {
     }));
     lines.push(plainInspectorLine(""));
 
-    // Persistence card
+    // Persistence card. Epoch (session-regeneration incarnation) is always
+    // shown — 0 for a session that has never regenerated — so the current
+    // epoch is visible at a glance; regen counters appear once it has.
+    const regenCount = Number(summary.regenCount) || 0;
+    const lastRegen = summary.lastRegenStats && typeof summary.lastRegenStats === "object" ? summary.lastRegenStats : null;
+    const currentEpoch = Number.isFinite(lastRegen?.toEpoch) ? lastRegen.toEpoch : regenCount;
+    // Distillation provenance: "fast" = deterministic package; otherwise the
+    // distiller model label (strip the provider: prefix for width).
+    const distillLabel = lastRegen
+        ? (lastRegen.distillMode === "deterministic" || (!lastRegen.distillMode && !lastRegen.distillerModel)
+            ? "fast"
+            : String(lastRegen.distillerModel || "llm").replace(/^[^:]*:/, ""))
+        : null;
+    const lastRegenLabel = lastRegen
+        ? `${lastRegen.turnsArchived ?? 0} turn${lastRegen.turnsArchived === 1 ? "" : "s"} · ${(Number(lastRegen.totalMs) / 1000).toFixed(1)}s${distillLabel ? ` · ${distillLabel}` : ""}`
+        : null;
     lines.push(...buildMessageCardLines({
         title: "Persistence",
         body: formatKeyValueTable([
+            ["Epoch",           String(currentEpoch)],
+            ["Regens",          regenCount > 0 ? String(regenCount) : null],
+            ["Last Regen",      lastRegenLabel],
             ["Snapshot",        formatCompactBytes(summary.snapshotSizeBytes)],
             ["Uncompressed",    summary.rawSizeBytes ? formatCompactBytes(summary.rawSizeBytes) : null],
             ["Compression",     formatCompressionRatio(summary.rawSizeBytes, summary.snapshotSizeBytes)],