@agent-team-foundation/first-tree-hub 0.2.0 → 0.3.1

package/dist/{core-CD3xEbyB.mjs → core-D-c9r7D6.mjs}

@@ -1,13 +1,15 @@
+import { a as getGitHubUsername, b as serverConfigSchema, c as DEFAULT_CONFIG_DIR, d as clientConfigSchema, f as collectMissingPrompts, h as loadAgents, m as initConfig, r as checkBootstrapStatus, s as resolveServerUrl, t as bootstrapToken$1, u as agentConfigSchema, x as setConfigValue, y as resolveConfigReadonly } from "./bootstrap-B9JsJR3Z.mjs";
 import { ZodError, z } from "zod";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { parse, stringify } from "yaml";
+import { parse } from "yaml";
 import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
 import bcrypt from "bcrypt";
-import { and, desc, eq, inArray, isNotNull, isNull, lt, ne, sql } from "drizzle-orm";
+import { and, desc, eq, gt, inArray, isNotNull, isNull, lt, ne, sql } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
+import { execFileSync, execSync } from "node:child_process";
 import { EventEmitter } from "node:events";
 import WebSocket$1 from "ws";
 import { dirname as dirname$1, join as join$1 } from "path";
@@ -22,7 +24,6 @@ import { cwd } from "process";
 import * as r from "fs";
 import { realpathSync } from "fs";
 import { promisify } from "util";
