@yeaft/webchat-agent 1.0.345 → 1.0.346

package/local-runtime/server/db/connection.js

@@ -235,6 +235,7 @@ db.exec(`
     user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
     catalog_key TEXT NOT NULL,
     pinned INTEGER NOT NULL DEFAULT 0,
+    is_hidden INTEGER NOT NULL DEFAULT 0,
     sort_rank INTEGER,
     updated_at INTEGER NOT NULL,
     PRIMARY KEY (user_id, catalog_key)
@@ -335,10 +336,18 @@ for (const migration of yeaftMigrations) {
 const yeaftProjectMigrations = [
   `ALTER TABLE yeaft_projects ADD COLUMN instruction TEXT NOT NULL DEFAULT ''`,
 ];
+
+const sessionUiMetadataMigrations = [
+  `ALTER TABLE session_ui_metadata ADD COLUMN is_hidden INTEGER NOT NULL DEFAULT 0`,
+];
 for (const migration of yeaftProjectMigrations) {
   try { db.exec(migration); } catch (_) { /* column exists */ }
 }
 
+for (const migration of sessionUiMetadataMigrations) {
+  try { db.exec(migration); } catch (_) { /* column exists */ }
+}
+
 for (const migration of migrations) {
   try {
     db.exec(migration);
@@ -663,10 +672,11 @@ export const stmts = {
   `),
 
   upsertSessionUiMetadata: db.prepare(`
-    INSERT INTO session_ui_metadata (user_id, catalog_key, pinned, sort_rank, updated_at)
-    VALUES (?, ?, ?, ?, ?)
+    INSERT INTO session_ui_metadata (user_id, catalog_key, pinned, is_hidden, sort_rank, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
     ON CONFLICT(user_id, catalog_key) DO UPDATE SET
       pinned = excluded.pinned,
+      is_hidden = excluded.is_hidden,
       sort_rank = excluded.sort_rank,
       updated_at = excluded.updated_at
   `),

package/local-runtime/server/db/session-ui-metadata-db.js

@@ -1,36 +1,56 @@
 import { stmts, transaction } from './connection.js';
