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

package/dist/{bootstrap-C_K2CKXC.mjs → bootstrap-BCZC1ki6.mjs}

@@ -576,12 +576,22 @@ const serverConfigSchema = defineConfig({
 		}),
 		githubTokenRepos: field(z.string().optional(), { env: "FIRST_TREE_HUB_CONTEXT_TREE_GITHUB_TOKEN_REPOS" })
 	}),
-	oauth: optional({ github: optional({
-		clientId: field(z.string(), { env: "FIRST_TREE_HUB_GITHUB_OAUTH_CLIENT_ID" }),
-		clientSecret: field(z.string(), {
-			env: "FIRST_TREE_HUB_GITHUB_OAUTH_CLIENT_SECRET",
+	oauth: optional({ githubApp: optional({
+		appId: field(z.string().min(1), { env: "FIRST_TREE_HUB_GITHUB_APP_ID" }),
+		clientId: field(z.string().min(1), { env: "FIRST_TREE_HUB_GITHUB_APP_CLIENT_ID" }),
+		clientSecret: field(z.string().min(1), {
+			env: "FIRST_TREE_HUB_GITHUB_APP_CLIENT_SECRET",
 			secret: true
-		})
+		}),
+		privateKeyPem: field(z.string().min(1), {
+			env: "FIRST_TREE_HUB_GITHUB_APP_PRIVATE_KEY",
+			secret: true
+		}),
+		webhookSecret: field(z.string().min(1), {
+			env: "FIRST_TREE_HUB_GITHUB_APP_WEBHOOK_SECRET",
+			secret: true
+		}),
+		slug: field(z.string().min(1).optional(), { env: "FIRST_TREE_HUB_GITHUB_APP_SLUG" })
 	}) }),
 	cors: optional({ origin: field(z.string(), { env: "FIRST_TREE_HUB_CORS_ORIGIN" }) }),
 	trustProxy: field(z.boolean().default(false), { env: "FIRST_TREE_HUB_TRUST_PROXY" }),

package/dist/cli/index.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import "../observability-BAScT_5S-BcW9HgkG.mjs";
-import { $ as formatStaleReason, A as checkDocker, B as isServiceSupported, C as createApiNameResolver, D as checkBackgroundService, E as checkAgentConfigs, F as checkWebSocket, H as restartClientService, I as printResults, J as stopPostgres, L as reconcileAgentConfigs, M as checkServerConfig, N as checkServerHealth, O as checkClientConfig, P as checkServerReachable, Q as findStaleAliases, R as getClientServiceStatus, S as runHomeMigration, T as runMigrations, U as startClientService, W as stopClientService, X as handleClientOrgMismatch, Y as ClientRuntime, _ as formatCheckReport, a as declineUpdate, at as success, b as onboardCreate, c as detectInstallMode, ct as FirstTreeHubSDK, d as startServer, dt as cleanWorkspaces, et as removeLocalAgent, f as reconcileLocalRuntimeProviders, ft as probeCapabilities, g as promptMissingFields, h as promptAddAgent, i as createExecuteUpdate, it as fail, j as checkNodeVersion, k as checkDatabase, l as fetchLatestVersion, lt as SdkError, m as isInteractive, mt as configureClientLoggerForService, o as promptUpdate, ot as ClientOrgMismatchError, p as uploadClientCapabilities, pt as applyClientLoggerConfig, r as registerSaaSConnectCommand, rt as resolveReplyToFromEnv, s as PACKAGE_NAME, st as ClientUserMismatchError, tt as createOwner, u as installGlobalLatest, ut as SessionRegistry, v as loadOnboardState, w as migrateLocalAgentDirs, x as saveOnboardState, y as onboardCheck, z as installClientService } from "../saas-connect-S71rG182.mjs";
+import { $ as formatStaleReason, A as checkDocker, B as isServiceSupported, C as createApiNameResolver, D as checkBackgroundService, E as checkAgentConfigs, F as checkWebSocket, H as restartClientService, I as printResults, J as stopPostgres, L as reconcileAgentConfigs, M as checkServerConfig, N as checkServerHealth, O as checkClientConfig, P as checkServerReachable, Q as findStaleAliases, R as getClientServiceStatus, S as runHomeMigration, T as runMigrations, U as startClientService, W as stopClientService, X as handleClientOrgMismatch, Y as ClientRuntime, _ as formatCheckReport, a as declineUpdate, at as fail, b as onboardCreate, c as detectInstallMode, ct as ClientUserMismatchError, d as startServer, dt as SessionRegistry, et as removeLocalAgent, f as reconcileLocalRuntimeProviders, ft as cleanWorkspaces, g as promptMissingFields, h as promptAddAgent, ht as configureClientLoggerForService, i as createExecuteUpdate, it as resolveSenderName, j as checkNodeVersion, k as checkDatabase, l as fetchLatestVersion, lt as FirstTreeHubSDK, m as isInteractive, mt as applyClientLoggerConfig, o as promptUpdate, ot as success, p as uploadClientCapabilities, pt as probeCapabilities, r as registerSaaSConnectCommand, rt as resolveReplyToFromEnv, s as PACKAGE_NAME, st as ClientOrgMismatchError, tt as createOwner, u as installGlobalLatest, ut as SdkError, v as loadOnboardState, w as migrateLocalAgentDirs, x as saveOnboardState, y as onboardCheck, z as installClientService } from "../saas-connect-RCN8zL5e.mjs";
 import "../logger-core-BTmvdflj-DjW8FM4T.mjs";
-import { C as resetConfigMeta, E as setConfigValue, S as resetConfig, T as serverConfigSchema, _ as getConfigValue, a as ensureFreshAdminToken, c as resolveServerUrl, d as DEFAULT_CONFIG_DIR, f as DEFAULT_DATA_DIR, h as clientConfigSchema, i as ensureFreshAccessToken, l as saveAgentConfig, m as agentConfigSchema, o as loadCredentials, p as DEFAULT_HOME_DIR, u as saveCredentials, v as initConfig, w as resolveConfigReadonly, x as readConfigFile, y as loadAgents } from "../bootstrap-C_K2CKXC.mjs";
+import { C as resetConfigMeta, E as setConfigValue, S as resetConfig, T as serverConfigSchema, _ as getConfigValue, a as ensureFreshAdminToken, c as resolveServerUrl, d as DEFAULT_CONFIG_DIR, f as DEFAULT_DATA_DIR, h as clientConfigSchema, i as ensureFreshAccessToken, l as saveAgentConfig, m as agentConfigSchema, o as loadCredentials, p as DEFAULT_HOME_DIR, u as saveCredentials, v as initConfig, w as resolveConfigReadonly, x as readConfigFile, y as loadAgents } from "../bootstrap-BCZC1ki6.mjs";
 import { a as print, n as CLI_USER_AGENT, o as setJsonMode, r as COMMAND_VERSION, t as cliFetch } from "../cli-fetch--tiwKm5S.mjs";
-import "../dist-CMhywpXB.mjs";
-import { n as bindFeishuUser, t as bindFeishuBot } from "../feishu-tkZS0vvL.mjs";
+import "../dist-xP6NpdMp.mjs";
+import { n as bindFeishuUser, t as bindFeishuBot } from "../feishu-CsfadBKa.mjs";
 import "../errors-CF5evtJt-B0NTIVPt.mjs";
 import "../src-DNBS5Yjj.mjs";
-import "../client-D1TDiik_-NV_lkhfI.mjs";
+import "../client-B89AKi3Q-DAyGdQSq.mjs";
 import "../invitation-Bg0TRiyx-BsZH4GCS.mjs";
 import { join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
@@ -215,14 +215,16 @@ function resolveLocalAgent(agentName) {
 		schema: agentConfigSchema,
 		agentsDir
 	});
-	if (agents.size === 0) fail("MISSING_AGENT", "No agent configured. Run `first-tree-hub agent add` first.", 2);
+	const resolution = resolveSenderName({
+		override: agentName,
+		envAgentId: process.env.FIRST_TREE_HUB_AGENT_ID,
+		agents
+	});
 	let resolvedName;
-	if (agentName) resolvedName = agentName;
-	else if (agents.size === 1) {
-		const [only] = [...agents.keys()];
-		if (!only) fail("MISSING_AGENT", "No agent configured. Run `first-tree-hub agent add` first.", 2);
-		resolvedName = only;
-	} else fail("AMBIGUOUS_AGENT", `Multiple agents configured — specify --agent <name>. Available: ${[...agents.keys()].join(", ")}`, 2);
+	if (resolution.kind === "ok") resolvedName = resolution.name;
+	else if (resolution.kind === "none") fail("MISSING_AGENT", "No agent configured. Run `first-tree-hub agent add` first.", 2);
+	else if (resolution.kind === "envMismatch") fail("ENV_AGENT_NOT_LOCAL", `FIRST_TREE_HUB_AGENT_ID="${resolution.envAgentId}" is not configured on this machine. Available local agents: ${resolution.available.join(", ")}. Pick one explicitly: \`first-tree-hub agent send --agent <senderName> <recipientName> "..."\`.`, 2);
+	else fail("AMBIGUOUS_AGENT", `Multiple agents are configured on this machine (${resolution.available.join(", ")}) and FIRST_TREE_HUB_AGENT_ID is not set, so the CLI can't tell which one is the sender. Specify it explicitly: \`first-tree-hub agent send --agent <senderName> <recipientName> "..."\` (--agent picks the SENDER; the recipient is the next positional argument).`, 2);
 	const cfg = agents.get(resolvedName);
 	if (!cfg) fail("UNKNOWN_AGENT", `Agent "${resolvedName}" not found in ${agentsDir}`, 2);
 	let serverUrl;
@@ -1670,13 +1672,13 @@ function isSecretField(schema, dotPath) {
 //#region src/commands/onboard.ts
 async function promptMissing(args) {
 	if (!args.server) try {
-		const { resolveServerUrl } = await import("../bootstrap-C_K2CKXC.mjs").then((n) => n.r);
+		const { resolveServerUrl } = await import("../bootstrap-BCZC1ki6.mjs").then((n) => n.r);
 		resolveServerUrl();
 	} catch {
 		args.server = await input({ message: "Hub server URL:" });
 		saveOnboardState(args);
 	}
-	const { loadCredentials } = await import("../bootstrap-C_K2CKXC.mjs").then((n) => n.r);
+	const { loadCredentials } = await import("../bootstrap-BCZC1ki6.mjs").then((n) => n.r);
 	if (!loadCredentials()) throw new Error("No saved credentials. Run `first-tree-hub client connect <server-url>` before onboarding.");
 	if (!args.id) {
 		args.id = await input({ message: "Agent ID:" });

package/dist/{client-D1TDiik_-NV_lkhfI.mjs → client-B89AKi3Q-DAyGdQSq.mjs}

@@ -1,10 +1,10 @@
 import { O as withSpan, f as messageAttrs, s as createLogger } from "./observability-BAScT_5S-BcW9HgkG.mjs";
-import { A as extractMentions, X as questionMessageContentSchema, Y as questionAnswerMessageContentSchema, a as AGENT_VISIBILITY, g as clientCapabilitiesSchema, i as AGENT_STATUSES, tt as scanMentionTokens } from "./dist-CMhywpXB.mjs";
+import { $ as questionMessageContentSchema, M as extractMentions, O as defaultParticipantMode, Q as questionAnswerMessageContentSchema, _ as clientCapabilitiesSchema, a as AGENT_VISIBILITY, h as agentTypeSchema, i as AGENT_STATUSES, it as scanMentionTokens } from "./dist-xP6NpdMp.mjs";
 import { a as ConflictError, i as ClientUserMismatchError, l as organizations, n as BadRequestError, o as ForbiddenError, s as NotFoundError, u as users } from "./errors-CF5evtJt-B0NTIVPt.mjs";
 import { randomUUID } from "node:crypto";
 import { and, desc, eq, inArray, isNotNull, lt, ne, or, sql } from "drizzle-orm";
 import { bigserial, boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique } from "drizzle-orm/pg-core";
-//#region ../server/dist/client-D1TDiik_.mjs
+//#region ../server/dist/client-B89AKi3Q.mjs
 /**
 * Client connections. A client is a single SDK process (AgentRuntime) that may
 * host multiple agents. From the unified-user-token milestone on, a client is
@@ -185,6 +185,140 @@ function invalidateChatAudience(chatId) {
 	cache.delete(chatId);
 }
 /**
+* Single source of truth for writing `chat_participants`.
+*
+* **This is the ONLY place in the codebase that may `INSERT` into the
+* `chat_participants` table.** Do not call `tx.insert(chatParticipants)`
+* or `db.insert(chatParticipants)` from anywhere else. The original bug
+* (docs/chat-participant-mode-fix-design.md §1.1) was caused by ten
+* scattered insert sites each re-deriving the `mode` rule, several of
+* which violated `group + non-human ⇒ mention_only`. Re-introducing a
+* second writer reopens that hole — please don't.
+*
+* Test fixtures under `src/__tests__/` that deliberately seed
+* pathological rows (e.g. cross-org pollution tests) may bypass this
+* rule; they are setting up "what bad data looks like" rather than
+* exercising the production write path.
+*
+* All callers that need to add a participant — `createChat`, `addParticipant`,
+* `ensureParticipant`, `joinChat`, `createMeChat`, `addMeChatParticipants`,
+* `findOrCreateDirectChat`, `findOrCreateChatForChannel`, `joinAsParticipant`,
+* … — go through `addChatParticipants`. The function performs ONE round-trip
+* to read `chats.type` + every involved `agents.type`, runs each row through
+* `defaultParticipantMode`, and inserts the result. `agents.type` is parsed
+* through the shared `agentTypeSchema` so schema drift surfaces loudly
+* instead of silently coercing to a default.
+*
+* `changeChatType` complements it on the type-flip path: when a `direct`
+* chat is being upgraded to `group` by the very next participant insert, the
+* existing non-human rows must be re-graded to `mention_only`. Callers that
+* trigger an upgrade are expected to invoke `changeChatType` BEFORE
+* `addChatParticipants`, inside the same transaction, so the new row picks
+* up the post-upgrade `chats.type` and existing rows get re-graded together.
+*/
+/**
+* Insert participant rows whose `mode` is derived from `(chats.type, agents.type)`.
+*
+* Reads:
+*   - `chats.type` for the target chat (NotFoundError on missing)
+*   - `agents.type` for every requested participant (BadRequestError on missing)
+*
+* Mode derivation:
+*   - for each row, `peerAgentTypes` is the type of every OTHER participant
+*     being inserted in the same call PLUS every EXISTING participant of
+*     the chat. This matters only for `direct` chats; the helper ignores
+*     it for `group` / `thread`.
+*
+* Writes one INSERT (multi-row) per call.
+*
+* No watcher / audience-cache side effects — the caller owns those, since
+* different entrypoints have different surrounding work (state-carry, watcher
+* recompute, audience invalidation). Keeping this module side-effect-free
+* makes it testable from any tx context.
+*/
+async function addChatParticipants(tx, chatId, participants, options = {}) {
+	if (participants.length === 0) return;
+	const [chat] = await tx.select({ type: chats.type }).from(chats).where(eq(chats.id, chatId)).limit(1);
+	if (!chat) throw new NotFoundError(`Chat "${chatId}" not found`);
+	if (chat.type !== "direct" && chat.type !== "group" && chat.type !== "thread") throw new Error(`Unexpected chat type "${chat.type}" for chat "${chatId}"`);
+	const chatType = chat.type;
+	const agentIds = participants.map((p) => p.agentId);
+	const agentRows = await tx.select({
+		uuid: agents.uuid,
+		type: agents.type
+	}).from(agents).where(inArray(agents.uuid, agentIds));
+	const agentTypeById = /* @__PURE__ */ new Map();
+	for (const row of agentRows) agentTypeById.set(row.uuid, row.type);
+	const missing = agentIds.filter((id) => !agentTypeById.has(id));
+	if (missing.length > 0) throw new BadRequestError(`Agents not found: ${missing.join(", ")}`);
+	if (options.assertHuman) {
+		const nonHuman = agentRows.filter((a) => a.type !== "human");
+		if (nonHuman.length > 0) throw new BadRequestError(`assertHuman violated: agents must be of type 'human' but got ${nonHuman.map((a) => `${a.uuid}=${a.type}`).join(", ")}`);
+	}
+	let existingAgentTypes = [];
+	if (chatType === "direct") existingAgentTypes = await loadExistingAgentTypes(tx, chatId, new Set(agentIds));
+	const rows = participants.map((spec) => {
+		const rawAgentType = agentTypeById.get(spec.agentId);
+		if (rawAgentType === void 0) throw new Error("Unexpected: agent type lookup unset after presence check");
+		const agentType = agentTypeSchema.parse(rawAgentType);
+		const peerTypesForRow = chatType === "direct" ? [...existingAgentTypes, ...participants.filter((p) => p.agentId !== spec.agentId).map((p) => agentTypeById.get(p.agentId)).filter((t) => t !== void 0)].map((t) => agentTypeSchema.parse(t)) : [];
+		return {
+			chatId,
+			agentId: spec.agentId,
+			role: spec.role ?? "member",
+			mode: defaultParticipantMode(chatType, agentType, peerTypesForRow),
+			lastReadAt: spec.carriedReadState?.lastReadAt ?? null,
+			unreadMentionCount: spec.carriedReadState?.unreadMentionCount ?? 0
+		};
+	});
+	const insert = tx.insert(chatParticipants).values(rows);
+	if (options.onConflictDoNothing) await insert.onConflictDoNothing({ target: [chatParticipants.chatId, chatParticipants.agentId] });
+	else await insert;
+}
+async function loadExistingAgentTypes(tx, chatId, excludeAgentIds) {
+	return (await tx.select({
+		type: agents.type,
+		agentId: chatParticipants.agentId
+	}).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.uuid)).where(eq(chatParticipants.chatId, chatId))).filter((r) => !excludeAgentIds.has(r.agentId)).map((r) => r.type);
+}
+/**
+* Upgrade `chats.type` from `direct` → `group` AND re-grade every existing
+* non-human participant to `mention_only`. Idempotent: if `chat.type` is
+* already `group` (or any non-`direct` value), no-op.
+*
+* Callers that are about to insert a 3rd participant on a `direct` chat
+* invoke this BEFORE `addChatParticipants` so the new row picks up the
+* post-upgrade `chats.type` and the existing rows are re-graded in the
+* same transaction.
+*
+* Note: this is the replacement for `services/chat.ts`'s
+* `maybeUpgradeDirectToGroup` (the one in `services/watcher.ts` is
+* removed). Keep the rename: `changeChatType` is more precise about the
+* primary mutation; `maybe…ToGroup` overstated the conditional gate.
+*/
+async function changeChatType(tx, chatId, newType) {
+	const [chat] = await tx.select({ type: chats.type }).from(chats).where(eq(chats.id, chatId)).limit(1);
+	if (!chat) throw new NotFoundError(`Chat "${chatId}" not found`);
+	if (chat.type === newType) return;
+	if (newType === "group" && chat.type !== "direct") throw new BadRequestError(`Cannot change chat type from "${chat.type}" to "${newType}"`);
+	await tx.update(chats).set({
+		type: newType,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(chats.id, chatId));
+	const ids = (await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.uuid)).where(and(eq(chatParticipants.chatId, chatId), ne(agents.type, "human")))).map((r) => r.agentId);
+	if (ids.length === 0) return;
+	await tx.update(chatParticipants).set({ mode: "mention_only" }).where(and(eq(chatParticipants.chatId, chatId), inArray(chatParticipants.agentId, ids)));
+}
+/**
+* Heuristic for whether an insert about to happen would push the chat past
+* the direct → group threshold. Pure helper so callers can decide whether
+* to call `changeChatType` before `addChatParticipants` without re-deriving
+* the rule locally.
+*/
+function wouldUpgradeToGroup(currentParticipantCount, newParticipantCount) {
+	return currentParticipantCount + newParticipantCount >= 3;
+}
+/**
 * Chat-first workspace — watcher subscription helpers.
 *
 * Watchers (rows in `chat_subscriptions`) are non-speaking observers. A
@@ -276,24 +410,6 @@ async function recomputeWatchersForMember(db, memberId) {
 	for (const { chatId } of rows) await recomputeChatWatchers(db, chatId);
 }
 /**
-* Mirror of `services/chat.ts` `maybeUpgradeDirectToGroup`. Inlined here so
-* `joinAsParticipant` keeps the upgrade rule + the state carry in one
-* transaction without depending on chat.ts (avoids a circular import).
-*/
-async function maybeUpgradeDirectToGroup$1(tx, chatId, existingParticipantIds) {
-	if (existingParticipantIds.length + 1 < 3) return;
-	const [chat] = await tx.select({ type: chats.type }).from(chats).where(eq(chats.id, chatId)).limit(1);
-	if (!chat || chat.type !== "direct") return;
-	await tx.update(chats).set({
-		type: "group",
-		updatedAt: /* @__PURE__ */ new Date()
-	}).where(eq(chats.id, chatId));
-	if (existingParticipantIds.length === 0) return;
-	const ids = (await tx.select({ uuid: agents.uuid }).from(agents).where(and(inArray(agents.uuid, existingParticipantIds), ne(agents.type, "human")))).map((r) => r.uuid);
-	if (ids.length === 0) return;
-	await tx.update(chatParticipants).set({ mode: "mention_only" }).where(and(eq(chatParticipants.chatId, chatId), inArray(chatParticipants.agentId, ids)));
-}
-/**
 * Watcher → speaking participant. State-carry transaction.
 *
 *   1. DELETE the watcher row (returning read state).
@@ -318,15 +434,15 @@ async function joinAsParticipant(db, chatId, humanAgentId) {
 			inserted: false,
 			carried: carriedRow ?? null
 		};
-		await maybeUpgradeDirectToGroup$1(tx, chatId, (await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).map((p) => p.agentId));
-		await tx.insert(chatParticipants).values({
-			chatId,
+		if (wouldUpgradeToGroup((await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).length, 1)) await changeChatType(tx, chatId, "group");
+		await addChatParticipants(tx, chatId, [{
 			agentId: humanAgentId,
 			role: "member",
-			mode: "full",
-			lastReadAt: carriedRow?.lastReadAt ?? null,
-			unreadMentionCount: carriedRow?.unreadMentionCount ?? 0
-		});
+			carriedReadState: carriedRow ? {
+				lastReadAt: carriedRow.lastReadAt,
+				unreadMentionCount: carriedRow.unreadMentionCount
+			} : void 0
+		}], { assertHuman: true });
 		return {
 			chatId,
 			inserted: true,
@@ -405,28 +521,6 @@ function ensureCanJoin(membership) {
 	if (membership === "participant") throw new ConflictError("Already a participant in this chat");
 	if (membership === null) throw new ForbiddenError("Not a watcher of this chat — open the chat from your workspace before joining");
 }
-/**
-* When a direct chat grows past 2 participants, upgrade it to `group` and
-* flip every existing non-human agent participant to `mention_only` — see
-* proposals/hub-agent-messaging-reply-and-mentions §3.3. The caller is
-* expected to insert the new participant AFTER this runs, so the "existing"
-* set excludes them.
-*
-* Idempotent: if the chat is already a group, no-op.
-*/
-async function maybeUpgradeDirectToGroup(db, chatId, existingParticipantIds, newParticipantCount) {
-	if (existingParticipantIds.length + newParticipantCount < 3) return;
-	const [chat] = await db.select({ type: chats.type }).from(chats).where(eq(chats.id, chatId)).limit(1);
-	if (!chat || chat.type !== "direct") return;
-	await db.update(chats).set({
-		type: "group",
-		updatedAt: /* @__PURE__ */ new Date()
-	}).where(eq(chats.id, chatId));
-	if (existingParticipantIds.length === 0) return;
-	const ids = (await db.select({ uuid: agents.uuid }).from(agents).where(and(inArray(agents.uuid, existingParticipantIds), ne(agents.type, "human")))).map((a) => a.uuid);
-	if (ids.length === 0) return;
-	await db.update(chatParticipants).set({ mode: "mention_only" }).where(and(eq(chatParticipants.chatId, chatId), inArray(chatParticipants.agentId, ids)));
-}
 async function createChat(db, creatorId, data) {
 	const chatId = randomUUID();
 	const allParticipantIds = new Set([creatorId, ...data.participantIds]);
@@ -444,7 +538,6 @@ async function createChat(db, creatorId, data) {
 	const orgId = creator.organizationId;
 	const crossOrg = existingAgents.filter((a) => a.organizationId !== orgId);
 	if (crossOrg.length > 0) throw new BadRequestError(`Cross-organization chat not allowed: ${crossOrg.map((a) => a.id).join(", ")}`);
-	const isDirectAgentOnly = data.type === "direct" && existingAgents.every((a) => a.type !== "human");
 	return db.transaction(async (tx) => {
 		const [chat] = await tx.insert(chats).values({
 			id: chatId,
@@ -453,13 +546,10 @@ async function createChat(db, creatorId, data) {
 			topic: data.topic ?? null,
 			metadata: data.metadata ?? {}
 		}).returning();
-		const participantRows = [...allParticipantIds].map((agentId) => ({
-			chatId,
+		await addChatParticipants(tx, chatId, [...allParticipantIds].map((agentId) => ({
 			agentId,
-			role: agentId === creatorId ? "owner" : "member",
-			...isDirectAgentOnly ? { mode: "mention_only" } : {}
-		}));
-		await tx.insert(chatParticipants).values(participantRows);
+			role: agentId === creatorId ? "owner" : "member"
+		})));
 		await recomputeChatWatchers(tx, chatId);
 		const participants = await tx.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
 		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
@@ -518,18 +608,23 @@ async function assertParticipant(db, chatId, agentId) {
 	const [row] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, agentId))).limit(1);
 	if (!row) throw new ForbiddenError("Not a participant of this chat");
 }
+/**
+* Non-throwing membership check. Used by routing logic that needs to fall
+* back to a different chat when the candidate target isn't a member of the
+* caller's current chat (see `sendToAgent`'s current-chat routing branch).
+*/
+async function isParticipant(db, chatId, agentId) {
+	const [row] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, agentId))).limit(1);
+	return Boolean(row);
+}
 /** Ensure an agent is a participant of a chat. Silently adds them if not already. */
 async function ensureParticipant(db, chatId, agentId) {
 	const [existing] = await db.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, agentId))).limit(1);
 	if (existing) return;
 	await db.transaction(async (tx) => {
-		await maybeUpgradeDirectToGroup(tx, chatId, (await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).map((p) => p.agentId), 1);
+		if (wouldUpgradeToGroup((await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).length, 1)) await changeChatType(tx, chatId, "group");
 		await tx.delete(chatSubscriptions).where(and(eq(chatSubscriptions.chatId, chatId), eq(chatSubscriptions.agentId, agentId)));
-		await tx.insert(chatParticipants).values({
-			chatId,
-			agentId,
-			mode: "full"
-		}).onConflictDoNothing({ target: [chatParticipants.chatId, chatParticipants.agentId] });
+		await addChatParticipants(tx, chatId, [{ agentId }], { onConflictDoNothing: true });
 		await recomputeChatWatchers(tx, chatId);
 	});
 	invalidateChatAudience(chatId);
@@ -546,13 +641,9 @@ async function addParticipant(db, chatId, requesterId, data) {
 	const [existing] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, data.agentId))).limit(1);
 	if (existing) throw new ConflictError(`Agent "${data.agentId}" is already a participant`);
 	await db.transaction(async (tx) => {
-		await maybeUpgradeDirectToGroup(tx, chatId, (await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).map((p) => p.agentId), 1);
+		if (wouldUpgradeToGroup((await tx.select({ agentId: chatParticipants.agentId }).from(chatParticipants).where(eq(chatParticipants.chatId, chatId))).length, 1)) await changeChatType(tx, chatId, "group");
 		await tx.delete(chatSubscriptions).where(and(eq(chatSubscriptions.chatId, chatId), eq(chatSubscriptions.agentId, data.agentId)));
-		await tx.insert(chatParticipants).values({
-			chatId,
-			agentId: data.agentId,
-			mode: data.mode ?? "full"
-		});
+		await addChatParticipants(tx, chatId, [{ agentId: data.agentId }]);
 		await recomputeChatWatchers(tx, chatId);
 	});
 	invalidateChatAudience(chatId);
