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

package/dist/{core-CD3xEbyB.mjs → core-uG-Hkr9K.mjs}

@@ -1,11 +1,11 @@
 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 { 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 { EventEmitter } from "node:events";
@@ -36,7 +36,7 @@ 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) {
+function field$1(schema, options) {
 	return {
 		_tag: "field",
 		_type: void 0,
@@ -45,46 +45,47 @@ function field(schema, options) {
 	};
 }
 /** Mark a config group as optional — present only when at least one field has an explicit value. */
-function optional(shape) {
+function optional$1(shape) {
 	return {
 		_tag: "optional",
 		shape
 	};
 }
 /** Define a config shape. Identity function used for type inference. */
-function defineConfig(shape) {
+function defineConfig$1(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)),
+const agentConfigSchema = defineConfig$1({
+	token: field$1(z.string(), { secret: true }),
+	type: field$1(z.string().default("claude-code")),
+	concurrency: field$1(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))
+		idle_timeout: field$1(z.number().int().positive().default(300)),
+		max_sessions: field$1(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(), {
+const clientConfigSchema = defineConfig$1({
+	server: { url: field$1(z.string(), {
 		env: "FIRST_TREE_HUB_SERVER_URL",
 		prompt: {
 			message: "Server URL:",
 			default: "http://localhost:8000"
 		}
 	}) },
-	logLevel: field(z.enum([
+	logLevel: field$1(z.enum([
 		"debug",
 		"info",
 		"warn",
 		"error"
 	]).default("info"), { env: "FIRST_TREE_HUB_LOG_LEVEL" })
 });
-const DEFAULT_CONFIG_DIR = join(homedir(), ".first-tree-hub");
+const DEFAULT_HOME_DIR$1 = join(homedir(), ".first-tree-hub");
+const DEFAULT_CONFIG_DIR = join(DEFAULT_HOME_DIR$1, "config");
+const DEFAULT_DATA_DIR$1 = join(DEFAULT_HOME_DIR$1, "data");
 function isFieldDef(value) {
 	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "field";
 }
@@ -425,9 +426,9 @@ function loadAgents(options) {
 	}
 	return result;
 }
-const serverConfigSchema = defineConfig({
+const serverConfigSchema = defineConfig$1({
 	database: {
-		url: field(z.string(), {
+		url: field$1(z.string(), {
 			env: "FIRST_TREE_HUB_DATABASE_URL",
 			auto: "docker-pg",
 			prompt: {
@@ -442,34 +443,34 @@ const serverConfigSchema = defineConfig({
 				}]
 			}
 		}),
-		provider: field(z.enum(["docker", "external"]).default("docker"))
+		provider: field$1(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" })
+		port: field$1(z.number().default(8e3), { env: "FIRST_TREE_HUB_PORT" }),
+		host: field$1(z.string().default("127.0.0.1"), { env: "FIRST_TREE_HUB_HOST" })
 	},
 	secrets: {
-		jwtSecret: field(z.string(), {
+		jwtSecret: field$1(z.string(), {
 			env: "FIRST_TREE_HUB_JWT_SECRET",
 			auto: "random:base64url:32",
 			secret: true
 		}),
-		encryptionKey: field(z.string(), {
+		encryptionKey: field$1(z.string(), {
 			env: "FIRST_TREE_HUB_ENCRYPTION_KEY",
 			auto: "random:hex:32",
 			secret: true
 		})
 	},
 	contextTree: {
-		repo: field(z.string(), {
+		repo: field$1(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))
+		branch: field$1(z.string().default("main")),
+		syncInterval: field$1(z.number().default(60))
 	},
 	github: {
-		token: field(z.string(), {
+		token: field$1(z.string(), {
 			env: "FIRST_TREE_HUB_GITHUB_TOKEN",
 			secret: true,
 			prompt: {
@@ -477,16 +478,16 @@ const serverConfigSchema = defineConfig({
 				type: "password"
 			}
 		}),
-		webhookSecret: field(z.string().optional(), {
+		webhookSecret: field$1(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" })
+	cors: optional$1({ origin: field$1(z.string(), { env: "FIRST_TREE_HUB_CORS_ORIGIN" }) }),
+	rateLimit: optional$1({
+		max: field$1(z.number().default(100), { env: "FIRST_TREE_HUB_RATE_LIMIT_MAX" }),
+		loginMax: field$1(z.number().default(5), { env: "FIRST_TREE_HUB_RATE_LIMIT_LOGIN_MAX" }),
+		webhookMax: field$1(z.number().default(60), { env: "FIRST_TREE_HUB_RATE_LIMIT_WEBHOOK_MAX" })
 	})
 });
 //#endregion
@@ -22846,6 +22847,7 @@ function Aa({ prompt: $, options: X }) {
 }
 //#endregion
 //#region ../client/dist/index.mjs
+const FETCH_TIMEOUT_MS = 15e3;
 var FirstTreeHubSDK = class {
 	_baseUrl;
 	_token;
@@ -22868,9 +22870,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 +22934,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 +22964,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 +22984,7 @@ var AgentConnection = class extends EventEmitter {
 	pollingInterval;
 	pullLimit;
 	serverUrl;
+	rateLimitedUntil = 0;
 	constructor(config) {
 		super();
 		this.serverUrl = config.serverUrl.replace(/\/+$/, "");
@@ -23010,10 +23027,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 +23049,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 +23070,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 +23096,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 +23116,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,6 +23173,301 @@ function getHandlerFactory(type) {
 	}
 	return factory;
 }
+/** 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))
+	}
+});
+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 = 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, ".git"))) {
+			if (execFileSync("git", [
+				"rev-parse",
+				"--abbrev-ref",
+				"HEAD"
+			], {
+				cwd: CONTEXT_TREE_DIR,
+				encoding: "utf-8",
+				timeout: 5e3
+			}).trim() !== branch) {
+				execFileSync("git", ["checkout", branch], {
+					cwd: CONTEXT_TREE_DIR,
+					stdio: "pipe",
+					timeout: 1e4
+				});
+				log(`Context Tree switched to branch ${branch}`);
+			}
+			execFileSync("git", ["pull", "--ff-only"], {
+				cwd: CONTEXT_TREE_DIR,
+				stdio: "pipe",
+				timeout: 3e4
+			});
+			log(`Context Tree updated (pull)`);
+		} else {
+			mkdirSync(CONTEXT_TREE_DIR, { recursive: true });
+			execFileSync("git", [
+				"clone",
+				"--branch",
+				branch,
+				"--single-branch",
+				repo,
+				CONTEXT_TREE_DIR
+			], {
+				stdio: "pipe",
+				timeout: 6e4
+			});
+			log(`Context Tree cloned from ${repo} (branch: ${branch})`);
+		}
+		return CONTEXT_TREE_DIR;
+	} 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, ".git"))) {
+			log("Diverged history detected, attempting fresh clone...");
+			try {
+				rmSync(CONTEXT_TREE_DIR, {
+					recursive: true,
+					force: true
+				});
+				mkdirSync(CONTEXT_TREE_DIR, { recursive: true });
+				execFileSync("git", [
+					"clone",
+					"--branch",
+					branch,
+					"--single-branch",
+					repo,
+					CONTEXT_TREE_DIR
+				], {
+					stdio: "pipe",
+					timeout: 6e4
+				});
+				log("Context Tree re-cloned successfully");
+				return CONTEXT_TREE_DIR;
+			} catch {
+				log("Context Tree re-clone also failed, continuing without context");
+			}
+		}
+		if (existsSync(join(CONTEXT_TREE_DIR, ".git"))) {
+			log("Using existing Context Tree clone despite sync failure");
+			return CONTEXT_TREE_DIR;
+		}
+		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.
 *
@@ -23156,6 +23522,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 +23571,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 +23581,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 +23634,7 @@ const createClaudeCodeHandler = (config) => {
 			options: {
 				sessionId: resume ? void 0 : sessionId,
 				resume,
-				cwd,
+				cwd: cwd ?? void 0,
 				persistSession: true,
 				abortController,
 				permissionMode,
@@ -23228,10 +23651,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 +23667,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 +23689,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 +23718,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 +23755,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 +24198,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 +24239,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 +24270,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}`);
@@ -24705,6 +25212,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()),
@@ -24832,7 +25340,7 @@ const SYSTEM_CONFIG_DEFAULTS = {
 	[SYSTEM_CONFIG_KEYS.PRESENCE_CLEANUP_SECONDS]: 60
 };
 //#endregion
-//#region ../server/dist/app-DUdS4lE-.mjs
+//#region ../server/dist/app-DtKgrri9.mjs
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -24850,6 +25358,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({}),
@@ -25331,6 +25840,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 +25854,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,36 +25883,128 @@ 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) {
-		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
-		});
-	}
-	return members;
+	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;
 }
-/** Parse NODE.md frontmatter for agent metadata. */
-function parseNodeMetadata(content) {
-	const match = /^---\n([\s\S]*?)\n---/.exec(content);
-	if (!match) return {
-		type: "autonomous_agent",
-		displayName: null,
-		delegateMention: 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;
-	};
-	return {
-		type: getValue("type") ?? "autonomous_agent",
-		displayName: getValue("display_name") ?? getValue("title") ?? getValue("name"),
-		delegateMention: getValue("delegate_mention")
-	};
+/**
+* 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;
+		if (nodeMdPaths.has(`${entry.path}/NODE.md`)) memberDirs.push(entry.path);
+	}
+	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) {
+	const match = /^---\n([\s\S]*?)\n---/.exec(content);
+	if (!match) return {
+		type: "autonomous_agent",
+		displayName: null,
+		delegateMention: 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;
+	};
+	return {
+		type: getValue("type") ?? "autonomous_agent",
+		displayName: getValue("display_name") ?? getValue("title") ?? getValue("name"),
+		delegateMention: getValue("delegate_mention")
+	};
 }
 /** Stored for the /status endpoint */
 let _lastSyncResult;
@@ -25455,31 +26039,31 @@ async function syncFromGitHub(db, repo, branch, githubToken) {
 			displayName: null,
 			delegateMention: null
 		};
-		const existing = await db.execute(sql`SELECT id, status, type, display_name, delegate_mention FROM agents WHERE id = ${member.name}`);
+		const existing = await db.execute(sql`SELECT id, status, type, display_name, delegate_mention, tree_path 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)
+          VALUES (${member.name}, ${meta.type}, ${meta.displayName}, ${meta.delegateMention}, ${member.treePath}, 'active', ${`inbox_${member.name}`})
         `);
 			result.created++;
 		} else {
 			const agent = existing[0];
 			if (agent.status === "suspended") {
 				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}
             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) {
 				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}
             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 +26167,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,
@@ -25658,6 +26243,133 @@ async function revokeToken(db, agentId, tokenId) {
 	if (!token) throw new NotFoundError("Token not found or already revoked");
 	return token;
 }
+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;
+	});
+}
 /** 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. */
@@ -25687,36 +26399,217 @@ function forceDisconnect(agentId) {
 	activeConnections.delete(agentId);
 	return true;
 }
-/** 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(),
-	lastHeartbeat: timestamp("last_heartbeat", { withTimezone: true }).notNull().defaultNow()
-});
-async function setOnline(db, agentId, instanceId) {
-	const now = /* @__PURE__ */ new Date();
-	await db.insert(agentPresence).values({
-		agentId,
-		status: "online",
-		instanceId,
-		connectedAt: now,
-		lastSeenAt: now
-	}).onConflictDoUpdate({
-		target: agentPresence.agentId,
-		set: {
-			status: "online",
-			instanceId,
-			connectedAt: now,
-			lastSeenAt: now
+/** 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);
+			}
 		}
-	});
-}
-async function setOffline(db, agentId) {
-	await db.update(agentPresence).set({
+		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(),
+	lastHeartbeat: timestamp("last_heartbeat", { withTimezone: true }).notNull().defaultNow()
+});
+async function setOnline(db, agentId, instanceId) {
+	const now = /* @__PURE__ */ new Date();
+	await db.insert(agentPresence).values({
+		agentId,
+		status: "online",
+		instanceId,
+		connectedAt: now,
+		lastSeenAt: now
+	}).onConflictDoUpdate({
+		target: agentPresence.agentId,
+		set: {
+			status: "online",
+			instanceId,
+			connectedAt: now,
+			lastSeenAt: now
+		}
+	});
+}
+async function setOffline(db, agentId) {
+	await db.update(agentPresence).set({
 		status: "offline",
 		instanceId: null,
 		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 +26694,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 +26979,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 +27029,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,
@@ -26270,18 +27085,16 @@ async function agentChatRoutes(app) {
 		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)]);
+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
+		});
+	});
+}
 const DEFAULT_INBOX_TIMEOUT_SECONDS = 300;
 const DEFAULT_MAX_RETRY_COUNT = 3;
 async function pollInbox(db, inboxId, limit) {
@@ -26394,171 +27207,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()
@@ -27752,6 +28400,7 @@ 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(agentWsRoutes(notifier, config.instanceId), { prefix: "/ws" });
 		}, { prefix: "/agent" });
 	}, { prefix: "/api/v1" });
@@ -27911,4 +28560,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 { SessionRegistry as A, clientConfigSchema as B, stopPostgres as C, DEFAULT_WORKSPACE_TTL_MS as D, AgentSlot as E, createAdminUser$1 as F, resetConfig as G, initConfig as H, hasAdminUser as I, setConfigValue as J, resetConfigMeta as K, DEFAULT_CONFIG_DIR as L, getHandlerFactory as M, loadRuntimeConfig as N, FirstTreeHubSDK as O, registerBuiltinHandlers as P, DEFAULT_DATA_DIR$1 as R, isDockerAvailable as S, AgentRuntime as T, loadAgents as U, getConfigValue as V, readConfigFile 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, cleanWorkspaces as j, SdkError as k, checkContextTreeRepo as l, checkServerConfig as m, isInteractive as n, checkAgentConfigs as o, checkNodeVersion as p, serverConfigSchema as q, promptAddAgent as r, checkAgentTokens as s, startServer as t, checkDatabase as u, printResults as v, ClientRuntime as w, ensurePostgres as x, blank as y, agentConfigSchema as z };