pilotswarm 0.5.22 → 0.5.24

package/package.json

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

package/tui/src/node-sdk-transport.js

@@ -1690,8 +1690,13 @@ export class NodeSdkTransport {
                         const payload = JSON.parse(body || "{}");
                         const items = Array.isArray(payload?.items) ? payload.items : [];
                         resolve(items
-                            .map((item) => String(item?.metadata?.name || "").trim())
-                            .filter(Boolean));
+                            .map((item) => ({
+                                name: String(item?.metadata?.name || "").trim(),
+                                containers: (Array.isArray(item?.spec?.containers) ? item.spec.containers : [])
+                                    .map((container) => String(container?.name || "").trim())
+                                    .filter(Boolean),
+                            }))
+                            .filter((pod) => pod.name));
                     } catch (error) {
                         reject(error);
                     }
@@ -1709,6 +1714,9 @@ export class NodeSdkTransport {
             timestamps: "true",
             tailLines: String(options.tailLines ?? 500),
         });
+        // Multi-container pods (sidecars, init containers) reject log reads
+        // that don't name a container (400 BadRequest).
+        if (options.container) params.set("container", options.container);
         const pathName = `/api/v1/namespaces/${encodeURIComponent(config.namespace)}/pods/${encodeURIComponent(podName)}/log?${params.toString()}`;
 
         return new Promise((resolve, reject) => {
@@ -1810,9 +1818,9 @@ export class NodeSdkTransport {
         this.logTailHandle = handle;
 
         this.listPodsFromKubeApi(config, labelSelector)
-            .then(async (podNames) => {
+            .then(async (pods) => {
                 if (handle.stopped || this.logTailHandle !== handle) return;
-                if (podNames.length === 0) {
+                if (pods.length === 0) {
                     this.emitSyntheticLogMessage(
                         `No pods matched label selector ${JSON.stringify(labelSelector)} in namespace ${config.namespace}.`,
                         "warn",
@@ -1820,8 +1828,17 @@ export class NodeSdkTransport {
                     return;
                 }
 
+                // Container selection per pod: explicit K8S_LOG_CONTAINER wins,
+                // else the conventional "worker" container when present, else
+                // the pod's first container. Single-container pods work either
+                // way; multi-container pods 400 without an explicit name.
+                const configuredContainer = String(process.env.K8S_LOG_CONTAINER || "").trim();
                 const results = await Promise.allSettled(
-                    podNames.map((podName) => this.streamPodLogsFromKubeApi(config, podName, handle)),
+                    pods.map((pod) => {
+                        const container = configuredContainer
+                            || (pod.containers.includes("worker") ? "worker" : pod.containers[0]);
+                        return this.streamPodLogsFromKubeApi(config, pod.name, handle, container ? { container } : {});
+                    }),
                 );
 
                 if (handle.stopped || this.logTailHandle !== handle) return;

package/ui/core/src/controller.js

@@ -32,6 +32,7 @@ import {
     selectLiveActivityLines,
     selectChatLines,
     selectFileBrowserItems,
+    selectChatOrderedArtifactIds,
     selectFileSessionIdsForScope,
     selectFilesScope,
     selectFilesView,
@@ -1067,6 +1068,9 @@ function normalizePreviewPayload(filename, rawContent, contentType = "", metadat
     };
 }
 
+/** How long a fetched artifact list is trusted before a refetch. */
+const FILES_LIST_TTL_MS = 10_000;
+
 export class PilotSwarmUiController {
     constructor({ store, transport }) {
         this.store = store;
@@ -2761,7 +2765,13 @@ export class PilotSwarmUiController {
 
         const current = this.getState().files.bySessionId[sessionId];
         if (!force && current?.loading) return current;
-        if (!force && current?.loaded) {
+        // A short TTL rather than force-on-every-call. Forcing unconditionally
+        // made the periodic inspector refresh refetch every cycle, which
+        // re-rendered the list and made it visibly flicker. Caching forever was
+        // the original bug. Ten seconds keeps a live agent's new artifacts
+        // appearing on their own without hammering the API.
+        const age = Date.now() - (Number(current?.fetchedAt) || 0);
+        if (!force && current?.loaded && age < FILES_LIST_TTL_MS) {
             if (current.selectedFilename) {
                 await this.ensureFilePreview(sessionId, current.selectedFilename).catch(() => {});
             }
@@ -2771,10 +2781,12 @@ export class PilotSwarmUiController {
         this.dispatch({ type: "files/sessionLoading", sessionId });
         try {
             const entries = await this.transport.listArtifacts(sessionId);
+            const fetchedAt = Date.now();
             this.dispatch({
                 type: "files/sessionLoaded",
                 sessionId,
                 entries,
+                fetchedAt,
             });
             const nextState = this.getState().files.bySessionId[sessionId];
             if (nextState?.selectedFilename) {
@@ -3024,6 +3036,97 @@ export class PilotSwarmUiController {
         return download;
     }
 
+    /**
+     * Bulk selection on the artifact list.
+     *
+     * Marking never moves selectedArtifactId, so the preview keeps showing the
+     * artifact it was already on while you mark others for deletion.
+     */
+    toggleArtifactMark(item) {
+        if (!item?.id) return;
+        this.dispatch({ type: "files/toggleMark", artifactId: item.id });
+    }
+
+    /** Shift-click: mark the contiguous run between the anchor and `item`. */
+    markArtifactRange(item) {
+        if (!item?.id) return;
+        const items = selectFileBrowserItems(this.getState());
+        const marked = this.getState().files.markedIds || [];
+        const anchorId = marked.length > 0 ? marked[marked.length - 1] : this.getState().files.selectedArtifactId;
+        const from = items.findIndex((entry) => entry.id === anchorId);
+        const to = items.findIndex((entry) => entry.id === item.id);
+        if (to < 0) return;
+        if (from < 0) {
+            this.dispatch({ type: "files/toggleMark", artifactId: item.id });
+            return;
+        }
+        const [lo, hi] = from <= to ? [from, to] : [to, from];
+        const range = items.slice(lo, hi + 1).map((entry) => entry.id);
+        this.dispatch({ type: "files/setMarks", artifactIds: [...new Set([...marked, ...range])] });
+    }
+
+    clearArtifactMarks() {
+        this.dispatch({ type: "files/clearMarks" });
+    }
+
+    /** Delete every marked artifact. Confirms once for the whole batch. */
+    async deleteMarkedArtifacts({ confirmed = false } = {}) {
+        const state = this.getState();
+        const markedIds = state.files.markedIds || [];
+        if (markedIds.length === 0) {
+            this.dispatch({ type: "ui/status", text: "No artifacts marked" });
+            return false;
+        }
+        if (typeof this.transport.deleteArtifact !== "function") {
+            this.dispatch({ type: "ui/status", text: "Artifact deletion is not supported by this transport" });
+            return false;
+        }
+        if (!confirmed) {
+            this.dispatch({
+                type: "ui/modal",
+                modal: {
+                    type: "confirm",
+                    title: "Delete Artifacts",
+                    message: `Delete ${markedIds.length} artifact${markedIds.length === 1 ? "" : "s"}? This action cannot be undone.`,
+                    confirmLabel: `Delete ${markedIds.length}`,
+                    action: "deleteMarkedArtifacts",
+                    previousFocus: state.ui.focusRegion,
+                },
+            });
+            return false;
+        }
+
+        const touchedSessions = new Set();
+        let deleted = 0;
+        const failures = [];
+        for (const id of markedIds) {
+            const slash = String(id).indexOf("/");
+            if (slash <= 0) continue;
+            const sessionId = id.slice(0, slash);
+            const filename = id.slice(slash + 1);
+            try {
+                await this.transport.deleteArtifact(sessionId, filename);
+                this.dispatch({ type: "files/deleted", sessionId, filename });
+                touchedSessions.add(sessionId);
+                deleted += 1;
+            } catch (error) {
+                // Keep going: one failure should not strand the rest of the batch.
+                failures.push(`${filename}: ${error?.message || String(error)}`);
+            }
+        }
+        for (const sessionId of touchedSessions) {
+            await this.ensureFilesForSession(sessionId, { force: true }).catch(() => null);
+        }
+        this.dispatch({ type: "files/clearMarks" });
+        this.dispatch({
+            type: "ui/status",
+            text: failures.length > 0
+                ? `Deleted ${deleted}, ${failures.length} failed — ${failures[0]}`
+                : `Deleted ${deleted} artifact${deleted === 1 ? "" : "s"}`,
+        });
+        return failures.length === 0;
+    }
+
     async deleteSelectedArtifact({ confirmed = false } = {}) {
         const state = this.getState();
         const selectedItem = selectSelectedFileBrowserItem(state);
@@ -3228,6 +3331,7 @@ export class PilotSwarmUiController {
 
     async selectFileBrowserItem(item) {
         if (!item?.sessionId || !item?.filename) return;
+        this.dispatch({ type: "files/previewOrigin", origin: "list" });
         const scope = selectFilesScope(this.getState());
         if (scope === "allSessions") {
             this.dispatch({
@@ -3870,7 +3974,7 @@ export class PilotSwarmUiController {
     }
 
     setChatViewMode(mode) {
-        if (mode !== "summary" && mode !== "transcript") return;
+        if (mode !== "summary" && mode !== "transcript" && mode !== "rich") return;
         if (this.getActiveSession()?.isGroup) return;
         this.dispatch({ type: "ui/chatViewMode", mode });
     }
@@ -4331,6 +4435,129 @@ export class PilotSwarmUiController {
         return created.sessionId;
     }
 
+    /**
+     * Reveal an artifact in the Files tab with its preview loaded.
+     *
+     * The entry point for artifact links in the chat transcript: the chat only
+     * ever offered "download", which is the wrong verb for a patch you want to
+     * READ. Switches the inspector to Files, selects the artifact, and warms
+     * the preview so the pane is populated by the time it renders.
+     */
+    async revealArtifact(sessionId, filename, { force = true, fullscreen = false } = {}) {
+        const resolvedSessionId = sessionId || this.getState().sessions.activeSessionId;
+        const name = String(filename || "").trim();
+        if (!resolvedSessionId || !name) return false;
+
+        // Capture the list's current selection BEFORE we move it, so backing
+        // out of a chat-opened preview leaves the artifact list untouched.
+        this.dispatch({
+            type: "files/previewOrigin",
+            origin: "chat",
+            restoreArtifactId: this.getState().files.selectedArtifactId || null,
+        });
+
+        if (this.getState().sessions.activeSessionId !== resolvedSessionId) {
+            await this.loadSession(resolvedSessionId).catch(() => null);
+        }
+        this.dispatch({ type: "ui/inspectorTab", inspectorTab: "files" });
+        // Focus the inspector, not just the tab. On desktop this makes j/k
+        // drive the artifact list immediately; on mobile the visible pane is
+        // derived from focusRegion, so without this the preview would open on
+        // a pane the user cannot see.
+        this.setFocus("inspector");
+        await this.ensureFilesForSession(resolvedSessionId, { force }).catch(() => null);
+        this.dispatch({ type: "files/select", sessionId: resolvedSessionId, filename: name });
+        await this.ensureFilePreview(resolvedSessionId, name, { force }).catch(() => null);
+        if (fullscreen) this.dispatch({ type: "files/fullscreen", fullscreen: true });
+        return true;
+    }
+
+    /**
+     * Leave the artifact preview, returning wherever the user came FROM.
+     *
+     * A chat-opened preview backs out to the chat pane and restores the list's
+     * previous selection — following a link from the transcript must not
+     * reorganize the Files tab behind the user's back. A list-opened preview
+     * just drops out of full screen and stays on the list.
+     */
+    async closeArtifactPreview() {
+        const state = this.getState();
+        const origin = state.files.previewOrigin;
+        this.dispatch({ type: "files/fullscreen", fullscreen: false });
+
+        if (origin !== "chat") {
+            this.dispatch({ type: "files/previewOrigin", origin: null });
+            this.setFocus(FOCUS_REGIONS.INSPECTOR);
+            return;
+        }
+
+        const restoreId = state.files.restoreArtifactId;
+        if (restoreId) {
+            const slash = String(restoreId).indexOf("/");
+            if (slash > 0) {
+                this.dispatch({
+                    type: "files/select",
+                    sessionId: restoreId.slice(0, slash),
+                    filename: restoreId.slice(slash + 1),
+                });
+            }
+        } else {
+            this.dispatch({ type: "files/select", sessionId: null, filename: null });
+        }
+        this.dispatch({ type: "files/previewOrigin", origin: null });
+        // Dispatch the focus DIRECTLY rather than via setFocus: that runs the
+        // region through normalizeFocusRegion, which falls back to order[0]
+        // when the region is missing from the current layout's focus order —
+        // so "chat" was being clamped to the inspector and back-from-chat
+        // landed on the artifact list instead of the transcript.
+        this.dispatch({ type: "ui/focus", focusRegion: FOCUS_REGIONS.CHAT });
+    }
+
+    /**
+     * Step the preview to the next/previous artifact. Never wraps.
+     *
+     * A chat-opened preview walks the CONVERSATION order — the order the work
+     * happened in — while a list-opened one walks the Files list order, which
+     * is sorted for browsing. Same buttons, two sequences, chosen by origin.
+     */
+    async stepArtifactPreview(delta) {
+        const state = this.getState();
+        if (state.files.previewOrigin !== "chat") {
+            await this.moveFileSelection(delta);
+            return;
+        }
+        const ordered = selectChatOrderedArtifactIds(state);
+        if (ordered.length === 0) {
+            await this.moveFileSelection(delta);
+            return;
+        }
+        const currentIndex = ordered.indexOf(state.files.selectedArtifactId);
+        // Unknown current position: start from whichever end we are heading in
+        // from, rather than silently doing nothing.
+        const from = currentIndex >= 0 ? currentIndex : (delta > 0 ? -1 : ordered.length);
+        const nextIndex = from + (delta > 0 ? 1 : -1);
+        if (nextIndex < 0 || nextIndex >= ordered.length) return;   // no wraparound
+        const nextId = ordered[nextIndex];
+        const slash = nextId.indexOf("/");
+        if (slash <= 0) return;
+        const sessionId = nextId.slice(0, slash);
+        const filename = nextId.slice(slash + 1);
+        this.dispatch({ type: "files/select", sessionId, filename });
+        await this.ensureFilePreview(sessionId, filename).catch(() => {});
+    }
+
+    /** Can the preview step in this direction? Drives arrow disabled state. */
+    canStepArtifactPreview(delta) {
+        const state = this.getState();
+        const ordered = state.files.previewOrigin === "chat"
+            ? selectChatOrderedArtifactIds(state)
+            : selectFileBrowserItems(state).map((item) => item.id);
+        if (ordered.length === 0) return false;
+        const i = ordered.indexOf(state.files.selectedArtifactId);
+        if (i < 0) return true;
+        return delta > 0 ? i < ordered.length - 1 : i > 0;
+    }
+
     async finalizeArtifactUpload(upload, { sessionId = null, suppressStatus = false } = {}) {
         const resolvedSessionId = sessionId || upload?.sessionId || await this.ensurePromptAttachmentSessionId();
         if (!resolvedSessionId || !upload?.filename) {
@@ -5160,6 +5387,8 @@ export class PilotSwarmUiController {
                 await this.regenerateActiveSession({ confirmed: true, ...(modal.extras || {}) });
             } else if (modal.action === "deleteArtifact") {
                 await this.deleteSelectedArtifact({ confirmed: true });
+            } else if (modal.action === "deleteMarkedArtifacts") {
+                await this.deleteMarkedArtifacts({ confirmed: true });
             }
             return;
         }
@@ -6058,10 +6287,30 @@ export class PilotSwarmUiController {
         });
     }
 
+    /** True when the artifact preview has taken over the activity slot. */
+    artifactPreviewOwnsActivitySlot(state = this.getState()) {
+        return state.ui.inspectorTab === "files" && Boolean(state.files?.selectedArtifactId);
+    }
+
+    /** Inspector focus with the Files tab open = the artifact list is driving. */
+    focusIsArtifactList(state = this.getState()) {
+        return state.ui.focusRegion === FOCUS_REGIONS.INSPECTOR && state.ui.inspectorTab === "files";
+    }
+
     getScrollablePaneForFocus() {
-        const focus = this.getState().ui.focusRegion;
+        const state = this.getState();
+        const focus = state.ui.focusRegion;
         if (focus === FOCUS_REGIONS.CHAT) return "chat";
-        if (focus === FOCUS_REGIONS.ACTIVITY) return "activity";
+        if (focus === FOCUS_REGIONS.ACTIVITY) {
+            // The preview occupies the activity slot while an artifact is
+            // selected, so activity focus must scroll the PREVIEW. This is what
+            // lets clicking the list and clicking the preview mean different
+            // things: the list keeps inspector focus (arrows move the
+            // selection) while the preview claims activity focus (arrows
+            // scroll it).
+            if (this.artifactPreviewOwnsActivitySlot(state)) return "filePreview";
+            return "activity";
+        }
         if (focus === FOCUS_REGIONS.INSPECTOR) {
             if (this.getState().ui.inspectorTab === "files") return "filePreview";
             return "inspector";
@@ -6659,7 +6908,14 @@ export class PilotSwarmUiController {
         });
     }
 
-    async regenerateActiveSession({ confirmed = false, instructions = "", distillMode = "llm" } = {}) {
+    async regenerateActiveSession({
+        confirmed = false,
+        instructions = "",
+        distillMode = "llm",
+        distillerModel = "",
+        distillerEffort = "",
+        distillerContextTier = "",
+    } = {}) {
         const state = this.getState();
         const sessionId = state.sessions.activeSessionId;
         if (!sessionId) return;
@@ -6695,7 +6951,18 @@ export class PilotSwarmUiController {
                     // Distillation inputs the portal's renderer binds via
                     // updateConfirmExtras; plain-confirm renderers submit these
                     // defaults untouched.
-                    extras: { instructions: "", distillMode: "llm" },
+                    extras: {
+                        instructions: "",
+                        distillMode: "llm",
+                        // Empty = deployment default (cluster default model,
+                        // model's own default effort/tier). The distiller runs
+                        // on machinery config, NOT the served session's model,
+                        // so these are explicit choices rather than inherited.
+                        distillerModel: "",
+                        distillerEffort: "",
+                        distillerContextTier: "",
+                        distillerModelOptions: await this._loadDistillerModelOptions(),
+                    },
                 },
             });
             return;
@@ -6709,6 +6976,9 @@ export class PilotSwarmUiController {
                 force: true,
                 ...(trimmed ? { instructions: trimmed.slice(0, 4000) } : {}),
                 ...(distillMode === "deterministic" ? { distillMode: "deterministic" } : {}),
+                ...(distillerModel ? { distillerModel } : {}),
+                ...(distillerEffort ? { distillerReasoningEffort: distillerEffort } : {}),
+                ...(distillerContextTier ? { distillerContextTier } : {}),
             });
             this.dispatch({ type: "ui/status", text: `Regeneration requested for ${sessionId.slice(0, 8)} — rebuilding at the next boundary` });
         } catch (error) {
@@ -6718,6 +6988,49 @@ export class PilotSwarmUiController {
         await this.refreshSessions();
     }
 
+    /**
+     * Model choices for the regen distiller picker: qualified name plus the
+     * efforts / context tiers each model actually supports, so the UI can
+     * offer only valid combinations. Failure is non-fatal — the picker simply
+     * falls back to "deployment default".
+     */
+    async _loadDistillerModelOptions() {
+        if (typeof this.transport.listModels !== "function") return [];
+        try {
+            // The web transport's listModels() takes no arguments and returns a
+            // FLAT model list, while the direct transport can return provider
+            // groups. Reading only `group.models` flatMapped the flat shape to
+            // nothing, so the portal offered "deployment default" and nothing
+            // else — with the catch below hiding it. Accept both shapes.
+            const raw = await this.transport.listModels({ groupByProvider: true });
+            const top = Array.isArray(raw)
+                ? raw
+                : (Array.isArray(raw?.providers) ? raw.providers
+                    : (Array.isArray(raw?.models) ? raw.models : []));
+            const list = top.flatMap((entry) => (
+                Array.isArray(entry?.models)
+                    ? entry.models.map((m) => ({ ...m, providerId: m.providerId || entry.providerId }))
+                    : [entry]
+            ));
+            return list.filter((model) => model && (model.qualifiedName || model.modelName)).map((model) => ({
+                qualifiedName: model.qualifiedName || model.modelName,
+                modelName: model.modelName || model.qualifiedName,
+                providerId: model.providerId || "",
+                supportedReasoningEfforts: Array.isArray(model.supportedReasoningEfforts)
+                    ? model.supportedReasoningEfforts
+                    : [],
+                supportedContextTiers: Array.isArray(model.supportedContextTiers)
+                    ? model.supportedContextTiers
+                    : [],
+            }));
+        } catch (error) {
+            // Previously swallowed silently, which is how an empty picker
+            // looked like "no models configured" instead of a failed call.
+            this.dispatch({ type: "ui/status", text: `Could not load distiller models: ${error?.message || String(error)}` });
+            return [];
+        }
+    }
+
     /**
      * Stop the active session's in-flight LLM turn without touching session
      * lifecycle. Applies to user AND system sessions; only group/container
@@ -7265,6 +7578,12 @@ export class PilotSwarmUiController {
                     await this.moveSessionPage(-1);
                     return;
                 }
+                // Focused on the artifact LIST: page the selection, not a
+                // scroll offset — the list is the thing being driven there.
+                if (this.focusIsArtifactList()) {
+                    await this.moveFileSelection(-10);
+                    return;
+                }
                 this.scrollCurrentPane(10);
                 return;
             case UI_COMMANDS.PAGE_DOWN:
@@ -7272,6 +7591,10 @@ export class PilotSwarmUiController {
                     await this.moveSessionPage(1);
                     return;
                 }
+                if (this.focusIsArtifactList()) {
+                    await this.moveFileSelection(10);
+                    return;
+                }
                 this.scrollCurrentPane(-10);
                 return;
             case UI_COMMANDS.EXPAND_HISTORY:

package/ui/core/src/formatting.js

@@ -100,6 +100,44 @@ export function shortModelName(model) {
     return value.includes(":") ? value.split(":").slice(1).join(":") : value;
 }
 
+/**
+ * Compact timestamp for fixed-width columns (the sequence pane).
+ *
+ * formatTimestamp renders "26 Jul 20:10:19" once a row is older than today —
+ * 15 characters into a column sized for "20:10:19", so the date-bearing rows
+ * clipped to "26 Jul …" and the time was lost entirely. Dropping the seconds
+ * and the space inside the date gets a dated stamp to 11 characters, which
+ * fits alongside the same-day form without stealing width from the lanes.
+ */
+export function formatTimestampCompact(value, now = new Date()) {
+    if (!value) return "";
+    try {
+        const date = value instanceof Date ? value : new Date(value);
+        if (Number.isNaN(date.getTime())) return "";
+        const hhmm = date.toLocaleTimeString(undefined, {
+            hour: "2-digit", minute: "2-digit", hour12: false,
+        });
+        const sameLocalDay = date.getFullYear() === now.getFullYear()
+            && date.getMonth() === now.getMonth()
+            && date.getDate() === now.getDate();
+        if (sameLocalDay) {
+            return date.toLocaleTimeString(undefined, {
+                hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false,
+            });
+        }
+        const day = String(date.getDate());
+        const month = date.toLocaleDateString("en-GB", { month: "short" });
+        // Year only when it differs — a two-digit suffix, since the column is
+        // shared with same-day rows and every extra char costs lane width.
+        const year = date.getFullYear() === now.getFullYear()
+            ? ""
+            : String(date.getFullYear()).slice(-2);
+        return `${day}${month}${year} ${hhmm}`;
+    } catch {
+        return "";
+    }
+}
+
 export function formatTimestamp(value, now = new Date()) {
     if (!value) return "";
     try {
@@ -403,7 +441,14 @@ export function decorateArtifactLinksForChat(text) {
     const source = String(text || "");
     if (!source) return source;
     ARTIFACT_URI_RE.lastIndex = 0;
-    const withArtifacts = source.replace(ARTIFACT_URI_RE, (_match, sessionId, rawFilename) => {
+    const withArtifacts = source.replace(ARTIFACT_URI_RE, (_match, sessionId, rawFilename, offset, whole) => {
+        // IDEMPOTENCE. This runs from ~8 call sites and some paths decorate the
+        // same text twice. A bare `artifact://` becomes `[artifact: f](artifact://…)`,
+        // and on a second pass the URI now sitting inside the link TARGET matched
+        // again, producing a nested link whose href was `[artifact: f](artifact://…`.
+        // The browser then treated that as a relative URL and navigated away from
+        // the SPA entirely. Skip any URI already in a markdown link target.
+        if (whole.slice(Math.max(0, offset - 2), offset) === "](") return _match;
         const filename = normalizeArtifactFilename(rawFilename);
         if (!sessionId || !filename) return _match;
         return `[artifact: ${filename}](artifact://${sessionId}/${filename}) (press a to download)`;

package/ui/core/src/history.js

@@ -24,6 +24,12 @@ export const CHAT_HISTORY_EVENT_TYPES = [
     // 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",
+    // A regeneration that was accepted and then FAILED downstream (archive or
+    // distill). Previously invisible: the tool returns an optimistic ack on
+    // enqueue, so a failure left the agent reporting success while the epoch
+    // silently never flipped. Observed live — two attempts died on
+    // ARTIFACT_TOO_LARGE with nothing shown in the transcript.
+    "session.regenerate_failed",
 ];
 
 // Build the inline transcript divider marking a session-regeneration epoch
@@ -58,6 +64,20 @@ function buildRegenRefusedItem(event) {
     };
 }
 
+function buildRegenFailedItem(event) {
+    const data = event?.data && typeof event.data === "object" ? event.data : {};
+    const rawError = typeof data.error === "string" ? data.error : "";
+    return {
+        id: `${event.sessionId}:${event.seq}:regen-failed`,
+        kind: "regen-failed",
+        role: "regen-failed",
+        stage: typeof data.stage === "string" ? data.stage : "unknown",
+        error: rawError,
+        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);
@@ -947,6 +967,10 @@ export function buildHistoryModel(events = [], options = {}) {
             chat.push(buildRegenRefusedItem(event));
             continue;
         }
+        if (event.eventType === "session.regenerate_failed") {
+            chat.push(buildRegenFailedItem(event));
+            continue;
+        }
         const activityItem = formatActivity(event);
         if (activityItem) activity.push(activityItem);
     }
@@ -1054,6 +1078,11 @@ export function appendEventToHistory(history, event) {
         next.chat = clampHistoryItems(next.chat, loadedEventLimit);
         return next;
     }
+    if (event.eventType === "session.regenerate_failed") {
+        next.chat.push(buildRegenFailedItem(event));
+        next.chat = clampHistoryItems(next.chat, loadedEventLimit);
+        return next;
+    }
     const activityItem = formatActivity(event);
     if (activityItem) {
         next.activity.push(activityItem);