@@ -660,15 +751,15 @@ async function joinChat(db, chatId, memberId, humanAgentId) {
 			lastReadAt: chatSubscriptions.lastReadAt,
 			unreadMentionCount: chatSubscriptions.unreadMentionCount
 		});
-		await maybeUpgradeDirectToGroup(tx, chatId, participantAgentIds, 1);
-		await tx.insert(chatParticipants).values({
-			chatId,
+		if (wouldUpgradeToGroup(participantAgentIds.length, 1)) await changeChatType(tx, chatId, "group");
+		await addChatParticipants(tx, chatId, [{
 			agentId: humanAgentId,
 			role: "member",
-			mode: "full",
-			lastReadAt: carriedRow?.lastReadAt ?? null,
-			unreadMentionCount: carriedRow?.unreadMentionCount ?? 0
-		});
+			carriedReadState: carriedRow ? {
+				lastReadAt: carriedRow.lastReadAt,
+				unreadMentionCount: carriedRow.unreadMentionCount
+			} : void 0
+		}], { assertHuman: true });
 		await recomputeChatWatchers(tx, chatId);
 	});
 	invalidateChatAudience(chatId);
@@ -710,7 +801,6 @@ async function findOrCreateDirectChat(db, agentAId, agentBId) {
 		const directChats = await db.select().from(chats).where(and(inArray(chats.id, commonChatIds), eq(chats.type, "direct"), eq(chats.organizationId, orgId))).orderBy(chats.createdAt, chats.id).limit(1);
 		if (directChats.length > 0 && directChats[0]) return directChats[0];
 	}
