@agent-team-foundation/first-tree-hub 0.12.7 → 0.12.9

package/dist/{saas-connect-CY2NxeKx.mjs → saas-connect-CXZhK485.mjs}

@@ -2,10 +2,10 @@ import { a as __toCommonJS, o as __toESM, t as __commonJSMin } from "./chunk-BSw
 import { A as FIRST_TREE_HUB_ATTR, C as stampOrgScope, D as untrustedAttrs, E as startWsConnectionSpan, M as require_pino, O as withSpan, S as stampChatResource, _ as rootLogger$1, a as buildRateLimitError, c as currentTraceId, g as reportErrorToRoot, i as bodyCaptureOnSendHook, j as redactUrl, k as withWsMessageSpan, l as decodeJwtForTrace, m as observabilityPlugin, n as applyLoggerConfig, o as classifyJoseError, r as attachRequestContext, s as createLogger$1, t as adapterAttrs, u as endWsConnectionSpan, x as stampAgentResource, y as setWsConnectionAttrs } from "./observability-BAScT_5S-BcW9HgkG.mjs";
 import { C as resetConfigMeta, E as setConfigValue, S as resetConfig, T as serverConfigSchema, b as migrateLegacyHome, c as resolveServerUrl, d as DEFAULT_CONFIG_DIR, f as DEFAULT_DATA_DIR$1, g as collectMissingPrompts, h as clientConfigSchema, i as ensureFreshAccessToken, l as saveAgentConfig, m as agentConfigSchema, o as loadCredentials, p as DEFAULT_HOME_DIR$1, u as saveCredentials, v as initConfig, w as resolveConfigReadonly, y as loadAgents } from "./bootstrap-BCZC1ki6.mjs";
 import { a as print, i as blank, n as CLI_USER_AGENT, r as COMMAND_VERSION, s as status, t as cliFetch } from "./cli-fetch--tiwKm5S.mjs";
-import { A as delegateFeishuUserSchema, B as inboxPollQuerySchema, C as createAgentSchema, D as createOrgFromMeSchema, E as createMemberSchema, F as githubDevCallbackQuerySchema, G as listMeChatsQuerySchema, H as isRedactedEnvValue, I as githubStartQuerySchema, J as notificationQuerySchema, K as loginSchema, L as imageInlineContentSchema, N as githubAppInstallationClaimBodySchema, P as githubCallbackQuerySchema, R as inboxAckFrameSchema, S as createAdapterMappingSchema, St as wsAuthFrameSchema, T as createMeChatSchema, U as isReservedAgentName$1, V as isOrgSettingNamespace, W as joinByInvitationSchema, X as paginationQuerySchema, Y as onboardingEventSchema, Z as patchOnboardingSchema, _t as updateAgentSchema, a as AGENT_VISIBILITY, at as selfServiceFeishuBotSchema, b as contextTreeSnapshotSchema, bt as updateMemberSchema, c as ORG_SETTINGS_NAMESPACES$1, ct as sessionCompletionMessageSchema, d as addParticipantSchema, dt as sessionReconcileRequestSchema, et as rebindAgentSchema, f as agentBindRequestSchema, ft as sessionStateMessageSchema, g as chatMetadataSchema$1, gt as updateAgentRuntimeConfigSchema, h as agentTypeSchema$1, ht as updateAdapterConfigSchema, i as AGENT_STATUSES, j as dryRunAgentRuntimeConfigSchema, k as defaultRuntimeConfigPayload, l as WS_AUTH_FRAME_TIMEOUT_MS, lt as sessionEventMessageSchema, m as agentRuntimeConfigPayloadSchema$1, mt as submitQuestionAnswerSchema, n as AGENT_NAME_REGEX$1, nt as runtimeStateMessageSchema, ot as sendMessageSchema, p as agentPinnedMessageSchema$1, pt as stripCode, q as messageSourceSchema$1, r as AGENT_SELECTOR_HEADER$1, rt as safeRedirectPath, s as MENTION_REGEX, st as sendToAgentSchema, t as AGENT_BIND_REJECT_REASONS, tt as refreshTokenSchema, u as addMeChatParticipantsSchema, ut as sessionEventSchema$1, v as clientRegisterSchema, vt as updateChatSchema, w as createChatSchema, x as createAdapterConfigSchema, xt as updateOrganizationSchema, y as connectTokenExchangeSchema, yt as updateClientCapabilitiesSchema, z as inboxDeliverFrameSchema$1 } from "./dist-CTkhS6p5.mjs";
+import { $ as patchOnboardingSchema, A as defaultRuntimeConfigPayload, B as inboxDeliverFrameSchema$1, C as createAdapterMappingSchema, Ct as updateOrganizationSchema, D as createMemberSchema, E as createMeChatSchema, F as githubCallbackQuerySchema, G as joinByInvitationSchema, H as isOrgSettingNamespace, I as githubDevCallbackQuerySchema, J as messageSourceSchema$1, K as listMeChatsQuerySchema, L as githubStartQuerySchema, M as dryRunAgentRuntimeConfigSchema, O as createOrgFromMeSchema, P as githubAppInstallationClaimBodySchema, Q as patchChatEngagementSchema, R as imageInlineContentSchema, S as createAdapterConfigSchema, St as updateMemberSchema, T as createChatSchema, U as isRedactedEnvValue, V as inboxPollQuerySchema, W as isReservedAgentName$1, X as onboardingEventSchema, Y as notificationQuerySchema, Z as paginationQuerySchema, _ as chatMetadataSchema$1, _t as updateAdapterConfigSchema, a as AGENT_VISIBILITY, at as safeRedirectPath, b as connectTokenExchangeSchema, bt as updateChatSchema, c as MENTION_REGEX, ct as sendMessageSchema, d as addMeChatParticipantsSchema, dt as sessionEventMessageSchema, f as addParticipantSchema, ft as sessionEventSchema$1, g as agentTypeSchema$1, gt as submitQuestionAnswerSchema, h as agentRuntimeConfigPayloadSchema$1, ht as stripCode, i as AGENT_STATUSES, it as runtimeStateMessageSchema, j as delegateFeishuUserSchema, l as ORG_SETTINGS_NAMESPACES$1, lt as sendToAgentSchema, m as agentPinnedMessageSchema$1, mt as sessionStateMessageSchema, n as AGENT_NAME_REGEX$1, nt as rebindAgentSchema, o as CHAT_ENGAGEMENT_STATUSES, p as agentBindRequestSchema, pt as sessionReconcileRequestSchema, q as loginSchema, r as AGENT_SELECTOR_HEADER$1, rt as refreshTokenSchema, st as selfServiceFeishuBotSchema, t as AGENT_BIND_REJECT_REASONS, u as WS_AUTH_FRAME_TIMEOUT_MS, ut as sessionCompletionMessageSchema, vt as updateAgentRuntimeConfigSchema, w as createAgentSchema, wt as wsAuthFrameSchema, x as contextTreeSnapshotSchema, xt as updateClientCapabilitiesSchema, y as clientRegisterSchema, yt as updateAgentSchema, z as inboxAckFrameSchema } from "./dist-CnjqakXS.mjs";
 import { a as ConflictError, c as UnauthorizedError, i as ClientUserMismatchError$1, l as organizations, n as BadRequestError, o as ForbiddenError, r as ClientOrgMismatchError$1, s as NotFoundError, t as AppError, u as users } from "./errors-CF5evtJt-B0NTIVPt.mjs";
 import { n as init_esm, r as trace, t as esm_exports } from "./esm-iadMkGbV.mjs";
