pilotswarm 0.5.34 → 0.5.35

package/package.json

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

package/ui/core/src/controller.js

@@ -24,6 +24,8 @@ import {
     MIN_ACTIVITY_PANE_HEIGHT,
     MIN_INSPECTOR_PANE_HEIGHT,
     DEFAULT_ACTIVITY_PANE_RATIO,
+    DEFAULT_LEFT_PANE_RATIO,
+    COLLAPSE_RIGHT_THRESHOLD,
     normalizeFocusRegion,
 } from "./layout.js";
 import { parseTerminalMarkupRuns } from "./formatting.js";
@@ -680,7 +682,7 @@ function getRenameSessionPrefix(session) {
     if (separatorIndex > 0) {
         return currentTitle.slice(0, separatorIndex).trim() || null;
     }
-    return currentTitle || null;
+    return null;
 }
 
 function getRenameSessionMaxLength(session) {
@@ -1243,6 +1245,12 @@ function isBinaryPreview(filename, contentType = "") {
         || normalizedType === "application/wasm";
 }
 
+// How recent a `session.artifact_presented` event must be for the portal to
+// act on it. Long enough to survive a slow turn and a brief reconnect; short
+// enough that a catch-up burst after a long disconnect does not reorganize the
+// workspace around something the agent said ages ago.
+const PRESENTED_ARTIFACT_FRESHNESS_MS = 120_000;
+
 function truncateFilePreview(content, limit = FILE_PREVIEW_CHAR_LIMIT) {
     const text = String(content ?? "");
     if (text.length <= limit) return text;
@@ -4195,6 +4203,32 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * Act on a `session.artifact_presented` event from the live stream.
+     *
+     * Separate from mergeSessionEvent so the guards are testable on their own
+     * and so the merge path stays a straight line. Returns whether it revealed.
+     */
+    maybeRevealPresentedArtifact(sessionId, event) {
+        const filename = String(event?.data?.filename || "").trim();
+        if (!filename) return false;
+        if (sessionId !== this.getState().sessions.activeSessionId) return false;
+
+        const createdAt = event?.createdAt ? Date.parse(event.createdAt) : Number.NaN;
+        if (Number.isFinite(createdAt) && Date.now() - createdAt > PRESENTED_ARTIFACT_FRESHNESS_MS) {
+            return false;
+        }
+
+        // Same destination a user click reaches: the artifact reader, with the
+        // chat still beside it. `fullscreen` from the tool means "give it the
+        // whole window" and stays the phone/fullscreen path.
+        const fullscreen = event?.data?.fullscreen === true;
+        this.revealArtifact(sessionId, filename, fullscreen
+            ? { fullscreen: true }
+            : { pane: true }).catch(() => {});
+        return true;
+    }
+
     mergeSessionEvent(sessionId, event) {
         if (!sessionId || !event) return false;
         const state = this.getState();
@@ -4227,6 +4261,24 @@ export class PilotSwarmUiController {
                 },
             });
         }
+        // show_artifact: the agent is presenting something to look at, so the
+        // inspector switches to Files and opens that preview live.
+        //
+        // Three guards, because "the UI moves on its own" is only acceptable
+        // when it is unmistakably a response to what is happening right now:
+        //
+        //  - active session only. A background session finishing a dashboard
+        //    must never yank the pane away from the session being read.
+        //  - fresh events only. This path also runs for the catch-up burst
+        //    after a reconnect; replaying an hour-old presentation as if it
+        //    just happened would be a jump scare, not a feature.
+        //  - live path only. Bulk history loads (ensureSessionHistory) do not
+        //    come through here, so merely OPENING a session never auto-opens
+        //    whatever it last presented. Reopening is what the artifact link
+        //    in the transcript and the deep link are for.
+        if (event.eventType === "session.artifact_presented") {
+            this.maybeRevealPresentedArtifact(sessionId, event);
+        }
         this.reconcileOutboxAgainstEvent(sessionId, event);
         const derivedModel = extractSessionModelFromEvent(event);
         const currentSession = this.getState().sessions.byId[sessionId] || { sessionId };