-	const mode = agentA.type !== "human" && agentB.type !== "human" ? "mention_only" : "full";
 	const chatId = randomUUID();
 	return db.transaction(async (tx) => {
 		const [chat] = await tx.insert(chats).values({
@@ -718,16 +808,12 @@ async function findOrCreateDirectChat(db, agentAId, agentBId) {
 			organizationId: orgId,
 			type: "direct"
 		}).returning();
-		await tx.insert(chatParticipants).values([{
-			chatId,
+		await addChatParticipants(tx, chatId, [{
 			agentId: agentAId,
-			role: "member",
-			mode
+			role: "member"
 		}, {
-			chatId,
 			agentId: agentBId,
-			role: "member",
-			mode
+			role: "member"
 		}]);
 		await recomputeChatWatchers(tx, chatId);
 		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
@@ -1684,7 +1770,6 @@ async function sendToAgent(db, senderUuid, targetName, data) {
 	if (!sender) throw new NotFoundError(`Agent "${senderUuid}" not found`);
 	const [target] = await db.select({ uuid: agents.uuid }).from(agents).where(and(eq(agents.organizationId, sender.organizationId), eq(agents.name, targetName), ne(agents.status, "deleted"))).limit(1);
 	if (!target) throw new NotFoundError(`Agent "${targetName}" not found${/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(targetName) ? " — `agent send` expects an agent NAME, not a uuid. Run `first-tree-hub agent list` to see available names." : ""}`);
-	const chat = await findOrCreateDirectChat(db, senderUuid, target.uuid);
 	const incomingMeta = data.metadata ?? {};
 	const existingMentionsRaw = incomingMeta.mentions;
 	const existingMentions = Array.isArray(existingMentionsRaw) ? existingMentionsRaw.filter((m) => typeof m === "string") : [];
@@ -1693,7 +1778,18 @@ async function sendToAgent(db, senderUuid, targetName, data) {
 		...incomingMeta,
 		mentions: mergedMentions
 	};
-	return sendMessage(db, chat.id, senderUuid, {
+	if (data.replyToChat) {
+		const [targetIsMember, senderIsMember] = await Promise.all([isParticipant(db, data.replyToChat, target.uuid), isParticipant(db, data.replyToChat, senderUuid)]);
+		if (targetIsMember && senderIsMember) return sendMessage(db, data.replyToChat, senderUuid, {
+			format: data.format,
+			content: data.content,
+			metadata,
+			replyToInbox: void 0,
+			replyToChat: void 0,
+			source: data.source
+		}, { normalizeMentionsInContent: true });
+	}
+	return sendMessage(db, (await findOrCreateDirectChat(db, senderUuid, target.uuid)).id, senderUuid, {
 		format: data.format,
 		content: data.content,
 		metadata,
@@ -2032,4 +2128,4 @@ async function cleanupStaleClients(db, staleSeconds = 60) {
 	return result.length;
 }
 //#endregion
-export { pendingQuestions as $, heartbeatClient as A, listAgentsWithRuntime as B, findOrCreateDirectChat as C, getClient as D, getChatDetail as E, joinChat as F, listClientsForOrgAdmin as G, listChats as H, leaveAsParticipant as I, markStaleAgents as J, listMessages as K, leaveChat as L, inboxEntries as M, invalidateChatAudience as N, getOnlineCount as O, joinAsParticipant as P, notifyRecipients as Q, listActiveAgentsPinnedToClient as R, ensureParticipant as S, getCachedAudience as T, listChatsForMember as U, listChatParticipantsWithNames as V, listClients as W, members as X, markSupersededByChat as Y, messages as Z, createNotifier as _, updateClientCapabilities as _t, agents as a, removeParticipant as at, editMessage as b, bindAgent as c, retireClient as ct, chats as d, serverInstances as dt, recomputeChatWatchers as et, claimClient as f, setOffline as ft, createChat as g, unbindAgent as gt, clients as h, touchAgent as ht, agentVisibilityCondition as i, registerClient as it, heartbeatInstance as j, getPresence as k, chatParticipants as l, sendMessage as lt, cleanupStalePresence as m, submitAnswer as mt, agentChatSessions as n, recomputeWatchersForMember as nt, assertClientOwner as o, resetActivity as ot, cleanupStaleClients as p, setRuntimeState as pt, listMyPinnedAgents as q, agentPresence as r, registerChatMessageDispatcher as rt, assertParticipant as s, resolveChatMembership as st, addParticipant as t, recomputeWatchersForAgent as tt, chatSubscriptions as u, sendToAgent as ut, deriveAuthState as v, upsertSessionState as vt, getActivityOverview as w, ensureCanJoin as x, disconnectClient as y, listAgentsManagedByUser as z };
+export { messages as $, getOnlineCount as A, listActiveAgentsPinnedToClient as B, ensureCanJoin as C, getCachedAudience as D, getActivityOverview as E, invalidateChatAudience as F, listChatsForMember as G, listAgentsWithRuntime as H, joinAsParticipant as I, listMessages as J, listClients as K, joinChat as L, heartbeatClient as M, heartbeatInstance as N, getChatDetail as O, inboxEntries as P, members as Q, leaveAsParticipant as R, editMessage as S, findOrCreateDirectChat as T, listChatParticipantsWithNames as U, listAgentsManagedByUser as V, listChats as W, markStaleAgents as X, listMyPinnedAgents as Y, markSupersededByChat as Z, clients as _, touchAgent as _t, agentVisibilityCondition as a, registerChatMessageDispatcher as at, deriveAuthState as b, upsertSessionState as bt, assertParticipant as c, resetActivity as ct, chatParticipants as d, sendMessage as dt, notifyRecipients as et, chatSubscriptions as f, sendToAgent as ft, cleanupStalePresence as g, submitAnswer as gt, cleanupStaleClients as h, setRuntimeState as ht, agentPresence as i, recomputeWatchersForMember as it, getPresence as j, getClient as k, bindAgent as l, resolveChatMembership as lt, claimClient as m, setOffline as mt, addParticipant as n, recomputeChatWatchers as nt, agents as o, registerClient as ot, chats as p, serverInstances as pt, listClientsForOrgAdmin as q, agentChatSessions as r, recomputeWatchersForAgent as rt, assertClientOwner as s, removeParticipant as st, addChatParticipants as t, pendingQuestions as tt, changeChatType as u, retireClient as ut, createChat as v, unbindAgent as vt, ensureParticipant as w, disconnectClient as x, createNotifier as y, updateClientCapabilities as yt, leaveChat as z };

package/dist/{client-0RrgrMjR-CylTJGEb.mjs → client-GOgUQxVe-Dqk9oZf9.mjs}

@@ -1,7 +1,7 @@
 import "./observability-BAScT_5S-BcW9HgkG.mjs";
 import "./logger-core-BTmvdflj-DjW8FM4T.mjs";
-import "./dist-CMhywpXB.mjs";
+import "./dist-xP6NpdMp.mjs";
 import "./errors-CF5evtJt-B0NTIVPt.mjs";
 import "./src-DNBS5Yjj.mjs";
-import { q as listMyPinnedAgents } from "./client-D1TDiik_-NV_lkhfI.mjs";
+import { Y as listMyPinnedAgents } from "./client-B89AKi3Q-DAyGdQSq.mjs";
 export { listMyPinnedAgents };