-import { $ as messages, A as getOnlineCount, B as listActiveAgentsPinnedToClient, C as ensureCanJoin, D as getCachedAudience, E as getActivityOverview, F as invalidateChatAudience, G as listChatsForMember, H as listAgentsWithRuntime, I as joinAsParticipant, J as listMessages, K as listClients, L as joinChat, M as heartbeatClient, N as heartbeatInstance, O as getChatDetail, P as inboxEntries, Q as members, R as leaveAsParticipant, S as editMessage, T as findOrCreateDirectChat, U as listChatParticipantsWithNames, V as listAgentsManagedByUser, W as listChats, X as markStaleAgents, Z as markSupersededByChat, _ as clients, _t as touchAgent, a as agentVisibilityCondition, at as registerChatMessageDispatcher, b as deriveAuthState, bt as upsertSessionState, c as assertParticipant, ct as resetActivity, d as chatParticipants, dt as sendMessage, et as notifyRecipients, f as chatSubscriptions, ft as sendToAgent$1, g as cleanupStalePresence, gt as submitAnswer, h as cleanupStaleClients, ht as setRuntimeState, i as agentPresence, it as recomputeWatchersForMember, j as getPresence, k as getClient, l as bindAgent, lt as resolveChatMembership, m as claimClient, mt as setOffline, n as addParticipant, nt as recomputeChatWatchers, o as agents, ot as registerClient, p as chats, pt as serverInstances, q as listClientsForOrgAdmin, r as agentChatSessions, rt as recomputeWatchersForAgent, s as assertClientOwner, st as removeParticipant, t as addChatParticipants, tt as pendingQuestions, u as changeChatType, ut as retireClient, v as createChat, vt as unbindAgent, w as ensureParticipant$1, x as disconnectClient, y as createNotifier, yt as updateClientCapabilities, z as leaveChat } from "./client-h5l7mi0m-OEX7MOBg.mjs";
+import { $ as notifyRecipients, A as getPresence, B as listAgentsManagedByUser, C as ensureParticipant, D as getChatDetail, E as getCachedAudience, F as joinAsParticipant, G as listClients, H as listChatParticipantsWithNames, I as joinChat, K as listClientsForOrgAdmin, L as leaveAsParticipant, M as heartbeatInstance, N as inboxEntries, O as getClient, P as invalidateChatAudience, Q as messages, R as leaveChat, S as ensureCanJoin, T as getActivityOverview, U as listChats, V as listAgentsWithRuntime, W as listChatsForMember, X as markSupersededByChat, Y as markStaleAgents, Z as members, _ as createChat, _t as unbindAgent, a as agentVisibilityCondition, at as registerClient, b as disconnectClient, c as assertParticipant, ct as resolveChatMembership, d as chatMembership, dt as sendToAgent$1, et as pendingQuestions, f as chats, ft as serverInstances, g as clients, gt as touchAgent, h as cleanupStalePresence, ht as submitAnswer, i as agentPresence, it as registerChatMessageDispatcher, j as heartbeatClient, k as getOnlineCount, l as bindAgent, lt as retireClient, m as cleanupStaleClients, mt as setRuntimeState, n as addParticipant, nt as recomputeWatchersForAgent, o as agents, ot as removeParticipant, p as claimClient, pt as setOffline, q as listMessages, r as agentChatSessions, rt as recomputeWatchersForMember, s as assertClientOwner, st as resetActivity, t as addChatParticipants, tt as recomputeChatWatchers, u as changeChatType, ut as sendMessage, v as createNotifier, vt as updateClientCapabilities, w as findOrCreateDirectChat, x as editMessage, y as deriveAuthState, yt as upsertSessionState, z as listActiveAgentsPinnedToClient } from "./client-OMwJMCQt-R1T06ZH6.mjs";
 import { a as invitationRedemptions, c as recordRedemption, i as getActiveInvitation, l as rotateInvitation, n as ensureActiveInvitation, o as invitations, r as findActiveByToken, t as buildInviteUrl, u as uuidv7 } from "./invitation-Bg0TRiyx-BsZH4GCS.mjs";
 import { createRequire } from "node:module";
 import { ZodError, z } from "zod";