@@ -5262,7 +5314,11 @@ export class PilotSwarmUiController {
      * 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 } = {}) {
+    async revealArtifact(sessionId, filename, {
+        force = true,
+        fullscreen = false,
+        pane = false,
+    } = {}) {
         const resolvedSessionId = sessionId || this.getState().sessions.activeSessionId;
         const name = String(filename || "").trim();
         if (!resolvedSessionId || !name) return false;
@@ -5278,12 +5334,37 @@ export class PilotSwarmUiController {
         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");
+        // The reader REPLACES the inspector, so it has no business changing
+        // which inspector tab is selected. Switching to Files here meant that
+        // opening an artifact from a session you were watching on the Sequence
+        // tab silently reassigned that tab, and ✕ dropped you on a file list
+        // you never opened. Leaving it alone makes ✕ restore the tab for free,
+        // with no state to capture. The non-pane paths still need Files,
+        // because there the inspector IS the preview.
+        if (!pane) this.dispatch({ type: "ui/inspectorTab", inspectorTab: "files" });
+        // The takeover pane is its own focus surface and, unlike the inspector,
+        // it is what the user is looking at — so it must NOT steal focus to the
+        // artifact list underneath. Chat keeps focus, which is the point: you
+        // followed a link from the transcript and should still be able to type.
+        if (pane) {
+            // Whether the column was already collapsed is read HERE rather than
+            // taken from the caller, so every entry point — a chat card, a deep
+            // link, an agent's show_artifact — gets the same answer.
+            //
+            // And if it WAS collapsed, the column has to be opened: rendering
+            // the reader into a zero-width track produced a pane that existed
+            // in the DOM, reported itself open, and could not be seen. Closing
+            // collapses it again, so the detour is invisible.
+            const wasHidden = Boolean(this.getCurrentLayout()?.rightHidden);
+            if (wasHidden) this.expandRightColumn();
+            this.dispatch({ type: "files/pane", open: true, restoresToHidden: wasHidden });
+        } else {
+            // 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);
@@ -5291,6 +5372,57 @@ export class PilotSwarmUiController {
         return true;
     }
 
+    /**
+     * Close the artifact takeover pane, restoring the right column.
+     *
+     * Restores the inspector/activity split it replaced — unless the column was
+     * already collapsed when the pane opened, in which case it collapses again.
+     * Opening a reader must not become a way to un-hide panes the user had
+     * deliberately resized away.
+     */
+    async closeArtifactPane() {
+        const restoresToHidden = this.getState().files.paneRestoresToHidden;
+        this.dispatch({ type: "files/pane", open: false });
+        this.dispatch({ type: "files/fullscreen", fullscreen: false });
+        // Selection is deliberately left alone: the artifact stays selected in
+        // the Files list, so reopening the column shows what you were reading
+        // rather than an empty preview.
+        this.dispatch({ type: "files/previewOrigin", origin: null });
+        if (restoresToHidden) this.collapseRightColumn();
+        this.dispatch({ type: "ui/focus", focusRegion: FOCUS_REGIONS.CHAT });
+        return { collapsedRightColumn: Boolean(restoresToHidden) };
+    }
+
+    /**
+     * Drive the left/right split far enough right that the layout's own
+     * collapse rule hides the right column.
+     *
+     * Expressed as a paneAdjust rather than a new "hidden" flag so there stays
+     * exactly one source of truth for column width — the same number the
+     * resizer writes. A second flag would let the two disagree.
+     */
+    /** Return the left/right split to its default, un-collapsing the column. */
+    expandRightColumn() {
+        this.dispatch({ type: "ui/paneAdjust", paneAdjust: 0 });
+        const nextLayout = this.getCurrentLayout({ paneAdjust: 0 });
+        const currentFocus = this.getState().ui.focusRegion;
+        const safeFocus = normalizeFocusRegion(currentFocus, nextLayout);
+        if (safeFocus !== currentFocus) this.setFocus(safeFocus);
+    }
+
+    collapseRightColumn() {
+        const layoutState = this.getState().ui.layout || {};
+        const totalWidth = layoutState.viewportWidth ?? 120;
+        const baseLeftWidth = Math.floor(totalWidth * DEFAULT_LEFT_PANE_RATIO);
+        // One past the threshold: `<=` collapses, so land strictly inside it.
+        const paneAdjust = totalWidth - COLLAPSE_RIGHT_THRESHOLD - baseLeftWidth;
+        this.dispatch({ type: "ui/paneAdjust", paneAdjust });
+        const nextLayout = this.getCurrentLayout({ paneAdjust });
+        const currentFocus = this.getState().ui.focusRegion;
+        const safeFocus = normalizeFocusRegion(currentFocus, nextLayout);
+        if (safeFocus !== currentFocus) this.setFocus(safeFocus);
+    }
+
     /**
      * Leave the artifact preview, returning wherever the user came FROM.
      *
@@ -5612,7 +5744,9 @@ export class PilotSwarmUiController {
             type: "ui/modal",
             modal: {
                 type: "renameSession",
-                title: `Rename (${shortSessionIdValue(sessionId)})`,
+                // A group row's id is synthetic, so showing its short form
+                // reads as a stray hex string rather than an identifier.
+                title: session.isGroup ? "Rename folder" : `Rename (${shortSessionIdValue(sessionId)})`,
                 sessionId,
                 previousFocus: state.ui.focusRegion,
                 value,
@@ -5620,13 +5754,19 @@ export class PilotSwarmUiController {
                 agentTitlePrefix,
                 currentTitle: String(session.title || "").trim(),
                 maxLength,
+                // Folders share this modal but not its caveats: a group has no
+                // agent and no LLM-generated title, so the selector suppresses
+                // the auto-title warning for them.
+                isGroup: Boolean(session.isGroup),
             },
         });
         this.dispatch({
             type: "ui/status",
-            text: agentTitlePrefix
-                ? `Rename title for ${agentTitlePrefix}; the agent-name prefix stays fixed`
-                : "Type a new session title and press Enter to save",
+            text: session.isGroup
+                ? "Type a new folder name and press Enter to save"
+                : agentTitlePrefix
+                    ? `Rename title for ${agentTitlePrefix}; the agent-name prefix stays fixed`
+                    : "Type a new session title and press Enter to save",
         });
     }
 

package/ui/core/src/formatting.js

@@ -9,6 +9,18 @@ const DEFAULT_STYLE = {
 const ARTIFACT_URI_RE = /artifact:\/\/([a-f0-9-]+)\/([^\s"'{}]+)/g;
 const SESSION_URI_RE = /session:\/\/([A-Za-z0-9-]+)/g;
 
+/**
+ * The TUI's affordance for an artifact link, appended when a bare
+ * `artifact://` URI is decorated for display.
+ *
+ * Exported because the PORTAL has to remove it again: there, an artifact link
+ * renders as a card you click, so an instruction to press a key that does not
+ * exist in a browser is noise. Hosts disagree about the affordance but share
+ * the decorator, so the string is named in one place rather than matched by
+ * two copies of a literal that can drift apart.
+ */
+export const ARTIFACT_DOWNLOAD_HINT = " (press a to download)";
+
 const COLOR_NAME_MAP = {
     black: "black",
     red: "red",
@@ -495,7 +507,7 @@ export function decorateArtifactLinksForChat(text) {
         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)`;
+        return `[artifact: ${filename}](artifact://${sessionId}/${filename})${ARTIFACT_DOWNLOAD_HINT}`;
     });
     SESSION_URI_RE.lastIndex = 0;
     return withArtifacts.replace(SESSION_URI_RE, (_match, sessionId) => {

package/ui/core/src/history.js

@@ -703,6 +703,14 @@ function formatActivity(event) {
         case "assistant.streaming_progress":
             return null;
 
+        case "session.artifact_presented": {
+            const data = (event?.data ?? {}) || {};
+            const filename = String(data.filename || "artifact");
+            const note = typeof data.note === "string" && data.note.trim() ? ` — ${data.note.trim()}` : "";
+            runs = buildLabeledActivityRuns(time, "[show]", "cyan", `${filename}${note}`, "white");
+            break;
+        }
+
         case "tool.execution_start":
             runs = formatToolActivityRuns(time, event, "start");
             break;

package/ui/core/src/reducer.js

@@ -2568,6 +2568,53 @@ export function appReducer(state, action) {
                 },
             };
 
+        // The artifact takeover pane. `restoresToHidden` is captured ONCE, on
+        // the opening transition — reopening while already open must not
+        // overwrite it with "the column is visible", which is trivially true
+        // whenever the pane itself is showing and would strand a user who had
+        // collapsed the column with an inspector they never asked for.
+        case "files/pane":
+            return {
+                ...state,
+                files: {
+                    ...state.files,
+                    paneOpen: Boolean(action.open),
+                    paneRestoresToHidden: action.open
+                        ? (state.files.paneOpen
+                            ? state.files.paneRestoresToHidden
+                            : Boolean(action.restoresToHidden))
+                        : false,
+                },
+            };
+
+        case "files/htmlViewMode":
+            return {
+                ...state,
+                files: {
+                    ...state.files,
+                    htmlViewMode: action.mode === "source" ? "source" : "rendered",
+                },
+            };
+
+        case "files/htmlFitWidth":
+            return {
+                ...state,
+                files: {
+                    ...state.files,
+                    htmlFitWidth: Boolean(action.enabled),
+                },
+            };
+
+        // Clamped here rather than at the call site so every entry point —
+        // buttons, keyboard, a restored profile — lands in the same range.
+        case "files/htmlZoom": {
+            const requested = Number(action.zoom);
+            const zoom = Number.isFinite(requested)
+                ? Math.min(3, Math.max(0.5, Math.round(requested * 100) / 100))
+                : 1;
+            return { ...state, files: { ...state.files, htmlZoom: zoom } };
+        }
+
         case "files/clearMarks":
             return { ...state, files: { ...state.files, markedIds: [] } };
 

package/ui/core/src/selectors.js

@@ -5801,11 +5801,16 @@ export function selectRenameSessionModal(state, maxWidth = 76) {
                 text: " cancel",
                 color: "gray",
             }],
-            [{ text: "", color: "gray" }],
-            [{
-                text: "Manual titles stop future automatic LLM title changes for this session.",
-                color: "gray",
-            }],
+            // A folder has no agent writing titles for it, so the auto-title
+            // caveat is noise there — and worse, it implies a folder is a
+            // session.
+            ...(modal.isGroup ? [] : [
+                [{ text: "", color: "gray" }],
+                [{
+                    text: "Manual titles stop future automatic LLM title changes for this session.",
+                    color: "gray",
+                }],
+            ]),
         ],
         detailsLines,
         idealWidth: Math.min(

package/ui/core/src/state.js

@@ -268,6 +268,34 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             // Selection to restore when leaving a chat-opened preview, so
             // following a chat link never disturbs the list.
             restoreArtifactId: null,
+            // The portal's artifact takeover pane: a full-height reader that
+            // replaces the inspector AND activity panes in the right column.
+            // Opened by chat artifact cards and artifact deep links; the Files
+            // list keeps its own stacked list-above-preview view, because
+            // taking over the column would hide the list being browsed.
+            //
+            // The TUI ignores this entirely — it has no such pane.
+            paneOpen: false,
+            // What the right column looked like BEFORE the pane opened, so ✕
+            // can put it back. When the user had already resized the column
+            // out of existence, closing must return to that — not conjure an
+            // inspector they had deliberately dismissed.
+            paneRestoresToHidden: false,
+            // Rendered page vs. HTML source. Lifted out of the preview
+            // component so the reader pane's single header can own the toggle
+            // — the alternative was a second header row stacked under the
+            // first, which is exactly the box-in-a-box the pane exists to undo.
+            htmlViewMode: "rendered",
+            // Zoom for the rendered HTML frame ONLY. Browser zoom scales the
+            // whole workspace — the session list and transcript included —
+            // when all you wanted was to read a dense chart. This scales the
+            // artifact and nothing else.
+            htmlZoom: 1,
+            // Fit-to-width for the rendered HTML frame. Lifted here for the
+            // same reason htmlViewMode is: on mobile the panel is chromeless
+            // and the artifact bar owns the controls, so the two surfaces have
+            // to read one value.
+            htmlFitWidth: false,
             filter: {
                 scope: "selectedSession",
                 query: "",

package/ui/core/src/themes/duroxide.js

@@ -0,0 +1,136 @@
+import { createTheme, THEME_GROUP_OTHER } from "./helpers.js";
+
+// Duroxide (2025-) - the durable execution runtime, wearing its own brand.
+//
+// This is NOT the Rust theme with a different accent. Rust is rustc OUTPUT:
+// hot Ferris orange on cold graphite, with the compiler's error/warning/help
+// levels as the status palette. Duroxide is the PROJECT BRAND: the banner is
+// a sheet of near-black felt with the mark pressed into it, and the mark is
+// not orange at all - it is iron oxide, a terracotta so muted it reads as a
+// material rather than a highlight. Ground, accent and mood all differ, which
+// is what keeps two warm-dark themes from collapsing into one.
+//
+// Every value below is MEASURED off the banner artwork rather than picked by
+// eye. The ground is #282627 with a paper grain running about +/-12 levels
+// either side; the mark's modal colour is #a35838, its lit edge #ba714c.
+//
+// The catch: #a35838 on #282627 is 2.87:1. The exact brand colour cannot be
+// text. So the brand oxide is spent on CHROME - the logo, borders, rules -
+// and the interactive accent is a brightened sibling, #d2764a, which clears
+// 4.5:1 on both grounds while staying recognisably the same pigment. Getting
+// that backwards is how a brand palette becomes an unreadable interface.
+//
+// Rust's DNA survives where it earns its place: the status slots keep rustc's
+// three-level vocabulary (error red, warning amber, help blue) with cargo
+// green for success - a status palette a session list can use directly - but
+// each is desaturated to sit inside the brand's restraint rather than shout
+// over it.
+//
+// The banner's felt grain is not expressible as a palette entry, so it rides
+// on [data-ps-theme="duroxide"] in the stylesheet, the same hook Win95 uses
+// for its bevels.
+
+// The brand oxide, sampled from the mark itself. Chrome only - see above.
+const OXIDE = "#a35838";
+
+// The mark itself, traced from the banner artwork at 1.8px tolerance: hexagon
+// ring, eight-tooth gear, and the replay arrow sweeping its lower arc. Four
+// subpaths in one string - outers wound clockwise, holes counter-clockwise.
+const DUROXIDE_MARK =
+    "M4.14 33.09L4.14 18.89L5.7 15.77L30.05 1.4L33.95 1.4L43.32 6.56L57.99 15.3L59.08 16.7L59.7"
+    + "1 18.58L59.71 45.27L59.08 47.14L56.9 49.64L41.44 58.38L38.32 60.57L33.64 62.91L30.52 62.91"
+    + "L27.71 61.66L14.6 53.7L6.79 49.48L5.54 48.23L4.45 46.2L4.14 44.49L4.14 33.09ZM55.8 26.07L5"
+    + "5.8 19.36L55.02 18.42L33.8 6.09L31.45 5.78L30.05 6.24L8.51 18.89L8.51 45.11L10.22 46.67L18"
+    + ".03 50.89L30.05 58.22L31.77 58.85L33.17 58.69L53.93 46.67L55.65 44.96L55.8 26.07ZM17.09 34"
+    + ".81L16.78 33.56L13.19 32.62L13.19 27.0L17.09 26.54L18.97 23.26L16.94 19.67L21.0 15.61L24.4"
+    + "3 17.95L27.86 16.86L29.11 12.8L34.58 12.8L35.51 16.86L38.63 17.95L39.57 17.8L42.69 15.61L4"
+    + "6.6 19.67L46.28 20.92L44.88 22.95L44.88 23.73L46.28 26.38L50.65 27.16L50.65 32.47L47.69 33"
+    + ".4L47.06 34.03L42.54 32.0L42.54 29.97L41.91 27.63L40.82 25.6L38.63 23.26L34.73 21.39L32.55"
+    + " 21.07L29.11 21.39L26.3 22.48L23.96 24.35L22.4 26.54L21.31 29.97L21.31 33.25L22.87 37.46L2"
+    + "4.12 39.18L27.4 41.83L24.59 42.77L19.9 42.93L16.0 41.68L15.22 40.12L17.72 37.31L17.09 34.8"
+    + "1ZM36.76 35.59L35.51 32.62L35.82 32.0L50.19 39.34L49.25 41.99L43.32 51.2L42.54 51.04L41.6 "
+    + "46.2L35.51 49.64L31.3 50.58L28.49 50.58L21.93 49.01L18.97 47.3L16.47 45.11L16.78 44.8L19.1"
+    + "2 45.58L22.09 45.74L25.21 45.42L28.18 44.33L29.74 44.49L33.48 42.46L37.39 39.18L37.85 37.9"
+    + "3L36.76 35.59Z";
+
+const duroxideTheme = createTheme({
+    id: "duroxide",
+    label: "Duroxide",
+    description: "Iron oxide pressed into black felt - the durable-execution runtime's own mark, traced from the banner.",
+    group: THEME_GROUP_OTHER,
+    // Traced from the banner artwork, not redrawn: the hexagon, the eight-tooth
+    // gear, and the replay arrow sweeping its lower arc. Subpaths are wound so
+    // the default nonzero fill rule punches the holes - ThemeIconMark renders
+    // a bare <path d fill> with no fill-rule to lean on.
+    icon: {
+        viewBox: "0 0 64 64",
+        // ONE path, not four. ThemeIconMark renders each entry as its own
+        // <path>, and the nonzero fill rule can only cancel windings WITHIN a
+        // single element - split across four, the hexagon ring and the gear
+        // hole both filled solid and the mark came out as a plain blob.
+        paths: [
+            { d: DUROXIDE_MARK, fill: OXIDE },
+        ],
+    },
+    page: {
+        // Deeper than the banner so panels sit ON the sheet rather than in it.
+        background: "#201e1f",
+        foreground: "#e5e0dc",
+        overlayBackground: "#2e2c2d",
+        overlayForeground: "#e5e0dc",
+        hintColor: "#a89f99",
+        modalBackdrop: "rgba(23, 21, 23, 0.86)",
+        modalBackground: "#2e2c2d",
+        modalBorder: "#4d4643",
+        modalForeground: "#e5e0dc",
+        modalMuted: "#a89f99",
+        // Selection is the oxide at its deepest measured shadow, not a tint of
+        // the accent - the colour the pressed edge of the mark actually goes.
+        modalSelectedBackground: "#7c3f26",
+        modalSelectedBorder: "#a35838",
+        modalSelectedForeground: "#ffeee4",
+    },
+    terminal: {
+        // The banner tone, exactly.
+        background: "#282627",
+        foreground: "#e5e0dc",
+        cursor: "#d2764a",
+        cursorAccent: "#201e1f",
+        selectionBackground: "#7c3f26",
+        black: "#201e1f",
+        // rustc's levels, desaturated into the brand's register.
+        red: "#e86a5f",        // error[E0382]
+        green: "#7fb069",      // Compiling / Finished
+        yellow: "#d9a441",     // warning:
+        blue: "#6a9fd4",       // the --> gutter rail and help:
+        magenta: "#b98bc4",
+        // The accent slot. The portal derives --ps-accent from tui.cyan, so the
+        // interactive colour travels here regardless of the slot's name.
+        cyan: "#d2764a",
+        white: "#e5e0dc",
+        brightBlack: "#a89f99",
+        brightRed: "#f4897f",
+        brightGreen: "#9bc888",
+        brightYellow: "#efc069",
+        brightBlue: "#8fbce4",
+        brightMagenta: "#d0a8d9",
+        // The banner's lit edge, measured where the press catches the light.
+        brightCyan: "#ba714c",
+        brightWhite: "#fdf7f2",
+    },
+    tui: {
+        border: "#46403d",
+        // The human speaks in the warning register, as in the Rust theme: the
+        // accent stays reserved for the machine and what it produces.
+        userChat: "#e0b070",
+        userChatLabel: "#f0cf9a",
+        selectionBackground: "#7c3f26",
+        selectionForeground: "#ffeee4",
+        activeHighlightBackground: "#7c3f26",
+        activeHighlightForeground: "#ffeee4",
+        promptCursorBackground: "#d2764a",
+        promptCursorForeground: "#201e1f",
+    },
+});
+
+export default duroxideTheme;

package/ui/core/src/themes/index.js

@@ -17,6 +17,7 @@ import msDosTheme from "./ms-dos.js";
 import doomTheme from "./doom.js";
 import winampTheme from "./winamp.js";
 import rustTheme from "./rust.js";
+import duroxideTheme from "./duroxide.js";
 import spongebobTheme from "./spongebob.js";
 
 // Themes are ordered by GROUP first, then alphabetically inside it — the
@@ -54,6 +55,7 @@ const THEMES = Object.freeze([
     doomTheme,
     winampTheme,
     rustTheme,
+    duroxideTheme,
     spongebobTheme,
 ].sort(byGroupThenLabel));