@agent-team-foundation/first-tree-hub 0.12.6 → 0.12.8

package/dist/{saas-connect-RCN8zL5e.mjs → saas-connect-CLcon-De.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-xP6NpdMp.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-B89AKi3Q-DAyGdQSq.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-bR8nwHaV-OxnjyKOk.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";
@@ -570,10 +570,15 @@ const runtimeStateSchema = z.enum([
 z.enum([
 	"active",
 	"suspended",
-	"evicted"
+	"evicted",
+	"errored"
 ]);
 /** Wire-level states a client may report. `evicted` from a stale client is rejected. */
-const clientSessionStateSchema = z.enum(["active", "suspended"]);
+const clientSessionStateSchema = z.enum([
+	"active",
+	"suspended",
+	"errored"
+]);
 z.object({
 	chatId: z.string().min(1),
 	state: clientSessionStateSchema
@@ -759,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(),
@@ -788,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) });
@@ -1237,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(),
@@ -1258,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),
@@ -3353,8 +3372,26 @@ function normalizePath(rawPath) {
 function shortHash(input) {
 	return createHash("sha256").update(input).digest("hex").slice(0, 8);
 }
-function deriveSessionBranchName(sessionKey, url) {
-	return `${SESSION_BRANCH_PREFIX}-${shortHash(sessionKey)}-${shortHash(url)}`;
+/**
+* Branch name a session's worktree attaches to. The hash inputs include the
+* agent dimension because `(chat, url)` alone is not unique: two agents that
+* share a chat each open their own worktree at
+* `<workspaces>/<agent>/<chatId>/...`, and git refuses to point two worktrees
+* at the same branch (`fatal: '<branch>' is already used by worktree at …`).
+* Hash inputs are joined with `:` so `(chatA, agentB)` cannot collide with
+* `(chatAB, "")`.
+*
+* The caller picks `agentName`. Prefer the operator-stable name
+* (`config.yaml::agents.<name>`); fall back to `agent.agentId` (a UUID,
+* globally unique) when the stable name isn't available. Anything stable
+* across `start` and `resume` for the same `(agent, chat)` pair will do —
+* the contract is "no collision with a peer agent in the same chat", not
+* "human-readable in the branch name".
+*
+* See docs/workspace-session-branch-collision-fix-design.md §3.2.
+*/
+function deriveSessionBranchName(sessionKey, agentName, url) {
+	return `${SESSION_BRANCH_PREFIX}-${shortHash(`${sessionKey}:${agentName}`)}-${shortHash(url)}`;
 }
 /**
 * A value is SHA-like when it's a 7–40 character hex string. Used to decide
@@ -3766,12 +3803,12 @@ function createGitMirrorManager(opts) {
 				}
 			});
 		},
-		createWorktree({ url, ref, targetPath, sessionKey }) {
+		createWorktree({ url, ref, targetPath, sessionKey, agentName }) {
 			return withUrlLock(url, async () => {
 				const mirror = mirrorDir(url);
 				if (!existsSync(join(mirror, "HEAD"))) throw new GitMirrorError(`Cannot create worktree — no mirror exists for "${url}"`);
 				const absTarget = resolve(targetPath);
-				const branchName = deriveSessionBranchName(sessionKey, url);
+				const branchName = deriveSessionBranchName(sessionKey, agentName, url);
 				if (existsSync(absTarget) && !isHubManagedWorktree(absTarget)) {
 					log?.warn({
 						gitUrl: url,
@@ -4112,15 +4149,53 @@ var InputController = class {
 };
 const DEFAULT_WORKSPACE_TTL_MS = 10080 * 60 * 1e3;
 /**
+* Sentinel that flags "stage-2 of session bootstrap (git worktree
+* materialisation) completed successfully". Distinct from the
+* `FIRST_TREE_WORKSPACE_MARKER` (`.first-tree-workspace`) which is the
+* "agent workspace boundary" — Codex's `project_root_markers` uses that one
+* to stop walking up the filesystem when looking for `AGENTS.md`. Splitting
+* the two so the boundary marker can be written eagerly (stage 1) while the
+* completion sentinel only appears after stage 2 lets `acquireWorkspace`
+* detect half-baked directories from a previous failed start and self-heal.
+*
+* See docs/workspace-session-branch-collision-fix-design.md §3.4.
+*/
+const INIT_COMPLETE_SENTINEL_REL = join(".agent", "init-complete");
+/**
 * Acquire a per-chat workspace directory.
-* Creates the directory if it does not exist; returns the path if it does.
+*
+* Healing rule: if the directory exists AND carries the boundary marker
+* (`.first-tree-workspace`, written in stage 1) AND is missing the
+* completion sentinel (`.agent/init-complete`, written after stage 2), the
+* previous session start crashed between the two writes — wipe it so the
+* fresh start gets a clean slate. The boundary marker alone (without the
+* sentinel) is the unambiguous shape of a half-baked workspace: only stage 1
+* writes it, and only stage 2 writes the sentinel.
 */
 function acquireWorkspace(workspaceRoot, chatId) {
 	const dir = join(workspaceRoot, chatId);
+	if (existsSync(dir) && existsSync(join(dir, ".first-tree-workspace")) && !existsSync(join(dir, INIT_COMPLETE_SENTINEL_REL))) rmSync(dir, {
+		recursive: true,
+		force: true
+	});
 	mkdirSync(dir, { recursive: true });
 	return dir;
 }
 /**
+* Write the stage-2 completion sentinel. Callers must invoke this AFTER all
+* pre-handler-spawn setup (workspace bootstrap, git worktrees, first-tree
+* integration) succeeded, so a process that crashes earlier leaves a
+* half-baked workspace the next acquireWorkspace can heal.
+*/
+function markWorkspaceInitComplete(workspaceCwd) {
+	const path = join(workspaceCwd, INIT_COMPLETE_SENTINEL_REL);
+	mkdirSync(join(workspaceCwd, ".agent"), { recursive: true });
+	writeFileSync(path, JSON.stringify({
+		completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		schemaVersion: 1
+	}), "utf-8");
+}
+/**
 * Clean stale workspace directories for an agent.
 *
 * A workspace is considered stale when:
@@ -4864,12 +4939,13 @@ const createClaudeCodeHandler = (config) => {
 			const mirror = await gitMirrorManager.ensureMirror(repo.url);
 			if (mirror.cloned) sessionCtx.log(`Git: cloned ${repo.url} in ${mirror.elapsedMs}ms`);
 			await gitMirrorManager.fetchMirror(repo.url);
+			const branchAgentKey = agentName ?? sessionCtx.agent.agentId;
 			if (existsSync(targetPath) && isHubWorktreeMarker(targetPath)) {
 				sessionCtx.log(`Git: reusing existing worktree at ${localPath}`);
 				ownedWorktrees.push({
 					url: repo.url,
 					path: targetPath,
-					branchName: deriveSessionBranchName(sessionCtx.chatId, repo.url)
+					branchName: deriveSessionBranchName(sessionCtx.chatId, branchAgentKey, repo.url)
 				});
 				continue;
 			}
@@ -4877,7 +4953,8 @@ const createClaudeCodeHandler = (config) => {
 				url: repo.url,
 				ref: repo.ref,
 				targetPath,
-				sessionKey: sessionCtx.chatId
+				sessionKey: sessionCtx.chatId,
+				agentName: branchAgentKey
 			});
 			ownedWorktrees.push({
 				url: repo.url,
@@ -4926,6 +5003,7 @@ const createClaudeCodeHandler = (config) => {
 			runBootstrap(cwd, sessionCtx);
 			const payload = agentConfigCache?.get(sessionCtx.agent.agentId)?.payload;
 			await prepareGitWorktrees(cwd, payload, sessionCtx);
+			markWorkspaceInitComplete(cwd);
 			sessionCtx.log(`Starting session (${claudeSessionId}), cwd=${cwd}, permissionMode=${config.permissionMode ?? "bypassPermissions"}`);
 			spawnQuery(claudeSessionId, sessionCtx);
 			const sdkMsg = await toSDKUserMessage(message, sessionCtx, claudeSessionId);
@@ -4938,9 +5016,10 @@ const createClaudeCodeHandler = (config) => {
 			claudeSessionId = sessionId;
 			retryCount = 0;
 			cwd = acquireWorkspace(workspaceRoot, sessionCtx.chatId);
-			if (!existsSync(join(cwd, ".agent", "identity.json"))) runBootstrap(cwd, sessionCtx);
+			if (!existsSync(join(cwd, INIT_COMPLETE_SENTINEL_REL))) runBootstrap(cwd, sessionCtx);
 			const payload = agentConfigCache?.get(sessionCtx.agent.agentId)?.payload;
 			await prepareGitWorktrees(cwd, payload, sessionCtx);
+			markWorkspaceInitComplete(cwd);
 			sessionCtx.log(`Resuming session (${sessionId}), cwd=${cwd}`);
 			spawnQuery(sessionId, sessionCtx, sessionId);
 			if (message) inputController?.push(await toSDKUserMessage(message, sessionCtx, sessionId));
@@ -5157,8 +5236,9 @@ const createCodexHandler = (config) => {
 	function toCodexInput(message, sessionCtx) {
 		return sessionCtx.formatInboundContent(message).then((text) => text);
 	}
-	async function prepareGitWorktrees(payload, workspaceCwd, chatId) {
+	async function prepareGitWorktrees(payload, workspaceCwd, sessionCtx) {
 		if (!gitMirrorManager) return;
+		const branchAgentKey = agentName ?? sessionCtx.agent.agentId;
 		for (const repo of payload.gitRepos) {
 			const localPath = repo.localPath ?? deriveRepoLocalPath(repo.url);
 			if (!localPath) continue;
@@ -5171,7 +5251,8 @@ const createCodexHandler = (config) => {
 					url: repo.url,
 					ref: repo.ref,
 					targetPath,
-					sessionKey: chatId
+					sessionKey: sessionCtx.chatId,
+					agentName: branchAgentKey
 				});
 				ownedWorktrees.push({
 					url: repo.url,
@@ -5413,7 +5494,8 @@ const createCodexHandler = (config) => {
 				}
 			});
 			ensureFirstTreeBinding(cwd, sessionCtx);
-			await prepareGitWorktrees(payload, cwd, sessionCtx.chatId);
+			await prepareGitWorktrees(payload, cwd, sessionCtx);
+			markWorkspaceInitComplete(cwd);
 			codex = new Codex({
 				env: buildEnv(sessionCtx),
 				config: buildCodexConfig(payload)
@@ -5437,7 +5519,7 @@ const createCodexHandler = (config) => {
 				env: [],
 				gitRepos: []
 			};
-			if (!existsSync(join(cwd, ".agent", "identity.json"))) {
+			if (!existsSync(join(cwd, INIT_COMPLETE_SENTINEL_REL))) {
 				bootstrapWorkspace({
 					workspacePath: cwd,
 					identity: sessionCtx.agent,
@@ -5451,7 +5533,8 @@ const createCodexHandler = (config) => {
 				});
 				ensureFirstTreeBinding(cwd, sessionCtx);
 			}
-			await prepareGitWorktrees(payload, cwd, sessionCtx.chatId);
+			await prepareGitWorktrees(payload, cwd, sessionCtx);
+			markWorkspaceInitComplete(cwd);
 			codex = new Codex({
 				env: buildEnv(sessionCtx),
 				config: buildCodexConfig(payload)
@@ -6111,11 +6194,24 @@ var SessionManager = class {
 			this.persistRegistry();
 			this.notifySessionState(chatId, "active");
 		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			const phase = evicted ? "resume" : "start";
 			this.config.log.error({
 				chatId,
 				err,
-				phase: evicted ? "resume" : "start"
+				phase
 			}, "session start/resume failed");
+			this.notifySessionState(chatId, "errored");
+			try {
+				const preview = errMsg.slice(0, 800);
+				const userMsg = `⚠️ Session ${phase} failed (${this.config.agentIdentity.displayName ?? this.config.agentIdentity.agentId}): ${preview}`;
+				await ctx.forwardResult(userMsg);
+			} catch (forwardErr) {
+				this.config.log.warn({
+					chatId,
+					forwardErr
+				}, "session error forward failed");
+			}
 			this.sessions.delete(chatId);
 			this.sessionRuntimeStates.delete(chatId);
 			this.recomputeRuntimeState();
@@ -6147,11 +6243,25 @@ var SessionManager = class {
 			this.persistRegistry();
 			this.notifySessionState(entry.chatId, "active");
 		} catch (err) {
-			this.config.log.warn({
+			const errMsg = err instanceof Error ? err.message : String(err);
+			this.config.log.error({
 				chatId: entry.chatId,
 				err
 			}, "resume failed");
-			entry.status = "suspended";
+			this.notifySessionState(entry.chatId, "errored");
+			try {
+				const preview = errMsg.slice(0, 800);
+				const userMsg = `⚠️ Session resume failed (${this.config.agentIdentity.displayName ?? this.config.agentIdentity.agentId}): ${preview}`;
+				await ctx.forwardResult(userMsg);
+			} catch (forwardErr) {
+				this.config.log.warn({
+					chatId: entry.chatId,
+					forwardErr
+				}, "session error forward failed");
+			}
+			this.sessions.delete(entry.chatId);
+			this.sessionRuntimeStates.delete(entry.chatId);
+			this.recomputeRuntimeState();
 			this._activeCount--;
 		}
 	}
@@ -9326,7 +9436,7 @@ async function onboardCreate(args) {
 	}
 	const runtimeAgent = args.type === "human" ? args.assistant : args.id;
 	if (args.feishuBotAppId && args.feishuBotAppSecret) {
-		const { bindFeishuBot } = await import("./feishu-CsfadBKa.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 {
@@ -10539,7 +10649,7 @@ function createFeedbackHandler(config) {
 	return { handle };
 }
 //#endregion
-//#region ../server/dist/app-DFZ1LKZa.mjs
+//#region ../server/dist/app-mkBHfGPl.mjs
 var import_fastify_opentelemetry = /* @__PURE__ */ __toESM(require_fastify_opentelemetry(), 1);
 init_esm();
 var __defProp = Object.defineProperty;
@@ -10646,7 +10756,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);
@@ -10655,7 +10765,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);
@@ -11747,19 +11857,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({
@@ -11842,9 +11939,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))];
@@ -12245,7 +12342,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);
@@ -15171,6 +15268,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`.
@@ -15366,7 +15504,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));
 }
@@ -15375,16 +15513,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}`;
@@ -15408,17 +15547,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;
@@ -15426,28 +15609,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,
@@ -15455,20 +15622,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}
@@ -15487,11 +15660,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) ?? [];
@@ -15515,10 +15688,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,
@@ -15526,7 +15700,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
@@ -15538,11 +15713,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;
@@ -15596,7 +15766,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,
@@ -15610,45 +15780,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(),
@@ -15674,7 +15835,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}
@@ -15698,10 +15859,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) => ({
@@ -15712,6 +15875,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);
@@ -15804,7 +15976,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"
@@ -15831,7 +16003,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,
@@ -17228,7 +17400,7 @@ async function healthzRoutes(app) {
 * `api/orgs/invitations.ts` (Class B, admin-gated).
 */
 async function publicInvitationRoutes(app) {
-	const { previewInvitation } = await import("./invitation-C299fxkP-DFBBuUcj.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);
@@ -17494,7 +17666,7 @@ async function meRoutes(app) {
 	*/
 	app.get("/me/pinned-agents", async (request) => {
 		const { userId } = requireUser(request);
-		const { listMyPinnedAgents } = await import("./client-GOgUQxVe-Dqk9oZf9.mjs");
+		const { listMyPinnedAgents } = await import("./client-DNEtPEBu-BtHkUya2.mjs");
 		return listMyPinnedAgents(app.db, { userId });
 	});
 	/**
@@ -17680,7 +17852,8 @@ async function orgActivityRoutes(app) {
 				activeSessions: a.activeSessions,
 				totalSessions: a.totalSessions,
 				runtimeUpdatedAt: a.runtimeUpdatedAt?.toISOString() ?? null,
-				type: "type" in a ? a.type : null
+				type: "type" in a ? a.type : null,
+				managedByMe: "managerId" in a ? a.managerId === scope.memberId : false
 			}))
 		};
 	});
@@ -17903,7 +18076,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;
@@ -19429,8 +19602,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,