+import { chatCatalogKey, yeaftCatalogKey } from '../session-catalog.js';
+
+function normalizeMetadataUpdate(update) {
+  if (!update?.catalogKey) throw new Error('Catalog metadata update requires catalogKey');
+  if (!['yeaft', 'claude-code', 'copilot'].includes(update.runtimeProvider)) {
+    throw new Error('Unknown Session runtime provider during metadata update');
+  }
+  return {
+    ...update,
+    pinned: typeof update.pinned === 'boolean' ? update.pinned : null,
+    hidden: typeof update.hidden === 'boolean' ? update.hidden : null,
+    hasSortRank: Object.prototype.hasOwnProperty.call(update, 'sortRank'),
+    sortRank: Number.isFinite(update.sortRank) ? update.sortRank : null,
+  };
+}
 
 export function applySessionUiMetadataUpdates(userId, updates, now = Date.now()) {
   if (!userId || !Array.isArray(updates) || updates.length === 0) return false;
-  for (const update of updates) {
-    if (!update?.catalogKey) throw new Error('Catalog metadata update requires catalogKey');
+  for (const rawUpdate of updates) {
+    const update = normalizeMetadataUpdate(rawUpdate);
+    const existing = stmts.getSessionUiMetadata.get(userId, update.catalogKey);
+    const pinned = update.pinned ?? (existing?.pinned === 1);
+    const hidden = update.hidden ?? (existing?.is_hidden === 1);
+    const sortRank = update.hasSortRank
+      ? update.sortRank
+      : (Number.isFinite(existing?.sort_rank) ? existing.sort_rank : null);
     stmts.upsertSessionUiMetadata.run(
       userId,
       update.catalogKey,
-      update.pinned === true ? 1 : 0,
-      Number.isFinite(update.sortRank) ? update.sortRank : null,
+      pinned ? 1 : 0,
+      hidden ? 1 : 0,
+      sortRank,
       now,
     );
     if (update.runtimeProvider === 'yeaft') {
       const result = stmts.setYeaftSessionPinnedForAgent.run(
-        update.pinned === true ? 1 : 0,
+        pinned ? 1 : 0,
         now,
         update.sessionId,
         userId,
         update.agentId,
       );
       if (result.changes !== 1) throw new Error('Yeaft Session identity changed during metadata update');
-    } else if (update.runtimeProvider === 'claude-code' || update.runtimeProvider === 'copilot') {
+    } else {
       const result = stmts.updateSessionPinnedForRoute.run(
-        update.pinned === true ? 1 : 0,
+        pinned ? 1 : 0,
         now,
         update.sessionId,
         update.agentId,
         userId,
       );
       if (result.changes !== 1) throw new Error('Chat Session identity changed during metadata update');
-    } else {
-      throw new Error('Unknown Session runtime provider during metadata update');
     }
   }
   return true;
@@ -42,24 +62,13 @@ function mapRow(row) {
     userId: row.user_id,
     catalogKey: row.catalog_key,
     pinned: row.pinned === 1,
+    hidden: row.is_hidden === 1,
     sortRank: Number.isFinite(row.sort_rank) ? row.sort_rank : null,
     updatedAt: row.updated_at,
   };
 }
 
 export const sessionUiMetadataDb = {
-  upsert(userId, catalogKey, { pinned = false, sortRank = null } = {}) {
-    if (!userId || !catalogKey) return false;
-    stmts.upsertSessionUiMetadata.run(
-      userId,
-      catalogKey,
-      pinned ? 1 : 0,
-      Number.isFinite(sortRank) ? sortRank : null,
-      Date.now(),
-    );
-    return true;
-  },
-
   get(userId, catalogKey) {
     if (!userId || !catalogKey) return null;
     return mapRow(stmts.getSessionUiMetadata.get(userId, catalogKey));
@@ -79,4 +88,12 @@ export const sessionUiMetadataDb = {
     if (!userId || !catalogKey) return false;
     return stmts.deleteSessionUiMetadata.run(userId, catalogKey).changes > 0;
   },
+
+  deleteForRoute(userId, { runtimeProvider, agentId, sessionId } = {}) {
+    if (!userId || !agentId || !sessionId) return false;
+    const catalogKey = runtimeProvider === 'yeaft'
+      ? yeaftCatalogKey(agentId, sessionId)
+      : chatCatalogKey(sessionId);
+    return this.delete(userId, catalogKey);
+  },
 };

package/local-runtime/server/handlers/agent-conversation.js

@@ -1,4 +1,4 @@
-import { sessionDb, messageDb } from '../database.js';
+import { sessionDb, messageDb, sessionUiMetadataDb } from '../database.js';
 import {
   broadcastAgentList, notifyConversationUpdate, forwardToClients
 } from '../ws-utils.js';
@@ -313,16 +313,36 @@ export async function handleAgentConversation(agentId, agent, msg) {
       }
       break;
 
-    case 'conversation_deleted':
+    case 'conversation_deleted': {
+      // The event came from an authenticated Agent, but the conversation id
+      // alone is not an ownership proof: a stale Agent can still hold an id
+      // after the Session was moved. Always preserve the established delete
+      // lifecycle (deactivate it), but only clear sidebar metadata when the
+      // exact persisted owner-scoped Agent/user route matches.
+      const persistedSession = sessionDb.get(msg.conversationId);
+      const metadataOwnerId = persistedSession?.user_id || null;
+      const canClearMetadata = !!persistedSession
+        && persistedSession.agent_id === agentId
+        && !!agent.ownerId
+        && metadataOwnerId === agent.ownerId;
+
       agent.conversations.delete(msg.conversationId);
       try {
         sessionDb.setActive(msg.conversationId, false);
+        if (canClearMetadata) {
+          sessionUiMetadataDb.deleteForRoute(metadataOwnerId, {
+            runtimeProvider: persistedSession.provider || 'claude-code',
+            agentId,
+            sessionId: msg.conversationId,
+          });
+        }
       } catch (e) {
-        console.error('Failed to update session in database:', e.message);
+        console.error('Failed to update deleted conversation metadata:', e.message);
       }
       await notifyConversationUpdate(agentId, msg);
       await broadcastAgentList();
       break;
+    }
 
     case 'history_sessions_list':
     case 'folders_list':

package/local-runtime/server/handlers/agent-output.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto';
-import { messageDb, yeaftProjectDb, yeaftSessionDb } from '../database.js';
+import { messageDb, sessionUiMetadataDb, yeaftProjectDb, yeaftSessionDb } from '../database.js';
 import { transaction } from '../db/connection.js';
 import { broadcastAgentList, broadcastSessionCatalog, forwardToClients, sendToAgent, sendToWebClient } from '../ws-utils.js';
 import { webClients, previewFiles } from '../context.js';
@@ -95,6 +95,11 @@ function syncYeaftSessionMetadata(agentId, agent, event) {
   try {
     yeaftSessionDb.deleteForAgent(ownerId, agentId, sessionId);
     yeaftProjectDb.removeSession(ownerId, agentId, sessionId);
+    sessionUiMetadataDb.deleteForRoute(ownerId, {
+      runtimeProvider: 'yeaft',
+      agentId,
+      sessionId,
+    });
   } catch (e) {
     console.warn('[Server] Yeaft Session metadata cleanup failed:', e?.message || e);
   }

package/local-runtime/server/handlers/client-conversation.js

@@ -11,7 +11,7 @@ import {
 import { agents, pendingFiles, trackUserTurn, webClients } from '../context.js';
 import {
   sendToWebClient, forwardToAgent,
-  broadcastAgentList, broadcastSessionCatalog, buildSessionCatalog,
+  broadcastAgentList, broadcastSessionCatalog, buildSessionCatalog, buildHiddenSessionCatalog,
   verifyConversationOwnership, verifyAgentOwnership
 } from '../ws-utils.js';
 import { routeSessionPin } from './session-pin-router.js';
@@ -100,16 +100,38 @@ function persistSessionPin(userId, routeRef, pinned) {
   }]);
 }
 
+function catalogMetadataUpdates(rows) {
+  const seen = new Set();
+  const updates = [];
+  for (const row of rows) {
+    const routeRef = row?.routeRef;
+    if (!row?.catalogKey || seen.has(row.catalogKey)
+        || !routeRef?.runtimeProvider || !routeRef?.agentId || !routeRef?.sessionId) return null;
+    seen.add(row.catalogKey);
+    updates.push({
+      catalogKey: row.catalogKey,
+      runtimeProvider: routeRef.runtimeProvider,
+      agentId: routeRef.agentId,
+      sessionId: routeRef.sessionId,
+      pinned: row.pinned === true,
+      hidden: row.hidden === true,
+      sortRank: updates.length,
+    });
+  }
+  return updates;
+}
+
 function catalogOrderUpdates(client, items) {
   if (!client?.userId || !Array.isArray(items) || items.length === 0) return null;
   const canonical = buildSessionCatalog(client.userId, client.role);
+  const hidden = buildHiddenSessionCatalog(client.userId, client.role);
   if (canonical.length !== items.length) return null;
   const canonicalByKey = new Map(canonical.map(row => [row.catalogKey, row]));
   if (canonicalByKey.size !== canonical.length) return null;
 
   const seen = new Set();
-  const updates = [];
-  for (const [sortRank, item] of items.entries()) {
+  const orderedVisible = [];
+  for (const item of items) {
     const row = canonicalByKey.get(item?.catalogKey);
     const routeRef = item?.routeRef;
     if (!row || seen.has(item.catalogKey)
@@ -117,16 +139,44 @@ function catalogOrderUpdates(client, items) {
         || routeRef?.agentId !== row.routeRef?.agentId
         || routeRef?.sessionId !== row.routeRef?.sessionId) return null;
     seen.add(item.catalogKey);
-    updates.push({
-      catalogKey: row.catalogKey,
-      runtimeProvider: row.routeRef.runtimeProvider,
-      agentId: row.routeRef.agentId,
-      sessionId: row.routeRef.sessionId,
-      pinned: row.pinned === true,
-      sortRank,
-    });
+    orderedVisible.push(row);
   }
-  return seen.size === canonical.length ? updates : null;
+  if (seen.size !== canonical.length) return null;
+
+  // Hidden rows are deliberately absent from a drag payload, but their stale
+  // ranks must not collide with the newly ordered visible catalog when they
+  // are restored. Normalize both sets in the same transaction, preserving the
+  // visible order chosen by the client and the current hidden-row order.
+  return catalogMetadataUpdates([...orderedVisible, ...hidden]);
+}
+
+function catalogVisibilityUpdates(client, row, hidden) {
+  if (!client?.userId || !row?.catalogKey || !row?.routeRef) return null;
+  const visible = buildSessionCatalog(client.userId, client.role);
+  const hiddenRows = buildHiddenSessionCatalog(client.userId, client.role);
+  const visibleByKey = new Map(visible.map(item => [item.catalogKey, item]));
+  const hiddenByKey = new Map(hiddenRows.map(item => [item.catalogKey, item]));
+  if (visibleByKey.size !== visible.length || hiddenByKey.size !== hiddenRows.length) return null;
+
+  if (hidden) {
+    const visibleRow = visibleByKey.get(row.catalogKey);
+    if (!visibleRow || hiddenByKey.has(row.catalogKey)) return null;
+    return catalogMetadataUpdates([
+      ...visible.filter(item => item.catalogKey !== row.catalogKey),
+      { ...visibleRow, hidden: true },
+      ...hiddenRows,
+    ]);
+  }
+
+  const hiddenRow = hiddenByKey.get(row.catalogKey);
+  if (!hiddenRow || visibleByKey.has(row.catalogKey)) return null;
+
+  // The UI adds a restored Session after the visible list. Keep that policy on
+  // the server and also normalize any still-hidden rows, so no stale rank can
+  // collide with this restored row during a later refresh or restore.
+  const restored = { ...hiddenRow, hidden: false };
+  const remainingHidden = hiddenRows.filter(item => item.catalogKey !== restored.catalogKey);
+  return catalogMetadataUpdates([...visible, restored, ...remainingHidden]);
 }
 
 export function groupOnlineYeaftSessions(rows, agentRegistry = agents) {
@@ -472,6 +522,11 @@ export async function handleClientConversation(clientId, client, msg, checkAgent
 
       try {
         sessionDb.setActive(msg.conversationId, false);
+        sessionUiMetadataDb.deleteForRoute(client.userId, {
+          runtimeProvider: persisted?.provider || 'claude-code',
+          agentId: deleteAgentId,
+          sessionId: msg.conversationId,
+        });
         const deleteAgent = agents.get(deleteAgentId);
         deleteAgent?.conversations.delete(msg.conversationId);
         await broadcastAgentList();
@@ -574,31 +629,67 @@ export async function handleClientConversation(clientId, client, msg, checkAgent
       if (!client.userId || !msg.catalogKey || !msg.routeRef?.runtimeProvider) break;
       const { runtimeProvider, agentId, sessionId } = msg.routeRef;
       let expectedCatalogKey = null;
+      let sessionRow = null;
       if (runtimeProvider === 'yeaft') {
-        if (agentId && sessionId && yeaftSessionDb.getForAgent(client.userId, agentId, sessionId)) {
-          expectedCatalogKey = yeaftCatalogKey(agentId, sessionId);
-        }
+        sessionRow = agentId && sessionId
+          ? yeaftSessionDb.getForAgent(client.userId, agentId, sessionId)
+          : null;
+        if (sessionRow) expectedCatalogKey = yeaftCatalogKey(agentId, sessionId);
       } else if (runtimeProvider === 'claude-code' || runtimeProvider === 'copilot') {
-        const row = sessionId ? sessionDb.get(sessionId) : null;
+        sessionRow = sessionId ? sessionDb.get(sessionId) : null;
         if (agentId && sessionId
           && (CONFIG.skipAuth || verifyConversationOwnership(sessionId, client.userId, client.role))
-          && row?.agent_id === agentId
-          && (row.provider || 'claude-code') === runtimeProvider) {
+          && sessionRow?.agent_id === agentId
+          && (sessionRow.provider || 'claude-code') === runtimeProvider) {
           expectedCatalogKey = chatCatalogKey(sessionId);
         }
       }
       const authorized = expectedCatalogKey === msg.catalogKey;
+      let currentMetadata = null;
+      if (authorized) {
+        try {
+          currentMetadata = sessionUiMetadataDb.get(client.userId, expectedCatalogKey);
+        } catch (e) {
+          console.warn('[Server] Session metadata read failed:', e?.message || e);
+        }
+      }
+      const persistedPinned = runtimeProvider === 'yeaft'
+        ? (sessionRow?.pinned === true || sessionRow?.isPinned === true)
+        : sessionRow?.is_pinned === 1;
+      const nextPinned = typeof msg.pinned === 'boolean'
+        ? msg.pinned
+        : (currentMetadata?.pinned ?? !!persistedPinned);
+      const hasHidden = typeof msg.hidden === 'boolean';
+      const nextHidden = hasHidden
+        ? msg.hidden
+        : currentMetadata?.hidden === true;
+      const nextSortRank = Number.isFinite(msg.sortRank)
+        ? msg.sortRank
+        : (currentMetadata?.sortRank ?? null);
+      const hasSortRank = Object.prototype.hasOwnProperty.call(msg, 'sortRank');
       let persisted = false;
       if (authorized) {
         try {
-          persisted = sessionUiMetadataDb.applyBatch(client.userId, [{
-            catalogKey: expectedCatalogKey,
-            runtimeProvider,
-            agentId,
-            sessionId,
-            pinned: msg.pinned === true,
-            sortRank: Number.isFinite(msg.sortRank) ? msg.sortRank : null,
-          }]);
+          // Only an explicit hidden mutation changes catalog membership. A
+          // pinned-only first update has no metadata row yet, so comparing an
+          // implicit undefined state to false would incorrectly treat it as a
+          // restore and reject the valid visible route.
+          const visibilityChanged = hasHidden && (currentMetadata?.hidden === true) !== nextHidden;
+          const updates = visibilityChanged
+            ? catalogVisibilityUpdates(client, {
+              catalogKey: expectedCatalogKey,
+              routeRef: { runtimeProvider, agentId, sessionId },
+            }, nextHidden)
+            : [{
+              catalogKey: expectedCatalogKey,
+              runtimeProvider,
+              agentId,
+              sessionId,
+              pinned: nextPinned,
+              hidden: nextHidden,
+              ...(hasSortRank ? { sortRank: nextSortRank } : {}),
+            }];
+          persisted = updates ? sessionUiMetadataDb.applyBatch(client.userId, updates) : false;
           if (persisted) await broadcastSessionCatalog(client.userId);
         } catch (e) {
           console.warn('[Server] Session metadata update failed:', e?.message || e);
@@ -611,8 +702,9 @@ export async function handleClientConversation(clientId, client, msg, checkAgent
         catalogKey: msg.catalogKey,
         routeRef: msg.routeRef,
         ...(persisted ? {
-          pinned: msg.pinned === true,
-          sortRank: Number.isFinite(msg.sortRank) ? msg.sortRank : null,
+          pinned: nextPinned,
+          hidden: nextHidden,
+          sortRank: nextSortRank,
         } : { error: 'Permission denied or stale Session route' }),
       });
       break;

package/local-runtime/server/session-catalog.js

@@ -35,11 +35,24 @@ function hasCompleteSortRanks(rows) {
   return ranks.every(Number.isFinite) && new Set(ranks).size === rows.length;
 }
 
+function catalogSort(left, right, ranked = false) {
+  if (left.pinned !== right.pinned) return left.pinned ? -1 : 1;
+  if (ranked) {
+    const leftRank = Number.isFinite(left.sortRank) ? left.sortRank : Number.MAX_SAFE_INTEGER;
+    const rightRank = Number.isFinite(right.sortRank) ? right.sortRank : Number.MAX_SAFE_INTEGER;
+    if (leftRank !== rightRank) return leftRank - rightRank;
+  }
+  const metadataDelta = timestampValue(right.metadataUpdatedAt) - timestampValue(left.metadataUpdatedAt);
+  if (metadataDelta !== 0) return metadataDelta;
+  return left.catalogKey.localeCompare(right.catalogKey);
+}
+
 export function projectSessionCatalog({
   chatSessions = [],
   yeaftSessions = [],
   metadata = [],
   onlineAgentIds = new Set(),
+  includeHidden = false,
 } = {}) {
   const metadataByKey = new Map(metadata.map(row => [row.catalogKey, row]));
   const onlineAgents = onlineAgentIds instanceof Set ? onlineAgentIds : new Set(onlineAgentIds);
@@ -50,6 +63,7 @@ export function projectSessionCatalog({
     const catalogKey = chatCatalogKey(session.id);
     const runtimeProvider = normalizeChatRuntimeProvider(session.provider);
     const meta = metadataByKey.get(catalogKey) || {};
+    if (!includeHidden && meta.hidden === true) continue;
     rows.push({
       catalogKey,
       runtimeProvider,
@@ -60,6 +74,7 @@ export function projectSessionCatalog({
       agentName: session.agent_name || '',
       availability: onlineAgents.has(session.agent_id) ? 'online' : 'offline',
       pinned: meta.pinned ?? session.is_pinned === 1,
+      hidden: meta.hidden === true,
       sortRank: meta.sortRank ?? null,
       createdAt: session.created_at || null,
       metadataUpdatedAt: session.metadata_updated_at ?? session.created_at ?? null,
@@ -69,6 +84,7 @@ export function projectSessionCatalog({
   for (const session of yeaftSessions) {
     const catalogKey = yeaftCatalogKey(session.agentId, session.id);
     const meta = metadataByKey.get(catalogKey) || {};
+    if (!includeHidden && meta.hidden === true) continue;
     rows.push({
       catalogKey,
       runtimeProvider: 'yeaft',
@@ -79,6 +95,7 @@ export function projectSessionCatalog({
       agentName: session.agentName || '',
       availability: onlineAgents.has(session.agentId) ? 'online' : 'offline',
       pinned: meta.pinned ?? !!session.pinned,
+      hidden: meta.hidden === true,
       sortRank: meta.sortRank ?? null,
       createdAt: session.createdAt || null,
       metadataUpdatedAt: session.metadataUpdatedAt ?? session.createdAt ?? null,
@@ -86,15 +103,5 @@ export function projectSessionCatalog({
   }
 
   const ranked = hasCompleteSortRanks(rows);
-  return rows.sort((left, right) => {
-    if (left.pinned !== right.pinned) return left.pinned ? -1 : 1;
-    if (ranked) {
-      const leftRank = Number.isFinite(left.sortRank) ? left.sortRank : Number.MAX_SAFE_INTEGER;
-      const rightRank = Number.isFinite(right.sortRank) ? right.sortRank : Number.MAX_SAFE_INTEGER;
-      if (leftRank !== rightRank) return leftRank - rightRank;
-    }
-    const metadataDelta = timestampValue(right.metadataUpdatedAt) - timestampValue(left.metadataUpdatedAt);
-    if (metadataDelta !== 0) return metadataDelta;
-    return left.catalogKey.localeCompare(right.catalogKey);
-  });
+  return rows.sort((left, right) => catalogSort(left, right, ranked));
 }

package/local-runtime/server/ws-utils.js

@@ -100,7 +100,7 @@ export function verifyPersistedAgentOwnership(agentId, userId, role = null) {
     || yeaftSessionDb.getByUser(userId).some(row => row.agentId === agentId);
 }
 
-export function buildSessionCatalog(userId, role = null) {
+function catalogProjectionInputs(userId, role = null) {
   const chatSessions = sessionDb.getActiveByUser(userId).filter((session) => {
     if (CONFIG.skipAuth || session.user_id === userId) return true;
     if (session.user_id != null) return false;
@@ -108,12 +108,25 @@ export function buildSessionCatalog(userId, role = null) {
     // offline. This same predicate protects catalog mutations.
     return verifyPersistedAgentOwnership(session.agent_id, userId, role);
   });
-  return projectSessionCatalog({
+  const yeaftSessions = yeaftSessionDb.getByUser(userId);
+  const metadata = sessionUiMetadataDb.getByUser(userId);
+  return {
     chatSessions,
-    yeaftSessions: yeaftSessionDb.getByUser(userId),
-    metadata: sessionUiMetadataDb.getByUser(userId),
+    yeaftSessions,
+    metadata,
     onlineAgentIds: onlineAgentIdsForUser(userId, role),
-  });
+  };
+}
+
+export function buildSessionCatalog(userId, role = null) {
+  return projectSessionCatalog(catalogProjectionInputs(userId, role));
+}
+
+export function buildHiddenSessionCatalog(userId, role = null) {
+  return projectSessionCatalog({
+    ...catalogProjectionInputs(userId, role),
+    includeHidden: true,
+  }).filter(row => row.hidden === true);
 }
 
 // Broadcast the owner-scoped read model after canonical Session state changes.
@@ -126,6 +139,7 @@ export async function broadcastSessionCatalog(userId) {
       await sendToWebClient(client, {
         type: 'session_catalog_snapshot',
         catalog: buildSessionCatalog(userId, client.role),
+        hiddenCatalog: buildHiddenSessionCatalog(userId, client.role),
         projects: yeaftProjectDb.list(userId),
         projectsAuthoritative: true,
       });
@@ -189,6 +203,7 @@ export async function broadcastAgentList() {
         await sendToWebClient(client, {
           type: 'session_catalog_snapshot',
           catalog: buildSessionCatalog(client.userId, client.role),
+          hiddenCatalog: buildHiddenSessionCatalog(client.userId, client.role),
           projects: yeaftProjectDb.list(client.userId),
           projectsAuthoritative: true,
         });

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.345"}
+{"version":"1.0.346"}