@csdwd/ai-teams-server 0.1.0

package/dist/index.js

@@ -0,0 +1,2364 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import Fastify from "fastify";
+import swagger from "@fastify/swagger";
+import swaggerUi from "@fastify/swagger-ui";
+import websocket from "@fastify/websocket";
+import fastifyStatic from "@fastify/static";
+
+// ../../packages/shared/dist/index.js
+var ProtocolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProtocolError";
+  }
+};
+function parseJsonMessage(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ProtocolError("Message is not valid JSON.");
+  }
+}
+function parseLeaderToServerMessage(value) {
+  const message = objectValue(value, "message");
+  const type = stringField(message, "type");
+  if (type === "command.dispatch") {
+    return {
+      type,
+      atAgents: agentTargetField(message, "atAgents"),
+      prompt: nonEmptyStringField(message, "prompt"),
+      workspace: optionalStringField(message, "workspace"),
+      timeoutSec: optionalPositiveNumberField(message, "timeoutSec")
+    };
+  }
+  if (type === "command.send") {
+    return {
+      type,
+      employeeId: nonEmptyStringField(message, "employeeId"),
+      prompt: nonEmptyStringField(message, "prompt"),
+      workspace: optionalStringField(message, "workspace"),
+      timeoutSec: optionalPositiveNumberField(message, "timeoutSec")
+    };
+  }
+  if (type === "command.broadcast") {
+    return {
+      type,
+      prompt: nonEmptyStringField(message, "prompt"),
+      workspace: optionalStringField(message, "workspace"),
+      timeoutSec: optionalPositiveNumberField(message, "timeoutSec")
+    };
+  }
+  if (type === "task.cancel") {
+    return { type, taskId: nonEmptyStringField(message, "taskId") };
+  }
+  throw new ProtocolError(`Unsupported leader message type: ${type}`);
+}
+function parseEmployeeToServerMessage(value) {
+  const message = objectValue(value, "message");
+  const type = stringField(message, "type");
+  if (type === "agent.register") {
+    return {
+      type,
+      employeeId: nonEmptyStringField(message, "employeeId"),
+      name: nonEmptyStringField(message, "name"),
+      machineId: nonEmptyStringField(message, "machineId"),
+      hostname: nonEmptyStringField(message, "hostname"),
+      labels: stringArrayField(message, "labels"),
+      activeMainTaskId: optionalNullableStringField(message, "activeMainTaskId"),
+      activeQueueTaskId: optionalNullableStringField(message, "activeQueueTaskId"),
+      lastOutputSeq: optionalNonNegativeNumberField(message, "lastOutputSeq")
+    };
+  }
+  if (type === "agent.heartbeat") {
+    return { type, employeeId: nonEmptyStringField(message, "employeeId") };
+  }
+  if (type === "agent.request_task") {
+    return { type, employeeId: nonEmptyStringField(message, "employeeId") };
+  }
+  if (type === "task.accepted" || type === "task.cancelled") {
+    return { type, taskId: nonEmptyStringField(message, "taskId") };
+  }
+  if (type === "task.started") {
+    return {
+      type,
+      taskId: nonEmptyStringField(message, "taskId"),
+      pid: nonNegativeNumberField(message, "pid"),
+      sessionId: optionalNullableStringField(message, "sessionId")
+    };
+  }
+  if (type === "task.output") {
+    const stream = stringField(message, "stream");
+    if (stream !== "stdout" && stream !== "stderr") {
+      throw new ProtocolError("task.output.stream must be stdout or stderr.");
+    }
+    return {
+      type,
+      taskId: nonEmptyStringField(message, "taskId"),
+      stream,
+      seq: positiveIntegerField(message, "seq"),
+      content: stringField(message, "content")
+    };
+  }
+  if (type === "task.completed") {
+    return {
+      type,
+      taskId: nonEmptyStringField(message, "taskId"),
+      exitCode: nonNegativeNumberField(message, "exitCode"),
+      summary: optionalStringField(message, "summary"),
+      durationMs: optionalNonNegativeNumberField(message, "durationMs"),
+      durationApiMs: optionalNonNegativeNumberField(message, "durationApiMs"),
+      numTurns: optionalNonNegativeNumberField(message, "numTurns"),
+      totalCostUsd: optionalNonNegativeNumberField(message, "totalCostUsd"),
+      usageInputTokens: optionalNonNegativeNumberField(message, "usageInputTokens"),
+      usageOutputTokens: optionalNonNegativeNumberField(message, "usageOutputTokens"),
+      usageCacheReadTokens: optionalNonNegativeNumberField(message, "usageCacheReadTokens"),
+      usageCacheCreationTokens: optionalNonNegativeNumberField(message, "usageCacheCreationTokens")
+    };
+  }
+  if (type === "task.failed") {
+    return { type, taskId: nonEmptyStringField(message, "taskId"), error: nonEmptyStringField(message, "error") };
+  }
+  throw new ProtocolError(`Unsupported employee message type: ${type}`);
+}
+function objectValue(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ProtocolError(`${label} must be an object.`);
+  }
+  return value;
+}
+function stringField(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new ProtocolError(`${key} must be a string.`);
+  }
+  return value;
+}
+function nonEmptyStringField(record, key) {
+  const value = stringField(record, key).trim();
+  if (!value) {
+    throw new ProtocolError(`${key} must not be empty.`);
+  }
+  return value;
+}
+function optionalStringField(record, key) {
+  const value = record[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new ProtocolError(`${key} must be a string.`);
+  }
+  return value;
+}
+function optionalNullableStringField(record, key) {
+  const value = record[key];
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    throw new ProtocolError(`${key} must be a string or null.`);
+  }
+  return value;
+}
+function stringArrayField(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new ProtocolError(`${key} must be a string array.`);
+  }
+  return value;
+}
+function agentTargetField(record, key) {
+  const value = record[key];
+  if (value === "queue") {
+    return "queue";
+  }
+  if (value === "all") {
+    return "all";
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) {
+    throw new ProtocolError(`${key} must be "queue", "all", or a non-empty string array.`);
+  }
+  return value.map((item) => item.trim());
+}
+function positiveNumberField(record, key) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new ProtocolError(`${key} must be a positive number.`);
+  }
+  return value;
+}
+function optionalPositiveNumberField(record, key) {
+  if (record[key] === void 0) {
+    return void 0;
+  }
+  return positiveNumberField(record, key);
+}
+function nonNegativeNumberField(record, key) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new ProtocolError(`${key} must be a non-negative number.`);
+  }
+  return value;
+}
+function optionalNonNegativeNumberField(record, key) {
+  if (record[key] === void 0) {
+    return void 0;
+  }
+  return nonNegativeNumberField(record, key);
+}
+function positiveIntegerField(record, key) {
+  const value = positiveNumberField(record, key);
+  if (!Number.isInteger(value)) {
+    throw new ProtocolError(`${key} must be an integer.`);
+  }
+  return value;
+}
+function isEncryptedEnvelope(value) {
+  return typeof value === "object" && value !== null && value.encrypted === true && typeof value.iv === "string" && typeof value.ciphertext === "string" && typeof value.tag === "string";
+}
+function parseEncryptionKey(hex) {
+  const key = Buffer.from(hex, "hex");
+  if (key.length !== 32) {
+    throw new Error("AI_TEAMS_ENCRYPTION_KEY must be 32 bytes (64 hex characters).");
+  }
+  return key;
+}
+
+// src/db.ts
+import { DatabaseSync } from "node:sqlite";
+import pg from "pg";
+var SqliteDatabase = class _SqliteDatabase {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static toSqlite(sql, params) {
+    let idx = 0;
+    const converted = sql.replace(/\$\d+/g, () => {
+      idx += 1;
+      return "?";
+    });
+    return { sql: converted, params: params ?? [] };
+  }
+  async run(sql, params) {
+    const { sql: q, params: p } = _SqliteDatabase.toSqlite(sql, params);
+    this.db.prepare(q).run(...p);
+  }
+  async get(sql, params) {
+    const { sql: q, params: p } = _SqliteDatabase.toSqlite(sql, params);
+    return this.db.prepare(q).get(...p);
+  }
+  async all(sql, params) {
+    const { sql: q, params: p } = _SqliteDatabase.toSqlite(sql, params);
+    return this.db.prepare(q).all(...p);
+  }
+  async close() {
+    this.db.close();
+  }
+};
+var PostgresDatabase = class {
+  pool;
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async run(sql, params) {
+    await this.pool.query(sql, params ?? []);
+  }
+  async get(sql, params) {
+    const result = await this.pool.query(sql, params ?? []);
+    return result.rows[0] ?? void 0;
+  }
+  async all(sql, params) {
+    const result = await this.pool.query(sql, params ?? []);
+    return result.rows;
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+async function createDatabaseFromEnv(env) {
+  const databaseUrl = env.DATABASE_URL;
+  if (databaseUrl) {
+    const pool = new pg.Pool({ connectionString: databaseUrl });
+    return new PostgresDatabase(pool);
+  }
+  const dataDir = env.DATA_DIR ?? process.cwd();
+  const dbPath = env.DB_PATH ?? `${dataDir}/ai-teams.db`;
+  const { mkdirSync } = await import("node:fs");
+  const { dirname } = await import("node:path");
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  return new SqliteDatabase(db);
+}
+async function initDb(db) {
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  await db.run(`
+    INSERT INTO schema_meta (key, value)
+    VALUES ('version', '2')
+    ON CONFLICT(key) DO UPDATE SET value = '2'
+  `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS employees (
+      id TEXT PRIMARY KEY,
+      payload_json TEXT NOT NULL
+    )
+  `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id                          TEXT PRIMARY KEY,
+      leader_command_id           TEXT NOT NULL,
+      employee_id                 TEXT,
+      session_id                  TEXT,
+      target_mode                 TEXT NOT NULL DEFAULT 'queue',
+      prompt                      TEXT NOT NULL,
+      workspace                   TEXT,
+      status                      TEXT NOT NULL DEFAULT 'queued',
+      timeout_sec                 INTEGER NOT NULL DEFAULT 1800,
+      cli_config                  TEXT,
+      priority                    INTEGER NOT NULL DEFAULT 1,
+      required_labels             TEXT,
+      created_at                  TEXT NOT NULL,
+      started_at                  TEXT,
+      finished_at                 TEXT,
+      exit_code                   INTEGER,
+      summary                     TEXT,
+      error                       TEXT,
+      duration_ms                 INTEGER,
+      duration_api_ms             INTEGER,
+      num_turns                   INTEGER,
+      total_cost_usd              REAL,
+      usage_input_tokens          INTEGER,
+      usage_output_tokens         INTEGER,
+      usage_cache_read_tokens     INTEGER,
+      usage_cache_creation_tokens INTEGER
+    )
+  `);
+  await db.run(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)
+  `);
+  await db.run(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_employee ON tasks(employee_id)
+  `);
+  await db.run(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_leader_cmd ON tasks(leader_command_id)
+  `);
+  await db.run(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id)
+  `);
+  await db.run(`
+    CREATE INDEX IF NOT EXISTS idx_tasks_created ON tasks(created_at)
+  `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS task_logs (
+      task_id       TEXT NOT NULL,
+      seq           INTEGER NOT NULL,
+      payload_json  TEXT NOT NULL,
+      PRIMARY KEY (task_id, seq)
+    )
+  `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS task_webhooks (
+      task_id      TEXT PRIMARY KEY,
+      webhook_url  TEXT NOT NULL
+    )
+  `);
+}
+async function hydrateState(db, state, defaultTimeoutSec, maxLogChunksPerTask) {
+  const employeeRows = await db.all("SELECT payload_json FROM employees");
+  for (const row of employeeRows) {
+    const employee = JSON.parse(row.payload_json);
+    employee.status = "offline";
+    state.employees.set(employee.id, employee);
+  }
+  const taskRows = await db.all("SELECT * FROM tasks");
+  for (const row of taskRows) {
+    const task = dbRowToTask(row, defaultTimeoutSec);
+    state.tasks.set(task.id, task);
+    if (task.status === "queued") {
+      if (task.targetMode === "queue" || !task.employeeId) {
+        state.sharedTaskQueue.push(task.id);
+      } else {
+        const queue = state.taskQueues.get(task.employeeId) ?? [];
+        queue.push(task.id);
+        state.taskQueues.set(task.employeeId, queue);
+      }
+    }
+  }
+  const logRows = await db.all(
+    `SELECT payload_json FROM (
+      SELECT task_id, seq, payload_json,
+      ROW_NUMBER() OVER (PARTITION BY task_id ORDER BY seq DESC) AS rn
+      FROM task_logs
+    ) sub
+    WHERE rn <= $1
+    ORDER BY task_id ASC, seq ASC`,
+    [maxLogChunksPerTask]
+  );
+  for (const row of logRows) {
+    const chunk = JSON.parse(row.payload_json);
+    const history = state.taskLogs.get(chunk.taskId) ?? [];
+    history.push(chunk);
+    state.taskLogs.set(chunk.taskId, history);
+  }
+  const webhookRows = await db.all("SELECT task_id, webhook_url FROM task_webhooks");
+  for (const row of webhookRows) {
+    state.taskWebhooks.set(row.task_id, row.webhook_url);
+  }
+  const cursorRow = await db.get("SELECT value FROM schema_meta WHERE key = 'sharedQueueCursor'");
+  if (cursorRow) {
+    state.sharedQueueCursor = Number(cursorRow.value) || 0;
+  }
+}
+async function persistEmployee(db, employee) {
+  await db.run(
+    `INSERT INTO employees (id, payload_json)
+     VALUES ($1, $2)
+     ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json`,
+    [employee.id, JSON.stringify(employee)]
+  );
+}
+var TASK_COLUMNS = [
+  "id",
+  "leader_command_id",
+  "employee_id",
+  "session_id",
+  "target_mode",
+  "prompt",
+  "workspace",
+  "status",
+  "timeout_sec",
+  "cli_config",
+  "priority",
+  "required_labels",
+  "created_at",
+  "started_at",
+  "finished_at",
+  "exit_code",
+  "summary",
+  "error",
+  "duration_ms",
+  "duration_api_ms",
+  "num_turns",
+  "total_cost_usd",
+  "usage_input_tokens",
+  "usage_output_tokens",
+  "usage_cache_read_tokens",
+  "usage_cache_creation_tokens"
+];
+var TASK_PLACEHOLDERS = TASK_COLUMNS.map((_, i) => `$${i + 1}`).join(", ");
+var TASK_UPDATE_SET = TASK_COLUMNS.slice(1).map((col) => `${col} = excluded.${col}`).join(", ");
+async function persistTask(db, task) {
+  const values = taskToDbValues(task);
+  await db.run(
+    `INSERT INTO tasks (${TASK_COLUMNS.join(", ")})
+     VALUES (${TASK_PLACEHOLDERS})
+     ON CONFLICT(id) DO UPDATE SET ${TASK_UPDATE_SET}`,
+    values
+  );
+}
+async function persistTaskWebhook(db, taskId, webhookUrl) {
+  await db.run(
+    `INSERT INTO task_webhooks (task_id, webhook_url)
+     VALUES ($1, $2)
+     ON CONFLICT(task_id) DO UPDATE SET webhook_url = excluded.webhook_url`,
+    [taskId, webhookUrl]
+  );
+}
+async function persistSharedQueueCursor(db, cursor) {
+  await db.run(
+    `INSERT INTO schema_meta (key, value)
+     VALUES ('sharedQueueCursor', $1)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+    [String(cursor)]
+  );
+}
+async function persistTaskLog(db, chunk, maxLogChunksPerTask) {
+  await db.run(
+    `INSERT INTO task_logs (task_id, seq, payload_json)
+     VALUES ($1, $2, $3)
+     ON CONFLICT(task_id, seq) DO UPDATE SET payload_json = excluded.payload_json`,
+    [chunk.taskId, chunk.seq, JSON.stringify(chunk)]
+  );
+  await db.run(
+    `DELETE FROM task_logs
+     WHERE task_id = $1
+       AND seq NOT IN (
+         SELECT seq FROM task_logs
+         WHERE task_id = $2
+         ORDER BY seq DESC
+         LIMIT $3
+       )`,
+    [chunk.taskId, chunk.taskId, maxLogChunksPerTask]
+  );
+}
+async function queryTasks(db, filters) {
+  const conditions = [];
+  const params = [];
+  let paramIdx = 1;
+  if (filters.status) {
+    conditions.push(`status = $${paramIdx++}`);
+    params.push(filters.status);
+  }
+  if (filters.employeeId) {
+    conditions.push(`employee_id = $${paramIdx++}`);
+    params.push(filters.employeeId);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters.limit ?? 50;
+  const offset = filters.offset ?? 0;
+  params.push(limit, offset);
+  return db.all(
+    `SELECT * FROM tasks ${where} ORDER BY created_at DESC LIMIT $${paramIdx++} OFFSET $${paramIdx++}`,
+    params
+  );
+}
+async function getTaskById(db, taskId) {
+  return db.get("SELECT * FROM tasks WHERE id = $1", [taskId]);
+}
+async function deleteTask(db, taskId) {
+  const row = await db.get("SELECT status FROM tasks WHERE id = $1", [taskId]);
+  if (!row) return false;
+  if (!["completed", "failed", "cancelled", "timeout"].includes(row.status)) return false;
+  await db.run("DELETE FROM task_logs WHERE task_id = $1", [taskId]);
+  await db.run("DELETE FROM task_webhooks WHERE task_id = $1", [taskId]);
+  await db.run("DELETE FROM tasks WHERE id = $1", [taskId]);
+  return true;
+}
+async function updateTaskFields(db, taskId, fields) {
+  const entries = Object.entries(fields);
+  if (entries.length === 0) return getTaskById(db, taskId);
+  const setClauses = entries.map(([key], i) => `${toSnakeCase(key)} = $${i + 2}`).join(", ");
+  const values = entries.map(([, val]) => val);
+  await db.run(
+    `UPDATE tasks SET ${setClauses} WHERE id = $1`,
+    [taskId, ...values]
+  );
+  return getTaskById(db, taskId);
+}
+function dbRowToTask(row, defaultTimeoutSec) {
+  return {
+    id: row.id,
+    leaderCommandId: row.leader_command_id,
+    employeeId: row.employee_id,
+    sessionId: row.session_id,
+    targetMode: row.target_mode || (row.employee_id ? "direct" : "queue"),
+    prompt: row.prompt,
+    workspace: row.workspace,
+    timeoutSec: row.timeout_sec ?? defaultTimeoutSec,
+    cliConfig: row.cli_config ? JSON.parse(row.cli_config) : null,
+    priority: row.priority ?? 1,
+    requiredLabels: row.required_labels ? JSON.parse(row.required_labels) : null,
+    status: row.status || "queued",
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    exitCode: row.exit_code,
+    summary: row.summary,
+    error: row.error,
+    durationMs: row.duration_ms,
+    durationApiMs: row.duration_api_ms,
+    numTurns: row.num_turns,
+    totalCostUsd: row.total_cost_usd,
+    usageInputTokens: row.usage_input_tokens,
+    usageOutputTokens: row.usage_output_tokens,
+    usageCacheReadTokens: row.usage_cache_read_tokens,
+    usageCacheCreationTokens: row.usage_cache_creation_tokens
+  };
+}
+function taskToDbValues(task) {
+  return [
+    task.id,
+    task.leaderCommandId,
+    task.employeeId,
+    task.sessionId,
+    task.targetMode,
+    task.prompt,
+    task.workspace,
+    task.status,
+    task.timeoutSec,
+    task.cliConfig ? JSON.stringify(task.cliConfig) : null,
+    task.priority,
+    task.requiredLabels ? JSON.stringify(task.requiredLabels) : null,
+    task.createdAt,
+    task.startedAt,
+    task.finishedAt,
+    task.exitCode,
+    task.summary,
+    task.error,
+    task.durationMs,
+    task.durationApiMs,
+    task.numTurns,
+    task.totalCostUsd,
+    task.usageInputTokens,
+    task.usageOutputTokens,
+    task.usageCacheReadTokens,
+    task.usageCacheCreationTokens
+  ];
+}
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+// src/schemas.ts
+var errorResponseSchema = {
+  type: "object",
+  required: ["error"],
+  properties: {
+    error: { type: "string" }
+  }
+};
+var taskStatusSchema = {
+  type: "string",
+  enum: ["queued", "dispatched", "accepted", "running", "completed", "failed", "cancelled", "timeout"]
+};
+var nullableNumber = { anyOf: [{ type: "number" }, { type: "null" }] };
+var nullableString = { anyOf: [{ type: "string" }, { type: "null" }] };
+var taskCliConfigSchema = {
+  type: "object",
+  properties: {
+    model: { type: "string" },
+    permissionMode: { type: "string" },
+    maxTurns: { type: "number" },
+    systemPrompt: { type: "string" },
+    appendSystemPrompt: { type: "string" },
+    allowedTools: { type: "array", items: { type: "string" } },
+    disallowedTools: { type: "array", items: { type: "string" } },
+    extraArgs: { type: "array", items: { type: "string" } }
+  }
+};
+var taskRecordSchema = {
+  type: "object",
+  required: [
+    "id",
+    "leaderCommandId",
+    "employeeId",
+    "sessionId",
+    "targetMode",
+    "prompt",
+    "workspace",
+    "timeoutSec",
+    "cliConfig",
+    "priority",
+    "requiredLabels",
+    "status",
+    "createdAt",
+    "startedAt",
+    "finishedAt",
+    "exitCode",
+    "summary",
+    "error",
+    "durationMs",
+    "durationApiMs",
+    "numTurns",
+    "totalCostUsd",
+    "usageInputTokens",
+    "usageOutputTokens",
+    "usageCacheReadTokens",
+    "usageCacheCreationTokens"
+  ],
+  properties: {
+    id: { type: "string" },
+    leaderCommandId: { type: "string" },
+    employeeId: nullableString,
+    sessionId: nullableString,
+    targetMode: { type: "string", enum: ["queue", "direct", "broadcast"] },
+    prompt: { type: "string" },
+    workspace: nullableString,
+    timeoutSec: { type: "number" },
+    cliConfig: { anyOf: [taskCliConfigSchema, { type: "null" }] },
+    priority: { type: "integer", minimum: 0, maximum: 3 },
+    requiredLabels: { anyOf: [{ type: "array", items: { type: "string" } }, { type: "null" }] },
+    status: taskStatusSchema,
+    createdAt: { type: "string", format: "date-time" },
+    startedAt: { anyOf: [{ type: "string", format: "date-time" }, { type: "null" }] },
+    finishedAt: { anyOf: [{ type: "string", format: "date-time" }, { type: "null" }] },
+    exitCode: nullableNumber,
+    summary: nullableString,
+    error: nullableString,
+    durationMs: nullableNumber,
+    durationApiMs: nullableNumber,
+    numTurns: nullableNumber,
+    totalCostUsd: nullableNumber,
+    usageInputTokens: nullableNumber,
+    usageOutputTokens: nullableNumber,
+    usageCacheReadTokens: nullableNumber,
+    usageCacheCreationTokens: nullableNumber
+  }
+};
+var employeeSnapshotSchema = {
+  type: "object",
+  required: [
+    "id",
+    "name",
+    "machineId",
+    "hostname",
+    "labels",
+    "status",
+    "mainTaskId",
+    "mainTaskPrompt",
+    "queueTaskId",
+    "queueTaskPrompt",
+    "lastSeenAt"
+  ],
+  properties: {
+    id: { type: "string" },
+    name: { type: "string" },
+    machineId: { type: "string" },
+    hostname: { type: "string" },
+    labels: { type: "array", items: { type: "string" } },
+    status: { type: "string", enum: ["online", "offline"] },
+    mainTaskId: { anyOf: [{ type: "string" }, { type: "null" }] },
+    mainTaskPrompt: { anyOf: [{ type: "string" }, { type: "null" }] },
+    queueTaskId: { anyOf: [{ type: "string" }, { type: "null" }] },
+    queueTaskPrompt: { anyOf: [{ type: "string" }, { type: "null" }] },
+    lastSeenAt: { type: "string", format: "date-time" }
+  }
+};
+var taskOutputChunkSchema = {
+  type: "object",
+  required: ["taskId", "employeeId", "stream", "seq", "content", "createdAt"],
+  properties: {
+    taskId: { type: "string" },
+    employeeId: { type: "string" },
+    stream: { type: "string", enum: ["stdout", "stderr"] },
+    seq: { type: "number" },
+    content: { type: "string" },
+    createdAt: { type: "string", format: "date-time" }
+  }
+};
+var snapshotSchema = {
+  type: "object",
+  required: ["employees", "tasks", "logs"],
+  properties: {
+    employees: { type: "array", items: employeeSnapshotSchema },
+    tasks: { type: "array", items: taskRecordSchema },
+    logs: {
+      type: "object",
+      additionalProperties: {
+        type: "array",
+        items: taskOutputChunkSchema
+      }
+    }
+  }
+};
+var restTaskRequestSchema = {
+  type: "object",
+  required: ["prompt"],
+  properties: {
+    atAgents: {
+      anyOf: [
+        { type: "string", enum: ["queue", "all"] },
+        { type: "array", items: { type: "string" }, minItems: 1 }
+      ],
+      default: "queue"
+    },
+    prompt: { type: "string", minLength: 1 },
+    workspace: { type: "string" },
+    timeoutSec: { type: "number", minimum: 1 },
+    priority: { type: "integer", minimum: 0, maximum: 3 },
+    requiredLabels: { type: "array", items: { type: "string" } },
+    cliConfig: taskCliConfigSchema,
+    webhook: {
+      anyOf: [
+        { type: "string", format: "uri" },
+        {
+          type: "object",
+          required: ["url"],
+          properties: {
+            url: { type: "string", format: "uri" }
+          }
+        }
+      ]
+    },
+    webHook: {
+      anyOf: [{ type: "string", format: "uri" }, { type: "object", required: ["url"], properties: { url: { type: "string" } } }]
+    },
+    webhookUrl: { type: "string", format: "uri" }
+  }
+};
+var restTaskAcceptedSchema = {
+  type: "object",
+  required: ["status", "leaderCommandId", "tasks"],
+  properties: {
+    status: { type: "string", enum: ["accepted"] },
+    leaderCommandId: { type: "string" },
+    tasks: { type: "array", items: taskRecordSchema }
+  }
+};
+var sessionHistoryMessageSchema = {
+  type: "object",
+  required: ["type", "role", "taskId", "content", "createdAt"],
+  properties: {
+    type: { type: "string", enum: ["task.prompt", "task.output", "task.result"] },
+    role: { type: "string", enum: ["user", "assistant", "system"] },
+    taskId: { type: "string" },
+    stream: { type: "string", enum: ["stdout", "stderr"] },
+    seq: { type: "number" },
+    content: { type: "string" },
+    createdAt: { type: "string", format: "date-time" }
+  }
+};
+var sessionHistorySchema = {
+  type: "object",
+  required: ["sessionId", "tasks", "messages"],
+  properties: {
+    sessionId: { type: "string" },
+    tasks: { type: "array", items: taskRecordSchema },
+    messages: { type: "array", items: sessionHistoryMessageSchema }
+  }
+};
+var taskListResponseSchema = {
+  type: "object",
+  required: ["tasks"],
+  properties: {
+    tasks: { type: "array", items: taskRecordSchema }
+  }
+};
+var taskPatchSchema = {
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["cancelled"] },
+    timeoutSec: { type: "number", minimum: 1 },
+    cliConfig: taskCliConfigSchema
+  }
+};
+var claudeSessionItemSchema = {
+  type: "object",
+  required: ["id", "sizeBytes", "modifiedAt", "lineCount"],
+  properties: {
+    id: { type: "string" },
+    sizeBytes: { type: "number" },
+    modifiedAt: { type: "string", format: "date-time" },
+    lineCount: { type: "number" },
+    firstUserMessage: nullableString,
+    latestUserMessage: nullableString
+  }
+};
+var claudeSessionsResponseSchema = {
+  type: "object",
+  required: ["employeeId", "workspace", "sessions"],
+  properties: {
+    employeeId: { type: "string" },
+    workspace: nullableString,
+    activeSessionId: nullableString,
+    sessions: { type: "array", items: claudeSessionItemSchema }
+  }
+};
+function parseRestTaskRequest(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new Error("Request body must be a JSON object.");
+  }
+  const request = body;
+  const command = parseLeaderToServerMessage({
+    type: "command.dispatch",
+    atAgents: request.atAgents ?? "queue",
+    prompt: request.prompt,
+    workspace: request.workspace,
+    timeoutSec: request.timeoutSec
+  });
+  const webhookUrl = parseWebhookUrl(request.webhook ?? request.webHook ?? request.webhookUrl);
+  return {
+    command,
+    webhookUrl,
+    cliConfig: request.cliConfig ?? void 0,
+    priority: typeof request.priority === "number" ? request.priority : void 0,
+    requiredLabels: Array.isArray(request.requiredLabels) ? request.requiredLabels : void 0
+  };
+}
+function parseWebhookUrl(value) {
+  if (value === void 0 || value === null || value === "") {
+    return null;
+  }
+  const rawUrl = typeof value === "string" ? value : typeof value === "object" && !Array.isArray(value) && typeof value.url === "string" ? value.url : null;
+  if (!rawUrl) {
+    throw new Error("webhook must be a URL string or an object with a url string.");
+  }
+  const url = new URL(rawUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("webhook URL must use http or https.");
+  }
+  return url.toString();
+}
+
+// src/dispatch.ts
+import { createHmac, randomUUID } from "node:crypto";
+import WebSocket from "ws";
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "timeout"]);
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sendJson(socket, payload, encryptor) {
+  if (socket.readyState === WebSocket.OPEN) {
+    const plain = JSON.stringify(payload);
+    socket.send(encryptor ? encryptor.encrypt(plain) : plain);
+  }
+}
+function extractDoneSessionId(content) {
+  const match = content.match(/^\[done\]\s+session_id:\s*(\S+)/m);
+  return match?.[1] ?? null;
+}
+function createDispatch(ctx) {
+  const { state, db, log } = ctx;
+  function broadcastToLeaders(payload) {
+    for (const socket of state.leaderSockets) {
+      sendJson(socket, payload, ctx.encryptor);
+    }
+  }
+  function upsertEmployee(employee) {
+    state.employees.set(employee.id, employee);
+    persistEmployee(db, employee).catch((error) => log.error({ error, employeeId: employee.id }, "Failed to persist employee"));
+    broadcastToLeaders({ type: "employee.upsert", employee });
+  }
+  function resetHeartbeatTimer(employeeId) {
+    const existing = state.heartbeatTimers.get(employeeId);
+    if (existing) clearTimeout(existing);
+    state.heartbeatTimers.set(employeeId, setTimeout(() => {
+      state.heartbeatTimers.delete(employeeId);
+      const employee = state.employees.get(employeeId);
+      if (!employee || employee.status === "offline") return;
+      log.warn({ employeeId }, "Agent heartbeat timeout, marking offline");
+      employee.status = "offline";
+      upsertEmployee(employee);
+      const queueTaskId = employee.queueTaskId;
+      if (queueTaskId) {
+        const task = state.tasks.get(queueTaskId);
+        if (task && (task.status === "queued" || task.status === "dispatched")) {
+          task.status = "queued";
+          task.employeeId = null;
+          task.startedAt = null;
+          upsertTask(task);
+          state.sharedTaskQueue.push(task.id);
+          log.info({ taskId: task.id }, "Reclaimed queue task from unresponsive agent");
+        }
+      }
+      setQueueTask(employeeId, null, null);
+      dispatchSharedQueuedTasks();
+    }, 3e4));
+  }
+  function upsertTask(task) {
+    state.tasks.set(task.id, task);
+    persistTask(db, task).catch((error) => log.error({ error, taskId: task.id }, "Failed to persist task"));
+    broadcastToLeaders({ type: "task.upsert", task });
+  }
+  function signWebhookPayload(body) {
+    const hmac = createHmac("sha256", ctx.authToken);
+    hmac.update(body);
+    return `sha256=${hmac.digest("hex")}`;
+  }
+  async function deliverWebhook(webhookUrl, body, signature, taskId, attempt = 1) {
+    try {
+      const response = await fetch(webhookUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-ai-teams-signature": signature
+        },
+        body
+      });
+      if (!response.ok && attempt < 3) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        return deliverWebhook(webhookUrl, body, signature, taskId, attempt + 1);
+      }
+      if (!response.ok) {
+        log.warn({ taskId, webhookUrl, status: response.status, attempt }, "Task webhook returned non-2xx after retries");
+      } else if (attempt > 1) {
+        log.info({ taskId, webhookUrl, attempt }, "Task webhook succeeded on retry");
+      }
+    } catch (error) {
+      if (attempt < 3) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        return deliverWebhook(webhookUrl, body, signature, taskId, attempt + 1);
+      }
+      log.warn({ taskId, webhookUrl, error, attempt }, "Task webhook delivery failed after retries");
+    }
+  }
+  function postTaskWebhook(task, event, extra = {}) {
+    const webhookUrl = state.taskWebhooks.get(task.id);
+    if (!webhookUrl) {
+      return;
+    }
+    const payload = {
+      event,
+      timestamp: nowIso(),
+      task,
+      ...extra
+    };
+    const body = JSON.stringify(payload);
+    void deliverWebhook(webhookUrl, body, signWebhookPayload(body), task.id);
+  }
+  function clearTaskTimeout(taskId) {
+    const timer = state.taskTimeouts.get(taskId);
+    if (timer) {
+      clearTimeout(timer);
+      state.taskTimeouts.delete(taskId);
+    }
+  }
+  function setMainTask(employeeId, taskId, prompt) {
+    const employee = state.employees.get(employeeId);
+    if (!employee) {
+      return;
+    }
+    employee.mainTaskId = taskId;
+    employee.mainTaskPrompt = prompt;
+    employee.lastSeenAt = nowIso();
+    upsertEmployee(employee);
+  }
+  function setQueueTask(employeeId, taskId, prompt) {
+    const employee = state.employees.get(employeeId);
+    if (!employee) {
+      return;
+    }
+    employee.queueTaskId = taskId;
+    employee.queueTaskPrompt = prompt;
+    employee.lastSeenAt = nowIso();
+    upsertEmployee(employee);
+  }
+  function markTaskFailed(taskId, error) {
+    const task = state.tasks.get(taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) {
+      return;
+    }
+    clearTaskTimeout(taskId);
+    task.status = "failed";
+    task.error = error;
+    task.summary = task.summary ?? error;
+    task.finishedAt = nowIso();
+    log.warn({ taskId, employeeId: task.employeeId, error }, "Task failed");
+    upsertTask(task);
+    postTaskWebhook(task, "task.failed");
+    if (task.employeeId) {
+      const employeeId = task.employeeId;
+      const isMainSlot = task.targetMode !== "queue";
+      if (isMainSlot) {
+        setMainTask(employeeId, null, null);
+        dispatchNextMainQueuedTask(employeeId);
+      } else {
+        setQueueTask(employeeId, null, null);
+        dispatchNextQueuedTask(employeeId);
+      }
+    } else {
+      removeFromSharedQueue(task.id);
+      dispatchSharedQueuedTasks();
+    }
+  }
+  function appendTaskLog(chunk) {
+    const task = state.tasks.get(chunk.taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) {
+      return;
+    }
+    const doneSessionId = extractDoneSessionId(chunk.content);
+    if (!task.sessionId && doneSessionId) {
+      task.sessionId = doneSessionId;
+      upsertTask(task);
+    }
+    const history = state.taskLogs.get(chunk.taskId) ?? [];
+    history.push(chunk);
+    if (history.length > ctx.maxLogChunksPerTask) {
+      history.splice(0, history.length - ctx.maxLogChunksPerTask);
+    }
+    state.taskLogs.set(chunk.taskId, history);
+    persistTaskLog(db, chunk, ctx.maxLogChunksPerTask).catch((error) => log.error({ error, taskId: chunk.taskId, seq: chunk.seq }, "Failed to persist task log"));
+    broadcastToLeaders({ type: "task.output", chunk });
+    postTaskWebhook(task, "task.output", { chunk });
+  }
+  function markTaskTimeout(task) {
+    const current = state.tasks.get(task.id);
+    if (!current || TERMINAL_STATUSES.has(current.status)) {
+      return;
+    }
+    const socket = task.employeeId ? state.agentSockets.get(task.employeeId) : void 0;
+    if (socket) {
+      sendJson(socket, { type: "task.cancel", taskId: task.id }, ctx.encryptor);
+    }
+    current.status = "timeout";
+    current.finishedAt = nowIso();
+    current.error = `\u4EFB\u52A1\u8D85\u8FC7 ${task.timeoutSec} \u79D2\u672A\u5B8C\u6210\uFF0C\u5DF2\u8D85\u65F6\u3002`;
+    log.warn({ taskId: task.id, employeeId: task.employeeId, timeoutSec: task.timeoutSec }, "Task timed out");
+    current.summary = current.error;
+    upsertTask(current);
+    postTaskWebhook(current, "task.timeout");
+    if (task.employeeId) {
+      const isMainSlot = task.targetMode !== "queue";
+      if (isMainSlot) {
+        setMainTask(task.employeeId, null, null);
+      } else {
+        setQueueTask(task.employeeId, null, null);
+      }
+    }
+    clearTaskTimeout(task.id);
+    if (task.employeeId) {
+      const isMainSlot = task.targetMode !== "queue";
+      if (isMainSlot) {
+        dispatchNextMainQueuedTask(task.employeeId);
+      } else {
+        dispatchNextQueuedTask(task.employeeId);
+      }
+    }
+  }
+  function enqueueSharedTask(taskId) {
+    if (state.sharedTaskQueue.includes(taskId)) return;
+    const task = state.tasks.get(taskId);
+    if (!task) {
+      state.sharedTaskQueue.push(taskId);
+      return;
+    }
+    let insertAt = state.sharedTaskQueue.length;
+    for (let i = 0; i < state.sharedTaskQueue.length; i++) {
+      const existing = state.tasks.get(state.sharedTaskQueue[i]);
+      if (existing && task.priority > existing.priority) {
+        insertAt = i;
+        break;
+      }
+    }
+    state.sharedTaskQueue.splice(insertAt, 0, taskId);
+  }
+  function removeFromSharedQueue(taskId) {
+    const index = state.sharedTaskQueue.indexOf(taskId);
+    if (index !== -1) {
+      state.sharedTaskQueue.splice(index, 1);
+    }
+  }
+  function pickAvailableEmployeeIdForQueue(requiredLabels) {
+    let available = [...state.employees.values()].filter((employee2) => {
+      const socket = state.agentSockets.get(employee2.id);
+      if (employee2.status !== "online" || employee2.queueTaskId || socket?.readyState !== WebSocket.OPEN) {
+        return false;
+      }
+      if (requiredLabels && requiredLabels.length > 0) {
+        return requiredLabels.every((label) => employee2.labels.includes(label));
+      }
+      return true;
+    });
+    if (available.length === 0) {
+      return null;
+    }
+    available.sort((a, b) => {
+      const loadA = (a.mainTaskId ? 1 : 0) + (a.queueTaskId ? 1 : 0);
+      const loadB = (b.mainTaskId ? 1 : 0) + (b.queueTaskId ? 1 : 0);
+      if (loadA !== loadB) return loadA - loadB;
+      return a.id.localeCompare(b.id);
+    });
+    const minLoad = (available[0].mainTaskId ? 1 : 0) + (available[0].queueTaskId ? 1 : 0);
+    const lightest = available.filter((e) => (e.mainTaskId ? 1 : 0) + (e.queueTaskId ? 1 : 0) === minLoad);
+    const employee = lightest[state.sharedQueueCursor % lightest.length];
+    state.sharedQueueCursor = (state.sharedQueueCursor + 1) % Math.max(lightest.length, 1);
+    void persistSharedQueueCursor(db, state.sharedQueueCursor);
+    return employee.id;
+  }
+  function dispatchSharedQueuedTask(preferredEmployeeId) {
+    if (state.sharedTaskQueue.length === 0) {
+      return;
+    }
+    let firstTask = null;
+    for (const tid of state.sharedTaskQueue) {
+      const t = state.tasks.get(tid);
+      if (t && t.status === "queued") {
+        firstTask = t;
+        break;
+      }
+    }
+    const requiredLabels = firstTask?.requiredLabels;
+    const employeeId = preferredEmployeeId ?? pickAvailableEmployeeIdForQueue(requiredLabels);
+    if (!employeeId) {
+      return;
+    }
+    const employee = state.employees.get(employeeId);
+    if (!employee || employee.queueTaskId || employee.status !== "online") {
+      return;
+    }
+    while (state.sharedTaskQueue.length > 0) {
+      const taskId = state.sharedTaskQueue.shift();
+      const task = state.tasks.get(taskId);
+      if (task && task.status === "queued" && task.targetMode === "queue") {
+        dispatchTask(task, employeeId);
+        return;
+      }
+    }
+  }
+  function dispatchSharedQueuedTasks() {
+    for (let index = 0; index < state.employees.size && state.sharedTaskQueue.length > 0; index += 1) {
+      const employeeId = pickAvailableEmployeeIdForQueue();
+      if (!employeeId) {
+        return;
+      }
+      dispatchSharedQueuedTask(employeeId);
+    }
+  }
+  function dispatchTask(task, assignedEmployeeId = task.employeeId) {
+    const isQueueSlot = task.targetMode === "queue";
+    if (!assignedEmployeeId) {
+      if (isQueueSlot) {
+        enqueueSharedTask(task.id);
+        dispatchSharedQueuedTasks();
+      } else {
+        markTaskFailed(task.id, "\u975E\u961F\u5217\u4EFB\u52A1\u5FC5\u987B\u6307\u5B9A\u76EE\u6807\u5458\u5DE5\u3002");
+      }
+      return;
+    }
+    const employee = state.employees.get(assignedEmployeeId);
+    const socket = state.agentSockets.get(assignedEmployeeId);
+    if (!employee || employee.status !== "online" || !socket) {
+      markTaskFailed(task.id, "\u76EE\u6807\u5458\u5DE5\u5F53\u524D\u79BB\u7EBF\uFF0C\u4EFB\u52A1\u672A\u80FD\u5206\u53D1\u3002");
+      return;
+    }
+    const currentSlotTaskId = isQueueSlot ? employee.queueTaskId : employee.mainTaskId;
+    if (currentSlotTaskId && currentSlotTaskId !== task.id) {
+      const queueMap = isQueueSlot ? state.taskQueues : state.mainTaskQueues;
+      const queue = queueMap.get(assignedEmployeeId) ?? [];
+      queue.push(task.id);
+      queueMap.set(assignedEmployeeId, queue);
+      return;
+    }
+    task.employeeId = assignedEmployeeId;
+    task.status = "dispatched";
+    log.info({ taskId: task.id, employeeId: assignedEmployeeId, targetMode: task.targetMode, prompt: task.prompt.slice(0, 80) }, "Task dispatched");
+    upsertTask(task);
+    if (isQueueSlot) {
+      setQueueTask(assignedEmployeeId, task.id, task.prompt);
+    } else {
+      setMainTask(assignedEmployeeId, task.id, task.prompt);
+    }
+    clearTaskTimeout(task.id);
+    state.taskTimeouts.set(task.id, setTimeout(() => markTaskTimeout(task), task.timeoutSec * 1e3));
+    sendJson(socket, {
+      type: "task.dispatch",
+      taskId: task.id,
+      leaderCommandId: task.leaderCommandId,
+      employeeId: assignedEmployeeId,
+      targetMode: task.targetMode,
+      prompt: task.prompt,
+      workspace: task.workspace,
+      timeoutSec: task.timeoutSec,
+      cliConfig: task.cliConfig
+    }, ctx.encryptor);
+  }
+  function dispatchNextQueuedTask(employeeId) {
+    const employee = state.employees.get(employeeId);
+    if (!employee || employee.queueTaskId || employee.status !== "online") {
+      return;
+    }
+    const queue = state.taskQueues.get(employeeId);
+    if (!queue || queue.length === 0) {
+      dispatchSharedQueuedTasks();
+      return;
+    }
+    while (queue.length > 0) {
+      const taskId = queue.shift();
+      if (queue.length === 0) {
+        state.taskQueues.delete(employeeId);
+      }
+      const task = state.tasks.get(taskId);
+      if (task && task.status === "queued") {
+        dispatchTask(task, employeeId);
+        return;
+      }
+    }
+    dispatchSharedQueuedTasks();
+  }
+  function dispatchNextMainQueuedTask(employeeId) {
+    const employee = state.employees.get(employeeId);
+    if (!employee || employee.mainTaskId || employee.status !== "online") {
+      return;
+    }
+    const queue = state.mainTaskQueues.get(employeeId);
+    if (!queue || queue.length === 0) {
+      return;
+    }
+    while (queue.length > 0) {
+      const taskId = queue.shift();
+      if (queue.length === 0) {
+        state.mainTaskQueues.delete(employeeId);
+      }
+      const task = state.tasks.get(taskId);
+      if (task && task.status === "queued") {
+        dispatchTask(task, employeeId);
+        return;
+      }
+    }
+  }
+  function createTask(employeeId, prompt, workspace, timeoutSec, leaderCommandId, targetMode, webhookUrl, cliConfig, priority, requiredLabels) {
+    const task = {
+      id: randomUUID(),
+      leaderCommandId: leaderCommandId ?? randomUUID(),
+      employeeId,
+      sessionId: null,
+      targetMode,
+      prompt,
+      workspace: workspace?.trim() || null,
+      timeoutSec: timeoutSec ?? ctx.defaultTimeoutSec,
+      cliConfig: cliConfig && typeof cliConfig === "object" && !Array.isArray(cliConfig) ? cliConfig : null,
+      priority: priority ?? 1,
+      requiredLabels: requiredLabels ?? null,
+      status: "queued",
+      createdAt: nowIso(),
+      startedAt: null,
+      finishedAt: null,
+      exitCode: null,
+      summary: null,
+      error: null,
+      durationMs: null,
+      durationApiMs: null,
+      numTurns: null,
+      totalCostUsd: null,
+      usageInputTokens: null,
+      usageOutputTokens: null,
+      usageCacheReadTokens: null,
+      usageCacheCreationTokens: null
+    };
+    if (webhookUrl) {
+      state.taskWebhooks.set(task.id, webhookUrl);
+      persistTaskWebhook(db, task.id, webhookUrl).catch((error) => log.error({ error, taskId: task.id }, "Failed to persist task webhook"));
+    }
+    upsertTask(task);
+    log.info({ taskId: task.id, targetMode, employeeId, prompt: prompt.slice(0, 80) }, "Task created");
+    if (targetMode === "queue") {
+      enqueueSharedTask(task.id);
+      dispatchSharedQueuedTasks();
+    } else {
+      dispatchTask(task);
+    }
+    return task;
+  }
+  function resolveTargetIds(target) {
+    if (target === "queue") {
+      return [];
+    }
+    if (target === "all") {
+      return [...state.employees.values()].map((employee) => employee.id);
+    }
+    return [...new Set(target)];
+  }
+  function dispatchLeaderCommand(message, webhookUrl, cliConfig, priority, requiredLabels) {
+    const leaderCommandId = randomUUID();
+    if (message.atAgents === "queue") {
+      return {
+        ok: true,
+        leaderCommandId,
+        tasks: [createTask(null, message.prompt, message.workspace, message.timeoutSec, leaderCommandId, "queue", webhookUrl, cliConfig, message.priority, message.requiredLabels)]
+      };
+    }
+    const targetIds = resolveTargetIds(message.atAgents);
+    if (targetIds.length === 0) {
+      return {
+        ok: false,
+        code: "no_target_agents",
+        message: "\u6CA1\u6709\u53EF\u7528\u7684\u76EE\u6807\u5458\u5DE5\u3002"
+      };
+    }
+    const targetMode = message.atAgents === "all" ? "broadcast" : "direct";
+    return {
+      ok: true,
+      leaderCommandId,
+      tasks: targetIds.map(
+        (employeeId) => createTask(employeeId, message.prompt, message.workspace, message.timeoutSec, leaderCommandId, targetMode, webhookUrl, cliConfig, message.priority, message.requiredLabels)
+      )
+    };
+  }
+  function handleRegister(message, socket) {
+    const previous = state.employees.get(message.employeeId);
+    const previousMainTaskId = previous?.mainTaskId ?? null;
+    const previousQueueTaskId = previous?.queueTaskId ?? null;
+    const activeMainTaskId = message.activeMainTaskId ?? null;
+    const activeQueueTaskId = message.activeQueueTaskId ?? null;
+    const disconnectTimer = state.disconnectTimers.get(message.employeeId);
+    if (disconnectTimer) {
+      clearTimeout(disconnectTimer);
+      state.disconnectTimers.delete(message.employeeId);
+    }
+    state.agentSockets.set(message.employeeId, socket);
+    state.socketToEmployeeId.set(socket, message.employeeId);
+    let mainTaskId = null;
+    let mainTaskPrompt = null;
+    let queueTaskId = null;
+    let queueTaskPrompt = null;
+    if (previousMainTaskId && activeMainTaskId !== previousMainTaskId) {
+      markTaskFailed(previousMainTaskId, "\u5458\u5DE5\u91CD\u8FDE\u65F6\u672A\u6062\u590D\u539F\u8FD0\u884C\u7684\u4E3B\u4EFB\u52A1\u3002");
+    } else if (activeMainTaskId) {
+      const activeTask = state.tasks.get(activeMainTaskId);
+      if (activeTask && activeTask.employeeId === message.employeeId && !TERMINAL_STATUSES.has(activeTask.status)) {
+        mainTaskId = activeTask.id;
+        mainTaskPrompt = activeTask.prompt;
+      }
+    }
+    if (previousQueueTaskId && activeQueueTaskId !== previousQueueTaskId) {
+      markTaskFailed(previousQueueTaskId, "\u5458\u5DE5\u91CD\u8FDE\u65F6\u672A\u6062\u590D\u539F\u8FD0\u884C\u7684\u961F\u5217\u4EFB\u52A1\u3002");
+    } else if (activeQueueTaskId) {
+      const activeTask = state.tasks.get(activeQueueTaskId);
+      if (activeTask && activeTask.employeeId === message.employeeId && !TERMINAL_STATUSES.has(activeTask.status)) {
+        queueTaskId = activeTask.id;
+        queueTaskPrompt = activeTask.prompt;
+      }
+    }
+    upsertEmployee({
+      id: message.employeeId,
+      name: message.name,
+      machineId: message.machineId,
+      hostname: message.hostname,
+      labels: message.labels,
+      status: "online",
+      mainTaskId,
+      mainTaskPrompt,
+      queueTaskId,
+      queueTaskPrompt,
+      lastSeenAt: nowIso()
+    });
+    if (!mainTaskId) {
+      dispatchNextMainQueuedTask(message.employeeId);
+    }
+    if (!queueTaskId) {
+      dispatchNextQueuedTask(message.employeeId);
+    }
+    resetHeartbeatTimer(message.employeeId);
+  }
+  function taskBelongsToSocket(taskId, employeeId, socket) {
+    const socketEmployeeId = state.socketToEmployeeId.get(socket);
+    if (!socketEmployeeId || employeeId && employeeId !== socketEmployeeId) {
+      return false;
+    }
+    const task = state.tasks.get(taskId);
+    return Boolean(task && task.employeeId === socketEmployeeId);
+  }
+  function handleAgentMessage(message, socket) {
+    if (message.type === "agent.register") {
+      handleRegister(message, socket);
+      return;
+    }
+    const socketEmployeeId = state.socketToEmployeeId.get(socket);
+    if (!socketEmployeeId) {
+      sendJson(socket, {
+        type: "server.error",
+        code: "agent_not_registered",
+        message: "Agent must register before sending task events."
+      }, ctx.encryptor);
+      socket.close(1008, "agent_not_registered");
+      return;
+    }
+    if (message.type === "agent.heartbeat") {
+      if (message.employeeId !== socketEmployeeId) {
+        socket.close(1008, "employee_mismatch");
+        return;
+      }
+      const employee = state.employees.get(message.employeeId);
+      if (employee) {
+        employee.lastSeenAt = nowIso();
+        employee.status = "online";
+        upsertEmployee(employee);
+        resetHeartbeatTimer(message.employeeId);
+      }
+      return;
+    }
+    if (message.type === "agent.request_task") {
+      if (message.employeeId !== socketEmployeeId) {
+        socket.close(1008, "employee_mismatch");
+        return;
+      }
+      dispatchNextQueuedTask(message.employeeId);
+      return;
+    }
+    if (!taskBelongsToSocket(message.taskId, socketEmployeeId, socket)) {
+      socket.close(1008, "task_owner_mismatch");
+      return;
+    }
+    const task = state.tasks.get(message.taskId);
+    if (!task || TERMINAL_STATUSES.has(task.status)) {
+      return;
+    }
+    switch (message.type) {
+      case "task.accepted":
+        task.status = "accepted";
+        upsertTask(task);
+        log.info({ taskId: task.id, employeeId: socketEmployeeId }, "Task accepted");
+        break;
+      case "task.started":
+        task.status = "running";
+        task.sessionId = message.sessionId ?? task.sessionId;
+        task.startedAt = task.startedAt ?? nowIso();
+        upsertTask(task);
+        postTaskWebhook(task, "task.started");
+        log.info({ taskId: task.id, employeeId: socketEmployeeId, sessionId: task.sessionId, pid: message.pid }, "Task started");
+        break;
+      case "task.output":
+        if (!task.employeeId) {
+          return;
+        }
+        appendTaskLog({
+          taskId: message.taskId,
+          employeeId: task.employeeId,
+          stream: message.stream,
+          seq: message.seq,
+          content: message.content,
+          createdAt: nowIso()
+        });
+        break;
+      case "task.completed":
+        task.status = "completed";
+        clearTaskTimeout(task.id);
+        task.finishedAt = nowIso();
+        task.exitCode = message.exitCode;
+        task.summary = message.summary ?? "\u4EFB\u52A1\u6267\u884C\u5B8C\u6210\u3002";
+        task.error = null;
+        task.durationMs = message.durationMs ?? task.durationMs;
+        task.durationApiMs = message.durationApiMs ?? task.durationApiMs;
+        task.numTurns = message.numTurns ?? task.numTurns;
+        task.totalCostUsd = message.totalCostUsd ?? task.totalCostUsd;
+        task.usageInputTokens = message.usageInputTokens ?? task.usageInputTokens;
+        task.usageOutputTokens = message.usageOutputTokens ?? task.usageOutputTokens;
+        task.usageCacheReadTokens = message.usageCacheReadTokens ?? task.usageCacheReadTokens;
+        task.usageCacheCreationTokens = message.usageCacheCreationTokens ?? task.usageCacheCreationTokens;
+        upsertTask(task);
+        postTaskWebhook(task, "task.completed");
+        log.info({ taskId: task.id, employeeId: task.employeeId, exitCode: task.exitCode, durationMs: task.durationMs, numTurns: task.numTurns, totalCostUsd: task.totalCostUsd }, "Task completed");
+        if (task.employeeId) {
+          const isMainSlot = task.targetMode !== "queue";
+          if (isMainSlot) {
+            setMainTask(task.employeeId, null, null);
+            dispatchNextMainQueuedTask(task.employeeId);
+          } else {
+            setQueueTask(task.employeeId, null, null);
+            dispatchNextQueuedTask(task.employeeId);
+          }
+        }
+        break;
+      case "task.failed":
+        markTaskFailed(message.taskId, message.error);
+        break;
+      case "task.cancelled":
+        task.status = "cancelled";
+        clearTaskTimeout(task.id);
+        task.finishedAt = nowIso();
+        task.summary = "\u4EFB\u52A1\u5DF2\u53D6\u6D88\u3002";
+        log.info({ taskId: task.id, employeeId: task.employeeId }, "Task cancelled");
+        upsertTask(task);
+        postTaskWebhook(task, "task.cancelled");
+        if (task.employeeId) {
+          const isMainSlot = task.targetMode !== "queue";
+          if (isMainSlot) {
+            setMainTask(task.employeeId, null, null);
+            dispatchNextMainQueuedTask(task.employeeId);
+          } else {
+            setQueueTask(task.employeeId, null, null);
+            dispatchNextQueuedTask(task.employeeId);
+          }
+        }
+        break;
+    }
+  }
+  function cancelTaskById(taskId) {
+    const task = state.tasks.get(taskId);
+    if (!task) {
+      return { ok: false, code: "not_found", message: "\u4EFB\u52A1\u4E0D\u5B58\u5728\u3002" };
+    }
+    if (TERMINAL_STATUSES.has(task.status)) {
+      return { ok: false, code: "already_terminal", message: `\u4EFB\u52A1\u5DF2\u5904\u4E8E\u7EC8\u6001 ${task.status}\uFF0C\u65E0\u6CD5\u53D6\u6D88\u3002` };
+    }
+    if (task.status === "queued") {
+      if (task.employeeId) {
+        const isMainSlot = task.targetMode !== "queue";
+        const queueMap = isMainSlot ? state.mainTaskQueues : state.taskQueues;
+        const queue = queueMap.get(task.employeeId);
+        if (queue) {
+          const idx = queue.indexOf(task.id);
+          if (idx !== -1) {
+            queue.splice(idx, 1);
+          }
+          if (queue.length === 0) {
+            queueMap.delete(task.employeeId);
+          }
+        }
+      } else {
+        removeFromSharedQueue(task.id);
+      }
+      task.status = "cancelled";
+      task.finishedAt = nowIso();
+      task.summary = "\u4EFB\u52A1\u5DF2\u53D6\u6D88\u3002";
+      upsertTask(task);
+      postTaskWebhook(task, "task.cancelled");
+      return { ok: true, task };
+    }
+    if (!task.employeeId) {
+      markTaskFailed(task.id, "\u4EFB\u52A1\u5C1A\u672A\u5206\u914D\u7ED9\u5458\u5DE5\uFF0C\u65E0\u6CD5\u53D6\u6D88\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B\u3002");
+      return { ok: true, task: state.tasks.get(task.id) };
+    }
+    const agentSocket = state.agentSockets.get(task.employeeId);
+    if (!agentSocket) {
+      markTaskFailed(task.id, "\u5458\u5DE5\u5DF2\u79BB\u7EBF\uFF0C\u65E0\u6CD5\u53D6\u6D88\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B\u3002");
+      return { ok: true, task: state.tasks.get(task.id) };
+    }
+    sendJson(agentSocket, { type: "task.cancel", taskId: task.id }, ctx.encryptor);
+    return { ok: true, task };
+  }
+  function handleLeaderMessage(message, socket) {
+    switch (message.type) {
+      case "command.dispatch": {
+        const result = dispatchLeaderCommand(message);
+        if (!result.ok) {
+          sendJson(socket, {
+            type: "command.error",
+            code: result.code,
+            message: result.message
+          }, ctx.encryptor);
+        }
+        break;
+      }
+      case "command.send":
+        createTask(message.employeeId, message.prompt, message.workspace, message.timeoutSec, void 0, "direct");
+        break;
+      case "command.broadcast":
+        handleLeaderMessage(
+          {
+            type: "command.dispatch",
+            atAgents: "all",
+            prompt: message.prompt,
+            workspace: message.workspace,
+            timeoutSec: message.timeoutSec
+          },
+          socket
+        );
+        break;
+      case "task.cancel":
+        cancelTaskById(message.taskId);
+        break;
+    }
+  }
+  return {
+    dispatchLeaderCommand,
+    handleAgentMessage,
+    handleLeaderMessage,
+    cancelTaskById
+  };
+}
+
+// src/state-store.ts
+function createInMemoryStateStore() {
+  return {
+    agentSockets: /* @__PURE__ */ new Map(),
+    leaderSockets: /* @__PURE__ */ new Set(),
+    employees: /* @__PURE__ */ new Map(),
+    tasks: /* @__PURE__ */ new Map(),
+    taskLogs: /* @__PURE__ */ new Map(),
+    taskWebhooks: /* @__PURE__ */ new Map(),
+    socketToEmployeeId: /* @__PURE__ */ new WeakMap(),
+    taskTimeouts: /* @__PURE__ */ new Map(),
+    disconnectTimers: /* @__PURE__ */ new Map(),
+    heartbeatTimers: /* @__PURE__ */ new Map(),
+    taskQueues: /* @__PURE__ */ new Map(),
+    mainTaskQueues: /* @__PURE__ */ new Map(),
+    sharedTaskQueue: [],
+    sharedQueueCursor: 0
+  };
+}
+
+// src/crypto.ts
+import crypto from "node:crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+function createEncryptor(encryptionKeyHex) {
+  if (!encryptionKeyHex) {
+    return {
+      encrypt(plainText) {
+        return plainText;
+      },
+      decrypt(raw) {
+        return raw;
+      }
+    };
+  }
+  const key = parseEncryptionKey(encryptionKeyHex);
+  return {
+    encrypt(plainText) {
+      const iv = crypto.randomBytes(IV_LENGTH);
+      const cipher = crypto.createCipheriv(ALGORITHM, key, iv, { authTagLength: TAG_LENGTH });
+      const encrypted = Buffer.concat([cipher.update(plainText, "utf8"), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      const envelope = {
+        encrypted: true,
+        iv: iv.toString("base64"),
+        ciphertext: encrypted.toString("base64"),
+        tag: tag.toString("base64")
+      };
+      return JSON.stringify(envelope);
+    },
+    decrypt(raw) {
+      const parsed = JSON.parse(raw);
+      if (!isEncryptedEnvelope(parsed)) {
+        return raw;
+      }
+      const iv = Buffer.from(parsed.iv, "base64");
+      const ciphertext = Buffer.from(parsed.ciphertext, "base64");
+      const tag = Buffer.from(parsed.tag, "base64");
+      const decipher = crypto.createDecipheriv(ALGORITHM, key, iv, { authTagLength: TAG_LENGTH });
+      decipher.setAuthTag(tag);
+      return decipher.update(ciphertext) + decipher.final("utf8");
+    }
+  };
+}
+
+// src/index.ts
+var DEFAULT_PORT = 3789;
+function isAuthorized(authToken, rawUrl, headers) {
+  const bearer = typeof headers.authorization === "string" ? headers.authorization : "";
+  const tokenFromHeader = bearer.startsWith("Bearer ") ? bearer.slice("Bearer ".length) : "";
+  const tokenFromQuery = new URL(rawUrl, "http://localhost").searchParams.get("token") ?? "";
+  return tokenFromHeader === authToken || tokenFromQuery === authToken;
+}
+async function createAiTeamsServer(options) {
+  if (!options.authToken) {
+    throw new Error("AI_TEAMS_AUTH_TOKEN is required.");
+  }
+  const defaultTimeoutSec = options.defaultTimeoutSec ?? 1800;
+  const disconnectGraceMs = options.disconnectGraceMs ?? 15e3;
+  const maxLogChunksPerTask = options.maxLogChunksPerTask ?? 400;
+  const dataDir = options.dataDir ?? path.join(process.cwd(), "data");
+  const dbPath = options.dbPath ?? path.join(dataDir, "ai-teams.db");
+  let closing = false;
+  const state = createInMemoryStateStore();
+  const db = await createDatabaseFromEnv({
+    AI_TEAMS_AUTH_TOKEN: options.authToken,
+    DATA_DIR: options.dataDir,
+    DB_PATH: options.dbPath,
+    DATABASE_URL: process.env.DATABASE_URL
+  });
+  await initDb(db);
+  await hydrateState(db, state, defaultTimeoutSec, maxLogChunksPerTask);
+  const logLevel = options.logLevel || process.env.LOG_LEVEL || "info";
+  const logDir = options.logDir || process.env.LOG_DIR;
+  let loggerConfig = { level: logLevel };
+  if (logDir && options.logger !== false) {
+    fs.mkdirSync(logDir, { recursive: true });
+    loggerConfig = {
+      level: logLevel,
+      transport: {
+        targets: [
+          { target: "pino/file", options: { destination: 1 }, level: logLevel },
+          { target: "pino/file", options: { destination: path.join(logDir, "server.log") }, level: logLevel }
+        ]
+      }
+    };
+  }
+  const app = Fastify({ logger: options.logger === false ? false : loggerConfig });
+  await app.register(websocket);
+  await app.register(swagger, {
+    openapi: {
+      info: {
+        title: "AI Teams Server API",
+        description: "REST API for submitting AI Teams tasks and reading runtime state.",
+        version: "0.1.0"
+      },
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer"
+          }
+        }
+      },
+      security: [{ bearerAuth: [] }]
+    }
+  });
+  await app.register(swaggerUi, {
+    routePrefix: "/docs",
+    uiConfig: {
+      docExpansion: "list",
+      deepLinking: false
+    },
+    staticCSP: true
+  });
+  const webDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "web");
+  if (fs.existsSync(webDir)) {
+    await app.register(fastifyStatic, { root: webDir, prefix: "/" });
+    app.setNotFoundHandler((_, reply) => {
+      reply.sendFile("index.html");
+    });
+    app.log.info({ webDir }, "Web UI enabled");
+  }
+  const dispatchCtx = {
+    state,
+    db,
+    log: app.log,
+    authToken: options.authToken,
+    defaultTimeoutSec,
+    maxLogChunksPerTask,
+    disconnectGraceMs,
+    encryptor: createEncryptor(process.env.AI_TEAMS_ENCRYPTION_KEY)
+  };
+  const { dispatchLeaderCommand, handleAgentMessage, handleLeaderMessage, cancelTaskById } = createDispatch(dispatchCtx);
+  function buildSnapshot() {
+    return {
+      employees: [...state.employees.values()],
+      tasks: [...state.tasks.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt)),
+      logs: Object.fromEntries(state.taskLogs.entries())
+    };
+  }
+  function buildSessionHistory(sessionId) {
+    const extractDoneSessionId2 = (content) => {
+      const match = content.match(/^\[done\]\s+session_id:\s*(\S+)/m);
+      return match?.[1] ?? null;
+    };
+    const tasks = [...state.tasks.values()].filter((task) => task.sessionId === sessionId || (state.taskLogs.get(task.id) ?? []).some((chunk) => extractDoneSessionId2(chunk.content) === sessionId)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    const messages = tasks.flatMap((task) => {
+      const taskLogs = [...state.taskLogs.get(task.id) ?? []].sort((a, b) => a.seq - b.seq);
+      const outputMessages = taskLogs.map((chunk) => ({
+        type: "task.output",
+        role: "assistant",
+        taskId: task.id,
+        stream: chunk.stream,
+        seq: chunk.seq,
+        content: chunk.content,
+        createdAt: chunk.createdAt
+      }));
+      const resultMessage = task.finishedAt && (task.summary || task.error) ? [
+        {
+          type: "task.result",
+          role: task.status === "failed" || task.status === "timeout" ? "system" : "assistant",
+          taskId: task.id,
+          content: task.summary || task.error || task.status,
+          createdAt: task.finishedAt
+        }
+      ] : [];
+      return [
+        {
+          type: "task.prompt",
+          role: "user",
+          taskId: task.id,
+          content: task.prompt,
+          createdAt: task.createdAt
+        },
+        ...outputMessages,
+        ...resultMessage
+      ];
+    });
+    return { sessionId, tasks, messages };
+  }
+  function extractUserMessage(line) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "human" || obj.role === "user" || obj.message?.role === "user") {
+        const content = obj.message?.content ?? obj.content;
+        if (typeof content === "string") return content.slice(0, 200);
+        if (Array.isArray(content)) {
+          const text = content.filter((c) => typeof c.text === "string").map((c) => c.text).join("\n");
+          return text.slice(0, 200) || null;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  function buildClaudeSessions(employeeId) {
+    const employee = state.employees.get(employeeId);
+    const workspace = [...state.tasks.values()].filter((t) => t.employeeId === employeeId && t.workspace).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0]?.workspace ?? null;
+    if (!workspace) {
+      return { employeeId, workspace: null, activeSessionId: null, sessions: [] };
+    }
+    const encodedPath = workspace.replace(/\//g, "-");
+    const claudeProjectsDir = path.join(os.homedir(), ".claude", "projects", encodedPath);
+    let entries;
+    try {
+      entries = fs.readdirSync(claudeProjectsDir, { withFileTypes: true });
+    } catch {
+      return { employeeId, workspace, activeSessionId: null, sessions: [] };
+    }
+    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).sort((a, b) => b.name.localeCompare(a.name));
+    const sessions = jsonlFiles.map((entry) => {
+      const filePath = path.join(claudeProjectsDir, entry.name);
+      const stat = fs.statSync(filePath);
+      const sessionId = entry.name.replace(/\.jsonl$/, "");
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split("\n").filter(Boolean);
+      const lineCount = lines.length;
+      let firstUserMessage = null;
+      let latestUserMessage = null;
+      for (const line of lines) {
+        const msg = extractUserMessage(line);
+        if (msg && !firstUserMessage) firstUserMessage = msg;
+        if (msg) latestUserMessage = msg;
+      }
+      return { id: sessionId, sizeBytes: stat.size, modifiedAt: stat.mtime.toISOString(), lineCount, firstUserMessage, latestUserMessage };
+    });
+    let activeSessionId = null;
+    const agentStatePath = path.join(workspace, ".ai-teams", "agents", employeeId, "session-state.json");
+    try {
+      const raw = fs.readFileSync(agentStatePath, "utf8");
+      activeSessionId = JSON.parse(raw).claudeSessionId ?? null;
+    } catch {
+    }
+    return { employeeId, workspace, activeSessionId, sessions };
+  }
+  app.addHook("preHandler", async (request, reply) => {
+    if (request.url.startsWith("/ws/") || request.url.startsWith("/docs")) {
+      return;
+    }
+    if (!isAuthorized(options.authToken, request.url, request.headers)) {
+      app.log.warn({ url: request.url, ip: request.ip }, "Unauthorized request");
+      await reply.code(401).send({ error: "unauthorized" });
+    }
+  });
+  app.get(
+    "/health",
+    {
+      schema: {
+        tags: ["system"],
+        summary: "Check server health",
+        response: {
+          200: {
+            type: "object",
+            required: ["status", "timestamp", "dbPath", "employees", "leaders", "tasks"],
+            properties: {
+              status: { type: "string", enum: ["ok"] },
+              timestamp: { type: "string", format: "date-time" },
+              dbPath: { type: "string" },
+              employees: { type: "number" },
+              leaders: { type: "number" },
+              tasks: { type: "number" }
+            }
+          },
+          401: errorResponseSchema
+        }
+      }
+    },
+    async () => ({
+      status: "ok",
+      timestamp: nowIso(),
+      dbPath,
+      employees: state.employees.size,
+      leaders: state.leaderSockets.size,
+      tasks: state.tasks.size
+    })
+  );
+  app.get(
+    "/api/snapshot",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Get current employees, tasks, and task logs",
+        response: {
+          200: snapshotSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async () => buildSnapshot()
+  );
+  app.get(
+    "/api/sessions/:sessionId/history",
+    {
+      schema: {
+        tags: ["sessions"],
+        summary: "Get conversation history by session ID",
+        description: "Returns task prompts, task output chunks, and terminal summaries/errors for the specified AI Teams Claude session ID.",
+        params: {
+          type: "object",
+          required: ["sessionId"],
+          properties: {
+            sessionId: { type: "string", minLength: 1 }
+          }
+        },
+        response: {
+          200: sessionHistorySchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request) => buildSessionHistory(request.params.sessionId)
+  );
+  app.get(
+    "/api/employees/:employeeId/claude-sessions",
+    {
+      schema: {
+        tags: ["employees"],
+        summary: "List local Claude Code sessions for an agent's workspace",
+        params: {
+          type: "object",
+          required: ["employeeId"],
+          properties: { employeeId: { type: "string", minLength: 1 } }
+        },
+        response: {
+          200: claudeSessionsResponseSchema,
+          404: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      const employee = state.employees.get(request.params.employeeId);
+      if (!employee) {
+        return reply.code(404).send({ error: "Employee not found." });
+      }
+      return buildClaudeSessions(request.params.employeeId);
+    }
+  );
+  app.post(
+    "/api/tasks",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Submit a task",
+        description: "Submit a task to the shared queue, all agents, or one or more selected agents. Optional webhook receives task lifecycle callbacks.",
+        body: restTaskRequestSchema,
+        response: {
+          202: restTaskAcceptedSchema,
+          400: {
+            type: "object",
+            required: ["status", "code", "message"],
+            properties: {
+              status: { type: "string", enum: ["rejected"] },
+              code: { type: "string" },
+              message: { type: "string" }
+            }
+          },
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      try {
+        const { command, webhookUrl, cliConfig, priority, requiredLabels } = parseRestTaskRequest(request.body);
+        const result = dispatchLeaderCommand(command, webhookUrl, cliConfig, priority, requiredLabels);
+        if (!result.ok) {
+          return reply.code(400).send({
+            status: "rejected",
+            code: result.code,
+            message: result.message
+          });
+        }
+        return reply.code(202).send({
+          status: "accepted",
+          leaderCommandId: result.leaderCommandId,
+          tasks: result.tasks
+        });
+      } catch (error) {
+        return reply.code(400).send({
+          status: "rejected",
+          code: "invalid_request",
+          message: error instanceof Error ? error.message : "Invalid task request."
+        });
+      }
+    }
+  );
+  app.get(
+    "/api/tasks",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "List tasks with optional filters",
+        querystring: {
+          type: "object",
+          properties: {
+            status: { type: "string", enum: ["queued", "dispatched", "accepted", "running", "completed", "failed", "cancelled", "timeout"] },
+            employeeId: { type: "string" },
+            limit: { type: "number", minimum: 1, maximum: 100 },
+            offset: { type: "number", minimum: 0 }
+          }
+        },
+        response: {
+          200: taskListResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request) => {
+      const rows = await queryTasks(db, {
+        status: request.query.status,
+        employeeId: request.query.employeeId,
+        limit: request.query.limit,
+        offset: request.query.offset
+      });
+      return { tasks: rows.map((row) => dbRowToTask(row, defaultTimeoutSec)) };
+    }
+  );
+  app.get(
+    "/api/tasks/:taskId",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Get a single task by ID",
+        params: {
+          type: "object",
+          required: ["taskId"],
+          properties: { taskId: { type: "string", minLength: 1 } }
+        },
+        response: {
+          200: taskRecordSchema,
+          404: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      const row = await getTaskById(db, request.params.taskId);
+      if (!row) {
+        return reply.code(404).send({ error: "Task not found." });
+      }
+      return dbRowToTask(row, defaultTimeoutSec);
+    }
+  );
+  app.patch(
+    "/api/tasks/:taskId",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Update a task",
+        params: {
+          type: "object",
+          required: ["taskId"],
+          properties: { taskId: { type: "string", minLength: 1 } }
+        },
+        body: taskPatchSchema,
+        response: {
+          200: taskRecordSchema,
+          404: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      const allowed = /* @__PURE__ */ new Set(["status", "timeoutSec", "cliConfig"]);
+      const fields = {};
+      for (const [key, value] of Object.entries(request.body)) {
+        if (allowed.has(key)) {
+          fields[key] = value;
+        }
+      }
+      const row = await updateTaskFields(db, request.params.taskId, fields);
+      if (!row) {
+        return reply.code(404).send({ error: "Task not found." });
+      }
+      return dbRowToTask(row, defaultTimeoutSec);
+    }
+  );
+  app.post(
+    "/api/tasks/:taskId/cancel",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Cancel a task",
+        description: "Cancel a queued or running task. For running tasks, notifies the agent to terminate the claude process.",
+        params: {
+          type: "object",
+          required: ["taskId"],
+          properties: { taskId: { type: "string", minLength: 1 } }
+        },
+        response: {
+          200: taskRecordSchema,
+          404: errorResponseSchema,
+          409: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      const result = cancelTaskById(request.params.taskId);
+      if (!result.ok) {
+        const code = result.code === "not_found" ? 404 : 409;
+        return reply.code(code).send({ error: result.message });
+      }
+      return result.task;
+    }
+  );
+  app.delete(
+    "/api/tasks/:taskId",
+    {
+      schema: {
+        tags: ["tasks"],
+        summary: "Delete a task (only terminal status)",
+        params: {
+          type: "object",
+          required: ["taskId"],
+          properties: { taskId: { type: "string", minLength: 1 } }
+        },
+        response: {
+          200: { type: "object", required: ["deleted"], properties: { deleted: { type: "boolean" } } },
+          404: errorResponseSchema,
+          409: errorResponseSchema,
+          401: errorResponseSchema
+        }
+      }
+    },
+    async (request, reply) => {
+      const deleted = await deleteTask(db, request.params.taskId);
+      if (!deleted) {
+        const row = await getTaskById(db, request.params.taskId);
+        if (!row) {
+          return reply.code(404).send({ error: "Task not found." });
+        }
+        return reply.code(409).send({ error: "Task is not in a terminal status." });
+      }
+      return { deleted: true };
+    }
+  );
+  app.get("/ws/agent", { websocket: true }, (socket, request) => {
+    if (!isAuthorized(options.authToken, request.url, request.headers)) {
+      socket.close(1008, "unauthorized");
+      return;
+    }
+    app.log.info("Agent connected");
+    socket.on("message", (raw) => {
+      try {
+        const decrypted = dispatchCtx.encryptor.decrypt(raw.toString());
+        const message = parseEmployeeToServerMessage(parseJsonMessage(decrypted));
+        handleAgentMessage(message, socket);
+      } catch (error) {
+        app.log.error({ error }, "Failed to parse agent message");
+        socket.close(1008, "invalid_message");
+      }
+    });
+    socket.on("close", () => {
+      if (closing) {
+        return;
+      }
+      const employeeId = state.socketToEmployeeId.get(socket);
+      if (!employeeId || state.agentSockets.get(employeeId) !== socket) {
+        return;
+      }
+      state.agentSockets.delete(employeeId);
+      state.socketToEmployeeId.delete(socket);
+      const heartbeatTimer = state.heartbeatTimers.get(employeeId);
+      if (heartbeatTimer) {
+        clearTimeout(heartbeatTimer);
+        state.heartbeatTimers.delete(employeeId);
+      }
+      const employee = state.employees.get(employeeId);
+      if (employee) {
+        employee.status = "offline";
+        employee.lastSeenAt = nowIso();
+        for (const leaderSocket of state.leaderSockets) {
+          sendJson(leaderSocket, { type: "employee.upsert", employee }, dispatchCtx.encryptor);
+        }
+      }
+      app.log.info({ employeeId }, "Agent disconnected");
+    });
+  });
+  app.get("/ws/leader", { websocket: true }, (socket, request) => {
+    if (!isAuthorized(options.authToken, request.url, request.headers)) {
+      socket.close(1008, "unauthorized");
+      return;
+    }
+    state.leaderSockets.add(socket);
+    sendJson(socket, { type: "snapshot", snapshot: buildSnapshot() }, dispatchCtx.encryptor);
+    app.log.info("Leader connected");
+    socket.on("message", (raw) => {
+      try {
+        const decrypted = dispatchCtx.encryptor.decrypt(raw.toString());
+        const message = parseLeaderToServerMessage(parseJsonMessage(decrypted));
+        handleLeaderMessage(message, socket);
+      } catch (error) {
+        app.log.error({ error }, "Failed to parse leader message");
+        sendJson(socket, {
+          type: "command.error",
+          code: "invalid_message",
+          message: error instanceof Error ? error.message : "Invalid leader message."
+        }, dispatchCtx.encryptor);
+      }
+    });
+    socket.on("close", () => {
+      state.leaderSockets.delete(socket);
+      app.log.info("Leader disconnected");
+    });
+  });
+  return {
+    app,
+    buildSnapshot,
+    close: async () => {
+      closing = true;
+      for (const timer of state.taskTimeouts.values()) {
+        clearTimeout(timer);
+      }
+      for (const timer of state.disconnectTimers.values()) {
+        clearTimeout(timer);
+      }
+      for (const timer of state.heartbeatTimers.values()) {
+        clearTimeout(timer);
+      }
+      await app.close();
+      db.close();
+    }
+  };
+}
+function readOptionsFromEnv(env = process.env) {
+  return {
+    authToken: env.AI_TEAMS_AUTH_TOKEN ?? "",
+    port: Number(env.PORT ?? env.AI_TEAMS_SERVER_PORT) || DEFAULT_PORT,
+    host: env.HOST || "0.0.0.0",
+    dataDir: env.DATA_DIR,
+    dbPath: env.DB_PATH,
+    defaultTimeoutSec: Number(env.DEFAULT_TIMEOUT_SEC) || 1800,
+    disconnectGraceMs: Number(env.DISCONNECT_GRACE_MS) || 15e3,
+    maxLogChunksPerTask: Number(env.MAX_LOG_CHUNKS_PER_TASK) || 400,
+    logLevel: env.LOG_LEVEL,
+    logDir: env.LOG_DIR
+  };
+}
+async function startServer(options = readOptionsFromEnv()) {
+  const server = await createAiTeamsServer(options);
+  await server.app.listen({ port: options.port ?? DEFAULT_PORT, host: options.host ?? "0.0.0.0" });
+  return server;
+}
+var isCli = process.argv[1] === fileURLToPath(import.meta.url);
+if (isCli) {
+  let getArgValue = function(name) {
+    const idx = args.indexOf(name);
+    if (idx === -1) return void 0;
+    return args[idx + 1];
+  };
+  getArgValue2 = getArgValue;
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`ai-teams-server \u2014 AI Teams \u4E2D\u592E\u670D\u52A1\u5668
+
+\u7528\u6CD5: ai-teams-server [\u9009\u9879]
+
+\u9009\u9879:
+  --token <token>       \u8BA4\u8BC1 Token (\u5FC5\u586B\uFF0C\u6216\u8BBE AI_TEAMS_AUTH_TOKEN)
+  --port <port>         \u670D\u52A1\u7AEF\u53E3 (\u9ED8\u8BA4 3789)
+  --host <host>         \u7ED1\u5B9A\u5730\u5740 (\u9ED8\u8BA4 0.0.0.0)
+  --data-dir <dir>      \u6570\u636E\u76EE\u5F55
+  --db-path <path>      \u6570\u636E\u5E93\u8DEF\u5F84
+  --log-level <level>   \u65E5\u5FD7\u7EA7\u522B trace/debug/info/warn/error (\u9ED8\u8BA4 info)
+  --log-dir <dir>       \u65E5\u5FD7\u6587\u4EF6\u76EE\u5F55 (\u4E0D\u8BBE\u5219\u4EC5\u8F93\u51FA\u5230 stdout)
+  -h, --help            \u663E\u793A\u5E2E\u52A9
+`);
+    process.exit(0);
+  }
+  const cliToken = getArgValue("--token");
+  const cliPort = getArgValue("--port");
+  const cliHost = getArgValue("--host");
+  const cliDataDir = getArgValue("--data-dir");
+  const cliDbPath = getArgValue("--db-path");
+  const cliLogLevel = getArgValue("--log-level");
+  const cliLogDir = getArgValue("--log-dir");
+  if (cliToken) process.env.AI_TEAMS_AUTH_TOKEN = cliToken;
+  if (cliPort) process.env.AI_TEAMS_SERVER_PORT = cliPort;
+  if (cliHost) process.env.HOST = cliHost;
+  if (cliDataDir) process.env.DATA_DIR = cliDataDir;
+  if (cliDbPath) process.env.DB_PATH = cliDbPath;
+  if (cliLogLevel) process.env.LOG_LEVEL = cliLogLevel;
+  if (cliLogDir) process.env.LOG_DIR = cliLogDir;
+  const options = readOptionsFromEnv();
+  if (!options.authToken) {
+    console.error("\u9519\u8BEF: \u9700\u8981\u8BA4\u8BC1 Token\u3002\u4F7F\u7528 --token <token> \u6216\u8BBE\u7F6E AI_TEAMS_AUTH_TOKEN \u73AF\u5883\u53D8\u91CF\u3002");
+    process.exit(1);
+  }
+  startServer(options).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+var getArgValue2;
+export {
+  createAiTeamsServer,
+  readOptionsFromEnv,
+  startServer
+};