@@ -764,6 +764,12 @@ const chatTypeSchema = z.enum([
 	"group",
 	"thread"
 ]);
+const chatEngagementStatusSchema = z.enum([
+	"active",
+	"archived",
+	"deleted"
+]);
+z.object({ status: chatEngagementStatusSchema });
 z.object({
 	type: chatTypeSchema,
 	topic: z.string().max(500).optional(),
@@ -793,7 +799,8 @@ z.object({
 }).extend({
 	participants: z.array(chatParticipantSchema),
 	title: z.string(),
-	firstMessagePreview: z.string().nullable()
+	firstMessagePreview: z.string().nullable(),
+	engagementStatus: chatEngagementStatusSchema
 });
 z.object({ topic: z.string().trim().max(500).nullable() });
 z.object({ agentId: z.string().min(1) });
@@ -1242,10 +1249,16 @@ const meChatFilterSchema = z.enum([
 	"watching"
 ]);
 const meChatMembershipKindSchema = z.enum(["participant", "watching"]);
+const chatEngagementViewSchema = z.enum([
+	"active",
+	"archived",
+	"all"
+]);
 z.object({
 	cursor: z.string().optional(),
 	limit: z.coerce.number().int().min(1).max(200).default(50),
-	filter: meChatFilterSchema.default("all")
+	filter: meChatFilterSchema.default("all"),
+	engagement: chatEngagementViewSchema.default("active")
 });
 const meChatParticipantSchema = z.object({
 	agentId: z.string(),
@@ -1263,7 +1276,8 @@ const meChatRowSchema = z.object({
 	lastMessageAt: z.string().nullable(),
 	lastMessagePreview: z.string().nullable(),
 	unreadMentionCount: z.number().int(),
-	canReply: z.boolean()
+	canReply: z.boolean(),
+	engagementStatus: chatEngagementStatusSchema
 });
 z.object({
 	rows: z.array(meChatRowSchema),
@@ -3240,7 +3254,9 @@ You are running inside **Agent Hub**, a messaging platform for agent teams.
 - **Your final text response is automatically delivered** to the chat — just respond normally
 - For **proactive communication** (sending to other agents, other chats, or structured data),
   use the \`first-tree-hub\` CLI below
-- **Use your judgment about when to respond.** Not every message requires a reply.
+- **Use your judgment about when to respond.** Not every message requires
+  a reply — if you have nothing new for the recipient, output nothing and
+  the runtime will end the turn silently.
   Your role and responsibilities are injected via the Hub-managed system prompt.
 
 ## Environment Variables
@@ -5844,6 +5860,11 @@ function createResultSink(deps) {
 		return { mentions: [trigger.senderId] };
 	}
 	return async function forwardResult(text) {
+		if (text.trim().length === 0) {
+			deps.clearTrigger();
+			deps.log("silent turn: agent produced empty output, skipping delivery");
+			return;
+		}
 		const trigger = deps.getTrigger();
 		deps.clearTrigger();
 		const metadata = await buildMetadata(trigger);
@@ -9422,7 +9443,7 @@ async function onboardCreate(args) {
 	}
 	const runtimeAgent = args.type === "human" ? args.assistant : args.id;
 	if (args.feishuBotAppId && args.feishuBotAppSecret) {
-		const { bindFeishuBot } = await import("./feishu-DJm0EaZP.mjs").then((n) => n.r);
+		const { bindFeishuBot } = await import("./feishu-DrnBbl8T.mjs").then((n) => n.r);
 		const targetAgentUuid = args.type === "human" ? assistantUuid : primary.uuid;
 		if (!targetAgentUuid) print.line(`Warning: Cannot bind Feishu bot — no runtime agent available for "${args.id}".\n`);
 		else {
@@ -10635,7 +10656,7 @@ function createFeedbackHandler(config) {
 	return { handle };
 }
 //#endregion
-//#region ../server/dist/app-BGjMcVXo.mjs
+//#region ../server/dist/app-BpskScln.mjs
 var import_fastify_opentelemetry = /* @__PURE__ */ __toESM(require_fastify_opentelemetry(), 1);
 init_esm();
 var __defProp = Object.defineProperty;
@@ -10742,7 +10763,7 @@ async function requireChatAccess(request, db) {
 		role: caller.role,
 		humanAgentId: caller.humanAgentId
 	};
-	const [direct] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, caller.humanAgentId))).limit(1);
+	const [direct] = await db.select({ chatId: chatMembership.chatId }).from(chatMembership).where(and(eq(chatMembership.chatId, chatId), eq(chatMembership.agentId, caller.humanAgentId), eq(chatMembership.accessMode, "speaker"))).limit(1);
 	if (direct) {
 		stampOrgScope(request, scope);
 		stampChatResource(request, chat);
@@ -10751,7 +10772,7 @@ async function requireChatAccess(request, db) {
 			scope
 		};
 	}
-	const participantRows = await db.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
+	const participantRows = await db.select({ agentId: chatMembership.agentId }).from(chatMembership).where(and(eq(chatMembership.chatId, chatId), eq(chatMembership.accessMode, "speaker")));
 	if (participantRows.length === 0) throw new NotFoundError(`Chat "${chatId}" not found`);
 	const participantIds = participantRows.map((p) => p.agentId);
 	const [managed] = await db.select({ uuid: agents.uuid }).from(agents).where(and(inArray(agents.uuid, participantIds), eq(agents.managerId, caller.memberId))).limit(1);
@@ -11843,19 +11864,6 @@ async function findOrCreateChatForChannel(db, data) {
 		return chatId;
 	});
 }
-/**
-* Ensure an agent is a participant of a chat (no-op if already). Mode is
-* derived via the canonical entrypoint — pre-fix this also wrote `mode:`
-* implicitly via schema default `'full'`, which is wrong for non-human
-* agents in a group chat (the bug §1.1 of the Phase 1 design doc fixes).
-*/
-async function ensureParticipant(db, chatId, agentId) {
-	const [exists] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, agentId))).limit(1);
-	if (!exists) await addChatParticipants(db, chatId, [{
-		agentId,
-		role: "member"
-	}], { onConflictDoNothing: true });
-}
 /** Store a cross-reference between internal and external message. */
 async function createMessageReference(db, data) {
 	await db.insert(adapterMessageReferences).values({
@@ -11938,9 +11946,9 @@ async function buildClientMessagePayloadsForInbox(db, inboxId, items) {
 	const modeByChat = /* @__PURE__ */ new Map();
 	if (chatIds.length > 0) {
 		const rows = await db.select({
-			chatId: chatParticipants.chatId,
-			mode: chatParticipants.mode
-		}).from(chatParticipants).where(and(eq(chatParticipants.agentId, agentId), inArray(chatParticipants.chatId, chatIds)));
+			chatId: chatMembership.chatId,
+			mode: chatMembership.mode
+		}).from(chatMembership).where(and(eq(chatMembership.agentId, agentId), inArray(chatMembership.chatId, chatIds), eq(chatMembership.accessMode, "speaker")));
 		for (const r of rows) modeByChat.set(r.chatId, normaliseMode(r.mode));
 	}
 	const inReplyToIds = [...new Set(items.map((it) => it.message.inReplyTo).filter((id) => id !== null))];
@@ -12341,7 +12349,7 @@ async function prepareImageOutbound(db, notifier, chatId, data) {
 * chat reply (see `services/message.ts` replyTo routing).
 */
 async function collectTargetInboxes(db, chatId, inReplyTo) {
-	const participants = await db.select({ inboxId: agents.inboxId }).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.uuid)).where(eq(chatParticipants.chatId, chatId));
+	const participants = await db.select({ inboxId: agents.inboxId }).from(chatMembership).innerJoin(agents, eq(chatMembership.agentId, agents.uuid)).where(and(eq(chatMembership.chatId, chatId), eq(chatMembership.accessMode, "speaker")));
 	const set = new Set(participants.map((p) => p.inboxId));
 	if (inReplyTo) {
 		const [original] = await db.select({ replyToInbox: messages.replyToInbox }).from(messages).where(eq(messages.id, inReplyTo)).limit(1);
@@ -15267,6 +15275,47 @@ async function bootstrapConfigRoutes(_app) {
 		return { allowedOrg: null };
 	});
 }
+/**
+* Per-(chat, agent) user state — independent from membership structure.
+*
+* This is the third layer of the chat data model: while `chats` owns
+* the entity and `chat_membership` owns the structural relation
+* (who can speak, who watches), this table owns the user's private
+* state about a chat. The reason it lives apart: structural changes
+* (speaker ↔ watcher, manager rebind, recompute) must never overwrite
+* user-private state — physical separation makes that an invariant
+* rather than a service-layer discipline.
+*
+* Columns evolve incrementally as new per-user state is needed.
+* Currently:
+*   - `last_read_at`, `unread_mention_count` — seeded by PR-A from
+*     the legacy `chat_participants` / `chat_subscriptions` columns.
+*   - `engagement_status` — added in 0040; per-(chat, user) view
+*     state (active / archived / deleted). Auto-revives archived →
+*     active on new message; deleted is sticky (only the user can
+*     restore from the chat detail page).
+*
+* Future fields slated for this table: pinned, mute_until, draft,
+* custom_title, last_seen_at — each as a separate change.
+*
+* Rows are lazy-upserted on first user write (markRead / mention
+* counter bump / engagement transition). Reads use COALESCE for
+* defaults so callers see `'active'` etc. even when no row exists.
+* Service-layer integrity (no FK / CHECK / trigger).
+*
+* See proposals/chat-data-model-restructure.20260512.md §8.6.
+*/
+const chatUserState = pgTable("chat_user_state", {
+	chatId: text("chat_id").notNull(),
+	agentId: text("agent_id").notNull(),
+	lastReadAt: timestamp("last_read_at", { withTimezone: true }),
+	unreadMentionCount: integer("unread_mention_count").notNull().default(0),
+	engagementStatus: text("engagement_status").notNull().default("active")
+}, (table) => [
+	primaryKey({ columns: [table.chatId, table.agentId] }),
+	index("idx_user_state_agent").on(table.agentId),
+	index("idx_user_state_unread").on(table.agentId).where(sql`unread_mention_count > 0`)
+]);
 /** Extract a plain-text summary from a message's JSONB content field.
 *  Used as the auto-title fallback in chat list rendering — see
 *  `me-chat.ts:resolveChatTitle` and `admin/chats.ts:getChat`.
@@ -15462,7 +15511,7 @@ async function transitionSessionState(db, agentId, chatId, target, from, organiz
 async function filterSessionsByParticipant(db, sessions, participantAgentId) {
 	if (sessions.length === 0) return [];
 	const chatIds = sessions.map((s) => s.chatId);
-	const participantRows = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(inArray(chatParticipants.chatId, chatIds), eq(chatParticipants.agentId, participantAgentId)));
+	const participantRows = await db.select({ chatId: chatMembership.chatId }).from(chatMembership).where(and(inArray(chatMembership.chatId, chatIds), eq(chatMembership.agentId, participantAgentId), eq(chatMembership.accessMode, "speaker")));
 	const allowedChatIds = new Set(participantRows.map((r) => r.chatId));
 	return sessions.filter((s) => allowedChatIds.has(s.chatId));
 }
@@ -15471,16 +15520,17 @@ async function filterSessionsByParticipant(db, sessions, participantAgentId) {
 * workspace).
 *
 * Responsibilities:
-*   - Cursor-paginated conversation list across participant + watcher rows
-*     for the caller's human agent.
+*   - Cursor-paginated conversation list (single-stream JOIN over the
+*     unified `chat_membership` + `chat_user_state` tables).
 *   - Create a new chat (no dedupe, runs `recomputeChatWatchers` after).
-*   - Add participants (idempotent, runs `recomputeChatWatchers` after).
-*   - Mark-read (touches whichever of the two tables holds the user's row).
-*   - Join → state-carry watcher → speaker (delegates to `watcher.ts`).
-*   - Leave → state-carry speaker → watcher (delegates to `watcher.ts`).
+*   - Add participants (idempotent, UPSERT into `chat_membership`,
+*     runs `recomputeChatWatchers` after).
+*   - Mark-read (UPSERT into `chat_user_state`).
+*   - Join → watcher to speaker (delegates to `watcher.ts`).
+*   - Leave → speaker to watcher or detach (delegates to `watcher.ts`).
 *
-* See docs/chat-first-workspace-product-design.md "API Contract" + "Data
-* Model".
+* See proposals/chat-data-model-restructure.20260512.md §8 (schema)
+* and §11.1 (per-route mapping).
 */
 function encodeCursor(lastMessageAt, chatId) {
 	const payload = `${lastMessageAt ? lastMessageAt.toISOString() : ""}|${chatId}`;
@@ -15504,17 +15554,61 @@ function decodeCursor(cursor) {
 		return null;
 	}
 }
+const { ACTIVE, ARCHIVED, DELETED } = CHAT_ENGAGEMENT_STATUSES;
+/**
+* SQL predicate for each engagement view tab. `deleted` is never a valid view
+* value — deleted rows are reachable only through `GET /chats/:chatId` + the
+* Restore banner on the chat detail page.
+*/
+const ENGAGEMENT_VIEW_PREDICATE = {
+	active: sql`COALESCE(cus.engagement_status, ${ACTIVE}) = ${ACTIVE}`,
+	archived: sql`COALESCE(cus.engagement_status, ${ACTIVE}) = ${ARCHIVED}`,
+	all: sql`COALESCE(cus.engagement_status, ${ACTIVE}) IN (${ACTIVE}, ${ARCHIVED})`
+};
+/**
+* Write the caller's engagement state for this chat. UPSERT into
+* `chat_user_state` — the row may not yet exist (the user might not have
+* marked-read or been @-mentioned), so an INSERT with the engagement value
+* is the first write; subsequent transitions are UPDATEs.
+*
+* Idempotent. Mirrors the UPSERT shape used by `markMeChatRead`.
+*/
+async function setChatEngagement(db, chatId, agentId, status) {
+	await db.insert(chatUserState).values({
+		chatId,
+		agentId,
+		unreadMentionCount: 0,
+		engagementStatus: status
+	}).onConflictDoUpdate({
+		target: [chatUserState.chatId, chatUserState.agentId],
+		set: { engagementStatus: status }
+	});
+}
+/**
+* Read the caller's engagement state. Returns `'active'` when no
+* `chat_user_state` row exists yet (lazy-materialised; matches the SQL
+* `COALESCE(..., 'active')` used elsewhere).
+*/
+async function getCallerEngagement(db, chatId, agentId) {
+	const [row] = await db.select({ engagementStatus: chatUserState.engagementStatus }).from(chatUserState).where(and(eq(chatUserState.chatId, chatId), eq(chatUserState.agentId, agentId))).limit(1);
+	return row?.engagementStatus ?? ACTIVE;
+}
 /**
 * GET /me/chats — cursor-paginated conversation list.
 *
 * SQL strategy:
-*   - One query that UNIONs participant rows and subscription rows for the
-*     caller's human agent, joined to chats. The UNION+coalesce keeps both
-*     `unread_mention_count` and `membership_kind` per row.
-*   - Filter `parent_chat_id IS NULL` (threads are excluded in v1).
+*   - Single-stream query: `chats JOIN chat_membership LEFT JOIN
+*     chat_user_state`. The membership row carries access_mode
+*     (speaker → "participant" / watcher → "watching"); the user
+*     state row supplies the unread counter (COALESCE → 0 when
+*     row is missing).
+*   - Filter `parent_chat_id IS NULL` (threads excluded in v1).
+*   - Filter `c.organization_id = ?` to defend against historical
+*     cross-org pollution rows that may still reference the caller
+*     (see fix/cross-org-direct-chat-pollution).
 *   - Sort `(last_message_at DESC NULLS LAST, chat_id DESC)`.
-*   - Cursor narrows the result to rows STRICTLY before `(cursor.ts, cursor.id)`.
-*   - Followed by a small participant-list lookup for the page only.
+*   - Cursor narrows the result to rows STRICTLY before the cursor.
+*   - Followed by a participants-list lookup for the page only.
 */
 async function listMeChats(db, humanAgentId, organizationId, query) {
 	const limit = query.limit;
@@ -15522,28 +15616,12 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
 	if (query.cursor && !cursor) throw new BadRequestError("Invalid cursor");
 	const filterUnreadOnly = query.filter === "unread";
 	const filterWatchingOnly = query.filter === "watching";
+	const engagementPredicate = ENGAGEMENT_VIEW_PREDICATE[query.engagement];
 	const cursorTsIso = cursor?.lastMessageAt ? cursor.lastMessageAt.toISOString() : null;
 	const cursorPredicate = !cursor ? sql`TRUE` : cursor.lastMessageAt === null ? sql`(c.last_message_at IS NULL AND c.id < ${cursor.chatId})` : sql`(c.last_message_at IS NULL
              OR c.last_message_at < ${cursorTsIso}::timestamptz
              OR (c.last_message_at = ${cursorTsIso}::timestamptz AND c.id < ${cursor.chatId}))`;
 	const rawRows = await db.execute(sql`
-    WITH membership AS (
-      SELECT chat_id, 'participant'::text AS membership_kind, unread_mention_count
-        FROM chat_participants
-       WHERE agent_id = ${humanAgentId}
-      UNION ALL
-      SELECT chat_id, 'watching'::text   AS membership_kind, unread_mention_count
-        FROM chat_subscriptions
-       WHERE agent_id = ${humanAgentId}
-    ),
-    /* Resolve duplicates (should not happen post-invariant-1, but cheap) by
-       preferring the participant row. */
-    deduped AS (
-      SELECT DISTINCT ON (chat_id)
-        chat_id, membership_kind, unread_mention_count
-        FROM membership
-        ORDER BY chat_id, CASE WHEN membership_kind = 'participant' THEN 0 ELSE 1 END
-    )
     SELECT
       c.id                  AS chat_id,
       c.type                AS type,
@@ -15551,20 +15629,26 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
       c.parent_chat_id      AS parent_chat_id,
       c.last_message_at     AS last_message_at,
       c.last_message_preview AS last_message_preview,
-      (SELECT count(*) FROM chat_participants WHERE chat_id = c.id) AS participant_count,
-      d.membership_kind     AS membership_kind,
-      d.unread_mention_count AS unread_mention_count
+      (SELECT count(*) FROM chat_membership
+        WHERE chat_id = c.id AND access_mode = 'speaker') AS participant_count,
+      cm.access_mode AS access_mode,
+      COALESCE(cus.unread_mention_count, 0) AS unread_mention_count,
+      COALESCE(cus.engagement_status, ${ACTIVE}) AS engagement_status
       FROM chats c
-      JOIN deduped d ON d.chat_id = c.id
+      JOIN chat_membership cm
+        ON cm.chat_id = c.id AND cm.agent_id = ${humanAgentId}
+      LEFT JOIN chat_user_state cus
+        ON cus.chat_id = c.id AND cus.agent_id = ${humanAgentId}
      WHERE c.parent_chat_id IS NULL
-       /* Scope to the caller's org. Without this, cross-org dirty chats
-          whose chat_participants still reference the caller's human agent
-          (historical pollution — see fix/cross-org-direct-chat-pollution)
-          would leak into the list and 404 on click via requireChatAccess. */
+       /* Scope to the caller's org. Without this, cross-org dirty
+          chats whose chat_membership still references the caller's
+          human agent (historical pollution — see
+          fix/cross-org-direct-chat-pollution) would leak into the
+          list and 404 on click via requireChatAccess. */
        AND c.organization_id = ${organizationId}
-       /* Filter: unread / watching */
-       AND (${!filterUnreadOnly}::bool OR d.unread_mention_count > 0)
-       AND (${!filterWatchingOnly}::bool OR d.membership_kind = 'watching')
+       AND (${!filterUnreadOnly}::bool OR COALESCE(cus.unread_mention_count, 0) > 0)
+       AND (${!filterWatchingOnly}::bool OR cm.access_mode = 'watcher')
+       AND ${engagementPredicate}
        AND ${cursorPredicate}
      ORDER BY c.last_message_at DESC NULLS LAST, c.id DESC
      LIMIT ${limit + 1}
@@ -15583,11 +15667,11 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
 	};
 	const chatIds = pageRaw.map((r) => r.chat_id);
 	const participantRows = await db.select({
-		chatId: chatParticipants.chatId,
-		agentId: chatParticipants.agentId,
+		chatId: chatMembership.chatId,
+		agentId: chatMembership.agentId,
 		displayName: agents.displayName,
 		type: agents.type
-	}).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.uuid)).where(inArray(chatParticipants.chatId, chatIds));
+	}).from(chatMembership).innerJoin(agents, eq(chatMembership.agentId, agents.uuid)).where(and(inArray(chatMembership.chatId, chatIds), eq(chatMembership.accessMode, "speaker")));
 	const participantsByChat = /* @__PURE__ */ new Map();
 	for (const p of participantRows) {
 		const list = participantsByChat.get(p.chatId) ?? [];
@@ -15611,10 +15695,11 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
 		rows: pageRaw.map((r) => {
 			const participants = participantsByChat.get(r.chat_id) ?? [];
 			const title = resolveChatTitle(r.topic, firstMessageSummary.get(r.chat_id) ?? null, participants, humanAgentId);
+			const isSpeaker = r.access_mode === "speaker";
 			return {
 				chatId: r.chat_id,
 				type: r.type,
-				membershipKind: r.membership_kind,
+				membershipKind: isSpeaker ? "participant" : "watching",
 				title,
 				topic: r.topic,
 				participants,
@@ -15622,7 +15707,8 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
 				lastMessageAt: toDate(r.last_message_at)?.toISOString() ?? null,
 				lastMessagePreview: r.last_message_preview,
 				unreadMentionCount: r.unread_mention_count,
-				canReply: r.membership_kind === "participant"
+				canReply: isSpeaker,
+				engagementStatus: r.engagement_status
 			};
 		}),
 		nextCursor
@@ -15634,11 +15720,6 @@ async function listMeChats(db, humanAgentId, organizationId, query) {
 *   1. `chat.topic` (manual, set via `PATCH /chats/:chatId`)
 *   2. First message summary (auto, ≤ 50 chars from `extractSummary`)
 *   3. Participant join (fallback when chat has no messages yet)
-*
-* The first-message fallback is the chat-first equivalent of how
-* ChatGPT / Claude.ai name conversations from the user's opening
-* prompt — gives same-agent multi-chats distinct identities and
-* removes the "title duplicates participants chip row" anti-pattern.
 */
 function resolveChatTitle(topic, firstMessageSummary, participants, selfAgentId) {
 	if (topic && topic.length > 0) return topic;
@@ -15692,7 +15773,7 @@ async function addMeChatParticipants(db, chatId, callerHumanAgentId, callerOrgan
 	}).from(chats).where(eq(chats.id, chatId)).limit(1);
 	if (!chat) throw new NotFoundError(`Chat "${chatId}" not found`);
 	if (chat.organizationId !== callerOrganizationId) throw new NotFoundError(`Chat "${chatId}" not found`);
-	const [callerRow] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, callerHumanAgentId))).limit(1);
+	const [callerRow] = await db.select({ chatId: chatMembership.chatId }).from(chatMembership).where(and(eq(chatMembership.chatId, chatId), eq(chatMembership.agentId, callerHumanAgentId), eq(chatMembership.accessMode, "speaker"))).limit(1);
 	if (!callerRow) throw new NotFoundError(`Chat "${chatId}" not found`);
 	const found = await db.select({
 		uuid: agents.uuid,
@@ -15706,45 +15787,36 @@ async function addMeChatParticipants(db, chatId, callerHumanAgentId, callerOrgan
 	const crossOrg = found.filter((a) => a.organizationId !== chat.organizationId);
 	if (crossOrg.length > 0) throw new BadRequestError(`Cross-organization participant rejected: ${crossOrg.map((a) => a.uuid).join(", ")}`);
 	await db.transaction(async (tx) => {
-		const existing = await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
-		const existingSet = new Set(existing.map((e) => e.agentId));
-		const toInsert = distinct.filter((id) => !existingSet.has(id));
-		if (toInsert.length === 0) {
+		const existingSpeakers = await tx.select({ agentId: chatMembership.agentId }).from(chatMembership).where(and(eq(chatMembership.chatId, chatId), eq(chatMembership.accessMode, "speaker")));
+		const existingSpeakerSet = new Set(existingSpeakers.map((e) => e.agentId));
+		const toUpsert = distinct.filter((id) => !existingSpeakerSet.has(id));
+		if (toUpsert.length === 0) {
 			await recomputeChatWatchers(tx, chatId);
 			return;
 		}
-		if (existing.length + toInsert.length >= 3 && chat.type === "direct") await changeChatType(tx, chatId, "group");
-		const carriedRows = await tx.delete(chatSubscriptions).where(and(eq(chatSubscriptions.chatId, chatId), inArray(chatSubscriptions.agentId, toInsert))).returning({
-			agentId: chatSubscriptions.agentId,
-			lastReadAt: chatSubscriptions.lastReadAt,
-			unreadMentionCount: chatSubscriptions.unreadMentionCount
-		});
-		const carriedByAgent = new Map(carriedRows.map((r) => [r.agentId, r]));
-		await addChatParticipants(tx, chatId, toInsert.map((agentId) => {
-			const carried = carriedByAgent.get(agentId);
-			return {
-				agentId,
-				role: "member",
-				carriedReadState: carried ? {
-					lastReadAt: carried.lastReadAt,
-					unreadMentionCount: carried.unreadMentionCount
-				} : void 0
-			};
-		}), { onConflictDoNothing: true });
+		if (existingSpeakers.length + toUpsert.length >= 3 && chat.type === "direct") await changeChatType(tx, chatId, "group");
+		await addChatParticipants(tx, chatId, toUpsert.map((agentId) => ({
+			agentId,
+			role: "member"
+		})), { upgradeWatcherToSpeaker: true });
 		await recomputeChatWatchers(tx, chatId);
 	});
 	invalidateChatAudience(chatId);
 }
 async function markMeChatRead(db, chatId, humanAgentId) {
 	const now = /* @__PURE__ */ new Date();
-	await db.update(chatParticipants).set({
-		lastReadAt: now,
-		unreadMentionCount: 0
-	}).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, humanAgentId)));
-	await db.update(chatSubscriptions).set({
+	await db.insert(chatUserState).values({
+		chatId,
+		agentId: humanAgentId,
 		lastReadAt: now,
 		unreadMentionCount: 0
-	}).where(and(eq(chatSubscriptions.chatId, chatId), eq(chatSubscriptions.agentId, humanAgentId)));
+	}).onConflictDoUpdate({
+		target: [chatUserState.chatId, chatUserState.agentId],
+		set: {
+			lastReadAt: now,
+			unreadMentionCount: 0
+		}
+	});
 	return {
 		chatId,
 		lastReadAt: now.toISOString(),
@@ -15770,7 +15842,7 @@ async function leaveMeChat(db, chatId, humanAgentId) {
 async function chatRoutes(app) {
 	app.get("/:chatId", async (request) => {
 		const { chat, scope } = await requireChatAccess(request, app.db);
-		const participants = await app.db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chat.id));
+		const participants = await app.db.select().from(chatMembership).where(and(eq(chatMembership.chatId, chat.id), eq(chatMembership.accessMode, "speaker")));
 		const firstMsgRows = await app.db.execute(sql`
       SELECT content FROM messages
        WHERE chat_id = ${chat.id}
@@ -15794,10 +15866,12 @@ async function chatRoutes(app) {
 			};
 		});
 		const title = resolveChatTitle(chat.topic, firstMessagePreview, participantsForTitle, scope.humanAgentId);
+		const engagementStatus = await getCallerEngagement(app.db, chat.id, scope.humanAgentId);
 		return {
 			...chat,
 			title,
 			firstMessagePreview,
+			engagementStatus,
 			createdAt: chat.createdAt.toISOString(),
 			updatedAt: chat.updatedAt.toISOString(),
 			participants: participants.map((p) => ({
@@ -15808,6 +15882,15 @@ async function chatRoutes(app) {
 			}))
 		};
 	});
+	app.post("/:chatId/engagement", { config: { otelRecordBody: true } }, async (request, reply) => {
+		const { scope } = await requireChatAccess(request, app.db);
+		const body = patchChatEngagementSchema.parse(request.body);
+		await setChatEngagement(app.db, request.params.chatId, scope.humanAgentId, body.status);
+		return reply.status(200).send({
+			chatId: request.params.chatId,
+			engagementStatus: body.status
+		});
+	});
 	app.patch("/:chatId", { config: { otelRecordBody: true } }, async (request) => {
 		await requireChatAccess(request, app.db);
 		const body = updateChatSchema.parse(request.body);
@@ -15900,7 +15983,7 @@ async function chatRoutes(app) {
 	app.post("/:chatId/messages", async (request, reply) => {
 		const { scope } = await requireChatAccess(request, app.db);
 		const body = sendMessageSchema.parse(request.body);
-		await ensureParticipant$1(app.db, request.params.chatId, scope.humanAgentId);
+		await ensureParticipant(app.db, request.params.chatId, scope.humanAgentId);
 		const prepared = await prepareImageOutbound(app.db, app.notifier, request.params.chatId, {
 			...body,
 			source: "hub_ui"
@@ -15927,7 +16010,7 @@ async function chatRoutes(app) {
 	app.post("/:chatId/questions/:correlationId/answer", { config: { otelRecordBody: false } }, async (request, reply) => {
 		const { scope } = await requireChatAccess(request, app.db);
 		const body = submitQuestionAnswerSchema.parse(request.body);
-		await ensureParticipant$1(app.db, request.params.chatId, scope.humanAgentId);
+		await ensureParticipant(app.db, request.params.chatId, scope.humanAgentId);
 		const result = await submitAnswer(app.db, app.notifier, {
 			correlationId: request.params.correlationId,
 			chatId: request.params.chatId,
@@ -17324,7 +17407,7 @@ async function healthzRoutes(app) {
 * `api/orgs/invitations.ts` (Class B, admin-gated).
 */
 async function publicInvitationRoutes(app) {
-	const { previewInvitation } = await import("./invitation-C299fxkP-jQiGR5fl.mjs");
+	const { previewInvitation } = await import("./invitation-C299fxkP-KKslbta2.mjs");
 	app.get("/:token/preview", async (request, reply) => {
 		if (!request.params.token) throw new UnauthorizedError("Token required");
 		const preview = await previewInvitation(app.db, request.params.token);
@@ -17590,7 +17673,7 @@ async function meRoutes(app) {
 	*/
 	app.get("/me/pinned-agents", async (request) => {
 		const { userId } = requireUser(request);
-		const { listMyPinnedAgents } = await import("./client-93HZWg84-MIPzQD9A.mjs");
+		const { listMyPinnedAgents } = await import("./client-CjGIGddS-BrpazWa3.mjs");
 		return listMyPinnedAgents(app.db, { userId });
 	});
 	/**
@@ -18000,7 +18083,7 @@ async function orgChatRoutes(app) {
 				createdAt: chats.createdAt,
 				updatedAt: chats.updatedAt,
 				participantCount: sql`(
-            SELECT count(*)::int FROM chat_participants WHERE chat_id = ${chats.id}
+            SELECT count(*)::int FROM chat_membership WHERE chat_id = ${chats.id} AND access_mode = 'speaker'
           )`
 			}).from(chats).where(and(...conditions)).orderBy(desc(chats.createdAt)).limit(query.limit + 1);
 			const hasMore = rows.length > query.limit;
@@ -19526,8 +19609,8 @@ var schema_exports = /* @__PURE__ */ __exportAll({
 	agentPresence: () => agentPresence,
 	agents: () => agents,
 	authIdentities: () => authIdentities,
-	chatParticipants: () => chatParticipants,
-	chatSubscriptions: () => chatSubscriptions,
+	chatMembership: () => chatMembership,
+	chatUserState: () => chatUserState,
 	chats: () => chats,
 	clients: () => clients,
 	githubAppInstallations: () => githubAppInstallations,

package/dist/web/assets/{index-JGwkYWtM.js → index-BPMrSv_A.js}

@@ -1,4 +1,4 @@
-import{c as r,j as e,U as o,L as s,A as i,F as a,r as l}from"./index-BNM-YSSu.js";/**
+import{c as r,j as e,U as o,L as s,A as i,F as a,r as l}from"./index-ntmzuk5X.js";/**
  * @license lucide-react v0.577.0 - ISC
  *
  * This source code is licensed under the ISC license.