@agent-team-foundation/first-tree-hub 0.4.0 → 0.5.0

package/dist/{core-CMeOAZmx.mjs → core-jjk1xFW_.mjs}

@@ -1,4 +1,4 @@
-import { S as setConfigValue, a as getGitHubUsername, b as resolveConfigReadonly, c as DEFAULT_CONFIG_DIR, d as agentConfigSchema, f as clientConfigSchema, g as loadAgents, h as initConfig, p as collectMissingPrompts, s as resolveServerUrl, t as bootstrapToken$1, u as DEFAULT_HOME_DIR$1, x as serverConfigSchema } from "./bootstrap-uyPaaI05.mjs";
+import { S as setConfigValue, a as getGitHubUsername, b as resolveConfigReadonly, c as DEFAULT_CONFIG_DIR, d as agentConfigSchema, f as clientConfigSchema, g as loadAgents, h as initConfig, p as collectMissingPrompts, s as resolveServerUrl, t as bootstrapToken$1, u as DEFAULT_HOME_DIR$1, x as serverConfigSchema } from "./bootstrap-BU_7B03u.mjs";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { EventEmitter } from "node:events";
@@ -45,7 +45,7 @@ var FirstTreeHubSDK = class {
 	async register() {
 		const agent = await this.requestJson("/api/v1/agent/me");
 		return {
-			agentId: agent.id,
+			agentId: agent.uuid,
 			inboxId: agent.inboxId,
 			status: agent.status,
 			displayName: agent.displayName,
@@ -79,8 +79,8 @@ var FirstTreeHubSDK = class {
 		});
 	}
 	/** Send a direct message to another agent. */
-	async sendToAgent(agentId, data) {
-		return this.requestJson(`/api/v1/agent/agents/${agentId}/messages`, {
+	async sendToAgent(agentName, data) {
+		return this.requestJson(`/api/v1/agent/agents/${agentName}/messages`, {
 			method: "POST",
 			body: JSON.stringify(data)
 		});
@@ -2408,7 +2408,7 @@ const AGENT_STATUSES = {
 };
 z.enum(["active", "suspended"]);
 const createAgentSchema = z.object({
-	id: z.string().min(1).max(100).regex(/^[a-z0-9_-]+$/, "Only lowercase alphanumeric, hyphens, and underscores").optional(),
+	name: z.string().min(1).max(100).regex(/^[a-z0-9_-]+$/, "Only lowercase alphanumeric, hyphens, and underscores").optional(),
 	type: agentTypeSchema,
 	displayName: z.string().max(200).optional(),
 	delegateMention: z.string().max(100).optional(),
@@ -2424,7 +2424,8 @@ const updateAgentSchema = z.object({
 	metadata: z.record(z.string(), z.unknown()).optional()
 });
 z.object({
-	id: z.string(),
+	uuid: z.string(),
+	name: z.string().nullable(),
 	organizationId: z.string(),
 	type: agentTypeSchema,
 	displayName: z.string().nullable(),
@@ -2573,7 +2574,7 @@ const SYSTEM_CONFIG_DEFAULTS = {
 	[SYSTEM_CONFIG_KEYS.PRESENCE_CLEANUP_SECONDS]: 60
 };
 //#endregion
-//#region ../server/dist/app-41WnR_ri.mjs
+//#region ../server/dist/app-dUnTcJpC.mjs
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -2586,7 +2587,8 @@ var __exportAll = (all, no_symbols) => {
 };
 /** Agent registration. Each agent owns a unique inboxId for message delivery. */
 const agents = pgTable("agents", {
-	id: text("id").primaryKey(),
+	uuid: text("uuid").primaryKey(),
+	name: text("name"),
 	organizationId: text("organization_id").notNull().default("default"),
 	type: text("type").notNull(),
 	displayName: text("display_name"),
@@ -2597,13 +2599,13 @@ const agents = pgTable("agents", {
 	metadata: jsonb("metadata").$type().notNull().default({}),
 	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
 	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [index("idx_agents_org").on(table.organizationId)]);
+}, (table) => [index("idx_agents_org").on(table.organizationId), unique("uq_agents_org_name").on(table.organizationId, table.name)]);
 /** Maps external user identities to internal Agents. */
 const adapterAgentMappings = pgTable("adapter_agent_mappings", {
 	id: serial("id").primaryKey(),
 	platform: text("platform").notNull(),
 	externalUserId: text("external_user_id").notNull(),
-	agentId: text("agent_id").notNull().references(() => agents.id),
+	agentId: text("agent_id").notNull().references(() => agents.uuid),
 	boundVia: text("bound_via"),
 	displayName: text("display_name"),
 	metadata: jsonb("metadata").$type().notNull().default({}),
@@ -2661,7 +2663,7 @@ const chats = pgTable("chats", {
 /** Chat participants (M:N). */
 const chatParticipants = pgTable("chat_participants", {
 	chatId: text("chat_id").notNull().references(() => chats.id, { onDelete: "cascade" }),
-	agentId: text("agent_id").notNull().references(() => agents.id),
+	agentId: text("agent_id").notNull().references(() => agents.uuid),
 	role: text("role").notNull().default("member"),
 	mode: text("mode").notNull().default("full"),
 	joinedAt: timestamp("joined_at", { withTimezone: true }).notNull().defaultNow()
@@ -2778,7 +2780,7 @@ async function findOrCreateChatForChannel(db, data) {
 	const chatId = randomUUID();
 	const internalType = data.chatType === "p2p" ? "direct" : "group";
 	return db.transaction(async (tx) => {
-		const [botAgent] = await tx.select({ organizationId: agents.organizationId }).from(agents).where(eq(agents.id, data.botAgentId)).limit(1);
+		const [botAgent] = await tx.select({ organizationId: agents.organizationId }).from(agents).where(eq(agents.uuid, data.botAgentId)).limit(1);
 		const orgId = botAgent?.organizationId ?? "default";
 		await tx.insert(chats).values({
 			id: chatId,
@@ -2861,10 +2863,10 @@ async function adminAdapterMappingRoutes(app) {
 	app.post("/", async (request, reply) => {
 		const body = createAdapterMappingSchema.parse(request.body);
 		const [agent] = await app.db.select({
-			id: agents.id,
+			id: agents.uuid,
 			type: agents.type,
 			status: agents.status
-		}).from(agents).where(eq(agents.id, body.agentId)).limit(1);
+		}).from(agents).where(eq(agents.uuid, body.agentId)).limit(1);
 		if (!agent || agent.status === "deleted") throw new NotFoundError(`Agent "${body.agentId}" not found`);
 		if (agent.type !== "human") throw new BadRequestError("User bindings can only be created for human agents");
 		const row = await createAgentMapping(app.db, {
@@ -2900,7 +2902,7 @@ async function adminAdapterStatusRoutes(app) {
 const adapterConfigs = pgTable("adapter_configs", {
 	id: serial("id").primaryKey(),
 	platform: text("platform").notNull(),
-	agentId: text("agent_id").notNull().references(() => agents.id),
+	agentId: text("agent_id").notNull().references(() => agents.uuid),
 	credentials: jsonb("credentials").$type().notNull(),
 	status: text("status").notNull().default("active"),
 	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
@@ -2962,9 +2964,9 @@ function requireEncryptionKey(key) {
 }
 async function validateAgentId(db, agentId) {
 	const [agent] = await db.select({
-		id: agents.id,
+		id: agents.uuid,
 		type: agents.type
-	}).from(agents).where(and(eq(agents.id, agentId), ne(agents.status, "deleted"))).limit(1);
+	}).from(agents).where(and(eq(agents.uuid, agentId), ne(agents.status, "deleted"))).limit(1);
 	if (!agent) throw new NotFoundError(`Agent "${agentId}" not found`);
 	if (agent.type === "human") throw new BadRequestError("Adapter configs can only be bound to non-human agents");
 }
@@ -3079,7 +3081,7 @@ async function adminAdapterRoutes(app) {
 }
 /** Agent online status. Tracked via WebSocket connections; stale entries are cleaned up using server_instances heartbeat. */
 const agentPresence = pgTable("agent_presence", {
-	agentId: text("agent_id").primaryKey().references(() => agents.id, { onDelete: "cascade" }),
+	agentId: text("agent_id").primaryKey().references(() => agents.uuid, { onDelete: "cascade" }),
 	status: text("status").notNull().default("offline"),
 	instanceId: text("instance_id"),
 	connectedAt: timestamp("connected_at", { withTimezone: true }),
@@ -3088,7 +3090,7 @@ const agentPresence = pgTable("agent_presence", {
 /** Agent bearer tokens. Multiple tokens can coexist for zero-downtime rotation. */
 const agentTokens = pgTable("agent_tokens", {
 	id: text("id").primaryKey(),
-	agentId: text("agent_id").notNull().references(() => agents.id, { onDelete: "cascade" }),
+	agentId: text("agent_id").notNull().references(() => agents.uuid, { onDelete: "cascade" }),
 	tokenHash: text("token_hash").notNull(),
 	name: text("name"),
 	expiresAt: timestamp("expires_at", { withTimezone: true }),
@@ -3096,56 +3098,71 @@ const agentTokens = pgTable("agent_tokens", {
 	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
 	lastUsedAt: timestamp("last_used_at", { withTimezone: true })
 }, (table) => [index("idx_agent_tokens_agent").on(table.agentId), index("idx_agent_tokens_hash").on(table.tokenHash)]);
+/** Generate a UUID v7 (time-ordered). No external dependency. */
+function uuidv7() {
+	const now = BigInt(Date.now());
+	const bytes = new Uint8Array(16);
+	bytes[0] = Number(now >> 40n & 255n);
+	bytes[1] = Number(now >> 32n & 255n);
+	bytes[2] = Number(now >> 24n & 255n);
+	bytes[3] = Number(now >> 16n & 255n);
+	bytes[4] = Number(now >> 8n & 255n);
+	bytes[5] = Number(now & 255n);
+	const rand = randomBytes(10);
+	for (let i = 0; i < 10; i++) {
+		const b = rand[i];
+		if (b !== void 0) bytes[6 + i] = b;
+	}
+	bytes[6] = (bytes[6] ?? 0) & 15 | 112;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 function hashToken$1(raw) {
 	return createHash("sha256").update(raw).digest("hex");
 }
 async function createAgent(db, data) {
-	const id = data.id ?? randomUUID();
-	const inboxId = `inbox_${id}`;
-	const [existing] = await db.select({
-		id: agents.id,
-		status: agents.status
-	}).from(agents).where(eq(agents.id, id)).limit(1);
-	if (existing) {
-		if (existing.status !== AGENT_STATUSES.DELETED) throw new ConflictError(`Agent "${id}" already exists`);
-		const [agent] = await db.update(agents).set({
-			organizationId: data.organizationId ?? "default",
+	const uuid = uuidv7();
+	const name = data.name ?? null;
+	const inboxId = `inbox_${uuid}`;
+	const orgId = data.organizationId ?? "default";
+	try {
+		const [agent] = await db.insert(agents).values({
+			uuid,
+			name,
+			organizationId: orgId,
 			type: data.type,
 			displayName: data.displayName ?? null,
 			delegateMention: data.delegateMention ?? null,
 			profile: data.profile ?? null,
-			status: "active",
-			metadata: data.metadata ?? {},
-			updatedAt: /* @__PURE__ */ new Date()
-		}).where(eq(agents.id, id)).returning();
-		if (!agent) throw new Error("Unexpected: UPDATE RETURNING produced no row");
+			inboxId,
+			metadata: data.metadata ?? {}
+		}).returning();
+		if (!agent) throw new Error("Unexpected: INSERT RETURNING produced no row");
 		return agent;
+	} catch (err) {
+		if ((err?.code ?? err?.cause?.code ?? "") === "23505" && name) throw new ConflictError(`Agent name "${name}" already exists in organization "${orgId}"`);
+		throw err;
 	}
-	const [agent] = await db.insert(agents).values({
-		id,
-		organizationId: data.organizationId ?? "default",
-		type: data.type,
-		displayName: data.displayName ?? null,
-		delegateMention: data.delegateMention ?? null,
-		profile: data.profile ?? null,
-		inboxId,
-		metadata: data.metadata ?? {}
-	}).returning();
-	if (!agent) throw new Error("Unexpected: INSERT RETURNING produced no row");
+}
+async function getAgent(db, uuid) {
+	const [agent] = await db.select().from(agents).where(and(eq(agents.uuid, uuid), ne(agents.status, AGENT_STATUSES.DELETED))).limit(1);
+	if (!agent) throw new NotFoundError(`Agent "${uuid}" not found`);
 	return agent;
 }
-async function getAgent(db, id) {
-	const [agent] = await db.select().from(agents).where(and(eq(agents.id, id), ne(agents.status, AGENT_STATUSES.DELETED))).limit(1);
-	if (!agent) throw new NotFoundError(`Agent "${id}" not found`);
+async function getAgentByName(db, orgId, name) {
+	const [agent] = await db.select().from(agents).where(and(eq(agents.organizationId, orgId), eq(agents.name, name), ne(agents.status, AGENT_STATUSES.DELETED))).limit(1);
+	if (!agent) throw new NotFoundError(`Agent "${name}" not found in organization "${orgId}"`);
 	return agent;
 }
-async function listAgents(db, limit, cursor, type) {
-	const conditions = [ne(agents.status, AGENT_STATUSES.DELETED)];
+async function listAgents(db, orgId, limit, cursor, type) {
+	const conditions = [ne(agents.status, AGENT_STATUSES.DELETED), eq(agents.organizationId, orgId)];
 	if (cursor) conditions.push(lt(agents.createdAt, new Date(cursor)));
 	if (type) conditions.push(eq(agents.type, type));
 	const where = and(...conditions);
 	const rows = await db.select({
-		id: agents.id,
+		uuid: agents.uuid,
+		name: agents.name,
 		organizationId: agents.organizationId,
 		type: agents.type,
 		displayName: agents.displayName,
@@ -3157,7 +3174,7 @@ async function listAgents(db, limit, cursor, type) {
 		createdAt: agents.createdAt,
 		updatedAt: agents.updatedAt,
 		presenceStatus: agentPresence.status
-	}).from(agents).leftJoin(agentPresence, eq(agents.id, agentPresence.agentId)).where(where).orderBy(desc(agents.createdAt)).limit(limit + 1);
+	}).from(agents).leftJoin(agentPresence, eq(agents.uuid, agentPresence.agentId)).where(where).orderBy(desc(agents.createdAt)).limit(limit + 1);
 	const hasMore = rows.length > limit;
 	const items = hasMore ? rows.slice(0, limit) : rows;
 	const last = items[items.length - 1];
@@ -3166,72 +3183,74 @@ async function listAgents(db, limit, cursor, type) {
 		nextCursor: hasMore && last ? last.createdAt.toISOString() : null
 	};
 }
-async function updateAgent(db, id, data) {
-	const agent = await getAgent(db, id);
+async function updateAgent(db, uuid, data) {
+	const agent = await getAgent(db, uuid);
 	const updates = { updatedAt: /* @__PURE__ */ new Date() };
 	if (data.type !== void 0) updates.type = data.type;
 	if (data.displayName !== void 0) updates.displayName = data.displayName;
 	if (data.delegateMention !== void 0) updates.delegateMention = data.delegateMention;
 	if (data.profile !== void 0) updates.profile = data.profile;
 	if (data.metadata !== void 0) updates.metadata = data.metadata;
-	const [updated] = await db.update(agents).set(updates).where(eq(agents.id, agent.id)).returning();
+	const [updated] = await db.update(agents).set(updates).where(eq(agents.uuid, agent.uuid)).returning();
 	if (!updated) throw new Error("Unexpected: UPDATE RETURNING produced no row");
 	return updated;
 }
 /**
 * Reactivate a suspended agent.
 */
-async function reactivateAgent(db, id) {
+async function reactivateAgent(db, uuid) {
 	const [existing] = await db.select({
-		id: agents.id,
+		uuid: agents.uuid,
 		status: agents.status
-	}).from(agents).where(eq(agents.id, id)).limit(1);
-	if (!existing || existing.status === AGENT_STATUSES.DELETED) throw new NotFoundError(`Agent "${id}" not found`);
+	}).from(agents).where(eq(agents.uuid, uuid)).limit(1);
+	if (!existing || existing.status === AGENT_STATUSES.DELETED) throw new NotFoundError(`Agent "${uuid}" not found`);
 	if (existing.status !== AGENT_STATUSES.SUSPENDED) throw new BadRequestError("Only suspended agents can be reactivated.");
 	const [agent] = await db.update(agents).set({
 		status: AGENT_STATUSES.ACTIVE,
 		updatedAt: /* @__PURE__ */ new Date()
-	}).where(eq(agents.id, id)).returning();
+	}).where(eq(agents.uuid, uuid)).returning();
 	if (!agent) throw new Error("Unexpected: UPDATE RETURNING produced no row");
 	return agent;
 }
 /**
 * Suspend an agent. Revokes all active tokens so the agent can no longer authenticate.
 */
-async function suspendAgent(db, id) {
+async function suspendAgent(db, uuid) {
 	const [agent] = await db.update(agents).set({
 		status: AGENT_STATUSES.SUSPENDED,
 		updatedAt: /* @__PURE__ */ new Date()
-	}).where(and(eq(agents.id, id), ne(agents.status, AGENT_STATUSES.DELETED))).returning();
-	if (!agent) throw new NotFoundError(`Agent "${id}" not found`);
-	await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.agentId, id), isNull(agentTokens.revokedAt)));
+	}).where(and(eq(agents.uuid, uuid), ne(agents.status, AGENT_STATUSES.DELETED))).returning();
+	if (!agent) throw new NotFoundError(`Agent "${uuid}" not found`);
+	await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.agentId, uuid), isNull(agentTokens.revokedAt)));
 	return agent;
 }
 /**
 * Delete an agent. Only allowed when status is "suspended".
 * Suspend the agent first to revoke tokens, then delete.
+* Sets name to NULL to release the name for reuse.
 */
-async function deleteAgent(db, id) {
+async function deleteAgent(db, uuid) {
 	const [existing] = await db.select({
-		id: agents.id,
+		uuid: agents.uuid,
 		status: agents.status
-	}).from(agents).where(eq(agents.id, id)).limit(1);
-	if (!existing || existing.status === AGENT_STATUSES.DELETED) throw new NotFoundError(`Agent "${id}" not found`);
+	}).from(agents).where(eq(agents.uuid, uuid)).limit(1);
+	if (!existing || existing.status === AGENT_STATUSES.DELETED) throw new NotFoundError(`Agent "${uuid}" not found`);
 	if (existing.status !== AGENT_STATUSES.SUSPENDED) throw new BadRequestError("Only suspended agents can be deleted. Suspend the agent first.");
 	const [agent] = await db.update(agents).set({
 		status: AGENT_STATUSES.DELETED,
+		name: null,
 		updatedAt: /* @__PURE__ */ new Date()
-	}).where(eq(agents.id, id)).returning();
-	await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.agentId, id), isNull(agentTokens.revokedAt)));
-	await db.delete(adapterConfigs).where(eq(adapterConfigs.agentId, id));
-	await db.delete(adapterAgentMappings).where(eq(adapterAgentMappings.agentId, id));
+	}).where(eq(agents.uuid, uuid)).returning();
+	await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.agentId, uuid), isNull(agentTokens.revokedAt)));
+	await db.delete(adapterConfigs).where(eq(adapterConfigs.agentId, uuid));
+	await db.delete(adapterAgentMappings).where(eq(adapterAgentMappings.agentId, uuid));
 	if (!agent) throw new Error("Unexpected: UPDATE RETURNING produced no row");
 	return agent;
 }
-async function bootstrapToken(db, agentId, githubUsername, options) {
+async function bootstrapToken(db, agentName, orgId, githubUsername, options) {
 	let agent;
 	try {
-		agent = await getAgent(db, agentId);
+		agent = await getAgentByName(db, orgId, agentName);
 	} catch (err) {
 		if (err instanceof NotFoundError) {
 			const metadata = {
@@ -3239,19 +3258,20 @@ async function bootstrapToken(db, agentId, githubUsername, options) {
 				owners: [githubUsername]
 			};
 			agent = await createAgent(db, {
-				id: agentId,
+				name: agentName,
 				type: options?.type ?? "autonomous_agent",
-				displayName: options?.displayName ?? agentId,
+				displayName: options?.displayName ?? agentName,
 				delegateMention: options?.delegateMention,
 				profile: options?.profile,
+				organizationId: orgId,
 				metadata
 			});
 		} else throw err;
 	}
-	if (!(Array.isArray(agent.metadata?.owners) ? agent.metadata.owners : []).includes(githubUsername)) throw new ForbiddenError(`GitHub user "${githubUsername}" is not in the owners list for agent "${agentId}"`);
-	const activeTokens = await db.select({ id: agentTokens.id }).from(agentTokens).where(and(eq(agentTokens.agentId, agentId), isNull(agentTokens.revokedAt)));
-	if (activeTokens.length > 0) throw new ConflictError(`Agent "${agentId}" already has ${activeTokens.length} active token(s). Revoke all tokens first to re-bootstrap.`);
-	return createToken(db, agentId, { name: options?.tokenName ?? "bootstrap" });
+	if (!(Array.isArray(agent.metadata?.owners) ? agent.metadata.owners : []).includes(githubUsername)) throw new ForbiddenError(`GitHub user "${githubUsername}" is not in the owners list for agent "${agentName}"`);
+	const activeTokens = await db.select({ id: agentTokens.id }).from(agentTokens).where(and(eq(agentTokens.agentId, agent.uuid), isNull(agentTokens.revokedAt)));
+	if (activeTokens.length > 0) throw new ConflictError(`Agent "${agentName}" already has ${activeTokens.length} active token(s). Revoke all tokens first to re-bootstrap.`);
+	return createToken(db, agent.uuid, { name: options?.tokenName ?? "bootstrap" });
 }
 /**
 * Check if a GitHub user belongs to a specific organization.
@@ -3264,14 +3284,14 @@ async function checkGitHubOrgMembership(githubToken, org) {
 	if (!res.ok) return false;
 	return (await res.json()).some((o) => o.login.toLowerCase() === org.toLowerCase());
 }
-async function createToken(db, agentId, data) {
-	await getAgent(db, agentId);
+async function createToken(db, agentUuid, data) {
+	await getAgent(db, agentUuid);
 	const raw = `aghub_${randomBytes(32).toString("hex")}`;
 	const tokenHash = hashToken$1(raw);
-	const tokenId = randomUUID();
+	const tokenId = uuidv7();
 	const [token] = await db.insert(agentTokens).values({
 		id: tokenId,
-		agentId,
+		agentId: agentUuid,
 		tokenHash,
 		name: data.name ?? null,
 		expiresAt: data.expiresAt ? new Date(data.expiresAt) : null
@@ -3288,7 +3308,7 @@ async function createToken(db, agentId, data) {
 		token: raw
 	};
 }
-async function listTokens(db, agentId) {
+async function listTokens(db, agentUuid) {
 	return db.select({
 		id: agentTokens.id,
 		agentId: agentTokens.agentId,
@@ -3297,10 +3317,10 @@ async function listTokens(db, agentId) {
 		revokedAt: agentTokens.revokedAt,
 		createdAt: agentTokens.createdAt,
 		lastUsedAt: agentTokens.lastUsedAt
-	}).from(agentTokens).where(eq(agentTokens.agentId, agentId)).orderBy(desc(agentTokens.createdAt));
+	}).from(agentTokens).where(eq(agentTokens.agentId, agentUuid)).orderBy(desc(agentTokens.createdAt));
 }
-async function revokeToken(db, agentId, tokenId) {
-	const [token] = await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.id, tokenId), eq(agentTokens.agentId, agentId), isNull(agentTokens.revokedAt))).returning();
+async function revokeToken(db, agentUuid, tokenId) {
+	const [token] = await db.update(agentTokens).set({ revokedAt: /* @__PURE__ */ new Date() }).where(and(eq(agentTokens.id, tokenId), eq(agentTokens.agentId, agentUuid), isNull(agentTokens.revokedAt))).returning();
 	if (!token) throw new NotFoundError("Token not found or already revoked");
 	return token;
 }
@@ -3308,9 +3328,9 @@ async function createChat(db, creatorId, data) {
 	const chatId = randomUUID();
 	const allParticipantIds = new Set([creatorId, ...data.participantIds]);
 	const existingAgents = await db.select({
-		id: agents.id,
+		id: agents.uuid,
 		organizationId: agents.organizationId
-	}).from(agents).where(inArray(agents.id, [...allParticipantIds]));
+	}).from(agents).where(inArray(agents.uuid, [...allParticipantIds]));
 	if (existingAgents.length !== allParticipantIds.size) {
 		const found = new Set(existingAgents.map((a) => a.id));
 		throw new BadRequestError(`Agents not found: ${[...allParticipantIds].filter((id) => !found.has(id)).join(", ")}`);
@@ -3379,9 +3399,9 @@ async function addParticipant(db, chatId, requesterId, data) {
 	const chat = await getChat(db, chatId);
 	await assertParticipant(db, chatId, requesterId);
 	const [targetAgent] = await db.select({
-		id: agents.id,
+		id: agents.uuid,
 		organizationId: agents.organizationId
-	}).from(agents).where(eq(agents.id, data.agentId)).limit(1);
+	}).from(agents).where(eq(agents.uuid, data.agentId)).limit(1);
 	if (!targetAgent) throw new NotFoundError(`Agent "${data.agentId}" not found`);
 	if (targetAgent.organizationId !== chat.organizationId) throw new BadRequestError("Cannot add agent from different organization");
 	const [existing] = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, data.agentId))).limit(1);
@@ -3409,7 +3429,7 @@ async function findOrCreateDirectChat(db, agentAId, agentBId) {
 		const directChats = await db.select().from(chats).where(and(inArray(chats.id, commonChatIds), eq(chats.type, "direct")));
 		if (directChats.length > 0 && directChats[0]) return directChats[0];
 	}
-	const [agentA] = await db.select({ organizationId: agents.organizationId }).from(agents).where(eq(agents.id, agentAId)).limit(1);
+	const [agentA] = await db.select({ organizationId: agents.organizationId }).from(agents).where(eq(agents.uuid, agentAId)).limit(1);
 	if (!agentA) throw new NotFoundError(`Agent "${agentAId}" not found`);
 	const chatId = randomUUID();
 	return db.transaction(async (tx) => {
@@ -3489,7 +3509,7 @@ async function sendMessage(db, chatId, senderId, data) {
 		const entries = (await tx.select({
 			agentId: chatParticipants.agentId,
 			inboxId: agents.inboxId
-		}).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.id)).where(eq(chatParticipants.chatId, chatId))).filter((p) => p.agentId !== senderId).map((p) => ({
+		}).from(chatParticipants).innerJoin(agents, eq(chatParticipants.agentId, agents.uuid)).where(eq(chatParticipants.chatId, chatId))).filter((p) => p.agentId !== senderId).map((p) => ({
 			inboxId: p.inboxId,
 			messageId,
 			chatId
@@ -3518,18 +3538,15 @@ async function sendMessage(db, chatId, senderId, data) {
 		};
 	});
 }
-async function sendToAgent(db, senderId, targetAgentId, data) {
+async function sendToAgent(db, senderUuid, targetName, data) {
 	const [sender] = await db.select({
-		id: agents.id,
+		uuid: agents.uuid,
 		organizationId: agents.organizationId
-	}).from(agents).where(eq(agents.id, senderId)).limit(1);
-	if (!sender) throw new NotFoundError(`Agent "${senderId}" not found`);
-	const [target] = await db.select({
-		id: agents.id,
-		organizationId: agents.organizationId
-	}).from(agents).where(eq(agents.id, targetAgentId)).limit(1);
-	if (!target) throw new NotFoundError(`Agent "${targetAgentId}" not found`);
-	return sendMessage(db, (await findOrCreateDirectChat(db, senderId, targetAgentId)).id, senderId, {
+	}).from(agents).where(eq(agents.uuid, senderUuid)).limit(1);
+	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`);
+	return sendMessage(db, (await findOrCreateDirectChat(db, senderUuid, target.uuid)).id, senderUuid, {
 		format: data.format,
 		content: data.content,
 		metadata: data.metadata,
@@ -3703,7 +3720,8 @@ async function adminAgentRoutes(app) {
 	app.get("/", async (request) => {
 		const query = paginationQuerySchema.parse(request.query);
 		const { type } = listAgentsFilterSchema.parse(request.query);
-		const result = await listAgents(app.db, query.limit, query.cursor, type);
+		const org = request.query.org ?? "default";
+		const result = await listAgents(app.db, org, query.limit, query.cursor, type);
 		return {
 			items: result.items.map((a) => ({
 				...a,
@@ -3723,26 +3741,26 @@ async function adminAgentRoutes(app) {
 			updatedAt: agent.updatedAt.toISOString()
 		});
 	});
-	app.patch("/:agentId", async (request) => {
+	app.patch("/:uuid", async (request) => {
 		const body = updateAgentSchema.parse(request.body);
-		const agent = await updateAgent(app.db, request.params.agentId, body);
+		const agent = await updateAgent(app.db, request.params.uuid, body);
 		return {
 			...agent,
 			createdAt: agent.createdAt.toISOString(),
 			updatedAt: agent.updatedAt.toISOString()
 		};
 	});
-	app.get("/:agentId", async (request) => {
-		const agent = await getAgent(app.db, request.params.agentId);
+	app.get("/:uuid", async (request) => {
+		const agent = await getAgent(app.db, request.params.uuid);
 		return {
 			...agent,
 			createdAt: agent.createdAt.toISOString(),
 			updatedAt: agent.updatedAt.toISOString()
 		};
 	});
-	app.post("/:agentId/tokens", async (request, reply) => {
+	app.post("/:uuid/tokens", async (request, reply) => {
 		const body = createAgentTokenSchema.parse(request.body);
-		const result = await createToken(app.db, request.params.agentId, body);
+		const result = await createToken(app.db, request.params.uuid, body);
 		return reply.status(201).send({
 			...result,
 			expiresAt: serializeDate$1(result.expiresAt),
@@ -3751,8 +3769,8 @@ async function adminAgentRoutes(app) {
 			lastUsedAt: serializeDate$1(result.lastUsedAt)
 		});
 	});
-	app.get("/:agentId/tokens", async (request) => {
-		return (await listTokens(app.db, request.params.agentId)).map((t) => ({
+	app.get("/:uuid/tokens", async (request) => {
+		return (await listTokens(app.db, request.params.uuid)).map((t) => ({
 			...t,
 			expiresAt: serializeDate$1(t.expiresAt),
 			revokedAt: serializeDate$1(t.revokedAt),
@@ -3760,55 +3778,55 @@ async function adminAgentRoutes(app) {
 			lastUsedAt: serializeDate$1(t.lastUsedAt)
 		}));
 	});
-	app.delete("/:agentId/tokens/:tokenId", async (request, reply) => {
-		await revokeToken(app.db, request.params.agentId, request.params.tokenId);
+	app.delete("/:uuid/tokens/:tokenId", async (request, reply) => {
+		await revokeToken(app.db, request.params.uuid, request.params.tokenId);
 		return reply.status(204).send();
 	});
-	app.post("/:agentId/disconnect", async (request, reply) => {
-		const { agentId } = request.params;
-		await getAgent(app.db, agentId);
-		const wasConnected = forceDisconnect(agentId);
-		await setOffline(app.db, agentId);
+	app.post("/:uuid/disconnect", async (request, reply) => {
+		const { uuid } = request.params;
+		await getAgent(app.db, uuid);
+		const wasConnected = forceDisconnect(uuid);
+		await setOffline(app.db, uuid);
 		return reply.status(200).send({ disconnected: wasConnected });
 	});
-	app.post("/:agentId/suspend", async (request) => {
-		const agent = await suspendAgent(app.db, request.params.agentId);
+	app.post("/:uuid/suspend", async (request) => {
+		const agent = await suspendAgent(app.db, request.params.uuid);
 		return {
 			...agent,
 			createdAt: agent.createdAt.toISOString(),
 			updatedAt: agent.updatedAt.toISOString()
 		};
 	});
-	app.post("/:agentId/reactivate", async (request) => {
-		const agent = await reactivateAgent(app.db, request.params.agentId);
+	app.post("/:uuid/reactivate", async (request) => {
+		const agent = await reactivateAgent(app.db, request.params.uuid);
 		return {
 			...agent,
 			createdAt: agent.createdAt.toISOString(),
 			updatedAt: agent.updatedAt.toISOString()
 		};
 	});
-	app.delete("/:agentId", async (request, reply) => {
-		await deleteAgent(app.db, request.params.agentId);
+	app.delete("/:uuid", async (request, reply) => {
+		await deleteAgent(app.db, request.params.uuid);
 		return reply.status(204).send();
 	});
-	app.post("/:agentId/test", async (request, reply) => {
-		const { agentId } = request.params;
-		const [, presence] = await Promise.all([getAgent(app.db, agentId), getPresence(app.db, agentId)]);
+	app.post("/:uuid/test", async (request, reply) => {
+		const { uuid } = request.params;
+		const [, presence] = await Promise.all([getAgent(app.db, uuid), getPresence(app.db, uuid)]);
 		if (!presence || presence.status !== "online") return reply.status(200).send({
 			status: "offline",
 			message: "Agent is not connected. Start the client first."
 		});
-		const [owner] = await app.db.select({ id: agents.id }).from(agents).where(and(eq(agents.delegateMention, agentId), eq(agents.status, "active"))).limit(1);
-		let senderId = owner?.id ?? null;
+		const [owner] = await app.db.select({ uuid: agents.uuid }).from(agents).where(and(eq(agents.delegateMention, uuid), eq(agents.status, "active"))).limit(1);
+		let senderId = owner?.uuid ?? null;
 		if (!senderId) {
-			const [other] = await app.db.select({ id: agents.id }).from(agents).where(and(ne(agents.id, agentId), eq(agents.status, "active"))).limit(1);
-			senderId = other?.id ?? null;
+			const [other] = await app.db.select({ uuid: agents.uuid }).from(agents).where(and(ne(agents.uuid, uuid), eq(agents.status, "active"))).limit(1);
+			senderId = other?.uuid ?? null;
 		}
 		if (!senderId) return reply.status(200).send({
 			status: "error",
 			message: "No suitable sender found. Need at least one other active agent."
 		});
-		const chat = await findOrCreateDirectChat(app.db, senderId, agentId);
+		const chat = await findOrCreateDirectChat(app.db, senderId, uuid);
 		const testContent = `[System Test] Verify your connection. Respond with your identity and role. Time: ${(/* @__PURE__ */ new Date()).toISOString()}`;
 		const result = await sendMessage(app.db, chat.id, senderId, {
 			format: "text",
@@ -3821,7 +3839,7 @@ async function adminAgentRoutes(app) {
 		const pollStart = Date.now();
 		while (Date.now() - pollStart < POLL_TIMEOUT) {
 			await new Promise((r) => setTimeout(r, POLL_INTERVAL));
-			const [response] = await app.db.select().from(messages).where(and(eq(messages.chatId, chat.id), eq(messages.senderId, agentId), gt(messages.createdAt, threshold))).limit(1);
+			const [response] = await app.db.select().from(messages).where(and(eq(messages.chatId, chat.id), eq(messages.senderId, uuid), gt(messages.createdAt, threshold))).limit(1);
 			if (response) {
 				const content = typeof response.content === "string" ? response.content.slice(0, 500) : JSON.stringify(response.content).slice(0, 500);
 				return reply.status(200).send({
@@ -3903,7 +3921,10 @@ async function adminChatRoutes(app) {
 	/** List chats with participant count */
 	app.get("/", async (request) => {
 		const query = paginationQuerySchema.parse(request.query);
-		const where = query.cursor ? lt(chats.createdAt, new Date(query.cursor)) : void 0;
+		const org = request.query.org ?? "default";
+		const conditions = [eq(chats.organizationId, org)];
+		if (query.cursor) conditions.push(lt(chats.createdAt, new Date(query.cursor)));
+		const where = and(...conditions);
 		const rows = await app.db.select({
 			id: chats.id,
 			organizationId: chats.organizationId,
@@ -3982,9 +4003,10 @@ async function adminChatRoutes(app) {
 	});
 }
 async function adminOverviewRoutes(app) {
-	app.get("/", async () => {
-		const [agentCount] = await app.db.select({ count: sql`count(*)::int` }).from(agents).where(ne(agents.status, "deleted"));
-		const [chatCount] = await app.db.select({ count: sql`count(*)::int` }).from(chats);
+	app.get("/", async (request) => {
+		const org = (request.query ?? {}).org ?? "default";
+		const [agentCount] = await app.db.select({ count: sql`count(*)::int` }).from(agents).where(and(ne(agents.status, "deleted"), eq(agents.organizationId, org)));
+		const [chatCount] = await app.db.select({ count: sql`count(*)::int` }).from(chats).where(eq(chats.organizationId, org));
 		const onlineCount = await getOnlineCount(app.db);
 		return {
 			agents: agentCount?.count ?? 0,
@@ -4137,7 +4159,7 @@ async function agentChatRoutes(app) {
 	app.post("/", async (request, reply) => {
 		const identity = requireAgent(request);
 		const body = createChatSchema.parse(request.body);
-		const result = await createChat(app.db, identity.id, body);
+		const result = await createChat(app.db, identity.uuid, body);
 		return reply.status(201).send({
 			...serializeChat(result),
 			participants: result.participants.map((p) => ({
@@ -4149,7 +4171,7 @@ async function agentChatRoutes(app) {
 	app.get("/", async (request) => {
 		const identity = requireAgent(request);
 		const query = paginationQuerySchema.parse(request.query);
-		const result = await listChats(app.db, identity.id, query.limit, query.cursor);
+		const result = await listChats(app.db, identity.uuid, query.limit, query.cursor);
 		return {
 			items: result.items.map(serializeChat),
 			nextCursor: result.nextCursor
@@ -4157,7 +4179,7 @@ async function agentChatRoutes(app) {
 	});
 	app.get("/:chatId", async (request) => {
 		const identity = requireAgent(request);
-		await assertParticipant(app.db, request.params.chatId, identity.id);
+		await assertParticipant(app.db, request.params.chatId, identity.uuid);
 		const detail = await getChatDetail(app.db, request.params.chatId);
 		return {
 			...serializeChat(detail),
@@ -4170,7 +4192,7 @@ async function agentChatRoutes(app) {
 	app.post("/:chatId/participants", async (request, reply) => {
 		const identity = requireAgent(request);
 		const body = addParticipantSchema.parse(request.body);
-		const participants = await addParticipant(app.db, request.params.chatId, identity.id, body);
+		const participants = await addParticipant(app.db, request.params.chatId, identity.uuid, body);
 		return reply.status(201).send(participants.map((p) => ({
 			...p,
 			joinedAt: p.joinedAt.toISOString()
@@ -4178,7 +4200,7 @@ async function agentChatRoutes(app) {
 	});
 	app.delete("/:chatId/participants/:agentId", async (request, reply) => {
 		const identity = requireAgent(request);
-		await removeParticipant(app.db, request.params.chatId, identity.id, request.params.agentId);
+		await removeParticipant(app.db, request.params.chatId, identity.uuid, request.params.agentId);
 		return reply.status(204).send();
 	});
 }
@@ -4190,8 +4212,8 @@ async function agentFeishuBotRoutes(app) {
 	app.put("/me/feishu-bot", async (request, reply) => {
 		const identity = requireAgent(request);
 		const body = selfServiceFeishuBotSchema.parse(request.body);
-		if ((await getAgent(app.db, identity.id)).type === "human") throw new BadRequestError("Human agents cannot bind Feishu bots. Use bind-user instead.");
-		const current = (await listAdapterConfigs(app.db)).find((c) => c.agentId === identity.id && c.platform === "feishu");
+		if ((await getAgent(app.db, identity.uuid)).type === "human") throw new BadRequestError("Human agents cannot bind Feishu bots. Use bind-user instead.");
+		const current = (await listAdapterConfigs(app.db)).find((c) => c.agentId === identity.uuid && c.platform === "feishu");
 		let config;
 		if (current) config = await updateAdapterConfig(app.db, current.id, {
 			credentials: {
@@ -4202,7 +4224,7 @@ async function agentFeishuBotRoutes(app) {
 		}, app.config.secrets.encryptionKey);
 		else config = await createAdapterConfig(app.db, {
 			platform: "feishu",
-			agentId: identity.id,
+			agentId: identity.uuid,
 			credentials: {
 				app_id: body.appId,
 				app_secret: body.appSecret
@@ -4223,7 +4245,7 @@ async function agentFeishuBotRoutes(app) {
 	*/
 	app.delete("/me/feishu-bot", async (request, reply) => {
 		const identity = requireAgent(request);
-		const current = (await listAdapterConfigs(app.db)).find((c) => c.agentId === identity.id && c.platform === "feishu");
+		const current = (await listAdapterConfigs(app.db)).find((c) => c.agentId === identity.uuid && c.platform === "feishu");
 		if (!current) return reply.status(204).send();
 		await deleteAdapterConfig(app.db, current.id);
 		app.adapterManager.reload().catch((err) => app.log.error(err, "Adapter reload failed after self-service unbind"));
@@ -4242,7 +4264,7 @@ async function agentFeishuUserRoutes(app) {
 		const body = delegateFeishuUserSchema.parse(request.body);
 		const humanAgent = await getAgent(app.db, humanAgentId);
 		if (humanAgent.type !== "human") throw new BadRequestError(`Agent "${humanAgentId}" is not a human agent`);
-		if (humanAgent.delegateMention !== identity.id) throw new ForbiddenError(`Agent "${identity.id}" is not the delegate of "${humanAgentId}". Expected delegate_mention="${identity.id}" but found "${humanAgent.delegateMention ?? "(none)"}".`);
+		if (humanAgent.delegateMention !== identity.uuid) throw new ForbiddenError(`Agent "${identity.uuid}" is not the delegate of "${humanAgentId}". Expected delegate_mention="${identity.uuid}" but found "${humanAgent.delegateMention ?? "(none)"}".`);
 		const mapping = await createAgentMapping(app.db, {
 			platform: "feishu",
 			externalUserId: body.feishuUserId,
@@ -4267,7 +4289,7 @@ async function agentFeishuUserRoutes(app) {
 	app.delete("/:humanAgentId/feishu-user", async (request, reply) => {
 		const identity = requireAgent(request);
 		const { humanAgentId } = request.params;
-		if ((await getAgent(app.db, humanAgentId)).delegateMention !== identity.id) throw new ForbiddenError(`Agent "${identity.id}" is not the delegate of "${humanAgentId}"`);
+		if ((await getAgent(app.db, humanAgentId)).delegateMention !== identity.uuid) throw new ForbiddenError(`Agent "${identity.uuid}" is not the delegate of "${humanAgentId}"`);
 		await app.db.delete(adapterAgentMappings).where(and(eq(adapterAgentMappings.platform, "feishu"), eq(adapterAgentMappings.agentId, humanAgentId)));
 		return reply.status(204).send();
 	});
@@ -4376,7 +4398,7 @@ async function agentInboxRoutes(app) {
 async function agentMeRoutes(app) {
 	app.get("/me", async (request) => {
 		const identity = requireAgent(request);
-		const agent = await getAgent(app.db, identity.id);
+		const agent = await getAgent(app.db, identity.uuid);
 		return {
 			...agent,
 			createdAt: agent.createdAt.toISOString(),
@@ -4391,9 +4413,9 @@ const editMessageSchema = z.object({
 async function agentMessageRoutes(app) {
 	app.post("/:chatId/messages", async (request, reply) => {
 		const identity = requireAgent(request);
-		await assertParticipant(app.db, request.params.chatId, identity.id);
+		await assertParticipant(app.db, request.params.chatId, identity.uuid);
 		const body = sendMessageSchema.parse(request.body);
-		const { message: msg, recipients } = await sendMessage(app.db, request.params.chatId, identity.id, body);
+		const { message: msg, recipients } = await sendMessage(app.db, request.params.chatId, identity.uuid, body);
 		notifyRecipients(app.notifier, recipients, msg.id);
 		return reply.status(201).send({
 			...msg,
@@ -4402,9 +4424,9 @@ async function agentMessageRoutes(app) {
 	});
 	app.patch("/:chatId/messages/:messageId", async (request) => {
 		const identity = requireAgent(request);
-		await assertParticipant(app.db, request.params.chatId, identity.id);
+		await assertParticipant(app.db, request.params.chatId, identity.uuid);
 		const body = editMessageSchema.parse(request.body);
-		const msg = await editMessage(app.db, request.params.chatId, request.params.messageId, identity.id, body);
+		const msg = await editMessage(app.db, request.params.chatId, request.params.messageId, identity.uuid, body);
 		app.adapterManager.editOutboundMessage(msg.id, msg.format, msg.content).catch((err) => app.log.error({
 			err,
 			messageId: msg.id
@@ -4416,7 +4438,7 @@ async function agentMessageRoutes(app) {
 	});
 	app.get("/:chatId/messages", async (request) => {
 		const identity = requireAgent(request);
-		await assertParticipant(app.db, request.params.chatId, identity.id);
+		await assertParticipant(app.db, request.params.chatId, identity.uuid);
 		const query = paginationQuerySchema.parse(request.query);
 		const result = await listMessages(app.db, request.params.chatId, query.limit, query.cursor);
 		return {
@@ -4429,10 +4451,10 @@ async function agentMessageRoutes(app) {
 	});
 }
 async function agentSendToAgentRoutes(app) {
-	app.post("/:agentId/messages", async (request, reply) => {
+	app.post("/:name/messages", async (request, reply) => {
 		const identity = requireAgent(request);
 		const body = sendToAgentSchema.parse(request.body);
-		const { message: msg, recipients } = await sendToAgent(app.db, identity.id, request.params.agentId, body);
+		const { message: msg, recipients } = await sendToAgent(app.db, identity.uuid, request.params.name, body);
 		notifyRecipients(app.notifier, recipients, msg.id);
 		return reply.status(201).send({
 			...msg,
@@ -4448,18 +4470,18 @@ function agentWsRoutes(notifier, instanceId) {
 				socket.close(4001, "Unauthorized");
 				return;
 			}
-			if (hasActiveConnection(agent.id)) {
+			if (hasActiveConnection(agent.uuid)) {
 				socket.close(WS_CLOSE_ALREADY_CONNECTED, "Agent already connected");
 				return;
 			}
 			const inboxId = agent.inboxId;
-			await setOnline(app.db, agent.id, instanceId);
-			setConnection(agent.id, socket);
+			await setOnline(app.db, agent.uuid, instanceId);
+			setConnection(agent.uuid, socket);
 			notifier.subscribe(inboxId, socket);
 			socket.on("close", async () => {
 				notifier.unsubscribe(inboxId, socket);
-				if (removeConnection(agent.id, socket)) try {
-					await setOffline(app.db, agent.id);
+				if (removeConnection(agent.uuid, socket)) try {
+					await setOffline(app.db, agent.uuid);
 				} catch {}
 			});
 		});
@@ -4473,13 +4495,13 @@ async function bootstrapConfigRoutes(app) {
 }
 async function bootstrapRoutes(app) {
 	/**
-	* POST /bootstrap/:agentId/token
+	* POST /bootstrap/:name/token
 	* GitHub identity → Agent token.
 	* Auto-creates the agent if it does not exist.
 	* Only works when the agent has no active tokens.
 	*/
-	app.post("/:agentId/token", async (request, reply) => {
-		const { agentId } = request.params;
+	app.post("/:name/token", async (request, reply) => {
+		const { name } = request.params;
 		const githubUser = request.githubUser;
 		if (!githubUser) throw new ForbiddenError("GitHub authentication required");
 		const allowedOrg = app.config.github.allowedOrg;
@@ -4488,7 +4510,7 @@ async function bootstrapRoutes(app) {
 		if (!githubToken || typeof githubToken !== "string") throw new ForbiddenError("Missing GitHub token for org membership check");
 		if (!await checkGitHubOrgMembership(githubToken, allowedOrg)) throw new ForbiddenError(`GitHub user "${githubUser.username}" is not a member of organization "${allowedOrg}"`);
 		const body = bootstrapTokenRequestSchema.parse(request.body ?? {});
-		const result = await bootstrapToken(app.db, agentId, githubUser.username, {
+		const result = await bootstrapToken(app.db, name, "default", githubUser.username, {
 			tokenName: body.name,
 			type: body.type,
 			displayName: body.displayName,
@@ -4506,16 +4528,16 @@ async function bootstrapRoutes(app) {
 		});
 	});
 	/**
-	* GET /bootstrap/:agentId/status
+	* GET /bootstrap/:name/status
 	* Check if an agent exists and its status (for polling).
 	*/
-	app.get("/:agentId/status", async (request) => {
-		const { agentId } = request.params;
+	app.get("/:name/status", async (request) => {
+		const { name } = request.params;
 		const githubUser = request.githubUser;
 		if (!githubUser) throw new ForbiddenError("GitHub authentication required");
 		try {
-			const agent = await getAgent(app.db, agentId);
-			if (!(Array.isArray(agent.metadata?.owners) ? agent.metadata.owners : []).includes(githubUser.username)) throw new ForbiddenError(`GitHub user "${githubUser.username}" is not in the owners list for agent "${agentId}"`);
+			const agent = await getAgentByName(app.db, "default", name);
+			if (!(Array.isArray(agent.metadata?.owners) ? agent.metadata.owners : []).includes(githubUser.username)) throw new ForbiddenError(`GitHub user "${githubUser.username}" is not in the owners list for agent "${name}"`);
 			return {
 				exists: true,
 				status: agent.status
@@ -4580,34 +4602,35 @@ function verifySignature(secret, rawBody, signatureHeader) {
 	if (expectedBuf.length !== receivedBuf.length || !timingSafeEqual(expectedBuf, receivedBuf)) throw new UnauthorizedError("Invalid webhook signature");
 }
 async function ensureGitHubAdapterAgent(db) {
-	const [existing] = await db.select({ id: agents.id }).from(agents).where(eq(agents.id, GITHUB_ADAPTER_ID)).limit(1);
-	if (existing) return existing.id;
+	const [existing] = await db.select({ uuid: agents.uuid }).from(agents).where(and(eq(agents.organizationId, "default"), eq(agents.name, GITHUB_ADAPTER_ID))).limit(1);
+	if (existing) return existing.uuid;
 	try {
 		return (await createAgent(db, {
-			id: GITHUB_ADAPTER_ID,
+			name: GITHUB_ADAPTER_ID,
 			type: "autonomous_agent",
 			displayName: "GitHub Adapter",
 			metadata: {
 				source: "github",
 				managed: true
 			}
-		})).id;
+		})).uuid;
 	} catch (err) {
 		if (err instanceof ConflictError) {
-			const [created] = await db.select({ id: agents.id }).from(agents).where(eq(agents.id, GITHUB_ADAPTER_ID)).limit(1);
-			if (created) return created.id;
+			const [created] = await db.select({ uuid: agents.uuid }).from(agents).where(and(eq(agents.organizationId, "default"), eq(agents.name, GITHUB_ADAPTER_ID))).limit(1);
+			if (created) return created.uuid;
 		}
 		throw err;
 	}
 }
 async function findTargetAgent(db, repoFullName) {
 	const allAgents = await db.select({
-		id: agents.id,
+		id: agents.uuid,
+		name: agents.name,
 		metadata: agents.metadata,
 		type: agents.type
 	}).from(agents).where(eq(agents.status, "active"));
 	for (const agent of allAgents) {
-		if (agent.id === GITHUB_ADAPTER_ID) continue;
+		if (agent.name === GITHUB_ADAPTER_ID) continue;
 		const meta = agent.metadata;
 		if (meta && typeof meta === "object" && "github" in meta) {
 			const github = meta.github;
@@ -4642,27 +4665,29 @@ function extractMentions(text) {
 async function routeMentionDelegations(app, mentionedNames, ctx) {
 	if (mentionedNames.length === 0) return 0;
 	const delegates = await app.db.select({
-		id: agents.id,
+		id: agents.uuid,
+		name: agents.name,
 		delegateMention: agents.delegateMention,
 		status: agents.status
-	}).from(agents).where(and(inArray(agents.id, mentionedNames), isNotNull(agents.delegateMention)));
+	}).from(agents).where(and(inArray(agents.name, mentionedNames), isNotNull(agents.delegateMention)));
 	let routed = 0;
 	for (const agent of delegates) {
 		if (agent.status !== "active" || !agent.delegateMention) continue;
 		const [target] = await app.db.select({
-			id: agents.id,
+			id: agents.uuid,
 			status: agents.status
-		}).from(agents).where(eq(agents.id, agent.delegateMention)).limit(1);
+		}).from(agents).where(eq(agents.uuid, agent.delegateMention)).limit(1);
 		if (!target || target.status !== "active") {
-			app.log.warn(`delegate_mention target "${agent.delegateMention}" for "${agent.id}" is not active, skipping`);
+			app.log.warn(`delegate_mention target "${agent.delegateMention}" for "${agent.name}" is not active, skipping`);
 			continue;
 		}
 		try {
-			const { message: msg, recipients } = await sendToAgent(app.db, agent.id, agent.delegateMention, {
+			const chat = await findOrCreateDirectChat(app.db, agent.id, agent.delegateMention);
+			const { message: msg, recipients } = await sendMessage(app.db, chat.id, agent.id, {
 				format: "card",
 				content: {
 					type: "github_mention",
-					mentionedUser: agent.id,
+					mentionedUser: agent.name,
 					event: ctx.event,
 					repository: ctx.repository,
 					sender: ctx.sender,
@@ -4673,13 +4698,13 @@ async function routeMentionDelegations(app, mentionedNames, ctx) {
 				metadata: {
 					source: "github",
 					event: "mention_delegation",
-					mentionedUser: agent.id
+					mentionedUser: agent.name
 				}
 			});
 			notifyRecipients(app.notifier, recipients, msg.id);
 			routed++;
 		} catch (err) {
-			app.log.error(err, `Failed to route mention delegation from "${agent.id}" to "${agent.delegateMention}"`);
+			app.log.error(err, `Failed to route mention delegation from "${agent.name}" to "${agent.delegateMention}"`);
 		}
 	}
 	return routed;
@@ -4967,7 +4992,8 @@ async function handleIssuesEvent(app, eventType, payload, reply) {
 		event: "issues",
 		action: data.action
 	};
-	const { message: msg, recipients } = await sendToAgent(app.db, senderId, targetAgentId, {
+	const chat = await findOrCreateDirectChat(app.db, senderId, targetAgentId);
+	const { message: msg, recipients } = await sendMessage(app.db, chat.id, senderId, {
 		format: "card",
 		content,
 		metadata
@@ -5022,7 +5048,8 @@ async function handleIssueCommentEvent(app, eventType, payload, reply) {
 		event: "issue_comment",
 		action: data.action
 	};
-	const { message: msg, recipients } = await sendToAgent(app.db, senderId, targetAgentId, {
+	const chat = await findOrCreateDirectChat(app.db, senderId, targetAgentId);
+	const { message: msg, recipients } = await sendMessage(app.db, chat.id, senderId, {
 		format: "card",
 		content,
 		metadata
@@ -5096,10 +5123,11 @@ function agentAuthHook(db) {
 		const [tokenDetail] = await db.select({ expiresAt: agentTokens.expiresAt }).from(agentTokens).where(eq(agentTokens.id, tokenRow.tokenId)).limit(1);
 		if (tokenDetail?.expiresAt && tokenDetail.expiresAt < now) throw new UnauthorizedError("Token has expired");
 		const [agent] = await db.select({
-			id: agents.id,
+			uuid: agents.uuid,
+			name: agents.name,
 			organizationId: agents.organizationId,
 			inboxId: agents.inboxId
-		}).from(agents).where(and(eq(agents.id, tokenRow.agentId), eq(agents.status, "active"))).limit(1);
+		}).from(agents).where(and(eq(agents.uuid, tokenRow.agentId), eq(agents.status, "active"))).limit(1);
 		if (!agent) throw new UnauthorizedError("Agent is suspended or not found");
 		db.update(agentTokens).set({ lastUsedAt: now }).where(eq(agentTokens.id, tokenRow.tokenId)).then(() => {}, () => {});
 		request.agent = agent;
@@ -5458,10 +5486,10 @@ async function handleBindCommand(db, bot, event, agentId, log) {
 		return;
 	}
 	const [agent] = await db.select({
-		id: agents.id,
+		id: agents.uuid,
 		type: agents.type,
 		status: agents.status
-	}).from(agents).where(eq(agents.id, agentId)).limit(1);
+	}).from(agents).where(eq(agents.uuid, agentId)).limit(1);
 	if (!agent) {
 		await reply(`Agent "${agentId}" not found. Check the ID and try again.`);
 		return;
@@ -5517,7 +5545,7 @@ async function processFeishuOutbound(db, findBotByAgentId, log) {
     WHERE id IN (
       SELECT ie.id FROM inbox_entries ie
       JOIN agents a ON ie.inbox_id = a.inbox_id
-      JOIN adapter_agent_mappings aam ON a.id = aam.agent_id
+      JOIN adapter_agent_mappings aam ON a.uuid = aam.agent_id
       WHERE aam.platform = 'feishu' AND ie.status = 'pending'
       ORDER BY ie.created_at
       LIMIT ${OUTBOUND_BATCH_SIZE$1}
@@ -5708,8 +5736,8 @@ function createKaelRuntime(db, encryptionKey, kaelEndpoint, kaelApiKey, serverUr
 			}
 			const configs = await db.select().from(adapterConfigs).where(and(eq(adapterConfigs.platform, "kael"), eq(adapterConfigs.status, "active")));
 			const configAgentIds = configs.filter((c) => c.credentials).map((c) => c.agentId);
-			const agentRows = configAgentIds.length > 0 ? await db.execute(sql`SELECT id, inbox_id FROM agents WHERE id IN (${sql.join(configAgentIds.map((id) => sql`${id}`), sql`, `)}) AND status = 'active'`) : [];
-			const agentInboxMap = new Map(agentRows.map((a) => [a.id, a.inbox_id]));
+			const agentRows = configAgentIds.length > 0 ? await db.execute(sql`SELECT uuid, inbox_id FROM agents WHERE uuid IN (${sql.join(configAgentIds.map((id) => sql`${id}`), sql`, `)}) AND status = 'active'`) : [];
+			const agentInboxMap = new Map(agentRows.map((a) => [a.uuid, a.inbox_id]));
 			const seen = /* @__PURE__ */ new Set();
 			for (const config of configs) {
 				if (!config.credentials) continue;
@@ -5769,10 +5797,10 @@ function createKaelRuntime(db, encryptionKey, kaelEndpoint, kaelApiKey, serverUr
           WHERE id IN (
             SELECT ie.id FROM inbox_entries ie
             JOIN agents a ON ie.inbox_id = a.inbox_id
-            JOIN adapter_configs ac ON a.id = ac.agent_id
+            JOIN adapter_configs ac ON a.uuid = ac.agent_id
             WHERE ac.platform = 'kael' AND ac.status = 'active'
               AND ie.status = 'pending'
-              AND a.id IN (${sql.join(agentIds.map((id) => sql`${id}`), sql`, `)})
+              AND a.uuid IN (${sql.join(agentIds.map((id) => sql`${id}`), sql`, `)})
             ORDER BY ie.created_at
             LIMIT ${OUTBOUND_BATCH_SIZE}
             FOR UPDATE OF ie SKIP LOCKED