-import { execFileSync, execSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import { input, password, select } from "@inquirer/prompts";
@@ -34,462 +35,6 @@ import Fastify from "fastify";
 import { bigserial, index, integer, jsonb, pgTable, primaryKey, serial, text, timestamp, unique } from "drizzle-orm/pg-core";
 import { SignJWT, jwtVerify } from "jose";
 import { Client, EventDispatcher, LoggerLevel, WSClient } from "@larksuiteoapi/node-sdk";
-//#region ../shared/dist/config/index.mjs
-/** Declare a config field with a Zod schema and optional metadata. */
-function field(schema, options) {
-	return {
-		_tag: "field",
-		_type: void 0,
-		schema,
-		options: options ?? {}
-	};
-}
-/** Mark a config group as optional — present only when at least one field has an explicit value. */
-function optional(shape) {
-	return {
-		_tag: "optional",
-		shape
-	};
-}
-/** Define a config shape. Identity function used for type inference. */
-function defineConfig(shape) {
-	return shape;
-}
-const agentConfigSchema = defineConfig({
-	token: field(z.string(), { secret: true }),
-	type: field(z.string().default("claude-code")),
-	cwd: field(z.string().optional()),
-	concurrency: field(z.number().int().positive().default(5)),
-	session: {
-		idle_timeout: field(z.number().int().positive().default(300)),
-		max_sessions: field(z.number().int().positive().default(10))
-	}
-});
-/** Store the resolved config as a singleton. Called by initConfig(). */
-function setConfig(config) {}
-/** Reset the config singleton. For testing only. */
-function resetConfig() {}
-const clientConfigSchema = defineConfig({
-	server: { url: field(z.string(), {
-		env: "FIRST_TREE_HUB_SERVER_URL",
-		prompt: {
-			message: "Server URL:",
-			default: "http://localhost:8000"
-		}
-	}) },
-	logLevel: field(z.enum([
-		"debug",
-		"info",
-		"warn",
-		"error"
-	]).default("info"), { env: "FIRST_TREE_HUB_LOG_LEVEL" })
-});
-const DEFAULT_CONFIG_DIR = join(homedir(), ".first-tree-hub");
-function isFieldDef(value) {
-	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "field";
-}
-function isOptionalGroup(value) {
-	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "optional";
-}
-function getByPath(obj, path) {
-	let current = obj;
-	for (const key of path) {
-		if (current === null || current === void 0 || typeof current !== "object") return;
-		current = current[key];
-	}
-	return current;
-}
-function setByPath(obj, path, value) {
-	let current = obj;
-	for (let i = 0; i < path.length - 1; i++) {
-		const key = path[i];
-		if (key === void 0) continue;
-		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
-		current = current[key];
-	}
-	const lastKey = path.at(-1);
-	if (lastKey !== void 0) current[lastKey] = value;
-}
-/** Unwrap ZodDefault / ZodOptional to get the inner type for coercion. */
-function unwrapZodType(schema) {
-	if (schema instanceof z.ZodDefault) return unwrapZodType(schema._def.innerType);
-	if (schema instanceof z.ZodOptional) return unwrapZodType(schema._def.innerType);
-	return schema;
-}
-/** Coerce a string env var to the JS type expected by the Zod schema. */
-function coerceEnvValue(value, schema) {
-	const inner = unwrapZodType(schema);
-	if (inner instanceof z.ZodNumber) {
-		const num = Number(value);
-		return Number.isNaN(num) ? value : num;
-	}
-	if (inner instanceof z.ZodBoolean) {
-		if (value === "true" || value === "1") return true;
-		if (value === "false" || value === "0") return false;
-		return value;
-	}
-	return value;
-}
-function builtinAutoGenerate(strategy) {
-	const match = /^random:(\w+):(\d+)$/.exec(strategy);
-	if (!match) throw new Error(`Unknown auto-generation strategy: ${strategy}`);
-	const encoding = match[1];
-	const bytes = Number(match[2]);
-	if (!encoding) throw new Error(`Invalid auto-generation strategy: ${strategy}`);
-	if (encoding === "base64url") return randomBytes(bytes).toString("base64url");
-	if (encoding === "hex") return randomBytes(bytes).toString("hex");
-	throw new Error(`Unknown random encoding: ${encoding}`);
-}
-function ensureDir(dir) {
-	if (!existsSync(dir)) mkdirSync(dir, {
-		recursive: true,
-		mode: 448
-	});
-}
-function deepMerge(target, source) {
-	const result = { ...target };
-	for (const [key, value] of Object.entries(source)) if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) result[key] = deepMerge(result[key], value);
-	else result[key] = value;
-	return result;
-}
-function deepFreeze(obj) {
-	if (typeof obj !== "object" || obj === null) return obj;
-	Object.freeze(obj);
-	for (const value of Object.values(obj)) deepFreeze(value);
-	return obj;
-}
-function collectFields(shape, path = [], optionalGroupPath = null) {
-	const fields = [];
-	for (const [key, value] of Object.entries(shape)) {
-		const currentPath = [...path, key];
-		if (isFieldDef(value)) fields.push({
-			path: currentPath,
-			fieldDef: value,
-			optionalGroupPath
-		});
-		else if (isOptionalGroup(value)) fields.push(...collectFields(value.shape, currentPath, currentPath));
-		else if (typeof value === "object" && value !== null) fields.push(...collectFields(value, currentPath, optionalGroupPath));
-	}
-	return fields;
-}
-/** Build a Zod object schema from the config shape for validation. */
-function buildZodSchema(shape) {
-	const zodShape = {};
-	for (const [key, value] of Object.entries(shape)) if (isFieldDef(value)) zodShape[key] = value.schema;
-	else if (isOptionalGroup(value)) zodShape[key] = buildZodSchema(value.shape).optional();
-	else if (typeof value === "object" && value !== null) zodShape[key] = buildZodSchema(value).default({});
-	return z.object(zodShape);
-}
-function resetConfigMeta() {}
-const CONFIG_HEADER = "# Generated by first-tree-hub. Edit as needed.\n# https://github.com/agent-team-foundation/first-tree-hub\n\n";
-/**
-* Initialize config from the priority chain:
-*   CLI args > env vars > YAML file > auto-generated > Zod defaults
-*
-* Auto-generated values are written back to the YAML file.
-* Result is frozen and stored as a singleton accessible via getConfig().
-*/
-async function initConfig(options) {
-	const { schema, role, cliArgs = {}, autoGenerators = {} } = options;
-	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
-	let fileValues = {};
-	if (existsSync(configPath)) {
-		const raw = parse(readFileSync(configPath, "utf-8"));
-		if (typeof raw === "object" && raw !== null) fileValues = raw;
-	}
-	const fields = collectFields(schema);
-	const resolved = {};
-	const meta = /* @__PURE__ */ new Map();
-	const autoGenerated = {};
-	const activeOptionalGroups = /* @__PURE__ */ new Set();
-	for (const { path, fieldDef, optionalGroupPath } of fields) {
-		if (!optionalGroupPath) continue;
-		const groupKey = optionalGroupPath.join(".");
-		if (activeOptionalGroups.has(groupKey)) continue;
-		if (getByPath(cliArgs, path) !== void 0) {
-			activeOptionalGroups.add(groupKey);
-			continue;
-		}
-		if (fieldDef.options.env) {
-			const envValue = process.env[fieldDef.options.env];
-			if (envValue !== void 0 && envValue !== "") {
-				activeOptionalGroups.add(groupKey);
-				continue;
-			}
-		}
-		if (getByPath(fileValues, path) !== void 0) activeOptionalGroups.add(groupKey);
-	}
-	for (const { path, fieldDef, optionalGroupPath } of fields) {
-		const dotPath = path.join(".");
-		if (optionalGroupPath && !activeOptionalGroups.has(optionalGroupPath.join("."))) continue;
-		const cliValue = getByPath(cliArgs, path);
-		if (cliValue !== void 0) {
-			setByPath(resolved, path, cliValue);
-			meta.set(dotPath, {
-				value: cliValue,
-				source: "cli",
-				secret: fieldDef.options.secret ?? false
-			});
-			continue;
-		}
-		if (fieldDef.options.env) {
-			const envValue = process.env[fieldDef.options.env];
-			if (envValue !== void 0 && envValue !== "") {
-				const coerced = coerceEnvValue(envValue, fieldDef.schema);
-				setByPath(resolved, path, coerced);
-				meta.set(dotPath, {
-					value: coerced,
-					source: "env",
-					secret: fieldDef.options.secret ?? false
-				});
-				continue;
-			}
-		}
-		const fileValue = getByPath(fileValues, path);
-		if (fileValue !== void 0) {
-			setByPath(resolved, path, fileValue);
-			meta.set(dotPath, {
-				value: fileValue,
-				source: "file",
-				secret: fieldDef.options.secret ?? false
-			});
-			continue;
-		}
-		if (fieldDef.options.auto) {
-			const strategy = fieldDef.options.auto;
-			const customGen = autoGenerators[strategy];
-			let generated;
-			if (customGen) generated = await customGen();
-			else generated = builtinAutoGenerate(strategy);
-			setByPath(resolved, path, generated);
-			setByPath(autoGenerated, path, generated);
-			meta.set(dotPath, {
-				value: generated,
-				source: "auto",
-				secret: fieldDef.options.secret ?? false
-			});
-			continue;
-		}
-		meta.set(dotPath, {
-			value: void 0,
-			source: "default",
-			secret: fieldDef.options.secret ?? false
-		});
-	}
-	const result = buildZodSchema(schema).safeParse(resolved);
-	if (!result.success) {
-		const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-		throw new Error(`Configuration validation failed:\n${issues}`);
-	}
-	const config = result.data;
-	for (const { path, fieldDef } of fields) {
-		const dotPath = path.join(".");
-		if (meta.get(dotPath)?.value === void 0) {
-			const val = getByPath(config, path);
-			if (val !== void 0) meta.set(dotPath, {
-				value: val,
-				source: "default",
-				secret: fieldDef.options.secret ?? false
-			});
-		}
-	}
-	if (Object.keys(autoGenerated).length > 0) {
-		const merged = deepMerge(fileValues, autoGenerated);
-		ensureDir(dirname(configPath));
-		writeFileSync(configPath, CONFIG_HEADER + stringify(merged), { mode: 384 });
-	}
-	const frozen = deepFreeze(config);
-	setConfig(frozen);
-	return frozen;
-}
-/** Set a value in a YAML config file by dot-path. */
-function setConfigValue(configPath, dotPath, value) {
-	let fileValues = {};
-	if (existsSync(configPath)) {
-		const raw = parse(readFileSync(configPath, "utf-8"));
-		if (typeof raw === "object" && raw !== null) fileValues = raw;
-	}
-	setByPath(fileValues, dotPath.split("."), value);
-	ensureDir(dirname(configPath));
-	writeFileSync(configPath, CONFIG_HEADER + stringify(fileValues), { mode: 384 });
-}
-/** Get a value from a YAML config file by dot-path. */
-function getConfigValue(configPath, dotPath) {
-	if (!existsSync(configPath)) return void 0;
-	const raw = parse(readFileSync(configPath, "utf-8"));
-	if (typeof raw !== "object" || raw === null) return void 0;
-	return getByPath(raw, dotPath.split("."));
-}
-/** Read all values from a YAML config file. */
-function readConfigFile(configPath) {
-	if (!existsSync(configPath)) return {};
-	const raw = parse(readFileSync(configPath, "utf-8"));
-	if (typeof raw !== "object" || raw === null) return {};
-	return raw;
-}
-/**
-* Scan a config schema and return fields that:
-* 1. Have a `prompt` definition
-* 2. Don't have a value from CLI args, env vars, or the config file
-* 3. Don't have an `auto` strategy (auto-gen fields don't need prompting)
-*
-* Used by CLI to show interactive prompts before calling initConfig().
-*/
-function collectMissingPrompts(options) {
-	const { schema, role, cliArgs = {} } = options;
-	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
-	let fileValues = {};
-	if (existsSync(configPath)) {
-		const raw = parse(readFileSync(configPath, "utf-8"));
-		if (typeof raw === "object" && raw !== null) fileValues = raw;
-	}
-	const fields = collectFields(schema);
-	const missing = [];
-	for (const { path, fieldDef, optionalGroupPath } of fields) {
-		if (optionalGroupPath) continue;
-		if (!fieldDef.options.prompt) continue;
-		if (getByPath(cliArgs, path) !== void 0) continue;
-		if (fieldDef.options.env) {
-			const envValue = process.env[fieldDef.options.env];
-			if (envValue !== void 0 && envValue !== "") continue;
-		}
-		if (getByPath(fileValues, path) !== void 0) continue;
-		missing.push({
-			dotPath: path.join("."),
-			prompt: fieldDef.options.prompt
-		});
-	}
-	return missing;
-}
-/**
-* Resolve config values through the same priority chain as initConfig()
-* (env vars > YAML file > Zod defaults), but **without side effects**:
-* - No auto-generation
-* - No file writes
-* - No singleton mutation
-* - Partial results (unresolvable fields are omitted, no validation error)
-*
-* Returns the best-effort resolved config as a plain object.
-*/
-function resolveConfigReadonly(options) {
-	const { schema, role } = options;
-	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${role}.yaml`);
-	let fileValues = {};
-	if (existsSync(configPath)) {
-		const raw = parse(readFileSync(configPath, "utf-8"));
-		if (typeof raw === "object" && raw !== null) fileValues = raw;
-	}
-	const fields = collectFields(schema);
-	const resolved = {};
-	for (const { path, fieldDef } of fields) {
-		if (fieldDef.options.env) {
-			const envValue = process.env[fieldDef.options.env];
-			if (envValue !== void 0 && envValue !== "") {
-				setByPath(resolved, path, coerceEnvValue(envValue, fieldDef.schema));
-				continue;
-			}
-		}
-		const fileValue = getByPath(fileValues, path);
-		if (fileValue !== void 0) {
-			setByPath(resolved, path, fileValue);
-			continue;
-		}
-		const defaultResult = fieldDef.schema.safeParse(void 0);
-		if (defaultResult.success && defaultResult.data !== void 0) setByPath(resolved, path, defaultResult.data);
-	}
-	return resolved;
-}
-/**
-* Scan an agents directory and load each agent's config.
-*
-* Expected structure:
-*   {agentsDir}/
-*     code-reviewer/agent.yaml
-*     scheduler/agent.yaml
-*
-* Returns a Map keyed by directory name (agent name).
-*/
-function loadAgents(options) {
-	const { schema, agentsDir } = options;
-	const result = /* @__PURE__ */ new Map();
-	if (!existsSync(agentsDir)) return result;
-	const zodSchema = buildZodSchema(schema);
-	for (const entry of readdirSync(agentsDir)) {
-		const agentDir = join(agentsDir, entry);
-		if (!statSync(agentDir).isDirectory()) continue;
-		const configPath = join(agentDir, "agent.yaml");
-		if (!existsSync(configPath)) continue;
-		const raw = parse(readFileSync(configPath, "utf-8"));
-		const parsed = zodSchema.parse(raw);
-		result.set(entry, parsed);
-	}
-	return result;
-}
-const serverConfigSchema = defineConfig({
-	database: {
-		url: field(z.string(), {
-			env: "FIRST_TREE_HUB_DATABASE_URL",
-			auto: "docker-pg",
-			prompt: {
-				message: "PostgreSQL:",
-				type: "select",
-				choices: [{
-					name: "Auto-provision via Docker",
-					value: "__auto__"
-				}, {
-					name: "Provide connection URL",
-					value: "__input__"
-				}]
-			}
-		}),
-		provider: field(z.enum(["docker", "external"]).default("docker"))
-	},
-	server: {
-		port: field(z.number().default(8e3), { env: "FIRST_TREE_HUB_PORT" }),
-		host: field(z.string().default("127.0.0.1"), { env: "FIRST_TREE_HUB_HOST" })
-	},
-	secrets: {
-		jwtSecret: field(z.string(), {
-			env: "FIRST_TREE_HUB_JWT_SECRET",
-			auto: "random:base64url:32",
-			secret: true
-		}),
-		encryptionKey: field(z.string(), {
-			env: "FIRST_TREE_HUB_ENCRYPTION_KEY",
-			auto: "random:hex:32",
-			secret: true
-		})
-	},
-	contextTree: {
-		repo: field(z.string(), {
-			env: "FIRST_TREE_HUB_CONTEXT_TREE_REPO",
-			prompt: { message: "Context Tree repo URL (e.g. https://github.com/org/first-tree):" }
-		}),
-		branch: field(z.string().default("main")),
-		syncInterval: field(z.number().default(60))
-	},
-	github: {
-		token: field(z.string(), {
-			env: "FIRST_TREE_HUB_GITHUB_TOKEN",
-			secret: true,
-			prompt: {
-				message: "GitHub token (create at https://github.com/settings/tokens → repo scope):",
-				type: "password"
-			}
-		}),
-		webhookSecret: field(z.string().optional(), {
-			env: "FIRST_TREE_HUB_GITHUB_WEBHOOK_SECRET",
-			secret: true
-		})
-	},
-	cors: optional({ origin: field(z.string(), { env: "FIRST_TREE_HUB_CORS_ORIGIN" }) }),
-	rateLimit: optional({
-		max: field(z.number().default(100), { env: "FIRST_TREE_HUB_RATE_LIMIT_MAX" }),
-		loginMax: field(z.number().default(5), { env: "FIRST_TREE_HUB_RATE_LIMIT_LOGIN_MAX" }),
-		webhookMax: field(z.number().default(60), { env: "FIRST_TREE_HUB_RATE_LIMIT_WEBHOOK_MAX" })
-	})
-});
-//#endregion
 //#region src/core/admin.ts
 /**
 * Check if any admin user exists.
@@ -22846,6 +22391,7 @@ function Aa({ prompt: $, options: X }) {
 }
 //#endregion
 //#region ../client/dist/index.mjs
+const FETCH_TIMEOUT_MS = 15e3;
 var FirstTreeHubSDK = class {
 	_baseUrl;
 	_token;
@@ -22868,9 +22414,16 @@ var FirstTreeHubSDK = class {
 			agentId: agent.id,
 			inboxId: agent.inboxId,
 			status: agent.status,
-			displayName: agent.displayName
+			displayName: agent.displayName,
+			type: agent.type,
+			delegateMention: agent.delegateMention ?? null,
+			metadata: agent.metadata ?? {}
 		};
 	}
+	/** Fetch Context Tree configuration from the server. */
+	async getContextTreeConfig() {
+		return this.requestJson("/api/v1/agent/context-tree");
+	}
 	/** Fetch pending inbox entries. */
 	async pull(limit = 10) {
 		return { entries: await this.requestJson(`/api/v1/agent/inbox?limit=${limit}`) };
@@ -22925,9 +22478,12 @@ var FirstTreeHubSDK = class {
 		const url = `${this._baseUrl}${path}`;
 		const headers = { Authorization: `Bearer ${this._token}` };
 		if (init?.body) headers["Content-Type"] = "application/json";
+		const timeout = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+		const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
 		return fetch(url, {
 			...init,
-			headers
+			headers,
+			signal
 		});
 	}
 	async toSdkError(response) {
@@ -22952,12 +22508,16 @@ const DEFAULT_POLLING_INTERVAL = 5e3;
 const DEFAULT_PULL_LIMIT = 10;
 const RECONNECT_BASE_MS = 1e3;
 const RECONNECT_MAX_MS = 3e4;
+const WS_CONNECT_TIMEOUT_MS = 1e4;
+const WS_PING_INTERVAL_MS = 3e3;
 var AgentConnection = class extends EventEmitter {
 	sdk;
 	_state = "disconnected";
 	_agent = null;
 	handler = null;
 	ws = null;
+	wsConnectTimer = null;
+	wsPingTimer = null;
 	pollingTimer = null;
 	reconnectTimer = null;
 	reconnectAttempt = 0;
@@ -22968,6 +22528,7 @@ var AgentConnection = class extends EventEmitter {
 	pollingInterval;
 	pullLimit;
 	serverUrl;
+	rateLimitedUntil = 0;
 	constructor(config) {
 		super();
 		this.serverUrl = config.serverUrl.replace(/\/+$/, "");
@@ -23010,10 +22571,19 @@ var AgentConnection = class extends EventEmitter {
 	}
 	openWebSocket() {
 		const ws = new WebSocket$1(`${this.serverUrl.replace(/^http/, "ws")}/api/v1/agent/ws/inbox`, { headers: { Authorization: `Bearer ${this.token}` } });
+		this.wsConnectTimer = setTimeout(() => {
+			this.wsConnectTimer = null;
+			if (ws.readyState === WebSocket$1.CONNECTING) ws.terminate();
+		}, WS_CONNECT_TIMEOUT_MS);
 		ws.on("open", () => {
+			if (this.wsConnectTimer) {
+				clearTimeout(this.wsConnectTimer);
+				this.wsConnectTimer = null;
+			}
 			this.reconnectAttempt = 0;
 			this._state = "connected";
 			this.emit("connected");
+			this.startPing();
 			this.startPolling();
 			this.pullAndDispatch();
 		});
@@ -23023,14 +22593,17 @@ var AgentConnection = class extends EventEmitter {
 			} catch {}
 		});
 		ws.on("close", () => {
+			this.stopPing();
 			if (!this.closing) this.scheduleReconnect();
 		});
 		ws.on("error", (err) => {
+			if (this.handleRateLimit(err)) return;
 			this.emit("error", err);
 		});
 		this.ws = ws;
 	}
 	scheduleReconnect() {
+		if (Date.now() < this.rateLimitedUntil) return;
 		this._state = "reconnecting";
 		this.reconnectAttempt++;
 		this.emit("reconnecting", this.reconnectAttempt);
@@ -23041,6 +22614,18 @@ var AgentConnection = class extends EventEmitter {
 			if (!this.closing) this.openWebSocket();
 		}, delay);
 	}
+	startPing() {
+		this.stopPing();
+		this.wsPingTimer = setInterval(() => {
+			if (this.ws?.readyState === WebSocket$1.OPEN) this.ws.ping();
+		}, WS_PING_INTERVAL_MS);
+	}
+	stopPing() {
+		if (this.wsPingTimer) {
+			clearInterval(this.wsPingTimer);
+			this.wsPingTimer = null;
+		}
+	}
 	startPolling() {
 		if (this.pollingTimer) return;
 		this.pollingTimer = setInterval(() => {
@@ -23055,6 +22640,7 @@ var AgentConnection = class extends EventEmitter {
 	}
 	async pullAndDispatch() {
 		if (this.closing || !this.handler) return;
+		if (Date.now() < this.rateLimitedUntil) return;
 		if (this.isPulling) {
 			this.pullAgain = true;
 			return;
@@ -23074,13 +22660,42 @@ var AgentConnection = class extends EventEmitter {
 				}
 			} while (this.pullAgain && !this.closing);
 		} catch (err) {
+			if (this.handleRateLimit(err)) return;
 			this.emit("error", err instanceof Error ? err : new Error(String(err)));
 		} finally {
 			this.isPulling = false;
 		}
 	}
+	/** Detect 429 responses and pause all activity. Returns true if rate-limited. */
+	handleRateLimit(err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (!msg.includes("429") && !msg.toLowerCase().includes("rate limit")) return false;
+		const backoff = 6e4;
+		this.rateLimitedUntil = Date.now() + backoff;
+		this.emit("error", /* @__PURE__ */ new Error(`Rate limited, pausing for ${backoff / 1e3}s`));
+		this.stopPolling();
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		setTimeout(() => {
+			if (this.closing) return;
+			this.rateLimitedUntil = 0;
+			this.startPolling();
+			if (!this.ws || this.ws.readyState !== WebSocket$1.OPEN) {
+				this.reconnectAttempt = 0;
+				this.openWebSocket();
+			}
+		}, backoff);
+		return true;
+	}
 	clearTimers() {
 		this.stopPolling();
+		this.stopPing();
+		if (this.wsConnectTimer) {
+			clearTimeout(this.wsConnectTimer);
+			this.wsConnectTimer = null;
+		}
 		if (this.reconnectTimer) {
 			clearTimeout(this.reconnectTimer);
 			this.reconnectTimer = null;
@@ -23102,40 +22717,335 @@ function getHandlerFactory(type) {
 	}
 	return factory;
 }
-/**
-* InputController — push-based async iterable bridge.
-*
-* Bridges imperative `push()` calls to the `AsyncIterable` that
-* the Agent SDK `query()` expects as streaming input.
-*/
-var InputController = class {
-	buffer = [];
-	waiter = null;
-	done = false;
-	/** Push a message for the consumer. Buffered if consumer is busy. */
-	push(value) {
-		if (this.done) return;
-		if (this.waiter) {
-			const resolve = this.waiter;
-			this.waiter = null;
-			resolve({
-				value,
-				done: false
-			});
-		} else this.buffer.push(value);
+/** Declare a config field with a Zod schema and optional metadata. */
+function field(schema, options) {
+	return {
+		_tag: "field",
+		_type: void 0,
+		schema,
+		options: options ?? {}
+	};
+}
+/** Mark a config group as optional — present only when at least one field has an explicit value. */
+function optional(shape) {
+	return {
+		_tag: "optional",
+		shape
+	};
+}
+/** Define a config shape. Identity function used for type inference. */
+function defineConfig(shape) {
+	return shape;
+}
+defineConfig({
+	token: field(z.string(), { secret: true }),
+	type: field(z.string().default("claude-code")),
+	concurrency: field(z.number().int().positive().default(5)),
+	session: {
+		idle_timeout: field(z.number().int().positive().default(300)),
+		max_sessions: field(z.number().int().positive().default(10))
 	}
-	/** Signal no more messages will be sent. */
-	end() {
-		if (this.done) return;
-		this.done = true;
-		if (this.waiter) {
-			const resolve = this.waiter;
-			this.waiter = null;
-			resolve({
-				value: void 0,
-				done: true
-			});
-		}
+});
+defineConfig({
+	server: { url: field(z.string(), {
+		env: "FIRST_TREE_HUB_SERVER_URL",
+		prompt: {
+			message: "Server URL:",
+			default: "http://localhost:8000"
+		}
+	}) },
+	logLevel: field(z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]).default("info"), { env: "FIRST_TREE_HUB_LOG_LEVEL" })
+});
+const DEFAULT_HOME_DIR = join(homedir(), ".first-tree-hub");
+join(DEFAULT_HOME_DIR, "config");
+const DEFAULT_DATA_DIR = join(DEFAULT_HOME_DIR, "data");
+defineConfig({
+	database: {
+		url: field(z.string(), {
+			env: "FIRST_TREE_HUB_DATABASE_URL",
+			auto: "docker-pg",
+			prompt: {
+				message: "PostgreSQL:",
+				type: "select",
+				choices: [{
+					name: "Auto-provision via Docker",
+					value: "__auto__"
+				}, {
+					name: "Provide connection URL",
+					value: "__input__"
+				}]
+			}
+		}),
+		provider: field(z.enum(["docker", "external"]).default("docker"))
+	},
+	server: {
+		port: field(z.number().default(8e3), { env: "FIRST_TREE_HUB_PORT" }),
+		host: field(z.string().default("127.0.0.1"), { env: "FIRST_TREE_HUB_HOST" })
+	},
+	secrets: {
+		jwtSecret: field(z.string(), {
+			env: "FIRST_TREE_HUB_JWT_SECRET",
+			auto: "random:base64url:32",
+			secret: true
+		}),
+		encryptionKey: field(z.string(), {
+			env: "FIRST_TREE_HUB_ENCRYPTION_KEY",
+			auto: "random:hex:32",
+			secret: true
+		})
+	},
+	contextTree: {
+		repo: field(z.string(), {
+			env: "FIRST_TREE_HUB_CONTEXT_TREE_REPO",
+			prompt: { message: "Context Tree repo URL (e.g. https://github.com/org/first-tree):" }
+		}),
+		branch: field(z.string().default("main")),
+		syncInterval: field(z.number().default(60))
+	},
+	github: {
+		token: field(z.string(), {
+			env: "FIRST_TREE_HUB_GITHUB_TOKEN",
+			secret: true,
+			prompt: {
+				message: "GitHub token (create at https://github.com/settings/tokens → repo scope):",
+				type: "password"
+			}
+		}),
+		webhookSecret: field(z.string().optional(), {
+			env: "FIRST_TREE_HUB_GITHUB_WEBHOOK_SECRET",
+			secret: true
+		})
+	},
+	cors: optional({ origin: field(z.string(), { env: "FIRST_TREE_HUB_CORS_ORIGIN" }) }),
+	rateLimit: optional({
+		max: field(z.number().default(100), { env: "FIRST_TREE_HUB_RATE_LIMIT_MAX" }),
+		loginMax: field(z.number().default(5), { env: "FIRST_TREE_HUB_RATE_LIMIT_LOGIN_MAX" }),
+		webhookMax: field(z.number().default(60), { env: "FIRST_TREE_HUB_RATE_LIMIT_WEBHOOK_MAX" })
+	})
+});
+const CONTEXT_TREE_DIR$1 = join(DEFAULT_DATA_DIR, "context-tree");
+/**
+* Sync the shared Context Tree git clone.
+*
+* Clones on first run, pulls on subsequent runs.
+* Returns the clone path on success, null on failure (graceful degradation).
+*/
+async function syncContextTree(serverUrl, token, log) {
+	try {
+		execFileSync("git", ["--version"], { stdio: "ignore" });
+	} catch {
+		log("Context Tree sync skipped: git is not installed");
+		return null;
+	}
+	let repo;
+	let branch;
+	try {
+		const config = await new FirstTreeHubSDK({
+			serverUrl,
+			token
+		}).getContextTreeConfig();
+		repo = config.repo;
+		branch = config.branch;
+	} catch (err) {
+		log(`Context Tree sync skipped: failed to fetch config from server (${err instanceof Error ? err.message : String(err)})`);
+		return null;
+	}
+	try {
+		if (existsSync(join(CONTEXT_TREE_DIR$1, ".git"))) {
+			if (execFileSync("git", [
+				"rev-parse",
+				"--abbrev-ref",
+				"HEAD"
+			], {
+				cwd: CONTEXT_TREE_DIR$1,
+				encoding: "utf-8",
+				timeout: 5e3
+			}).trim() !== branch) {
+				execFileSync("git", ["checkout", branch], {
+					cwd: CONTEXT_TREE_DIR$1,
+					stdio: "pipe",
+					timeout: 1e4
+				});
+				log(`Context Tree switched to branch ${branch}`);
+			}
+			execFileSync("git", ["pull", "--ff-only"], {
+				cwd: CONTEXT_TREE_DIR$1,
+				stdio: "pipe",
+				timeout: 3e4
+			});
+			log(`Context Tree updated (pull)`);
+		} else {
+			mkdirSync(CONTEXT_TREE_DIR$1, { recursive: true });
+			execFileSync("git", [
+				"clone",
+				"--branch",
+				branch,
+				"--single-branch",
+				repo,
+				CONTEXT_TREE_DIR$1
+			], {
+				stdio: "pipe",
+				timeout: 6e4
+			});
+			log(`Context Tree cloned from ${repo} (branch: ${branch})`);
+		}
+		return CONTEXT_TREE_DIR$1;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		log(`Context Tree sync failed: ${msg}`);
+		log("Check that git credentials (SSH key or credential helper) are configured for this repo");
+		if ((msg.includes("cannot fast-forward") || msg.includes("not possible to fast-forward") || msg.includes("CONFLICT")) && existsSync(join(CONTEXT_TREE_DIR$1, ".git"))) {
+			log("Diverged history detected, attempting fresh clone...");
+			try {
+				rmSync(CONTEXT_TREE_DIR$1, {
+					recursive: true,
+					force: true
+				});
+				mkdirSync(CONTEXT_TREE_DIR$1, { recursive: true });
+				execFileSync("git", [
+					"clone",
+					"--branch",
+					branch,
+					"--single-branch",
+					repo,
+					CONTEXT_TREE_DIR$1
+				], {
+					stdio: "pipe",
+					timeout: 6e4
+				});
+				log("Context Tree re-cloned successfully");
+				return CONTEXT_TREE_DIR$1;
+			} catch {
+				log("Context Tree re-clone also failed, continuing without context");
+			}
+		}
+		if (existsSync(join(CONTEXT_TREE_DIR$1, ".git"))) {
+			log("Using existing Context Tree clone despite sync failure");
+			return CONTEXT_TREE_DIR$1;
+		}
+		return null;
+	}
+}
+/**
+* Bootstrap a workspace with .agent/ directory files.
+*
+* Writes identity.json, context/self.md (if context tree available), and tools.md.
+* Designed to be called on every handler start() and conditionally on resume().
+*/
+function bootstrapWorkspace(options) {
+	const { workspacePath, identity, contextTreePath, serverUrl, chatId } = options;
+	const agentDir = join(workspacePath, ".agent");
+	const contextDir = join(agentDir, "context");
+	if (existsSync(contextDir)) rmSync(contextDir, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(contextDir, { recursive: true });
+	const identityData = {
+		agentId: identity.agentId,
+		displayName: identity.displayName,
+		type: identity.type,
+		delegateMention: identity.delegateMention,
+		metadata: identity.metadata,
+		chatId,
+		serverUrl,
+		contextTreePath
+	};
+	writeFileSync(join(agentDir, "identity.json"), JSON.stringify(identityData, null, 2), "utf-8");
+	if (contextTreePath) {
+		const selfNodePath = join(contextTreePath, "members", identity.agentId, "NODE.md");
+		if (existsSync(selfNodePath)) copyFileSync(selfNodePath, join(contextDir, "self.md"));
+		const agentMdPath = join(contextTreePath, "AGENT.md");
+		if (existsSync(agentMdPath)) copyFileSync(agentMdPath, join(contextDir, "agent-instructions.md"));
+		const rootNodePath = join(contextTreePath, "NODE.md");
+		if (existsSync(rootNodePath)) copyFileSync(rootNodePath, join(contextDir, "domain-map.md"));
+	} else writeFileSync(join(contextDir, "degraded.md"), "Context Tree is not available for this session.\nOrganizational context, domain structure, and ownership information are not loaded.\n", "utf-8");
+	writeFileSync(join(agentDir, "tools.md"), generateToolsDoc(), "utf-8");
+}
+function generateToolsDoc() {
+	return `# Agent Hub SDK
+
+## How You Communicate
+
+You are running inside **Agent Hub**, a messaging platform for agent teams.
+
+- Messages from other team members arrive as your prompt input
+- Each message includes a \`[From: sender-id]\` header so you know who sent it
+- **Your final text response is automatically delivered** to the chat — just respond normally
+- For **proactive communication** (sending to other agents, other chats, or structured data),
+  use the curl API endpoints below
+- **Use your judgment about when to respond.** Not every message requires a reply.
+  Your role and responsibilities (defined in your profile above) guide your behavior
+
+## Environment Variables
+
+These are injected automatically when the agent process starts:
+
+| Variable | Description |
+|----------|-------------|
+| \`FIRST_TREE_HUB_SERVER_URL\` | Server address for API calls |
+| \`FIRST_TREE_HUB_AGENT_TOKEN\` | Bearer token for authentication |
+| \`FIRST_TREE_HUB_CHAT_ID\` | Current chat context ID |
+| \`FIRST_TREE_HUB_AGENT_ID\` | Your agent ID |
+
+## Sending Messages
+
+Use curl or any HTTP client with the bearer token:
+
+\`\`\`bash
+# Reply in current chat
+curl -X POST "$FIRST_TREE_HUB_SERVER_URL/api/v1/agent/chats/$FIRST_TREE_HUB_CHAT_ID/messages" \\
+  -H "Authorization: Bearer $FIRST_TREE_HUB_AGENT_TOKEN" \\
+  -H "Content-Type: application/json" \\
+  -d '{"format": "text", "content": "your message"}'
+
+# Send to another agent directly
+curl -X POST "$FIRST_TREE_HUB_SERVER_URL/api/v1/agent/agents/{agentId}/messages" \\
+  -H "Authorization: Bearer $FIRST_TREE_HUB_AGENT_TOKEN" \\
+  -H "Content-Type: application/json" \\
+  -d '{"format": "text", "content": "your message"}'
+\`\`\`
+`;
+}
+/**
+* InputController — push-based async iterable bridge.
+*
+* Bridges imperative `push()` calls to the `AsyncIterable` that
+* the Agent SDK `query()` expects as streaming input.
+*/
+var InputController = class {
+	buffer = [];
+	waiter = null;
+	done = false;
+	/** Push a message for the consumer. Buffered if consumer is busy. */
+	push(value) {
+		if (this.done) return;
+		if (this.waiter) {
+			const resolve = this.waiter;
+			this.waiter = null;
+			resolve({
+				value,
+				done: false
+			});
+		} else this.buffer.push(value);
+	}
+	/** Signal no more messages will be sent. */
+	end() {
+		if (this.done) return;
+		this.done = true;
+		if (this.waiter) {
+			const resolve = this.waiter;
+			this.waiter = null;
+			resolve({
+				value: void 0,
+				done: true
+			});
+		}
 	}
 	/** The async iterable consumed by `query()`. */
 	get iterable() {
@@ -23156,6 +23066,46 @@ var InputController = class {
 		});
 	}
 };
