pilotswarm 0.5.44 → 0.5.47

package/ui/core/src/controller.js

@@ -579,7 +579,7 @@ function buildSessionOwnerFilterItems(state) {
             id: "all",
             kind: "all",
             label: "All",
-            description: "Show every session, including system and unowned sessions.",
+            description: "Every session you can see — your own, ones shared with you, and system sessions.",
         },
         {
             id: "system",
@@ -893,7 +893,127 @@ export function agentPickerInitialIndex(items = []) {
     return firstClosed >= 0 ? firstClosed : 0;
 }
 
-export function buildAgentPickerItems(catalog = [], collapsedKeys = [], genericItem = null) {
+/** How the picker may be ordered. `used` is per-person; the rest are stable. */
+export const AGENT_PICKER_SORTS = ["used", "name", "package"];
+export const AGENT_PICKER_DEFAULT_SORT = "used";
+
+/** Profile-settings key holding this person's per-agent start counts. */
+export const AGENT_USAGE_SETTING = "agentPickerUsage";
+
+/** Everything a query is matched against, lowercased once per agent. */
+function agentHaystack(agent) {
+    return [
+        agent?.label, agent?.agentName, agent?.title, agent?.description,
+        agent?.packageTitle, agent?.packageName,
+        ...(Array.isArray(agent?.tools) ? agent.tools : []),
+    ].filter(Boolean).join(" ").toLowerCase();
+}
+
+/**
+ * Lexical match: every whitespace-separated term must appear somewhere in the
+ * agent's text. AND rather than OR, because "rcakit pg" should narrow to one
+ * agent rather than widen to everything mentioning either word.
+ *
+ * The score only ranks matches against each other — a name hit outranks a
+ * description hit, and a prefix outranks a mid-word hit, so typing "rca" puts
+ * the agents CALLED rcakit above the ones that merely mention it.
+ */
+export function scoreAgentMatch(agent, query) {
+    const terms = String(query || "").toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0) return 0;
+    const hay = agentHaystack(agent);
+    const name = `${agent?.label || ""} ${agent?.agentName || ""}`.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        if (!hay.includes(term)) return -1;          // every term must land
+        if (name.startsWith(term)) score += 6;
+        else if (new RegExp(`\\b${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(name)) score += 4;
+        else if (name.includes(term)) score += 3;
+        else score += 1;
+    }
+    return score;
+}
+
+function agentUsageCount(usage, agent) {
+    if (!usage || !agent?.agentName) return 0;
+    return Number(usage[String(agent.agentName)]) || 0;
+}
+
+function compareAgentsForSort(sort, usage) {
+    const byName = (a, b) => String(a.label || a.agentName || "")
+        .localeCompare(String(b.label || b.agentName || ""), undefined, { sensitivity: "base" });
+    if (sort === "name") return byName;
+    if (sort === "package") {
+        return (a, b) => String(a.packageTitle || a.packageName || "")
+            .localeCompare(String(b.packageTitle || b.packageName || ""), undefined, { sensitivity: "base" })
+            || byName(a, b);
+    }
+    // "used": most-started first, then alphabetical so the long tail of
+    // never-started agents is not in arbitrary order.
+    return (a, b) => agentUsageCount(usage, b) - agentUsageCount(usage, a) || byName(a, b);
+}
+
+/**
+ * The picker list: ONE ROW PER AGENT.
+ *
+ * The old shape gave each package a header row and then repeated its agents
+ * beneath. Nearly every package holds exactly one agent, so that spent two
+ * rows saying the same thing twice and pushed the list past a screen. The
+ * package is still shown — as trailing metadata on the row it belongs to,
+ * and as a sort key — but it no longer costs a row of its own.
+ */
+export function buildAgentPickerItems(catalog = [], opts = {}) {
+    const {
+        query = "",
+        sort = AGENT_PICKER_DEFAULT_SORT,
+        usage = null,
+        genericItem = null,
+    } = opts || {};
+
+    // Generic sits ABOVE everything and never filters out on an empty query:
+    // it is not an agent, it is the absence of one, and it is the most common
+    // pick. A typed query does filter it, so search can reach past it.
+    const items = [];
+    const terms = String(query || "").trim();
+    if (genericItem && (!terms || scoreAgentMatch({ label: genericItem.label, description: genericItem.description }, terms) >= 0)) {
+        items.push({ ...genericItem, depth: 0 });
+    }
+
+    // Composition still decides whether an agent can be STARTED — `startedBy`
+    // resolving inside its own set is what makes it called-only. The flat list
+    // drops the nesting, not that derivation, so each set still goes through
+    // orderAgentsByComposition; only its ordering is discarded here.
+    const raw = catalog.filter((agent) => agent && agent.kind !== "section");
+    const sets = new Map();
+    for (const agent of raw) {
+        const key = agent.builtin ? "builtin" : agentPickerPackageKey(agent);
+        if (!sets.has(key)) sets.set(key, []);
+        sets.get(key).push(agent);
+    }
+    const agents = [];
+    for (const set of sets.values()) {
+        for (const agent of orderAgentsByComposition(set)) agents.push({ ...agent, depth: 0 });
+    }
+
+    const scored = terms
+        ? agents.map((agent) => ({ agent, score: scoreAgentMatch(agent, terms) })).filter((row) => row.score >= 0)
+        : agents.map((agent) => ({ agent, score: 0 }));
+
+    const compare = compareAgentsForSort(sort, usage);
+    scored.sort((a, b) => (terms ? b.score - a.score : 0) || compare(a.agent, b.agent));
+
+    for (const { agent } of scored) {
+        items.push({
+            ...agent,
+            depth: 0,
+            usageCount: agentUsageCount(usage, agent),
+        });
+    }
+    return items;
+}
+
+/** @deprecated the grouped shape; kept only for the TUI's collapse tests. */
+export function buildGroupedAgentPickerItems(catalog = [], collapsedKeys = [], genericItem = null) {
     const collapsed = new Set(collapsedKeys);
     const items = [];
 
@@ -2614,6 +2734,14 @@ export class PilotSwarmUiController {
      */
     async refreshWorkerRegistryIfStale() {
         const workers = this.getState().admin?.workers;
+        // The registry is fleet:admin. Polling it as a plain user is a 403
+        // every few seconds and a red console for nothing.
+        const role = this.getState().auth?.authorization?.role;
+        const isAdmin = role === "admin" || role === "anonymous" || this.getState().admin?.profile?.isAdmin === true;
+        if (!isAdmin) {
+            this.dispatch({ type: "admin/workers/attempt", skip: "not admin" });
+            return;
+        }
         if (workers?.loading) {
             this.dispatch({ type: "admin/workers/attempt", skip: "already in flight" });
             return;
@@ -3155,6 +3283,15 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * Drop a failed provider mutation's error. Called when the sheet that
+     * raised it closes — the failure was that sheet's, and a banner outliving
+     * it describes a change the person already abandoned.
+     */
+    dismissAdminModelProviderMutationError() {
+        this.dispatch({ type: "admin/modelProviders/mutationDismissed" });
+    }
+
     async _runAdminModelProviderMutation(pending, run) {
         this.dispatch({ type: "admin/modelProviders/mutationPending", pending });
         try {
@@ -3180,6 +3317,28 @@ export class PilotSwarmUiController {
         }));
     }
 
+    /**
+     * Rotate a provider's key in place.
+     *
+     * Two ops, one per scope, the same split deleteAdminProvider uses: a
+     * personal provider answers to its owner, a shared one to an admin. Both
+     * change ONLY the key — the name, type, base URL, defaults, system-session
+     * routing and usage history all stay, which is the whole reason this
+     * exists rather than delete-and-recreate.
+     */
+    async updateAdminProviderCredential({ name, credentials, shared = false } = {}) {
+        const op = shared ? "updateSharedProviderCredential" : "updateMyProviderCredential";
+        if (typeof this.transport[op] !== "function") {
+            const error = shared
+                ? "Shared provider credential updates are not available on this transport."
+                : "Provider credential updates are not available on this transport.";
+            this.dispatch({ type: "admin/modelProviders/mutationFailed", error });
+            return { ok: false, result: null, error };
+        }
+        return this._runAdminModelProviderMutation("updateCredential", () =>
+            this.transport[op]({ name, credentials }));
+    }
+
     async deleteAdminProvider(name, { shared = false } = {}) {
         const op = shared ? "deleteProvider" : "deleteMyProvider";
         if (typeof this.transport[op] !== "function") {
@@ -3257,13 +3416,25 @@ export class PilotSwarmUiController {
             name = `${base}-${suffix}`;
             suffix += 1;
         }
-        this.dispatch({ type: "admin/modelProviders/createBegin", name, typeId, shared });
+        this.dispatch({ type: "admin/modelProviders/createBegin", name, typeId, shared, mode: "create" });
     }
 
     beginAdminCreateGithubProvider() {
         this.beginAdminCreateProvider({ shared: false });
     }
 
+    beginAdminUpdateProviderCredential(provider) {
+        if (!provider?.name || provider.class === "shared") return;
+        this.dispatch({
+            type: "admin/modelProviders/createBegin",
+            name: provider.name,
+            typeId: provider.typeId,
+            shared: false,
+            mode: "update",
+            stage: "credential",
+        });
+    }
+
     cycleAdminProviderCreateType() {
         const providers = selectAdminConsole(this.getState()).modelProviders;
         const create = this.getState().admin?.modelProviders?.create;
@@ -3334,7 +3505,9 @@ export class PilotSwarmUiController {
         };
         // Clear the credential from shared state before any network await.
         this.dispatch({ type: "admin/modelProviders/createSaving" });
-        const outcome = await this.createAdminProvider(input);
+        const outcome = create.mode === "update"
+            ? await this.updateAdminProviderCredential({ name: input.name, credentials: input.credentials })
+            : await this.createAdminProvider(input);
         this.dispatch(outcome?.ok
             ? { type: "admin/modelProviders/createEnd" }
             : { type: "admin/modelProviders/createFailed", error: outcome?.error });
@@ -3654,6 +3827,13 @@ export class PilotSwarmUiController {
                 case "delete":
                     await this.transport.deleteAgentPackage(name, selector);
                     break;
+                // Editors live on the shared copy only — no selector.
+                case "grantEditor":
+                    await this.transport.grantAgentPackageEditor(name, arg);
+                    break;
+                case "revokeEditor":
+                    await this.transport.revokeAgentPackageEditor(name, arg);
+                    break;
                 default:
                     throw new Error(`unknown package action: ${kind}`);
             }
@@ -5270,12 +5450,11 @@ export class PilotSwarmUiController {
         // the authority; this is the friendly refusal). The canvas mutates —
         // a shared viewer may be looking at a different revision than the one
         // the creator is conversing through, so their clicks must not speak.
-        const me = this.getState().auth?.principal || null;
-        const ownerRow = this.getState().sessions.byId[sessionId]?.owner || null;
-        if (me && ownerRow && (String(ownerRow.provider || "") !== String(me.provider || "")
-            || String(ownerRow.subject || "") !== String(me.subject || ""))) {
-            return Promise.resolve({ ok: false, reason: "only the session's creator can use canvas controls" });
-        }
+        // Who may ring is the SERVER's decision (owner, admin, or anyone with
+        // session write — interactive-canvas-apps Part E). The client no
+        // longer pre-refuses non-owners: a write-shared collaborator's click
+        // must reach the agent, and the server's refusal for a read-only
+        // viewer comes back as the result's reason.
         const contract = this.getState().canvas.bySessionId[sessionId]?.responseContract || null;
         const verdict = validateCanvasAction(contract, message);
         if (!verdict.ok) return Promise.resolve(verdict);
@@ -5386,6 +5565,23 @@ export class PilotSwarmUiController {
         return true;
     }
 
+    /**
+     * Listen for canvas KV changes on a session (the live path of the canvas
+     * KV store). Returns an unsubscriber. Frames use this to post
+     * `canvas-kv-change` into their page.
+     */
+    subscribeCanvasKv(sessionId, callback) {
+        if (!sessionId || typeof callback !== "function") return () => {};
+        if (!this._canvasKvListeners) this._canvasKvListeners = new Map();
+        if (!this._canvasKvListeners.has(sessionId)) this._canvasKvListeners.set(sessionId, new Set());
+        const set = this._canvasKvListeners.get(sessionId);
+        set.add(callback);
+        return () => {
+            set.delete(callback);
+            if (set.size === 0) this._canvasKvListeners.delete(sessionId);
+        };
+    }
+
     applyCanvasDataEvent(sessionId, event) {
         this.dispatch({
             type: "canvas/data",
@@ -5413,6 +5609,17 @@ export class PilotSwarmUiController {
             if (event.eventType === "session.canvas_data") {
                 this.applyCanvasDataEvent(sessionId, event);
             }
+            if (event.eventType === "session.canvas_kv") {
+                // KV changes never touch the reducer: they go straight to
+                // the canvas frames listening for this session, which post
+                // them into the page as `canvas-kv-change`.
+                const listeners = this._canvasKvListeners?.get(sessionId);
+                if (listeners) {
+                    for (const cb of listeners) {
+                        try { cb(event.data); } catch { /* one frame's problem */ }
+                    }
+                }
+            }
             if (event.eventType === "session.canvas_plane_released") {
                 // The plane died for this session (server error/rollback).
                 // Clear the reducer's takeover so legacy durable ticks — the
@@ -5606,6 +5813,10 @@ export class PilotSwarmUiController {
         try {
             const requestOptions = this.applyActiveGroupDefault(options);
             const created = await this.transport.createSessionForAgent(agentName, requestOptions);
+            // Count the start for this person's "most used" ordering. Deliberately
+            // not awaited: the picker's sort order must never delay opening the
+            // session that was just created, and a lost count only reorders a list.
+            this._recordAgentPickerUse(agentName);
             await this.placeCreatedSessionInGroup(created, requestOptions.groupId ?? null);
             await this.refreshSessions();
             await this.loadSession(created.sessionId);
@@ -6101,18 +6312,14 @@ export class PilotSwarmUiController {
             }
             : null;
 
-        // EVERYTHING starts closed. The dialog opens as a short menu of
-        // categories — Generic, then whichever of Built-in / Shared / Yours
-        // this deployment actually has — and you open the one you want. A
-        // section expanded by default is a section every other user has to
-        // scroll past.
-        const collapsed = [
-            AGENT_PICKER_BUILTIN_KEY,
-            AGENT_PICKER_SHARED_KEY,
-            AGENT_PICKER_MINE_KEY,
-            ...new Set(catalog.filter((item) => !item.builtin).map((item) => agentPickerPackageKey(item))),
-        ];
-        const items = buildAgentPickerItems(catalog, collapsed, genericItem);
+        // Per-person start counts, so "most used" means most used BY YOU.
+        // Best-effort: a profile that cannot be read just sorts alphabetically
+        // rather than failing the picker open.
+        const usage = await this._loadAgentPickerUsage();
+        const sort = AGENT_PICKER_SORTS.includes(this._agentPickerSort)
+            ? this._agentPickerSort
+            : AGENT_PICKER_DEFAULT_SORT;
+        const items = buildAgentPickerItems(catalog, { query: "", sort, usage, genericItem });
 
         this.dispatch({
             type: "ui/modal",
@@ -6121,8 +6328,10 @@ export class PilotSwarmUiController {
                 title: "Select agent for new session",
                 catalog,
                 genericItem,
-                collapsed,
                 items,
+                query: "",
+                sort,
+                usage,
                 // Land somewhere Enter does something useful. First choice is a
                 // real agent row; with none visible (no generic, no baked
                 // agents, every package closed) fall back to the first CLOSED
@@ -7673,61 +7882,96 @@ export class PilotSwarmUiController {
      * cursor shifts every index below it, and re-using the old number would
      * silently move the highlight onto a different agent.
      */
-    toggleAgentPickerSection(sectionKey, force = null) {
+    /**
+     * This person's per-agent start counts, from their profile settings.
+     * Best-effort by design: a profile that cannot be read sorts the picker
+     * alphabetically instead of refusing to open.
+     */
+    async _loadAgentPickerUsage() {
+        try {
+            if (typeof this.transport.getCurrentUserProfile !== "function") return null;
+            const profile = await this.transport.getCurrentUserProfile();
+            const raw = profile?.profileSettings?.[AGENT_USAGE_SETTING];
+            if (!raw || typeof raw !== "object") return {};
+            const usage = {};
+            for (const [name, count] of Object.entries(raw)) {
+                const n = Number(count);
+                if (Number.isFinite(n) && n > 0) usage[name] = n;
+            }
+            return usage;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Count one start. Read-modify-write against the whole settings document,
+     * because that is the shape the API takes — so a concurrent write from
+     * another tab can lose a count. A miscount only reorders a picker, which
+     * is not worth a locking protocol.
+     */
+    async _recordAgentPickerUse(agentName) {
+        const name = String(agentName || "").trim();
+        if (!name) return;
+        try {
+            if (typeof this.transport.getCurrentUserProfile !== "function"
+                || typeof this.transport.setCurrentUserProfileSettings !== "function") return;
+            const profile = await this.transport.getCurrentUserProfile();
+            const settings = { ...(profile?.profileSettings || {}) };
+            const usage = { ...(settings[AGENT_USAGE_SETTING] || {}) };
+            usage[name] = (Number(usage[name]) || 0) + 1;
+            settings[AGENT_USAGE_SETTING] = usage;
+            // Into state before the network: the portal's own profile save
+            // fires on the very activeSessionId change this create causes,
+            // and it writes the whole document from state. If state does not
+            // have the new count by then, that save erases it.
+            this.dispatch({ type: "ui/agentPickerUsage", usage });
+            await this.transport.setCurrentUserProfileSettings({ settings });
+        } catch {
+            // Never let bookkeeping fail a session create.
+        }
+    }
+
+    /** Re-run the list against a new query or sort, keeping the selection. */
+    _refreshAgentPicker(patch) {
         const modal = this.getState().ui.modal;
-        if (!modal || modal.type !== "sessionAgentPicker" || !sectionKey) return;
-        const collapsed = new Set(modal.collapsed || []);
-        const shouldCollapse = force === null ? !collapsed.has(sectionKey) : force;
-        if (shouldCollapse === collapsed.has(sectionKey)) return;
-        if (shouldCollapse) collapsed.add(sectionKey);
-        else collapsed.delete(sectionKey);
-
-        const nextCollapsed = [...collapsed];
-        const items = buildAgentPickerItems(modal.catalog || [], nextCollapsed, modal.genericItem || null);
+        if (!modal || modal.type !== "sessionAgentPicker") return;
+        const next = { ...modal, ...patch };
+        const items = buildAgentPickerItems(next.catalog || [], {
+            query: next.query,
+            sort: next.sort,
+            usage: next.usage,
+            genericItem: next.genericItem || null,
+        });
+        // Keep the same agent selected when it survives the new list; land on
+        // the first row when it does not, so Enter always does something.
         const selectedId = modal.items?.[modal.selectedIndex || 0]?.id;
-        let nextIndex = items.findIndex((item) => item.id === selectedId);
-        if (nextIndex < 0) {
-            // The selected row was inside the section that just closed — land
-            // on that section's own header, which is where it went.
-            nextIndex = Math.max(0, items.findIndex((item) => item.sectionKey === sectionKey));
-        }
+        const keptIndex = items.findIndex((item) => item.id === selectedId);
         this.dispatch({
             type: "ui/modal",
-            modal: { ...modal, collapsed: nextCollapsed, items, selectedIndex: nextIndex },
+            modal: { ...next, items, selectedIndex: keptIndex >= 0 ? keptIndex : 0 },
         });
     }
 
-    /**
-     * Left/right on the agent picker. Right opens a closed section (or steps
-     * into it); left closes an open one, or jumps to the parent header when
-     * the cursor is already on a leaf — the same shape as the session tree.
-     */
-    moveAgentPickerSection(delta) {
-        const modal = this.getState().ui.modal;
-        if (!modal || modal.type !== "sessionAgentPicker") return false;
-        const items = Array.isArray(modal.items) ? modal.items : [];
-        const index = Math.max(0, Math.min(Number(modal.selectedIndex) || 0, items.length - 1));
-        const item = items[index];
-        if (!item) return false;
+    setAgentPickerQuery(query) {
+        this._refreshAgentPicker({ query: String(query ?? "") });
+    }
 
-        if (delta > 0) {
-            if (item.kind === "section" && item.collapsed) {
-                this.toggleAgentPickerSection(item.sectionKey, false);
-                return true;
-            }
-            return false;
-        }
+    setAgentPickerSort(sort) {
+        if (!AGENT_PICKER_SORTS.includes(sort)) return;
+        this._agentPickerSort = sort;      // remembered for the next open
+        this._refreshAgentPicker({ sort });
+    }
 
-        if (item.kind === "section" && !item.collapsed) {
-            this.toggleAgentPickerSection(item.sectionKey, true);
-            return true;
-        }
-        for (let i = index - 1; i >= 0; i -= 1) {
-            if (items[i].kind === "section" && items[i].depth < item.depth) {
-                this.dispatch({ type: "ui/modalSelection", index: i });
-                return true;
-            }
-        }
+    /**
+     * Left/right on the agent picker: nothing.
+     *
+     * These keys used to open and close package headings. The picker is a flat
+     * list of agents now, so there is nothing to expand — and returning false
+     * matters, because that is what lets the keystroke reach the search box and
+     * move the caret instead of being swallowed here.
+     */
+    moveAgentPickerSection() {
         return false;
     }
 
@@ -7950,11 +8194,6 @@ export class PilotSwarmUiController {
         }
         if (modal.type === "sessionAgentPicker") {
             const item = modal.items?.[modal.selectedIndex || 0];
-            // Enter on a heading opens or closes it; the dialog stays up.
-            if (item?.kind === "section") {
-                this.toggleAgentPickerSection(item.sectionKey);
-                return;
-            }
             // A called-only agent is rendered so the package's composition is
             // visible, but starting one cold is not a thing you can do. Refuse
             // here rather than letting the create fail after the dialog closes.

package/ui/core/src/history.js

@@ -129,6 +129,18 @@ export function stripLeadingRehydrationNoticeText(text) {
     return normalized;
 }
 
+// The runtime neutralizes a FORGED `[SYSTEM:` marker by inserting a zero-width
+// character after the bracket, so a collaborator cannot inject system guidance
+// (orchestration/utils.ts). That neutralizer runs when the queued message is
+// consumed — AFTER the runtime has appended its own timer/cron notice to the
+// same text — so a GENUINE notice on a message from anyone but the session
+// owner arrives neutralized too. Match both spellings, or those notices print
+// as raw prose in the transcript.
+const NOTICE_MARKER_INVISIBLES = "[\\u200b-\\u200f\\u2060-\\u2064\\ufeff]*";
+const SYSTEM_NOTICE_LINE_RE = new RegExp(`^\\s*\\[${NOTICE_MARKER_INVISIBLES}SYSTEM:`, "i");
+const SYSTEM_NOTICE_SINGLE_LINE_RE = new RegExp(`^\\s*\\[${NOTICE_MARKER_INVISIBLES}SYSTEM:\\s*(.*?)\\]\\s*$`, "i");
+const SYSTEM_NOTICE_OPENING_RE = new RegExp(`^\\s*\\[${NOTICE_MARKER_INVISIBLES}SYSTEM:\\s*`, "i");
+
 function splitSystemNoticeSegments(text) {
     const lines = String(text || "").replace(/\r\n/g, "\n").split("\n");
     const segments = [];
@@ -145,13 +157,13 @@ function splitSystemNoticeSegments(text) {
 
     for (let index = 0; index < lines.length;) {
         const line = lines[index];
-        if (!/^\s*\[SYSTEM:/i.test(line)) {
+        if (!SYSTEM_NOTICE_LINE_RE.test(line)) {
             textLines.push(line);
             index += 1;
             continue;
         }
 
-        const singleLineMatch = /^\s*\[SYSTEM:\s*(.*?)\]\s*$/i.exec(line);
+        const singleLineMatch = SYSTEM_NOTICE_SINGLE_LINE_RE.exec(line);
         if (singleLineMatch) {
             flushText();
             segments.push({
@@ -162,7 +174,7 @@ function splitSystemNoticeSegments(text) {
             continue;
         }
 
-        const noticeLines = [line.replace(/^\s*\[SYSTEM:\s*/i, "")];
+        const noticeLines = [line.replace(SYSTEM_NOTICE_OPENING_RE, "")];
         let closingIndex = -1;
         for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
             const closingLine = lines[cursor];
@@ -254,7 +266,7 @@ function isInternalSystemLikeText(text) {
     const normalized = normalizeMessageText(text);
     if (!normalized) return false;
 
-    return /^\[SYSTEM:/i.test(normalized)
+    return SYSTEM_NOTICE_LINE_RE.test(normalized)
         || /^\[CHILD_UPDATE\b/i.test(normalized)
         || /^\[SESSION_MESSAGE(?:_RESPONSE)?\b/i.test(normalized)
         || /^Buffered child updates arrived /i.test(normalized)
@@ -469,13 +481,19 @@ function buildChatMessage(event, role) {
     const sessionMessageCard = buildSessionMessageChatCard(event, rawText);
     if (sessionMessageCard) return sessionMessageCard;
 
+    // The attribution prefix and any embedded system notice come off BEFORE
+    // the canvas check. A collaborator pressing a button in the drawn page
+    // arrives as `[FROM: …]\n[canvas-action] {…}\n\n[SYSTEM: …]`: testing the
+    // raw text misses it on both ends, and the message then prints as an
+    // ordinary chat line with its raw JSON payload showing.
+    const visibleText = stripLeadingSenderMarker(extractVisibleChatText(rawText, role));
+
     // A structured canvas response — the browser sent it on the viewer's
     // behalf after validating it against the drawn contract. One item shape
     // from ONE builder, so bulk load and live append cannot disagree. The
-    // portal chat hides it (the redraw is the visible half of the loop);
-    // the TUI shows a compact line.
-    if (role === "user" && isCanvasActionContent(rawText)) {
-        const parsed = parseCanvasActionContent(rawText);
+    // portal collapses it to one row; the TUI shows a compact line.
+    if (role === "user" && isCanvasActionContent(visibleText)) {
+        const parsed = parseCanvasActionContent(visibleText);
         if (parsed) {
             return {
                 id: `${event.sessionId}:${event.seq}`,
@@ -483,7 +501,7 @@ function buildChatMessage(event, role) {
                 role: "user",
                 action: parsed.action,
                 data: parsed.data,
-                text: rawText,
+                text: visibleText,
                 time: formatTimestamp(event.createdAt),
                 createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
                 // Without the ids, the distinct-ids rule can never fire and two
@@ -496,7 +514,7 @@ function buildChatMessage(event, role) {
         }
     }
 
-    const text = stripLeadingSenderMarker(extractVisibleChatText(rawText, role));
+    const text = visibleText;
     if (!hasVisibleMessageText(text)) return null;
     const clientMessageIds = Array.isArray(event?.data?.clientMessageIds)
         ? event.data.clientMessageIds.filter((id) => typeof id === "string" && id)
@@ -524,6 +542,27 @@ function buildChatMessage(event, role) {
     };
 }
 
+// The per-turn system prompt, as the SDK summarises it for CMS: a marker line
+// naming the size with a 120-char snippet, never the whole 170k-char prompt.
+// Matched narrowly on purpose — it is the ONE system.message worth a row in
+// the conversation, and widening this would move rehydration notices, child
+// updates and sub-agent chatter in with it.
+const SYSTEM_PROMPT_NOTICE_RE = /rebuilt the full system prompt for model input/i;
+
+/**
+ * Is this the system prompt itself, rather than internal chatter?
+ *
+ * It stays in the ACTIVITY feed as before — that is the raw diagnostic
+ * stream — and additionally earns one collapsed row in the transcript, the
+ * same affordance as a sub-agent response or a canvas action. Visible enough
+ * to open when you want to know what the model was told; folded away the rest
+ * of the time.
+ */
+export function isSystemPromptNotice(event) {
+    if (event?.eventType !== "system.message") return false;
+    return SYSTEM_PROMPT_NOTICE_RE.test(messageTextFromEvent(event) || "");
+}
+
 function shouldRenderSystemMessageAsActivity(event) {
     // Most system.message events stay out of the chat pane. They include the
     // per-turn system prompt sent to the LLM plus internal rehydration notices,
@@ -1102,6 +1141,13 @@ export function buildHistoryModel(events = [], options = {}) {
             if (shouldRenderSystemMessageAsActivity(event)) {
                 const activityItem = formatActivity(event);
                 if (activityItem) activity.push(activityItem);
+                // The system prompt also earns a collapsed row in the
+                // transcript. It stays in the activity feed above — that is
+                // the raw stream — and this is the readable handle on it.
+                if (isSystemPromptNotice(event)) {
+                    const message = buildChatMessage(event, "system");
+                    if (message) chat.push(message);
+                }
             } else {
                 const message = buildChatMessage(event, "system");
                 if (message) chat.push(message);
@@ -1229,6 +1275,15 @@ export function appendEventToHistory(history, event) {
                 next.activity.push(activityItem);
                 next.activity = clampHistoryItems(next.activity, loadedEventLimit);
             }
+            // Same as the bulk path: the system prompt is also worth one
+            // collapsed row in the conversation.
+            if (isSystemPromptNotice(event)) {
+                const message = buildChatMessage(event, "system");
+                if (message) {
+                    next.chat.push(message);
+                    next.chat = clampHistoryItems(dedupeChatMessages(next.chat), loadedEventLimit);
+                }
+            }
         } else {
             const message = buildChatMessage(event, "system");
             if (!message) return next;