+const DEFAULT_WORKSPACE_TTL_MS = 10080 * 60 * 1e3;
+/**
+* Acquire a per-chat workspace directory.
+* Creates the directory if it does not exist; returns the path if it does.
+*/
+function acquireWorkspace(workspaceRoot, chatId) {
+	const dir = join(workspaceRoot, chatId);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/**
+* Clean stale workspace directories for an agent.
+*
+* A workspace is considered stale when:
+* 1. Its mtime is older than `ttlMs`
+* 2. Its chatId is NOT in the `activeChatIds` set
+*
+* Returns the list of removed chatIds.
+*/
+function cleanWorkspaces(workspaceRoot, activeChatIds, ttlMs = DEFAULT_WORKSPACE_TTL_MS) {
+	if (!existsSync(workspaceRoot)) return [];
+	const now = Date.now();
+	const removed = [];
+	for (const entry of readdirSync(workspaceRoot)) {
+		if (activeChatIds.has(entry)) continue;
+		const entryPath = join(workspaceRoot, entry);
+		try {
+			const stat = statSync(entryPath);
+			if (!stat.isDirectory()) continue;
+			if (now - stat.mtimeMs > ttlMs) {
+				rmSync(entryPath, {
+					recursive: true,
+					force: true
+				});
+				removed.push(entry);
+			}
+		} catch {}
+	}
+	return removed;
+}
 const MAX_RETRIES = 2;
 /**
 * Claude Code Handler — session-oriented handler using the Agent SDK.
@@ -23165,7 +23115,8 @@ const MAX_RETRIES = 2;
 * and session resume from disk for idle reclaim recovery.
 */
 const createClaudeCodeHandler = (config) => {
-	const cwd = config.cwd;
+	const workspaceRoot = config.workspaceRoot;
+	let cwd = null;
 	let claudeSessionId = null;
 	let currentQuery = null;
 	let inputController = null;
@@ -23174,19 +23125,35 @@ const createClaudeCodeHandler = (config) => {
 	let retryCount = 0;
 	let ctx = null;
 	function toSDKUserMessage(message, sessionId) {
+		const rawContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
 		return {
 			type: "user",
 			message: {
 				role: "user",
-				content: typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+				content: message.senderId ? `[From: ${message.senderId}]\n\n${rawContent}` : rawContent
 			},
 			parent_tool_use_id: null,
 			session_id: sessionId
 		};
 	}
+	/**
+	* Build env for the child Claude Code process.
+	*
+	* When the client runtime runs inside a Claude Code session (nested env),
+	* process.env contains internal markers (CLAUDECODE, CLAUDE_CODE_ENTRYPOINT,
+	* CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS, npm_lifecycle_script) that cause the
+	* child to enable Agent Teams infrastructure and use wrong init paths,
+	* resulting in ~90s cold start vs ~17s standalone. Strip these so the child
+	* starts clean; the SDK sets its own CLAUDE_CODE_ENTRYPOINT="sdk-ts".
+	*/
 	function buildEnv(sessionCtx) {
+		const env = { ...process.env };
+		delete env.CLAUDECODE;
+		delete env.CLAUDE_CODE_ENTRYPOINT;
+		delete env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+		delete env.npm_lifecycle_script;
 		return {
-			...process.env,
+			...env,
 			FIRST_TREE_HUB_SERVER_URL: sessionCtx.sdk.serverUrl,
 			FIRST_TREE_HUB_AGENT_TOKEN: sessionCtx.sdk.agentToken,
 			FIRST_TREE_HUB_CHAT_ID: sessionCtx.chatId,
@@ -23211,7 +23178,7 @@ const createClaudeCodeHandler = (config) => {
 			options: {
 				sessionId: resume ? void 0 : sessionId,
 				resume,
-				cwd,
+				cwd: cwd ?? void 0,
 				persistSession: true,
 				abortController,
 				permissionMode,
@@ -23228,10 +23195,15 @@ const createClaudeCodeHandler = (config) => {
 					sessionCtx.touch();
 					if (message.type === "result") {
 						const result = message;
-						if (result.subtype === "success") retryCount = 0;
-						else {
+						if (result.subtype === "success") {
+							retryCount = 0;
+							if (result.result && sessionCtx.chatId) sessionCtx.sdk.sendMessage(sessionCtx.chatId, {
+								format: "text",
+								content: result.result
+							}).then(() => sessionCtx.log("Result forwarded to chat")).catch((err) => sessionCtx.log(`Failed to forward result: ${err instanceof Error ? err.message : String(err)}`));
+						} else {
 							const errors = result.errors ? result.errors.join("; ") : result.subtype;
-							sessionCtx.log(`Query result error: ${errors}`);
+							sessionCtx.log(`Query result error: ${errors} (subtype=${result.subtype}, turns=${result.num_turns ?? "?"}, duration=${result.duration_ms ?? "?"}ms)`);
 						}
 					}
 				}
@@ -23239,6 +23211,13 @@ const createClaudeCodeHandler = (config) => {
 			} catch (err) {
 				const errMsg = err instanceof Error ? err.message : String(err);
 				sessionCtx.log(`Query error: ${errMsg}`);
+				if (err instanceof Error) {
+					if (err.cause) sessionCtx.log(`  cause: ${err.cause instanceof Error ? err.cause.message : String(err.cause)}`);
+					if ("exitCode" in err) sessionCtx.log(`  exitCode: ${err.exitCode}`);
+					if ("stderr" in err) sessionCtx.log(`  stderr: ${err.stderr}`);
+					if ("code" in err) sessionCtx.log(`  code: ${err.code}`);
+					if (err.stack) sessionCtx.log(`  stack: ${err.stack.split("\n").slice(1, 4).join(" | ")}`);
+				}
 				if (retryCount >= MAX_RETRIES || !claudeSessionId) {
 					sessionCtx.log("Exhausted retries, session will be suspended");
 					return;
@@ -23254,12 +23233,28 @@ const createClaudeCodeHandler = (config) => {
 			}
 		}
 	}
+	const contextTreePath = config.contextTreePath ?? null;
+	/** Bootstrap workspace and generate CLAUDE.md. */
+	function runBootstrap(workspace, sessionCtx) {
+		bootstrapWorkspace({
+			workspacePath: workspace,
+			identity: sessionCtx.agent,
+			contextTreePath,
+			serverUrl: sessionCtx.sdk.serverUrl,
+			chatId: sessionCtx.chatId
+		});
+		generateClaudeMd(workspace, sessionCtx.agent, contextTreePath);
+	}
 	const handler = {
 		async start(message, sessionCtx) {
 			ctx = sessionCtx;
 			claudeSessionId = randomUUID();
+			cwd = acquireWorkspace(workspaceRoot, sessionCtx.chatId);
+			runBootstrap(cwd, sessionCtx);
+			sessionCtx.log(`Starting session (${claudeSessionId}), cwd=${cwd}, permissionMode=${config.permissionMode ?? "bypassPermissions"}`);
 			spawnQuery(claudeSessionId, sessionCtx);
-			inputController?.push(toSDKUserMessage(message, claudeSessionId));
+			const sdkMsg = toSDKUserMessage(message, claudeSessionId);
+			inputController?.push(sdkMsg);
 			sessionCtx.log(`Session started (${claudeSessionId})`);
 			return claudeSessionId;
 		},
@@ -23267,6 +23262,9 @@ const createClaudeCodeHandler = (config) => {
 			ctx = sessionCtx;
 			claudeSessionId = sessionId;
 			retryCount = 0;
+			cwd = acquireWorkspace(workspaceRoot, sessionCtx.chatId);
+			if (!existsSync(join(cwd, ".agent", "identity.json"))) runBootstrap(cwd, sessionCtx);
+			sessionCtx.log(`Resuming session (${sessionId}), cwd=${cwd}`);
 			spawnQuery(sessionId, sessionCtx, sessionId);
 			inputController?.push(toSDKUserMessage(message, sessionId));
 			sessionCtx.log(`Session resumed (${sessionId})`);
@@ -23301,6 +23299,50 @@ const createClaudeCodeHandler = (config) => {
 	};
 	return handler;
 };
+/**
+* Generate a CLAUDE.md file from .agent/ bootstrap data.
+*
+* Layered Bootstrap:
+*   Layer 1 (always): Agent identity + member profile + AGENT.md operating instructions
+*   Layer 2 (if available): Organization domain map from root NODE.md
+*   Layer 3 (on-demand): Agent reads specific domain nodes via contextTreePath
+*/
+function generateClaudeMd(workspacePath, identity, contextTreePath) {
+	const sections = [];
+	const contextDir = join(workspacePath, ".agent", "context");
+	const name = identity.displayName ?? identity.agentId;
+	if (identity.type === "personal_assistant") sections.push(`# Agent Identity\n\nYou are ${name}, a personal assistant agent.\n`);
+	else sections.push(`# Agent Identity\n\nYou are ${name}, an autonomous agent.\n`);
+	const selfMdPath = join(contextDir, "self.md");
+	if (existsSync(selfMdPath)) {
+		const selfContent = readFileSync(selfMdPath, "utf-8");
+		sections.push(`## Your Profile\n\n${selfContent}\n`);
+	} else sections.push("## Your Profile\n\nNo member profile available. Your responsibilities are not loaded from the Context Tree.\n");
+	const agentInstructionsPath = join(contextDir, "agent-instructions.md");
+	if (existsSync(agentInstructionsPath)) {
+		const instructions = readFileSync(agentInstructionsPath, "utf-8");
+		sections.push(`## Context Tree Operating Instructions\n\n${instructions}\n`);
+	} else sections.push("## Context Tree Operating Instructions\n\nContext Tree instructions unavailable. Organizational context is not loaded for this session.\n");
+	const domainMapPath = join(contextDir, "domain-map.md");
+	if (existsSync(domainMapPath)) {
+		const domainMap = readFileSync(domainMapPath, "utf-8");
+		sections.push(`## Organization Domain Map\n\n${domainMap}\n`);
+	}
+	if (contextTreePath) sections.push(`## Context Tree Location\n\nThe full Context Tree is available at: \`${contextTreePath}\`\n\nRead specific domain nodes as needed following the operating instructions above.\n`);
+	else {
+		const degradedPath = join(contextDir, "degraded.md");
+		if (existsSync(degradedPath)) {
+			const degradedMsg = readFileSync(degradedPath, "utf-8");
+			sections.push(`## Context Tree Location\n\nWARNING: ${degradedMsg}\nYou can still use the SDK tools below, but you lack organizational context for decisions.\n`);
+		}
+	}
+	const toolsPath = join(workspacePath, ".agent", "tools.md");
+	if (existsSync(toolsPath)) {
+		const toolsContent = readFileSync(toolsPath, "utf-8");
+		sections.push(toolsContent);
+	}
+	writeFileSync(join(workspacePath, "CLAUDE.md"), sections.join("\n"), "utf-8");
+}
 /** Register all built-in handlers. Call once at startup. */
 function registerBuiltinHandlers() {
 	registerHandler("claude-code", createClaudeCodeHandler);
@@ -23700,18 +23742,24 @@ var AgentSlot = class {
 		this.connection.on("reconnecting", (attempt) => this.logFn(`Reconnecting (attempt ${attempt})...`));
 		this.connection.on("error", (err) => this.logFn(`Error: ${err.message}`));
 	}
-	async start() {
+	async start(contextTreePath) {
 		const agent = await this.connection.connect();
 		this.logFn(`Registered as ${agent.displayName ?? agent.agentId} (${agent.agentId})`);
-		const registryPath = join(homedir(), ".first-tree-hub", "data", "sessions", `${this.config.name}.json`);
+		const registryPath = join(DEFAULT_DATA_DIR, "sessions", `${this.config.name}.json`);
 		this.sessionManager = new SessionManager({
 			session: this.config.session,
 			concurrency: this.config.concurrency,
 			handlerFactory: this.config.handlerFactory,
-			handlerConfig: { cwd: this.config.cwd ?? process.cwd() },
+			handlerConfig: {
+				workspaceRoot: join(DEFAULT_DATA_DIR, "workspaces", this.config.name),
+				contextTreePath: contextTreePath ?? void 0
+			},
 			agentIdentity: {
 				agentId: agent.agentId,
-				displayName: agent.displayName
+				displayName: agent.displayName,
+				type: agent.type,
+				delegateMention: agent.delegateMention,
+				metadata: agent.metadata
 			},
 			sdk: this.connection.sdk,
 			log: this.logFn,
@@ -23735,7 +23783,6 @@ const sessionConfigSchema = z.object({
 const agentSlotConfigSchema = z.object({
 	token: z.string().min(1),
 	type: z.string().min(1),
-	cwd: z.string().optional(),
 	session: sessionConfigSchema.default({}),
 	concurrency: z.number().int().positive().default(5)
 });
@@ -23767,30 +23814,34 @@ function loadRuntimeConfig(configPath) {
 const DEFAULT_SHUTDOWN_TIMEOUT = 3e4;
 var AgentRuntime = class {
 	slots = [];
+	config;
 	shutdownTimeout;
 	stopping = false;
 	constructor(options) {
-		const { config } = options;
+		this.config = options.config;
 		this.shutdownTimeout = options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT;
-		for (const [name, agentConfig] of Object.entries(config.agents)) {
+		for (const [name, agentConfig] of Object.entries(this.config.agents)) {
 			const handlerFactory = getHandlerFactory(agentConfig.type);
 			this.slots.push(new AgentSlot({
 				name,
-				serverUrl: config.server,
+				serverUrl: this.config.server,
 				token: agentConfig.token,
 				type: agentConfig.type,
 				handlerFactory,
 				session: agentConfig.session,
-				concurrency: agentConfig.concurrency,
-				cwd: agentConfig.cwd
+				concurrency: agentConfig.concurrency
 			}));
 		}
 	}
 	/** Start all agent slots and block until shutdown signal. */
 	async start() {
 		const log = (msg) => process.stderr.write(`[runtime] ${msg}\n`);
+		const firstToken = Object.values(this.config.agents)[0]?.token;
+		let contextTreePath = null;
+		if (firstToken) contextTreePath = await syncContextTree(this.config.server, firstToken, log);
+		if (!contextTreePath) log("WARNING: Context Tree sync failed — agents will start without organizational context");
 		log(`Starting ${this.slots.length} agent(s)...`);
-		const results = await Promise.allSettled(this.slots.map((slot) => slot.start()));
+		const results = await Promise.allSettled(this.slots.map((slot) => slot.start(contextTreePath)));
 		let failed = 0;
 		for (const result of results) if (result.status === "rejected") {
 			log(`Failed to start agent: ${result.reason instanceof Error ? result.reason.message : result.reason}`);
@@ -24467,57 +24518,568 @@ async function runMigrations(databaseUrl) {
 	}
 }
 //#endregion
-//#region src/core/prompt.ts
-/**
-* Check if interactive mode is available.
-* Returns false if --no-interactive flag is set or stdin is not a TTY.
-*/
-function isInteractive(noInteractiveFlag) {
-	if (noInteractiveFlag) return false;
-	return process.stdin.isTTY === true;
+//#region src/core/onboard.ts
+const STATE_FILE = join(homedir(), ".first-tree-hub", ".onboard-state.json");
+/** Save current onboard args to state file for resume. */
+function saveOnboardState(args) {
+	mkdirSync(join(homedir(), ".first-tree-hub"), { recursive: true });
+	writeFileSync(STATE_FILE, JSON.stringify({ args }, null, 2));
+}
+/** Load saved onboard args from state file. */
+function loadOnboardState() {
+	try {
+		return JSON.parse(readFileSync(STATE_FILE, "utf-8")).args;
+	} catch {
+		return null;
+	}
 }
-/**
-* Schema-driven interactive setup.
-* Scans the config schema for fields with `prompt` that are missing.
-*
-* In interactive mode: prompts the user and writes results to YAML.
-* In non-interactive mode: fails with a clear error listing missing fields.
-*/
-async function promptMissingFields(options) {
-	const missing = collectMissingPrompts({
-		schema: options.schema,
-		role: options.role,
-		configDir: options.configDir,
-		cliArgs: options.cliArgs
-	});
-	if (missing.length === 0) return {};
-	if (!isInteractive(options.noInteractive)) {
-		const lines = missing.map((m) => {
-			const envHint = findEnvVar(options.schema, m.dotPath);
-			const envStr = envHint ? `  (env: ${envHint})` : "";
-			return `  ${m.dotPath}${envStr}`;
+async function onboardCheck(args) {
+	const items = [];
+	let ghUsername = null;
+	try {
+		ghUsername = getGitHubUsername();
+		items.push({
+			key: "github_cli",
+			label: "GitHub CLI",
+			status: "ok",
+			value: `authenticated as ${ghUsername}`
+		});
+	} catch {
+		items.push({
+			key: "github_cli",
+			label: "GitHub CLI",
+			status: "missing_required",
+			hint: "Install and authenticate: gh auth login"
 		});
-		throw new Error(`Missing required configuration:\n${lines.join("\n")}\n\nProvide values via environment variables, config file (~/.first-tree-hub/server.yaml),
-or run without --no-interactive to use the interactive setup wizard.`);
 	}
-	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${options.role}.yaml`);
-	const results = {};
-	for (const { dotPath, prompt } of missing) {
-		const value = await askPrompt(dotPath, prompt);
-		if (value !== void 0) {
-			setConfigValue(configPath, dotPath, value);
-			setNestedByDot(results, dotPath, value);
+	try {
+		const serverUrl = resolveServerUrl(args.server);
+		items.push({
+			key: "server",
+			label: "Server URL",
+			status: "ok",
+			value: serverUrl
+		});
+		try {
+			const res = await fetch(`${serverUrl}/api/v1/health`);
+			items.push({
+				key: "server_reachable",
+				label: "Server reachable",
+				status: res.ok ? "ok" : "error",
+				value: res.ok ? "yes" : `HTTP ${res.status}`
+			});
+		} catch {
+			items.push({
+				key: "server_reachable",
+				label: "Server reachable",
+				status: "error",
+				value: "no"
+			});
 		}
+	} catch {
+		items.push({
+			key: "server",
+			label: "Server URL",
+			status: "missing_required",
+			hint: "--server <url> or FIRST_TREE_HUB_SERVER"
+		});
 	}
-	return results;
-}
-/**
-* Interactive add agent — simple two-field prompt.
-*/
-async function promptAddAgent() {
-	return {
-		name: await input({
-			message: "Agent name:",
+	const repoPath = await resolveContextTreeRepo(args.server);
+	if (repoPath) items.push({
+		key: "repo",
+		label: "Context Tree repo",
+		status: "ok",
+		value: repoPath
+	});
+	else {
+		const serverAvailable = items.some((i) => i.key === "server" && i.status === "ok");
+		items.push({
+			key: "repo",
+			label: "Context Tree repo",
+			status: "missing_required",
+			hint: serverAvailable ? "auto-clone failed (check server Context Tree config and gh auth)" : "configure --server first (repo will be auto-cloned from server)"
+		});
+	}
+	items.push(args.id ? {
+		key: "id",
+		label: "id",
+		status: "ok",
+		value: args.id
+	} : {
+		key: "id",
+		label: "id",
+		status: "missing_required",
+		hint: "Member directory name"
+	});
+	items.push(args.type ? {
+		key: "type",
+		label: "type",
+		status: "ok",
+		value: args.type
+	} : {
+		key: "type",
+		label: "type",
+		status: "missing_required",
+		hint: "human | personal_assistant | autonomous_agent"
+	});
+	items.push(args.role ? {
+		key: "role",
+		label: "role",
+		status: "ok",
+		value: args.role
+	} : {
+		key: "role",
+		label: "role",
+		status: "missing_required",
+		hint: "e.g. \"Engineer\""
+	});
+	items.push(args.domains ? {
+		key: "domains",
+		label: "domains",
+		status: "ok",
+		value: args.domains
+	} : {
+		key: "domains",
+		label: "domains",
+		status: "missing_required",
+		hint: "Comma-separated, e.g. \"backend,infra\""
+	});
+	items.push(args.displayName ? {
+		key: "display_name",
+		label: "display-name",
+		status: "ok",
+		value: args.displayName
+	} : {
+		key: "display_name",
+		label: "display-name",
+		status: "missing_optional",
+		hint: `defaults to "${args.id ?? ""}"`
+	});
+	items.push(args.assistant ? {
+		key: "assistant",
+		label: "assistant",
+		status: "ok",
+		value: args.assistant
+	} : {
+		key: "assistant",
+		label: "assistant",
+		status: "missing_optional",
+		hint: "Also create a personal_assistant"
+	});
+	items.push(args.feishuBotAppId ? {
+		key: "feishu_bot",
+		label: "feishu-bot-app-id",
+		status: "ok",
+		value: args.feishuBotAppId
+	} : {
+		key: "feishu_bot",
+		label: "feishu-bot-app-id",
+		status: "missing_optional",
+		hint: "Feishu bot App ID for assistant"
+	});
+	if (args.id && repoPath) if (existsSync(join(repoPath, "members", args.id))) try {
+		execSync(`git ls-files --error-unmatch members/${args.id}/NODE.md`, {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+		items.push({
+			key: "conflict",
+			label: `ID "${args.id}" availability`,
+			status: "warning",
+			value: "already exists (will overwrite)"
+		});
+	} catch {
+		items.push({
+			key: "conflict",
+			label: `ID "${args.id}" availability`,
+			status: "ok",
+			value: "resuming (local files from previous run)"
+		});
+	}
+	else items.push({
+		key: "conflict",
+		label: `ID "${args.id}" availability`,
+		status: "ok",
+		value: "available"
+	});
+	return items;
+}
+function formatCheckReport(items) {
+	const lines = [];
+	for (const item of items) {
+		const icon = item.status === "ok" ? "✅" : item.status === "missing_required" ? "❌" : item.status === "error" ? "❌" : item.status === "warning" ? "⚠️" : "⬜";
+		const valueStr = item.value ? `  ${item.value}` : "";
+		const hintStr = item.hint ? `  (${item.hint})` : "";
+		lines.push(`  ${icon} ${item.label.padEnd(20)}${valueStr}${hintStr}`);
+	}
+	return lines.join("\n");
+}
+async function onboardCreate(args) {
+	const repoPath = await resolveContextTreeRepo(args.server);
+	if (!repoPath) throw new Error("Context Tree repo not available. Ensure --server is configured and the server is running.");
+	const ghUsername = getGitHubUsername();
+	const githubField = args.type === "human" ? ghUsername : null;
+	const humanNodePath = join(repoPath, "members", args.id, "NODE.md");
+	if (existsSync(humanNodePath) && isTrackedByGit(repoPath, join("members", args.id, "NODE.md"))) {
+		process.stderr.write(`Member "${args.id}" already exists, skipping NODE.md creation.\n`);
+		if (args.assistant) {
+			const existingContent = readFileSync(humanNodePath, "utf-8");
+			if (!existingContent.includes("delegate_mention")) {
+				writeFileSync(humanNodePath, existingContent.replace(/^(---\n[\s\S]*?)(---)/m, `$1delegate_mention: ${args.assistant}\n$2`));
+				process.stderr.write(`Updated delegate_mention → ${args.assistant}\n`);
+			}
+		}
+	} else createMemberNodeMd(repoPath, {
+		id: args.id,
+		type: args.type,
+		displayName: args.displayName ?? args.id,
+		role: args.role,
+		domains: args.domains.split(",").map((d) => d.trim()),
+		owner: ghUsername,
+		github: githubField,
+		delegateMention: args.assistant ?? args.delegateMention ?? null
+	});
+	if (args.assistant) if (existsSync(join(repoPath, "members", args.id, args.assistant, "NODE.md")) && isTrackedByGit(repoPath, join("members", args.id, args.assistant, "NODE.md"))) process.stderr.write(`Assistant "${args.assistant}" already exists, skipping.\n`);
+	else createMemberNodeMd(repoPath, {
+		parentPath: join("members", args.id),
+		id: args.assistant,
+		type: "personal_assistant",
+		displayName: args.assistant,
+		role: `Personal Assistant to ${args.id}`,
+		domains: ["message triage", "task coordination"],
+		owner: ghUsername,
+		github: null,
+		delegateMention: null
+	});
+	try {
+		execSync("npx -y first-tree verify", {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+	} catch (err) {
+		const stderr = err instanceof Error && "stderr" in err ? err.stderr.toString() : "";
+		const stdout = err instanceof Error && "stdout" in err ? err.stdout.toString() : "";
+		const output = stderr || stdout || String(err);
+		if (output.includes("VERSION") || output.includes("AGENT.md") || output.includes("Root NODE.md")) throw new Error("Context Tree repo is not properly initialized.\nRun 'context-tree init' in the repo first, or see:\n  https://github.com/agent-team-foundation/first-tree\n\n" + output);
+		throw new Error(`Verification failed:\n${output}`);
+	}
+	const baseBranch = `onboard/${args.id}`;
+	let branch = baseBranch;
+	const branchExists = (name) => {
+		try {
+			execSync(`git rev-parse --verify ${name}`, {
+				cwd: repoPath,
+				stdio: "pipe"
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	if (branchExists(branch)) branch = `${baseBranch}-${Date.now().toString(36)}`;
+	try {
+		execSync("git checkout main", {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+	} catch {
+		try {
+			execSync("git checkout master", {
+				cwd: repoPath,
+				stdio: "pipe"
+			});
+		} catch {}
+	}
+	execSync(`git checkout -b ${branch}`, {
+		cwd: repoPath,
+		stdio: "pipe"
+	});
+	execSync(`git add members/${args.id}`, {
+		cwd: repoPath,
+		stdio: "pipe"
+	});
+	execFileSync("git", [
+		"commit",
+		"-m",
+		args.assistant ? `feat: onboard ${args.id} + ${args.assistant}` : `feat: onboard ${args.id}`
+	], {
+		cwd: repoPath,
+		stdio: "pipe"
+	});
+	const pushToken = execSync("gh auth token", {
+		encoding: "utf-8",
+		stdio: "pipe"
+	}).trim();
+	const cleanRemote = execSync("git remote get-url origin", {
+		cwd: repoPath,
+		encoding: "utf-8",
+		stdio: "pipe"
+	}).trim();
+	execSync(`git remote set-url origin "${cleanRemote.replace("https://github.com/", `https://x-access-token:${pushToken}@github.com/`)}"`, {
+		cwd: repoPath,
+		stdio: "pipe"
+	});
+	try {
+		execSync(`git push -u origin ${branch}`, {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+	} finally {
+		execSync(`git remote set-url origin "${cleanRemote}"`, {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+	}
+	const prOutput = execSync(`gh pr create --title "${args.assistant ? `Onboard ${args.id} + assistant` : `Onboard ${args.id}`}" --body "Automated onboard via first-tree-hub CLI"`, {
+		cwd: repoPath,
+		encoding: "utf-8"
+	}).trim();
+	const state = {
+		args,
+		branch,
+		prUrl: prOutput
+	};
+	mkdirSync(join(homedir(), ".first-tree-hub"), { recursive: true });
+	writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+	return { prUrl: prOutput };
+}
+async function onboardContinue(args) {
+	let state = null;
+	try {
+		state = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+	} catch {}
+	if (!state && !args.id) throw new Error("No onboard in progress. Run 'first-tree-hub onboard' first to start a new onboard.");
+	const mergedArgs = {
+		...state?.args,
+		...stripUndefined(args)
+	};
+	const serverUrl = resolveServerUrl(mergedArgs.server).replace(/\/+$/, "");
+	const agentToBootstrap = mergedArgs.assistant ?? mergedArgs.id;
+	if (!agentToBootstrap) throw new Error("Cannot determine which agent to bootstrap. Provide --id or run onboard first.");
+	if (!mergedArgs.id) throw new Error("Cannot determine member ID. Provide --id or run onboard first.");
+	process.stderr.write(`Waiting for agent "${agentToBootstrap}" to be synced...\n`);
+	let synced = false;
+	for (let i = 0; i < 30; i++) {
+		try {
+			const status = await checkBootstrapStatus(serverUrl, agentToBootstrap);
+			if (status.exists && status.status === "active") {
+				synced = true;
+				break;
+			}
+		} catch (err) {
+			if (i === 0) process.stderr.write(`  (check failed: ${err instanceof Error ? err.message : String(err)})\n`);
+		}
+		await sleep(2e3);
+	}
+	if (!synced) throw new Error(`Agent "${agentToBootstrap}" not found after 60s. Trigger sync manually or wait for auto-sync.`);
+	process.stderr.write(`Bootstrapping token for "${agentToBootstrap}"...\n`);
+	let token;
+	try {
+		token = (await bootstrapToken$1(serverUrl, agentToBootstrap, { saveTo: "agent" })).token;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (msg.includes("already has") || msg.includes("409")) throw new Error(`Agent "${agentToBootstrap}" already has an active token.\nAsk an admin to revoke the existing token in the Web UI, then re-run:
+  first-tree-hub onboard --continue`);
+		throw err;
+	}
+	process.stderr.write(`Token saved to ~/.first-tree-hub/agents/${agentToBootstrap}/agent.yaml\n`);
+	if (mergedArgs.feishuBotAppId && mergedArgs.feishuBotAppSecret) {
+		const { bindFeishuBot } = await import("./feishu-Y4m2zFc3.mjs").then((n) => n.r);
+		process.stderr.write("Binding Feishu bot...\n");
+		await bindFeishuBot(serverUrl, token, mergedArgs.feishuBotAppId, mergedArgs.feishuBotAppSecret);
+		process.stderr.write("Feishu bot bound.\n");
+	}
+	try {
+		const { unlinkSync } = await import("node:fs");
+		unlinkSync(STATE_FILE);
+	} catch {}
+	process.stderr.write("\n✅ Onboard complete!\n\n");
+	process.stderr.write(`  Human:     ${mergedArgs.id}\n`);
+	if (mergedArgs.assistant) process.stderr.write(`  Assistant: ${mergedArgs.assistant}\n`);
+	process.stderr.write(`  Token:     ~/.first-tree-hub/agents/${agentToBootstrap}/agent.yaml\n`);
+	if (mergedArgs.feishuBotAppId) process.stderr.write(`  Feishu:    bot bound (${mergedArgs.feishuBotAppId})\n`);
+	if (mergedArgs.type === "human") {
+		process.stderr.write("\n  Next step — bind your Feishu account:\n");
+		process.stderr.write(`    Send this message to the bot in Feishu:  /bind ${mergedArgs.id}\n`);
+		if (!mergedArgs.feishuBotAppId) process.stderr.write("    (requires a Feishu bot to be configured in the system)\n");
+	}
+	process.stderr.write("\n");
+}
+function createMemberNodeMd(repoPath, data) {
+	const memberDir = join(repoPath, data.parentPath ?? "members", data.id);
+	mkdirSync(memberDir, { recursive: true });
+	const domainsList = data.domains.map((d) => `  - "${d}"`).join("\n");
+	const githubLine = data.github ? `\ngithub: ${data.github}` : "";
+	const delegateLine = data.delegateMention ? `\ndelegate_mention: ${data.delegateMention}` : "";
+	const content = `---
+title: "${data.displayName}"
+owners: [${data.owner}]
+type: ${data.type}
+role: "${data.role}"
+domains:
+${domainsList}${githubLine}${delegateLine}
+---
+
+# ${data.displayName}
+
+## About
+
+## Current Focus
+`;
+	writeFileSync(join(memberDir, "NODE.md"), content);
+}
+function isTrackedByGit(repoPath, filePath) {
+	try {
+		execSync(`git ls-files --error-unmatch ${filePath}`, {
+			cwd: repoPath,
+			stdio: "pipe"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+const CONTEXT_TREE_DIR = join(homedir(), ".first-tree-hub", "context-tree");
+/**
+* Resolve Context Tree to a **local path** at ~/.first-tree-hub/context-tree/.
+*
+* Repo URL is obtained from the Hub server. The local clone is always
+* managed in the standard location — no custom paths allowed.
+*/
+async function resolveContextTreeRepo(serverUrl) {
+	const repoUrl = await fetchRepoUrlFromServer(serverUrl);
+	if (!repoUrl) return null;
+	let ghToken;
+	try {
+		ghToken = execSync("gh auth token", {
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim();
+	} catch {
+		return null;
+	}
+	const gitEnv = {
+		...process.env,
+		GIT_ASKPASS: "echo",
+		GIT_TERMINAL_PROMPT: "0",
+		GH_TOKEN: ghToken,
+		GITHUB_TOKEN: ghToken
+	};
+	const gitConfigArgs = `-c url."https://x-access-token:${ghToken}@github.com/".insteadOf="https://github.com/"`;
+	if (existsSync(join(CONTEXT_TREE_DIR, ".git"))) {
+		try {
+			if (execSync("git remote get-url origin", {
+				cwd: CONTEXT_TREE_DIR,
+				encoding: "utf-8",
+				stdio: "pipe"
+			}).trim().includes(repoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, ""))) {
+				process.stderr.write("Updating Context Tree...\n");
+				execSync("git checkout main 2>/dev/null || git checkout master", {
+					cwd: CONTEXT_TREE_DIR,
+					stdio: "pipe"
+				});
+				try {
+					execSync(`git ${gitConfigArgs} pull --ff-only`, {
+						cwd: CONTEXT_TREE_DIR,
+						stdio: "pipe",
+						env: gitEnv
+					});
+				} catch {}
+				return CONTEXT_TREE_DIR;
+			}
+		} catch {}
+		const safePrefix = join(homedir(), ".first-tree-hub");
+		if (!CONTEXT_TREE_DIR.startsWith(safePrefix) || CONTEXT_TREE_DIR === safePrefix) throw new Error(`Refusing to delete unsafe path: ${CONTEXT_TREE_DIR}`);
+		execSync(`rm -rf ${CONTEXT_TREE_DIR}`);
+	}
+	try {
+		process.stderr.write(`Cloning Context Tree to ${CONTEXT_TREE_DIR}...\n`);
+		mkdirSync(join(homedir(), ".first-tree-hub"), { recursive: true });
+		execSync(`git ${gitConfigArgs} clone ${repoUrl} ${CONTEXT_TREE_DIR}`, {
+			stdio: "pipe",
+			env: gitEnv
+		});
+		return CONTEXT_TREE_DIR;
+	} catch {
+		return null;
+	}
+}
+/** Query server for Context Tree repo URL. */
+async function fetchRepoUrlFromServer(serverUrl) {
+	if (!serverUrl) try {
+		serverUrl = resolveServerUrl();
+	} catch {
+		return null;
+	}
+	try {
+		const url = `${serverUrl.replace(/\/+$/, "")}/api/v1/context-tree/info`;
+		const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+		if (!res.ok) return null;
+		return (await res.json()).repo ?? null;
+	} catch {
+		return null;
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripUndefined(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+	return result;
+}
+//#endregion
+//#region src/core/prompt.ts
+/**
+* Check if interactive mode is available.
+* Returns false if --no-interactive flag is set or stdin is not a TTY.
+*/
+function isInteractive(noInteractiveFlag) {
+	if (noInteractiveFlag) return false;
+	return process.stdin.isTTY === true;
+}
+/**
+* Schema-driven interactive setup.
+* Scans the config schema for fields with `prompt` that are missing.
+*
+* In interactive mode: prompts the user and writes results to YAML.
+* In non-interactive mode: fails with a clear error listing missing fields.
+*/
+async function promptMissingFields(options) {
+	const missing = collectMissingPrompts({
+		schema: options.schema,
+		role: options.role,
+		configDir: options.configDir,
+		cliArgs: options.cliArgs
+	});
+	if (missing.length === 0) return {};
+	if (!isInteractive(options.noInteractive)) {
+		const lines = missing.map((m) => {
+			const envHint = findEnvVar(options.schema, m.dotPath);
+			const envStr = envHint ? `  (env: ${envHint})` : "";
+			return `  ${m.dotPath}${envStr}`;
+		});
+		throw new Error(`Missing required configuration:\n${lines.join("\n")}\n\nProvide values via environment variables, config file (~/.first-tree-hub/server.yaml),
+or run without --no-interactive to use the interactive setup wizard.`);
+	}
+	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${options.role}.yaml`);
+	const results = {};
+	for (const { dotPath, prompt } of missing) {
+		const value = await askPrompt(dotPath, prompt);
+		if (value !== void 0) {
+			setConfigValue(configPath, dotPath, value);
+			setNestedByDot(results, dotPath, value);
+		}
+	}
+	return results;
+}
+/**
+* Interactive add agent — simple two-field prompt.
+*/
+async function promptAddAgent() {
+	return {
+		name: await input({
+			message: "Agent name:",
 			validate: (v) => /^[a-z0-9][a-z0-9-]*$/.test(v) ? true : "Lowercase alphanumeric and hyphens only"
 		}),
 		token: await input({
@@ -24606,6 +25168,10 @@ const adapterBindMethodSchema = z.enum([
 	"oauth",
 	"manual"
 ]);
+const selfServiceFeishuBotSchema = z.object({
+	appId: z.string().min(1),
+	appSecret: z.string().min(1)
+});
 const createAdapterMappingSchema = z.object({
 	platform: adapterPlatformSchema,
 	externalUserId: z.string().min(1),
@@ -24622,6 +25188,10 @@ z.object({
 	displayName: z.string().nullable(),
 	createdAt: z.string()
 });
+const delegateFeishuUserSchema = z.object({
+	feishuUserId: z.string().min(1),
+	displayName: z.string().max(200).optional()
+});
 z.object({
 	configId: z.number(),
 	platform: z.string(),
@@ -24705,6 +25275,7 @@ z.object({
 	type: agentTypeSchema,
 	displayName: z.string().nullable(),
 	delegateMention: z.string().nullable(),
+	treePath: z.string().nullable(),
 	inboxId: z.string(),
 	status: z.string(),
 	metadata: z.record(z.unknown()),
@@ -24712,6 +25283,16 @@ z.object({
 	createdAt: z.string(),
 	updatedAt: z.string()
 });
+const bootstrapTokenRequestSchema = z.object({ name: z.string().max(100).optional() });
+z.object({
+	exists: z.boolean(),
+	status: z.enum(["active", "suspended"]).nullable()
+});
+z.object({
+	repo: z.string(),
+	branch: z.string(),
+	lastSync: z.string().nullable()
+});
 const createAgentTokenSchema = z.object({
 	name: z.string().max(100).optional(),
 	expiresAt: z.string().datetime().optional()
@@ -24832,7 +25413,7 @@ const SYSTEM_CONFIG_DEFAULTS = {
 	[SYSTEM_CONFIG_KEYS.PRESENCE_CLEANUP_SECONDS]: 60
 };
 //#endregion
-//#region ../server/dist/app-DUdS4lE-.mjs
+//#region ../server/dist/app-BVTDWxJE.mjs
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -24850,6 +25431,7 @@ const agents = pgTable("agents", {
 	type: text("type").notNull(),
 	displayName: text("display_name"),
 	delegateMention: text("delegate_mention"),
+	treePath: text("tree_path"),
 	inboxId: text("inbox_id").unique().notNull(),
 	status: text("status").notNull().default("active"),
 	metadata: jsonb("metadata").$type().notNull().default({}),
@@ -24984,6 +25566,11 @@ async function findAgentByExternalUser(db, platform, externalUserId) {
 	}).from(adapterAgentMappings).where(and(eq(adapterAgentMappings.platform, platform), eq(adapterAgentMappings.externalUserId, externalUserId))).limit(1);
 	return row ?? null;
 }
+/** Look up the external user ID for an internal agent. */
+async function findExternalUserByAgent(db, platform, agentId) {
+	const [row] = await db.select({ externalUserId: adapterAgentMappings.externalUserId }).from(adapterAgentMappings).where(and(eq(adapterAgentMappings.platform, platform), eq(adapterAgentMappings.agentId, agentId))).limit(1);
+	return row ?? null;
+}
 /** Create an agent mapping. */
 async function createAgentMapping(db, data) {
 	const [row] = await db.insert(adapterAgentMappings).values({
@@ -25331,6 +25918,7 @@ async function adminAdapterRoutes(app) {
 	});
 }
 const GRAPHQL_URL = "https://api.github.com/graphql";
+const REST_API_URL = "https://api.github.com";
 /** Parse "owner/repo" or "https://github.com/owner/repo" into { owner, name }. */
 function parseRepo(input) {
 	const urlMatch = /github\.com\/([^/]+)\/([^/.]+)/.exec(input);
@@ -25344,31 +25932,13 @@ function parseRepo(input) {
 		name: parts[1] ?? ""
 	};
 }
-/**
-* Fetch all members from a Context Tree repo via GitHub GraphQL API.
-* Single request regardless of member count.
-*/
-async function fetchMembers(repo, branch, token) {
-	const { owner, name } = parseRepo(repo);
-	if (!owner || !name) throw new Error(`Invalid repo format: "${repo}" — expected "owner/repo" or a GitHub URL`);
+/** Step 1: Get the tree OID of the members/ directory via GraphQL. */
+async function fetchMembersTreeOid(owner, name, branch, token) {
 	const query = `
     query($owner: String!, $name: String!, $expr: String!) {
       repository(owner: $owner, name: $name) {
         object(expression: $expr) {
-          ... on Tree {
-            entries {
-              name
-              type
-              object {
-                ... on Tree {
-                  entries {
-                    name
-                    object { ... on Blob { text } }
-                  }
-                }
-              }
-            }
-          }
+          ... on Tree { oid }
         }
       }
     }
@@ -25391,17 +25961,109 @@ async function fetchMembers(repo, branch, token) {
 	if (!res.ok) throw new Error(`GitHub API returned ${res.status}: ${await res.text()}`);
 	const json = await res.json();
 	if (json.errors) throw new Error(`GitHub GraphQL errors: ${json.errors.map((e) => e.message).join(", ")}`);
-	const entries = json.data?.repository?.object?.entries ?? [];
-	const members = [];
-	for (const entry of entries) {
+	return json.data?.repository?.object?.oid ?? null;
+}
+/** Step 2: Recursively list all entries under the members/ tree via REST API. */
+async function fetchRecursiveTree(owner, name, treeSha, token) {
+	const url = `${REST_API_URL}/repos/${owner}/${name}/git/trees/${treeSha}?recursive=1`;
+	const res = await fetch(url, { headers: {
+		Authorization: `Bearer ${token}`,
+		Accept: "application/vnd.github+json"
+	} });
+	if (!res.ok) throw new Error(`GitHub REST API returned ${res.status}: ${await res.text()}`);
+	const json = await res.json();
+	if (json.truncated) throw new Error("[context-tree-sync] GitHub REST tree API returned truncated response — members/ subtree is too large. Sync aborted to prevent incorrect agent suspension from partial data.");
+	return json.tree;
+}
+/**
+* Step 3: Batch-fetch NODE.md content for all member directories via GraphQL aliases.
+* Each alias fetches one NODE.md file by expression.
+*/
+async function batchFetchNodeMd(owner, name, branch, memberPaths, token) {
+	if (memberPaths.length === 0) return /* @__PURE__ */ new Map();
+	const query = `
+    query($owner: String!, $name: String!) {
+      repository(owner: $owner, name: $name) {
+        ${memberPaths.map((p, i) => {
+		const expr = `${branch}:members/${p}/NODE.md`;
+		return `m${i}: object(expression: ${JSON.stringify(expr)}) { ... on Blob { text } }`;
+	}).join("\n        ")}
+      }
+    }
+  `;
+	const res = await fetch(GRAPHQL_URL, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			query,
+			variables: {
+				owner,
+				name
+			}
+		})
+	});
+	if (!res.ok) throw new Error(`GitHub API returned ${res.status}: ${await res.text()}`);
+	const json = await res.json();
+	if (json.errors) throw new Error(`GitHub GraphQL errors: ${json.errors.map((e) => e.message).join(", ")}`);
+	const repo = json.data?.repository ?? {};
+	const result = /* @__PURE__ */ new Map();
+	for (let i = 0; i < memberPaths.length; i++) {
+		const blob = repo[`m${i}`];
+		const path = memberPaths[i];
+		if (blob?.text && path) result.set(path, blob.text);
+	}
+	return result;
+}
+/**
+* Extract member directory paths from a recursive tree listing.
+* A directory is a member if it contains a NODE.md blob.
+*/
+function extractMemberDirs(treeEntries) {
+	const nodeMdPaths = /* @__PURE__ */ new Set();
+	for (const entry of treeEntries) if (entry.type === "blob" && entry.path.endsWith("/NODE.md")) nodeMdPaths.add(entry.path);
+	const memberDirs = [];
+	for (const entry of treeEntries) {
 		if (entry.type !== "tree") continue;
-		const nodeFile = entry.object?.entries?.find((f) => f.name === "NODE.md");
-		members.push({
-			name: entry.name,
-			nodeContent: nodeFile?.object?.text ?? null
-		});
+		if (nodeMdPaths.has(`${entry.path}/NODE.md`)) memberDirs.push(entry.path);
 	}
-	return members;
+	return memberDirs.sort();
+}
+/**
+* Fetch all members from a Context Tree repo via GitHub API.
+* Uses 3 API calls:
+*   1. GraphQL: get members/ tree OID
+*   2. REST: recursive tree listing (scoped to members/ only)
+*   3. GraphQL: batch-fetch all NODE.md contents via aliases
+*/
+async function fetchMembers(repo, branch, token) {
+	const { owner, name } = parseRepo(repo);
+	if (!owner || !name) throw new Error(`Invalid repo format: "${repo}" — expected "owner/repo" or a GitHub URL`);
+	const treeOid = await fetchMembersTreeOid(owner, name, branch, token);
+	if (!treeOid) {
+		console.warn("[context-tree-sync] members/ directory not found in repo");
+		return [];
+	}
+	const memberDirs = extractMemberDirs(await fetchRecursiveTree(owner, name, treeOid, token));
+	if (memberDirs.length === 0) {
+		console.warn("[context-tree-sync] No member directories with NODE.md found");
+		return [];
+	}
+	const nameMap = /* @__PURE__ */ new Map();
+	for (const dir of memberDirs) {
+		const dirName = dir.split("/").pop() ?? dir;
+		const existing = nameMap.get(dirName);
+		if (existing) throw new Error(`[context-tree-sync] Duplicate member directory name '${dirName}' found at 'members/${existing}' and 'members/${dir}' — directory names must be unique across all levels under members/. Fix this in the Context Tree repo.`);
+		nameMap.set(dirName, dir);
+	}
+	const nodeContents = await batchFetchNodeMd(owner, name, branch, memberDirs, token);
+	return memberDirs.map((dir) => ({
+		name: dir.split("/").pop() ?? dir,
+		treePath: dir,
+		nodeContent: nodeContents.get(dir) ?? null
+	}));
 }
 /** Parse NODE.md frontmatter for agent metadata. */
 function parseNodeMetadata(content) {
@@ -25409,17 +26071,27 @@ function parseNodeMetadata(content) {
 	if (!match) return {
 		type: "autonomous_agent",
 		displayName: null,
-		delegateMention: null
+		delegateMention: null,
+		owners: [],
+		github: null
 	};
 	const frontmatter = match[1] ?? "";
 	const getValue = (key) => {
 		const lineMatch = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(frontmatter);
 		return lineMatch ? lineMatch[1]?.trim().replace(/^["']|["']$/g, "") ?? null : null;
 	};
+	const ownersRaw = getValue("owners");
+	let owners = [];
+	if (ownersRaw) {
+		const listMatch = /^\[([^\]]*)\]$/.exec(ownersRaw);
+		if (listMatch?.[1]) owners = listMatch[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+	}
 	return {
 		type: getValue("type") ?? "autonomous_agent",
 		displayName: getValue("display_name") ?? getValue("title") ?? getValue("name"),
-		delegateMention: getValue("delegate_mention")
+		delegateMention: getValue("delegate_mention"),
+		owners,
+		github: getValue("github")
 	};
 }
 /** Stored for the /status endpoint */
@@ -25453,33 +26125,45 @@ async function syncFromGitHub(db, repo, branch, githubToken) {
 		const meta = member.nodeContent ? parseNodeMetadata(member.nodeContent) : {
 			type: "autonomous_agent",
 			displayName: null,
-			delegateMention: null
+			delegateMention: null,
+			owners: [],
+			github: null
 		};
-		const existing = await db.execute(sql`SELECT id, status, type, display_name, delegate_mention FROM agents WHERE id = ${member.name}`);
+		const metadataJson = JSON.stringify({
+			owners: meta.owners,
+			github: meta.github
+		});
+		const existing = await db.execute(sql`SELECT id, status, type, display_name, delegate_mention, tree_path, metadata FROM agents WHERE id = ${member.name}`);
 		if (existing.length === 0) {
 			await db.execute(sql`
-          INSERT INTO agents (id, type, display_name, delegate_mention, status, inbox_id)
-          VALUES (${member.name}, ${meta.type}, ${meta.displayName}, ${meta.delegateMention}, 'active', ${`inbox_${member.name}`})
+          INSERT INTO agents (id, type, display_name, delegate_mention, tree_path, status, inbox_id, metadata)
+          VALUES (${member.name}, ${meta.type}, ${meta.displayName}, ${meta.delegateMention}, ${member.treePath}, 'active', ${`inbox_${member.name}`}, ${metadataJson}::jsonb)
         `);
 			result.created++;
 		} else {
 			const agent = existing[0];
-			if (agent.status === "suspended") {
+			const existingMeta = agent.metadata ?? {};
+			const mergedMeta = JSON.stringify({
+				...existingMeta,
+				owners: meta.owners,
+				github: meta.github
+			});
+			if (agent.status === "suspended" || agent.status === "deleted") {
 				await db.execute(sql`
-            UPDATE agents SET status = 'active', type = ${meta.type}, display_name = ${meta.displayName}, delegate_mention = ${meta.delegateMention}
+            UPDATE agents SET status = 'active', type = ${meta.type}, display_name = ${meta.displayName}, delegate_mention = ${meta.delegateMention}, tree_path = ${member.treePath}, metadata = ${mergedMeta}::jsonb
             WHERE id = ${member.name}
           `);
 				result.reactivated++;
-			} else if (agent.type !== meta.type || agent.display_name !== meta.displayName || agent.delegate_mention !== meta.delegateMention) {
+			} else if (agent.type !== meta.type || agent.display_name !== meta.displayName || agent.delegate_mention !== meta.delegateMention || agent.tree_path !== member.treePath || JSON.stringify(existingMeta.owners) !== JSON.stringify(meta.owners) || (existingMeta.github ?? null) !== (meta.github ?? null)) {
 				await db.execute(sql`
-            UPDATE agents SET type = ${meta.type}, display_name = ${meta.displayName}, delegate_mention = ${meta.delegateMention}
+            UPDATE agents SET type = ${meta.type}, display_name = ${meta.displayName}, delegate_mention = ${meta.delegateMention}, tree_path = ${member.treePath}, metadata = ${mergedMeta}::jsonb
             WHERE id = ${member.name}
           `);
 				result.updated++;
 			} else result.unchanged++;
 		}
 	} catch (err) {
-		console.error(`[context-tree-sync] Failed to sync member "${member.name}":`, err);
+		console.error(`[context-tree-sync] Failed to sync member "${member.name}" (path: members/${member.treePath}):`, err);
 		result.errors++;
 	}
 	try {
@@ -25583,6 +26267,7 @@ async function listAgents(db, limit, cursor) {
 		type: agents.type,
 		displayName: agents.displayName,
 		delegateMention: agents.delegateMention,
+		treePath: agents.treePath,
 		inboxId: agents.inboxId,
 		status: agents.status,
 		metadata: agents.metadata,
@@ -25618,6 +26303,17 @@ async function deleteAgent(db, id) {
 	if (!agent) throw new Error("Unexpected: UPDATE RETURNING produced no row");
 	return agent;
 }
+/**
+* Bootstrap a token for an agent using GitHub identity.
+* Only works when the agent has no active (non-revoked, non-expired) tokens.
+*/
+async function bootstrapToken(db, agentId, githubUsername, tokenName) {
+	const agent = await getAgent(db, agentId);
+	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: tokenName ?? "bootstrap" });
+}
 async function createToken(db, agentId, data) {
 	await getAgent(db, agentId);
 	const raw = `aghub_${randomBytes(32).toString("hex")}`;
@@ -25658,35 +26354,339 @@ async function revokeToken(db, agentId, tokenId) {
 	if (!token) throw new NotFoundError("Token not found or already revoked");
 	return token;
 }
-/** WS close code: agent already connected from another client. */
-const WS_CLOSE_ALREADY_CONNECTED = 4009;
-/** Track active WS connections per agentId. At most one entry per agent. */
-const activeConnections = /* @__PURE__ */ new Map();
-/** Check if an agent already has an active WS connection. */
-function hasActiveConnection(agentId) {
-	const ws = activeConnections.get(agentId);
-	return ws !== void 0 && ws.readyState <= 1;
-}
-/** Register a WS connection for an agent. */
-function setConnection(agentId, ws) {
-	activeConnections.set(agentId, ws);
-}
-/** Remove a WS connection if it matches the registered one. Returns true if removed. */
-function removeConnection(agentId, ws) {
-	if (activeConnections.get(agentId) === ws) {
-		activeConnections.delete(agentId);
-		return true;
+async function createChat(db, creatorId, data) {
+	const chatId = randomUUID();
+	const allParticipantIds = new Set([creatorId, ...data.participantIds]);
+	const existingAgents = await db.select({
+		id: agents.id,
+		organizationId: agents.organizationId
+	}).from(agents).where(inArray(agents.id, [...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(", ")}`);
 	}
-	return false;
-}
-/** Force-disconnect an agent's active WS connection. Returns true if a connection was closed. */
-function forceDisconnect(agentId) {
-	const ws = activeConnections.get(agentId);
-	if (!ws) return false;
-	ws.close(WS_CLOSE_ALREADY_CONNECTED, "Disconnected by admin");
-	activeConnections.delete(agentId);
-	return true;
-}
+	const creator = existingAgents.find((a) => a.id === creatorId);
+	if (!creator) throw new Error("Unexpected: creator not in existingAgents");
+	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(", ")}`);
+	return db.transaction(async (tx) => {
+		const [chat] = await tx.insert(chats).values({
+			id: chatId,
+			organizationId: orgId,
+			type: data.type,
+			topic: data.topic ?? null,
+			metadata: data.metadata ?? {}
+		}).returning();
+		const participantRows = [...allParticipantIds].map((agentId) => ({
+			chatId,
+			agentId,
+			role: agentId === creatorId ? "owner" : "member"
+		}));
+		await tx.insert(chatParticipants).values(participantRows);
+		const participants = await tx.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
+		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
+		return {
+			...chat,
+			participants
+		};
+	});
+}
+async function getChat(db, chatId) {
+	const [chat] = await db.select().from(chats).where(eq(chats.id, chatId)).limit(1);
+	if (!chat) throw new NotFoundError(`Chat "${chatId}" not found`);
+	return chat;
+}
+async function getChatDetail(db, chatId) {
+	const chat = await getChat(db, chatId);
+	const participants = await db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
+	return {
+		...chat,
+		participants
+	};
+}
+async function listChats(db, agentId, limit, cursor) {
+	const chatIds = (await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentId))).map((r) => r.chatId);
+	if (chatIds.length === 0) return {
+		items: [],
+		nextCursor: null
+	};
+	const where = cursor ? and(inArray(chats.id, chatIds), lt(chats.updatedAt, new Date(cursor))) : inArray(chats.id, chatIds);
+	const rows = await db.select().from(chats).where(where).orderBy(desc(chats.updatedAt)).limit(limit + 1);
+	const hasMore = rows.length > limit;
+	const items = hasMore ? rows.slice(0, limit) : rows;
+	const last = items[items.length - 1];
+	return {
+		items,
+		nextCursor: hasMore && last ? last.updatedAt.toISOString() : null
+	};
+}
+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");
+}
+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,
+		organizationId: agents.organizationId
+	}).from(agents).where(eq(agents.id, 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);
+	if (existing) throw new ConflictError(`Agent "${data.agentId}" is already a participant`);
+	await db.insert(chatParticipants).values({
+		chatId,
+		agentId: data.agentId,
+		mode: data.mode ?? "full"
+	});
+	return db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
+}
+async function removeParticipant(db, chatId, requesterId, targetAgentId) {
+	await assertParticipant(db, chatId, requesterId);
+	if (requesterId === targetAgentId) throw new BadRequestError("Cannot remove yourself from a chat");
+	const [removed] = await db.delete(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, targetAgentId))).returning();
+	if (!removed) throw new NotFoundError(`Agent "${targetAgentId}" is not a participant of this chat`);
+	return db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
+}
+async function findOrCreateDirectChat(db, agentAId, agentBId) {
+	const aChats = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentAId));
+	const bChats = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentBId));
+	const bChatIds = new Set(bChats.map((r) => r.chatId));
+	const commonChatIds = aChats.map((r) => r.chatId).filter((id) => bChatIds.has(id));
+	if (commonChatIds.length > 0) {
+		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);
+	if (!agentA) throw new NotFoundError(`Agent "${agentAId}" not found`);
+	const chatId = randomUUID();
+	return db.transaction(async (tx) => {
+		const [chat] = await tx.insert(chats).values({
+			id: chatId,
+			organizationId: agentA.organizationId,
+			type: "direct"
+		}).returning();
+		await tx.insert(chatParticipants).values([{
+			chatId,
+			agentId: agentAId,
+			role: "member"
+		}, {
+			chatId,
+			agentId: agentBId,
+			role: "member"
+		}]);
+		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
+		return chat;
+	});
+}
+/** WS close code: agent already connected from another client. */
+const WS_CLOSE_ALREADY_CONNECTED = 4009;
+/** Track active WS connections per agentId. At most one entry per agent. */
+const activeConnections = /* @__PURE__ */ new Map();
+/** Check if an agent already has an active WS connection. */
+function hasActiveConnection(agentId) {
+	const ws = activeConnections.get(agentId);
+	return ws !== void 0 && ws.readyState <= 1;
+}
+/** Register a WS connection for an agent. */
+function setConnection(agentId, ws) {
+	activeConnections.set(agentId, ws);
+}
+/** Remove a WS connection if it matches the registered one. Returns true if removed. */
+function removeConnection(agentId, ws) {
+	if (activeConnections.get(agentId) === ws) {
+		activeConnections.delete(agentId);
+		return true;
+	}
+	return false;
+}
+/** Force-disconnect an agent's active WS connection. Returns true if a connection was closed. */
+function forceDisconnect(agentId) {
+	const ws = activeConnections.get(agentId);
+	if (!ws) return false;
+	ws.close(WS_CLOSE_ALREADY_CONNECTED, "Disconnected by admin");
+	activeConnections.delete(agentId);
+	return true;
+}
+/** Delivery queue (envelope). One entry per recipient created during message fan-out. Uses SKIP LOCKED for concurrent-safe consumption. */
+const inboxEntries = pgTable("inbox_entries", {
+	id: bigserial("id", { mode: "number" }).primaryKey(),
+	inboxId: text("inbox_id").notNull(),
+	messageId: text("message_id").notNull().references(() => messages.id),
+	chatId: text("chat_id"),
+	status: text("status").notNull().default("pending"),
+	retryCount: integer("retry_count").notNull().default(0),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+	deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+	ackedAt: timestamp("acked_at", { withTimezone: true })
+}, (table) => [unique("uq_inbox_delivery").on(table.inboxId, table.messageId, table.chatId), index("idx_inbox_pending").on(table.inboxId, table.createdAt)]);
+async function sendMessage(db, chatId, senderId, data) {
+	return db.transaction(async (tx) => {
+		const messageId = randomUUID();
+		const [msg] = await tx.insert(messages).values({
+			id: messageId,
+			chatId,
+			senderId,
+			format: data.format,
+			content: data.content,
+			metadata: data.metadata ?? {},
+			replyToInbox: data.replyToInbox ?? null,
+			replyToChat: data.replyToChat ?? null,
+			inReplyTo: data.inReplyTo ?? null
+		}).returning();
+		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) => ({
+			inboxId: p.inboxId,
+			messageId,
+			chatId
+		}));
+		if (entries.length > 0) await tx.insert(inboxEntries).values(entries);
+		const recipients = entries.map((e) => e.inboxId);
+		if (data.inReplyTo) {
+			const [original] = await tx.select({
+				replyToInbox: messages.replyToInbox,
+				replyToChat: messages.replyToChat
+			}).from(messages).where(eq(messages.id, data.inReplyTo)).limit(1);
+			if (original?.replyToInbox && original?.replyToChat) {
+				await tx.insert(inboxEntries).values({
+					inboxId: original.replyToInbox,
+					messageId,
+					chatId: original.replyToChat
+				}).onConflictDoNothing();
+				if (!recipients.includes(original.replyToInbox)) recipients.push(original.replyToInbox);
+			}
+		}
+		await tx.update(chats).set({ updatedAt: /* @__PURE__ */ new Date() }).where(eq(chats.id, chatId));
+		if (!msg) throw new Error("Unexpected: INSERT RETURNING produced no row");
+		return {
+			message: msg,
+			recipients
+		};
+	});
+}
+async function sendToAgent(db, senderId, targetAgentId, data) {
+	const [sender] = await db.select({
+		id: agents.id,
+		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, {
+		format: data.format,
+		content: data.content,
+		metadata: data.metadata,
+		replyToInbox: data.replyToInbox,
+		replyToChat: data.replyToChat
+	});
+}
+async function editMessage(db, chatId, messageId, senderId, data) {
+	const [msg] = await db.select().from(messages).where(eq(messages.id, messageId)).limit(1);
+	if (!msg) throw new NotFoundError(`Message "${messageId}" not found`);
+	if (msg.chatId !== chatId) throw new NotFoundError(`Message "${messageId}" not found in this chat`);
+	if (msg.senderId !== senderId) throw new ForbiddenError("Only the sender can edit a message");
+	const setClause = {};
+	if (data.format !== void 0) setClause.format = data.format;
+	if (data.content !== void 0) setClause.content = data.content;
+	const meta = msg.metadata ?? {};
+	meta.editedAt = (/* @__PURE__ */ new Date()).toISOString();
+	setClause.metadata = meta;
+	const [updated] = await db.update(messages).set(setClause).where(eq(messages.id, messageId)).returning();
+	if (!updated) throw new Error("Unexpected: UPDATE RETURNING produced no row");
+	return updated;
+}
+async function listMessages(db, chatId, limit, cursor) {
+	const where = cursor ? and(eq(messages.chatId, chatId), lt(messages.createdAt, new Date(cursor))) : eq(messages.chatId, chatId);
+	const rows = await db.select().from(messages).where(where).orderBy(desc(messages.createdAt)).limit(limit + 1);
+	const hasMore = rows.length > limit;
+	const items = hasMore ? rows.slice(0, limit) : rows;
+	const last = items[items.length - 1];
+	return {
+		items,
+		nextCursor: hasMore && last ? last.createdAt.toISOString() : null
+	};
+}
+const INBOX_CHANNEL = "inbox_notifications";
+const CONFIG_CHANNEL = "config_changes";
+function createNotifier(listenClient) {
+	const subscriptions = /* @__PURE__ */ new Map();
+	const configChangeHandlers = [];
+	let unlistenInboxFn = null;
+	let unlistenConfigFn = null;
+	function handleNotification(payload) {
+		const sepIdx = payload.indexOf(":");
+		if (sepIdx === -1) return;
+		const inboxId = payload.slice(0, sepIdx);
+		const messageId = payload.slice(sepIdx + 1);
+		const sockets = subscriptions.get(inboxId);
+		if (!sockets) return;
+		const data = JSON.stringify({
+			type: "new_message",
+			inboxId,
+			messageId
+		});
+		for (const ws of sockets) if (ws.readyState === ws.OPEN) ws.send(data);
+	}
+	return {
+		subscribe(inboxId, ws) {
+			let set = subscriptions.get(inboxId);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				subscriptions.set(inboxId, set);
+			}
+			set.add(ws);
+		},
+		unsubscribe(inboxId, ws) {
+			const set = subscriptions.get(inboxId);
+			if (set) {
+				set.delete(ws);
+				if (set.size === 0) subscriptions.delete(inboxId);
+			}
+		},
+		async notify(inboxId, messageId) {
+			try {
+				await listenClient`SELECT pg_notify(${INBOX_CHANNEL}, ${`${inboxId}:${messageId}`})`;
+			} catch {}
+		},
+		async notifyConfigChange(configType) {
+			try {
+				await listenClient`SELECT pg_notify(${CONFIG_CHANNEL}, ${configType})`;
+			} catch {}
+		},
+		onConfigChange(handler) {
+			configChangeHandlers.push(handler);
+		},
+		async start() {
+			unlistenInboxFn = (await listenClient.listen(INBOX_CHANNEL, (payload) => {
+				if (payload) handleNotification(payload);
+			})).unlisten;
+			unlistenConfigFn = (await listenClient.listen(CONFIG_CHANNEL, (payload) => {
+				if (payload) for (const handler of configChangeHandlers) handler(payload);
+			})).unlisten;
+		},
+		async stop() {
+			if (unlistenInboxFn) {
+				await unlistenInboxFn();
+				unlistenInboxFn = null;
+			}
+			if (unlistenConfigFn) {
+				await unlistenConfigFn();
+				unlistenConfigFn = null;
+			}
+		}
+	};
+}
+/** Fire-and-forget: notify all recipients that a new message is available. */
+function notifyRecipients(notifier, recipients, messageId) {
+	for (const inboxId of recipients) notifier.notify(inboxId, messageId).catch(() => {});
+}
 /** Server instance heartbeat. Used to detect crashed instances and clean up associated agent_presence records. */
 const serverInstances = pgTable("server_instances", {
 	instanceId: text("instance_id").primaryKey(),
@@ -25717,6 +26717,10 @@ async function setOffline(db, agentId) {
 		lastSeenAt: /* @__PURE__ */ new Date()
 	}).where(eq(agentPresence.agentId, agentId));
 }
+async function getPresence(db, agentId) {
+	const [row] = await db.select().from(agentPresence).where(eq(agentPresence.agentId, agentId)).limit(1);
+	return row ?? null;
+}
 async function getOnlineCount(db) {
 	const [result] = await db.select({ count: sql`count(*)::int` }).from(agentPresence).where(eq(agentPresence.status, "online"));
 	return result?.count ?? 0;
@@ -25801,6 +26805,53 @@ async function adminAgentRoutes(app) {
 		await deleteAgent(app.db, request.params.agentId);
 		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)]);
+		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;
+		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;
+		}
+		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 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",
+			content: testContent
+		});
+		notifyRecipients(app.notifier, result.recipients, result.message.id);
+		const POLL_TIMEOUT = 3e4;
+		const POLL_INTERVAL = 1e3;
+		const threshold = result.message.createdAt;
+		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);
+			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({
+					status: "success",
+					chatId: chat.id,
+					responseContent: content,
+					responseTime: response.createdAt.getTime() - threshold.getTime()
+				});
+			}
+		}
+		return reply.status(200).send({
+			status: "timeout",
+			chatId: chat.id,
+			message: "Agent is connected but did not respond within 30 seconds."
+		});
+	});
 }
 /** Admin accounts. Passwords are stored as bcrypt hashes. */
 const adminUsers = pgTable("admin_users", {
@@ -26039,8 +27090,10 @@ async function updateAdminUser(db, id, data) {
 	return toResponse(row);
 }
 async function deleteAdminUser(db, id) {
-	const [row] = await db.delete(adminUsers).where(eq(adminUsers.id, id)).returning();
-	if (!row) throw new NotFoundError(`Admin user "${id}" not found`);
+	const [target] = await db.select().from(adminUsers).where(eq(adminUsers.id, id)).limit(1);
+	if (!target) throw new NotFoundError(`Admin user "${id}" not found`);
+	if (target.role === "super_admin") throw new ForbiddenError("Cannot delete a super_admin account");
+	await db.delete(adminUsers).where(eq(adminUsers.id, id));
 }
 function serializeDate(d) {
 	return d ? d.toISOString() : null;
@@ -26087,133 +27140,6 @@ function requireAgent(request) {
 	if (!agent) throw new UnauthorizedError("Agent authentication required");
 	return agent;
 }
-async function createChat(db, creatorId, data) {
-	const chatId = randomUUID();
-	const allParticipantIds = new Set([creatorId, ...data.participantIds]);
-	const existingAgents = await db.select({
-		id: agents.id,
-		organizationId: agents.organizationId
-	}).from(agents).where(inArray(agents.id, [...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(", ")}`);
-	}
-	const creator = existingAgents.find((a) => a.id === creatorId);
-	if (!creator) throw new Error("Unexpected: creator not in existingAgents");
-	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(", ")}`);
-	return db.transaction(async (tx) => {
-		const [chat] = await tx.insert(chats).values({
-			id: chatId,
-			organizationId: orgId,
-			type: data.type,
-			topic: data.topic ?? null,
-			metadata: data.metadata ?? {}
-		}).returning();
-		const participantRows = [...allParticipantIds].map((agentId) => ({
-			chatId,
-			agentId,
-			role: agentId === creatorId ? "owner" : "member"
-		}));
-		await tx.insert(chatParticipants).values(participantRows);
-		const participants = await tx.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
-		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
-		return {
-			...chat,
-			participants
-		};
-	});
-}
-async function getChat(db, chatId) {
-	const [chat] = await db.select().from(chats).where(eq(chats.id, chatId)).limit(1);
-	if (!chat) throw new NotFoundError(`Chat "${chatId}" not found`);
-	return chat;
-}
-async function getChatDetail(db, chatId) {
-	const chat = await getChat(db, chatId);
-	const participants = await db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
-	return {
-		...chat,
-		participants
-	};
-}
-async function listChats(db, agentId, limit, cursor) {
-	const chatIds = (await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentId))).map((r) => r.chatId);
-	if (chatIds.length === 0) return {
-		items: [],
-		nextCursor: null
-	};
-	const where = cursor ? and(inArray(chats.id, chatIds), lt(chats.updatedAt, new Date(cursor))) : inArray(chats.id, chatIds);
-	const rows = await db.select().from(chats).where(where).orderBy(desc(chats.updatedAt)).limit(limit + 1);
-	const hasMore = rows.length > limit;
-	const items = hasMore ? rows.slice(0, limit) : rows;
-	const last = items[items.length - 1];
-	return {
-		items,
-		nextCursor: hasMore && last ? last.updatedAt.toISOString() : null
-	};
-}
-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");
-}
-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,
-		organizationId: agents.organizationId
-	}).from(agents).where(eq(agents.id, 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);
-	if (existing) throw new ConflictError(`Agent "${data.agentId}" is already a participant`);
-	await db.insert(chatParticipants).values({
-		chatId,
-		agentId: data.agentId,
-		mode: data.mode ?? "full"
-	});
-	return db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
-}
-async function removeParticipant(db, chatId, requesterId, targetAgentId) {
-	await assertParticipant(db, chatId, requesterId);
-	if (requesterId === targetAgentId) throw new BadRequestError("Cannot remove yourself from a chat");
-	const [removed] = await db.delete(chatParticipants).where(and(eq(chatParticipants.chatId, chatId), eq(chatParticipants.agentId, targetAgentId))).returning();
-	if (!removed) throw new NotFoundError(`Agent "${targetAgentId}" is not a participant of this chat`);
-	return db.select().from(chatParticipants).where(eq(chatParticipants.chatId, chatId));
-}
-async function findOrCreateDirectChat(db, agentAId, agentBId) {
-	const aChats = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentAId));
-	const bChats = await db.select({ chatId: chatParticipants.chatId }).from(chatParticipants).where(eq(chatParticipants.agentId, agentBId));
-	const bChatIds = new Set(bChats.map((r) => r.chatId));
-	const commonChatIds = aChats.map((r) => r.chatId).filter((id) => bChatIds.has(id));
-	if (commonChatIds.length > 0) {
-		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);
-	if (!agentA) throw new NotFoundError(`Agent "${agentAId}" not found`);
-	const chatId = randomUUID();
-	return db.transaction(async (tx) => {
-		const [chat] = await tx.insert(chats).values({
-			id: chatId,
-			organizationId: agentA.organizationId,
-			type: "direct"
-		}).returning();
-		await tx.insert(chatParticipants).values([{
-			chatId,
-			agentId: agentAId,
-			role: "member"
-		}, {
-			chatId,
-			agentId: agentBId,
-			role: "member"
-		}]);
-		if (!chat) throw new Error("Unexpected: INSERT RETURNING produced no row");
-		return chat;
-	});
-}
 function serializeChat(chat) {
 	return {
 		...chat,
@@ -26264,24 +27190,112 @@ async function agentChatRoutes(app) {
 			joinedAt: p.joinedAt.toISOString()
 		})));
 	});
-	app.delete("/:chatId/participants/:agentId", async (request, reply) => {
+	app.delete("/:chatId/participants/:agentId", async (request, reply) => {
+		const identity = requireAgent(request);
+		await removeParticipant(app.db, request.params.chatId, identity.id, request.params.agentId);
+		return reply.status(204).send();
+	});
+}
+async function agentContextTreeRoutes(app) {
+	app.get("/", async (_request, reply) => {
+		const { repo, branch } = app.config.contextTree;
+		if (!repo) return reply.status(404).send({ error: "Context Tree not configured" });
+		return reply.send({
+			repo,
+			branch
+		});
+	});
+}
+async function agentFeishuBotRoutes(app) {
+	/**
+	* PUT /agent/me/feishu-bot
+	* Self-service: agent binds its own Feishu bot (upsert).
+	*/
+	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");
+		let config;
+		if (current) config = await updateAdapterConfig(app.db, current.id, {
+			credentials: {
+				app_id: body.appId,
+				app_secret: body.appSecret
+			},
+			status: "active"
+		}, app.config.secrets.encryptionKey);
+		else config = await createAdapterConfig(app.db, {
+			platform: "feishu",
+			agentId: identity.id,
+			credentials: {
+				app_id: body.appId,
+				app_secret: body.appSecret
+			},
+			status: "active"
+		}, app.config.secrets.encryptionKey);
+		app.adapterManager.reload().catch((err) => app.log.error(err, "Adapter reload failed after self-service bind"));
+		app.notifier.notifyConfigChange("adapter_configs").catch(() => {});
+		return reply.status(current ? 200 : 201).send({
+			...config,
+			createdAt: config.createdAt.toISOString(),
+			updatedAt: config.updatedAt.toISOString()
+		});
+	});
+	/**
+	* DELETE /agent/me/feishu-bot
+	* Self-service: agent unbinds its own Feishu bot.
+	*/
+	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");
+		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"));
+		app.notifier.notifyConfigChange("adapter_configs").catch(() => {});
+		return reply.status(204).send();
+	});
+}
+async function agentFeishuUserRoutes(app) {
+	/**
+	* POST /agent/delegated/:humanAgentId/feishu-user
+	* Assistant binds its owner's Feishu user ID via delegate_mention authorization.
+	*/
+	app.post("/:humanAgentId/feishu-user", async (request, reply) => {
+		const identity = requireAgent(request);
+		const { humanAgentId } = request.params;
+		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)"}".`);
+		const mapping = await createAgentMapping(app.db, {
+			platform: "feishu",
+			externalUserId: body.feishuUserId,
+			agentId: humanAgentId,
+			boundVia: "delegate",
+			displayName: body.displayName
+		});
+		return reply.status(201).send({
+			id: mapping.id,
+			platform: mapping.platform,
+			externalUserId: mapping.externalUserId,
+			agentId: mapping.agentId,
+			boundVia: mapping.boundVia,
+			displayName: mapping.displayName,
+			createdAt: mapping.createdAt.toISOString()
+		});
+	});
+	/**
+	* DELETE /agent/delegated/:humanAgentId/feishu-user
+	* Assistant unbinds its owner's Feishu user ID.
+	*/
+	app.delete("/:humanAgentId/feishu-user", async (request, reply) => {
 		const identity = requireAgent(request);
-		await removeParticipant(app.db, request.params.chatId, identity.id, request.params.agentId);
+		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}"`);
+		await app.db.delete(adapterAgentMappings).where(and(eq(adapterAgentMappings.platform, "feishu"), eq(adapterAgentMappings.agentId, humanAgentId)));
 		return reply.status(204).send();
 	});
 }
-/** Delivery queue (envelope). One entry per recipient created during message fan-out. Uses SKIP LOCKED for concurrent-safe consumption. */
-const inboxEntries = pgTable("inbox_entries", {
-	id: bigserial("id", { mode: "number" }).primaryKey(),
-	inboxId: text("inbox_id").notNull(),
-	messageId: text("message_id").notNull().references(() => messages.id),
-	chatId: text("chat_id"),
-	status: text("status").notNull().default("pending"),
-	retryCount: integer("retry_count").notNull().default(0),
-	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-	deliveredAt: timestamp("delivered_at", { withTimezone: true }),
-	ackedAt: timestamp("acked_at", { withTimezone: true })
-}, (table) => [unique("uq_inbox_delivery").on(table.inboxId, table.messageId, table.chatId), index("idx_inbox_pending").on(table.inboxId, table.createdAt)]);
 const DEFAULT_INBOX_TIMEOUT_SECONDS = 300;
 const DEFAULT_MAX_RETRY_COUNT = 3;
 async function pollInbox(db, inboxId, limit) {
@@ -26394,171 +27408,6 @@ async function agentMeRoutes(app) {
 		};
 	});
 }
-async function sendMessage(db, chatId, senderId, data) {
-	return db.transaction(async (tx) => {
-		const messageId = randomUUID();
-		const [msg] = await tx.insert(messages).values({
-			id: messageId,
-			chatId,
-			senderId,
-			format: data.format,
-			content: data.content,
-			metadata: data.metadata ?? {},
-			replyToInbox: data.replyToInbox ?? null,
-			replyToChat: data.replyToChat ?? null,
-			inReplyTo: data.inReplyTo ?? null
-		}).returning();
-		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) => ({
-			inboxId: p.inboxId,
-			messageId,
-			chatId
-		}));
-		if (entries.length > 0) await tx.insert(inboxEntries).values(entries);
-		const recipients = entries.map((e) => e.inboxId);
-		if (data.inReplyTo) {
-			const [original] = await tx.select({
-				replyToInbox: messages.replyToInbox,
-				replyToChat: messages.replyToChat
-			}).from(messages).where(eq(messages.id, data.inReplyTo)).limit(1);
-			if (original?.replyToInbox && original?.replyToChat) {
-				await tx.insert(inboxEntries).values({
-					inboxId: original.replyToInbox,
-					messageId,
-					chatId: original.replyToChat
-				}).onConflictDoNothing();
-				if (!recipients.includes(original.replyToInbox)) recipients.push(original.replyToInbox);
-			}
-		}
-		await tx.update(chats).set({ updatedAt: /* @__PURE__ */ new Date() }).where(eq(chats.id, chatId));
-		if (!msg) throw new Error("Unexpected: INSERT RETURNING produced no row");
-		return {
-			message: msg,
-			recipients
-		};
-	});
-}
-async function sendToAgent(db, senderId, targetAgentId, data) {
-	const [sender] = await db.select({
-		id: agents.id,
-		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, {
-		format: data.format,
-		content: data.content,
-		metadata: data.metadata,
-		replyToInbox: data.replyToInbox,
-		replyToChat: data.replyToChat
-	});
-}
-async function editMessage(db, chatId, messageId, senderId, data) {
-	const [msg] = await db.select().from(messages).where(eq(messages.id, messageId)).limit(1);
-	if (!msg) throw new NotFoundError(`Message "${messageId}" not found`);
-	if (msg.chatId !== chatId) throw new NotFoundError(`Message "${messageId}" not found in this chat`);
-	if (msg.senderId !== senderId) throw new ForbiddenError("Only the sender can edit a message");
-	const setClause = {};
-	if (data.format !== void 0) setClause.format = data.format;
-	if (data.content !== void 0) setClause.content = data.content;
-	const meta = msg.metadata ?? {};
-	meta.editedAt = (/* @__PURE__ */ new Date()).toISOString();
-	setClause.metadata = meta;
-	const [updated] = await db.update(messages).set(setClause).where(eq(messages.id, messageId)).returning();
-	if (!updated) throw new Error("Unexpected: UPDATE RETURNING produced no row");
-	return updated;
-}
-async function listMessages(db, chatId, limit, cursor) {
-	const where = cursor ? and(eq(messages.chatId, chatId), lt(messages.createdAt, new Date(cursor))) : eq(messages.chatId, chatId);
-	const rows = await db.select().from(messages).where(where).orderBy(desc(messages.createdAt)).limit(limit + 1);
-	const hasMore = rows.length > limit;
-	const items = hasMore ? rows.slice(0, limit) : rows;
-	const last = items[items.length - 1];
-	return {
-		items,
-		nextCursor: hasMore && last ? last.createdAt.toISOString() : null
-	};
-}
-const INBOX_CHANNEL = "inbox_notifications";
-const CONFIG_CHANNEL = "config_changes";
-function createNotifier(listenClient) {
-	const subscriptions = /* @__PURE__ */ new Map();
-	const configChangeHandlers = [];
-	let unlistenInboxFn = null;
-	let unlistenConfigFn = null;
-	function handleNotification(payload) {
-		const sepIdx = payload.indexOf(":");
-		if (sepIdx === -1) return;
-		const inboxId = payload.slice(0, sepIdx);
-		const messageId = payload.slice(sepIdx + 1);
-		const sockets = subscriptions.get(inboxId);
-		if (!sockets) return;
-		const data = JSON.stringify({
-			type: "new_message",
-			inboxId,
-			messageId
-		});
-		for (const ws of sockets) if (ws.readyState === ws.OPEN) ws.send(data);
-	}
-	return {
-		subscribe(inboxId, ws) {
-			let set = subscriptions.get(inboxId);
-			if (!set) {
-				set = /* @__PURE__ */ new Set();
-				subscriptions.set(inboxId, set);
-			}
-			set.add(ws);
-		},
-		unsubscribe(inboxId, ws) {
-			const set = subscriptions.get(inboxId);
-			if (set) {
-				set.delete(ws);
-				if (set.size === 0) subscriptions.delete(inboxId);
-			}
-		},
-		async notify(inboxId, messageId) {
-			try {
-				await listenClient`SELECT pg_notify(${INBOX_CHANNEL}, ${`${inboxId}:${messageId}`})`;
-			} catch {}
-		},
-		async notifyConfigChange(configType) {
-			try {
-				await listenClient`SELECT pg_notify(${CONFIG_CHANNEL}, ${configType})`;
-			} catch {}
-		},
-		onConfigChange(handler) {
-			configChangeHandlers.push(handler);
-		},
-		async start() {
-			unlistenInboxFn = (await listenClient.listen(INBOX_CHANNEL, (payload) => {
-				if (payload) handleNotification(payload);
-			})).unlisten;
-			unlistenConfigFn = (await listenClient.listen(CONFIG_CHANNEL, (payload) => {
-				if (payload) for (const handler of configChangeHandlers) handler(payload);
-			})).unlisten;
-		},
-		async stop() {
-			if (unlistenInboxFn) {
-				await unlistenInboxFn();
-				unlistenInboxFn = null;
-			}
-			if (unlistenConfigFn) {
-				await unlistenConfigFn();
-				unlistenConfigFn = null;
-			}
-		}
-	};
-}
-/** Fire-and-forget: notify all recipients that a new message is available. */
-function notifyRecipients(notifier, recipients, messageId) {
-	for (const inboxId of recipients) notifier.notify(inboxId, messageId).catch(() => {});
-}
 const editMessageSchema = z.object({
 	format: z.string().optional(),
 	content: z.unknown()
@@ -26640,6 +27489,62 @@ function agentWsRoutes(notifier, instanceId) {
 		});
 	};
 }
+async function bootstrapRoutes(app) {
+	/**
+	* POST /bootstrap/:agentId/token
+	* GitHub identity → Agent token.
+	* Only works when the agent has no active tokens.
+	*/
+	app.post("/:agentId/token", async (request, reply) => {
+		const { agentId } = request.params;
+		const githubUser = request.githubUser;
+		if (!githubUser) throw new ForbiddenError("GitHub authentication required");
+		const body = bootstrapTokenRequestSchema.parse(request.body ?? {});
+		const result = await bootstrapToken(app.db, agentId, githubUser.username, body.name);
+		return reply.status(201).send({
+			id: result.id,
+			agentId: result.agentId,
+			name: result.name,
+			token: result.token,
+			expiresAt: result.expiresAt?.toISOString() ?? null,
+			createdAt: result.createdAt.toISOString()
+		});
+	});
+	/**
+	* GET /bootstrap/:agentId/status
+	* Check if an agent exists and its status (for polling after PR merge + sync).
+	*/
+	app.get("/:agentId/status", async (request) => {
+		const { agentId } = 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}"`);
+			return {
+				exists: true,
+				status: agent.status
+			};
+		} catch (err) {
+			if (err instanceof NotFoundError) return {
+				exists: false,
+				status: null
+			};
+			throw err;
+		}
+	});
+}
+async function contextTreeInfoRoutes(app) {
+	/** Public endpoint — returns Context Tree repo metadata for CLI auto-discovery. */
+	app.get("/info", async () => {
+		const { repo, branch } = app.config.contextTree;
+		return {
+			repo,
+			branch,
+			lastSync: null
+		};
+	});
+}
 async function healthRoutes(app) {
 	app.get("/health", async () => {
 		try {
@@ -27207,6 +28112,25 @@ function agentAuthHook(db) {
 		request.agent = agent;
 	};
 }
+const GITHUB_API_URL = "https://api.github.com/user";
+/**
+* Middleware that validates a GitHub token from the `X-GitHub-Token` header.
+* On success, sets `request.githubUser = { username }`.
+*/
+function githubAuthHook() {
+	return async (request, _reply) => {
+		const token = request.headers["x-github-token"];
+		if (!token || typeof token !== "string") throw new UnauthorizedError("Missing X-GitHub-Token header");
+		const res = await fetch(GITHUB_API_URL, { headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: "application/vnd.github+json"
+		} });
+		if (!res.ok) throw new UnauthorizedError("Invalid GitHub token");
+		const data = await res.json();
+		if (!data.login) throw new ForbiddenError("Could not determine GitHub username from token");
+		request.githubUser = { username: data.login };
+	};
+}
 const PROXY_ENV_KEYS = [
 	"HTTP_PROXY",
 	"HTTPS_PROXY",
@@ -27440,6 +28364,12 @@ function parseEventData(appId, data) {
 	};
 }
 async function processInboundMessage(db, event, bot, log, inboxNotifier) {
+	const messageText = extractTextContent(event);
+	const bindMatch = /^\/bind\s+(\S+)/.exec(messageText);
+	if (bindMatch?.[1]) {
+		await handleBindCommand(db, bot, event, bindMatch[1], log);
+		return;
+	}
 	const agentMapping = await findAgentByExternalUser(db, "feishu", event.senderId);
 	if (!agentMapping) {
 		await replyUnknownUser(bot, event, log);
@@ -27482,8 +28412,9 @@ async function processInboundMessage(db, event, bot, log, inboxNotifier) {
 async function replyUnknownUser(bot, event, log) {
 	const text = [
 		"Your account is not linked to First Tree Hub yet.",
-		"Please contact your admin to set up the binding.",
-		`Your user ID: ${event.senderId}`
+		"To bind, send:  /bind <your-agent-id>",
+		"",
+		"Example:  /bind alice"
 	].join("\n");
 	try {
 		await botApiCall(bot, () => bot.client.im.v1.message.create({
@@ -27501,6 +28432,81 @@ async function replyUnknownUser(bot, event, log) {
 		}, "Failed to send unknown-user reply");
 	}
 }
+/** Extract plain text from a Feishu message event. */
+function extractTextContent(event) {
+	if (typeof event.content === "object" && event.content !== null && "text" in event.content) return (event.content.text ?? "").trim();
+	return "";
+}
+/**
+* Handle `/bind <agentId>` command from Feishu.
+* Binds the sender's Feishu user ID to the specified human agent.
+*/
+async function handleBindCommand(db, bot, event, agentId, log) {
+	const reply = async (text) => {
+		try {
+			await botApiCall(bot, () => bot.client.im.v1.message.create({
+				params: { receive_id_type: "chat_id" },
+				data: {
+					receive_id: event.externalChannelId,
+					msg_type: "text",
+					content: JSON.stringify({ text })
+				}
+			}));
+		} catch (err) {
+			log.warn({ err }, "Failed to send /bind reply");
+		}
+	};
+	const existingMapping = await findAgentByExternalUser(db, "feishu", event.senderId);
+	if (existingMapping) {
+		await reply(`You are already bound to agent "${existingMapping.agentId}". Unbind first if you want to rebind.`);
+		return;
+	}
+	const [agent] = await db.select({
+		id: agents.id,
+		type: agents.type,
+		status: agents.status
+	}).from(agents).where(eq(agents.id, agentId)).limit(1);
+	if (!agent) {
+		await reply(`Agent "${agentId}" not found. Check the ID and try again.`);
+		return;
+	}
+	if (agent.status !== "active") {
+		await reply(`Agent "${agentId}" is ${agent.status}. Only active agents can be bound.`);
+		return;
+	}
+	if (agent.type !== "human") {
+		await reply(`Agent "${agentId}" is not a human agent (type: ${agent.type}). Only human agents can bind Feishu users.`);
+		return;
+	}
+	const existingAgentBinding = await findExternalUserByAgent(db, "feishu", agentId);
+	if (existingAgentBinding) {
+		await reply(`Agent "${agentId}" is already bound to Feishu user ${existingAgentBinding.externalUserId}. Unbind first if you want to rebind.`);
+		return;
+	}
+	try {
+		await createAgentMapping(db, {
+			platform: "feishu",
+			externalUserId: event.senderId,
+			agentId,
+			boundVia: "command",
+			displayName: void 0
+		});
+	} catch (err) {
+		log.error({
+			err,
+			agentId,
+			senderId: event.senderId
+		}, "/bind: failed to create mapping");
+		await reply("Binding failed due to an internal error. Please try again or contact your admin.");
+		return;
+	}
+	await reply(`Binding successful! Your Feishu account is now linked to "${agentId}".`);
+	log.info({
+		agentId,
+		senderId: event.senderId,
+		appId: bot.appId
+	}, "/bind: Feishu user bound via command");
+}
 /**
 * Process outbound messages for all feishu-bound human agents.
 * Consumes pending inbox entries for human agents that have feishu platform bindings,
@@ -27695,6 +28701,7 @@ async function buildApp(config) {
 	});
 	const agentAuth = agentAuthHook(db);
 	const adminAuth = adminAuthHook(db, config.secrets.jwtSecret);
+	const githubAuth = githubAuthHook();
 	app.setErrorHandler((error, _request, reply) => {
 		if (error instanceof AppError) return reply.status(error.statusCode).send({ error: error.message });
 		if (error instanceof ZodError) return reply.status(400).send({
@@ -27709,6 +28716,11 @@ async function buildApp(config) {
 		await api.register(healthRoutes);
 		await api.register(githubWebhookRoutes, { prefix: "/webhooks" });
 		await api.register(adminAuthRoutes, { prefix: "/admin/auth" });
+		await api.register(contextTreeInfoRoutes, { prefix: "/context-tree" });
+		await api.register(async (bootstrapApp) => {
+			bootstrapApp.addHook("onRequest", githubAuth);
+			await bootstrapApp.register(bootstrapRoutes);
+		}, { prefix: "/bootstrap" });
 		await api.register(async (adminApp) => {
 			adminApp.addHook("onRequest", adminAuth);
 			await adminApp.register(adminAgentRoutes);
@@ -27752,6 +28764,9 @@ async function buildApp(config) {
 			await agentApp.register(agentMessageRoutes, { prefix: "/chats" });
 			await agentApp.register(agentSendToAgentRoutes, { prefix: "/agents" });
 			await agentApp.register(agentInboxRoutes, { prefix: "/inbox" });
+			await agentApp.register(agentContextTreeRoutes, { prefix: "/context-tree" });
+			await agentApp.register(agentFeishuBotRoutes);
+			await agentApp.register(agentFeishuUserRoutes, { prefix: "/delegated" });
 			await agentApp.register(agentWsRoutes(notifier, config.instanceId), { prefix: "/ws" });
 		}, { prefix: "/agent" });
 	}, { prefix: "/api/v1" });
@@ -27911,4 +28926,4 @@ function resolveWebDist() {
 	} catch {}
 }
 //#endregion
-export { loadRuntimeConfig as A, readConfigFile as B, stopPostgres as C, FirstTreeHubSDK as D, AgentSlot as E, agentConfigSchema as F, resetConfigMeta as H, clientConfigSchema as I, getConfigValue as L, createAdminUser$1 as M, hasAdminUser as N, SdkError as O, DEFAULT_CONFIG_DIR as P, initConfig as R, isDockerAvailable as S, AgentRuntime as T, serverConfigSchema as U, resetConfig as V, setConfigValue as W, checkWebSocket as _, runMigrations as a, status as b, checkClientConfig as c, checkDocker as d, checkGitHubToken as f, checkServerReachable as g, checkServerHealth as h, promptMissingFields as i, registerBuiltinHandlers as j, getHandlerFactory as k, checkContextTreeRepo as l, checkServerConfig as m, isInteractive as n, checkAgentConfigs as o, checkNodeVersion as p, promptAddAgent as r, checkAgentTokens as s, startServer as t, checkDatabase as u, printResults as v, ClientRuntime as w, ensurePostgres as x, blank as y, loadAgents as z };
+export { ClientRuntime as A, registerBuiltinHandlers as B, checkWebSocket as C, ensurePostgres as D, status as E, SdkError as F, hasAdminUser as H, SessionRegistry as I, cleanWorkspaces as L, AgentSlot as M, DEFAULT_WORKSPACE_TTL_MS as N, isDockerAvailable as O, FirstTreeHubSDK as P, getHandlerFactory as R, checkServerReachable as S, blank as T, createAdminUser$1 as V, checkDocker as _, formatCheckReport as a, checkServerConfig as b, onboardContinue as c, runMigrations as d, checkAgentConfigs as f, checkDatabase as g, checkContextTreeRepo as h, promptMissingFields as i, AgentRuntime as j, stopPostgres as k, onboardCreate as l, checkClientConfig as m, isInteractive as n, loadOnboardState as o, checkAgentTokens as p, promptAddAgent as r, onboardCheck as s, startServer as t, saveOnboardState as u, checkGitHubToken as v, printResults as w, checkServerHealth as x, checkNodeVersion as y, loadRuntimeConfig as z };